From 7a9b058483ae397bd77fd52ca0c152a1f30787bc Mon Sep 17 00:00:00 2001 From: ucwong Date: Mon, 25 May 2026 10:54:40 +0000 Subject: [PATCH] deps --- go.mod | 20 +- go.sum | 50 +- vendor/github.com/anacrolix/dht/v2/globals.go | 3 +- .../aws/aws-sdk-go-v2/config/CHANGELOG.md | 4 + .../config/go_module_metadata.go | 2 +- .../aws-sdk-go-v2/credentials/CHANGELOG.md | 4 + .../credentials/go_module_metadata.go | 2 +- .../service/ssooidc/CHANGELOG.md | 4 + .../service/ssooidc/endpoints.go | 305 +- .../service/ssooidc/go_module_metadata.go | 2 +- .../endpoints/private/bdd/evaluate.go | 35 + vendor/github.com/pion/sctp/README.md | 6 +- vendor/github.com/pion/sctp/association.go | 602 +- .../sctp/association_interleaving_options.go | 135 + .../pion/sctp/association_options.go | 11 + .../pion/sctp/chunk_i_forward_tsn.go | 207 + .../pion/sctp/chunk_payload_data.go | 126 +- vendor/github.com/pion/sctp/chunktype.go | 6 + vendor/github.com/pion/sctp/errors.go | 6 + vendor/github.com/pion/sctp/packet.go | 4 + vendor/github.com/pion/sctp/pending_queue.go | 421 +- .../github.com/pion/sctp/reassembly_queue.go | 312 +- .../pion/sctp/receive_payload_queue.go | 44 + vendor/github.com/pion/sctp/stream.go | 107 +- .../github.com/pion/webrtc/v4/datachannel.go | 11 +- .../pion/webrtc/v4/peerconnection.go | 18 + .../pion/webrtc/v4/sctptransport.go | 39 + .../pion/webrtc/v4/sctptransport_js.go | 6 + vendor/github.com/pion/webrtc/v4/stats.go | 28 + vendor/golang.org/x/crypto/blake2b/go125.go | 11 - vendor/golang.org/x/net/http2/server.go | 21 - .../golang.org/x/net/http2/server_common.go | 22 + vendor/golang.org/x/net/http2/server_wrap.go | 40 + vendor/golang.org/x/net/http2/transport.go | 34 - .../x/net/http2/transport_common.go | 34 + .../x/net/http2/writesched_common.go | 41 + .../net/http2/writesched_priority_rfc7540.go | 41 - vendor/golang.org/x/sys/cpu/cpu.go | 19 +- .../golang.org/x/sys/cpu/cpu_linux_riscv64.go | 2 + vendor/golang.org/x/sys/cpu/cpu_loong64.go | 16 +- vendor/golang.org/x/sys/cpu/cpu_riscv64.go | 1 + vendor/golang.org/x/sys/unix/mkerrors.sh | 3 + vendor/golang.org/x/sys/unix/readv_unix.go | 103 + .../golang.org/x/sys/unix/syscall_darwin.go | 89 - vendor/golang.org/x/sys/unix/syscall_linux.go | 106 +- .../golang.org/x/sys/unix/syscall_openbsd.go | 4 + vendor/golang.org/x/sys/unix/zerrors_linux.go | 61 +- .../x/sys/unix/zerrors_linux_386.go | 7 +- .../x/sys/unix/zerrors_linux_amd64.go | 7 +- .../x/sys/unix/zerrors_linux_arm.go | 7 +- .../x/sys/unix/zerrors_linux_arm64.go | 7 +- .../x/sys/unix/zerrors_linux_loong64.go | 7 +- .../x/sys/unix/zerrors_linux_mips.go | 7 +- .../x/sys/unix/zerrors_linux_mips64.go | 7 +- .../x/sys/unix/zerrors_linux_mips64le.go | 7 +- .../x/sys/unix/zerrors_linux_mipsle.go | 7 +- .../x/sys/unix/zerrors_linux_ppc.go | 7 +- .../x/sys/unix/zerrors_linux_ppc64.go | 7 +- .../x/sys/unix/zerrors_linux_ppc64le.go | 7 +- .../x/sys/unix/zerrors_linux_riscv64.go | 1114 +- .../x/sys/unix/zerrors_linux_s390x.go | 7 +- .../x/sys/unix/zerrors_linux_sparc64.go | 7 +- .../golang.org/x/sys/unix/zsyscall_linux.go | 8 +- .../x/sys/unix/zsyscall_openbsd_386.go | 84 + .../x/sys/unix/zsyscall_openbsd_386.s | 20 + .../x/sys/unix/zsyscall_openbsd_amd64.go | 84 + .../x/sys/unix/zsyscall_openbsd_amd64.s | 20 + .../x/sys/unix/zsyscall_openbsd_arm.go | 84 + .../x/sys/unix/zsyscall_openbsd_arm.s | 20 + .../x/sys/unix/zsyscall_openbsd_arm64.go | 84 + .../x/sys/unix/zsyscall_openbsd_arm64.s | 20 + .../x/sys/unix/zsyscall_openbsd_mips64.go | 84 + .../x/sys/unix/zsyscall_openbsd_mips64.s | 20 + .../x/sys/unix/zsyscall_openbsd_ppc64.go | 84 + .../x/sys/unix/zsyscall_openbsd_ppc64.s | 24 + .../x/sys/unix/zsyscall_openbsd_riscv64.go | 84 + .../x/sys/unix/zsyscall_openbsd_riscv64.s | 20 + .../x/sys/unix/zsysnum_linux_386.go | 4 + .../x/sys/unix/zsysnum_linux_amd64.go | 5 + .../x/sys/unix/zsysnum_linux_arm.go | 4 + .../x/sys/unix/zsysnum_linux_arm64.go | 4 + .../x/sys/unix/zsysnum_linux_loong64.go | 5 + .../x/sys/unix/zsysnum_linux_mips.go | 4 + .../x/sys/unix/zsysnum_linux_mips64.go | 4 + .../x/sys/unix/zsysnum_linux_mips64le.go | 4 + .../x/sys/unix/zsysnum_linux_mipsle.go | 4 + .../x/sys/unix/zsysnum_linux_ppc.go | 4 + .../x/sys/unix/zsysnum_linux_ppc64.go | 4 + .../x/sys/unix/zsysnum_linux_ppc64le.go | 4 + .../x/sys/unix/zsysnum_linux_riscv64.go | 4 + .../x/sys/unix/zsysnum_linux_s390x.go | 4 + .../x/sys/unix/zsysnum_linux_sparc64.go | 5 + vendor/golang.org/x/sys/unix/ztypes_linux.go | 47 +- .../golang.org/x/sys/unix/ztypes_linux_386.go | 8 + .../x/sys/unix/ztypes_linux_amd64.go | 8 + .../golang.org/x/sys/unix/ztypes_linux_arm.go | 8 + .../x/sys/unix/ztypes_linux_arm64.go | 8 + .../x/sys/unix/ztypes_linux_loong64.go | 8 + .../x/sys/unix/ztypes_linux_mips.go | 8 + .../x/sys/unix/ztypes_linux_mips64.go | 8 + .../x/sys/unix/ztypes_linux_mips64le.go | 8 + .../x/sys/unix/ztypes_linux_mipsle.go | 8 + .../golang.org/x/sys/unix/ztypes_linux_ppc.go | 8 + .../x/sys/unix/ztypes_linux_ppc64.go | 8 + .../x/sys/unix/ztypes_linux_ppc64le.go | 8 + .../x/sys/unix/ztypes_linux_riscv64.go | 8 + .../x/sys/unix/ztypes_linux_s390x.go | 8 + .../x/sys/unix/ztypes_linux_sparc64.go | 8 + .../x/sys/windows/syscall_windows.go | 3 + .../golang.org/x/sys/windows/types_windows.go | 4 +- .../x/sys/windows/zsyscall_windows.go | 35 + vendor/modernc.org/libc/.gitignore | 1 + vendor/modernc.org/libc/CLAUDE.md | 106 + vendor/modernc.org/libc/GEMINI.md | 56 + vendor/modernc.org/libc/atomic.go | 24 +- vendor/modernc.org/libc/ccgo_linux_386.go | 9018 +++++++++-------- vendor/modernc.org/libc/ccgo_linux_amd64.go | 8626 ++++++++-------- vendor/modernc.org/libc/ccgo_linux_arm.go | 8864 ++++++++-------- vendor/modernc.org/libc/ccgo_linux_arm64.go | 8608 ++++++++-------- vendor/modernc.org/libc/ccgo_linux_loong64.go | 8550 ++++++++-------- vendor/modernc.org/libc/ccgo_linux_ppc64le.go | 8626 ++++++++-------- vendor/modernc.org/libc/ccgo_linux_riscv64.go | 8632 ++++++++-------- vendor/modernc.org/libc/ccgo_linux_s390x.go | 8616 ++++++++-------- vendor/modernc.org/libc/etc.go | 4 +- vendor/modernc.org/libc/libc.go | 13 +- vendor/modernc.org/libc/libc32.go | 8 +- vendor/modernc.org/libc/libc64.go | 8 +- vendor/modernc.org/libc/libc_darwin.go | 6 + vendor/modernc.org/libc/libc_freebsd.go | 6 + vendor/modernc.org/libc/libc_musl.go | 8 +- vendor/modernc.org/libc/libc_netbsd.go | 6 + vendor/modernc.org/libc/libc_openbsd.go | 8 +- vendor/modernc.org/libc/libc_unix.go | 60 +- vendor/modernc.org/libc/libc_windows.go | 9 +- vendor/modernc.org/libc/mem.go | 10 +- vendor/modernc.org/libc/mem_brk.go | 12 +- vendor/modernc.org/libc/mem_brk_musl.go | 3 + vendor/modernc.org/libc/memgrind.go | 31 +- vendor/modernc.org/libc/memgrind_musl.go | 31 +- vendor/modernc.org/libc/pthread.go | 15 +- vendor/modernc.org/libc/pthread_musl.go | 18 +- vendor/modernc.org/libc/stdatomic.go | 290 +- vendor/modules.txt | 21 +- 143 files changed, 39393 insertions(+), 36293 deletions(-) create mode 100644 vendor/github.com/aws/smithy-go/endpoints/private/bdd/evaluate.go create mode 100644 vendor/github.com/pion/sctp/association_interleaving_options.go create mode 100644 vendor/github.com/pion/sctp/chunk_i_forward_tsn.go delete mode 100644 vendor/golang.org/x/crypto/blake2b/go125.go create mode 100644 vendor/golang.org/x/sys/unix/readv_unix.go create mode 100644 vendor/modernc.org/libc/CLAUDE.md create mode 100644 vendor/modernc.org/libc/GEMINI.md diff --git a/go.mod b/go.mod index eb612e350a..aa87c93708 100644 --- a/go.mod +++ b/go.mod @@ -12,8 +12,8 @@ require ( github.com/VictoriaMetrics/fastcache v1.13.3 github.com/arsham/figurine v1.3.0 github.com/aws/aws-sdk-go-v2 v1.41.7 - github.com/aws/aws-sdk-go-v2/config v1.32.17 - github.com/aws/aws-sdk-go-v2/credentials v1.19.16 + github.com/aws/aws-sdk-go-v2/config v1.32.18 + github.com/aws/aws-sdk-go-v2/credentials v1.19.17 github.com/aws/aws-sdk-go-v2/service/route53 v1.62.7 github.com/cespare/cp v1.1.1 github.com/charmbracelet/bubbletea v1.3.10 @@ -64,10 +64,10 @@ require ( github.com/ucwong/color v1.10.1-0.20200624105241-fba1e010fe1e github.com/urfave/cli/v2 v2.27.7 go.uber.org/automaxprocs v1.6.0 - golang.org/x/crypto v0.51.0 + golang.org/x/crypto v0.52.0 golang.org/x/mobile v0.0.0-20201217150744-e6ae53a27f4f golang.org/x/sync v0.20.0 - golang.org/x/sys v0.44.0 + golang.org/x/sys v0.45.0 golang.org/x/text v0.37.0 golang.org/x/time v0.15.0 golang.org/x/tools v0.45.0 @@ -89,7 +89,7 @@ require ( github.com/alecthomas/atomic v0.1.0-alpha2 // indirect github.com/anacrolix/btree v0.1.1 // indirect github.com/anacrolix/chansync v0.7.0 // indirect - github.com/anacrolix/dht/v2 v2.23.0 // indirect + github.com/anacrolix/dht/v2 v2.24.0 // indirect github.com/anacrolix/envpprof v1.5.0 // indirect github.com/anacrolix/generics v0.2.0 // indirect github.com/anacrolix/go-libutp v1.4.0 // indirect @@ -116,7 +116,7 @@ require ( github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.23 // indirect github.com/aws/aws-sdk-go-v2/service/signin v1.0.11 // indirect github.com/aws/aws-sdk-go-v2/service/sso v1.30.17 // indirect - github.com/aws/aws-sdk-go-v2/service/ssooidc v1.35.21 // indirect + github.com/aws/aws-sdk-go-v2/service/ssooidc v1.36.0 // indirect github.com/aws/aws-sdk-go-v2/service/sts v1.42.1 // indirect github.com/aws/smithy-go v1.25.1 // indirect github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect @@ -203,7 +203,7 @@ require ( github.com/pion/randutil v0.1.0 // indirect github.com/pion/rtcp v1.2.16 // indirect github.com/pion/rtp v1.10.2 // indirect - github.com/pion/sctp v1.9.5 // indirect + github.com/pion/sctp v1.10.0 // indirect github.com/pion/sdp/v3 v3.0.18 // indirect github.com/pion/srtp/v3 v3.0.10 // indirect github.com/pion/stun/v3 v3.1.2 // indirect @@ -211,7 +211,7 @@ require ( github.com/pion/transport/v3 v3.1.1 // indirect github.com/pion/transport/v4 v4.0.1 // indirect github.com/pion/turn/v5 v5.0.4 // indirect - github.com/pion/webrtc/v4 v4.2.12 // indirect + github.com/pion/webrtc/v4 v4.2.13 // indirect github.com/pkg/errors v0.9.1 // indirect github.com/pmezard/go-difflib v1.0.0 // indirect github.com/prometheus/client_golang v1.23.2 // indirect @@ -251,12 +251,12 @@ require ( go.yaml.in/yaml/v2 v2.4.4 // indirect golang.org/x/exp v0.0.0-20260508232706-74f9aab9d74a // indirect golang.org/x/mod v0.36.0 // indirect - golang.org/x/net v0.54.0 // indirect + golang.org/x/net v0.55.0 // indirect golang.org/x/term v0.43.0 // indirect gopkg.in/yaml.v2 v2.4.0 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect lukechampine.com/blake3 v1.4.1 // indirect - modernc.org/libc v1.72.3 // indirect + modernc.org/libc v1.72.4 // indirect modernc.org/mathutil v1.7.1 // indirect modernc.org/memory v1.11.0 // indirect modernc.org/sqlite v1.50.1 // indirect diff --git a/go.sum b/go.sum index 1e435fd65e..fc10fc9c2d 100644 --- a/go.sum +++ b/go.sum @@ -137,8 +137,8 @@ github.com/anacrolix/dht/v2 v2.3.2-0.20200103043204-8dce00767ebd/go.mod h1:cgjKy github.com/anacrolix/dht/v2 v2.5.1-0.20200317023935-129f05e9b752/go.mod h1:7RLvyOjm+ZPA7vgFRP+1eRjFzrh27p/nF0VCk5LcjoU= github.com/anacrolix/dht/v2 v2.6.1-0.20200416071723-3850fa1b802a/go.mod h1:7jf6kAZRU7FFwyeLP3f4LVH8WglAHdMte1mGcq8HQAg= github.com/anacrolix/dht/v2 v2.6.1/go.mod h1:7jf6kAZRU7FFwyeLP3f4LVH8WglAHdMte1mGcq8HQAg= -github.com/anacrolix/dht/v2 v2.23.0 h1:EuD17ykTTEkAMPLjBsS5QjGOwuBgLTdQhds6zPAjeVY= -github.com/anacrolix/dht/v2 v2.23.0/go.mod h1:seXRz6HLw8zEnxlysf9ye2eQbrKUmch6PyOHpe/Nb/U= +github.com/anacrolix/dht/v2 v2.24.0 h1:qKIZKmJjW0y/LoqeMPPQ99JBy3Op15voFZrR7OpeOh8= +github.com/anacrolix/dht/v2 v2.24.0/go.mod h1:0IpTSbqYnFcjmexGvnINUGq/kbx93S5cKIryH4oJL8U= github.com/anacrolix/envpprof v0.0.0-20180404065416-323002cec2fa/go.mod h1:KgHhUaQMc8cC0+cEflSgCFNFbKwi5h54gqtVn8yhP7c= github.com/anacrolix/envpprof v1.0.0/go.mod h1:KgHhUaQMc8cC0+cEflSgCFNFbKwi5h54gqtVn8yhP7c= github.com/anacrolix/envpprof v1.0.1/go.mod h1:My7T5oSqVfEn4MD4Meczkw/f5lSIndGAKu/0SM/rkf4= @@ -266,10 +266,10 @@ github.com/aws/aws-sdk-go v1.31.0/go.mod h1:5zCpMtNQVjRREroY7sYe8lOMRSxkhG6MZveU github.com/aws/aws-sdk-go-v2 v0.18.0/go.mod h1:JWVYvqSMppoMJC0x5wdwiImzgXTI9FuZwxzkQq9wy+g= github.com/aws/aws-sdk-go-v2 v1.41.7 h1:DWpAJt66FmnnaRIOT/8ASTucrvuDPZASqhhLey6tLY8= github.com/aws/aws-sdk-go-v2 v1.41.7/go.mod h1:4LAfZOPHNVNQEckOACQx60Y8pSRjIkNZQz1w92xpMJc= -github.com/aws/aws-sdk-go-v2/config v1.32.17 h1:FpL4/758/diKwqbytU0prpuiu60fgXKUWCpDJtApclU= -github.com/aws/aws-sdk-go-v2/config v1.32.17/go.mod h1:OXqUMzgXytfoF9JaKkhrOYsyh72t9G+MJH8mMRaexOE= -github.com/aws/aws-sdk-go-v2/credentials v1.19.16 h1:r3RJBuU7X9ibt8RHbMjWE6y60QbKBiII6wSrXnapxSU= -github.com/aws/aws-sdk-go-v2/credentials v1.19.16/go.mod h1:6cx7zqDENJDbBIIWX6P8s0h6hqHC8Avbjh9Dseo27ug= +github.com/aws/aws-sdk-go-v2/config v1.32.18 h1:Hcia46bxhGgF3BaSnG8nSNCWmqTK6bj9xN9/FJ3WK6Q= +github.com/aws/aws-sdk-go-v2/config v1.32.18/go.mod h1:zEjCAYmxqDadH1WX8CdBvmLKhUEUVFgKRQG38zjDmrY= +github.com/aws/aws-sdk-go-v2/credentials v1.19.17 h1:gP2nkGsS+KMvF/jfFz2Vv2qiiOqWKyPACSzPsqHgoW8= +github.com/aws/aws-sdk-go-v2/credentials v1.19.17/go.mod h1:Bsew3S/moG5iT77giPj1q8wb/s0RE5/QfH+ASjYtuQc= github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.23 h1:UuSfcORqNSz/ey3VPRS8TcVH2Ikf0/sC+Hdj400QI6U= github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.23/go.mod h1:+G/OSGiOFnSOkYloKj/9M35s74LgVAdJBSD5lsFfqKg= github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.23 h1:GpT/TrnBYuE5gan2cZbTtvP+JlHsutdmlV2YfEyNde0= @@ -288,8 +288,8 @@ github.com/aws/aws-sdk-go-v2/service/signin v1.0.11 h1:TdJ+HdzOBhU8+iVAOGUTU63VX github.com/aws/aws-sdk-go-v2/service/signin v1.0.11/go.mod h1:R82ZRExE/nheo0N+T8zHPcLRTcH8MGsnR3BiVGX0TwI= github.com/aws/aws-sdk-go-v2/service/sso v1.30.17 h1:7byT8HUWrgoRp6sXjxtZwgOKfhss5fW6SkLBtqzgRoE= github.com/aws/aws-sdk-go-v2/service/sso v1.30.17/go.mod h1:xNWknVi4Ezm1vg1QsB/5EWpAJURq22uqd38U8qKvOJc= -github.com/aws/aws-sdk-go-v2/service/ssooidc v1.35.21 h1:+1Kl1zx6bWi4X7cKi3VYh29h8BvsCoHQEQ6ST9X8w7w= -github.com/aws/aws-sdk-go-v2/service/ssooidc v1.35.21/go.mod h1:4vIRDq+CJB2xFAXZ+YgGUTiEft7oAQlhIs71xcSeuVg= +github.com/aws/aws-sdk-go-v2/service/ssooidc v1.36.0 h1:nDARhv/oF55bcxF7rCI/4PDxOKnVXVWwDuDwCs2I2SQ= +github.com/aws/aws-sdk-go-v2/service/ssooidc v1.36.0/go.mod h1:4vIRDq+CJB2xFAXZ+YgGUTiEft7oAQlhIs71xcSeuVg= github.com/aws/aws-sdk-go-v2/service/sts v1.42.1 h1:F/M5Y9I3nwr2IEpshZgh1GeHpOItExNM9L1euNuh/fk= github.com/aws/aws-sdk-go-v2/service/sts v1.42.1/go.mod h1:mTNxImtovCOEEuD65mKW7DCsL+2gjEH+RPEAexAzAio= github.com/aws/smithy-go v1.25.1 h1:J8ERsGSU7d+aCmdQur5Txg6bVoYelvQJgtZehD12GkI= @@ -1008,8 +1008,8 @@ github.com/pion/rtp v1.4.0/go.mod h1:/l4cvcKd0D3u9JLs2xSVI95YkfXW87a3br3nqmVtSlE github.com/pion/rtp v1.10.2 h1:l+f6tTDcAH6xwepaAoW791ddhuYsJlqRATOzirO04Mo= github.com/pion/rtp v1.10.2/go.mod h1:Au8fc6cEByy8RLTwKTQTEeQqDB/SJDxwL4mZuxYA5Pk= github.com/pion/sctp v1.7.6/go.mod h1:ichkYQ5tlgCQwEwvgfdcAolqx1nHbYCxo4D7zK/K0X8= -github.com/pion/sctp v1.9.5 h1:QoSFB/drmAsmSeSFNQNI3xx010nW4HsycCZckRVWWag= -github.com/pion/sctp v1.9.5/go.mod h1:N20Dq6LY+JvJDAh9VVh1JELngb2rQ8dPgds5yBWiPgw= +github.com/pion/sctp v1.10.0 h1:qeoD6swF/2M5bYRcAGayqSbTKX3m4AW29CiQxG1+Pfg= +github.com/pion/sctp v1.10.0/go.mod h1:N20Dq6LY+JvJDAh9VVh1JELngb2rQ8dPgds5yBWiPgw= github.com/pion/sdp/v2 v2.3.7/go.mod h1:+ZZf35r1+zbaWYiZLfPutWfx58DAWcGb2QsS3D/s9M8= github.com/pion/sdp/v3 v3.0.18 h1:l0bAXazKHpepazVdp+tPYnrsy9dfh7ZbT8DxesH5ZnI= github.com/pion/sdp/v3 v3.0.18/go.mod h1:ZREGo6A9ZygQ9XkqAj5xYCQtQpif0i6Pa81HOiAdqQ8= @@ -1035,14 +1035,12 @@ github.com/pion/transport/v3 v3.1.1/go.mod h1:+c2eewC5WJQHiAA46fkMMzoYZSuGzA/7E2 github.com/pion/transport/v4 v4.0.1 h1:sdROELU6BZ63Ab7FrOLn13M6YdJLY20wldXW2Cu2k8o= github.com/pion/transport/v4 v4.0.1/go.mod h1:nEuEA4AD5lPdcIegQDpVLgNoDGreqM/YqmEx3ovP4jM= github.com/pion/turn/v2 v2.0.3/go.mod h1:kl1hmT3NxcLynpXVnwJgObL8C9NaCyPTeqI2DcCpSZs= -github.com/pion/turn/v4 v4.1.4 h1:EU11yMXKIsK43FhcUnjLlrhE4nboHZq+TXBIi3QpcxQ= -github.com/pion/turn/v4 v4.1.4/go.mod h1:ES1DXVFKnOhuDkqn9hn5VJlSWmZPaRJLyBXoOeO/BmQ= github.com/pion/turn/v5 v5.0.4 h1:xKAnP1b5eCnjFPd55OgxkqIVoyzbHKZa06SxZ3fopXQ= github.com/pion/turn/v5 v5.0.4/go.mod h1:zbPsMp+fIVhKt5uWu2jcjk88FcoRbGMBSzVsaTuhcmM= github.com/pion/webrtc/v2 v2.2.7/go.mod h1:EfCuvKjzMgX4F/aSryRUC7L9o3u2N8WNUgnzd6wOO+8= github.com/pion/webrtc/v2 v2.2.9/go.mod h1:TcArPDphZIBtZ+mh8J/qOREyY3ca7ihQrenulOIvfPQ= -github.com/pion/webrtc/v4 v4.2.12 h1:ux8i+aJxu0OdhcAcVO39JEeodWugD0wdVJoRDtXk1CY= -github.com/pion/webrtc/v4 v4.2.12/go.mod h1:M/DeGZkhdWZVmVgGr34HOD9yUDekVJtz9c9PGO18urQ= +github.com/pion/webrtc/v4 v4.2.13 h1:sakZ/O++jTuMC+CpmpbIGnze7HvFAKZdrz89qWu1JtQ= +github.com/pion/webrtc/v4 v4.2.13/go.mod h1:/l7Ags53B/mocZXrO3AH+t+tb6cGawKMErVu5DBaEUo= github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c h1:+mdjkGKdHQG3305AYmdv1U2eRNDiU2ErMBj1gwrq8eQ= github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c/go.mod h1:7rwL4CYBLnjLxUqIJNnCWiEdr3bn6IUYi15bNlnbCCU= github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA= @@ -1377,8 +1375,8 @@ golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5y golang.org/x/crypto v0.8.0/go.mod h1:mRqEX+O9/h5TFCrQhkgjo2yKi0yYA+9ecGkdQoHrywE= golang.org/x/crypto v0.12.0/go.mod h1:NF0Gs7EO5K4qLn+Ylc+fih8BSTeIjAP05siRnAh98yw= golang.org/x/crypto v0.18.0/go.mod h1:R0j02AL6hcrfOiy9T4ZYp/rcWeMxM3L6QYxlOuEG1mg= -golang.org/x/crypto v0.51.0 h1:IBPXwPfKxY7cWQZ38ZCIRPI50YLeevDLlLnyC5wRGTI= -golang.org/x/crypto v0.51.0/go.mod h1:8AdwkbraGNABw2kOX6YFPs3WM22XqI4EXEd8g+x7Oc8= +golang.org/x/crypto v0.52.0 h1:RMs7fP2rXdep0CftQlK8Uf+kibLm7qkCcradZWYz988= +golang.org/x/crypto v0.52.0/go.mod h1:1QgfPxDqh0T2M/elOJtp9RvuR95kVjir0e6/BvEmGbc= golang.org/x/exp v0.0.0-20180321215751-8460e604b9de/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20180807140117-3d87b88a115f/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= @@ -1478,8 +1476,8 @@ golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns= golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg= golang.org/x/net v0.14.0/go.mod h1:PpSgVXXLK0OxS0F31C1/tv6XNguvCrnXIDrFMspZIUI= golang.org/x/net v0.20.0/go.mod h1:z8BVo6PvndSri0LbOE3hAn0apkU+1YvI6E70E9jsnvY= -golang.org/x/net v0.54.0 h1:2zJIZAxAHV/OHCDTCOHAYehQzLfSXuf/5SoL/Dv6w/w= -golang.org/x/net v0.54.0/go.mod h1:Sj4oj8jK6XmHpBZU/zWHw3BV3abl4Kvi+Ut7cQcY+cQ= +golang.org/x/net v0.55.0 h1:bcvxaJn3e1U6InsFWt1JUq1aSjnRxLzT2rtD2KfkDF8= +golang.org/x/net v0.55.0/go.mod h1:L5U2KuzuOe1lY7Z+aWVIKK6qEeJXnXV9yzGA+WCHJww= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20181017192945-9dcd33a902f4/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20181203162652-d668ce993890/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= @@ -1577,8 +1575,8 @@ golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.16.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= -golang.org/x/sys v0.44.0 h1:ildZl3J4uzeKP07r2F++Op7E9B29JRUy+a27EibtBTQ= -golang.org/x/sys v0.44.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= +golang.org/x/sys v0.45.0 h1:dO4czNzziLiiXplLQgBCEpCvXQ3dnkn0SdaZSYdQ+FY= +golang.org/x/sys v0.45.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k= @@ -1786,18 +1784,18 @@ lukechampine.com/blake3 v1.4.1 h1:I3Smz7gso8w4/TunLKec6K2fn+kyKtDxr/xcQEN84Wg= lukechampine.com/blake3 v1.4.1/go.mod h1:QFosUxmjB8mnrWFSNwKmvxHpfY72bmD2tQ0kBMM3kwo= modernc.org/cc/v4 v4.28.2 h1:3tQ0lf2ADtoby2EtSP+J7IE2SHwEJdP8ioR59wx7XpY= modernc.org/cc/v4 v4.28.2/go.mod h1:OnovgIhbbMXMu1aISnJ0wvVD1KnW+cAUJkIrAWh+kVI= -modernc.org/ccgo/v4 v4.34.0 h1:yRLPFZieg532OT4rp4JFNIVcquwalMX26G95WQDqwCQ= -modernc.org/ccgo/v4 v4.34.0/go.mod h1:AS5WYMyBakQ+fhsHhtP8mWB82KTGPkNNJDGfGQCe0/A= +modernc.org/ccgo/v4 v4.34.2 h1:mxsy2FdrB6+qG3NfXefz1AmWv0ehOSDO4jxgxd7h9yo= +modernc.org/ccgo/v4 v4.34.2/go.mod h1:1L7us56+kAKu04p25EATpmBBvhbcqqZ85ibqWVwVgog= modernc.org/fileutil v1.4.0 h1:j6ZzNTftVS054gi281TyLjHPp6CPHr2KCxEXjEbD6SM= modernc.org/fileutil v1.4.0/go.mod h1:EqdKFDxiByqxLk8ozOxObDSfcVOv/54xDs/DUHdvCUU= modernc.org/gc/v2 v2.6.5 h1:nyqdV8q46KvTpZlsw66kWqwXRHdjIlJOhG6kxiV/9xI= modernc.org/gc/v2 v2.6.5/go.mod h1:YgIahr1ypgfe7chRuJi2gD7DBQiKSLMPgBQe9oIiito= -modernc.org/gc/v3 v3.1.2 h1:ZtDCnhonXSZexk/AYsegNRV1lJGgaNZJuKjJSWKyEqo= -modernc.org/gc/v3 v3.1.2/go.mod h1:HFK/6AGESC7Ex+EZJhJ2Gni6cTaYpSMmU/cT9RmlfYY= +modernc.org/gc/v3 v3.1.3 h1:6QAplYyVO+KdPW3pGnqmJDUxtkec8ooEWvks/hhU3lc= +modernc.org/gc/v3 v3.1.3/go.mod h1:HFK/6AGESC7Ex+EZJhJ2Gni6cTaYpSMmU/cT9RmlfYY= modernc.org/goabi0 v0.2.0 h1:HvEowk7LxcPd0eq6mVOAEMai46V+i7Jrj13t4AzuNks= modernc.org/goabi0 v0.2.0/go.mod h1:CEFRnnJhKvWT1c1JTI3Avm+tgOWbkOu5oPA8eH8LnMI= -modernc.org/libc v1.72.3 h1:ZnDF4tXn4NBXFutMMQC4vtbTFSXhhKzR73fv0beZEAU= -modernc.org/libc v1.72.3/go.mod h1:dn0dZNnnn1clLyvRxLxYExxiKRZIRENOfqQ8XEeg4Qs= +modernc.org/libc v1.72.4 h1:OKm/AonhnNwP/brQY/8uaIMw/EsoOuacBWvLEUl5aT8= +modernc.org/libc v1.72.4/go.mod h1:np0N7KDJ7eUtMZmOqVZNldrZyG+DHLl2B5pg8Hbar3U= modernc.org/mathutil v1.7.1 h1:GCZVGXdaN8gTqB1Mf/usp1Y/hSqgI2vAGGP4jZMCxOU= modernc.org/mathutil v1.7.1/go.mod h1:4p5IwJITfppl0G4sUEDtCr4DthTaT47/N3aT6MhfgJg= modernc.org/memory v1.11.0 h1:o4QC8aMQzmcwCK3t3Ux/ZHmwFPzE6hf2Y5LbkRs+hbI= diff --git a/vendor/github.com/anacrolix/dht/v2/globals.go b/vendor/github.com/anacrolix/dht/v2/globals.go index c652453c25..4e72f7bee9 100644 --- a/vendor/github.com/anacrolix/dht/v2/globals.go +++ b/vendor/github.com/anacrolix/dht/v2/globals.go @@ -4,4 +4,5 @@ import ( "golang.org/x/time/rate" ) -var DefaultSendLimiter = rate.NewLimiter(25, 25) +// https://github.com/anacrolix/torrent/issues/1005#issuecomment-2856881633 +var DefaultSendLimiter = rate.NewLimiter(250, 25) diff --git a/vendor/github.com/aws/aws-sdk-go-v2/config/CHANGELOG.md b/vendor/github.com/aws/aws-sdk-go-v2/config/CHANGELOG.md index 6f932e910a..a977899a4a 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/config/CHANGELOG.md +++ b/vendor/github.com/aws/aws-sdk-go-v2/config/CHANGELOG.md @@ -1,3 +1,7 @@ +# v1.32.18 (2026-05-22) + +* **Dependency Update**: Updated to the latest SDK module versions + # v1.32.17 (2026-04-29) * **Dependency Update**: Update to smithy-go v1.25.1. diff --git a/vendor/github.com/aws/aws-sdk-go-v2/config/go_module_metadata.go b/vendor/github.com/aws/aws-sdk-go-v2/config/go_module_metadata.go index fdbfa78e45..36b7e501ce 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/config/go_module_metadata.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/config/go_module_metadata.go @@ -3,4 +3,4 @@ package config // goModuleVersion is the tagged release for this module -const goModuleVersion = "1.32.17" +const goModuleVersion = "1.32.18" diff --git a/vendor/github.com/aws/aws-sdk-go-v2/credentials/CHANGELOG.md b/vendor/github.com/aws/aws-sdk-go-v2/credentials/CHANGELOG.md index 0b215e6b83..1eda74ea7c 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/credentials/CHANGELOG.md +++ b/vendor/github.com/aws/aws-sdk-go-v2/credentials/CHANGELOG.md @@ -1,3 +1,7 @@ +# v1.19.17 (2026-05-22) + +* **Dependency Update**: Updated to the latest SDK module versions + # v1.19.16 (2026-04-29) * **Dependency Update**: Update to smithy-go v1.25.1. diff --git a/vendor/github.com/aws/aws-sdk-go-v2/credentials/go_module_metadata.go b/vendor/github.com/aws/aws-sdk-go-v2/credentials/go_module_metadata.go index 5abad90cd9..cfabb14a68 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/credentials/go_module_metadata.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/credentials/go_module_metadata.go @@ -3,4 +3,4 @@ package credentials // goModuleVersion is the tagged release for this module -const goModuleVersion = "1.19.16" +const goModuleVersion = "1.19.17" diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ssooidc/CHANGELOG.md b/vendor/github.com/aws/aws-sdk-go-v2/service/ssooidc/CHANGELOG.md index e645209405..33082c0e54 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/ssooidc/CHANGELOG.md +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ssooidc/CHANGELOG.md @@ -1,3 +1,7 @@ +# v1.36.0 (2026-05-22) + +* **Feature**: Adding new BDD representation of endpoint ruleset + # v1.35.21 (2026-04-29) * **Dependency Update**: Update to smithy-go v1.25.1. diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ssooidc/endpoints.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ssooidc/endpoints.go index 884983eb4d..0834533561 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/ssooidc/endpoints.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ssooidc/endpoints.go @@ -14,6 +14,7 @@ import ( internalendpoints "github.com/aws/aws-sdk-go-v2/service/ssooidc/internal/endpoints" smithyauth "github.com/aws/smithy-go/auth" smithyendpoints "github.com/aws/smithy-go/endpoints" + "github.com/aws/smithy-go/endpoints/private/bdd" "github.com/aws/smithy-go/endpoints/private/rulesfn" "github.com/aws/smithy-go/middleware" "github.com/aws/smithy-go/ptr" @@ -294,21 +295,157 @@ func (p EndpointParameters) WithDefaults() EndpointParameters { return p } -type stringSlice []string +const bddRoot int32 = 2 -func (s stringSlice) Get(i int) *string { - if i < 0 || i >= len(s) { - return nil - } +var bddNodes = [42]int32{ + -1, 1, -1, 0, 13, 3, 1, 4, 100000012, 2, 5, 100000012, 3, 8, 6, 4, 7, 100000011, 5, 100000009, 100000010, 4, 11, 9, 6, 10, 100000008, 7, 100000006, 100000007, 5, 12, 100000005, 6, 100000004, 100000005, 3, 100000001, 14, 4, 100000002, 100000003} + +type conditionContext struct { + PartitionResult *awsrulesfn.PartitionConfig +} - v := s[i] - return &v +func evalCondition(idx int, params *EndpointParameters, c *conditionContext) bool { + switch idx { + case 0: + return params.Endpoint != nil + case 1: + return params.Region != nil + case 2: + if v := awsrulesfn.GetPartition(*params.Region); v != nil { + c.PartitionResult = v + return true + } + return false + case 3: + return *params.UseFIPS == true + case 4: + return *params.UseDualStack == true + case 5: + return c.PartitionResult.SupportsDualStack == true + case 6: + return c.PartitionResult.SupportsFIPS == true + case 7: + return c.PartitionResult.Name == "aws-us-gov" + } + return false +} + +func resolveResult(idx int32, params *EndpointParameters, c *conditionContext) (smithyendpoints.Endpoint, error) { + switch idx { + case 0: + return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint resolution failed: no matching rule") + case 1: + return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, %s", "Invalid Configuration: FIPS and custom endpoint are not supported") + case 2: + return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, %s", "Invalid Configuration: Dualstack and custom endpoint are not supported") + case 3: + uriString := *params.Endpoint + uri, err := url.Parse(uriString) + if err != nil { + return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString) + } + return smithyendpoints.Endpoint{ + URI: *uri, + Headers: http.Header{}, + }, nil + case 4: + uriString := func() string { + var out strings.Builder + out.WriteString("https://oidc-fips.") + out.WriteString(*params.Region) + out.WriteString(".") + out.WriteString(c.PartitionResult.DualStackDnsSuffix) + return out.String() + }() + uri, err := url.Parse(uriString) + if err != nil { + return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString) + } + return smithyendpoints.Endpoint{ + URI: *uri, + Headers: http.Header{}, + }, nil + case 5: + return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, %s", "FIPS and DualStack are enabled, but this partition does not support one or both") + case 6: + uriString := func() string { + var out strings.Builder + out.WriteString("https://oidc.") + out.WriteString(*params.Region) + out.WriteString(".amazonaws.com") + return out.String() + }() + uri, err := url.Parse(uriString) + if err != nil { + return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString) + } + return smithyendpoints.Endpoint{ + URI: *uri, + Headers: http.Header{}, + }, nil + case 7: + uriString := func() string { + var out strings.Builder + out.WriteString("https://oidc-fips.") + out.WriteString(*params.Region) + out.WriteString(".") + out.WriteString(c.PartitionResult.DnsSuffix) + return out.String() + }() + uri, err := url.Parse(uriString) + if err != nil { + return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString) + } + return smithyendpoints.Endpoint{ + URI: *uri, + Headers: http.Header{}, + }, nil + case 8: + return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, %s", "FIPS is enabled but this partition does not support FIPS") + case 9: + uriString := func() string { + var out strings.Builder + out.WriteString("https://oidc.") + out.WriteString(*params.Region) + out.WriteString(".") + out.WriteString(c.PartitionResult.DualStackDnsSuffix) + return out.String() + }() + uri, err := url.Parse(uriString) + if err != nil { + return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString) + } + return smithyendpoints.Endpoint{ + URI: *uri, + Headers: http.Header{}, + }, nil + case 10: + return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, %s", "DualStack is enabled but this partition does not support DualStack") + case 11: + uriString := func() string { + var out strings.Builder + out.WriteString("https://oidc.") + out.WriteString(*params.Region) + out.WriteString(".") + out.WriteString(c.PartitionResult.DnsSuffix) + return out.String() + }() + uri, err := url.Parse(uriString) + if err != nil { + return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString) + } + return smithyendpoints.Endpoint{ + URI: *uri, + Headers: http.Header{}, + }, nil + case 12: + return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, %s", "Invalid Configuration: Missing Region") + } + return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, invalid result index: %d", idx) } // EndpointResolverV2 provides the interface for resolving service endpoints. type EndpointResolverV2 interface { - // ResolveEndpoint attempts to resolve the endpoint with the provided options, - // returning the endpoint if found. Otherwise an error is returned. ResolveEndpoint(ctx context.Context, params EndpointParameters) ( smithyendpoints.Endpoint, error, ) @@ -332,152 +469,12 @@ func (r *resolver) ResolveEndpoint( if err = params.ValidateRequired(); err != nil { return endpoint, fmt.Errorf("endpoint parameters are not valid, %w", err) } - _UseDualStack := *params.UseDualStack - _ = _UseDualStack - _UseFIPS := *params.UseFIPS - _ = _UseFIPS - - if exprVal := params.Endpoint; exprVal != nil { - _Endpoint := *exprVal - _ = _Endpoint - if _UseFIPS == true { - return endpoint, fmt.Errorf("endpoint rule error, %s", "Invalid Configuration: FIPS and custom endpoint are not supported") - } - if _UseDualStack == true { - return endpoint, fmt.Errorf("endpoint rule error, %s", "Invalid Configuration: Dualstack and custom endpoint are not supported") - } - uriString := _Endpoint - - uri, err := url.Parse(uriString) - if err != nil { - return endpoint, fmt.Errorf("Failed to parse uri: %s", uriString) - } - - return smithyendpoints.Endpoint{ - URI: *uri, - Headers: http.Header{}, - }, nil - } - if exprVal := params.Region; exprVal != nil { - _Region := *exprVal - _ = _Region - if exprVal := awsrulesfn.GetPartition(_Region); exprVal != nil { - _PartitionResult := *exprVal - _ = _PartitionResult - if _UseFIPS == true { - if _UseDualStack == true { - if true == _PartitionResult.SupportsFIPS { - if true == _PartitionResult.SupportsDualStack { - uriString := func() string { - var out strings.Builder - out.WriteString("https://oidc-fips.") - out.WriteString(_Region) - out.WriteString(".") - out.WriteString(_PartitionResult.DualStackDnsSuffix) - return out.String() - }() - - uri, err := url.Parse(uriString) - if err != nil { - return endpoint, fmt.Errorf("Failed to parse uri: %s", uriString) - } - - return smithyendpoints.Endpoint{ - URI: *uri, - Headers: http.Header{}, - }, nil - } - } - return endpoint, fmt.Errorf("endpoint rule error, %s", "FIPS and DualStack are enabled, but this partition does not support one or both") - } - } - if _UseFIPS == true { - if _PartitionResult.SupportsFIPS == true { - if _PartitionResult.Name == "aws-us-gov" { - uriString := func() string { - var out strings.Builder - out.WriteString("https://oidc.") - out.WriteString(_Region) - out.WriteString(".amazonaws.com") - return out.String() - }() - - uri, err := url.Parse(uriString) - if err != nil { - return endpoint, fmt.Errorf("Failed to parse uri: %s", uriString) - } - - return smithyendpoints.Endpoint{ - URI: *uri, - Headers: http.Header{}, - }, nil - } - uriString := func() string { - var out strings.Builder - out.WriteString("https://oidc-fips.") - out.WriteString(_Region) - out.WriteString(".") - out.WriteString(_PartitionResult.DnsSuffix) - return out.String() - }() - - uri, err := url.Parse(uriString) - if err != nil { - return endpoint, fmt.Errorf("Failed to parse uri: %s", uriString) - } - - return smithyendpoints.Endpoint{ - URI: *uri, - Headers: http.Header{}, - }, nil - } - return endpoint, fmt.Errorf("endpoint rule error, %s", "FIPS is enabled but this partition does not support FIPS") - } - if _UseDualStack == true { - if true == _PartitionResult.SupportsDualStack { - uriString := func() string { - var out strings.Builder - out.WriteString("https://oidc.") - out.WriteString(_Region) - out.WriteString(".") - out.WriteString(_PartitionResult.DualStackDnsSuffix) - return out.String() - }() - - uri, err := url.Parse(uriString) - if err != nil { - return endpoint, fmt.Errorf("Failed to parse uri: %s", uriString) - } - - return smithyendpoints.Endpoint{ - URI: *uri, - Headers: http.Header{}, - }, nil - } - return endpoint, fmt.Errorf("endpoint rule error, %s", "DualStack is enabled but this partition does not support DualStack") - } - uriString := func() string { - var out strings.Builder - out.WriteString("https://oidc.") - out.WriteString(_Region) - out.WriteString(".") - out.WriteString(_PartitionResult.DnsSuffix) - return out.String() - }() - - uri, err := url.Parse(uriString) - if err != nil { - return endpoint, fmt.Errorf("Failed to parse uri: %s", uriString) - } - return smithyendpoints.Endpoint{ - URI: *uri, - Headers: http.Header{}, - }, nil - } - return endpoint, fmt.Errorf("Endpoint resolution failed. Invalid operation or environment input.") - } - return endpoint, fmt.Errorf("endpoint rule error, %s", "Invalid Configuration: Missing Region") + c := &conditionContext{} + ref := bdd.Evaluate(bddNodes[:], bddRoot, func(idx int) bool { + return evalCondition(idx, ¶ms, c) + }) + return resolveResult(ref, ¶ms, c) } type endpointParamsBinder interface { diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ssooidc/go_module_metadata.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ssooidc/go_module_metadata.go index af00268dfc..f94dbeb9b5 100644 --- a/vendor/github.com/aws/aws-sdk-go-v2/service/ssooidc/go_module_metadata.go +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ssooidc/go_module_metadata.go @@ -3,4 +3,4 @@ package ssooidc // goModuleVersion is the tagged release for this module -const goModuleVersion = "1.35.21" +const goModuleVersion = "1.36.0" diff --git a/vendor/github.com/aws/smithy-go/endpoints/private/bdd/evaluate.go b/vendor/github.com/aws/smithy-go/endpoints/private/bdd/evaluate.go new file mode 100644 index 0000000000..ae0fb7fdad --- /dev/null +++ b/vendor/github.com/aws/smithy-go/endpoints/private/bdd/evaluate.go @@ -0,0 +1,35 @@ +package bdd + +const resultOffset int32 = 100_000_000 +const intsPerNode = 3 + +// Evaluate traverses a compiled BDD node array and returns the result index. +// nodes is a flat array of [condIdx, hi, lo] triples (1-indexed). +// root is the root node reference. evalCond returns true/false for condition index. +func Evaluate(nodes []int32, root int32, evalCond func(int) bool) int32 { + ref := root + for { + if ref >= resultOffset { + return ref - resultOffset + } + if ref == 1 || ref == -1 { + return 0 // NoMatchRule + } + + complement := ref < 0 + nodeIdx := ref + if complement { + nodeIdx = -ref + } + base := (nodeIdx - 1) * intsPerNode + condIdx := nodes[base] + hi := nodes[base+1] + lo := nodes[base+2] + + if complement != evalCond(int(condIdx)) { + ref = hi + } else { + ref = lo + } + } +} diff --git a/vendor/github.com/pion/sctp/README.md b/vendor/github.com/pion/sctp/README.md index ef33fb5b97..168a7710b4 100644 --- a/vendor/github.com/pion/sctp/README.md +++ b/vendor/github.com/pion/sctp/README.md @@ -36,10 +36,10 @@ Ideally, we would like to add the following features as part of a [v2 refresh](h Feature | Reference | Progress --- | --- | --- -RACK (tail loss probing) | [Paper](https://icnp20.cs.ucr.edu/proceedings/nipaa/RACK%20for%20SCTP.pdf), [Comment](https://github.com/pion/sctp/issues/206#issuecomment-968265853)| [In review](https://github.com/pion/sctp/pull/390) -Adaptive burst mitigation | [Paper, see section 5A](https://icnp20.cs.ucr.edu/proceedings/nipaa/RACK%20for%20SCTP.pdf)| [In review](https://github.com/pion/sctp/pull/394) +RACK (tail loss probing) | [Paper](https://icnp20.cs.ucr.edu/proceedings/nipaa/RACK%20for%20SCTP.pdf), [Comment](https://github.com/pion/sctp/issues/206#issuecomment-968265853)| [Implemented](https://github.com/pion/sctp/pull/390) +Adaptive burst mitigation | [Paper, see section 5A](https://icnp20.cs.ucr.edu/proceedings/nipaa/RACK%20for%20SCTP.pdf)| [Implemented](https://github.com/pion/sctp/pull/394) Update to RFC 9260 | [Parent issue](https://github.com/pion/sctp/issues/402) | [In progress](https://github.com/pion/sctp/issues/402) -Implement RFC 8260 | [Issue](https://github.com/pion/sctp/issues/435) | In progress (no PR available yet) +Implement RFC 8260 | [Issue](https://github.com/pion/sctp/issues/435) | [Implemented](https://github.com/pion/sctp/pull/443) Blocking writes | [1](https://github.com/pion/sctp/issues/77), [2](https://github.com/pion/sctp/issues/357) | [Potentially in progress](https://github.com/pion/sctp/issues/357#issuecomment-3382050767) association.listener (and better docs) | [1](https://github.com/pion/sctp/issues/74), [2](https://github.com/pion/sctp/issues/173) | Not started, [blocked by above](https://github.com/pion/sctp/issues/74#issuecomment-545550714) diff --git a/vendor/github.com/pion/sctp/association.go b/vendor/github.com/pion/sctp/association.go index 1b66147aaa..a3cc89cf95 100644 --- a/vendor/github.com/pion/sctp/association.go +++ b/vendor/github.com/pion/sctp/association.go @@ -74,9 +74,35 @@ const ( initialRecvBufSize uint32 = 1024 * 1024 commonHeaderSize uint32 = 12 dataChunkHeaderSize uint32 = 16 + iDataChunkHeaderSize uint32 = 20 defaultMaxMessageSize uint32 = 65536 ) +// PartialReliabilityMode indicates the negotiated partial reliability mode. +type PartialReliabilityMode int + +// PartialReliabilityMode values. +const ( + PartialReliabilityModeNone PartialReliabilityMode = iota + PartialReliabilityModeForwardTSN + PartialReliabilityModeIForwardTSN +) + +// AssociationMetadata describes negotiated association capabilities. +type AssociationMetadata struct { + // MessageInterleavingEnabled indicates whether RFC 8260 user message interleaving was negotiated. + MessageInterleavingEnabled bool `json:"messageInterleavingEnabled"` + + // PartialReliabilityMode indicates which FORWARD-TSN variant is active. + PartialReliabilityMode PartialReliabilityMode `json:"partialReliabilityMode"` + + // ZeroChecksumSendingEnabled indicates whether outgoing packets use zero checksum. + ZeroChecksumSendingEnabled bool `json:"zeroChecksumSendingEnabled"` + + // ZeroChecksumReceivingEnabled indicates whether incoming packets may use zero checksum. + ZeroChecksumReceivingEnabled bool `json:"zeroChecksumReceivingEnabled"` +} + // association state enums. const ( closed uint32 = iota @@ -234,6 +260,12 @@ type Association struct { cumulativeTSNAckPoint uint32 advancedPeerTSNAckPoint uint32 useForwardTSN bool + useIForwardTSN bool + useInterleaving bool + localInterleaving bool + peerInterleaving bool + peerForwardTSN bool + peerIForwardTSN bool sendZeroChecksum bool recvZeroChecksum bool @@ -333,10 +365,9 @@ type snapConfig struct { // Config collects the arguments to createAssociation construction into // a single structure. type Config struct { - LoggerFactory logging.LoggerFactory - Name string - NetConn net.Conn - + LoggerFactory logging.LoggerFactory + Name string + NetConn net.Conn BlockWrite bool EnableZeroChecksum bool MTU uint32 @@ -356,8 +387,14 @@ type Config struct { // RACK config options rack rackSettings + // User message interleaving config options + interleaving *interleavingSettings + // SNAP/sctp-init snapConfig *snapConfig + + enableInterleaving bool + enableInterleavingSet bool } // Server accepts a SCTP stream over a conn. @@ -416,7 +453,9 @@ func createSNAPAssociation(config *Config) (*Association, error) { return nil, err } assoc := createAssociationFromConfigWithTsn(config, local.initialTSN) - assoc.initWithOutOfBandTokens(local, remote) + if err = assoc.initWithOutOfBandTokens(local, remote); err != nil { + return nil, err + } return assoc, nil } @@ -467,6 +506,15 @@ func (c *Config) applyDefaults() { if c.MTU == 0 { c.MTU = initialMTU } + if !c.enableInterleavingSet { + c.enableInterleaving = true + } + if c.interleaving == nil { + c.interleaving = &interleavingSettings{} + } + if c.interleaving.newStreamScheduler == nil { + setWeightedFairQueueingStreamScheduler(c.interleaving) + } } func createServerAssociation(opts ...ServerOption) (*Association, error) { @@ -524,6 +572,11 @@ func (c Config) applyServer(cfg *Config) error { //nolint:dupl,cyclop } cfg.rack = c.rack + cfg.interleaving = cloneInterleavingSettings(c.interleaving) + if c.enableInterleavingSet { + cfg.enableInterleaving = c.enableInterleaving + cfg.enableInterleavingSet = true + } return nil } @@ -572,7 +625,7 @@ func (a *Association) initClient() { init.numInboundStreams = a.myMaxNumInboundStreams init.initiateTag = a.myVerificationTag init.advertisedReceiverWindowCredit = a.maxReceiveBufferSize - setSupportedExtensions(&init.chunkInitCommon) + setSupportedExtensions(&init.chunkInitCommon, a.localInterleaving) if a.recvZeroChecksum { init.params = append(init.params, ¶mZeroChecksumAcceptable{edmid: dtlsErrorDetectionMethod}) @@ -632,6 +685,11 @@ func (c Config) applyClient(cfg *Config) error { //nolint:dupl,cyclop } cfg.rack = c.rack + cfg.interleaving = cloneInterleavingSettings(c.interleaving) + if c.enableInterleavingSet { + cfg.enableInterleaving = c.enableInterleaving + cfg.enableInterleavingSet = true + } cfg.snapConfig = c.snapConfig @@ -683,6 +741,11 @@ func createAssociationFromConfigWithTsn(cfg *Config, tsn uint32) *Association { } rtoMax := cfg.RTOMax + interleaving := cfg.interleaving + if interleaving == nil { + interleaving = &interleavingSettings{} + setWeightedFairQueueingStreamScheduler(interleaving) + } assoc := &Association{ netConn: cfg.NetConn, @@ -697,7 +760,7 @@ func createAssociationFromConfigWithTsn(cfg *Config, tsn uint32) *Association { payloadQueue: newReceivePayloadQueue(getMaxTSNOffset(maxReceiveBufferSize)), inflightQueue: newPayloadQueue(), - pendingQueue: newPendingQueue(), + pendingQueue: newPendingQueue(interleaving.newStreamScheduler), controlQueue: newControlQueue(), mtu: mtu, maxPayloadSize: mtu - (commonHeaderSize + dataChunkHeaderSize), @@ -719,6 +782,7 @@ func createAssociationFromConfigWithTsn(cfg *Config, tsn uint32) *Association { cumulativeTSNAckPoint: tsn - 1, advancedPeerTSNAckPoint: tsn - 1, recvZeroChecksum: cfg.EnableZeroChecksum, + localInterleaving: cfg.enableInterleaving, silentError: ErrSilentlyDiscard, stats: &associationStats{}, log: cfg.LoggerFactory.NewLogger("sctp"), @@ -768,7 +832,7 @@ func createAssociationFromConfigWithTsn(cfg *Config, tsn uint32) *Association { return assoc } -func (a *Association) initWithOutOfBandTokens(localInit *chunkInit, remoteInit *chunkInit) { +func (a *Association) initWithOutOfBandTokens(localInit *chunkInit, remoteInit *chunkInit) error { a.lock.Lock() defer a.lock.Unlock() @@ -782,27 +846,59 @@ func (a *Association) initWithOutOfBandTokens(localInit *chunkInit, remoteInit * a.peerVerificationTag = remoteInit.initiateTag a.sourcePort = defaultSCTPSrcDstPort a.destinationPort = defaultSCTPSrcDstPort - for _, param := range remoteInit.params { - switch v := param.(type) { // nolint:gocritic - case *paramSupportedExtensions: - for _, t := range v.ChunkTypes { - if t == ctForwardTSN { - a.log.Debugf("[%s] use ForwardTSN (on init)", a.name) - a.useForwardTSN = true - } - } - case *paramZeroChecksumAcceptable: - a.sendZeroChecksum = v.edmid == dtlsErrorDetectionMethod - } + + localExtensions := getSupportedExtensions(localInit.params) + a.localInterleaving = localExtensions.interleaving + a.setPeerSupportedExtensions(getSupportedExtensions(remoteInit.params)) + a.setSendZeroChecksum(remoteInit.params) + + a.ssthresh = a.RWND() + + if err := a.establish("init"); err != nil { + return err } - if !a.useForwardTSN { - a.log.Warnf("[%s] not using ForwardTSN (on init)", a.name) + return nil +} + +func (a *Association) setPeerSupportedExtensions(extensions supportedExtensions) { + a.peerForwardTSN = extensions.forwardTSN + a.peerInterleaving = extensions.interleaving + a.peerIForwardTSN = extensions.iForwardTSN +} + +func (a *Association) setSendZeroChecksum(params []param) { + for _, param := range params { + if zeroChecksum, ok := param.(*paramZeroChecksumAcceptable); ok { + a.sendZeroChecksum = zeroChecksum.edmid == dtlsErrorDetectionMethod + } } +} - a.ssthresh = a.RWND() +func (a *Association) logNegotiatedExtensions(stage string) { + switch { + case a.useInterleaving: + a.log.Debugf("[%s] use interleaving (on %s)", a.name, stage) + if !a.useIForwardTSN { + a.log.Warnf("[%s] not using I-ForwardTSN (on %s)", a.name, stage) + } + case a.useForwardTSN: + a.log.Debugf("[%s] use ForwardTSN (on %s)", a.name, stage) + default: + a.log.Warnf("[%s] not using ForwardTSN (on %s)", a.name, stage) + } +} +// establish finalizes negotiated options and transitions the association to ESTABLISHED. +// The caller should hold the lock. +func (a *Association) establish(stage string) error { + if err := a.updateInterleavingState(); err != nil { + return err + } + a.logNegotiatedExtensions(stage) a.setState(established) + + return nil } // caller must hold a.lock. @@ -1298,9 +1394,17 @@ func (a *Association) gatherOutboundFastRetransmissionPackets( //nolint:gocognit continue } - // include padding for sizing. - chunkBytes := int(dataChunkHeaderSize) + len(chunkPayload.userData) - chunkBytes += getPadding(chunkBytes) + // RFC 4960 Sec 7.2.4 Fast Retransmit on Gap Reports + // 3) Determine how many of the earliest (i.e., lowest TSN) DATA chunks + // marked for retransmission will fit into a single packet, subject + // to constraint of the path MTU of the destination transport + // address to which the packet is being sent. Call this value K. + // Retransmit those K DATA chunks in a single packet. When a Fast + // Retransmit is being performed, the sender SHOULD ignore the value + // of cwnd and SHOULD NOT delay retransmission for this single + // packet. + + chunkBytes := chunkPayload.chunkSizeInPacket() // fast retransmit window cap if fastRetransWnd < fastRetransSize+chunkBytes { @@ -1396,10 +1500,18 @@ func (a *Association) gatherOutboundSackPackets(rawPackets [][]byte) [][]byte { // The caller should hold the lock. func (a *Association) gatherOutboundForwardTSNPackets(rawPackets [][]byte) [][]byte { - if a.willSendForwardTSN { + if a.willSendForwardTSN { //nolint:nestif a.willSendForwardTSN = false if sna32GT(a.advancedPeerTSNAckPoint, a.cumulativeTSNAckPoint) { - fwdtsn := a.createForwardTSN() + var fwdtsn chunk + if a.useIForwardTSN { + fwdtsn = a.createIForwardTSN() + } else if a.useForwardTSN { + fwdtsn = a.createForwardTSN() + } + if fwdtsn == nil { + return rawPackets + } raw, err := a.marshalPacket(a.createPacket([]chunk{fwdtsn})) if err != nil { a.log.Warnf("[%s] failed to serialize a Forward TSN packet", a.name) @@ -1672,6 +1784,32 @@ func (a *Association) SRTT() float64 { return a.srtt.Load().(float64) //nolint:forcetypeassert } +// Metadata returns negotiated association metadata. The ok return value is false +// until the SCTP handshake has completed. +func (a *Association) Metadata() (AssociationMetadata, bool) { + a.lock.RLock() + defer a.lock.RUnlock() + + if a.getState() != established { + return AssociationMetadata{}, false + } + + partialReliabilityMode := PartialReliabilityModeNone + switch { + case a.useIForwardTSN: + partialReliabilityMode = PartialReliabilityModeIForwardTSN + case a.useForwardTSN: + partialReliabilityMode = PartialReliabilityModeForwardTSN + } + + return AssociationMetadata{ + MessageInterleavingEnabled: a.useInterleaving, + PartialReliabilityMode: partialReliabilityMode, + ZeroChecksumSendingEnabled: a.sendZeroChecksum, + ZeroChecksumReceivingEnabled: a.recvZeroChecksum, + }, true +} + // getMaxTSNOffset returns the maximum offset over the current cummulative TSN that // we are willing to enqueue. This ensures that we keep the bytes utilized in the receive // buffer within a small multiple of the user provided max receive buffer size. @@ -1682,17 +1820,99 @@ func getMaxTSNOffset(maxReceiveBufferSize uint32) uint32 { return offset } -func setSupportedExtensions(init *chunkInitCommon) { +func setSupportedExtensions(init *chunkInitCommon, enableInterleaving bool) { // nolint:godox // TODO RFC5061 https://tools.ietf.org/html/rfc6525#section-5.2 // An implementation supporting this (Supported Extensions Parameter) // extension MUST list the ASCONF, the ASCONF-ACK, and the AUTH chunks // in its INIT and INIT-ACK parameters. + chunkTypes := []chunkType{ctReconfig, ctForwardTSN} + if enableInterleaving { + chunkTypes = append(chunkTypes, ctIData, ctIForwardTSN) + } init.params = append(init.params, ¶mSupportedExtensions{ - ChunkTypes: []chunkType{ctReconfig, ctForwardTSN}, + ChunkTypes: chunkTypes, }) } +type supportedExtensions struct { + forwardTSN bool + interleaving bool + iForwardTSN bool +} + +func getSupportedExtensions(params []param) supportedExtensions { + var extensions supportedExtensions + for _, param := range params { + if supported, ok := param.(*paramSupportedExtensions); ok { + parsed := supportedExtensionsFromChunkTypes(supported.ChunkTypes) + extensions.forwardTSN = extensions.forwardTSN || parsed.forwardTSN + extensions.interleaving = extensions.interleaving || parsed.interleaving + extensions.iForwardTSN = extensions.iForwardTSN || parsed.iForwardTSN + } + } + + return extensions +} + +func supportedExtensionsFromChunkTypes(chunkTypes []chunkType) supportedExtensions { + var extensions supportedExtensions + for _, t := range chunkTypes { + switch t { + case ctForwardTSN: + extensions.forwardTSN = true + case ctIData: + extensions.interleaving = true + case ctIForwardTSN: + extensions.iForwardTSN = true + default: + } + } + + return extensions +} + +func (a *Association) updateInterleavingState() error { + useInterleaving := a.localInterleaving && a.peerInterleaving + if useInterleaving != a.useInterleaving { + if err := a.pendingQueue.setInterleaving(useInterleaving); err != nil { + return err + } + + a.useInterleaving = useInterleaving + if useInterleaving { + a.maxPayloadSize = a.mtu - (commonHeaderSize + iDataChunkHeaderSize) + } else { + a.maxPayloadSize = a.mtu - (commonHeaderSize + dataChunkHeaderSize) + } + } + + if useInterleaving { + a.useIForwardTSN = a.peerIForwardTSN && a.localInterleaving + a.useForwardTSN = false + } else { + a.useIForwardTSN = false + a.useForwardTSN = a.peerForwardTSN + } + + return nil +} + +func (a *Association) partialReliabilityEnabled() bool { + return a.useForwardTSN || a.useIForwardTSN +} + +// The caller should hold the lock. +func (a *Association) abortProtocolViolation(reason string) { + a.log.Warnf("[%s] protocol violation: %s", a.name, reason) + a.willSendAbort = true + a.willSendAbortCause = &errorCauseProtocolViolation{ + errorCauseHeader: errorCauseHeader{code: protocolViolation}, + additionalInformation: []byte(reason), + } + a.awakeWriteLoop() +} + // The caller should hold the lock. // //nolint:cyclop @@ -1732,21 +1952,33 @@ func (a *Association) handleInit(pkt *packet, initChunk *chunkInit) ([]*packet, a.setRWND(initChunk.advertisedReceiverWindowCredit) a.log.Debugf("[%s] initial rwnd=%d", a.name, a.RWND()) + a.peerInterleaving = false + a.peerForwardTSN = false + a.peerIForwardTSN = false + for _, param := range initChunk.params { - switch v := param.(type) { // nolint:gocritic + switch val := param.(type) { // nolint:gocritic case *paramSupportedExtensions: - for _, t := range v.ChunkTypes { - if t == ctForwardTSN { - a.log.Debugf("[%s] use ForwardTSN (on init)", a.name) - a.useForwardTSN = true - } - } + extensions := supportedExtensionsFromChunkTypes(val.ChunkTypes) + a.peerForwardTSN = a.peerForwardTSN || extensions.forwardTSN + a.peerInterleaving = a.peerInterleaving || extensions.interleaving + a.peerIForwardTSN = a.peerIForwardTSN || extensions.iForwardTSN case *paramZeroChecksumAcceptable: - a.sendZeroChecksum = v.edmid == dtlsErrorDetectionMethod + a.sendZeroChecksum = val.edmid == dtlsErrorDetectionMethod } } - if !a.useForwardTSN { + if err := a.updateInterleavingState(); err != nil { + return nil, err + } + if a.useInterleaving { //nolint:nestif,gocritic + a.log.Debugf("[%s] use interleaving (on init)", a.name) + if !a.useIForwardTSN { + a.log.Warnf("[%s] not using I-ForwardTSN (on init)", a.name) + } + } else if a.useForwardTSN { + a.log.Debugf("[%s] use ForwardTSN (on init)", a.name) + } else { a.log.Warnf("[%s] not using ForwardTSN (on init)", a.name) } @@ -1780,7 +2012,7 @@ func (a *Association) handleInit(pkt *packet, initChunk *chunkInit) ([]*packet, } a.log.Debugf("[%s] sendZeroChecksum=%t (on init)", a.name, a.sendZeroChecksum) - setSupportedExtensions(&initAck.chunkInitCommon) + setSupportedExtensions(&initAck.chunkInitCommon, a.localInterleaving) outbound.chunks = []chunk{initAck} @@ -1826,26 +2058,38 @@ func (a *Association) handleInitAck(pkt *packet, initChunkAck *chunkInitAck) err a.t1Init.stop() a.storedInit = nil + a.peerInterleaving = false + a.peerForwardTSN = false + a.peerIForwardTSN = false + var cookieParam *paramStateCookie for _, param := range initChunkAck.params { - switch v := param.(type) { + switch val := param.(type) { case *paramStateCookie: - cookieParam = v + cookieParam = val case *paramSupportedExtensions: - for _, t := range v.ChunkTypes { - if t == ctForwardTSN { - a.log.Debugf("[%s] use ForwardTSN (on initAck)", a.name) - a.useForwardTSN = true - } - } + extensions := supportedExtensionsFromChunkTypes(val.ChunkTypes) + a.peerForwardTSN = a.peerForwardTSN || extensions.forwardTSN + a.peerInterleaving = a.peerInterleaving || extensions.interleaving + a.peerIForwardTSN = a.peerIForwardTSN || extensions.iForwardTSN case *paramZeroChecksumAcceptable: - a.sendZeroChecksum = v.edmid == dtlsErrorDetectionMethod + a.sendZeroChecksum = val.edmid == dtlsErrorDetectionMethod } } a.log.Debugf("[%s] sendZeroChecksum=%t (on initAck)", a.name, a.sendZeroChecksum) - if !a.useForwardTSN { + if err := a.updateInterleavingState(); err != nil { + return err + } + if a.useInterleaving { //nolint:gocritic + a.log.Tracef("[%s] use interleaving (on initAck)", a.name) + if !a.useIForwardTSN { + a.log.Warnf("[%s] not using I-ForwardTSN (on initAck)", a.name) + } + } else if a.useForwardTSN { + a.log.Tracef("[%s] use ForwardTSN (on initAck)", a.name) + } else { a.log.Warnf("[%s] not using ForwardTSN (on initAck)", a.name) } if cookieParam == nil { @@ -1970,7 +2214,11 @@ func (a *Association) handleCookieEcho(cookieEcho *chunkCookieEcho) []*packet { a.t1Cookie.stop() a.storedCookieEcho = nil - a.setState(established) + if err := a.establish("cookieEcho"); err != nil { + a.completeHandshake(err) + + return nil + } if !a.completeHandshake(nil) { return nil } @@ -2001,48 +2249,40 @@ func (a *Association) handleCookieAck() { a.t1Cookie.stop() a.storedCookieEcho = nil - a.setState(established) + if err := a.establish("cookieAck"); err != nil { + a.completeHandshake(err) + + return + } a.completeHandshake(nil) } // The caller should hold the lock. func (a *Association) handleData(chunkPayload *chunkPayloadData) []*packet { + state := a.getState() + if state != established && state != shutdownPending && state != shutdownReceived { + return nil + } + + if chunkPayload.isIData() != a.useInterleaving { + if chunkPayload.isIData() { + a.abortProtocolViolation("received I-DATA without interleaving negotiated") + } else { + a.abortProtocolViolation("received DATA with interleaving negotiated") + } + + return nil + } + a.log.Tracef("[%s] DATA: tsn=%d immediateSack=%v len=%d", a.name, chunkPayload.tsn, chunkPayload.immediateSack, len(chunkPayload.userData)) a.stats.incDATAs() canPush := a.payloadQueue.canPush(chunkPayload.tsn) - if canPush { //nolint:nestif - stream := a.getOrCreateStream(chunkPayload.streamIdentifier, true, PayloadTypeUnknown) - if stream == nil { - // silently discard the data. (sender will retry on T3-rtx timeout) - // see pion/sctp#30 - a.log.Debugf("[%s] discard %d", a.name, chunkPayload.streamSequenceNumber) - + if canPush { + if !a.acceptPayloadData(chunkPayload) { return nil } - - if a.getMyReceiverWindowCredit() > 0 { - // Pass the new chunk to stream level as soon as it arrives - a.payloadQueue.push(chunkPayload.tsn) - stream.handleData(chunkPayload) - } else { - // Receive buffer is full - lastTSN, ok := a.payloadQueue.getLastTSNReceived() - if ok && sna32LT(chunkPayload.tsn, lastTSN) { - a.log.Debugf( - "[%s] receive buffer full, but accepted as this is a missing chunk with tsn=%d ssn=%d", - a.name, chunkPayload.tsn, chunkPayload.streamSequenceNumber, - ) - a.payloadQueue.push(chunkPayload.tsn) - stream.handleData(chunkPayload) - } else { - a.log.Debugf( - "[%s] receive buffer full. dropping DATA with tsn=%d ssn=%d", - a.name, chunkPayload.tsn, chunkPayload.streamSequenceNumber, - ) - } - } } // Upon the reception of a new DATA chunk, an endpoint shall examine the @@ -2059,6 +2299,53 @@ func (a *Association) handleData(chunkPayload *chunkPayloadData) []*packet { return a.handlePeerLastTSNAndAcknowledgement(sackNow) } +// The caller should hold the lock. +func (a *Association) acceptPayloadData(chunkPayload *chunkPayloadData) bool { + stream := a.getOrCreateStream(chunkPayload.streamIdentifier, true, PayloadTypeUnknown) + if stream == nil { + // silently discard the data. (sender will retry on T3-rtx timeout) + // see pion/sctp#30 + a.log.Debugf("[%s] discard %d", a.name, chunkPayload.streamSequenceNumber) + + return false + } + + if a.getMyReceiverWindowCredit() > 0 { + // Pass the new chunk to stream level as soon as it arrives + return a.pushPayloadDataToStream(stream, chunkPayload) + } + + // Receive buffer is full + lastTSN, ok := a.payloadQueue.getLastTSNReceived() + if !ok || !sna32LT(chunkPayload.tsn, lastTSN) { + a.log.Debugf( + "[%s] receive buffer full. dropping DATA with tsn=%d ssn=%d", + a.name, chunkPayload.tsn, chunkPayload.streamSequenceNumber, + ) + + return true + } + + a.log.Debugf( + "[%s] receive buffer full, but accepted as this is a missing chunk with tsn=%d ssn=%d", + a.name, chunkPayload.tsn, chunkPayload.streamSequenceNumber, + ) + + return a.pushPayloadDataToStream(stream, chunkPayload) +} + +// The caller should hold the lock. +func (a *Association) pushPayloadDataToStream(stream *Stream, chunkPayload *chunkPayloadData) bool { + a.payloadQueue.push(chunkPayload.tsn) + if err := stream.handleData(chunkPayload); err != nil { + a.abortProtocolViolation(err.Error()) + + return false + } + + return true +} + // A common routine for handleData and handleForwardTSN routines // The caller should hold the lock. func (a *Association) handlePeerLastTSNAndAcknowledgement(sackImmediately bool) []*packet { //nolint:cyclop @@ -2570,7 +2857,7 @@ func (a *Association) handleSack(selectiveAckChunk *chunkSelectiveAck) error { return err } - if a.useForwardTSN { + if a.partialReliabilityEnabled() { // RFC 3758 Sec 3.5 C1 if sna32LT(a.advancedPeerTSNAckPoint, a.cumulativeTSNAckPoint) { a.advancedPeerTSNAckPoint = a.cumulativeTSNAckPoint @@ -2732,6 +3019,52 @@ func (a *Association) createForwardTSN() *chunkForwardTSN { return fwdtsn } +// createIForwardTSN generates I-FORWARD-TSN chunk. +// The caller should hold the lock. +func (a *Association) createIForwardTSN() *chunkIForwardTSN { + ordered := map[uint16]uint32{} + unordered := map[uint16]uint32{} + for i := a.cumulativeTSNAckPoint + 1; sna32LTE(i, a.advancedPeerTSNAckPoint); i++ { + c, ok := a.inflightQueue.get(i) + if !ok { + break + } + if c.unordered { + mid, ok := unordered[c.streamIdentifier] + if !ok || sna32LT(mid, c.messageIdentifier) { + unordered[c.streamIdentifier] = c.messageIdentifier + } + } else { + mid, ok := ordered[c.streamIdentifier] + if !ok || sna32LT(mid, c.messageIdentifier) { + ordered[c.streamIdentifier] = c.messageIdentifier + } + } + } + + fwdtsn := &chunkIForwardTSN{ + newCumulativeTSN: a.advancedPeerTSNAckPoint, + streams: []chunkIForwardTSNStream{}, + } + + for si, mid := range ordered { + fwdtsn.streams = append(fwdtsn.streams, chunkIForwardTSNStream{ + identifier: si, + unordered: false, + messageIdentifier: mid, + }) + } + for si, mid := range unordered { + fwdtsn.streams = append(fwdtsn.streams, chunkIForwardTSNStream{ + identifier: si, + unordered: true, + messageIdentifier: mid, + }) + } + + return fwdtsn +} + // createPacket wraps chunks in a packet. // The caller should hold the read lock. func (a *Association) createPacket(cs []chunk) *packet { @@ -2774,6 +3107,12 @@ func (a *Association) handleReconfig(reconfigChunk *chunkReconfig) ([]*packet, e func (a *Association) handleForwardTSN(chunkTSN *chunkForwardTSN) []*packet { a.log.Tracef("[%s] FwdTSN: %s", a.name, chunkTSN.String()) + if a.useInterleaving { + a.abortProtocolViolation("received FORWARD-TSN with interleaving enabled") + + return nil + } + if !a.useForwardTSN { a.log.Warn("[%s] received FwdTSN but not enabled") // Return an error chunk @@ -2818,10 +3157,7 @@ func (a *Association) handleForwardTSN(chunkTSN *chunkForwardTSN) []*packet { // its cumulative TSN point to the value carried in the FORWARD TSN // chunk, - // Advance peerLastTSN - for sna32LT(a.peerLastTSN(), chunkTSN.newCumulativeTSN) { - a.payloadQueue.pop(true) // may not exist - } + a.payloadQueue.advanceCumulativeTSN(chunkTSN.newCumulativeTSN) // Report new peerLastTSN value and abandoned largest SSN value to // corresponding streams so that the abandoned chunks can be removed @@ -2844,6 +3180,42 @@ func (a *Association) handleForwardTSN(chunkTSN *chunkForwardTSN) []*packet { return a.handlePeerLastTSNAndAcknowledgement(false) } +// The caller should hold the lock. +func (a *Association) handleIForwardTSN(chunkTSN *chunkIForwardTSN) []*packet { + a.log.Tracef("[%s] I-FwdTSN: %s", a.name, chunkTSN.String()) + + if !a.useIForwardTSN { + a.abortProtocolViolation("received I-FORWARD-TSN without support") + + return nil + } + + a.log.Tracef("[%s] should send ack? newCumTSN=%d peerLastTSN=%d", + a.name, chunkTSN.newCumulativeTSN, a.peerLastTSN()) + if sna32LTE(chunkTSN.newCumulativeTSN, a.peerLastTSN()) { + a.log.Tracef("[%s] sending ack on I-Forward TSN", a.name) + a.ackState = ackStateImmediate + a.ackTimer.stop() + a.awakeWriteLoop() + + return nil + } + + a.payloadQueue.advanceCumulativeTSN(chunkTSN.newCumulativeTSN) + + for _, forwarded := range chunkTSN.streams { + if s, ok := a.streams[forwarded.identifier]; ok { + if forwarded.unordered { + s.handleForwardTSNForUnorderedMID(forwarded.messageIdentifier) + } else { + s.handleForwardTSNForOrderedMID(forwarded.messageIdentifier) + } + } + } + + return a.handlePeerLastTSNAndAcknowledgement(false) +} + func (a *Association) sendResetRequest(streamIdentifier uint16) error { a.lock.Lock() defer a.lock.Unlock() @@ -2870,6 +3242,8 @@ func (a *Association) sendResetRequest(streamIdentifier uint16) error { } // The caller should hold the lock. +// +//nolint:cyclop func (a *Association) handleReconfigParam(raw param) (*packet, error) { switch par := raw.(type) { case *paramOutgoingResetRequest: @@ -2910,6 +3284,9 @@ func (a *Association) handleReconfigParam(raw param) (*packet, error) { return nil, nil //nolint:nilnil } + if par.result == reconfigResultSuccessPerformed { + a.resetOutgoingStreamSequenceNumbers(par.reconfigResponseSequenceNumber) + } delete(a.reconfigs, par.reconfigResponseSequenceNumber) if len(a.reconfigs) == 0 { a.tReconfig.stop() @@ -2921,6 +3298,23 @@ func (a *Association) handleReconfigParam(raw param) (*packet, error) { } } +// The caller should hold the lock. +func (a *Association) resetOutgoingStreamSequenceNumbers(reconfigRequestSequenceNumber uint32) { + reconfig := a.reconfigs[reconfigRequestSequenceNumber] + if reconfig == nil { + return + } + resetRequest, ok := reconfig.paramA.(*paramOutgoingResetRequest) + if !ok { + return + } + for _, id := range resetRequest.streamIdentifiers { + if s, ok := a.streams[id]; ok { + s.resetOutgoingStreamSequenceNumbers() + } + } +} + // The caller should hold the lock. func (a *Association) resetStreamsIfAny(resetRequest *paramOutgoingResetRequest) *packet { result := reconfigResultSuccessPerformed @@ -3038,9 +3432,7 @@ func (a *Association) popPendingDataChunksToSend( //nolint:cyclop,gocognit break // no more rwnd } - // compute current DATA chunk size including padding. - chunkBytes := int(dataChunkHeaderSize) + len(chunkPayload.userData) - chunkBytes += getPadding(chunkBytes) + chunkBytes := chunkPayload.chunkSizeInPacket() // ensure MTU bundling matches bundleDataChunksIntoPackets(). addBytes := chunkBytes @@ -3083,8 +3475,7 @@ func (a *Association) popPendingDataChunksToSend( //nolint:cyclop,gocognit c := a.pendingQueue.peek() if c != nil && len(c.userData) > 0 { // probe is a new packet: common header + chunk bytes. - chunkBytes := int(dataChunkHeaderSize) + len(c.userData) - chunkBytes += getPadding(chunkBytes) + chunkBytes := c.chunkSizeInPacket() addBytes := int(commonHeaderSize) + chunkBytes if addBytes <= int(a.MTU()) && a.tlrAllowSendLocked(budgetScaled, consumed, addBytes) { @@ -3118,8 +3509,7 @@ func (a *Association) bundleDataChunksIntoPackets(chunks []*chunkPayloadData) [] // single packet. Furthermore, DATA chunks being retransmitted MAY be // bundled with new DATA chunks, as long as the resulting packet size // does not exceed the path MTU. - chunkSizeInPacket := int(dataChunkHeaderSize) + len(chunkPayload.userData) - chunkSizeInPacket += getPadding(chunkSizeInPacket) + chunkSizeInPacket := chunkPayload.chunkSizeInPacket() if bytesInPacket+chunkSizeInPacket > int(a.MTU()) { packets = append(packets, a.createPacket(chunksToSend)) chunksToSend = []chunk{} @@ -3183,7 +3573,7 @@ func (a *Association) sendPayloadData(ctx context.Context, chunks []*chunkPayloa // The caller should hold the lock. func (a *Association) checkPartialReliabilityStatus(chunkPayload *chunkPayloadData) { - if !a.useForwardTSN { + if !a.partialReliabilityEnabled() { return } @@ -3253,8 +3643,7 @@ func (a *Association) getDataPacketsToRetransmit(budgetScaled *int64, consumed * break } - chunkBytes := int(dataChunkHeaderSize) + len(chunkPayload.userData) - chunkBytes += getPadding(chunkBytes) + chunkBytes := chunkPayload.chunkSizeInPacket() // retry as first chunk in a new packet if needed. for { @@ -3369,8 +3758,12 @@ func (a *Association) handleChunk(receivedPacket *packet, receivedChunk chunk) e var packets []*packet var err error - if _, err = receivedChunk.check(); err != nil { + var abort bool + if abort, err = receivedChunk.check(); err != nil { a.log.Errorf("[%s] failed validating chunk: %s ", a.name, err) + if abort && shouldAbortOnChunkValidationError(receivedChunk) { + a.abortProtocolViolation(err.Error()) + } return nil } @@ -3423,6 +3816,8 @@ func (a *Association) handleChunk(receivedPacket *packet, receivedChunk chunk) e case *chunkForwardTSN: packets = a.handleForwardTSN(receivedChunk) + case *chunkIForwardTSN: + packets = a.handleIForwardTSN(receivedChunk) case *chunkShutdown: a.handleShutdown(receivedChunk) @@ -3454,6 +3849,15 @@ func (a *Association) handleChunk(receivedPacket *packet, receivedChunk chunk) e return nil } +func shouldAbortOnChunkValidationError(receivedChunk chunk) bool { + switch receivedChunk.(type) { + case *chunkInit, *chunkInitAck, *chunkCookieEcho: + return false + default: + return true + } +} + func (a *Association) onRetransmissionTimeout(id int, nRtos uint) { //nolint:cyclop a.lock.Lock() defer a.lock.Unlock() @@ -3523,7 +3927,7 @@ func (a *Association) onRetransmissionTimeout(id int, nRtos uint) { //nolint:cyc // A5) Any time the T3-rtx timer expires, on any destination, the sender // SHOULD try to advance the "Advanced.Peer.Ack.Point" by following // the procedures outlined in C2 - C5. - if a.useForwardTSN { + if a.partialReliabilityEnabled() { // RFC 3758 Sec 3.5 C2 for i := a.advancedPeerTSNAckPoint + 1; ; i++ { c, ok := a.inflightQueue.get(i) @@ -4356,7 +4760,7 @@ func GenerateOutOfBandToken(opts ...ClientOption) ([]byte, error) { init.numInboundStreams = math.MaxUint16 init.initiateTag = generateInitiateTag() init.advertisedReceiverWindowCredit = config.MaxReceiveBufferSize - setSupportedExtensions(&init.chunkInitCommon) + setSupportedExtensions(&init.chunkInitCommon, config.enableInterleaving) if config.EnableZeroChecksum { init.params = append(init.params, ¶mZeroChecksumAcceptable{edmid: dtlsErrorDetectionMethod}) diff --git a/vendor/github.com/pion/sctp/association_interleaving_options.go b/vendor/github.com/pion/sctp/association_interleaving_options.go new file mode 100644 index 0000000000..06bf2708c2 --- /dev/null +++ b/vendor/github.com/pion/sctp/association_interleaving_options.go @@ -0,0 +1,135 @@ +// SPDX-FileCopyrightText: 2026 The Pion community +// SPDX-License-Identifier: MIT + +package sctp + +import "maps" + +type interleavingSettings struct { + newStreamScheduler InterleavingStreamSchedulerFactory + wfqWeights map[uint16]uint16 +} + +func setWeightedFairQueueingStreamScheduler(s *interleavingSettings) { + weights := maps.Clone(s.wfqWeights) + s.newStreamScheduler = func() InterleavingStreamScheduler { + return newWeightedFairQueueingPendingQueuePolicy(weights) + } +} + +func cloneInterleavingSettings(s *interleavingSettings) *interleavingSettings { + if s == nil { + return &interleavingSettings{} + } + + clone := &interleavingSettings{ + newStreamScheduler: s.newStreamScheduler, + } + if len(s.wfqWeights) > 0 { + clone.wfqWeights = make(map[uint16]uint16, len(s.wfqWeights)) + maps.Copy(clone.wfqWeights, s.wfqWeights) + } + + return clone +} + +// StreamSchedulerChunk is the scheduler-visible view of a DATA or I-DATA chunk. +// Stream reset chunks are control markers queued with data to preserve ordering. +type StreamSchedulerChunk interface { + StreamIdentifier() uint16 + UserDataLen() int + IsStreamReset() bool + + chunkPayloadData() *chunkPayloadData +} + +// InterleavingStreamScheduler schedules I-DATA chunks across streams when RFC 8260 +// user message interleaving is negotiated. +type InterleavingStreamScheduler interface { + // Reset clears scheduler state before use and when the scheduler is detached. + Reset() + Push(StreamSchedulerChunk) + Peek() StreamSchedulerChunk + Pop(StreamSchedulerChunk) error +} + +// InterleavingStreamSchedulerFactory creates an empty interleaving stream scheduler. +type InterleavingStreamSchedulerFactory func() InterleavingStreamScheduler + +// AssociationInterleavingOption configures RFC 8260 user message interleaving. +type AssociationInterleavingOption func(*interleavingSettings) error + +// WithInterleavingStreamSchedulerFactory selects a custom stream scheduler factory +// used when user message interleaving is negotiated. +func WithInterleavingStreamSchedulerFactory( + newScheduler InterleavingStreamSchedulerFactory, +) AssociationInterleavingOption { + return func(s *interleavingSettings) error { + if newScheduler == nil { + return errNilStreamScheduler + } + s.newStreamScheduler = newScheduler + + return nil + } +} + +// WithInterleavingWeightedFairQueueingScheduler selects the built-in RFC 8260 +// weighted fair queueing stream scheduler. +func WithInterleavingWeightedFairQueueingScheduler() AssociationInterleavingOption { + return func(s *interleavingSettings) error { + setWeightedFairQueueingStreamScheduler(s) + + return nil + } +} + +// WithInterleavingWeightedFairQueueingWeight sets the WFQ weight for a stream. +// Larger weights receive proportionally more scheduling service when multiple +// streams are backlogged. +func WithInterleavingWeightedFairQueueingWeight(streamID uint16, weight uint16) AssociationInterleavingOption { + return func(s *interleavingSettings) error { + if weight == 0 { + return errInvalidStreamSchedulerWeight + } + if s.wfqWeights == nil { + s.wfqWeights = map[uint16]uint16{} + } + s.wfqWeights[streamID] = weight + setWeightedFairQueueingStreamScheduler(s) + + return nil + } +} + +// WithInterleavingRoundRobinScheduler selects the built-in round-robin stream scheduler. +func WithInterleavingRoundRobinScheduler() AssociationInterleavingOption { + return func(s *interleavingSettings) error { + s.newStreamScheduler = func() InterleavingStreamScheduler { + return newRoundRobinPendingQueuePolicy() + } + + return nil + } +} + +// WithInterleavingOptions configures RFC 8260 user message interleaving options. +// The default interleaving stream scheduler is weighted fair queueing. +func WithInterleavingOptions(opts ...AssociationInterleavingOption) AssociationOption { + return sharedOption(func(c *Config) error { + cfg := cloneInterleavingSettings(c.interleaving) + for _, opt := range opts { + if opt == nil { + continue + } + + if err := opt(cfg); err != nil { + return err + } + } + + c.interleaving = cfg + + return nil + }) +} diff --git a/vendor/github.com/pion/sctp/association_options.go b/vendor/github.com/pion/sctp/association_options.go index 4e91fb14a7..6b2d276940 100644 --- a/vendor/github.com/pion/sctp/association_options.go +++ b/vendor/github.com/pion/sctp/association_options.go @@ -84,6 +84,17 @@ func WithEnableZeroChecksum(b bool) AssociationOption { }) } +// WithEnableInterleaving sets whether the association should negotiate message interleaving. +// By default this is true. +func WithEnableInterleaving(b bool) AssociationOption { + return sharedOption(func(c *Config) error { + c.enableInterleaving = b + c.enableInterleavingSet = true + + return nil + }) +} + // WithMTU sets the MTU size for the association. // By default this is 1228. func WithMTU(size uint32) AssociationOption { diff --git a/vendor/github.com/pion/sctp/chunk_i_forward_tsn.go b/vendor/github.com/pion/sctp/chunk_i_forward_tsn.go new file mode 100644 index 0000000000..45fa96e983 --- /dev/null +++ b/vendor/github.com/pion/sctp/chunk_i_forward_tsn.go @@ -0,0 +1,207 @@ +// SPDX-FileCopyrightText: 2026 The Pion community +// SPDX-License-Identifier: MIT + +package sctp + +import ( + "encoding/binary" + "errors" + "fmt" + "strings" +) + +// This chunk be used by the data sender to inform the data +// receiver to adjust its cumulative received TSN. +// +// 0 1 2 3 +// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 +// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ +// | Type = 194 | Flags = 0x00 | Length = Variable | +// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ +// | New Cumulative TSN | +// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ +// | Stream Identifier | Reserved |U| | +// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ +// | Message Identifier | +// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ +// \ / +// / \ +// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ +// | Stream Identifier | Reserved |U| | +// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ +// | Message Identifier | +// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ +// https://www.rfc-editor.org/rfc/rfc8260.html#section-2.3.1 + +type chunkIForwardTSN struct { + chunkHeader + + // This indicates the new cumulative TSN to the data receiver. + newCumulativeTSN uint32 + + streams []chunkIForwardTSNStream +} + +const ( + iForwardTSNEntryLength = 8 + maxIForwardTSNStreams = ((1 << 16) - 1 - chunkHeaderSize - newCumulativeTSNLength) / iForwardTSNEntryLength +) + +// I-FORWARD-TSN chunk errors. +var ( + errIForwardTSNChunkTooShort = errors.New("i-forward-tsn chunk too short") + errIForwardTSNChunkInvalidLength = errors.New("i-forward-tsn chunk invalid length") + errIForwardTSNTooManyStreams = errors.New("i-forward-tsn chunk contains too many streams") +) + +type iForwardTSNStreamKey struct { + identifier uint16 + unordered bool +} + +func (c *chunkIForwardTSN) unmarshal(raw []byte) error { + if err := c.chunkHeader.unmarshal(raw); err != nil { + return err + } + + if len(c.raw) < newCumulativeTSNLength { + return errIForwardTSNChunkTooShort + } + c.streams = nil + + c.newCumulativeTSN = binary.BigEndian.Uint32(c.raw[0:]) + + streamBytes := len(c.raw) - newCumulativeTSNLength + if streamBytes%iForwardTSNEntryLength != 0 { + return fmt.Errorf("%w: %w", ErrMarshalStreamFailed, errIForwardTSNChunkInvalidLength) + } + + streamCount := streamBytes / iForwardTSNEntryLength + if streamCount > maxIForwardTSNStreams { + return fmt.Errorf("%w: %d exceeds %d", errIForwardTSNTooManyStreams, streamCount, maxIForwardTSNStreams) + } + + streams := make([]chunkIForwardTSNStream, 0, streamCount) + for i := range streamCount { + offset := newCumulativeTSNLength + i*iForwardTSNEntryLength + s := chunkIForwardTSNStream{} + if err := s.unmarshal(c.raw[offset : offset+iForwardTSNEntryLength]); err != nil { + return fmt.Errorf("%w: %w", ErrMarshalStreamFailed, err) + } + + streams = append(streams, s) + } + c.streams = normalizeIForwardTSNStreams(streams) + + return nil +} + +func (c *chunkIForwardTSN) marshal() ([]byte, error) { + c.streams = normalizeIForwardTSNStreams(c.streams) + if _, err := c.check(); err != nil { + return nil, err + } + + out := make([]byte, newCumulativeTSNLength+len(c.streams)*iForwardTSNEntryLength) + binary.BigEndian.PutUint32(out[0:], c.newCumulativeTSN) + + offset := newCumulativeTSNLength + for _, s := range c.streams { + b, err := s.marshal() + if err != nil { + return nil, fmt.Errorf("%w: %v", ErrMarshalStreamFailed, err) //nolint:errorlint + } + + copy(out[offset:], b) + offset += len(b) + } + + c.typ = ctIForwardTSN + c.raw = out + + return c.chunkHeader.marshal() +} + +func (c *chunkIForwardTSN) check() (abort bool, err error) { + c.streams = normalizeIForwardTSNStreams(c.streams) + + if len(c.streams) > maxIForwardTSNStreams { + return true, fmt.Errorf("%w: %d exceeds %d", errIForwardTSNTooManyStreams, len(c.streams), maxIForwardTSNStreams) + } + + return false, nil +} + +func normalizeIForwardTSNStreams(streams []chunkIForwardTSNStream) []chunkIForwardTSNStream { + if len(streams) < 2 { + return streams + } + + normalized := make([]chunkIForwardTSNStream, 0, len(streams)) + forwarded := make(map[iForwardTSNStreamKey]int, len(streams)) + for _, stream := range streams { + key := iForwardTSNStreamKey{ + identifier: stream.identifier, + unordered: stream.unordered, + } + if idx, ok := forwarded[key]; ok { + if sna32LT(normalized[idx].messageIdentifier, stream.messageIdentifier) { + normalized[idx].messageIdentifier = stream.messageIdentifier + } + + continue + } + + forwarded[key] = len(normalized) + normalized = append(normalized, stream) + } + + return normalized +} + +// String makes chunkIForwardTSN printable. +func (c *chunkIForwardTSN) String() string { + var res strings.Builder + fmt.Fprintf(&res, "New Cumulative TSN: %d\n", c.newCumulativeTSN) + for _, s := range c.streams { + fmt.Fprintf(&res, " - si=%d mid=%d unordered=%v\n", s.identifier, s.messageIdentifier, s.unordered) + } + + return res.String() +} + +type chunkIForwardTSNStream struct { + identifier uint16 + unordered bool + messageIdentifier uint32 +} + +func (s *chunkIForwardTSNStream) length() int { + return iForwardTSNEntryLength +} + +func (s *chunkIForwardTSNStream) unmarshal(raw []byte) error { + if len(raw) < iForwardTSNEntryLength { + return errIForwardTSNChunkTooShort + } + s.identifier = binary.BigEndian.Uint16(raw[0:]) + flags := binary.BigEndian.Uint16(raw[2:]) + s.unordered = flags&0x1 != 0 + s.messageIdentifier = binary.BigEndian.Uint32(raw[4:]) + + return nil +} + +func (s *chunkIForwardTSNStream) marshal() ([]byte, error) { // nolint:unparam + out := make([]byte, iForwardTSNEntryLength) + + binary.BigEndian.PutUint16(out[0:], s.identifier) + if s.unordered { + binary.BigEndian.PutUint16(out[2:], 0x1) + } else { + binary.BigEndian.PutUint16(out[2:], 0x0) + } + binary.BigEndian.PutUint32(out[4:], s.messageIdentifier) + + return out, nil +} diff --git a/vendor/github.com/pion/sctp/chunk_payload_data.go b/vendor/github.com/pion/sctp/chunk_payload_data.go index dfd8ef776f..9e2ed96cd7 100644 --- a/vendor/github.com/pion/sctp/chunk_payload_data.go +++ b/vendor/github.com/pion/sctp/chunk_payload_data.go @@ -54,11 +54,14 @@ type chunkPayloadData struct { endingFragment bool immediateSack bool - tsn uint32 - streamIdentifier uint16 - streamSequenceNumber uint16 - payloadType PayloadProtocolIdentifier - userData []byte + tsn uint32 + streamIdentifier uint16 + streamSequenceNumber uint16 + messageIdentifier uint32 + fragmentSequenceNumber uint32 + payloadType PayloadProtocolIdentifier + userData []byte + iData bool // Whether this data chunk was acknowledged (received by peer) acked bool @@ -81,6 +84,22 @@ type chunkPayloadData struct { rackInList bool } +func (p *chunkPayloadData) StreamIdentifier() uint16 { + return p.streamIdentifier +} + +func (p *chunkPayloadData) UserDataLen() int { + return len(p.userData) +} + +func (p *chunkPayloadData) IsStreamReset() bool { + return p.userData == nil +} + +func (p *chunkPayloadData) chunkPayloadData() *chunkPayloadData { + return p +} + const ( payloadDataEndingFragmentBitmask = 1 payloadDataBeginingFragmentBitmask = 2 @@ -88,6 +107,7 @@ const ( payloadDataImmediateSACK = 8 payloadDataHeaderSize = 12 + iDataHeaderSize = 16 ) // PayloadProtocolIdentifier is an enum for DataChannel payload types. @@ -136,19 +156,77 @@ func (p *chunkPayloadData) unmarshal(raw []byte) error { p.beginningFragment = p.flags&payloadDataBeginingFragmentBitmask != 0 p.endingFragment = p.flags&payloadDataEndingFragmentBitmask != 0 - if len(p.raw) < payloadDataHeaderSize { - return ErrChunkPayloadSmall + switch p.typ { + case ctPayloadData: + if len(p.raw) < payloadDataHeaderSize { + return ErrChunkPayloadSmall + } + p.tsn = binary.BigEndian.Uint32(p.raw[0:]) + p.streamIdentifier = binary.BigEndian.Uint16(p.raw[4:]) + p.streamSequenceNumber = binary.BigEndian.Uint16(p.raw[6:]) + p.payloadType = PayloadProtocolIdentifier(binary.BigEndian.Uint32(p.raw[8:])) + p.userData = p.raw[payloadDataHeaderSize:] + p.iData = false + case ctIData: + if len(p.raw) < iDataHeaderSize { + return ErrChunkPayloadSmall + } + p.tsn = binary.BigEndian.Uint32(p.raw[0:]) + p.streamIdentifier = binary.BigEndian.Uint16(p.raw[4:]) + p.messageIdentifier = binary.BigEndian.Uint32(p.raw[8:]) + if p.beginningFragment { + p.payloadType = PayloadProtocolIdentifier(binary.BigEndian.Uint32(p.raw[12:])) + p.fragmentSequenceNumber = 0 + } else { + p.fragmentSequenceNumber = binary.BigEndian.Uint32(p.raw[12:]) + p.payloadType = PayloadTypeUnknown + } + p.streamSequenceNumber = uint16(p.messageIdentifier) //nolint:gosec // lower 16 bits for API exposure + p.userData = p.raw[iDataHeaderSize:] + p.iData = true + default: + return fmt.Errorf("%w: unsupported payload data chunk type %d", ErrChunkTypeUnhandled, p.typ) } - p.tsn = binary.BigEndian.Uint32(p.raw[0:]) - p.streamIdentifier = binary.BigEndian.Uint16(p.raw[4:]) - p.streamSequenceNumber = binary.BigEndian.Uint16(p.raw[6:]) - p.payloadType = PayloadProtocolIdentifier(binary.BigEndian.Uint32(p.raw[8:])) - p.userData = p.raw[payloadDataHeaderSize:] return nil } -func (p *chunkPayloadData) marshal() ([]byte, error) { +func (p *chunkPayloadData) marshal() ([]byte, error) { //nolint:cyclop + if p.isIData() { //nolint:nestif + payRaw := make([]byte, iDataHeaderSize+len(p.userData)) + + binary.BigEndian.PutUint32(payRaw[0:], p.tsn) + binary.BigEndian.PutUint16(payRaw[4:], p.streamIdentifier) + binary.BigEndian.PutUint16(payRaw[6:], 0) + binary.BigEndian.PutUint32(payRaw[8:], p.messageIdentifier) + if p.beginningFragment { + binary.BigEndian.PutUint32(payRaw[12:], uint32(p.payloadType)) + } else { + binary.BigEndian.PutUint32(payRaw[12:], p.fragmentSequenceNumber) + } + copy(payRaw[iDataHeaderSize:], p.userData) + + flags := uint8(0) + if p.endingFragment { + flags = 1 + } + if p.beginningFragment { + flags |= 1 << 1 + } + if p.unordered { + flags |= 1 << 2 + } + if p.immediateSack { + flags |= 1 << 3 + } + + p.chunkHeader.flags = flags + p.chunkHeader.typ = ctIData + p.chunkHeader.raw = payRaw + + return p.chunkHeader.marshal() + } + payRaw := make([]byte, payloadDataHeaderSize+len(p.userData)) binary.BigEndian.PutUint32(payRaw[0:], p.tsn) @@ -184,6 +262,10 @@ func (p *chunkPayloadData) check() (abort bool, err error) { // String makes chunkPayloadData printable. func (p *chunkPayloadData) String() string { + if p.isIData() { + return fmt.Sprintf("%s\ntsn=%d mid=%d fsn=%d", p.chunkHeader, p.tsn, p.messageIdentifier, p.fragmentSequenceNumber) + } + return fmt.Sprintf("%s\n%d", p.chunkHeader, p.tsn) } @@ -217,3 +299,21 @@ func (p *chunkPayloadData) setAllInflight() { func (p *chunkPayloadData) isFragmented() bool { return p.head != nil || !p.beginningFragment || !p.endingFragment } + +func (p *chunkPayloadData) isIData() bool { + return p.iData || p.typ == ctIData +} + +func (p *chunkPayloadData) chunkSize() int { + if p.isIData() { + return chunkHeaderSize + iDataHeaderSize + len(p.userData) + } + + return chunkHeaderSize + payloadDataHeaderSize + len(p.userData) +} + +func (p *chunkPayloadData) chunkSizeInPacket() int { + chunkSize := p.chunkSize() + + return chunkSize + getPadding(chunkSize) +} diff --git a/vendor/github.com/pion/sctp/chunktype.go b/vendor/github.com/pion/sctp/chunktype.go index 3fe0aa350b..e15a25ffc8 100644 --- a/vendor/github.com/pion/sctp/chunktype.go +++ b/vendor/github.com/pion/sctp/chunktype.go @@ -13,6 +13,7 @@ type chunkType uint8 // List of known chunkType enums. const ( ctPayloadData chunkType = 0 + ctIData chunkType = 64 ctInit chunkType = 1 ctInitAck chunkType = 2 ctSack chunkType = 3 @@ -28,12 +29,15 @@ const ( ctShutdownComplete chunkType = 14 ctReconfig chunkType = 130 ctForwardTSN chunkType = 192 + ctIForwardTSN chunkType = 194 ) func (c chunkType) String() string { //nolint:cyclop switch c { case ctPayloadData: return "DATA" + case ctIData: + return "I-DATA" case ctInit: return "INIT" case ctInitAck: @@ -64,6 +68,8 @@ func (c chunkType) String() string { //nolint:cyclop return "RECONFIG" // Re-configuration case ctForwardTSN: return "FORWARD-TSN" + case ctIForwardTSN: + return "I-FORWARD-TSN" default: return fmt.Sprintf("Unknown ChunkType: %d", c) } diff --git a/vendor/github.com/pion/sctp/errors.go b/vendor/github.com/pion/sctp/errors.go index dd2ab1e5bb..8817cc6d4a 100644 --- a/vendor/github.com/pion/sctp/errors.go +++ b/vendor/github.com/pion/sctp/errors.go @@ -36,4 +36,10 @@ var ( // errInvalidSnapToken indicates a SNAP token that is not parseable. errInvalidSnapToken = errors.New("SNAP token is invalid") + + // errNilStreamScheduler indicates that a nil stream scheduler factory was configured. + errNilStreamScheduler = errors.New("stream scheduler must not be nil") + + // errInvalidStreamSchedulerWeight indicates a stream scheduler weight was set to zero. + errInvalidStreamSchedulerWeight = errors.New("stream scheduler weight must be > 0") ) diff --git a/vendor/github.com/pion/sctp/packet.go b/vendor/github.com/pion/sctp/packet.go index 31dec63fe2..f25bdb5c8c 100644 --- a/vendor/github.com/pion/sctp/packet.go +++ b/vendor/github.com/pion/sctp/packet.go @@ -122,12 +122,16 @@ func (p *packet) unmarshal(doChecksum bool, raw []byte) error { //nolint:cyclop dataChunk = &chunkHeartbeat{} case ctPayloadData: dataChunk = &chunkPayloadData{} + case ctIData: + dataChunk = &chunkPayloadData{} case ctSack: dataChunk = &chunkSelectiveAck{} case ctReconfig: dataChunk = &chunkReconfig{} case ctForwardTSN: dataChunk = &chunkForwardTSN{} + case ctIForwardTSN: + dataChunk = &chunkIForwardTSN{} case ctError: dataChunk = &chunkError{} case ctShutdown: diff --git a/vendor/github.com/pion/sctp/pending_queue.go b/vendor/github.com/pion/sctp/pending_queue.go index be150f06a3..9b5ce74167 100644 --- a/vendor/github.com/pion/sctp/pending_queue.go +++ b/vendor/github.com/pion/sctp/pending_queue.go @@ -5,6 +5,7 @@ package sctp import ( "errors" + "math" ) // pendingBaseQueue @@ -52,43 +53,37 @@ func (q *pendingBaseQueue) size() int { // pendingQueue -type pendingQueue struct { +type pendingQueuePolicy interface { + push(*chunkPayloadData) + peek() *chunkPayloadData + pop(*chunkPayloadData) error +} + +type messagePendingQueuePolicy struct { unorderedQueue *pendingBaseQueue orderedQueue *pendingBaseQueue - nBytes int selected bool unorderedIsSelected bool } -// Pending queue errors. -var ( - ErrUnexpectedChunkPoppedUnordered = errors.New("unexpected chunk popped (unordered)") - ErrUnexpectedChunkPoppedOrdered = errors.New("unexpected chunk popped (ordered)") - ErrUnexpectedQState = errors.New("unexpected q state (should've been selected)") - - // Deprecated: use ErrUnexpectedChunkPoppedUnordered. - ErrUnexpectedChuckPoppedUnordered = ErrUnexpectedChunkPoppedUnordered - // Deprecated: use ErrUnexpectedChunkPoppedOrdered. - ErrUnexpectedChuckPoppedOrdered = ErrUnexpectedChunkPoppedOrdered -) - -func newPendingQueue() *pendingQueue { - return &pendingQueue{ +func newMessagePendingQueuePolicy() *messagePendingQueuePolicy { + return &messagePendingQueuePolicy{ unorderedQueue: newPendingBaseQueue(), orderedQueue: newPendingBaseQueue(), } } -func (q *pendingQueue) push(c *chunkPayloadData) { - if c.unordered { - q.unorderedQueue.push(c) - } else { - q.orderedQueue.push(c) +func (q *messagePendingQueuePolicy) push(chunk *chunkPayloadData) { + if chunk.unordered { + q.unorderedQueue.push(chunk) + + return } - q.nBytes += len(c.userData) + + q.orderedQueue.push(chunk) } -func (q *pendingQueue) peek() *chunkPayloadData { +func (q *messagePendingQueuePolicy) peek() *chunkPayloadData { if q.selected { if q.unorderedIsSelected { return q.unorderedQueue.get(0) @@ -104,46 +99,351 @@ func (q *pendingQueue) peek() *chunkPayloadData { return q.orderedQueue.get(0) } -func (q *pendingQueue) pop(chunkPayload *chunkPayloadData) error { //nolint:cyclop - if q.selected { //nolint:nestif - var popped *chunkPayloadData - if q.unorderedIsSelected { - popped = q.unorderedQueue.pop() - if popped != chunkPayload { - return ErrUnexpectedChunkPoppedUnordered - } - } else { - popped = q.orderedQueue.pop() - if popped != chunkPayload { - return ErrUnexpectedChunkPoppedOrdered - } +func (q *messagePendingQueuePolicy) pop(chunkPayload *chunkPayloadData) error { + if q.selected { + return q.popSelected(chunkPayload) + } + if !chunkPayload.beginningFragment { + return ErrUnexpectedQState + } + + return q.popNewSelection(chunkPayload) +} + +func (q *messagePendingQueuePolicy) popSelected(chunkPayload *chunkPayloadData) error { + var ( + popped *chunkPayloadData + err error + ) + + if q.unorderedIsSelected { + popped = q.unorderedQueue.pop() + err = ErrUnexpectedChunkPoppedUnordered + } else { + popped = q.orderedQueue.pop() + err = ErrUnexpectedChunkPoppedOrdered + } + if popped != chunkPayload { + return err + } + if popped.endingFragment { + q.selected = false + } + + return nil +} + +func (q *messagePendingQueuePolicy) popNewSelection(chunkPayload *chunkPayloadData) error { + var ( + popped *chunkPayloadData + err error + isSelected bool + ) + + if chunkPayload.unordered { + popped = q.unorderedQueue.pop() + err = ErrUnexpectedChunkPoppedUnordered + isSelected = true + } else { + popped = q.orderedQueue.pop() + err = ErrUnexpectedChunkPoppedOrdered + } + if popped != chunkPayload { + return err + } + if !popped.endingFragment { + q.selected = true + q.unorderedIsSelected = isSelected + } + + return nil +} + +type interleavingStreamSchedulerPolicy struct { + scheduler InterleavingStreamScheduler +} + +func (q *interleavingStreamSchedulerPolicy) push(chunk *chunkPayloadData) { + q.scheduler.Push(chunk) +} + +func (q *interleavingStreamSchedulerPolicy) peek() *chunkPayloadData { + chunk := q.scheduler.Peek() + if chunk == nil { + return nil + } + + return chunk.chunkPayloadData() +} + +func (q *interleavingStreamSchedulerPolicy) pop(chunk *chunkPayloadData) error { + return q.scheduler.Pop(chunk) +} + +type roundRobinPendingQueuePolicy struct { + streamQueues map[uint16]*pendingBaseQueue + streamOrder []uint16 + streamSelected bool + selectedStream uint16 +} + +func (q *roundRobinPendingQueuePolicy) Reset() { + q.streamQueues = map[uint16]*pendingBaseQueue{} + q.streamOrder = nil + q.streamSelected = false + q.selectedStream = 0 +} + +func newRoundRobinPendingQueuePolicy() *roundRobinPendingQueuePolicy { + q := &roundRobinPendingQueuePolicy{} + q.Reset() + + return q +} + +func (q *roundRobinPendingQueuePolicy) Push(chunk StreamSchedulerChunk) { + streamQueue := q.streamQueues[chunk.StreamIdentifier()] + wasEmpty := streamQueue == nil || streamQueue.size() == 0 + if streamQueue == nil { + streamQueue = newPendingBaseQueue() + q.streamQueues[chunk.StreamIdentifier()] = streamQueue + } + streamQueue.push(chunk.chunkPayloadData()) + if wasEmpty { + q.streamOrder = append(q.streamOrder, chunk.StreamIdentifier()) + } +} + +func (q *roundRobinPendingQueuePolicy) Peek() StreamSchedulerChunk { + if q.streamSelected { + return q.streamQueues[q.selectedStream].get(0) + } + if len(q.streamOrder) == 0 { + return nil + } + q.streamSelected = true + q.selectedStream = q.streamOrder[0] + + return q.streamQueues[q.selectedStream].get(0) +} + +func (q *roundRobinPendingQueuePolicy) Pop(chunkPayload StreamSchedulerChunk) error { + if !q.streamSelected { + return ErrUnexpectedQState + } + + streamQueue := q.streamQueues[q.selectedStream] + if streamQueue == nil { + return ErrUnexpectedQState + } + + popped := streamQueue.pop() + if popped != chunkPayload.chunkPayloadData() { + return ErrUnexpectedChunkPoppedStream + } + + if len(q.streamOrder) > 0 { + q.streamOrder = q.streamOrder[1:] + } + if streamQueue.size() > 0 { + q.streamOrder = append(q.streamOrder, q.selectedStream) + } else { + delete(q.streamQueues, q.selectedStream) + } + q.streamSelected = false + q.selectedStream = 0 + + return nil +} + +type weightedFairQueueingPendingQueuePolicy struct { + streamQueues map[uint16]*pendingBaseQueue + streamFinish map[uint16]float64 + chunkFinish map[*chunkPayloadData]float64 + weights map[uint16]uint16 + virtualTime float64 + streamSelected bool + selectedStream uint16 +} + +func (q *weightedFairQueueingPendingQueuePolicy) Reset() { + q.streamQueues = map[uint16]*pendingBaseQueue{} + q.streamFinish = map[uint16]float64{} + q.chunkFinish = map[*chunkPayloadData]float64{} + q.virtualTime = 0 + q.streamSelected = false + q.selectedStream = 0 +} + +func newWeightedFairQueueingPendingQueuePolicy(weights map[uint16]uint16) *weightedFairQueueingPendingQueuePolicy { + copiedWeights := map[uint16]uint16{} + for streamID, weight := range weights { + if weight != 0 { + copiedWeights[streamID] = weight + } + } + + q := &weightedFairQueueingPendingQueuePolicy{ + weights: copiedWeights, + } + q.Reset() + + return q +} + +func (q *weightedFairQueueingPendingQueuePolicy) Push(chunk StreamSchedulerChunk) { + streamID := chunk.StreamIdentifier() + streamQueue := q.streamQueues[streamID] + if streamQueue == nil { + streamQueue = newPendingBaseQueue() + q.streamQueues[streamID] = streamQueue + } + + weight := float64(q.weights[streamID]) + if weight == 0 { + weight = 1 + } + + start := math.Max(q.virtualTime, q.streamFinish[streamID]) + finish := start + (float64(chunk.UserDataLen()) / weight) + q.streamFinish[streamID] = finish + q.chunkFinish[chunk.chunkPayloadData()] = finish + streamQueue.push(chunk.chunkPayloadData()) +} + +func (q *weightedFairQueueingPendingQueuePolicy) Peek() StreamSchedulerChunk { + if q.streamSelected { + return q.streamQueues[q.selectedStream].get(0) + } + + var ( + selectedChunk *chunkPayloadData + selectedStream uint16 + selectedFinish = math.Inf(1) + ) + + for streamID, streamQueue := range q.streamQueues { + chunk := streamQueue.get(0) + if chunk == nil { + continue } - if popped.endingFragment { - q.selected = false + finish := q.chunkFinish[chunk] + if finish < selectedFinish || (finish == selectedFinish && streamID < selectedStream) { + selectedChunk = chunk + selectedStream = streamID + selectedFinish = finish } - } else { - if !chunkPayload.beginningFragment { - return ErrUnexpectedQState + } + if selectedChunk == nil { + return nil + } + + q.streamSelected = true + q.selectedStream = selectedStream + + return selectedChunk +} + +func (q *weightedFairQueueingPendingQueuePolicy) Pop(chunkPayload StreamSchedulerChunk) error { + if !q.streamSelected { + return ErrUnexpectedQState + } + + streamQueue := q.streamQueues[q.selectedStream] + if streamQueue == nil { + return ErrUnexpectedQState + } + + popped := streamQueue.pop() + if popped != chunkPayload.chunkPayloadData() { + return ErrUnexpectedChunkPoppedStream + } + + q.virtualTime = math.Max(q.virtualTime, q.chunkFinish[chunkPayload.chunkPayloadData()]) + delete(q.chunkFinish, chunkPayload.chunkPayloadData()) + if streamQueue.size() == 0 { + delete(q.streamQueues, q.selectedStream) + } + + q.streamSelected = false + q.selectedStream = 0 + + return nil +} + +type pendingQueue struct { + nBytes int + nChunks int + interleaving bool + newStreamScheduler InterleavingStreamSchedulerFactory + policy pendingQueuePolicy +} + +// Pending queue errors. +var ( + ErrUnexpectedChunkPoppedUnordered = errors.New("unexpected chunk popped (unordered)") + ErrUnexpectedChunkPoppedOrdered = errors.New("unexpected chunk popped (ordered)") + ErrUnexpectedChunkPoppedStream = errors.New("unexpected chunk popped (stream)") + ErrUnexpectedQState = errors.New("unexpected q state (should've been selected)") + ErrPendingQueueModeChangeNonEmpty = errors.New( + "cannot change pending queue interleaving mode while queue is not empty", + ) + + // Deprecated: use ErrUnexpectedChunkPoppedUnordered. + ErrUnexpectedChuckPoppedUnordered = ErrUnexpectedChunkPoppedUnordered + // Deprecated: use ErrUnexpectedChunkPoppedOrdered. + ErrUnexpectedChuckPoppedOrdered = ErrUnexpectedChunkPoppedOrdered +) + +func newPendingQueue(newStreamScheduler InterleavingStreamSchedulerFactory) *pendingQueue { + return &pendingQueue{ + newStreamScheduler: newStreamScheduler, + policy: newMessagePendingQueuePolicy(), + } +} + +func (q *pendingQueue) setInterleaving(enabled bool) error { + if q.interleaving == enabled { + return nil + } + if q.nChunks != 0 { + return ErrPendingQueueModeChangeNonEmpty + } + + q.interleaving = enabled + if enabled { + if q.newStreamScheduler == nil { + return errNilStreamScheduler } - if chunkPayload.unordered { - popped := q.unorderedQueue.pop() - if popped != chunkPayload { - return ErrUnexpectedChunkPoppedUnordered - } - if !popped.endingFragment { - q.selected = true - q.unorderedIsSelected = true - } - } else { - popped := q.orderedQueue.pop() - if popped != chunkPayload { - return ErrUnexpectedChunkPoppedOrdered - } - if !popped.endingFragment { - q.selected = true - q.unorderedIsSelected = false - } + streamScheduler := q.newStreamScheduler() + if streamScheduler == nil { + return errNilStreamScheduler + } + streamScheduler.Reset() + q.policy = &interleavingStreamSchedulerPolicy{scheduler: streamScheduler} + } else { + if schedulerPolicy, ok := q.policy.(*interleavingStreamSchedulerPolicy); ok { + schedulerPolicy.scheduler.Reset() } + q.policy = newMessagePendingQueuePolicy() + } + + return nil +} + +func (q *pendingQueue) push(chunk *chunkPayloadData) { + q.policy.push(chunk) + q.nBytes += len(chunk.userData) + q.nChunks++ +} + +func (q *pendingQueue) peek() *chunkPayloadData { + return q.policy.peek() +} + +func (q *pendingQueue) pop(chunkPayload *chunkPayloadData) error { + if err := q.policy.pop(chunkPayload); err != nil { + return err } // guard against negative values (should never happen, but just in case). @@ -151,6 +451,7 @@ func (q *pendingQueue) pop(chunkPayload *chunkPayloadData) error { //nolint:cycl if q.nBytes < 0 { q.nBytes = 0 } + q.nChunks-- return nil } @@ -160,5 +461,5 @@ func (q *pendingQueue) getNumBytes() int { } func (q *pendingQueue) size() int { - return q.unorderedQueue.size() + q.orderedQueue.size() + return q.nChunks } diff --git a/vendor/github.com/pion/sctp/reassembly_queue.go b/vendor/github.com/pion/sctp/reassembly_queue.go index 998824ee60..6efc1b483d 100644 --- a/vendor/github.com/pion/sctp/reassembly_queue.go +++ b/vendor/github.com/pion/sctp/reassembly_queue.go @@ -22,6 +22,24 @@ func sortChunksBySSN(a []*chunkSet) { }) } +func sortChunksByFSN(a []*chunkPayloadData) { + sort.Slice(a, func(i, j int) bool { + return sna32LT(a[i].fragmentSequenceNumber, a[j].fragmentSequenceNumber) + }) +} + +func insertChunkSetByMID(a []*chunkSetMID, cset *chunkSetMID) []*chunkSetMID { + insertAt := sort.Search(len(a), func(i int) bool { + return !sna32LT(a[i].mid, cset.mid) + }) + + a = append(a, nil) + copy(a[insertAt+1:], a[insertAt:]) + a[insertAt] = cset + + return a +} + // chunkSet is a set of chunks that share the same SSN. type chunkSet struct { ssn uint16 // used only with the ordered chunks @@ -100,17 +118,93 @@ func (set *chunkSet) isComplete() bool { return true } +// chunkSetMID is a set of chunks that share the same MID. +type chunkSetMID struct { + mid uint32 + ppi PayloadProtocolIdentifier + chunks []*chunkPayloadData +} + +func newChunkSetMID(mid uint32, ppi PayloadProtocolIdentifier) *chunkSetMID { + return &chunkSetMID{ + mid: mid, + ppi: ppi, + chunks: []*chunkPayloadData{}, + } +} + +func (set *chunkSetMID) pushAndCheck(chunk *chunkPayloadData) (complete bool, accepted bool) { + if set.isComplete() { + return false, false + } + + for _, c := range set.chunks { + if c.fragmentSequenceNumber == chunk.fragmentSequenceNumber { + return false, false + } + } + + set.chunks = append(set.chunks, chunk) + if chunk.beginningFragment { + set.ppi = chunk.payloadType + } + sortChunksByFSN(set.chunks) + + return set.isComplete(), true +} + +func (set *chunkSetMID) isComplete() bool { + nChunks := len(set.chunks) + if nChunks == 0 { + return false + } + + if !set.chunks[0].beginningFragment { + return false + } + + if !set.chunks[nChunks-1].endingFragment { + return false + } + + if set.chunks[0].fragmentSequenceNumber != 0 { + return false + } + + lastFSN := set.chunks[0].fragmentSequenceNumber + for i, chunk := range set.chunks { + if i > 0 { + if chunk.fragmentSequenceNumber != lastFSN+1 { + return false + } + } + lastFSN = chunk.fragmentSequenceNumber + } + + return true +} + type reassemblyQueue struct { si uint16 nextSSN uint16 // expected SSN for next ordered chunk + nextMID uint32 // expected MID for next ordered I-DATA ordered []*chunkSet unordered []*chunkSet unorderedChunks []*chunkPayloadData + orderedMID []*chunkSetMID + unorderedMID []*chunkSetMID + orderedMIDMap map[uint32]*chunkSetMID + unorderedMIDMap map[uint32]*chunkSetMID + useInterleaving bool nBytes uint64 } var errTryAgain = errors.New("try again") +const maxReassemblyQueueMIDEntries = 1024 + +var errReassemblyQueueMIDLimitExceeded = errors.New("reassembly queue i-data message identifier limit exceeded") + func newReassemblyQueue(si uint16) *reassemblyQueue { // From RFC 4960 Sec 6.5: // The Stream Sequence Number in all the streams MUST start from 0 when @@ -118,18 +212,35 @@ func newReassemblyQueue(si uint16) *reassemblyQueue { // Number reaches the value 65535 the next Stream Sequence Number MUST // be set to 0. return &reassemblyQueue{ - si: si, - nextSSN: 0, // From RFC 4960 Sec 6.5: - ordered: make([]*chunkSet, 0), - unordered: make([]*chunkSet, 0), + si: si, + nextSSN: 0, // From RFC 4960 Sec 6.5: + nextMID: 0, + ordered: make([]*chunkSet, 0), + unordered: make([]*chunkSet, 0), + orderedMID: make([]*chunkSetMID, 0), + unorderedMID: make([]*chunkSetMID, 0), + orderedMIDMap: map[uint32]*chunkSetMID{}, + unorderedMIDMap: map[uint32]*chunkSetMID{}, } } -func (r *reassemblyQueue) push(chunk *chunkPayloadData) bool { //nolint:cyclop +func (r *reassemblyQueue) push(chunk *chunkPayloadData) bool { + complete, _ := r.pushWithError(chunk) + + return complete +} + +func (r *reassemblyQueue) pushWithError(chunk *chunkPayloadData) (bool, error) { //nolint:cyclop var cset *chunkSet + if chunk.isIData() { + r.useInterleaving = true + + return r.pushIData(chunk) + } + if chunk.streamIdentifier != r.si { - return false + return false, nil } if chunk.unordered { @@ -145,16 +256,16 @@ func (r *reassemblyQueue) push(chunk *chunkPayloadData) bool { //nolint:cyclop if cset != nil { r.unordered = append(r.unordered, cset) - return true + return true, nil } - return false + return false, nil } // This is an ordered chunk if sna16LT(chunk.streamSequenceNumber, r.nextSSN) { - return false + return false, nil } // Check if a fragmented chunkSet with the fragmented SSN already exists @@ -188,7 +299,94 @@ func (r *reassemblyQueue) push(chunk *chunkPayloadData) bool { //nolint:cyclop atomic.AddUint64(&r.nBytes, uint64(len(chunk.userData))) - return cset.push(chunk) + return cset.push(chunk), nil +} + +func (r *reassemblyQueue) pushIData(chunk *chunkPayloadData) (bool, error) { + if chunk.streamIdentifier != r.si { + return false, nil + } + + if chunk.unordered { + return r.pushUnorderedIData(chunk) + } + + return r.pushOrderedIData(chunk) +} + +func (r *reassemblyQueue) pushUnorderedIData(chunk *chunkPayloadData) (bool, error) { + if r.hasQueuedUnorderedMID(chunk.messageIdentifier) { + return false, nil + } + + if r.unorderedMIDMap == nil { + r.unorderedMIDMap = map[uint32]*chunkSetMID{} + } + cset := r.unorderedMIDMap[chunk.messageIdentifier] + if cset == nil { + if r.unorderedMIDEntryCount() >= maxReassemblyQueueMIDEntries { + return false, errReassemblyQueueMIDLimitExceeded + } + cset = newChunkSetMID(chunk.messageIdentifier, chunk.payloadType) + r.unorderedMIDMap[chunk.messageIdentifier] = cset + } + + complete, accepted := cset.pushAndCheck(chunk) + if !accepted { + return false, nil + } + + atomic.AddUint64(&r.nBytes, uint64(len(chunk.userData))) + if complete { + delete(r.unorderedMIDMap, chunk.messageIdentifier) + r.unorderedMID = append(r.unorderedMID, cset) + + return true, nil + } + + return false, nil +} + +func (r *reassemblyQueue) pushOrderedIData(chunk *chunkPayloadData) (bool, error) { + if sna32LT(chunk.messageIdentifier, r.nextMID) { + return false, nil + } + + if r.orderedMIDMap == nil { + r.orderedMIDMap = map[uint32]*chunkSetMID{} + } + cset := r.orderedMIDMap[chunk.messageIdentifier] + if cset == nil { + if len(r.orderedMIDMap) >= maxReassemblyQueueMIDEntries { + return false, errReassemblyQueueMIDLimitExceeded + } + cset = newChunkSetMID(chunk.messageIdentifier, chunk.payloadType) + r.orderedMIDMap[chunk.messageIdentifier] = cset + r.orderedMID = insertChunkSetByMID(r.orderedMID, cset) + } + + complete, accepted := cset.pushAndCheck(chunk) + if !accepted { + return false, nil + } + + atomic.AddUint64(&r.nBytes, uint64(len(chunk.userData))) + + return complete, nil +} + +func (r *reassemblyQueue) unorderedMIDEntryCount() int { + return len(r.unorderedMIDMap) + len(r.unorderedMID) +} + +func (r *reassemblyQueue) hasQueuedUnorderedMID(mid uint32) bool { + for _, set := range r.unorderedMID { + if set.mid == mid { + return true + } + } + + return false } func (r *reassemblyQueue) findCompleteUnorderedChunkSet() *chunkSet { @@ -253,6 +451,20 @@ func (r *reassemblyQueue) findCompleteUnorderedChunkSet() *chunkSet { } func (r *reassemblyQueue) isReadable() bool { + if r.useInterleaving { + if len(r.unorderedMID) > 0 { + return true + } + if len(r.orderedMID) > 0 { + cset := r.orderedMID[0] + if cset.isComplete() && sna32LTE(cset.mid, r.nextMID) { + return true + } + } + + return false + } + // Check unordered first if len(r.unordered) > 0 { // The chunk sets in r.unordered should all be complete. @@ -272,7 +484,7 @@ func (r *reassemblyQueue) isReadable() bool { return false } -func (r *reassemblyQueue) read(buf []byte) (int, PayloadProtocolIdentifier, error) { // nolint: cyclop +func (r *reassemblyQueue) read(buf []byte) (int, PayloadProtocolIdentifier, error) { // nolint: cyclop,gocognit var ( cset *chunkSet isUnordered bool @@ -280,6 +492,51 @@ func (r *reassemblyQueue) read(buf []byte) (int, PayloadProtocolIdentifier, erro err error ) + if r.useInterleaving { //nolint:nestif + var iSet *chunkSetMID + switch { + case len(r.unorderedMID) > 0: + iSet = r.unorderedMID[0] + isUnordered = true + case len(r.orderedMID) > 0: + iSet = r.orderedMID[0] + if !iSet.isComplete() { + return 0, 0, errTryAgain + } + if sna32GT(iSet.mid, r.nextMID) { + return 0, 0, errTryAgain + } + default: + return 0, 0, errTryAgain + } + + for _, c := range iSet.chunks { + if len(buf)-nTotal < len(c.userData) { + err = io.ErrShortBuffer + } else { + copy(buf[nTotal:], c.userData) + } + nTotal += len(c.userData) + } + + switch { + case err != nil: + return nTotal, 0, err + case isUnordered: + r.unorderedMID = r.unorderedMID[1:] + default: + r.orderedMID = r.orderedMID[1:] + delete(r.orderedMIDMap, iSet.mid) + if iSet.mid == r.nextMID { + r.nextMID++ + } + } + + r.subtractNumBytes(nTotal) + + return nTotal, iSet.ppi, err + } + switch { case len(r.unordered) > 0: cset = r.unordered[0] @@ -369,6 +626,39 @@ func (r *reassemblyQueue) forwardTSNForUnordered(newCumulativeTSN uint32) { } } +func (r *reassemblyQueue) forwardTSNForOrderedMID(lastMID uint32) { + keep := []*chunkSetMID{} + for _, set := range r.orderedMID { + if sna32LTE(set.mid, lastMID) { + if !set.isComplete() { + for _, c := range set.chunks { + r.subtractNumBytes(len(c.userData)) + } + delete(r.orderedMIDMap, set.mid) + + continue + } + } + keep = append(keep, set) + } + r.orderedMID = keep + + if sna32LTE(r.nextMID, lastMID) { + r.nextMID = lastMID + 1 + } +} + +func (r *reassemblyQueue) forwardTSNForUnorderedMID(lastMID uint32) { + for mid, set := range r.unorderedMIDMap { + if sna32LTE(mid, lastMID) { + for _, c := range set.chunks { + r.subtractNumBytes(len(c.userData)) + } + delete(r.unorderedMIDMap, mid) + } + } +} + func (r *reassemblyQueue) subtractNumBytes(nBytes int) { cur := atomic.LoadUint64(&r.nBytes) if int(cur) >= nBytes { //nolint:gosec // G115 diff --git a/vendor/github.com/pion/sctp/receive_payload_queue.go b/vendor/github.com/pion/sctp/receive_payload_queue.go index 676e69cca5..cac1959697 100644 --- a/vendor/github.com/pion/sctp/receive_payload_queue.go +++ b/vendor/github.com/pion/sctp/receive_payload_queue.go @@ -103,6 +103,50 @@ func (q *receivePayloadQueue) pop(force bool) bool { return false } +// advanceCumulativeTSN moves the cumulative TSN forward and removes any queued +// TSNs that are now covered by the cumulative point. +func (q *receivePayloadQueue) advanceCumulativeTSN(cumulativeTSN uint32) { + if !sna32LT(q.cumulativeTSN, cumulativeTSN) { + return + } + + if q.chunkSize == 0 || sna32LTE(q.tailTSN, cumulativeTSN) { + for i := range q.tsnBitmask { + q.tsnBitmask[i] = 0 + } + q.chunkSize = 0 + q.cumulativeTSN = cumulativeTSN + q.tailTSN = cumulativeTSN + + return + } + + q.clearTSNRange(q.cumulativeTSN+1, cumulativeTSN) + q.cumulativeTSN = cumulativeTSN + if q.chunkSize == 0 { + q.tailTSN = cumulativeTSN + } +} + +func (q *receivePayloadQueue) clearTSNRange(startTSN, endTSN uint32) { + for remaining := endTSN - startTSN + 1; remaining > 0; { + offset := startTSN % 64 + n := min(remaining, 64-offset) + mask := ^uint64(0) + if n < 64 { + mask = ((uint64(1) << n) - 1) << offset + } + + index := int(startTSN/64) % len(q.tsnBitmask) + cleared := q.tsnBitmask[index] & mask + q.tsnBitmask[index] &^= mask + q.chunkSize -= bits.OnesCount64(cleared) + + startTSN += n + remaining -= n + } +} + // popDuplicates returns an array of TSN values that were duplicated. func (q *receivePayloadQueue) popDuplicates() []uint32 { dups := q.dupTSN diff --git a/vendor/github.com/pion/sctp/stream.go b/vendor/github.com/pion/sctp/stream.go index 4fd2382b1b..52e3a94d5e 100644 --- a/vendor/github.com/pion/sctp/stream.go +++ b/vendor/github.com/pion/sctp/stream.go @@ -64,6 +64,8 @@ type Stream struct { defaultPayloadType PayloadProtocolIdentifier reassemblyQueue *reassemblyQueue sequenceNumber uint16 + nextOrderedMID uint32 + nextUnorderedMID uint32 readNotifier *sync.Cond readErr error readTimeoutCancel chan struct{} @@ -198,12 +200,16 @@ func (s *Stream) SetReadDeadline(deadline time.Time) error { return nil } -func (s *Stream) handleData(pd *chunkPayloadData) { +func (s *Stream) handleData(pd *chunkPayloadData) error { s.lock.Lock() defer s.lock.Unlock() var readable bool - if s.reassemblyQueue.push(pd) { + complete, err := s.reassemblyQueue.pushWithError(pd) + if err != nil { + return err + } + if complete { readable = s.reassemblyQueue.isReadable() s.log.Debugf("[%s] reassemblyQueue readable=%v", s.name, readable) if readable { @@ -212,6 +218,8 @@ func (s *Stream) handleData(pd *chunkPayloadData) { s.log.Debugf("[%s] readNotifier.signal() done", s.name) } } + + return nil } func (s *Stream) handleForwardTSNForOrdered(ssn uint16) { @@ -260,6 +268,38 @@ func (s *Stream) handleForwardTSNForUnordered(newCumulativeTSN uint32) { } } +func (s *Stream) handleForwardTSNForOrderedMID(mid uint32) { + var readable bool + + func() { + s.lock.Lock() + defer s.lock.Unlock() + + s.reassemblyQueue.forwardTSNForOrderedMID(mid) + readable = s.reassemblyQueue.isReadable() + }() + + if readable { + s.readNotifier.Signal() + } +} + +func (s *Stream) handleForwardTSNForUnorderedMID(mid uint32) { + var readable bool + + func() { + s.lock.Lock() + defer s.lock.Unlock() + + s.reassemblyQueue.forwardTSNForUnorderedMID(mid) + readable = s.reassemblyQueue.isReadable() + }() + + if readable { + s.readNotifier.Signal() + } +} + // Write writes len(payload) bytes from payload with the default Payload Protocol Identifier. func (s *Stream) Write(payload []byte) (n int, err error) { ppi := PayloadProtocolIdentifier(atomic.LoadUint32((*uint32)(&s.defaultPayloadType))) @@ -284,13 +324,20 @@ func (s *Stream) WriteSCTP(payload []byte, ppi PayloadProtocolIdentifier) (int, if s.association.isBlockWrite() { s.writeLock.Lock() } + useInterleaving := s.association.useInterleaving chunks, unordered := s.packetize(payload, ppi) n := len(payload) err := s.association.sendPayloadData(s.writeDeadline, chunks) - if err != nil { + if err != nil { //nolint:nestif s.lock.Lock() s.bufferedAmount -= uint64(n) - if !unordered { + if useInterleaving { + if unordered { + s.nextUnorderedMID-- + } else { + s.nextOrderedMID-- + } + } else if !unordered { s.sequenceNumber-- } s.lock.Unlock() @@ -332,8 +379,21 @@ func (s *Stream) packetize(raw []byte, ppi PayloadProtocolIdentifier) ([]*chunkP // ordered delivery and reliable transmission. unordered := ppi != PayloadTypeWebRTCDCEP && s.unordered + useInterleaving := s.association.useInterleaving + var mid uint32 + if useInterleaving { + if unordered { + mid = s.nextUnorderedMID + s.nextUnorderedMID++ + } else { + mid = s.nextOrderedMID + s.nextOrderedMID++ + } + } + var chunks []*chunkPayloadData var head *chunkPayloadData + fsn := uint32(0) for remaining != 0 { fragmentSize := min32(s.association.maxPayloadSize, remaining) @@ -343,15 +403,22 @@ func (s *Stream) packetize(raw []byte, ppi PayloadProtocolIdentifier) ([]*chunkP copy(userData, raw[offset:offset+fragmentSize]) chunk := &chunkPayloadData{ - streamIdentifier: s.streamIdentifier, - userData: userData, - unordered: unordered, - beginningFragment: offset == 0, - endingFragment: remaining-fragmentSize == 0, - immediateSack: false, - payloadType: ppi, - streamSequenceNumber: s.sequenceNumber, - head: head, + streamIdentifier: s.streamIdentifier, + userData: userData, + unordered: unordered, + beginningFragment: offset == 0, + endingFragment: remaining-fragmentSize == 0, + immediateSack: false, + payloadType: ppi, + streamSequenceNumber: s.sequenceNumber, + messageIdentifier: mid, + fragmentSequenceNumber: fsn, + iData: useInterleaving, + head: head, + } + + if useInterleaving { + chunk.streamSequenceNumber = uint16(mid) //nolint:gosec } if head == nil { @@ -360,6 +427,7 @@ func (s *Stream) packetize(raw []byte, ppi PayloadProtocolIdentifier) ([]*chunkP chunks = append(chunks, chunk) + fsn++ remaining -= fragmentSize offset += fragmentSize } @@ -368,7 +436,7 @@ func (s *Stream) packetize(raw []byte, ppi PayloadProtocolIdentifier) ([]*chunkP // Note: When transmitting ordered and unordered data, an endpoint does // not increment its Stream Sequence Number when transmitting a DATA // chunk with U flag set to 1. - if !unordered { + if !useInterleaving && !unordered { s.sequenceNumber++ } @@ -505,6 +573,17 @@ func (s *Stream) onInboundStreamReset() { } } +func (s *Stream) resetOutgoingStreamSequenceNumbers() { + s.lock.Lock() + defer s.lock.Unlock() + + // RFC 8260 extends RFC 6525 stream reset, so when an outgoing stream is + // reset, the SSN and both ordered/unordered MID counters restart at zero. + s.sequenceNumber = 0 + s.nextOrderedMID = 0 + s.nextUnorderedMID = 0 +} + // State return the stream state. func (s *Stream) State() StreamState { s.lock.RLock() diff --git a/vendor/github.com/pion/webrtc/v4/datachannel.go b/vendor/github.com/pion/webrtc/v4/datachannel.go index c3c3ebd299..967571d7f9 100644 --- a/vendor/github.com/pion/webrtc/v4/datachannel.go +++ b/vendor/github.com/pion/webrtc/v4/datachannel.go @@ -53,6 +53,7 @@ type DataChannel struct { onOpenHandler func() dialHandlerOnce sync.Once onDialHandler func() + closeHandlerOnce sync.Once onCloseHandler func() onBufferedAmountLow func() onErrorHandler func(error) @@ -284,8 +285,14 @@ func (d *DataChannel) onDial() { // prior to GracefulClose. func (d *DataChannel) OnClose(f func()) { d.mu.Lock() - defer d.mu.Unlock() + d.closeHandlerOnce = sync.Once{} d.onCloseHandler = f + d.mu.Unlock() + + if d.ReadyState() == DataChannelStateClosed { + // If the data channel is already closed, call the handler immediately. + go d.closeHandlerOnce.Do(f) + } } func (d *DataChannel) onClose() { @@ -294,7 +301,7 @@ func (d *DataChannel) onClose() { d.mu.RUnlock() if handler != nil { - go handler() + go d.closeHandlerOnce.Do(handler) } } diff --git a/vendor/github.com/pion/webrtc/v4/peerconnection.go b/vendor/github.com/pion/webrtc/v4/peerconnection.go index acb5b5bbb3..88782eaf1e 100644 --- a/vendor/github.com/pion/webrtc/v4/peerconnection.go +++ b/vendor/github.com/pion/webrtc/v4/peerconnection.go @@ -140,6 +140,7 @@ func (api *API) NewPeerConnection(configuration Configuration) (*PeerConnection, api: api, log: api.settingEngine.LoggerFactory.NewLogger("pc"), } + pc.onDataChannelHandler = pc.defaultOnDataChannelHandler pc.ops = newOperations(pc.updateNegotiationNeededFlagOnEmptyChain, pc.onNegotiationNeeded) pc.iceConnectionState.Store(ICEConnectionStateNew) @@ -296,12 +297,29 @@ func (pc *PeerConnection) onSignalingStateChange(newState SignalingState) { // OnDataChannel sets an event handler which is invoked when a data // channel message arrives from a remote peer. +// When handler is nil, the default handler will be used which closes +// the incoming data channel immediately. func (pc *PeerConnection) OnDataChannel(f func(*DataChannel)) { pc.mu.Lock() defer pc.mu.Unlock() + if f == nil { + pc.onDataChannelHandler = pc.defaultOnDataChannelHandler + + return + } pc.onDataChannelHandler = f } +func (pc *PeerConnection) defaultOnDataChannelHandler(d *DataChannel) { + if d == nil { + return + } + + if err := d.Close(); err != nil { + pc.log.Warnf("Failed to close undeclared DataChannel: %v", err) + } +} + // OnNegotiationNeeded sets an event handler which is invoked when // a change has occurred which requires session negotiation. func (pc *PeerConnection) OnNegotiationNeeded(f func()) { diff --git a/vendor/github.com/pion/webrtc/v4/sctptransport.go b/vendor/github.com/pion/webrtc/v4/sctptransport.go index 9bb9a72230..f5c32443eb 100644 --- a/vendor/github.com/pion/webrtc/v4/sctptransport.go +++ b/vendor/github.com/pion/webrtc/v4/sctptransport.go @@ -20,6 +20,25 @@ import ( const sctpMaxChannels = uint16(65535) +func newSCTPTransportMetadata(metadata sctp.AssociationMetadata) SCTPTransportMetadata { + partialReliabilityMode := SCTPTransportPartialReliabilityModeNone + switch metadata.PartialReliabilityMode { + case sctp.PartialReliabilityModeForwardTSN: + partialReliabilityMode = SCTPTransportPartialReliabilityModeForwardTSN + case sctp.PartialReliabilityModeIForwardTSN: + partialReliabilityMode = SCTPTransportPartialReliabilityModeIForwardTSN + case sctp.PartialReliabilityModeNone: + partialReliabilityMode = SCTPTransportPartialReliabilityModeNone + } + + return SCTPTransportMetadata{ + MessageInterleavingEnabled: metadata.MessageInterleavingEnabled, + PartialReliabilityMode: partialReliabilityMode, + ZeroChecksumSendingEnabled: metadata.ZeroChecksumSendingEnabled, + ZeroChecksumReceivingEnabled: metadata.ZeroChecksumReceivingEnabled, + } +} + // SCTPTransport provides details about the SCTP transport. type SCTPTransport struct { lock sync.RWMutex @@ -437,6 +456,22 @@ func (r *SCTPTransport) State() SCTPTransportState { return r.state } +// Metadata returns negotiated SCTP association metadata. The ok return value is +// false until the SCTP association has been established. +func (r *SCTPTransport) Metadata() (SCTPTransportMetadata, bool) { + association := r.association() + if association == nil { + return SCTPTransportMetadata{}, false + } + + metadata, ok := association.Metadata() + if !ok { + return SCTPTransportMetadata{}, false + } + + return newSCTPTransportMetadata(metadata), true +} + // Stats reports the current statistics of the SCTPTransport. func (r *SCTPTransport) Stats() SCTPTransportStats { stats := SCTPTransportStats{ @@ -453,6 +488,10 @@ func (r *SCTPTransport) Stats() SCTPTransportStats { stats.CongestionWindow = association.CWND() stats.ReceiverWindow = association.RWND() stats.MTU = association.MTU() + if metadata, ok := association.Metadata(); ok { + transportMetadata := newSCTPTransportMetadata(metadata) + stats.Metadata = &transportMetadata + } } return stats diff --git a/vendor/github.com/pion/webrtc/v4/sctptransport_js.go b/vendor/github.com/pion/webrtc/v4/sctptransport_js.go index 0c2df49f85..ec6179784d 100644 --- a/vendor/github.com/pion/webrtc/v4/sctptransport_js.go +++ b/vendor/github.com/pion/webrtc/v4/sctptransport_js.go @@ -30,3 +30,9 @@ func (r *SCTPTransport) Transport() *DTLSTransport { underlying: underlying, } } + +// Metadata returns negotiated SCTP association metadata. The ok return value is +// always false in the js/wasm build because browsers do not expose this metadata. +func (r *SCTPTransport) Metadata() (SCTPTransportMetadata, bool) { + return SCTPTransportMetadata{}, false +} diff --git a/vendor/github.com/pion/webrtc/v4/stats.go b/vendor/github.com/pion/webrtc/v4/stats.go index 042fe971ad..52aa2e3c97 100644 --- a/vendor/github.com/pion/webrtc/v4/stats.go +++ b/vendor/github.com/pion/webrtc/v4/stats.go @@ -178,6 +178,31 @@ type statsReportCollector struct { mux sync.Mutex } +// SCTPTransportPartialReliabilityMode indicates the negotiated SCTP partial reliability mode. +type SCTPTransportPartialReliabilityMode string + +// SCTPTransportPartialReliabilityMode values. +const ( + SCTPTransportPartialReliabilityModeNone SCTPTransportPartialReliabilityMode = "none" + SCTPTransportPartialReliabilityModeForwardTSN SCTPTransportPartialReliabilityMode = "forward-tsn" + SCTPTransportPartialReliabilityModeIForwardTSN SCTPTransportPartialReliabilityMode = "i-forward-tsn" +) + +// SCTPTransportMetadata describes negotiated SCTP transport capabilities. +type SCTPTransportMetadata struct { + // MessageInterleavingEnabled indicates whether RFC 8260 user message interleaving was negotiated. + MessageInterleavingEnabled bool `json:"messageInterleavingEnabled"` + + // PartialReliabilityMode indicates which FORWARD-TSN variant is active. + PartialReliabilityMode SCTPTransportPartialReliabilityMode `json:"partialReliabilityMode"` + + // ZeroChecksumSendingEnabled indicates whether outgoing packets use zero checksum. + ZeroChecksumSendingEnabled bool `json:"zeroChecksumSendingEnabled"` + + // ZeroChecksumReceivingEnabled indicates whether incoming packets may use zero checksum. + ZeroChecksumReceivingEnabled bool `json:"zeroChecksumReceivingEnabled"` +} + func newStatsReportCollector() *statsReportCollector { return &statsReportCollector{report: make(StatsReport)} } @@ -2429,6 +2454,9 @@ type SCTPTransportStats struct { // UNACKData is the number of unacknowledged DATA chunks, corresponding to sstat_unackdata defined in [RFC6458]. UNACKData uint32 `json:"unackData"` + // Metadata contains negotiated SCTP association metadata. + Metadata *SCTPTransportMetadata `json:"metadata,omitempty"` + // BytesSent represents the total number of bytes sent on this SCTPTransport BytesSent uint64 `json:"bytesSent"` diff --git a/vendor/golang.org/x/crypto/blake2b/go125.go b/vendor/golang.org/x/crypto/blake2b/go125.go deleted file mode 100644 index 67e990b7e1..0000000000 --- a/vendor/golang.org/x/crypto/blake2b/go125.go +++ /dev/null @@ -1,11 +0,0 @@ -// Copyright 2025 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 go1.25 - -package blake2b - -import "hash" - -var _ hash.XOF = (*xof)(nil) diff --git a/vendor/golang.org/x/net/http2/server.go b/vendor/golang.org/x/net/http2/server.go index fbb145115a..a7d2053b6c 100644 --- a/vendor/golang.org/x/net/http2/server.go +++ b/vendor/golang.org/x/net/http2/server.go @@ -2657,21 +2657,6 @@ func (rws *responseWriterState) writeChunk(p []byte) (n int, err error) { return len(p), nil } -// TrailerPrefix is a magic prefix for ResponseWriter.Header map keys -// that, if present, signals that the map entry is actually for -// the response trailers, and not the response headers. The prefix -// is stripped after the ServeHTTP call finishes and the values are -// sent in the trailers. -// -// This mechanism is intended only for trailers that are not known -// prior to the headers being written. If the set of trailers is fixed -// or known before the header is written, the normal Go trailers mechanism -// is preferred: -// -// https://golang.org/pkg/net/http/#ResponseWriter -// https://golang.org/pkg/net/http/#example_ResponseWriter_trailers -const TrailerPrefix = "Trailer:" - // promoteUndeclaredTrailers permits http.Handlers to set trailers // after the header has already been flushed. Because the Go // ResponseWriter interface has no way to set Trailers (only the @@ -2948,12 +2933,6 @@ func (w *responseWriter) handlerDone() { responseWriterStatePool.Put(rws) } -// Push errors. -var ( - ErrRecursivePush = errors.New("http2: recursive push not allowed") - ErrPushLimitReached = errors.New("http2: push would exceed peer's SETTINGS_MAX_CONCURRENT_STREAMS") -) - var _ http.Pusher = (*responseWriter)(nil) func (w *responseWriter) Push(target string, opts *http.PushOptions) error { diff --git a/vendor/golang.org/x/net/http2/server_common.go b/vendor/golang.org/x/net/http2/server_common.go index e2faeb9b6a..449538c861 100644 --- a/vendor/golang.org/x/net/http2/server_common.go +++ b/vendor/golang.org/x/net/http2/server_common.go @@ -6,11 +6,33 @@ package http2 import ( "context" + "errors" "net" "net/http" "time" ) +// TrailerPrefix is a magic prefix for ResponseWriter.Header map keys +// that, if present, signals that the map entry is actually for +// the response trailers, and not the response headers. The prefix +// is stripped after the ServeHTTP call finishes and the values are +// sent in the trailers. +// +// This mechanism is intended only for trailers that are not known +// prior to the headers being written. If the set of trailers is fixed +// or known before the header is written, the normal Go trailers mechanism +// is preferred: +// +// https://golang.org/pkg/net/http/#ResponseWriter +// https://golang.org/pkg/net/http/#example_ResponseWriter_trailers +const TrailerPrefix = "Trailer:" + +// Push errors. +var ( + ErrRecursivePush = errors.New("http2: recursive push not allowed") + ErrPushLimitReached = errors.New("http2: push would exceed peer's SETTINGS_MAX_CONCURRENT_STREAMS") +) + // ConfigureServer adds HTTP/2 support to a net/http Server. // // The configuration conf may be nil. diff --git a/vendor/golang.org/x/net/http2/server_wrap.go b/vendor/golang.org/x/net/http2/server_wrap.go index 9e6003b895..a7a09551c4 100644 --- a/vendor/golang.org/x/net/http2/server_wrap.go +++ b/vendor/golang.org/x/net/http2/server_wrap.go @@ -159,3 +159,43 @@ type FrameWriteRequest struct { // to avoid duplicating an exported symbol across two files, // but the changes required to make this work are fairly large. } + +func (wr FrameWriteRequest) StreamID() uint32 { + return 0 +} + +func (wr FrameWriteRequest) DataSize() int { + return 0 +} + +func (wr FrameWriteRequest) Consume(n int32) (FrameWriteRequest, FrameWriteRequest, int) { + return FrameWriteRequest{}, FrameWriteRequest{}, 0 +} + +func (wr FrameWriteRequest) String() string { + return "" +} + +// NewPriorityWriteScheduler is deprecated. +// +// Deprecated: User-provided write schedulers are deprecated. +func NewPriorityWriteScheduler(cfg *PriorityWriteSchedulerConfig) WriteScheduler { + return unsupportedWriteScheduler{} +} + +// NewRandomWriteScheduler is deprecated. +// +// Deprecated: User-provided write schedulers are deprecated. +func NewRandomWriteScheduler() WriteScheduler { + return unsupportedWriteScheduler{} +} + +type unsupportedWriteScheduler struct{} + +func (unsupportedWriteScheduler) OpenStream(streamID uint32, options OpenStreamOptions) {} +func (unsupportedWriteScheduler) CloseStream(streamID uint32) {} +func (unsupportedWriteScheduler) AdjustStream(streamID uint32, priority PriorityParam) {} +func (unsupportedWriteScheduler) Push(wr FrameWriteRequest) {} +func (unsupportedWriteScheduler) Pop() (wr FrameWriteRequest, ok bool) { + return FrameWriteRequest{}, false +} diff --git a/vendor/golang.org/x/net/http2/transport.go b/vendor/golang.org/x/net/http2/transport.go index 882a926945..08ac409b0e 100644 --- a/vendor/golang.org/x/net/http2/transport.go +++ b/vendor/golang.org/x/net/http2/transport.go @@ -399,27 +399,6 @@ func (sew stickyErrWriter) Write(p []byte) (n int, err error) { return n, err } -// noCachedConnError is the concrete type of ErrNoCachedConn, which -// needs to be detected by net/http regardless of whether it's its -// bundled version (in h2_bundle.go with a rewritten type name) or -// from a user's x/net/http2. As such, as it has a unique method name -// (IsHTTP2NoCachedConnError) that net/http sniffs for via func -// isNoCachedConnError. -type noCachedConnError struct{} - -func (noCachedConnError) IsHTTP2NoCachedConnError() {} -func (noCachedConnError) Error() string { return "http2: no cached connection was available" } - -// isNoCachedConnError reports whether err is of type noCachedConnError -// or its equivalent renamed type in net/http2's h2_bundle.go. Both types -// may coexist in the same running program. -func isNoCachedConnError(err error) bool { - _, ok := err.(interface{ IsHTTP2NoCachedConnError() }) - return ok -} - -var ErrNoCachedConn error = noCachedConnError{} - func (t *Transport) roundTripOpt(req *http.Request, opt RoundTripOpt) (*http.Response, error) { switch req.URL.Scheme { case "https": @@ -1786,19 +1765,6 @@ func (cc *ClientConn) readLoop() { } } -// GoAwayError is returned by the Transport when the server closes the -// TCP connection after sending a GOAWAY frame. -type GoAwayError struct { - LastStreamID uint32 - ErrCode ErrCode - DebugData string -} - -func (e GoAwayError) Error() string { - return fmt.Sprintf("http2: server sent GOAWAY and closed the connection; LastStreamID=%v, ErrCode=%v, debug=%q", - e.LastStreamID, e.ErrCode, e.DebugData) -} - func isEOFOrNetReadError(err error) bool { if err == io.EOF { return true diff --git a/vendor/golang.org/x/net/http2/transport_common.go b/vendor/golang.org/x/net/http2/transport_common.go index f7f85b3ad5..b9f52932e9 100644 --- a/vendor/golang.org/x/net/http2/transport_common.go +++ b/vendor/golang.org/x/net/http2/transport_common.go @@ -411,3 +411,37 @@ func (t *Transport) dialTLSWithContext(ctx context.Context, network, addr string tlsCn := cn.(*tls.Conn) // DialContext comment promises this will always succeed return tlsCn, nil } + +// GoAwayError is returned by the Transport when the server closes the +// TCP connection after sending a GOAWAY frame. +type GoAwayError struct { + LastStreamID uint32 + ErrCode ErrCode + DebugData string +} + +func (e GoAwayError) Error() string { + return fmt.Sprintf("http2: server sent GOAWAY and closed the connection; LastStreamID=%v, ErrCode=%v, debug=%q", + e.LastStreamID, e.ErrCode, e.DebugData) +} + +// noCachedConnError is the concrete type of ErrNoCachedConn, which +// needs to be detected by net/http regardless of whether it's its +// bundled version (in h2_bundle.go with a rewritten type name) or +// from a user's x/net/http2. As such, as it has a unique method name +// (IsHTTP2NoCachedConnError) that net/http sniffs for via func +// isNoCachedConnError. +type noCachedConnError struct{} + +func (noCachedConnError) IsHTTP2NoCachedConnError() {} +func (noCachedConnError) Error() string { return "http2: no cached connection was available" } + +// isNoCachedConnError reports whether err is of type noCachedConnError +// or its equivalent renamed type in net/http2's h2_bundle.go. Both types +// may coexist in the same running program. +func isNoCachedConnError(err error) bool { + _, ok := err.(interface{ IsHTTP2NoCachedConnError() }) + return ok +} + +var ErrNoCachedConn error = noCachedConnError{} diff --git a/vendor/golang.org/x/net/http2/writesched_common.go b/vendor/golang.org/x/net/http2/writesched_common.go index 957bc659e7..75354c1ff8 100644 --- a/vendor/golang.org/x/net/http2/writesched_common.go +++ b/vendor/golang.org/x/net/http2/writesched_common.go @@ -47,3 +47,44 @@ type OpenStreamOptions struct { // priority is used to set the priority of the newly opened stream. priority PriorityParam } + +// PriorityWriteSchedulerConfig configures a priorityWriteScheduler. +// +// Deprecated: User-provided write schedulers are deprecated. +type PriorityWriteSchedulerConfig struct { + // MaxClosedNodesInTree controls the maximum number of closed streams to + // retain in the priority tree. Setting this to zero saves a small amount + // of memory at the cost of performance. + // + // See RFC 7540, Section 5.3.4: + // "It is possible for a stream to become closed while prioritization + // information ... is in transit. ... This potentially creates suboptimal + // prioritization, since the stream could be given a priority that is + // different from what is intended. To avoid these problems, an endpoint + // SHOULD retain stream prioritization state for a period after streams + // become closed. The longer state is retained, the lower the chance that + // streams are assigned incorrect or default priority values." + MaxClosedNodesInTree int + + // MaxIdleNodesInTree controls the maximum number of idle streams to + // retain in the priority tree. Setting this to zero saves a small amount + // of memory at the cost of performance. + // + // See RFC 7540, Section 5.3.4: + // Similarly, streams that are in the "idle" state can be assigned + // priority or become a parent of other streams. This allows for the + // creation of a grouping node in the dependency tree, which enables + // more flexible expressions of priority. Idle streams begin with a + // default priority (Section 5.3.5). + MaxIdleNodesInTree int + + // ThrottleOutOfOrderWrites enables write throttling to help ensure that + // data is delivered in priority order. This works around a race where + // stream B depends on stream A and both streams are about to call Write + // to queue DATA frames. If B wins the race, a naive scheduler would eagerly + // write as much data from B as possible, but this is suboptimal because A + // is a higher-priority stream. With throttling enabled, we write a small + // amount of data from B to minimize the amount of bandwidth that B can + // steal from A. + ThrottleOutOfOrderWrites bool +} diff --git a/vendor/golang.org/x/net/http2/writesched_priority_rfc7540.go b/vendor/golang.org/x/net/http2/writesched_priority_rfc7540.go index ccd1afef2a..10e67f7cee 100644 --- a/vendor/golang.org/x/net/http2/writesched_priority_rfc7540.go +++ b/vendor/golang.org/x/net/http2/writesched_priority_rfc7540.go @@ -15,47 +15,6 @@ import ( // RFC 7540, Section 5.3.5: the default weight is 16. const priorityDefaultWeightRFC7540 = 15 // 16 = 15 + 1 -// PriorityWriteSchedulerConfig configures a priorityWriteScheduler. -// -// Deprecated: User-provided write schedulers are deprecated. -type PriorityWriteSchedulerConfig struct { - // MaxClosedNodesInTree controls the maximum number of closed streams to - // retain in the priority tree. Setting this to zero saves a small amount - // of memory at the cost of performance. - // - // See RFC 7540, Section 5.3.4: - // "It is possible for a stream to become closed while prioritization - // information ... is in transit. ... This potentially creates suboptimal - // prioritization, since the stream could be given a priority that is - // different from what is intended. To avoid these problems, an endpoint - // SHOULD retain stream prioritization state for a period after streams - // become closed. The longer state is retained, the lower the chance that - // streams are assigned incorrect or default priority values." - MaxClosedNodesInTree int - - // MaxIdleNodesInTree controls the maximum number of idle streams to - // retain in the priority tree. Setting this to zero saves a small amount - // of memory at the cost of performance. - // - // See RFC 7540, Section 5.3.4: - // Similarly, streams that are in the "idle" state can be assigned - // priority or become a parent of other streams. This allows for the - // creation of a grouping node in the dependency tree, which enables - // more flexible expressions of priority. Idle streams begin with a - // default priority (Section 5.3.5). - MaxIdleNodesInTree int - - // ThrottleOutOfOrderWrites enables write throttling to help ensure that - // data is delivered in priority order. This works around a race where - // stream B depends on stream A and both streams are about to call Write - // to queue DATA frames. If B wins the race, a naive scheduler would eagerly - // write as much data from B as possible, but this is suboptimal because A - // is a higher-priority stream. With throttling enabled, we write a small - // amount of data from B to minimize the amount of bandwidth that B can - // steal from A. - ThrottleOutOfOrderWrites bool -} - // NewPriorityWriteScheduler constructs a WriteScheduler that schedules // frames by following HTTP/2 priorities as described in RFC 7540 Section 5.3. // If cfg is nil, default options are used. diff --git a/vendor/golang.org/x/sys/cpu/cpu.go b/vendor/golang.org/x/sys/cpu/cpu.go index 63541994ef..f1ce515d5c 100644 --- a/vendor/golang.org/x/sys/cpu/cpu.go +++ b/vendor/golang.org/x/sys/cpu/cpu.go @@ -152,13 +152,17 @@ var ARM struct { // The booleans in Loong64 contain the correspondingly named cpu feature bit. // The struct is padded to avoid false sharing. var Loong64 struct { - _ CacheLinePad - HasLSX bool // support 128-bit vector extension - HasLASX bool // support 256-bit vector extension - HasCRC32 bool // support CRC instruction - HasLAM_BH bool // support AM{SWAP/ADD}[_DB].{B/H} instruction - HasLAMCAS bool // support AMCAS[_DB].{B/H/W/D} instruction - _ CacheLinePad + _ CacheLinePad + HasLSX bool // support 128-bit vector extension + HasLASX bool // support 256-bit vector extension + HasCRC32 bool // support CRC instruction + HasLAMCAS bool // support AMCAS[_DB].{B/H/W/D} + HasLAM_BH bool // support AM{SWAP/ADD}[_DB].{B/H} instruction + HasLLACQ_SCREL bool // support LLACQ.{W/D}, SCREL.{W/D} instruction + HasSCQ bool // support SC.Q instruction + HasDBAR_HINTS bool // supports finer-grained DBAR hints + + _ CacheLinePad } // MIPS64X contains the supported CPU features of the current mips64/mips64le @@ -232,6 +236,7 @@ var RISCV64 struct { HasZba bool // Address generation instructions extension HasZbb bool // Basic bit-manipulation extension HasZbs bool // Single-bit instructions extension + HasZbc bool // Carryless multiplication extension HasZvbb bool // Vector Basic Bit-manipulation HasZvbc bool // Vector Carryless Multiplication HasZvkb bool // Vector Cryptography Bit-manipulation diff --git a/vendor/golang.org/x/sys/cpu/cpu_linux_riscv64.go b/vendor/golang.org/x/sys/cpu/cpu_linux_riscv64.go index ad741536f3..f4fb52ee96 100644 --- a/vendor/golang.org/x/sys/cpu/cpu_linux_riscv64.go +++ b/vendor/golang.org/x/sys/cpu/cpu_linux_riscv64.go @@ -58,6 +58,7 @@ const ( riscv_HWPROBE_EXT_ZBA = 0x8 riscv_HWPROBE_EXT_ZBB = 0x10 riscv_HWPROBE_EXT_ZBS = 0x20 + riscv_HWPROBE_EXT_ZBC = 0x80 riscv_HWPROBE_EXT_ZVBB = 0x20000 riscv_HWPROBE_EXT_ZVBC = 0x40000 riscv_HWPROBE_EXT_ZVKB = 0x80000 @@ -108,6 +109,7 @@ func doinit() { RISCV64.HasZba = isSet(v, riscv_HWPROBE_EXT_ZBA) RISCV64.HasZbb = isSet(v, riscv_HWPROBE_EXT_ZBB) RISCV64.HasZbs = isSet(v, riscv_HWPROBE_EXT_ZBS) + RISCV64.HasZbc = isSet(v, riscv_HWPROBE_EXT_ZBC) RISCV64.HasZvbb = isSet(v, riscv_HWPROBE_EXT_ZVBB) RISCV64.HasZvbc = isSet(v, riscv_HWPROBE_EXT_ZVBC) RISCV64.HasZvkb = isSet(v, riscv_HWPROBE_EXT_ZVKB) diff --git a/vendor/golang.org/x/sys/cpu/cpu_loong64.go b/vendor/golang.org/x/sys/cpu/cpu_loong64.go index 45ecb29ae7..8c234b4415 100644 --- a/vendor/golang.org/x/sys/cpu/cpu_loong64.go +++ b/vendor/golang.org/x/sys/cpu/cpu_loong64.go @@ -15,8 +15,13 @@ const ( cpucfg1_CRC32 = 1 << 25 // CPUCFG2 bits - cpucfg2_LAM_BH = 1 << 27 - cpucfg2_LAMCAS = 1 << 28 + cpucfg2_LAM_BH = 1 << 27 + cpucfg2_LAMCAS = 1 << 28 + cpucfg2_LLACQ_SCREL = 1 << 29 + cpucfg2_SCQ = 1 << 30 + + // CPUCFG3 bits + cpucfg3_DBAR_HINTS = 1 << 17 ) func initOptions() { @@ -26,6 +31,9 @@ func initOptions() { {Name: "crc32", Feature: &Loong64.HasCRC32}, {Name: "lam_bh", Feature: &Loong64.HasLAM_BH}, {Name: "lamcas", Feature: &Loong64.HasLAMCAS}, + {Name: "llacq_screl", Feature: &Loong64.HasLLACQ_SCREL}, + {Name: "scq", Feature: &Loong64.HasSCQ}, + {Name: "dbar_hints", Feature: &Loong64.HasDBAR_HINTS}, } // The CPUCFG data on Loong64 only reflects the hardware capabilities, @@ -37,10 +45,14 @@ func initOptions() { // through CPUCFG cfg1 := get_cpucfg(1) cfg2 := get_cpucfg(2) + cfg3 := get_cpucfg(3) Loong64.HasCRC32 = cfgIsSet(cfg1, cpucfg1_CRC32) Loong64.HasLAMCAS = cfgIsSet(cfg2, cpucfg2_LAMCAS) Loong64.HasLAM_BH = cfgIsSet(cfg2, cpucfg2_LAM_BH) + Loong64.HasLLACQ_SCREL = cfgIsSet(cfg2, cpucfg2_LLACQ_SCREL) + Loong64.HasSCQ = cfgIsSet(cfg2, cpucfg2_SCQ) + Loong64.HasDBAR_HINTS = cfgIsSet(cfg3, cpucfg3_DBAR_HINTS) } func get_cpucfg(reg uint32) uint32 diff --git a/vendor/golang.org/x/sys/cpu/cpu_riscv64.go b/vendor/golang.org/x/sys/cpu/cpu_riscv64.go index 0f617aef54..d4e9885f31 100644 --- a/vendor/golang.org/x/sys/cpu/cpu_riscv64.go +++ b/vendor/golang.org/x/sys/cpu/cpu_riscv64.go @@ -16,6 +16,7 @@ func initOptions() { {Name: "zba", Feature: &RISCV64.HasZba}, {Name: "zbb", Feature: &RISCV64.HasZbb}, {Name: "zbs", Feature: &RISCV64.HasZbs}, + {Name: "zbc", Feature: &RISCV64.HasZbc}, // RISC-V Cryptography Extensions {Name: "zvbb", Feature: &RISCV64.HasZvbb}, {Name: "zvbc", Feature: &RISCV64.HasZvbc}, diff --git a/vendor/golang.org/x/sys/unix/mkerrors.sh b/vendor/golang.org/x/sys/unix/mkerrors.sh index fd39be4efd..fa74cfe9e8 100644 --- a/vendor/golang.org/x/sys/unix/mkerrors.sh +++ b/vendor/golang.org/x/sys/unix/mkerrors.sh @@ -354,6 +354,9 @@ struct ltchars { // Renamed in v6.16, commit c6d732c38f93 ("net: ethtool: remove duplicate defines for family info") #define ETHTOOL_FAMILY_NAME ETHTOOL_GENL_NAME #define ETHTOOL_FAMILY_VERSION ETHTOOL_GENL_VERSION + +// Removed in v6.17, commit 760e6f7befba ("futex: Remove support for IMMUTABLE") +#define PR_FUTEX_HASH_GET_IMMUTABLE 3 ' includes_NetBSD=' diff --git a/vendor/golang.org/x/sys/unix/readv_unix.go b/vendor/golang.org/x/sys/unix/readv_unix.go new file mode 100644 index 0000000000..38a2be937e --- /dev/null +++ b/vendor/golang.org/x/sys/unix/readv_unix.go @@ -0,0 +1,103 @@ +// Copyright 2026 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 darwin || linux || openbsd + +package unix + +import "unsafe" + +// minIovec is the size of the small initial allocation used by +// Readv, Writev, etc. +// +// This small allocation gets stack allocated, which lets the +// common use case of len(iovs) <= minIovec avoid more expensive +// heap allocations. +const minIovec = 8 + +// appendBytes converts bs to Iovecs and appends them to vecs. +func appendBytes(vecs []Iovec, bs [][]byte) []Iovec { + for _, b := range bs { + var v Iovec + v.SetLen(len(b)) + if len(b) > 0 { + v.Base = &b[0] + } else { + v.Base = (*byte)(unsafe.Pointer(&_zero)) + } + vecs = append(vecs, v) + } + return vecs +} + +// writevRaceDetect tells the race detector that the program +// has read the first n bytes stored in iovecs. +func writevRaceDetect(iovecs []Iovec, n int) { + if !raceenabled { + return + } + for i := 0; n > 0 && i < len(iovecs); i++ { + m := min(int(iovecs[i].Len), n) + n -= m + if m > 0 { + raceReadRange(unsafe.Pointer(iovecs[i].Base), m) + } + } +} + +// readvRaceDetect tells the race detector that the program +// has written to the first n bytes stored in iovecs. +func readvRaceDetect(iovecs []Iovec, n int, err error) { + if !raceenabled { + return + } + for i := 0; n > 0 && i < len(iovecs); i++ { + m := min(int(iovecs[i].Len), n) + n -= m + if m > 0 { + raceWriteRange(unsafe.Pointer(iovecs[i].Base), m) + } + } + if err == nil { + raceAcquire(unsafe.Pointer(&ioSync)) + } +} + +func Readv(fd int, iovs [][]byte) (n int, err error) { + iovecs := make([]Iovec, 0, minIovec) + iovecs = appendBytes(iovecs, iovs) + n, err = readv(fd, iovecs) + readvRaceDetect(iovecs, n, err) + return n, err +} + +func Preadv(fd int, iovs [][]byte, offset int64) (n int, err error) { + iovecs := make([]Iovec, 0, minIovec) + iovecs = appendBytes(iovecs, iovs) + n, err = preadv(fd, iovecs, offset) + readvRaceDetect(iovecs, n, err) + return n, err +} + +func Writev(fd int, iovs [][]byte) (n int, err error) { + iovecs := make([]Iovec, 0, minIovec) + iovecs = appendBytes(iovecs, iovs) + if raceenabled { + raceReleaseMerge(unsafe.Pointer(&ioSync)) + } + n, err = writev(fd, iovecs) + writevRaceDetect(iovecs, n) + return n, err +} + +func Pwritev(fd int, iovs [][]byte, offset int64) (n int, err error) { + iovecs := make([]Iovec, 0, minIovec) + iovecs = appendBytes(iovecs, iovs) + if raceenabled { + raceReleaseMerge(unsafe.Pointer(&ioSync)) + } + n, err = pwritev(fd, iovecs, offset) + writevRaceDetect(iovecs, n) + return n, err +} diff --git a/vendor/golang.org/x/sys/unix/syscall_darwin.go b/vendor/golang.org/x/sys/unix/syscall_darwin.go index 7838ca5db2..38590ca81d 100644 --- a/vendor/golang.org/x/sys/unix/syscall_darwin.go +++ b/vendor/golang.org/x/sys/unix/syscall_darwin.go @@ -602,95 +602,6 @@ func Connectx(fd int, srcIf uint32, srcAddr, dstAddr Sockaddr, associd SaeAssocI return } -const minIovec = 8 - -func Readv(fd int, iovs [][]byte) (n int, err error) { - iovecs := make([]Iovec, 0, minIovec) - iovecs = appendBytes(iovecs, iovs) - n, err = readv(fd, iovecs) - readvRacedetect(iovecs, n, err) - return n, err -} - -func Preadv(fd int, iovs [][]byte, offset int64) (n int, err error) { - iovecs := make([]Iovec, 0, minIovec) - iovecs = appendBytes(iovecs, iovs) - n, err = preadv(fd, iovecs, offset) - readvRacedetect(iovecs, n, err) - return n, err -} - -func Writev(fd int, iovs [][]byte) (n int, err error) { - iovecs := make([]Iovec, 0, minIovec) - iovecs = appendBytes(iovecs, iovs) - if raceenabled { - raceReleaseMerge(unsafe.Pointer(&ioSync)) - } - n, err = writev(fd, iovecs) - writevRacedetect(iovecs, n) - return n, err -} - -func Pwritev(fd int, iovs [][]byte, offset int64) (n int, err error) { - iovecs := make([]Iovec, 0, minIovec) - iovecs = appendBytes(iovecs, iovs) - if raceenabled { - raceReleaseMerge(unsafe.Pointer(&ioSync)) - } - n, err = pwritev(fd, iovecs, offset) - writevRacedetect(iovecs, n) - return n, err -} - -func appendBytes(vecs []Iovec, bs [][]byte) []Iovec { - for _, b := range bs { - var v Iovec - v.SetLen(len(b)) - if len(b) > 0 { - v.Base = &b[0] - } else { - v.Base = (*byte)(unsafe.Pointer(&_zero)) - } - vecs = append(vecs, v) - } - return vecs -} - -func writevRacedetect(iovecs []Iovec, n int) { - if !raceenabled { - return - } - for i := 0; n > 0 && i < len(iovecs); i++ { - m := int(iovecs[i].Len) - if m > n { - m = n - } - n -= m - if m > 0 { - raceReadRange(unsafe.Pointer(iovecs[i].Base), m) - } - } -} - -func readvRacedetect(iovecs []Iovec, n int, err error) { - if !raceenabled { - return - } - for i := 0; n > 0 && i < len(iovecs); i++ { - m := int(iovecs[i].Len) - if m > n { - m = n - } - n -= m - if m > 0 { - raceWriteRange(unsafe.Pointer(iovecs[i].Base), m) - } - } - if err == nil { - raceAcquire(unsafe.Pointer(&ioSync)) - } -} - //sys connectx(fd int, endpoints *SaEndpoints, associd SaeAssocID, flags uint32, iov []Iovec, n *uintptr, connid *SaeConnID) (err error) //sys sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error) diff --git a/vendor/golang.org/x/sys/unix/syscall_linux.go b/vendor/golang.org/x/sys/unix/syscall_linux.go index f7b82bccac..ce4d7ab1ed 100644 --- a/vendor/golang.org/x/sys/unix/syscall_linux.go +++ b/vendor/golang.org/x/sys/unix/syscall_linux.go @@ -2150,33 +2150,10 @@ func Signalfd(fd int, sigmask *Sigset_t, flags int) (newfd int, err error) { //sys exitThread(code int) (err error) = SYS_EXIT //sys readv(fd int, iovs []Iovec) (n int, err error) = SYS_READV //sys writev(fd int, iovs []Iovec) (n int, err error) = SYS_WRITEV -//sys preadv(fd int, iovs []Iovec, offs_l uintptr, offs_h uintptr) (n int, err error) = SYS_PREADV -//sys pwritev(fd int, iovs []Iovec, offs_l uintptr, offs_h uintptr) (n int, err error) = SYS_PWRITEV -//sys preadv2(fd int, iovs []Iovec, offs_l uintptr, offs_h uintptr, flags int) (n int, err error) = SYS_PREADV2 -//sys pwritev2(fd int, iovs []Iovec, offs_l uintptr, offs_h uintptr, flags int) (n int, err error) = SYS_PWRITEV2 - -// minIovec is the size of the small initial allocation used by -// Readv, Writev, etc. -// -// This small allocation gets stack allocated, which lets the -// common use case of len(iovs) <= minIovs avoid more expensive -// heap allocations. -const minIovec = 8 - -// appendBytes converts bs to Iovecs and appends them to vecs. -func appendBytes(vecs []Iovec, bs [][]byte) []Iovec { - for _, b := range bs { - var v Iovec - v.SetLen(len(b)) - if len(b) > 0 { - v.Base = &b[0] - } else { - v.Base = (*byte)(unsafe.Pointer(&_zero)) - } - vecs = append(vecs, v) - } - return vecs -} +//sys preadvSyscall(fd int, iovs []Iovec, offs_l uintptr, offs_h uintptr) (n int, err error) = SYS_PREADV +//sys pwritevSyscall(fd int, iovs []Iovec, offs_l uintptr, offs_h uintptr) (n int, err error) = SYS_PWRITEV +//sys preadv2Syscall(fd int, iovs []Iovec, offs_l uintptr, offs_h uintptr, flags int) (n int, err error) = SYS_PREADV2 +//sys pwritev2Syscall(fd int, iovs []Iovec, offs_l uintptr, offs_h uintptr, flags int) (n int, err error) = SYS_PWRITEV2 // offs2lohi splits offs into its low and high order bits. func offs2lohi(offs int64) (lo, hi uintptr) { @@ -2184,69 +2161,23 @@ func offs2lohi(offs int64) (lo, hi uintptr) { return uintptr(offs), uintptr(uint64(offs) >> (longBits - 1) >> 1) // two shifts to avoid false positive in vet } -func Readv(fd int, iovs [][]byte) (n int, err error) { - iovecs := make([]Iovec, 0, minIovec) - iovecs = appendBytes(iovecs, iovs) - n, err = readv(fd, iovecs) - readvRacedetect(iovecs, n, err) - return n, err -} - -func Preadv(fd int, iovs [][]byte, offset int64) (n int, err error) { - iovecs := make([]Iovec, 0, minIovec) - iovecs = appendBytes(iovecs, iovs) +func preadv(fd int, iovecs []Iovec, offset int64) (n int, err error) { lo, hi := offs2lohi(offset) - n, err = preadv(fd, iovecs, lo, hi) - readvRacedetect(iovecs, n, err) - return n, err + return preadvSyscall(fd, iovecs, lo, hi) } func Preadv2(fd int, iovs [][]byte, offset int64, flags int) (n int, err error) { iovecs := make([]Iovec, 0, minIovec) iovecs = appendBytes(iovecs, iovs) lo, hi := offs2lohi(offset) - n, err = preadv2(fd, iovecs, lo, hi, flags) - readvRacedetect(iovecs, n, err) - return n, err -} - -func readvRacedetect(iovecs []Iovec, n int, err error) { - if !raceenabled { - return - } - for i := 0; n > 0 && i < len(iovecs); i++ { - m := min(int(iovecs[i].Len), n) - n -= m - if m > 0 { - raceWriteRange(unsafe.Pointer(iovecs[i].Base), m) - } - } - if err == nil { - raceAcquire(unsafe.Pointer(&ioSync)) - } -} - -func Writev(fd int, iovs [][]byte) (n int, err error) { - iovecs := make([]Iovec, 0, minIovec) - iovecs = appendBytes(iovecs, iovs) - if raceenabled { - raceReleaseMerge(unsafe.Pointer(&ioSync)) - } - n, err = writev(fd, iovecs) - writevRacedetect(iovecs, n) + n, err = preadv2Syscall(fd, iovecs, lo, hi, flags) + readvRaceDetect(iovecs, n, err) return n, err } -func Pwritev(fd int, iovs [][]byte, offset int64) (n int, err error) { - iovecs := make([]Iovec, 0, minIovec) - iovecs = appendBytes(iovecs, iovs) - if raceenabled { - raceReleaseMerge(unsafe.Pointer(&ioSync)) - } +func pwritev(fd int, iovecs []Iovec, offset int64) (n int, err error) { lo, hi := offs2lohi(offset) - n, err = pwritev(fd, iovecs, lo, hi) - writevRacedetect(iovecs, n) - return n, err + return pwritevSyscall(fd, iovecs, lo, hi) } func Pwritev2(fd int, iovs [][]byte, offset int64, flags int) (n int, err error) { @@ -2256,24 +2187,11 @@ func Pwritev2(fd int, iovs [][]byte, offset int64, flags int) (n int, err error) raceReleaseMerge(unsafe.Pointer(&ioSync)) } lo, hi := offs2lohi(offset) - n, err = pwritev2(fd, iovecs, lo, hi, flags) - writevRacedetect(iovecs, n) + n, err = pwritev2Syscall(fd, iovecs, lo, hi, flags) + writevRaceDetect(iovecs, n) return n, err } -func writevRacedetect(iovecs []Iovec, n int) { - if !raceenabled { - return - } - for i := 0; n > 0 && i < len(iovecs); i++ { - m := min(int(iovecs[i].Len), n) - n -= m - if m > 0 { - raceReadRange(unsafe.Pointer(iovecs[i].Base), m) - } - } -} - // mmap varies by architecture; see syscall_linux_*.go. //sys munmap(addr uintptr, length uintptr) (err error) //sys mremap(oldaddr uintptr, oldlength uintptr, newlength uintptr, flags int, newaddr uintptr) (xaddr uintptr, err error) diff --git a/vendor/golang.org/x/sys/unix/syscall_openbsd.go b/vendor/golang.org/x/sys/unix/syscall_openbsd.go index b86ded549c..7b0ef8e123 100644 --- a/vendor/golang.org/x/sys/unix/syscall_openbsd.go +++ b/vendor/golang.org/x/sys/unix/syscall_openbsd.go @@ -300,6 +300,10 @@ func Uname(uname *Utsname) error { //sys Pathconf(path string, name int) (val int, err error) //sys pread(fd int, p []byte, offset int64) (n int, err error) //sys pwrite(fd int, p []byte, offset int64) (n int, err error) +//sys readv(fd int, iovecs []Iovec) (n int, err error) +//sys writev(fd int, iovecs []Iovec) (n int, err error) +//sys preadv(fd int, iovecs []Iovec, offset int64) (n int, err error) +//sys pwritev(fd int, iovecs []Iovec, offset int64) (n int, err error) //sys read(fd int, p []byte) (n int, err error) //sys Readlink(path string, buf []byte) (n int, err error) //sys Readlinkat(dirfd int, path string, buf []byte) (n int, err error) diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux.go b/vendor/golang.org/x/sys/unix/zerrors_linux.go index 120a7b35d1..9d72a6b73a 100644 --- a/vendor/golang.org/x/sys/unix/zerrors_linux.go +++ b/vendor/golang.org/x/sys/unix/zerrors_linux.go @@ -353,8 +353,10 @@ const ( AUDIT_MAC_IPSEC_EVENT = 0x587 AUDIT_MAC_MAP_ADD = 0x581 AUDIT_MAC_MAP_DEL = 0x582 + AUDIT_MAC_OBJ_CONTEXTS = 0x592 AUDIT_MAC_POLICY_LOAD = 0x57b AUDIT_MAC_STATUS = 0x57c + AUDIT_MAC_TASK_CONTEXTS = 0x591 AUDIT_MAC_UNLBL_ALLOW = 0x57e AUDIT_MAC_UNLBL_STCADD = 0x588 AUDIT_MAC_UNLBL_STCDEL = 0x589 @@ -591,8 +593,13 @@ const ( CAN_CTRLMODE_LOOPBACK = 0x1 CAN_CTRLMODE_ONE_SHOT = 0x8 CAN_CTRLMODE_PRESUME_ACK = 0x40 + CAN_CTRLMODE_RESTRICTED = 0x800 CAN_CTRLMODE_TDC_AUTO = 0x200 CAN_CTRLMODE_TDC_MANUAL = 0x400 + CAN_CTRLMODE_XL = 0x1000 + CAN_CTRLMODE_XL_TDC_AUTO = 0x2000 + CAN_CTRLMODE_XL_TDC_MANUAL = 0x4000 + CAN_CTRLMODE_XL_TMS = 0x8000 CAN_EFF_FLAG = 0x80000000 CAN_EFF_ID_BITS = 0x1d CAN_EFF_MASK = 0x1fffffff @@ -800,6 +807,8 @@ const ( DEVLINK_PORT_FN_CAP_IPSEC_PACKET = 0x8 DEVLINK_PORT_FN_CAP_MIGRATABLE = 0x2 DEVLINK_PORT_FN_CAP_ROCE = 0x1 + DEVLINK_RATE_TCS_MAX = 0x8 + DEVLINK_RATE_TC_INDEX_MAX = 0x7 DEVLINK_SB_THRESHOLD_TO_ALPHA_MAX = 0x14 DEVLINK_SUPPORTED_FLASH_OVERWRITE_SECTIONS = 0x3 DEVMEM_MAGIC = 0x454d444d @@ -1186,6 +1195,7 @@ const ( ETH_P_MPLS_UC = 0x8847 ETH_P_MRP = 0x88e3 ETH_P_MVRP = 0x88f5 + ETH_P_MXLGSW = 0x88c3 ETH_P_NCSI = 0x88f8 ETH_P_NSH = 0x894f ETH_P_PAE = 0x888e @@ -1218,6 +1228,7 @@ const ( ETH_P_WCCP = 0x883e ETH_P_X25 = 0x805 ETH_P_XDSA = 0xf8 + ETH_P_YT921X = 0x9988 ET_CORE = 0x4 ET_DYN = 0x3 ET_EXEC = 0x2 @@ -1258,6 +1269,7 @@ const ( FALLOC_FL_NO_HIDE_STALE = 0x4 FALLOC_FL_PUNCH_HOLE = 0x2 FALLOC_FL_UNSHARE_RANGE = 0x40 + FALLOC_FL_WRITE_ZEROES = 0x80 FALLOC_FL_ZERO_RANGE = 0x10 FANOTIFY_METADATA_VERSION = 0x3 FAN_ACCESS = 0x1 @@ -1477,6 +1489,7 @@ const ( GRND_INSECURE = 0x4 GRND_NONBLOCK = 0x1 GRND_RANDOM = 0x2 + GUEST_MEMFD_MAGIC = 0x474d454d HDIO_DRIVE_CMD = 0x31f HDIO_DRIVE_CMD_AEB = 0x31e HDIO_DRIVE_CMD_HDR_SIZE = 0x4 @@ -1517,6 +1530,7 @@ const ( HDIO_SET_XFER = 0x306 HDIO_TRISTATE_HWIF = 0x31b HDIO_UNREGISTER_HWIF = 0x32a + HIDIOCTL_LAST = 0xd HID_MAX_DESCRIPTOR_SIZE = 0x1000 HOSTFS_SUPER_MAGIC = 0xc0ffee HPFS_SUPER_MAGIC = 0xf995e849 @@ -1809,6 +1823,8 @@ const ( KEXEC_ARCH_X86_64 = 0x3e0000 KEXEC_CRASH_HOTPLUG_SUPPORT = 0x8 KEXEC_FILE_DEBUG = 0x8 + KEXEC_FILE_FORCE_DTB = 0x20 + KEXEC_FILE_NO_CMA = 0x10 KEXEC_FILE_NO_INITRAMFS = 0x4 KEXEC_FILE_ON_CRASH = 0x2 KEXEC_FILE_UNLOAD = 0x1 @@ -1905,6 +1921,7 @@ const ( LANDLOCK_RESTRICT_SELF_LOG_NEW_EXEC_ON = 0x2 LANDLOCK_RESTRICT_SELF_LOG_SAME_EXEC_OFF = 0x1 LANDLOCK_RESTRICT_SELF_LOG_SUBDOMAINS_OFF = 0x4 + LANDLOCK_RESTRICT_SELF_TSYNC = 0x8 LANDLOCK_SCOPE_ABSTRACT_UNIX_SOCKET = 0x1 LANDLOCK_SCOPE_SIGNAL = 0x2 LINUX_REBOOT_CMD_CAD_OFF = 0x0 @@ -2412,6 +2429,7 @@ const ( NN_PRXFPREG = "LINUX" NN_RISCV_CSR = "LINUX" NN_RISCV_TAGGED_ADDR_CTRL = "LINUX" + NN_RISCV_USER_CFI = "LINUX" NN_RISCV_VECTOR = "LINUX" NN_S390_CTRS = "LINUX" NN_S390_GS_BC = "LINUX" @@ -2493,6 +2511,7 @@ const ( NT_PRXFPREG = 0x46e62b7f NT_RISCV_CSR = 0x900 NT_RISCV_TAGGED_ADDR_CTRL = 0x902 + NT_RISCV_USER_CFI = 0x903 NT_RISCV_VECTOR = 0x901 NT_S390_CTRS = 0x304 NT_S390_GS_BC = 0x30c @@ -2515,6 +2534,7 @@ const ( NT_X86_SHSTK = 0x204 NT_X86_XSAVE_LAYOUT = 0x205 NT_X86_XSTATE = 0x202 + NULL_FS_MAGIC = 0x4e554c4c OCFS2_SUPER_MAGIC = 0x7461636f OCRNL = 0x8 OFDEL = 0x80 @@ -2594,6 +2614,7 @@ const ( PERF_ATTR_SIZE_VER6 = 0x78 PERF_ATTR_SIZE_VER7 = 0x80 PERF_ATTR_SIZE_VER8 = 0x88 + PERF_ATTR_SIZE_VER9 = 0x90 PERF_AUX_FLAG_COLLISION = 0x8 PERF_AUX_FLAG_CORESIGHT_FORMAT_CORESIGHT = 0x0 PERF_AUX_FLAG_CORESIGHT_FORMAT_RAW = 0x100 @@ -2629,6 +2650,7 @@ const ( PERF_MEM_LVLNUM_ANY_CACHE = 0xb PERF_MEM_LVLNUM_CXL = 0x9 PERF_MEM_LVLNUM_IO = 0xa + PERF_MEM_LVLNUM_L0 = 0x7 PERF_MEM_LVLNUM_L1 = 0x1 PERF_MEM_LVLNUM_L2 = 0x2 PERF_MEM_LVLNUM_L2_MHB = 0x5 @@ -2662,6 +2684,23 @@ const ( PERF_MEM_OP_PFETCH = 0x8 PERF_MEM_OP_SHIFT = 0x0 PERF_MEM_OP_STORE = 0x4 + PERF_MEM_REGION_L_NON_SHARE = 0x3 + PERF_MEM_REGION_L_SHARE = 0x2 + PERF_MEM_REGION_MEM0 = 0x8 + PERF_MEM_REGION_MEM1 = 0x9 + PERF_MEM_REGION_MEM2 = 0xa + PERF_MEM_REGION_MEM3 = 0xb + PERF_MEM_REGION_MEM4 = 0xc + PERF_MEM_REGION_MEM5 = 0xd + PERF_MEM_REGION_MEM6 = 0xe + PERF_MEM_REGION_MEM7 = 0xf + PERF_MEM_REGION_MMIO = 0x7 + PERF_MEM_REGION_NA = 0x0 + PERF_MEM_REGION_O_IO = 0x4 + PERF_MEM_REGION_O_NON_SHARE = 0x6 + PERF_MEM_REGION_O_SHARE = 0x5 + PERF_MEM_REGION_RSVD = 0x1 + PERF_MEM_REGION_SHIFT = 0x2e PERF_MEM_REMOTE_REMOTE = 0x1 PERF_MEM_REMOTE_SHIFT = 0x25 PERF_MEM_SNOOPX_FWD = 0x1 @@ -2776,6 +2815,10 @@ const ( PR_CAP_AMBIENT_IS_SET = 0x1 PR_CAP_AMBIENT_LOWER = 0x3 PR_CAP_AMBIENT_RAISE = 0x2 + PR_CFI_BRANCH_LANDING_PADS = 0x0 + PR_CFI_DISABLE = 0x2 + PR_CFI_ENABLE = 0x1 + PR_CFI_LOCK = 0x4 PR_ENDIAN_BIG = 0x0 PR_ENDIAN_LITTLE = 0x1 PR_ENDIAN_PPC_LITTLE = 0x2 @@ -2798,6 +2841,7 @@ const ( PR_FUTEX_HASH_GET_SLOTS = 0x2 PR_FUTEX_HASH_SET_SLOTS = 0x1 PR_GET_AUXV = 0x41555856 + PR_GET_CFI = 0x50 PR_GET_CHILD_SUBREAPER = 0x25 PR_GET_DUMPABLE = 0x3 PR_GET_ENDIAN = 0x13 @@ -2834,6 +2878,7 @@ const ( PR_MDWE_REFUSE_EXEC_GAIN = 0x1 PR_MPX_DISABLE_MANAGEMENT = 0x2c PR_MPX_ENABLE_MANAGEMENT = 0x2b + PR_MTE_STORE_ONLY = 0x80000 PR_MTE_TAG_MASK = 0x7fff8 PR_MTE_TAG_SHIFT = 0x3 PR_MTE_TCF_ASYNC = 0x4 @@ -2877,6 +2922,10 @@ const ( PR_RISCV_V_VSTATE_CTRL_NEXT_MASK = 0xc PR_RISCV_V_VSTATE_CTRL_OFF = 0x1 PR_RISCV_V_VSTATE_CTRL_ON = 0x2 + PR_RSEQ_SLICE_EXTENSION = 0x4f + PR_RSEQ_SLICE_EXTENSION_GET = 0x1 + PR_RSEQ_SLICE_EXTENSION_SET = 0x2 + PR_RSEQ_SLICE_EXT_ENABLE = 0x1 PR_SCHED_CORE = 0x3e PR_SCHED_CORE_CREATE = 0x1 PR_SCHED_CORE_GET = 0x0 @@ -2886,6 +2935,7 @@ const ( PR_SCHED_CORE_SCOPE_THREAD_GROUP = 0x1 PR_SCHED_CORE_SHARE_FROM = 0x3 PR_SCHED_CORE_SHARE_TO = 0x2 + PR_SET_CFI = 0x51 PR_SET_CHILD_SUBREAPER = 0x24 PR_SET_DUMPABLE = 0x4 PR_SET_ENDIAN = 0x14 @@ -2951,11 +3001,14 @@ const ( PR_SVE_SET_VL_ONEXEC = 0x40000 PR_SVE_VL_INHERIT = 0x20000 PR_SVE_VL_LEN_MASK = 0xffff + PR_SYS_DISPATCH_EXCLUSIVE_ON = 0x1 + PR_SYS_DISPATCH_INCLUSIVE_ON = 0x2 PR_SYS_DISPATCH_OFF = 0x0 PR_SYS_DISPATCH_ON = 0x1 PR_TAGGED_ADDR_ENABLE = 0x1 PR_TASK_PERF_EVENTS_DISABLE = 0x1f PR_TASK_PERF_EVENTS_ENABLE = 0x20 + PR_THP_DISABLE_EXCEPT_ADVISED = 0x2 PR_TIMER_CREATE_RESTORE_IDS = 0x4d PR_TIMER_CREATE_RESTORE_IDS_GET = 0x2 PR_TIMER_CREATE_RESTORE_IDS_OFF = 0x0 @@ -2987,8 +3040,10 @@ const ( PTP_STRICT_FLAGS = 0x8 PTP_SYS_OFFSET_EXTENDED = 0xc4c03d09 PTP_SYS_OFFSET_EXTENDED2 = 0xc4c03d12 + PTP_SYS_OFFSET_EXTENDED_CYCLES = 0xc4c03d16 PTP_SYS_OFFSET_PRECISE = 0xc0403d08 PTP_SYS_OFFSET_PRECISE2 = 0xc0403d11 + PTP_SYS_OFFSET_PRECISE_CYCLES = 0xc0403d15 PTRACE_ATTACH = 0x10 PTRACE_CONT = 0x7 PTRACE_DETACH = 0x11 @@ -3330,8 +3385,9 @@ const ( RWF_DSYNC = 0x2 RWF_HIPRI = 0x1 RWF_NOAPPEND = 0x20 + RWF_NOSIGNAL = 0x100 RWF_NOWAIT = 0x8 - RWF_SUPPORTED = 0xff + RWF_SUPPORTED = 0x1ff RWF_SYNC = 0x4 RWF_WRITE_LIFE_NOT_SET = 0x0 SCHED_BATCH = 0x3 @@ -3714,7 +3770,7 @@ const ( TASKSTATS_GENL_NAME = "TASKSTATS" TASKSTATS_GENL_VERSION = 0x1 TASKSTATS_TYPE_MAX = 0x6 - TASKSTATS_VERSION = 0x10 + TASKSTATS_VERSION = 0x11 TCIFLUSH = 0x0 TCIOFF = 0x2 TCIOFLUSH = 0x2 @@ -4052,6 +4108,7 @@ const ( XDP_FLAGS_REPLACE = 0x10 XDP_FLAGS_SKB_MODE = 0x2 XDP_FLAGS_UPDATE_IF_NOEXIST = 0x1 + XDP_MAX_TX_SKB_BUDGET = 0x9 XDP_MMAP_OFFSETS = 0x1 XDP_OPTIONS = 0x8 XDP_OPTIONS_ZEROCOPY = 0x1 diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_386.go b/vendor/golang.org/x/sys/unix/zerrors_linux_386.go index 97a61fc5b8..c0a8ea1de0 100644 --- a/vendor/golang.org/x/sys/unix/zerrors_linux_386.go +++ b/vendor/golang.org/x/sys/unix/zerrors_linux_386.go @@ -159,6 +159,7 @@ const ( NFDBITS = 0x20 NLDLY = 0x100 NOFLSH = 0x80 + NS_GET_ID = 0x8008b70d NS_GET_MNTNS_ID = 0x8008b705 NS_GET_NSTYPE = 0xb703 NS_GET_OWNER_UID = 0xb704 @@ -305,6 +306,7 @@ const ( RTC_WKALM_SET = 0x4028700f SCM_DEVMEM_DMABUF = 0x4f SCM_DEVMEM_LINEAR = 0x4e + SCM_INQ = 0x54 SCM_TIMESTAMPING = 0x25 SCM_TIMESTAMPING_OPT_STATS = 0x36 SCM_TIMESTAMPING_PKTINFO = 0x3a @@ -352,6 +354,7 @@ const ( SO_ERROR = 0x4 SO_INCOMING_CPU = 0x31 SO_INCOMING_NAPI_ID = 0x38 + SO_INQ = 0x54 SO_KEEPALIVE = 0x9 SO_LINGER = 0xd SO_LOCK_FILTER = 0x2c @@ -596,6 +599,8 @@ const ( EDESTADDRREQ = syscall.Errno(0x59) EDOTDOT = syscall.Errno(0x49) EDQUOT = syscall.Errno(0x7a) + EFSBADCRC = syscall.Errno(0x4a) + EFSCORRUPTED = syscall.Errno(0x75) EHOSTDOWN = syscall.Errno(0x70) EHOSTUNREACH = syscall.Errno(0x71) EHWPOISON = syscall.Errno(0x85) @@ -819,7 +824,7 @@ var errorList = [...]struct { {114, "EALREADY", "operation already in progress"}, {115, "EINPROGRESS", "operation now in progress"}, {116, "ESTALE", "stale file handle"}, - {117, "EUCLEAN", "structure needs cleaning"}, + {117, "EFSCORRUPTED", "structure needs cleaning"}, {118, "ENOTNAM", "not a XENIX named type file"}, {119, "ENAVAIL", "no XENIX semaphores available"}, {120, "EISNAM", "is a named type file"}, diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go index a0d6d498c4..ff927c8301 100644 --- a/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go +++ b/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go @@ -159,6 +159,7 @@ const ( NFDBITS = 0x40 NLDLY = 0x100 NOFLSH = 0x80 + NS_GET_ID = 0x8008b70d NS_GET_MNTNS_ID = 0x8008b705 NS_GET_NSTYPE = 0xb703 NS_GET_OWNER_UID = 0xb704 @@ -306,6 +307,7 @@ const ( RTC_WKALM_SET = 0x4028700f SCM_DEVMEM_DMABUF = 0x4f SCM_DEVMEM_LINEAR = 0x4e + SCM_INQ = 0x54 SCM_TIMESTAMPING = 0x25 SCM_TIMESTAMPING_OPT_STATS = 0x36 SCM_TIMESTAMPING_PKTINFO = 0x3a @@ -353,6 +355,7 @@ const ( SO_ERROR = 0x4 SO_INCOMING_CPU = 0x31 SO_INCOMING_NAPI_ID = 0x38 + SO_INQ = 0x54 SO_KEEPALIVE = 0x9 SO_LINGER = 0xd SO_LOCK_FILTER = 0x2c @@ -596,6 +599,8 @@ const ( EDESTADDRREQ = syscall.Errno(0x59) EDOTDOT = syscall.Errno(0x49) EDQUOT = syscall.Errno(0x7a) + EFSBADCRC = syscall.Errno(0x4a) + EFSCORRUPTED = syscall.Errno(0x75) EHOSTDOWN = syscall.Errno(0x70) EHOSTUNREACH = syscall.Errno(0x71) EHWPOISON = syscall.Errno(0x85) @@ -819,7 +824,7 @@ var errorList = [...]struct { {114, "EALREADY", "operation already in progress"}, {115, "EINPROGRESS", "operation now in progress"}, {116, "ESTALE", "stale file handle"}, - {117, "EUCLEAN", "structure needs cleaning"}, + {117, "EFSCORRUPTED", "structure needs cleaning"}, {118, "ENOTNAM", "not a XENIX named type file"}, {119, "ENAVAIL", "no XENIX semaphores available"}, {120, "EISNAM", "is a named type file"}, diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go b/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go index dd9c903f9a..55294eda5b 100644 --- a/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go +++ b/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go @@ -156,6 +156,7 @@ const ( NFDBITS = 0x20 NLDLY = 0x100 NOFLSH = 0x80 + NS_GET_ID = 0x8008b70d NS_GET_MNTNS_ID = 0x8008b705 NS_GET_NSTYPE = 0xb703 NS_GET_OWNER_UID = 0xb704 @@ -311,6 +312,7 @@ const ( RTC_WKALM_SET = 0x4028700f SCM_DEVMEM_DMABUF = 0x4f SCM_DEVMEM_LINEAR = 0x4e + SCM_INQ = 0x54 SCM_TIMESTAMPING = 0x25 SCM_TIMESTAMPING_OPT_STATS = 0x36 SCM_TIMESTAMPING_PKTINFO = 0x3a @@ -358,6 +360,7 @@ const ( SO_ERROR = 0x4 SO_INCOMING_CPU = 0x31 SO_INCOMING_NAPI_ID = 0x38 + SO_INQ = 0x54 SO_KEEPALIVE = 0x9 SO_LINGER = 0xd SO_LOCK_FILTER = 0x2c @@ -601,6 +604,8 @@ const ( EDESTADDRREQ = syscall.Errno(0x59) EDOTDOT = syscall.Errno(0x49) EDQUOT = syscall.Errno(0x7a) + EFSBADCRC = syscall.Errno(0x4a) + EFSCORRUPTED = syscall.Errno(0x75) EHOSTDOWN = syscall.Errno(0x70) EHOSTUNREACH = syscall.Errno(0x71) EHWPOISON = syscall.Errno(0x85) @@ -824,7 +829,7 @@ var errorList = [...]struct { {114, "EALREADY", "operation already in progress"}, {115, "EINPROGRESS", "operation now in progress"}, {116, "ESTALE", "stale file handle"}, - {117, "EUCLEAN", "structure needs cleaning"}, + {117, "EFSCORRUPTED", "structure needs cleaning"}, {118, "ENOTNAM", "not a XENIX named type file"}, {119, "ENAVAIL", "no XENIX semaphores available"}, {120, "EISNAM", "is a named type file"}, diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go index 384c61ca3a..5dac54c35c 100644 --- a/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go +++ b/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go @@ -161,6 +161,7 @@ const ( NFDBITS = 0x40 NLDLY = 0x100 NOFLSH = 0x80 + NS_GET_ID = 0x8008b70d NS_GET_MNTNS_ID = 0x8008b705 NS_GET_NSTYPE = 0xb703 NS_GET_OWNER_UID = 0xb704 @@ -304,6 +305,7 @@ const ( RTC_WKALM_SET = 0x4028700f SCM_DEVMEM_DMABUF = 0x4f SCM_DEVMEM_LINEAR = 0x4e + SCM_INQ = 0x54 SCM_TIMESTAMPING = 0x25 SCM_TIMESTAMPING_OPT_STATS = 0x36 SCM_TIMESTAMPING_PKTINFO = 0x3a @@ -351,6 +353,7 @@ const ( SO_ERROR = 0x4 SO_INCOMING_CPU = 0x31 SO_INCOMING_NAPI_ID = 0x38 + SO_INQ = 0x54 SO_KEEPALIVE = 0x9 SO_LINGER = 0xd SO_LOCK_FILTER = 0x2c @@ -598,6 +601,8 @@ const ( EDESTADDRREQ = syscall.Errno(0x59) EDOTDOT = syscall.Errno(0x49) EDQUOT = syscall.Errno(0x7a) + EFSBADCRC = syscall.Errno(0x4a) + EFSCORRUPTED = syscall.Errno(0x75) EHOSTDOWN = syscall.Errno(0x70) EHOSTUNREACH = syscall.Errno(0x71) EHWPOISON = syscall.Errno(0x85) @@ -821,7 +826,7 @@ var errorList = [...]struct { {114, "EALREADY", "operation already in progress"}, {115, "EINPROGRESS", "operation now in progress"}, {116, "ESTALE", "stale file handle"}, - {117, "EUCLEAN", "structure needs cleaning"}, + {117, "EFSCORRUPTED", "structure needs cleaning"}, {118, "ENOTNAM", "not a XENIX named type file"}, {119, "ENAVAIL", "no XENIX semaphores available"}, {120, "EISNAM", "is a named type file"}, diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go index 6384c9831f..46ac1fcb22 100644 --- a/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go +++ b/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go @@ -160,6 +160,7 @@ const ( NFDBITS = 0x40 NLDLY = 0x100 NOFLSH = 0x80 + NS_GET_ID = 0x8008b70d NS_GET_MNTNS_ID = 0x8008b705 NS_GET_NSTYPE = 0xb703 NS_GET_OWNER_UID = 0xb704 @@ -298,6 +299,7 @@ const ( RTC_WKALM_SET = 0x4028700f SCM_DEVMEM_DMABUF = 0x4f SCM_DEVMEM_LINEAR = 0x4e + SCM_INQ = 0x54 SCM_TIMESTAMPING = 0x25 SCM_TIMESTAMPING_OPT_STATS = 0x36 SCM_TIMESTAMPING_PKTINFO = 0x3a @@ -345,6 +347,7 @@ const ( SO_ERROR = 0x4 SO_INCOMING_CPU = 0x31 SO_INCOMING_NAPI_ID = 0x38 + SO_INQ = 0x54 SO_KEEPALIVE = 0x9 SO_LINGER = 0xd SO_LOCK_FILTER = 0x2c @@ -588,6 +591,8 @@ const ( EDESTADDRREQ = syscall.Errno(0x59) EDOTDOT = syscall.Errno(0x49) EDQUOT = syscall.Errno(0x7a) + EFSBADCRC = syscall.Errno(0x4a) + EFSCORRUPTED = syscall.Errno(0x75) EHOSTDOWN = syscall.Errno(0x70) EHOSTUNREACH = syscall.Errno(0x71) EHWPOISON = syscall.Errno(0x85) @@ -811,7 +816,7 @@ var errorList = [...]struct { {114, "EALREADY", "operation already in progress"}, {115, "EINPROGRESS", "operation now in progress"}, {116, "ESTALE", "stale file handle"}, - {117, "EUCLEAN", "structure needs cleaning"}, + {117, "EFSCORRUPTED", "structure needs cleaning"}, {118, "ENOTNAM", "not a XENIX named type file"}, {119, "ENAVAIL", "no XENIX semaphores available"}, {120, "EISNAM", "is a named type file"}, diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go b/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go index 553c1c6f15..b55483e8a9 100644 --- a/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go +++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go @@ -156,6 +156,7 @@ const ( NFDBITS = 0x20 NLDLY = 0x100 NOFLSH = 0x80 + NS_GET_ID = 0x4008b70d NS_GET_MNTNS_ID = 0x4008b705 NS_GET_NSTYPE = 0x2000b703 NS_GET_OWNER_UID = 0x2000b704 @@ -304,6 +305,7 @@ const ( RTC_WKALM_SET = 0x8028700f SCM_DEVMEM_DMABUF = 0x4f SCM_DEVMEM_LINEAR = 0x4e + SCM_INQ = 0x54 SCM_TIMESTAMPING = 0x25 SCM_TIMESTAMPING_OPT_STATS = 0x36 SCM_TIMESTAMPING_PKTINFO = 0x3a @@ -351,6 +353,7 @@ const ( SO_ERROR = 0x1007 SO_INCOMING_CPU = 0x31 SO_INCOMING_NAPI_ID = 0x38 + SO_INQ = 0x54 SO_KEEPALIVE = 0x8 SO_LINGER = 0x80 SO_LOCK_FILTER = 0x2c @@ -597,6 +600,8 @@ const ( EDESTADDRREQ = syscall.Errno(0x60) EDOTDOT = syscall.Errno(0x49) EDQUOT = syscall.Errno(0x46d) + EFSBADCRC = syscall.Errno(0x4d) + EFSCORRUPTED = syscall.Errno(0x87) EHOSTDOWN = syscall.Errno(0x93) EHOSTUNREACH = syscall.Errno(0x94) EHWPOISON = syscall.Errno(0xa8) @@ -814,7 +819,7 @@ var errorList = [...]struct { {132, "ENOBUFS", "no buffer space available"}, {133, "EISCONN", "transport endpoint is already connected"}, {134, "ENOTCONN", "transport endpoint is not connected"}, - {135, "EUCLEAN", "structure needs cleaning"}, + {135, "EFSCORRUPTED", "structure needs cleaning"}, {137, "ENOTNAM", "not a XENIX named type file"}, {138, "ENAVAIL", "no XENIX semaphores available"}, {139, "EISNAM", "is a named type file"}, diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go index b3339f2099..71890c98a4 100644 --- a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go +++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go @@ -156,6 +156,7 @@ const ( NFDBITS = 0x40 NLDLY = 0x100 NOFLSH = 0x80 + NS_GET_ID = 0x4008b70d NS_GET_MNTNS_ID = 0x4008b705 NS_GET_NSTYPE = 0x2000b703 NS_GET_OWNER_UID = 0x2000b704 @@ -304,6 +305,7 @@ const ( RTC_WKALM_SET = 0x8028700f SCM_DEVMEM_DMABUF = 0x4f SCM_DEVMEM_LINEAR = 0x4e + SCM_INQ = 0x54 SCM_TIMESTAMPING = 0x25 SCM_TIMESTAMPING_OPT_STATS = 0x36 SCM_TIMESTAMPING_PKTINFO = 0x3a @@ -351,6 +353,7 @@ const ( SO_ERROR = 0x1007 SO_INCOMING_CPU = 0x31 SO_INCOMING_NAPI_ID = 0x38 + SO_INQ = 0x54 SO_KEEPALIVE = 0x8 SO_LINGER = 0x80 SO_LOCK_FILTER = 0x2c @@ -597,6 +600,8 @@ const ( EDESTADDRREQ = syscall.Errno(0x60) EDOTDOT = syscall.Errno(0x49) EDQUOT = syscall.Errno(0x46d) + EFSBADCRC = syscall.Errno(0x4d) + EFSCORRUPTED = syscall.Errno(0x87) EHOSTDOWN = syscall.Errno(0x93) EHOSTUNREACH = syscall.Errno(0x94) EHWPOISON = syscall.Errno(0xa8) @@ -814,7 +819,7 @@ var errorList = [...]struct { {132, "ENOBUFS", "no buffer space available"}, {133, "EISCONN", "transport endpoint is already connected"}, {134, "ENOTCONN", "transport endpoint is not connected"}, - {135, "EUCLEAN", "structure needs cleaning"}, + {135, "EFSCORRUPTED", "structure needs cleaning"}, {137, "ENOTNAM", "not a XENIX named type file"}, {138, "ENAVAIL", "no XENIX semaphores available"}, {139, "EISNAM", "is a named type file"}, diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go index 177091d2bc..a78b6cc14b 100644 --- a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go +++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go @@ -156,6 +156,7 @@ const ( NFDBITS = 0x40 NLDLY = 0x100 NOFLSH = 0x80 + NS_GET_ID = 0x4008b70d NS_GET_MNTNS_ID = 0x4008b705 NS_GET_NSTYPE = 0x2000b703 NS_GET_OWNER_UID = 0x2000b704 @@ -304,6 +305,7 @@ const ( RTC_WKALM_SET = 0x8028700f SCM_DEVMEM_DMABUF = 0x4f SCM_DEVMEM_LINEAR = 0x4e + SCM_INQ = 0x54 SCM_TIMESTAMPING = 0x25 SCM_TIMESTAMPING_OPT_STATS = 0x36 SCM_TIMESTAMPING_PKTINFO = 0x3a @@ -351,6 +353,7 @@ const ( SO_ERROR = 0x1007 SO_INCOMING_CPU = 0x31 SO_INCOMING_NAPI_ID = 0x38 + SO_INQ = 0x54 SO_KEEPALIVE = 0x8 SO_LINGER = 0x80 SO_LOCK_FILTER = 0x2c @@ -597,6 +600,8 @@ const ( EDESTADDRREQ = syscall.Errno(0x60) EDOTDOT = syscall.Errno(0x49) EDQUOT = syscall.Errno(0x46d) + EFSBADCRC = syscall.Errno(0x4d) + EFSCORRUPTED = syscall.Errno(0x87) EHOSTDOWN = syscall.Errno(0x93) EHOSTUNREACH = syscall.Errno(0x94) EHWPOISON = syscall.Errno(0xa8) @@ -814,7 +819,7 @@ var errorList = [...]struct { {132, "ENOBUFS", "no buffer space available"}, {133, "EISCONN", "transport endpoint is already connected"}, {134, "ENOTCONN", "transport endpoint is not connected"}, - {135, "EUCLEAN", "structure needs cleaning"}, + {135, "EFSCORRUPTED", "structure needs cleaning"}, {137, "ENOTNAM", "not a XENIX named type file"}, {138, "ENAVAIL", "no XENIX semaphores available"}, {139, "EISNAM", "is a named type file"}, diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go b/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go index c5abf156d0..d0e38ca739 100644 --- a/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go +++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go @@ -156,6 +156,7 @@ const ( NFDBITS = 0x20 NLDLY = 0x100 NOFLSH = 0x80 + NS_GET_ID = 0x4008b70d NS_GET_MNTNS_ID = 0x4008b705 NS_GET_NSTYPE = 0x2000b703 NS_GET_OWNER_UID = 0x2000b704 @@ -304,6 +305,7 @@ const ( RTC_WKALM_SET = 0x8028700f SCM_DEVMEM_DMABUF = 0x4f SCM_DEVMEM_LINEAR = 0x4e + SCM_INQ = 0x54 SCM_TIMESTAMPING = 0x25 SCM_TIMESTAMPING_OPT_STATS = 0x36 SCM_TIMESTAMPING_PKTINFO = 0x3a @@ -351,6 +353,7 @@ const ( SO_ERROR = 0x1007 SO_INCOMING_CPU = 0x31 SO_INCOMING_NAPI_ID = 0x38 + SO_INQ = 0x54 SO_KEEPALIVE = 0x8 SO_LINGER = 0x80 SO_LOCK_FILTER = 0x2c @@ -597,6 +600,8 @@ const ( EDESTADDRREQ = syscall.Errno(0x60) EDOTDOT = syscall.Errno(0x49) EDQUOT = syscall.Errno(0x46d) + EFSBADCRC = syscall.Errno(0x4d) + EFSCORRUPTED = syscall.Errno(0x87) EHOSTDOWN = syscall.Errno(0x93) EHOSTUNREACH = syscall.Errno(0x94) EHWPOISON = syscall.Errno(0xa8) @@ -814,7 +819,7 @@ var errorList = [...]struct { {132, "ENOBUFS", "no buffer space available"}, {133, "EISCONN", "transport endpoint is already connected"}, {134, "ENOTCONN", "transport endpoint is not connected"}, - {135, "EUCLEAN", "structure needs cleaning"}, + {135, "EFSCORRUPTED", "structure needs cleaning"}, {137, "ENOTNAM", "not a XENIX named type file"}, {138, "ENAVAIL", "no XENIX semaphores available"}, {139, "EISNAM", "is a named type file"}, diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go index f1f3fadf57..c883e14c77 100644 --- a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go +++ b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go @@ -158,6 +158,7 @@ const ( NL3 = 0x300 NLDLY = 0x300 NOFLSH = 0x80000000 + NS_GET_ID = 0x4008b70d NS_GET_MNTNS_ID = 0x4008b705 NS_GET_NSTYPE = 0x2000b703 NS_GET_OWNER_UID = 0x2000b704 @@ -359,6 +360,7 @@ const ( RTC_WKALM_SET = 0x8028700f SCM_DEVMEM_DMABUF = 0x4f SCM_DEVMEM_LINEAR = 0x4e + SCM_INQ = 0x54 SCM_TIMESTAMPING = 0x25 SCM_TIMESTAMPING_OPT_STATS = 0x36 SCM_TIMESTAMPING_PKTINFO = 0x3a @@ -406,6 +408,7 @@ const ( SO_ERROR = 0x4 SO_INCOMING_CPU = 0x31 SO_INCOMING_NAPI_ID = 0x38 + SO_INQ = 0x54 SO_KEEPALIVE = 0x9 SO_LINGER = 0xd SO_LOCK_FILTER = 0x2c @@ -653,6 +656,8 @@ const ( EDESTADDRREQ = syscall.Errno(0x59) EDOTDOT = syscall.Errno(0x49) EDQUOT = syscall.Errno(0x7a) + EFSBADCRC = syscall.Errno(0x4a) + EFSCORRUPTED = syscall.Errno(0x75) EHOSTDOWN = syscall.Errno(0x70) EHOSTUNREACH = syscall.Errno(0x71) EHWPOISON = syscall.Errno(0x85) @@ -877,7 +882,7 @@ var errorList = [...]struct { {114, "EALREADY", "operation already in progress"}, {115, "EINPROGRESS", "operation now in progress"}, {116, "ESTALE", "stale file handle"}, - {117, "EUCLEAN", "structure needs cleaning"}, + {117, "EFSCORRUPTED", "structure needs cleaning"}, {118, "ENOTNAM", "not a XENIX named type file"}, {119, "ENAVAIL", "no XENIX semaphores available"}, {120, "EISNAM", "is a named type file"}, diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go index 203ad9c54a..1834273d44 100644 --- a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go +++ b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go @@ -158,6 +158,7 @@ const ( NL3 = 0x300 NLDLY = 0x300 NOFLSH = 0x80000000 + NS_GET_ID = 0x4008b70d NS_GET_MNTNS_ID = 0x4008b705 NS_GET_NSTYPE = 0x2000b703 NS_GET_OWNER_UID = 0x2000b704 @@ -363,6 +364,7 @@ const ( RTC_WKALM_SET = 0x8028700f SCM_DEVMEM_DMABUF = 0x4f SCM_DEVMEM_LINEAR = 0x4e + SCM_INQ = 0x54 SCM_TIMESTAMPING = 0x25 SCM_TIMESTAMPING_OPT_STATS = 0x36 SCM_TIMESTAMPING_PKTINFO = 0x3a @@ -410,6 +412,7 @@ const ( SO_ERROR = 0x4 SO_INCOMING_CPU = 0x31 SO_INCOMING_NAPI_ID = 0x38 + SO_INQ = 0x54 SO_KEEPALIVE = 0x9 SO_LINGER = 0xd SO_LOCK_FILTER = 0x2c @@ -657,6 +660,8 @@ const ( EDESTADDRREQ = syscall.Errno(0x59) EDOTDOT = syscall.Errno(0x49) EDQUOT = syscall.Errno(0x7a) + EFSBADCRC = syscall.Errno(0x4a) + EFSCORRUPTED = syscall.Errno(0x75) EHOSTDOWN = syscall.Errno(0x70) EHOSTUNREACH = syscall.Errno(0x71) EHWPOISON = syscall.Errno(0x85) @@ -881,7 +886,7 @@ var errorList = [...]struct { {114, "EALREADY", "operation already in progress"}, {115, "EINPROGRESS", "operation now in progress"}, {116, "ESTALE", "stale file handle"}, - {117, "EUCLEAN", "structure needs cleaning"}, + {117, "EFSCORRUPTED", "structure needs cleaning"}, {118, "ENOTNAM", "not a XENIX named type file"}, {119, "ENAVAIL", "no XENIX semaphores available"}, {120, "EISNAM", "is a named type file"}, diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go index 4b9abcb21a..39945dd9ae 100644 --- a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go +++ b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go @@ -158,6 +158,7 @@ const ( NL3 = 0x300 NLDLY = 0x300 NOFLSH = 0x80000000 + NS_GET_ID = 0x4008b70d NS_GET_MNTNS_ID = 0x4008b705 NS_GET_NSTYPE = 0x2000b703 NS_GET_OWNER_UID = 0x2000b704 @@ -363,6 +364,7 @@ const ( RTC_WKALM_SET = 0x8028700f SCM_DEVMEM_DMABUF = 0x4f SCM_DEVMEM_LINEAR = 0x4e + SCM_INQ = 0x54 SCM_TIMESTAMPING = 0x25 SCM_TIMESTAMPING_OPT_STATS = 0x36 SCM_TIMESTAMPING_PKTINFO = 0x3a @@ -410,6 +412,7 @@ const ( SO_ERROR = 0x4 SO_INCOMING_CPU = 0x31 SO_INCOMING_NAPI_ID = 0x38 + SO_INQ = 0x54 SO_KEEPALIVE = 0x9 SO_LINGER = 0xd SO_LOCK_FILTER = 0x2c @@ -657,6 +660,8 @@ const ( EDESTADDRREQ = syscall.Errno(0x59) EDOTDOT = syscall.Errno(0x49) EDQUOT = syscall.Errno(0x7a) + EFSBADCRC = syscall.Errno(0x4a) + EFSCORRUPTED = syscall.Errno(0x75) EHOSTDOWN = syscall.Errno(0x70) EHOSTUNREACH = syscall.Errno(0x71) EHWPOISON = syscall.Errno(0x85) @@ -881,7 +886,7 @@ var errorList = [...]struct { {114, "EALREADY", "operation already in progress"}, {115, "EINPROGRESS", "operation now in progress"}, {116, "ESTALE", "stale file handle"}, - {117, "EUCLEAN", "structure needs cleaning"}, + {117, "EFSCORRUPTED", "structure needs cleaning"}, {118, "ENOTNAM", "not a XENIX named type file"}, {119, "ENAVAIL", "no XENIX semaphores available"}, {120, "EISNAM", "is a named type file"}, diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go index f87983037d..bc0f372416 100644 --- a/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go +++ b/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go @@ -11,553 +11,569 @@ package unix import "syscall" const ( - B1000000 = 0x1008 - B115200 = 0x1002 - B1152000 = 0x1009 - B1500000 = 0x100a - B2000000 = 0x100b - B230400 = 0x1003 - B2500000 = 0x100c - B3000000 = 0x100d - B3500000 = 0x100e - B4000000 = 0x100f - B460800 = 0x1004 - B500000 = 0x1005 - B57600 = 0x1001 - B576000 = 0x1006 - B921600 = 0x1007 - BLKALIGNOFF = 0x127a - BLKBSZGET = 0x80081270 - BLKBSZSET = 0x40081271 - BLKDISCARD = 0x1277 - BLKDISCARDZEROES = 0x127c - BLKFLSBUF = 0x1261 - BLKFRAGET = 0x1265 - BLKFRASET = 0x1264 - BLKGETDISKSEQ = 0x80081280 - BLKGETSIZE = 0x1260 - BLKGETSIZE64 = 0x80081272 - BLKIOMIN = 0x1278 - BLKIOOPT = 0x1279 - BLKPBSZGET = 0x127b - BLKRAGET = 0x1263 - BLKRASET = 0x1262 - BLKROGET = 0x125e - BLKROSET = 0x125d - BLKROTATIONAL = 0x127e - BLKRRPART = 0x125f - BLKSECDISCARD = 0x127d - BLKSECTGET = 0x1267 - BLKSECTSET = 0x1266 - BLKSSZGET = 0x1268 - BLKZEROOUT = 0x127f - BOTHER = 0x1000 - BS1 = 0x2000 - BSDLY = 0x2000 - CBAUD = 0x100f - CBAUDEX = 0x1000 - CIBAUD = 0x100f0000 - CLOCAL = 0x800 - CR1 = 0x200 - CR2 = 0x400 - CR3 = 0x600 - CRDLY = 0x600 - CREAD = 0x80 - CS6 = 0x10 - CS7 = 0x20 - CS8 = 0x30 - CSIZE = 0x30 - CSTOPB = 0x40 - DM_MPATH_PROBE_PATHS = 0xfd12 - ECCGETLAYOUT = 0x81484d11 - ECCGETSTATS = 0x80104d12 - ECHOCTL = 0x200 - ECHOE = 0x10 - ECHOK = 0x20 - ECHOKE = 0x800 - ECHONL = 0x40 - ECHOPRT = 0x400 - EFD_CLOEXEC = 0x80000 - EFD_NONBLOCK = 0x800 - EPIOCGPARAMS = 0x80088a02 - EPIOCSPARAMS = 0x40088a01 - EPOLL_CLOEXEC = 0x80000 - EXTPROC = 0x10000 - FF1 = 0x8000 - FFDLY = 0x8000 - FICLONE = 0x40049409 - FICLONERANGE = 0x4020940d - FLUSHO = 0x1000 - FS_IOC_ENABLE_VERITY = 0x40806685 - FS_IOC_GETFLAGS = 0x80086601 - FS_IOC_GET_ENCRYPTION_NONCE = 0x8010661b - FS_IOC_GET_ENCRYPTION_POLICY = 0x400c6615 - FS_IOC_GET_ENCRYPTION_PWSALT = 0x40106614 - FS_IOC_SETFLAGS = 0x40086602 - FS_IOC_SET_ENCRYPTION_POLICY = 0x800c6613 - F_GETLK = 0x5 - F_GETLK64 = 0x5 - F_GETOWN = 0x9 - F_RDLCK = 0x0 - F_SETLK = 0x6 - F_SETLK64 = 0x6 - F_SETLKW = 0x7 - F_SETLKW64 = 0x7 - F_SETOWN = 0x8 - F_UNLCK = 0x2 - F_WRLCK = 0x1 - HIDIOCGRAWINFO = 0x80084803 - HIDIOCGRDESC = 0x90044802 - HIDIOCGRDESCSIZE = 0x80044801 - HIDIOCREVOKE = 0x4004480d - HUPCL = 0x400 - ICANON = 0x2 - IEXTEN = 0x8000 - IN_CLOEXEC = 0x80000 - IN_NONBLOCK = 0x800 - IOCTL_MEI_NOTIFY_GET = 0x80044803 - IOCTL_MEI_NOTIFY_SET = 0x40044802 - IOCTL_VM_SOCKETS_GET_LOCAL_CID = 0x7b9 - IPV6_FLOWINFO_MASK = 0xffffff0f - IPV6_FLOWLABEL_MASK = 0xffff0f00 - ISIG = 0x1 - IUCLC = 0x200 - IXOFF = 0x1000 - IXON = 0x400 - MAP_ANON = 0x20 - MAP_ANONYMOUS = 0x20 - MAP_DENYWRITE = 0x800 - MAP_EXECUTABLE = 0x1000 - MAP_GROWSDOWN = 0x100 - MAP_HUGETLB = 0x40000 - MAP_LOCKED = 0x2000 - MAP_NONBLOCK = 0x10000 - MAP_NORESERVE = 0x4000 - MAP_POPULATE = 0x8000 - MAP_STACK = 0x20000 - MAP_SYNC = 0x80000 - MCL_CURRENT = 0x1 - MCL_FUTURE = 0x2 - MCL_ONFAULT = 0x4 - MEMERASE = 0x40084d02 - MEMERASE64 = 0x40104d14 - MEMGETBADBLOCK = 0x40084d0b - MEMGETINFO = 0x80204d01 - MEMGETOOBSEL = 0x80c84d0a - MEMGETREGIONCOUNT = 0x80044d07 - MEMISLOCKED = 0x80084d17 - MEMLOCK = 0x40084d05 - MEMREAD = 0xc0404d1a - MEMREADOOB = 0xc0104d04 - MEMSETBADBLOCK = 0x40084d0c - MEMUNLOCK = 0x40084d06 - MEMWRITEOOB = 0xc0104d03 - MTDFILEMODE = 0x4d13 - NFDBITS = 0x40 - NLDLY = 0x100 - NOFLSH = 0x80 - NS_GET_MNTNS_ID = 0x8008b705 - NS_GET_NSTYPE = 0xb703 - NS_GET_OWNER_UID = 0xb704 - NS_GET_PARENT = 0xb702 - NS_GET_PID_FROM_PIDNS = 0x8004b706 - NS_GET_PID_IN_PIDNS = 0x8004b708 - NS_GET_TGID_FROM_PIDNS = 0x8004b707 - NS_GET_TGID_IN_PIDNS = 0x8004b709 - NS_GET_USERNS = 0xb701 - OLCUC = 0x2 - ONLCR = 0x4 - OTPERASE = 0x400c4d19 - OTPGETREGIONCOUNT = 0x40044d0e - OTPGETREGIONINFO = 0x400c4d0f - OTPLOCK = 0x800c4d10 - OTPSELECT = 0x80044d0d - O_APPEND = 0x400 - O_ASYNC = 0x2000 - O_CLOEXEC = 0x80000 - O_CREAT = 0x40 - O_DIRECT = 0x4000 - O_DIRECTORY = 0x10000 - O_DSYNC = 0x1000 - O_EXCL = 0x80 - O_FSYNC = 0x101000 - O_LARGEFILE = 0x0 - O_NDELAY = 0x800 - O_NOATIME = 0x40000 - O_NOCTTY = 0x100 - O_NOFOLLOW = 0x20000 - O_NONBLOCK = 0x800 - O_PATH = 0x200000 - O_RSYNC = 0x101000 - O_SYNC = 0x101000 - O_TMPFILE = 0x410000 - O_TRUNC = 0x200 - PARENB = 0x100 - PARODD = 0x200 - PENDIN = 0x4000 - PERF_EVENT_IOC_DISABLE = 0x2401 - PERF_EVENT_IOC_ENABLE = 0x2400 - PERF_EVENT_IOC_ID = 0x80082407 - PERF_EVENT_IOC_MODIFY_ATTRIBUTES = 0x4008240b - PERF_EVENT_IOC_PAUSE_OUTPUT = 0x40042409 - PERF_EVENT_IOC_PERIOD = 0x40082404 - PERF_EVENT_IOC_QUERY_BPF = 0xc008240a - PERF_EVENT_IOC_REFRESH = 0x2402 - PERF_EVENT_IOC_RESET = 0x2403 - PERF_EVENT_IOC_SET_BPF = 0x40042408 - PERF_EVENT_IOC_SET_FILTER = 0x40082406 - PERF_EVENT_IOC_SET_OUTPUT = 0x2405 - PPPIOCATTACH = 0x4004743d - PPPIOCATTCHAN = 0x40047438 - PPPIOCBRIDGECHAN = 0x40047435 - PPPIOCCONNECT = 0x4004743a - PPPIOCDETACH = 0x4004743c - PPPIOCDISCONN = 0x7439 - PPPIOCGASYNCMAP = 0x80047458 - PPPIOCGCHAN = 0x80047437 - PPPIOCGDEBUG = 0x80047441 - PPPIOCGFLAGS = 0x8004745a - PPPIOCGIDLE = 0x8010743f - PPPIOCGIDLE32 = 0x8008743f - PPPIOCGIDLE64 = 0x8010743f - PPPIOCGL2TPSTATS = 0x80487436 - PPPIOCGMRU = 0x80047453 - PPPIOCGRASYNCMAP = 0x80047455 - PPPIOCGUNIT = 0x80047456 - PPPIOCGXASYNCMAP = 0x80207450 - PPPIOCSACTIVE = 0x40107446 - PPPIOCSASYNCMAP = 0x40047457 - PPPIOCSCOMPRESS = 0x4010744d - PPPIOCSDEBUG = 0x40047440 - PPPIOCSFLAGS = 0x40047459 - PPPIOCSMAXCID = 0x40047451 - PPPIOCSMRRU = 0x4004743b - PPPIOCSMRU = 0x40047452 - PPPIOCSNPMODE = 0x4008744b - PPPIOCSPASS = 0x40107447 - PPPIOCSRASYNCMAP = 0x40047454 - PPPIOCSXASYNCMAP = 0x4020744f - PPPIOCUNBRIDGECHAN = 0x7434 - PPPIOCXFERUNIT = 0x744e - PR_SET_PTRACER_ANY = 0xffffffffffffffff - PTP_CLOCK_GETCAPS = 0x80503d01 - PTP_CLOCK_GETCAPS2 = 0x80503d0a - PTP_ENABLE_PPS = 0x40043d04 - PTP_ENABLE_PPS2 = 0x40043d0d - PTP_EXTTS_REQUEST = 0x40103d02 - PTP_EXTTS_REQUEST2 = 0x40103d0b - PTP_MASK_CLEAR_ALL = 0x3d13 - PTP_MASK_EN_SINGLE = 0x40043d14 - PTP_PEROUT_REQUEST = 0x40383d03 - PTP_PEROUT_REQUEST2 = 0x40383d0c - PTP_PIN_SETFUNC = 0x40603d07 - PTP_PIN_SETFUNC2 = 0x40603d10 - PTP_SYS_OFFSET = 0x43403d05 - PTP_SYS_OFFSET2 = 0x43403d0e - PTRACE_GETFDPIC = 0x21 - PTRACE_GETFDPIC_EXEC = 0x0 - PTRACE_GETFDPIC_INTERP = 0x1 - RLIMIT_AS = 0x9 - RLIMIT_MEMLOCK = 0x8 - RLIMIT_NOFILE = 0x7 - RLIMIT_NPROC = 0x6 - RLIMIT_RSS = 0x5 - RNDADDENTROPY = 0x40085203 - RNDADDTOENTCNT = 0x40045201 - RNDCLEARPOOL = 0x5206 - RNDGETENTCNT = 0x80045200 - RNDGETPOOL = 0x80085202 - RNDRESEEDCRNG = 0x5207 - RNDZAPENTCNT = 0x5204 - RTC_AIE_OFF = 0x7002 - RTC_AIE_ON = 0x7001 - RTC_ALM_READ = 0x80247008 - RTC_ALM_SET = 0x40247007 - RTC_EPOCH_READ = 0x8008700d - RTC_EPOCH_SET = 0x4008700e - RTC_IRQP_READ = 0x8008700b - RTC_IRQP_SET = 0x4008700c - RTC_PARAM_GET = 0x40187013 - RTC_PARAM_SET = 0x40187014 - RTC_PIE_OFF = 0x7006 - RTC_PIE_ON = 0x7005 - RTC_PLL_GET = 0x80207011 - RTC_PLL_SET = 0x40207012 - RTC_RD_TIME = 0x80247009 - RTC_SET_TIME = 0x4024700a - RTC_UIE_OFF = 0x7004 - RTC_UIE_ON = 0x7003 - RTC_VL_CLR = 0x7014 - RTC_VL_READ = 0x80047013 - RTC_WIE_OFF = 0x7010 - RTC_WIE_ON = 0x700f - RTC_WKALM_RD = 0x80287010 - RTC_WKALM_SET = 0x4028700f - SCM_DEVMEM_DMABUF = 0x4f - SCM_DEVMEM_LINEAR = 0x4e - SCM_TIMESTAMPING = 0x25 - SCM_TIMESTAMPING_OPT_STATS = 0x36 - SCM_TIMESTAMPING_PKTINFO = 0x3a - SCM_TIMESTAMPNS = 0x23 - SCM_TS_OPT_ID = 0x51 - SCM_TXTIME = 0x3d - SCM_WIFI_STATUS = 0x29 - SECCOMP_IOCTL_NOTIF_ADDFD = 0x40182103 - SECCOMP_IOCTL_NOTIF_ID_VALID = 0x40082102 - SECCOMP_IOCTL_NOTIF_SET_FLAGS = 0x40082104 - SFD_CLOEXEC = 0x80000 - SFD_NONBLOCK = 0x800 - SIOCATMARK = 0x8905 - SIOCGPGRP = 0x8904 - SIOCGSTAMPNS_NEW = 0x80108907 - SIOCGSTAMP_NEW = 0x80108906 - SIOCINQ = 0x541b - SIOCOUTQ = 0x5411 - SIOCSPGRP = 0x8902 - SOCK_CLOEXEC = 0x80000 - SOCK_DGRAM = 0x2 - SOCK_NONBLOCK = 0x800 - SOCK_STREAM = 0x1 - SOL_SOCKET = 0x1 - SO_ACCEPTCONN = 0x1e - SO_ATTACH_BPF = 0x32 - SO_ATTACH_REUSEPORT_CBPF = 0x33 - SO_ATTACH_REUSEPORT_EBPF = 0x34 - SO_BINDTODEVICE = 0x19 - SO_BINDTOIFINDEX = 0x3e - SO_BPF_EXTENSIONS = 0x30 - SO_BROADCAST = 0x6 - SO_BSDCOMPAT = 0xe - SO_BUF_LOCK = 0x48 - SO_BUSY_POLL = 0x2e - SO_BUSY_POLL_BUDGET = 0x46 - SO_CNX_ADVICE = 0x35 - SO_COOKIE = 0x39 - SO_DETACH_REUSEPORT_BPF = 0x44 - SO_DEVMEM_DMABUF = 0x4f - SO_DEVMEM_DONTNEED = 0x50 - SO_DEVMEM_LINEAR = 0x4e - SO_DOMAIN = 0x27 - SO_DONTROUTE = 0x5 - SO_ERROR = 0x4 - SO_INCOMING_CPU = 0x31 - SO_INCOMING_NAPI_ID = 0x38 - SO_KEEPALIVE = 0x9 - SO_LINGER = 0xd - SO_LOCK_FILTER = 0x2c - SO_MARK = 0x24 - SO_MAX_PACING_RATE = 0x2f - SO_MEMINFO = 0x37 - SO_NETNS_COOKIE = 0x47 - SO_NOFCS = 0x2b - SO_OOBINLINE = 0xa - SO_PASSCRED = 0x10 - SO_PASSPIDFD = 0x4c - SO_PASSRIGHTS = 0x53 - SO_PASSSEC = 0x22 - SO_PEEK_OFF = 0x2a - SO_PEERCRED = 0x11 - SO_PEERGROUPS = 0x3b - SO_PEERPIDFD = 0x4d - SO_PEERSEC = 0x1f - SO_PREFER_BUSY_POLL = 0x45 - SO_PROTOCOL = 0x26 - SO_RCVBUF = 0x8 - SO_RCVBUFFORCE = 0x21 - SO_RCVLOWAT = 0x12 - SO_RCVMARK = 0x4b - SO_RCVPRIORITY = 0x52 - SO_RCVTIMEO = 0x14 - SO_RCVTIMEO_NEW = 0x42 - SO_RCVTIMEO_OLD = 0x14 - SO_RESERVE_MEM = 0x49 - SO_REUSEADDR = 0x2 - SO_REUSEPORT = 0xf - SO_RXQ_OVFL = 0x28 - SO_SECURITY_AUTHENTICATION = 0x16 - SO_SECURITY_ENCRYPTION_NETWORK = 0x18 - SO_SECURITY_ENCRYPTION_TRANSPORT = 0x17 - SO_SELECT_ERR_QUEUE = 0x2d - SO_SNDBUF = 0x7 - SO_SNDBUFFORCE = 0x20 - SO_SNDLOWAT = 0x13 - SO_SNDTIMEO = 0x15 - SO_SNDTIMEO_NEW = 0x43 - SO_SNDTIMEO_OLD = 0x15 - SO_TIMESTAMPING = 0x25 - SO_TIMESTAMPING_NEW = 0x41 - SO_TIMESTAMPING_OLD = 0x25 - SO_TIMESTAMPNS = 0x23 - SO_TIMESTAMPNS_NEW = 0x40 - SO_TIMESTAMPNS_OLD = 0x23 - SO_TIMESTAMP_NEW = 0x3f - SO_TXREHASH = 0x4a - SO_TXTIME = 0x3d - SO_TYPE = 0x3 - SO_WIFI_STATUS = 0x29 - SO_ZEROCOPY = 0x3c - TAB1 = 0x800 - TAB2 = 0x1000 - TAB3 = 0x1800 - TABDLY = 0x1800 - TCFLSH = 0x540b - TCGETA = 0x5405 - TCGETS = 0x5401 - TCGETS2 = 0x802c542a - TCGETX = 0x5432 - TCSAFLUSH = 0x2 - TCSBRK = 0x5409 - TCSBRKP = 0x5425 - TCSETA = 0x5406 - TCSETAF = 0x5408 - TCSETAW = 0x5407 - TCSETS = 0x5402 - TCSETS2 = 0x402c542b - TCSETSF = 0x5404 - TCSETSF2 = 0x402c542d - TCSETSW = 0x5403 - TCSETSW2 = 0x402c542c - TCSETX = 0x5433 - TCSETXF = 0x5434 - TCSETXW = 0x5435 - TCXONC = 0x540a - TFD_CLOEXEC = 0x80000 - TFD_NONBLOCK = 0x800 - TIOCCBRK = 0x5428 - TIOCCONS = 0x541d - TIOCEXCL = 0x540c - TIOCGDEV = 0x80045432 - TIOCGETD = 0x5424 - TIOCGEXCL = 0x80045440 - TIOCGICOUNT = 0x545d - TIOCGISO7816 = 0x80285442 - TIOCGLCKTRMIOS = 0x5456 - TIOCGPGRP = 0x540f - TIOCGPKT = 0x80045438 - TIOCGPTLCK = 0x80045439 - TIOCGPTN = 0x80045430 - TIOCGPTPEER = 0x5441 - TIOCGRS485 = 0x542e - TIOCGSERIAL = 0x541e - TIOCGSID = 0x5429 - TIOCGSOFTCAR = 0x5419 - TIOCGWINSZ = 0x5413 - TIOCINQ = 0x541b - TIOCLINUX = 0x541c - TIOCMBIC = 0x5417 - TIOCMBIS = 0x5416 - TIOCMGET = 0x5415 - TIOCMIWAIT = 0x545c - TIOCMSET = 0x5418 - TIOCM_CAR = 0x40 - TIOCM_CD = 0x40 - TIOCM_CTS = 0x20 - TIOCM_DSR = 0x100 - TIOCM_RI = 0x80 - TIOCM_RNG = 0x80 - TIOCM_SR = 0x10 - TIOCM_ST = 0x8 - TIOCNOTTY = 0x5422 - TIOCNXCL = 0x540d - TIOCOUTQ = 0x5411 - TIOCPKT = 0x5420 - TIOCSBRK = 0x5427 - TIOCSCTTY = 0x540e - TIOCSERCONFIG = 0x5453 - TIOCSERGETLSR = 0x5459 - TIOCSERGETMULTI = 0x545a - TIOCSERGSTRUCT = 0x5458 - TIOCSERGWILD = 0x5454 - TIOCSERSETMULTI = 0x545b - TIOCSERSWILD = 0x5455 - TIOCSER_TEMT = 0x1 - TIOCSETD = 0x5423 - TIOCSIG = 0x40045436 - TIOCSISO7816 = 0xc0285443 - TIOCSLCKTRMIOS = 0x5457 - TIOCSPGRP = 0x5410 - TIOCSPTLCK = 0x40045431 - TIOCSRS485 = 0x542f - TIOCSSERIAL = 0x541f - TIOCSSOFTCAR = 0x541a - TIOCSTI = 0x5412 - TIOCSWINSZ = 0x5414 - TIOCVHANGUP = 0x5437 - TOSTOP = 0x100 - TUNATTACHFILTER = 0x401054d5 - TUNDETACHFILTER = 0x401054d6 - TUNGETDEVNETNS = 0x54e3 - TUNGETFEATURES = 0x800454cf - TUNGETFILTER = 0x801054db - TUNGETIFF = 0x800454d2 - TUNGETSNDBUF = 0x800454d3 - TUNGETVNETBE = 0x800454df - TUNGETVNETHDRSZ = 0x800454d7 - TUNGETVNETLE = 0x800454dd - TUNSETCARRIER = 0x400454e2 - TUNSETDEBUG = 0x400454c9 - TUNSETFILTEREBPF = 0x800454e1 - TUNSETGROUP = 0x400454ce - TUNSETIFF = 0x400454ca - TUNSETIFINDEX = 0x400454da - TUNSETLINK = 0x400454cd - TUNSETNOCSUM = 0x400454c8 - TUNSETOFFLOAD = 0x400454d0 - TUNSETOWNER = 0x400454cc - TUNSETPERSIST = 0x400454cb - TUNSETQUEUE = 0x400454d9 - TUNSETSNDBUF = 0x400454d4 - TUNSETSTEERINGEBPF = 0x800454e0 - TUNSETTXFILTER = 0x400454d1 - TUNSETVNETBE = 0x400454de - TUNSETVNETHDRSZ = 0x400454d8 - TUNSETVNETLE = 0x400454dc - UBI_IOCATT = 0x40186f40 - UBI_IOCDET = 0x40046f41 - UBI_IOCEBCH = 0x40044f02 - UBI_IOCEBER = 0x40044f01 - UBI_IOCEBISMAP = 0x80044f05 - UBI_IOCEBMAP = 0x40084f03 - UBI_IOCEBUNMAP = 0x40044f04 - UBI_IOCMKVOL = 0x40986f00 - UBI_IOCRMVOL = 0x40046f01 - UBI_IOCRNVOL = 0x51106f03 - UBI_IOCRPEB = 0x40046f04 - UBI_IOCRSVOL = 0x400c6f02 - UBI_IOCSETVOLPROP = 0x40104f06 - UBI_IOCSPEB = 0x40046f05 - UBI_IOCVOLCRBLK = 0x40804f07 - UBI_IOCVOLRMBLK = 0x4f08 - UBI_IOCVOLUP = 0x40084f00 - VDISCARD = 0xd - VEOF = 0x4 - VEOL = 0xb - VEOL2 = 0x10 - VMIN = 0x6 - VREPRINT = 0xc - VSTART = 0x8 - VSTOP = 0x9 - VSUSP = 0xa - VSWTC = 0x7 - VT1 = 0x4000 - VTDLY = 0x4000 - VTIME = 0x5 - VWERASE = 0xe - WDIOC_GETBOOTSTATUS = 0x80045702 - WDIOC_GETPRETIMEOUT = 0x80045709 - WDIOC_GETSTATUS = 0x80045701 - WDIOC_GETSUPPORT = 0x80285700 - WDIOC_GETTEMP = 0x80045703 - WDIOC_GETTIMELEFT = 0x8004570a - WDIOC_GETTIMEOUT = 0x80045707 - WDIOC_KEEPALIVE = 0x80045705 - WDIOC_SETOPTIONS = 0x80045704 - WORDSIZE = 0x40 - XCASE = 0x4 - XTABS = 0x1800 - _HIDIOCGRAWNAME = 0x80804804 - _HIDIOCGRAWPHYS = 0x80404805 - _HIDIOCGRAWUNIQ = 0x80404808 + B1000000 = 0x1008 + B115200 = 0x1002 + B1152000 = 0x1009 + B1500000 = 0x100a + B2000000 = 0x100b + B230400 = 0x1003 + B2500000 = 0x100c + B3000000 = 0x100d + B3500000 = 0x100e + B4000000 = 0x100f + B460800 = 0x1004 + B500000 = 0x1005 + B57600 = 0x1001 + B576000 = 0x1006 + B921600 = 0x1007 + BLKALIGNOFF = 0x127a + BLKBSZGET = 0x80081270 + BLKBSZSET = 0x40081271 + BLKDISCARD = 0x1277 + BLKDISCARDZEROES = 0x127c + BLKFLSBUF = 0x1261 + BLKFRAGET = 0x1265 + BLKFRASET = 0x1264 + BLKGETDISKSEQ = 0x80081280 + BLKGETSIZE = 0x1260 + BLKGETSIZE64 = 0x80081272 + BLKIOMIN = 0x1278 + BLKIOOPT = 0x1279 + BLKPBSZGET = 0x127b + BLKRAGET = 0x1263 + BLKRASET = 0x1262 + BLKROGET = 0x125e + BLKROSET = 0x125d + BLKROTATIONAL = 0x127e + BLKRRPART = 0x125f + BLKSECDISCARD = 0x127d + BLKSECTGET = 0x1267 + BLKSECTSET = 0x1266 + BLKSSZGET = 0x1268 + BLKZEROOUT = 0x127f + BOTHER = 0x1000 + BS1 = 0x2000 + BSDLY = 0x2000 + CBAUD = 0x100f + CBAUDEX = 0x1000 + CIBAUD = 0x100f0000 + CLOCAL = 0x800 + CR1 = 0x200 + CR2 = 0x400 + CR3 = 0x600 + CRDLY = 0x600 + CREAD = 0x80 + CS6 = 0x10 + CS7 = 0x20 + CS8 = 0x30 + CSIZE = 0x30 + CSTOPB = 0x40 + DM_MPATH_PROBE_PATHS = 0xfd12 + ECCGETLAYOUT = 0x81484d11 + ECCGETSTATS = 0x80104d12 + ECHOCTL = 0x200 + ECHOE = 0x10 + ECHOK = 0x20 + ECHOKE = 0x800 + ECHONL = 0x40 + ECHOPRT = 0x400 + EFD_CLOEXEC = 0x80000 + EFD_NONBLOCK = 0x800 + EPIOCGPARAMS = 0x80088a02 + EPIOCSPARAMS = 0x40088a01 + EPOLL_CLOEXEC = 0x80000 + EXTPROC = 0x10000 + FF1 = 0x8000 + FFDLY = 0x8000 + FICLONE = 0x40049409 + FICLONERANGE = 0x4020940d + FLUSHO = 0x1000 + FS_IOC_ENABLE_VERITY = 0x40806685 + FS_IOC_GETFLAGS = 0x80086601 + FS_IOC_GET_ENCRYPTION_NONCE = 0x8010661b + FS_IOC_GET_ENCRYPTION_POLICY = 0x400c6615 + FS_IOC_GET_ENCRYPTION_PWSALT = 0x40106614 + FS_IOC_SETFLAGS = 0x40086602 + FS_IOC_SET_ENCRYPTION_POLICY = 0x800c6613 + F_GETLK = 0x5 + F_GETLK64 = 0x5 + F_GETOWN = 0x9 + F_RDLCK = 0x0 + F_SETLK = 0x6 + F_SETLK64 = 0x6 + F_SETLKW = 0x7 + F_SETLKW64 = 0x7 + F_SETOWN = 0x8 + F_UNLCK = 0x2 + F_WRLCK = 0x1 + HIDIOCGRAWINFO = 0x80084803 + HIDIOCGRDESC = 0x90044802 + HIDIOCGRDESCSIZE = 0x80044801 + HIDIOCREVOKE = 0x4004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x8000 + IN_CLOEXEC = 0x80000 + IN_NONBLOCK = 0x800 + IOCTL_MEI_NOTIFY_GET = 0x80044803 + IOCTL_MEI_NOTIFY_SET = 0x40044802 + IOCTL_VM_SOCKETS_GET_LOCAL_CID = 0x7b9 + IPV6_FLOWINFO_MASK = 0xffffff0f + IPV6_FLOWLABEL_MASK = 0xffff0f00 + ISIG = 0x1 + IUCLC = 0x200 + IXOFF = 0x1000 + IXON = 0x400 + MAP_ANON = 0x20 + MAP_ANONYMOUS = 0x20 + MAP_DENYWRITE = 0x800 + MAP_EXECUTABLE = 0x1000 + MAP_GROWSDOWN = 0x100 + MAP_HUGETLB = 0x40000 + MAP_LOCKED = 0x2000 + MAP_NONBLOCK = 0x10000 + MAP_NORESERVE = 0x4000 + MAP_POPULATE = 0x8000 + MAP_STACK = 0x20000 + MAP_SYNC = 0x80000 + MCL_CURRENT = 0x1 + MCL_FUTURE = 0x2 + MCL_ONFAULT = 0x4 + MEMERASE = 0x40084d02 + MEMERASE64 = 0x40104d14 + MEMGETBADBLOCK = 0x40084d0b + MEMGETINFO = 0x80204d01 + MEMGETOOBSEL = 0x80c84d0a + MEMGETREGIONCOUNT = 0x80044d07 + MEMISLOCKED = 0x80084d17 + MEMLOCK = 0x40084d05 + MEMREAD = 0xc0404d1a + MEMREADOOB = 0xc0104d04 + MEMSETBADBLOCK = 0x40084d0c + MEMUNLOCK = 0x40084d06 + MEMWRITEOOB = 0xc0104d03 + MTDFILEMODE = 0x4d13 + NFDBITS = 0x40 + NLDLY = 0x100 + NOFLSH = 0x80 + NS_GET_ID = 0x8008b70d + NS_GET_MNTNS_ID = 0x8008b705 + NS_GET_NSTYPE = 0xb703 + NS_GET_OWNER_UID = 0xb704 + NS_GET_PARENT = 0xb702 + NS_GET_PID_FROM_PIDNS = 0x8004b706 + NS_GET_PID_IN_PIDNS = 0x8004b708 + NS_GET_TGID_FROM_PIDNS = 0x8004b707 + NS_GET_TGID_IN_PIDNS = 0x8004b709 + NS_GET_USERNS = 0xb701 + OLCUC = 0x2 + ONLCR = 0x4 + OTPERASE = 0x400c4d19 + OTPGETREGIONCOUNT = 0x40044d0e + OTPGETREGIONINFO = 0x400c4d0f + OTPLOCK = 0x800c4d10 + OTPSELECT = 0x80044d0d + O_APPEND = 0x400 + O_ASYNC = 0x2000 + O_CLOEXEC = 0x80000 + O_CREAT = 0x40 + O_DIRECT = 0x4000 + O_DIRECTORY = 0x10000 + O_DSYNC = 0x1000 + O_EXCL = 0x80 + O_FSYNC = 0x101000 + O_LARGEFILE = 0x0 + O_NDELAY = 0x800 + O_NOATIME = 0x40000 + O_NOCTTY = 0x100 + O_NOFOLLOW = 0x20000 + O_NONBLOCK = 0x800 + O_PATH = 0x200000 + O_RSYNC = 0x101000 + O_SYNC = 0x101000 + O_TMPFILE = 0x410000 + O_TRUNC = 0x200 + PARENB = 0x100 + PARODD = 0x200 + PENDIN = 0x4000 + PERF_EVENT_IOC_DISABLE = 0x2401 + PERF_EVENT_IOC_ENABLE = 0x2400 + PERF_EVENT_IOC_ID = 0x80082407 + PERF_EVENT_IOC_MODIFY_ATTRIBUTES = 0x4008240b + PERF_EVENT_IOC_PAUSE_OUTPUT = 0x40042409 + PERF_EVENT_IOC_PERIOD = 0x40082404 + PERF_EVENT_IOC_QUERY_BPF = 0xc008240a + PERF_EVENT_IOC_REFRESH = 0x2402 + PERF_EVENT_IOC_RESET = 0x2403 + PERF_EVENT_IOC_SET_BPF = 0x40042408 + PERF_EVENT_IOC_SET_FILTER = 0x40082406 + PERF_EVENT_IOC_SET_OUTPUT = 0x2405 + PPPIOCATTACH = 0x4004743d + PPPIOCATTCHAN = 0x40047438 + PPPIOCBRIDGECHAN = 0x40047435 + PPPIOCCONNECT = 0x4004743a + PPPIOCDETACH = 0x4004743c + PPPIOCDISCONN = 0x7439 + PPPIOCGASYNCMAP = 0x80047458 + PPPIOCGCHAN = 0x80047437 + PPPIOCGDEBUG = 0x80047441 + PPPIOCGFLAGS = 0x8004745a + PPPIOCGIDLE = 0x8010743f + PPPIOCGIDLE32 = 0x8008743f + PPPIOCGIDLE64 = 0x8010743f + PPPIOCGL2TPSTATS = 0x80487436 + PPPIOCGMRU = 0x80047453 + PPPIOCGRASYNCMAP = 0x80047455 + PPPIOCGUNIT = 0x80047456 + PPPIOCGXASYNCMAP = 0x80207450 + PPPIOCSACTIVE = 0x40107446 + PPPIOCSASYNCMAP = 0x40047457 + PPPIOCSCOMPRESS = 0x4010744d + PPPIOCSDEBUG = 0x40047440 + PPPIOCSFLAGS = 0x40047459 + PPPIOCSMAXCID = 0x40047451 + PPPIOCSMRRU = 0x4004743b + PPPIOCSMRU = 0x40047452 + PPPIOCSNPMODE = 0x4008744b + PPPIOCSPASS = 0x40107447 + PPPIOCSRASYNCMAP = 0x40047454 + PPPIOCSXASYNCMAP = 0x4020744f + PPPIOCUNBRIDGECHAN = 0x7434 + PPPIOCXFERUNIT = 0x744e + PR_SET_PTRACER_ANY = 0xffffffffffffffff + PTP_CLOCK_GETCAPS = 0x80503d01 + PTP_CLOCK_GETCAPS2 = 0x80503d0a + PTP_ENABLE_PPS = 0x40043d04 + PTP_ENABLE_PPS2 = 0x40043d0d + PTP_EXTTS_REQUEST = 0x40103d02 + PTP_EXTTS_REQUEST2 = 0x40103d0b + PTP_MASK_CLEAR_ALL = 0x3d13 + PTP_MASK_EN_SINGLE = 0x40043d14 + PTP_PEROUT_REQUEST = 0x40383d03 + PTP_PEROUT_REQUEST2 = 0x40383d0c + PTP_PIN_SETFUNC = 0x40603d07 + PTP_PIN_SETFUNC2 = 0x40603d10 + PTP_SYS_OFFSET = 0x43403d05 + PTP_SYS_OFFSET2 = 0x43403d0e + PTRACE_CFI_BRANCH_EXPECTED_LANDING_PAD_BIT = 0x2 + PTRACE_CFI_BRANCH_EXPECTED_LANDING_PAD_STATE = 0x4 + PTRACE_CFI_BRANCH_LANDING_PAD_EN_BIT = 0x0 + PTRACE_CFI_BRANCH_LANDING_PAD_EN_STATE = 0x1 + PTRACE_CFI_BRANCH_LANDING_PAD_LOCK_BIT = 0x1 + PTRACE_CFI_BRANCH_LANDING_PAD_LOCK_STATE = 0x2 + PTRACE_CFI_SHADOW_STACK_EN_BIT = 0x3 + PTRACE_CFI_SHADOW_STACK_EN_STATE = 0x8 + PTRACE_CFI_SHADOW_STACK_LOCK_BIT = 0x4 + PTRACE_CFI_SHADOW_STACK_LOCK_STATE = 0x10 + PTRACE_CFI_SHADOW_STACK_PTR_BIT = 0x5 + PTRACE_CFI_SHADOW_STACK_PTR_STATE = 0x20 + PTRACE_CFI_STATE_INVALID_MASK = 0xffffffffffffffc0 + PTRACE_GETFDPIC = 0x21 + PTRACE_GETFDPIC_EXEC = 0x0 + PTRACE_GETFDPIC_INTERP = 0x1 + RLIMIT_AS = 0x9 + RLIMIT_MEMLOCK = 0x8 + RLIMIT_NOFILE = 0x7 + RLIMIT_NPROC = 0x6 + RLIMIT_RSS = 0x5 + RNDADDENTROPY = 0x40085203 + RNDADDTOENTCNT = 0x40045201 + RNDCLEARPOOL = 0x5206 + RNDGETENTCNT = 0x80045200 + RNDGETPOOL = 0x80085202 + RNDRESEEDCRNG = 0x5207 + RNDZAPENTCNT = 0x5204 + RTC_AIE_OFF = 0x7002 + RTC_AIE_ON = 0x7001 + RTC_ALM_READ = 0x80247008 + RTC_ALM_SET = 0x40247007 + RTC_EPOCH_READ = 0x8008700d + RTC_EPOCH_SET = 0x4008700e + RTC_IRQP_READ = 0x8008700b + RTC_IRQP_SET = 0x4008700c + RTC_PARAM_GET = 0x40187013 + RTC_PARAM_SET = 0x40187014 + RTC_PIE_OFF = 0x7006 + RTC_PIE_ON = 0x7005 + RTC_PLL_GET = 0x80207011 + RTC_PLL_SET = 0x40207012 + RTC_RD_TIME = 0x80247009 + RTC_SET_TIME = 0x4024700a + RTC_UIE_OFF = 0x7004 + RTC_UIE_ON = 0x7003 + RTC_VL_CLR = 0x7014 + RTC_VL_READ = 0x80047013 + RTC_WIE_OFF = 0x7010 + RTC_WIE_ON = 0x700f + RTC_WKALM_RD = 0x80287010 + RTC_WKALM_SET = 0x4028700f + SCM_DEVMEM_DMABUF = 0x4f + SCM_DEVMEM_LINEAR = 0x4e + SCM_INQ = 0x54 + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a + SCM_TIMESTAMPNS = 0x23 + SCM_TS_OPT_ID = 0x51 + SCM_TXTIME = 0x3d + SCM_WIFI_STATUS = 0x29 + SECCOMP_IOCTL_NOTIF_ADDFD = 0x40182103 + SECCOMP_IOCTL_NOTIF_ID_VALID = 0x40082102 + SECCOMP_IOCTL_NOTIF_SET_FLAGS = 0x40082104 + SFD_CLOEXEC = 0x80000 + SFD_NONBLOCK = 0x800 + SIOCATMARK = 0x8905 + SIOCGPGRP = 0x8904 + SIOCGSTAMPNS_NEW = 0x80108907 + SIOCGSTAMP_NEW = 0x80108906 + SIOCINQ = 0x541b + SIOCOUTQ = 0x5411 + SIOCSPGRP = 0x8902 + SOCK_CLOEXEC = 0x80000 + SOCK_DGRAM = 0x2 + SOCK_NONBLOCK = 0x800 + SOCK_STREAM = 0x1 + SOL_SOCKET = 0x1 + SO_ACCEPTCONN = 0x1e + SO_ATTACH_BPF = 0x32 + SO_ATTACH_REUSEPORT_CBPF = 0x33 + SO_ATTACH_REUSEPORT_EBPF = 0x34 + SO_BINDTODEVICE = 0x19 + SO_BINDTOIFINDEX = 0x3e + SO_BPF_EXTENSIONS = 0x30 + SO_BROADCAST = 0x6 + SO_BSDCOMPAT = 0xe + SO_BUF_LOCK = 0x48 + SO_BUSY_POLL = 0x2e + SO_BUSY_POLL_BUDGET = 0x46 + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 + SO_DEVMEM_DMABUF = 0x4f + SO_DEVMEM_DONTNEED = 0x50 + SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x27 + SO_DONTROUTE = 0x5 + SO_ERROR = 0x4 + SO_INCOMING_CPU = 0x31 + SO_INCOMING_NAPI_ID = 0x38 + SO_INQ = 0x54 + SO_KEEPALIVE = 0x9 + SO_LINGER = 0xd + SO_LOCK_FILTER = 0x2c + SO_MARK = 0x24 + SO_MAX_PACING_RATE = 0x2f + SO_MEMINFO = 0x37 + SO_NETNS_COOKIE = 0x47 + SO_NOFCS = 0x2b + SO_OOBINLINE = 0xa + SO_PASSCRED = 0x10 + SO_PASSPIDFD = 0x4c + SO_PASSRIGHTS = 0x53 + SO_PASSSEC = 0x22 + SO_PEEK_OFF = 0x2a + SO_PEERCRED = 0x11 + SO_PEERGROUPS = 0x3b + SO_PEERPIDFD = 0x4d + SO_PEERSEC = 0x1f + SO_PREFER_BUSY_POLL = 0x45 + SO_PROTOCOL = 0x26 + SO_RCVBUF = 0x8 + SO_RCVBUFFORCE = 0x21 + SO_RCVLOWAT = 0x12 + SO_RCVMARK = 0x4b + SO_RCVPRIORITY = 0x52 + SO_RCVTIMEO = 0x14 + SO_RCVTIMEO_NEW = 0x42 + SO_RCVTIMEO_OLD = 0x14 + SO_RESERVE_MEM = 0x49 + SO_REUSEADDR = 0x2 + SO_REUSEPORT = 0xf + SO_RXQ_OVFL = 0x28 + SO_SECURITY_AUTHENTICATION = 0x16 + SO_SECURITY_ENCRYPTION_NETWORK = 0x18 + SO_SECURITY_ENCRYPTION_TRANSPORT = 0x17 + SO_SELECT_ERR_QUEUE = 0x2d + SO_SNDBUF = 0x7 + SO_SNDBUFFORCE = 0x20 + SO_SNDLOWAT = 0x13 + SO_SNDTIMEO = 0x15 + SO_SNDTIMEO_NEW = 0x43 + SO_SNDTIMEO_OLD = 0x15 + SO_TIMESTAMPING = 0x25 + SO_TIMESTAMPING_NEW = 0x41 + SO_TIMESTAMPING_OLD = 0x25 + SO_TIMESTAMPNS = 0x23 + SO_TIMESTAMPNS_NEW = 0x40 + SO_TIMESTAMPNS_OLD = 0x23 + SO_TIMESTAMP_NEW = 0x3f + SO_TXREHASH = 0x4a + SO_TXTIME = 0x3d + SO_TYPE = 0x3 + SO_WIFI_STATUS = 0x29 + SO_ZEROCOPY = 0x3c + TAB1 = 0x800 + TAB2 = 0x1000 + TAB3 = 0x1800 + TABDLY = 0x1800 + TCFLSH = 0x540b + TCGETA = 0x5405 + TCGETS = 0x5401 + TCGETS2 = 0x802c542a + TCGETX = 0x5432 + TCSAFLUSH = 0x2 + TCSBRK = 0x5409 + TCSBRKP = 0x5425 + TCSETA = 0x5406 + TCSETAF = 0x5408 + TCSETAW = 0x5407 + TCSETS = 0x5402 + TCSETS2 = 0x402c542b + TCSETSF = 0x5404 + TCSETSF2 = 0x402c542d + TCSETSW = 0x5403 + TCSETSW2 = 0x402c542c + TCSETX = 0x5433 + TCSETXF = 0x5434 + TCSETXW = 0x5435 + TCXONC = 0x540a + TFD_CLOEXEC = 0x80000 + TFD_NONBLOCK = 0x800 + TIOCCBRK = 0x5428 + TIOCCONS = 0x541d + TIOCEXCL = 0x540c + TIOCGDEV = 0x80045432 + TIOCGETD = 0x5424 + TIOCGEXCL = 0x80045440 + TIOCGICOUNT = 0x545d + TIOCGISO7816 = 0x80285442 + TIOCGLCKTRMIOS = 0x5456 + TIOCGPGRP = 0x540f + TIOCGPKT = 0x80045438 + TIOCGPTLCK = 0x80045439 + TIOCGPTN = 0x80045430 + TIOCGPTPEER = 0x5441 + TIOCGRS485 = 0x542e + TIOCGSERIAL = 0x541e + TIOCGSID = 0x5429 + TIOCGSOFTCAR = 0x5419 + TIOCGWINSZ = 0x5413 + TIOCINQ = 0x541b + TIOCLINUX = 0x541c + TIOCMBIC = 0x5417 + TIOCMBIS = 0x5416 + TIOCMGET = 0x5415 + TIOCMIWAIT = 0x545c + TIOCMSET = 0x5418 + TIOCM_CAR = 0x40 + TIOCM_CD = 0x40 + TIOCM_CTS = 0x20 + TIOCM_DSR = 0x100 + TIOCM_RI = 0x80 + TIOCM_RNG = 0x80 + TIOCM_SR = 0x10 + TIOCM_ST = 0x8 + TIOCNOTTY = 0x5422 + TIOCNXCL = 0x540d + TIOCOUTQ = 0x5411 + TIOCPKT = 0x5420 + TIOCSBRK = 0x5427 + TIOCSCTTY = 0x540e + TIOCSERCONFIG = 0x5453 + TIOCSERGETLSR = 0x5459 + TIOCSERGETMULTI = 0x545a + TIOCSERGSTRUCT = 0x5458 + TIOCSERGWILD = 0x5454 + TIOCSERSETMULTI = 0x545b + TIOCSERSWILD = 0x5455 + TIOCSER_TEMT = 0x1 + TIOCSETD = 0x5423 + TIOCSIG = 0x40045436 + TIOCSISO7816 = 0xc0285443 + TIOCSLCKTRMIOS = 0x5457 + TIOCSPGRP = 0x5410 + TIOCSPTLCK = 0x40045431 + TIOCSRS485 = 0x542f + TIOCSSERIAL = 0x541f + TIOCSSOFTCAR = 0x541a + TIOCSTI = 0x5412 + TIOCSWINSZ = 0x5414 + TIOCVHANGUP = 0x5437 + TOSTOP = 0x100 + TUNATTACHFILTER = 0x401054d5 + TUNDETACHFILTER = 0x401054d6 + TUNGETDEVNETNS = 0x54e3 + TUNGETFEATURES = 0x800454cf + TUNGETFILTER = 0x801054db + TUNGETIFF = 0x800454d2 + TUNGETSNDBUF = 0x800454d3 + TUNGETVNETBE = 0x800454df + TUNGETVNETHDRSZ = 0x800454d7 + TUNGETVNETLE = 0x800454dd + TUNSETCARRIER = 0x400454e2 + TUNSETDEBUG = 0x400454c9 + TUNSETFILTEREBPF = 0x800454e1 + TUNSETGROUP = 0x400454ce + TUNSETIFF = 0x400454ca + TUNSETIFINDEX = 0x400454da + TUNSETLINK = 0x400454cd + TUNSETNOCSUM = 0x400454c8 + TUNSETOFFLOAD = 0x400454d0 + TUNSETOWNER = 0x400454cc + TUNSETPERSIST = 0x400454cb + TUNSETQUEUE = 0x400454d9 + TUNSETSNDBUF = 0x400454d4 + TUNSETSTEERINGEBPF = 0x800454e0 + TUNSETTXFILTER = 0x400454d1 + TUNSETVNETBE = 0x400454de + TUNSETVNETHDRSZ = 0x400454d8 + TUNSETVNETLE = 0x400454dc + UBI_IOCATT = 0x40186f40 + UBI_IOCDET = 0x40046f41 + UBI_IOCEBCH = 0x40044f02 + UBI_IOCEBER = 0x40044f01 + UBI_IOCEBISMAP = 0x80044f05 + UBI_IOCEBMAP = 0x40084f03 + UBI_IOCEBUNMAP = 0x40044f04 + UBI_IOCMKVOL = 0x40986f00 + UBI_IOCRMVOL = 0x40046f01 + UBI_IOCRNVOL = 0x51106f03 + UBI_IOCRPEB = 0x40046f04 + UBI_IOCRSVOL = 0x400c6f02 + UBI_IOCSETVOLPROP = 0x40104f06 + UBI_IOCSPEB = 0x40046f05 + UBI_IOCVOLCRBLK = 0x40804f07 + UBI_IOCVOLRMBLK = 0x4f08 + UBI_IOCVOLUP = 0x40084f00 + VDISCARD = 0xd + VEOF = 0x4 + VEOL = 0xb + VEOL2 = 0x10 + VMIN = 0x6 + VREPRINT = 0xc + VSTART = 0x8 + VSTOP = 0x9 + VSUSP = 0xa + VSWTC = 0x7 + VT1 = 0x4000 + VTDLY = 0x4000 + VTIME = 0x5 + VWERASE = 0xe + WDIOC_GETBOOTSTATUS = 0x80045702 + WDIOC_GETPRETIMEOUT = 0x80045709 + WDIOC_GETSTATUS = 0x80045701 + WDIOC_GETSUPPORT = 0x80285700 + WDIOC_GETTEMP = 0x80045703 + WDIOC_GETTIMELEFT = 0x8004570a + WDIOC_GETTIMEOUT = 0x80045707 + WDIOC_KEEPALIVE = 0x80045705 + WDIOC_SETOPTIONS = 0x80045704 + WORDSIZE = 0x40 + XCASE = 0x4 + XTABS = 0x1800 + _HIDIOCGRAWNAME = 0x80804804 + _HIDIOCGRAWPHYS = 0x80404805 + _HIDIOCGRAWUNIQ = 0x80404808 ) // Errors @@ -585,6 +601,8 @@ const ( EDESTADDRREQ = syscall.Errno(0x59) EDOTDOT = syscall.Errno(0x49) EDQUOT = syscall.Errno(0x7a) + EFSBADCRC = syscall.Errno(0x4a) + EFSCORRUPTED = syscall.Errno(0x75) EHOSTDOWN = syscall.Errno(0x70) EHOSTUNREACH = syscall.Errno(0x71) EHWPOISON = syscall.Errno(0x85) @@ -808,7 +826,7 @@ var errorList = [...]struct { {114, "EALREADY", "operation already in progress"}, {115, "EINPROGRESS", "operation now in progress"}, {116, "ESTALE", "stale file handle"}, - {117, "EUCLEAN", "structure needs cleaning"}, + {117, "EFSCORRUPTED", "structure needs cleaning"}, {118, "ENOTNAM", "not a XENIX named type file"}, {119, "ENAVAIL", "no XENIX semaphores available"}, {120, "EISNAM", "is a named type file"}, diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go b/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go index 64347eb354..6e87bd6598 100644 --- a/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go +++ b/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go @@ -156,6 +156,7 @@ const ( NFDBITS = 0x40 NLDLY = 0x100 NOFLSH = 0x80 + NS_GET_ID = 0x8008b70d NS_GET_MNTNS_ID = 0x8008b705 NS_GET_NSTYPE = 0xb703 NS_GET_OWNER_UID = 0xb704 @@ -367,6 +368,7 @@ const ( RTC_WKALM_SET = 0x4028700f SCM_DEVMEM_DMABUF = 0x4f SCM_DEVMEM_LINEAR = 0x4e + SCM_INQ = 0x54 SCM_TIMESTAMPING = 0x25 SCM_TIMESTAMPING_OPT_STATS = 0x36 SCM_TIMESTAMPING_PKTINFO = 0x3a @@ -414,6 +416,7 @@ const ( SO_ERROR = 0x4 SO_INCOMING_CPU = 0x31 SO_INCOMING_NAPI_ID = 0x38 + SO_INQ = 0x54 SO_KEEPALIVE = 0x9 SO_LINGER = 0xd SO_LOCK_FILTER = 0x2c @@ -657,6 +660,8 @@ const ( EDESTADDRREQ = syscall.Errno(0x59) EDOTDOT = syscall.Errno(0x49) EDQUOT = syscall.Errno(0x7a) + EFSBADCRC = syscall.Errno(0x4a) + EFSCORRUPTED = syscall.Errno(0x75) EHOSTDOWN = syscall.Errno(0x70) EHOSTUNREACH = syscall.Errno(0x71) EHWPOISON = syscall.Errno(0x85) @@ -880,7 +885,7 @@ var errorList = [...]struct { {114, "EALREADY", "operation already in progress"}, {115, "EINPROGRESS", "operation now in progress"}, {116, "ESTALE", "stale file handle"}, - {117, "EUCLEAN", "structure needs cleaning"}, + {117, "EFSCORRUPTED", "structure needs cleaning"}, {118, "ENOTNAM", "not a XENIX named type file"}, {119, "ENAVAIL", "no XENIX semaphores available"}, {120, "EISNAM", "is a named type file"}, diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go index 7d71911718..7e2b2e8a66 100644 --- a/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go +++ b/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go @@ -161,6 +161,7 @@ const ( NFDBITS = 0x40 NLDLY = 0x100 NOFLSH = 0x80 + NS_GET_ID = 0x4008b70d NS_GET_MNTNS_ID = 0x4008b705 NS_GET_NSTYPE = 0x2000b703 NS_GET_OWNER_UID = 0x2000b704 @@ -358,6 +359,7 @@ const ( RTC_WKALM_SET = 0x8028700f SCM_DEVMEM_DMABUF = 0x58 SCM_DEVMEM_LINEAR = 0x57 + SCM_INQ = 0x5d SCM_TIMESTAMPING = 0x23 SCM_TIMESTAMPING_OPT_STATS = 0x38 SCM_TIMESTAMPING_PKTINFO = 0x3c @@ -453,6 +455,7 @@ const ( SO_ERROR = 0x1007 SO_INCOMING_CPU = 0x33 SO_INCOMING_NAPI_ID = 0x3a + SO_INQ = 0x5d SO_KEEPALIVE = 0x8 SO_LINGER = 0x80 SO_LOCK_FILTER = 0x28 @@ -694,6 +697,8 @@ const ( EDESTADDRREQ = syscall.Errno(0x27) EDOTDOT = syscall.Errno(0x58) EDQUOT = syscall.Errno(0x45) + EFSBADCRC = syscall.Errno(0x4c) + EFSCORRUPTED = syscall.Errno(0x75) EHOSTDOWN = syscall.Errno(0x40) EHOSTUNREACH = syscall.Errno(0x41) EHWPOISON = syscall.Errno(0x87) @@ -921,7 +926,7 @@ var errorList = [...]struct { {114, "ELIBACC", "can not access a needed shared library"}, {115, "ENOTUNIQ", "name not unique on network"}, {116, "ERESTART", "interrupted system call should be restarted"}, - {117, "EUCLEAN", "structure needs cleaning"}, + {117, "EFSCORRUPTED", "structure needs cleaning"}, {118, "ENOTNAM", "not a XENIX named type file"}, {119, "ENAVAIL", "no XENIX semaphores available"}, {120, "EISNAM", "is a named type file"}, diff --git a/vendor/golang.org/x/sys/unix/zsyscall_linux.go b/vendor/golang.org/x/sys/unix/zsyscall_linux.go index 886f5de5bc..80f40e4013 100644 --- a/vendor/golang.org/x/sys/unix/zsyscall_linux.go +++ b/vendor/golang.org/x/sys/unix/zsyscall_linux.go @@ -1785,7 +1785,7 @@ func writev(fd int, iovs []Iovec) (n int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func preadv(fd int, iovs []Iovec, offs_l uintptr, offs_h uintptr) (n int, err error) { +func preadvSyscall(fd int, iovs []Iovec, offs_l uintptr, offs_h uintptr) (n int, err error) { var _p0 unsafe.Pointer if len(iovs) > 0 { _p0 = unsafe.Pointer(&iovs[0]) @@ -1802,7 +1802,7 @@ func preadv(fd int, iovs []Iovec, offs_l uintptr, offs_h uintptr) (n int, err er // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func pwritev(fd int, iovs []Iovec, offs_l uintptr, offs_h uintptr) (n int, err error) { +func pwritevSyscall(fd int, iovs []Iovec, offs_l uintptr, offs_h uintptr) (n int, err error) { var _p0 unsafe.Pointer if len(iovs) > 0 { _p0 = unsafe.Pointer(&iovs[0]) @@ -1819,7 +1819,7 @@ func pwritev(fd int, iovs []Iovec, offs_l uintptr, offs_h uintptr) (n int, err e // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func preadv2(fd int, iovs []Iovec, offs_l uintptr, offs_h uintptr, flags int) (n int, err error) { +func preadv2Syscall(fd int, iovs []Iovec, offs_l uintptr, offs_h uintptr, flags int) (n int, err error) { var _p0 unsafe.Pointer if len(iovs) > 0 { _p0 = unsafe.Pointer(&iovs[0]) @@ -1836,7 +1836,7 @@ func preadv2(fd int, iovs []Iovec, offs_l uintptr, offs_h uintptr, flags int) (n // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func pwritev2(fd int, iovs []Iovec, offs_l uintptr, offs_h uintptr, flags int) (n int, err error) { +func pwritev2Syscall(fd int, iovs []Iovec, offs_l uintptr, offs_h uintptr, flags int) (n int, err error) { var _p0 unsafe.Pointer if len(iovs) > 0 { _p0 = unsafe.Pointer(&iovs[0]) diff --git a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_386.go b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_386.go index 1851df14e8..6487475f0d 100644 --- a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_386.go +++ b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_386.go @@ -1633,6 +1633,90 @@ var libc_pwrite_trampoline_addr uintptr // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT +func readv(fd int, iovecs []Iovec) (n int, err error) { + var _p0 unsafe.Pointer + if len(iovecs) > 0 { + _p0 = unsafe.Pointer(&iovecs[0]) + } else { + _p0 = unsafe.Pointer(&_zero) + } + r0, _, e1 := syscall_syscall(libc_readv_trampoline_addr, uintptr(fd), uintptr(_p0), uintptr(len(iovecs))) + n = int(r0) + if e1 != 0 { + err = errnoErr(e1) + } + return +} + +var libc_readv_trampoline_addr uintptr + +//go:cgo_import_dynamic libc_readv readv "libc.so" + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func writev(fd int, iovecs []Iovec) (n int, err error) { + var _p0 unsafe.Pointer + if len(iovecs) > 0 { + _p0 = unsafe.Pointer(&iovecs[0]) + } else { + _p0 = unsafe.Pointer(&_zero) + } + r0, _, e1 := syscall_syscall(libc_writev_trampoline_addr, uintptr(fd), uintptr(_p0), uintptr(len(iovecs))) + n = int(r0) + if e1 != 0 { + err = errnoErr(e1) + } + return +} + +var libc_writev_trampoline_addr uintptr + +//go:cgo_import_dynamic libc_writev writev "libc.so" + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func preadv(fd int, iovecs []Iovec, offset int64) (n int, err error) { + var _p0 unsafe.Pointer + if len(iovecs) > 0 { + _p0 = unsafe.Pointer(&iovecs[0]) + } else { + _p0 = unsafe.Pointer(&_zero) + } + r0, _, e1 := syscall_syscall6(libc_preadv_trampoline_addr, uintptr(fd), uintptr(_p0), uintptr(len(iovecs)), uintptr(offset), uintptr(offset>>32), 0) + n = int(r0) + if e1 != 0 { + err = errnoErr(e1) + } + return +} + +var libc_preadv_trampoline_addr uintptr + +//go:cgo_import_dynamic libc_preadv preadv "libc.so" + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func pwritev(fd int, iovecs []Iovec, offset int64) (n int, err error) { + var _p0 unsafe.Pointer + if len(iovecs) > 0 { + _p0 = unsafe.Pointer(&iovecs[0]) + } else { + _p0 = unsafe.Pointer(&_zero) + } + r0, _, e1 := syscall_syscall6(libc_pwritev_trampoline_addr, uintptr(fd), uintptr(_p0), uintptr(len(iovecs)), uintptr(offset), uintptr(offset>>32), 0) + n = int(r0) + if e1 != 0 { + err = errnoErr(e1) + } + return +} + +var libc_pwritev_trampoline_addr uintptr + +//go:cgo_import_dynamic libc_pwritev pwritev "libc.so" + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + func read(fd int, p []byte) (n int, err error) { var _p0 unsafe.Pointer if len(p) > 0 { diff --git a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_386.s b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_386.s index 0b43c69365..f10201dacb 100644 --- a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_386.s +++ b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_386.s @@ -498,6 +498,26 @@ TEXT libc_pwrite_trampoline<>(SB),NOSPLIT,$0-0 GLOBL ·libc_pwrite_trampoline_addr(SB), RODATA, $4 DATA ·libc_pwrite_trampoline_addr(SB)/4, $libc_pwrite_trampoline<>(SB) +TEXT libc_readv_trampoline<>(SB),NOSPLIT,$0-0 + JMP libc_readv(SB) +GLOBL ·libc_readv_trampoline_addr(SB), RODATA, $4 +DATA ·libc_readv_trampoline_addr(SB)/4, $libc_readv_trampoline<>(SB) + +TEXT libc_writev_trampoline<>(SB),NOSPLIT,$0-0 + JMP libc_writev(SB) +GLOBL ·libc_writev_trampoline_addr(SB), RODATA, $4 +DATA ·libc_writev_trampoline_addr(SB)/4, $libc_writev_trampoline<>(SB) + +TEXT libc_preadv_trampoline<>(SB),NOSPLIT,$0-0 + JMP libc_preadv(SB) +GLOBL ·libc_preadv_trampoline_addr(SB), RODATA, $4 +DATA ·libc_preadv_trampoline_addr(SB)/4, $libc_preadv_trampoline<>(SB) + +TEXT libc_pwritev_trampoline<>(SB),NOSPLIT,$0-0 + JMP libc_pwritev(SB) +GLOBL ·libc_pwritev_trampoline_addr(SB), RODATA, $4 +DATA ·libc_pwritev_trampoline_addr(SB)/4, $libc_pwritev_trampoline<>(SB) + TEXT libc_read_trampoline<>(SB),NOSPLIT,$0-0 JMP libc_read(SB) GLOBL ·libc_read_trampoline_addr(SB), RODATA, $4 diff --git a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_amd64.go b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_amd64.go index e1ec0dbe4e..50980475d5 100644 --- a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_amd64.go +++ b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_amd64.go @@ -1633,6 +1633,90 @@ var libc_pwrite_trampoline_addr uintptr // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT +func readv(fd int, iovecs []Iovec) (n int, err error) { + var _p0 unsafe.Pointer + if len(iovecs) > 0 { + _p0 = unsafe.Pointer(&iovecs[0]) + } else { + _p0 = unsafe.Pointer(&_zero) + } + r0, _, e1 := syscall_syscall(libc_readv_trampoline_addr, uintptr(fd), uintptr(_p0), uintptr(len(iovecs))) + n = int(r0) + if e1 != 0 { + err = errnoErr(e1) + } + return +} + +var libc_readv_trampoline_addr uintptr + +//go:cgo_import_dynamic libc_readv readv "libc.so" + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func writev(fd int, iovecs []Iovec) (n int, err error) { + var _p0 unsafe.Pointer + if len(iovecs) > 0 { + _p0 = unsafe.Pointer(&iovecs[0]) + } else { + _p0 = unsafe.Pointer(&_zero) + } + r0, _, e1 := syscall_syscall(libc_writev_trampoline_addr, uintptr(fd), uintptr(_p0), uintptr(len(iovecs))) + n = int(r0) + if e1 != 0 { + err = errnoErr(e1) + } + return +} + +var libc_writev_trampoline_addr uintptr + +//go:cgo_import_dynamic libc_writev writev "libc.so" + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func preadv(fd int, iovecs []Iovec, offset int64) (n int, err error) { + var _p0 unsafe.Pointer + if len(iovecs) > 0 { + _p0 = unsafe.Pointer(&iovecs[0]) + } else { + _p0 = unsafe.Pointer(&_zero) + } + r0, _, e1 := syscall_syscall6(libc_preadv_trampoline_addr, uintptr(fd), uintptr(_p0), uintptr(len(iovecs)), uintptr(offset), 0, 0) + n = int(r0) + if e1 != 0 { + err = errnoErr(e1) + } + return +} + +var libc_preadv_trampoline_addr uintptr + +//go:cgo_import_dynamic libc_preadv preadv "libc.so" + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func pwritev(fd int, iovecs []Iovec, offset int64) (n int, err error) { + var _p0 unsafe.Pointer + if len(iovecs) > 0 { + _p0 = unsafe.Pointer(&iovecs[0]) + } else { + _p0 = unsafe.Pointer(&_zero) + } + r0, _, e1 := syscall_syscall6(libc_pwritev_trampoline_addr, uintptr(fd), uintptr(_p0), uintptr(len(iovecs)), uintptr(offset), 0, 0) + n = int(r0) + if e1 != 0 { + err = errnoErr(e1) + } + return +} + +var libc_pwritev_trampoline_addr uintptr + +//go:cgo_import_dynamic libc_pwritev pwritev "libc.so" + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + func read(fd int, p []byte) (n int, err error) { var _p0 unsafe.Pointer if len(p) > 0 { diff --git a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_amd64.s b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_amd64.s index 880c6d6e31..9de2cbaa45 100644 --- a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_amd64.s +++ b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_amd64.s @@ -498,6 +498,26 @@ TEXT libc_pwrite_trampoline<>(SB),NOSPLIT,$0-0 GLOBL ·libc_pwrite_trampoline_addr(SB), RODATA, $8 DATA ·libc_pwrite_trampoline_addr(SB)/8, $libc_pwrite_trampoline<>(SB) +TEXT libc_readv_trampoline<>(SB),NOSPLIT,$0-0 + JMP libc_readv(SB) +GLOBL ·libc_readv_trampoline_addr(SB), RODATA, $8 +DATA ·libc_readv_trampoline_addr(SB)/8, $libc_readv_trampoline<>(SB) + +TEXT libc_writev_trampoline<>(SB),NOSPLIT,$0-0 + JMP libc_writev(SB) +GLOBL ·libc_writev_trampoline_addr(SB), RODATA, $8 +DATA ·libc_writev_trampoline_addr(SB)/8, $libc_writev_trampoline<>(SB) + +TEXT libc_preadv_trampoline<>(SB),NOSPLIT,$0-0 + JMP libc_preadv(SB) +GLOBL ·libc_preadv_trampoline_addr(SB), RODATA, $8 +DATA ·libc_preadv_trampoline_addr(SB)/8, $libc_preadv_trampoline<>(SB) + +TEXT libc_pwritev_trampoline<>(SB),NOSPLIT,$0-0 + JMP libc_pwritev(SB) +GLOBL ·libc_pwritev_trampoline_addr(SB), RODATA, $8 +DATA ·libc_pwritev_trampoline_addr(SB)/8, $libc_pwritev_trampoline<>(SB) + TEXT libc_read_trampoline<>(SB),NOSPLIT,$0-0 JMP libc_read(SB) GLOBL ·libc_read_trampoline_addr(SB), RODATA, $8 diff --git a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm.go b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm.go index 7c8452a63e..33c9c3a43e 100644 --- a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm.go +++ b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm.go @@ -1633,6 +1633,90 @@ var libc_pwrite_trampoline_addr uintptr // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT +func readv(fd int, iovecs []Iovec) (n int, err error) { + var _p0 unsafe.Pointer + if len(iovecs) > 0 { + _p0 = unsafe.Pointer(&iovecs[0]) + } else { + _p0 = unsafe.Pointer(&_zero) + } + r0, _, e1 := syscall_syscall(libc_readv_trampoline_addr, uintptr(fd), uintptr(_p0), uintptr(len(iovecs))) + n = int(r0) + if e1 != 0 { + err = errnoErr(e1) + } + return +} + +var libc_readv_trampoline_addr uintptr + +//go:cgo_import_dynamic libc_readv readv "libc.so" + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func writev(fd int, iovecs []Iovec) (n int, err error) { + var _p0 unsafe.Pointer + if len(iovecs) > 0 { + _p0 = unsafe.Pointer(&iovecs[0]) + } else { + _p0 = unsafe.Pointer(&_zero) + } + r0, _, e1 := syscall_syscall(libc_writev_trampoline_addr, uintptr(fd), uintptr(_p0), uintptr(len(iovecs))) + n = int(r0) + if e1 != 0 { + err = errnoErr(e1) + } + return +} + +var libc_writev_trampoline_addr uintptr + +//go:cgo_import_dynamic libc_writev writev "libc.so" + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func preadv(fd int, iovecs []Iovec, offset int64) (n int, err error) { + var _p0 unsafe.Pointer + if len(iovecs) > 0 { + _p0 = unsafe.Pointer(&iovecs[0]) + } else { + _p0 = unsafe.Pointer(&_zero) + } + r0, _, e1 := syscall_syscall6(libc_preadv_trampoline_addr, uintptr(fd), uintptr(_p0), uintptr(len(iovecs)), 0, uintptr(offset), uintptr(offset>>32)) + n = int(r0) + if e1 != 0 { + err = errnoErr(e1) + } + return +} + +var libc_preadv_trampoline_addr uintptr + +//go:cgo_import_dynamic libc_preadv preadv "libc.so" + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func pwritev(fd int, iovecs []Iovec, offset int64) (n int, err error) { + var _p0 unsafe.Pointer + if len(iovecs) > 0 { + _p0 = unsafe.Pointer(&iovecs[0]) + } else { + _p0 = unsafe.Pointer(&_zero) + } + r0, _, e1 := syscall_syscall6(libc_pwritev_trampoline_addr, uintptr(fd), uintptr(_p0), uintptr(len(iovecs)), 0, uintptr(offset), uintptr(offset>>32)) + n = int(r0) + if e1 != 0 { + err = errnoErr(e1) + } + return +} + +var libc_pwritev_trampoline_addr uintptr + +//go:cgo_import_dynamic libc_pwritev pwritev "libc.so" + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + func read(fd int, p []byte) (n int, err error) { var _p0 unsafe.Pointer if len(p) > 0 { diff --git a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm.s b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm.s index b8ef95b0fa..c6b9175a6f 100644 --- a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm.s +++ b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm.s @@ -498,6 +498,26 @@ TEXT libc_pwrite_trampoline<>(SB),NOSPLIT,$0-0 GLOBL ·libc_pwrite_trampoline_addr(SB), RODATA, $4 DATA ·libc_pwrite_trampoline_addr(SB)/4, $libc_pwrite_trampoline<>(SB) +TEXT libc_readv_trampoline<>(SB),NOSPLIT,$0-0 + JMP libc_readv(SB) +GLOBL ·libc_readv_trampoline_addr(SB), RODATA, $4 +DATA ·libc_readv_trampoline_addr(SB)/4, $libc_readv_trampoline<>(SB) + +TEXT libc_writev_trampoline<>(SB),NOSPLIT,$0-0 + JMP libc_writev(SB) +GLOBL ·libc_writev_trampoline_addr(SB), RODATA, $4 +DATA ·libc_writev_trampoline_addr(SB)/4, $libc_writev_trampoline<>(SB) + +TEXT libc_preadv_trampoline<>(SB),NOSPLIT,$0-0 + JMP libc_preadv(SB) +GLOBL ·libc_preadv_trampoline_addr(SB), RODATA, $4 +DATA ·libc_preadv_trampoline_addr(SB)/4, $libc_preadv_trampoline<>(SB) + +TEXT libc_pwritev_trampoline<>(SB),NOSPLIT,$0-0 + JMP libc_pwritev(SB) +GLOBL ·libc_pwritev_trampoline_addr(SB), RODATA, $4 +DATA ·libc_pwritev_trampoline_addr(SB)/4, $libc_pwritev_trampoline<>(SB) + TEXT libc_read_trampoline<>(SB),NOSPLIT,$0-0 JMP libc_read(SB) GLOBL ·libc_read_trampoline_addr(SB), RODATA, $4 diff --git a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm64.go b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm64.go index 2ffdf861f7..d3410262e9 100644 --- a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm64.go +++ b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm64.go @@ -1633,6 +1633,90 @@ var libc_pwrite_trampoline_addr uintptr // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT +func readv(fd int, iovecs []Iovec) (n int, err error) { + var _p0 unsafe.Pointer + if len(iovecs) > 0 { + _p0 = unsafe.Pointer(&iovecs[0]) + } else { + _p0 = unsafe.Pointer(&_zero) + } + r0, _, e1 := syscall_syscall(libc_readv_trampoline_addr, uintptr(fd), uintptr(_p0), uintptr(len(iovecs))) + n = int(r0) + if e1 != 0 { + err = errnoErr(e1) + } + return +} + +var libc_readv_trampoline_addr uintptr + +//go:cgo_import_dynamic libc_readv readv "libc.so" + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func writev(fd int, iovecs []Iovec) (n int, err error) { + var _p0 unsafe.Pointer + if len(iovecs) > 0 { + _p0 = unsafe.Pointer(&iovecs[0]) + } else { + _p0 = unsafe.Pointer(&_zero) + } + r0, _, e1 := syscall_syscall(libc_writev_trampoline_addr, uintptr(fd), uintptr(_p0), uintptr(len(iovecs))) + n = int(r0) + if e1 != 0 { + err = errnoErr(e1) + } + return +} + +var libc_writev_trampoline_addr uintptr + +//go:cgo_import_dynamic libc_writev writev "libc.so" + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func preadv(fd int, iovecs []Iovec, offset int64) (n int, err error) { + var _p0 unsafe.Pointer + if len(iovecs) > 0 { + _p0 = unsafe.Pointer(&iovecs[0]) + } else { + _p0 = unsafe.Pointer(&_zero) + } + r0, _, e1 := syscall_syscall6(libc_preadv_trampoline_addr, uintptr(fd), uintptr(_p0), uintptr(len(iovecs)), uintptr(offset), 0, 0) + n = int(r0) + if e1 != 0 { + err = errnoErr(e1) + } + return +} + +var libc_preadv_trampoline_addr uintptr + +//go:cgo_import_dynamic libc_preadv preadv "libc.so" + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func pwritev(fd int, iovecs []Iovec, offset int64) (n int, err error) { + var _p0 unsafe.Pointer + if len(iovecs) > 0 { + _p0 = unsafe.Pointer(&iovecs[0]) + } else { + _p0 = unsafe.Pointer(&_zero) + } + r0, _, e1 := syscall_syscall6(libc_pwritev_trampoline_addr, uintptr(fd), uintptr(_p0), uintptr(len(iovecs)), uintptr(offset), 0, 0) + n = int(r0) + if e1 != 0 { + err = errnoErr(e1) + } + return +} + +var libc_pwritev_trampoline_addr uintptr + +//go:cgo_import_dynamic libc_pwritev pwritev "libc.so" + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + func read(fd int, p []byte) (n int, err error) { var _p0 unsafe.Pointer if len(p) > 0 { diff --git a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm64.s b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm64.s index 2af3b5c762..1be10bb45c 100644 --- a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm64.s +++ b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm64.s @@ -498,6 +498,26 @@ TEXT libc_pwrite_trampoline<>(SB),NOSPLIT,$0-0 GLOBL ·libc_pwrite_trampoline_addr(SB), RODATA, $8 DATA ·libc_pwrite_trampoline_addr(SB)/8, $libc_pwrite_trampoline<>(SB) +TEXT libc_readv_trampoline<>(SB),NOSPLIT,$0-0 + JMP libc_readv(SB) +GLOBL ·libc_readv_trampoline_addr(SB), RODATA, $8 +DATA ·libc_readv_trampoline_addr(SB)/8, $libc_readv_trampoline<>(SB) + +TEXT libc_writev_trampoline<>(SB),NOSPLIT,$0-0 + JMP libc_writev(SB) +GLOBL ·libc_writev_trampoline_addr(SB), RODATA, $8 +DATA ·libc_writev_trampoline_addr(SB)/8, $libc_writev_trampoline<>(SB) + +TEXT libc_preadv_trampoline<>(SB),NOSPLIT,$0-0 + JMP libc_preadv(SB) +GLOBL ·libc_preadv_trampoline_addr(SB), RODATA, $8 +DATA ·libc_preadv_trampoline_addr(SB)/8, $libc_preadv_trampoline<>(SB) + +TEXT libc_pwritev_trampoline<>(SB),NOSPLIT,$0-0 + JMP libc_pwritev(SB) +GLOBL ·libc_pwritev_trampoline_addr(SB), RODATA, $8 +DATA ·libc_pwritev_trampoline_addr(SB)/8, $libc_pwritev_trampoline<>(SB) + TEXT libc_read_trampoline<>(SB),NOSPLIT,$0-0 JMP libc_read(SB) GLOBL ·libc_read_trampoline_addr(SB), RODATA, $8 diff --git a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_mips64.go b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_mips64.go index 1da08d5267..dea19d54e4 100644 --- a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_mips64.go +++ b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_mips64.go @@ -1633,6 +1633,90 @@ var libc_pwrite_trampoline_addr uintptr // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT +func readv(fd int, iovecs []Iovec) (n int, err error) { + var _p0 unsafe.Pointer + if len(iovecs) > 0 { + _p0 = unsafe.Pointer(&iovecs[0]) + } else { + _p0 = unsafe.Pointer(&_zero) + } + r0, _, e1 := syscall_syscall(libc_readv_trampoline_addr, uintptr(fd), uintptr(_p0), uintptr(len(iovecs))) + n = int(r0) + if e1 != 0 { + err = errnoErr(e1) + } + return +} + +var libc_readv_trampoline_addr uintptr + +//go:cgo_import_dynamic libc_readv readv "libc.so" + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func writev(fd int, iovecs []Iovec) (n int, err error) { + var _p0 unsafe.Pointer + if len(iovecs) > 0 { + _p0 = unsafe.Pointer(&iovecs[0]) + } else { + _p0 = unsafe.Pointer(&_zero) + } + r0, _, e1 := syscall_syscall(libc_writev_trampoline_addr, uintptr(fd), uintptr(_p0), uintptr(len(iovecs))) + n = int(r0) + if e1 != 0 { + err = errnoErr(e1) + } + return +} + +var libc_writev_trampoline_addr uintptr + +//go:cgo_import_dynamic libc_writev writev "libc.so" + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func preadv(fd int, iovecs []Iovec, offset int64) (n int, err error) { + var _p0 unsafe.Pointer + if len(iovecs) > 0 { + _p0 = unsafe.Pointer(&iovecs[0]) + } else { + _p0 = unsafe.Pointer(&_zero) + } + r0, _, e1 := syscall_syscall6(libc_preadv_trampoline_addr, uintptr(fd), uintptr(_p0), uintptr(len(iovecs)), uintptr(offset), 0, 0) + n = int(r0) + if e1 != 0 { + err = errnoErr(e1) + } + return +} + +var libc_preadv_trampoline_addr uintptr + +//go:cgo_import_dynamic libc_preadv preadv "libc.so" + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func pwritev(fd int, iovecs []Iovec, offset int64) (n int, err error) { + var _p0 unsafe.Pointer + if len(iovecs) > 0 { + _p0 = unsafe.Pointer(&iovecs[0]) + } else { + _p0 = unsafe.Pointer(&_zero) + } + r0, _, e1 := syscall_syscall6(libc_pwritev_trampoline_addr, uintptr(fd), uintptr(_p0), uintptr(len(iovecs)), uintptr(offset), 0, 0) + n = int(r0) + if e1 != 0 { + err = errnoErr(e1) + } + return +} + +var libc_pwritev_trampoline_addr uintptr + +//go:cgo_import_dynamic libc_pwritev pwritev "libc.so" + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + func read(fd int, p []byte) (n int, err error) { var _p0 unsafe.Pointer if len(p) > 0 { diff --git a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_mips64.s b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_mips64.s index b7a251353b..a9fec24d96 100644 --- a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_mips64.s +++ b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_mips64.s @@ -498,6 +498,26 @@ TEXT libc_pwrite_trampoline<>(SB),NOSPLIT,$0-0 GLOBL ·libc_pwrite_trampoline_addr(SB), RODATA, $8 DATA ·libc_pwrite_trampoline_addr(SB)/8, $libc_pwrite_trampoline<>(SB) +TEXT libc_readv_trampoline<>(SB),NOSPLIT,$0-0 + JMP libc_readv(SB) +GLOBL ·libc_readv_trampoline_addr(SB), RODATA, $8 +DATA ·libc_readv_trampoline_addr(SB)/8, $libc_readv_trampoline<>(SB) + +TEXT libc_writev_trampoline<>(SB),NOSPLIT,$0-0 + JMP libc_writev(SB) +GLOBL ·libc_writev_trampoline_addr(SB), RODATA, $8 +DATA ·libc_writev_trampoline_addr(SB)/8, $libc_writev_trampoline<>(SB) + +TEXT libc_preadv_trampoline<>(SB),NOSPLIT,$0-0 + JMP libc_preadv(SB) +GLOBL ·libc_preadv_trampoline_addr(SB), RODATA, $8 +DATA ·libc_preadv_trampoline_addr(SB)/8, $libc_preadv_trampoline<>(SB) + +TEXT libc_pwritev_trampoline<>(SB),NOSPLIT,$0-0 + JMP libc_pwritev(SB) +GLOBL ·libc_pwritev_trampoline_addr(SB), RODATA, $8 +DATA ·libc_pwritev_trampoline_addr(SB)/8, $libc_pwritev_trampoline<>(SB) + TEXT libc_read_trampoline<>(SB),NOSPLIT,$0-0 JMP libc_read(SB) GLOBL ·libc_read_trampoline_addr(SB), RODATA, $8 diff --git a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_ppc64.go b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_ppc64.go index 6e85b0aac9..436efb586b 100644 --- a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_ppc64.go +++ b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_ppc64.go @@ -1633,6 +1633,90 @@ var libc_pwrite_trampoline_addr uintptr // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT +func readv(fd int, iovecs []Iovec) (n int, err error) { + var _p0 unsafe.Pointer + if len(iovecs) > 0 { + _p0 = unsafe.Pointer(&iovecs[0]) + } else { + _p0 = unsafe.Pointer(&_zero) + } + r0, _, e1 := syscall_syscall(libc_readv_trampoline_addr, uintptr(fd), uintptr(_p0), uintptr(len(iovecs))) + n = int(r0) + if e1 != 0 { + err = errnoErr(e1) + } + return +} + +var libc_readv_trampoline_addr uintptr + +//go:cgo_import_dynamic libc_readv readv "libc.so" + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func writev(fd int, iovecs []Iovec) (n int, err error) { + var _p0 unsafe.Pointer + if len(iovecs) > 0 { + _p0 = unsafe.Pointer(&iovecs[0]) + } else { + _p0 = unsafe.Pointer(&_zero) + } + r0, _, e1 := syscall_syscall(libc_writev_trampoline_addr, uintptr(fd), uintptr(_p0), uintptr(len(iovecs))) + n = int(r0) + if e1 != 0 { + err = errnoErr(e1) + } + return +} + +var libc_writev_trampoline_addr uintptr + +//go:cgo_import_dynamic libc_writev writev "libc.so" + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func preadv(fd int, iovecs []Iovec, offset int64) (n int, err error) { + var _p0 unsafe.Pointer + if len(iovecs) > 0 { + _p0 = unsafe.Pointer(&iovecs[0]) + } else { + _p0 = unsafe.Pointer(&_zero) + } + r0, _, e1 := syscall_syscall6(libc_preadv_trampoline_addr, uintptr(fd), uintptr(_p0), uintptr(len(iovecs)), uintptr(offset), 0, 0) + n = int(r0) + if e1 != 0 { + err = errnoErr(e1) + } + return +} + +var libc_preadv_trampoline_addr uintptr + +//go:cgo_import_dynamic libc_preadv preadv "libc.so" + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func pwritev(fd int, iovecs []Iovec, offset int64) (n int, err error) { + var _p0 unsafe.Pointer + if len(iovecs) > 0 { + _p0 = unsafe.Pointer(&iovecs[0]) + } else { + _p0 = unsafe.Pointer(&_zero) + } + r0, _, e1 := syscall_syscall6(libc_pwritev_trampoline_addr, uintptr(fd), uintptr(_p0), uintptr(len(iovecs)), uintptr(offset), 0, 0) + n = int(r0) + if e1 != 0 { + err = errnoErr(e1) + } + return +} + +var libc_pwritev_trampoline_addr uintptr + +//go:cgo_import_dynamic libc_pwritev pwritev "libc.so" + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + func read(fd int, p []byte) (n int, err error) { var _p0 unsafe.Pointer if len(p) > 0 { diff --git a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_ppc64.s b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_ppc64.s index f15dadf055..441ed4e409 100644 --- a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_ppc64.s +++ b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_ppc64.s @@ -597,6 +597,30 @@ TEXT libc_pwrite_trampoline<>(SB),NOSPLIT,$0-0 GLOBL ·libc_pwrite_trampoline_addr(SB), RODATA, $8 DATA ·libc_pwrite_trampoline_addr(SB)/8, $libc_pwrite_trampoline<>(SB) +TEXT libc_readv_trampoline<>(SB),NOSPLIT,$0-0 + CALL libc_readv(SB) + RET +GLOBL ·libc_readv_trampoline_addr(SB), RODATA, $8 +DATA ·libc_readv_trampoline_addr(SB)/8, $libc_readv_trampoline<>(SB) + +TEXT libc_writev_trampoline<>(SB),NOSPLIT,$0-0 + CALL libc_writev(SB) + RET +GLOBL ·libc_writev_trampoline_addr(SB), RODATA, $8 +DATA ·libc_writev_trampoline_addr(SB)/8, $libc_writev_trampoline<>(SB) + +TEXT libc_preadv_trampoline<>(SB),NOSPLIT,$0-0 + CALL libc_preadv(SB) + RET +GLOBL ·libc_preadv_trampoline_addr(SB), RODATA, $8 +DATA ·libc_preadv_trampoline_addr(SB)/8, $libc_preadv_trampoline<>(SB) + +TEXT libc_pwritev_trampoline<>(SB),NOSPLIT,$0-0 + CALL libc_pwritev(SB) + RET +GLOBL ·libc_pwritev_trampoline_addr(SB), RODATA, $8 +DATA ·libc_pwritev_trampoline_addr(SB)/8, $libc_pwritev_trampoline<>(SB) + TEXT libc_read_trampoline<>(SB),NOSPLIT,$0-0 CALL libc_read(SB) RET diff --git a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_riscv64.go b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_riscv64.go index 28b487df25..d801e4b4e8 100644 --- a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_riscv64.go +++ b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_riscv64.go @@ -1633,6 +1633,90 @@ var libc_pwrite_trampoline_addr uintptr // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT +func readv(fd int, iovecs []Iovec) (n int, err error) { + var _p0 unsafe.Pointer + if len(iovecs) > 0 { + _p0 = unsafe.Pointer(&iovecs[0]) + } else { + _p0 = unsafe.Pointer(&_zero) + } + r0, _, e1 := syscall_syscall(libc_readv_trampoline_addr, uintptr(fd), uintptr(_p0), uintptr(len(iovecs))) + n = int(r0) + if e1 != 0 { + err = errnoErr(e1) + } + return +} + +var libc_readv_trampoline_addr uintptr + +//go:cgo_import_dynamic libc_readv readv "libc.so" + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func writev(fd int, iovecs []Iovec) (n int, err error) { + var _p0 unsafe.Pointer + if len(iovecs) > 0 { + _p0 = unsafe.Pointer(&iovecs[0]) + } else { + _p0 = unsafe.Pointer(&_zero) + } + r0, _, e1 := syscall_syscall(libc_writev_trampoline_addr, uintptr(fd), uintptr(_p0), uintptr(len(iovecs))) + n = int(r0) + if e1 != 0 { + err = errnoErr(e1) + } + return +} + +var libc_writev_trampoline_addr uintptr + +//go:cgo_import_dynamic libc_writev writev "libc.so" + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func preadv(fd int, iovecs []Iovec, offset int64) (n int, err error) { + var _p0 unsafe.Pointer + if len(iovecs) > 0 { + _p0 = unsafe.Pointer(&iovecs[0]) + } else { + _p0 = unsafe.Pointer(&_zero) + } + r0, _, e1 := syscall_syscall6(libc_preadv_trampoline_addr, uintptr(fd), uintptr(_p0), uintptr(len(iovecs)), uintptr(offset), 0, 0) + n = int(r0) + if e1 != 0 { + err = errnoErr(e1) + } + return +} + +var libc_preadv_trampoline_addr uintptr + +//go:cgo_import_dynamic libc_preadv preadv "libc.so" + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func pwritev(fd int, iovecs []Iovec, offset int64) (n int, err error) { + var _p0 unsafe.Pointer + if len(iovecs) > 0 { + _p0 = unsafe.Pointer(&iovecs[0]) + } else { + _p0 = unsafe.Pointer(&_zero) + } + r0, _, e1 := syscall_syscall6(libc_pwritev_trampoline_addr, uintptr(fd), uintptr(_p0), uintptr(len(iovecs)), uintptr(offset), 0, 0) + n = int(r0) + if e1 != 0 { + err = errnoErr(e1) + } + return +} + +var libc_pwritev_trampoline_addr uintptr + +//go:cgo_import_dynamic libc_pwritev pwritev "libc.so" + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + func read(fd int, p []byte) (n int, err error) { var _p0 unsafe.Pointer if len(p) > 0 { diff --git a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_riscv64.s b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_riscv64.s index 1e7f321e43..b15cc01747 100644 --- a/vendor/golang.org/x/sys/unix/zsyscall_openbsd_riscv64.s +++ b/vendor/golang.org/x/sys/unix/zsyscall_openbsd_riscv64.s @@ -498,6 +498,26 @@ TEXT libc_pwrite_trampoline<>(SB),NOSPLIT,$0-0 GLOBL ·libc_pwrite_trampoline_addr(SB), RODATA, $8 DATA ·libc_pwrite_trampoline_addr(SB)/8, $libc_pwrite_trampoline<>(SB) +TEXT libc_readv_trampoline<>(SB),NOSPLIT,$0-0 + JMP libc_readv(SB) +GLOBL ·libc_readv_trampoline_addr(SB), RODATA, $8 +DATA ·libc_readv_trampoline_addr(SB)/8, $libc_readv_trampoline<>(SB) + +TEXT libc_writev_trampoline<>(SB),NOSPLIT,$0-0 + JMP libc_writev(SB) +GLOBL ·libc_writev_trampoline_addr(SB), RODATA, $8 +DATA ·libc_writev_trampoline_addr(SB)/8, $libc_writev_trampoline<>(SB) + +TEXT libc_preadv_trampoline<>(SB),NOSPLIT,$0-0 + JMP libc_preadv(SB) +GLOBL ·libc_preadv_trampoline_addr(SB), RODATA, $8 +DATA ·libc_preadv_trampoline_addr(SB)/8, $libc_preadv_trampoline<>(SB) + +TEXT libc_pwritev_trampoline<>(SB),NOSPLIT,$0-0 + JMP libc_pwritev(SB) +GLOBL ·libc_pwritev_trampoline_addr(SB), RODATA, $8 +DATA ·libc_pwritev_trampoline_addr(SB)/8, $libc_pwritev_trampoline<>(SB) + TEXT libc_read_trampoline<>(SB),NOSPLIT,$0-0 JMP libc_read(SB) GLOBL ·libc_read_trampoline_addr(SB), RODATA, $8 diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go index aca56ee494..49d1b88031 100644 --- a/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go +++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go @@ -463,4 +463,8 @@ const ( SYS_LISTXATTRAT = 465 SYS_REMOVEXATTRAT = 466 SYS_OPEN_TREE_ATTR = 467 + SYS_FILE_GETATTR = 468 + SYS_FILE_SETATTR = 469 + SYS_LISTNS = 470 + SYS_RSEQ_SLICE_YIELD = 471 ) diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go index 2ea1ef58c3..f11f1de777 100644 --- a/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go +++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go @@ -342,6 +342,7 @@ const ( SYS_IO_PGETEVENTS = 333 SYS_RSEQ = 334 SYS_URETPROBE = 335 + SYS_UPROBE = 336 SYS_PIDFD_SEND_SIGNAL = 424 SYS_IO_URING_SETUP = 425 SYS_IO_URING_ENTER = 426 @@ -386,4 +387,8 @@ const ( SYS_LISTXATTRAT = 465 SYS_REMOVEXATTRAT = 466 SYS_OPEN_TREE_ATTR = 467 + SYS_FILE_GETATTR = 468 + SYS_FILE_SETATTR = 469 + SYS_LISTNS = 470 + SYS_RSEQ_SLICE_YIELD = 471 ) diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go index d22c8af319..bad740b79a 100644 --- a/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go +++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go @@ -427,4 +427,8 @@ const ( SYS_LISTXATTRAT = 465 SYS_REMOVEXATTRAT = 466 SYS_OPEN_TREE_ATTR = 467 + SYS_FILE_GETATTR = 468 + SYS_FILE_SETATTR = 469 + SYS_LISTNS = 470 + SYS_RSEQ_SLICE_YIELD = 471 ) diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go index 5ee264ae97..fe646d18ef 100644 --- a/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go +++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go @@ -330,4 +330,8 @@ const ( SYS_LISTXATTRAT = 465 SYS_REMOVEXATTRAT = 466 SYS_OPEN_TREE_ATTR = 467 + SYS_FILE_GETATTR = 468 + SYS_FILE_SETATTR = 469 + SYS_LISTNS = 470 + SYS_RSEQ_SLICE_YIELD = 471 ) diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go index f9f03ebf5f..4362f6d559 100644 --- a/vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go +++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go @@ -306,6 +306,7 @@ const ( SYS_LANDLOCK_CREATE_RULESET = 444 SYS_LANDLOCK_ADD_RULE = 445 SYS_LANDLOCK_RESTRICT_SELF = 446 + SYS_MEMFD_SECRET = 447 SYS_PROCESS_MRELEASE = 448 SYS_FUTEX_WAITV = 449 SYS_SET_MEMPOLICY_HOME_NODE = 450 @@ -326,4 +327,8 @@ const ( SYS_LISTXATTRAT = 465 SYS_REMOVEXATTRAT = 466 SYS_OPEN_TREE_ATTR = 467 + SYS_FILE_GETATTR = 468 + SYS_FILE_SETATTR = 469 + SYS_LISTNS = 470 + SYS_RSEQ_SLICE_YIELD = 471 ) diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go index 87c2118e84..b63d155ae9 100644 --- a/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go +++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go @@ -447,4 +447,8 @@ const ( SYS_LISTXATTRAT = 4465 SYS_REMOVEXATTRAT = 4466 SYS_OPEN_TREE_ATTR = 4467 + SYS_FILE_GETATTR = 4468 + SYS_FILE_SETATTR = 4469 + SYS_LISTNS = 4470 + SYS_RSEQ_SLICE_YIELD = 4471 ) diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go index 391ad102fb..435d43319b 100644 --- a/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go +++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go @@ -377,4 +377,8 @@ const ( SYS_LISTXATTRAT = 5465 SYS_REMOVEXATTRAT = 5466 SYS_OPEN_TREE_ATTR = 5467 + SYS_FILE_GETATTR = 5468 + SYS_FILE_SETATTR = 5469 + SYS_LISTNS = 5470 + SYS_RSEQ_SLICE_YIELD = 5471 ) diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go index 5656157757..dcc0468d67 100644 --- a/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go +++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go @@ -377,4 +377,8 @@ const ( SYS_LISTXATTRAT = 5465 SYS_REMOVEXATTRAT = 5466 SYS_OPEN_TREE_ATTR = 5467 + SYS_FILE_GETATTR = 5468 + SYS_FILE_SETATTR = 5469 + SYS_LISTNS = 5470 + SYS_RSEQ_SLICE_YIELD = 5471 ) diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go index 0482b52e3c..b96f85ebd6 100644 --- a/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go +++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go @@ -447,4 +447,8 @@ const ( SYS_LISTXATTRAT = 4465 SYS_REMOVEXATTRAT = 4466 SYS_OPEN_TREE_ATTR = 4467 + SYS_FILE_GETATTR = 4468 + SYS_FILE_SETATTR = 4469 + SYS_LISTNS = 4470 + SYS_RSEQ_SLICE_YIELD = 4471 ) diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc.go index 71806f08f3..bffa2bd1e7 100644 --- a/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc.go +++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc.go @@ -454,4 +454,8 @@ const ( SYS_LISTXATTRAT = 465 SYS_REMOVEXATTRAT = 466 SYS_OPEN_TREE_ATTR = 467 + SYS_FILE_GETATTR = 468 + SYS_FILE_SETATTR = 469 + SYS_LISTNS = 470 + SYS_RSEQ_SLICE_YIELD = 471 ) diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go index e35a710582..57bfc6b260 100644 --- a/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go +++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go @@ -426,4 +426,8 @@ const ( SYS_LISTXATTRAT = 465 SYS_REMOVEXATTRAT = 466 SYS_OPEN_TREE_ATTR = 467 + SYS_FILE_GETATTR = 468 + SYS_FILE_SETATTR = 469 + SYS_LISTNS = 470 + SYS_RSEQ_SLICE_YIELD = 471 ) diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go index 2aea476705..750f706d57 100644 --- a/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go +++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go @@ -426,4 +426,8 @@ const ( SYS_LISTXATTRAT = 465 SYS_REMOVEXATTRAT = 466 SYS_OPEN_TREE_ATTR = 467 + SYS_FILE_GETATTR = 468 + SYS_FILE_SETATTR = 469 + SYS_LISTNS = 470 + SYS_RSEQ_SLICE_YIELD = 471 ) diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go index 6c9bb4e560..303ccbf46f 100644 --- a/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go +++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go @@ -331,4 +331,8 @@ const ( SYS_LISTXATTRAT = 465 SYS_REMOVEXATTRAT = 466 SYS_OPEN_TREE_ATTR = 467 + SYS_FILE_GETATTR = 468 + SYS_FILE_SETATTR = 469 + SYS_LISTNS = 470 + SYS_RSEQ_SLICE_YIELD = 471 ) diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go index 680bc9915a..5e5dd4ccb0 100644 --- a/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go +++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go @@ -392,4 +392,8 @@ const ( SYS_LISTXATTRAT = 465 SYS_REMOVEXATTRAT = 466 SYS_OPEN_TREE_ATTR = 467 + SYS_FILE_GETATTR = 468 + SYS_FILE_SETATTR = 469 + SYS_LISTNS = 470 + SYS_RSEQ_SLICE_YIELD = 471 ) diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go index 620f271052..f7c4fb3df9 100644 --- a/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go +++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go @@ -374,6 +374,7 @@ const ( SYS_FSMOUNT = 432 SYS_FSPICK = 433 SYS_PIDFD_OPEN = 434 + SYS_CLONE3 = 435 SYS_CLOSE_RANGE = 436 SYS_OPENAT2 = 437 SYS_PIDFD_GETFD = 438 @@ -405,4 +406,8 @@ const ( SYS_LISTXATTRAT = 465 SYS_REMOVEXATTRAT = 466 SYS_OPEN_TREE_ATTR = 467 + SYS_FILE_GETATTR = 468 + SYS_FILE_SETATTR = 469 + SYS_LISTNS = 470 + SYS_RSEQ_SLICE_YIELD = 471 ) diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux.go b/vendor/golang.org/x/sys/unix/ztypes_linux.go index 45476a73c6..d11d5b96a4 100644 --- a/vendor/golang.org/x/sys/unix/ztypes_linux.go +++ b/vendor/golang.org/x/sys/unix/ztypes_linux.go @@ -18,6 +18,11 @@ type ( _C_long_long int64 ) +type KernelTimespec struct { + Sec int64 + Nsec int64 +} + type ItimerSpec struct { Interval Timespec Value Timespec @@ -521,6 +526,14 @@ type TCPInfo struct { Total_rto uint16 Total_rto_recoveries uint16 Total_rto_time uint32 + Received_ce uint32 + Delivered_e1_bytes uint32 + Delivered_e0_bytes uint32 + Delivered_ce_bytes uint32 + Received_e1_bytes uint32 + Received_e0_bytes uint32 + Received_ce_bytes uint32 + _ [4]byte } type TCPVegasInfo struct { @@ -586,7 +599,7 @@ const ( SizeofIPv6MTUInfo = 0x20 SizeofICMPv6Filter = 0x20 SizeofUcred = 0xc - SizeofTCPInfo = 0xf8 + SizeofTCPInfo = 0x118 SizeofTCPCCInfo = 0x14 SizeofCanFilter = 0x8 SizeofTCPRepairOpt = 0x8 @@ -1324,7 +1337,7 @@ const ( PERF_RECORD_CGROUP = 0x13 PERF_RECORD_TEXT_POKE = 0x14 PERF_RECORD_AUX_OUTPUT_HW_ID = 0x15 - PERF_RECORD_MAX = 0x16 + PERF_RECORD_MAX = 0x17 PERF_RECORD_KSYMBOL_TYPE_UNKNOWN = 0x0 PERF_RECORD_KSYMBOL_TYPE_BPF = 0x1 PERF_RECORD_KSYMBOL_TYPE_OOL = 0x2 @@ -3566,7 +3579,7 @@ const ( DEVLINK_ATTR_LINECARD_SUPPORTED_TYPES = 0xae DEVLINK_ATTR_NESTED_DEVLINK = 0xaf DEVLINK_ATTR_SELFTESTS = 0xb0 - DEVLINK_ATTR_MAX = 0xb3 + DEVLINK_ATTR_MAX = 0xb7 DEVLINK_DPIPE_FIELD_MAPPING_TYPE_NONE = 0x0 DEVLINK_DPIPE_FIELD_MAPPING_TYPE_IFINDEX = 0x1 DEVLINK_DPIPE_MATCH_TYPE_FIELD_EXACT = 0x0 @@ -3888,7 +3901,7 @@ const ( ETHTOOL_MSG_PHY_GET = 0x2d ETHTOOL_MSG_TSCONFIG_GET = 0x2e ETHTOOL_MSG_TSCONFIG_SET = 0x2f - ETHTOOL_MSG_USER_MAX = 0x2f + ETHTOOL_MSG_USER_MAX = 0x33 ETHTOOL_MSG_KERNEL_NONE = 0x0 ETHTOOL_MSG_STRSET_GET_REPLY = 0x1 ETHTOOL_MSG_LINKINFO_GET_REPLY = 0x2 @@ -3938,7 +3951,7 @@ const ( ETHTOOL_MSG_PHY_NTF = 0x2e ETHTOOL_MSG_TSCONFIG_GET_REPLY = 0x2f ETHTOOL_MSG_TSCONFIG_SET_REPLY = 0x30 - ETHTOOL_MSG_KERNEL_MAX = 0x30 + ETHTOOL_MSG_KERNEL_MAX = 0x36 ETHTOOL_FLAG_COMPACT_BITSETS = 0x1 ETHTOOL_FLAG_OMIT_REPLY = 0x2 ETHTOOL_FLAG_STATS = 0x4 @@ -4867,7 +4880,7 @@ const ( NL80211_ATTR_MAC_HINT = 0xc8 NL80211_ATTR_MAC_MASK = 0xd7 NL80211_ATTR_MAX_AP_ASSOC_STA = 0xca - NL80211_ATTR_MAX = 0x151 + NL80211_ATTR_MAX = 0x15c NL80211_ATTR_MAX_CRIT_PROT_DURATION = 0xb4 NL80211_ATTR_MAX_CSA_COUNTERS = 0xce NL80211_ATTR_MAX_HW_TIMESTAMP_PEERS = 0x143 @@ -5082,12 +5095,12 @@ const ( NL80211_ATTR_WOWLAN_TRIGGERS = 0x75 NL80211_ATTR_WOWLAN_TRIGGERS_SUPPORTED = 0x76 NL80211_ATTR_WPA_VERSIONS = 0x4b - NL80211_AUTHTYPE_AUTOMATIC = 0x8 + NL80211_AUTHTYPE_AUTOMATIC = 0x9 NL80211_AUTHTYPE_FILS_PK = 0x7 NL80211_AUTHTYPE_FILS_SK = 0x5 NL80211_AUTHTYPE_FILS_SK_PFS = 0x6 NL80211_AUTHTYPE_FT = 0x2 - NL80211_AUTHTYPE_MAX = 0x7 + NL80211_AUTHTYPE_MAX = 0x8 NL80211_AUTHTYPE_NETWORK_EAP = 0x3 NL80211_AUTHTYPE_OPEN_SYSTEM = 0x0 NL80211_AUTHTYPE_SAE = 0x4 @@ -5120,7 +5133,7 @@ const ( NL80211_BAND_IFTYPE_ATTR_HE_CAP_PHY = 0x3 NL80211_BAND_IFTYPE_ATTR_HE_CAP_PPE = 0x5 NL80211_BAND_IFTYPE_ATTR_IFTYPES = 0x1 - NL80211_BAND_IFTYPE_ATTR_MAX = 0xb + NL80211_BAND_IFTYPE_ATTR_MAX = 0xd NL80211_BAND_IFTYPE_ATTR_VENDOR_ELEMS = 0x7 NL80211_BAND_LC = 0x5 NL80211_BAND_S1GHZ = 0x4 @@ -5255,7 +5268,7 @@ const ( NL80211_CMD_LEAVE_MESH = 0x45 NL80211_CMD_LEAVE_OCB = 0x6d NL80211_CMD_LINKS_REMOVED = 0x9a - NL80211_CMD_MAX = 0x9d + NL80211_CMD_MAX = 0x9f NL80211_CMD_MICHAEL_MIC_FAILURE = 0x29 NL80211_CMD_MODIFY_LINK_STA = 0x97 NL80211_CMD_NAN_MATCH = 0x78 @@ -5501,7 +5514,7 @@ const ( NL80211_FREQUENCY_ATTR_GO_CONCURRENT = 0xf NL80211_FREQUENCY_ATTR_INDOOR_ONLY = 0xe NL80211_FREQUENCY_ATTR_IR_CONCURRENT = 0xf - NL80211_FREQUENCY_ATTR_MAX = 0x22 + NL80211_FREQUENCY_ATTR_MAX = 0x27 NL80211_FREQUENCY_ATTR_MAX_TX_POWER = 0x6 NL80211_FREQUENCY_ATTR_NO_10MHZ = 0x11 NL80211_FREQUENCY_ATTR_NO_160MHZ = 0xc @@ -5766,7 +5779,7 @@ const ( NL80211_PMSR_FTM_CAPA_ATTR_ASAP = 0x1 NL80211_PMSR_FTM_CAPA_ATTR_BANDWIDTHS = 0x6 NL80211_PMSR_FTM_CAPA_ATTR_MAX_BURSTS_EXPONENT = 0x7 - NL80211_PMSR_FTM_CAPA_ATTR_MAX = 0xa + NL80211_PMSR_FTM_CAPA_ATTR_MAX = 0x12 NL80211_PMSR_FTM_CAPA_ATTR_MAX_FTMS_PER_BURST = 0x8 NL80211_PMSR_FTM_CAPA_ATTR_NON_ASAP = 0x2 NL80211_PMSR_FTM_CAPA_ATTR_NON_TRIGGER_BASED = 0xa @@ -5788,7 +5801,7 @@ const ( NL80211_PMSR_FTM_REQ_ATTR_BURST_PERIOD = 0x4 NL80211_PMSR_FTM_REQ_ATTR_FTMS_PER_BURST = 0x6 NL80211_PMSR_FTM_REQ_ATTR_LMR_FEEDBACK = 0xc - NL80211_PMSR_FTM_REQ_ATTR_MAX = 0xd + NL80211_PMSR_FTM_REQ_ATTR_MAX = 0xe NL80211_PMSR_FTM_REQ_ATTR_NON_TRIGGER_BASED = 0xb NL80211_PMSR_FTM_REQ_ATTR_NUM_BURSTS_EXP = 0x3 NL80211_PMSR_FTM_REQ_ATTR_NUM_FTMR_RETRIES = 0x7 @@ -5806,7 +5819,7 @@ const ( NL80211_PMSR_FTM_RESP_ATTR_FAIL_REASON = 0x1 NL80211_PMSR_FTM_RESP_ATTR_FTMS_PER_BURST = 0x8 NL80211_PMSR_FTM_RESP_ATTR_LCI = 0x13 - NL80211_PMSR_FTM_RESP_ATTR_MAX = 0x15 + NL80211_PMSR_FTM_RESP_ATTR_MAX = 0x16 NL80211_PMSR_FTM_RESP_ATTR_NUM_BURSTS_EXP = 0x6 NL80211_PMSR_FTM_RESP_ATTR_NUM_FTMR_ATTEMPTS = 0x3 NL80211_PMSR_FTM_RESP_ATTR_NUM_FTMR_SUCCESSES = 0x4 @@ -5913,7 +5926,7 @@ const ( NL80211_RATE_INFO_HE_RU_ALLOC_52 = 0x1 NL80211_RATE_INFO_HE_RU_ALLOC_996 = 0x5 NL80211_RATE_INFO_HE_RU_ALLOC = 0x11 - NL80211_RATE_INFO_MAX = 0x1d + NL80211_RATE_INFO_MAX = 0x20 NL80211_RATE_INFO_MCS = 0x2 NL80211_RATE_INFO_S1G_MCS = 0x17 NL80211_RATE_INFO_S1G_NSS = 0x18 @@ -6167,7 +6180,7 @@ const ( NL80211_TXRATE_HT = 0x2 NL80211_TXRATE_LEGACY = 0x1 NL80211_TX_RATE_LIMITED = 0x1 - NL80211_TXRATE_MAX = 0x7 + NL80211_TXRATE_MAX = 0xa NL80211_TXRATE_MCS = 0x2 NL80211_TXRATE_VHT = 0x3 NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_INT = 0x1 @@ -6183,7 +6196,7 @@ const ( NL80211_WIPHY_RADIO_ATTR_FREQ_RANGE = 0x2 NL80211_WIPHY_RADIO_ATTR_INDEX = 0x1 NL80211_WIPHY_RADIO_ATTR_INTERFACE_COMBINATION = 0x3 - NL80211_WIPHY_RADIO_ATTR_MAX = 0x4 + NL80211_WIPHY_RADIO_ATTR_MAX = 0x5 NL80211_WIPHY_RADIO_FREQ_ATTR_END = 0x2 NL80211_WIPHY_RADIO_FREQ_ATTR_MAX = 0x2 NL80211_WIPHY_RADIO_FREQ_ATTR_START = 0x1 diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_386.go b/vendor/golang.org/x/sys/unix/ztypes_linux_386.go index 485f2d3a1b..97ef790deb 100644 --- a/vendor/golang.org/x/sys/unix/ztypes_linux_386.go +++ b/vendor/golang.org/x/sys/unix/ztypes_linux_386.go @@ -354,6 +354,14 @@ type Taskstats struct { Wpcopy_delay_min uint64 Irq_delay_max uint64 Irq_delay_min uint64 + Cpu_delay_max_ts KernelTimespec + Blkio_delay_max_ts KernelTimespec + Swapin_delay_max_ts KernelTimespec + Freepages_delay_max_ts KernelTimespec + Thrashing_delay_max_ts KernelTimespec + Compact_delay_max_ts KernelTimespec + Wpcopy_delay_max_ts KernelTimespec + Irq_delay_max_ts KernelTimespec } type cpuMask uint32 diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_amd64.go b/vendor/golang.org/x/sys/unix/ztypes_linux_amd64.go index ecbd1ad8bc..90b50da680 100644 --- a/vendor/golang.org/x/sys/unix/ztypes_linux_amd64.go +++ b/vendor/golang.org/x/sys/unix/ztypes_linux_amd64.go @@ -367,6 +367,14 @@ type Taskstats struct { Wpcopy_delay_min uint64 Irq_delay_max uint64 Irq_delay_min uint64 + Cpu_delay_max_ts KernelTimespec + Blkio_delay_max_ts KernelTimespec + Swapin_delay_max_ts KernelTimespec + Freepages_delay_max_ts KernelTimespec + Thrashing_delay_max_ts KernelTimespec + Compact_delay_max_ts KernelTimespec + Wpcopy_delay_max_ts KernelTimespec + Irq_delay_max_ts KernelTimespec } type cpuMask uint64 diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_arm.go b/vendor/golang.org/x/sys/unix/ztypes_linux_arm.go index 02f0463a44..acda136851 100644 --- a/vendor/golang.org/x/sys/unix/ztypes_linux_arm.go +++ b/vendor/golang.org/x/sys/unix/ztypes_linux_arm.go @@ -345,6 +345,14 @@ type Taskstats struct { Wpcopy_delay_min uint64 Irq_delay_max uint64 Irq_delay_min uint64 + Cpu_delay_max_ts KernelTimespec + Blkio_delay_max_ts KernelTimespec + Swapin_delay_max_ts KernelTimespec + Freepages_delay_max_ts KernelTimespec + Thrashing_delay_max_ts KernelTimespec + Compact_delay_max_ts KernelTimespec + Wpcopy_delay_max_ts KernelTimespec + Irq_delay_max_ts KernelTimespec } type cpuMask uint32 diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_arm64.go b/vendor/golang.org/x/sys/unix/ztypes_linux_arm64.go index 6f4d400d24..ef7a99e1f9 100644 --- a/vendor/golang.org/x/sys/unix/ztypes_linux_arm64.go +++ b/vendor/golang.org/x/sys/unix/ztypes_linux_arm64.go @@ -346,6 +346,14 @@ type Taskstats struct { Wpcopy_delay_min uint64 Irq_delay_max uint64 Irq_delay_min uint64 + Cpu_delay_max_ts KernelTimespec + Blkio_delay_max_ts KernelTimespec + Swapin_delay_max_ts KernelTimespec + Freepages_delay_max_ts KernelTimespec + Thrashing_delay_max_ts KernelTimespec + Compact_delay_max_ts KernelTimespec + Wpcopy_delay_max_ts KernelTimespec + Irq_delay_max_ts KernelTimespec } type cpuMask uint64 diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_loong64.go b/vendor/golang.org/x/sys/unix/ztypes_linux_loong64.go index cd532cfa55..966063dfc1 100644 --- a/vendor/golang.org/x/sys/unix/ztypes_linux_loong64.go +++ b/vendor/golang.org/x/sys/unix/ztypes_linux_loong64.go @@ -347,6 +347,14 @@ type Taskstats struct { Wpcopy_delay_min uint64 Irq_delay_max uint64 Irq_delay_min uint64 + Cpu_delay_max_ts KernelTimespec + Blkio_delay_max_ts KernelTimespec + Swapin_delay_max_ts KernelTimespec + Freepages_delay_max_ts KernelTimespec + Thrashing_delay_max_ts KernelTimespec + Compact_delay_max_ts KernelTimespec + Wpcopy_delay_max_ts KernelTimespec + Irq_delay_max_ts KernelTimespec } type cpuMask uint64 diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_mips.go b/vendor/golang.org/x/sys/unix/ztypes_linux_mips.go index 4133620851..dc53b20b74 100644 --- a/vendor/golang.org/x/sys/unix/ztypes_linux_mips.go +++ b/vendor/golang.org/x/sys/unix/ztypes_linux_mips.go @@ -350,6 +350,14 @@ type Taskstats struct { Wpcopy_delay_min uint64 Irq_delay_max uint64 Irq_delay_min uint64 + Cpu_delay_max_ts KernelTimespec + Blkio_delay_max_ts KernelTimespec + Swapin_delay_max_ts KernelTimespec + Freepages_delay_max_ts KernelTimespec + Thrashing_delay_max_ts KernelTimespec + Compact_delay_max_ts KernelTimespec + Wpcopy_delay_max_ts KernelTimespec + Irq_delay_max_ts KernelTimespec } type cpuMask uint32 diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_mips64.go b/vendor/golang.org/x/sys/unix/ztypes_linux_mips64.go index eaa37eb718..9ad0aa8c31 100644 --- a/vendor/golang.org/x/sys/unix/ztypes_linux_mips64.go +++ b/vendor/golang.org/x/sys/unix/ztypes_linux_mips64.go @@ -349,6 +349,14 @@ type Taskstats struct { Wpcopy_delay_min uint64 Irq_delay_max uint64 Irq_delay_min uint64 + Cpu_delay_max_ts KernelTimespec + Blkio_delay_max_ts KernelTimespec + Swapin_delay_max_ts KernelTimespec + Freepages_delay_max_ts KernelTimespec + Thrashing_delay_max_ts KernelTimespec + Compact_delay_max_ts KernelTimespec + Wpcopy_delay_max_ts KernelTimespec + Irq_delay_max_ts KernelTimespec } type cpuMask uint64 diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_mips64le.go b/vendor/golang.org/x/sys/unix/ztypes_linux_mips64le.go index 98ae6a1e4a..29d55493d5 100644 --- a/vendor/golang.org/x/sys/unix/ztypes_linux_mips64le.go +++ b/vendor/golang.org/x/sys/unix/ztypes_linux_mips64le.go @@ -349,6 +349,14 @@ type Taskstats struct { Wpcopy_delay_min uint64 Irq_delay_max uint64 Irq_delay_min uint64 + Cpu_delay_max_ts KernelTimespec + Blkio_delay_max_ts KernelTimespec + Swapin_delay_max_ts KernelTimespec + Freepages_delay_max_ts KernelTimespec + Thrashing_delay_max_ts KernelTimespec + Compact_delay_max_ts KernelTimespec + Wpcopy_delay_max_ts KernelTimespec + Irq_delay_max_ts KernelTimespec } type cpuMask uint64 diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_mipsle.go b/vendor/golang.org/x/sys/unix/ztypes_linux_mipsle.go index cae1961594..a4d9e15848 100644 --- a/vendor/golang.org/x/sys/unix/ztypes_linux_mipsle.go +++ b/vendor/golang.org/x/sys/unix/ztypes_linux_mipsle.go @@ -350,6 +350,14 @@ type Taskstats struct { Wpcopy_delay_min uint64 Irq_delay_max uint64 Irq_delay_min uint64 + Cpu_delay_max_ts KernelTimespec + Blkio_delay_max_ts KernelTimespec + Swapin_delay_max_ts KernelTimespec + Freepages_delay_max_ts KernelTimespec + Thrashing_delay_max_ts KernelTimespec + Compact_delay_max_ts KernelTimespec + Wpcopy_delay_max_ts KernelTimespec + Irq_delay_max_ts KernelTimespec } type cpuMask uint32 diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_ppc.go b/vendor/golang.org/x/sys/unix/ztypes_linux_ppc.go index 6ce3b4e028..f8a2977716 100644 --- a/vendor/golang.org/x/sys/unix/ztypes_linux_ppc.go +++ b/vendor/golang.org/x/sys/unix/ztypes_linux_ppc.go @@ -357,6 +357,14 @@ type Taskstats struct { Wpcopy_delay_min uint64 Irq_delay_max uint64 Irq_delay_min uint64 + Cpu_delay_max_ts KernelTimespec + Blkio_delay_max_ts KernelTimespec + Swapin_delay_max_ts KernelTimespec + Freepages_delay_max_ts KernelTimespec + Thrashing_delay_max_ts KernelTimespec + Compact_delay_max_ts KernelTimespec + Wpcopy_delay_max_ts KernelTimespec + Irq_delay_max_ts KernelTimespec } type cpuMask uint32 diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go b/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go index c7429c6a14..4158d6c4ee 100644 --- a/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go +++ b/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go @@ -356,6 +356,14 @@ type Taskstats struct { Wpcopy_delay_min uint64 Irq_delay_max uint64 Irq_delay_min uint64 + Cpu_delay_max_ts KernelTimespec + Blkio_delay_max_ts KernelTimespec + Swapin_delay_max_ts KernelTimespec + Freepages_delay_max_ts KernelTimespec + Thrashing_delay_max_ts KernelTimespec + Compact_delay_max_ts KernelTimespec + Wpcopy_delay_max_ts KernelTimespec + Irq_delay_max_ts KernelTimespec } type cpuMask uint64 diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go b/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go index 4bf4baf4ca..1035af49f7 100644 --- a/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go +++ b/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go @@ -356,6 +356,14 @@ type Taskstats struct { Wpcopy_delay_min uint64 Irq_delay_max uint64 Irq_delay_min uint64 + Cpu_delay_max_ts KernelTimespec + Blkio_delay_max_ts KernelTimespec + Swapin_delay_max_ts KernelTimespec + Freepages_delay_max_ts KernelTimespec + Thrashing_delay_max_ts KernelTimespec + Compact_delay_max_ts KernelTimespec + Wpcopy_delay_max_ts KernelTimespec + Irq_delay_max_ts KernelTimespec } type cpuMask uint64 diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go b/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go index e9709d70af..2297125d3c 100644 --- a/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go +++ b/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go @@ -374,6 +374,14 @@ type Taskstats struct { Wpcopy_delay_min uint64 Irq_delay_max uint64 Irq_delay_min uint64 + Cpu_delay_max_ts KernelTimespec + Blkio_delay_max_ts KernelTimespec + Swapin_delay_max_ts KernelTimespec + Freepages_delay_max_ts KernelTimespec + Thrashing_delay_max_ts KernelTimespec + Compact_delay_max_ts KernelTimespec + Wpcopy_delay_max_ts KernelTimespec + Irq_delay_max_ts KernelTimespec } type cpuMask uint64 diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_s390x.go b/vendor/golang.org/x/sys/unix/ztypes_linux_s390x.go index fb44268ca7..8481e9bd98 100644 --- a/vendor/golang.org/x/sys/unix/ztypes_linux_s390x.go +++ b/vendor/golang.org/x/sys/unix/ztypes_linux_s390x.go @@ -369,6 +369,14 @@ type Taskstats struct { Wpcopy_delay_min uint64 Irq_delay_max uint64 Irq_delay_min uint64 + Cpu_delay_max_ts KernelTimespec + Blkio_delay_max_ts KernelTimespec + Swapin_delay_max_ts KernelTimespec + Freepages_delay_max_ts KernelTimespec + Thrashing_delay_max_ts KernelTimespec + Compact_delay_max_ts KernelTimespec + Wpcopy_delay_max_ts KernelTimespec + Irq_delay_max_ts KernelTimespec } type cpuMask uint64 diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_sparc64.go b/vendor/golang.org/x/sys/unix/ztypes_linux_sparc64.go index 9c38265c74..a6828a0310 100644 --- a/vendor/golang.org/x/sys/unix/ztypes_linux_sparc64.go +++ b/vendor/golang.org/x/sys/unix/ztypes_linux_sparc64.go @@ -351,6 +351,14 @@ type Taskstats struct { Wpcopy_delay_min uint64 Irq_delay_max uint64 Irq_delay_min uint64 + Cpu_delay_max_ts KernelTimespec + Blkio_delay_max_ts KernelTimespec + Swapin_delay_max_ts KernelTimespec + Freepages_delay_max_ts KernelTimespec + Thrashing_delay_max_ts KernelTimespec + Compact_delay_max_ts KernelTimespec + Wpcopy_delay_max_ts KernelTimespec + Irq_delay_max_ts KernelTimespec } type cpuMask uint64 diff --git a/vendor/golang.org/x/sys/windows/syscall_windows.go b/vendor/golang.org/x/sys/windows/syscall_windows.go index 453a7b97f1..9755bca9fd 100644 --- a/vendor/golang.org/x/sys/windows/syscall_windows.go +++ b/vendor/golang.org/x/sys/windows/syscall_windows.go @@ -452,6 +452,7 @@ func NewCallbackCDecl(fn interface{}) uintptr { //sys RtlInitString(destinationString *NTString, sourceString *byte) = ntdll.RtlInitString //sys NtCreateFile(handle *Handle, access uint32, oa *OBJECT_ATTRIBUTES, iosb *IO_STATUS_BLOCK, allocationSize *int64, attributes uint32, share uint32, disposition uint32, options uint32, eabuffer uintptr, ealength uint32) (ntstatus error) = ntdll.NtCreateFile //sys NtCreateNamedPipeFile(pipe *Handle, access uint32, oa *OBJECT_ATTRIBUTES, iosb *IO_STATUS_BLOCK, share uint32, disposition uint32, options uint32, typ uint32, readMode uint32, completionMode uint32, maxInstances uint32, inboundQuota uint32, outputQuota uint32, timeout *int64) (ntstatus error) = ntdll.NtCreateNamedPipeFile +//sys NtQueryInformationFile(handle Handle, iosb *IO_STATUS_BLOCK, outBuffer *byte, outBufferLen uint32, class uint32) (ntstatus error) = ntdll.NtQueryInformationFile //sys NtSetInformationFile(handle Handle, iosb *IO_STATUS_BLOCK, inBuffer *byte, inBufferLen uint32, class uint32) (ntstatus error) = ntdll.NtSetInformationFile //sys RtlDosPathNameToNtPathName(dosName *uint16, ntName *NTUnicodeString, ntFileNamePart *uint16, relativeName *RTL_RELATIVE_NAME) (ntstatus error) = ntdll.RtlDosPathNameToNtPathName_U_WithStatus //sys RtlDosPathNameToRelativeNtPathName(dosName *uint16, ntName *NTUnicodeString, ntFileNamePart *uint16, relativeName *RTL_RELATIVE_NAME) (ntstatus error) = ntdll.RtlDosPathNameToRelativeNtPathName_U_WithStatus @@ -460,6 +461,8 @@ func NewCallbackCDecl(fn interface{}) uintptr { //sys NtSetInformationProcess(proc Handle, procInfoClass int32, procInfo unsafe.Pointer, procInfoLen uint32) (ntstatus error) = ntdll.NtSetInformationProcess //sys NtQuerySystemInformation(sysInfoClass int32, sysInfo unsafe.Pointer, sysInfoLen uint32, retLen *uint32) (ntstatus error) = ntdll.NtQuerySystemInformation //sys NtSetSystemInformation(sysInfoClass int32, sysInfo unsafe.Pointer, sysInfoLen uint32) (ntstatus error) = ntdll.NtSetSystemInformation +//sys NtQueryEaFile(handle Handle, iosb *IO_STATUS_BLOCK, outBuffer *byte, outBufferLen uint32, returnSingleEntry bool, eaList *byte, eaListLen uint32, eaIndex *uint32, restartScan bool) (ntstatus error) = ntdll.NtQueryEaFile +//sys NtSetEaFile(handle Handle, iosb *IO_STATUS_BLOCK, inBuffer *byte, inBufferLen uint32) (ntstatus error) = ntdll.NtSetEaFile //sys RtlAddFunctionTable(functionTable *RUNTIME_FUNCTION, entryCount uint32, baseAddress uintptr) (ret bool) = ntdll.RtlAddFunctionTable //sys RtlDeleteFunctionTable(functionTable *RUNTIME_FUNCTION) (ret bool) = ntdll.RtlDeleteFunctionTable diff --git a/vendor/golang.org/x/sys/windows/types_windows.go b/vendor/golang.org/x/sys/windows/types_windows.go index d82299e33f..d2574a73ee 100644 --- a/vendor/golang.org/x/sys/windows/types_windows.go +++ b/vendor/golang.org/x/sys/windows/types_windows.go @@ -3043,8 +3043,10 @@ const ( ) const ( - // FileInformationClass for NtSetInformationFile + // FileInformationClass for NtSetInformationFile/NtQueryInformationFile, see + // https://learn.microsoft.com/en-us/windows-hardware/drivers/ddi/wdm/ne-wdm-_file_information_class FileBasicInformation = 4 + FileEaInformation = 7 FileRenameInformation = 10 FileDispositionInformation = 13 FilePositionInformation = 14 diff --git a/vendor/golang.org/x/sys/windows/zsyscall_windows.go b/vendor/golang.org/x/sys/windows/zsyscall_windows.go index a506ac0f1e..192d193002 100644 --- a/vendor/golang.org/x/sys/windows/zsyscall_windows.go +++ b/vendor/golang.org/x/sys/windows/zsyscall_windows.go @@ -428,8 +428,11 @@ var ( procNetUserGetInfo = modnetapi32.NewProc("NetUserGetInfo") procNtCreateFile = modntdll.NewProc("NtCreateFile") procNtCreateNamedPipeFile = modntdll.NewProc("NtCreateNamedPipeFile") + procNtQueryEaFile = modntdll.NewProc("NtQueryEaFile") + procNtQueryInformationFile = modntdll.NewProc("NtQueryInformationFile") procNtQueryInformationProcess = modntdll.NewProc("NtQueryInformationProcess") procNtQuerySystemInformation = modntdll.NewProc("NtQuerySystemInformation") + procNtSetEaFile = modntdll.NewProc("NtSetEaFile") procNtSetInformationFile = modntdll.NewProc("NtSetInformationFile") procNtSetInformationProcess = modntdll.NewProc("NtSetInformationProcess") procNtSetSystemInformation = modntdll.NewProc("NtSetSystemInformation") @@ -3740,6 +3743,30 @@ func NtCreateNamedPipeFile(pipe *Handle, access uint32, oa *OBJECT_ATTRIBUTES, i return } +func NtQueryEaFile(handle Handle, iosb *IO_STATUS_BLOCK, outBuffer *byte, outBufferLen uint32, returnSingleEntry bool, eaList *byte, eaListLen uint32, eaIndex *uint32, restartScan bool) (ntstatus error) { + var _p0 uint32 + if returnSingleEntry { + _p0 = 1 + } + var _p1 uint32 + if restartScan { + _p1 = 1 + } + r0, _, _ := syscall.SyscallN(procNtQueryEaFile.Addr(), uintptr(handle), uintptr(unsafe.Pointer(iosb)), uintptr(unsafe.Pointer(outBuffer)), uintptr(outBufferLen), uintptr(_p0), uintptr(unsafe.Pointer(eaList)), uintptr(eaListLen), uintptr(unsafe.Pointer(eaIndex)), uintptr(_p1)) + if r0 != 0 { + ntstatus = NTStatus(r0) + } + return +} + +func NtQueryInformationFile(handle Handle, iosb *IO_STATUS_BLOCK, outBuffer *byte, outBufferLen uint32, class uint32) (ntstatus error) { + r0, _, _ := syscall.SyscallN(procNtQueryInformationFile.Addr(), uintptr(handle), uintptr(unsafe.Pointer(iosb)), uintptr(unsafe.Pointer(outBuffer)), uintptr(outBufferLen), uintptr(class)) + if r0 != 0 { + ntstatus = NTStatus(r0) + } + return +} + func NtQueryInformationProcess(proc Handle, procInfoClass int32, procInfo unsafe.Pointer, procInfoLen uint32, retLen *uint32) (ntstatus error) { r0, _, _ := syscall.SyscallN(procNtQueryInformationProcess.Addr(), uintptr(proc), uintptr(procInfoClass), uintptr(procInfo), uintptr(procInfoLen), uintptr(unsafe.Pointer(retLen))) if r0 != 0 { @@ -3756,6 +3783,14 @@ func NtQuerySystemInformation(sysInfoClass int32, sysInfo unsafe.Pointer, sysInf return } +func NtSetEaFile(handle Handle, iosb *IO_STATUS_BLOCK, inBuffer *byte, inBufferLen uint32) (ntstatus error) { + r0, _, _ := syscall.SyscallN(procNtSetEaFile.Addr(), uintptr(handle), uintptr(unsafe.Pointer(iosb)), uintptr(unsafe.Pointer(inBuffer)), uintptr(inBufferLen)) + if r0 != 0 { + ntstatus = NTStatus(r0) + } + return +} + func NtSetInformationFile(handle Handle, iosb *IO_STATUS_BLOCK, inBuffer *byte, inBufferLen uint32, class uint32) (ntstatus error) { r0, _, _ := syscall.SyscallN(procNtSetInformationFile.Addr(), uintptr(handle), uintptr(unsafe.Pointer(iosb)), uintptr(unsafe.Pointer(inBuffer)), uintptr(inBufferLen), uintptr(class)) if r0 != 0 { diff --git a/vendor/modernc.org/libc/.gitignore b/vendor/modernc.org/libc/.gitignore index a2aa5e6156..81db0e063d 100644 --- a/vendor/modernc.org/libc/.gitignore +++ b/vendor/modernc.org/libc/.gitignore @@ -4,3 +4,4 @@ go.work go.sum musl-* COPYRIGHT-MUSL +.claude/ diff --git a/vendor/modernc.org/libc/CLAUDE.md b/vendor/modernc.org/libc/CLAUDE.md new file mode 100644 index 0000000000..31436c1d46 --- /dev/null +++ b/vendor/modernc.org/libc/CLAUDE.md @@ -0,0 +1,106 @@ +# CLAUDE.md + +This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository. + +## What this is + +`modernc.org/libc` is a partial reimplementation of C libc in pure Go. It is the **runtime** for C programs translated to Go by the `modernc.org/ccgo` transpiler (notably `modernc.org/sqlite`). It is not a standalone library for general use; its API tracks the needs of ccgo-generated code and may change incompatibly between versions. + +Compatibility note: callers of this package (e.g. `modernc.org/sqlite`) must use the libc version that matches their generated code (see the consumer's `go.mod`). Do not bump the libc version of a downstream consumer in isolation without re-translating its C sources. + +## Architectural split: musl-derived vs hand-written + +This is the most important thing to understand before editing any file. There are two completely separate code paths selected by build constraint: + +1. **musl-derived (linux/amd64, arm64, loong64, ppc64le, s390x, riscv64, 386, arm)** — the libc implementation is generated by transpiling musl-libc's C source to Go via `ccgo/v4`. The canonical build tag is: + ``` + //go:build linux && (amd64 || arm64 || loong64 || ppc64le || s390x || riscv64 || 386 || arm) + ``` + Generated files for this path: `ccgo_linux_*.go` (~4 MB each, the bulk of the musl translation), the per-arch `musl_*.go` files written by older tooling, and on amd64 the assembly stubs in `abi0_linux_amd64.{go,s}` (generated by `qbecc --abi0wrap`). The hand-written glue lives in `libc_musl.go`, `etc_musl.go`, `mem_brk_musl.go`, `mem_musl.go`, `memgrind_musl.go`, `pthread_musl.go`, `syscall_musl.go`, `aliases.go`, `atomic.go`, `atomic{32,64}.go`, `builtin{32,64}.go`, `libc_linux_statfs.go`. + +2. **Hand-written (darwin, freebsd, netbsd, openbsd, illumos, windows, linux/mips64le)** — the libc surface is implemented by hand in Go, with the negated build constraint: + ``` + //go:build !(linux && (amd64 || arm64 || loong64 || ppc64le || s390x || riscv64 || 386 || arm)) + ``` + Main files: `libc.go`, `libc_unix.go`, `libc_unix{1,2,3}.go`, `libc_.go`, `libc__.go`, `libc_windows*.go`, `pthread.go`, `mem.go`, `memgrind.go`, `mem_brk.go`. These ports also pull in an older set of ccgo/v3-generated `musl__.go` files for the platform-independent pieces (strtod, math, network, etc.). + +When you make a change you almost always need to make it in both code paths. Look at the existing build tag of the file you're editing — if it has the long `linux && (amd64 || ...)` form, you're in the musl path, and there's a sibling file with the negated tag that needs the parallel change. + +## Common commands + +Build / sanity check: +- `go build ./...` — current platform only +- `make editor` — fast iteration: compile tests to /dev/null, build generator, lint generated asm +- `make build_all_targets` — full cross-compile sweep across all supported GOOS/GOARCH × build tags (slow; required before submitting per `CONTRIBUTING.md`) +- `make vet` — vet, filtering out known abi0 false positives + +Tests: +- `make short-test` — `go test -short` plus log-grep summary +- `make test` — full test, 24h timeout +- `make xtest` — full test with `-tags=ccgo.dmesg,ccgo.assert` (verbose ccgo debugging) +- `make libc-test` — runs only `TestLibc`, which transpiles and runs the musl libc-test suite under `testdata/nsz.repo.hu/libc-test` +- `make xlibc` — `TestLibc` with debug tags +- `make membrk-test` — full test with `-tags=libc.membrk` (the sbrk-style debug allocator) +- Run one test: `go test -v -run TestStrtod -count=1` +- Filter `TestLibc` subtests: `go test -v -run TestLibc -re ''` (the `-re` flag is defined in `all_musl_test.go`) + +Regenerate musl-derived code: +- `make generate` — downloads the pinned musl tarball if needed, re-translates it via `go run generator.go` into `$DIR` (default `/tmp/libc`), then rebuilds and short-tests. **Only works on linux.** Output files (`ccgo_linux_*.go`, etc.) are committed to the repo and should not be hand-edited. +- `make dev` — same as `generate` but with `GO_GENERATE_DEV=1` and `-tags=ccgo.dmesg,ccgo.assert` for ccgo debugging +- Cross-arch generation: set `GO_GENERATE_GOARCH=arm64` etc. The `builder.json` `autogen` regex lists which arches CI auto-regenerates; recent commits like `pi32 auto generate` are these. +- Pinned musl version: `internal/archive/archive.go` (currently `musl-7ada6dde6f9dc6a2836c3d92c2f762d35fd229e0`). + +## Build tags + +Functional tags (passed via `-tags=`): +- `libc.membrk` — replaces malloc with a fixed-size sbrk-style allocator (1 GiB on 64-bit), `free` becomes a no-op, heap pre-filled with PRNG bytes. Used to surface use-after-free in downstream code. +- `libc.memgrind` — wraps the allocator with an audit table; `MemAuditStart` / `MemAuditReport` detect leaks. Adds overhead. +- `libc.dmesg` — appends a per-pid log to `/tmp/libc.log` of major libc events. +- `libc.strace` — flips `__ccgo_strace` to `true` so every `Xfoo` entry prints a trace line. Heavy. +- `libc.memexpvar` — exposes allocator stats through `expvar`. +- `ccgo.dmesg`, `ccgo.assert` — consumed by ccgo during generation, not at runtime. + +`libc.membrk` and `libc.memgrind` are mutually exclusive (the file build tags enforce it). + +## Symbol naming conventions + +ccgo encodes C identifiers with prefixes; the same scheme is used in hand-written files for consistency: +- `Xfoo` — externally visible C function `foo` (e.g. `Xmalloc`, `Xputchar`) +- `Yfoo` — abi0-wrapped entry to `Xfoo` (linux/amd64 only, in `abi0_linux_amd64.go`) +- `Tfoo_t` — typedef'd C type `foo_t` (e.g. `Tsize_t`, `Tssize_t`) +- `Sfoo` — struct tag `foo`, `Ufoo` — union tag, `Ffield` — struct field +- `X__foo` / `X___foo` — C identifiers starting with `_` get folded; both `__errno_location` and `___errno_location` exist +- Lowercase `xfoo`, `_foo` — internal helpers + +`capi__.go` lists every exported symbol — these are the source-of-truth files ccgo consults when linking against this libc. If you add a new `Xfoo`, add it to the relevant `capi_*.go` files too (the generators do this automatically for the musl path). + +## TLS — thread-local state + +A `*TLS` represents a C "thread". Every `Xfoo` takes one as the first argument. `TLS` is **not safe for concurrent use** — one goroutine per `TLS`. + +- Inside an `Xmain`-style entry point: `Start(main)` creates the main TLS, locks the goroutine to the OS thread, and runs `main`. +- Library callers (e.g. sqlite): call `NewTLS()` per goroutine, `defer tls.Close()`. The first `NewTLS()` is the "main" thread and is *not* OS-thread-locked. +- Pthread support: `Xpthread_create` spawns a goroutine with its own TLS. The musl pthread path (`pthread_musl.go`) and the hand-written path (`pthread.go`) implement this separately. +- `tls_linux_amd64.{go,s}` — assembly stubs that let abi0-translated code reach `tls.Alloc` / `tls.Free` without going through Go calling conventions. + +## Subpackages + +The repo contains a constellation of subpackages under `errno/`, `fcntl/`, `pthread/`, `signal/`, `stdio/`, `stdlib/`, `sys/{types,socket,stat,vfs,random}`, `time/`, `unistd/`, `pwd/`, `grp/`, `netdb/`, `netinet/`, etc. They are thin: mostly typedefs and integer constants for use by ccgo-generated callers. They are not meant to be imported by general Go code. + +`internal/archive` — declares the pinned musl version; `internal/autogen` and `internal/overlay` — supporting files for the generator. + +## What is generated vs hand-written + +Code generated (do not hand-edit; regenerate via `make generate`): +- `ccgo_linux_*.go` — the bulk of the musl translation, one per Linux arch +- `musl__.go` — older ccgo/v3 generation for non-Linux ports and some helpers +- `abi0_linux_amd64.{go,s}` — qbecc-generated abi0 wrappers +- `capi_*.go` — exported-symbol manifests (regenerated by ccgo) + +Anything else (`libc.go`, `libc_musl.go`, `libc_.go`, `libc_unix*.go`, `mem*.go`, `pthread*.go`, `aliases.go`, etc.) is hand-written. + +`generate.go` and `genheaders.go` are old (`//go:build ignore`) ccgo/v3 helpers, kept around but mostly superseded by `generator.go` (ccgo/v4). + +## Debugging artifacts in the tree + +Several large files in the repo root are debug logs / surface dumps (`log`, `log-test`, `log-generate`, `surface.old`, `surface.new`). They are tracked but stale; do not depend on their contents. diff --git a/vendor/modernc.org/libc/GEMINI.md b/vendor/modernc.org/libc/GEMINI.md new file mode 100644 index 0000000000..8fe4784c54 --- /dev/null +++ b/vendor/modernc.org/libc/GEMINI.md @@ -0,0 +1,56 @@ +# GEMINI.md + +This file provides guidance for the Gemini AI assistant when working with the `modernc.org/libc` repository. + +## Overview +`modernc.org/libc` is a partial reimplementation of C libc in pure Go. It acts as the runtime for C programs transpiled to Go by the `modernc.org/ccgo` transpiler (used notably by `modernc.org/sqlite`). It is not intended as a general-purpose standalone library. + +**Key Rule:** The API tracks the needs of `ccgo`-generated code. Callers must use the libc version matching their generated code. Do not bump the libc version of downstream consumers without re-translating their C sources. + +## Architecture +The codebase is split into two completely separate code paths, selected by build constraints: + +1. **musl-derived (Linux)** + - Targeted via: `//go:build linux && (amd64 || arm64 || loong64 || ppc64le || s390x || riscv64 || 386 || arm)` + - Generated files: `ccgo_linux_*.go` (~4MB each), per-arch `musl_*.go`, and assembly stubs `abi0_linux_amd64.{go,s}`. **Do not hand-edit generated files**. + - Hand-written glue files: `libc_musl.go`, `etc_musl.go`, `mem_brk_musl.go`, `mem_musl.go`, `memgrind_musl.go`, `pthread_musl.go`, `syscall_musl.go`, `aliases.go`, `atomic.go`, `atomic{32,64}.go`, `builtin{32,64}.go`, `libc_linux_statfs.go`. + +2. **Hand-written (non-Linux / mips64le)** + - Targeted via negated constraints. + - Main files: `libc.go`, `libc_unix.go`, `libc_.go`, `libc_windows*.go`, `pthread.go`, `mem.go`. + - These platforms use handwritten implementations combined with some older `ccgo/v3`-generated `musl__.go` pieces. + +**Important:** When making a change, you usually need to update *both* code paths (the musl path and the hand-written path). + +## Common Commands +- **Build/Lint**: + - `go build ./...` + - `make editor` (fast iteration) + - `make build_all_targets` (full cross-compile, required before submitting) +- **Tests**: + - `make short-test` + - `make test` (full test) + - `make libc-test` (musl libc-test suite) + - `go test -v -run ` +- **Generate** (Linux only): + - `make generate` (downloads musl, translates via `ccgo`, rebuilds, and tests) + +## Build Tags +- `libc.membrk`: Sbrk-style allocator for detecting use-after-free. +- `libc.memgrind`: Allocator audit table for leak detection. +- `libc.dmesg`: Per-pid logging to `/tmp/libc.log`. +- `libc.strace`: Traces C function entries. +- *Note: `libc.membrk` and `libc.memgrind` are mutually exclusive.* + +## Symbol Naming Conventions +- `Xfoo`: Externally visible C function `foo`. +- `Yfoo`: abi0-wrapped entry to `Xfoo` (linux/amd64). +- `Tfoo_t`: Typedef'd C type `foo_t`. +- `Sfoo` / `Ufoo`: Struct / Union tags. +- `Ffield`: Struct field. + +If you add a new `Xfoo` symbol in hand-written files, ensure it is added to the relevant `capi__.go` files. + +## Thread Local State (TLS) +- `*TLS` represents a C "thread". It is passed as the first argument to every `Xfoo` function. +- `TLS` is **not safe for concurrent use**. Use one goroutine per TLS. diff --git a/vendor/modernc.org/libc/atomic.go b/vendor/modernc.org/libc/atomic.go index 6e42a3d0c5..ed42fa4b76 100644 --- a/vendor/modernc.org/libc/atomic.go +++ b/vendor/modernc.org/libc/atomic.go @@ -44,9 +44,15 @@ func _a_ctz_64(tls *TLS, x uint64) int32 { } func AtomicAddFloat32(addr *float32, delta float32) (new float32) { - v := AtomicLoadFloat32(addr) + delta - AtomicStoreFloat32(addr, v) - return v + for { + oldBits := atomic.LoadUint32((*uint32)(unsafe.Pointer(addr))) + oldVal := math.Float32frombits(oldBits) + newVal := oldVal + delta + newBits := math.Float32bits(newVal) + if atomic.CompareAndSwapUint32((*uint32)(unsafe.Pointer(addr)), oldBits, newBits) { + return newVal + } + } } func AtomicLoadFloat32(addr *float32) (val float32) { @@ -58,9 +64,15 @@ func AtomicStoreFloat32(addr *float32, val float32) { } func AtomicAddFloat64(addr *float64, delta float64) (new float64) { - v := AtomicLoadFloat64(addr) + delta - AtomicStoreFloat64(addr, v) - return v + for { + oldBits := atomic.LoadUint64((*uint64)(unsafe.Pointer(addr))) + oldVal := math.Float64frombits(oldBits) + newVal := oldVal + delta + newBits := math.Float64bits(newVal) + if atomic.CompareAndSwapUint64((*uint64)(unsafe.Pointer(addr)), oldBits, newBits) { + return newVal + } + } } func AtomicLoadFloat64(addr *float64) (val float64) { diff --git a/vendor/modernc.org/libc/ccgo_linux_386.go b/vendor/modernc.org/libc/ccgo_linux_386.go index 46b8508876..ab789664ed 100644 --- a/vendor/modernc.org/libc/ccgo_linux_386.go +++ b/vendor/modernc.org/libc/ccgo_linux_386.go @@ -556,7 +556,7 @@ func ___frexp_exp(tls *TLS, x float64, expt uintptr) (r float64) { */ exp_x = Xexp(tls, x-_kln2) hx = uint32(*(*Tuint64_t)(unsafe.Pointer(&exp_x)) >> int32(32)) - *(*int32)(unsafe.Pointer(expt)) = Int32FromUint32(hx>>Int32FromInt32(20) - Uint32FromInt32(Int32FromInt32(0x3ff)+Int32FromInt32(1023)) + _k) + **(**int32)(__ccgo_up(expt)) = Int32FromUint32(hx>>Int32FromInt32(20) - Uint32FromInt32(Int32FromInt32(0x3ff)+Int32FromInt32(1023)) + _k) v1 = uint64(hx&Uint32FromInt32(0xfffff)|Uint32FromInt32((Int32FromInt32(0x3ff)+Int32FromInt32(1023))<>Int32FromInt32(23) - Uint32FromInt32(Int32FromInt32(0x7f)+Int32FromInt32(127)) + _k1) + **(**int32)(__ccgo_up(expt)) = Int32FromUint32(hx>>Int32FromInt32(23) - Uint32FromInt32(Int32FromInt32(0x7f)+Int32FromInt32(127)) + _k1) v1 = hx&uint32(0x7fffff) | Uint32FromInt32((Int32FromInt32(0x7f)+Int32FromInt32(127))< uint32(35) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uint32(0) } } @@ -3289,7 +3289,7 @@ func Xfpathconf(tls *TLS, fd int32, name int32) (r int32) { defer func() { trc("-> %v", r) }() } if Uint32FromInt32(name) >= Uint32FromInt64(42)/Uint32FromInt64(2) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } return int32(_values[name]) @@ -7573,7 +7573,7 @@ func Xsysconf(tls *TLS, name int32) (r int32) { var _ /* si at bp+144 */ Tsysinfo _, _, _, _, _, _, _ = cnt, i, mem, val, v1, v3, v5 if Uint32FromInt32(name) >= Uint32FromInt64(502)/Uint32FromInt64(2) || !(_values1[name] != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } else { if int32(_values1[name]) >= -int32(1) { @@ -7581,13 +7581,13 @@ func Xsysconf(tls *TLS, name int32) (r int32) { } else { if int32(_values1[name]) < -int32(256) { Xgetrlimit(tls, int32(_values1[name])&int32(16383), bp) - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur == ^Uint64FromUint64(0) { + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur == ^Uint64FromUint64(0) { return -int32(1) } - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur > uint64(0x7fffffff) { + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur > uint64(0x7fffffff) { v1 = uint64(0x7fffffff) } else { - v1 = (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur + v1 = (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur } return Int32FromUint64(v1) } @@ -7609,7 +7609,7 @@ func Xsysconf(tls *TLS, name int32) (r int32) { case (-Int32FromInt32(256) | Int32FromInt32(6)) & Int32FromInt32(255): fallthrough case (-Int32FromInt32(256) | Int32FromInt32(7)) & Int32FromInt32(255): - *(*[128]uint8)(unsafe.Pointer(bp + 16)) = [128]uint8{ + **(**[128]uint8)(__ccgo_up(bp + 16)) = [128]uint8{ 0: uint8(1), } X__syscall3(tls, int32(SYS_sched_getaffinity), int32(Int32FromInt32(0)), Int32FromUint32(Uint32FromInt64(128)), int32(bp+16)) @@ -7621,14 +7621,14 @@ func Xsysconf(tls *TLS, name int32) (r int32) { break } for { - if !((*(*[128]uint8)(unsafe.Pointer(bp + 16)))[i] != 0) { + if !((**(**[128]uint8)(__ccgo_up(bp + 16)))[i] != 0) { break } goto _4 _4: ; v5 = bp + 16 + uintptr(i) - *(*uint8)(unsafe.Pointer(v5)) = uint8(int32(*(*uint8)(unsafe.Pointer(v5))) & (Int32FromUint8((*(*[128]uint8)(unsafe.Pointer(bp + 16)))[i]) - Int32FromInt32(1))) + *(*uint8)(unsafe.Pointer(v5)) = uint8(int32(*(*uint8)(unsafe.Pointer(v5))) & (Int32FromUint8((**(**[128]uint8)(__ccgo_up(bp + 16)))[i]) - Int32FromInt32(1))) cnt = cnt + 1 } goto _2 @@ -7641,15 +7641,15 @@ func Xsysconf(tls *TLS, name int32) (r int32) { fallthrough case (-Int32FromInt32(256) | Int32FromInt32(9)) & Int32FromInt32(255): X__lsysinfo(tls, bp+144) - if !((*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fmem_unit != 0) { - (*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fmem_unit = uint32(1) + if !((**(**Tsysinfo)(__ccgo_up(bp + 144))).Fmem_unit != 0) { + (**(**Tsysinfo)(__ccgo_up(bp + 144))).Fmem_unit = uint32(1) } if name == int32(_SC_PHYS_PAGES) { - mem = uint64((*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Ftotalram) + mem = uint64((**(**Tsysinfo)(__ccgo_up(bp + 144))).Ftotalram) } else { - mem = uint64((*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Ffreeram + (*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fbufferram) + mem = uint64((**(**Tsysinfo)(__ccgo_up(bp + 144))).Ffreeram + (**(**Tsysinfo)(__ccgo_up(bp + 144))).Fbufferram) } - mem = mem * uint64((*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fmem_unit) + mem = mem * uint64((**(**Tsysinfo)(__ccgo_up(bp + 144))).Fmem_unit) mem = mem / uint64(PAGESIZE) if mem > uint64(0x7fffffff) { v1 = uint64(0x7fffffff) @@ -9049,7 +9049,7 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { for cond := true; cond; cond = dptr < end { v1 = sptr sptr = sptr + 1 - tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = uint32(**(**uint8)(__ccgo_up(v1))) tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) @@ -9061,7 +9061,7 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { c1 = tmp v1 = sptr sptr = sptr + 1 - tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = uint32(**(**uint8)(__ccgo_up(v1))) tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) @@ -9073,13 +9073,13 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { c2 = tmp v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(c1<>int32(4)) + **(**uint8)(__ccgo_up(v1)) = uint8(c1<>int32(4)) if dptr >= end { break } v1 = sptr sptr = sptr + 1 - tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = uint32(**(**uint8)(__ccgo_up(v1))) tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) @@ -9091,13 +9091,13 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { c3 = tmp v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(c2&uint32(0x0F)<>int32(2)) + **(**uint8)(__ccgo_up(v1)) = uint8(c2&uint32(0x0F)<>int32(2)) if dptr >= end { break } v1 = sptr sptr = sptr + 1 - tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = uint32(**(**uint8)(__ccgo_up(v1))) tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) @@ -9109,7 +9109,7 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { c4 = tmp v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(c3&uint32(0x03)<>int32(2)] + **(**uint8)(__ccgo_up(v1)) = _BF_itoa64[c1>>int32(2)] c1 = c1 & uint32(0x03) << int32(4) if sptr >= end { v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] + **(**uint8)(__ccgo_up(v1)) = _BF_itoa64[c1] break } v1 = sptr sptr = sptr + 1 - c2 = uint32(*(*uint8)(unsafe.Pointer(v1))) + c2 = uint32(**(**uint8)(__ccgo_up(v1))) c1 = c1 | c2>>int32(4) v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] + **(**uint8)(__ccgo_up(v1)) = _BF_itoa64[c1] c1 = c2 & uint32(0x0f) << int32(2) if sptr >= end { v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] + **(**uint8)(__ccgo_up(v1)) = _BF_itoa64[c1] break } v1 = sptr sptr = sptr + 1 - c2 = uint32(*(*uint8)(unsafe.Pointer(v1))) + c2 = uint32(**(**uint8)(__ccgo_up(v1))) c1 = c1 | c2>>int32(6) v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] + **(**uint8)(__ccgo_up(v1)) = _BF_itoa64[c1] v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c2&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _BF_itoa64[c2&uint32(0x3f)] } } @@ -9170,11 +9170,11 @@ func _BF_swap(tls *TLS, x uintptr, count int32) { v1 = int32(1) if *(*int8)(unsafe.Pointer(&v1)) != 0 { for { - tmp = *(*TBF_word)(unsafe.Pointer(x)) + tmp = **(**TBF_word)(__ccgo_up(x)) tmp = tmp<>Int32FromInt32(16) v4 = x x += 4 - *(*TBF_word)(unsafe.Pointer(v4)) = tmp&uint32(0x00FF00FF)<>Int32FromInt32(8)&uint32(0x00FF00FF) + **(**TBF_word)(__ccgo_up(v4)) = tmp&uint32(0x00FF00FF)<>Int32FromInt32(8)&uint32(0x00FF00FF) goto _3 _3: ; @@ -9194,7 +9194,7 @@ func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, e _, _, _, _, _, _, _ = i, ptr, tmp1, tmp2, tmp3, tmp4, v2 ptr = start for cond := true; cond; cond = ptr < end { - L = L ^ *(*TBF_word)(unsafe.Pointer(ctx)) + L = L ^ **(**TBF_word)(__ccgo_up(ctx)) i = 0 for { if !(i < int32(16)) { @@ -9206,12 +9206,12 @@ func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, e tmp3 = L >> int32(16) tmp3 = tmp3 & uint32(0xFF) tmp4 = L >> int32(24) - tmp1 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 3*1024 + uintptr(tmp1)*4)) - tmp2 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 2*1024 + uintptr(tmp2)*4)) - tmp3 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 1*1024 + uintptr(tmp3)*4)) - tmp3 = tmp3 + *(*TBF_word)(unsafe.Pointer(ctx + 72 + uintptr(tmp4)*4)) + tmp1 = **(**TBF_word)(__ccgo_up(ctx + 72 + 3*1024 + uintptr(tmp1)*4)) + tmp2 = **(**TBF_word)(__ccgo_up(ctx + 72 + 2*1024 + uintptr(tmp2)*4)) + tmp3 = **(**TBF_word)(__ccgo_up(ctx + 72 + 1*1024 + uintptr(tmp3)*4)) + tmp3 = tmp3 + **(**TBF_word)(__ccgo_up(ctx + 72 + uintptr(tmp4)*4)) tmp3 = tmp3 ^ tmp2 - R = R ^ *(*TBF_word)(unsafe.Pointer(ctx + uintptr(i+int32(1))*4)) + R = R ^ **(**TBF_word)(__ccgo_up(ctx + uintptr(i+int32(1))*4)) tmp3 = tmp3 + tmp1 R = R ^ tmp3 tmp1 = R & uint32(0xFF) @@ -9220,12 +9220,12 @@ func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, e tmp3 = R >> int32(16) tmp3 = tmp3 & uint32(0xFF) tmp4 = R >> int32(24) - tmp1 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 3*1024 + uintptr(tmp1)*4)) - tmp2 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 2*1024 + uintptr(tmp2)*4)) - tmp3 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 1*1024 + uintptr(tmp3)*4)) - tmp3 = tmp3 + *(*TBF_word)(unsafe.Pointer(ctx + 72 + uintptr(tmp4)*4)) + tmp1 = **(**TBF_word)(__ccgo_up(ctx + 72 + 3*1024 + uintptr(tmp1)*4)) + tmp2 = **(**TBF_word)(__ccgo_up(ctx + 72 + 2*1024 + uintptr(tmp2)*4)) + tmp3 = **(**TBF_word)(__ccgo_up(ctx + 72 + 1*1024 + uintptr(tmp3)*4)) + tmp3 = tmp3 + **(**TBF_word)(__ccgo_up(ctx + 72 + uintptr(tmp4)*4)) tmp3 = tmp3 ^ tmp2 - L = L ^ *(*TBF_word)(unsafe.Pointer(ctx + uintptr(i+int32(1)+int32(1))*4)) + L = L ^ **(**TBF_word)(__ccgo_up(ctx + uintptr(i+int32(1)+int32(1))*4)) tmp3 = tmp3 + tmp1 L = L ^ tmp3 goto _1 @@ -9235,13 +9235,13 @@ func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, e } tmp4 = R R = L - L = tmp4 ^ *(*TBF_word)(unsafe.Pointer(ctx + uintptr(Int32FromInt32(BF_N)+Int32FromInt32(1))*4)) + L = tmp4 ^ **(**TBF_word)(__ccgo_up(ctx + uintptr(Int32FromInt32(BF_N)+Int32FromInt32(1))*4)) v2 = ptr ptr += 4 - *(*TBF_word)(unsafe.Pointer(v2)) = L + **(**TBF_word)(__ccgo_up(v2)) = L v2 = ptr ptr += 4 - *(*TBF_word)(unsafe.Pointer(v2)) = R + **(**TBF_word)(__ccgo_up(v2)) = R } return L } @@ -9301,17 +9301,17 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags break } v1 = Uint32FromInt32(0) - (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)] = v1 - (*(*[2]TBF_word)(unsafe.Pointer(bp)))[0] = v1 + (**(**[2]TBF_word)(__ccgo_up(bp)))[int32(1)] = v1 + (**(**[2]TBF_word)(__ccgo_up(bp)))[0] = v1 j = uint32(0) for { if !(j < uint32(4)) { break } - *(*TBF_word)(unsafe.Pointer(bp)) <<= uint32(8) - *(*TBF_word)(unsafe.Pointer(bp)) |= uint32(Uint8FromInt8(*(*int8)(unsafe.Pointer(ptr)))) /* correct */ - *(*TBF_word)(unsafe.Pointer(bp + 1*4)) <<= uint32(8) - *(*TBF_word)(unsafe.Pointer(bp + 1*4)) |= Uint32FromInt8(*(*int8)(unsafe.Pointer(ptr))) /* bug */ + **(**TBF_word)(__ccgo_up(bp)) <<= uint32(8) + **(**TBF_word)(__ccgo_up(bp)) |= uint32(Uint8FromInt8(**(**int8)(__ccgo_up(ptr)))) /* correct */ + **(**TBF_word)(__ccgo_up(bp + 1*4)) <<= uint32(8) + **(**TBF_word)(__ccgo_up(bp + 1*4)) |= Uint32FromInt8(int8(**(**int8)(__ccgo_up(ptr)))) /* bug */ /* * Sign extension in the first char has no effect - nothing to overwrite yet, * and those extra 24 bits will be fully shifted out of the 32-bit word. For @@ -9319,9 +9319,9 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags * extension in tmp[1] occurs. Once this flag is set, it remains set. */ if j != 0 { - sign = sign | (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)]&uint32(0x80) + sign = sign | (**(**[2]TBF_word)(__ccgo_up(bp)))[int32(1)]&uint32(0x80) } - if !(*(*int8)(unsafe.Pointer(ptr)) != 0) { + if !(**(**int8)(__ccgo_up(ptr)) != 0) { ptr = key } else { ptr = ptr + 1 @@ -9331,9 +9331,9 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags ; j = j + 1 } - diff = diff | ((*(*[2]TBF_word)(unsafe.Pointer(bp)))[0] ^ (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)]) /* Non-zero on any differences */ - *(*TBF_word)(unsafe.Pointer(expanded + uintptr(i)*4)) = (*(*[2]TBF_word)(unsafe.Pointer(bp)))[bug] - *(*TBF_word)(unsafe.Pointer(initial + uintptr(i)*4)) = *(*TBF_word)(unsafe.Pointer(uintptr(unsafe.Pointer(&_BF_init_state)) + uintptr(i)*4)) ^ (*(*[2]TBF_word)(unsafe.Pointer(bp)))[bug] + diff = diff | ((**(**[2]TBF_word)(__ccgo_up(bp)))[0] ^ (**(**[2]TBF_word)(__ccgo_up(bp)))[int32(1)]) /* Non-zero on any differences */ + **(**TBF_word)(__ccgo_up(expanded + uintptr(i)*4)) = (**(**[2]TBF_word)(__ccgo_up(bp)))[bug] + **(**TBF_word)(__ccgo_up(initial + uintptr(i)*4)) = **(**TBF_word)(__ccgo_up(uintptr(unsafe.Pointer(&_BF_init_state)) + uintptr(i)*4)) ^ (**(**[2]TBF_word)(__ccgo_up(bp)))[bug] goto _2 _2: ; @@ -9364,7 +9364,7 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags * state that could be directly specified by a password to the buggy algorithm * (and to the fully correct one as well, but that's a side-effect). */ - *(*TBF_word)(unsafe.Pointer(initial)) ^= sign + **(**TBF_word)(__ccgo_up(initial)) ^= sign } var _flags_by_subtype = [26]uint8{ @@ -9391,28 +9391,28 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w } } _, _, _, _, _, _, _, _, _, _, _, _ = L, L1, R, count, done, i, ptr, tmp1, tmp2, tmp3, tmp4, v1 - if int32(*(*int8)(unsafe.Pointer(setting))) != int32('$') || int32(*(*int8)(unsafe.Pointer(setting + 1))) != int32('2') || Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(setting + 2)))-int32('a')) > uint32(25) || !(_flags_by_subtype[int32(*(*int8)(unsafe.Pointer(setting + 2)))-int32('a')] != 0) || int32(*(*int8)(unsafe.Pointer(setting + 3))) != int32('$') || Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(setting + 4)))-int32('0')) > uint32(1) || Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(setting + 5)))-int32('0')) > uint32(9) || int32(*(*int8)(unsafe.Pointer(setting + 6))) != int32('$') { + if int32(**(**int8)(__ccgo_up(setting))) != int32('$') || int32(**(**int8)(__ccgo_up(setting + 1))) != int32('2') || Uint32FromInt32(int32(**(**int8)(__ccgo_up(setting + 2)))-int32('a')) > uint32(25) || !(_flags_by_subtype[int32(**(**int8)(__ccgo_up(setting + 2)))-int32('a')] != 0) || int32(**(**int8)(__ccgo_up(setting + 3))) != int32('$') || Uint32FromInt32(int32(**(**int8)(__ccgo_up(setting + 4)))-int32('0')) > uint32(1) || Uint32FromInt32(int32(**(**int8)(__ccgo_up(setting + 5)))-int32('0')) > uint32(9) || int32(**(**int8)(__ccgo_up(setting + 6))) != int32('$') { return UintptrFromInt32(0) } - count = Uint32FromInt32(1) << ((int32(*(*int8)(unsafe.Pointer(setting + 4)))-int32('0'))*int32(10) + (int32(*(*int8)(unsafe.Pointer(setting + 5))) - int32('0'))) + count = Uint32FromInt32(1) << ((int32(**(**int8)(__ccgo_up(setting + 4)))-int32('0'))*int32(10) + (int32(**(**int8)(__ccgo_up(setting + 5))) - int32('0'))) if count < min || _BF_decode(tls, bp+4240, setting+7, int32(16)) != 0 { return UintptrFromInt32(0) } _BF_swap(tls, bp+4240, int32(4)) - _BF_set_key(tls, key, bp+4168, bp, _flags_by_subtype[int32(*(*int8)(unsafe.Pointer(setting + 2)))-int32('a')]) + _BF_set_key(tls, key, bp+4168, bp, _flags_by_subtype[int32(**(**int8)(__ccgo_up(setting + 2)))-int32('a')]) Xmemcpy(tls, bp+72, uintptr(unsafe.Pointer(&_BF_init_state))+72, uint32(4096)) L = uint32(0) R = uint32(0) ptr = bp for cond := true; cond; cond = int32(1) != 0 { - L = _BF_encrypt(tls, bp, L^*(*TBF_word)(unsafe.Pointer(bp + 4240)), R^*(*TBF_word)(unsafe.Pointer(bp + 4240 + 1*4)), ptr, ptr) - R = *(*TBF_word)(unsafe.Pointer(ptr + UintptrFromInt32(1)*4)) + L = _BF_encrypt(tls, bp, L^**(**TBF_word)(__ccgo_up(bp + 4240)), R^**(**TBF_word)(__ccgo_up(bp + 4240 + 1*4)), ptr, ptr) + R = **(**TBF_word)(__ccgo_up(ptr + UintptrFromInt32(1)*4)) ptr = ptr + uintptr(2)*4 if ptr >= bp+uintptr(Int32FromInt32(BF_N)+Int32FromInt32(2)+Int32FromInt32(4)*Int32FromInt32(0x100))*4 { break } - L = _BF_encrypt(tls, bp, L^*(*TBF_word)(unsafe.Pointer(bp + 4240 + 2*4)), R^*(*TBF_word)(unsafe.Pointer(bp + 4240 + 3*4)), ptr, ptr) - R = *(*TBF_word)(unsafe.Pointer(ptr + UintptrFromInt32(1)*4)) + L = _BF_encrypt(tls, bp, L^**(**TBF_word)(__ccgo_up(bp + 4240 + 2*4)), R^**(**TBF_word)(__ccgo_up(bp + 4240 + 3*4)), ptr, ptr) + R = **(**TBF_word)(__ccgo_up(ptr + UintptrFromInt32(1)*4)) ptr = ptr + uintptr(2)*4 } for { @@ -9421,8 +9421,8 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w if !(i < Int32FromInt32(BF_N)+Int32FromInt32(2)) { break } - *(*TBF_word)(unsafe.Pointer(bp + uintptr(i)*4)) ^= *(*TBF_word)(unsafe.Pointer(bp + 4168 + uintptr(i)*4)) - *(*TBF_word)(unsafe.Pointer(bp + uintptr(i+int32(1))*4)) ^= *(*TBF_word)(unsafe.Pointer(bp + 4168 + uintptr(i+int32(1))*4)) + **(**TBF_word)(__ccgo_up(bp + uintptr(i)*4)) ^= **(**TBF_word)(__ccgo_up(bp + 4168 + uintptr(i)*4)) + **(**TBF_word)(__ccgo_up(bp + uintptr(i+int32(1))*4)) ^= **(**TBF_word)(__ccgo_up(bp + 4168 + uintptr(i+int32(1))*4)) goto _3 _3: ; @@ -9435,26 +9435,26 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w break } done = int32(1) - tmp1 = *(*TBF_word)(unsafe.Pointer(bp + 4240)) - tmp2 = *(*TBF_word)(unsafe.Pointer(bp + 4240 + 1*4)) - tmp3 = *(*TBF_word)(unsafe.Pointer(bp + 4240 + 2*4)) - tmp4 = *(*TBF_word)(unsafe.Pointer(bp + 4240 + 3*4)) + tmp1 = **(**TBF_word)(__ccgo_up(bp + 4240)) + tmp2 = **(**TBF_word)(__ccgo_up(bp + 4240 + 1*4)) + tmp3 = **(**TBF_word)(__ccgo_up(bp + 4240 + 2*4)) + tmp4 = **(**TBF_word)(__ccgo_up(bp + 4240 + 3*4)) i = 0 for { if !(i < int32(BF_N)) { break } - *(*TBF_word)(unsafe.Pointer(bp + uintptr(i)*4)) ^= tmp1 - *(*TBF_word)(unsafe.Pointer(bp + uintptr(i+int32(1))*4)) ^= tmp2 - *(*TBF_word)(unsafe.Pointer(bp + uintptr(i+int32(2))*4)) ^= tmp3 - *(*TBF_word)(unsafe.Pointer(bp + uintptr(i+int32(3))*4)) ^= tmp4 + **(**TBF_word)(__ccgo_up(bp + uintptr(i)*4)) ^= tmp1 + **(**TBF_word)(__ccgo_up(bp + uintptr(i+int32(1))*4)) ^= tmp2 + **(**TBF_word)(__ccgo_up(bp + uintptr(i+int32(2))*4)) ^= tmp3 + **(**TBF_word)(__ccgo_up(bp + uintptr(i+int32(3))*4)) ^= tmp4 goto _4 _4: ; i = i + int32(4) } - *(*TBF_word)(unsafe.Pointer(bp + 16*4)) ^= tmp1 - *(*TBF_word)(unsafe.Pointer(bp + 17*4)) ^= tmp2 + **(**TBF_word)(__ccgo_up(bp + 16*4)) ^= tmp1 + **(**TBF_word)(__ccgo_up(bp + 17*4)) ^= tmp2 } goto _2 _2: @@ -9471,10 +9471,10 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w break } L1 = _BF_magic_w[i] - (*(*[2]TBF_word)(unsafe.Pointer(bp + 4264)))[int32(1)] = _BF_magic_w[i+int32(1)] + (**(**[2]TBF_word)(__ccgo_up(bp + 4264)))[int32(1)] = _BF_magic_w[i+int32(1)] count = uint32(64) for { - L1 = _BF_encrypt(tls, bp, L1, (*(*[2]TBF_word)(unsafe.Pointer(bp + 4264)))[int32(1)], bp+4264, bp+4264) + L1 = _BF_encrypt(tls, bp, L1, (**(**[2]TBF_word)(__ccgo_up(bp + 4264)))[int32(1)], bp+4264, bp+4264) goto _7 _7: ; @@ -9484,20 +9484,20 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w break } } - *(*TBF_word)(unsafe.Pointer(bp + 4240 + uintptr(i)*4)) = L1 - *(*TBF_word)(unsafe.Pointer(bp + 4240 + uintptr(i+int32(1))*4)) = (*(*[2]TBF_word)(unsafe.Pointer(bp + 4264)))[int32(1)] + **(**TBF_word)(__ccgo_up(bp + 4240 + uintptr(i)*4)) = L1 + **(**TBF_word)(__ccgo_up(bp + 4240 + uintptr(i+int32(1))*4)) = (**(**[2]TBF_word)(__ccgo_up(bp + 4264)))[int32(1)] goto _5 _5: ; i = i + int32(2) } Xmemcpy(tls, output, setting, Uint32FromInt32(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1))) - *(*int8)(unsafe.Pointer(output + uintptr(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1)))) = Int8FromUint8(_BF_itoa64[Int32FromUint8(_BF_atoi64[int32(*(*int8)(unsafe.Pointer(setting + uintptr(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1)))))-int32(0x20)])&int32(0x30)]) + **(**int8)(__ccgo_up(output + uintptr(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1)))) = Int8FromUint8(_BF_itoa64[Int32FromUint8(_BF_atoi64[int32(**(**int8)(__ccgo_up(setting + uintptr(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1)))))-int32(0x20)])&int32(0x30)]) /* This has to be bug-compatible with the original implementation, so * only encode 23 of the 24 bytes. :-) */ _BF_swap(tls, bp+4240, int32(6)) _BF_encode(tls, output+uintptr(Int32FromInt32(7)+Int32FromInt32(22)), bp+4240, int32(23)) - *(*int8)(unsafe.Pointer(output + uintptr(Int32FromInt32(7)+Int32FromInt32(22)+Int32FromInt32(31)))) = int8('\000') + **(**int8)(__ccgo_up(output + uintptr(Int32FromInt32(7)+Int32FromInt32(22)+Int32FromInt32(31)))) = int8('\000') return output } @@ -9556,19 +9556,19 @@ func X__crypt_blowfish(tls *TLS, key uintptr, setting uintptr, output uintptr) ( */ Xmemcpy(tls, bp, test_setting, uint32(30)) if retval != 0 { - flags = uint32(_flags_by_subtype[int32(*(*int8)(unsafe.Pointer(setting + 2)))-int32('a')]) + flags = uint32(_flags_by_subtype[int32(**(**int8)(__ccgo_up(setting + 2)))-int32('a')]) test_hash = uintptr(unsafe.Pointer(&_test_hashes)) + uintptr(flags&uint32(1))*34 - *(*int8)(unsafe.Pointer(bp + 2)) = *(*int8)(unsafe.Pointer(setting + 2)) + **(**int8)(__ccgo_up(bp + 2)) = **(**int8)(__ccgo_up(setting + 2)) } Xmemset(tls, bp+30, int32(0x55), uint32(63)) - *(*int8)(unsafe.Pointer(bp + 30 + uintptr(Uint32FromInt64(63)-Uint32FromInt32(1)))) = 0 + **(**int8)(__ccgo_up(bp + 30 + uintptr(Uint32FromInt64(63)-Uint32FromInt32(1)))) = 0 p = _BF_crypt(tls, test_key, bp, bp+30, uint32(1)) ok = BoolInt32(p == bp+30 && !(Xmemcmp(tls, p, bp, Uint32FromInt32(Int32FromInt32(7)+Int32FromInt32(22))) != 0) && !(Xmemcmp(tls, p+uintptr(Int32FromInt32(7)+Int32FromInt32(22)), test_hash, Uint32FromInt32(Int32FromInt32(31)+Int32FromInt32(1)+Int32FromInt32(1)+Int32FromInt32(1))) != 0)) k = __ccgo_ts + 58 - _BF_set_key(tls, k, bp+96, bp+168, uint8(2)) /* $2a$ */ - _BF_set_key(tls, k, bp+240, bp+312, uint8(4)) /* $2y$ */ - *(*TBF_word)(unsafe.Pointer(bp + 168)) ^= uint32(0x10000) /* undo the safety (for comparison) */ - ok = BoolInt32(ok != 0 && (*(*TBF_key)(unsafe.Pointer(bp + 168)))[0] == uint32(0xdb9c59bc) && (*(*TBF_key)(unsafe.Pointer(bp + 240)))[int32(17)] == uint32(0x33343500) && !(Xmemcmp(tls, bp+96, bp+240, uint32(72)) != 0) && !(Xmemcmp(tls, bp+168, bp+312, uint32(72)) != 0)) + _BF_set_key(tls, k, bp+96, bp+168, uint8(2)) /* $2a$ */ + _BF_set_key(tls, k, bp+240, bp+312, uint8(4)) /* $2y$ */ + **(**TBF_word)(__ccgo_up(bp + 168)) ^= uint32(0x10000) /* undo the safety (for comparison) */ + ok = BoolInt32(ok != 0 && (**(**TBF_key)(__ccgo_up(bp + 168)))[0] == uint32(0xdb9c59bc) && (**(**TBF_key)(__ccgo_up(bp + 240)))[int32(17)] == uint32(0x33343500) && !(Xmemcmp(tls, bp+96, bp+240, uint32(72)) != 0) && !(Xmemcmp(tls, bp+168, bp+312, uint32(72)) != 0)) if ok != 0 && retval != 0 { return retval } @@ -11418,8 +11418,8 @@ func X__des_setkey(tls *TLS, key uintptr, ekey uintptr) { var i, ibit, j, round, shifts uint32 var k0, k1, kl, kr, rawkey0, rawkey1, t0, t1, v1 Tuint32_t _, _, _, _, _, _, _, _, _, _, _, _, _, _ = i, ibit, j, k0, k1, kl, kr, rawkey0, rawkey1, round, shifts, t0, t1, v1 - rawkey0 = uint32(*(*uint8)(unsafe.Pointer(key + 3))) | uint32(*(*uint8)(unsafe.Pointer(key + 2)))<>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskl)) + uintptr(i+uint32(4))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4))) - k1 = k1 | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j)*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) + k0 = k0 | (**(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_key_perm_maskl)) + uintptr(i)*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_key_perm_maskl)) + uintptr(i+uint32(4))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4))) + k1 = k1 | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j)*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) ibit = ibit - uint32(4) - k1 = k1 | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j+uint32(1))*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(i+uint32(8))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4))) + k1 = k1 | (**(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j+uint32(1))*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(i+uint32(8))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4))) goto _2 _2: ; @@ -11464,19 +11464,19 @@ func X__des_setkey(tls *TLS, key uintptr, ekey uintptr) { if !(i < uint32(4)) { break } - kl = kl | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskl0)) + uintptr(i)*32 + uintptr(t0>>ibit&uint32(7))*4)) - kr = kr | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskr0)) + uintptr(i)*32 + uintptr(t1>>ibit&uint32(7))*4)) + kl = kl | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_comp_maskl0)) + uintptr(i)*32 + uintptr(t0>>ibit&uint32(7))*4)) + kr = kr | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_comp_maskr0)) + uintptr(i)*32 + uintptr(t1>>ibit&uint32(7))*4)) ibit = ibit - uint32(4) - kl = kl | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskl1)) + uintptr(i)*64 + uintptr(t0>>ibit&uint32(0xf))*4)) - kr = kr | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskr1)) + uintptr(i)*64 + uintptr(t1>>ibit&uint32(0xf))*4)) + kl = kl | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_comp_maskl1)) + uintptr(i)*64 + uintptr(t0>>ibit&uint32(0xf))*4)) + kr = kr | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_comp_maskr1)) + uintptr(i)*64 + uintptr(t1>>ibit&uint32(0xf))*4)) ibit = ibit - uint32(3) goto _5 _5: ; i = i + 1 } - *(*Tuint32_t)(unsafe.Pointer(ekey + uintptr(round)*4)) = kl - *(*Tuint32_t)(unsafe.Pointer(ekey + 64 + uintptr(round)*4)) = kr + **(**Tuint32_t)(__ccgo_up(ekey + uintptr(round)*4)) = kl + **(**Tuint32_t)(__ccgo_up(ekey + 64 + uintptr(round)*4)) = kr goto _3 _3: ; @@ -11510,8 +11510,8 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui if !(i < uint32(8)) { break } - l = l | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4))) - r = r | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4))) + l = l | (**(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4))) + r = r | (**(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4))) goto _2 _2: ; @@ -11549,15 +11549,15 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui f = (r48l ^ r48r) & saltbits v5 = kl kl += 4 - r48l = r48l ^ (f ^ *(*Tuint32_t)(unsafe.Pointer(v5))) + r48l = r48l ^ (f ^ **(**Tuint32_t)(__ccgo_up(v5))) v5 = kr kr += 4 - r48r = r48r ^ (f ^ *(*Tuint32_t)(unsafe.Pointer(v5))) + r48r = r48r ^ (f ^ **(**Tuint32_t)(__ccgo_up(v5))) /* * Do S-box lookups (which shrink it back to 32 bits) * and do the P-box permutation at the same time. */ - f = *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + uintptr(r48l>>int32(18))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 1*256 + uintptr(r48l>>Int32FromInt32(12)&uint32(0x3f))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 2*256 + uintptr(r48l>>Int32FromInt32(6)&uint32(0x3f))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 3*256 + uintptr(r48l&uint32(0x3f))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 4*256 + uintptr(r48r>>int32(18))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 5*256 + uintptr(r48r>>Int32FromInt32(12)&uint32(0x3f))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 6*256 + uintptr(r48r>>Int32FromInt32(6)&uint32(0x3f))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 7*256 + uintptr(r48r&uint32(0x3f))*4)) + f = **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + uintptr(r48l>>int32(18))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 1*256 + uintptr(r48l>>Int32FromInt32(12)&uint32(0x3f))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 2*256 + uintptr(r48l>>Int32FromInt32(6)&uint32(0x3f))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 3*256 + uintptr(r48l&uint32(0x3f))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 4*256 + uintptr(r48r>>int32(18))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 5*256 + uintptr(r48r>>Int32FromInt32(12)&uint32(0x3f))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 6*256 + uintptr(r48r>>Int32FromInt32(6)&uint32(0x3f))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 7*256 + uintptr(r48r&uint32(0x3f))*4)) /* * Now that we've permuted things, complete f(). */ @@ -11580,17 +11580,17 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui if !(i1 < uint32(4)) { break } - ro = ro | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4))) + ro = ro | (**(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4))) ibit1 = ibit1 - uint32(4) - lo = lo | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4))) + lo = lo | (**(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4))) goto _8 _8: ; i1 = i1 + 1 ibit1 = ibit1 - uint32(4) } - *(*Tuint32_t)(unsafe.Pointer(l_out)) = lo - *(*Tuint32_t)(unsafe.Pointer(r_out)) = ro + **(**Tuint32_t)(__ccgo_up(l_out)) = lo + **(**Tuint32_t)(__ccgo_up(r_out)) = ro } func _des_cipher(tls *TLS, in uintptr, out uintptr, count Tuint32_t, saltbits Tuint32_t, ekey uintptr) { @@ -11600,17 +11600,17 @@ func _des_cipher(tls *TLS, in uintptr, out uintptr, count Tuint32_t, saltbits Tu var _ /* l_out at bp+0 */ Tuint32_t var _ /* r_out at bp+4 */ Tuint32_t _, _ = rawl, rawr - rawl = uint32(*(*uint8)(unsafe.Pointer(in + 3))) | uint32(*(*uint8)(unsafe.Pointer(in + 2)))<> int32(24)) - *(*uint8)(unsafe.Pointer(out + 1)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp)) >> int32(16)) - *(*uint8)(unsafe.Pointer(out + 2)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp)) >> int32(8)) - *(*uint8)(unsafe.Pointer(out + 3)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp))) - *(*uint8)(unsafe.Pointer(out + 4)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp + 4)) >> int32(24)) - *(*uint8)(unsafe.Pointer(out + 5)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp + 4)) >> int32(16)) - *(*uint8)(unsafe.Pointer(out + 6)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp + 4)) >> int32(8)) - *(*uint8)(unsafe.Pointer(out + 7)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp + 4))) + **(**uint8)(__ccgo_up(out)) = uint8(**(**Tuint32_t)(__ccgo_up(bp)) >> int32(24)) + **(**uint8)(__ccgo_up(out + 1)) = uint8(**(**Tuint32_t)(__ccgo_up(bp)) >> int32(16)) + **(**uint8)(__ccgo_up(out + 2)) = uint8(**(**Tuint32_t)(__ccgo_up(bp)) >> int32(8)) + **(**uint8)(__ccgo_up(out + 3)) = uint8(**(**Tuint32_t)(__ccgo_up(bp))) + **(**uint8)(__ccgo_up(out + 4)) = uint8(**(**Tuint32_t)(__ccgo_up(bp + 4)) >> int32(24)) + **(**uint8)(__ccgo_up(out + 5)) = uint8(**(**Tuint32_t)(__ccgo_up(bp + 4)) >> int32(16)) + **(**uint8)(__ccgo_up(out + 6)) = uint8(**(**Tuint32_t)(__ccgo_up(bp + 4)) >> int32(8)) + **(**uint8)(__ccgo_up(out + 7)) = uint8(**(**Tuint32_t)(__ccgo_up(bp + 4))) } func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uintptr) (r uintptr) { @@ -11634,13 +11634,13 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin for q <= bp+128+uintptr(Uint32FromInt64(8)-Uint32FromInt32(1)) { v1 = q q = q + 1 - *(*uint8)(unsafe.Pointer(v1)) = Uint8FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(key))) << int32(1)) - if *(*uint8)(unsafe.Pointer(key)) != 0 { + **(**uint8)(__ccgo_up(v1)) = Uint8FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(key))) << int32(1)) + if **(**uint8)(__ccgo_up(key)) != 0 { key = key + 1 } } X__des_setkey(tls, bp+128, bp) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(setting))) == int32('_') { + if Int32FromUint8(**(**uint8)(__ccgo_up(setting))) == int32('_') { /* * "new"-style: * setting - underscore, 4 chars of count, 4 chars of salt @@ -11652,8 +11652,8 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin if !(i < uint32(5)) { break } - value = _ascii_to_bin(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(i))))) - if Int32FromUint8(_ascii64[value]) != Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(i)))) { + value = _ascii_to_bin(tls, Int32FromUint8(**(**uint8)(__ccgo_up(setting + uintptr(i))))) + if Int32FromUint8(_ascii64[value]) != Int32FromUint8(**(**uint8)(__ccgo_up(setting + uintptr(i)))) { return UintptrFromInt32(0) } count = count | value<<((i-uint32(1))*uint32(6)) @@ -11671,8 +11671,8 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin if !(i < uint32(9)) { break } - value1 = _ascii_to_bin(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(i))))) - if Int32FromUint8(_ascii64[value1]) != Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(i)))) { + value1 = _ascii_to_bin(tls, Int32FromUint8(**(**uint8)(__ccgo_up(setting + uintptr(i))))) + if Int32FromUint8(_ascii64[value1]) != Int32FromUint8(**(**uint8)(__ccgo_up(setting + uintptr(i)))) { return UintptrFromInt32(0) } salt = salt | value1<<((i-uint32(5))*uint32(6)) @@ -11681,7 +11681,7 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin ; i = i + 1 } - for *(*uint8)(unsafe.Pointer(key)) != 0 { + for **(**uint8)(__ccgo_up(key)) != 0 { /* * Encrypt the key with itself. */ @@ -11690,18 +11690,18 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin * And XOR with the next 8 characters of the key. */ q = bp + 128 - for q <= bp+128+uintptr(Uint32FromInt64(8)-Uint32FromInt32(1)) && *(*uint8)(unsafe.Pointer(key)) != 0 { + for q <= bp+128+uintptr(Uint32FromInt64(8)-Uint32FromInt32(1)) && **(**uint8)(__ccgo_up(key)) != 0 { v4 = q q = q + 1 v1 = v4 v5 = key key = key + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(int32(*(*uint8)(unsafe.Pointer(v1))) ^ Int32FromUint8(*(*uint8)(unsafe.Pointer(v5)))<> int32(8) + l = **(**Tuint32_t)(__ccgo_up(bp + 136)) >> int32(8) v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l&uint32(0x3f)] - l = *(*Tuint32_t)(unsafe.Pointer(bp + 136))<>Int32FromInt32(16)&uint32(0xffff) + **(**uint8)(__ccgo_up(v1)) = _ascii64[l&uint32(0x3f)] + l = **(**Tuint32_t)(__ccgo_up(bp + 136))<>Int32FromInt32(16)&uint32(0xffff) v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l&uint32(0x3f)] - l = *(*Tuint32_t)(unsafe.Pointer(bp + 140)) << int32(2) + **(**uint8)(__ccgo_up(v1)) = _ascii64[l&uint32(0x3f)] + l = **(**Tuint32_t)(__ccgo_up(bp + 140)) << int32(2) v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l&uint32(0x3f)] - *(*uint8)(unsafe.Pointer(p)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = _ascii64[l&uint32(0x3f)] + **(**uint8)(__ccgo_up(p)) = uint8(0) return output } @@ -11778,7 +11778,7 @@ func X__crypt_des(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uin test_key = __ccgo_ts + 72 test_setting = __ccgo_ts + 93 test_hash = __ccgo_ts + 103 - if int32(*(*int8)(unsafe.Pointer(setting))) != int32('_') { + if int32(**(**int8)(__ccgo_up(setting))) != int32('_') { test_setting = __ccgo_ts + 124 test_hash = __ccgo_ts + 127 } @@ -11797,7 +11797,7 @@ func X__crypt_des(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uin if p != 0 && !(Xstrcmp(tls, p, test_hash) != 0) && retval != 0 { return retval } - if int32(*(*int8)(unsafe.Pointer(setting))) == int32('*') { + if int32(**(**int8)(__ccgo_up(setting))) == int32('*') { v1 = __ccgo_ts + 141 } else { v1 = __ccgo_ts + 70 @@ -11898,80 +11898,80 @@ func _processblock(tls *TLS, s uintptr, buf uintptr) { if !(i < uint32(16)) { break } - (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] = uint32(*(*Tuint8_t)(unsafe.Pointer(buf + uintptr(uint32(4)*i)))) - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(i)*4)) |= uint32(*(*Tuint8_t)(unsafe.Pointer(buf + uintptr(uint32(4)*i+uint32(1))))) << int32(8) - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(i)*4)) |= uint32(*(*Tuint8_t)(unsafe.Pointer(buf + uintptr(uint32(4)*i+uint32(2))))) << int32(16) - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(i)*4)) |= uint32(*(*Tuint8_t)(unsafe.Pointer(buf + uintptr(uint32(4)*i+uint32(3))))) << int32(24) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[i] = uint32(**(**Tuint8_t)(__ccgo_up(buf + uintptr(uint32(4)*i)))) + **(**Tuint32_t)(__ccgo_up(bp + uintptr(i)*4)) |= uint32(**(**Tuint8_t)(__ccgo_up(buf + uintptr(uint32(4)*i+uint32(1))))) << int32(8) + **(**Tuint32_t)(__ccgo_up(bp + uintptr(i)*4)) |= uint32(**(**Tuint8_t)(__ccgo_up(buf + uintptr(uint32(4)*i+uint32(2))))) << int32(16) + **(**Tuint32_t)(__ccgo_up(bp + uintptr(i)*4)) |= uint32(**(**Tuint8_t)(__ccgo_up(buf + uintptr(uint32(4)*i+uint32(3))))) << int32(24) goto _1 _1: ; i = i + 1 } - a = *(*Tuint32_t)(unsafe.Pointer(s + 8)) - b = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) - c = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 2*4)) - d = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) + a = **(**Tuint32_t)(__ccgo_up(s + 8)) + b = **(**Tuint32_t)(__ccgo_up(s + 8 + 1*4)) + c = **(**Tuint32_t)(__ccgo_up(s + 8 + 2*4)) + d = **(**Tuint32_t)(__ccgo_up(s + 8 + 3*4)) i = uint32(0) for i < uint32(16) { - a = a + (d ^ b&(c^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) + a = a + (d ^ b&(c^d) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[i] + _tab[i]) a = _rol(tls, a, int32(7)) + b i = i + 1 - d = d + (c ^ a&(b^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) + d = d + (c ^ a&(b^c) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[i] + _tab[i]) d = _rol(tls, d, int32(12)) + a i = i + 1 - c = c + (b ^ d&(a^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) + c = c + (b ^ d&(a^b) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[i] + _tab[i]) c = _rol(tls, c, int32(17)) + d i = i + 1 - b = b + (a ^ c&(d^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) + b = b + (a ^ c&(d^a) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[i] + _tab[i]) b = _rol(tls, b, int32(22)) + c i = i + 1 } for i < uint32(32) { - a = a + (c ^ d&(c^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) + a = a + (c ^ d&(c^b) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) a = _rol(tls, a, int32(5)) + b i = i + 1 - d = d + (b ^ c&(b^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) + d = d + (b ^ c&(b^a) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) d = _rol(tls, d, int32(9)) + a i = i + 1 - c = c + (a ^ b&(a^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) + c = c + (a ^ b&(a^d) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) c = _rol(tls, c, int32(14)) + d i = i + 1 - b = b + (d ^ a&(d^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) + b = b + (d ^ a&(d^c) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) b = _rol(tls, b, int32(20)) + c i = i + 1 } for i < uint32(48) { - a = a + (b ^ c ^ d + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) + a = a + (b ^ c ^ d + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) a = _rol(tls, a, int32(4)) + b i = i + 1 - d = d + (a ^ b ^ c + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) + d = d + (a ^ b ^ c + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) d = _rol(tls, d, int32(11)) + a i = i + 1 - c = c + (d ^ a ^ b + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) + c = c + (d ^ a ^ b + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) c = _rol(tls, c, int32(16)) + d i = i + 1 - b = b + (c ^ d ^ a + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) + b = b + (c ^ d ^ a + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) b = _rol(tls, b, int32(23)) + c i = i + 1 } for i < uint32(64) { - a = a + (c ^ (b | ^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) + a = a + (c ^ (b | ^d) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) a = _rol(tls, a, int32(6)) + b i = i + 1 - d = d + (b ^ (a | ^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) + d = d + (b ^ (a | ^c) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) d = _rol(tls, d, int32(10)) + a i = i + 1 - c = c + (a ^ (d | ^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) + c = c + (a ^ (d | ^b) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) c = _rol(tls, c, int32(15)) + d i = i + 1 - b = b + (d ^ (c | ^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) + b = b + (d ^ (c | ^a) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) b = _rol(tls, b, int32(21)) + c i = i + 1 } - *(*Tuint32_t)(unsafe.Pointer(s + 8)) += a - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) += b - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 2*4)) += c - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) += d + **(**Tuint32_t)(__ccgo_up(s + 8)) += a + **(**Tuint32_t)(__ccgo_up(s + 8 + 1*4)) += b + **(**Tuint32_t)(__ccgo_up(s + 8 + 2*4)) += c + **(**Tuint32_t)(__ccgo_up(s + 8 + 3*4)) += d } func _pad(tls *TLS, s uintptr) { @@ -11980,31 +11980,31 @@ func _pad(tls *TLS, s uintptr) { r = uint32((*Tmd5)(unsafe.Pointer(s)).Flen1 % uint64(64)) v1 = r r = r + 1 - *(*Tuint8_t)(unsafe.Pointer(s + 24 + uintptr(v1))) = uint8(0x80) + **(**Tuint8_t)(__ccgo_up(s + 24 + uintptr(v1))) = uint8(0x80) if r > uint32(56) { Xmemset(tls, s+24+uintptr(r), 0, uint32(64)-r) r = uint32(0) _processblock(tls, s, s+24) } Xmemset(tls, s+24+uintptr(r), 0, uint32(56)-r) - *(*Tuint64_t)(unsafe.Pointer(s)) *= uint64(8) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 56)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 57)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(8)) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 58)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(16)) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 59)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(24)) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 60)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(32)) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 61)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(40)) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 62)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(48)) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 63)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(56)) + **(**Tuint64_t)(__ccgo_up(s)) *= uint64(8) + **(**Tuint8_t)(__ccgo_up(s + 24 + 56)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1) + **(**Tuint8_t)(__ccgo_up(s + 24 + 57)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(8)) + **(**Tuint8_t)(__ccgo_up(s + 24 + 58)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(16)) + **(**Tuint8_t)(__ccgo_up(s + 24 + 59)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(24)) + **(**Tuint8_t)(__ccgo_up(s + 24 + 60)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(32)) + **(**Tuint8_t)(__ccgo_up(s + 24 + 61)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(40)) + **(**Tuint8_t)(__ccgo_up(s + 24 + 62)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(48)) + **(**Tuint8_t)(__ccgo_up(s + 24 + 63)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(56)) _processblock(tls, s, s+24) } func _md5_init(tls *TLS, s uintptr) { (*Tmd5)(unsafe.Pointer(s)).Flen1 = uint64(0) - *(*Tuint32_t)(unsafe.Pointer(s + 8)) = uint32(0x67452301) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) = uint32(0xefcdab89) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 2*4)) = uint32(0x98badcfe) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) = uint32(0x10325476) + **(**Tuint32_t)(__ccgo_up(s + 8)) = uint32(0x67452301) + **(**Tuint32_t)(__ccgo_up(s + 8 + 1*4)) = uint32(0xefcdab89) + **(**Tuint32_t)(__ccgo_up(s + 8 + 2*4)) = uint32(0x98badcfe) + **(**Tuint32_t)(__ccgo_up(s + 8 + 3*4)) = uint32(0x10325476) } func _md5_sum(tls *TLS, s uintptr, md uintptr) { @@ -12016,10 +12016,10 @@ func _md5_sum(tls *TLS, s uintptr, md uintptr) { if !(i < int32(4)) { break } - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4))) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i+int32(1)))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4)) >> int32(8)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i+int32(2)))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4)) >> int32(16)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i+int32(3)))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4)) >> int32(24)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4))) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i+int32(1)))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4)) >> int32(8)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i+int32(2)))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4)) >> int32(16)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i+int32(3)))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4)) >> int32(24)) goto _1 _1: ; @@ -12033,7 +12033,7 @@ func _md5_update(tls *TLS, s uintptr, m uintptr, len1 uint32) { _, _ = p, r p = m r = uint32((*Tmd5)(unsafe.Pointer(s)).Flen1 % uint64(64)) - *(*Tuint64_t)(unsafe.Pointer(s)) += uint64(len1) + **(**Tuint64_t)(__ccgo_up(s)) += uint64(len1) if r != 0 { if len1 < uint32(64)-r { Xmemcpy(tls, s+24+uintptr(r), p, len1) @@ -12100,7 +12100,7 @@ func _to64(tls *TLS, s uintptr, u uint32, n int32) (r uintptr) { } v2 = s s = s + 1 - *(*int8)(unsafe.Pointer(v2)) = Int8FromUint8(_b64[u%uint32(64)]) + **(**int8)(__ccgo_up(v2)) = Int8FromUint8(_b64[u%uint32(64)]) u = u / uint32(64) } return s @@ -12126,7 +12126,7 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt salt = setting + uintptr(3) i = uint32(0) for { - if !(i < uint32(SALT_MAX) && *(*int8)(unsafe.Pointer(salt + uintptr(i))) != 0 && int32(*(*int8)(unsafe.Pointer(salt + uintptr(i)))) != int32('$')) { + if !(i < uint32(SALT_MAX) && **(**int8)(__ccgo_up(salt + uintptr(i))) != 0 && int32(**(**int8)(__ccgo_up(salt + uintptr(i)))) != int32('$')) { break } goto _1 @@ -12157,7 +12157,7 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt i = i - uint32(16) } _md5_update(tls, bp, bp+88, i) - (*(*[16]uint8)(unsafe.Pointer(bp + 88)))[0] = uint8(0) + (**(**[16]uint8)(__ccgo_up(bp + 88)))[0] = uint8(0) i = klen for { if !(i != 0) { @@ -12208,20 +12208,20 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt p = output + uintptr(3) + uintptr(slen) v5 = p p = p + 1 - *(*int8)(unsafe.Pointer(v5)) = int8('$') + **(**int8)(__ccgo_up(v5)) = int8('$') i = uint32(0) for { if !(i < uint32(5)) { break } - p = _to64(tls, p, Uint32FromInt32(Int32FromUint8((*(*[16]uint8)(unsafe.Pointer(bp + 88)))[*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_perm)) + uintptr(i)*3))])<>Int32FromInt32(10) + (*(*[64]Tuint32_t)(unsafe.Pointer(bp)))[i-int32(7)] + (_ror(tls, (*(*[64]Tuint32_t)(unsafe.Pointer(bp)))[i-int32(15)], int32(7)) ^ _ror(tls, (*(*[64]Tuint32_t)(unsafe.Pointer(bp)))[i-int32(15)], int32(18)) ^ (*(*[64]Tuint32_t)(unsafe.Pointer(bp)))[i-int32(15)]>>Int32FromInt32(3)) + (*(*[64]Tuint32_t)(unsafe.Pointer(bp)))[i-int32(16)] + (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i] = _ror(tls, (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(2)], int32(17)) ^ _ror(tls, (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(2)], int32(19)) ^ (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(2)]>>Int32FromInt32(10) + (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(7)] + (_ror(tls, (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(15)], int32(7)) ^ _ror(tls, (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(15)], int32(18)) ^ (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(15)]>>Int32FromInt32(3)) + (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(16)] goto _2 _2: ; i = i + 1 } - a = *(*Tuint32_t)(unsafe.Pointer(s + 8)) - b = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) - c = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 2*4)) - d = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) - e = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 4*4)) - f = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 5*4)) - g = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 6*4)) - h = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 7*4)) + a = **(**Tuint32_t)(__ccgo_up(s + 8)) + b = **(**Tuint32_t)(__ccgo_up(s + 8 + 1*4)) + c = **(**Tuint32_t)(__ccgo_up(s + 8 + 2*4)) + d = **(**Tuint32_t)(__ccgo_up(s + 8 + 3*4)) + e = **(**Tuint32_t)(__ccgo_up(s + 8 + 4*4)) + f = **(**Tuint32_t)(__ccgo_up(s + 8 + 5*4)) + g = **(**Tuint32_t)(__ccgo_up(s + 8 + 6*4)) + h = **(**Tuint32_t)(__ccgo_up(s + 8 + 7*4)) i = 0 for { if !(i < int32(64)) { break } - t1 = h + (_ror(tls, e, int32(6)) ^ _ror(tls, e, int32(11)) ^ _ror(tls, e, int32(25))) + (g ^ e&(f^g)) + _K[i] + (*(*[64]Tuint32_t)(unsafe.Pointer(bp)))[i] + t1 = h + (_ror(tls, e, int32(6)) ^ _ror(tls, e, int32(11)) ^ _ror(tls, e, int32(25))) + (g ^ e&(f^g)) + _K[i] + (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i] t2 = _ror(tls, a, int32(2)) ^ _ror(tls, a, int32(13)) ^ _ror(tls, a, int32(22)) + (a&b | c&(a|b)) h = g g = f @@ -12458,14 +12458,14 @@ func _processblock1(tls *TLS, s uintptr, buf uintptr) { ; i = i + 1 } - *(*Tuint32_t)(unsafe.Pointer(s + 8)) += a - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) += b - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 2*4)) += c - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) += d - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 4*4)) += e - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 5*4)) += f - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 6*4)) += g - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 7*4)) += h + **(**Tuint32_t)(__ccgo_up(s + 8)) += a + **(**Tuint32_t)(__ccgo_up(s + 8 + 1*4)) += b + **(**Tuint32_t)(__ccgo_up(s + 8 + 2*4)) += c + **(**Tuint32_t)(__ccgo_up(s + 8 + 3*4)) += d + **(**Tuint32_t)(__ccgo_up(s + 8 + 4*4)) += e + **(**Tuint32_t)(__ccgo_up(s + 8 + 5*4)) += f + **(**Tuint32_t)(__ccgo_up(s + 8 + 6*4)) += g + **(**Tuint32_t)(__ccgo_up(s + 8 + 7*4)) += h } func _pad1(tls *TLS, s uintptr) { @@ -12474,35 +12474,35 @@ func _pad1(tls *TLS, s uintptr) { r = uint32((*Tsha256)(unsafe.Pointer(s)).Flen1 % uint64(64)) v1 = r r = r + 1 - *(*Tuint8_t)(unsafe.Pointer(s + 40 + uintptr(v1))) = uint8(0x80) + **(**Tuint8_t)(__ccgo_up(s + 40 + uintptr(v1))) = uint8(0x80) if r > uint32(56) { Xmemset(tls, s+40+uintptr(r), 0, uint32(64)-r) r = uint32(0) _processblock1(tls, s, s+40) } Xmemset(tls, s+40+uintptr(r), 0, uint32(56)-r) - *(*Tuint64_t)(unsafe.Pointer(s)) *= uint64(8) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 56)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(56)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 57)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(48)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 58)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(40)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 59)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(32)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 60)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(24)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 61)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(16)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 62)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(8)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 63)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1) + **(**Tuint64_t)(__ccgo_up(s)) *= uint64(8) + **(**Tuint8_t)(__ccgo_up(s + 40 + 56)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(56)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 57)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(48)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 58)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(40)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 59)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(32)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 60)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(24)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 61)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(16)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 62)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(8)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 63)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1) _processblock1(tls, s, s+40) } func _sha256_init(tls *TLS, s uintptr) { (*Tsha256)(unsafe.Pointer(s)).Flen1 = uint64(0) - *(*Tuint32_t)(unsafe.Pointer(s + 8)) = uint32(0x6a09e667) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) = uint32(0xbb67ae85) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 2*4)) = uint32(0x3c6ef372) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) = uint32(0xa54ff53a) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 4*4)) = uint32(0x510e527f) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 5*4)) = uint32(0x9b05688c) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 6*4)) = uint32(0x1f83d9ab) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 7*4)) = uint32(0x5be0cd19) + **(**Tuint32_t)(__ccgo_up(s + 8)) = uint32(0x6a09e667) + **(**Tuint32_t)(__ccgo_up(s + 8 + 1*4)) = uint32(0xbb67ae85) + **(**Tuint32_t)(__ccgo_up(s + 8 + 2*4)) = uint32(0x3c6ef372) + **(**Tuint32_t)(__ccgo_up(s + 8 + 3*4)) = uint32(0xa54ff53a) + **(**Tuint32_t)(__ccgo_up(s + 8 + 4*4)) = uint32(0x510e527f) + **(**Tuint32_t)(__ccgo_up(s + 8 + 5*4)) = uint32(0x9b05688c) + **(**Tuint32_t)(__ccgo_up(s + 8 + 6*4)) = uint32(0x1f83d9ab) + **(**Tuint32_t)(__ccgo_up(s + 8 + 7*4)) = uint32(0x5be0cd19) } func _sha256_sum(tls *TLS, s uintptr, md uintptr) { @@ -12514,10 +12514,10 @@ func _sha256_sum(tls *TLS, s uintptr, md uintptr) { if !(i < int32(8)) { break } - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4)) >> int32(24)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i+int32(1)))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4)) >> int32(16)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i+int32(2)))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4)) >> int32(8)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i+int32(3)))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4))) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4)) >> int32(24)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i+int32(1)))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4)) >> int32(16)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i+int32(2)))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4)) >> int32(8)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i+int32(3)))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4))) goto _1 _1: ; @@ -12531,7 +12531,7 @@ func _sha256_update(tls *TLS, s uintptr, m uintptr, len1 uint32) { _, _ = p, r p = m r = uint32((*Tsha256)(unsafe.Pointer(s)).Flen1 % uint64(64)) - *(*Tuint64_t)(unsafe.Pointer(s)) += uint64(len1) + **(**Tuint64_t)(__ccgo_up(s)) += uint64(len1) if r != 0 { if len1 < uint32(64)-r { Xmemcpy(tls, s+40+uintptr(r), p, len1) @@ -12570,7 +12570,7 @@ func _to641(tls *TLS, s uintptr, u uint32, n int32) (r uintptr) { } v2 = s s = s + 1 - *(*int8)(unsafe.Pointer(v2)) = Int8FromUint8(_b641[u%uint32(64)]) + **(**int8)(__ccgo_up(v2)) = Int8FromUint8(_b641[u%uint32(64)]) u = u / uint32(64) } return s @@ -12612,7 +12612,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui var _ /* rounds at bp+200 */ [20]int8 var _ /* smd at bp+168 */ [32]uint8 _, _, _, _, _, _, _ = i, klen, p, r, salt, slen, u - *(*[20]int8)(unsafe.Pointer(bp + 200)) = [20]int8{} + **(**[20]int8)(__ccgo_up(bp + 200)) = [20]int8{} /* reject large keys */ klen = Xstrnlen(tls, key, Uint32FromInt32(Int32FromInt32(KEY_MAX1)+Int32FromInt32(1))) if klen > uint32(KEY_MAX1) { @@ -12638,14 +12638,14 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui * the host's value of ULONG_MAX. */ salt = salt + uintptr(Uint32FromInt64(8)-Uint32FromInt32(1)) - if !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(salt)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + if !(BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(salt)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } u = Xstrtoul(tls, salt, bp+220, int32(10)) - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 220))))) != int32('$') { + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 220))))) != int32('$') { return uintptr(0) } - salt = *(*uintptr)(unsafe.Pointer(bp + 220)) + uintptr(1) + salt = **(**uintptr)(__ccgo_up(bp + 220)) + uintptr(1) if u < uint32(ROUNDS_MIN) { r = uint32(ROUNDS_MIN) } else { @@ -12660,11 +12660,11 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui } i = uint32(0) for { - if !(i < uint32(SALT_MAX1) && *(*int8)(unsafe.Pointer(salt + uintptr(i))) != 0 && int32(*(*int8)(unsafe.Pointer(salt + uintptr(i)))) != int32('$')) { + if !(i < uint32(SALT_MAX1) && **(**int8)(__ccgo_up(salt + uintptr(i))) != 0 && int32(**(**int8)(__ccgo_up(salt + uintptr(i)))) != int32('$')) { break } /* reject characters that interfere with /etc/shadow parsing */ - if int32(*(*int8)(unsafe.Pointer(salt + uintptr(i)))) == int32('\n') || int32(*(*int8)(unsafe.Pointer(salt + uintptr(i)))) == int32(':') { + if int32(**(**int8)(__ccgo_up(salt + uintptr(i)))) == int32('\n') || int32(**(**int8)(__ccgo_up(salt + uintptr(i)))) == int32(':') { return uintptr(0) } goto _1 @@ -12718,7 +12718,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui _sha256_init(tls, bp) i = uint32(0) for { - if !(i < Uint32FromInt32(int32(16)+Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp + 104)))[0]))) { + if !(i < Uint32FromInt32(int32(16)+Int32FromUint8((**(**[32]uint8)(__ccgo_up(bp + 104)))[0]))) { break } _sha256_update(tls, bp, salt, slen) @@ -12765,14 +12765,14 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui if !(i < uint32(10)) { break } - p = _to641(tls, p, Uint32FromInt32(Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp + 104)))[*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_perm1)) + uintptr(i)*3))])<>Int32FromInt32(6) + (*(*[80]Tuint64_t)(unsafe.Pointer(bp)))[i-int32(7)] + (_ror1(tls, (*(*[80]Tuint64_t)(unsafe.Pointer(bp)))[i-int32(15)], int32(1)) ^ _ror1(tls, (*(*[80]Tuint64_t)(unsafe.Pointer(bp)))[i-int32(15)], int32(8)) ^ (*(*[80]Tuint64_t)(unsafe.Pointer(bp)))[i-int32(15)]>>Int32FromInt32(7)) + (*(*[80]Tuint64_t)(unsafe.Pointer(bp)))[i-int32(16)] + (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i] = _ror1(tls, (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(2)], int32(19)) ^ _ror1(tls, (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(2)], int32(61)) ^ (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(2)]>>Int32FromInt32(6) + (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(7)] + (_ror1(tls, (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(15)], int32(1)) ^ _ror1(tls, (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(15)], int32(8)) ^ (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(15)]>>Int32FromInt32(7)) + (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(16)] goto _2 _2: ; i = i + 1 } - a = *(*Tuint64_t)(unsafe.Pointer(s + 8)) - b = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 1*8)) - c = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 2*8)) - d = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 3*8)) - e = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 4*8)) - f = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 5*8)) - g = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 6*8)) - h = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 7*8)) + a = **(**Tuint64_t)(__ccgo_up(s + 8)) + b = **(**Tuint64_t)(__ccgo_up(s + 8 + 1*8)) + c = **(**Tuint64_t)(__ccgo_up(s + 8 + 2*8)) + d = **(**Tuint64_t)(__ccgo_up(s + 8 + 3*8)) + e = **(**Tuint64_t)(__ccgo_up(s + 8 + 4*8)) + f = **(**Tuint64_t)(__ccgo_up(s + 8 + 5*8)) + g = **(**Tuint64_t)(__ccgo_up(s + 8 + 6*8)) + h = **(**Tuint64_t)(__ccgo_up(s + 8 + 7*8)) i = 0 for { if !(i < int32(80)) { break } - t1 = h + (_ror1(tls, e, int32(14)) ^ _ror1(tls, e, int32(18)) ^ _ror1(tls, e, int32(41))) + (g ^ e&(f^g)) + _K1[i] + (*(*[80]Tuint64_t)(unsafe.Pointer(bp)))[i] + t1 = h + (_ror1(tls, e, int32(14)) ^ _ror1(tls, e, int32(18)) ^ _ror1(tls, e, int32(41))) + (g ^ e&(f^g)) + _K1[i] + (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i] t2 = _ror1(tls, a, int32(28)) ^ _ror1(tls, a, int32(34)) ^ _ror1(tls, a, int32(39)) + (a&b | c&(a|b)) h = g g = f @@ -13012,14 +13012,14 @@ func _processblock2(tls *TLS, s uintptr, buf uintptr) { ; i = i + 1 } - *(*Tuint64_t)(unsafe.Pointer(s + 8)) += a - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 1*8)) += b - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 2*8)) += c - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 3*8)) += d - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 4*8)) += e - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 5*8)) += f - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 6*8)) += g - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 7*8)) += h + **(**Tuint64_t)(__ccgo_up(s + 8)) += a + **(**Tuint64_t)(__ccgo_up(s + 8 + 1*8)) += b + **(**Tuint64_t)(__ccgo_up(s + 8 + 2*8)) += c + **(**Tuint64_t)(__ccgo_up(s + 8 + 3*8)) += d + **(**Tuint64_t)(__ccgo_up(s + 8 + 4*8)) += e + **(**Tuint64_t)(__ccgo_up(s + 8 + 5*8)) += f + **(**Tuint64_t)(__ccgo_up(s + 8 + 6*8)) += g + **(**Tuint64_t)(__ccgo_up(s + 8 + 7*8)) += h } func _pad2(tls *TLS, s uintptr) { @@ -13028,35 +13028,35 @@ func _pad2(tls *TLS, s uintptr) { r = uint32((*Tsha512)(unsafe.Pointer(s)).Flen1 % uint64(128)) v1 = r r = r + 1 - *(*Tuint8_t)(unsafe.Pointer(s + 72 + uintptr(v1))) = uint8(0x80) + **(**Tuint8_t)(__ccgo_up(s + 72 + uintptr(v1))) = uint8(0x80) if r > uint32(112) { Xmemset(tls, s+72+uintptr(r), 0, uint32(128)-r) r = uint32(0) _processblock2(tls, s, s+72) } Xmemset(tls, s+72+uintptr(r), 0, uint32(120)-r) - *(*Tuint64_t)(unsafe.Pointer(s)) *= uint64(8) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 120)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(56)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 121)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(48)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 122)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(40)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 123)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(32)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 124)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(24)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 125)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(16)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 126)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(8)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 127)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1) + **(**Tuint64_t)(__ccgo_up(s)) *= uint64(8) + **(**Tuint8_t)(__ccgo_up(s + 72 + 120)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(56)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 121)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(48)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 122)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(40)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 123)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(32)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 124)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(24)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 125)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(16)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 126)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(8)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 127)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1) _processblock2(tls, s, s+72) } func _sha512_init(tls *TLS, s uintptr) { (*Tsha512)(unsafe.Pointer(s)).Flen1 = uint64(0) - *(*Tuint64_t)(unsafe.Pointer(s + 8)) = uint64(0x6a09e667f3bcc908) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 1*8)) = uint64(0xbb67ae8584caa73b) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 2*8)) = uint64(0x3c6ef372fe94f82b) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 3*8)) = uint64(0xa54ff53a5f1d36f1) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 4*8)) = uint64(0x510e527fade682d1) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 5*8)) = uint64(0x9b05688c2b3e6c1f) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 6*8)) = uint64(0x1f83d9abfb41bd6b) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 7*8)) = uint64(0x5be0cd19137e2179) + **(**Tuint64_t)(__ccgo_up(s + 8)) = uint64(0x6a09e667f3bcc908) + **(**Tuint64_t)(__ccgo_up(s + 8 + 1*8)) = uint64(0xbb67ae8584caa73b) + **(**Tuint64_t)(__ccgo_up(s + 8 + 2*8)) = uint64(0x3c6ef372fe94f82b) + **(**Tuint64_t)(__ccgo_up(s + 8 + 3*8)) = uint64(0xa54ff53a5f1d36f1) + **(**Tuint64_t)(__ccgo_up(s + 8 + 4*8)) = uint64(0x510e527fade682d1) + **(**Tuint64_t)(__ccgo_up(s + 8 + 5*8)) = uint64(0x9b05688c2b3e6c1f) + **(**Tuint64_t)(__ccgo_up(s + 8 + 6*8)) = uint64(0x1f83d9abfb41bd6b) + **(**Tuint64_t)(__ccgo_up(s + 8 + 7*8)) = uint64(0x5be0cd19137e2179) } func _sha512_sum(tls *TLS, s uintptr, md uintptr) { @@ -13068,14 +13068,14 @@ func _sha512_sum(tls *TLS, s uintptr, md uintptr) { if !(i < int32(8)) { break } - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(56)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(1)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(48)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(2)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(40)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(3)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(32)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(4)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(24)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(5)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(16)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(6)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(8)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(7)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8))) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(56)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(1)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(48)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(2)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(40)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(3)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(32)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(4)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(24)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(5)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(16)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(6)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(8)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(7)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8))) goto _1 _1: ; @@ -13089,7 +13089,7 @@ func _sha512_update(tls *TLS, s uintptr, m uintptr, len1 uint32) { _, _ = p, r p = m r = uint32((*Tsha512)(unsafe.Pointer(s)).Flen1 % uint64(128)) - *(*Tuint64_t)(unsafe.Pointer(s)) += uint64(len1) + **(**Tuint64_t)(__ccgo_up(s)) += uint64(len1) if r != 0 { if len1 < uint32(128)-r { Xmemcpy(tls, s+72+uintptr(r), p, len1) @@ -13128,7 +13128,7 @@ func _to642(tls *TLS, s uintptr, u uint32, n int32) (r uintptr) { } v2 = s s = s + 1 - *(*int8)(unsafe.Pointer(v2)) = Int8FromUint8(_b642[u%uint32(64)]) + **(**int8)(__ccgo_up(v2)) = Int8FromUint8(_b642[u%uint32(64)]) u = u / uint32(64) } return s @@ -13170,11 +13170,11 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui var _ /* rounds at bp+392 */ [20]int8 var _ /* smd at bp+328 */ [64]uint8 _, _, _, _, _, _, _ = i, klen, p, r, salt, slen, u - *(*[20]int8)(unsafe.Pointer(bp + 392)) = [20]int8{} + **(**[20]int8)(__ccgo_up(bp + 392)) = [20]int8{} /* reject large keys */ i = uint32(0) for { - if !(i <= uint32(KEY_MAX1) && *(*int8)(unsafe.Pointer(key + uintptr(i))) != 0) { + if !(i <= uint32(KEY_MAX1) && **(**int8)(__ccgo_up(key + uintptr(i))) != 0) { break } goto _1 @@ -13206,14 +13206,14 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui * the host's value of ULONG_MAX. */ salt = salt + uintptr(Uint32FromInt64(8)-Uint32FromInt32(1)) - if !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(salt)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + if !(BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(salt)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } u = Xstrtoul(tls, salt, bp+412, int32(10)) - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 412))))) != int32('$') { + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 412))))) != int32('$') { return uintptr(0) } - salt = *(*uintptr)(unsafe.Pointer(bp + 412)) + uintptr(1) + salt = **(**uintptr)(__ccgo_up(bp + 412)) + uintptr(1) if u < uint32(ROUNDS_MIN) { r = uint32(ROUNDS_MIN) } else { @@ -13228,11 +13228,11 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui } i = uint32(0) for { - if !(i < uint32(SALT_MAX1) && *(*int8)(unsafe.Pointer(salt + uintptr(i))) != 0 && int32(*(*int8)(unsafe.Pointer(salt + uintptr(i)))) != int32('$')) { + if !(i < uint32(SALT_MAX1) && **(**int8)(__ccgo_up(salt + uintptr(i))) != 0 && int32(**(**int8)(__ccgo_up(salt + uintptr(i)))) != int32('$')) { break } /* reject characters that interfere with /etc/shadow parsing */ - if int32(*(*int8)(unsafe.Pointer(salt + uintptr(i)))) == int32('\n') || int32(*(*int8)(unsafe.Pointer(salt + uintptr(i)))) == int32(':') { + if int32(**(**int8)(__ccgo_up(salt + uintptr(i)))) == int32('\n') || int32(**(**int8)(__ccgo_up(salt + uintptr(i)))) == int32(':') { return uintptr(0) } goto _2 @@ -13286,7 +13286,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui _sha512_init(tls, bp) i = uint32(0) for { - if !(i < Uint32FromInt32(int32(16)+Int32FromUint8((*(*[64]uint8)(unsafe.Pointer(bp + 200)))[0]))) { + if !(i < Uint32FromInt32(int32(16)+Int32FromUint8((**(**[64]uint8)(__ccgo_up(bp + 200)))[0]))) { break } _sha512_update(tls, bp, salt, slen) @@ -13333,14 +13333,14 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui if !(i < uint32(21)) { break } - p = _to642(tls, p, Uint32FromInt32(Int32FromUint8((*(*[64]uint8)(unsafe.Pointer(bp + 200)))[*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_perm2)) + uintptr(i)*3))])<= 0) { break } v3 = bp + uintptr(i) - *(*uint8)(unsafe.Pointer(v3)) = uint8(uint32(*(*uint8)(unsafe.Pointer(v3))) | Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(key)))&Int32FromInt32(1))<= 0) { break } - *(*Tuint32_t)(unsafe.Pointer(bp + 128 + uintptr(i)*4)) |= Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(p)))&Int32FromInt32(1)) << j + **(**Tuint32_t)(__ccgo_up(bp + 128 + uintptr(i)*4)) |= Uint32FromInt32(int32(**(**int8)(__ccgo_up(p)))&Int32FromInt32(1)) << j goto _2 _2: ; @@ -13558,15 +13558,15 @@ func Xencrypt(tls *TLS, block uintptr, edflag int32) { if !(i < int32(16)) { break } - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(i)*4)) = *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&___encrypt_key)) + uintptr(int32(15)-i)*4)) - *(*Tuint32_t)(unsafe.Pointer(bp + 64 + uintptr(i)*4)) = *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&___encrypt_key)) + 64 + uintptr(int32(15)-i)*4)) + **(**Tuint32_t)(__ccgo_up(bp + uintptr(i)*4)) = **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&___encrypt_key)) + uintptr(int32(15)-i)*4)) + **(**Tuint32_t)(__ccgo_up(bp + 64 + uintptr(i)*4)) = **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&___encrypt_key)) + 64 + uintptr(int32(15)-i)*4)) goto _3 _3: ; i = i + 1 } } - X__do_des(tls, (*(*[2]Tuint32_t)(unsafe.Pointer(bp + 128)))[0], (*(*[2]Tuint32_t)(unsafe.Pointer(bp + 128)))[int32(1)], bp+128, bp+128+uintptr(1)*4, uint32(1), uint32(0), key) + X__do_des(tls, (**(**[2]Tuint32_t)(__ccgo_up(bp + 128)))[0], (**(**[2]Tuint32_t)(__ccgo_up(bp + 128)))[int32(1)], bp+128, bp+128+uintptr(1)*4, uint32(1), uint32(0), key) p = block i = 0 for { @@ -13580,7 +13580,7 @@ func Xencrypt(tls *TLS, block uintptr, edflag int32) { } v6 = p p = p + 1 - *(*int8)(unsafe.Pointer(v6)) = Int8FromUint32((*(*[2]Tuint32_t)(unsafe.Pointer(bp + 128)))[i] >> j & uint32(1)) + **(**int8)(__ccgo_up(v6)) = Int8FromUint32((**(**[2]Tuint32_t)(__ccgo_up(bp + 128)))[i] >> j & uint32(1)) goto _5 _5: ; @@ -14055,7 +14055,7 @@ func X__ctype_get_mb_cur_max(tls *TLS) (r Tsize_t) { } var v1 int32 _ = v1 - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v1 = int32(4) } else { v1 = int32(1) @@ -17619,10 +17619,10 @@ func Xwctype(tls *TLS, s uintptr) (r Twctype_t) { i = int32(1) p = uintptr(unsafe.Pointer(&_names)) for { - if !(*(*int8)(unsafe.Pointer(p)) != 0) { + if !(**(**int8)(__ccgo_up(p)) != 0) { break } - if int32(*(*int8)(unsafe.Pointer(s))) == int32(*(*int8)(unsafe.Pointer(p))) && !(Xstrcmp(tls, s, p) != 0) { + if int32(**(**int8)(__ccgo_up(s))) == int32(**(**int8)(__ccgo_up(p))) && !(Xstrcmp(tls, s, p) != 0) { return Uint32FromInt32(i) } goto _1 @@ -22368,9 +22368,9 @@ func _casemap(tls *TLS, c uint32, dir int32) (r1 int32) { xn = Uint32FromInt32(rd & int32(0xff)) xb = Uint32FromInt32(rd) >> int32(8) for xn != 0 { - try = uint32(*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_exceptions)) + uintptr(xb+xn/uint32(2))*2))) + try = uint32(**(**uint8)(__ccgo_up(uintptr(unsafe.Pointer(&_exceptions)) + uintptr(xb+xn/uint32(2))*2))) if try == c { - r = _rules[*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_exceptions)) + uintptr(xb+xn/uint32(2))*2 + 1))] + r = _rules[**(**uint8)(__ccgo_up(uintptr(unsafe.Pointer(&_exceptions)) + uintptr(xb+xn/uint32(2))*2 + 1))] rt = Uint32FromInt32(r & int32(255)) rd = r >> int32(8) if rt < uint32(2) { @@ -22463,8 +22463,8 @@ func Xwcswidth(tls *TLS, wcs uintptr, n Tsize_t) (r int32) { for { v2 = n n = n - 1 - if v4 = v2 != 0 && *(*Twchar_t)(unsafe.Pointer(wcs)) != 0; v4 { - v3 = Xwcwidth(tls, *(*Twchar_t)(unsafe.Pointer(wcs))) + if v4 = v2 != 0 && **(**Twchar_t)(__ccgo_up(wcs)) != 0; v4 { + v3 = Xwcwidth(tls, **(**Twchar_t)(__ccgo_up(wcs))) k = v3 } if !(v4 && v3 >= 0) { @@ -24664,7 +24664,7 @@ func Xalphasort(tls *TLS, a uintptr, b uintptr) (r int32) { trc("tls=%v a=%v b=%v, (%v:)", tls, a, b, origin(2)) defer func() { trc("-> %v", r) }() } - return Xstrcoll(tls, *(*uintptr)(unsafe.Pointer(a))+19, *(*uintptr)(unsafe.Pointer(b))+19) + return Xstrcoll(tls, **(**uintptr)(__ccgo_up(a))+19, **(**uintptr)(__ccgo_up(b))+19) } type TDIR = struct { @@ -24845,11 +24845,11 @@ func Xfdopendir(tls *TLS, fd int32) (r uintptr) { return uintptr(0) } if Xfcntl(tls, fd, int32(F_GETFL), 0)&int32(O_PATH) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EBADF) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EBADF) return uintptr(0) } - if !((*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&Uint32FromInt32(S_IFMT) == Uint32FromInt32(S_IFDIR)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOTDIR) + if !((**(**Tstat)(__ccgo_up(bp))).Fst_mode&Uint32FromInt32(S_IFMT) == Uint32FromInt32(S_IFDIR)) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOTDIR) return uintptr(0) } v1 = Xcalloc(tls, uint32(1), uint32(2072)) @@ -24984,7 +24984,7 @@ func Xreaddir(tls *TLS, dir uintptr) (r uintptr) { len1 = int32(X__syscall3(tls, int32(SYS_getdents64), (*TDIR)(unsafe.Pointer(dir)).Ffd, int32(dir+24), Int32FromUint32(Uint32FromInt64(2048)))) if len1 <= 0 { if len1 < 0 && len1 != -int32(ENOENT) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = -len1 + **(**int32)(__ccgo_up(X__errno_location(tls))) = -len1 } return uintptr(0) } @@ -24992,7 +24992,7 @@ func Xreaddir(tls *TLS, dir uintptr) (r uintptr) { (*TDIR)(unsafe.Pointer(dir)).Fbuf_pos = 0 } de = dir + 24 + uintptr((*TDIR)(unsafe.Pointer(dir)).Fbuf_pos) - *(*int32)(unsafe.Pointer(dir + 12)) += Int32FromUint16((*Tdirent)(unsafe.Pointer(de)).Fd_reclen) + **(**int32)(__ccgo_up(dir + 12)) += Int32FromUint16((*Tdirent)(unsafe.Pointer(de)).Fd_reclen) (*TDIR)(unsafe.Pointer(dir)).Ftell = (*Tdirent)(unsafe.Pointer(de)).Fd_off return de } @@ -25005,24 +25005,24 @@ func Xreaddir_r(tls *TLS, dir uintptr, buf uintptr, result uintptr) (r int32) { var de uintptr var errno_save, ret, v1 int32 _, _, _, _ = de, errno_save, ret, v1 - errno_save = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + errno_save = **(**int32)(__ccgo_up(X__errno_location(tls))) ___lock(tls, dir+20) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = 0 + **(**int32)(__ccgo_up(X__errno_location(tls))) = 0 de = Xreaddir(tls, dir) - v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = **(**int32)(__ccgo_up(X__errno_location(tls))) ret = v1 if v1 != 0 { ___unlock(tls, dir+20) return ret } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = errno_save + **(**int32)(__ccgo_up(X__errno_location(tls))) = errno_save if de != 0 { Xmemcpy(tls, buf, de, uint32((*Tdirent)(unsafe.Pointer(de)).Fd_reclen)) } else { buf = UintptrFromInt32(0) } ___unlock(tls, dir+20) - *(*uintptr)(unsafe.Pointer(result)) = buf + **(**uintptr)(__ccgo_up(result)) = buf return 0 } @@ -25058,12 +25058,12 @@ func Xscandir(tls *TLS, path uintptr, res uintptr, __ccgo_fp_sel uintptr, __ccgo names = uintptr(0) cnt = uint32(0) len1 = uint32(0) - old_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + old_errno = **(**int32)(__ccgo_up(X__errno_location(tls))) if !(d != 0) { return -int32(1) } for { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = 0 + **(**int32)(__ccgo_up(X__errno_location(tls))) = 0 v1 = Xreaddir(tls, d) de = v1 if !(v1 != 0) { @@ -25083,16 +25083,16 @@ func Xscandir(tls *TLS, path uintptr, res uintptr, __ccgo_fp_sel uintptr, __ccgo } names = tmp } - *(*uintptr)(unsafe.Pointer(names + uintptr(cnt)*4)) = Xmalloc(tls, uint32((*Tdirent)(unsafe.Pointer(de)).Fd_reclen)) - if !(*(*uintptr)(unsafe.Pointer(names + uintptr(cnt)*4)) != 0) { + **(**uintptr)(__ccgo_up(names + uintptr(cnt)*4)) = Xmalloc(tls, uint32((*Tdirent)(unsafe.Pointer(de)).Fd_reclen)) + if !(**(**uintptr)(__ccgo_up(names + uintptr(cnt)*4)) != 0) { break } v2 = cnt cnt = cnt + 1 - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(names + uintptr(v2)*4)), de, uint32((*Tdirent)(unsafe.Pointer(de)).Fd_reclen)) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(names + uintptr(v2)*4)), de, uint32((*Tdirent)(unsafe.Pointer(de)).Fd_reclen)) } Xclosedir(tls, d) - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != 0 { + if **(**int32)(__ccgo_up(X__errno_location(tls))) != 0 { if names != 0 { for { v2 = cnt @@ -25100,17 +25100,17 @@ func Xscandir(tls *TLS, path uintptr, res uintptr, __ccgo_fp_sel uintptr, __ccgo if !(v2 > uint32(0)) { break } - Xfree(tls, *(*uintptr)(unsafe.Pointer(names + uintptr(cnt)*4))) + Xfree(tls, **(**uintptr)(__ccgo_up(names + uintptr(cnt)*4))) } } Xfree(tls, names) return -int32(1) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = old_errno + **(**int32)(__ccgo_up(X__errno_location(tls))) = old_errno if __ccgo_fp_cmp != 0 { Xqsort(tls, names, cnt, uint32(4), __ccgo_fp_cmp) } - *(*uintptr)(unsafe.Pointer(res)) = names + **(**uintptr)(__ccgo_up(res)) = names return Int32FromUint32(cnt) } @@ -25141,7 +25141,7 @@ func Xversionsort(tls *TLS, a uintptr, b uintptr) (r int32) { trc("tls=%v a=%v b=%v, (%v:)", tls, a, b, origin(2)) defer func() { trc("-> %v", r) }() } - return Xstrverscmp(tls, *(*uintptr)(unsafe.Pointer(a))+19, *(*uintptr)(unsafe.Pointer(b))+19) + return Xstrverscmp(tls, **(**uintptr)(__ccgo_up(a))+19, **(**uintptr)(__ccgo_up(b))+19) } func X__reset_tls(tls *TLS) { @@ -25153,7 +25153,7 @@ func X__reset_tls(tls *TLS) { var self Tpthread_t _, _, _, _, _ = i, mem, n, p, self self = uintptr(___get_tp(tls)) - n = *(*Tuintptr_t)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(self)).Fdtv)) + n = **(**Tuintptr_t)(__ccgo_up((*t__pthread)(unsafe.Pointer(self)).Fdtv)) if n != 0 { p = X__libc.Ftls_head i = Uint32FromInt32(1) @@ -25161,7 +25161,7 @@ func X__reset_tls(tls *TLS) { if !(i <= n) { break } - mem = uintptr(*(*Tuintptr_t)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(self)).Fdtv + uintptr(i)*4)) - Uint32FromInt32(DTP_OFFSET)) + mem = uintptr(**(**Tuintptr_t)(__ccgo_up((*t__pthread)(unsafe.Pointer(self)).Fdtv + uintptr(i)*4)) - Uint32FromInt32(DTP_OFFSET)) Xmemcpy(tls, mem, (*Ttls_module)(unsafe.Pointer(p)).Fimage, (*Ttls_module)(unsafe.Pointer(p)).Flen1) Xmemset(tls, mem+uintptr((*Ttls_module)(unsafe.Pointer(p)).Flen1), 0, (*Ttls_module)(unsafe.Pointer(p)).Fsize-(*Ttls_module)(unsafe.Pointer(p)).Flen1) goto _1 @@ -25216,10 +25216,10 @@ func Xclearenv(tls *TLS) (r int32) { e = Xenviron Xenviron = uintptr(0) if e != 0 { - for *(*uintptr)(unsafe.Pointer(e)) != 0 { + for **(**uintptr)(__ccgo_up(e)) != 0 { v1 = e e += 4 - X__env_rm_add(tls, *(*uintptr)(unsafe.Pointer(v1)), uintptr(0)) + X__env_rm_add(tls, **(**uintptr)(__ccgo_up(v1)), uintptr(0)) } } return 0 @@ -25234,14 +25234,14 @@ func Xgetenv(tls *TLS, name uintptr) (r uintptr) { var l Tsize_t _, _ = e, l l = Uint32FromInt32(int32(X__strchrnul(tls, name, int32('='))) - int32(name)) - if l != 0 && !(*(*int8)(unsafe.Pointer(name + uintptr(l))) != 0) && Xenviron != 0 { + if l != 0 && !(**(**int8)(__ccgo_up(name + uintptr(l))) != 0) && Xenviron != 0 { e = Xenviron for { - if !(*(*uintptr)(unsafe.Pointer(e)) != 0) { + if !(**(**uintptr)(__ccgo_up(e)) != 0) { break } - if !(Xstrncmp(tls, name, *(*uintptr)(unsafe.Pointer(e)), l) != 0) && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(e)) + uintptr(l)))) == int32('=') { - return *(*uintptr)(unsafe.Pointer(e)) + uintptr(l) + uintptr(1) + if !(Xstrncmp(tls, name, **(**uintptr)(__ccgo_up(e)), l) != 0) && int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(e)) + uintptr(l)))) == int32('=') { + return **(**uintptr)(__ccgo_up(e)) + uintptr(l) + uintptr(1) } goto _1 _1: @@ -25267,12 +25267,12 @@ func X__putenv(tls *TLS, s uintptr, l Tsize_t, r uintptr) (r1 int32) { if Xenviron != 0 { e = Xenviron for { - if !(*(*uintptr)(unsafe.Pointer(e)) != 0) { + if !(**(**uintptr)(__ccgo_up(e)) != 0) { break } - if !(Xstrncmp(tls, s, *(*uintptr)(unsafe.Pointer(e)), l+uint32(1)) != 0) { - tmp = *(*uintptr)(unsafe.Pointer(e)) - *(*uintptr)(unsafe.Pointer(e)) = s + if !(Xstrncmp(tls, s, **(**uintptr)(__ccgo_up(e)), l+uint32(1)) != 0) { + tmp = **(**uintptr)(__ccgo_up(e)) + **(**uintptr)(__ccgo_up(e)) = s X__env_rm_add(tls, tmp, r) return 0 } @@ -25298,8 +25298,8 @@ func X__putenv(tls *TLS, s uintptr, l Tsize_t, r uintptr) (r1 int32) { } Xfree(tls, _oldenv) } - *(*uintptr)(unsafe.Pointer(newenv + uintptr(i)*4)) = s - *(*uintptr)(unsafe.Pointer(newenv + uintptr(i+uint32(1))*4)) = uintptr(0) + **(**uintptr)(__ccgo_up(newenv + uintptr(i)*4)) = s + **(**uintptr)(__ccgo_up(newenv + uintptr(i+uint32(1))*4)) = uintptr(0) v2 = newenv _oldenv = v2 Xenviron = v2 @@ -25324,7 +25324,7 @@ func Xputenv(tls *TLS, s uintptr) (r int32) { var l Tsize_t _ = l l = Uint32FromInt32(int32(X__strchrnul(tls, s, int32('='))) - int32(s)) - if !(l != 0) || !(*(*int8)(unsafe.Pointer(s + uintptr(l))) != 0) { + if !(l != 0) || !(**(**int8)(__ccgo_up(s + uintptr(l))) != 0) { return Xunsetenv(tls, s) } return X__putenv(tls, s, l, uintptr(0)) @@ -25369,13 +25369,13 @@ func X__env_rm_add(tls *TLS, old uintptr, new1 uintptr) { if !(i < _env_alloced_n) { break } - if *(*uintptr)(unsafe.Pointer(_env_alloced + uintptr(i)*4)) == old { - *(*uintptr)(unsafe.Pointer(_env_alloced + uintptr(i)*4)) = new1 + if **(**uintptr)(__ccgo_up(_env_alloced + uintptr(i)*4)) == old { + **(**uintptr)(__ccgo_up(_env_alloced + uintptr(i)*4)) = new1 Xfree(tls, old) return } else { - if !(*(*uintptr)(unsafe.Pointer(_env_alloced + uintptr(i)*4)) != 0) && new1 != 0 { - *(*uintptr)(unsafe.Pointer(_env_alloced + uintptr(i)*4)) = new1 + if !(**(**uintptr)(__ccgo_up(_env_alloced + uintptr(i)*4)) != 0) && new1 != 0 { + **(**uintptr)(__ccgo_up(_env_alloced + uintptr(i)*4)) = new1 new1 = uintptr(0) } } @@ -25395,7 +25395,7 @@ func X__env_rm_add(tls *TLS, old uintptr, new1 uintptr) { _env_alloced = v2 v3 = _env_alloced_n _env_alloced_n = _env_alloced_n + 1 - *(*uintptr)(unsafe.Pointer(v2 + uintptr(v3)*4)) = new1 + **(**uintptr)(__ccgo_up(v2 + uintptr(v3)*4)) = new1 } var _env_alloced uintptr @@ -25415,8 +25415,8 @@ func Xsetenv(tls *TLS, var1 uintptr, value uintptr, overwrite int32) (r int32) { v1 = Uint32FromInt32(int32(X__strchrnul(tls, var1, int32('='))) - int32(var1)) l1 = v1 } - if v2 || !(v1 != 0) || *(*int8)(unsafe.Pointer(var1 + uintptr(l1))) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if v2 || !(v1 != 0) || **(**int8)(__ccgo_up(var1 + uintptr(l1))) != 0 { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } if !(overwrite != 0) && Xgetenv(tls, var1) != 0 { @@ -25428,7 +25428,7 @@ func Xsetenv(tls *TLS, var1 uintptr, value uintptr, overwrite int32) (r int32) { return -int32(1) } Xmemcpy(tls, s, var1, l1) - *(*int8)(unsafe.Pointer(s + uintptr(l1))) = int8('=') + **(**int8)(__ccgo_up(s + uintptr(l1))) = int8('=') Xmemcpy(tls, s+uintptr(l1)+uintptr(1), value, l2+uint32(1)) return X__putenv(tls, s, l1, s) } @@ -25445,24 +25445,24 @@ func Xunsetenv(tls *TLS, name uintptr) (r int32) { var l Tsize_t _, _, _, _ = e, eo, l, v2 l = Uint32FromInt32(int32(X__strchrnul(tls, name, int32('='))) - int32(name)) - if !(l != 0) || *(*int8)(unsafe.Pointer(name + uintptr(l))) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if !(l != 0) || **(**int8)(__ccgo_up(name + uintptr(l))) != 0 { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } if Xenviron != 0 { e = Xenviron eo = e for { - if !(*(*uintptr)(unsafe.Pointer(e)) != 0) { + if !(**(**uintptr)(__ccgo_up(e)) != 0) { break } - if !(Xstrncmp(tls, name, *(*uintptr)(unsafe.Pointer(e)), l) != 0) && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(e)) + uintptr(l)))) == int32('=') { - X__env_rm_add(tls, *(*uintptr)(unsafe.Pointer(e)), uintptr(0)) + if !(Xstrncmp(tls, name, **(**uintptr)(__ccgo_up(e)), l) != 0) && int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(e)) + uintptr(l)))) == int32('=') { + X__env_rm_add(tls, **(**uintptr)(__ccgo_up(e)), uintptr(0)) } else { if eo != e { v2 = eo eo += 4 - *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(e)) + **(**uintptr)(__ccgo_up(v2)) = **(**uintptr)(__ccgo_up(e)) } else { eo += 4 } @@ -25473,7 +25473,7 @@ func Xunsetenv(tls *TLS, name uintptr) (r int32) { e += 4 } if eo != e { - *(*uintptr)(unsafe.Pointer(eo)) = uintptr(0) + **(**uintptr)(__ccgo_up(eo)) = uintptr(0) } } return 0 @@ -25783,7 +25783,7 @@ func X__strerror_l(tls *TLS, e int32, loc Tlocale_t) (r uintptr) { e = 0 } s = uintptr(unsafe.Pointer(&_errmsgstr)) + uintptr(_errmsgidx[e]) - return X__lctrans(tls, s, *(*uintptr)(unsafe.Pointer(loc + 5*4))) + return X__lctrans(tls, s, **(**uintptr)(__ccgo_up(loc + 5*4))) } func Xstrerror(tls *TLS, e int32) (r uintptr) { @@ -25920,10 +25920,10 @@ func Xfcntl(tls *TLS, fd int32, cmd int32, va uintptr) (r int32) { if ret != 0 { return X__syscall_ret(tls, Uint32FromInt32(ret)) } - if (*(*Tf_owner_ex)(unsafe.Pointer(bp))).Ftype1 == int32(F_OWNER_PGRP) { - v1 = -(*(*Tf_owner_ex)(unsafe.Pointer(bp))).Fpid + if (**(**Tf_owner_ex)(__ccgo_up(bp))).Ftype1 == int32(F_OWNER_PGRP) { + v1 = -(**(**Tf_owner_ex)(__ccgo_up(bp))).Fpid } else { - v1 = (*(*Tf_owner_ex)(unsafe.Pointer(bp))).Fpid + v1 = (**(**Tf_owner_ex)(__ccgo_up(bp))).Fpid } return v1 } @@ -26183,7 +26183,7 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { v3 = f + 4 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26194,7 +26194,7 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { v3 = f + 4 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26224,7 +26224,7 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { v3 = f + 4 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26243,7 +26243,7 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { v3 = f + 4 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26260,7 +26260,7 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { v3 = f + 4 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26313,7 +26313,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__shgetc(tls, f) } @@ -26325,7 +26325,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__shgetc(tls, f) } @@ -26343,14 +26343,14 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__shgetc(tls, f) } c = v2 } } - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0] = uint32(0) + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[0] = uint32(0) for { if !(Uint32FromInt32(c-int32('0')) < uint32(10) || c == int32('.')) { break @@ -26368,9 +26368,9 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, lnz = int32(dc) } if j != 0 { - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k]*uint32(10) + Uint32FromInt32(c) - uint32('0') + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] = (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k]*uint32(10) + Uint32FromInt32(c) - uint32('0') } else { - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] = Uint32FromInt32(c - int32('0')) + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] = Uint32FromInt32(c - int32('0')) } j = j + 1 v2 = j @@ -26383,7 +26383,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, dc = dc + 1 if c != int32('0') { lnz = (Int32FromInt32(KMAX) - Int32FromInt32(4)) * Int32FromInt32(9) - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(Int32FromInt32(KMAX)-Int32FromInt32(4))*4)) |= uint32(1) + **(**Tuint32_t)(__ccgo_up(bp + uintptr(Int32FromInt32(KMAX)-Int32FromInt32(4))*4)) |= uint32(1) } } } @@ -26394,7 +26394,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__shgetc(tls, f) } @@ -26425,24 +26425,24 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, } } if !(gotdig != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) X__shlim(tls, f, int64(Int32FromInt32(0))) return Float64FromInt32(0) } /* Handle zero specially to avoid nasty special cases later */ - if !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0] != 0) { + if !((**(**[128]Tuint32_t)(__ccgo_up(bp)))[0] != 0) { return float64(float64(sign) * float64(0)) } /* Optimize small integers (w/no exponent) and over/under-flow */ - if lrp == dc && dc < int64(10) && (bits > int32(30) || (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0]>>bits == uint32(0)) { - return float64(float64(sign) * float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0])) + if lrp == dc && dc < int64(10) && (bits > int32(30) || (**(**[128]Tuint32_t)(__ccgo_up(bp)))[0]>>bits == uint32(0)) { + return float64(float64(sign) * float64((**(**[128]Tuint32_t)(__ccgo_up(bp)))[0])) } if lrp > int64(-emin/int32(2)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return float64(float64(float64(sign)*Float64FromFloat64(1.79769313486231570815e+308)) * Float64FromFloat64(1.79769313486231570815e+308)) } if lrp < int64(emin-Int32FromInt32(2)*Int32FromInt32(LDBL_MANT_DIG)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return float64(float64(float64(sign)*Float64FromFloat64(2.22507385850720138309e-308)) * Float64FromFloat64(2.22507385850720138309e-308)) } /* Align incomplete final B1B digit */ @@ -26451,7 +26451,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if !(j < int32(9)) { break } - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(k)*4)) *= uint32(10) + **(**Tuint32_t)(__ccgo_up(bp + uintptr(k)*4)) *= uint32(10) goto _17 _17: ; @@ -26467,19 +26467,19 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, /* Optimize small to mid-size integers (even in exp. notation) */ if lnz < int32(9) && lnz <= rp && rp < int32(18) { if rp == int32(9) { - return float64(float64(sign) * float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0])) + return float64(float64(sign) * float64((**(**[128]Tuint32_t)(__ccgo_up(bp)))[0])) } if rp < int32(9) { - return float64(float64(sign)*float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0])) / float64(_p10s[int32(8)-rp]) + return float64(float64(sign)*float64((**(**[128]Tuint32_t)(__ccgo_up(bp)))[0])) / float64(_p10s[int32(8)-rp]) } bitlim = bits - int32(3)*(rp-Int32FromInt32(9)) - if bitlim > int32(30) || (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0]>>bitlim == uint32(0) { - return float64(float64(float64(sign)*float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0])) * float64(_p10s[rp-int32(10)])) + if bitlim > int32(30) || (**(**[128]Tuint32_t)(__ccgo_up(bp)))[0]>>bitlim == uint32(0) { + return float64(float64(float64(sign)*float64((**(**[128]Tuint32_t)(__ccgo_up(bp)))[0])) * float64(_p10s[rp-int32(10)])) } } /* Drop trailing zeros */ for { - if !!((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[z-int32(1)] != 0) { + if !!((**(**[128]Tuint32_t)(__ccgo_up(bp)))[z-int32(1)] != 0) { break } goto _18 @@ -26502,10 +26502,10 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if !(k != z) { break } - tmp = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] % Uint32FromInt32(p10) - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k]/Uint32FromInt32(p10) + carry + tmp = (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] % Uint32FromInt32(p10) + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] = (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k]/Uint32FromInt32(p10) + carry carry = Uint32FromInt32(int32(1000000000)/p10) * tmp - if k == a && !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] != 0) { + if k == a && !((**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] != 0) { a = (a + int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) rp = rp - int32(9) } @@ -26517,25 +26517,25 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if carry != 0 { v2 = z z = z + 1 - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v2] = carry + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[v2] = carry } rp = rp + (int32(9) - rpm9) } /* Upscale until desired number of bits are left of radix point */ - for rp < Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) || rp == Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) && (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[a] < _th[0] { + for rp < Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) || rp == Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) && (**(**[128]Tuint32_t)(__ccgo_up(bp)))[a] < _th[0] { carry1 = uint32(0) e2 = e2 - int32(29) k = (z - int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) for { - tmp1 = uint64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k])< uint64(1000000000) { carry1 = uint32(tmp1 / uint64(1000000000)) - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] = uint32(tmp1 % uint64(1000000000)) + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] = uint32(tmp1 % uint64(1000000000)) } else { carry1 = uint32(0) - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] = uint32(tmp1) + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] = uint32(tmp1) } - if k == (z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) && k != a && !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] != 0) { + if k == (z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) && k != a && !((**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] != 0) { z = k } if k == a { @@ -26551,9 +26551,9 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, a = (a - int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) if a == z { z = (z - int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr((z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)))*4)) |= (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[z] + **(**Tuint32_t)(__ccgo_up(bp + uintptr((z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)))*4)) |= (**(**[128]Tuint32_t)(__ccgo_up(bp)))[z] } - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[a] = carry1 + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[a] = carry1 } } /* Downscale until exactly number of bits are left of radix point */ @@ -26566,11 +26566,11 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, break } k = (a + i) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) - if k == z || (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] < _th[i] { + if k == z || (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] < _th[i] { i = int32(LD_B1B_DIG) break } - if (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))] > _th[i] { + if (**(**[128]Tuint32_t)(__ccgo_up(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))] > _th[i] { break } goto _24 @@ -26591,10 +26591,10 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if !(k != z) { break } - tmp2 = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] & Uint32FromInt32(int32(1)<>sh + carry2 + tmp2 = (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] & Uint32FromInt32(int32(1)<>sh + carry2 carry2 = Uint32FromInt32(Int32FromInt32(1000000000)>>sh) * tmp2 - if k == a && !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] != 0) { + if k == a && !((**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] != 0) { a = (a + int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) i = i - 1 rp = rp - int32(9) @@ -26606,10 +26606,10 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, } if carry2 != 0 { if (z+int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) != a { - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[z] = carry2 + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[z] = carry2 z = (z + int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) } else { - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr((z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)))*4)) |= uint32(1) + **(**Tuint32_t)(__ccgo_up(bp + uintptr((z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)))*4)) |= uint32(1) } } goto _23 @@ -26626,9 +26626,9 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if (a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1)) == z { v6 = (z + Int32FromInt32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) z = v6 - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v6-int32(1)] = uint32(0) + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[v6-int32(1)] = uint32(0) } - y = float64(Float64FromFloat64(1e+09)*y) + float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))]) + y = float64(Float64FromFloat64(1e+09)*y) + float64((**(**[128]Tuint32_t)(__ccgo_up(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))]) goto _26 _26: ; @@ -26652,7 +26652,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, } /* Process tail of decimal input so it can affect rounding */ if (a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1)) != z { - t = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))] + t = (**(**[128]Tuint32_t)(__ccgo_up(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))] if t < uint32(500000000) && (t != 0 || (a+i+int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) != z) { frac = frac + float64(float64(0.25)*float64(sign)) } else { @@ -26683,7 +26683,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, e2 = e2 + 1 } if e2+int32(LDBL_MANT_DIG) > emax || denormal != 0 && frac != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) } } return Xscalbnl(tls, y, e2) @@ -26726,7 +26726,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 v3 = f + 4 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26744,7 +26744,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 v3 = f + 4 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26756,7 +26756,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 v3 = f + 4 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26775,7 +26775,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 v3 = f + 4 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26822,7 +26822,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 v3 = f + 4 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26876,11 +26876,11 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 return float64(float64(sign) * float64(0)) } if e2 > int64(-emin) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return float64(float64(float64(sign)*Float64FromFloat64(1.79769313486231570815e+308)) * Float64FromFloat64(1.79769313486231570815e+308)) } if e2 < int64(emin-Int32FromInt32(2)*Int32FromInt32(LDBL_MANT_DIG)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return float64(float64(float64(sign)*Float64FromFloat64(2.22507385850720138309e-308)) * Float64FromFloat64(2.22507385850720138309e-308)) } for x < uint32(0x80000000) { @@ -26909,7 +26909,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 y = bias + float64(float64(sign)*float64(x)) + float64(float64(sign)*y) y = y - bias if !(y != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) } return Xscalbnl(tls, y, int32(e2)) } @@ -26942,7 +26942,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__shgetc(tls, f) } @@ -26962,7 +26962,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -26970,7 +26970,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { } i = uint32(0) for { - if !(i < uint32(8) && c|int32(32) == int32(*(*int8)(unsafe.Pointer(__ccgo_ts + 247 + uintptr(i))))) { + if !(i < uint32(8) && c|int32(32) == int32(**(**int8)(__ccgo_up(__ccgo_ts + 247 + uintptr(i))))) { break } if i < uint32(7) { @@ -26978,7 +26978,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27014,7 +27014,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { if !(i != 0) { i = uint32(0) for { - if !(i < uint32(3) && c|int32(32) == int32(*(*int8)(unsafe.Pointer(__ccgo_ts + 256 + uintptr(i))))) { + if !(i < uint32(3) && c|int32(32) == int32(**(**int8)(__ccgo_up(__ccgo_ts + 256 + uintptr(i))))) { break } if i < uint32(2) { @@ -27022,7 +27022,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27039,7 +27039,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27055,7 +27055,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27070,7 +27070,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if !(pok != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) X__shlim(tls, f, int64(Int32FromInt32(0))) return Float64FromInt32(0) } @@ -27096,7 +27096,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) X__shlim(tls, f, int64(Int32FromInt32(0))) return Float64FromInt32(0) } @@ -27105,7 +27105,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27396,7 +27396,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint val = uintptr(unsafe.Pointer(&_table6)) + uintptr(1) neg = 0 if base > uint32(36) || base == uint32(1) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uint64(0) } for { @@ -27404,7 +27404,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__shgetc(tls, f) } @@ -27424,7 +27424,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27435,7 +27435,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27445,12 +27445,12 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } c = v1 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) >= int32(16) { + if Int32FromUint8(**(**uint8)(__ccgo_up(val + uintptr(c)))) >= int32(16) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } @@ -27473,12 +27473,12 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint if base == uint32(0) { base = uint32(10) } - if uint32(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) >= base { + if uint32(**(**uint8)(__ccgo_up(val + uintptr(c)))) >= base { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } X__shlim(tls, f, int64(Int32FromInt32(0))) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uint64(0) } } @@ -27496,7 +27496,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27515,7 +27515,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27526,13 +27526,13 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint } } else { if !(base&(base-Uint32FromInt32(1)) != 0) { - bs = int32(*(*int8)(unsafe.Pointer(__ccgo_ts + 260 + uintptr(uint32(0x17)*base>>int32(5)&uint32(7))))) + bs = int32(**(**int8)(__ccgo_up(__ccgo_ts + 260 + uintptr(uint32(0x17)*base>>int32(5)&uint32(7))))) x = uint32(0) for { - if !(uint32(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) < base && x <= Uint32FromUint32(0xffffffff)/Uint32FromInt32(32)) { + if !(uint32(**(**uint8)(__ccgo_up(val + uintptr(c)))) < base && x <= Uint32FromUint32(0xffffffff)/Uint32FromInt32(32)) { break } - x = x<>bs) { + if !(uint32(**(**uint8)(__ccgo_up(val + uintptr(c)))) < base && y <= (Uint64FromUint64(2)*Uint64FromInt64(0x7fffffffffffffff)+Uint64FromInt32(1))>>bs) { break } - y = y<= lim { if !(lim&Uint64FromInt32(1) != 0) && !(neg != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return lim - uint64(1) } else { if y > lim { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return lim } } @@ -27659,8 +27659,8 @@ func X__procfdname(tls *TLS, buf uintptr, fd uint32) { _, _, _, _ = i, j, v2, v5 i = uint32(0) for { - v2 = *(*int8)(unsafe.Pointer(__ccgo_ts + 269 + uintptr(i))) - *(*int8)(unsafe.Pointer(buf + uintptr(i))) = v2 + v2 = **(**int8)(__ccgo_up(__ccgo_ts + 269 + uintptr(i))) + **(**int8)(__ccgo_up(buf + uintptr(i))) = v2 if !(v2 != 0) { break } @@ -27670,8 +27670,8 @@ func X__procfdname(tls *TLS, buf uintptr, fd uint32) { i = i + 1 } if !(fd != 0) { - *(*int8)(unsafe.Pointer(buf + uintptr(i))) = int8('0') - *(*int8)(unsafe.Pointer(buf + uintptr(i+uint32(1)))) = 0 + **(**int8)(__ccgo_up(buf + uintptr(i))) = int8('0') + **(**int8)(__ccgo_up(buf + uintptr(i+uint32(1)))) = 0 return } j = fd @@ -27685,14 +27685,14 @@ func X__procfdname(tls *TLS, buf uintptr, fd uint32) { j = j / uint32(10) i = i + 1 } - *(*int8)(unsafe.Pointer(buf + uintptr(i))) = 0 + **(**int8)(__ccgo_up(buf + uintptr(i))) = 0 for { if !(fd != 0) { break } i = i - 1 v5 = i - *(*int8)(unsafe.Pointer(buf + uintptr(v5))) = Int8FromUint32(uint32('0') + fd%uint32(10)) + **(**int8)(__ccgo_up(buf + uintptr(v5))) = Int8FromUint32(uint32('0') + fd%uint32(10)) goto _4 _4: ; @@ -27747,7 +27747,7 @@ func X__shgetc(tls *TLS, f uintptr) (r int32) { } (*TFILE)(unsafe.Pointer(f)).Fshcnt = int64(int32((*TFILE)(unsafe.Pointer(f)).Fbuf)-int32((*TFILE)(unsafe.Pointer(f)).Frpos)) + cnt if (*TFILE)(unsafe.Pointer(f)).Frpos <= (*TFILE)(unsafe.Pointer(f)).Fbuf { - *(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos + uintptr(-Int32FromInt32(1)))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos + uintptr(-Int32FromInt32(1)))) = Uint8FromInt32(c) } return c } @@ -27758,7 +27758,7 @@ func X__syscall_ret(tls *TLS, r uint32) (r1 int32) { defer func() { trc("-> %v", r1) }() } if r > -Uint32FromUint32(4096) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = Int32FromUint32(-r) + **(**int32)(__ccgo_up(X__errno_location(tls))) = Int32FromUint32(-r) return -int32(1) } return Int32FromUint32(r) @@ -27833,7 +27833,7 @@ func Xftok(tls *TLS, path uintptr, id int32) (r Tkey_t) { if Xstat(tls, path, bp) < 0 { return -int32(1) } - return Int32FromUint64((*(*Tstat)(unsafe.Pointer(bp))).Fst_ino&Uint64FromInt32(0xffff) | (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev&Uint64FromInt32(0xff)<= 0 && cmd&(Int32FromInt32(IPC_STAT)&Int32FromInt32(0x100)) != 0 { buf = orig - *(*Tmsqid_ds)(unsafe.Pointer(buf)) = *(*Tmsqid_ds)(unsafe.Pointer(bp)) + **(**Tmsqid_ds)(__ccgo_up(buf)) = **(**Tmsqid_ds)(__ccgo_up(bp)) (*Tmsqid_ds)(unsafe.Pointer(buf)).Fmsg_stime = Int64FromUint32((*Tmsqid_ds)(unsafe.Pointer(buf)).F__msg_stime_lo) | (0+Int64FromUint32((*Tmsqid_ds)(unsafe.Pointer(buf)).F__msg_stime_hi))<= 0 && cmd&(Int32FromInt32(IPC_STAT)&Int32FromInt32(0x100)) != 0 { *(*uintptr)(unsafe.Pointer(bp)) = orig - *(*Tsemid_ds)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) = *(*Tsemid_ds)(unsafe.Pointer(bp + 4)) + **(**Tsemid_ds)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp)))) = **(**Tsemid_ds)(__ccgo_up(bp + 4)) (*Tsemid_ds)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fsem_otime = Int64FromUint32((*Tsemid_ds)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).F__sem_otime_lo) | (0+Int64FromUint32((*Tsemid_ds)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).F__sem_otime_hi))< -Uint32FromInt32(SHMLBA) { v1 = uintptr(ret) } else { - v1 = *(*uintptr)(unsafe.Pointer(bp)) + v1 = **(**uintptr)(__ccgo_up(bp)) } return v1 } @@ -28267,14 +28267,14 @@ func Xshmctl(tls *TLS, id int32, cmd int32, buf uintptr) (r1 int32) { var _ /* out at bp+0 */ Tshmid_ds _, _ = orig, r if cmd&(Int32FromInt32(IPC_STAT)&Int32FromInt32(0x100)) != 0 { - *(*Tshmid_ds)(unsafe.Pointer(bp)) = Tshmid_ds{} + **(**Tshmid_ds)(__ccgo_up(bp)) = Tshmid_ds{} orig = buf buf = bp } r = int32(X__syscall6(tls, int32(SYS_ipc), int32(Int32FromInt32(IPCOP_shmctl)), id, int32(cmd & ^(Int32FromInt32(IPC_STAT)&Int32FromInt32(0x100)) | Int32FromInt32(IPC_64)), int32(Int32FromInt32(0)), int32(buf), int32(Int32FromInt32(0)))) if r >= 0 && cmd&(Int32FromInt32(IPC_STAT)&Int32FromInt32(0x100)) != 0 { buf = orig - *(*Tshmid_ds)(unsafe.Pointer(buf)) = *(*Tshmid_ds)(unsafe.Pointer(bp)) + **(**Tshmid_ds)(__ccgo_up(buf)) = **(**Tshmid_ds)(__ccgo_up(bp)) (*Tshmid_ds)(unsafe.Pointer(buf)).Fshm_atime = Int64FromUint32((*Tshmid_ds)(unsafe.Pointer(buf)).F__shm_atime_lo) | (0+Int64FromUint32((*Tshmid_ds)(unsafe.Pointer(buf)).F__shm_atime_hi))< int64(1000) || (*Ttimeval)(unsafe.Pointer(in)).Ftv_usec > int64(1000000000) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } - (*(*Ttimex)(unsafe.Pointer(bp))).Foffset = int32((*Ttimeval)(unsafe.Pointer(in)).Ftv_sec*int64(1000000) + (*Ttimeval)(unsafe.Pointer(in)).Ftv_usec) - (*(*Ttimex)(unsafe.Pointer(bp))).Fmodes = uint32(ADJ_OFFSET_SINGLESHOT) + (**(**Ttimex)(__ccgo_up(bp))).Foffset = int32((*Ttimeval)(unsafe.Pointer(in)).Ftv_sec*int64(1000000) + (*Ttimeval)(unsafe.Pointer(in)).Ftv_usec) + (**(**Ttimex)(__ccgo_up(bp))).Fmodes = uint32(ADJ_OFFSET_SINGLESHOT) } if Xadjtimex(tls, bp) < 0 { return -int32(1) } if out != 0 { - (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec = int64((*(*Ttimex)(unsafe.Pointer(bp))).Foffset / int32(1000000)) - v1 = int64((*(*Ttimex)(unsafe.Pointer(bp))).Foffset % Int32FromInt32(1000000)) + (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec = int64((**(**Ttimex)(__ccgo_up(bp))).Foffset / int32(1000000)) + v1 = int64((**(**Ttimex)(__ccgo_up(bp))).Foffset % Int32FromInt32(1000000)) (*Ttimeval)(unsafe.Pointer(out)).Ftv_usec = v1 if v1 < 0 { (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec = (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec - 1 - *(*Tsuseconds_t)(unsafe.Pointer(out + 8)) += int64(1000000) + **(**Tsuseconds_t)(__ccgo_up(out + 8)) += int64(1000000) } } return 0 @@ -29419,7 +29419,7 @@ func Xclock_adjtime(tls *TLS, clock_id Tclockid_t, utx uintptr) (r1 int32) { var _ /* ktx at bp+208 */ Tktimex _ = r r = -int32(ENOSYS) - *(*Tktimex64)(unsafe.Pointer(bp)) = Tktimex64{ + **(**Tktimex64)(__ccgo_up(bp)) = Tktimex64{ Fmodes: (*Ttimex)(unsafe.Pointer(utx)).Fmodes, Foffset: int64((*Ttimex)(unsafe.Pointer(utx)).Foffset), Ffreq: int64((*Ttimex)(unsafe.Pointer(utx)).Ffreq), @@ -29444,27 +29444,27 @@ func Xclock_adjtime(tls *TLS, clock_id Tclockid_t, utx uintptr) (r1 int32) { } r = int32(X__syscall2(tls, int32(SYS_clock_adjtime64), clock_id, int32(bp))) if r >= 0 { - (*Ttimex)(unsafe.Pointer(utx)).Fmodes = (*(*Tktimex64)(unsafe.Pointer(bp))).Fmodes - (*Ttimex)(unsafe.Pointer(utx)).Foffset = int32((*(*Tktimex64)(unsafe.Pointer(bp))).Foffset) - (*Ttimex)(unsafe.Pointer(utx)).Ffreq = int32((*(*Tktimex64)(unsafe.Pointer(bp))).Ffreq) - (*Ttimex)(unsafe.Pointer(utx)).Fmaxerror = int32((*(*Tktimex64)(unsafe.Pointer(bp))).Fmaxerror) - (*Ttimex)(unsafe.Pointer(utx)).Festerror = int32((*(*Tktimex64)(unsafe.Pointer(bp))).Festerror) - (*Ttimex)(unsafe.Pointer(utx)).Fstatus = (*(*Tktimex64)(unsafe.Pointer(bp))).Fstatus - (*Ttimex)(unsafe.Pointer(utx)).Fconstant = int32((*(*Tktimex64)(unsafe.Pointer(bp))).Fconstant) - (*Ttimex)(unsafe.Pointer(utx)).Fprecision = int32((*(*Tktimex64)(unsafe.Pointer(bp))).Fprecision) - (*Ttimex)(unsafe.Pointer(utx)).Ftolerance = int32((*(*Tktimex64)(unsafe.Pointer(bp))).Ftolerance) - (*Ttimex)(unsafe.Pointer(utx)).Ftime.Ftv_sec = (*(*Tktimex64)(unsafe.Pointer(bp))).Ftime_sec - (*Ttimex)(unsafe.Pointer(utx)).Ftime.Ftv_usec = (*(*Tktimex64)(unsafe.Pointer(bp))).Ftime_usec - (*Ttimex)(unsafe.Pointer(utx)).Ftick = int32((*(*Tktimex64)(unsafe.Pointer(bp))).Ftick) - (*Ttimex)(unsafe.Pointer(utx)).Fppsfreq = int32((*(*Tktimex64)(unsafe.Pointer(bp))).Fppsfreq) - (*Ttimex)(unsafe.Pointer(utx)).Fjitter = int32((*(*Tktimex64)(unsafe.Pointer(bp))).Fjitter) - (*Ttimex)(unsafe.Pointer(utx)).Fshift = (*(*Tktimex64)(unsafe.Pointer(bp))).Fshift - (*Ttimex)(unsafe.Pointer(utx)).Fstabil = int32((*(*Tktimex64)(unsafe.Pointer(bp))).Fstabil) - (*Ttimex)(unsafe.Pointer(utx)).Fjitcnt = int32((*(*Tktimex64)(unsafe.Pointer(bp))).Fjitcnt) - (*Ttimex)(unsafe.Pointer(utx)).Fcalcnt = int32((*(*Tktimex64)(unsafe.Pointer(bp))).Fcalcnt) - (*Ttimex)(unsafe.Pointer(utx)).Ferrcnt = int32((*(*Tktimex64)(unsafe.Pointer(bp))).Ferrcnt) - (*Ttimex)(unsafe.Pointer(utx)).Fstbcnt = int32((*(*Tktimex64)(unsafe.Pointer(bp))).Fstbcnt) - (*Ttimex)(unsafe.Pointer(utx)).Ftai = (*(*Tktimex64)(unsafe.Pointer(bp))).Ftai + (*Ttimex)(unsafe.Pointer(utx)).Fmodes = (**(**Tktimex64)(__ccgo_up(bp))).Fmodes + (*Ttimex)(unsafe.Pointer(utx)).Foffset = int32((**(**Tktimex64)(__ccgo_up(bp))).Foffset) + (*Ttimex)(unsafe.Pointer(utx)).Ffreq = int32((**(**Tktimex64)(__ccgo_up(bp))).Ffreq) + (*Ttimex)(unsafe.Pointer(utx)).Fmaxerror = int32((**(**Tktimex64)(__ccgo_up(bp))).Fmaxerror) + (*Ttimex)(unsafe.Pointer(utx)).Festerror = int32((**(**Tktimex64)(__ccgo_up(bp))).Festerror) + (*Ttimex)(unsafe.Pointer(utx)).Fstatus = (**(**Tktimex64)(__ccgo_up(bp))).Fstatus + (*Ttimex)(unsafe.Pointer(utx)).Fconstant = int32((**(**Tktimex64)(__ccgo_up(bp))).Fconstant) + (*Ttimex)(unsafe.Pointer(utx)).Fprecision = int32((**(**Tktimex64)(__ccgo_up(bp))).Fprecision) + (*Ttimex)(unsafe.Pointer(utx)).Ftolerance = int32((**(**Tktimex64)(__ccgo_up(bp))).Ftolerance) + (*Ttimex)(unsafe.Pointer(utx)).Ftime.Ftv_sec = (**(**Tktimex64)(__ccgo_up(bp))).Ftime_sec + (*Ttimex)(unsafe.Pointer(utx)).Ftime.Ftv_usec = (**(**Tktimex64)(__ccgo_up(bp))).Ftime_usec + (*Ttimex)(unsafe.Pointer(utx)).Ftick = int32((**(**Tktimex64)(__ccgo_up(bp))).Ftick) + (*Ttimex)(unsafe.Pointer(utx)).Fppsfreq = int32((**(**Tktimex64)(__ccgo_up(bp))).Fppsfreq) + (*Ttimex)(unsafe.Pointer(utx)).Fjitter = int32((**(**Tktimex64)(__ccgo_up(bp))).Fjitter) + (*Ttimex)(unsafe.Pointer(utx)).Fshift = (**(**Tktimex64)(__ccgo_up(bp))).Fshift + (*Ttimex)(unsafe.Pointer(utx)).Fstabil = int32((**(**Tktimex64)(__ccgo_up(bp))).Fstabil) + (*Ttimex)(unsafe.Pointer(utx)).Fjitcnt = int32((**(**Tktimex64)(__ccgo_up(bp))).Fjitcnt) + (*Ttimex)(unsafe.Pointer(utx)).Fcalcnt = int32((**(**Tktimex64)(__ccgo_up(bp))).Fcalcnt) + (*Ttimex)(unsafe.Pointer(utx)).Ferrcnt = int32((**(**Tktimex64)(__ccgo_up(bp))).Ferrcnt) + (*Ttimex)(unsafe.Pointer(utx)).Fstbcnt = int32((**(**Tktimex64)(__ccgo_up(bp))).Fstbcnt) + (*Ttimex)(unsafe.Pointer(utx)).Ftai = (**(**Tktimex64)(__ccgo_up(bp))).Ftai } if Bool(false) || r != -int32(ENOSYS) { return X__syscall_ret(tls, Uint32FromInt32(r)) @@ -29473,7 +29473,7 @@ func Xclock_adjtime(tls *TLS, clock_id Tclockid_t, utx uintptr) (r1 int32) { return X__syscall_ret(tls, Uint32FromInt32(-Int32FromInt32(EOPNOTSUPP))) } if uint32(8) > uint32(4) { - *(*Tktimex)(unsafe.Pointer(bp + 208)) = Tktimex{ + **(**Tktimex)(__ccgo_up(bp + 208)) = Tktimex{ Fmodes: (*Ttimex)(unsafe.Pointer(utx)).Fmodes, Foffset: (*Ttimex)(unsafe.Pointer(utx)).Foffset, Ffreq: (*Ttimex)(unsafe.Pointer(utx)).Ffreq, @@ -29502,27 +29502,27 @@ func Xclock_adjtime(tls *TLS, clock_id Tclockid_t, utx uintptr) (r1 int32) { r = int32(X__syscall2(tls, int32(SYS_clock_adjtime), clock_id, int32(bp+208))) } if r >= 0 { - (*Ttimex)(unsafe.Pointer(utx)).Fmodes = (*(*Tktimex)(unsafe.Pointer(bp + 208))).Fmodes - (*Ttimex)(unsafe.Pointer(utx)).Foffset = (*(*Tktimex)(unsafe.Pointer(bp + 208))).Foffset - (*Ttimex)(unsafe.Pointer(utx)).Ffreq = (*(*Tktimex)(unsafe.Pointer(bp + 208))).Ffreq - (*Ttimex)(unsafe.Pointer(utx)).Fmaxerror = (*(*Tktimex)(unsafe.Pointer(bp + 208))).Fmaxerror - (*Ttimex)(unsafe.Pointer(utx)).Festerror = (*(*Tktimex)(unsafe.Pointer(bp + 208))).Festerror - (*Ttimex)(unsafe.Pointer(utx)).Fstatus = (*(*Tktimex)(unsafe.Pointer(bp + 208))).Fstatus - (*Ttimex)(unsafe.Pointer(utx)).Fconstant = (*(*Tktimex)(unsafe.Pointer(bp + 208))).Fconstant - (*Ttimex)(unsafe.Pointer(utx)).Fprecision = (*(*Tktimex)(unsafe.Pointer(bp + 208))).Fprecision - (*Ttimex)(unsafe.Pointer(utx)).Ftolerance = (*(*Tktimex)(unsafe.Pointer(bp + 208))).Ftolerance - (*Ttimex)(unsafe.Pointer(utx)).Ftime.Ftv_sec = int64((*(*Tktimex)(unsafe.Pointer(bp + 208))).Ftime_sec) - (*Ttimex)(unsafe.Pointer(utx)).Ftime.Ftv_usec = int64((*(*Tktimex)(unsafe.Pointer(bp + 208))).Ftime_usec) - (*Ttimex)(unsafe.Pointer(utx)).Ftick = (*(*Tktimex)(unsafe.Pointer(bp + 208))).Ftick - (*Ttimex)(unsafe.Pointer(utx)).Fppsfreq = (*(*Tktimex)(unsafe.Pointer(bp + 208))).Fppsfreq - (*Ttimex)(unsafe.Pointer(utx)).Fjitter = (*(*Tktimex)(unsafe.Pointer(bp + 208))).Fjitter - (*Ttimex)(unsafe.Pointer(utx)).Fshift = (*(*Tktimex)(unsafe.Pointer(bp + 208))).Fshift - (*Ttimex)(unsafe.Pointer(utx)).Fstabil = (*(*Tktimex)(unsafe.Pointer(bp + 208))).Fstabil - (*Ttimex)(unsafe.Pointer(utx)).Fjitcnt = (*(*Tktimex)(unsafe.Pointer(bp + 208))).Fjitcnt - (*Ttimex)(unsafe.Pointer(utx)).Fcalcnt = (*(*Tktimex)(unsafe.Pointer(bp + 208))).Fcalcnt - (*Ttimex)(unsafe.Pointer(utx)).Ferrcnt = (*(*Tktimex)(unsafe.Pointer(bp + 208))).Ferrcnt - (*Ttimex)(unsafe.Pointer(utx)).Fstbcnt = (*(*Tktimex)(unsafe.Pointer(bp + 208))).Fstbcnt - (*Ttimex)(unsafe.Pointer(utx)).Ftai = (*(*Tktimex)(unsafe.Pointer(bp + 208))).Ftai + (*Ttimex)(unsafe.Pointer(utx)).Fmodes = (**(**Tktimex)(__ccgo_up(bp + 208))).Fmodes + (*Ttimex)(unsafe.Pointer(utx)).Foffset = (**(**Tktimex)(__ccgo_up(bp + 208))).Foffset + (*Ttimex)(unsafe.Pointer(utx)).Ffreq = (**(**Tktimex)(__ccgo_up(bp + 208))).Ffreq + (*Ttimex)(unsafe.Pointer(utx)).Fmaxerror = (**(**Tktimex)(__ccgo_up(bp + 208))).Fmaxerror + (*Ttimex)(unsafe.Pointer(utx)).Festerror = (**(**Tktimex)(__ccgo_up(bp + 208))).Festerror + (*Ttimex)(unsafe.Pointer(utx)).Fstatus = (**(**Tktimex)(__ccgo_up(bp + 208))).Fstatus + (*Ttimex)(unsafe.Pointer(utx)).Fconstant = (**(**Tktimex)(__ccgo_up(bp + 208))).Fconstant + (*Ttimex)(unsafe.Pointer(utx)).Fprecision = (**(**Tktimex)(__ccgo_up(bp + 208))).Fprecision + (*Ttimex)(unsafe.Pointer(utx)).Ftolerance = (**(**Tktimex)(__ccgo_up(bp + 208))).Ftolerance + (*Ttimex)(unsafe.Pointer(utx)).Ftime.Ftv_sec = int64((**(**Tktimex)(__ccgo_up(bp + 208))).Ftime_sec) + (*Ttimex)(unsafe.Pointer(utx)).Ftime.Ftv_usec = int64((**(**Tktimex)(__ccgo_up(bp + 208))).Ftime_usec) + (*Ttimex)(unsafe.Pointer(utx)).Ftick = (**(**Tktimex)(__ccgo_up(bp + 208))).Ftick + (*Ttimex)(unsafe.Pointer(utx)).Fppsfreq = (**(**Tktimex)(__ccgo_up(bp + 208))).Fppsfreq + (*Ttimex)(unsafe.Pointer(utx)).Fjitter = (**(**Tktimex)(__ccgo_up(bp + 208))).Fjitter + (*Ttimex)(unsafe.Pointer(utx)).Fshift = (**(**Tktimex)(__ccgo_up(bp + 208))).Fshift + (*Ttimex)(unsafe.Pointer(utx)).Fstabil = (**(**Tktimex)(__ccgo_up(bp + 208))).Fstabil + (*Ttimex)(unsafe.Pointer(utx)).Fjitcnt = (**(**Tktimex)(__ccgo_up(bp + 208))).Fjitcnt + (*Ttimex)(unsafe.Pointer(utx)).Fcalcnt = (**(**Tktimex)(__ccgo_up(bp + 208))).Fcalcnt + (*Ttimex)(unsafe.Pointer(utx)).Ferrcnt = (**(**Tktimex)(__ccgo_up(bp + 208))).Ferrcnt + (*Ttimex)(unsafe.Pointer(utx)).Fstbcnt = (**(**Tktimex)(__ccgo_up(bp + 208))).Fstbcnt + (*Ttimex)(unsafe.Pointer(utx)).Ftai = (**(**Tktimex)(__ccgo_up(bp + 208))).Ftai } return X__syscall_ret(tls, Uint32FromInt32(r)) } @@ -30594,12 +30594,12 @@ func Xprlimit(tls *TLS, pid Tpid_t, resource int32, new_limit uintptr, old_limit var _ /* tmp at bp+0 */ Trlimit _ = r if new_limit != 0 && Bool(^Uint64FromUint64(0) != ^Uint64FromUint64(0)) { - *(*Trlimit)(unsafe.Pointer(bp)) = *(*Trlimit)(unsafe.Pointer(new_limit)) - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur >= ^Uint64FromUint64(0) { - (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur = ^Uint64FromUint64(0) + **(**Trlimit)(__ccgo_up(bp)) = **(**Trlimit)(__ccgo_up(new_limit)) + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur >= ^Uint64FromUint64(0) { + (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur = ^Uint64FromUint64(0) } - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_max >= ^Uint64FromUint64(0) { - (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_max = ^Uint64FromUint64(0) + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_max >= ^Uint64FromUint64(0) { + (**(**Trlimit)(__ccgo_up(bp))).Frlim_max = ^Uint64FromUint64(0) } new_limit = bp } @@ -30794,7 +30794,7 @@ func Xptrace(tls *TLS, req int32, va uintptr) (r int32) { if ret < 0 || Uint32FromInt32(req)-uint32(1) >= uint32(3) { return ret } - return *(*int32)(unsafe.Pointer(bp)) + return **(**int32)(__ccgo_up(bp)) } func Xpwritev2(tls *TLS, fd int32, iov uintptr, count int32, ofs Toff_t, flags int32) (r Tssize_t) { @@ -31106,22 +31106,22 @@ func Xstatx(tls *TLS, dirfd int32, path uintptr, flags int32, mask uint32, stx u if ret != 0 { return ret } - (*Tstatx)(unsafe.Pointer(stx)).Fstx_dev_major = uint32((*(*Tstat)(unsafe.Pointer(bp))).Fst_dev>>Int32FromInt32(31)>>Int32FromInt32(1)&Uint64FromUint32(0xfffff000) | (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev>>Int32FromInt32(8)&Uint64FromInt32(0x00000fff)) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_dev_minor = uint32((*(*Tstat)(unsafe.Pointer(bp))).Fst_dev>>Int32FromInt32(12)&Uint64FromUint32(0xffffff00) | (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev&Uint64FromInt32(0x000000ff)) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_ino = (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino - (*Tstatx)(unsafe.Pointer(stx)).Fstx_mode = uint16((*(*Tstat)(unsafe.Pointer(bp))).Fst_mode) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_nlink = (*(*Tstat)(unsafe.Pointer(bp))).Fst_nlink - (*Tstatx)(unsafe.Pointer(stx)).Fstx_uid = (*(*Tstat)(unsafe.Pointer(bp))).Fst_uid - (*Tstatx)(unsafe.Pointer(stx)).Fstx_gid = (*(*Tstat)(unsafe.Pointer(bp))).Fst_gid - (*Tstatx)(unsafe.Pointer(stx)).Fstx_size = Uint64FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_size) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_blksize = Uint32FromInt32((*(*Tstat)(unsafe.Pointer(bp))).Fst_blksize) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_blocks = Uint64FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_blocks) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_atime.Ftv_sec = (*(*Tstat)(unsafe.Pointer(bp))).Fst_atim.Ftv_sec - (*Tstatx)(unsafe.Pointer(stx)).Fstx_atime.Ftv_nsec = Uint32FromInt32((*(*Tstat)(unsafe.Pointer(bp))).Fst_atim.Ftv_nsec) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_mtime.Ftv_sec = (*(*Tstat)(unsafe.Pointer(bp))).Fst_mtim.Ftv_sec - (*Tstatx)(unsafe.Pointer(stx)).Fstx_mtime.Ftv_nsec = Uint32FromInt32((*(*Tstat)(unsafe.Pointer(bp))).Fst_mtim.Ftv_nsec) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_ctime.Ftv_sec = (*(*Tstat)(unsafe.Pointer(bp))).Fst_ctim.Ftv_sec - (*Tstatx)(unsafe.Pointer(stx)).Fstx_ctime.Ftv_nsec = Uint32FromInt32((*(*Tstat)(unsafe.Pointer(bp))).Fst_ctim.Ftv_nsec) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_dev_major = uint32((**(**Tstat)(__ccgo_up(bp))).Fst_dev>>Int32FromInt32(31)>>Int32FromInt32(1)&Uint64FromUint32(0xfffff000) | (**(**Tstat)(__ccgo_up(bp))).Fst_dev>>Int32FromInt32(8)&Uint64FromInt32(0x00000fff)) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_dev_minor = uint32((**(**Tstat)(__ccgo_up(bp))).Fst_dev>>Int32FromInt32(12)&Uint64FromUint32(0xffffff00) | (**(**Tstat)(__ccgo_up(bp))).Fst_dev&Uint64FromInt32(0x000000ff)) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_ino = (**(**Tstat)(__ccgo_up(bp))).Fst_ino + (*Tstatx)(unsafe.Pointer(stx)).Fstx_mode = uint16((**(**Tstat)(__ccgo_up(bp))).Fst_mode) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_nlink = (**(**Tstat)(__ccgo_up(bp))).Fst_nlink + (*Tstatx)(unsafe.Pointer(stx)).Fstx_uid = (**(**Tstat)(__ccgo_up(bp))).Fst_uid + (*Tstatx)(unsafe.Pointer(stx)).Fstx_gid = (**(**Tstat)(__ccgo_up(bp))).Fst_gid + (*Tstatx)(unsafe.Pointer(stx)).Fstx_size = Uint64FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_size) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_blksize = Uint32FromInt32((**(**Tstat)(__ccgo_up(bp))).Fst_blksize) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_blocks = Uint64FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_blocks) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_atime.Ftv_sec = (**(**Tstat)(__ccgo_up(bp))).Fst_atim.Ftv_sec + (*Tstatx)(unsafe.Pointer(stx)).Fstx_atime.Ftv_nsec = Uint32FromInt32((**(**Tstat)(__ccgo_up(bp))).Fst_atim.Ftv_nsec) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_mtime.Ftv_sec = (**(**Tstat)(__ccgo_up(bp))).Fst_mtim.Ftv_sec + (*Tstatx)(unsafe.Pointer(stx)).Fstx_mtime.Ftv_nsec = Uint32FromInt32((**(**Tstat)(__ccgo_up(bp))).Fst_mtim.Ftv_nsec) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_ctime.Ftv_sec = (**(**Tstat)(__ccgo_up(bp))).Fst_ctim.Ftv_sec + (*Tstatx)(unsafe.Pointer(stx)).Fstx_ctime.Ftv_nsec = Uint32FromInt32((**(**Tstat)(__ccgo_up(bp))).Fst_ctim.Ftv_nsec) (*Tstatx)(unsafe.Pointer(stx)).Fstx_btime = Tstatx_timestamp{} (*Tstatx)(unsafe.Pointer(stx)).Fstx_mask = uint32(0x7ff) return 0 @@ -31135,8 +31135,8 @@ func Xstime(tls *TLS, t uintptr) (r int32) { bp := tls.Alloc(16) defer tls.Free(16) var _ /* tv at bp+0 */ Ttimeval - *(*Ttimeval)(unsafe.Pointer(bp)) = Ttimeval{ - Ftv_sec: *(*Ttime_t)(unsafe.Pointer(t)), + **(**Ttimeval)(__ccgo_up(bp)) = Ttimeval{ + Ftv_sec: **(**Ttime_t)(__ccgo_up(t)), } return Xsettimeofday(tls, bp, UintptrFromInt32(0)) } @@ -31254,10 +31254,10 @@ func Xtimerfd_settime(tls *TLS, fd int32, flags int32, new1 uintptr, old uintptr } r = int32(X__syscall4(tls, int32(SYS_timerfd_settime32), fd, flags, int32(bp+32), int32(bp+48))) if !(r != 0) && old != 0 { - (*Titimerspec)(unsafe.Pointer(old)).Fit_interval.Ftv_sec = int64((*(*[4]int32)(unsafe.Pointer(bp + 48)))[0]) - (*Titimerspec)(unsafe.Pointer(old)).Fit_interval.Ftv_nsec = (*(*[4]int32)(unsafe.Pointer(bp + 48)))[int32(1)] - (*Titimerspec)(unsafe.Pointer(old)).Fit_value.Ftv_sec = int64((*(*[4]int32)(unsafe.Pointer(bp + 48)))[int32(2)]) - (*Titimerspec)(unsafe.Pointer(old)).Fit_value.Ftv_nsec = (*(*[4]int32)(unsafe.Pointer(bp + 48)))[int32(3)] + (*Titimerspec)(unsafe.Pointer(old)).Fit_interval.Ftv_sec = int64((**(**[4]int32)(__ccgo_up(bp + 48)))[0]) + (*Titimerspec)(unsafe.Pointer(old)).Fit_interval.Ftv_nsec = (**(**[4]int32)(__ccgo_up(bp + 48)))[int32(1)] + (*Titimerspec)(unsafe.Pointer(old)).Fit_value.Ftv_sec = int64((**(**[4]int32)(__ccgo_up(bp + 48)))[int32(2)]) + (*Titimerspec)(unsafe.Pointer(old)).Fit_value.Ftv_nsec = (**(**[4]int32)(__ccgo_up(bp + 48)))[int32(3)] } return X__syscall_ret(tls, Uint32FromInt32(r)) return X__syscall_ret(tls, Uint32FromInt32(X__syscall4(tls, int32(SYS_timerfd_settime32), fd, flags, int32(new1), int32(old)))) @@ -31282,10 +31282,10 @@ func Xtimerfd_gettime(tls *TLS, fd int32, cur uintptr) (r1 int32) { } r = int32(X__syscall2(tls, int32(SYS_timerfd_gettime32), fd, int32(bp))) if !(r != 0) { - (*Titimerspec)(unsafe.Pointer(cur)).Fit_interval.Ftv_sec = int64((*(*[4]int32)(unsafe.Pointer(bp)))[0]) - (*Titimerspec)(unsafe.Pointer(cur)).Fit_interval.Ftv_nsec = (*(*[4]int32)(unsafe.Pointer(bp)))[int32(1)] - (*Titimerspec)(unsafe.Pointer(cur)).Fit_value.Ftv_sec = int64((*(*[4]int32)(unsafe.Pointer(bp)))[int32(2)]) - (*Titimerspec)(unsafe.Pointer(cur)).Fit_value.Ftv_nsec = (*(*[4]int32)(unsafe.Pointer(bp)))[int32(3)] + (*Titimerspec)(unsafe.Pointer(cur)).Fit_interval.Ftv_sec = int64((**(**[4]int32)(__ccgo_up(bp)))[0]) + (*Titimerspec)(unsafe.Pointer(cur)).Fit_interval.Ftv_nsec = (**(**[4]int32)(__ccgo_up(bp)))[int32(1)] + (*Titimerspec)(unsafe.Pointer(cur)).Fit_value.Ftv_sec = int64((**(**[4]int32)(__ccgo_up(bp)))[int32(2)]) + (*Titimerspec)(unsafe.Pointer(cur)).Fit_value.Ftv_nsec = (**(**[4]int32)(__ccgo_up(bp)))[int32(3)] } return X__syscall_ret(tls, Uint32FromInt32(r)) return X__syscall_ret(tls, Uint32FromInt32(X__syscall2(tls, int32(SYS_timerfd_gettime32), fd, int32(cur)))) @@ -31453,12 +31453,12 @@ func Xwait4(tls *TLS, pid Tpid_t, status uintptr, options int32, ru uintptr) (r1 if r > 0 && ru != 0 && Bool(uint32(8) > uint32(4)) { Xmemcpy(tls, bp, dest, Uint32FromInt32(4)*Uint32FromInt64(4)) (*Trusage)(unsafe.Pointer(ru)).Fru_utime = Ttimeval{ - Ftv_sec: int64((*(*[4]int32)(unsafe.Pointer(bp)))[0]), - Ftv_usec: int64((*(*[4]int32)(unsafe.Pointer(bp)))[int32(1)]), + Ftv_sec: int64((**(**[4]int32)(__ccgo_up(bp)))[0]), + Ftv_usec: int64((**(**[4]int32)(__ccgo_up(bp)))[int32(1)]), } (*Trusage)(unsafe.Pointer(ru)).Fru_stime = Ttimeval{ - Ftv_sec: int64((*(*[4]int32)(unsafe.Pointer(bp)))[int32(2)]), - Ftv_usec: int64((*(*[4]int32)(unsafe.Pointer(bp)))[int32(3)]), + Ftv_sec: int64((**(**[4]int32)(__ccgo_up(bp)))[int32(2)]), + Ftv_usec: int64((**(**[4]int32)(__ccgo_up(bp)))[int32(3)]), } } return X__syscall_ret(tls, Uint32FromInt32(r)) @@ -31581,7 +31581,7 @@ func X__lctrans_cur(tls *TLS, msg uintptr) (r uintptr) { trc("tls=%v msg=%v, (%v:)", tls, msg, origin(2)) defer func() { trc("-> %v", r) }() } - return X__lctrans_impl(tls, msg, *(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale + 5*4))) + return X__lctrans_impl(tls, msg, **(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale + 5*4))) } func _swapc(tls *TLS, x Tuint32_t, c int32) (r Tuint32_t) { @@ -31605,27 +31605,27 @@ func X__mo_lookup(tls *TLS, p uintptr, size Tsize_t, s uintptr) (r uintptr) { var sign, sw int32 _, _, _, _, _, _, _, _, _, _, _ = b, mo, n, o, ol, os, sign, sw, t, tl, ts mo = p - sw = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(mo)) - uint32(0x950412de)) + sw = Int32FromUint32(**(**Tuint32_t)(__ccgo_up(mo)) - uint32(0x950412de)) b = uint32(0) - n = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + 2*4)), sw) - o = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + 3*4)), sw) - t = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + 4*4)), sw) + n = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + 2*4)), sw) + o = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + 3*4)), sw) + t = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + 4*4)), sw) if n >= size/uint32(4) || o >= size-uint32(4)*n || t >= size-uint32(4)*n || (o|t)%uint32(4) != 0 { return uintptr(0) } o = o / uint32(4) t = t / uint32(4) for { - ol = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + uintptr(o+uint32(2)*(b+n/uint32(2)))*4)), sw) - os = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + uintptr(o+uint32(2)*(b+n/uint32(2))+uint32(1))*4)), sw) - if os >= size || ol >= size-os || *(*int8)(unsafe.Pointer(p + uintptr(os+ol))) != 0 { + ol = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + uintptr(o+uint32(2)*(b+n/uint32(2)))*4)), sw) + os = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + uintptr(o+uint32(2)*(b+n/uint32(2))+uint32(1))*4)), sw) + if os >= size || ol >= size-os || **(**int8)(__ccgo_up(p + uintptr(os+ol))) != 0 { return uintptr(0) } sign = Xstrcmp(tls, s, p+uintptr(os)) if !(sign != 0) { - tl = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + uintptr(t+uint32(2)*(b+n/uint32(2)))*4)), sw) - ts = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + uintptr(t+uint32(2)*(b+n/uint32(2))+uint32(1))*4)), sw) - if ts >= size || tl >= size-ts || *(*int8)(unsafe.Pointer(p + uintptr(ts+tl))) != 0 { + tl = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + uintptr(t+uint32(2)*(b+n/uint32(2)))*4)), sw) + ts = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + uintptr(t+uint32(2)*(b+n/uint32(2))+uint32(1))*4)), sw) + if ts >= size || tl >= size-ts || **(**int8)(__ccgo_up(p + uintptr(ts+tl))) != 0 { return uintptr(0) } return p + uintptr(ts) @@ -31655,7 +31655,7 @@ func Xbind_textdomain_codeset(tls *TLS, domainname uintptr, codeset uintptr) (r defer func() { trc("-> %v", r) }() } if codeset != 0 && Xstrcasecmp(tls, codeset, __ccgo_ts+322) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) } return UintptrFromInt32(0) } @@ -31683,7 +31683,7 @@ func Xcatclose(tls *TLS, catd Tnl_catd) (r int32) { var v1, v2 Tuint32_t _, _, _ = map1, v1, v2 map1 = catd - v1 = *(*Tuint32_t)(unsafe.Pointer(map1 + UintptrFromInt32(8))) + v1 = **(**Tuint32_t)(__ccgo_up(map1 + UintptrFromInt32(8))) v2 = v1>>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v4>>int32(8)&uint32(0xff00) | v4<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v4>>int32(8)&uint32(0xff00) | v4<>int32(24) | v7>>int32(8)&uint32(0xff00) | v7<>int32(24) | v10>>int32(8)&uint32(0xff00) | v10<>int32(24) | v13>>int32(8)&uint32(0xff00) | v13<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v4>>int32(8)&uint32(0xff00) | v4<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v5>>int32(8)&uint32(0xff00) | v5< uint32(NAME_MAX) || dirlen >= uint32(PATH_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } ___lock(tls, uintptr(unsafe.Pointer(&_lock1))) @@ -32148,7 +32148,7 @@ func Xdcngettext(tls *TLS, domainname uintptr, msgid1 uintptr, msgid2 uintptr, n _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = alt_modlen, catlen, catname, csp, dirlen, dirname, domlen, l, lm, loc, loclen, locname, locp, map1, modlen, modname, name, np, old_cats, old_errno, p1, plural, q, r, rem, rule, trans, v11, v12, v20, v3, v5, v6 defer func() { Xrealloc(tls, name, 0) }() loc = (*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale - old_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + old_errno = **(**int32)(__ccgo_up(X__errno_location(tls))) /* match gnu gettext behaviour */ if !(msgid1 != 0) { goto notrans @@ -32179,14 +32179,14 @@ func Xdcngettext(tls *TLS, domainname uintptr, msgid1 uintptr, msgid2 uintptr, n if !(q != 0) { goto notrans } - lm = *(*uintptr)(unsafe.Pointer(loc + uintptr(category)*4)) + lm = **(**uintptr)(__ccgo_up(loc + uintptr(category)*4)) if !!(lm != 0) { goto _2 } goto notrans notrans: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = old_errno + **(**int32)(__ccgo_up(X__errno_location(tls))) = old_errno if n == uint32(1) { v3 = msgid1 } else { @@ -32259,21 +32259,21 @@ _2: } p1 = Xcalloc(tls, uint32(32), uint32(1)) if !(p1 != 0) { - X__munmap(tls, map1, *(*Tsize_t)(unsafe.Pointer(bp))) + X__munmap(tls, map1, **(**Tsize_t)(__ccgo_up(bp))) goto notrans } (*Tmsgcat)(unsafe.Pointer(p1)).Fcat = category (*Tmsgcat)(unsafe.Pointer(p1)).Fbinding = q (*Tmsgcat)(unsafe.Pointer(p1)).Flm = lm (*Tmsgcat)(unsafe.Pointer(p1)).Fmap1 = map1 - (*Tmsgcat)(unsafe.Pointer(p1)).Fmap_size = *(*Tsize_t)(unsafe.Pointer(bp)) + (*Tmsgcat)(unsafe.Pointer(p1)).Fmap_size = **(**Tsize_t)(__ccgo_up(bp)) rule = __ccgo_ts + 381 np = uint32(2) r = X__mo_lookup(tls, (*Tmsgcat)(unsafe.Pointer(p1)).Fmap1, (*Tmsgcat)(unsafe.Pointer(p1)).Fmap_size, __ccgo_ts) for r != 0 && Xstrncmp(tls, r, __ccgo_ts+387, uint32(13)) != 0 { - *(*uintptr)(unsafe.Pointer(bp + 4)) = Xstrchr(tls, r, int32('\n')) - if *(*uintptr)(unsafe.Pointer(bp + 4)) != 0 { - v3 = *(*uintptr)(unsafe.Pointer(bp + 4)) + uintptr(1) + **(**uintptr)(__ccgo_up(bp + 4)) = Xstrchr(tls, r, int32('\n')) + if **(**uintptr)(__ccgo_up(bp + 4)) != 0 { + v3 = **(**uintptr)(__ccgo_up(bp + 4)) + uintptr(1) } else { v3 = uintptr(0) } @@ -32282,7 +32282,7 @@ _2: if r != 0 { r = r + uintptr(13) for { - v11 = int32(*(*int8)(unsafe.Pointer(r))) + v11 = int32(**(**int8)(__ccgo_up(r))) v12 = BoolInt32(v11 == int32(' ') || Uint32FromInt32(v11)-uint32('\t') < uint32(5)) goto _13 _13: @@ -32293,15 +32293,15 @@ _2: } if !(Xstrncmp(tls, r, __ccgo_ts+401, uint32(9)) != 0) { np = Xstrtoul(tls, r+uintptr(9), bp+4, int32(10)) - r = *(*uintptr)(unsafe.Pointer(bp + 4)) + r = **(**uintptr)(__ccgo_up(bp + 4)) } - for *(*int8)(unsafe.Pointer(r)) != 0 && int32(*(*int8)(unsafe.Pointer(r))) != int32(';') { + for **(**int8)(__ccgo_up(r)) != 0 && int32(**(**int8)(__ccgo_up(r))) != int32(';') { r = r + 1 } - if *(*int8)(unsafe.Pointer(r)) != 0 { + if **(**int8)(__ccgo_up(r)) != 0 { r = r + 1 for { - v11 = int32(*(*int8)(unsafe.Pointer(r))) + v11 = int32(**(**int8)(__ccgo_up(r))) v12 = BoolInt32(v11 == int32(' ') || Uint32FromInt32(v11)-uint32('\t') < uint32(5)) goto _16 _16: @@ -32357,7 +32357,7 @@ _2: trans = trans + uintptr(l+uint32(1)) } } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = old_errno + **(**int32)(__ccgo_up(X__errno_location(tls))) = old_errno return trans } @@ -32401,7 +32401,7 @@ func X__duplocale(tls *TLS, old Tlocale_t) (r Tlocale_t) { if old == uintptr(-Int32FromInt32(1)) { old = uintptr(unsafe.Pointer(&X__libc)) + 32 } - *(*t__locale_struct)(unsafe.Pointer(new1)) = *(*t__locale_struct)(unsafe.Pointer(old)) + **(**t__locale_struct)(__ccgo_up(new1)) = **(**t__locale_struct)(__ccgo_up(old)) return new1 } @@ -98575,13 +98575,13 @@ var _rev_jis = [6879]uint16{ func _fuzzycmp(tls *TLS, a uintptr, b uintptr) (r int32) { for { - if !(*(*uint8)(unsafe.Pointer(a)) != 0 && *(*uint8)(unsafe.Pointer(b)) != 0) { + if !(**(**uint8)(__ccgo_up(a)) != 0 && **(**uint8)(__ccgo_up(b)) != 0) { break } - for *(*uint8)(unsafe.Pointer(a)) != 0 && uint32(*(*uint8)(unsafe.Pointer(a)))|uint32(32)-uint32('a') > uint32(26) && Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(a)))-int32('0')) > uint32(10) { + for **(**uint8)(__ccgo_up(a)) != 0 && uint32(**(**uint8)(__ccgo_up(a)))|uint32(32)-uint32('a') > uint32(26) && Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(a)))-int32('0')) > uint32(10) { a = a + 1 } - if uint32(*(*uint8)(unsafe.Pointer(a)))|uint32(32) != uint32(*(*uint8)(unsafe.Pointer(b))) { + if uint32(**(**uint8)(__ccgo_up(a)))|uint32(32) != uint32(**(**uint8)(__ccgo_up(b))) { return int32(1) } goto _1 @@ -98590,23 +98590,23 @@ func _fuzzycmp(tls *TLS, a uintptr, b uintptr) (r int32) { a = a + 1 b = b + 1 } - return BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(a))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(b)))) + return BoolInt32(Int32FromUint8(**(**uint8)(__ccgo_up(a))) != Int32FromUint8(**(**uint8)(__ccgo_up(b)))) } func _find_charmap(tls *TLS, name uintptr) (r Tsize_t) { var s uintptr _ = s - if !(*(*int8)(unsafe.Pointer(name)) != 0) { + if !(**(**int8)(__ccgo_up(name)) != 0) { name = uintptr(unsafe.Pointer(&_charmaps)) } /* "utf8" */ s = uintptr(unsafe.Pointer(&_charmaps)) for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { break } if !(_fuzzycmp(tls, name, s) != 0) { for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { break } goto _2 @@ -98617,11 +98617,11 @@ func _find_charmap(tls *TLS, name uintptr) (r Tsize_t) { return Uint32FromInt32(int32(s+uintptr(1)) - t__predefined_ptrdiff_t(uintptr(unsafe.Pointer(&_charmaps)))) } s = s + uintptr(_strlen(tls, s)+uint32(1)) - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) > int32(0200) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { + if Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) > int32(0200) { s = s + uintptr(2) } else { - s = s + uintptr(uint32(2)+(uint32(64)-uint32(*(*uint8)(unsafe.Pointer(s + 1))))*uint32(5)) + s = s + uintptr(uint32(2)+(uint32(64)-uint32(**(**uint8)(__ccgo_up(s + 1))))*uint32(5)) } } goto _1 @@ -98664,7 +98664,7 @@ func Xiconv_open(tls *TLS, to uintptr, from uintptr) (r Ticonv_t) { f = v2 } if v3 || v2 == Uint32FromInt32(-Int32FromInt32(1)) || Int32FromUint8(_charmaps[t]) >= int32(0330) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(-Int32FromInt32(1)) } cd = _combine_to_from(tls, t, f) @@ -98689,26 +98689,26 @@ func Xiconv_open(tls *TLS, to uintptr, from uintptr) (r Ticonv_t) { func _get_16(tls *TLS, s uintptr, e int32) (r uint32) { e = e & int32(1) - return Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(e))))<> int32(8)) - *(*uint8)(unsafe.Pointer(s + uintptr(int32(1)-e))) = uint8(c) + **(**uint8)(__ccgo_up(s + uintptr(e))) = uint8(c >> int32(8)) + **(**uint8)(__ccgo_up(s + uintptr(int32(1)-e))) = uint8(c) } func _get_32(tls *TLS, s uintptr, e int32) (r uint32) { e = e & int32(3) - return (uint32(*(*uint8)(unsafe.Pointer(s + uintptr(e))))+0)<> int32(24)) - *(*uint8)(unsafe.Pointer(s + uintptr(e^int32(1)))) = uint8(c >> int32(16)) - *(*uint8)(unsafe.Pointer(s + uintptr(e^int32(2)))) = uint8(c >> int32(8)) - *(*uint8)(unsafe.Pointer(s + uintptr(e^int32(3)))) = uint8(c) + **(**uint8)(__ccgo_up(s + uintptr(e^0))) = uint8(c >> int32(24)) + **(**uint8)(__ccgo_up(s + uintptr(e^int32(1)))) = uint8(c >> int32(16)) + **(**uint8)(__ccgo_up(s + uintptr(e^int32(2)))) = uint8(c >> int32(8)) + **(**uint8)(__ccgo_up(s + uintptr(e^int32(3)))) = uint8(c) } /* Adapt as needed */ @@ -98716,11 +98716,11 @@ func _put_32(tls *TLS, s uintptr, c uint32, e int32) { func _legacy_map(tls *TLS, map1 uintptr, c uint32) (r uint32) { var x, v1 uint32 _, _ = x, v1 - if c < Uint32FromInt32(int32(4)*Int32FromUint8(*(*uint8)(unsafe.Pointer(map1 + uintptr(-Int32FromInt32(1)))))) { + if c < Uint32FromInt32(int32(4)*Int32FromUint8(**(**uint8)(__ccgo_up(map1 + uintptr(-Int32FromInt32(1)))))) { return c } - x = c - Uint32FromInt32(int32(4)*Int32FromUint8(*(*uint8)(unsafe.Pointer(map1 + uintptr(-Int32FromInt32(1)))))) - x = Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(map1 + uintptr(x*uint32(5)/uint32(4)))))>>(uint32(2)*x%uint32(8)) | Int32FromUint8(*(*uint8)(unsafe.Pointer(map1 + uintptr(x*uint32(5)/uint32(4)+uint32(1)))))<<(uint32(8)-uint32(2)*x%uint32(8))&int32(1023)) + x = c - Uint32FromInt32(int32(4)*Int32FromUint8(**(**uint8)(__ccgo_up(map1 + uintptr(-Int32FromInt32(1)))))) + x = Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(map1 + uintptr(x*uint32(5)/uint32(4)))))>>(uint32(2)*x%uint32(8)) | Int32FromUint8(**(**uint8)(__ccgo_up(map1 + uintptr(x*uint32(5)/uint32(4)+uint32(1)))))<<(uint32(8)-uint32(2)*x%uint32(8))&int32(1023)) if x < uint32(256) { v1 = x } else { @@ -98737,7 +98737,7 @@ func _uni_to_jis(tls *TLS, c uint32) (r uint32) { for { i = nel / uint32(2) j = uint32(_rev_jis[b+i]) - d = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(j/uint32(256))*188 + uintptr(j%uint32(256))*2))) + d = uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(j/uint32(256))*188 + uintptr(j%uint32(256))*2))) if d == c { return j + uint32(0x2121) } else { @@ -98790,20 +98790,20 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui from = _extract_from(tls, cd) map1 = uintptr(unsafe.Pointer(&_charmaps)) + uintptr(from) + uintptr(1) tomap = uintptr(unsafe.Pointer(&_charmaps)) + uintptr(to) + uintptr(1) - *(*Tmbstate_t)(unsafe.Pointer(bp + 16)) = Tmbstate_t{} - type1 = *(*uint8)(unsafe.Pointer(map1 + uintptr(-Int32FromInt32(1)))) - totype = *(*uint8)(unsafe.Pointer(tomap + uintptr(-Int32FromInt32(1)))) + **(**Tmbstate_t)(__ccgo_up(bp + 16)) = Tmbstate_t{} + type1 = **(**uint8)(__ccgo_up(map1 + uintptr(-Int32FromInt32(1)))) + totype = **(**uint8)(__ccgo_up(tomap + uintptr(-Int32FromInt32(1)))) ploc = uintptr(___get_tp(tls)) + 96 - loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) - if !(in != 0) || !(*(*uintptr)(unsafe.Pointer(in)) != 0) || !(*(*Tsize_t)(unsafe.Pointer(inb)) != 0) { + loc = **(**Tlocale_t)(__ccgo_up(ploc)) + if !(in != 0) || !(**(**uintptr)(__ccgo_up(in)) != 0) || !(**(**Tsize_t)(__ccgo_up(inb)) != 0) { return uint32(0) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = uintptr(unsafe.Pointer(&X__c_dot_utf8_locale)) + **(**Tlocale_t)(__ccgo_up(ploc)) = uintptr(unsafe.Pointer(&X__c_dot_utf8_locale)) for { - if !(*(*Tsize_t)(unsafe.Pointer(inb)) != 0) { + if !(**(**Tsize_t)(__ccgo_up(inb)) != 0) { break } - c = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in))))) + c = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in))))) l = uint32(1) switch Int32FromUint8(type1) { case int32(UTF_8): @@ -98855,14 +98855,14 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if c < uint32(128) { goto _23 } - l = Xmbrtowc(tls, bp+24, *(*uintptr)(unsafe.Pointer(in)), *(*Tsize_t)(unsafe.Pointer(inb)), bp+16) + l = Xmbrtowc(tls, bp+24, **(**uintptr)(__ccgo_up(in)), **(**Tsize_t)(__ccgo_up(inb)), bp+16) if l == Uint32FromInt32(-Int32FromInt32(1)) { goto ilseq } if l == Uint32FromInt32(-Int32FromInt32(2)) { goto starved } - c = Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp + 24))) + c = Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp + 24))) goto _23 _3: ; @@ -98873,10 +98873,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui _4: ; l = uint32(4) - if *(*Tsize_t)(unsafe.Pointer(inb)) < l { + if **(**Tsize_t)(__ccgo_up(inb)) < l { goto starved } - c = Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in))))) + c = Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(in))))) if !(0 != 0) { goto _24 } @@ -98885,10 +98885,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui _5: ; l = uint32(4) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint32(4) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint32(4) { goto starved } - c = _get_32(tls, *(*uintptr)(unsafe.Pointer(in)), Int32FromUint8(type1)) + c = _get_32(tls, **(**uintptr)(__ccgo_up(in)), Int32FromUint8(type1)) _24: ; if c-uint32(0xd800) < uint32(0x800) || c >= uint32(0x110000) { @@ -98904,10 +98904,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui _7: ; l = uint32(2) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint32(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint32(2) { goto starved } - c = _get_16(tls, *(*uintptr)(unsafe.Pointer(in)), Int32FromUint8(type1)) + c = _get_16(tls, **(**uintptr)(__ccgo_up(in)), Int32FromUint8(type1)) if c-Uint32FromInt32(0xdc00) < uint32(0x400) { goto ilseq } @@ -98916,10 +98916,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto ilseq } l = uint32(4) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint32(4) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint32(4) { goto starved } - d = _get_16(tls, *(*uintptr)(unsafe.Pointer(in))+UintptrFromInt32(2), Int32FromUint8(type1)) + d = _get_16(tls, **(**uintptr)(__ccgo_up(in))+UintptrFromInt32(2), Int32FromUint8(type1)) if d-Uint32FromInt32(0xdc00) >= uint32(0x400) { goto ilseq } @@ -98932,10 +98932,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui ; l = uint32(0) if !((*Tstateful_cd)(unsafe.Pointer(scd)).Fstate != 0) { - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint32(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint32(2) { goto starved } - c = _get_16(tls, *(*uintptr)(unsafe.Pointer(in)), 0) + c = _get_16(tls, **(**uintptr)(__ccgo_up(in)), 0) if Int32FromUint8(type1) == int32(UCS2) { if c == uint32(0xfffe) { v26 = int32(UCS2LE) @@ -98962,10 +98962,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui ; l = uint32(0) if !((*Tstateful_cd)(unsafe.Pointer(scd)).Fstate != 0) { - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint32(4) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint32(4) { goto starved } - c = _get_32(tls, *(*uintptr)(unsafe.Pointer(in)), 0) + c = _get_32(tls, **(**uintptr)(__ccgo_up(in)), 0) if c == uint32(0xfffe0000) { v25 = int32(UTF_32LE) } else { @@ -98988,10 +98988,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _23 } l = uint32(2) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint32(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint32(2) { goto starved } - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(1)))) if c-uint32(129) <= Uint32FromInt32(Int32FromInt32(159)-Int32FromInt32(129)) { c = c - uint32(129) } else { @@ -99019,7 +99019,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if c >= uint32(84) { goto ilseq } - c = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(c)*188 + uintptr(d)*2))) + c = uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(c)*188 + uintptr(d)*2))) if !(c != 0) { goto ilseq } @@ -99030,10 +99030,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _23 } l = uint32(2) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint32(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint32(2) { goto starved } - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(1)))) if c == uint32(0x8e) { c = d if c-uint32(0xa1) > Uint32FromInt32(Int32FromInt32(0xdf)-Int32FromInt32(0xa1)) { @@ -99047,7 +99047,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if c >= uint32(84) || d >= uint32(94) { goto ilseq } - c = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(c)*188 + uintptr(d)*2))) + c = uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(c)*188 + uintptr(d)*2))) if !(c != 0) { goto ilseq } @@ -99059,11 +99059,11 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } if c == uint32('\033') { l = uint32(3) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint32(3) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint32(3) { goto starved } - c = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(2)))) + c = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(1)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(2)))) if c != uint32('(') && c != uint32('$') { goto ilseq } @@ -99098,16 +99098,16 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui fallthrough case uint32(3): l = uint32(2) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint32(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint32(2) { goto starved } - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(1)))) c = c - uint32(0x21) d = d - uint32(0x21) if c >= uint32(84) || d >= uint32(94) { goto ilseq } - c = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(c)*188 + uintptr(d)*2))) + c = uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(c)*188 + uintptr(d)*2))) if !(c != 0) { goto ilseq } @@ -99145,10 +99145,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto ilseq } l = uint32(2) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint32(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint32(2) { goto starved } - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(1)))) if d < uint32(0xa1) && Int32FromUint8(type1) == int32(GB2312) { goto ilseq } @@ -99157,16 +99157,16 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto ilseq } l = uint32(4) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint32(4) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint32(4) { goto starved } c = (uint32(10)*c + d - uint32('0')) * uint32(1260) - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(2)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(2)))) if d-uint32(0x81) > uint32(126) { goto ilseq } c = c + uint32(10)*(d-uint32(0x81)) - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(3)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(3)))) if d-uint32('0') > uint32(9) { goto ilseq } @@ -99188,7 +99188,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if !(j < int32(190)) { break } - if uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_gb18030)) + uintptr(i)*380 + uintptr(j)*2)))-d <= c-d { + if uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_gb18030)) + uintptr(i)*380 + uintptr(j)*2)))-d <= c-d { k = k + 1 } goto _31 @@ -99212,7 +99212,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if d > uint32(63) { d = d - 1 } - c = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_gb18030)) + uintptr(c)*380 + uintptr(d)*2))) + c = uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_gb18030)) + uintptr(c)*380 + uintptr(d)*2))) goto _23 _20: ; @@ -99220,10 +99220,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _23 } l = uint32(2) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint32(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint32(2) { goto starved } - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(1)))) if d-uint32(0x40) >= Uint32FromInt32(Int32FromInt32(0xff)-Int32FromInt32(0x40)) || d-uint32(0x7f) < Uint32FromInt32(Int32FromInt32(0xa1)-Int32FromInt32(0x7f)) { goto ilseq } @@ -99246,21 +99246,21 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui * range in the hkscs table then hard-coded * here. Ugly, yes. */ if c/uint32(256) == uint32(0xdc) { - *(*uintptr)(unsafe.Pointer(bp + 40)) = bp + 32 + **(**uintptr)(__ccgo_up(bp + 40)) = bp + 32 *(*uintptr)(unsafe.Pointer(bp)) = __ccgo_ts + 419 + uintptr(c%uint32(256)) *(*Tsize_t)(unsafe.Pointer(bp + 4)) = uint32(4) *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint32(8) tmpx = Xiconv(tls, _combine_to_from(tls, to, _find_charmap(tls, __ccgo_ts+436)), bp, bp+4, bp+40, bp+8) - tmplen = Uint32FromInt32(int32(*(*uintptr)(unsafe.Pointer(bp + 40))) - t__predefined_ptrdiff_t(bp+32)) - if tmplen > *(*Tsize_t)(unsafe.Pointer(outb)) { + tmplen = Uint32FromInt32(int32(**(**uintptr)(__ccgo_up(bp + 40))) - t__predefined_ptrdiff_t(bp+32)) + if tmplen > **(**Tsize_t)(__ccgo_up(outb)) { goto toobig } if tmpx != 0 { x = x + 1 } - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(out)), bp+32, tmplen) - *(*uintptr)(unsafe.Pointer(out)) += uintptr(tmplen) - *(*Tsize_t)(unsafe.Pointer(outb)) -= tmplen + Xmemcpy(tls, **(**uintptr)(__ccgo_up(out)), bp+32, tmplen) + **(**uintptr)(__ccgo_up(out)) += uintptr(tmplen) + **(**Tsize_t)(__ccgo_up(outb)) -= tmplen goto _1 } if !(c != 0) { @@ -99269,7 +99269,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _23 } c = c - uint32(0xa1) - c = Uint32FromInt32(Int32FromUint16(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_big5)) + uintptr(c)*314 + uintptr(d)*2))) | BoolInt32(c == uint32(0x27) && (d == uint32(0x3a) || d == uint32(0x3c) || d == uint32(0x42)))<= uint32(93) || d >= uint32(94) { @@ -99327,7 +99327,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if !(j1 < int32(94)) { break } - if uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ksc)) + uintptr(i1)*188 + uintptr(j1)*2)))-d <= c-d { + if uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_ksc)) + uintptr(i1)*188 + uintptr(j1)*2)))-d <= c-d { k = k + 1 } goto _34 @@ -99347,7 +99347,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } goto _23 } - c = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ksc)) + uintptr(c)*188 + uintptr(d)*2))) + c = uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_ksc)) + uintptr(c)*188 + uintptr(d)*2))) if !(c != 0) { goto ilseq } @@ -99400,26 +99400,26 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _51 _35: ; - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint32(4) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint32(4) { goto toobig } - *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(out)))) = Int32FromUint32(c) - *(*uintptr)(unsafe.Pointer(out)) += uintptr(4) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint32(4) + **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(out)))) = Int32FromUint32(c) + **(**uintptr)(__ccgo_up(out)) += uintptr(4) + **(**Tsize_t)(__ccgo_up(outb)) -= uint32(4) goto _51 _36: ; - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint32(4) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint32(4) { k = Uint32FromInt32(Xwctomb(tls, bp+44, Int32FromUint32(c))) - if *(*Tsize_t)(unsafe.Pointer(outb)) < k { + if **(**Tsize_t)(__ccgo_up(outb)) < k { goto toobig } - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(out)), bp+44, k) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(out)), bp+44, k) } else { - k = Uint32FromInt32(Xwctomb(tls, *(*uintptr)(unsafe.Pointer(out)), Int32FromUint32(c))) + k = Uint32FromInt32(Xwctomb(tls, **(**uintptr)(__ccgo_up(out)), Int32FromUint32(c))) } - *(*uintptr)(unsafe.Pointer(out)) += uintptr(k) - *(*Tsize_t)(unsafe.Pointer(outb)) -= k + **(**uintptr)(__ccgo_up(out)) += uintptr(k) + **(**Tsize_t)(__ccgo_up(outb)) -= k goto _51 _37: ; @@ -99435,7 +99435,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui ; _38: ; - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint32(1) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint32(1) { goto toobig } if !(c < uint32(256) && c == _legacy_map(tls, tomap, c)) { @@ -99444,14 +99444,14 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto revout revout: ; - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint32(1) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint32(1) { goto toobig } v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = Int8FromUint32(c) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint32(1) + **(**int8)(__ccgo_up(v54)) = Int8FromUint32(c) + **(**Tsize_t)(__ccgo_up(outb)) -= uint32(1) goto _51 _53: ; @@ -99493,7 +99493,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if !(c != 0) { goto subst } - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint32(2) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint32(2) { goto toobig } d = c % uint32(256) @@ -99506,7 +99506,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } else { v25 = int32(176) } - *(*int8)(unsafe.Pointer(v54)) = Int8FromUint32((c+uint32(1))/uint32(2) + Uint32FromInt32(v25)) + **(**int8)(__ccgo_up(v54)) = Int8FromUint32((c+uint32(1))/uint32(2) + Uint32FromInt32(v25)) v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 @@ -99515,8 +99515,8 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } else { v62 = d + uint32(126) } - *(*int8)(unsafe.Pointer(v54)) = Int8FromUint32(v62) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint32(2) + **(**int8)(__ccgo_up(v54)) = Int8FromUint32(v62) + **(**Tsize_t)(__ccgo_up(outb)) -= uint32(2) goto _51 _40: ; @@ -99531,18 +99531,18 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if !(c != 0) { goto subst } - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint32(2) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint32(2) { goto toobig } v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = Int8FromUint32(c/uint32(256) + uint32(0x80)) + **(**int8)(__ccgo_up(v54)) = Int8FromUint32(c/uint32(256) + uint32(0x80)) v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = Int8FromUint32(c%uint32(256) + uint32(0x80)) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint32(2) + **(**int8)(__ccgo_up(v54)) = Int8FromUint32(c%uint32(256) + uint32(0x80)) + **(**Tsize_t)(__ccgo_up(outb)) -= uint32(2) goto _51 _41: ; @@ -99550,102 +99550,102 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto revout } if c-uint32(0xff61) <= Uint32FromInt32(Int32FromInt32(0xdf)-Int32FromInt32(0xa1)) || c == uint32(0xa5) || c == uint32(0x203e) { - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint32(7) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint32(7) { goto toobig } v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = int8('\033') + **(**int8)(__ccgo_up(v54)) = int8('\033') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = int8('(') + **(**int8)(__ccgo_up(v54)) = int8('(') if c == uint32(0xa5) { v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = int8('J') + **(**int8)(__ccgo_up(v54)) = int8('J') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = int8('\\') + **(**int8)(__ccgo_up(v54)) = int8('\\') } else { if c == uint32(0x203e) { v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = int8('J') + **(**int8)(__ccgo_up(v54)) = int8('J') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = int8('~') + **(**int8)(__ccgo_up(v54)) = int8('~') } else { v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = int8('I') + **(**int8)(__ccgo_up(v54)) = int8('I') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = Int8FromUint32(c - uint32(0xff61) + uint32(0x21)) + **(**int8)(__ccgo_up(v54)) = Int8FromUint32(c - uint32(0xff61) + uint32(0x21)) } } v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = int8('\033') + **(**int8)(__ccgo_up(v54)) = int8('\033') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = int8('(') + **(**int8)(__ccgo_up(v54)) = int8('(') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = int8('B') - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint32(7) + **(**int8)(__ccgo_up(v54)) = int8('B') + **(**Tsize_t)(__ccgo_up(outb)) -= uint32(7) goto _51 } c = _uni_to_jis(tls, c) if !(c != 0) { goto subst } - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint32(8) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint32(8) { goto toobig } v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = int8('\033') + **(**int8)(__ccgo_up(v54)) = int8('\033') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = int8('$') + **(**int8)(__ccgo_up(v54)) = int8('$') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = int8('B') + **(**int8)(__ccgo_up(v54)) = int8('B') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = Int8FromUint32(c / uint32(256)) + **(**int8)(__ccgo_up(v54)) = Int8FromUint32(c / uint32(256)) v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = Int8FromUint32(c % uint32(256)) + **(**int8)(__ccgo_up(v54)) = Int8FromUint32(c % uint32(256)) v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = int8('\033') + **(**int8)(__ccgo_up(v54)) = int8('\033') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = int8('(') + **(**int8)(__ccgo_up(v54)) = int8('(') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = int8('B') - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint32(8) + **(**int8)(__ccgo_up(v54)) = int8('B') + **(**Tsize_t)(__ccgo_up(outb)) -= uint32(8) goto _51 _42: ; @@ -99664,22 +99664,22 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if c >= uint32(0x10000) { c = uint32(0xFFFD) } - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint32(2) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint32(2) { goto toobig } - _put_16(tls, *(*uintptr)(unsafe.Pointer(out)), c, Int32FromUint8(totype)) - *(*uintptr)(unsafe.Pointer(out)) += uintptr(2) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint32(2) + _put_16(tls, **(**uintptr)(__ccgo_up(out)), c, Int32FromUint8(totype)) + **(**uintptr)(__ccgo_up(out)) += uintptr(2) + **(**Tsize_t)(__ccgo_up(outb)) -= uint32(2) goto _51 } - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint32(4) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint32(4) { goto toobig } c = c - uint32(0x10000) - _put_16(tls, *(*uintptr)(unsafe.Pointer(out)), c>>int32(10)|uint32(0xd800), Int32FromUint8(totype)) - _put_16(tls, *(*uintptr)(unsafe.Pointer(out))+UintptrFromInt32(2), c&uint32(0x3ff)|uint32(0xdc00), Int32FromUint8(totype)) - *(*uintptr)(unsafe.Pointer(out)) += uintptr(4) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint32(4) + _put_16(tls, **(**uintptr)(__ccgo_up(out)), c>>int32(10)|uint32(0xd800), Int32FromUint8(totype)) + _put_16(tls, **(**uintptr)(__ccgo_up(out))+UintptrFromInt32(2), c&uint32(0x3ff)|uint32(0xdc00), Int32FromUint8(totype)) + **(**uintptr)(__ccgo_up(out)) += uintptr(4) + **(**Tsize_t)(__ccgo_up(outb)) -= uint32(4) goto _51 _48: ; @@ -99688,22 +99688,22 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui ; _49: ; - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint32(4) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint32(4) { goto toobig } - _put_32(tls, *(*uintptr)(unsafe.Pointer(out)), c, Int32FromUint8(totype)) - *(*uintptr)(unsafe.Pointer(out)) += uintptr(4) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint32(4) + _put_32(tls, **(**uintptr)(__ccgo_up(out)), c, Int32FromUint8(totype)) + **(**uintptr)(__ccgo_up(out)) += uintptr(4) + **(**Tsize_t)(__ccgo_up(outb)) -= uint32(4) goto _51 _51: ; goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(in)) += uintptr(l) - *(*Tsize_t)(unsafe.Pointer(inb)) -= l + **(**uintptr)(__ccgo_up(in)) += uintptr(l) + **(**Tsize_t)(__ccgo_up(inb)) -= l } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return x goto ilseq ilseq: @@ -99725,8 +99725,8 @@ starved: goto end end: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = err - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**int32)(__ccgo_up(X__errno_location(tls))) = err + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return x } @@ -99757,7 +99757,7 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { cat = item >> int32(16) idx = item & int32(65535) if item == int32(CODESET) { - if *(*uintptr)(unsafe.Pointer(loc)) != 0 { + if **(**uintptr)(__ccgo_up(loc)) != 0 { v1 = __ccgo_ts + 322 } else { v1 = __ccgo_ts + 441 @@ -99766,8 +99766,8 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { } /* _NL_LOCALE_NAME extension */ if idx == int32(65535) && cat < int32(LC_ALL) { - if *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*4)) != 0 { - v1 = *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*4)) + 8 + if **(**uintptr)(__ccgo_up(loc + uintptr(cat)*4)) != 0 { + v1 = **(**uintptr)(__ccgo_up(loc + uintptr(cat)*4)) + 8 } else { v1 = __ccgo_ts + 447 } @@ -99802,7 +99802,7 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { break } for { - if !(*(*int8)(unsafe.Pointer(str)) != 0) { + if !(**(**int8)(__ccgo_up(str)) != 0) { break } goto _4 @@ -99816,8 +99816,8 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { idx = idx - 1 str = str + 1 } - if cat != int32(LC_NUMERIC) && *(*int8)(unsafe.Pointer(str)) != 0 { - str = X__lctrans(tls, str, *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*4))) + if cat != int32(LC_NUMERIC) && **(**int8)(__ccgo_up(str)) != 0 { + str = X__lctrans(tls, str, **(**uintptr)(__ccgo_up(loc + uintptr(cat)*4))) } return str } @@ -99890,18 +99890,18 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = builtin, l, map1, n, new1, p, path, z, v1, v2, v3, v4, v5, v6, v7 new1 = uintptr(0) path = uintptr(0) - if !(*(*int8)(unsafe.Pointer(val)) != 0) { + if !(**(**int8)(__ccgo_up(val)) != 0) { v1 = Xgetenv(tls, __ccgo_ts+449) val = v1 - if v3 = v1 != 0 && *(*int8)(unsafe.Pointer(val)) != 0; !v3 { + if v3 = v1 != 0 && **(**int8)(__ccgo_up(val)) != 0; !v3 { v2 = Xgetenv(tls, uintptr(unsafe.Pointer(&_envvars))+uintptr(cat)*12) val = v2 } - if v5 = v3 || v2 != 0 && *(*int8)(unsafe.Pointer(val)) != 0; !v5 { + if v5 = v3 || v2 != 0 && **(**int8)(__ccgo_up(val)) != 0; !v5 { v4 = Xgetenv(tls, __ccgo_ts+336) val = v4 } - if v7 = v5 || v4 != 0 && *(*int8)(unsafe.Pointer(val)) != 0; !v7 { + if v7 = v5 || v4 != 0 && **(**int8)(__ccgo_up(val)) != 0; !v7 { v6 = __ccgo_ts + 456 val = v6 } @@ -99910,7 +99910,7 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { /* Limit name length and forbid leading dot or any slashes. */ n = uint32(0) for { - if !(n < uint32(LOCALE_NAME_MAX) && *(*int8)(unsafe.Pointer(val + uintptr(n))) != 0 && int32(*(*int8)(unsafe.Pointer(val + uintptr(n)))) != int32('/')) { + if !(n < uint32(LOCALE_NAME_MAX) && **(**int8)(__ccgo_up(val + uintptr(n))) != 0 && int32(**(**int8)(__ccgo_up(val + uintptr(n)))) != int32('/')) { break } goto _8 @@ -99918,12 +99918,12 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { ; n = n + 1 } - if int32(*(*int8)(unsafe.Pointer(val))) == int32('.') || *(*int8)(unsafe.Pointer(val + uintptr(n))) != 0 { + if int32(**(**int8)(__ccgo_up(val))) == int32('.') || **(**int8)(__ccgo_up(val + uintptr(n))) != 0 { val = __ccgo_ts + 456 } - builtin = BoolInt32(int32(*(*int8)(unsafe.Pointer(val))) == int32('C') && !(*(*int8)(unsafe.Pointer(val + 1)) != 0) || !(Xstrcmp(tls, val, __ccgo_ts+456) != 0) || !(Xstrcmp(tls, val, __ccgo_ts+464) != 0)) + builtin = BoolInt32(int32(**(**int8)(__ccgo_up(val))) == int32('C') && !(**(**int8)(__ccgo_up(val + 1)) != 0) || !(Xstrcmp(tls, val, __ccgo_ts+456) != 0) || !(Xstrcmp(tls, val, __ccgo_ts+464) != 0)) if builtin != 0 { - if cat == LC_CTYPE && int32(*(*int8)(unsafe.Pointer(val + 1))) == int32('.') { + if cat == LC_CTYPE && int32(**(**int8)(__ccgo_up(val + 1))) == int32('.') { return uintptr(unsafe.Pointer(&X__c_dot_utf8)) } return uintptr(0) @@ -99947,7 +99947,7 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { /* FIXME: add a default path? */ if path != 0 { for { - if !(*(*int8)(unsafe.Pointer(path)) != 0) { + if !(**(**int8)(__ccgo_up(path)) != 0) { break } z = X__strchrnul(tls, path, int32(':')) @@ -99956,20 +99956,20 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { goto _10 } Xmemcpy(tls, bp, path, l) - (*(*[256]int8)(unsafe.Pointer(bp)))[l] = int8('/') + (**(**[256]int8)(__ccgo_up(bp)))[l] = int8('/') Xmemcpy(tls, bp+uintptr(l)+uintptr(1), val, n) - (*(*[256]int8)(unsafe.Pointer(bp)))[l+uint32(1)+n] = 0 + (**(**[256]int8)(__ccgo_up(bp)))[l+uint32(1)+n] = 0 map1 = X__map_file(tls, bp, bp+256) if map1 != 0 { new1 = Xmalloc(tls, uint32(36)) if !(new1 != 0) { - X__munmap(tls, map1, *(*Tsize_t)(unsafe.Pointer(bp + 256))) + X__munmap(tls, map1, **(**Tsize_t)(__ccgo_up(bp + 256))) break } (*t__locale_map)(unsafe.Pointer(new1)).Fmap1 = map1 - (*t__locale_map)(unsafe.Pointer(new1)).Fmap_size = *(*Tsize_t)(unsafe.Pointer(bp + 256)) + (*t__locale_map)(unsafe.Pointer(new1)).Fmap_size = **(**Tsize_t)(__ccgo_up(bp + 256)) Xmemcpy(tls, new1+8, val, n) - *(*int8)(unsafe.Pointer(new1 + 8 + uintptr(n))) = 0 + **(**int8)(__ccgo_up(new1 + 8 + uintptr(n))) = 0 (*t__locale_map)(unsafe.Pointer(new1)).Fnext = AtomicLoadPUintptr(uintptr(unsafe.Pointer(&_loc_head))) AtomicStorePUintptr(uintptr(unsafe.Pointer(&_loc_head)), new1) break @@ -99977,7 +99977,7 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { goto _10 _10: ; - path = z + BoolUintptr(!!(*(*int8)(unsafe.Pointer(z)) != 0)) + path = z + BoolUintptr(!!(**(**int8)(__ccgo_up(z)) != 0)) } } /* If no locale definition was found, make a locale map @@ -99992,7 +99992,7 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { (*t__locale_map)(unsafe.Pointer(new1)).Fmap1 = X__c_dot_utf8.Fmap1 (*t__locale_map)(unsafe.Pointer(new1)).Fmap_size = X__c_dot_utf8.Fmap_size Xmemcpy(tls, new1+8, val, n) - *(*int8)(unsafe.Pointer(new1 + 8 + uintptr(n))) = 0 + **(**int8)(__ccgo_up(new1 + 8 + uintptr(n))) = 0 (*t__locale_map)(unsafe.Pointer(new1)).Fnext = AtomicLoadPUintptr(uintptr(unsafe.Pointer(&_loc_head))) AtomicStorePUintptr(uintptr(unsafe.Pointer(&_loc_head)), new1) } @@ -100076,7 +100076,7 @@ func _do_newlocale(tls *TLS, mask int32, name uintptr, loc Tlocale_t) (r Tlocale break } if !(mask&(Int32FromInt32(1)<,< are accepted with or without = */ - if i < int32(6) && int32(*(*int8)(unsafe.Pointer(s + 1))) == int32(_opch2[i]) { + if i < int32(6) && int32(**(**int8)(__ccgo_up(s + 1))) == int32(_opch2[i]) { (*Tst)(unsafe.Pointer(st)).Fop = i return s + uintptr(2) } @@ -100382,12 +100382,12 @@ func _evalexpr(tls *TLS, st uintptr, s uintptr, d int32) (r uintptr) { return __ccgo_ts } s = _evalbinop(tls, st, s, 0, d) - if int32(*(*int8)(unsafe.Pointer(s))) != int32('?') { + if int32(**(**int8)(__ccgo_up(s))) != int32('?') { return s } a = (*Tst)(unsafe.Pointer(st)).Fr s = _evalexpr(tls, st, s+uintptr(1), d) - if int32(*(*int8)(unsafe.Pointer(s))) != int32(':') { + if int32(**(**int8)(__ccgo_up(s))) != int32(':') { return __ccgo_ts } b = (*Tst)(unsafe.Pointer(st)).Fr @@ -100411,10 +100411,10 @@ func X__pleval(tls *TLS, s uintptr, n uint32) (r uint32) { var v1 uint32 var _ /* st at bp+0 */ Tst _ = v1 - (*(*Tst)(unsafe.Pointer(bp))).Fn = n + (**(**Tst)(__ccgo_up(bp))).Fn = n s = _evalexpr(tls, bp, s, int32(100)) - if int32(*(*int8)(unsafe.Pointer(s))) == int32(';') { - v1 = (*(*Tst)(unsafe.Pointer(bp))).Fr + if int32(**(**int8)(__ccgo_up(s))) == int32(';') { + v1 = (**(**Tst)(__ccgo_up(bp))).Fr } else { v1 = Uint32FromInt32(-Int32FromInt32(1)) } @@ -100447,7 +100447,7 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { * on the format, so it can easily be changed if needed. */ if cat == int32(LC_ALL) { if name != 0 { - *(*[24]int8)(unsafe.Pointer(bp + 24)) = [24]int8{'C', '.', 'U', 'T', 'F', '-', '8'} + **(**[24]int8)(__ccgo_up(bp + 24)) = [24]int8{'C', '.', 'U', 'T', 'F', '-', '8'} p = name i = 0 for { @@ -100457,8 +100457,8 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { z = X__strchrnul(tls, p, int32(';')) if int32(z)-int32(p) <= int32(LOCALE_NAME_MAX) { Xmemcpy(tls, bp+24, p, Uint32FromInt32(int32(z)-int32(p))) - (*(*[24]int8)(unsafe.Pointer(bp + 24)))[int32(z)-int32(p)] = 0 - if *(*int8)(unsafe.Pointer(z)) != 0 { + (**(**[24]int8)(__ccgo_up(bp + 24)))[int32(z)-int32(p)] = 0 + if **(**int8)(__ccgo_up(z)) != 0 { p = z + uintptr(1) } } @@ -100467,13 +100467,13 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { ___unlock(tls, uintptr(unsafe.Pointer(&X__locale_lock))) return uintptr(0) } - *(*uintptr)(unsafe.Pointer(bp + uintptr(i)*4)) = lm + **(**uintptr)(__ccgo_up(bp + uintptr(i)*4)) = lm goto _1 _1: ; i = i + 1 } - X__libc.Fglobal_locale = *(*t__locale_struct)(unsafe.Pointer(bp)) + X__libc.Fglobal_locale = **(**t__locale_struct)(__ccgo_up(bp)) } s = uintptr(unsafe.Pointer(&_buf1)) same = 0 @@ -100482,8 +100482,8 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { if !(i < int32(LC_ALL)) { break } - lm1 = *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 32 + uintptr(i)*4)) - if lm1 == *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 32)) { + lm1 = **(**uintptr)(__ccgo_up(uintptr(unsafe.Pointer(&X__libc)) + 32 + uintptr(i)*4)) + if lm1 == **(**uintptr)(__ccgo_up(uintptr(unsafe.Pointer(&X__libc)) + 32)) { same = same + 1 } if lm1 != 0 { @@ -100494,7 +100494,7 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { part1 = v3 l = _strlen(tls, part1) Xmemcpy(tls, s, part1, l) - *(*int8)(unsafe.Pointer(s + uintptr(l))) = int8(';') + **(**int8)(__ccgo_up(s + uintptr(l))) = int8(';') s = s + uintptr(l+uint32(1)) goto _2 _2: @@ -100503,7 +100503,7 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { } s = s - 1 v3 = s - *(*int8)(unsafe.Pointer(v3)) = 0 + **(**int8)(__ccgo_up(v3)) = 0 ___unlock(tls, uintptr(unsafe.Pointer(&X__locale_lock))) if same == int32(LC_ALL) { v3 = part1 @@ -100518,9 +100518,9 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { ___unlock(tls, uintptr(unsafe.Pointer(&X__locale_lock))) return uintptr(0) } - *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 32 + uintptr(cat)*4)) = lm + **(**uintptr)(__ccgo_up(uintptr(unsafe.Pointer(&X__libc)) + 32 + uintptr(cat)*4)) = lm } else { - lm = *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 32 + uintptr(cat)*4)) + lm = **(**uintptr)(__ccgo_up(uintptr(unsafe.Pointer(&X__libc)) + 32 + uintptr(cat)*4)) } if lm != 0 { v3 = lm + 8 @@ -100567,10 +100567,10 @@ func _vstrfmon_l(tls *TLS, s uintptr, n Tsize_t, loc Tlocale_t, fmt uintptr, ap s0 = s _3: ; - if !(n != 0 && *(*int8)(unsafe.Pointer(fmt)) != 0) { + if !(n != 0 && **(**int8)(__ccgo_up(fmt)) != 0) { goto _1 } - if !(int32(*(*int8)(unsafe.Pointer(fmt))) != int32('%')) { + if !(int32(**(**int8)(__ccgo_up(fmt))) != int32('%')) { goto _4 } goto literal @@ -100580,13 +100580,13 @@ literal: s = s + 1 v6 = fmt fmt = fmt + 1 - *(*int8)(unsafe.Pointer(v5)) = *(*int8)(unsafe.Pointer(v6)) + **(**int8)(__ccgo_up(v5)) = **(**int8)(__ccgo_up(v6)) n = n - 1 goto _2 _4: ; fmt = fmt + 1 - if int32(*(*int8)(unsafe.Pointer(fmt))) == int32('%') { + if int32(**(**int8)(__ccgo_up(fmt))) == int32('%') { goto literal } fill = int32(' ') @@ -100595,11 +100595,11 @@ _4: nosym = 0 left = 0 for { - switch int32(*(*int8)(unsafe.Pointer(fmt))) { + switch int32(**(**int8)(__ccgo_up(fmt))) { case int32('='): fmt = fmt + 1 v5 = fmt - fill = int32(*(*int8)(unsafe.Pointer(v5))) + fill = int32(**(**int8)(__ccgo_up(v5))) goto _7 case int32('^'): nogrp = int32(1) @@ -100624,10 +100624,10 @@ _4: } fw = 0 for { - if !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(fmt)))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(fmt)))-uint32('0') < uint32(10)) != 0) { break } - fw = int32(10)*fw + (int32(*(*int8)(unsafe.Pointer(fmt))) - int32('0')) + fw = int32(10)*fw + (int32(**(**int8)(__ccgo_up(fmt))) - int32('0')) goto _9 _9: ; @@ -100635,28 +100635,28 @@ _4: } lp = 0 rp = int32(2) - if int32(*(*int8)(unsafe.Pointer(fmt))) == int32('#') { + if int32(**(**int8)(__ccgo_up(fmt))) == int32('#') { lp = 0 fmt = fmt + 1 for { - if !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(fmt)))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(fmt)))-uint32('0') < uint32(10)) != 0) { break } - lp = int32(10)*lp + (int32(*(*int8)(unsafe.Pointer(fmt))) - int32('0')) + lp = int32(10)*lp + (int32(**(**int8)(__ccgo_up(fmt))) - int32('0')) goto _10 _10: ; fmt = fmt + 1 } } - if int32(*(*int8)(unsafe.Pointer(fmt))) == int32('.') { + if int32(**(**int8)(__ccgo_up(fmt))) == int32('.') { rp = 0 fmt = fmt + 1 for { - if !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(fmt)))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(fmt)))-uint32('0') < uint32(10)) != 0) { break } - rp = int32(10)*rp + (int32(*(*int8)(unsafe.Pointer(fmt))) - int32('0')) + rp = int32(10)*rp + (int32(**(**int8)(__ccgo_up(fmt))) - int32('0')) goto _11 _11: ; @@ -100665,7 +100665,7 @@ _4: } v5 = fmt fmt = fmt + 1 - intl = BoolInt32(int32(*(*int8)(unsafe.Pointer(v5))) == int32('i')) + intl = BoolInt32(int32(**(**int8)(__ccgo_up(v5))) == int32('i')) w = lp + int32(1) + rp if !(left != 0) && fw > w { w = fw @@ -100673,7 +100673,7 @@ _4: x = VaFloat64(&ap) l = Uint32FromInt32(Xsnprintf(tls, s, n, __ccgo_ts+485, VaList(bp+8, w, rp, x))) if l >= n { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(E2BIG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(E2BIG) return -int32(1) } s = s + uintptr(l) @@ -100838,7 +100838,7 @@ func Xtextdomain(tls *TLS, domainname uintptr) (r uintptr) { } domlen = _strlen(tls, domainname) if domlen > uint32(NAME_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } if !(_current_domain != 0) { @@ -100948,7 +100948,7 @@ func X__wcsxfrm_l(tls *TLS, dest uintptr, src uintptr, n Tsize_t, loc Tlocale_t) } else { if n != 0 { Xwmemcpy(tls, dest, src, n-uint32(1)) - *(*Twchar_t)(unsafe.Pointer(dest + uintptr(n-uint32(1))*4)) = 0 + **(**Twchar_t)(__ccgo_up(dest + uintptr(n-uint32(1))*4)) = 0 } } return l @@ -100979,7 +100979,7 @@ func Xreallocarray(tls *TLS, ptr uintptr, m Tsize_t, n Tsize_t) (r uintptr) { defer func() { trc("-> %v", r) }() } if n != 0 && m > Uint32FromInt32(-Int32FromInt32(1))/n { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return uintptr(0) } return Xrealloc(tls, ptr, m*n) @@ -101372,25 +101372,25 @@ func X__rem_pio2(tls *TLS, x float64, y uintptr) (r1 int32) { if ix <= uint32(0x4002d97c) { /* |x| ~<= 3pi/4 */ if !(sign != 0) { z = x - _pio2_1 /* one round good to 85 bits */ - *(*float64)(unsafe.Pointer(y)) = z - _pio2_1t - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) - _pio2_1t + **(**float64)(__ccgo_up(y)) = z - _pio2_1t + **(**float64)(__ccgo_up(y + 1*8)) = z - float64(**(**float64)(__ccgo_up(y))) - _pio2_1t return int32(1) } else { z = x + _pio2_1 - *(*float64)(unsafe.Pointer(y)) = z + _pio2_1t - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) + _pio2_1t + **(**float64)(__ccgo_up(y)) = z + _pio2_1t + **(**float64)(__ccgo_up(y + 1*8)) = z - float64(**(**float64)(__ccgo_up(y))) + _pio2_1t return -int32(1) } } else { if !(sign != 0) { z = x - float64(Float64FromInt32(2)*_pio2_1) - *(*float64)(unsafe.Pointer(y)) = z - Tdouble_t(Float64FromInt32(2)*_pio2_1t) - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) - Tdouble_t(Float64FromInt32(2)*_pio2_1t) + **(**float64)(__ccgo_up(y)) = z - Tdouble_t(Float64FromInt32(2)*_pio2_1t) + **(**float64)(__ccgo_up(y + 1*8)) = z - float64(**(**float64)(__ccgo_up(y))) - Tdouble_t(Float64FromInt32(2)*_pio2_1t) return int32(2) } else { z = x + float64(Float64FromInt32(2)*_pio2_1) - *(*float64)(unsafe.Pointer(y)) = z + Tdouble_t(Float64FromInt32(2)*_pio2_1t) - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) + Tdouble_t(Float64FromInt32(2)*_pio2_1t) + **(**float64)(__ccgo_up(y)) = z + Tdouble_t(Float64FromInt32(2)*_pio2_1t) + **(**float64)(__ccgo_up(y + 1*8)) = z - float64(**(**float64)(__ccgo_up(y))) + Tdouble_t(Float64FromInt32(2)*_pio2_1t) return -int32(2) } } @@ -101402,13 +101402,13 @@ func X__rem_pio2(tls *TLS, x float64, y uintptr) (r1 int32) { } if !(sign != 0) { z = x - float64(Float64FromInt32(3)*_pio2_1) - *(*float64)(unsafe.Pointer(y)) = z - Tdouble_t(Float64FromInt32(3)*_pio2_1t) - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) - Tdouble_t(Float64FromInt32(3)*_pio2_1t) + **(**float64)(__ccgo_up(y)) = z - Tdouble_t(Float64FromInt32(3)*_pio2_1t) + **(**float64)(__ccgo_up(y + 1*8)) = z - float64(**(**float64)(__ccgo_up(y))) - Tdouble_t(Float64FromInt32(3)*_pio2_1t) return int32(3) } else { z = x + float64(Float64FromInt32(3)*_pio2_1) - *(*float64)(unsafe.Pointer(y)) = z + Tdouble_t(Float64FromInt32(3)*_pio2_1t) - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) + Tdouble_t(Float64FromInt32(3)*_pio2_1t) + **(**float64)(__ccgo_up(y)) = z + Tdouble_t(Float64FromInt32(3)*_pio2_1t) + **(**float64)(__ccgo_up(y + 1*8)) = z - float64(**(**float64)(__ccgo_up(y))) + Tdouble_t(Float64FromInt32(3)*_pio2_1t) return -int32(3) } } else { @@ -101417,13 +101417,13 @@ func X__rem_pio2(tls *TLS, x float64, y uintptr) (r1 int32) { } if !(sign != 0) { z = x - float64(Float64FromInt32(4)*_pio2_1) - *(*float64)(unsafe.Pointer(y)) = z - Tdouble_t(Float64FromInt32(4)*_pio2_1t) - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) - Tdouble_t(Float64FromInt32(4)*_pio2_1t) + **(**float64)(__ccgo_up(y)) = z - Tdouble_t(Float64FromInt32(4)*_pio2_1t) + **(**float64)(__ccgo_up(y + 1*8)) = z - float64(**(**float64)(__ccgo_up(y))) - Tdouble_t(Float64FromInt32(4)*_pio2_1t) return int32(4) } else { z = x + float64(Float64FromInt32(4)*_pio2_1) - *(*float64)(unsafe.Pointer(y)) = z + Tdouble_t(Float64FromInt32(4)*_pio2_1t) - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) + Tdouble_t(Float64FromInt32(4)*_pio2_1t) + **(**float64)(__ccgo_up(y)) = z + Tdouble_t(Float64FromInt32(4)*_pio2_1t) + **(**float64)(__ccgo_up(y + 1*8)) = z - float64(**(**float64)(__ccgo_up(y))) + Tdouble_t(Float64FromInt32(4)*_pio2_1t) return -int32(4) } } @@ -101453,8 +101453,8 @@ medium: w = Tdouble_t(fn * _pio2_1t) } } - *(*float64)(unsafe.Pointer(y)) = r - w - *(*float64)(unsafe.Pointer(bp)) = *(*float64)(unsafe.Pointer(y)) + **(**float64)(__ccgo_up(y)) = r - w + *(*float64)(unsafe.Pointer(bp)) = **(**float64)(__ccgo_up(y)) ey = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(52) & uint64(0x7ff)) ex = Int32FromUint32(ix >> int32(20)) if ex-ey > int32(16) { /* 2nd round, good to 118 bits */ @@ -101462,18 +101462,18 @@ medium: w = Tdouble_t(fn * _pio2_2) r = t - w w = Tdouble_t(fn*_pio2_2t) - (t - r - w) - *(*float64)(unsafe.Pointer(y)) = r - w - *(*float64)(unsafe.Pointer(bp)) = *(*float64)(unsafe.Pointer(y)) + **(**float64)(__ccgo_up(y)) = r - w + *(*float64)(unsafe.Pointer(bp)) = **(**float64)(__ccgo_up(y)) ey = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(52) & uint64(0x7ff)) if ex-ey > int32(49) { /* 3rd round, good to 151 bits, covers all cases */ t = r w = Tdouble_t(fn * _pio2_3) r = t - w w = Tdouble_t(fn*_pio2_3t) - (t - r - w) - *(*float64)(unsafe.Pointer(y)) = r - w + **(**float64)(__ccgo_up(y)) = r - w } } - *(*float64)(unsafe.Pointer(y + 1*8)) = r - *(*float64)(unsafe.Pointer(y)) - w + **(**float64)(__ccgo_up(y + 1*8)) = r - float64(**(**float64)(__ccgo_up(y))) - w return n _1: ; @@ -101482,8 +101482,8 @@ _1: */ if ix >= uint32(0x7ff00000) { /* x is inf or NaN */ v2 = x - x - *(*float64)(unsafe.Pointer(y + 1*8)) = v2 - *(*float64)(unsafe.Pointer(y)) = v2 + **(**float64)(__ccgo_up(y + 1*8)) = v2 + **(**float64)(__ccgo_up(y)) = v2 return 0 } /* set z = scalbn(|x|,-ilogb(x)+23) */ @@ -101496,26 +101496,26 @@ _1: if !(i < int32(2)) { break } - (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i] = float64(int32(z)) - z = Tdouble_t((z - (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i]) * Float64FromFloat64(1.6777216e+07)) + (**(**[3]float64)(__ccgo_up(bp + 8)))[i] = float64(int32(z)) + z = Tdouble_t((z - (**(**[3]float64)(__ccgo_up(bp + 8)))[i]) * Float64FromFloat64(1.6777216e+07)) goto _3 _3: ; i = i + 1 } - (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i] = z + (**(**[3]float64)(__ccgo_up(bp + 8)))[i] = z /* skip zero terms, first term is non-zero */ - for (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i] == float64(0) { + for (**(**[3]float64)(__ccgo_up(bp + 8)))[i] == float64(0) { i = i - 1 } n = X__rem_pio2_large(tls, bp+8, bp+32, Int32FromUint32(ix>>Int32FromInt32(20))-(Int32FromInt32(0x3ff)+Int32FromInt32(23)), i+int32(1), int32(1)) if sign != 0 { - *(*float64)(unsafe.Pointer(y)) = -(*(*[2]float64)(unsafe.Pointer(bp + 32)))[0] - *(*float64)(unsafe.Pointer(y + 1*8)) = -(*(*[2]float64)(unsafe.Pointer(bp + 32)))[int32(1)] + **(**float64)(__ccgo_up(y)) = -(**(**[2]float64)(__ccgo_up(bp + 32)))[0] + **(**float64)(__ccgo_up(y + 1*8)) = -(**(**[2]float64)(__ccgo_up(bp + 32)))[int32(1)] return -n } - *(*float64)(unsafe.Pointer(y)) = (*(*[2]float64)(unsafe.Pointer(bp + 32)))[0] - *(*float64)(unsafe.Pointer(y + 1*8)) = (*(*[2]float64)(unsafe.Pointer(bp + 32)))[int32(1)] + **(**float64)(__ccgo_up(y)) = (**(**[2]float64)(__ccgo_up(bp + 32)))[0] + **(**float64)(__ccgo_up(y + 1*8)) = (**(**[2]float64)(__ccgo_up(bp + 32)))[int32(1)] return n } @@ -101677,7 +101677,7 @@ func X__rem_pio2_large(tls *TLS, x uintptr, y uintptr, e0 int32, nx int32, prec if !(j <= jx) { break } - fw = fw + float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8))*f[jx+i-j]) + fw = fw + float64(**(**float64)(__ccgo_up(x + uintptr(j)*8))*f[jx+i-j]) goto _4 _4: ; @@ -101702,7 +101702,7 @@ recompute: break } fw = float64(int32(float64(Float64FromFloat64(5.960464477539063e-08) * z))) - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] = int32(z - float64(Float64FromFloat64(1.6777216e+07)*fw)) + (**(**[20]Tint32_t)(__ccgo_up(bp)))[i] = int32(z - float64(Float64FromFloat64(1.6777216e+07)*fw)) z = q[j-int32(1)] + fw goto _5 _5: @@ -101717,13 +101717,13 @@ recompute: z = z - float64(n) ih = 0 if q0 > 0 { /* need iq[jz-1] to determine n */ - i = (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz-int32(1)] >> (int32(24) - q0) + i = (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz-int32(1)] >> (int32(24) - q0) n = n + i - *(*Tint32_t)(unsafe.Pointer(bp + uintptr(jz-int32(1))*4)) -= i << (int32(24) - q0) - ih = (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz-int32(1)] >> (int32(23) - q0) + **(**Tint32_t)(__ccgo_up(bp + uintptr(jz-int32(1))*4)) -= i << (int32(24) - q0) + ih = (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz-int32(1)] >> (int32(23) - q0) } else { if q0 == 0 { - ih = (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz-int32(1)] >> int32(23) + ih = (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz-int32(1)] >> int32(23) } else { if z >= float64(0.5) { ih = int32(2) @@ -101738,14 +101738,14 @@ recompute: if !(i < jz) { break } /* compute 1-q */ - j = (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] + j = (**(**[20]Tint32_t)(__ccgo_up(bp)))[i] if carry == 0 { if j != 0 { carry = int32(1) - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] = int32(0x1000000) - j + (**(**[20]Tint32_t)(__ccgo_up(bp)))[i] = int32(0x1000000) - j } } else { - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] = int32(0xffffff) - j + (**(**[20]Tint32_t)(__ccgo_up(bp)))[i] = int32(0xffffff) - j } goto _6 _6: @@ -101755,9 +101755,9 @@ recompute: if q0 > 0 { /* rare case: chance is 1 in 12 */ switch q0 { case int32(1): - *(*Tint32_t)(unsafe.Pointer(bp + uintptr(jz-int32(1))*4)) &= int32(0x7fffff) + **(**Tint32_t)(__ccgo_up(bp + uintptr(jz-int32(1))*4)) &= int32(0x7fffff) case int32(2): - *(*Tint32_t)(unsafe.Pointer(bp + uintptr(jz-int32(1))*4)) &= int32(0x3fffff) + **(**Tint32_t)(__ccgo_up(bp + uintptr(jz-int32(1))*4)) &= int32(0x3fffff) break } } @@ -101776,7 +101776,7 @@ recompute: if !(i >= jk) { break } - j = j | (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] + j = j | (**(**[20]Tint32_t)(__ccgo_up(bp)))[i] goto _7 _7: ; @@ -101785,7 +101785,7 @@ recompute: if j == 0 { /* need recomputation */ k = int32(1) for { - if !((*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jk-k] == 0) { + if !((**(**[20]Tint32_t)(__ccgo_up(bp)))[jk-k] == 0) { break } goto _8 @@ -101805,7 +101805,7 @@ recompute: if !(j <= jx) { break } - fw = fw + float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8))*f[jx+i-j]) + fw = fw + float64(**(**float64)(__ccgo_up(x + uintptr(j)*8))*f[jx+i-j]) goto _10 _10: ; @@ -101825,7 +101825,7 @@ recompute: if z == float64(0) { jz = jz - int32(1) q0 = q0 - int32(24) - for (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] == 0 { + for (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz] == 0 { jz = jz - 1 q0 = q0 - int32(24) } @@ -101833,12 +101833,12 @@ recompute: z = Xscalbn(tls, z, -q0) if z >= float64(1.6777216e+07) { fw = float64(int32(float64(Float64FromFloat64(5.960464477539063e-08) * z))) - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(z - float64(Float64FromFloat64(1.6777216e+07)*fw)) + (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz] = int32(z - float64(Float64FromFloat64(1.6777216e+07)*fw)) jz = jz + int32(1) q0 = q0 + int32(24) - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(fw) + (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz] = int32(fw) } else { - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(z) + (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz] = int32(z) } } /* convert integer "bit" chunk to floating-point value */ @@ -101848,7 +101848,7 @@ recompute: if !(i >= 0) { break } - q[i] = float64(fw * float64((*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i])) + q[i] = float64(fw * float64((**(**[20]Tint32_t)(__ccgo_up(bp)))[i])) fw = fw * float64(5.960464477539063e-08) goto _11 _11: @@ -101873,7 +101873,7 @@ recompute: ; k = k + 1 } - (*(*[20]float64)(unsafe.Pointer(bp + 80)))[jz-i] = fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[jz-i] = fw goto _12 _12: ; @@ -101899,7 +101899,7 @@ _14: if !(i >= 0) { break } - fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[i] goto _19 _19: ; @@ -101910,7 +101910,7 @@ _14: } else { v2 = -fw } - *(*float64)(unsafe.Pointer(y)) = v2 + **(**float64)(__ccgo_up(y)) = v2 goto _18 _16: ; @@ -101922,7 +101922,7 @@ _15: if !(i >= 0) { break } - fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[i] goto _21 _21: ; @@ -101935,14 +101935,14 @@ _15: } else { v2 = -fw } - *(*float64)(unsafe.Pointer(y)) = v2 - fw = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[0] - fw + **(**float64)(__ccgo_up(y)) = v2 + fw = (**(**[20]float64)(__ccgo_up(bp + 80)))[0] - fw i = int32(1) for { if !(i <= jz) { break } - fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[i] goto _23 _23: ; @@ -101953,7 +101953,7 @@ _15: } else { v2 = -fw } - *(*float64)(unsafe.Pointer(y + 1*8)) = v2 + **(**float64)(__ccgo_up(y + 1*8)) = v2 goto _18 _17: ; /* painful */ @@ -101963,9 +101963,9 @@ _27: if !(i > 0) { goto _25 } - fw = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i-int32(1)] + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] - *(*float64)(unsafe.Pointer(bp + 80 + uintptr(i)*8)) += (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i-int32(1)] - fw - (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i-int32(1)] = fw + fw = (**(**[20]float64)(__ccgo_up(bp + 80)))[i-int32(1)] + (**(**[20]float64)(__ccgo_up(bp + 80)))[i] + **(**float64)(__ccgo_up(bp + 80 + uintptr(i)*8)) += (**(**[20]float64)(__ccgo_up(bp + 80)))[i-int32(1)] - fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[i-int32(1)] = fw goto _26 _26: ; @@ -101979,9 +101979,9 @@ _25: if !(i > int32(1)) { break } - fw = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i-int32(1)] + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] - *(*float64)(unsafe.Pointer(bp + 80 + uintptr(i)*8)) += (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i-int32(1)] - fw - (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i-int32(1)] = fw + fw = (**(**[20]float64)(__ccgo_up(bp + 80)))[i-int32(1)] + (**(**[20]float64)(__ccgo_up(bp + 80)))[i] + **(**float64)(__ccgo_up(bp + 80 + uintptr(i)*8)) += (**(**[20]float64)(__ccgo_up(bp + 80)))[i-int32(1)] - fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[i-int32(1)] = fw goto _28 _28: ; @@ -101993,20 +101993,20 @@ _25: if !(i >= int32(2)) { break } - fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[i] goto _29 _29: ; i = i - 1 } if ih == 0 { - *(*float64)(unsafe.Pointer(y)) = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[0] - *(*float64)(unsafe.Pointer(y + 1*8)) = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[int32(1)] - *(*float64)(unsafe.Pointer(y + 2*8)) = fw + **(**float64)(__ccgo_up(y)) = (**(**[20]float64)(__ccgo_up(bp + 80)))[0] + **(**float64)(__ccgo_up(y + 1*8)) = (**(**[20]float64)(__ccgo_up(bp + 80)))[int32(1)] + **(**float64)(__ccgo_up(y + 2*8)) = fw } else { - *(*float64)(unsafe.Pointer(y)) = -(*(*[20]float64)(unsafe.Pointer(bp + 80)))[0] - *(*float64)(unsafe.Pointer(y + 1*8)) = -(*(*[20]float64)(unsafe.Pointer(bp + 80)))[int32(1)] - *(*float64)(unsafe.Pointer(y + 2*8)) = -fw + **(**float64)(__ccgo_up(y)) = -(**(**[20]float64)(__ccgo_up(bp + 80)))[0] + **(**float64)(__ccgo_up(y + 1*8)) = -(**(**[20]float64)(__ccgo_up(bp + 80)))[int32(1)] + **(**float64)(__ccgo_up(y + 2*8)) = -fw } _18: ; @@ -102060,36 +102060,36 @@ func X__rem_pio2f(tls *TLS, x float32, y uintptr) (r int32) { /* Use a specialized rint() to get fn. */ fn = Tdouble_t(float64(x)*_invpio21) + float64(_toint1) - float64(_toint1) n = int32(fn) - *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) + **(**float64)(__ccgo_up(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) /* Matters with directed rounding. */ - if *(*float64)(unsafe.Pointer(y)) < -_pio41 { + if **(**float64)(__ccgo_up(y)) < -_pio41 { n = n - 1 fn = fn - 1 - *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) + **(**float64)(__ccgo_up(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) } else { - if *(*float64)(unsafe.Pointer(y)) > _pio41 { + if **(**float64)(__ccgo_up(y)) > _pio41 { n = n + 1 fn = fn + 1 - *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) + **(**float64)(__ccgo_up(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) } } return n } if ix >= uint32(0x7f800000) { /* x is inf or NaN */ - *(*float64)(unsafe.Pointer(y)) = float64(x - x) + **(**float64)(__ccgo_up(y)) = float64(x - x) return 0 } /* scale x into [2^23, 2^24-1] */ sign = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(bp)) >> int32(31)) e0 = Int32FromUint32(ix>>Int32FromInt32(23) - Uint32FromInt32(Int32FromInt32(0x7f)+Int32FromInt32(23))) /* e0 = ilogb(|x|)-23, positive */ *(*Tuint32_t)(unsafe.Pointer(bp)) = ix - Uint32FromInt32(e0<>int32(52)&uint64(0x7ff) < Uint64FromInt32(Int32FromInt32(0x3ff)+Int32FromInt32(4)) { if !(y != 0) { - return _p10[int32(*(*float64)(unsafe.Pointer(bp)))+int32(15)] + return _p10[int32(**(**float64)(__ccgo_up(bp)))+int32(15)] } y = Xexp2(tls, float64(float64(3.321928094887362)*y)) - return float64(y * _p10[int32(*(*float64)(unsafe.Pointer(bp)))+int32(15)]) + return float64(y * _p10[int32(**(**float64)(__ccgo_up(bp)))+int32(15)]) } return Xpow(tls, float64(10), x) } @@ -104731,14 +104731,14 @@ func Xexp10f(tls *TLS, x float32) (r float32) { Fi [0]Tuint32_t Ff float32 }{} - *(*float32)(unsafe.Pointer(bp + 4)) = *(*float32)(unsafe.Pointer(bp)) + *(*float32)(unsafe.Pointer(bp + 4)) = **(**float32)(__ccgo_up(bp)) /* fabsf(n) < 8 without raising invalid on nan */ if *(*Tuint32_t)(unsafe.Pointer(bp + 4))>>int32(23)&uint32(0xff) < Uint32FromInt32(Int32FromInt32(0x7f)+Int32FromInt32(3)) { if !(y != 0) { - return _p101[int32(*(*float32)(unsafe.Pointer(bp)))+int32(7)] + return _p101[int32(**(**float32)(__ccgo_up(bp)))+int32(7)] } y = Xexp2f(tls, float32(Float32FromFloat32(3.321928094887362)*y)) - return float32(y * _p101[int32(*(*float32)(unsafe.Pointer(bp)))+int32(7)]) + return float32(y * _p101[int32(**(**float32)(__ccgo_up(bp)))+int32(7)]) } return float32(Xexp2(tls, float64(float64(3.321928094887362)*float64(x)))) } @@ -104902,16 +104902,16 @@ _5: /* 2^(k/N) ~= scale * (1 + tail). */ idx = uint64(2) * (ki % Uint64FromInt32(Int32FromInt32(1)<>Int32FromInt32(32) + BoolUint64(t1 > *(*Tuint64_t)(unsafe.Pointer(lo))) + **(**Tuint64_t)(__ccgo_up(lo)) = t1 + t2<>Int32FromInt32(32) + BoolUint64(t1 > **(**Tuint64_t)(__ccgo_up(lo))) } func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { @@ -105813,11 +105813,11 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { if d == 0 { } else { if d < int32(64) { - *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = *(*Tuint64_t)(unsafe.Pointer(bp))<<(int32(64)-d) | *(*Tuint64_t)(unsafe.Pointer(bp + 8))>>d | BoolUint64(!!(*(*Tuint64_t)(unsafe.Pointer(bp + 8))<<(Int32FromInt32(64)-d) != 0)) - *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp)) >> d + **(**Tuint64_t)(__ccgo_up(bp + 8)) = **(**Tuint64_t)(__ccgo_up(bp))<<(int32(64)-d) | **(**Tuint64_t)(__ccgo_up(bp + 8))>>d | BoolUint64(!!(**(**Tuint64_t)(__ccgo_up(bp + 8))<<(Int32FromInt32(64)-d) != 0)) + **(**Tuint64_t)(__ccgo_up(bp)) = **(**Tuint64_t)(__ccgo_up(bp)) >> d } else { - *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = uint64(1) - *(*Tuint64_t)(unsafe.Pointer(bp)) = uint64(0) + **(**Tuint64_t)(__ccgo_up(bp + 8)) = uint64(1) + **(**Tuint64_t)(__ccgo_up(bp)) = uint64(0) } } } @@ -105840,24 +105840,24 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { nonzero = int32(1) if samesign != 0 { /* r += z */ - *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) + zlo - *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp)) + (zhi + BoolUint64(*(*Tuint64_t)(unsafe.Pointer(bp + 8)) < zlo)) + **(**Tuint64_t)(__ccgo_up(bp + 8)) = **(**Tuint64_t)(__ccgo_up(bp + 8)) + zlo + **(**Tuint64_t)(__ccgo_up(bp)) = **(**Tuint64_t)(__ccgo_up(bp)) + (zhi + BoolUint64(**(**Tuint64_t)(__ccgo_up(bp + 8)) < zlo)) } else { /* r -= z */ - t = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) - *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) - zlo - *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp)) - zhi - BoolUint64(t < *(*Tuint64_t)(unsafe.Pointer(bp + 8))) - if *(*Tuint64_t)(unsafe.Pointer(bp))>>int32(63) != 0 { - *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = -*(*Tuint64_t)(unsafe.Pointer(bp + 8)) - *(*Tuint64_t)(unsafe.Pointer(bp)) = -*(*Tuint64_t)(unsafe.Pointer(bp)) - BoolUint64(!!(*(*Tuint64_t)(unsafe.Pointer(bp + 8)) != 0)) + t = **(**Tuint64_t)(__ccgo_up(bp + 8)) + **(**Tuint64_t)(__ccgo_up(bp + 8)) = **(**Tuint64_t)(__ccgo_up(bp + 8)) - zlo + **(**Tuint64_t)(__ccgo_up(bp)) = **(**Tuint64_t)(__ccgo_up(bp)) - zhi - BoolUint64(t < **(**Tuint64_t)(__ccgo_up(bp + 8))) + if **(**Tuint64_t)(__ccgo_up(bp))>>int32(63) != 0 { + **(**Tuint64_t)(__ccgo_up(bp + 8)) = -**(**Tuint64_t)(__ccgo_up(bp + 8)) + **(**Tuint64_t)(__ccgo_up(bp)) = -**(**Tuint64_t)(__ccgo_up(bp)) - BoolUint64(!!(**(**Tuint64_t)(__ccgo_up(bp + 8)) != 0)) sign = BoolInt32(!(sign != 0)) } - nonzero = BoolInt32(!!(*(*Tuint64_t)(unsafe.Pointer(bp)) != 0)) + nonzero = BoolInt32(!!(**(**Tuint64_t)(__ccgo_up(bp)) != 0)) } /* set rhi to top 63bit of the result (last bit is sticky) */ if nonzero != 0 { e = e + int32(64) - v1 = *(*Tuint64_t)(unsafe.Pointer(bp)) + v1 = **(**Tuint64_t)(__ccgo_up(bp)) if v1>>Int32FromInt32(32) != 0 { v2 = _a_clz_32(tls, uint32(v1>>int32(32))) goto _3 @@ -105867,10 +105867,10 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { _3: d = v2 - int32(1) /* note: d > 0 */ - *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp))<>(int32(64)-d) | BoolUint64(!!(*(*Tuint64_t)(unsafe.Pointer(bp + 8))<>(int32(64)-d) | BoolUint64(!!(**(**Tuint64_t)(__ccgo_up(bp + 8))<>Int32FromInt32(32) != 0 { v2 = _a_clz_32(tls, uint32(v1>>int32(32))) goto _6 @@ -105880,9 +105880,9 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { _6: d = v2 - int32(1) if d < 0 { - *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp + 8))>>int32(1) | *(*Tuint64_t)(unsafe.Pointer(bp + 8))&uint64(1) + **(**Tuint64_t)(__ccgo_up(bp)) = **(**Tuint64_t)(__ccgo_up(bp + 8))>>int32(1) | **(**Tuint64_t)(__ccgo_up(bp + 8))&uint64(1) } else { - *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) << d + **(**Tuint64_t)(__ccgo_up(bp)) = **(**Tuint64_t)(__ccgo_up(bp + 8)) << d } } else { /* exact +-0 */ @@ -105891,7 +105891,7 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { } e = e - d /* convert to double */ - i = Int64FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp))) /* i is in [1<<62,(1<<63)-1] */ + i = Int64FromUint64(**(**Tuint64_t)(__ccgo_up(bp))) /* i is in [1<<62,(1<<63)-1] */ if sign != 0 { i = -i } @@ -105912,8 +105912,8 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { } /* one bit is lost when scaled, add another top bit to only round once at conversion if it is inexact */ - if *(*Tuint64_t)(unsafe.Pointer(bp))<>int32(1) | *(*Tuint64_t)(unsafe.Pointer(bp))&uint64(1) | Uint64FromUint64(1)<>int32(1) | **(**Tuint64_t)(__ccgo_up(bp))&uint64(1) | Uint64FromUint64(1)<>d | BoolUint64(!!(*(*Tuint64_t)(unsafe.Pointer(bp))<<(Int32FromInt32(64)-d) != 0))) << d) + i = Int64FromUint64((**(**Tuint64_t)(__ccgo_up(bp))>>d | BoolUint64(!!(**(**Tuint64_t)(__ccgo_up(bp))<<(Int32FromInt32(64)-d) != 0))) << d) if sign != 0 { i = -i } @@ -106509,9 +106509,9 @@ func Xfrexp(tls *TLS, x float64, e uintptr) (r float64) { if !(ee != 0) { if x != 0 { x = Xfrexp(tls, float64(x*float64(1.8446744073709552e+19)), e) - *(*int32)(unsafe.Pointer(e)) -= int32(64) + **(**int32)(__ccgo_up(e)) -= int32(64) } else { - *(*int32)(unsafe.Pointer(e)) = 0 + **(**int32)(__ccgo_up(e)) = 0 } return x } else { @@ -106519,7 +106519,7 @@ func Xfrexp(tls *TLS, x float64, e uintptr) (r float64) { return x } } - *(*int32)(unsafe.Pointer(e)) = ee - int32(0x3fe) + **(**int32)(__ccgo_up(e)) = ee - int32(0x3fe) *(*Tuint64_t)(unsafe.Pointer(bp)) &= uint64(0x800fffffffffffff) *(*Tuint64_t)(unsafe.Pointer(bp)) |= uint64(0x3fe0000000000000) return *(*float64)(unsafe.Pointer(bp)) @@ -106551,9 +106551,9 @@ func Xfrexpf(tls *TLS, x float32, e uintptr) (r float32) { if !(ee != 0) { if x != 0 { x = Xfrexpf(tls, float32(float64(x)*float64(1.8446744073709552e+19)), e) - *(*int32)(unsafe.Pointer(e)) -= int32(64) + **(**int32)(__ccgo_up(e)) -= int32(64) } else { - *(*int32)(unsafe.Pointer(e)) = 0 + **(**int32)(__ccgo_up(e)) = 0 } return x } else { @@ -106561,7 +106561,7 @@ func Xfrexpf(tls *TLS, x float32, e uintptr) (r float32) { return x } } - *(*int32)(unsafe.Pointer(e)) = ee - int32(0x7e) + **(**int32)(__ccgo_up(e)) = ee - int32(0x7e) v1 = bp *(*Tuint32_t)(unsafe.Pointer(v1)) = Tuint32_t(*(*Tuint32_t)(unsafe.Pointer(v1)) & Uint32FromUint32(0x807fffff)) v1 = bp @@ -106585,8 +106585,8 @@ func _sq(tls *TLS, hi uintptr, lo uintptr, x float64) { xc = Tdouble_t(x * float64(Float64FromFloat64(1.34217728e+08)+Float64FromInt32(1))) xh = x - xc + xc xl = x - xh - *(*Tdouble_t)(unsafe.Pointer(hi)) = Tdouble_t(x * x) - *(*Tdouble_t)(unsafe.Pointer(lo)) = Tdouble_t(xh*xh) - *(*Tdouble_t)(unsafe.Pointer(hi)) + Tdouble_t(Tdouble_t(Float64FromInt32(2)*xh)*xl) + Tdouble_t(xl*xl) + **(**Tdouble_t)(__ccgo_up(hi)) = Tdouble_t(x * x) + **(**Tdouble_t)(__ccgo_up(lo)) = Tdouble_t(xh*xh) - **(**Tdouble_t)(__ccgo_up(hi)) + Tdouble_t(Tdouble_t(Float64FromInt32(2)*xh)*xl) + Tdouble_t(xl*xl) } func Xhypot(tls *TLS, x float64, y float64) (r float64) { @@ -106635,21 +106635,21 @@ func Xhypot(tls *TLS, x float64, y float64) (r float64) { *(*Tuint64_t)(unsafe.Pointer(bp)) &= -Uint64FromUint64(1) >> Int32FromInt32(1) *(*Tuint64_t)(unsafe.Pointer(bp + 8)) &= -Uint64FromUint64(1) >> Int32FromInt32(1) if *(*Tuint64_t)(unsafe.Pointer(bp)) < *(*Tuint64_t)(unsafe.Pointer(bp + 8)) { - ut = *(*struct { + ut = **(**struct { Fi [0]Tuint64_t Ff float64 - })(unsafe.Pointer(bp)) - *(*struct { + })(__ccgo_up(bp)) + **(**struct { Fi [0]Tuint64_t Ff float64 - })(unsafe.Pointer(bp)) = *(*struct { + })(__ccgo_up(bp)) = **(**struct { Fi [0]Tuint64_t Ff float64 - })(unsafe.Pointer(bp + 8)) - *(*struct { + })(__ccgo_up(bp + 8)) + **(**struct { Fi [0]Tuint64_t Ff float64 - })(unsafe.Pointer(bp + 8)) = ut + })(__ccgo_up(bp + 8)) = ut } /* special cases */ ex = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(52)) @@ -106684,7 +106684,7 @@ func Xhypot(tls *TLS, x float64, y float64) (r float64) { } _sq(tls, bp+16, bp+24, x) _sq(tls, bp+32, bp+40, y) - return float64(z * Xsqrt(tls, *(*Tdouble_t)(unsafe.Pointer(bp + 40))+*(*Tdouble_t)(unsafe.Pointer(bp + 24))+*(*Tdouble_t)(unsafe.Pointer(bp + 32))+*(*Tdouble_t)(unsafe.Pointer(bp + 16)))) + return float64(z * Xsqrt(tls, float64(**(**Tdouble_t)(__ccgo_up(bp + 40))+**(**Tdouble_t)(__ccgo_up(bp + 24))+**(**Tdouble_t)(__ccgo_up(bp + 32))+**(**Tdouble_t)(__ccgo_up(bp + 16))))) } func Xhypotf(tls *TLS, x float32, y float32) (r float32) { @@ -106727,21 +106727,21 @@ func Xhypotf(tls *TLS, x float32, y float32) (r float32) { *(*Tuint32_t)(unsafe.Pointer(bp)) &= -Uint32FromUint32(1) >> Int32FromInt32(1) *(*Tuint32_t)(unsafe.Pointer(bp + 4)) &= -Uint32FromUint32(1) >> Int32FromInt32(1) if *(*Tuint32_t)(unsafe.Pointer(bp)) < *(*Tuint32_t)(unsafe.Pointer(bp + 4)) { - ut = *(*struct { + ut = **(**struct { Fi [0]Tuint32_t Ff float32 - })(unsafe.Pointer(bp)) - *(*struct { + })(__ccgo_up(bp)) + **(**struct { Fi [0]Tuint32_t Ff float32 - })(unsafe.Pointer(bp)) = *(*struct { + })(__ccgo_up(bp)) = **(**struct { Fi [0]Tuint32_t Ff float32 - })(unsafe.Pointer(bp + 4)) - *(*struct { + })(__ccgo_up(bp + 4)) + **(**struct { Fi [0]Tuint32_t Ff float32 - })(unsafe.Pointer(bp + 4)) = ut + })(__ccgo_up(bp + 4)) = ut } x = *(*float32)(unsafe.Pointer(bp)) y = *(*float32)(unsafe.Pointer(bp + 4)) @@ -107169,8 +107169,8 @@ func _pzero(tls *TLS, x float64) (r1 float64) { } } z = float64(1) / float64(x*x) - r = *(*float64)(unsafe.Pointer(p)) + Tdouble_t(z*(*(*float64)(unsafe.Pointer(p + 1*8))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(p + 2*8))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(p + 3*8))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(p + 4*8))+Tdouble_t(z**(*float64)(unsafe.Pointer(p + 5*8))))))))))) - s = Float64FromFloat64(1) + Tdouble_t(z*(*(*float64)(unsafe.Pointer(q))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(q + 1*8))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(q + 2*8))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(q + 3*8))+Tdouble_t(z**(*float64)(unsafe.Pointer(q + 4*8))))))))))) + r = float64(**(**float64)(__ccgo_up(p))) + Tdouble_t(z*(float64(**(**float64)(__ccgo_up(p + 1*8)))+Tdouble_t(z*(float64(**(**float64)(__ccgo_up(p + 2*8)))+Tdouble_t(z*(float64(**(**float64)(__ccgo_up(p + 3*8)))+Tdouble_t(z*(float64(**(**float64)(__ccgo_up(p + 4*8)))+Tdouble_t(z*float64(**(**float64)(__ccgo_up(p + 5*8)))))))))))) + s = Float64FromFloat64(1) + Tdouble_t(z*(float64(**(**float64)(__ccgo_up(q)))+Tdouble_t(z*(float64(**(**float64)(__ccgo_up(q + 1*8)))+Tdouble_t(z*(float64(**(**float64)(__ccgo_up(q + 2*8)))+Tdouble_t(z*(float64(**(**float64)(__ccgo_up(q + 3*8)))+Tdouble_t(z*float64(**(**float64)(__ccgo_up(q + 4*8)))))))))))) return float64(Float64FromFloat64(1) + r/s) } @@ -107277,8 +107277,8 @@ func _qzero(tls *TLS, x float64) (r1 float64) { } } z = float64(1) / float64(x*x) - r = *(*float64)(unsafe.Pointer(p)) + Tdouble_t(z*(*(*float64)(unsafe.Pointer(p + 1*8))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(p + 2*8))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(p + 3*8))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(p + 4*8))+Tdouble_t(z**(*float64)(unsafe.Pointer(p + 5*8))))))))))) - s = Float64FromFloat64(1) + Tdouble_t(z*(*(*float64)(unsafe.Pointer(q))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(q + 1*8))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(q + 2*8))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(q + 3*8))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(q + 4*8))+Tdouble_t(z**(*float64)(unsafe.Pointer(q + 5*8))))))))))))) + r = float64(**(**float64)(__ccgo_up(p))) + Tdouble_t(z*(float64(**(**float64)(__ccgo_up(p + 1*8)))+Tdouble_t(z*(float64(**(**float64)(__ccgo_up(p + 2*8)))+Tdouble_t(z*(float64(**(**float64)(__ccgo_up(p + 3*8)))+Tdouble_t(z*(float64(**(**float64)(__ccgo_up(p + 4*8)))+Tdouble_t(z*float64(**(**float64)(__ccgo_up(p + 5*8)))))))))))) + s = Float64FromFloat64(1) + Tdouble_t(z*(float64(**(**float64)(__ccgo_up(q)))+Tdouble_t(z*(float64(**(**float64)(__ccgo_up(q + 1*8)))+Tdouble_t(z*(float64(**(**float64)(__ccgo_up(q + 2*8)))+Tdouble_t(z*(float64(**(**float64)(__ccgo_up(q + 3*8)))+Tdouble_t(z*(float64(**(**float64)(__ccgo_up(q + 4*8)))+Tdouble_t(z*float64(**(**float64)(__ccgo_up(q + 5*8)))))))))))))) return (float64(-Float64FromFloat64(0.125)) + r/s) / x } @@ -107502,8 +107502,8 @@ func _pzerof(tls *TLS, x float32) (r1 float32) { } } z = float64(Float32FromFloat32(1) / float32(x*x)) - r = float64(*(*float32)(unsafe.Pointer(p))) + Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 1*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 2*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 3*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 4*4)))+Tfloat_t(z*float64(*(*float32)(unsafe.Pointer(p + 5*4)))))))))))) - s = Float64FromFloat32(1) + Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 1*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 2*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 3*4)))+Tfloat_t(z*float64(*(*float32)(unsafe.Pointer(q + 4*4)))))))))))) + r = float64(**(**float32)(__ccgo_up(p))) + Tfloat_t(z*(float64(**(**float32)(__ccgo_up(p + 1*4)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(p + 2*4)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(p + 3*4)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(p + 4*4)))+Tfloat_t(z*float64(**(**float32)(__ccgo_up(p + 5*4)))))))))))) + s = Float64FromFloat32(1) + Tfloat_t(z*(float64(**(**float32)(__ccgo_up(q)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(q + 1*4)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(q + 2*4)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(q + 3*4)))+Tfloat_t(z*float64(**(**float32)(__ccgo_up(q + 4*4)))))))))))) return float32(Float64FromFloat32(1) + r/s) } @@ -107610,8 +107610,8 @@ func _qzerof(tls *TLS, x float32) (r1 float32) { } } z = float64(Float32FromFloat32(1) / float32(x*x)) - r = float64(*(*float32)(unsafe.Pointer(p))) + Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 1*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 2*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 3*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 4*4)))+Tfloat_t(z*float64(*(*float32)(unsafe.Pointer(p + 5*4)))))))))))) - s = Float64FromFloat32(1) + Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 1*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 2*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 3*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 4*4)))+Tfloat_t(z*float64(*(*float32)(unsafe.Pointer(q + 5*4)))))))))))))) + r = float64(**(**float32)(__ccgo_up(p))) + Tfloat_t(z*(float64(**(**float32)(__ccgo_up(p + 1*4)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(p + 2*4)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(p + 3*4)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(p + 4*4)))+Tfloat_t(z*float64(**(**float32)(__ccgo_up(p + 5*4)))))))))))) + s = Float64FromFloat32(1) + Tfloat_t(z*(float64(**(**float32)(__ccgo_up(q)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(q + 1*4)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(q + 2*4)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(q + 3*4)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(q + 4*4)))+Tfloat_t(z*float64(**(**float32)(__ccgo_up(q + 5*4)))))))))))))) return float32((float64(-Float32FromFloat32(0.125)) + r/s) / float64(x)) } @@ -107848,8 +107848,8 @@ func _pone(tls *TLS, x float64) (r1 float64) { } } z = float64(1) / float64(x*x) - r = *(*float64)(unsafe.Pointer(p)) + Tdouble_t(z*(*(*float64)(unsafe.Pointer(p + 1*8))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(p + 2*8))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(p + 3*8))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(p + 4*8))+Tdouble_t(z**(*float64)(unsafe.Pointer(p + 5*8))))))))))) - s = Float64FromFloat64(1) + Tdouble_t(z*(*(*float64)(unsafe.Pointer(q))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(q + 1*8))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(q + 2*8))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(q + 3*8))+Tdouble_t(z**(*float64)(unsafe.Pointer(q + 4*8))))))))))) + r = float64(**(**float64)(__ccgo_up(p))) + Tdouble_t(z*(float64(**(**float64)(__ccgo_up(p + 1*8)))+Tdouble_t(z*(float64(**(**float64)(__ccgo_up(p + 2*8)))+Tdouble_t(z*(float64(**(**float64)(__ccgo_up(p + 3*8)))+Tdouble_t(z*(float64(**(**float64)(__ccgo_up(p + 4*8)))+Tdouble_t(z*float64(**(**float64)(__ccgo_up(p + 5*8)))))))))))) + s = Float64FromFloat64(1) + Tdouble_t(z*(float64(**(**float64)(__ccgo_up(q)))+Tdouble_t(z*(float64(**(**float64)(__ccgo_up(q + 1*8)))+Tdouble_t(z*(float64(**(**float64)(__ccgo_up(q + 2*8)))+Tdouble_t(z*(float64(**(**float64)(__ccgo_up(q + 3*8)))+Tdouble_t(z*float64(**(**float64)(__ccgo_up(q + 4*8)))))))))))) return float64(Float64FromFloat64(1) + r/s) } @@ -107955,8 +107955,8 @@ func _qone(tls *TLS, x float64) (r1 float64) { } } z = float64(1) / float64(x*x) - r = *(*float64)(unsafe.Pointer(p)) + Tdouble_t(z*(*(*float64)(unsafe.Pointer(p + 1*8))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(p + 2*8))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(p + 3*8))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(p + 4*8))+Tdouble_t(z**(*float64)(unsafe.Pointer(p + 5*8))))))))))) - s = Float64FromFloat64(1) + Tdouble_t(z*(*(*float64)(unsafe.Pointer(q))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(q + 1*8))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(q + 2*8))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(q + 3*8))+Tdouble_t(z*(*(*float64)(unsafe.Pointer(q + 4*8))+Tdouble_t(z**(*float64)(unsafe.Pointer(q + 5*8))))))))))))) + r = float64(**(**float64)(__ccgo_up(p))) + Tdouble_t(z*(float64(**(**float64)(__ccgo_up(p + 1*8)))+Tdouble_t(z*(float64(**(**float64)(__ccgo_up(p + 2*8)))+Tdouble_t(z*(float64(**(**float64)(__ccgo_up(p + 3*8)))+Tdouble_t(z*(float64(**(**float64)(__ccgo_up(p + 4*8)))+Tdouble_t(z*float64(**(**float64)(__ccgo_up(p + 5*8)))))))))))) + s = Float64FromFloat64(1) + Tdouble_t(z*(float64(**(**float64)(__ccgo_up(q)))+Tdouble_t(z*(float64(**(**float64)(__ccgo_up(q + 1*8)))+Tdouble_t(z*(float64(**(**float64)(__ccgo_up(q + 2*8)))+Tdouble_t(z*(float64(**(**float64)(__ccgo_up(q + 3*8)))+Tdouble_t(z*(float64(**(**float64)(__ccgo_up(q + 4*8)))+Tdouble_t(z*float64(**(**float64)(__ccgo_up(q + 5*8)))))))))))))) return float64((Float64FromFloat64(0.375) + r/s) / x) } @@ -108179,8 +108179,8 @@ func _ponef(tls *TLS, x float32) (r1 float32) { } } z = float64(Float32FromFloat32(1) / float32(x*x)) - r = float64(*(*float32)(unsafe.Pointer(p))) + Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 1*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 2*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 3*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 4*4)))+Tfloat_t(z*float64(*(*float32)(unsafe.Pointer(p + 5*4)))))))))))) - s = Float64FromFloat32(1) + Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 1*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 2*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 3*4)))+Tfloat_t(z*float64(*(*float32)(unsafe.Pointer(q + 4*4)))))))))))) + r = float64(**(**float32)(__ccgo_up(p))) + Tfloat_t(z*(float64(**(**float32)(__ccgo_up(p + 1*4)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(p + 2*4)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(p + 3*4)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(p + 4*4)))+Tfloat_t(z*float64(**(**float32)(__ccgo_up(p + 5*4)))))))))))) + s = Float64FromFloat32(1) + Tfloat_t(z*(float64(**(**float32)(__ccgo_up(q)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(q + 1*4)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(q + 2*4)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(q + 3*4)))+Tfloat_t(z*float64(**(**float32)(__ccgo_up(q + 4*4)))))))))))) return float32(Float64FromFloat32(1) + r/s) } @@ -108286,8 +108286,8 @@ func _qonef(tls *TLS, x float32) (r1 float32) { } } z = float64(Float32FromFloat32(1) / float32(x*x)) - r = float64(*(*float32)(unsafe.Pointer(p))) + Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 1*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 2*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 3*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 4*4)))+Tfloat_t(z*float64(*(*float32)(unsafe.Pointer(p + 5*4)))))))))))) - s = Float64FromFloat32(1) + Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 1*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 2*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 3*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 4*4)))+Tfloat_t(z*float64(*(*float32)(unsafe.Pointer(q + 5*4)))))))))))))) + r = float64(**(**float32)(__ccgo_up(p))) + Tfloat_t(z*(float64(**(**float32)(__ccgo_up(p + 1*4)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(p + 2*4)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(p + 3*4)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(p + 4*4)))+Tfloat_t(z*float64(**(**float32)(__ccgo_up(p + 5*4)))))))))))) + s = Float64FromFloat32(1) + Tfloat_t(z*(float64(**(**float32)(__ccgo_up(q)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(q + 1*4)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(q + 2*4)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(q + 3*4)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(q + 4*4)))+Tfloat_t(z*float64(**(**float32)(__ccgo_up(q + 5*4)))))))))))))) return float32((Float64FromFloat32(0.375) + r/s) / float64(x)) } @@ -108968,7 +108968,7 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { }{} *(*float64)(unsafe.Pointer(bp)) = x /* purge off +-inf, NaN, +-0, tiny and negative arguments */ - *(*int32)(unsafe.Pointer(signgamp)) = int32(1) + **(**int32)(__ccgo_up(signgamp)) = int32(1) sign = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(63)) ix = uint32(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(32) & uint64(0x7fffffff)) if ix >= uint32(0x7ff00000) { @@ -108977,7 +108977,7 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { if ix < Uint32FromInt32((Int32FromInt32(0x3ff)-Int32FromInt32(70))< Float64FromFloat64(0) { - *(*int32)(unsafe.Pointer(signgamp)) = -int32(1) + **(**int32)(__ccgo_up(signgamp)) = -int32(1) } else { t = -t } @@ -109225,7 +109225,7 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { }{} *(*float32)(unsafe.Pointer(bp)) = x /* purge off +-inf, NaN, +-0, tiny and negative arguments */ - *(*int32)(unsafe.Pointer(signgamp)) = int32(1) + **(**int32)(__ccgo_up(signgamp)) = int32(1) sign = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(bp)) >> int32(31)) ix = *(*Tuint32_t)(unsafe.Pointer(bp)) & uint32(0x7fffffff) if ix >= uint32(0x7f800000) { @@ -109233,7 +109233,7 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { } if ix < uint32(0x35000000) { /* |x| < 2**-21, return -log(|x|) */ if sign != 0 { - *(*int32)(unsafe.Pointer(signgamp)) = -int32(1) + **(**int32)(__ccgo_up(signgamp)) = -int32(1) x = -x } return -Xlogf(tls, x) @@ -109245,7 +109245,7 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { return Float32FromFloat32(1) / (x - x) } if t > Float32FromFloat32(0) { - *(*int32)(unsafe.Pointer(signgamp)) = -int32(1) + **(**int32)(__ccgo_up(signgamp)) = -int32(1) } else { t = -t } @@ -109476,15 +109476,15 @@ func Xlog(tls *TLS, x1 float64) (r1 float64) { r = x1 - float64(1) r2 = Tdouble_t(r * r) r3 = Tdouble_t(r * r2) - y1 = Tdouble_t(r3 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 1*8)) + Tdouble_t(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 2*8))) + Tdouble_t(r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 3*8))) + Tdouble_t(r3*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 4*8))+Tdouble_t(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 5*8)))+Tdouble_t(r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 6*8)))+Tdouble_t(r3*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 7*8))+Tdouble_t(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 8*8)))+Tdouble_t(r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 9*8)))+Tdouble_t(r3**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 10*8))))))))) + y1 = Tdouble_t(r3 * (float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 1*8))) + Tdouble_t(r*float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 2*8)))) + Tdouble_t(r2*float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 3*8)))) + Tdouble_t(r3*(float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 4*8)))+Tdouble_t(r*float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 5*8))))+Tdouble_t(r2*float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 6*8))))+Tdouble_t(r3*(float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 7*8)))+Tdouble_t(r*float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 8*8))))+Tdouble_t(r2*float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 9*8))))+Tdouble_t(r3*float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 10*8)))))))))) /* Worst-case error is around 0.507 ULP. */ w = Tdouble_t(r * Float64FromFloat64(1.34217728e+08)) rhi = r + w - w rlo = r - rhi - w = Tdouble_t(Tdouble_t(rhi*rhi) * *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56))) /* B[0] == -0.5. */ + w = Tdouble_t(Tdouble_t(rhi*rhi) * float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56)))) /* B[0] == -0.5. */ hi = r + w lo = r - hi + w - lo = lo + Tdouble_t(Tdouble_t(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56))*rlo)*(rhi+r)) + lo = lo + Tdouble_t(Tdouble_t(float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56)))*rlo)*(rhi+r)) y1 = y1 + lo y1 = y1 + hi y = y1 @@ -109517,25 +109517,25 @@ func Xlog(tls *TLS, x1 float64) (r1 float64) { i = Int32FromUint64(tmp >> (Int32FromInt32(52) - Int32FromInt32(LOG_TABLE_BITS)) % Uint64FromInt32(Int32FromInt32(1)<> int32(52)) /* arithmetic shift */ iz = ix - tmp&(Uint64FromUint64(0xfff)< 0x1p-4: 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma). */ - y1 = lo + Tdouble_t(r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16))) + Tdouble_t(Tdouble_t(r*r2)*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 1*8))+Tdouble_t(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 2*8)))+Tdouble_t(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 3*8))+Tdouble_t(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 4*8))))))) + hi + y1 = lo + Tdouble_t(r2*float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 16)))) + Tdouble_t(Tdouble_t(r*r2)*(float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 1*8)))+Tdouble_t(r*float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 2*8))))+Tdouble_t(r2*(float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 3*8)))+Tdouble_t(r*float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 4*8)))))))) + hi y = y1 v1 = y goto _11 @@ -109996,10 +109996,10 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { r2 = Tdouble_t(r * r) /* rounding error: 0x1p-62. */ r4 = Tdouble_t(r2 * r2) /* Worst-case error is less than 0.54 ULP (0.55 ULP without fma). */ - p = Tdouble_t(r2 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64)) + Tdouble_t(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 1*8))))) + p = Tdouble_t(r2 * (float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64))) + Tdouble_t(r*float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 1*8)))))) y1 = hi + p lo = lo + (hi - y1 + p) - lo = lo + Tdouble_t(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 2*8))+Tdouble_t(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 3*8)))+Tdouble_t(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 4*8))+Tdouble_t(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 5*8)))))+Tdouble_t(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 6*8))+Tdouble_t(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 7*8)))+Tdouble_t(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 8*8))+Tdouble_t(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 9*8))))))))) + lo = lo + Tdouble_t(r4*(float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 2*8)))+Tdouble_t(r*float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 3*8))))+Tdouble_t(r2*(float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 4*8)))+Tdouble_t(r*float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 5*8))))))+Tdouble_t(r4*(float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 6*8)))+Tdouble_t(r*float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 7*8))))+Tdouble_t(r2*(float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 8*8)))+Tdouble_t(r*float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 9*8)))))))))) y1 = y1 + lo y = y1 v1 = y @@ -110031,24 +110031,24 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { i = Int32FromUint64(tmp >> (Int32FromInt32(52) - Int32FromInt32(LOG2_TABLE_BITS)) % Uint64FromInt32(Int32FromInt32(1)<> int32(52)) /* arithmetic shift */ iz = ix - tmp&(Uint64FromUint64(0xfff)< 0x1p-4: 0.547 ULP (0.550 ULP without fma). ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma). */ - p = *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16)) + Tdouble_t(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 1*8))) + Tdouble_t(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 2*8))+Tdouble_t(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 3*8))))) + Tdouble_t(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 4*8))+Tdouble_t(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 5*8))))) + p = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 16))) + Tdouble_t(r*float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 1*8)))) + Tdouble_t(r2*(float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 2*8)))+Tdouble_t(r*float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 3*8)))))) + Tdouble_t(r4*(float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 4*8)))+Tdouble_t(r*float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 5*8)))))) y1 = lo + Tdouble_t(r2*p) + hi y = y1 v1 = y @@ -110141,23 +110141,23 @@ func Xlog2f(tls *TLS, x1 float32) (r1 float32) { top = tmp & uint32(0xff800000) iz = ix - top k = Int32FromUint32(tmp) >> int32(23) /* arithmetic shift */ - invc = (*(*struct { + invc = (**(**struct { Finvc float64 Flogc float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + uintptr(i)*16))).Finvc - logc = (*(*struct { + })(__ccgo_up(uintptr(unsafe.Pointer(&X__log2f_data)) + uintptr(i)*16))).Finvc + logc = (**(**struct { Finvc float64 Flogc float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + uintptr(i)*16))).Flogc + })(__ccgo_up(uintptr(unsafe.Pointer(&X__log2f_data)) + uintptr(i)*16))).Flogc z = float64(*(*float32)(unsafe.Pointer(&iz))) /* log2(x) = log1p(z/c-1)/ln2 + log2(c) + k */ r = Tdouble_t(z*invc) - Float64FromInt32(1) y0 = logc + float64(k) /* Pipelined polynomial evaluation to approximate log1p(r)/ln2. */ r2 = Tdouble_t(r * r) - y1 = Tdouble_t(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 1*8))*r) + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 2*8)) - y1 = Tdouble_t(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256))*r2) + y1 - p = Tdouble_t(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 3*8))*r) + y0 + y1 = Tdouble_t(float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 1*8)))*r) + float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 2*8))) + y1 = Tdouble_t(float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2f_data)) + 256)))*r2) + y1 + p = Tdouble_t(float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 3*8)))*r) + y0 y1 = Tdouble_t(y1*r2) + p y = float32(y1) v1 = y @@ -110334,22 +110334,22 @@ func Xlogf(tls *TLS, x1 float32) (r1 float32) { i = Int32FromUint32(tmp >> (Int32FromInt32(23) - Int32FromInt32(LOGF_TABLE_BITS)) % Uint32FromInt32(Int32FromInt32(1)<> int32(23) /* arithmetic shift */ iz = ix - tmp&uint32(0xff800000) - invc = (*(*struct { + invc = (**(**struct { Finvc float64 Flogc float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + uintptr(i)*16))).Finvc - logc = (*(*struct { + })(__ccgo_up(uintptr(unsafe.Pointer(&X__logf_data)) + uintptr(i)*16))).Finvc + logc = (**(**struct { Finvc float64 Flogc float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + uintptr(i)*16))).Flogc + })(__ccgo_up(uintptr(unsafe.Pointer(&X__logf_data)) + uintptr(i)*16))).Flogc z = float64(*(*float32)(unsafe.Pointer(&iz))) /* log(x) = log1p(z/c-1) + log(c) + k*Ln2 */ r = Tdouble_t(z*invc) - Float64FromInt32(1) y0 = logc + Tdouble_t(float64(k)*X__logf_data.Fln2) /* Pipelined polynomial evaluation to approximate log1p(r). */ r2 = Tdouble_t(r * r) - y1 = Tdouble_t(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + 264 + 1*8))*r) + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + 264 + 2*8)) - y1 = Tdouble_t(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + 264))*r2) + y1 + y1 = Tdouble_t(float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__logf_data)) + 264 + 1*8)))*r) + float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__logf_data)) + 264 + 2*8))) + y1 = Tdouble_t(float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__logf_data)) + 264)))*r2) + y1 y1 = Tdouble_t(y1*r2) + (y0 + r) y = float32(y1) v1 = y @@ -110507,7 +110507,7 @@ func Xmodf(tls *TLS, x float64, iptr uintptr) (r float64) { e = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp))>>Int32FromInt32(52)&Uint64FromInt32(0x7ff)) - int32(0x3ff) /* no fractional part */ if e >= int32(52) { - *(*float64)(unsafe.Pointer(iptr)) = x + **(**float64)(__ccgo_up(iptr)) = x if e == int32(0x400) && *(*Tuint64_t)(unsafe.Pointer(bp))<> Int32FromInt32(12) >> e if *(*Tuint64_t)(unsafe.Pointer(bp))&mask == uint64(0) { - *(*float64)(unsafe.Pointer(iptr)) = x + **(**float64)(__ccgo_up(iptr)) = x *(*Tuint64_t)(unsafe.Pointer(bp)) &= Uint64FromUint64(1) << Int32FromInt32(63) return *(*float64)(unsafe.Pointer(bp)) } *(*Tuint64_t)(unsafe.Pointer(bp)) &= ^mask - *(*float64)(unsafe.Pointer(iptr)) = *(*float64)(unsafe.Pointer(bp)) + **(**float64)(__ccgo_up(iptr)) = *(*float64)(unsafe.Pointer(bp)) return x - *(*float64)(unsafe.Pointer(bp)) } @@ -110556,7 +110556,7 @@ func Xmodff(tls *TLS, x float32, iptr uintptr) (r float32) { e = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(bp))>>Int32FromInt32(23)&Uint32FromInt32(0xff)) - int32(0x7f) /* no fractional part */ if e >= int32(23) { - *(*float32)(unsafe.Pointer(iptr)) = x + **(**float32)(__ccgo_up(iptr)) = x if e == int32(0x80) && *(*Tuint32_t)(unsafe.Pointer(bp))<> e) if *(*Tuint32_t)(unsafe.Pointer(bp))&mask == uint32(0) { - *(*float32)(unsafe.Pointer(iptr)) = x + **(**float32)(__ccgo_up(iptr)) = x *(*Tuint32_t)(unsafe.Pointer(bp)) &= uint32(0x80000000) return *(*float32)(unsafe.Pointer(bp)) } *(*Tuint32_t)(unsafe.Pointer(bp)) &= ^mask - *(*float32)(unsafe.Pointer(iptr)) = *(*float32)(unsafe.Pointer(bp)) + **(**float32)(__ccgo_up(iptr)) = *(*float32)(unsafe.Pointer(bp)) return x - *(*float32)(unsafe.Pointer(bp)) } @@ -110591,7 +110591,7 @@ func Xmodfl(tls *TLS, x float64, iptr uintptr) (r1 float64) { var _ /* d at bp+0 */ float64 _ = r r = Xmodf(tls, x, bp) - *(*float64)(unsafe.Pointer(iptr)) = *(*float64)(unsafe.Pointer(bp)) + **(**float64)(__ccgo_up(iptr)) = float64(**(**float64)(__ccgo_up(bp))) return r } @@ -110993,24 +110993,24 @@ func _log_inline(tls *TLS, ix Tuint64_t, tail uintptr) (r1 Tdouble_t) { z = *(*float64)(unsafe.Pointer(&iz)) kd = float64(k) /* log(x) = k*Ln2 + log(c) + log1p(z/c-1). */ - invc = (*(*struct { + invc = (**(**struct { Finvc float64 Fpad float64 Flogc float64 Flogctail float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Finvc - logc = (*(*struct { + })(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Finvc + logc = (**(**struct { Finvc float64 Fpad float64 Flogc float64 Flogctail float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Flogc - logctail = (*(*struct { + })(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Flogc + logctail = (**(**struct { Finvc float64 Fpad float64 Flogc float64 Flogctail float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Flogctail + })(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Flogctail v1 = (iz + Uint64FromUint64(1)<> (Int32FromInt32(23) - Int32FromInt32(POWF_SCALE_BITS)) /* arithmetic shift */ - invc = (*(*struct { + invc = (**(**struct { Finvc float64 Flogc float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + uintptr(i)*16))).Finvc - logc = (*(*struct { + })(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + uintptr(i)*16))).Finvc + logc = (**(**struct { Finvc float64 Flogc float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + uintptr(i)*16))).Flogc + })(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + uintptr(i)*16))).Flogc z = float64(*(*float32)(unsafe.Pointer(&iz))) /* log2(x) = log1p(z/c-1)/ln2 + log2(c) + k */ r = Tdouble_t(z*invc) - Float64FromInt32(1) y0 = logc + float64(k) /* Pipelined polynomial evaluation to approximate log1p(r)/ln2. */ r2 = Tdouble_t(r * r) - y = Tdouble_t(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256))*r) + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 1*8)) - p = Tdouble_t(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 2*8))*r) + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 3*8)) + y = Tdouble_t(float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256)))*r) + float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 1*8))) + p = Tdouble_t(float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 2*8)))*r) + float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 3*8))) r4 = Tdouble_t(r2 * r2) - q = Tdouble_t(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 4*8))*r) + y0 + q = Tdouble_t(float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 4*8)))*r) + y0 q = Tdouble_t(p*r2) + q y = Tdouble_t(y*r4) + q return y @@ -111436,13 +111436,13 @@ _2: kd = kd - X__exp2f_data.Fshift_scaled /* k/N */ r = xd - kd /* exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1) */ - t = *(*Tuint64_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + uintptr(ki%Uint64FromInt32(Int32FromInt32(1)<> int32(63)) sy = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp + 16)) >> int32(63)) uxi = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) - *(*int32)(unsafe.Pointer(quo)) = 0 + **(**int32)(__ccgo_up(quo)) = 0 if v3 = *(*Tuint64_t)(unsafe.Pointer(bp + 16))<> int32(31)) sy = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(bp + 8)) >> int32(31)) uxi = *(*Tuint32_t)(unsafe.Pointer(bp + 4)) - *(*int32)(unsafe.Pointer(quo)) = 0 + **(**int32)(__ccgo_up(quo)) = 0 if v3 = *(*Tuint32_t)(unsafe.Pointer(bp + 8))<= uint32(0x7ff00000) { v1 = x3 - x3 - *(*float64)(unsafe.Pointer(cos)) = v1 - *(*float64)(unsafe.Pointer(sin)) = v1 + **(**float64)(__ccgo_up(cos)) = v1 + **(**float64)(__ccgo_up(sin)) = v1 return } /* argument reduction needed */ n = Uint32FromInt32(X__rem_pio2(tls, x3, bp)) - s = X__sin(tls, (*(*[2]float64)(unsafe.Pointer(bp)))[0], (*(*[2]float64)(unsafe.Pointer(bp)))[int32(1)], int32(1)) - c = X__cos(tls, (*(*[2]float64)(unsafe.Pointer(bp)))[0], (*(*[2]float64)(unsafe.Pointer(bp)))[int32(1)]) + s = X__sin(tls, (**(**[2]float64)(__ccgo_up(bp)))[0], (**(**[2]float64)(__ccgo_up(bp)))[int32(1)], int32(1)) + c = X__cos(tls, (**(**[2]float64)(__ccgo_up(bp)))[0], (**(**[2]float64)(__ccgo_up(bp)))[int32(1)]) switch n & Uint32FromInt32(3) { case uint32(0): - *(*float64)(unsafe.Pointer(sin)) = s - *(*float64)(unsafe.Pointer(cos)) = c + **(**float64)(__ccgo_up(sin)) = s + **(**float64)(__ccgo_up(cos)) = c case uint32(1): - *(*float64)(unsafe.Pointer(sin)) = c - *(*float64)(unsafe.Pointer(cos)) = -s + **(**float64)(__ccgo_up(sin)) = c + **(**float64)(__ccgo_up(cos)) = -s case uint32(2): - *(*float64)(unsafe.Pointer(sin)) = -s - *(*float64)(unsafe.Pointer(cos)) = -c + **(**float64)(__ccgo_up(sin)) = -s + **(**float64)(__ccgo_up(cos)) = -c case uint32(3): fallthrough default: - *(*float64)(unsafe.Pointer(sin)) = -c - *(*float64)(unsafe.Pointer(cos)) = s + **(**float64)(__ccgo_up(sin)) = -c + **(**float64)(__ccgo_up(cos)) = s break } } @@ -112680,23 +112680,23 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { y2 = float64(v1) } } - *(*float32)(unsafe.Pointer(sin)) = x3 - *(*float32)(unsafe.Pointer(cos)) = Float32FromFloat32(1) + **(**float32)(__ccgo_up(sin)) = x3 + **(**float32)(__ccgo_up(cos)) = Float32FromFloat32(1) return } - *(*float32)(unsafe.Pointer(sin)) = X__sindf(tls, float64(x3)) - *(*float32)(unsafe.Pointer(cos)) = X__cosdf(tls, float64(x3)) + **(**float32)(__ccgo_up(sin)) = X__sindf(tls, float64(x3)) + **(**float32)(__ccgo_up(cos)) = X__cosdf(tls, float64(x3)) return } /* |x| ~<= 5*pi/4 */ if ix <= uint32(0x407b53d1) { if ix <= uint32(0x4016cbe3) { /* |x| ~<= 3pi/4 */ if sign != 0 { - *(*float32)(unsafe.Pointer(sin)) = -X__cosdf(tls, float64(x3)+_s1pio2) - *(*float32)(unsafe.Pointer(cos)) = X__sindf(tls, float64(x3)+_s1pio2) + **(**float32)(__ccgo_up(sin)) = -X__cosdf(tls, float64(x3)+_s1pio2) + **(**float32)(__ccgo_up(cos)) = X__sindf(tls, float64(x3)+_s1pio2) } else { - *(*float32)(unsafe.Pointer(sin)) = X__cosdf(tls, _s1pio2-float64(x3)) - *(*float32)(unsafe.Pointer(cos)) = X__sindf(tls, _s1pio2-float64(x3)) + **(**float32)(__ccgo_up(sin)) = X__cosdf(tls, _s1pio2-float64(x3)) + **(**float32)(__ccgo_up(cos)) = X__sindf(tls, _s1pio2-float64(x3)) } return } @@ -112706,24 +112706,24 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { } else { v4 = float64(x3) - _s2pio2 } - *(*float32)(unsafe.Pointer(sin)) = -X__sindf(tls, v4) + **(**float32)(__ccgo_up(sin)) = -X__sindf(tls, v4) if sign != 0 { v4 = float64(x3) + _s2pio2 } else { v4 = float64(x3) - _s2pio2 } - *(*float32)(unsafe.Pointer(cos)) = -X__cosdf(tls, v4) + **(**float32)(__ccgo_up(cos)) = -X__cosdf(tls, v4) return } /* |x| ~<= 9*pi/4 */ if ix <= uint32(0x40e231d5) { if ix <= uint32(0x40afeddf) { /* |x| ~<= 7*pi/4 */ if sign != 0 { - *(*float32)(unsafe.Pointer(sin)) = X__cosdf(tls, float64(x3)+_s3pio2) - *(*float32)(unsafe.Pointer(cos)) = -X__sindf(tls, float64(x3)+_s3pio2) + **(**float32)(__ccgo_up(sin)) = X__cosdf(tls, float64(x3)+_s3pio2) + **(**float32)(__ccgo_up(cos)) = -X__sindf(tls, float64(x3)+_s3pio2) } else { - *(*float32)(unsafe.Pointer(sin)) = -X__cosdf(tls, float64(x3)-_s3pio2) - *(*float32)(unsafe.Pointer(cos)) = X__sindf(tls, float64(x3)-_s3pio2) + **(**float32)(__ccgo_up(sin)) = -X__cosdf(tls, float64(x3)-_s3pio2) + **(**float32)(__ccgo_up(cos)) = X__sindf(tls, float64(x3)-_s3pio2) } return } @@ -112732,41 +112732,41 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { } else { v4 = float64(x3) - _s4pio2 } - *(*float32)(unsafe.Pointer(sin)) = X__sindf(tls, v4) + **(**float32)(__ccgo_up(sin)) = X__sindf(tls, v4) if sign != 0 { v4 = float64(x3) + _s4pio2 } else { v4 = float64(x3) - _s4pio2 } - *(*float32)(unsafe.Pointer(cos)) = X__cosdf(tls, v4) + **(**float32)(__ccgo_up(cos)) = X__cosdf(tls, v4) return } /* sin(Inf or NaN) is NaN */ if ix >= uint32(0x7f800000) { v1 = x3 - x3 - *(*float32)(unsafe.Pointer(cos)) = v1 - *(*float32)(unsafe.Pointer(sin)) = v1 + **(**float32)(__ccgo_up(cos)) = v1 + **(**float32)(__ccgo_up(sin)) = v1 return } /* general argument reduction needed */ n = Uint32FromInt32(X__rem_pio2f(tls, x3, bp)) - s = float64(X__sindf(tls, *(*float64)(unsafe.Pointer(bp)))) - c = float64(X__cosdf(tls, *(*float64)(unsafe.Pointer(bp)))) + s = float64(X__sindf(tls, **(**float64)(__ccgo_up(bp)))) + c = float64(X__cosdf(tls, **(**float64)(__ccgo_up(bp)))) switch n & Uint32FromInt32(3) { case uint32(0): - *(*float32)(unsafe.Pointer(sin)) = float32(s) - *(*float32)(unsafe.Pointer(cos)) = float32(c) + **(**float32)(__ccgo_up(sin)) = float32(s) + **(**float32)(__ccgo_up(cos)) = float32(c) case uint32(1): - *(*float32)(unsafe.Pointer(sin)) = float32(c) - *(*float32)(unsafe.Pointer(cos)) = float32(-s) + **(**float32)(__ccgo_up(sin)) = float32(c) + **(**float32)(__ccgo_up(cos)) = float32(-s) case uint32(2): - *(*float32)(unsafe.Pointer(sin)) = float32(-s) - *(*float32)(unsafe.Pointer(cos)) = float32(-c) + **(**float32)(__ccgo_up(sin)) = float32(-s) + **(**float32)(__ccgo_up(cos)) = float32(-c) case uint32(3): fallthrough default: - *(*float32)(unsafe.Pointer(sin)) = float32(-c) - *(*float32)(unsafe.Pointer(cos)) = float32(s) + **(**float32)(__ccgo_up(sin)) = float32(-c) + **(**float32)(__ccgo_up(cos)) = float32(s) break } } @@ -112782,8 +112782,8 @@ func Xsincosl(tls *TLS, x float64, sin uintptr, cos uintptr) { var _ /* cosd at bp+8 */ float64 var _ /* sind at bp+0 */ float64 Xsincos(tls, x, bp, bp+8) - *(*float64)(unsafe.Pointer(sin)) = *(*float64)(unsafe.Pointer(bp)) - *(*float64)(unsafe.Pointer(cos)) = *(*float64)(unsafe.Pointer(bp + 8)) + **(**float64)(__ccgo_up(sin)) = float64(**(**float64)(__ccgo_up(bp))) + **(**float64)(__ccgo_up(cos)) = float64(**(**float64)(__ccgo_up(bp + 8))) } const M_PI_27 = 1.5707963267948966 @@ -112882,13 +112882,13 @@ func Xsinf(tls *TLS, x3 float32) (r float32) { n = X__rem_pio2f(tls, x3, bp) switch n & Int32FromInt32(3) { case 0: - return X__sindf(tls, *(*float64)(unsafe.Pointer(bp))) + return X__sindf(tls, **(**float64)(__ccgo_up(bp))) case int32(1): - return X__cosdf(tls, *(*float64)(unsafe.Pointer(bp))) + return X__cosdf(tls, **(**float64)(__ccgo_up(bp))) case int32(2): - return X__sindf(tls, -*(*float64)(unsafe.Pointer(bp))) + return X__sindf(tls, -**(**float64)(__ccgo_up(bp))) default: - return -X__cosdf(tls, *(*float64)(unsafe.Pointer(bp))) + return -X__cosdf(tls, **(**float64)(__ccgo_up(bp))) } return r } @@ -113334,7 +113334,7 @@ func Xtan(tls *TLS, x3 float64) (r float64) { } /* argument reduction */ n = Uint32FromInt32(X__rem_pio2(tls, x3, bp)) - return X__tan(tls, (*(*[2]float64)(unsafe.Pointer(bp)))[0], (*(*[2]float64)(unsafe.Pointer(bp)))[int32(1)], Int32FromUint32(n&uint32(1))) + return X__tan(tls, (**(**[2]float64)(__ccgo_up(bp)))[0], (**(**[2]float64)(__ccgo_up(bp)))[int32(1)], Int32FromUint32(n&uint32(1))) } const M_PI_29 = 1.5707963267948966 @@ -113435,7 +113435,7 @@ func Xtanf(tls *TLS, x3 float32) (r float32) { } /* argument reduction */ n = Uint32FromInt32(X__rem_pio2f(tls, x3, bp)) - return X__tandf(tls, *(*float64)(unsafe.Pointer(bp)), Int32FromUint32(n&uint32(1))) + return X__tandf(tls, **(**float64)(__ccgo_up(bp)), Int32FromUint32(n&uint32(1))) } const M_PI_210 = 0 @@ -113975,10 +113975,10 @@ func Xa64l(tls *TLS, s uintptr) (r int32) { x = uint32(0) e = 0 for { - if !(e < int32(36) && *(*int8)(unsafe.Pointer(s)) != 0) { + if !(e < int32(36) && **(**int8)(__ccgo_up(s)) != 0) { break } - d = Xstrchr(tls, uintptr(unsafe.Pointer(&_digits)), int32(*(*int8)(unsafe.Pointer(s)))) + d = Xstrchr(tls, uintptr(unsafe.Pointer(&_digits)), int32(**(**int8)(__ccgo_up(s)))) if !(d != 0) { break } @@ -114006,14 +114006,14 @@ func Xl64a(tls *TLS, x0 int32) (r uintptr) { if !(x != 0) { break } - *(*int8)(unsafe.Pointer(p)) = _digits[x&uint32(63)] + **(**int8)(__ccgo_up(p)) = _digits[x&uint32(63)] goto _1 _1: ; p = p + 1 x = x >> uint32(6) } - *(*int8)(unsafe.Pointer(p)) = 0 + **(**int8)(__ccgo_up(p)) = 0 return uintptr(unsafe.Pointer(&_s)) } @@ -114026,22 +114026,22 @@ func Xbasename(tls *TLS, s uintptr) (r uintptr) { } var i Tsize_t _ = i - if !(s != 0) || !(*(*int8)(unsafe.Pointer(s)) != 0) { + if !(s != 0) || !(**(**int8)(__ccgo_up(s)) != 0) { return __ccgo_ts + 483 } i = _strlen(tls, s) - uint32(1) for { - if !(i != 0 && int32(*(*int8)(unsafe.Pointer(s + uintptr(i)))) == int32('/')) { + if !(i != 0 && int32(**(**int8)(__ccgo_up(s + uintptr(i)))) == int32('/')) { break } - *(*int8)(unsafe.Pointer(s + uintptr(i))) = 0 + **(**int8)(__ccgo_up(s + uintptr(i))) = 0 goto _1 _1: ; i = i - 1 } for { - if !(i != 0 && int32(*(*int8)(unsafe.Pointer(s + uintptr(i-uint32(1))))) != int32('/')) { + if !(i != 0 && int32(**(**int8)(__ccgo_up(s + uintptr(i-uint32(1))))) != int32('/')) { break } goto _2 @@ -114067,12 +114067,12 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { } var i Tsize_t _ = i - if !(s != 0) || !(*(*int8)(unsafe.Pointer(s)) != 0) { + if !(s != 0) || !(**(**int8)(__ccgo_up(s)) != 0) { return __ccgo_ts + 483 } i = _strlen(tls, s) - uint32(1) for { - if !(int32(*(*int8)(unsafe.Pointer(s + uintptr(i)))) == int32('/')) { + if !(int32(**(**int8)(__ccgo_up(s + uintptr(i)))) == int32('/')) { break } if !(i != 0) { @@ -114084,7 +114084,7 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { i = i - 1 } for { - if !(int32(*(*int8)(unsafe.Pointer(s + uintptr(i)))) != int32('/')) { + if !(int32(**(**int8)(__ccgo_up(s + uintptr(i)))) != int32('/')) { break } if !(i != 0) { @@ -114096,7 +114096,7 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { i = i - 1 } for { - if !(int32(*(*int8)(unsafe.Pointer(s + uintptr(i)))) == int32('/')) { + if !(int32(**(**int8)(__ccgo_up(s + uintptr(i)))) == int32('/')) { break } if !(i != 0) { @@ -114107,7 +114107,7 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { ; i = i - 1 } - *(*int8)(unsafe.Pointer(s + uintptr(i+uint32(1)))) = 0 + **(**int8)(__ccgo_up(s + uintptr(i+uint32(1)))) = 0 return s } @@ -114198,10 +114198,10 @@ func __strcolcmp(tls *TLS, lstr uintptr, bstr uintptr) (r int32) { var i Tsize_t _ = i i = uint32(0) - for *(*int8)(unsafe.Pointer(lstr + uintptr(i))) != 0 && *(*int8)(unsafe.Pointer(bstr + uintptr(i))) != 0 && int32(*(*int8)(unsafe.Pointer(bstr + uintptr(i)))) == int32(*(*int8)(unsafe.Pointer(lstr + uintptr(i)))) { + for **(**int8)(__ccgo_up(lstr + uintptr(i))) != 0 && **(**int8)(__ccgo_up(bstr + uintptr(i))) != 0 && int32(**(**int8)(__ccgo_up(bstr + uintptr(i)))) == int32(**(**int8)(__ccgo_up(lstr + uintptr(i)))) { i = i + 1 } - if *(*int8)(unsafe.Pointer(lstr + uintptr(i))) != 0 || *(*int8)(unsafe.Pointer(bstr + uintptr(i))) != 0 && int32(*(*int8)(unsafe.Pointer(bstr + uintptr(i)))) != int32(':') { + if **(**int8)(__ccgo_up(lstr + uintptr(i))) != 0 || **(**int8)(__ccgo_up(bstr + uintptr(i))) != 0 && int32(**(**int8)(__ccgo_up(bstr + uintptr(i)))) != int32(':') { return int32(1) } return 0 @@ -114299,7 +114299,7 @@ func Xfmtmsg(tls *TLS, classification int32, label uintptr, severity int32, text } } if classification&int32(MM_PRINT) != 0 { - for cmsg != 0 && *(*int8)(unsafe.Pointer(cmsg)) != 0 { + for cmsg != 0 && **(**int8)(__ccgo_up(cmsg)) != 0 { i = 0 for { if !(msgs[i] != 0) { @@ -114375,7 +114375,7 @@ func Xfmtmsg(tls *TLS, classification int32, label uintptr, severity int32, text if ret&(Int32FromInt32(MM_NOCON)|Int32FromInt32(MM_NOMSG)) == Int32FromInt32(MM_NOCON)|Int32FromInt32(MM_NOMSG) { ret = -int32(1) } - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) return ret } @@ -114391,7 +114391,7 @@ func Xget_current_dir_name(tls *TLS) (r uintptr) { var _ /* b at bp+144 */ Tstat _ = res res = Xgetenv(tls, __ccgo_ts+607) - if res != 0 && *(*int8)(unsafe.Pointer(res)) != 0 && !(Xstat(tls, res, bp) != 0) && !(Xstat(tls, __ccgo_ts+483, bp+144) != 0) && (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev == (*(*Tstat)(unsafe.Pointer(bp + 144))).Fst_dev && (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino == (*(*Tstat)(unsafe.Pointer(bp + 144))).Fst_ino { + if res != 0 && **(**int8)(__ccgo_up(res)) != 0 && !(Xstat(tls, res, bp) != 0) && !(Xstat(tls, __ccgo_ts+483, bp+144) != 0) && (**(**Tstat)(__ccgo_up(bp))).Fst_dev == (**(**Tstat)(__ccgo_up(bp + 144))).Fst_dev && (**(**Tstat)(__ccgo_up(bp))).Fst_ino == (**(**Tstat)(__ccgo_up(bp + 144))).Fst_ino { return Xstrdup(tls, res) } return Xgetcwd(tls, uintptr(0), uint32(0)) @@ -114409,18 +114409,18 @@ func X__getauxval(tls *TLS, item uint32) (r uint32) { return Uint32FromInt8(X__libc.Fsecure) } for { - if !(*(*Tsize_t)(unsafe.Pointer(auxv)) != 0) { + if !(**(**Tsize_t)(__ccgo_up(auxv)) != 0) { break } - if *(*Tsize_t)(unsafe.Pointer(auxv)) == item { - return *(*Tsize_t)(unsafe.Pointer(auxv + 1*4)) + if uint32(**(**Tsize_t)(__ccgo_up(auxv))) == item { + return uint32(**(**Tsize_t)(__ccgo_up(auxv + 1*4))) } goto _1 _1: ; auxv = auxv + uintptr(2)*4 } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOENT) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOENT) return uint32(0) } @@ -114451,7 +114451,7 @@ func Xgetdomainname(tls *TLS, name uintptr, len1 Tsize_t) (r int32) { var _ /* temp at bp+0 */ Tutsname Xuname(tls, bp) if !(len1 != 0) || _strlen(tls, bp+325) >= len1 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } Xstrcpy(tls, name, bp+325) @@ -114472,14 +114472,14 @@ func Xgetentropy(tls *TLS, buffer uintptr, len1 Tsize_t) (r int32) { ret = 0 pos = buffer if len1 > uint32(256) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EIO) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EIO) return -int32(1) } _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp) for len1 != 0 { ret = Xgetrandom(tls, pos, len1, uint32(0)) if ret < 0 { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EINTR) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EINTR) { continue } else { break @@ -114489,7 +114489,7 @@ func Xgetentropy(tls *TLS, buffer uintptr, len1 Tsize_t) (r int32) { len1 = len1 - Uint32FromInt32(ret) ret = 0 } - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) return ret } @@ -114543,46 +114543,46 @@ func Xgetopt(tls *TLS, argc int32, argv uintptr, optstring uintptr) (r int32) { X__optpos = 0 Xoptind = int32(1) } - if Xoptind >= argc || !(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4)) != 0) { + if Xoptind >= argc || !(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*4)) != 0) { return -int32(1) } - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4))))) != int32('-') { - if int32(*(*int8)(unsafe.Pointer(optstring))) == int32('-') { + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*4))))) != int32('-') { + if int32(**(**int8)(__ccgo_up(optstring))) == int32('-') { v1 = Xoptind Xoptind = Xoptind + 1 - Xoptarg = *(*uintptr)(unsafe.Pointer(argv + uintptr(v1)*4)) + Xoptarg = **(**uintptr)(__ccgo_up(argv + uintptr(v1)*4)) return int32(1) } return -int32(1) } - if !(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4)) + 1)) != 0) { + if !(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*4)) + 1)) != 0) { return -int32(1) } - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4)) + 1))) == int32('-') && !(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4)) + 2)) != 0) { + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*4)) + 1))) == int32('-') && !(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*4)) + 2)) != 0) { Xoptind = Xoptind + 1 return -Int32FromInt32(1) } if !(X__optpos != 0) { X__optpos = X__optpos + 1 } - v1 = Xmbtowc(tls, bp, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4))+uintptr(X__optpos), uint32(MB_LEN_MAX)) + v1 = Xmbtowc(tls, bp, **(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*4))+uintptr(X__optpos), uint32(MB_LEN_MAX)) k = v1 if v1 < 0 { k = int32(1) - *(*Twchar_t)(unsafe.Pointer(bp)) = int32(0xfffd) /* replacement char */ + **(**Twchar_t)(__ccgo_up(bp)) = int32(0xfffd) /* replacement char */ } - optchar = *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4)) + uintptr(X__optpos) + optchar = **(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*4)) + uintptr(X__optpos) X__optpos = X__optpos + k - if !(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4)) + uintptr(X__optpos))) != 0) { + if !(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*4)) + uintptr(X__optpos))) != 0) { Xoptind = Xoptind + 1 X__optpos = 0 } - if int32(*(*int8)(unsafe.Pointer(optstring))) == int32('-') || int32(*(*int8)(unsafe.Pointer(optstring))) == int32('+') { + if int32(**(**int8)(__ccgo_up(optstring))) == int32('-') || int32(**(**int8)(__ccgo_up(optstring))) == int32('+') { optstring = optstring + 1 } i = 0 - *(*Twchar_t)(unsafe.Pointer(bp + 4)) = 0 - for cond := true; cond; cond = l != 0 && *(*Twchar_t)(unsafe.Pointer(bp + 4)) != *(*Twchar_t)(unsafe.Pointer(bp)) { + **(**Twchar_t)(__ccgo_up(bp + 4)) = 0 + for cond := true; cond; cond = l != 0 && **(**Twchar_t)(__ccgo_up(bp + 4)) != **(**Twchar_t)(__ccgo_up(bp)) { l = Xmbtowc(tls, bp+4, optstring+uintptr(i), uint32(MB_LEN_MAX)) if l > 0 { i = i + l @@ -114590,36 +114590,36 @@ func Xgetopt(tls *TLS, argc int32, argv uintptr, optstring uintptr) (r int32) { i = i + 1 } } - if *(*Twchar_t)(unsafe.Pointer(bp + 4)) != *(*Twchar_t)(unsafe.Pointer(bp)) || *(*Twchar_t)(unsafe.Pointer(bp)) == int32(':') { - Xoptopt = *(*Twchar_t)(unsafe.Pointer(bp)) - if int32(*(*int8)(unsafe.Pointer(optstring))) != int32(':') && Xopterr != 0 { - X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), __ccgo_ts+611, optchar, Uint32FromInt32(k)) + if **(**Twchar_t)(__ccgo_up(bp + 4)) != **(**Twchar_t)(__ccgo_up(bp)) || **(**Twchar_t)(__ccgo_up(bp)) == int32(':') { + Xoptopt = int32(**(**Twchar_t)(__ccgo_up(bp))) + if int32(**(**int8)(__ccgo_up(optstring))) != int32(':') && Xopterr != 0 { + X__getopt_msg(tls, **(**uintptr)(__ccgo_up(argv)), __ccgo_ts+611, optchar, Uint32FromInt32(k)) } return int32('?') } - if int32(*(*int8)(unsafe.Pointer(optstring + uintptr(i)))) == int32(':') { + if int32(**(**int8)(__ccgo_up(optstring + uintptr(i)))) == int32(':') { Xoptarg = uintptr(0) - if int32(*(*int8)(unsafe.Pointer(optstring + uintptr(i+int32(1))))) != int32(':') || X__optpos != 0 { + if int32(**(**int8)(__ccgo_up(optstring + uintptr(i+int32(1))))) != int32(':') || X__optpos != 0 { v1 = Xoptind Xoptind = Xoptind + 1 - Xoptarg = *(*uintptr)(unsafe.Pointer(argv + uintptr(v1)*4)) + Xoptarg = **(**uintptr)(__ccgo_up(argv + uintptr(v1)*4)) if X__optpos != 0 { Xoptarg = Xoptarg + uintptr(X__optpos) } X__optpos = 0 } if Xoptind > argc { - Xoptopt = *(*Twchar_t)(unsafe.Pointer(bp)) - if int32(*(*int8)(unsafe.Pointer(optstring))) == int32(':') { + Xoptopt = int32(**(**Twchar_t)(__ccgo_up(bp))) + if int32(**(**int8)(__ccgo_up(optstring))) == int32(':') { return int32(':') } if Xopterr != 0 { - X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), __ccgo_ts+635, optchar, Uint32FromInt32(k)) + X__getopt_msg(tls, **(**uintptr)(__ccgo_up(argv)), __ccgo_ts+635, optchar, Uint32FromInt32(k)) } return int32('?') } } - return *(*Twchar_t)(unsafe.Pointer(bp)) + return int32(**(**Twchar_t)(__ccgo_up(bp))) } func X__posix_getopt(tls *TLS, argc int32, argv uintptr, optstring uintptr) (r int32) { @@ -114646,19 +114646,19 @@ func _permute(tls *TLS, argv uintptr, dest int32, src int32) { var i int32 _, _, _ = av, i, tmp av = argv - tmp = *(*uintptr)(unsafe.Pointer(av + uintptr(src)*4)) + tmp = **(**uintptr)(__ccgo_up(av + uintptr(src)*4)) i = src for { if !(i > dest) { break } - *(*uintptr)(unsafe.Pointer(av + uintptr(i)*4)) = *(*uintptr)(unsafe.Pointer(av + uintptr(i-int32(1))*4)) + **(**uintptr)(__ccgo_up(av + uintptr(i)*4)) = **(**uintptr)(__ccgo_up(av + uintptr(i-int32(1))*4)) goto _1 _1: ; i = i - 1 } - *(*uintptr)(unsafe.Pointer(av + uintptr(dest)*4)) = tmp + **(**uintptr)(__ccgo_up(av + uintptr(dest)*4)) = tmp } func ___getopt_long(tls *TLS, argc int32, argv uintptr, optstring uintptr, longopts uintptr, idx uintptr, longonly int32) (r int32) { @@ -114669,17 +114669,17 @@ func ___getopt_long(tls *TLS, argc int32, argv uintptr, optstring uintptr, longo X__optpos = 0 Xoptind = int32(1) } - if Xoptind >= argc || !(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4)) != 0) { + if Xoptind >= argc || !(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*4)) != 0) { return -int32(1) } skipped = Xoptind - if int32(*(*int8)(unsafe.Pointer(optstring))) != int32('+') && int32(*(*int8)(unsafe.Pointer(optstring))) != int32('-') { + if int32(**(**int8)(__ccgo_up(optstring))) != int32('+') && int32(**(**int8)(__ccgo_up(optstring))) != int32('-') { i = Xoptind for { - if i >= argc || !(*(*uintptr)(unsafe.Pointer(argv + uintptr(i)*4)) != 0) { + if i >= argc || !(**(**uintptr)(__ccgo_up(argv + uintptr(i)*4)) != 0) { return -int32(1) } - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(i)*4))))) == int32('-') && *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(i)*4)) + 1)) != 0 { + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(i)*4))))) == int32('-') && **(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(i)*4)) + 1)) != 0 { break } goto _1 @@ -114714,31 +114714,31 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, var cnt, colon, i, j, l, match, v2 int32 _, _, _, _, _, _, _, _, _, _, _, _ = arg, cnt, colon, i, j, l, match, name, opt, start, v2, v5 Xoptarg = uintptr(0) - if longopts != 0 && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4))))) == int32('-') && (longonly != 0 && *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4)) + 1)) != 0 && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4)) + 1))) != int32('-') || int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4)) + 1))) == int32('-') && *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4)) + 2)) != 0) { - colon = BoolInt32(int32(*(*int8)(unsafe.Pointer(optstring + BoolUintptr(int32(*(*int8)(unsafe.Pointer(optstring))) == int32('+') || int32(*(*int8)(unsafe.Pointer(optstring))) == int32('-'))))) == int32(':')) - start = *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4)) + uintptr(1) + if longopts != 0 && int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*4))))) == int32('-') && (longonly != 0 && **(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*4)) + 1)) != 0 && int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*4)) + 1))) != int32('-') || int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*4)) + 1))) == int32('-') && **(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*4)) + 2)) != 0) { + colon = BoolInt32(int32(**(**int8)(__ccgo_up(optstring + BoolUintptr(int32(**(**int8)(__ccgo_up(optstring))) == int32('+') || int32(**(**int8)(__ccgo_up(optstring))) == int32('-'))))) == int32(':')) + start = **(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*4)) + uintptr(1) v2 = Int32FromInt32(0) i = v2 cnt = v2 for { - if !((*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*16))).Fname != 0) { + if !((**(**Toption)(__ccgo_up(longopts + uintptr(i)*16))).Fname != 0) { break } - name = (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*16))).Fname + name = (**(**Toption)(__ccgo_up(longopts + uintptr(i)*16))).Fname opt = start - if int32(*(*int8)(unsafe.Pointer(opt))) == int32('-') { + if int32(**(**int8)(__ccgo_up(opt))) == int32('-') { opt = opt + 1 } - for *(*int8)(unsafe.Pointer(opt)) != 0 && int32(*(*int8)(unsafe.Pointer(opt))) != int32('=') && int32(*(*int8)(unsafe.Pointer(opt))) == int32(*(*int8)(unsafe.Pointer(name))) { + for **(**int8)(__ccgo_up(opt)) != 0 && int32(**(**int8)(__ccgo_up(opt))) != int32('=') && int32(**(**int8)(__ccgo_up(opt))) == int32(**(**int8)(__ccgo_up(name))) { name = name + 1 opt = opt + 1 } - if *(*int8)(unsafe.Pointer(opt)) != 0 && int32(*(*int8)(unsafe.Pointer(opt))) != int32('=') { + if **(**int8)(__ccgo_up(opt)) != 0 && int32(**(**int8)(__ccgo_up(opt))) != int32('=') { goto _1 } arg = opt match = i - if !(*(*int8)(unsafe.Pointer(name)) != 0) { + if !(**(**int8)(__ccgo_up(name)) != 0) { cnt = int32(1) break } @@ -114752,12 +114752,12 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, l = int32(arg) - int32(start) i = 0 for { - if !(*(*int8)(unsafe.Pointer(optstring + uintptr(i))) != 0) { + if !(**(**int8)(__ccgo_up(optstring + uintptr(i))) != 0) { break } j = 0 for { - if !(j < l && int32(*(*int8)(unsafe.Pointer(start + uintptr(j)))) == int32(*(*int8)(unsafe.Pointer(optstring + uintptr(i+j))))) { + if !(j < l && int32(**(**int8)(__ccgo_up(start + uintptr(j)))) == int32(**(**int8)(__ccgo_up(optstring + uintptr(i+j))))) { break } goto _4 @@ -114779,44 +114779,44 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, i = match opt = arg Xoptind = Xoptind + 1 - if int32(*(*int8)(unsafe.Pointer(opt))) == int32('=') { - if !((*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*16))).Fhas_arg != 0) { - Xoptopt = (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*16))).Fval + if int32(**(**int8)(__ccgo_up(opt))) == int32('=') { + if !((**(**Toption)(__ccgo_up(longopts + uintptr(i)*16))).Fhas_arg != 0) { + Xoptopt = (**(**Toption)(__ccgo_up(longopts + uintptr(i)*16))).Fval if colon != 0 || !(Xopterr != 0) { return int32('?') } - X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), __ccgo_ts+667, (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*16))).Fname, _strlen(tls, (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*16))).Fname)) + X__getopt_msg(tls, **(**uintptr)(__ccgo_up(argv)), __ccgo_ts+667, (**(**Toption)(__ccgo_up(longopts + uintptr(i)*16))).Fname, _strlen(tls, (**(**Toption)(__ccgo_up(longopts + uintptr(i)*16))).Fname)) return int32('?') } Xoptarg = opt + uintptr(1) } else { - if (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*16))).Fhas_arg == int32(required_argument) { - v5 = *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4)) + if (**(**Toption)(__ccgo_up(longopts + uintptr(i)*16))).Fhas_arg == int32(required_argument) { + v5 = **(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*4)) Xoptarg = v5 if !(v5 != 0) { - Xoptopt = (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*16))).Fval + Xoptopt = (**(**Toption)(__ccgo_up(longopts + uintptr(i)*16))).Fval if colon != 0 { return int32(':') } if !(Xopterr != 0) { return int32('?') } - X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), __ccgo_ts+635, (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*16))).Fname, _strlen(tls, (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*16))).Fname)) + X__getopt_msg(tls, **(**uintptr)(__ccgo_up(argv)), __ccgo_ts+635, (**(**Toption)(__ccgo_up(longopts + uintptr(i)*16))).Fname, _strlen(tls, (**(**Toption)(__ccgo_up(longopts + uintptr(i)*16))).Fname)) return int32('?') } Xoptind = Xoptind + 1 } } if idx != 0 { - *(*int32)(unsafe.Pointer(idx)) = i + **(**int32)(__ccgo_up(idx)) = i } - if (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*16))).Fflag != 0 { - *(*int32)(unsafe.Pointer((*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*16))).Fflag)) = (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*16))).Fval + if (**(**Toption)(__ccgo_up(longopts + uintptr(i)*16))).Fflag != 0 { + **(**int32)(__ccgo_up((**(**Toption)(__ccgo_up(longopts + uintptr(i)*16))).Fflag)) = (**(**Toption)(__ccgo_up(longopts + uintptr(i)*16))).Fval return 0 } - return (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*16))).Fval + return (**(**Toption)(__ccgo_up(longopts + uintptr(i)*16))).Fval } - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4)) + 1))) == int32('-') { + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*4)) + 1))) == int32('-') { Xoptopt = 0 if !(colon != 0) && Xopterr != 0 { if cnt != 0 { @@ -114824,7 +114824,7 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, } else { v5 = __ccgo_ts + 611 } - X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), v5, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4))+uintptr(2), _strlen(tls, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4))+uintptr(2))) + X__getopt_msg(tls, **(**uintptr)(__ccgo_up(argv)), v5, **(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*4))+uintptr(2), _strlen(tls, **(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*4))+uintptr(2))) } Xoptind = Xoptind + 1 return int32('?') @@ -114899,22 +114899,22 @@ func Xgetrlimit(tls *TLS, resource int32, rlim uintptr) (r int32) { (*Trlimit)(unsafe.Pointer(rlim)).Frlim_max = ^Uint64FromUint64(0) } } - if !(ret != 0) || *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(ENOSYS) { + if !(ret != 0) || **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(ENOSYS) { return ret } if X__syscall_ret(tls, Uint32FromInt32(X__syscall2(tls, int32(SYS_ugetrlimit), resource, int32(bp)))) < 0 { return -int32(1) } - if (*(*[2]uint32)(unsafe.Pointer(bp)))[0] == -Uint32FromUint32(1) { + if (**(**[2]uint32)(__ccgo_up(bp)))[0] == -Uint32FromUint32(1) { v1 = ^Uint64FromUint64(0) } else { - v1 = uint64((*(*[2]uint32)(unsafe.Pointer(bp)))[0]) + v1 = uint64((**(**[2]uint32)(__ccgo_up(bp)))[0]) } (*Trlimit)(unsafe.Pointer(rlim)).Frlim_cur = v1 - if (*(*[2]uint32)(unsafe.Pointer(bp)))[int32(1)] == -Uint32FromUint32(1) { + if (**(**[2]uint32)(__ccgo_up(bp)))[int32(1)] == -Uint32FromUint32(1) { v1 = ^Uint64FromUint64(0) } else { - v1 = uint64((*(*[2]uint32)(unsafe.Pointer(bp)))[int32(1)]) + v1 = uint64((**(**[2]uint32)(__ccgo_up(bp)))[int32(1)]) } (*Trlimit)(unsafe.Pointer(rlim)).Frlim_max = v1 if (*Trlimit)(unsafe.Pointer(rlim)).Frlim_cur >= ^Uint64FromUint64(0) { @@ -114942,12 +114942,12 @@ func Xgetrusage(tls *TLS, who int32, ru uintptr) (r1 int32) { if !(r != 0) && Bool(uint32(8) > uint32(4)) { Xmemcpy(tls, bp, dest, Uint32FromInt32(4)*Uint32FromInt64(4)) (*Trusage)(unsafe.Pointer(ru)).Fru_utime = Ttimeval{ - Ftv_sec: int64((*(*[4]int32)(unsafe.Pointer(bp)))[0]), - Ftv_usec: int64((*(*[4]int32)(unsafe.Pointer(bp)))[int32(1)]), + Ftv_sec: int64((**(**[4]int32)(__ccgo_up(bp)))[0]), + Ftv_usec: int64((**(**[4]int32)(__ccgo_up(bp)))[int32(1)]), } (*Trusage)(unsafe.Pointer(ru)).Fru_stime = Ttimeval{ - Ftv_sec: int64((*(*[4]int32)(unsafe.Pointer(bp)))[int32(2)]), - Ftv_usec: int64((*(*[4]int32)(unsafe.Pointer(bp)))[int32(3)]), + Ftv_sec: int64((**(**[4]int32)(__ccgo_up(bp)))[int32(2)]), + Ftv_usec: int64((**(**[4]int32)(__ccgo_up(bp)))[int32(3)]), } } return X__syscall_ret(tls, Uint32FromInt32(r)) @@ -114962,30 +114962,30 @@ func Xgetsubopt(tls *TLS, opt uintptr, keys uintptr, val uintptr) (r int32) { var l Tsize_t var s, v1, v2 uintptr _, _, _, _, _ = i, l, s, v1, v2 - s = *(*uintptr)(unsafe.Pointer(opt)) - *(*uintptr)(unsafe.Pointer(val)) = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(opt)) = Xstrchr(tls, s, int32(',')) - if *(*uintptr)(unsafe.Pointer(opt)) != 0 { + s = **(**uintptr)(__ccgo_up(opt)) + **(**uintptr)(__ccgo_up(val)) = UintptrFromInt32(0) + **(**uintptr)(__ccgo_up(opt)) = Xstrchr(tls, s, int32(',')) + if **(**uintptr)(__ccgo_up(opt)) != 0 { v2 = opt v1 = *(*uintptr)(unsafe.Pointer(v2)) *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(v2)) + 1 - *(*int8)(unsafe.Pointer(v1)) = 0 + **(**int8)(__ccgo_up(v1)) = 0 } else { - *(*uintptr)(unsafe.Pointer(opt)) = s + uintptr(_strlen(tls, s)) + **(**uintptr)(__ccgo_up(opt)) = s + uintptr(_strlen(tls, s)) } i = 0 for { - if !(*(*uintptr)(unsafe.Pointer(keys + uintptr(i)*4)) != 0) { + if !(**(**uintptr)(__ccgo_up(keys + uintptr(i)*4)) != 0) { break } - l = _strlen(tls, *(*uintptr)(unsafe.Pointer(keys + uintptr(i)*4))) - if Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(keys + uintptr(i)*4)), s, l) != 0 { + l = _strlen(tls, **(**uintptr)(__ccgo_up(keys + uintptr(i)*4))) + if Xstrncmp(tls, **(**uintptr)(__ccgo_up(keys + uintptr(i)*4)), s, l) != 0 { goto _3 } - if int32(*(*int8)(unsafe.Pointer(s + uintptr(l)))) == int32('=') { - *(*uintptr)(unsafe.Pointer(val)) = s + uintptr(l) + uintptr(1) + if int32(**(**int8)(__ccgo_up(s + uintptr(l)))) == int32('=') { + **(**uintptr)(__ccgo_up(val)) = s + uintptr(l) + uintptr(1) } else { - if *(*int8)(unsafe.Pointer(s + uintptr(l))) != 0 { + if **(**int8)(__ccgo_up(s + uintptr(l))) != 0 { goto _3 } } @@ -115274,7 +115274,7 @@ func _convert_ioctl_struct(tls *TLS, map1 uintptr, old uintptr, new1 uintptr, di if !(i < Int32FromUint8((*Tioctl_compat_map)(unsafe.Pointer(map1)).Fnoffs)) { break } - ts_offset = Int32FromUint8(*(*uint8)(unsafe.Pointer(map1 + 12 + uintptr(i)))) + ts_offset = Int32FromUint8(**(**uint8)(__ccgo_up(map1 + 12 + uintptr(i)))) len1 = ts_offset - old_offset if dir == int32(W) { Xmemcpy(tls, old+uintptr(old_offset), new1+uintptr(new_offset), Uint32FromInt32(len1)) @@ -115292,11 +115292,11 @@ func _convert_ioctl_struct(tls *TLS, map1 uintptr, old uintptr, new1 uintptr, di new_offset = new_offset + (align-int32(1))&-new_offset if dir == int32(W) { Xmemcpy(tls, bp, new1+uintptr(new_offset), uint32(8)) - *(*int32)(unsafe.Pointer(bp + 8)) = int32(*(*int64)(unsafe.Pointer(bp))) + **(**int32)(__ccgo_up(bp + 8)) = int32(**(**int64)(__ccgo_up(bp))) Xmemcpy(tls, old+uintptr(old_offset), bp+8, uint32(4)) } else { Xmemcpy(tls, bp+8, old+uintptr(old_offset), uint32(4)) - *(*int64)(unsafe.Pointer(bp)) = int64(*(*int32)(unsafe.Pointer(bp + 8))) + **(**int64)(__ccgo_up(bp)) = int64(**(**int32)(__ccgo_up(bp + 8))) Xmemcpy(tls, new1+uintptr(new_offset), bp, uint32(8)) } new_offset = Int32FromUint32(uint32(new_offset) + Uint32FromInt64(8)) @@ -115374,31 +115374,31 @@ func Xlockf(tls *TLS, fd int32, op int32, size Toff_t) (r int32) { bp := tls.Alloc(48) defer tls.Free(48) var _ /* l at bp+0 */ Tflock - *(*Tflock)(unsafe.Pointer(bp)) = Tflock{ + **(**Tflock)(__ccgo_up(bp)) = Tflock{ Fl_type: int16(F_WRLCK), Fl_whence: int16(1), Fl_len: size, } switch op { case int32(F_TEST): - (*(*Tflock)(unsafe.Pointer(bp))).Fl_type = F_RDLCK + (**(**Tflock)(__ccgo_up(bp))).Fl_type = F_RDLCK if Xfcntl(tls, fd, int32(F_GETLK), VaList(bp+32, bp)) < 0 { return -int32(1) } - if int32((*(*Tflock)(unsafe.Pointer(bp))).Fl_type) == int32(F_UNLCK) || (*(*Tflock)(unsafe.Pointer(bp))).Fl_pid == Xgetpid(tls) { + if int32((**(**Tflock)(__ccgo_up(bp))).Fl_type) == int32(F_UNLCK) || (**(**Tflock)(__ccgo_up(bp))).Fl_pid == Xgetpid(tls) { return 0 } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EACCES) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EACCES) return -int32(1) case F_ULOCK: - (*(*Tflock)(unsafe.Pointer(bp))).Fl_type = int16(F_UNLCK) + (**(**Tflock)(__ccgo_up(bp))).Fl_type = int16(F_UNLCK) fallthrough case int32(F_TLOCK): return Xfcntl(tls, fd, int32(F_SETLK), VaList(bp+32, bp)) case int32(F_LOCK): return Xfcntl(tls, fd, int32(F_SETLKW), VaList(bp+32, bp)) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } @@ -115500,23 +115500,23 @@ func _unescape_ent(tls *TLS, beg uintptr) (r uintptr) { _, _, _, _, _, _, _ = cval, dest, i, src, val, v1, v2 dest = beg src = beg - for *(*int8)(unsafe.Pointer(src)) != 0 { + for **(**int8)(__ccgo_up(src)) != 0 { cval = uint8(0) - if int32(*(*int8)(unsafe.Pointer(src))) != int32('\\') { + if int32(**(**int8)(__ccgo_up(src))) != int32('\\') { v1 = dest dest = dest + 1 v2 = src src = src + 1 - *(*int8)(unsafe.Pointer(v1)) = *(*int8)(unsafe.Pointer(v2)) + **(**int8)(__ccgo_up(v1)) = **(**int8)(__ccgo_up(v2)) continue } - if int32(*(*int8)(unsafe.Pointer(src + 1))) == int32('\\') { + if int32(**(**int8)(__ccgo_up(src + 1))) == int32('\\') { src = src + 1 v1 = dest dest = dest + 1 v2 = src src = src + 1 - *(*int8)(unsafe.Pointer(v1)) = *(*int8)(unsafe.Pointer(v2)) + **(**int8)(__ccgo_up(v1)) = **(**int8)(__ccgo_up(v2)) continue } val = src + uintptr(1) @@ -115525,11 +115525,11 @@ func _unescape_ent(tls *TLS, beg uintptr) (r uintptr) { if !(i < int32(3)) { break } - if int32(*(*int8)(unsafe.Pointer(val))) >= int32('0') && int32(*(*int8)(unsafe.Pointer(val))) <= int32('7') { + if int32(**(**int8)(__ccgo_up(val))) >= int32('0') && int32(**(**int8)(__ccgo_up(val))) <= int32('7') { cval = Uint8FromInt32(int32(cval) << Int32FromInt32(3)) v1 = val val = val + 1 - cval = Uint8FromInt32(int32(cval) + (int32(*(*int8)(unsafe.Pointer(v1))) - Int32FromUint8('0'))) + cval = Uint8FromInt32(int32(cval) + (int32(**(**int8)(__ccgo_up(v1))) - Int32FromUint8('0'))) } else { break } @@ -115541,17 +115541,17 @@ func _unescape_ent(tls *TLS, beg uintptr) (r uintptr) { if cval != 0 { v1 = dest dest = dest + 1 - *(*int8)(unsafe.Pointer(v1)) = Int8FromUint8(cval) + **(**int8)(__ccgo_up(v1)) = Int8FromUint8(cval) src = val } else { v1 = dest dest = dest + 1 v2 = src src = src + 1 - *(*int8)(unsafe.Pointer(v1)) = *(*int8)(unsafe.Pointer(v2)) + **(**int8)(__ccgo_up(v1)) = **(**int8)(__ccgo_up(v2)) } } - *(*int8)(unsafe.Pointer(dest)) = 0 + **(**int8)(__ccgo_up(dest)) = 0 return beg } @@ -115569,7 +115569,7 @@ func Xgetmntent_r(tls *TLS, f uintptr, mnt uintptr, linebuf uintptr, buflen int3 use_internal = BoolInt32(linebuf == uintptr(unsafe.Pointer(&_internal_buf))) (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_freq = 0 (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_passno = 0 - for cond := true; cond; cond = int32(*(*int8)(unsafe.Pointer(linebuf + uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[0])))) == int32('#') || Uint32FromInt32((*(*[8]int32)(unsafe.Pointer(bp)))[int32(1)]) == len1 { + for cond := true; cond; cond = int32(**(**int8)(__ccgo_up(linebuf + uintptr((**(**[8]int32)(__ccgo_up(bp)))[0])))) == int32('#') || Uint32FromInt32((**(**[8]int32)(__ccgo_up(bp)))[int32(1)]) == len1 { if use_internal != 0 { Xgetline(tls, uintptr(unsafe.Pointer(&_internal_buf)), uintptr(unsafe.Pointer(&_internal_bufsize)), f) linebuf = _internal_buf @@ -115581,7 +115581,7 @@ func Xgetmntent_r(tls *TLS, f uintptr, mnt uintptr, linebuf uintptr, buflen int3 } if !(Xstrchr(tls, linebuf, int32('\n')) != 0) { Xfscanf(tls, f, __ccgo_ts+728, 0) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return uintptr(0) } len1 = _strlen(tls, linebuf) @@ -115593,7 +115593,7 @@ func Xgetmntent_r(tls *TLS, f uintptr, mnt uintptr, linebuf uintptr, buflen int3 if !(i < Uint32FromInt64(32)/Uint32FromInt64(4)) { break } - (*(*[8]int32)(unsafe.Pointer(bp)))[i] = Int32FromUint32(len1) + (**(**[8]int32)(__ccgo_up(bp)))[i] = Int32FromUint32(len1) goto _1 _1: ; @@ -115601,14 +115601,14 @@ func Xgetmntent_r(tls *TLS, f uintptr, mnt uintptr, linebuf uintptr, buflen int3 } Xsscanf(tls, linebuf, __ccgo_ts+740, VaList(bp+40, bp, bp+uintptr(1)*4, bp+uintptr(2)*4, bp+uintptr(3)*4, bp+uintptr(4)*4, bp+uintptr(5)*4, bp+uintptr(6)*4, bp+uintptr(7)*4, mnt+16, mnt+20)) } - *(*int8)(unsafe.Pointer(linebuf + uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(1)]))) = 0 - *(*int8)(unsafe.Pointer(linebuf + uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(3)]))) = 0 - *(*int8)(unsafe.Pointer(linebuf + uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(5)]))) = 0 - *(*int8)(unsafe.Pointer(linebuf + uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(7)]))) = 0 - (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_fsname = _unescape_ent(tls, linebuf+uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[0])) - (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_dir = _unescape_ent(tls, linebuf+uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(2)])) - (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_type = _unescape_ent(tls, linebuf+uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(4)])) - (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_opts = _unescape_ent(tls, linebuf+uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(6)])) + **(**int8)(__ccgo_up(linebuf + uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(1)]))) = 0 + **(**int8)(__ccgo_up(linebuf + uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(3)]))) = 0 + **(**int8)(__ccgo_up(linebuf + uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(5)]))) = 0 + **(**int8)(__ccgo_up(linebuf + uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(7)]))) = 0 + (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_fsname = _unescape_ent(tls, linebuf+uintptr((**(**[8]int32)(__ccgo_up(bp)))[0])) + (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_dir = _unescape_ent(tls, linebuf+uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(2)])) + (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_type = _unescape_ent(tls, linebuf+uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(4)])) + (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_opts = _unescape_ent(tls, linebuf+uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(6)])) return mnt } @@ -115665,39 +115665,39 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag var _ /* st at bp+0 */ Tstat _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, de, dfd, err, j, k, l, r, type1, v1, v10, v2, v3, v8 l = _strlen(tls, path) - if l != 0 && int32(*(*int8)(unsafe.Pointer(path + uintptr(l-uint32(1))))) == int32('/') { + if l != 0 && int32(**(**int8)(__ccgo_up(path + uintptr(l-uint32(1))))) == int32('/') { v1 = l - uint32(1) } else { v1 = l } j = v1 v2 = Uint64FromInt32(0) - (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino = v2 - (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev = v2 + (**(**Tstat)(__ccgo_up(bp))).Fst_ino = v2 + (**(**Tstat)(__ccgo_up(bp))).Fst_dev = v2 if flags&int32(FTW_PHYS) != 0 { v3 = Xlstat(tls, path, bp) } else { v3 = BoolInt32(Xstat(tls, path, bp) < 0) } if v3 != 0 { - if !(flags&Int32FromInt32(FTW_PHYS) != 0) && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENOENT) && !(Xlstat(tls, path, bp) != 0) { + if !(flags&Int32FromInt32(FTW_PHYS) != 0) && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENOENT) && !(Xlstat(tls, path, bp) != 0) { type1 = int32(FTW_SLN) } else { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(EACCES) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(EACCES) { return -int32(1) } else { type1 = int32(FTW_NS) } } } else { - if (*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFDIR) { + if (**(**Tstat)(__ccgo_up(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFDIR) { if flags&int32(FTW_DEPTH) != 0 { type1 = int32(FTW_DP) } else { type1 = int32(FTW_D) } } else { - if (*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { + if (**(**Tstat)(__ccgo_up(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { if flags&int32(FTW_PHYS) != 0 { type1 = int32(FTW_SL) } else { @@ -115708,26 +115708,26 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag } } } - if flags&int32(FTW_MOUNT) != 0 && h != 0 && type1 != int32(FTW_NS) && (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev != (*Thistory)(unsafe.Pointer(h)).Fdev { + if flags&int32(FTW_MOUNT) != 0 && h != 0 && type1 != int32(FTW_NS) && (**(**Tstat)(__ccgo_up(bp))).Fst_dev != (*Thistory)(unsafe.Pointer(h)).Fdev { return 0 } - (*(*Thistory)(unsafe.Pointer(bp + 144))).Fchain = h - (*(*Thistory)(unsafe.Pointer(bp + 144))).Fdev = (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev - (*(*Thistory)(unsafe.Pointer(bp + 144))).Fino = (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino + (**(**Thistory)(__ccgo_up(bp + 144))).Fchain = h + (**(**Thistory)(__ccgo_up(bp + 144))).Fdev = (**(**Tstat)(__ccgo_up(bp))).Fst_dev + (**(**Thistory)(__ccgo_up(bp + 144))).Fino = (**(**Tstat)(__ccgo_up(bp))).Fst_ino if h != 0 { v3 = (*Thistory)(unsafe.Pointer(h)).Flevel + int32(1) } else { v3 = 0 } - (*(*Thistory)(unsafe.Pointer(bp + 144))).Flevel = v3 - (*(*Thistory)(unsafe.Pointer(bp + 144))).Fbase = Int32FromUint32(j + uint32(1)) - (*(*TFTW)(unsafe.Pointer(bp + 176))).Flevel = (*(*Thistory)(unsafe.Pointer(bp + 144))).Flevel + (**(**Thistory)(__ccgo_up(bp + 144))).Flevel = v3 + (**(**Thistory)(__ccgo_up(bp + 144))).Fbase = Int32FromUint32(j + uint32(1)) + (**(**TFTW)(__ccgo_up(bp + 176))).Flevel = (**(**Thistory)(__ccgo_up(bp + 144))).Flevel if h != 0 { - (*(*TFTW)(unsafe.Pointer(bp + 176))).Fbase = (*Thistory)(unsafe.Pointer(h)).Fbase + (**(**TFTW)(__ccgo_up(bp + 176))).Fbase = (*Thistory)(unsafe.Pointer(h)).Fbase } else { k = j for { - if !(k != 0 && int32(*(*int8)(unsafe.Pointer(path + uintptr(k)))) == int32('/')) { + if !(k != 0 && int32(**(**int8)(__ccgo_up(path + uintptr(k)))) == int32('/')) { break } goto _5 @@ -115736,7 +115736,7 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag k = k - 1 } for { - if !(k != 0 && int32(*(*int8)(unsafe.Pointer(path + uintptr(k-uint32(1))))) != int32('/')) { + if !(k != 0 && int32(**(**int8)(__ccgo_up(path + uintptr(k-uint32(1))))) != int32('/')) { break } goto _6 @@ -115744,11 +115744,11 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag ; k = k - 1 } - (*(*TFTW)(unsafe.Pointer(bp + 176))).Fbase = Int32FromUint32(k) + (**(**TFTW)(__ccgo_up(bp + 176))).Fbase = Int32FromUint32(k) } if type1 == int32(FTW_D) || type1 == int32(FTW_DP) { dfd = Xopen(tls, path, O_RDONLY, 0) - err = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + err = **(**int32)(__ccgo_up(X__errno_location(tls))) if dfd < 0 && err == int32(EACCES) { type1 = int32(FTW_DNR) } @@ -115767,7 +115767,7 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag if !(h != 0) { break } - if (*Thistory)(unsafe.Pointer(h)).Fdev == (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev && (*Thistory)(unsafe.Pointer(h)).Fino == (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino { + if (*Thistory)(unsafe.Pointer(h)).Fdev == (**(**Tstat)(__ccgo_up(bp))).Fst_dev && (*Thistory)(unsafe.Pointer(h)).Fino == (**(**Tstat)(__ccgo_up(bp))).Fst_ino { return 0 } goto _9 @@ -115777,7 +115777,7 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag } if (type1 == int32(FTW_D) || type1 == int32(FTW_DP)) && fd_limit != 0 { if dfd < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = err + **(**int32)(__ccgo_up(X__errno_location(tls))) = err return -int32(1) } d = Xfdopendir(tls, dfd) @@ -115788,15 +115788,15 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag if !(v10 != 0) { break } - if int32(*(*int8)(unsafe.Pointer(de + 19))) == int32('.') && (!(*(*int8)(unsafe.Pointer(de + 19 + 1)) != 0) || int32(*(*int8)(unsafe.Pointer(de + 19 + 1))) == int32('.') && !(*(*int8)(unsafe.Pointer(de + 19 + 2)) != 0)) { + if int32(**(**int8)(__ccgo_up(de + 19))) == int32('.') && (!(**(**int8)(__ccgo_up(de + 19 + 1)) != 0) || int32(**(**int8)(__ccgo_up(de + 19 + 1))) == int32('.') && !(**(**int8)(__ccgo_up(de + 19 + 2)) != 0)) { continue } if _strlen(tls, de+19) >= uint32(PATH_MAX)-l { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENAMETOOLONG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENAMETOOLONG) Xclosedir(tls, d) return -int32(1) } - *(*int8)(unsafe.Pointer(path + uintptr(j))) = int8('/') + **(**int8)(__ccgo_up(path + uintptr(j))) = int8('/') Xstrcpy(tls, path+uintptr(j)+uintptr(1), de+19) v3 = _do_nftw(tls, path, __ccgo_fp_fn, fd_limit-int32(1), flags, bp+144) r = v3 @@ -115811,7 +115811,7 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag return -int32(1) } } - *(*int8)(unsafe.Pointer(path + uintptr(l))) = 0 + **(**int8)(__ccgo_up(path + uintptr(l))) = 0 if v8 = flags&int32(FTW_DEPTH) != 0; v8 { v3 = (*(*func(*TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_fn})))(tls, path, bp, type1, bp+176) r = v3 @@ -115841,13 +115841,13 @@ func Xnftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flags i } l = _strlen(tls, path) if l > uint32(PATH_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENAMETOOLONG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENAMETOOLONG) return -int32(1) } Xmemcpy(tls, bp+4, path, l+uint32(1)) _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp) r = _do_nftw(tls, bp+4, __ccgo_fp_fn, fd_limit, flags, UintptrFromInt32(0)) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) return r } @@ -115865,7 +115865,7 @@ func Xopenpty(tls *TLS, pm uintptr, ps uintptr, name uintptr, tio uintptr, ws ui var _ /* cs at bp+4 */ int32 var _ /* n at bp+0 */ int32 _, _, _ = m, s, v1 - *(*int32)(unsafe.Pointer(bp)) = 0 + **(**int32)(__ccgo_up(bp)) = 0 m = Xopen(tls, __ccgo_ts+814, Int32FromInt32(O_RDWR)|Int32FromInt32(O_NOCTTY), 0) if m < 0 { return -int32(1) @@ -115877,7 +115877,7 @@ func Xopenpty(tls *TLS, pm uintptr, ps uintptr, name uintptr, tio uintptr, ws ui if !(name != 0) { name = bp + 8 } - Xsnprintf(tls, name, uint32(20), __ccgo_ts+824, VaList(bp+40, *(*int32)(unsafe.Pointer(bp)))) + Xsnprintf(tls, name, uint32(20), __ccgo_ts+824, VaList(bp+40, **(**int32)(__ccgo_up(bp)))) v1 = Xopen(tls, name, Int32FromInt32(O_RDWR)|Int32FromInt32(O_NOCTTY), 0) s = v1 if v1 < 0 { @@ -115889,15 +115889,15 @@ func Xopenpty(tls *TLS, pm uintptr, ps uintptr, name uintptr, tio uintptr, ws ui if ws != 0 { Xioctl(tls, s, int32(TIOCSWINSZ), VaList(bp+40, ws)) } - *(*int32)(unsafe.Pointer(pm)) = m - *(*int32)(unsafe.Pointer(ps)) = s - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 4)), uintptr(0)) + **(**int32)(__ccgo_up(pm)) = m + **(**int32)(__ccgo_up(ps)) = s + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 4)), uintptr(0)) return 0 goto fail fail: ; Xclose(tls, m) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 4)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 4)), uintptr(0)) return -int32(1) } @@ -115910,7 +115910,7 @@ func Xptsname(tls *TLS, fd int32) (r uintptr) { _ = err err = X__ptsname_r(tls, fd, uintptr(unsafe.Pointer(&_buf2)), uint32(22)) if err != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = err + **(**int32)(__ccgo_up(X__errno_location(tls))) = err return uintptr(0) } return uintptr(unsafe.Pointer(&_buf2)) @@ -115926,8 +115926,8 @@ func Xposix_openpt(tls *TLS, flags int32) (r1 int32) { var r int32 _ = r r = Xopen(tls, __ccgo_ts+814, flags, 0) - if r < 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENOSPC) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EAGAIN) + if r < 0 && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENOSPC) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EAGAIN) } return r } @@ -115948,7 +115948,7 @@ func Xunlockpt(tls *TLS, fd int32) (r int32) { bp := tls.Alloc(32) defer tls.Free(32) var _ /* unlock at bp+0 */ int32 - *(*int32)(unsafe.Pointer(bp)) = 0 + **(**int32)(__ccgo_up(bp)) = 0 return Xioctl(tls, fd, int32(TIOCSPTLCK), VaList(bp+16, bp)) } @@ -115970,7 +115970,7 @@ func X__ptsname_r(tls *TLS, fd int32, buf uintptr, len1 Tsize_t) (r int32) { if v1 != 0 { return -err } - if Uint32FromInt32(Xsnprintf(tls, buf, len1, __ccgo_ts+824, VaList(bp+16, *(*int32)(unsafe.Pointer(bp))))) >= len1 { + if Uint32FromInt32(Xsnprintf(tls, buf, len1, __ccgo_ts+824, VaList(bp+16, **(**int32)(__ccgo_up(bp))))) >= len1 { return int32(ERANGE) } return 0 @@ -115988,7 +115988,7 @@ func _slash_len(tls *TLS, s uintptr) (r Tsize_t) { var s0 uintptr _ = s0 s0 = s - for int32(*(*int8)(unsafe.Pointer(s))) == int32('/') { + for int32(**(**int8)(__ccgo_up(s))) == int32('/') { s = s + 1 } return Uint32FromInt32(int32(s) - int32(s0)) @@ -116012,12 +116012,12 @@ func Xrealpath(tls *TLS, filename uintptr, resolved uintptr) (r uintptr) { nup = uint32(0) check_dir = 0 if !(filename != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } l = Xstrnlen(tls, filename, uint32(4097)) if !(l != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOENT) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOENT) return uintptr(0) } if l >= uint32(PATH_MAX) { @@ -116037,19 +116037,19 @@ _3: ; /* If stack starts with /, the whole component is / or // * and the output state must be reset. */ - if int32((*(*[4097]int8)(unsafe.Pointer(bp)))[p]) == int32('/') { + if int32((**(**[4097]int8)(__ccgo_up(bp)))[p]) == int32('/') { check_dir = 0 nup = uint32(0) q = uint32(0) v4 = q q = q + 1 - (*(*[4096]int8)(unsafe.Pointer(bp + 4097)))[v4] = int8('/') + (**(**[4096]int8)(__ccgo_up(bp + 4097)))[v4] = int8('/') p = p + 1 /* Initial // is special. */ - if int32((*(*[4097]int8)(unsafe.Pointer(bp)))[p]) == int32('/') && int32((*(*[4097]int8)(unsafe.Pointer(bp)))[p+uint32(1)]) != int32('/') { + if int32((**(**[4097]int8)(__ccgo_up(bp)))[p]) == int32('/') && int32((**(**[4097]int8)(__ccgo_up(bp)))[p+uint32(1)]) != int32('/') { v4 = q q = q + 1 - (*(*[4096]int8)(unsafe.Pointer(bp + 4097)))[v4] = int8('/') + (**(**[4096]int8)(__ccgo_up(bp + 4097)))[v4] = int8('/') } goto _2 } @@ -116061,30 +116061,30 @@ _3: goto _1 } /* Skip any . component but preserve check_dir status. */ - if l == uint32(1) && int32((*(*[4097]int8)(unsafe.Pointer(bp)))[p]) == int32('.') { + if l == uint32(1) && int32((**(**[4097]int8)(__ccgo_up(bp)))[p]) == int32('.') { p = p + l goto _2 } /* Copy next component onto output at least temporarily, to * call readlink, but wait to advance output position until * determining it's not a link. */ - if q != 0 && int32((*(*[4096]int8)(unsafe.Pointer(bp + 4097)))[q-uint32(1)]) != int32('/') { + if q != 0 && int32((**(**[4096]int8)(__ccgo_up(bp + 4097)))[q-uint32(1)]) != int32('/') { if !(p != 0) { goto toolong } p = p - 1 v4 = p - (*(*[4097]int8)(unsafe.Pointer(bp)))[v4] = int8('/') + (**(**[4097]int8)(__ccgo_up(bp)))[v4] = int8('/') l = l + 1 } if q+l >= uint32(PATH_MAX) { goto toolong } Xmemcpy(tls, bp+4097+uintptr(q), bp+uintptr(p), l) - (*(*[4096]int8)(unsafe.Pointer(bp + 4097)))[q+l] = 0 + (**(**[4096]int8)(__ccgo_up(bp + 4097)))[q+l] = 0 p = p + l up = 0 - if l0 == uint32(2) && int32((*(*[4097]int8)(unsafe.Pointer(bp)))[p-uint32(2)]) == int32('.') && int32((*(*[4097]int8)(unsafe.Pointer(bp)))[p-uint32(1)]) == int32('.') { + if l0 == uint32(2) && int32((**(**[4097]int8)(__ccgo_up(bp)))[p-uint32(2)]) == int32('.') && int32((**(**[4097]int8)(__ccgo_up(bp)))[p-uint32(1)]) == int32('.') { up = int32(1) /* Any non-.. path components we could cancel start * after nup repetitions of the 3-byte string "../"; @@ -116106,13 +116106,13 @@ _3: goto toolong } if !(k != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOENT) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOENT) return uintptr(0) } if !(k < 0) { goto _8 } - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(EINVAL) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(EINVAL) { return uintptr(0) } goto skip_readlink @@ -116120,10 +116120,10 @@ skip_readlink: ; check_dir = 0 if up != 0 { - for q != 0 && int32((*(*[4096]int8)(unsafe.Pointer(bp + 4097)))[q-uint32(1)]) != int32('/') { + for q != 0 && int32((**(**[4096]int8)(__ccgo_up(bp + 4097)))[q-uint32(1)]) != int32('/') { q = q - 1 } - if q > uint32(1) && (q > uint32(2) || int32((*(*[4096]int8)(unsafe.Pointer(bp + 4097)))[0]) != int32('/')) { + if q > uint32(1) && (q > uint32(2) || int32((**(**[4096]int8)(__ccgo_up(bp + 4097)))[0]) != int32('/')) { q = q - 1 } goto _2 @@ -116131,20 +116131,20 @@ skip_readlink: if l0 != 0 { q = q + l } - check_dir = int32((*(*[4097]int8)(unsafe.Pointer(bp)))[p]) + check_dir = int32((**(**[4097]int8)(__ccgo_up(bp)))[p]) goto _2 _8: ; cnt = cnt + 1 v4 = cnt if v4 == uint32(SYMLOOP_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ELOOP) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ELOOP) return uintptr(0) } /* If link contents end in /, strip any slashes already on * stack to avoid /->// or //->/// or spurious toolong. */ - if int32((*(*[4097]int8)(unsafe.Pointer(bp)))[k-int32(1)]) == int32('/') { - for int32((*(*[4097]int8)(unsafe.Pointer(bp)))[p]) == int32('/') { + if int32((**(**[4097]int8)(__ccgo_up(bp)))[k-int32(1)]) == int32('/') { + for int32((**(**[4097]int8)(__ccgo_up(bp)))[p]) == int32('/') { p = p + 1 } } @@ -116161,8 +116161,8 @@ _2: goto _1 _1: ; - (*(*[4096]int8)(unsafe.Pointer(bp + 4097)))[q] = 0 - if int32((*(*[4096]int8)(unsafe.Pointer(bp + 4097)))[0]) != int32('/') { + (**(**[4096]int8)(__ccgo_up(bp + 4097)))[q] = 0 + if int32((**(**[4096]int8)(__ccgo_up(bp + 4097)))[0]) != int32('/') { if !(Xgetcwd(tls, bp, uint32(4097)) != 0) { return uintptr(0) } @@ -116175,7 +116175,7 @@ _1: if !(v4 != 0) { break } - for l > uint32(1) && int32((*(*[4097]int8)(unsafe.Pointer(bp)))[l-uint32(1)]) != int32('/') { + for l > uint32(1) && int32((**(**[4097]int8)(__ccgo_up(bp)))[l-uint32(1)]) != int32('/') { l = l - 1 } if l > uint32(1) { @@ -116186,10 +116186,10 @@ _1: p = p + 1 } } - if q-p != 0 && int32((*(*[4097]int8)(unsafe.Pointer(bp)))[l-uint32(1)]) != int32('/') { + if q-p != 0 && int32((**(**[4097]int8)(__ccgo_up(bp)))[l-uint32(1)]) != int32('/') { v4 = l l = l + 1 - (*(*[4097]int8)(unsafe.Pointer(bp)))[v4] = int8('/') + (**(**[4097]int8)(__ccgo_up(bp)))[v4] = int8('/') } if l+(q-p)+uint32(1) >= uint32(PATH_MAX) { goto toolong @@ -116206,7 +116206,7 @@ _1: goto toolong toolong: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENAMETOOLONG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENAMETOOLONG) return uintptr(0) } @@ -116255,12 +116255,12 @@ func Xsetrlimit(tls *TLS, resource int32, rlim uintptr) (r int32) { var _ /* tmp at bp+0 */ Trlimit _, _, _ = ret, v1, v2 if ^Uint64FromUint64(0) != ^Uint64FromUint64(0) { - *(*Trlimit)(unsafe.Pointer(bp)) = *(*Trlimit)(unsafe.Pointer(rlim)) - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur >= ^Uint64FromUint64(0) { - (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur = ^Uint64FromUint64(0) + **(**Trlimit)(__ccgo_up(bp)) = **(**Trlimit)(__ccgo_up(rlim)) + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur >= ^Uint64FromUint64(0) { + (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur = ^Uint64FromUint64(0) } - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_max >= ^Uint64FromUint64(0) { - (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_max = ^Uint64FromUint64(0) + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_max >= ^Uint64FromUint64(0) { + (**(**Trlimit)(__ccgo_up(bp))).Frlim_max = ^Uint64FromUint64(0) } rlim = bp } @@ -116278,7 +116278,7 @@ func Xsetrlimit(tls *TLS, resource int32, rlim uintptr) (r int32) { } else { v2 = uint64(-Uint32FromUint32(1)) } - *(*Tctx)(unsafe.Pointer(bp + 16)) = Tctx{ + **(**Tctx)(__ccgo_up(bp + 16)) = Tctx{ Flim: [2]uint32{ 0: uint32(v1), 1: uint32(v2), @@ -116287,9 +116287,9 @@ func Xsetrlimit(tls *TLS, resource int32, rlim uintptr) (r int32) { Ferr: -int32(1), } ___synccall(tls, __ccgo_fp(_do_setrlimit), bp+16) - if (*(*Tctx)(unsafe.Pointer(bp + 16))).Ferr != 0 { - if (*(*Tctx)(unsafe.Pointer(bp + 16))).Ferr > 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = (*(*Tctx)(unsafe.Pointer(bp + 16))).Ferr + if (**(**Tctx)(__ccgo_up(bp + 16))).Ferr != 0 { + if (**(**Tctx)(__ccgo_up(bp + 16))).Ferr > 0 { + **(**int32)(__ccgo_up(X__errno_location(tls))) = (**(**Tctx)(__ccgo_up(bp + 16))).Ferr } return -int32(1) } @@ -116666,7 +116666,7 @@ func Xcloselog(tls *TLS) { Xclose(tls, _log_fd) _log_fd = -int32(1) ___unlock(tls, uintptr(unsafe.Pointer(&_lock2))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) } func ___openlog(tls *TLS) { @@ -116700,7 +116700,7 @@ func Xopenlog(tls *TLS, ident uintptr, opt int32, facility int32) { ___openlog(tls) } ___unlock(tls, uintptr(unsafe.Pointer(&_lock2))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) } func _is_lost_conn(tls *TLS, e int32) (r int32) { @@ -116717,14 +116717,14 @@ func __vsyslog(tls *TLS, priority int32, message uintptr, ap Tva_list) { var _ /* timebuf at bp+0 */ [16]int8 var _ /* tm at bp+24 */ Ttm _, _, _, _, _, _ = errno_save, fd, l, l2, pid, v1 - errno_save = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + errno_save = **(**int32)(__ccgo_up(X__errno_location(tls))) if _log_fd < 0 { ___openlog(tls) } if !(priority&Int32FromInt32(LOG_FACMASK) != 0) { priority = priority | _log_facility } - *(*Ttime_t)(unsafe.Pointer(bp + 16)) = Xtime(tls, UintptrFromInt32(0)) + **(**Ttime_t)(__ccgo_up(bp + 16)) = Xtime(tls, UintptrFromInt32(0)) Xgmtime_r(tls, bp+16, bp+24) Xstrftime_l(tls, bp, uint32(16), __ccgo_ts+836, bp+24, uintptr(unsafe.Pointer(&X__c_locale))) if _log_opt&int32(LOG_PID) != 0 { @@ -116734,7 +116734,7 @@ func __vsyslog(tls *TLS, priority int32, message uintptr, ap Tva_list) { } pid = v1 l = Xsnprintf(tls, bp+68, uint32(1024), __ccgo_ts+845, VaList(bp+1104, priority, bp, bp+1092, uintptr(unsafe.Pointer(&_log_ident)), __ccgo_ts+867+BoolUintptr(!(pid != 0)), pid, __ccgo_ts+869+BoolUintptr(!(pid != 0)))) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = errno_save + **(**int32)(__ccgo_up(X__errno_location(tls))) = errno_save l2 = Xvsnprintf(tls, bp+68+uintptr(l), uint32(1024)-Uint32FromInt32(l), message, ap) if l2 >= 0 { if Uint32FromInt32(l2) >= uint32(1024)-Uint32FromInt32(l) { @@ -116742,20 +116742,20 @@ func __vsyslog(tls *TLS, priority int32, message uintptr, ap Tva_list) { } else { l = l + l2 } - if int32((*(*[1024]int8)(unsafe.Pointer(bp + 68)))[l-int32(1)]) != int32('\n') { + if int32((**(**[1024]int8)(__ccgo_up(bp + 68)))[l-int32(1)]) != int32('\n') { v1 = l l = l + 1 - (*(*[1024]int8)(unsafe.Pointer(bp + 68)))[v1] = int8('\n') + (**(**[1024]int8)(__ccgo_up(bp + 68)))[v1] = int8('\n') } - if Xsend(tls, _log_fd, bp+68, Uint32FromInt32(l), 0) < 0 && (!(_is_lost_conn(tls, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) != 0) || Xconnect(tls, _log_fd, uintptr(unsafe.Pointer(&_log_addr)), uint32(12)) < 0 || Xsend(tls, _log_fd, bp+68, Uint32FromInt32(l), 0) < 0) && _log_opt&int32(LOG_CONS) != 0 { + if Xsend(tls, _log_fd, bp+68, Uint32FromInt32(l), 0) < 0 && (!(_is_lost_conn(tls, **(**int32)(__ccgo_up(X__errno_location(tls)))) != 0) || Xconnect(tls, _log_fd, uintptr(unsafe.Pointer(&_log_addr)), uint32(12)) < 0 || Xsend(tls, _log_fd, bp+68, Uint32FromInt32(l), 0) < 0) && _log_opt&int32(LOG_CONS) != 0 { fd = Xopen(tls, __ccgo_ts+564, Int32FromInt32(O_WRONLY)|Int32FromInt32(O_NOCTTY)|Int32FromInt32(O_CLOEXEC), 0) if fd >= 0 { - Xdprintf(tls, fd, __ccgo_ts+871, VaList(bp+1104, l-*(*int32)(unsafe.Pointer(bp + 1092)), bp+68+uintptr(*(*int32)(unsafe.Pointer(bp + 1092))))) + Xdprintf(tls, fd, __ccgo_ts+871, VaList(bp+1104, l-**(**int32)(__ccgo_up(bp + 1092)), bp+68+uintptr(**(**int32)(__ccgo_up(bp + 1092))))) Xclose(tls, fd) } } if _log_opt&int32(LOG_PERROR) != 0 { - Xdprintf(tls, int32(2), __ccgo_ts+871, VaList(bp+1104, l-*(*int32)(unsafe.Pointer(bp + 1092)), bp+68+uintptr(*(*int32)(unsafe.Pointer(bp + 1092))))) + Xdprintf(tls, int32(2), __ccgo_ts+871, VaList(bp+1104, l-**(**int32)(__ccgo_up(bp + 1092)), bp+68+uintptr(**(**int32)(__ccgo_up(bp + 1092))))) } } } @@ -116771,7 +116771,7 @@ func ___vsyslog(tls *TLS, priority int32, message uintptr, ap Tva_list) { ___lock(tls, uintptr(unsafe.Pointer(&_lock2))) __vsyslog(tls, priority, message, ap) ___unlock(tls, uintptr(unsafe.Pointer(&_lock2))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) } func Xsyslog(tls *TLS, priority int32, message uintptr, va uintptr) { @@ -116856,11 +116856,11 @@ func X__mmap(tls *TLS, start uintptr, len1 Tsize_t, prot int32, flags int32, fd var ret int32 _ = ret if Uint64FromInt64(off)&(-Uint64FromUint64(0x2000)<<(Uint32FromInt32(8)*Uint32FromInt64(4)-Uint32FromInt32(1))|(Uint64FromUint64(4096)-Uint64FromInt32(1))) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(-Int32FromInt32(1)) } if len1 >= Uint32FromInt32(Int32FromInt32(INT32_MAX)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return uintptr(-Int32FromInt32(1)) } if flags&int32(MAP_FIXED) != 0 { @@ -116915,7 +116915,7 @@ func X__mremap(tls *TLS, old_addr uintptr, old_len Tsize_t, new_len Tsize_t, fla _, _ = ap, new_addr new_addr = uintptr(0) if new_len >= Uint32FromInt32(Int32FromInt32(INT32_MAX)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return uintptr(-Int32FromInt32(1)) } if flags&int32(MREMAP_FIXED) != 0 { @@ -116997,17 +116997,17 @@ func X__shm_mapname(tls *TLS, name uintptr, buf uintptr) (r uintptr) { } var p, v1 uintptr _, _ = p, v1 - for int32(*(*int8)(unsafe.Pointer(name))) == int32('/') { + for int32(**(**int8)(__ccgo_up(name))) == int32('/') { name = name + 1 } v1 = X__strchrnul(tls, name, int32('/')) p = v1 - if *(*int8)(unsafe.Pointer(v1)) != 0 || p == name || int32(p)-int32(name) <= int32(2) && int32(*(*int8)(unsafe.Pointer(name))) == int32('.') && int32(*(*int8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) == int32('.') { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if **(**int8)(__ccgo_up(v1)) != 0 || p == name || int32(p)-int32(name) <= int32(2) && int32(**(**int8)(__ccgo_up(name))) == int32('.') && int32(**(**int8)(__ccgo_up(p + uintptr(-Int32FromInt32(1))))) == int32('.') { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } if int32(p)-int32(name) > int32(NAME_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENAMETOOLONG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENAMETOOLONG) return uintptr(0) } Xmemcpy(tls, buf, __ccgo_ts+876, uint32(9)) @@ -117034,7 +117034,7 @@ func Xshm_open(tls *TLS, name uintptr, flag int32, mode Tmode_t) (r int32) { } _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp) fd = Xopen(tls, name, flag|int32(O_NOFOLLOW)|int32(O_CLOEXEC)|int32(O_NONBLOCK), VaList(bp+280, mode)) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) return fd } @@ -117072,7 +117072,7 @@ func Xbtowc(tls *TLS, c int32) (r Twint_t) { if Uint32FromInt32(b) < uint32(128) { v1 = Uint32FromInt32(b) } else { - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v3 = int32(4) } else { v3 = int32(1) @@ -117104,22 +117104,22 @@ func Xc16rtomb(tls *TLS, s uintptr, c16 Tchar16_t, ps uintptr) (r Tsize_t) { } x = ps if !(s != 0) { - if *(*uint32)(unsafe.Pointer(x)) != 0 { + if **(**uint32)(__ccgo_up(x)) != 0 { goto ilseq } return uint32(1) } - if !(*(*uint32)(unsafe.Pointer(x)) != 0) && uint32(c16)-uint32(0xd800) < uint32(0x400) { - *(*uint32)(unsafe.Pointer(x)) = Uint32FromInt32((Int32FromUint16(c16) - int32(0xd7c0)) << int32(10)) + if !(**(**uint32)(__ccgo_up(x)) != 0) && uint32(c16)-uint32(0xd800) < uint32(0x400) { + **(**uint32)(__ccgo_up(x)) = Uint32FromInt32((Int32FromUint16(c16) - int32(0xd7c0)) << int32(10)) return uint32(0) } - if *(*uint32)(unsafe.Pointer(x)) != 0 { + if **(**uint32)(__ccgo_up(x)) != 0 { if uint32(c16)-uint32(0xdc00) >= uint32(0x400) { goto ilseq } else { - wc = Int32FromUint32(*(*uint32)(unsafe.Pointer(x)) + uint32(c16) - uint32(0xdc00)) + wc = Int32FromUint32(**(**uint32)(__ccgo_up(x)) + uint32(c16) - uint32(0xdc00)) } - *(*uint32)(unsafe.Pointer(x)) = uint32(0) + **(**uint32)(__ccgo_up(x)) = uint32(0) } else { wc = Int32FromUint16(c16) } @@ -117127,8 +117127,8 @@ func Xc16rtomb(tls *TLS, s uintptr, c16 Tchar16_t, ps uintptr) (r Tsize_t) { goto ilseq ilseq: ; - *(*uint32)(unsafe.Pointer(x)) = uint32(0) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EILSEQ) + **(**uint32)(__ccgo_up(x)) = uint32(0) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EILSEQ) return Uint32FromInt32(-Int32FromInt32(1)) } @@ -117187,21 +117187,21 @@ func Xmbrtoc16(tls *TLS, pc16 uintptr, s uintptr, n Tsize_t, ps uintptr) (r Tsiz } /* mbrtowc states for partial UTF-8 characters have the high bit set; * we use nonzero states without high bit for pending surrogates. */ - if Int32FromUint32(*(*uint32)(unsafe.Pointer(pending))) > 0 { + if Int32FromUint32(**(**uint32)(__ccgo_up(pending))) > 0 { if pc16 != 0 { - *(*Tchar16_t)(unsafe.Pointer(pc16)) = uint16(*(*uint32)(unsafe.Pointer(pending))) + **(**Tchar16_t)(__ccgo_up(pc16)) = uint16(**(**uint32)(__ccgo_up(pending))) } - *(*uint32)(unsafe.Pointer(pending)) = uint32(0) + **(**uint32)(__ccgo_up(pending)) = uint32(0) return Uint32FromInt32(-Int32FromInt32(3)) } ret = Xmbrtowc(tls, bp, s, n, ps) if ret <= uint32(4) { - if *(*Twchar_t)(unsafe.Pointer(bp)) >= int32(0x10000) { - *(*uint32)(unsafe.Pointer(pending)) = Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))&int32(0x3ff) + int32(0xdc00)) - *(*Twchar_t)(unsafe.Pointer(bp)) = int32(0xd7c0) + *(*Twchar_t)(unsafe.Pointer(bp))>>Int32FromInt32(10) + if **(**Twchar_t)(__ccgo_up(bp)) >= int32(0x10000) { + **(**uint32)(__ccgo_up(pending)) = Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))&int32(0x3ff) + int32(0xdc00)) + **(**Twchar_t)(__ccgo_up(bp)) = int32(0xd7c0) + **(**Twchar_t)(__ccgo_up(bp))>>Int32FromInt32(10) } if pc16 != 0 { - *(*Tchar16_t)(unsafe.Pointer(pc16)) = Uint16FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))) + **(**Tchar16_t)(__ccgo_up(pc16)) = Uint16FromInt32(**(**Twchar_t)(__ccgo_up(bp))) } } return ret @@ -117227,7 +117227,7 @@ func Xmbrtoc32(tls *TLS, pc32 uintptr, s uintptr, n Tsize_t, ps uintptr) (r Tsiz } ret = Xmbrtowc(tls, bp, s, n, ps) if ret <= uint32(4) && pc32 != 0 { - *(*Tchar32_t)(unsafe.Pointer(pc32)) = Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))) + **(**Tchar32_t)(__ccgo_up(pc32)) = Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))) } return ret } @@ -117253,7 +117253,7 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize if !(st != 0) { st = uintptr(unsafe.Pointer(&_internal_state3)) } - c = *(*uint32)(unsafe.Pointer(st)) + c = **(**uint32)(__ccgo_up(st)) if !(s != 0) { if c != 0 { goto ilseq @@ -117268,30 +117268,30 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize return Uint32FromInt32(-Int32FromInt32(2)) } if !(c != 0) { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) < int32(0x80) { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) - *(*Twchar_t)(unsafe.Pointer(wc)) = v1 + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) < int32(0x80) { + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(s))) + **(**Twchar_t)(__ccgo_up(wc)) = v1 return BoolUint32(!!(v1 != 0)) } - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v2 = int32(4) } else { v2 = int32(1) } if v2 == int32(1) { - *(*Twchar_t)(unsafe.Pointer(wc)) = int32(Int32FromInt32(0xdfff) & int32(Int8FromUint8(*(*uint8)(unsafe.Pointer(s))))) + **(**Twchar_t)(__ccgo_up(wc)) = int32(Int32FromInt32(0xdfff) & int32(Int8FromUint8(**(**uint8)(__ccgo_up(s))))) return Uint32FromInt32(1) } - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { goto ilseq } v3 = s s = s + 1 - c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v3)))-uint32(0xc2)] + c = X__fsmu8[uint32(**(**uint8)(__ccgo_up(v3)))-uint32(0xc2)] n = n - 1 } if n != 0 { - if (Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { + if (Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { goto ilseq } goto loop @@ -117299,27 +117299,27 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize ; v3 = s s = s + 1 - c = c<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { goto ilseq } goto loop } } - *(*uint32)(unsafe.Pointer(st)) = c + **(**uint32)(__ccgo_up(st)) = c return Uint32FromInt32(-Int32FromInt32(2)) goto ilseq ilseq: ; - *(*uint32)(unsafe.Pointer(st)) = uint32(0) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EILSEQ) + **(**uint32)(__ccgo_up(st)) = uint32(0) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EILSEQ) return Uint32FromInt32(-Int32FromInt32(1)) } @@ -117330,7 +117330,7 @@ func Xmbsinit(tls *TLS, st uintptr) (r int32) { trc("tls=%v st=%v, (%v:)", tls, st, origin(2)) defer func() { trc("-> %v", r) }() } - return BoolInt32(!(st != 0) || !(*(*uint32)(unsafe.Pointer(st)) != 0)) + return BoolInt32(!(st != 0) || !(**(**uint32)(__ccgo_up(st)) != 0)) } func Xmbsnrtowcs(tls *TLS, wcs uintptr, src uintptr, n Tsize_t, wn Tsize_t, st uintptr) (r Tsize_t) { @@ -117348,7 +117348,7 @@ func Xmbsnrtowcs(tls *TLS, wcs uintptr, src uintptr, n Tsize_t, wn Tsize_t, st u var _ /* wbuf at bp+0 */ [256]Twchar_t _, _, _, _, _, _, _, _ = cnt, l, n2, tmp_s, ws, v1, v2, v3 cnt = uint32(0) - *(*uintptr)(unsafe.Pointer(bp + 1024)) = *(*uintptr)(unsafe.Pointer(src)) + **(**uintptr)(__ccgo_up(bp + 1024)) = **(**uintptr)(__ccgo_up(src)) if !(wcs != 0) { ws = bp wn = Uint32FromInt64(1024) / Uint32FromInt64(4) @@ -117359,7 +117359,7 @@ func Xmbsnrtowcs(tls *TLS, wcs uintptr, src uintptr, n Tsize_t, wn Tsize_t, st u * that mbsrtowcs never reads more than n input bytes. thus * we can use mbsrtowcs as long as it's practical.. */ for { - if v2 = *(*uintptr)(unsafe.Pointer(bp + 1024)) != 0 && wn != 0; v2 { + if v2 = **(**uintptr)(__ccgo_up(bp + 1024)) != 0 && wn != 0; v2 { v1 = n / Uint32FromInt32(4) n2 = v1 } @@ -117369,7 +117369,7 @@ func Xmbsnrtowcs(tls *TLS, wcs uintptr, src uintptr, n Tsize_t, wn Tsize_t, st u if n2 >= wn { n2 = wn } - tmp_s = *(*uintptr)(unsafe.Pointer(bp + 1024)) + tmp_s = **(**uintptr)(__ccgo_up(bp + 1024)) l = Xmbsrtowcs(tls, ws, bp+1024, n2, st) if !(l+Uint32FromInt32(1) != 0) { cnt = l @@ -117380,31 +117380,31 @@ func Xmbsnrtowcs(tls *TLS, wcs uintptr, src uintptr, n Tsize_t, wn Tsize_t, st u ws = ws + uintptr(l)*4 wn = wn - l } - if *(*uintptr)(unsafe.Pointer(bp + 1024)) != 0 { - v3 = n - Uint32FromInt32(int32(*(*uintptr)(unsafe.Pointer(bp + 1024)))-int32(tmp_s)) + if **(**uintptr)(__ccgo_up(bp + 1024)) != 0 { + v3 = n - Uint32FromInt32(int32(**(**uintptr)(__ccgo_up(bp + 1024)))-int32(tmp_s)) } else { v3 = uint32(0) } n = v3 cnt = cnt + l } - if *(*uintptr)(unsafe.Pointer(bp + 1024)) != 0 { + if **(**uintptr)(__ccgo_up(bp + 1024)) != 0 { for wn != 0 && n != 0 { - l = Xmbrtowc(tls, ws, *(*uintptr)(unsafe.Pointer(bp + 1024)), n, st) + l = Xmbrtowc(tls, ws, **(**uintptr)(__ccgo_up(bp + 1024)), n, st) if l+uint32(2) <= uint32(2) { if !(l+Uint32FromInt32(1) != 0) { cnt = l break } if !(l != 0) { - *(*uintptr)(unsafe.Pointer(bp + 1024)) = uintptr(0) + **(**uintptr)(__ccgo_up(bp + 1024)) = uintptr(0) break } /* have to roll back partial character */ - *(*uint32)(unsafe.Pointer(st)) = uint32(0) + **(**uint32)(__ccgo_up(st)) = uint32(0) break } - *(*uintptr)(unsafe.Pointer(bp + 1024)) = *(*uintptr)(unsafe.Pointer(bp + 1024)) + uintptr(l) + **(**uintptr)(__ccgo_up(bp + 1024)) = **(**uintptr)(__ccgo_up(bp + 1024)) + uintptr(l) n = n - l /* safe - this loop runs fewer than sizeof(wbuf)/8 times */ ws += 4 @@ -117413,7 +117413,7 @@ func Xmbsnrtowcs(tls *TLS, wcs uintptr, src uintptr, n Tsize_t, wn Tsize_t, st u } } if wcs != 0 { - *(*uintptr)(unsafe.Pointer(src)) = *(*uintptr)(unsafe.Pointer(bp + 1024)) + **(**uintptr)(__ccgo_up(src)) = **(**uintptr)(__ccgo_up(bp + 1024)) } return cnt } @@ -117429,22 +117429,22 @@ func Xmbsrtowcs(tls *TLS, ws uintptr, src uintptr, wn Tsize_t, st uintptr) (r Ts var v2 bool var v3 int32 _, _, _, _, _, _, _, _ = c, s, wn0, v1, v2, v3, v5, v6 - s = *(*uintptr)(unsafe.Pointer(src)) + s = **(**uintptr)(__ccgo_up(src)) wn0 = wn c = uint32(0) if v2 = st != 0; v2 { - v1 = *(*uint32)(unsafe.Pointer(st)) + v1 = **(**uint32)(__ccgo_up(st)) c = v1 } if v2 && v1 != 0 { if ws != 0 { - *(*uint32)(unsafe.Pointer(st)) = uint32(0) + **(**uint32)(__ccgo_up(st)) = uint32(0) goto resume } else { goto resume0 } } - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v3 = int32(4) } else { v3 = int32(1) @@ -117455,24 +117455,24 @@ func Xmbsrtowcs(tls *TLS, ws uintptr, src uintptr, wn Tsize_t, st uintptr) (r Ts } for { if !(wn != 0) { - *(*uintptr)(unsafe.Pointer(src)) = s + **(**uintptr)(__ccgo_up(src)) = s return wn0 } - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { break } v5 = s s = s + 1 - c = uint32(*(*uint8)(unsafe.Pointer(v5))) + c = uint32(**(**uint8)(__ccgo_up(v5))) v5 = ws ws += 4 - *(*Twchar_t)(unsafe.Pointer(v5)) = int32(Int32FromInt32(0xdfff) & int32(Int8FromUint32(c))) + **(**Twchar_t)(__ccgo_up(v5)) = int32(Int32FromInt32(0xdfff) & int32(Int8FromUint32(c))) wn = wn - 1 goto _4 _4: } - *(*Twchar_t)(unsafe.Pointer(ws)) = 0 - *(*uintptr)(unsafe.Pointer(src)) = uintptr(0) + **(**Twchar_t)(__ccgo_up(ws)) = 0 + **(**uintptr)(__ccgo_up(src)) = uintptr(0) return wn0 - wn } if !!(ws != 0) { @@ -117480,39 +117480,39 @@ func Xmbsrtowcs(tls *TLS, ws uintptr, src uintptr, wn Tsize_t, st uintptr) (r Ts } _11: ; - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) && uint32(s)%uint32(4) == uint32(0) { - for !((*(*uint32)(unsafe.Pointer(s))|(*(*uint32)(unsafe.Pointer(s))-Uint32FromInt32(0x01010101)))&Uint32FromUint32(0x80808080) != 0) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(1) < uint32(0x7f) && uint32(s)%uint32(4) == uint32(0) { + for !((**(**uint32)(__ccgo_up(s))|(**(**uint32)(__ccgo_up(s))-Uint32FromInt32(0x01010101)))&Uint32FromUint32(0x80808080) != 0) { s = s + uintptr(4) wn = wn - uint32(4) } } - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(1) < uint32(0x7f) { s = s + 1 wn = wn - 1 goto _10 } - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { goto _9 } v5 = s s = s + 1 - c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v5)))-uint32(0xc2)] + c = X__fsmu8[uint32(**(**uint8)(__ccgo_up(v5)))-uint32(0xc2)] goto resume0 resume0: ; - if (Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { + if (Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { s = s - 1 goto _9 } s = s + 1 if c&(Uint32FromUint32(1)<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { s = s - uintptr(2) goto _9 } s = s + 1 if c&(Uint32FromUint32(1)<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { s = s - uintptr(3) goto _9 } @@ -117534,80 +117534,80 @@ _7: _15: ; if !(wn != 0) { - *(*uintptr)(unsafe.Pointer(src)) = s + **(**uintptr)(__ccgo_up(src)) = s return wn0 } - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) && uint32(s)%uint32(4) == uint32(0) { - for wn >= uint32(5) && !((*(*uint32)(unsafe.Pointer(s))|(*(*uint32)(unsafe.Pointer(s))-Uint32FromInt32(0x01010101)))&Uint32FromUint32(0x80808080) != 0) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(1) < uint32(0x7f) && uint32(s)%uint32(4) == uint32(0) { + for wn >= uint32(5) && !((**(**uint32)(__ccgo_up(s))|(**(**uint32)(__ccgo_up(s))-Uint32FromInt32(0x01010101)))&Uint32FromUint32(0x80808080) != 0) { v5 = ws ws += 4 v6 = s s = s + 1 - *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + **(**Twchar_t)(__ccgo_up(v5)) = Int32FromUint8(**(**uint8)(__ccgo_up(v6))) v5 = ws ws += 4 v6 = s s = s + 1 - *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + **(**Twchar_t)(__ccgo_up(v5)) = Int32FromUint8(**(**uint8)(__ccgo_up(v6))) v5 = ws ws += 4 v6 = s s = s + 1 - *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + **(**Twchar_t)(__ccgo_up(v5)) = Int32FromUint8(**(**uint8)(__ccgo_up(v6))) v5 = ws ws += 4 v6 = s s = s + 1 - *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + **(**Twchar_t)(__ccgo_up(v5)) = Int32FromUint8(**(**uint8)(__ccgo_up(v6))) wn = wn - uint32(4) } } - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(1) < uint32(0x7f) { v5 = ws ws += 4 v6 = s s = s + 1 - *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + **(**Twchar_t)(__ccgo_up(v5)) = Int32FromUint8(**(**uint8)(__ccgo_up(v6))) wn = wn - 1 goto _14 } - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { goto _13 } v5 = s s = s + 1 - c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v5)))-uint32(0xc2)] + c = X__fsmu8[uint32(**(**uint8)(__ccgo_up(v5)))-uint32(0xc2)] goto resume resume: ; - if (Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { + if (Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { s = s - 1 goto _13 } v5 = s s = s + 1 - c = c<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { s = s - uintptr(2) goto _13 } v5 = s s = s + 1 - c = c<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { s = s - uintptr(3) goto _13 } v5 = s s = s + 1 - c = c< Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { goto ilseq } v3 = s s = s + 1 - c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v3)))-uint32(0xc2)] + c = X__fsmu8[uint32(**(**uint8)(__ccgo_up(v3)))-uint32(0xc2)] /* Avoid excessive checks against n: If shifting the state n-1 * times does not clear the high bit, then the value of n is * insufficient to read a character */ if n < uint32(4) && c<<(uint32(6)*n-uint32(6))&(Uint32FromUint32(1)<>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { + if (Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { goto ilseq } v3 = s s = s + 1 - c = c<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { goto ilseq } v3 = s s = s + 1 - c = c<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { goto ilseq } v3 = s s = s + 1 - *(*Twchar_t)(unsafe.Pointer(wc)) = Int32FromUint32(c<>Int32FromInt32(6)) - *(*int8)(unsafe.Pointer(s)) = int8(int32(0x80) | wc&int32(0x3f)) + **(**int8)(__ccgo_up(v2)) = int8(int32(0xc0) | wc>>Int32FromInt32(6)) + **(**int8)(__ccgo_up(s)) = int8(int32(0x80) | wc&int32(0x3f)) return uint32(2) } else { if Uint32FromInt32(wc) < uint32(0xd800) || Uint32FromInt32(wc)-uint32(0xe000) < uint32(0x2000) { v2 = s s = s + 1 - *(*int8)(unsafe.Pointer(v2)) = int8(int32(0xe0) | wc>>Int32FromInt32(12)) + **(**int8)(__ccgo_up(v2)) = int8(int32(0xe0) | wc>>Int32FromInt32(12)) v2 = s s = s + 1 - *(*int8)(unsafe.Pointer(v2)) = int8(int32(0x80) | wc>>Int32FromInt32(6)&int32(0x3f)) - *(*int8)(unsafe.Pointer(s)) = int8(int32(0x80) | wc&int32(0x3f)) + **(**int8)(__ccgo_up(v2)) = int8(int32(0x80) | wc>>Int32FromInt32(6)&int32(0x3f)) + **(**int8)(__ccgo_up(s)) = int8(int32(0x80) | wc&int32(0x3f)) return uint32(3) } else { if Uint32FromInt32(wc)-uint32(0x10000) < uint32(0x100000) { v2 = s s = s + 1 - *(*int8)(unsafe.Pointer(v2)) = int8(int32(0xf0) | wc>>Int32FromInt32(18)) + **(**int8)(__ccgo_up(v2)) = int8(int32(0xf0) | wc>>Int32FromInt32(18)) v2 = s s = s + 1 - *(*int8)(unsafe.Pointer(v2)) = int8(int32(0x80) | wc>>Int32FromInt32(12)&int32(0x3f)) + **(**int8)(__ccgo_up(v2)) = int8(int32(0x80) | wc>>Int32FromInt32(12)&int32(0x3f)) v2 = s s = s + 1 - *(*int8)(unsafe.Pointer(v2)) = int8(int32(0x80) | wc>>Int32FromInt32(6)&int32(0x3f)) - *(*int8)(unsafe.Pointer(s)) = int8(int32(0x80) | wc&int32(0x3f)) + **(**int8)(__ccgo_up(v2)) = int8(int32(0x80) | wc>>Int32FromInt32(6)&int32(0x3f)) + **(**int8)(__ccgo_up(s)) = int8(int32(0x80) | wc&int32(0x3f)) return uint32(4) } } } } } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EILSEQ) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EILSEQ) return Uint32FromInt32(-Int32FromInt32(1)) } @@ -117804,7 +117804,7 @@ func Xwcsnrtombs(tls *TLS, dst uintptr, wcs uintptr, wn Tsize_t, n Tsize_t, st u var ws, v1 uintptr var _ /* tmp at bp+0 */ [4]int8 _, _, _, _ = cnt, l, ws, v1 - ws = *(*uintptr)(unsafe.Pointer(wcs)) + ws = **(**uintptr)(__ccgo_up(wcs)) cnt = uint32(0) if !(dst != 0) { n = uint32(0) @@ -117815,7 +117815,7 @@ func Xwcsnrtombs(tls *TLS, dst uintptr, wcs uintptr, wn Tsize_t, n Tsize_t, st u } else { v1 = dst } - l = Xwcrtomb(tls, v1, *(*Twchar_t)(unsafe.Pointer(ws)), uintptr(0)) + l = Xwcrtomb(tls, v1, **(**Twchar_t)(__ccgo_up(ws)), uintptr(0)) if l == Uint32FromInt32(-Int32FromInt32(1)) { cnt = Uint32FromInt32(-Int32FromInt32(1)) break @@ -117830,7 +117830,7 @@ func Xwcsnrtombs(tls *TLS, dst uintptr, wcs uintptr, wn Tsize_t, n Tsize_t, st u dst = dst + uintptr(l) n = n - l } - if !(*(*Twchar_t)(unsafe.Pointer(ws)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(ws)) != 0) { ws = uintptr(0) break } @@ -117839,7 +117839,7 @@ func Xwcsnrtombs(tls *TLS, dst uintptr, wcs uintptr, wn Tsize_t, n Tsize_t, st u cnt = cnt + l } if dst != 0 { - *(*uintptr)(unsafe.Pointer(wcs)) = ws + **(**uintptr)(__ccgo_up(wcs)) = ws } return cnt } @@ -117858,13 +117858,13 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize N = n if !(s != 0) { n = uint32(0) - ws2 = *(*uintptr)(unsafe.Pointer(ws)) + ws2 = **(**uintptr)(__ccgo_up(ws)) for { - if !(*(*Twchar_t)(unsafe.Pointer(ws2)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(ws2)) != 0) { break } - if Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(ws2))) >= uint32(0x80) { - l = Xwcrtomb(tls, bp, *(*Twchar_t)(unsafe.Pointer(ws2)), uintptr(0)) + if Uint32FromInt32(**(**Twchar_t)(__ccgo_up(ws2))) >= uint32(0x80) { + l = Xwcrtomb(tls, bp, **(**Twchar_t)(__ccgo_up(ws2)), uintptr(0)) if !(l+Uint32FromInt32(1) != 0) { return Uint32FromInt32(-Int32FromInt32(1)) } @@ -117880,13 +117880,13 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize return n } for n >= uint32(4) { - if Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))))-uint32(1) >= uint32(0x7f) { - if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))) != 0) { - *(*int8)(unsafe.Pointer(s)) = 0 - *(*uintptr)(unsafe.Pointer(ws)) = uintptr(0) + if Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))))-uint32(1) >= uint32(0x7f) { + if !(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))) != 0) { + **(**int8)(__ccgo_up(s)) = 0 + **(**uintptr)(__ccgo_up(ws)) = uintptr(0) return N - n } - l = Xwcrtomb(tls, s, *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))), uintptr(0)) + l = Xwcrtomb(tls, s, **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))), uintptr(0)) if !(l+Uint32FromInt32(1) != 0) { return Uint32FromInt32(-Int32FromInt32(1)) } @@ -117895,35 +117895,35 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize } else { v2 = s s = s + 1 - *(*int8)(unsafe.Pointer(v2)) = int8(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) + **(**int8)(__ccgo_up(v2)) = int8(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws))))) n = n - 1 } - *(*uintptr)(unsafe.Pointer(ws)) += 4 + **(**uintptr)(__ccgo_up(ws)) += 4 } for n != 0 { - if Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))))-uint32(1) >= uint32(0x7f) { - if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))) != 0) { - *(*int8)(unsafe.Pointer(s)) = 0 - *(*uintptr)(unsafe.Pointer(ws)) = uintptr(0) + if Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))))-uint32(1) >= uint32(0x7f) { + if !(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))) != 0) { + **(**int8)(__ccgo_up(s)) = 0 + **(**uintptr)(__ccgo_up(ws)) = uintptr(0) return N - n } - l = Xwcrtomb(tls, bp, *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))), uintptr(0)) + l = Xwcrtomb(tls, bp, **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))), uintptr(0)) if !(l+Uint32FromInt32(1) != 0) { return Uint32FromInt32(-Int32FromInt32(1)) } if l > n { return N - n } - Xwcrtomb(tls, s, *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))), uintptr(0)) + Xwcrtomb(tls, s, **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))), uintptr(0)) s = s + uintptr(l) n = n - l } else { v2 = s s = s + 1 - *(*int8)(unsafe.Pointer(v2)) = int8(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) + **(**int8)(__ccgo_up(v2)) = int8(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws))))) n = n - 1 } - *(*uintptr)(unsafe.Pointer(ws)) += 4 + **(**uintptr)(__ccgo_up(ws)) += 4 } return N } @@ -117949,7 +117949,7 @@ func Xwctob(tls *TLS, c Twint_t) (r int32) { if c < uint32(128) { return Int32FromUint32(c) } - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v1 = int32(4) } else { v1 = int32(1) @@ -118093,11 +118093,11 @@ func Xaccept4(tls *TLS, fd int32, addr uintptr, len1 uintptr, flg int32) (r1 int goto _11 _11: ret = X__syscall_ret(tls, Uint32FromInt32(v10)) - if ret >= 0 || *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(ENOSYS) && *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(EINVAL) { + if ret >= 0 || **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(ENOSYS) && **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(EINVAL) { return ret } if flg & ^(Int32FromInt32(SOCK_CLOEXEC)|Int32FromInt32(SOCK_NONBLOCK)) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } ret = Xaccept(tls, fd, addr, len1) @@ -119114,13 +119114,13 @@ func _getoffs(tls *TLS, offs uintptr, base uintptr, s uintptr) (r int32) { _, _ = i, v2 i = 0 for { - for Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))&int32(0xc0) != 0 { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))&int32(0xc0) != int32(0xc0) { + for Int32FromUint8(**(**uint8)(__ccgo_up(s)))&int32(0xc0) != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(s)))&int32(0xc0) != int32(0xc0) { return 0 } - s = base + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))&Int32FromInt32(0x3f)<= int32(0x4000) { @@ -119128,8 +119128,8 @@ func _getoffs(tls *TLS, offs uintptr, base uintptr, s uintptr) (r int32) { } v2 = i i = i + 1 - *(*int16)(unsafe.Pointer(offs + uintptr(v2)*2)) = int16(int32(s) - int32(base)) - s = s + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))+int32(1)) + **(**int16)(__ccgo_up(offs + uintptr(v2)*2)) = int16(int32(s) - int32(base)) + s = s + uintptr(Int32FromUint8(**(**uint8)(__ccgo_up(s)))+int32(1)) goto _1 _1: } @@ -119147,7 +119147,7 @@ func _getlens(tls *TLS, lens uintptr, s uintptr, l int32) (r int32) { k = 0 for { for { - if !(j < l && int32(*(*int8)(unsafe.Pointer(s + uintptr(j)))) != int32('.')) { + if !(j < l && int32(**(**int8)(__ccgo_up(s + uintptr(j)))) != int32('.')) { break } goto _2 @@ -119160,7 +119160,7 @@ func _getlens(tls *TLS, lens uintptr, s uintptr, l int32) (r int32) { } v3 = i i = i + 1 - *(*uint8)(unsafe.Pointer(lens + uintptr(v3))) = Uint8FromInt32(j - k) + **(**uint8)(__ccgo_up(lens + uintptr(v3))) = Uint8FromInt32(j - k) if j == l { return i } @@ -119190,15 +119190,15 @@ func _match(tls *TLS, offset uintptr, base uintptr, dn uintptr, end uintptr, len for { nlen = nlen - 1 v2 = nlen - l = Int32FromUint8(*(*uint8)(unsafe.Pointer(lens + uintptr(v2)))) + l = Int32FromUint8(**(**uint8)(__ccgo_up(lens + uintptr(v2)))) noff = noff - 1 v2 = noff - o = int32((*(*[128]int16)(unsafe.Pointer(bp)))[v2]) + o = int32((**(**[128]int16)(__ccgo_up(bp)))[v2]) end = end - uintptr(l) - if l != Int32FromUint8(*(*uint8)(unsafe.Pointer(base + uintptr(o)))) || Xmemcmp(tls, base+uintptr(o)+uintptr(1), end, Uint32FromInt32(l)) != 0 { + if l != Int32FromUint8(**(**uint8)(__ccgo_up(base + uintptr(o)))) || Xmemcmp(tls, base+uintptr(o)+uintptr(1), end, Uint32FromInt32(l)) != 0 { return m } - *(*int32)(unsafe.Pointer(offset)) = o + **(**int32)(__ccgo_up(offset)) = o m = m + l if nlen != 0 { m = m + 1 @@ -119229,14 +119229,14 @@ func Xdn_comp(tls *TLS, src uintptr, dst uintptr, space int32, dnptrs uintptr, l m = 0 bestlen = 0 l = Xstrnlen(tls, src, uint32(255)) - if l != 0 && int32(*(*int8)(unsafe.Pointer(src + uintptr(l-uint32(1))))) == int32('.') { + if l != 0 && int32(**(**int8)(__ccgo_up(src + uintptr(l-uint32(1))))) == int32('.') { l = l - 1 } if l > uint32(253) || space <= 0 { return -int32(1) } if !(l != 0) { - *(*uint8)(unsafe.Pointer(dst)) = uint8(0) + **(**uint8)(__ccgo_up(dst)) = uint8(0) return int32(1) } end = src + uintptr(l) @@ -119245,16 +119245,16 @@ func Xdn_comp(tls *TLS, src uintptr, dst uintptr, space int32, dnptrs uintptr, l return -int32(1) } p = dnptrs - if p != 0 && *(*uintptr)(unsafe.Pointer(p)) != 0 { + if p != 0 && **(**uintptr)(__ccgo_up(p)) != 0 { p += 4 for { - if !(*(*uintptr)(unsafe.Pointer(p)) != 0) { + if !(**(**uintptr)(__ccgo_up(p)) != 0) { break } - m = _match(tls, bp, *(*uintptr)(unsafe.Pointer(dnptrs)), *(*uintptr)(unsafe.Pointer(p)), end, bp+4, n) + m = _match(tls, bp, **(**uintptr)(__ccgo_up(dnptrs)), **(**uintptr)(__ccgo_up(p)), end, bp+4, n) if m > bestlen { bestlen = m - bestoff = *(*int32)(unsafe.Pointer(bp)) + bestoff = **(**int32)(__ccgo_up(bp)) if Uint32FromInt32(m) == l { break } @@ -119277,37 +119277,37 @@ func Xdn_comp(tls *TLS, src uintptr, dst uintptr, space int32, dnptrs uintptr, l if !(Uint32FromInt32(i) < l-Uint32FromInt32(bestlen)) { break } - *(*uint8)(unsafe.Pointer(dst + uintptr(i))) = (*(*[127]uint8)(unsafe.Pointer(bp + 4)))[j] + **(**uint8)(__ccgo_up(dst + uintptr(i))) = (**(**[127]uint8)(__ccgo_up(bp + 4)))[j] goto _2 _2: ; v3 = j j = j + 1 - i = i + (Int32FromUint8((*(*[127]uint8)(unsafe.Pointer(bp + 4)))[v3]) + int32(1)) + i = i + (Int32FromUint8((**(**[127]uint8)(__ccgo_up(bp + 4)))[v3]) + int32(1)) } /* add tail */ if bestlen != 0 { v3 = i i = i + 1 - *(*uint8)(unsafe.Pointer(dst + uintptr(v3))) = Uint8FromInt32(int32(0xc0) | bestoff>>int32(8)) + **(**uint8)(__ccgo_up(dst + uintptr(v3))) = Uint8FromInt32(int32(0xc0) | bestoff>>int32(8)) v3 = i i = i + 1 - *(*uint8)(unsafe.Pointer(dst + uintptr(v3))) = Uint8FromInt32(bestoff) + **(**uint8)(__ccgo_up(dst + uintptr(v3))) = Uint8FromInt32(bestoff) } else { v3 = i i = i + 1 - *(*uint8)(unsafe.Pointer(dst + uintptr(v3))) = uint8(0) + **(**uint8)(__ccgo_up(dst + uintptr(v3))) = uint8(0) } /* save dst pointer */ - if i > int32(2) && lastdnptr != 0 && dnptrs != 0 && *(*uintptr)(unsafe.Pointer(dnptrs)) != 0 { - for *(*uintptr)(unsafe.Pointer(p)) != 0 { + if i > int32(2) && lastdnptr != 0 && dnptrs != 0 && **(**uintptr)(__ccgo_up(dnptrs)) != 0 { + for **(**uintptr)(__ccgo_up(p)) != 0 { p += 4 } if p+uintptr(1)*4 < lastdnptr { v8 = p p += 4 - *(*uintptr)(unsafe.Pointer(v8)) = dst - *(*uintptr)(unsafe.Pointer(p)) = uintptr(0) + **(**uintptr)(__ccgo_up(v8)) = dst + **(**uintptr)(__ccgo_up(p)) = uintptr(0) } } return i @@ -119340,11 +119340,11 @@ func X__dn_expand(tls *TLS, base uintptr, end uintptr, src uintptr, dest uintptr break } /* loop invariants: p= int32(end)-int32(p) || j >= int32(dend)-int32(dest) { return -int32(1) } @@ -119375,10 +119375,10 @@ func X__dn_expand(tls *TLS, base uintptr, end uintptr, src uintptr, dest uintptr dest = dest + 1 v4 = p p = p + 1 - *(*int8)(unsafe.Pointer(v3)) = Int8FromUint8(*(*uint8)(unsafe.Pointer(v4))) + **(**int8)(__ccgo_up(v3)) = Int8FromUint8(**(**uint8)(__ccgo_up(v4))) } } else { - *(*int8)(unsafe.Pointer(dest)) = 0 + **(**int8)(__ccgo_up(dest)) = 0 if len1 < 0 { len1 = int32(p+uintptr(1)) - int32(src) } @@ -119410,20 +119410,20 @@ func Xdn_skipname(tls *TLS, s uintptr, end uintptr) (r int32) { _ = p p = s for p < end { - if !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if !(**(**uint8)(__ccgo_up(p)) != 0) { return int32(p) - int32(s) + int32(1) } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) >= int32(192) { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) >= int32(192) { if p+uintptr(1) < end { return int32(p) - int32(s) + int32(2) } else { break } } else { - if int32(end)-int32(p) < Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))+int32(1) { + if int32(end)-int32(p) < Int32FromUint8(**(**uint8)(__ccgo_up(p)))+int32(1) { break } else { - p = p + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))+int32(1)) + p = p + uintptr(Int32FromUint8(**(**uint8)(__ccgo_up(p)))+int32(1)) } } } @@ -119539,25 +119539,25 @@ func X__dns_parse(tls *TLS, r uintptr, rlen int32, __ccgo_fp_callback uintptr, c if rlen < int32(12) { return -int32(1) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 3)))&int32(15) != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(r + 3)))&int32(15) != 0 { return 0 } p = r + uintptr(12) - qdcount = Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 4)))*int32(256) + Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 5))) - ancount = Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 6)))*int32(256) + Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 7))) + qdcount = Int32FromUint8(**(**uint8)(__ccgo_up(r + 4)))*int32(256) + Int32FromUint8(**(**uint8)(__ccgo_up(r + 5))) + ancount = Int32FromUint8(**(**uint8)(__ccgo_up(r + 6)))*int32(256) + Int32FromUint8(**(**uint8)(__ccgo_up(r + 7))) for { v1 = qdcount qdcount = qdcount - 1 if !(v1 != 0) { break } - for int32(p)-int32(r) < rlen && uint32(*(*uint8)(unsafe.Pointer(p)))-uint32(1) < uint32(127) { + for int32(p)-int32(r) < rlen && uint32(**(**uint8)(__ccgo_up(p)))-uint32(1) < uint32(127) { p = p + 1 } if p > r+uintptr(rlen)-uintptr(6) { return -int32(1) } - p = p + uintptr(int32(5)+BoolInt32(!!(*(*uint8)(unsafe.Pointer(p)) != 0))) + p = p + uintptr(int32(5)+BoolInt32(!!(**(**uint8)(__ccgo_up(p)) != 0))) } for { v1 = ancount @@ -119565,18 +119565,18 @@ func X__dns_parse(tls *TLS, r uintptr, rlen int32, __ccgo_fp_callback uintptr, c if !(v1 != 0) { break } - for int32(p)-int32(r) < rlen && uint32(*(*uint8)(unsafe.Pointer(p)))-uint32(1) < uint32(127) { + for int32(p)-int32(r) < rlen && uint32(**(**uint8)(__ccgo_up(p)))-uint32(1) < uint32(127) { p = p + 1 } if p > r+uintptr(rlen)-uintptr(12) { return -int32(1) } - p = p + uintptr(int32(1)+BoolInt32(!!(*(*uint8)(unsafe.Pointer(p)) != 0))) - len1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 8)))*int32(256) + Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 9))) + p = p + uintptr(int32(1)+BoolInt32(!!(**(**uint8)(__ccgo_up(p)) != 0))) + len1 = Int32FromUint8(**(**uint8)(__ccgo_up(p + 8)))*int32(256) + Int32FromUint8(**(**uint8)(__ccgo_up(p + 9))) if len1+int32(10) > int32(r+uintptr(rlen))-int32(p) { return -int32(1) } - if (*(*func(*TLS, uintptr, int32, uintptr, int32, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_callback})))(tls, ctx, Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))), p+uintptr(10), len1, r, rlen) < 0 { + if (*(*func(*TLS, uintptr, int32, uintptr, int32, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_callback})))(tls, ctx, Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))), p+uintptr(10), len1, r, rlen) < 0 { return -int32(1) } p = p + uintptr(int32(10)+len1) @@ -119918,27 +119918,27 @@ func Xether_aton_r(tls *TLS, x uintptr, p_a uintptr) (r uintptr) { break } if ii != 0 { - if int32(*(*int8)(unsafe.Pointer(x))) != int32(':') { + if int32(**(**int8)(__ccgo_up(x))) != int32(':') { return uintptr(0) } else { x = x + 1 } } n = Xstrtoul(tls, x, bp+8, int32(16)) - x = *(*uintptr)(unsafe.Pointer(bp + 8)) + x = **(**uintptr)(__ccgo_up(bp + 8)) if n > uint32(0xFF) { return uintptr(0) } /* bad byte */ - *(*Tuint8_t)(unsafe.Pointer(bp + uintptr(ii))) = uint8(n) + **(**Tuint8_t)(__ccgo_up(bp + uintptr(ii))) = uint8(n) goto _1 _1: ; ii = ii + 1 } - if int32(*(*int8)(unsafe.Pointer(x))) != 0 { + if int32(**(**int8)(__ccgo_up(x))) != 0 { return uintptr(0) } /* bad format */ - *(*Tether_addr)(unsafe.Pointer(p_a)) = *(*Tether_addr)(unsafe.Pointer(bp)) + **(**Tether_addr)(__ccgo_up(p_a)) = **(**Tether_addr)(__ccgo_up(bp)) return p_a } @@ -119973,7 +119973,7 @@ func Xether_ntoa_r(tls *TLS, p_a uintptr, x uintptr) (r uintptr) { } else { v2 = __ccgo_ts + 891 } - x = x + uintptr(Xsprintf(tls, x, v2, VaList(bp+8, Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(p_a + uintptr(ii))))))) + x = x + uintptr(Xsprintf(tls, x, v2, VaList(bp+8, Int32FromUint8(**(**Tuint8_t)(__ccgo_up(p_a + uintptr(ii))))))) goto _1 _1: ; @@ -120058,11 +120058,11 @@ func Xgai_strerror(tls *TLS, ecode int32) (r uintptr) { s = uintptr(unsafe.Pointer(&_msgs)) ecode = ecode + 1 for { - if !(ecode != 0 && *(*int8)(unsafe.Pointer(s)) != 0) { + if !(ecode != 0 && **(**int8)(__ccgo_up(s)) != 0) { break } for { - if !(*(*int8)(unsafe.Pointer(s)) != 0) { + if !(**(**int8)(__ccgo_up(s)) != 0) { break } goto _2 @@ -120076,7 +120076,7 @@ func Xgai_strerror(tls *TLS, ecode int32) (r uintptr) { ecode = ecode + 1 s = s + 1 } - if !(*(*int8)(unsafe.Pointer(s)) != 0) { + if !(**(**int8)(__ccgo_up(s)) != 0) { s = s + 1 } return X__lctrans_cur(tls, s) @@ -120152,15 +120152,15 @@ func Xgetaddrinfo(tls *TLS, host uintptr, serv uintptr, hint uintptr, res uintpt if s >= 0 { _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp+1608) r = Xconnect(tls, s, ta[i], tl[i]) - saved_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 1608)), uintptr(0)) + saved_errno = **(**int32)(__ccgo_up(X__errno_location(tls))) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 1608)), uintptr(0)) Xclose(tls, s) if !(r != 0) { goto _1 } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = saved_errno + **(**int32)(__ccgo_up(X__errno_location(tls))) = saved_errno } - switch *(*int32)(unsafe.Pointer(X__errno_location(tls))) { + switch **(**int32)(__ccgo_up(X__errno_location(tls))) { case int32(EADDRNOTAVAIL): fallthrough case int32(EAFNOSUPPORT): @@ -120218,32 +120218,32 @@ func Xgetaddrinfo(tls *TLS, host uintptr, serv uintptr, hint uintptr, res uintpt if !(j < nservs) { break } - (*(*Taibuf)(unsafe.Pointer(out + uintptr(k)*68))).Fslot = int16(k) - if (*(*[48]Taddress)(unsafe.Pointer(bp + 8)))[i].Ffamily == int32(PF_INET) { + (**(**Taibuf)(__ccgo_up(out + uintptr(k)*68))).Fslot = int16(k) + if (**(**[48]Taddress)(__ccgo_up(bp + 8)))[i].Ffamily == int32(PF_INET) { v5 = uint32(16) } else { v5 = uint32(28) } - (*(*Taibuf)(unsafe.Pointer(out + uintptr(k)*68))).Fai = Taddrinfo{ - Fai_family: (*(*[48]Taddress)(unsafe.Pointer(bp + 8)))[i].Ffamily, - Fai_socktype: Int32FromUint8((*(*[2]Tservice)(unsafe.Pointer(bp)))[j].Fsocktype), - Fai_protocol: Int32FromUint8((*(*[2]Tservice)(unsafe.Pointer(bp)))[j].Fproto), + (**(**Taibuf)(__ccgo_up(out + uintptr(k)*68))).Fai = Taddrinfo{ + Fai_family: (**(**[48]Taddress)(__ccgo_up(bp + 8)))[i].Ffamily, + Fai_socktype: Int32FromUint8((**(**[2]Tservice)(__ccgo_up(bp)))[j].Fsocktype), + Fai_protocol: Int32FromUint8((**(**[2]Tservice)(__ccgo_up(bp)))[j].Fproto), Fai_addrlen: v5, Fai_addr: out + uintptr(k)*68 + 32, Fai_canonname: outcanon, } if k != 0 { - (*(*Taibuf)(unsafe.Pointer(out + uintptr(k-int32(1))*68))).Fai.Fai_next = out + uintptr(k)*68 + (**(**Taibuf)(__ccgo_up(out + uintptr(k-int32(1))*68))).Fai.Fai_next = out + uintptr(k)*68 } - switch (*(*[48]Taddress)(unsafe.Pointer(bp + 8)))[i].Ffamily { + switch (**(**[48]Taddress)(__ccgo_up(bp + 8)))[i].Ffamily { case int32(PF_INET): *(*Tsa_family_t)(unsafe.Pointer(out + uintptr(k)*68 + 32)) = uint16(PF_INET) - *(*Tin_port_t)(unsafe.Pointer(out + uintptr(k)*68 + 32 + 2)) = Xhtons(tls, (*(*[2]Tservice)(unsafe.Pointer(bp)))[j].Fport) + *(*Tin_port_t)(unsafe.Pointer(out + uintptr(k)*68 + 32 + 2)) = Xhtons(tls, (**(**[2]Tservice)(__ccgo_up(bp)))[j].Fport) Xmemcpy(tls, out+uintptr(k)*68+32+4, bp+8+uintptr(i)*28+8, uint32(4)) case int32(PF_INET6): *(*Tsa_family_t)(unsafe.Pointer(out + uintptr(k)*68 + 32)) = uint16(PF_INET6) - *(*Tin_port_t)(unsafe.Pointer(out + uintptr(k)*68 + 32 + 2)) = Xhtons(tls, (*(*[2]Tservice)(unsafe.Pointer(bp)))[j].Fport) - *(*Tuint32_t)(unsafe.Pointer(out + uintptr(k)*68 + 32 + 24)) = (*(*[48]Taddress)(unsafe.Pointer(bp + 8)))[i].Fscopeid + *(*Tin_port_t)(unsafe.Pointer(out + uintptr(k)*68 + 32 + 2)) = Xhtons(tls, (**(**[2]Tservice)(__ccgo_up(bp)))[j].Fport) + *(*Tuint32_t)(unsafe.Pointer(out + uintptr(k)*68 + 32 + 24)) = (**(**[48]Taddress)(__ccgo_up(bp + 8)))[i].Fscopeid Xmemcpy(tls, out+uintptr(k)*68+32+8, bp+8+uintptr(i)*28+8, uint32(16)) break } @@ -120258,8 +120258,8 @@ func Xgetaddrinfo(tls *TLS, host uintptr, serv uintptr, hint uintptr, res uintpt ; i = i + 1 } - (*(*Taibuf)(unsafe.Pointer(out))).Fref = int16(nais) - *(*uintptr)(unsafe.Pointer(res)) = out + (**(**Taibuf)(__ccgo_up(out))).Fref = int16(nais) + **(**uintptr)(__ccgo_up(res)) = out return 0 } @@ -120390,12 +120390,12 @@ func Xgethostbyaddr(tls *TLS, a uintptr, l Tsocklen_t, af int32) (r uintptr) { size = size + (size + uint32(1)) _h = Xmalloc(tls, size) if !(_h != 0) { - *(*int32)(unsafe.Pointer(X__h_errno_location(tls))) = int32(NO_RECOVERY) + **(**int32)(__ccgo_up(X__h_errno_location(tls))) = int32(NO_RECOVERY) return uintptr(0) } err = Xgethostbyaddr_r(tls, a, l, af, _h, _h+UintptrFromInt32(1)*20, size-uint32(20), bp, X__h_errno_location(tls)) } - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } var _h uintptr @@ -120432,7 +120432,7 @@ func Xgethostbyaddr_r(tls *TLS, a uintptr, l Tsocklen_t, af int32, h uintptr, bu v1 = uint32(16) } sl = v1 - *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) + **(**uintptr)(__ccgo_up(res)) = uintptr(0) /* Load address argument into sockaddr structure */ if af == int32(PF_INET6) && l == uint32(16) { Xmemcpy(tls, bp+8, a, uint32(16)) @@ -120440,7 +120440,7 @@ func Xgethostbyaddr_r(tls *TLS, a uintptr, l Tsocklen_t, af int32, h uintptr, bu if af == int32(PF_INET) && l == uint32(4) { Xmemcpy(tls, bp+4, a, uint32(4)) } else { - *(*int32)(unsafe.Pointer(err)) = int32(NO_RECOVERY) + **(**int32)(__ccgo_up(err)) = int32(NO_RECOVERY) return int32(EINVAL) } } @@ -120458,33 +120458,33 @@ func Xgethostbyaddr_r(tls *TLS, a uintptr, l Tsocklen_t, af int32, h uintptr, bu buf = buf + uintptr(Uint32FromInt32(2)*Uint32FromInt64(4)) (*Thostent)(unsafe.Pointer(h)).Fh_aliases = buf buf = buf + uintptr(Uint32FromInt32(2)*Uint32FromInt64(4)) - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list)) = buf - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list)), a, l) + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_addr_list)) = buf + Xmemcpy(tls, **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_addr_list)), a, l) buf = buf + uintptr(l) - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + 1*4)) = uintptr(0) - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) = buf - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*4)) = uintptr(0) + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + 1*4)) = uintptr(0) + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) = buf + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*4)) = uintptr(0) switch Xgetnameinfo(tls, bp, sl, buf, buflen, uintptr(0), uint32(0), 0) { case -int32(3): - *(*int32)(unsafe.Pointer(err)) = int32(TRY_AGAIN) + **(**int32)(__ccgo_up(err)) = int32(TRY_AGAIN) return int32(EAGAIN) case -int32(12): return int32(ERANGE) default: fallthrough case -int32(4): - *(*int32)(unsafe.Pointer(err)) = int32(NO_RECOVERY) + **(**int32)(__ccgo_up(err)) = int32(NO_RECOVERY) return int32(EBADMSG) case -int32(11): - *(*int32)(unsafe.Pointer(err)) = int32(NO_RECOVERY) - return *(*int32)(unsafe.Pointer(X__errno_location(tls))) + **(**int32)(__ccgo_up(err)) = int32(NO_RECOVERY) + return **(**int32)(__ccgo_up(X__errno_location(tls))) case 0: break } (*Thostent)(unsafe.Pointer(h)).Fh_addrtype = af (*Thostent)(unsafe.Pointer(h)).Fh_length = Int32FromUint32(l) - (*Thostent)(unsafe.Pointer(h)).Fh_name = *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) - *(*uintptr)(unsafe.Pointer(res)) = h + (*Thostent)(unsafe.Pointer(h)).Fh_name = **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) + **(**uintptr)(__ccgo_up(res)) = h return 0 } @@ -120513,12 +120513,12 @@ func Xgethostbyname2(tls *TLS, name uintptr, af int32) (r uintptr) { size = size + (size + uint32(1)) _h1 = Xmalloc(tls, size) if !(_h1 != 0) { - *(*int32)(unsafe.Pointer(X__h_errno_location(tls))) = int32(NO_RECOVERY) + **(**int32)(__ccgo_up(X__h_errno_location(tls))) = int32(NO_RECOVERY) return uintptr(0) } err = Xgethostbyname2_r(tls, name, af, _h1, _h1+UintptrFromInt32(1)*20, size-uint32(20), bp, X__h_errno_location(tls)) } - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } var _h1 uintptr @@ -120536,27 +120536,27 @@ func Xgethostbyname2_r(tls *TLS, name uintptr, af int32, h uintptr, buf uintptr, var _ /* addrs at bp+0 */ [48]Taddress var _ /* canon at bp+1344 */ [256]int8 _, _, _, _, _, _ = align, cnt, i, need, v1, v3 - *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) + **(**uintptr)(__ccgo_up(res)) = uintptr(0) cnt = X__lookup_name(tls, bp, bp+1344, name, af, int32(AI_CANONNAME)) if cnt < 0 { switch cnt { case -int32(2): - *(*int32)(unsafe.Pointer(err)) = int32(HOST_NOT_FOUND) + **(**int32)(__ccgo_up(err)) = int32(HOST_NOT_FOUND) return 0 case -int32(5): - *(*int32)(unsafe.Pointer(err)) = int32(NO_DATA) + **(**int32)(__ccgo_up(err)) = int32(NO_DATA) return 0 case -int32(3): - *(*int32)(unsafe.Pointer(err)) = int32(TRY_AGAIN) + **(**int32)(__ccgo_up(err)) = int32(TRY_AGAIN) return int32(EAGAIN) default: fallthrough case -int32(4): - *(*int32)(unsafe.Pointer(err)) = int32(NO_RECOVERY) + **(**int32)(__ccgo_up(err)) = int32(NO_RECOVERY) return int32(EBADMSG) case -int32(11): - *(*int32)(unsafe.Pointer(err)) = int32(NO_RECOVERY) - return *(*int32)(unsafe.Pointer(X__errno_location(tls))) + **(**int32)(__ccgo_up(err)) = int32(NO_RECOVERY) + return **(**int32)(__ccgo_up(X__errno_location(tls))) } } (*Thostent)(unsafe.Pointer(h)).Fh_addrtype = af @@ -120586,29 +120586,29 @@ func Xgethostbyname2_r(tls *TLS, name uintptr, af int32, h uintptr, buf uintptr, if !(i < cnt) { break } - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*4)) = buf + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*4)) = buf buf = buf + uintptr((*Thostent)(unsafe.Pointer(h)).Fh_length) - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*4)), bp+uintptr(i)*28+8, Uint32FromInt32((*Thostent)(unsafe.Pointer(h)).Fh_length)) + Xmemcpy(tls, **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*4)), bp+uintptr(i)*28+8, Uint32FromInt32((*Thostent)(unsafe.Pointer(h)).Fh_length)) goto _2 _2: ; i = i + 1 } - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*4)) = uintptr(0) + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*4)) = uintptr(0) v3 = buf - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) = v3 + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) = v3 (*Thostent)(unsafe.Pointer(h)).Fh_name = v3 Xstrcpy(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name, bp+1344) buf = buf + uintptr(_strlen(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name)+uint32(1)) if Xstrcmp(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name, name) != 0 { - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*4)) = buf - Xstrcpy(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*4)), name) - buf = buf + uintptr(_strlen(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*4)))+uint32(1)) + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*4)) = buf + Xstrcpy(tls, **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*4)), name) + buf = buf + uintptr(_strlen(tls, **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*4)))+uint32(1)) } else { - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*4)) = uintptr(0) + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*4)) = uintptr(0) } - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 2*4)) = uintptr(0) - *(*uintptr)(unsafe.Pointer(res)) = h + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 2*4)) = uintptr(0) + **(**uintptr)(__ccgo_up(res)) = h return 0 } @@ -120836,7 +120836,7 @@ func _copy_addr(tls *TLS, r uintptr, af int32, sa uintptr, addr uintptr, addrlen case int32(PF_INET6): dst = sa + 8 len1 = int32(16) - if Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(addr))) == int32(0xfe) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(addr + 1)))&int32(0xc0) == int32(0x80) || Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(addr))) == int32(0xff) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(addr + 1)))&int32(0xf) == int32(0x2) { + if Int32FromUint8(**(**Tuint8_t)(__ccgo_up(addr))) == int32(0xfe) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(addr + 1)))&int32(0xc0) == int32(0x80) || Int32FromUint8(**(**Tuint8_t)(__ccgo_up(addr))) == int32(0xff) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(addr + 1)))&int32(0xf) == int32(0x2) { (*(*Tsockaddr_in6)(unsafe.Pointer(sa))).Fsin6_scope_id = Uint32FromInt32(ifindex) } default: @@ -120847,7 +120847,7 @@ func _copy_addr(tls *TLS, r uintptr, af int32, sa uintptr, addr uintptr, addrlen } (*Tsockany)(unsafe.Pointer(sa)).Fsa.Fsa_family = Uint16FromInt32(af) Xmemcpy(tls, dst, addr, Uint32FromInt32(len1)) - *(*uintptr)(unsafe.Pointer(r)) = sa + **(**uintptr)(__ccgo_up(r)) = sa } func _gen_netmask(tls *TLS, r uintptr, af int32, sa uintptr, prefixlen int32) { @@ -120856,7 +120856,7 @@ func _gen_netmask(tls *TLS, r uintptr, af int32, sa uintptr, prefixlen int32) { var i, v1 int32 var _ /* addr at bp+0 */ [16]Tuint8_t _, _ = i, v1 - *(*[16]Tuint8_t)(unsafe.Pointer(bp)) = [16]Tuint8_t{} + **(**[16]Tuint8_t)(__ccgo_up(bp)) = [16]Tuint8_t{} if Uint32FromInt32(prefixlen) > Uint32FromInt32(8)*Uint32FromInt64(16) { prefixlen = Int32FromUint32(Uint32FromInt32(8) * Uint32FromInt64(16)) } @@ -120865,7 +120865,7 @@ func _gen_netmask(tls *TLS, r uintptr, af int32, sa uintptr, prefixlen int32) { if Uint32FromInt32(i) < uint32(16) { v1 = i i = i + 1 - (*(*[16]Tuint8_t)(unsafe.Pointer(bp)))[v1] = Uint8FromInt32(int32(0xff) << (int32(8) - prefixlen%int32(8))) + (**(**[16]Tuint8_t)(__ccgo_up(bp)))[v1] = Uint8FromInt32(int32(0xff) << (int32(8) - prefixlen%int32(8))) } _copy_addr(tls, r, af, sa, bp, uint32(16), 0) } @@ -120879,7 +120879,7 @@ func _copy_lladdr(tls *TLS, r uintptr, sa uintptr, addr uintptr, addrlen Tsize_t (*(*Tsockaddr_ll_hack)(unsafe.Pointer(sa))).Fsll_hatype = hatype (*(*Tsockaddr_ll_hack)(unsafe.Pointer(sa))).Fsll_halen = uint8(addrlen) Xmemcpy(tls, sa+12, addr, addrlen) - *(*uintptr)(unsafe.Pointer(r)) = sa + **(**uintptr)(__ccgo_up(r)) = sa } func _netlink_msg_to_ifaddr(tls *TLS, pctx uintptr, h uintptr) (r int32) { @@ -120908,7 +120908,7 @@ func _netlink_msg_to_ifaddr(tls *TLS, pctx uintptr, h uintptr) (r int32) { rta = rta + uintptr((Int32FromUint16((*Trtattr)(unsafe.Pointer(rta)).Frta_len)+Int32FromInt32(3)) & ^Int32FromInt32(3)) } } else { - ifs0 = *(*uintptr)(unsafe.Pointer(ctx + 8 + uintptr((*Tifaddrmsg)(unsafe.Pointer(ifa)).Fifa_index%uint32(IFADDRS_HASH_SIZE))*4)) + ifs0 = **(**uintptr)(__ccgo_up(ctx + 8 + uintptr((*Tifaddrmsg)(unsafe.Pointer(ifa)).Fifa_index%uint32(IFADDRS_HASH_SIZE))*4)) for { if !(ifs0 != 0) { break @@ -120959,8 +120959,8 @@ func _netlink_msg_to_ifaddr(tls *TLS, pctx uintptr, h uintptr) (r int32) { } if (*Tifaddrs_storage)(unsafe.Pointer(ifs)).Fifa.Fifa_name != 0 { bucket = (*Tifaddrs_storage)(unsafe.Pointer(ifs)).Findex % uint32(IFADDRS_HASH_SIZE) - (*Tifaddrs_storage)(unsafe.Pointer(ifs)).Fhash_next = *(*uintptr)(unsafe.Pointer(ctx + 8 + uintptr(bucket)*4)) - *(*uintptr)(unsafe.Pointer(ctx + 8 + uintptr(bucket)*4)) = ifs + (*Tifaddrs_storage)(unsafe.Pointer(ifs)).Fhash_next = **(**uintptr)(__ccgo_up(ctx + 8 + uintptr(bucket)*4)) + **(**uintptr)(__ccgo_up(ctx + 8 + uintptr(bucket)*4)) = ifs } } else { (*Tifaddrs_storage)(unsafe.Pointer(ifs)).Fifa.Fifa_name = (*Tifaddrs_storage)(unsafe.Pointer(ifs0)).Fifa.Fifa_name @@ -121035,7 +121035,7 @@ func Xgetifaddrs(tls *TLS, ifap uintptr) (r1 int32) { Xmemset(tls, ctx, 0, uint32(264)) r = X__rtnetlink_enumerate(tls, PF_UNSPEC, PF_UNSPEC, __ccgo_fp(_netlink_msg_to_ifaddr), ctx) if r == 0 { - *(*uintptr)(unsafe.Pointer(ifap)) = (*Tifaddrs_ctx)(unsafe.Pointer(ctx)).Ffirst + **(**uintptr)(__ccgo_up(ifap)) = (*Tifaddrs_ctx)(unsafe.Pointer(ctx)).Ffirst } else { Xfreeifaddrs(tls, (*Tifaddrs_ctx)(unsafe.Pointer(ctx)).Ffirst) } @@ -121050,11 +121050,11 @@ func _itoa(tls *TLS, p uintptr, x uint32) (r uintptr) { p = p + uintptr(Uint32FromInt32(3)*Uint32FromInt64(4)) p = p - 1 v1 = p - *(*int8)(unsafe.Pointer(v1)) = 0 + **(**int8)(__ccgo_up(v1)) = 0 for cond := true; cond; cond = x != 0 { p = p - 1 v1 = p - *(*int8)(unsafe.Pointer(v1)) = Int8FromUint32(uint32('0') + x%uint32(10)) + **(**int8)(__ccgo_up(v1)) = Int8FromUint32(uint32('0') + x%uint32(10)) x = x / uint32(10) } return p @@ -121063,7 +121063,7 @@ func _itoa(tls *TLS, p uintptr, x uint32) (r uintptr) { func _mkptr4(tls *TLS, s uintptr, ip uintptr) { bp := tls.Alloc(48) defer tls.Free(48) - Xsprintf(tls, s, __ccgo_ts+897, VaList(bp+8, Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + 3))), Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + 2))), Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + 1))), Int32FromUint8(*(*uint8)(unsafe.Pointer(ip))))) + Xsprintf(tls, s, __ccgo_ts+897, VaList(bp+8, Int32FromUint8(**(**uint8)(__ccgo_up(ip + 3))), Int32FromUint8(**(**uint8)(__ccgo_up(ip + 2))), Int32FromUint8(**(**uint8)(__ccgo_up(ip + 1))), Int32FromUint8(**(**uint8)(__ccgo_up(ip))))) } func _mkptr6(tls *TLS, s uintptr, ip uintptr) { @@ -121077,16 +121077,16 @@ func _mkptr6(tls *TLS, s uintptr, ip uintptr) { } v2 = s s = s + 1 - *(*int8)(unsafe.Pointer(v2)) = _xdigits[Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + uintptr(i))))&int32(15)] + **(**int8)(__ccgo_up(v2)) = _xdigits[Int32FromUint8(**(**uint8)(__ccgo_up(ip + uintptr(i))))&int32(15)] v2 = s s = s + 1 - *(*int8)(unsafe.Pointer(v2)) = int8('.') + **(**int8)(__ccgo_up(v2)) = int8('.') v2 = s s = s + 1 - *(*int8)(unsafe.Pointer(v2)) = _xdigits[Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + uintptr(i))))>>int32(4)] + **(**int8)(__ccgo_up(v2)) = _xdigits[Int32FromUint8(**(**uint8)(__ccgo_up(ip + uintptr(i))))>>int32(4)] v2 = s s = s + 1 - *(*int8)(unsafe.Pointer(v2)) = int8('.') + **(**int8)(__ccgo_up(v2)) = int8('.') goto _1 _1: ; @@ -121124,13 +121124,13 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int if v1 != 0 { v2 = p p = p + 1 - *(*int8)(unsafe.Pointer(v2)) = int8('\n') - *(*int8)(unsafe.Pointer(p)) = Int8FromInt32(0) + **(**int8)(__ccgo_up(v2)) = int8('\n') + **(**int8)(__ccgo_up(p)) = Int8FromInt32(0) } p = bp for { - if v7 = *(*int8)(unsafe.Pointer(p)) != 0; v7 { - v4 = int32(*(*int8)(unsafe.Pointer(p))) + if v7 = **(**int8)(__ccgo_up(p)) != 0; v7 { + v4 = int32(**(**int8)(__ccgo_up(p))) v5 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _6 _6: @@ -121143,26 +121143,26 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int ; p = p + 1 } - if !(*(*int8)(unsafe.Pointer(p)) != 0) { + if !(**(**int8)(__ccgo_up(p)) != 0) { continue } v1 = p p = p + 1 - *(*int8)(unsafe.Pointer(v1)) = 0 + **(**int8)(__ccgo_up(v1)) = 0 if X__lookup_ipliteral(tls, bp+1560, bp, PF_UNSPEC) <= 0 { continue } - if (*(*Taddress)(unsafe.Pointer(bp + 1560))).Ffamily == int32(PF_INET) { + if (**(**Taddress)(__ccgo_up(bp + 1560))).Ffamily == int32(PF_INET) { Xmemcpy(tls, bp+1560+8+uintptr(12), bp+1560+8, uint32(4)) Xmemcpy(tls, bp+1560+8, __ccgo_ts+942, uint32(12)) - (*(*Taddress)(unsafe.Pointer(bp + 1560))).Fscopeid = uint32(0) + (**(**Taddress)(__ccgo_up(bp + 1560))).Fscopeid = uint32(0) } - if Xmemcmp(tls, a, bp+1560+8, uint32(16)) != 0 || (*(*Taddress)(unsafe.Pointer(bp + 1560))).Fscopeid != scopeid { + if Xmemcmp(tls, a, bp+1560+8, uint32(16)) != 0 || (**(**Taddress)(__ccgo_up(bp + 1560))).Fscopeid != scopeid { continue } for { - if v7 = *(*int8)(unsafe.Pointer(p)) != 0; v7 { - v4 = int32(*(*int8)(unsafe.Pointer(p))) + if v7 = **(**int8)(__ccgo_up(p)) != 0; v7 { + v4 = int32(**(**int8)(__ccgo_up(p))) v5 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _12 _12: @@ -121177,8 +121177,8 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int } z = p for { - if v7 = *(*int8)(unsafe.Pointer(z)) != 0; v7 { - v4 = int32(*(*int8)(unsafe.Pointer(z))) + if v7 = **(**int8)(__ccgo_up(z)) != 0; v7 { + v4 = int32(**(**int8)(__ccgo_up(z))) v5 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _17 _17: @@ -121191,7 +121191,7 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int ; z = z + 1 } - *(*int8)(unsafe.Pointer(z)) = 0 + **(**int8)(__ccgo_up(z)) = 0 if int32(z)-int32(p) < int32(256) { Xmemcpy(tls, buf, p, Uint32FromInt32(int32(z)-int32(p)+int32(1))) break @@ -121222,13 +121222,13 @@ func _reverse_services(tls *TLS, buf uintptr, port int32, dgram int32) { if v1 != 0 { v2 = p p = p + 1 - *(*int8)(unsafe.Pointer(v2)) = int8('\n') - *(*int8)(unsafe.Pointer(p)) = Int8FromInt32(0) + **(**int8)(__ccgo_up(v2)) = int8('\n') + **(**int8)(__ccgo_up(p)) = Int8FromInt32(0) } p = bp for { - if v7 = *(*int8)(unsafe.Pointer(p)) != 0; v7 { - v4 = int32(*(*int8)(unsafe.Pointer(p))) + if v7 = **(**int8)(__ccgo_up(p)) != 0; v7 { + v4 = int32(**(**int8)(__ccgo_up(p))) v5 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _6 _6: @@ -121241,20 +121241,20 @@ func _reverse_services(tls *TLS, buf uintptr, port int32, dgram int32) { ; p = p + 1 } - if !(*(*int8)(unsafe.Pointer(p)) != 0) { + if !(**(**int8)(__ccgo_up(p)) != 0) { continue } v1 = p p = p + 1 - *(*int8)(unsafe.Pointer(v1)) = 0 + **(**int8)(__ccgo_up(v1)) = 0 svport = Xstrtoul(tls, p, bp+128, int32(10)) - if svport != Uint32FromInt32(port) || *(*uintptr)(unsafe.Pointer(bp + 128)) == p { + if svport != Uint32FromInt32(port) || **(**uintptr)(__ccgo_up(bp + 128)) == p { continue } - if dgram != 0 && Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(bp + 128)), __ccgo_ts+969, uint32(4)) != 0 { + if dgram != 0 && Xstrncmp(tls, **(**uintptr)(__ccgo_up(bp + 128)), __ccgo_ts+969, uint32(4)) != 0 { continue } - if !(dgram != 0) && Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(bp + 128)), __ccgo_ts+974, uint32(4)) != 0 { + if !(dgram != 0) && Xstrncmp(tls, **(**uintptr)(__ccgo_up(bp + 128)), __ccgo_ts+974, uint32(4)) != 0 { continue } if int32(p)-t__predefined_ptrdiff_t(bp) > int32(32) { @@ -121271,7 +121271,7 @@ func _dns_parse_callback(tls *TLS, c uintptr, rr int32, data uintptr, len1 int32 return 0 } if X__dn_expand(tls, packet, packet+uintptr(plen), data, c, int32(256)) <= 0 { - *(*int8)(unsafe.Pointer(c)) = 0 + **(**int8)(__ccgo_up(c)) = 0 } return 0 } @@ -121317,15 +121317,15 @@ func Xgetnameinfo(tls *TLS, sa uintptr, sl Tsocklen_t, node uintptr, nodelen Tso return -int32(6) } if node != 0 && nodelen != 0 { - (*(*[256]int8)(unsafe.Pointer(bp + 78)))[0] = 0 + (**(**[256]int8)(__ccgo_up(bp + 78)))[0] = 0 if !(flags&Int32FromInt32(NI_NUMERICHOST) != 0) { _reverse_hosts(tls, bp+78, a, scopeid, af) } - if !(*(*int8)(unsafe.Pointer(bp + 78)) != 0) && !(flags&Int32FromInt32(NI_NUMERICHOST) != 0) { + if !(**(**int8)(__ccgo_up(bp + 78)) != 0) && !(flags&Int32FromInt32(NI_NUMERICHOST) != 0) { qlen = X__res_mkquery(tls, 0, bp, int32(1), int32(RR_PTR), uintptr(0), 0, uintptr(0), bp+347, int32(96)) - (*(*[96]uint8)(unsafe.Pointer(bp + 347)))[int32(3)] = uint8(0) /* don't need AD flag */ + (**(**[96]uint8)(__ccgo_up(bp + 347)))[int32(3)] = uint8(0) /* don't need AD flag */ rlen = X__res_send(tls, bp+347, qlen, bp+443, int32(512)) - (*(*[256]int8)(unsafe.Pointer(bp + 78)))[0] = 0 + (**(**[256]int8)(__ccgo_up(bp + 78)))[0] = 0 if rlen > 0 { if Uint32FromInt32(rlen) > uint32(512) { rlen = int32(512) @@ -121333,14 +121333,14 @@ func Xgetnameinfo(tls *TLS, sa uintptr, sl Tsocklen_t, node uintptr, nodelen Tso X__dns_parse(tls, bp+443, rlen, __ccgo_fp(_dns_parse_callback), bp+78) } } - if !(*(*int8)(unsafe.Pointer(bp + 78)) != 0) { + if !(**(**int8)(__ccgo_up(bp + 78)) != 0) { if flags&int32(NI_NAMEREQD) != 0 { return -int32(2) } Xinet_ntop(tls, af, a, bp+78, uint32(256)) if scopeid != 0 { p = uintptr(0) - if !(flags&Int32FromInt32(NI_NUMERICSCOPE) != 0) && (Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a))) == int32(0xfe) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 1)))&int32(0xc0) == int32(0x80) || Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a))) == int32(0xff) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 1)))&int32(0xf) == int32(0x2)) { + if !(flags&Int32FromInt32(NI_NUMERICSCOPE) != 0) && (Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a))) == int32(0xfe) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 1)))&int32(0xc0) == int32(0x80) || Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a))) == int32(0xff) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 1)))&int32(0xf) == int32(0x2)) { p = Xif_indextoname(tls, scopeid, bp+955+uintptr(1)) } if !(p != 0) { @@ -121348,7 +121348,7 @@ func Xgetnameinfo(tls *TLS, sa uintptr, sl Tsocklen_t, node uintptr, nodelen Tso } p = p - 1 v1 = p - *(*int8)(unsafe.Pointer(v1)) = int8('%') + **(**int8)(__ccgo_up(v1)) = int8('%') Xstrcat(tls, bp+78, p) } } @@ -121360,11 +121360,11 @@ func Xgetnameinfo(tls *TLS, sa uintptr, sl Tsocklen_t, node uintptr, nodelen Tso if serv != 0 && servlen != 0 { p1 = bp + 78 port = Int32FromUint16(Xntohs(tls, (*Tsockaddr_in)(unsafe.Pointer(sa)).Fsin_port)) - (*(*[256]int8)(unsafe.Pointer(bp + 78)))[0] = 0 + (**(**[256]int8)(__ccgo_up(bp + 78)))[0] = 0 if !(flags&Int32FromInt32(NI_NUMERICSERV) != 0) { _reverse_services(tls, bp+78, port, flags&int32(NI_DGRAM)) } - if !(*(*int8)(unsafe.Pointer(p1)) != 0) { + if !(**(**int8)(__ccgo_up(p1)) != 0) { p1 = _itoa(tls, bp+334, Uint32FromInt32(port)) } if _strlen(tls, p1) >= servlen { @@ -121462,11 +121462,11 @@ func Xgetservbyname_r(tls *TLS, name uintptr, prots uintptr, se uintptr, buf uin var _ /* end at bp+8 */ uintptr var _ /* servs at bp+0 */ [2]Tservice _, _, _, _ = align, cnt, proto, v1 - *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) + **(**uintptr)(__ccgo_up(res)) = uintptr(0) /* Don't treat numeric port number strings as service records. */ - *(*uintptr)(unsafe.Pointer(bp + 8)) = __ccgo_ts + **(**uintptr)(__ccgo_up(bp + 8)) = __ccgo_ts Xstrtoul(tls, name, bp+8, int32(10)) - if !(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) != 0) { + if !(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) != 0) { return int32(ENOENT) } /* Align buffer */ @@ -121501,16 +121501,16 @@ func Xgetservbyname_r(tls *TLS, name uintptr, prots uintptr, se uintptr, buf uin } (*Tservent)(unsafe.Pointer(se)).Fs_name = name (*Tservent)(unsafe.Pointer(se)).Fs_aliases = buf - *(*uintptr)(unsafe.Pointer((*Tservent)(unsafe.Pointer(se)).Fs_aliases)) = (*Tservent)(unsafe.Pointer(se)).Fs_name - *(*uintptr)(unsafe.Pointer((*Tservent)(unsafe.Pointer(se)).Fs_aliases + 1*4)) = uintptr(0) - (*Tservent)(unsafe.Pointer(se)).Fs_port = Int32FromUint16(Xhtons(tls, (*(*[2]Tservice)(unsafe.Pointer(bp)))[0].Fport)) - if Int32FromUint8((*(*[2]Tservice)(unsafe.Pointer(bp)))[0].Fproto) == int32(IPPROTO_TCP) { + **(**uintptr)(__ccgo_up((*Tservent)(unsafe.Pointer(se)).Fs_aliases)) = (*Tservent)(unsafe.Pointer(se)).Fs_name + **(**uintptr)(__ccgo_up((*Tservent)(unsafe.Pointer(se)).Fs_aliases + 1*4)) = uintptr(0) + (*Tservent)(unsafe.Pointer(se)).Fs_port = Int32FromUint16(Xhtons(tls, (**(**[2]Tservice)(__ccgo_up(bp)))[0].Fport)) + if Int32FromUint8((**(**[2]Tservice)(__ccgo_up(bp)))[0].Fproto) == int32(IPPROTO_TCP) { v1 = __ccgo_ts + 979 } else { v1 = __ccgo_ts + 983 } (*Tservent)(unsafe.Pointer(se)).Fs_proto = v1 - *(*uintptr)(unsafe.Pointer(res)) = se + **(**uintptr)(__ccgo_up(res)) = se return 0 } @@ -121634,7 +121634,7 @@ _11: if false { break } - if *(*Tsocklen_t)(unsafe.Pointer(optlen)) < uint32(16) { + if **(**Tsocklen_t)(__ccgo_up(optlen)) < uint32(16) { return X__syscall_ret(tls, Uint32FromInt32(-Int32FromInt32(EINVAL))) } if optname == int32(SO_RCVTIMEO) { @@ -121693,9 +121693,9 @@ _11: break } tv = optval - (*Ttimeval)(unsafe.Pointer(tv)).Ftv_sec = int64((*(*[2]int32)(unsafe.Pointer(bp + 152)))[0]) - (*Ttimeval)(unsafe.Pointer(tv)).Ftv_usec = int64((*(*[2]int32)(unsafe.Pointer(bp + 152)))[int32(1)]) - *(*Tsocklen_t)(unsafe.Pointer(optlen)) = uint32(16) + (*Ttimeval)(unsafe.Pointer(tv)).Ftv_sec = int64((**(**[2]int32)(__ccgo_up(bp + 152)))[0]) + (*Ttimeval)(unsafe.Pointer(tv)).Ftv_usec = int64((**(**[2]int32)(__ccgo_up(bp + 152)))[int32(1)]) + **(**Tsocklen_t)(__ccgo_up(optlen)) = uint32(16) case int32(SO_TIMESTAMP): fallthrough case int32(SO_TIMESTAMPNS): @@ -121787,7 +121787,7 @@ func Xherror(tls *TLS, msg uintptr) { } else { v2 = __ccgo_ts } - Xfprintf(tls, uintptr(unsafe.Pointer(&X__stderr_FILE)), __ccgo_ts+987, VaList(bp+8, v1, v2, Xhstrerror(tls, *(*int32)(unsafe.Pointer(X__h_errno_location(tls)))))) + Xfprintf(tls, uintptr(unsafe.Pointer(&X__stderr_FILE)), __ccgo_ts+987, VaList(bp+8, v1, v2, Xhstrerror(tls, **(**int32)(__ccgo_up(X__h_errno_location(tls)))))) } var _msgs1 = [84]int8{'H', 'o', 's', 't', ' ', 'n', 'o', 't', ' ', 'f', 'o', 'u', 'n', 'd', 0, 'T', 'r', 'y', ' ', 'a', 'g', 'a', 'i', 'n', 0, 'N', 'o', 'n', '-', 'r', 'e', 'c', 'o', 'v', 'e', 'r', 'a', 'b', 'l', 'e', ' ', 'e', 'r', 'r', 'o', 'r', 0, 'A', 'd', 'd', 'r', 'e', 's', 's', ' ', 'n', 'o', 't', ' ', 'a', 'v', 'a', 'i', 'l', 'a', 'b', 'l', 'e', 0, 0, 'U', 'n', 'k', 'n', 'o', 'w', 'n', ' ', 'e', 'r', 'r', 'o', 'r'} @@ -121802,11 +121802,11 @@ func Xhstrerror(tls *TLS, ecode int32) (r uintptr) { s = uintptr(unsafe.Pointer(&_msgs1)) ecode = ecode - 1 for { - if !(ecode != 0 && *(*int8)(unsafe.Pointer(s)) != 0) { + if !(ecode != 0 && **(**int8)(__ccgo_up(s)) != 0) { break } for { - if !(*(*int8)(unsafe.Pointer(s)) != 0) { + if !(**(**int8)(__ccgo_up(s)) != 0) { break } goto _2 @@ -121820,7 +121820,7 @@ func Xhstrerror(tls *TLS, ecode int32) (r uintptr) { ecode = ecode - 1 s = s + 1 } - if !(*(*int8)(unsafe.Pointer(s)) != 0) { + if !(**(**int8)(__ccgo_up(s)) != 0) { s = s + 1 } return X__lctrans_cur(tls, s) @@ -121908,8 +121908,8 @@ func Xif_indextoname(tls *TLS, index uint32, name uintptr) (r1 uintptr) { r = Xioctl(tls, fd, int32(SIOCGIFNAME), VaList(bp+40, bp)) X__syscall1(tls, int32(SYS_close), fd) if r < 0 { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENODEV) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENXIO) + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENODEV) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENXIO) } return uintptr(0) } @@ -121962,7 +121962,7 @@ func _netlink_msg_to_nameindex(tls *TLS, pctx uintptr, h uintptr) (r int32) { } /* suppress duplicates */ bucket = index % int32(IFADDRS_HASH_SIZE) - i = *(*uint32)(unsafe.Pointer(ctx + 16 + uintptr(bucket)*4)) + i = **(**uint32)(__ccgo_up(ctx + 16 + uintptr(bucket)*4)) for i != 0 { map1 = (*Tifnameindexctx)(unsafe.Pointer(ctx)).Flist + uintptr(i-uint32(1))*28 if (*Tifnamemap)(unsafe.Pointer(map1)).Findex == Uint32FromInt32(index) && Int32FromUint8((*Tifnamemap)(unsafe.Pointer(map1)).Fnamelen) == namelen && Xmemcmp(tls, map1+9, rta+UintptrFromInt64(4), Uint32FromInt32(namelen)) == 0 { @@ -121991,10 +121991,10 @@ func _netlink_msg_to_nameindex(tls *TLS, pctx uintptr, h uintptr) (r int32) { (*Tifnamemap)(unsafe.Pointer(map1)).Findex = Uint32FromInt32(index) (*Tifnamemap)(unsafe.Pointer(map1)).Fnamelen = Uint8FromInt32(namelen) Xmemcpy(tls, map1+9, rta+UintptrFromInt64(4), Uint32FromInt32(namelen)) - *(*uint32)(unsafe.Pointer(ctx + 8)) += Uint32FromInt32(namelen + int32(1)) + **(**uint32)(__ccgo_up(ctx + 8)) += Uint32FromInt32(namelen + int32(1)) (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum = (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum + 1 - (*Tifnamemap)(unsafe.Pointer(map1)).Fhash_next = *(*uint32)(unsafe.Pointer(ctx + 16 + uintptr(bucket)*4)) - *(*uint32)(unsafe.Pointer(ctx + 16 + uintptr(bucket)*4)) = (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum + (*Tifnamemap)(unsafe.Pointer(map1)).Fhash_next = **(**uint32)(__ccgo_up(ctx + 16 + uintptr(bucket)*4)) + **(**uint32)(__ccgo_up(ctx + 16 + uintptr(bucket)*4)) = (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum return 0 goto _1 _1: @@ -122041,7 +122041,7 @@ func Xif_nameindex(tls *TLS) (r uintptr) { p = p + uintptr((*Tifnamemap)(unsafe.Pointer(s)).Fnamelen) v2 = p p = p + 1 - *(*int8)(unsafe.Pointer(v2)) = 0 + **(**int8)(__ccgo_up(v2)) = 0 goto _1 _1: ; @@ -122054,9 +122054,9 @@ func Xif_nameindex(tls *TLS) (r uintptr) { goto err err: ; - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 272)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 272)), uintptr(0)) Xfree(tls, (*Tifnameindexctx)(unsafe.Pointer(ctx)).Flist) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOBUFS) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOBUFS) return ifs } @@ -122097,7 +122097,7 @@ func Xinet_addr(tls *TLS, p uintptr) (r Tin_addr_t) { if !(X__inet_aton(tls, p, bp) != 0) { return Uint32FromInt32(-Int32FromInt32(1)) } - return (*(*Tin_addr)(unsafe.Pointer(bp))).Fs_addr + return (**(**Tin_addr)(__ccgo_up(bp))).Fs_addr } func X__inet_aton(tls *TLS, s0 uintptr, dest uintptr) (r int32) { @@ -122114,20 +122114,20 @@ func X__inet_aton(tls *TLS, s0 uintptr, dest uintptr) (r int32) { _, _, _ = d, i, s s = s0 d = dest - *(*[4]uint32)(unsafe.Pointer(bp)) = [4]uint32{} + **(**[4]uint32)(__ccgo_up(bp)) = [4]uint32{} i = 0 for { if !(i < int32(4)) { break } - (*(*[4]uint32)(unsafe.Pointer(bp)))[i] = Xstrtoul(tls, s, bp+16, 0) - if *(*uintptr)(unsafe.Pointer(bp + 16)) == s || *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))) != 0 && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16))))) != int32('.') || !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + (**(**[4]uint32)(__ccgo_up(bp)))[i] = Xstrtoul(tls, s, bp+16, 0) + if **(**uintptr)(__ccgo_up(bp + 16)) == s || **(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 16)))) != 0 && int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 16))))) != int32('.') || !(BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return 0 } - if !(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))) != 0) { + if !(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 16)))) != 0) { break } - s = *(*uintptr)(unsafe.Pointer(bp + 16)) + uintptr(1) + s = **(**uintptr)(__ccgo_up(bp + 16)) + uintptr(1) goto _1 _1: ; @@ -122138,26 +122138,26 @@ func X__inet_aton(tls *TLS, s0 uintptr, dest uintptr) (r int32) { } switch i { case 0: - (*(*[4]uint32)(unsafe.Pointer(bp)))[int32(1)] = (*(*[4]uint32)(unsafe.Pointer(bp)))[0] & uint32(0xffffff) - *(*uint32)(unsafe.Pointer(bp)) >>= uint32(24) + (**(**[4]uint32)(__ccgo_up(bp)))[int32(1)] = (**(**[4]uint32)(__ccgo_up(bp)))[0] & uint32(0xffffff) + **(**uint32)(__ccgo_up(bp)) >>= uint32(24) fallthrough case int32(1): - (*(*[4]uint32)(unsafe.Pointer(bp)))[int32(2)] = (*(*[4]uint32)(unsafe.Pointer(bp)))[int32(1)] & uint32(0xffff) - *(*uint32)(unsafe.Pointer(bp + 1*4)) >>= uint32(16) + (**(**[4]uint32)(__ccgo_up(bp)))[int32(2)] = (**(**[4]uint32)(__ccgo_up(bp)))[int32(1)] & uint32(0xffff) + **(**uint32)(__ccgo_up(bp + 1*4)) >>= uint32(16) fallthrough case int32(2): - (*(*[4]uint32)(unsafe.Pointer(bp)))[int32(3)] = (*(*[4]uint32)(unsafe.Pointer(bp)))[int32(2)] & uint32(0xff) - *(*uint32)(unsafe.Pointer(bp + 2*4)) >>= uint32(8) + (**(**[4]uint32)(__ccgo_up(bp)))[int32(3)] = (**(**[4]uint32)(__ccgo_up(bp)))[int32(2)] & uint32(0xff) + **(**uint32)(__ccgo_up(bp + 2*4)) >>= uint32(8) } i = 0 for { if !(i < int32(4)) { break } - if (*(*[4]uint32)(unsafe.Pointer(bp)))[i] > uint32(255) { + if (**(**[4]uint32)(__ccgo_up(bp)))[i] > uint32(255) { return 0 } - *(*uint8)(unsafe.Pointer(d + uintptr(i))) = uint8((*(*[4]uint32)(unsafe.Pointer(bp)))[i]) + **(**uint8)(__ccgo_up(d + uintptr(i))) = uint8((**(**[4]uint32)(__ccgo_up(bp)))[i]) goto _2 _2: ; @@ -122246,7 +122246,7 @@ func Xinet_ntoa(tls *TLS, _in Tin_addr) (r uintptr) { var a uintptr _ = a a = bp - Xsnprintf(tls, uintptr(unsafe.Pointer(&_buf4)), uint32(16), __ccgo_ts+995, VaList(bp+16, Int32FromUint8(*(*uint8)(unsafe.Pointer(a))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 1))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 2))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 3))))) + Xsnprintf(tls, uintptr(unsafe.Pointer(&_buf4)), uint32(16), __ccgo_ts+995, VaList(bp+16, Int32FromUint8(**(**uint8)(__ccgo_up(a))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 1))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 2))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 3))))) return uintptr(unsafe.Pointer(&_buf4)) } @@ -122267,14 +122267,14 @@ func Xinet_ntop(tls *TLS, af int32, a0 uintptr, s uintptr, l Tsocklen_t) (r uint a = a0 switch af { case int32(PF_INET): - if Uint32FromInt32(Xsnprintf(tls, s, l, __ccgo_ts+995, VaList(bp+112, Int32FromUint8(*(*uint8)(unsafe.Pointer(a))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 1))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 2))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 3)))))) < l { + if Uint32FromInt32(Xsnprintf(tls, s, l, __ccgo_ts+995, VaList(bp+112, Int32FromUint8(**(**uint8)(__ccgo_up(a))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 1))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 2))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 3)))))) < l { return s } case int32(PF_INET6): if Xmemcmp(tls, a, __ccgo_ts+942, uint32(12)) != 0 { - Xsnprintf(tls, bp, uint32(100), __ccgo_ts+1007, VaList(bp+112, int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 1))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 2)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 3))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 4)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 5))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 6)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 7))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 8)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 9))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 10)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 11))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 12)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 13))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 14)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 15))))) + Xsnprintf(tls, bp, uint32(100), __ccgo_ts+1007, VaList(bp+112, int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 1))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 2)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 3))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 4)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 5))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 6)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 7))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 8)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 9))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 10)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 11))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 12)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 13))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 14)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 15))))) } else { - Xsnprintf(tls, bp, uint32(100), __ccgo_ts+1031, VaList(bp+112, int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 1))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 2)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 3))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 4)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 5))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 6)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 7))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 8)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 9))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 10)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 11))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 12))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 13))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 14))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 15))))) + Xsnprintf(tls, bp, uint32(100), __ccgo_ts+1031, VaList(bp+112, int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 1))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 2)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 3))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 4)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 5))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 6)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 7))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 8)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 9))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 10)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 11))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 12))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 13))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 14))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 15))))) } /* Replace longest /(^0|:)[:0]{2,}/ with "::" */ v2 = Int32FromInt32(0) @@ -122282,10 +122282,10 @@ func Xinet_ntop(tls *TLS, af int32, a0 uintptr, s uintptr, l Tsocklen_t) (r uint i = v2 max = Int32FromInt32(2) for { - if !((*(*[100]int8)(unsafe.Pointer(bp)))[i] != 0) { + if !((**(**[100]int8)(__ccgo_up(bp)))[i] != 0) { break } - if i != 0 && int32((*(*[100]int8)(unsafe.Pointer(bp)))[i]) != int32(':') { + if i != 0 && int32((**(**[100]int8)(__ccgo_up(bp)))[i]) != int32(':') { goto _1 } j = Int32FromUint32(Xstrspn(tls, bp+uintptr(i), __ccgo_ts+1061)) @@ -122300,8 +122300,8 @@ func Xinet_ntop(tls *TLS, af int32, a0 uintptr, s uintptr, l Tsocklen_t) (r uint } if max > int32(3) { v3 = Int8FromUint8(':') - (*(*[100]int8)(unsafe.Pointer(bp)))[best+int32(1)] = v3 - (*(*[100]int8)(unsafe.Pointer(bp)))[best] = v3 + (**(**[100]int8)(__ccgo_up(bp)))[best+int32(1)] = v3 + (**(**[100]int8)(__ccgo_up(bp)))[best] = v3 Xmemmove(tls, bp+uintptr(best)+uintptr(2), bp+uintptr(best)+uintptr(max), Uint32FromInt32(i-best-max+int32(1))) } if _strlen(tls, bp) < l { @@ -122309,10 +122309,10 @@ func Xinet_ntop(tls *TLS, af int32, a0 uintptr, s uintptr, l Tsocklen_t) (r uint return s } default: - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EAFNOSUPPORT) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EAFNOSUPPORT) return uintptr(0) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOSPC) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOSPC) return uintptr(0) } @@ -122352,23 +122352,23 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { j = v3 v = v3 for { - if !(j < int32(3) && BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s + uintptr(j))))-uint32('0') < uint32(10)) != 0) { + if !(j < int32(3) && BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(s + uintptr(j))))-uint32('0') < uint32(10)) != 0) { break } - v = int32(10)*v + int32(*(*int8)(unsafe.Pointer(s + uintptr(j)))) - int32('0') + v = int32(10)*v + int32(**(**int8)(__ccgo_up(s + uintptr(j)))) - int32('0') goto _2 _2: ; j = j + 1 } - if j == 0 || j > int32(1) && int32(*(*int8)(unsafe.Pointer(s))) == int32('0') || v > int32(255) { + if j == 0 || j > int32(1) && int32(**(**int8)(__ccgo_up(s))) == int32('0') || v > int32(255) { return 0 } - *(*uint8)(unsafe.Pointer(a + uintptr(i))) = Uint8FromInt32(v) - if int32(*(*int8)(unsafe.Pointer(s + uintptr(j)))) == 0 && i == int32(3) { + **(**uint8)(__ccgo_up(a + uintptr(i))) = Uint8FromInt32(v) + if int32(**(**int8)(__ccgo_up(s + uintptr(j)))) == 0 && i == int32(3) { return int32(1) } - if int32(*(*int8)(unsafe.Pointer(s + uintptr(j)))) != int32('.') { + if int32(**(**int8)(__ccgo_up(s + uintptr(j)))) != int32('.') { return 0 } s = s + uintptr(j+int32(1)) @@ -122380,25 +122380,25 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { return 0 } else { if af != int32(PF_INET6) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EAFNOSUPPORT) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EAFNOSUPPORT) return -int32(1) } } - if v5 = int32(*(*int8)(unsafe.Pointer(s))) == int32(':'); v5 { + if v5 = int32(**(**int8)(__ccgo_up(s))) == int32(':'); v5 { s = s + 1 v4 = s } - if v5 && int32(*(*int8)(unsafe.Pointer(v4))) != int32(':') { + if v5 && int32(**(**int8)(__ccgo_up(v4))) != int32(':') { return 0 } i = 0 for { - if int32(*(*int8)(unsafe.Pointer(s))) == int32(':') && brk < 0 { + if int32(**(**int8)(__ccgo_up(s))) == int32(':') && brk < 0 { brk = i - (*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[i&int32(7)] = uint16(0) + (**(**[8]Tuint16_t)(__ccgo_up(bp)))[i&int32(7)] = uint16(0) s = s + 1 v4 = s - if !(*(*int8)(unsafe.Pointer(v4)) != 0) { + if !(**(**int8)(__ccgo_up(v4)) != 0) { break } if i == int32(7) { @@ -122411,7 +122411,7 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { v = v3 for { if v5 = j < int32(4); v5 { - v9 = _hexval(tls, Uint32FromInt8(*(*int8)(unsafe.Pointer(s + uintptr(j))))) + v9 = _hexval(tls, Uint32FromInt8(**(**int8)(__ccgo_up(s + uintptr(j))))) d = v9 } if !(v5 && v9 >= 0) { @@ -122426,20 +122426,20 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { if j == 0 { return 0 } - (*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[i&int32(7)] = Uint16FromInt32(v) - if !(*(*int8)(unsafe.Pointer(s + uintptr(j))) != 0) && (brk >= 0 || i == int32(7)) { + (**(**[8]Tuint16_t)(__ccgo_up(bp)))[i&int32(7)] = Uint16FromInt32(v) + if !(**(**int8)(__ccgo_up(s + uintptr(j))) != 0) && (brk >= 0 || i == int32(7)) { break } if i == int32(7) { return 0 } - if int32(*(*int8)(unsafe.Pointer(s + uintptr(j)))) != int32(':') { - if int32(*(*int8)(unsafe.Pointer(s + uintptr(j)))) != int32('.') || i < int32(6) && brk < 0 { + if int32(**(**int8)(__ccgo_up(s + uintptr(j)))) != int32(':') { + if int32(**(**int8)(__ccgo_up(s + uintptr(j)))) != int32('.') || i < int32(6) && brk < 0 { return 0 } need_v4 = int32(1) i = i + 1 - (*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[i&int32(7)] = uint16(0) + (**(**[8]Tuint16_t)(__ccgo_up(bp)))[i&int32(7)] = uint16(0) break } s = s + uintptr(j+int32(1)) @@ -122455,7 +122455,7 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { if !(j < int32(7)-i) { break } - (*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[brk+j] = uint16(0) + (**(**[8]Tuint16_t)(__ccgo_up(bp)))[brk+j] = uint16(0) goto _12 _12: ; @@ -122469,10 +122469,10 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { } v4 = a a = a + 1 - *(*uint8)(unsafe.Pointer(v4)) = Uint8FromInt32(Int32FromUint16((*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[j]) >> int32(8)) + **(**uint8)(__ccgo_up(v4)) = Uint8FromInt32(Int32FromUint16((**(**[8]Tuint16_t)(__ccgo_up(bp)))[j]) >> int32(8)) v4 = a a = a + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8((*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[j]) + **(**uint8)(__ccgo_up(v4)) = uint8((**(**[8]Tuint16_t)(__ccgo_up(bp)))[j]) goto _13 _13: ; @@ -122558,15 +122558,15 @@ func X__lookup_ipliteral(tls *TLS, buf uintptr, name uintptr, family int32) (r i return -int32(5) } Xmemcpy(tls, buf+8, bp, uint32(4)) - (*(*Taddress)(unsafe.Pointer(buf))).Ffamily = int32(PF_INET) - (*(*Taddress)(unsafe.Pointer(buf))).Fscopeid = uint32(0) + (**(**Taddress)(__ccgo_up(buf))).Ffamily = int32(PF_INET) + (**(**Taddress)(__ccgo_up(buf))).Fscopeid = uint32(0) return int32(1) } p = Xstrchr(tls, name, int32('%')) scopeid = uint64(0) if p != 0 && int32(p)-int32(name) < int32(64) { Xmemcpy(tls, bp+20, name, Uint32FromInt32(int32(p)-int32(name))) - (*(*[64]int8)(unsafe.Pointer(bp + 20)))[int32(p)-int32(name)] = 0 + (**(**[64]int8)(__ccgo_up(bp + 20)))[int32(p)-int32(name)] = 0 name = bp + 20 } if Xinet_pton(tls, int32(PF_INET6), name, bp+4) <= 0 { @@ -122576,17 +122576,17 @@ func X__lookup_ipliteral(tls *TLS, buf uintptr, name uintptr, family int32) (r i return -int32(5) } Xmemcpy(tls, buf+8, bp+4, uint32(16)) - (*(*Taddress)(unsafe.Pointer(buf))).Ffamily = int32(PF_INET6) + (**(**Taddress)(__ccgo_up(buf))).Ffamily = int32(PF_INET6) if p != 0 { p = p + 1 v1 = p - if BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(v1)))-uint32('0') < uint32(10)) != 0 { + if BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(v1)))-uint32('0') < uint32(10)) != 0 { scopeid = Xstrtoull(tls, p, bp+84, int32(10)) } else { - *(*uintptr)(unsafe.Pointer(bp + 84)) = p - uintptr(1) + **(**uintptr)(__ccgo_up(bp + 84)) = p - uintptr(1) } - if *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 84)))) != 0 { - if !(Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(bp + 4))) == int32(0xfe) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(bp + 4 + 1)))&int32(0xc0) == int32(0x80)) && !(Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(bp + 4))) == int32(0xff) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(bp + 4 + 1)))&int32(0xf) == int32(0x2)) { + if **(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 84)))) != 0 { + if !(Int32FromUint8(**(**Tuint8_t)(__ccgo_up(bp + 4))) == int32(0xfe) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(bp + 4 + 1)))&int32(0xc0) == int32(0x80)) && !(Int32FromUint8(**(**Tuint8_t)(__ccgo_up(bp + 4))) == int32(0xff) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(bp + 4 + 1)))&int32(0xf) == int32(0x2)) { return -int32(2) } scopeid = uint64(Xif_nametoindex(tls, p)) @@ -122598,7 +122598,7 @@ func X__lookup_ipliteral(tls *TLS, buf uintptr, name uintptr, family int32) (r i return -int32(2) } } - (*(*Taddress)(unsafe.Pointer(buf))).Fscopeid = uint32(scopeid) + (**(**Taddress)(__ccgo_up(buf))).Fscopeid = uint32(scopeid) return int32(1) } @@ -122622,7 +122622,7 @@ func _is_valid_hostname(tls *TLS, host uintptr) (r int32) { } s = host for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) >= int32(0x80) || Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('.') || Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('-') || Xisalnum(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))) != 0) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(s))) >= int32(0x80) || Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('.') || Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('-') || Xisalnum(tls, Int32FromUint8(**(**uint8)(__ccgo_up(s)))) != 0) { break } goto _1 @@ -122630,7 +122630,7 @@ func _is_valid_hostname(tls *TLS, host uintptr) (r int32) { ; s = s + 1 } - return BoolInt32(!(*(*uint8)(unsafe.Pointer(s)) != 0)) + return BoolInt32(!(**(**uint8)(__ccgo_up(s)) != 0)) } func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags int32) (r int32) { @@ -122644,14 +122644,14 @@ func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags in if family != int32(PF_INET6) { v1 = cnt cnt = cnt + 1 - *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ + **(**Taddress)(__ccgo_up(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET), } } if family != int32(PF_INET) { v1 = cnt cnt = cnt + 1 - *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ + **(**Taddress)(__ccgo_up(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET6), } } @@ -122659,7 +122659,7 @@ func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags in if family != int32(PF_INET6) { v1 = cnt cnt = cnt + 1 - *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ + **(**Taddress)(__ccgo_up(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET), Faddr: [16]Tuint8_t{ 0: uint8(127), @@ -122670,7 +122670,7 @@ func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags in if family != int32(PF_INET) { v1 = cnt cnt = cnt + 1 - *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ + **(**Taddress)(__ccgo_up(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET6), Faddr: [16]Tuint8_t{ 15: uint8(1), @@ -122702,7 +122702,7 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family have_canon = 0 f = X__fopen_rb_ca(tls, __ccgo_ts+931, bp+1544, bp+512, uint32(1032)) if !(f != 0) { - switch *(*int32)(unsafe.Pointer(X__errno_location(tls))) { + switch **(**int32)(__ccgo_up(X__errno_location(tls))) { case int32(ENOENT): fallthrough case int32(ENOTDIR): @@ -122719,21 +122719,21 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family if v1 != 0 { v2 = p p = p + 1 - *(*int8)(unsafe.Pointer(v2)) = int8('\n') - *(*int8)(unsafe.Pointer(p)) = Int8FromInt32(0) + **(**int8)(__ccgo_up(v2)) = int8('\n') + **(**int8)(__ccgo_up(p)) = Int8FromInt32(0) } p = bp + uintptr(1) for { v1 = Xstrstr(tls, p, name) p = v1 if v12 = v1 != 0; v12 { - v5 = int32(*(*int8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) + v5 = int32(**(**int8)(__ccgo_up(p + uintptr(-Int32FromInt32(1))))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _7 _7: ; if v11 = !(v6 != 0); !v11 { - v8 = int32(*(*int8)(unsafe.Pointer(p + uintptr(l)))) + v8 = int32(**(**int8)(__ccgo_up(p + uintptr(l)))) v9 = BoolInt32(v8 == int32(' ') || Uint32FromInt32(v8)-uint32('\t') < uint32(5)) goto _10 _10: @@ -122753,8 +122753,8 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family /* Isolate IP address to parse */ p = bp for { - if v11 = *(*int8)(unsafe.Pointer(p)) != 0; v11 { - v5 = int32(*(*int8)(unsafe.Pointer(p))) + if v11 = **(**int8)(__ccgo_up(p)) != 0; v11 { + v5 = int32(**(**int8)(__ccgo_up(p))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _16 _16: @@ -122769,7 +122769,7 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family } v1 = p p = p + 1 - *(*int8)(unsafe.Pointer(v1)) = 0 + **(**int8)(__ccgo_up(v1)) = 0 switch _name_from_numeric(tls, buf+uintptr(cnt)*28, bp, family) { case int32(1): cnt = cnt + 1 @@ -122784,8 +122784,8 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family } /* Extract first name as canonical name */ for { - if v11 = *(*int8)(unsafe.Pointer(p)) != 0; v11 { - v5 = int32(*(*int8)(unsafe.Pointer(p))) + if v11 = **(**int8)(__ccgo_up(p)) != 0; v11 { + v5 = int32(**(**int8)(__ccgo_up(p))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _22 _22: @@ -122800,8 +122800,8 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family } z = p for { - if v11 = *(*int8)(unsafe.Pointer(z)) != 0; v11 { - v5 = int32(*(*int8)(unsafe.Pointer(z))) + if v11 = **(**int8)(__ccgo_up(z)) != 0; v11 { + v5 = int32(**(**int8)(__ccgo_up(z))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _27 _27: @@ -122814,7 +122814,7 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family ; z = z + 1 } - *(*int8)(unsafe.Pointer(z)) = 0 + **(**int8)(__ccgo_up(z)) = 0 if _is_valid_hostname(tls, p) != 0 { have_canon = int32(1) Xmemcpy(tls, canon, p, Uint32FromInt32(int32(z)-int32(p)+int32(1))) @@ -122869,8 +122869,8 @@ func _dns_parse_callback1(tls *TLS, c uintptr, rr int32, data uintptr, len1 int3 family = int32(PF_INET6) break } - (*(*Taddress)(unsafe.Pointer((*Tdpc_ctx)(unsafe.Pointer(ctx)).Faddrs + uintptr((*Tdpc_ctx)(unsafe.Pointer(ctx)).Fcnt)*28))).Ffamily = family - (*(*Taddress)(unsafe.Pointer((*Tdpc_ctx)(unsafe.Pointer(ctx)).Faddrs + uintptr((*Tdpc_ctx)(unsafe.Pointer(ctx)).Fcnt)*28))).Fscopeid = uint32(0) + (**(**Taddress)(__ccgo_up((*Tdpc_ctx)(unsafe.Pointer(ctx)).Faddrs + uintptr((*Tdpc_ctx)(unsafe.Pointer(ctx)).Fcnt)*28))).Ffamily = family + (**(**Taddress)(__ccgo_up((*Tdpc_ctx)(unsafe.Pointer(ctx)).Faddrs + uintptr((*Tdpc_ctx)(unsafe.Pointer(ctx)).Fcnt)*28))).Fscopeid = uint32(0) v2 = ctx + 8 v1 = *(*int32)(unsafe.Pointer(v2)) *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) + 1 @@ -122891,16 +122891,16 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i var _ /* qlens at bp+10176 */ [2]int32 var _ /* qp at bp+10160 */ [2]uintptr _, _, _ = i, nq, qtypes - *(*[2]uintptr)(unsafe.Pointer(bp + 10160)) = [2]uintptr{ + **(**[2]uintptr)(__ccgo_up(bp + 10160)) = [2]uintptr{ 0: bp, 1: bp + 1*280, } - *(*[2]uintptr)(unsafe.Pointer(bp + 10168)) = [2]uintptr{ + **(**[2]uintptr)(__ccgo_up(bp + 10168)) = [2]uintptr{ 0: bp + 560, 1: bp + 560 + 1*4800, } nq = 0 - *(*Tdpc_ctx)(unsafe.Pointer(bp + 10192)) = Tdpc_ctx{ + **(**Tdpc_ctx)(__ccgo_up(bp + 10192)) = Tdpc_ctx{ Faddrs: buf, Fcanon: canon, } @@ -122910,15 +122910,15 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i break } if family != _afrr[i].Faf { - (*(*[2]int32)(unsafe.Pointer(bp + 10176)))[nq] = X__res_mkquery(tls, 0, name, int32(1), _afrr[i].Frr, uintptr(0), 0, uintptr(0), bp+uintptr(nq)*280, int32(280)) - if (*(*[2]int32)(unsafe.Pointer(bp + 10176)))[nq] == -int32(1) { + (**(**[2]int32)(__ccgo_up(bp + 10176)))[nq] = X__res_mkquery(tls, 0, name, int32(1), _afrr[i].Frr, uintptr(0), 0, uintptr(0), bp+uintptr(nq)*280, int32(280)) + if (**(**[2]int32)(__ccgo_up(bp + 10176)))[nq] == -int32(1) { return 0 } qtypes[nq] = _afrr[i].Frr - *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280 + 3)) = uint8(0) /* don't need AD flag */ + **(**uint8)(__ccgo_up(bp + uintptr(nq)*280 + 3)) = uint8(0) /* don't need AD flag */ /* Ensure query IDs are distinct. */ - if nq != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) { - *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280)) = *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280)) + 1 + if nq != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(bp + uintptr(nq)*280))) == Int32FromUint8(**(**uint8)(__ccgo_up(bp))) { + **(**uint8)(__ccgo_up(bp + uintptr(nq)*280)) = **(**uint8)(__ccgo_up(bp + uintptr(nq)*280)) + 1 } nq = nq + 1 } @@ -122935,13 +122935,13 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if !(i < nq) { break } - if (*(*[2]int32)(unsafe.Pointer(bp + 10184)))[i] < int32(4) || Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + 560 + uintptr(i)*4800 + 3)))&int32(15) == int32(2) { + if (**(**[2]int32)(__ccgo_up(bp + 10184)))[i] < int32(4) || Int32FromUint8(**(**uint8)(__ccgo_up(bp + 560 + uintptr(i)*4800 + 3)))&int32(15) == int32(2) { return -int32(3) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + 560 + uintptr(i)*4800 + 3)))&int32(15) == int32(3) { + if Int32FromUint8(**(**uint8)(__ccgo_up(bp + 560 + uintptr(i)*4800 + 3)))&int32(15) == int32(3) { return 0 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + 560 + uintptr(i)*4800 + 3)))&int32(15) != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(bp + 560 + uintptr(i)*4800 + 3)))&int32(15) != 0 { return -int32(4) } goto _2 @@ -122954,18 +122954,18 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if !(i >= 0) { break } - (*(*Tdpc_ctx)(unsafe.Pointer(bp + 10192))).Frrtype = qtypes[i] - if Uint32FromInt32((*(*[2]int32)(unsafe.Pointer(bp + 10184)))[i]) > uint32(4800) { - (*(*[2]int32)(unsafe.Pointer(bp + 10184)))[i] = int32(4800) + (**(**Tdpc_ctx)(__ccgo_up(bp + 10192))).Frrtype = qtypes[i] + if Uint32FromInt32((**(**[2]int32)(__ccgo_up(bp + 10184)))[i]) > uint32(4800) { + (**(**[2]int32)(__ccgo_up(bp + 10184)))[i] = int32(4800) } - X__dns_parse(tls, bp+560+uintptr(i)*4800, (*(*[2]int32)(unsafe.Pointer(bp + 10184)))[i], __ccgo_fp(_dns_parse_callback1), bp+10192) + X__dns_parse(tls, bp+560+uintptr(i)*4800, (**(**[2]int32)(__ccgo_up(bp + 10184)))[i], __ccgo_fp(_dns_parse_callback1), bp+10192) goto _3 _3: ; i = i - 1 } - if (*(*Tdpc_ctx)(unsafe.Pointer(bp + 10192))).Fcnt != 0 { - return (*(*Tdpc_ctx)(unsafe.Pointer(bp + 10192))).Fcnt + if (**(**Tdpc_ctx)(__ccgo_up(bp + 10192))).Fcnt != 0 { + return (**(**Tdpc_ctx)(__ccgo_up(bp + 10192))).Fcnt } return -int32(5) } @@ -123003,10 +123003,10 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f l = v2 dots = v2 for { - if !(*(*int8)(unsafe.Pointer(name + uintptr(l))) != 0) { + if !(**(**int8)(__ccgo_up(name + uintptr(l))) != 0) { break } - if int32(*(*int8)(unsafe.Pointer(name + uintptr(l)))) == int32('.') { + if int32(**(**int8)(__ccgo_up(name + uintptr(l)))) == int32('.') { dots = dots + 1 } goto _1 @@ -123014,14 +123014,14 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f ; l = l + 1 } - if dots >= (*(*Tresolvconf)(unsafe.Pointer(bp + 256))).Fndots || int32(*(*int8)(unsafe.Pointer(name + uintptr(l-uint32(1))))) == int32('.') { - *(*int8)(unsafe.Pointer(bp)) = 0 + if dots >= (**(**Tresolvconf)(__ccgo_up(bp + 256))).Fndots || int32(**(**int8)(__ccgo_up(name + uintptr(l-uint32(1))))) == int32('.') { + **(**int8)(__ccgo_up(bp)) = 0 } /* Strip final dot for canon, fail if multiple trailing dots. */ - if int32(*(*int8)(unsafe.Pointer(name + uintptr(l-uint32(1))))) == int32('.') { + if int32(**(**int8)(__ccgo_up(name + uintptr(l-uint32(1))))) == int32('.') { l = l - 1 } - if !(l != 0) || int32(*(*int8)(unsafe.Pointer(name + uintptr(l-uint32(1))))) == int32('.') { + if !(l != 0) || int32(**(**int8)(__ccgo_up(name + uintptr(l-uint32(1))))) == int32('.') { return -int32(2) } /* This can never happen; the caller already checked length. */ @@ -123033,14 +123033,14 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f * name is not a CNAME record) and serves as a buffer for passing * the full requested name to name_from_dns. */ Xmemcpy(tls, canon, name, l) - *(*int8)(unsafe.Pointer(canon + uintptr(l))) = int8('.') + **(**int8)(__ccgo_up(canon + uintptr(l))) = int8('.') p = bp for { - if !(*(*int8)(unsafe.Pointer(p)) != 0) { + if !(**(**int8)(__ccgo_up(p)) != 0) { break } for { - v5 = int32(*(*int8)(unsafe.Pointer(p))) + v5 = int32(**(**int8)(__ccgo_up(p))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _7 _7: @@ -123054,8 +123054,8 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f } z = p for { - if v12 = *(*int8)(unsafe.Pointer(z)) != 0; v12 { - v5 = int32(*(*int8)(unsafe.Pointer(z))) + if v12 = **(**int8)(__ccgo_up(z)) != 0; v12 { + v5 = int32(**(**int8)(__ccgo_up(z))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _11 _11: @@ -123073,7 +123073,7 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f } if Uint32FromInt32(int32(z)-int32(p)) < uint32(256)-l-uint32(1) { Xmemcpy(tls, canon+uintptr(l)+uintptr(1), p, Uint32FromInt32(int32(z)-int32(p))) - *(*int8)(unsafe.Pointer(canon + uintptr(Uint32FromInt32(int32(z)-int32(p)+int32(1))+l))) = 0 + **(**int8)(__ccgo_up(canon + uintptr(Uint32FromInt32(int32(z)-int32(p)+int32(1))+l))) = 0 cnt = _name_from_dns(tls, buf, canon, canon, family, bp+256) if cnt != 0 { return cnt @@ -123084,7 +123084,7 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f ; p = z } - *(*int8)(unsafe.Pointer(canon + uintptr(l))) = 0 + **(**int8)(__ccgo_up(canon + uintptr(l))) = 0 return _name_from_dns(tls, buf, canon, name, family, bp+256) } @@ -123145,7 +123145,7 @@ func _policyof(tls *TLS, a uintptr) (r uintptr) { if Xmemcmp(tls, a, uintptr(unsafe.Pointer(&_defpolicy))+uintptr(i)*20, uint32(_defpolicy[i].Flen1)) != 0 { goto _1 } - if Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + uintptr(_defpolicy[i].Flen1))))&Int32FromUint8(_defpolicy[i].Fmask) != Int32FromUint8(*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_defpolicy)) + uintptr(i)*20 + uintptr(_defpolicy[i].Flen1)))) { + if Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + uintptr(_defpolicy[i].Flen1))))&Int32FromUint8(_defpolicy[i].Fmask) != Int32FromUint8(**(**uint8)(__ccgo_up(uintptr(unsafe.Pointer(&_defpolicy)) + uintptr(i)*20 + uintptr(_defpolicy[i].Flen1)))) { goto _1 } return uintptr(unsafe.Pointer(&_defpolicy)) + uintptr(i)*20 @@ -123162,16 +123162,16 @@ func _labelof(tls *TLS, a uintptr) (r int32) { } func _scopeof(tls *TLS, a uintptr) (r int32) { - if Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a))) == int32(0xff) { - return Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 1))) & int32(15) + if Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a))) == int32(0xff) { + return Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 1))) & int32(15) } - if Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a))) == int32(0xfe) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 1)))&int32(0xc0) == int32(0x80) { + if Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a))) == int32(0xfe) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 1)))&int32(0xc0) == int32(0x80) { return int32(2) } - if *(*Tuint32_t)(unsafe.Pointer(a)) == uint32(0) && *(*Tuint32_t)(unsafe.Pointer(a + 1*4)) == uint32(0) && *(*Tuint32_t)(unsafe.Pointer(a + 2*4)) == uint32(0) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 12))) == 0 && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 13))) == 0 && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 14))) == 0 && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 15))) == int32(1) { + if **(**Tuint32_t)(__ccgo_up(a)) == uint32(0) && **(**Tuint32_t)(__ccgo_up(a + 1*4)) == uint32(0) && **(**Tuint32_t)(__ccgo_up(a + 2*4)) == uint32(0) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 12))) == 0 && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 13))) == 0 && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 14))) == 0 && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 15))) == int32(1) { return int32(2) } - if Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a))) == int32(0xfe) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 1)))&int32(0xc0) == int32(0xc0) { + if Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a))) == int32(0xfe) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 1)))&int32(0xc0) == int32(0xc0) { return int32(5) } return int32(14) @@ -123182,7 +123182,7 @@ func _prefixmatch(tls *TLS, s uintptr, d uintptr) (r int32) { _ = i i = uint32(0) for { - if !(i < uint32(128) && !((Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(s + uintptr(i/uint32(8)))))^Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(d + uintptr(i/uint32(8))))))&(Int32FromInt32(128)>>(i%Uint32FromInt32(8))) != 0)) { + if !(i < uint32(128) && !((Int32FromUint8(**(**Tuint8_t)(__ccgo_up(s + uintptr(i/uint32(8)))))^Int32FromUint8(**(**Tuint8_t)(__ccgo_up(d + uintptr(i/uint32(8))))))&(Int32FromInt32(128)>>(i%Uint32FromInt32(8))) != 0)) { break } goto _1 @@ -123220,7 +123220,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i var _ /* salen at bp+92 */ Tsocklen_t _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cnt, da, dalen, dlabel, dpolicy, dprec, dscope, family1, fd, i, j, key, l, prefixlen, sa, v1 cnt = 0 - *(*int8)(unsafe.Pointer(canon)) = 0 + **(**int8)(__ccgo_up(canon)) = 0 if name != 0 { /* reject empty name and check len so it fits into temp bufs */ l = Xstrnlen(tls, name, uint32(255)) @@ -123264,7 +123264,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i /* If any v6 results exist, remove v4 results. */ i = 0 for { - if !(i < cnt && (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily != int32(PF_INET6)) { + if !(i < cnt && (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Ffamily != int32(PF_INET6)) { break } goto _2 @@ -123278,10 +123278,10 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if !(i < cnt) { break } - if (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily == int32(PF_INET6) { + if (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Ffamily == int32(PF_INET6) { v1 = j j = j + 1 - *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = *(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28)) + **(**Taddress)(__ccgo_up(buf + uintptr(v1)*28)) = **(**Taddress)(__ccgo_up(buf + uintptr(i)*28)) } goto _3 _3: @@ -123299,12 +123299,12 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if !(i < cnt) { break } - if (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily != int32(PF_INET) { + if (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Ffamily != int32(PF_INET) { goto _6 } Xmemcpy(tls, buf+uintptr(i)*28+8+uintptr(12), buf+uintptr(i)*28+8, uint32(4)) Xmemcpy(tls, buf+uintptr(i)*28+8, __ccgo_ts+942, uint32(12)) - (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily = int32(PF_INET6) + (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Ffamily = int32(PF_INET6) goto _6 _6: ; @@ -123321,7 +123321,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if !(i < cnt) { break } - if (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily != int32(PF_INET) { + if (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Ffamily != int32(PF_INET) { break } goto _7 @@ -123343,16 +123343,16 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if !(i < cnt) { break } - family1 = (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily + family1 = (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Ffamily key = 0 - *(*Tsockaddr_in6)(unsafe.Pointer(bp + 4)) = Tsockaddr_in6{} - *(*Tsockaddr_in6)(unsafe.Pointer(bp + 32)) = Tsockaddr_in6{ + **(**Tsockaddr_in6)(__ccgo_up(bp + 4)) = Tsockaddr_in6{} + **(**Tsockaddr_in6)(__ccgo_up(bp + 32)) = Tsockaddr_in6{ Fsin6_family: uint16(PF_INET6), Fsin6_port: uint16(65535), - Fsin6_scope_id: (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Fscopeid, + Fsin6_scope_id: (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Fscopeid, } - *(*Tsockaddr_in)(unsafe.Pointer(bp + 60)) = Tsockaddr_in{} - *(*Tsockaddr_in)(unsafe.Pointer(bp + 76)) = Tsockaddr_in{ + **(**Tsockaddr_in)(__ccgo_up(bp + 60)) = Tsockaddr_in{} + **(**Tsockaddr_in)(__ccgo_up(bp + 76)) = Tsockaddr_in{ Fsin_family: uint16(PF_INET), Fsin_port: uint16(65535), } @@ -123361,7 +123361,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i da = bp + 32 dalen = uint32(28) sa = bp + 4 - *(*Tsocklen_t)(unsafe.Pointer(bp + 92)) = uint32(28) + **(**Tsocklen_t)(__ccgo_up(bp + 92)) = uint32(28) } else { Xmemcpy(tls, bp+4+8, __ccgo_ts+942, uint32(12)) Xmemcpy(tls, bp+32+8+uintptr(12), buf+uintptr(i)*28+8, uint32(4)) @@ -123371,7 +123371,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i da = bp + 76 dalen = uint32(16) sa = bp + 60 - *(*Tsocklen_t)(unsafe.Pointer(bp + 92)) = uint32(16) + **(**Tsocklen_t)(__ccgo_up(bp + 92)) = uint32(16) } dpolicy = _policyof(tls, bp+32+8) dscope = _scopeof(tls, bp+32+8) @@ -123401,14 +123401,14 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i key = key | (int32(15)-dscope)< uint32(65535) { return -int32(8) } if proto != int32(IPPROTO_UDP) { - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fport = uint16(port) - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_STREAM) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fport = uint16(port) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_STREAM) v1 = cnt cnt = cnt + 1 - (*(*Tservice)(unsafe.Pointer(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_TCP) + (**(**Tservice)(__ccgo_up(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_TCP) } if proto != int32(IPPROTO_TCP) { - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fport = uint16(port) - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_DGRAM) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fport = uint16(port) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_DGRAM) v1 = cnt cnt = cnt + 1 - (*(*Tservice)(unsafe.Pointer(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_UDP) + (**(**Tservice)(__ccgo_up(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_UDP) } return cnt } @@ -123494,7 +123494,7 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i l = _strlen(tls, name) f = X__fopen_rb_ca(tls, __ccgo_ts+955, bp+1164, bp+132, uint32(1032)) if !(f != 0) { - switch *(*int32)(unsafe.Pointer(X__errno_location(tls))) { + switch **(**int32)(__ccgo_up(X__errno_location(tls))) { case int32(ENOENT): fallthrough case int32(ENOTDIR): @@ -123511,8 +123511,8 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i if v3 != 0 { v4 = p p = p + 1 - *(*int8)(unsafe.Pointer(v4)) = int8('\n') - *(*int8)(unsafe.Pointer(p)) = Int8FromInt32(0) + **(**int8)(__ccgo_up(v4)) = int8('\n') + **(**int8)(__ccgo_up(p)) = Int8FromInt32(0) } /* Find service name */ p = bp @@ -123523,7 +123523,7 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i break } if v10 = p > bp; v10 { - v1 = int32(*(*int8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) + v1 = int32(**(**int8)(__ccgo_up(p + uintptr(-Int32FromInt32(1))))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _9 _9: @@ -123531,8 +123531,8 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i if v10 && !(v2 != 0) { goto _5 } - if v10 = *(*int8)(unsafe.Pointer(p + uintptr(l))) != 0; v10 { - v1 = int32(*(*int8)(unsafe.Pointer(p + uintptr(l)))) + if v10 = **(**int8)(__ccgo_up(p + uintptr(l))) != 0; v10 { + v1 = int32(**(**int8)(__ccgo_up(p + uintptr(l)))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _13 _13: @@ -123552,8 +123552,8 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i /* Skip past canonical name at beginning of line */ p = bp for { - if v10 = *(*int8)(unsafe.Pointer(p)) != 0; v10 { - v1 = int32(*(*int8)(unsafe.Pointer(p))) + if v10 = **(**int8)(__ccgo_up(p)) != 0; v10 { + v1 = int32(**(**int8)(__ccgo_up(p))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _18 _18: @@ -123567,28 +123567,28 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i p = p + 1 } port = Xstrtoul(tls, p, bp+128, int32(10)) - if port > uint32(65535) || *(*uintptr)(unsafe.Pointer(bp + 128)) == p { + if port > uint32(65535) || **(**uintptr)(__ccgo_up(bp + 128)) == p { continue } - if !(Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(bp + 128)), __ccgo_ts+969, uint32(4)) != 0) { + if !(Xstrncmp(tls, **(**uintptr)(__ccgo_up(bp + 128)), __ccgo_ts+969, uint32(4)) != 0) { if proto == int32(IPPROTO_TCP) { continue } - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fport = uint16(port) - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_DGRAM) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fport = uint16(port) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_DGRAM) v1 = cnt cnt = cnt + 1 - (*(*Tservice)(unsafe.Pointer(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_UDP) + (**(**Tservice)(__ccgo_up(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_UDP) } - if !(Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(bp + 128)), __ccgo_ts+974, uint32(4)) != 0) { + if !(Xstrncmp(tls, **(**uintptr)(__ccgo_up(bp + 128)), __ccgo_ts+974, uint32(4)) != 0) { if proto == int32(IPPROTO_UDP) { continue } - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fport = uint16(port) - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_STREAM) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fport = uint16(port) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_STREAM) v1 = cnt cnt = cnt + 1 - (*(*Tservice)(unsafe.Pointer(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_TCP) + (**(**Tservice)(__ccgo_up(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_TCP) } } X__fclose_ca(tls, f) @@ -123618,58 +123618,58 @@ func ___netlink_enumerate(tls *TLS, fd int32, seq uint32, type1 int32, af int32, (*(*struct { Fnlh Tnlmsghdr Fg Trtgenmsg - })(unsafe.Pointer(&*(*struct { + })(unsafe.Pointer(&**(**struct { Freq [0]struct { Fnlh Tnlmsghdr Fg Trtgenmsg } Freply [0]Tnlmsghdr Fbuf [8192]Tuint8_t - })(unsafe.Pointer(bp))))).Fnlh.Fnlmsg_len = uint32(20) + })(__ccgo_up(bp))))).Fnlh.Fnlmsg_len = uint32(20) (*(*struct { Fnlh Tnlmsghdr Fg Trtgenmsg - })(unsafe.Pointer(&*(*struct { + })(unsafe.Pointer(&**(**struct { Freq [0]struct { Fnlh Tnlmsghdr Fg Trtgenmsg } Freply [0]Tnlmsghdr Fbuf [8192]Tuint8_t - })(unsafe.Pointer(bp))))).Fnlh.Fnlmsg_type = Uint16FromInt32(type1) + })(__ccgo_up(bp))))).Fnlh.Fnlmsg_type = Uint16FromInt32(type1) (*(*struct { Fnlh Tnlmsghdr Fg Trtgenmsg - })(unsafe.Pointer(&*(*struct { + })(unsafe.Pointer(&**(**struct { Freq [0]struct { Fnlh Tnlmsghdr Fg Trtgenmsg } Freply [0]Tnlmsghdr Fbuf [8192]Tuint8_t - })(unsafe.Pointer(bp))))).Fnlh.Fnlmsg_flags = Uint16FromInt32(Int32FromInt32(NLM_F_ROOT) | Int32FromInt32(NLM_F_MATCH) | Int32FromInt32(NLM_F_REQUEST)) + })(__ccgo_up(bp))))).Fnlh.Fnlmsg_flags = Uint16FromInt32(Int32FromInt32(NLM_F_ROOT) | Int32FromInt32(NLM_F_MATCH) | Int32FromInt32(NLM_F_REQUEST)) (*(*struct { Fnlh Tnlmsghdr Fg Trtgenmsg - })(unsafe.Pointer(&*(*struct { + })(unsafe.Pointer(&**(**struct { Freq [0]struct { Fnlh Tnlmsghdr Fg Trtgenmsg } Freply [0]Tnlmsghdr Fbuf [8192]Tuint8_t - })(unsafe.Pointer(bp))))).Fnlh.Fnlmsg_seq = seq + })(__ccgo_up(bp))))).Fnlh.Fnlmsg_seq = seq (*(*struct { Fnlh Tnlmsghdr Fg Trtgenmsg - })(unsafe.Pointer(&*(*struct { + })(unsafe.Pointer(&**(**struct { Freq [0]struct { Fnlh Tnlmsghdr Fg Trtgenmsg } Freply [0]Tnlmsghdr Fbuf [8192]Tuint8_t - })(unsafe.Pointer(bp))))).Fg.Frtgen_family = Uint8FromInt32(af) + })(__ccgo_up(bp))))).Fg.Frtgen_family = Uint8FromInt32(af) r = Xsend(tls, fd, bp, uint32(20), 0) if r < 0 { return r @@ -123745,7 +123745,7 @@ func Xns_get16(tls *TLS, cp uintptr) (r uint32) { trc("tls=%v cp=%v, (%v:)", tls, cp, origin(2)) defer func() { trc("-> %v", r) }() } - return Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(cp)))< %v", r) }() } - return uint32(uint32(*(*uint8)(unsafe.Pointer(cp)))<> int32(8)) + **(**uint8)(__ccgo_up(v1)) = uint8(s >> int32(8)) v1 = cp cp = cp + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(s) + **(**uint8)(__ccgo_up(v1)) = uint8(s) } func Xns_put32(tls *TLS, l uint32, cp uintptr) { @@ -123778,16 +123778,16 @@ func Xns_put32(tls *TLS, l uint32, cp uintptr) { _ = v1 v1 = cp cp = cp + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(l >> int32(24)) + **(**uint8)(__ccgo_up(v1)) = uint8(l >> int32(24)) v1 = cp cp = cp + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(l >> int32(16)) + **(**uint8)(__ccgo_up(v1)) = uint8(l >> int32(16)) v1 = cp cp = cp + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(l >> int32(8)) + **(**uint8)(__ccgo_up(v1)) = uint8(l >> int32(8)) v1 = cp cp = cp + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(l) + **(**uint8)(__ccgo_up(v1)) = uint8(l) } func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int32) { @@ -123812,7 +123812,7 @@ func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int3 break } msg = msg + uintptr(2) - *(*Tuint16_t)(unsafe.Pointer(handle + 12 + uintptr(i)*2)) = uint16(Xns_get16(tls, msg-uintptr(2))) + **(**Tuint16_t)(__ccgo_up(handle + 12 + uintptr(i)*2)) = uint16(Xns_get16(tls, msg-uintptr(2))) goto _1 _1: ; @@ -123823,15 +123823,15 @@ func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int3 if !(i < int32(_ns_s_max)) { break } - if *(*Tuint16_t)(unsafe.Pointer(handle + 12 + uintptr(i)*2)) != 0 { - *(*uintptr)(unsafe.Pointer(handle + 20 + uintptr(i)*4)) = msg - r = Xns_skiprr(tls, msg, (*Tns_msg)(unsafe.Pointer(handle)).F_eom, i, Int32FromUint16(*(*Tuint16_t)(unsafe.Pointer(handle + 12 + uintptr(i)*2)))) + if **(**Tuint16_t)(__ccgo_up(handle + 12 + uintptr(i)*2)) != 0 { + **(**uintptr)(__ccgo_up(handle + 20 + uintptr(i)*4)) = msg + r = Xns_skiprr(tls, msg, (*Tns_msg)(unsafe.Pointer(handle)).F_eom, i, Int32FromUint16(**(**Tuint16_t)(__ccgo_up(handle + 12 + uintptr(i)*2)))) if r < 0 { return -int32(1) } msg = msg + uintptr(r) } else { - *(*uintptr)(unsafe.Pointer(handle + 20 + uintptr(i)*4)) = UintptrFromInt32(0) + **(**uintptr)(__ccgo_up(handle + 20 + uintptr(i)*4)) = UintptrFromInt32(0) } goto _2 _2: @@ -123848,7 +123848,7 @@ func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int3 goto bad bad: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EMSGSIZE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EMSGSIZE) return -int32(1) } @@ -123892,7 +123892,7 @@ func Xns_skiprr(tls *TLS, ptr uintptr, eom uintptr, section Tns_sect, count int3 goto bad bad: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EMSGSIZE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EMSGSIZE) return -int32(1) } @@ -123910,31 +123910,31 @@ func Xns_parserr(tls *TLS, handle uintptr, section Tns_sect, rrnum int32, rr uin if section != (*Tns_msg)(unsafe.Pointer(handle)).F_sect { (*Tns_msg)(unsafe.Pointer(handle)).F_sect = section (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum = 0 - (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr = *(*uintptr)(unsafe.Pointer(handle + 20 + uintptr(section)*4)) + (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr = **(**uintptr)(__ccgo_up(handle + 20 + uintptr(section)*4)) } if rrnum == -int32(1) { rrnum = (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum } - if rrnum < 0 || rrnum >= Int32FromUint16(*(*Tuint16_t)(unsafe.Pointer(handle + 12 + uintptr(section)*2))) { + if rrnum < 0 || rrnum >= Int32FromUint16(**(**Tuint16_t)(__ccgo_up(handle + 12 + uintptr(section)*2))) { goto bad } if rrnum < (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum { (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum = 0 - (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr = *(*uintptr)(unsafe.Pointer(handle + 20 + uintptr(section)*4)) + (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr = **(**uintptr)(__ccgo_up(handle + 20 + uintptr(section)*4)) } if rrnum > (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum { r = Xns_skiprr(tls, (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr, (*Tns_msg)(unsafe.Pointer(handle)).F_eom, section, rrnum-(*Tns_msg)(unsafe.Pointer(handle)).F_rrnum) if r < 0 { return -int32(1) } - *(*uintptr)(unsafe.Pointer(handle + 44)) += uintptr(r) + **(**uintptr)(__ccgo_up(handle + 44)) += uintptr(r) (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum = rrnum } r = Xns_name_uncompress(tls, (*Tns_msg)(unsafe.Pointer(handle)).F_msg, (*Tns_msg)(unsafe.Pointer(handle)).F_eom, (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr, rr, uint32(NS_MAXDNAME)) if r < 0 { return -int32(1) } - *(*uintptr)(unsafe.Pointer(handle + 44)) += uintptr(r) + **(**uintptr)(__ccgo_up(handle + 44)) += uintptr(r) if Int32FromInt32(2)*Int32FromInt32(NS_INT16SZ) > int32((*Tns_msg)(unsafe.Pointer(handle)).F_eom)-int32((*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr) { goto size } @@ -123958,14 +123958,14 @@ func Xns_parserr(tls *TLS, handle uintptr, section Tns_sect, rrnum int32, rr uin goto size } (*Tns_rr)(unsafe.Pointer(rr)).Frdata = (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr - *(*uintptr)(unsafe.Pointer(handle + 44)) += uintptr((*Tns_rr)(unsafe.Pointer(rr)).Frdlength) + **(**uintptr)(__ccgo_up(handle + 44)) += uintptr((*Tns_rr)(unsafe.Pointer(rr)).Frdlength) } else { (*Tns_rr)(unsafe.Pointer(rr)).Fttl = uint32(0) (*Tns_rr)(unsafe.Pointer(rr)).Frdlength = uint16(0) (*Tns_rr)(unsafe.Pointer(rr)).Frdata = UintptrFromInt32(0) } (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum = (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum + 1 - if (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum > Int32FromUint16(*(*Tuint16_t)(unsafe.Pointer(handle + 12 + uintptr(section)*2))) { + if (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum > Int32FromUint16(**(**Tuint16_t)(__ccgo_up(handle + 12 + uintptr(section)*2))) { (*Tns_msg)(unsafe.Pointer(handle)).F_sect = section + int32(1) if (*Tns_msg)(unsafe.Pointer(handle)).F_sect == int32(_ns_s_max) { (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum = -int32(1) @@ -123978,12 +123978,12 @@ func Xns_parserr(tls *TLS, handle uintptr, section Tns_sect, rrnum int32, rr uin goto bad bad: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENODEV) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENODEV) return -int32(1) goto size size: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EMSGSIZE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EMSGSIZE) return -int32(1) } @@ -123996,7 +123996,7 @@ func Xns_name_uncompress(tls *TLS, msg uintptr, eom uintptr, src uintptr, dst ui _ = r r = Xdn_expand(tls, msg, eom, src, dst, Int32FromUint32(dstsiz)) if r < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EMSGSIZE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EMSGSIZE) } return r } @@ -124236,7 +124236,7 @@ func Xrecvmmsg(tls *TLS, fd int32, msgvec uintptr, vlen uint32, flags uint32, ti if !(Uint32FromInt32(i) < vlen) { break } - *(*Tsocklen_t)(unsafe.Add(unsafe.Pointer(csize), i*4)) = (*(*Tmmsghdr)(unsafe.Pointer(msgvec + uintptr(i)*32))).Fmsg_hdr.Fmsg_controllen + *(*Tsocklen_t)(unsafe.Add(unsafe.Pointer(csize), i*4)) = (**(**Tmmsghdr)(__ccgo_up(msgvec + uintptr(i)*32))).Fmsg_hdr.Fmsg_controllen goto _5 _5: ; @@ -124322,9 +124322,9 @@ func X__convert_scm_timestamps(tls *TLS, msg uintptr, csize Tsocklen_t) { common: ; Xmemcpy(tls, bp, cmsg+UintptrFromInt32(1)*12, uint32(4)) - (*(*[2]int64)(unsafe.Pointer(bp + 4)))[0] = int64(*(*int32)(unsafe.Pointer(bp))) + (**(**[2]int64)(__ccgo_up(bp + 4)))[0] = int64(**(**int32)(__ccgo_up(bp))) Xmemcpy(tls, bp, cmsg+UintptrFromInt32(1)*12+uintptr(4), uint32(4)) - (*(*[2]int64)(unsafe.Pointer(bp + 4)))[int32(1)] = int64(*(*int32)(unsafe.Pointer(bp))) + (**(**[2]int64)(__ccgo_up(bp + 4)))[int32(1)] = int64(**(**int32)(__ccgo_up(bp))) goto _5 _5: } @@ -124343,10 +124343,10 @@ func X__convert_scm_timestamps(tls *TLS, msg uintptr, csize Tsocklen_t) { return } if (Uint32FromInt64(16)+Uint32FromInt64(4)-Uint32FromInt32(1)) & ^(Uint32FromInt64(4)-Uint32FromInt32(1)) + (Uint32FromInt64(12)+Uint32FromInt64(4)-Uint32FromInt32(1)) & ^(Uint32FromInt64(4)-Uint32FromInt32(1)) > csize-(*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_controllen { - *(*int32)(unsafe.Pointer(msg + 24)) |= int32(MSG_CTRUNC) + **(**int32)(__ccgo_up(msg + 24)) |= int32(MSG_CTRUNC) return } - *(*Tsocklen_t)(unsafe.Pointer(msg + 20)) += (Uint32FromInt64(16)+Uint32FromInt64(4)-Uint32FromInt32(1)) & ^(Uint32FromInt64(4)-Uint32FromInt32(1)) + (Uint32FromInt64(12)+Uint32FromInt64(4)-Uint32FromInt32(1)) & ^(Uint32FromInt64(4)-Uint32FromInt32(1)) + **(**Tsocklen_t)(__ccgo_up(msg + 20)) += (Uint32FromInt64(16)+Uint32FromInt64(4)-Uint32FromInt32(1)) & ^(Uint32FromInt64(4)-Uint32FromInt32(1)) + (Uint32FromInt64(12)+Uint32FromInt64(4)-Uint32FromInt32(1)) & ^(Uint32FromInt64(4)-Uint32FromInt32(1)) if (*Tcmsghdr)(unsafe.Pointer(last)).Fcmsg_len < uint32(12) || uint32((*Tcmsghdr)(unsafe.Pointer(last)).Fcmsg_len+Uint32FromInt64(4)-Uint32FromInt32(1))&Uint32FromInt32(^Int32FromUint32(Uint32FromInt64(4)-Uint32FromInt32(1)))+uint32(12) >= Uint32FromInt32(int32((*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_control+uintptr((*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_controllen))-int32(last)) { v2 = uintptr(0) } else { @@ -124442,10 +124442,10 @@ func X__res_mkquery(tls *TLS, op int32, dname uintptr, class int32, type1 int32, var _ /* ts at bp+280 */ Ttimespec _, _, _, _, _ = i, id, j, l, n l = Xstrnlen(tls, dname, uint32(255)) - if l != 0 && int32(*(*int8)(unsafe.Pointer(dname + uintptr(l-uint32(1))))) == int32('.') { + if l != 0 && int32(**(**int8)(__ccgo_up(dname + uintptr(l-uint32(1))))) == int32('.') { l = l - 1 } - if l != 0 && int32(*(*int8)(unsafe.Pointer(dname + uintptr(l-uint32(1))))) == int32('.') { + if l != 0 && int32(**(**int8)(__ccgo_up(dname + uintptr(l-uint32(1))))) == int32('.') { return -int32(1) } n = Int32FromUint32(uint32(17) + l + BoolUint32(!!(l != 0))) @@ -124454,18 +124454,18 @@ func X__res_mkquery(tls *TLS, op int32, dname uintptr, class int32, type1 int32, } /* Construct query template - ID will be filled later */ Xmemset(tls, bp, 0, Uint32FromInt32(n)) - (*(*[280]uint8)(unsafe.Pointer(bp)))[int32(2)] = Uint8FromInt32(op*int32(8) + int32(1)) - (*(*[280]uint8)(unsafe.Pointer(bp)))[int32(3)] = uint8(32) /* AD */ - (*(*[280]uint8)(unsafe.Pointer(bp)))[int32(5)] = uint8(1) + (**(**[280]uint8)(__ccgo_up(bp)))[int32(2)] = Uint8FromInt32(op*int32(8) + int32(1)) + (**(**[280]uint8)(__ccgo_up(bp)))[int32(3)] = uint8(32) /* AD */ + (**(**[280]uint8)(__ccgo_up(bp)))[int32(5)] = uint8(1) Xmemcpy(tls, bp+uintptr(13), dname, l) i = int32(13) for { - if !((*(*[280]uint8)(unsafe.Pointer(bp)))[i] != 0) { + if !((**(**[280]uint8)(__ccgo_up(bp)))[i] != 0) { break } j = i for { - if !((*(*[280]uint8)(unsafe.Pointer(bp)))[j] != 0 && Int32FromUint8((*(*[280]uint8)(unsafe.Pointer(bp)))[j]) != int32('.')) { + if !((**(**[280]uint8)(__ccgo_up(bp)))[j] != 0 && Int32FromUint8((**(**[280]uint8)(__ccgo_up(bp)))[j]) != int32('.')) { break } goto _2 @@ -124476,19 +124476,19 @@ func X__res_mkquery(tls *TLS, op int32, dname uintptr, class int32, type1 int32, if Uint32FromInt32(j-i)-uint32(1) > uint32(62) { return -int32(1) } - (*(*[280]uint8)(unsafe.Pointer(bp)))[i-int32(1)] = Uint8FromInt32(j - i) + (**(**[280]uint8)(__ccgo_up(bp)))[i-int32(1)] = Uint8FromInt32(j - i) goto _1 _1: ; i = j + int32(1) } - (*(*[280]uint8)(unsafe.Pointer(bp)))[i+int32(1)] = Uint8FromInt32(type1) - (*(*[280]uint8)(unsafe.Pointer(bp)))[i+int32(3)] = Uint8FromInt32(class) + (**(**[280]uint8)(__ccgo_up(bp)))[i+int32(1)] = Uint8FromInt32(type1) + (**(**[280]uint8)(__ccgo_up(bp)))[i+int32(3)] = Uint8FromInt32(class) /* Make a reasonably unpredictable id */ Xclock_gettime(tls, CLOCK_REALTIME, bp+280) - id = Int32FromUint32((Uint32FromInt32((*(*Ttimespec)(unsafe.Pointer(bp + 280))).Ftv_nsec) + Uint32FromInt32((*(*Ttimespec)(unsafe.Pointer(bp + 280))).Ftv_nsec)/uint32(65536)) & uint32(0xffff)) - (*(*[280]uint8)(unsafe.Pointer(bp)))[0] = Uint8FromInt32(id / int32(256)) - (*(*[280]uint8)(unsafe.Pointer(bp)))[int32(1)] = Uint8FromInt32(id) + id = Int32FromUint32((Uint32FromInt32((**(**Ttimespec)(__ccgo_up(bp + 280))).Ftv_nsec) + Uint32FromInt32((**(**Ttimespec)(__ccgo_up(bp + 280))).Ftv_nsec)/uint32(65536)) & uint32(0xffff)) + (**(**[280]uint8)(__ccgo_up(bp)))[0] = Uint8FromInt32(id / int32(256)) + (**(**[280]uint8)(__ccgo_up(bp)))[int32(1)] = Uint8FromInt32(id) Xmemcpy(tls, buf, bp, Uint32FromInt32(n)) return n } @@ -124605,11 +124605,11 @@ func _cleanup(tls *TLS, p uintptr) { pfd = p i = 0 for { - if !((*(*Tpollfd)(unsafe.Pointer(pfd + uintptr(i)*8))).Ffd >= -int32(1)) { + if !((**(**Tpollfd)(__ccgo_up(pfd + uintptr(i)*8))).Ffd >= -int32(1)) { break } - if (*(*Tpollfd)(unsafe.Pointer(pfd + uintptr(i)*8))).Ffd >= 0 { - X__syscall1(tls, int32(SYS_close), (*(*Tpollfd)(unsafe.Pointer(pfd + uintptr(i)*8))).Ffd) + if (**(**Tpollfd)(__ccgo_up(pfd + uintptr(i)*8))).Ffd >= 0 { + X__syscall1(tls, int32(SYS_close), int32((**(**Tpollfd)(__ccgo_up(pfd + uintptr(i)*8))).Ffd)) } goto _1 _1: @@ -124622,10 +124622,10 @@ func _mtime(tls *TLS) (r uint32) { bp := tls.Alloc(16) defer tls.Free(16) var _ /* ts at bp+0 */ Ttimespec - if Xclock_gettime(tls, int32(CLOCK_MONOTONIC), bp) < 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENOSYS) { + if Xclock_gettime(tls, int32(CLOCK_MONOTONIC), bp) < 0 && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENOSYS) { Xclock_gettime(tls, CLOCK_REALTIME, bp) } - return Uint32FromInt64((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec)*uint32(1000) + Uint32FromInt32((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_nsec/int32(1000000)) + return Uint32FromInt64((**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec)*uint32(1000) + Uint32FromInt32((**(**Ttimespec)(__ccgo_up(bp))).Ftv_nsec/int32(1000000)) } func _start_tcp(tls *TLS, pfd uintptr, family int32, sa uintptr, sl Tsocklen_t, q uintptr, ql int32) (r1 int32) { @@ -124648,7 +124648,7 @@ func _start_tcp(tls *TLS, pfd uintptr, family int32, sa uintptr, sl Tsocklen_t, Fiov_len: Uint32FromInt32(ql), }, } - *(*Tmsghdr)(unsafe.Pointer(bp + 24)) = Tmsghdr{ + **(**Tmsghdr)(__ccgo_up(bp + 24)) = Tmsghdr{ Fmsg_name: sa, Fmsg_namelen: sl, Fmsg_iov: bp, @@ -124666,12 +124666,12 @@ func _start_tcp(tls *TLS, pfd uintptr, family int32, sa uintptr, sl Tsocklen_t, if r >= 0 { return r } - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EINPROGRESS) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EINPROGRESS) { return 0 } } r = Xconnect(tls, fd, sa, sl) - if !(r != 0) || *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EINPROGRESS) { + if !(r != 0) || **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EINPROGRESS) { return 0 } Xclose(tls, fd) @@ -124690,7 +124690,7 @@ func _step_mh(tls *TLS, mh uintptr, n Tsize_t) { return } (*Tiovec)(unsafe.Pointer((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov)).Fiov_base = (*Tiovec)(unsafe.Pointer((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov)).Fiov_base + uintptr(n) - *(*Tsize_t)(unsafe.Pointer((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov + 4)) -= n + **(**Tsize_t)(__ccgo_up((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov + 4)) -= n } /* Internal contract for __res_msend[_rc]: asize must be >=512, nqueries @@ -124742,11 +124742,11 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a F__ccgo_pad2 [12]byte }{} *(*uint16)(unsafe.Pointer(bp + 48)) = uint16(0) - *(*[3]struct { + **(**[3]struct { Fsin6 [0]Tsockaddr_in6 Fsin Tsockaddr_in F__ccgo_pad2 [12]byte - })(unsafe.Pointer(bp + 76)) = [3]struct { + })(__ccgo_up(bp + 76)) = [3]struct { Fsin6 [0]Tsockaddr_in6 Fsin Tsockaddr_in F__ccgo_pad2 [12]byte @@ -124773,16 +124773,16 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a iplit = conf + uintptr(nns)*28 if (*Taddress)(unsafe.Pointer(iplit)).Ffamily == int32(PF_INET) { Xmemcpy(tls, bp+76+uintptr(nns)*28+4, iplit+8, uint32(4)) - (*(*[3]struct { + (**(**[3]struct { Fsin6 [0]Tsockaddr_in6 Fsin Tsockaddr_in F__ccgo_pad2 [12]byte - })(unsafe.Pointer(bp + 76)))[nns].Fsin.Fsin_port = Xhtons(tls, uint16(53)) - (*(*[3]struct { + })(__ccgo_up(bp + 76)))[nns].Fsin.Fsin_port = Xhtons(tls, uint16(53)) + (**(**[3]struct { Fsin6 [0]Tsockaddr_in6 Fsin Tsockaddr_in F__ccgo_pad2 [12]byte - })(unsafe.Pointer(bp + 76)))[nns].Fsin.Fsin_family = uint16(PF_INET) + })(__ccgo_up(bp + 76)))[nns].Fsin.Fsin_family = uint16(PF_INET) } else { sl = uint32(28) Xmemcpy(tls, bp+76+uintptr(nns)*28+8, iplit+8, uint32(16)) @@ -124800,10 +124800,10 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a /* Get local address and open/bind a socket */ fd = Xsocket(tls, family, Int32FromInt32(SOCK_DGRAM)|Int32FromInt32(SOCK_CLOEXEC)|Int32FromInt32(SOCK_NONBLOCK), 0) /* Handle case where system lacks IPv6 support */ - if fd < 0 && family == int32(PF_INET6) && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EAFNOSUPPORT) { + if fd < 0 && family == int32(PF_INET6) && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EAFNOSUPPORT) { i = 0 for { - if !(i < nns && (*(*Taddress)(unsafe.Pointer(conf + uintptr(nns)*28))).Ffamily == int32(PF_INET6)) { + if !(i < nns && (**(**Taddress)(__ccgo_up(conf + uintptr(nns)*28))).Ffamily == int32(PF_INET6)) { break } goto _7 @@ -124812,7 +124812,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a i = i + 1 } if i == nns { - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 160)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 160)), uintptr(0)) return -int32(1) } fd = Xsocket(tls, int32(PF_INET), Int32FromInt32(SOCK_DGRAM)|Int32FromInt32(SOCK_CLOEXEC)|Int32FromInt32(SOCK_NONBLOCK), 0) @@ -124828,11 +124828,11 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a if !(i < nns) { break } - if Int32FromUint16((*(*[3]struct { + if Int32FromUint16((**(**[3]struct { Fsin6 [0]Tsockaddr_in6 Fsin Tsockaddr_in F__ccgo_pad2 [12]byte - })(unsafe.Pointer(bp + 76)))[i].Fsin.Fsin_family) != int32(PF_INET) { + })(__ccgo_up(bp + 76)))[i].Fsin.Fsin_family) != int32(PF_INET) { goto _8 } Xmemcpy(tls, bp+76+uintptr(i)*28+8+uintptr(12), bp+76+uintptr(i)*28+4, uint32(4)) @@ -124846,16 +124846,16 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a i = i + 1 } } - (*(*struct { + (**(**struct { Fsin6 [0]Tsockaddr_in6 Fsin Tsockaddr_in F__ccgo_pad2 [12]byte - })(unsafe.Pointer(bp + 48))).Fsin.Fsin_family = Uint16FromInt32(family) + })(__ccgo_up(bp + 48))).Fsin.Fsin_family = Uint16FromInt32(family) if fd < 0 || Xbind(tls, fd, bp+48, sl) < 0 { if fd >= 0 { Xclose(tls, fd) } - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 160)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 160)), uintptr(0)) return -int32(1) } /* Past this point, there are no errors. Each individual query will @@ -124876,7 +124876,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), nqueries*8))).Fevents = int16(POLLIN) (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), (nqueries+int32(1))*8))).Ffd = -int32(2) __pthread_cleanup_push(tls, bp+164, __ccgo_fp(_cleanup), pfd) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 160)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 160)), uintptr(0)) Xmemset(tls, alens, 0, uint32(4)*Uint32FromInt32(nqueries)) retry_interval = timeout / attempts next = 0 @@ -124892,7 +124892,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a * have an accepted answer. */ i = 0 for { - if !(i < nqueries && *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) > 0) { + if !(i < nqueries && **(**int32)(__ccgo_up(alens + uintptr(i)*4)) > 0) { break } goto _12 @@ -124910,13 +124910,13 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a if !(i < nqueries) { break } - if !(*(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) != 0) { + if !(**(**int32)(__ccgo_up(alens + uintptr(i)*4)) != 0) { j = 0 for { if !(j < nns) { break } - Xsendto(tls, fd, *(*uintptr)(unsafe.Pointer(queries + uintptr(i)*4)), Uint32FromInt32(*(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))), int32(MSG_NOSIGNAL), bp+76+uintptr(j)*28, sl) + Xsendto(tls, fd, **(**uintptr)(__ccgo_up(queries + uintptr(i)*4)), Uint32FromInt32(**(**int32)(__ccgo_up(qlens + uintptr(i)*4))), int32(MSG_NOSIGNAL), bp+76+uintptr(j)*28, sl) goto _14 _14: ; @@ -124938,11 +124938,11 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a for next < nqueries { *(*[1]Tiovec)(unsafe.Pointer(bp + 8)) = [1]Tiovec{ 0: { - Fiov_base: *(*uintptr)(unsafe.Pointer(answers + uintptr(next)*4)), + Fiov_base: **(**uintptr)(__ccgo_up(answers + uintptr(next)*4)), Fiov_len: Uint32FromInt32(asize), }, } - *(*Tmsghdr)(unsafe.Pointer(bp + 176)) = Tmsghdr{ + **(**Tmsghdr)(__ccgo_up(bp + 176)) = Tmsghdr{ Fmsg_name: bp + 48, Fmsg_namelen: sl, Fmsg_iov: bp + 8, @@ -124973,7 +124973,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a /* Find which query this answer goes with, if any */ i = next for { - if !(i < nqueries && (Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(answers + uintptr(next)*4))))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(queries + uintptr(i)*4))))) || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(answers + uintptr(next)*4)) + 1))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(queries + uintptr(i)*4)) + 1))))) { + if !(i < nqueries && (Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(answers + uintptr(next)*4))))) != Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(queries + uintptr(i)*4))))) || Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(answers + uintptr(next)*4)) + 1))) != Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(queries + uintptr(i)*4)) + 1))))) { break } goto _16 @@ -124984,13 +124984,13 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a if i == nqueries { continue } - if *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) != 0 { + if **(**int32)(__ccgo_up(alens + uintptr(i)*4)) != 0 { continue } /* Only accept positive or negative responses; * retry immediately on server failure, and ignore * all other codes such as refusal. */ - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(answers + uintptr(next)*4)) + 3))) & Int32FromInt32(15) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(answers + uintptr(next)*4)) + 3))) & Int32FromInt32(15) { case 0: fallthrough case int32(3): @@ -125000,7 +125000,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a servfail_retry = servfail_retry - 1 } if v18 && v6 != 0 { - Xsendto(tls, fd, *(*uintptr)(unsafe.Pointer(queries + uintptr(i)*4)), Uint32FromInt32(*(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))), int32(MSG_NOSIGNAL), bp+76+uintptr(j)*28, sl) + Xsendto(tls, fd, **(**uintptr)(__ccgo_up(queries + uintptr(i)*4)), Uint32FromInt32(**(**int32)(__ccgo_up(qlens + uintptr(i)*4))), int32(MSG_NOSIGNAL), bp+76+uintptr(j)*28, sl) } fallthrough default: @@ -125008,10 +125008,10 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a } /* Store answer in the right slot, or update next * available temp slot if it's already in place. */ - *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) = rlen + **(**int32)(__ccgo_up(alens + uintptr(i)*4)) = rlen if i == next { for { - if !(next < nqueries && *(*int32)(unsafe.Pointer(alens + uintptr(next)*4)) != 0) { + if !(next < nqueries && **(**int32)(__ccgo_up(alens + uintptr(next)*4)) != 0) { break } goto _19 @@ -125020,18 +125020,18 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a next = next + 1 } } else { - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(answers + uintptr(i)*4)), *(*uintptr)(unsafe.Pointer(answers + uintptr(next)*4)), Uint32FromInt32(rlen)) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(answers + uintptr(i)*4)), **(**uintptr)(__ccgo_up(answers + uintptr(next)*4)), Uint32FromInt32(rlen)) } /* Ignore further UDP if all slots full or TCP-mode */ if next == nqueries { (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), nqueries*8))).Fevents = 0 } /* If answer is truncated (TC bit), fallback to TCP */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(answers + uintptr(i)*4)) + 2)))&int32(2) != 0 || (*(*Tmsghdr)(unsafe.Pointer(bp + 176))).Fmsg_flags&int32(MSG_TRUNC) != 0 { - *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) = -int32(1) + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(answers + uintptr(i)*4)) + 2)))&int32(2) != 0 || (**(**Tmsghdr)(__ccgo_up(bp + 176))).Fmsg_flags&int32(MSG_TRUNC) != 0 { + **(**int32)(__ccgo_up(alens + uintptr(i)*4)) = -int32(1) _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), uintptr(0)) - r = _start_tcp(tls, pfd+uintptr(i)*8, family, bp+76+uintptr(j)*28, sl, *(*uintptr)(unsafe.Pointer(queries + uintptr(i)*4)), *(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 160)), uintptr(0)) + r = _start_tcp(tls, pfd+uintptr(i)*8, family, bp+76+uintptr(j)*28, sl, **(**uintptr)(__ccgo_up(queries + uintptr(i)*4)), **(**int32)(__ccgo_up(qlens + uintptr(i)*4))) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 160)), uintptr(0)) if r >= 0 { *(*int32)(unsafe.Add(unsafe.Pointer(qpos), i*4)) = r *(*int32)(unsafe.Add(unsafe.Pointer(apos), i*4)) = 0 @@ -125046,8 +125046,8 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a } if int32((*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), i*8))).Frevents)&int32(POLLOUT) != 0 { *(*[2]Tuint8_t)(unsafe.Pointer(bp + 28)) = [2]Tuint8_t{ - 0: Uint8FromInt32(*(*int32)(unsafe.Pointer(qlens + uintptr(i)*4)) >> int32(8)), - 1: Uint8FromInt32(*(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))), + 0: Uint8FromInt32(**(**int32)(__ccgo_up(qlens + uintptr(i)*4)) >> int32(8)), + 1: Uint8FromInt32(**(**int32)(__ccgo_up(qlens + uintptr(i)*4))), } *(*[2]Tiovec)(unsafe.Pointer(bp + 12)) = [2]Tiovec{ 0: { @@ -125055,11 +125055,11 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a Fiov_len: uint32(2), }, 1: { - Fiov_base: *(*uintptr)(unsafe.Pointer(queries + uintptr(i)*4)), - Fiov_len: Uint32FromInt32(*(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))), + Fiov_base: **(**uintptr)(__ccgo_up(queries + uintptr(i)*4)), + Fiov_len: Uint32FromInt32(**(**int32)(__ccgo_up(qlens + uintptr(i)*4))), }, } - *(*Tmsghdr)(unsafe.Pointer(bp + 204)) = Tmsghdr{ + **(**Tmsghdr)(__ccgo_up(bp + 204)) = Tmsghdr{ Fmsg_iov: bp + 12, Fmsg_iovlen: int32(2), } @@ -125068,8 +125068,8 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a if r < 0 { goto out } - *(*int32)(unsafe.Pointer(qpos + uintptr(i)*4)) += r - if *(*int32)(unsafe.Add(unsafe.Pointer(qpos), i*4)) == *(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))+int32(2) { + **(**int32)(__ccgo_up(qpos + uintptr(i)*4)) += r + if *(*int32)(unsafe.Add(unsafe.Pointer(qpos), i*4)) == **(**int32)(__ccgo_up(qlens + uintptr(i)*4))+int32(2) { (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), i*8))).Fevents = int16(POLLIN) } } @@ -125090,11 +125090,11 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a Fiov_len: uint32(2), }, 1: { - Fiov_base: *(*uintptr)(unsafe.Pointer(answers + uintptr(i)*4)), + Fiov_base: **(**uintptr)(__ccgo_up(answers + uintptr(i)*4)), Fiov_len: Uint32FromInt32(asize), }, } - *(*Tmsghdr)(unsafe.Pointer(bp + 232)) = Tmsghdr{ + **(**Tmsghdr)(__ccgo_up(bp + 232)) = Tmsghdr{ Fmsg_iov: bp + 32, Fmsg_iovlen: int32(2), } @@ -125103,25 +125103,25 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a if r <= 0 { goto out } - *(*int32)(unsafe.Pointer(apos + uintptr(i)*4)) += r + **(**int32)(__ccgo_up(apos + uintptr(i)*4)) += r if *(*int32)(unsafe.Add(unsafe.Pointer(apos), i*4)) < int32(2) { goto _21 } - alen = Int32FromUint8(*(*uint8)(unsafe.Pointer(alen_buf + uintptr(i)*2)))*int32(256) + Int32FromUint8(*(*uint8)(unsafe.Pointer(alen_buf + uintptr(i)*2 + 1))) + alen = Int32FromUint8(**(**uint8)(__ccgo_up(alen_buf + uintptr(i)*2)))*int32(256) + Int32FromUint8(**(**uint8)(__ccgo_up(alen_buf + uintptr(i)*2 + 1))) if alen < int32(13) { goto out } if *(*int32)(unsafe.Add(unsafe.Pointer(apos), i*4)) < alen+int32(2) && *(*int32)(unsafe.Add(unsafe.Pointer(apos), i*4)) < asize+int32(2) { goto _21 } - rcode = Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(answers + uintptr(i)*4)) + 3))) & int32(15) + rcode = Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(answers + uintptr(i)*4)) + 3))) & int32(15) if rcode != 0 && rcode != int32(3) { goto out } /* Storing the length here commits the accepted answer. * Immediately close TCP socket so as not to consume * resources we no longer need. */ - *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) = alen + **(**int32)(__ccgo_up(alens + uintptr(i)*4)) = alen X__syscall1(tls, int32(SYS_close), (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), i*8))).Ffd) (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), i*8))).Ffd = -int32(1) } @@ -125145,8 +125145,8 @@ out: if !(i < nqueries) { break } - if *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) < 0 { - *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) = 0 + if **(**int32)(__ccgo_up(alens + uintptr(i)*4)) < 0 { + **(**int32)(__ccgo_up(alens + uintptr(i)*4)) = 0 } goto _22 _22: @@ -125184,23 +125184,23 @@ func X__res_send(tls *TLS, _msg uintptr, _msglen int32, _answer uintptr, _anslen var r, v1 int32 var _ /* buf at bp+16 */ [512]uint8 _, _ = r, v1 - if *(*int32)(unsafe.Pointer(bp + 12)) < int32(512) { - r = X__res_send(tls, *(*uintptr)(unsafe.Pointer(bp)), *(*int32)(unsafe.Pointer(bp + 4)), bp+16, int32(512)) + if **(**int32)(__ccgo_up(bp + 12)) < int32(512) { + r = X__res_send(tls, **(**uintptr)(__ccgo_up(bp)), **(**int32)(__ccgo_up(bp + 4)), bp+16, int32(512)) if r >= 0 { - if r < *(*int32)(unsafe.Pointer(bp + 12)) { + if r < **(**int32)(__ccgo_up(bp + 12)) { v1 = r } else { - v1 = *(*int32)(unsafe.Pointer(bp + 12)) + v1 = **(**int32)(__ccgo_up(bp + 12)) } - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(bp + 8)), bp+16, Uint32FromInt32(v1)) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(bp + 8)), bp+16, Uint32FromInt32(v1)) } return r } - r = X__res_msend(tls, int32(1), bp, bp+4, bp+8, bp+12, *(*int32)(unsafe.Pointer(bp + 12))) - if r < 0 || !(*(*int32)(unsafe.Pointer(bp + 12)) != 0) { + r = X__res_msend(tls, int32(1), bp, bp+4, bp+8, bp+12, **(**int32)(__ccgo_up(bp + 12))) + if r < 0 || !(**(**int32)(__ccgo_up(bp + 12)) != 0) { v1 = -int32(1) } else { - v1 = *(*int32)(unsafe.Pointer(bp + 12)) + v1 = **(**int32)(__ccgo_up(bp + 12)) } return v1 } @@ -125247,11 +125247,11 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ (*Tresolvconf)(unsafe.Pointer(conf)).Ftimeout = uint32(5) (*Tresolvconf)(unsafe.Pointer(conf)).Fattempts = uint32(2) if search != 0 { - *(*int8)(unsafe.Pointer(search)) = 0 + **(**int8)(__ccgo_up(search)) = 0 } f = X__fopen_rb_ca(tls, __ccgo_ts+1064, bp+512, bp+256, uint32(256)) if !(f != 0) { - switch *(*int32)(unsafe.Pointer(X__errno_location(tls))) { + switch **(**int32)(__ccgo_up(X__errno_location(tls))) { case int32(ENOENT): fallthrough case int32(ENOTDIR): @@ -125270,17 +125270,17 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ continue } if v4 = !(Xstrncmp(tls, bp, __ccgo_ts+1081, uint32(7)) != 0); v4 { - v1 = int32((*(*[256]int8)(unsafe.Pointer(bp)))[int32(7)]) + v1 = int32((**(**[256]int8)(__ccgo_up(bp)))[int32(7)]) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _3 _3: } if v4 && v2 != 0 { p = Xstrstr(tls, bp, __ccgo_ts+1089) - if p != 0 && BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(p + 6)))-uint32('0') < uint32(10)) != 0 { + if p != 0 && BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(p + 6)))-uint32('0') < uint32(10)) != 0 { p = p + uintptr(6) x = Xstrtoul(tls, p, bp+648, int32(10)) - if *(*uintptr)(unsafe.Pointer(bp + 648)) != p { + if **(**uintptr)(__ccgo_up(bp + 648)) != p { if x > uint32(15) { v5 = uint32(15) } else { @@ -125290,10 +125290,10 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ } } p = Xstrstr(tls, bp, __ccgo_ts+1096) - if p != 0 && BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(p + 9)))-uint32('0') < uint32(10)) != 0 { + if p != 0 && BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(p + 9)))-uint32('0') < uint32(10)) != 0 { p = p + uintptr(9) x1 = Xstrtoul(tls, p, bp+648, int32(10)) - if *(*uintptr)(unsafe.Pointer(bp + 648)) != p { + if **(**uintptr)(__ccgo_up(bp + 648)) != p { if x1 > uint32(10) { v5 = uint32(10) } else { @@ -125303,10 +125303,10 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ } } p = Xstrstr(tls, bp, __ccgo_ts+1106) - if p != 0 && (BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(p + 8)))-uint32('0') < uint32(10)) != 0 || int32(*(*int8)(unsafe.Pointer(p + 8))) == int32('.')) { + if p != 0 && (BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(p + 8)))-uint32('0') < uint32(10)) != 0 || int32(**(**int8)(__ccgo_up(p + 8))) == int32('.')) { p = p + uintptr(8) x2 = Xstrtoul(tls, p, bp+648, int32(10)) - if *(*uintptr)(unsafe.Pointer(bp + 648)) != p { + if **(**uintptr)(__ccgo_up(bp + 648)) != p { if x2 > uint32(60) { v5 = uint32(60) } else { @@ -125318,7 +125318,7 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ continue } if v4 = !(Xstrncmp(tls, bp, __ccgo_ts+1115, uint32(10)) != 0); v4 { - v1 = int32((*(*[256]int8)(unsafe.Pointer(bp)))[int32(10)]) + v1 = int32((**(**[256]int8)(__ccgo_up(bp)))[int32(10)]) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _10 _10: @@ -125329,7 +125329,7 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ } p = bp + uintptr(11) for { - v1 = int32(*(*int8)(unsafe.Pointer(p))) + v1 = int32(**(**int8)(__ccgo_up(p))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _15 _15: @@ -125341,10 +125341,10 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ ; p = p + 1 } - *(*uintptr)(unsafe.Pointer(bp + 648)) = p + **(**uintptr)(__ccgo_up(bp + 648)) = p for { - if v4 = *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 648)))) != 0; v4 { - v1 = int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 648))))) + if v4 = **(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 648)))) != 0; v4 { + v1 = int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 648))))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _19 _19: @@ -125355,9 +125355,9 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ goto _16 _16: ; - *(*uintptr)(unsafe.Pointer(bp + 648)) = *(*uintptr)(unsafe.Pointer(bp + 648)) + 1 + **(**uintptr)(__ccgo_up(bp + 648)) = **(**uintptr)(__ccgo_up(bp + 648)) + 1 } - *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 648)))) = 0 + **(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 648)))) = 0 if X__lookup_ipliteral(tls, conf+uintptr(nns)*28, p, PF_UNSPEC) > 0 { nns = nns + 1 } @@ -125367,7 +125367,7 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ continue } if v4 = Xstrncmp(tls, bp, __ccgo_ts+1126, uint32(6)) != 0 && Xstrncmp(tls, bp, __ccgo_ts+1133, uint32(6)) != 0; !v4 { - v1 = int32((*(*[256]int8)(unsafe.Pointer(bp)))[int32(6)]) + v1 = int32((**(**[256]int8)(__ccgo_up(bp)))[int32(6)]) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _23 _23: @@ -125377,7 +125377,7 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ } p = bp + uintptr(7) for { - v1 = int32(*(*int8)(unsafe.Pointer(p))) + v1 = int32(**(**int8)(__ccgo_up(p))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _28 _28: @@ -125816,7 +125816,7 @@ func Xsockatmark(tls *TLS, s int32) (r int32) { if Xioctl(tls, s, int32(SIOCATMARK), VaList(bp+16, bp)) < 0 { return -int32(1) } - return *(*int32)(unsafe.Pointer(bp)) + return **(**int32)(__ccgo_up(bp)) } func Xsocket(tls *TLS, domain int32, type1 int32, protocol int32) (r1 int32) { @@ -125982,7 +125982,7 @@ func Xsocketpair(tls *TLS, domain int32, type1 int32, protocol int32, fd uintptr goto _11 _11: r1 = X__syscall_ret(tls, Uint32FromInt32(v10)) - if r1 < 0 && (*(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EINVAL) || *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EPROTONOSUPPORT)) && type1&(Int32FromInt32(SOCK_CLOEXEC)|Int32FromInt32(SOCK_NONBLOCK)) != 0 { + if r1 < 0 && (**(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EINVAL) || **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EPROTONOSUPPORT)) && type1&(Int32FromInt32(SOCK_CLOEXEC)|Int32FromInt32(SOCK_NONBLOCK)) != 0 { v12 = int32(SYS_socketpair) v13 = int32(__SC_socketpair) v14 = 0 @@ -126030,12 +126030,12 @@ _11: return r1 } if type1&int32(SOCK_CLOEXEC) != 0 { - X__syscall3(tls, int32(SYS_fcntl64), *(*int32)(unsafe.Pointer(fd)), int32(Int32FromInt32(F_SETFD)), int32(Int32FromInt32(FD_CLOEXEC))) - X__syscall3(tls, int32(SYS_fcntl64), *(*int32)(unsafe.Pointer(fd + 1*4)), int32(Int32FromInt32(F_SETFD)), int32(Int32FromInt32(FD_CLOEXEC))) + X__syscall3(tls, int32(SYS_fcntl64), int32(**(**int32)(__ccgo_up(fd))), int32(Int32FromInt32(F_SETFD)), int32(Int32FromInt32(FD_CLOEXEC))) + X__syscall3(tls, int32(SYS_fcntl64), int32(**(**int32)(__ccgo_up(fd + 1*4))), int32(Int32FromInt32(F_SETFD)), int32(Int32FromInt32(FD_CLOEXEC))) } if type1&int32(SOCK_NONBLOCK) != 0 { - X__syscall3(tls, int32(SYS_fcntl64), *(*int32)(unsafe.Pointer(fd)), int32(Int32FromInt32(F_SETFL)), int32(Int32FromInt32(O_NONBLOCK))) - X__syscall3(tls, int32(SYS_fcntl64), *(*int32)(unsafe.Pointer(fd + 1*4)), int32(Int32FromInt32(F_SETFL)), int32(Int32FromInt32(O_NONBLOCK))) + X__syscall3(tls, int32(SYS_fcntl64), int32(**(**int32)(__ccgo_up(fd))), int32(Int32FromInt32(F_SETFL)), int32(Int32FromInt32(O_NONBLOCK))) + X__syscall3(tls, int32(SYS_fcntl64), int32(**(**int32)(__ccgo_up(fd + 1*4))), int32(Int32FromInt32(F_SETFL)), int32(Int32FromInt32(O_NONBLOCK))) } } return r1 @@ -126072,10 +126072,10 @@ func Xfgetgrent(tls *TLS, f uintptr) (r uintptr) { var _ /* nmem at bp+8 */ Tsize_t var _ /* res at bp+0 */ uintptr var _ /* size at bp+4 */ Tsize_t - *(*Tsize_t)(unsafe.Pointer(bp + 4)) = uint32(0) - *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint32(0) + **(**Tsize_t)(__ccgo_up(bp + 4)) = uint32(0) + **(**Tsize_t)(__ccgo_up(bp + 8)) = uint32(0) X__getgrent_a(tls, f, uintptr(unsafe.Pointer(&_gr)), uintptr(unsafe.Pointer(&_line1)), bp+4, uintptr(unsafe.Pointer(&_mem)), bp+8, bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } var _line1 uintptr @@ -126093,9 +126093,9 @@ func Xfgetpwent(tls *TLS, f uintptr) (r uintptr) { defer tls.Free(16) var _ /* res at bp+4 */ uintptr var _ /* size at bp+0 */ Tsize_t - *(*Tsize_t)(unsafe.Pointer(bp)) = uint32(0) + **(**Tsize_t)(__ccgo_up(bp)) = uint32(0) X__getpwent_a(tls, f, uintptr(unsafe.Pointer(&_pw)), uintptr(unsafe.Pointer(&_line2)), bp, bp+4) - return *(*uintptr)(unsafe.Pointer(bp + 4)) + return **(**uintptr)(__ccgo_up(bp + 4)) } var _line2 uintptr @@ -126141,11 +126141,11 @@ func _itoa1(tls *TLS, p uintptr, x Tuint32_t) (r uintptr) { p = p + uintptr(11) p = p - 1 v1 = p - *(*int8)(unsafe.Pointer(v1)) = 0 + **(**int8)(__ccgo_up(v1)) = 0 for cond := true; cond; cond = x != 0 { p = p - 1 v1 = p - *(*int8)(unsafe.Pointer(v1)) = Int8FromUint32(uint32('0') + x%uint32(10)) + **(**int8)(__ccgo_up(v1)) = Int8FromUint32(uint32('0') + x%uint32(10)) x = x / uint32(10) } return p @@ -126170,36 +126170,36 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz var _ /* swap at bp+40 */ int32 _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, grlist_len, i, key, len1, ptr, req, rv, tmp, tmp1, v1, v10, v5, v6 rv = 0 - *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) + **(**uintptr)(__ccgo_up(res)) = uintptr(0) _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp) f = Xfopen(tls, __ccgo_ts+1150, __ccgo_ts+315) if !(f != 0) { - rv = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + rv = **(**int32)(__ccgo_up(X__errno_location(tls))) goto done } for { v1 = X__getgrent_a(tls, f, gr, buf, size, mem, nmem, res) rv = v1 - if !(!(v1 != 0) && *(*uintptr)(unsafe.Pointer(res)) != 0) { + if !(!(v1 != 0) && **(**uintptr)(__ccgo_up(res)) != 0) { break } - if name != 0 && !(Xstrcmp(tls, name, (*Tgroup)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(res)))).Fgr_name) != 0) || !(name != 0) && (*Tgroup)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(res)))).Fgr_gid == gid { + if name != 0 && !(Xstrcmp(tls, name, (*Tgroup)(unsafe.Pointer(**(**uintptr)(__ccgo_up(res)))).Fgr_name) != 0) || !(name != 0) && (*Tgroup)(unsafe.Pointer(**(**uintptr)(__ccgo_up(res)))).Fgr_gid == gid { break } } Xfclose(tls, f) - if !(*(*uintptr)(unsafe.Pointer(res)) != 0) && (rv == 0 || rv == int32(ENOENT) || rv == int32(ENOTDIR)) { + if !(**(**uintptr)(__ccgo_up(res)) != 0) && (rv == 0 || rv == int32(ENOENT) || rv == int32(ENOTDIR)) { if name != 0 { v1 = int32(GETGRBYNAME) } else { v1 = int32(GETGRBYGID) } req = v1 - *(*[6]Tint32_t)(unsafe.Pointer(bp + 4)) = [6]Tint32_t{} + **(**[6]Tint32_t)(__ccgo_up(bp + 4)) = [6]Tint32_t{} len1 = uint32(0) grlist_len = uint32(0) - *(*[11]int8)(unsafe.Pointer(bp + 28)) = [11]int8{} - *(*int32)(unsafe.Pointer(bp + 40)) = 0 + **(**[11]int8)(__ccgo_up(bp + 28)) = [11]int8{} + **(**int32)(__ccgo_up(bp + 40)) = 0 if name != 0 { key = name } else { @@ -126211,116 +126211,116 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz } f = X__nscd_query(tls, req, key, bp+4, uint32(24), bp+40) if !(f != 0) { - rv = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + rv = **(**int32)(__ccgo_up(X__errno_location(tls))) goto done } - if !((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRFOUND)] != 0) { + if !((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRFOUND)] != 0) { rv = 0 goto cleanup_f } - if !((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRNAMELEN)] != 0) || !((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRPASSWDLEN)] != 0) { + if !((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRNAMELEN)] != 0) || !((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRPASSWDLEN)] != 0) { rv = int32(EIO) goto cleanup_f } - if Uint32FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRNAMELEN)]) > uint32(0xffffffff)-Uint32FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRPASSWDLEN)]) { + if Uint32FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRNAMELEN)]) > uint32(0xffffffff)-Uint32FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRPASSWDLEN)]) { rv = int32(ENOMEM) goto cleanup_f } - len1 = Uint32FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRNAMELEN)] + (*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRPASSWDLEN)]) + len1 = Uint32FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRNAMELEN)] + (**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRPASSWDLEN)]) i = 0 for { - if !(i < (*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)]) { + if !(i < (**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)]) { break } if Xfread(tls, bp+44, uint32(4), uint32(1), f) < uint32(1) { if Xferror(tls, f) != 0 { - v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = **(**int32)(__ccgo_up(X__errno_location(tls))) } else { v1 = int32(EIO) } rv = v1 goto cleanup_f } - if *(*int32)(unsafe.Pointer(bp + 40)) != 0 { - v5 = *(*Tuint32_t)(unsafe.Pointer(bp + 44)) + if **(**int32)(__ccgo_up(bp + 40)) != 0 { + v5 = **(**Tuint32_t)(__ccgo_up(bp + 44)) v6 = v5>>int32(24) | v5>>int32(8)&uint32(0xff00) | v5< uint32(0xffffffff)-grlist_len || *(*Tuint32_t)(unsafe.Pointer(bp + 44)) > uint32(0xffffffff)-len1 { + if **(**Tuint32_t)(__ccgo_up(bp + 44)) > uint32(0xffffffff)-grlist_len || **(**Tuint32_t)(__ccgo_up(bp + 44)) > uint32(0xffffffff)-len1 { rv = int32(ENOMEM) goto cleanup_f } - len1 = len1 + *(*Tuint32_t)(unsafe.Pointer(bp + 44)) - grlist_len = grlist_len + *(*Tuint32_t)(unsafe.Pointer(bp + 44)) + len1 = len1 + **(**Tuint32_t)(__ccgo_up(bp + 44)) + grlist_len = grlist_len + **(**Tuint32_t)(__ccgo_up(bp + 44)) goto _3 _3: ; i = i + 1 } - if len1 > *(*Tsize_t)(unsafe.Pointer(size)) || !(*(*uintptr)(unsafe.Pointer(buf)) != 0) { - tmp = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(buf)), len1) + if len1 > **(**Tsize_t)(__ccgo_up(size)) || !(**(**uintptr)(__ccgo_up(buf)) != 0) { + tmp = Xrealloc(tls, **(**uintptr)(__ccgo_up(buf)), len1) if !(tmp != 0) { - rv = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + rv = **(**int32)(__ccgo_up(X__errno_location(tls))) goto cleanup_f } - *(*uintptr)(unsafe.Pointer(buf)) = tmp - *(*Tsize_t)(unsafe.Pointer(size)) = len1 + **(**uintptr)(__ccgo_up(buf)) = tmp + **(**Tsize_t)(__ccgo_up(size)) = len1 } - if !(Xfread(tls, *(*uintptr)(unsafe.Pointer(buf)), len1, uint32(1), f) != 0) { + if !(Xfread(tls, **(**uintptr)(__ccgo_up(buf)), len1, uint32(1), f) != 0) { if Xferror(tls, f) != 0 { - v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = **(**int32)(__ccgo_up(X__errno_location(tls))) } else { v1 = int32(EIO) } rv = v1 goto cleanup_f } - if Uint32FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)]+int32(1)) > *(*Tsize_t)(unsafe.Pointer(nmem)) { - if Uint32FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)]+int32(1)) > Uint32FromUint32(0xffffffff)/Uint32FromInt64(4) { + if Uint32FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)]+int32(1)) > **(**Tsize_t)(__ccgo_up(nmem)) { + if Uint32FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)]+int32(1)) > Uint32FromUint32(0xffffffff)/Uint32FromInt64(4) { rv = int32(ENOMEM) goto cleanup_f } - tmp1 = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(mem)), Uint32FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)]+Int32FromInt32(1))*uint32(4)) + tmp1 = Xrealloc(tls, **(**uintptr)(__ccgo_up(mem)), Uint32FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)]+Int32FromInt32(1))*uint32(4)) if !(tmp1 != 0) { - rv = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + rv = **(**int32)(__ccgo_up(X__errno_location(tls))) goto cleanup_f } - *(*uintptr)(unsafe.Pointer(mem)) = tmp1 - *(*Tsize_t)(unsafe.Pointer(nmem)) = Uint32FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)] + int32(1)) + **(**uintptr)(__ccgo_up(mem)) = tmp1 + **(**Tsize_t)(__ccgo_up(nmem)) = Uint32FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)] + int32(1)) } - if (*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)] != 0 { - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)))) = *(*uintptr)(unsafe.Pointer(buf)) + uintptr((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRNAMELEN)]) + uintptr((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRPASSWDLEN)]) - ptr = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)))) + if (**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)] != 0 { + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)))) = **(**uintptr)(__ccgo_up(buf)) + uintptr((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRNAMELEN)]) + uintptr((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRPASSWDLEN)]) + ptr = **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)))) i = Int32FromInt32(0) for { - if !(ptr != *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem))))+uintptr(grlist_len)) { + if !(ptr != **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem))))+uintptr(grlist_len)) { break } - if !(*(*int8)(unsafe.Pointer(ptr)) != 0) { + if !(**(**int8)(__ccgo_up(ptr)) != 0) { i = i + 1 v10 = i - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v10)*4)) = ptr + uintptr(1) + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)) + uintptr(v10)*4)) = ptr + uintptr(1) } goto _9 _9: ; ptr = ptr + 1 } - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(i)*4)) = uintptr(0) - if i != (*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)] { + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)) + uintptr(i)*4)) = uintptr(0) + if i != (**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)] { rv = int32(EIO) goto cleanup_f } } else { - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)))) = uintptr(0) + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)))) = uintptr(0) } - (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = *(*uintptr)(unsafe.Pointer(buf)) - (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = (*Tgroup)(unsafe.Pointer(gr)).Fgr_name + uintptr((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRNAMELEN)]) - (*Tgroup)(unsafe.Pointer(gr)).Fgr_gid = Uint32FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRGID)]) - (*Tgroup)(unsafe.Pointer(gr)).Fgr_mem = *(*uintptr)(unsafe.Pointer(mem)) - if *(*int8)(unsafe.Pointer((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd + uintptr(-Int32FromInt32(1)))) != 0 || *(*int8)(unsafe.Pointer((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd + uintptr((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRPASSWDLEN)]-int32(1)))) != 0 { + (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = **(**uintptr)(__ccgo_up(buf)) + (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = (*Tgroup)(unsafe.Pointer(gr)).Fgr_name + uintptr((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRNAMELEN)]) + (*Tgroup)(unsafe.Pointer(gr)).Fgr_gid = Uint32FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRGID)]) + (*Tgroup)(unsafe.Pointer(gr)).Fgr_mem = **(**uintptr)(__ccgo_up(mem)) + if **(**int8)(__ccgo_up((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd + uintptr(-Int32FromInt32(1)))) != 0 || **(**int8)(__ccgo_up((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd + uintptr((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRPASSWDLEN)]-int32(1)))) != 0 { rv = int32(EIO) goto cleanup_f } @@ -126328,7 +126328,7 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz rv = int32(EIO) goto cleanup_f } - *(*uintptr)(unsafe.Pointer(res)) = gr + **(**uintptr)(__ccgo_up(res)) = gr goto cleanup_f cleanup_f: ; @@ -126338,9 +126338,9 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz goto done done: ; - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) if rv != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = rv + **(**int32)(__ccgo_up(X__errno_location(tls))) = rv } return rv } @@ -126356,42 +126356,42 @@ func _getgr_r(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, size var _ /* mem at bp+8 */ uintptr var _ /* nmem at bp+12 */ Tsize_t _, _ = i, rv - *(*uintptr)(unsafe.Pointer(bp)) = uintptr(0) - *(*Tsize_t)(unsafe.Pointer(bp + 4)) = uint32(0) - *(*uintptr)(unsafe.Pointer(bp + 8)) = uintptr(0) - *(*Tsize_t)(unsafe.Pointer(bp + 12)) = uint32(0) + **(**uintptr)(__ccgo_up(bp)) = uintptr(0) + **(**Tsize_t)(__ccgo_up(bp + 4)) = uint32(0) + **(**uintptr)(__ccgo_up(bp + 8)) = uintptr(0) + **(**Tsize_t)(__ccgo_up(bp + 12)) = uint32(0) rv = 0 _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp+16) rv = X__getgr_a(tls, name, gid, gr, bp, bp+4, bp+8, bp+12, res) - if *(*uintptr)(unsafe.Pointer(res)) != 0 && size < *(*Tsize_t)(unsafe.Pointer(bp + 4))+(*(*Tsize_t)(unsafe.Pointer(bp + 12))+uint32(1))*uint32(4)+uint32(32) { - *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) + if **(**uintptr)(__ccgo_up(res)) != 0 && size < **(**Tsize_t)(__ccgo_up(bp + 4))+(**(**Tsize_t)(__ccgo_up(bp + 12))+uint32(1))*uint32(4)+uint32(32) { + **(**uintptr)(__ccgo_up(res)) = uintptr(0) rv = int32(ERANGE) } - if *(*uintptr)(unsafe.Pointer(res)) != 0 { + if **(**uintptr)(__ccgo_up(res)) != 0 { buf = buf + uintptr((uint32(16)-uint32(buf))%uint32(16)) (*Tgroup)(unsafe.Pointer(gr)).Fgr_mem = buf - buf = buf + uintptr((*(*Tsize_t)(unsafe.Pointer(bp + 12))+uint32(1))*uint32(4)) - Xmemcpy(tls, buf, *(*uintptr)(unsafe.Pointer(bp)), *(*Tsize_t)(unsafe.Pointer(bp + 4))) - (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = uintptr(int32((*Tgroup)(unsafe.Pointer(gr)).Fgr_name)-int32(*(*uintptr)(unsafe.Pointer(bp)))) + buf - (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = uintptr(int32((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd)-int32(*(*uintptr)(unsafe.Pointer(bp)))) + buf + buf = buf + uintptr((**(**Tsize_t)(__ccgo_up(bp + 12))+uint32(1))*uint32(4)) + Xmemcpy(tls, buf, **(**uintptr)(__ccgo_up(bp)), **(**Tsize_t)(__ccgo_up(bp + 4))) + (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = uintptr(int32((*Tgroup)(unsafe.Pointer(gr)).Fgr_name)-int32(**(**uintptr)(__ccgo_up(bp)))) + buf + (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = uintptr(int32((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd)-int32(**(**uintptr)(__ccgo_up(bp)))) + buf i = uint32(0) for { - if !(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*4)) != 0) { + if !(**(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + uintptr(i)*4)) != 0) { break } - *(*uintptr)(unsafe.Pointer((*Tgroup)(unsafe.Pointer(gr)).Fgr_mem + uintptr(i)*4)) = uintptr(int32(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*4)))-int32(*(*uintptr)(unsafe.Pointer(bp)))) + buf + **(**uintptr)(__ccgo_up((*Tgroup)(unsafe.Pointer(gr)).Fgr_mem + uintptr(i)*4)) = uintptr(int32(**(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + uintptr(i)*4)))-int32(**(**uintptr)(__ccgo_up(bp)))) + buf goto _1 _1: ; i = i + 1 } - *(*uintptr)(unsafe.Pointer((*Tgroup)(unsafe.Pointer(gr)).Fgr_mem + uintptr(i)*4)) = uintptr(0) + **(**uintptr)(__ccgo_up((*Tgroup)(unsafe.Pointer(gr)).Fgr_mem + uintptr(i)*4)) = uintptr(0) } - Xfree(tls, *(*uintptr)(unsafe.Pointer(bp + 8))) - Xfree(tls, *(*uintptr)(unsafe.Pointer(bp))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 16)), uintptr(0)) + Xfree(tls, **(**uintptr)(__ccgo_up(bp + 8))) + Xfree(tls, **(**uintptr)(__ccgo_up(bp))) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 16)), uintptr(0)) if rv != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = rv + **(**int32)(__ccgo_up(X__errno_location(tls))) = rv } return rv } @@ -126437,8 +126437,8 @@ func Xgetgrent(tls *TLS) (r uintptr) { var _ /* nmem at bp+8 */ Tsize_t var _ /* res at bp+0 */ uintptr var _ /* size at bp+4 */ Tsize_t - *(*Tsize_t)(unsafe.Pointer(bp + 4)) = uint32(0) - *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint32(0) + **(**Tsize_t)(__ccgo_up(bp + 4)) = uint32(0) + **(**Tsize_t)(__ccgo_up(bp + 8)) = uint32(0) if !(_f1 != 0) { _f1 = Xfopen(tls, __ccgo_ts+1150, __ccgo_ts+315) } @@ -126446,7 +126446,7 @@ func Xgetgrent(tls *TLS) (r uintptr) { return uintptr(0) } X__getgrent_a(tls, _f1, uintptr(unsafe.Pointer(&_gr1)), uintptr(unsafe.Pointer(&_line3)), bp+4, uintptr(unsafe.Pointer(&_mem1)), bp+8, bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func Xgetgrgid(tls *TLS, gid Tgid_t) (r uintptr) { @@ -126459,10 +126459,10 @@ func Xgetgrgid(tls *TLS, gid Tgid_t) (r uintptr) { var _ /* nmem at bp+8 */ Tsize_t var _ /* res at bp+0 */ uintptr var _ /* size at bp+4 */ Tsize_t - *(*Tsize_t)(unsafe.Pointer(bp + 4)) = uint32(0) - *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint32(0) + **(**Tsize_t)(__ccgo_up(bp + 4)) = uint32(0) + **(**Tsize_t)(__ccgo_up(bp + 8)) = uint32(0) X__getgr_a(tls, uintptr(0), gid, uintptr(unsafe.Pointer(&_gr1)), uintptr(unsafe.Pointer(&_line3)), bp+4, uintptr(unsafe.Pointer(&_mem1)), bp+8, bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func Xgetgrnam(tls *TLS, name uintptr) (r uintptr) { @@ -126475,10 +126475,10 @@ func Xgetgrnam(tls *TLS, name uintptr) (r uintptr) { var _ /* nmem at bp+8 */ Tsize_t var _ /* res at bp+0 */ uintptr var _ /* size at bp+4 */ Tsize_t - *(*Tsize_t)(unsafe.Pointer(bp + 4)) = uint32(0) - *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint32(0) + **(**Tsize_t)(__ccgo_up(bp + 4)) = uint32(0) + **(**Tsize_t)(__ccgo_up(bp + 8)) = uint32(0) X__getgr_a(tls, name, uint32(0), uintptr(unsafe.Pointer(&_gr1)), uintptr(unsafe.Pointer(&_line3)), bp+4, uintptr(unsafe.Pointer(&_mem1)), bp+8, bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func Xendgrent(tls *TLS) { @@ -126493,14 +126493,14 @@ func _atou(tls *TLS, s uintptr) (r uint32) { _ = x x = uint32(0) for { - if !(Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-int32('0')) < uint32(10)) { + if !(Uint32FromInt32(int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-int32('0')) < uint32(10)) { break } - x = uint32(10)*x + Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-Int32FromUint8('0')) + x = uint32(10)*x + Uint32FromInt32(int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-Int32FromUint8('0')) goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s)) = *(*uintptr)(unsafe.Pointer(s)) + 1 + **(**uintptr)(__ccgo_up(s)) = **(**uintptr)(__ccgo_up(s)) + 1 } return x } @@ -126526,107 +126526,107 @@ func X__getgrent_a(tls *TLS, f uintptr, gr uintptr, line uintptr, size uintptr, l = v2 if v2 < 0 { if Xferror(tls, f) != 0 { - v3 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v3 = **(**int32)(__ccgo_up(X__errno_location(tls))) } else { v3 = 0 } rv = v3 - Xfree(tls, *(*uintptr)(unsafe.Pointer(line))) - *(*uintptr)(unsafe.Pointer(line)) = uintptr(0) + Xfree(tls, **(**uintptr)(__ccgo_up(line))) + **(**uintptr)(__ccgo_up(line)) = uintptr(0) gr = uintptr(0) goto end } - *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(line)) + uintptr(l-int32(1)))) = 0 - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(line)) - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(line)) + uintptr(l-int32(1)))) = 0 + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(line)) + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = v4 - v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v4 + v4 = Xstrchr(tls, **(**uintptr)(__ccgo_up(bp)), int32(':')) + **(**uintptr)(__ccgo_up(bp)) = v4 if !(v4 != 0) { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*int8)(unsafe.Pointer(v4)) = 0 - (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = *(*uintptr)(unsafe.Pointer(bp)) - v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v4 + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**int8)(__ccgo_up(v4)) = 0 + (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = **(**uintptr)(__ccgo_up(bp)) + v4 = Xstrchr(tls, **(**uintptr)(__ccgo_up(bp)), int32(':')) + **(**uintptr)(__ccgo_up(bp)) = v4 if !(v4 != 0) { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*int8)(unsafe.Pointer(v4)) = 0 + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**int8)(__ccgo_up(v4)) = 0 (*Tgroup)(unsafe.Pointer(gr)).Fgr_gid = _atou(tls, bp) - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32(':') { + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) != int32(':') { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*int8)(unsafe.Pointer(v4)) = 0 - mems = *(*uintptr)(unsafe.Pointer(bp)) + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**int8)(__ccgo_up(v4)) = 0 + mems = **(**uintptr)(__ccgo_up(bp)) break goto _1 _1: } - *(*Tsize_t)(unsafe.Pointer(nmem)) = BoolUint32(!!(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) != 0)) + **(**Tsize_t)(__ccgo_up(nmem)) = BoolUint32(!!(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))) != 0)) for { - if !(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) != 0) { + if !(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))) != 0) { break } - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32(',') { - *(*Tsize_t)(unsafe.Pointer(nmem)) = *(*Tsize_t)(unsafe.Pointer(nmem)) + 1 + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) == int32(',') { + **(**Tsize_t)(__ccgo_up(nmem)) = **(**Tsize_t)(__ccgo_up(nmem)) + 1 } goto _10 _10: ; - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - } - Xfree(tls, *(*uintptr)(unsafe.Pointer(mem))) - *(*uintptr)(unsafe.Pointer(mem)) = Xcalloc(tls, uint32(4), *(*Tsize_t)(unsafe.Pointer(nmem))+uint32(1)) - if !(*(*uintptr)(unsafe.Pointer(mem)) != 0) { - rv = *(*int32)(unsafe.Pointer(X__errno_location(tls))) - Xfree(tls, *(*uintptr)(unsafe.Pointer(line))) - *(*uintptr)(unsafe.Pointer(line)) = uintptr(0) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + } + Xfree(tls, **(**uintptr)(__ccgo_up(mem))) + **(**uintptr)(__ccgo_up(mem)) = Xcalloc(tls, uint32(4), **(**Tsize_t)(__ccgo_up(nmem))+uint32(1)) + if !(**(**uintptr)(__ccgo_up(mem)) != 0) { + rv = **(**int32)(__ccgo_up(X__errno_location(tls))) + Xfree(tls, **(**uintptr)(__ccgo_up(line))) + **(**uintptr)(__ccgo_up(line)) = uintptr(0) gr = uintptr(0) goto end } - if *(*int8)(unsafe.Pointer(mems)) != 0 { - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)))) = mems - *(*uintptr)(unsafe.Pointer(bp)) = mems + if **(**int8)(__ccgo_up(mems)) != 0 { + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)))) = mems + **(**uintptr)(__ccgo_up(bp)) = mems i = Uint32FromInt32(0) for { - if !(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) != 0) { + if !(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))) != 0) { break } - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32(',') { - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*int8)(unsafe.Pointer(v4)) = 0 + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) == int32(',') { + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**int8)(__ccgo_up(v4)) = 0 i = i + 1 v13 = i - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v13)*4)) = *(*uintptr)(unsafe.Pointer(bp)) + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)) + uintptr(v13)*4)) = **(**uintptr)(__ccgo_up(bp)) } goto _11 _11: ; - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 } i = i + 1 v13 = i - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v13)*4)) = uintptr(0) + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)) + uintptr(v13)*4)) = uintptr(0) } else { - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)))) = uintptr(0) + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)))) = uintptr(0) } - (*Tgroup)(unsafe.Pointer(gr)).Fgr_mem = *(*uintptr)(unsafe.Pointer(mem)) + (*Tgroup)(unsafe.Pointer(gr)).Fgr_mem = **(**uintptr)(__ccgo_up(mem)) goto end end: ; - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 4)), uintptr(0)) - *(*uintptr)(unsafe.Pointer(res)) = gr + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 4)), uintptr(0)) + **(**uintptr)(__ccgo_up(res)) = gr if rv != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = rv + **(**int32)(__ccgo_up(X__errno_location(tls))) = rv } return rv } @@ -126654,44 +126654,44 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u _, _, _, _, _, _, _, _, _, _, _, _, _ = f, i, n, nbytes, nlim, nscdbuf, ret, rv, v1, v3, v4, v6, v9 ret = -int32(1) n = int32(1) - *(*int32)(unsafe.Pointer(bp + 20)) = 0 + **(**int32)(__ccgo_up(bp + 20)) = 0 nscdbuf = uintptr(0) - *(*uintptr)(unsafe.Pointer(bp + 36)) = uintptr(0) - *(*uintptr)(unsafe.Pointer(bp + 40)) = uintptr(0) - *(*Tsize_t)(unsafe.Pointer(bp + 44)) = uint32(0) - nlim = *(*int32)(unsafe.Pointer(ngroups)) + **(**uintptr)(__ccgo_up(bp + 36)) = uintptr(0) + **(**uintptr)(__ccgo_up(bp + 40)) = uintptr(0) + **(**Tsize_t)(__ccgo_up(bp + 44)) = uint32(0) + nlim = **(**int32)(__ccgo_up(ngroups)) if nlim >= int32(1) { v1 = groups groups += 4 - *(*Tgid_t)(unsafe.Pointer(v1)) = gid + **(**Tgid_t)(__ccgo_up(v1)) = gid } f = X__nscd_query(tls, int32(GETINITGR), user, bp+24, uint32(12), bp+20) if !(f != 0) { goto cleanup } - if (*(*[3]Tint32_t)(unsafe.Pointer(bp + 24)))[int32(INITGRFOUND)] != 0 { - nscdbuf = Xcalloc(tls, Uint32FromInt32((*(*[3]Tint32_t)(unsafe.Pointer(bp + 24)))[int32(INITGRNGRPS)]), uint32(4)) + if (**(**[3]Tint32_t)(__ccgo_up(bp + 24)))[int32(INITGRFOUND)] != 0 { + nscdbuf = Xcalloc(tls, Uint32FromInt32((**(**[3]Tint32_t)(__ccgo_up(bp + 24)))[int32(INITGRNGRPS)]), uint32(4)) if !(nscdbuf != 0) { goto cleanup } - nbytes = uint32(4) * Uint32FromInt32((*(*[3]Tint32_t)(unsafe.Pointer(bp + 24)))[int32(INITGRNGRPS)]) + nbytes = uint32(4) * Uint32FromInt32((**(**[3]Tint32_t)(__ccgo_up(bp + 24)))[int32(INITGRNGRPS)]) if nbytes != 0 && !(Xfread(tls, nscdbuf, nbytes, uint32(1), f) != 0) { if !(Xferror(tls, f) != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EIO) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EIO) } goto cleanup } - if *(*int32)(unsafe.Pointer(bp + 20)) != 0 { + if **(**int32)(__ccgo_up(bp + 20)) != 0 { i = 0 for { - if !(i < (*(*[3]Tint32_t)(unsafe.Pointer(bp + 24)))[int32(INITGRNGRPS)]) { + if !(i < (**(**[3]Tint32_t)(__ccgo_up(bp + 24)))[int32(INITGRNGRPS)]) { break } - v3 = *(*Tuint32_t)(unsafe.Pointer(nscdbuf + uintptr(i)*4)) + v3 = **(**Tuint32_t)(__ccgo_up(nscdbuf + uintptr(i)*4)) v4 = v3>>int32(24) | v3>>int32(8)&uint32(0xff00) | v3<= Uint32FromUint32(0xffffffff)/Uint32FromInt32(8) { + if Uint32FromInt32((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWNAMELEN)]|(**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWPASSWDLEN)]|(**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWGECOSLEN)]|(**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWDIRLEN)]|(**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWSHELLLEN)]) >= Uint32FromUint32(0xffffffff)/Uint32FromInt32(8) { rv = int32(ENOMEM) goto cleanup_f } - len1 = Uint32FromInt32((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWNAMELEN)] + (*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWPASSWDLEN)] + (*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWGECOSLEN)] + (*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWDIRLEN)] + (*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWSHELLLEN)]) - if len1 > *(*Tsize_t)(unsafe.Pointer(size)) || !(*(*uintptr)(unsafe.Pointer(buf)) != 0) { - tmp = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(buf)), len1) + len1 = Uint32FromInt32((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWNAMELEN)] + (**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWPASSWDLEN)] + (**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWGECOSLEN)] + (**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWDIRLEN)] + (**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWSHELLLEN)]) + if len1 > **(**Tsize_t)(__ccgo_up(size)) || !(**(**uintptr)(__ccgo_up(buf)) != 0) { + tmp = Xrealloc(tls, **(**uintptr)(__ccgo_up(buf)), len1) if !(tmp != 0) { - rv = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + rv = **(**int32)(__ccgo_up(X__errno_location(tls))) goto cleanup_f } - *(*uintptr)(unsafe.Pointer(buf)) = tmp - *(*Tsize_t)(unsafe.Pointer(size)) = len1 + **(**uintptr)(__ccgo_up(buf)) = tmp + **(**Tsize_t)(__ccgo_up(size)) = len1 } - if !(Xfread(tls, *(*uintptr)(unsafe.Pointer(buf)), len1, uint32(1), f) != 0) { + if !(Xfread(tls, **(**uintptr)(__ccgo_up(buf)), len1, uint32(1), f) != 0) { if Xferror(tls, f) != 0 { - v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = **(**int32)(__ccgo_up(X__errno_location(tls))) } else { v1 = int32(EIO) } rv = v1 goto cleanup_f } - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = *(*uintptr)(unsafe.Pointer(buf)) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name + uintptr((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWNAMELEN)]) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd + uintptr((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWPASSWDLEN)]) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos + uintptr((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWGECOSLEN)]) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir + uintptr((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWDIRLEN)]) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_uid = Uint32FromInt32((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWUID)]) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gid = Uint32FromInt32((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWGID)]) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = **(**uintptr)(__ccgo_up(buf)) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name + uintptr((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWNAMELEN)]) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd + uintptr((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWPASSWDLEN)]) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos + uintptr((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWGECOSLEN)]) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir + uintptr((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWDIRLEN)]) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_uid = Uint32FromInt32((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWUID)]) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gid = Uint32FromInt32((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWGID)]) /* Don't assume that nscd made sure to null terminate strings. * It's supposed to, but malicious nscd should be ignored * rather than causing a crash. */ - if *(*int8)(unsafe.Pointer((*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd + uintptr(-Int32FromInt32(1)))) != 0 || *(*int8)(unsafe.Pointer((*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos + uintptr(-Int32FromInt32(1)))) != 0 || *(*int8)(unsafe.Pointer((*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir + uintptr(-Int32FromInt32(1)))) != 0 || *(*int8)(unsafe.Pointer((*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell + uintptr((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWSHELLLEN)]-int32(1)))) != 0 { + if **(**int8)(__ccgo_up((*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd + uintptr(-Int32FromInt32(1)))) != 0 || **(**int8)(__ccgo_up((*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos + uintptr(-Int32FromInt32(1)))) != 0 || **(**int8)(__ccgo_up((*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir + uintptr(-Int32FromInt32(1)))) != 0 || **(**int8)(__ccgo_up((*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell + uintptr((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWSHELLLEN)]-int32(1)))) != 0 { rv = int32(EIO) goto cleanup_f } @@ -126927,7 +126927,7 @@ func X__getpw_a(tls *TLS, name uintptr, uid Tuid_t, pw uintptr, buf uintptr, siz rv = int32(EIO) goto cleanup_f } - *(*uintptr)(unsafe.Pointer(res)) = pw + **(**uintptr)(__ccgo_up(res)) = pw goto cleanup_f cleanup_f: ; @@ -126937,9 +126937,9 @@ func X__getpw_a(tls *TLS, name uintptr, uid Tuid_t, pw uintptr, buf uintptr, siz goto done done: ; - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 4)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 4)), uintptr(0)) if rv != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = rv + **(**int32)(__ccgo_up(X__errno_location(tls))) = rv } return rv } @@ -126952,27 +126952,27 @@ func _getpw_r(tls *TLS, name uintptr, uid Tuid_t, pw uintptr, buf uintptr, size var _ /* len at bp+4 */ Tsize_t var _ /* line at bp+0 */ uintptr _ = rv - *(*uintptr)(unsafe.Pointer(bp)) = uintptr(0) - *(*Tsize_t)(unsafe.Pointer(bp + 4)) = uint32(0) + **(**uintptr)(__ccgo_up(bp)) = uintptr(0) + **(**Tsize_t)(__ccgo_up(bp + 4)) = uint32(0) rv = 0 _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp+8) rv = X__getpw_a(tls, name, uid, pw, bp, bp+4, res) - if *(*uintptr)(unsafe.Pointer(res)) != 0 && size < *(*Tsize_t)(unsafe.Pointer(bp + 4)) { - *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) + if **(**uintptr)(__ccgo_up(res)) != 0 && size < **(**Tsize_t)(__ccgo_up(bp + 4)) { + **(**uintptr)(__ccgo_up(res)) = uintptr(0) rv = int32(ERANGE) } - if *(*uintptr)(unsafe.Pointer(res)) != 0 { - Xmemcpy(tls, buf, *(*uintptr)(unsafe.Pointer(bp)), *(*Tsize_t)(unsafe.Pointer(bp + 4))) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = uintptr(int32((*Tpasswd)(unsafe.Pointer(pw)).Fpw_name)-int32(*(*uintptr)(unsafe.Pointer(bp)))) + buf - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = uintptr(int32((*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd)-int32(*(*uintptr)(unsafe.Pointer(bp)))) + buf - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = uintptr(int32((*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos)-int32(*(*uintptr)(unsafe.Pointer(bp)))) + buf - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = uintptr(int32((*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir)-int32(*(*uintptr)(unsafe.Pointer(bp)))) + buf - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = uintptr(int32((*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell)-int32(*(*uintptr)(unsafe.Pointer(bp)))) + buf + if **(**uintptr)(__ccgo_up(res)) != 0 { + Xmemcpy(tls, buf, **(**uintptr)(__ccgo_up(bp)), **(**Tsize_t)(__ccgo_up(bp + 4))) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = uintptr(int32((*Tpasswd)(unsafe.Pointer(pw)).Fpw_name)-int32(**(**uintptr)(__ccgo_up(bp)))) + buf + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = uintptr(int32((*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd)-int32(**(**uintptr)(__ccgo_up(bp)))) + buf + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = uintptr(int32((*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos)-int32(**(**uintptr)(__ccgo_up(bp)))) + buf + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = uintptr(int32((*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir)-int32(**(**uintptr)(__ccgo_up(bp)))) + buf + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = uintptr(int32((*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell)-int32(**(**uintptr)(__ccgo_up(bp)))) + buf } - Xfree(tls, *(*uintptr)(unsafe.Pointer(bp))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 8)), uintptr(0)) + Xfree(tls, **(**uintptr)(__ccgo_up(bp))) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 8)), uintptr(0)) if rv != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = rv + **(**int32)(__ccgo_up(X__errno_location(tls))) = rv } return rv } @@ -127023,7 +127023,7 @@ func Xgetpwent(tls *TLS) (r uintptr) { return uintptr(0) } X__getpwent_a(tls, _f2, uintptr(unsafe.Pointer(&_pw1)), uintptr(unsafe.Pointer(&_line4)), uintptr(unsafe.Pointer(&_size)), bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func Xgetpwuid(tls *TLS, uid Tuid_t) (r uintptr) { @@ -127035,7 +127035,7 @@ func Xgetpwuid(tls *TLS, uid Tuid_t) (r uintptr) { defer tls.Free(16) var _ /* res at bp+0 */ uintptr X__getpw_a(tls, uintptr(0), uid, uintptr(unsafe.Pointer(&_pw1)), uintptr(unsafe.Pointer(&_line4)), uintptr(unsafe.Pointer(&_size)), bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func Xgetpwnam(tls *TLS, name uintptr) (r uintptr) { @@ -127047,7 +127047,7 @@ func Xgetpwnam(tls *TLS, name uintptr) (r uintptr) { defer tls.Free(16) var _ /* res at bp+0 */ uintptr X__getpw_a(tls, name, uint32(0), uintptr(unsafe.Pointer(&_pw1)), uintptr(unsafe.Pointer(&_line4)), uintptr(unsafe.Pointer(&_size)), bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func Xendpwent(tls *TLS) { @@ -127062,14 +127062,14 @@ func _atou1(tls *TLS, s uintptr) (r uint32) { _ = x x = uint32(0) for { - if !(Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-int32('0')) < uint32(10)) { + if !(Uint32FromInt32(int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-int32('0')) < uint32(10)) { break } - x = uint32(10)*x + Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-Int32FromUint8('0')) + x = uint32(10)*x + Uint32FromInt32(int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-Int32FromUint8('0')) goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s)) = *(*uintptr)(unsafe.Pointer(s)) + 1 + **(**uintptr)(__ccgo_up(s)) = **(**uintptr)(__ccgo_up(s)) + 1 } return x } @@ -127094,79 +127094,79 @@ func X__getpwent_a(tls *TLS, f uintptr, pw uintptr, line uintptr, size uintptr, l = v2 if v2 < 0 { if Xferror(tls, f) != 0 { - v3 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v3 = **(**int32)(__ccgo_up(X__errno_location(tls))) } else { v3 = 0 } rv = v3 - Xfree(tls, *(*uintptr)(unsafe.Pointer(line))) - *(*uintptr)(unsafe.Pointer(line)) = uintptr(0) + Xfree(tls, **(**uintptr)(__ccgo_up(line))) + **(**uintptr)(__ccgo_up(line)) = uintptr(0) pw = uintptr(0) break } - *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(line)) + uintptr(l-int32(1)))) = 0 - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(line)) - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(line)) + uintptr(l-int32(1)))) = 0 + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(line)) + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = v4 - v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v4 + v4 = Xstrchr(tls, **(**uintptr)(__ccgo_up(bp)), int32(':')) + **(**uintptr)(__ccgo_up(bp)) = v4 if !(v4 != 0) { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*int8)(unsafe.Pointer(v4)) = 0 - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = *(*uintptr)(unsafe.Pointer(bp)) - v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v4 + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**int8)(__ccgo_up(v4)) = 0 + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = **(**uintptr)(__ccgo_up(bp)) + v4 = Xstrchr(tls, **(**uintptr)(__ccgo_up(bp)), int32(':')) + **(**uintptr)(__ccgo_up(bp)) = v4 if !(v4 != 0) { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*int8)(unsafe.Pointer(v4)) = 0 + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**int8)(__ccgo_up(v4)) = 0 (*Tpasswd)(unsafe.Pointer(pw)).Fpw_uid = _atou1(tls, bp) - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32(':') { + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) != int32(':') { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*int8)(unsafe.Pointer(v4)) = 0 + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**int8)(__ccgo_up(v4)) = 0 (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gid = _atou1(tls, bp) - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32(':') { + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) != int32(':') { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*int8)(unsafe.Pointer(v4)) = 0 - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = *(*uintptr)(unsafe.Pointer(bp)) - v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v4 + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**int8)(__ccgo_up(v4)) = 0 + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = **(**uintptr)(__ccgo_up(bp)) + v4 = Xstrchr(tls, **(**uintptr)(__ccgo_up(bp)), int32(':')) + **(**uintptr)(__ccgo_up(bp)) = v4 if !(v4 != 0) { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*int8)(unsafe.Pointer(v4)) = 0 - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = *(*uintptr)(unsafe.Pointer(bp)) - v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v4 + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**int8)(__ccgo_up(v4)) = 0 + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = **(**uintptr)(__ccgo_up(bp)) + v4 = Xstrchr(tls, **(**uintptr)(__ccgo_up(bp)), int32(':')) + **(**uintptr)(__ccgo_up(bp)) = v4 if !(v4 != 0) { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*int8)(unsafe.Pointer(v4)) = 0 - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = *(*uintptr)(unsafe.Pointer(bp)) + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**int8)(__ccgo_up(v4)) = 0 + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = **(**uintptr)(__ccgo_up(bp)) break goto _1 _1: } - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 4)), uintptr(0)) - *(*uintptr)(unsafe.Pointer(res)) = pw + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 4)), uintptr(0)) + **(**uintptr)(__ccgo_up(res)) = pw if rv != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = rv + **(**int32)(__ccgo_up(X__errno_location(tls))) = rv } return rv } @@ -127230,7 +127230,7 @@ func X__nscd_query(tls *TLS, req Tint32_t, key uintptr, buf uintptr, len1 Tsize_ var _ /* req_buf at bp+16 */ [3]Tint32_t _, _, _, _, _, _, _ = errno_save, f, fd, i, v1, v3, v4 f = uintptr(0) - *(*[3]Tint32_t)(unsafe.Pointer(bp + 16)) = [3]Tint32_t{ + **(**[3]Tint32_t)(__ccgo_up(bp + 16)) = [3]Tint32_t{ 0: int32(NSCDVERSION), 1: req, 2: Int32FromUint32(Xstrnlen(tls, key, uint32(LOGIN_NAME_MAX)) + uint32(1)), @@ -127245,23 +127245,23 @@ func X__nscd_query(tls *TLS, req Tint32_t, key uintptr, buf uintptr, len1 Tsize_ Fiov_len: _strlen(tls, key) + uint32(1), }, } - *(*Tmsghdr)(unsafe.Pointer(bp + 28)) = Tmsghdr{ + **(**Tmsghdr)(__ccgo_up(bp + 28)) = Tmsghdr{ Fmsg_iov: bp, Fmsg_iovlen: int32(2), } - errno_save = *(*int32)(unsafe.Pointer(X__errno_location(tls))) - *(*int32)(unsafe.Pointer(swap)) = 0 + errno_save = **(**int32)(__ccgo_up(X__errno_location(tls))) + **(**int32)(__ccgo_up(swap)) = 0 goto retry retry: ; Xmemset(tls, buf, 0, len1) - *(*Tint32_t)(unsafe.Pointer(buf)) = int32(NSCDVERSION) + **(**Tint32_t)(__ccgo_up(buf)) = int32(NSCDVERSION) fd = Xsocket(tls, int32(PF_LOCAL), Int32FromInt32(SOCK_STREAM)|Int32FromInt32(SOCK_CLOEXEC), 0) if fd < 0 { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EAFNOSUPPORT) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EAFNOSUPPORT) { f = Xfopen(tls, __ccgo_ts+1173, __ccgo_ts+1183) if f != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = errno_save + **(**int32)(__ccgo_up(X__errno_location(tls))) = errno_save } return f } @@ -127273,7 +127273,7 @@ retry: Xclose(tls, fd) return uintptr(0) } - if (*(*[3]Tint32_t)(unsafe.Pointer(bp + 16)))[int32(2)] > int32(LOGIN_NAME_MAX) { + if (**(**[3]Tint32_t)(__ccgo_up(bp + 16)))[int32(2)] > int32(LOGIN_NAME_MAX) { return f } if Xconnect(tls, fd, uintptr(unsafe.Pointer(&_addr)), uint32(24)) < 0 { @@ -127281,8 +127281,8 @@ retry: * result and the caller is responsible for calling * fclose on the (unconnected) socket. The value of * errno must be left unchanged in this case. */ - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EACCES) || *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ECONNREFUSED) || *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENOENT) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = errno_save + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EACCES) || **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ECONNREFUSED) || **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENOENT) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = errno_save return f } goto error @@ -127299,41 +127299,41 @@ retry: if Xferror(tls, f) != 0 { goto error } - if !(*(*int32)(unsafe.Pointer(swap)) != 0) { + if !(**(**int32)(__ccgo_up(swap)) != 0) { Xfclose(tls, f) i = uint32(0) for { if !(i < Uint32FromInt64(12)/Uint32FromInt64(4)) { break } - v3 = Uint32FromInt32((*(*[3]Tint32_t)(unsafe.Pointer(bp + 16)))[i]) + v3 = Uint32FromInt32((**(**[3]Tint32_t)(__ccgo_up(bp + 16)))[i]) v4 = v3>>int32(24) | v3>>int32(8)&uint32(0xff00) | v3<>int32(24) | v3>>int32(8)&uint32(0xff00) | v3<> int32(16)) - *(*uint16)(unsafe.Pointer(xi + 2*2)) = uint16(x >> int32(32)) + x = uint64(uint32(**(**uint16)(__ccgo_up(xi)))|(uint32(**(**uint16)(__ccgo_up(xi + 1*2)))+0)<> int32(16)) + **(**uint16)(__ccgo_up(xi + 2*2)) = uint16(x >> int32(32)) return x & uint64(0xffffffffffff) } @@ -127642,8 +127642,8 @@ func Xrand_r(tls *TLS, seed uintptr) (r int32) { } var v1 uint32 _ = v1 - v1 = *(*uint32)(unsafe.Pointer(seed))*Uint32FromInt32(1103515245) + Uint32FromInt32(12345) - *(*uint32)(unsafe.Pointer(seed)) = v1 + v1 = **(**uint32)(__ccgo_up(seed))*Uint32FromInt32(1103515245) + Uint32FromInt32(12345) + **(**uint32)(__ccgo_up(seed)) = v1 return Int32FromUint32(_temper(tls, v1) / uint32(2)) } @@ -127702,15 +127702,15 @@ func _lcg64(tls *TLS, x Tuint64_t) (r Tuint64_t) { } func _savestate(tls *TLS) (r uintptr) { - *(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(-Int32FromInt32(1))*4)) = Uint32FromInt32(_n<> int32(16)) - _i = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(-Int32FromInt32(1))*4)) >> Int32FromInt32(8) & uint32(0xff)) - _j = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(-Int32FromInt32(1))*4)) & uint32(0xff)) + _n = Int32FromUint32(**(**Tuint32_t)(__ccgo_up(_x1 + uintptr(-Int32FromInt32(1))*4)) >> int32(16)) + _i = Int32FromUint32(**(**Tuint32_t)(__ccgo_up(_x1 + uintptr(-Int32FromInt32(1))*4)) >> Int32FromInt32(8) & uint32(0xff)) + _j = Int32FromUint32(**(**Tuint32_t)(__ccgo_up(_x1 + uintptr(-Int32FromInt32(1))*4)) & uint32(0xff)) } func ___srandom(tls *TLS, seed uint32) { @@ -127719,7 +127719,7 @@ func ___srandom(tls *TLS, seed uint32) { _, _, _ = k, s, v1 s = uint64(seed) if _n == 0 { - *(*Tuint32_t)(unsafe.Pointer(_x1)) = uint32(s) + **(**Tuint32_t)(__ccgo_up(_x1)) = uint32(s) return } if _n == int32(31) || _n == int32(7) { @@ -127735,14 +127735,14 @@ func ___srandom(tls *TLS, seed uint32) { break } s = _lcg64(tls, s) - *(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(k)*4)) = uint32(s >> int32(32)) + **(**Tuint32_t)(__ccgo_up(_x1 + uintptr(k)*4)) = uint32(s >> int32(32)) goto _2 _2: ; k = k + 1 } /* make sure x contains at least one odd number */ - *(*Tuint32_t)(unsafe.Pointer(_x1)) |= uint32(1) + **(**Tuint32_t)(__ccgo_up(_x1)) |= uint32(1) } func Xsrandom(tls *TLS, seed uint32) { @@ -127814,13 +127814,13 @@ func Xrandom(tls *TLS) (r int32) { _, _, _ = k, v1, v2 ___lock(tls, uintptr(unsafe.Pointer(&_lock3))) if _n == 0 { - v1 = _lcg31(tls, *(*Tuint32_t)(unsafe.Pointer(_x1))) - *(*Tuint32_t)(unsafe.Pointer(_x1)) = v1 + v1 = _lcg31(tls, **(**Tuint32_t)(__ccgo_up(_x1))) + **(**Tuint32_t)(__ccgo_up(_x1)) = v1 k = Int32FromUint32(v1) goto end } - *(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(_i)*4)) += *(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(_j)*4)) - k = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(_i)*4)) >> int32(1)) + **(**Tuint32_t)(__ccgo_up(_x1 + uintptr(_i)*4)) += **(**Tuint32_t)(__ccgo_up(_x1 + uintptr(_j)*4)) + k = Int32FromUint32(**(**Tuint32_t)(__ccgo_up(_x1 + uintptr(_i)*4)) >> int32(1)) _i = _i + 1 v2 = _i if v2 == _n { @@ -128026,8 +128026,8 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { defer func() { Xrealloc(tls, b, 0) }() path = Xgetenv(tls, __ccgo_ts+1276) seen_eacces = 0 - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOENT) - if !(*(*int8)(unsafe.Pointer(file)) != 0) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOENT) + if !(**(**int8)(__ccgo_up(file)) != 0) { return -int32(1) } if Xstrchr(tls, file, int32('/')) != 0 { @@ -128038,7 +128038,7 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { } k = Xstrnlen(tls, file, Uint32FromInt32(Int32FromInt32(NAME_MAX)+Int32FromInt32(1))) if k > uint32(NAME_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENAMETOOLONG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENAMETOOLONG) return -int32(1) } l = Xstrnlen(tls, path, Uint32FromInt32(Int32FromInt32(PATH_MAX)-Int32FromInt32(1))) + uint32(1) @@ -128050,7 +128050,7 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { if Uint32FromInt32(int32(z)-int32(p)) >= l { v3 = z z = z + 1 - if !(*(*int8)(unsafe.Pointer(v3)) != 0) { + if !(**(**int8)(__ccgo_up(v3)) != 0) { break } goto _1 @@ -128059,7 +128059,7 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { *(*int8)(unsafe.Add(unsafe.Pointer(b), int32(z)-int32(p))) = int8('/') Xmemcpy(tls, b+uintptr(int32(z)-int32(p))+BoolUintptr(z > p), file, k+uint32(1)) Xexecve(tls, b, argv, envp) - switch *(*int32)(unsafe.Pointer(X__errno_location(tls))) { + switch **(**int32)(__ccgo_up(X__errno_location(tls))) { case int32(EACCES): seen_eacces = int32(1) fallthrough @@ -128071,7 +128071,7 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { } v3 = z z = z + 1 - if !(*(*int8)(unsafe.Pointer(v3)) != 0) { + if !(**(**int8)(__ccgo_up(v3)) != 0) { break } goto _1 @@ -128080,7 +128080,7 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { p = z } if seen_eacces != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EACCES) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EACCES) } return -int32(1) } @@ -128117,8 +128117,8 @@ func Xfexecve(tls *TLS, fd int32, argv uintptr, envp uintptr) (r1 int32) { } X__procfdname(tls, bp, Uint32FromInt32(fd)) Xexecve(tls, bp, argv, envp) - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENOENT) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EBADF) + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENOENT) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EBADF) } return -int32(1) } @@ -128355,7 +128355,7 @@ func Xposix_spawnattr_getflags(tls *TLS, attr uintptr, flags uintptr) (r int32) trc("tls=%v attr=%v flags=%v, (%v:)", tls, attr, flags, origin(2)) defer func() { trc("-> %v", r) }() } - *(*int16)(unsafe.Pointer(flags)) = int16((*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__flags) + **(**int16)(__ccgo_up(flags)) = int16((*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__flags) return 0 } @@ -128364,7 +128364,7 @@ func Xposix_spawnattr_getpgroup(tls *TLS, attr uintptr, pgrp uintptr) (r int32) trc("tls=%v attr=%v pgrp=%v, (%v:)", tls, attr, pgrp, origin(2)) defer func() { trc("-> %v", r) }() } - *(*Tpid_t)(unsafe.Pointer(pgrp)) = (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__pgrp + **(**Tpid_t)(__ccgo_up(pgrp)) = (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__pgrp return 0 } @@ -128373,7 +128373,7 @@ func Xposix_spawnattr_getsigdefault(tls *TLS, attr uintptr, def uintptr) (r int3 trc("tls=%v attr=%v def=%v, (%v:)", tls, attr, def, origin(2)) defer func() { trc("-> %v", r) }() } - *(*Tsigset_t)(unsafe.Pointer(def)) = (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__def + **(**Tsigset_t)(__ccgo_up(def)) = (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__def return 0 } @@ -128382,7 +128382,7 @@ func Xposix_spawnattr_getsigmask(tls *TLS, attr uintptr, mask uintptr) (r int32) trc("tls=%v attr=%v mask=%v, (%v:)", tls, attr, mask, origin(2)) defer func() { trc("-> %v", r) }() } - *(*Tsigset_t)(unsafe.Pointer(mask)) = (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__mask + **(**Tsigset_t)(__ccgo_up(mask)) = (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__mask return 0 } @@ -128391,7 +128391,7 @@ func Xposix_spawnattr_init(tls *TLS, attr uintptr) (r int32) { trc("tls=%v attr=%v, (%v:)", tls, attr, origin(2)) defer func() { trc("-> %v", r) }() } - *(*Tposix_spawnattr_t)(unsafe.Pointer(attr)) = Tposix_spawnattr_t{} + **(**Tposix_spawnattr_t)(__ccgo_up(attr)) = Tposix_spawnattr_t{} return 0 } @@ -128456,7 +128456,7 @@ func Xposix_spawnattr_setsigdefault(tls *TLS, attr uintptr, def uintptr) (r int3 trc("tls=%v attr=%v def=%v, (%v:)", tls, attr, def, origin(2)) defer func() { trc("-> %v", r) }() } - (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__def = *(*Tsigset_t)(unsafe.Pointer(def)) + (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__def = **(**Tsigset_t)(__ccgo_up(def)) return 0 } @@ -128465,7 +128465,7 @@ func Xposix_spawnattr_setsigmask(tls *TLS, attr uintptr, mask uintptr) (r int32) trc("tls=%v attr=%v mask=%v, (%v:)", tls, attr, mask, origin(2)) defer func() { trc("-> %v", r) }() } - (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__mask = *(*Tsigset_t)(unsafe.Pointer(mask)) + (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__mask = **(**Tsigset_t)(__ccgo_up(mask)) return 0 } @@ -128523,20 +128523,20 @@ func _str_next(tls *TLS, str uintptr, n Tsize_t, step uintptr) (r int32) { var _ /* wc at bp+0 */ Twchar_t _ = k if !(n != 0) { - *(*Tsize_t)(unsafe.Pointer(step)) = uint32(0) + **(**Tsize_t)(__ccgo_up(step)) = uint32(0) return 0 } - if Uint32FromInt8(*(*int8)(unsafe.Pointer(str))) >= uint32(128) { + if Uint32FromInt8(**(**int8)(__ccgo_up(str))) >= uint32(128) { k = Xmbtowc(tls, bp, str, n) if k < 0 { - *(*Tsize_t)(unsafe.Pointer(step)) = uint32(1) + **(**Tsize_t)(__ccgo_up(step)) = uint32(1) return -int32(1) } - *(*Tsize_t)(unsafe.Pointer(step)) = Uint32FromInt32(k) - return *(*Twchar_t)(unsafe.Pointer(bp)) + **(**Tsize_t)(__ccgo_up(step)) = Uint32FromInt32(k) + return int32(**(**Twchar_t)(__ccgo_up(bp))) } - *(*Tsize_t)(unsafe.Pointer(step)) = uint32(1) - return int32(*(*int8)(unsafe.Pointer(str))) + **(**Tsize_t)(__ccgo_up(step)) = uint32(1) + return int32(**(**int8)(__ccgo_up(str))) } func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r int32) { @@ -128547,43 +128547,43 @@ func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r i var _ /* wc at bp+0 */ Twchar_t _, _, _, _ = esc, k, k1, z esc = 0 - if !(m != 0) || !(*(*int8)(unsafe.Pointer(pat)) != 0) { - *(*Tsize_t)(unsafe.Pointer(step)) = uint32(0) + if !(m != 0) || !(**(**int8)(__ccgo_up(pat)) != 0) { + **(**Tsize_t)(__ccgo_up(step)) = uint32(0) return END } - *(*Tsize_t)(unsafe.Pointer(step)) = uint32(1) - if int32(*(*int8)(unsafe.Pointer(pat))) == int32('\\') && *(*int8)(unsafe.Pointer(pat + 1)) != 0 && !(flags&Int32FromInt32(FNM_NOESCAPE) != 0) { - *(*Tsize_t)(unsafe.Pointer(step)) = uint32(2) + **(**Tsize_t)(__ccgo_up(step)) = uint32(1) + if int32(**(**int8)(__ccgo_up(pat))) == int32('\\') && **(**int8)(__ccgo_up(pat + 1)) != 0 && !(flags&Int32FromInt32(FNM_NOESCAPE) != 0) { + **(**Tsize_t)(__ccgo_up(step)) = uint32(2) pat = pat + 1 esc = int32(1) goto escaped } - if int32(*(*int8)(unsafe.Pointer(pat))) == int32('[') { + if int32(**(**int8)(__ccgo_up(pat))) == int32('[') { k = uint32(1) if k < m { - if int32(*(*int8)(unsafe.Pointer(pat + uintptr(k)))) == int32('^') || int32(*(*int8)(unsafe.Pointer(pat + uintptr(k)))) == int32('!') { + if int32(**(**int8)(__ccgo_up(pat + uintptr(k)))) == int32('^') || int32(**(**int8)(__ccgo_up(pat + uintptr(k)))) == int32('!') { k = k + 1 } } if k < m { - if int32(*(*int8)(unsafe.Pointer(pat + uintptr(k)))) == int32(']') { + if int32(**(**int8)(__ccgo_up(pat + uintptr(k)))) == int32(']') { k = k + 1 } } for { - if !(k < m && *(*int8)(unsafe.Pointer(pat + uintptr(k))) != 0 && int32(*(*int8)(unsafe.Pointer(pat + uintptr(k)))) != int32(']')) { + if !(k < m && **(**int8)(__ccgo_up(pat + uintptr(k))) != 0 && int32(**(**int8)(__ccgo_up(pat + uintptr(k)))) != int32(']')) { break } - if k+uint32(1) < m && *(*int8)(unsafe.Pointer(pat + uintptr(k+uint32(1)))) != 0 && int32(*(*int8)(unsafe.Pointer(pat + uintptr(k)))) == int32('[') && (int32(*(*int8)(unsafe.Pointer(pat + uintptr(k+uint32(1))))) == int32(':') || int32(*(*int8)(unsafe.Pointer(pat + uintptr(k+uint32(1))))) == int32('.') || int32(*(*int8)(unsafe.Pointer(pat + uintptr(k+uint32(1))))) == int32('=')) { - z = int32(*(*int8)(unsafe.Pointer(pat + uintptr(k+uint32(1))))) + if k+uint32(1) < m && **(**int8)(__ccgo_up(pat + uintptr(k+uint32(1)))) != 0 && int32(**(**int8)(__ccgo_up(pat + uintptr(k)))) == int32('[') && (int32(**(**int8)(__ccgo_up(pat + uintptr(k+uint32(1))))) == int32(':') || int32(**(**int8)(__ccgo_up(pat + uintptr(k+uint32(1))))) == int32('.') || int32(**(**int8)(__ccgo_up(pat + uintptr(k+uint32(1))))) == int32('=')) { + z = int32(**(**int8)(__ccgo_up(pat + uintptr(k+uint32(1))))) k = k + uint32(2) - if k < m && *(*int8)(unsafe.Pointer(pat + uintptr(k))) != 0 { + if k < m && **(**int8)(__ccgo_up(pat + uintptr(k))) != 0 { k = k + 1 } - for k < m && *(*int8)(unsafe.Pointer(pat + uintptr(k))) != 0 && (int32(*(*int8)(unsafe.Pointer(pat + uintptr(k-uint32(1))))) != z || int32(*(*int8)(unsafe.Pointer(pat + uintptr(k)))) != int32(']')) { + for k < m && **(**int8)(__ccgo_up(pat + uintptr(k))) != 0 && (int32(**(**int8)(__ccgo_up(pat + uintptr(k-uint32(1))))) != z || int32(**(**int8)(__ccgo_up(pat + uintptr(k)))) != int32(']')) { k = k + 1 } - if k == m || !(*(*int8)(unsafe.Pointer(pat + uintptr(k))) != 0) { + if k == m || !(**(**int8)(__ccgo_up(pat + uintptr(k))) != 0) { break } } @@ -128592,32 +128592,32 @@ func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r i ; k = k + 1 } - if k == m || !(*(*int8)(unsafe.Pointer(pat + uintptr(k))) != 0) { - *(*Tsize_t)(unsafe.Pointer(step)) = uint32(1) + if k == m || !(**(**int8)(__ccgo_up(pat + uintptr(k))) != 0) { + **(**Tsize_t)(__ccgo_up(step)) = uint32(1) return int32('[') } - *(*Tsize_t)(unsafe.Pointer(step)) = k + uint32(1) + **(**Tsize_t)(__ccgo_up(step)) = k + uint32(1) return -int32(3) } - if int32(*(*int8)(unsafe.Pointer(pat))) == int32('*') { + if int32(**(**int8)(__ccgo_up(pat))) == int32('*') { return -int32(5) } - if int32(*(*int8)(unsafe.Pointer(pat))) == int32('?') { + if int32(**(**int8)(__ccgo_up(pat))) == int32('?') { return -int32(4) } goto escaped escaped: ; - if Uint32FromInt8(*(*int8)(unsafe.Pointer(pat))) >= uint32(128) { + if Uint32FromInt8(**(**int8)(__ccgo_up(pat))) >= uint32(128) { k1 = Xmbtowc(tls, bp, pat, m) if k1 < 0 { - *(*Tsize_t)(unsafe.Pointer(step)) = uint32(0) + **(**Tsize_t)(__ccgo_up(step)) = uint32(0) return -int32(2) } - *(*Tsize_t)(unsafe.Pointer(step)) = Uint32FromInt32(k1 + esc) - return *(*Twchar_t)(unsafe.Pointer(bp)) + **(**Tsize_t)(__ccgo_up(step)) = Uint32FromInt32(k1 + esc) + return int32(**(**Twchar_t)(__ccgo_up(bp))) } - return int32(*(*int8)(unsafe.Pointer(pat))) + return int32(**(**int8)(__ccgo_up(pat))) } func _casefold(tls *TLS, k int32) (r int32) { @@ -128644,59 +128644,59 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { _, _, _, _, _ = inv, l, l1, p0, z inv = 0 p = p + 1 - if int32(*(*int8)(unsafe.Pointer(p))) == int32('^') || int32(*(*int8)(unsafe.Pointer(p))) == int32('!') { + if int32(**(**int8)(__ccgo_up(p))) == int32('^') || int32(**(**int8)(__ccgo_up(p))) == int32('!') { inv = int32(1) p = p + 1 } - if int32(*(*int8)(unsafe.Pointer(p))) == int32(']') { + if int32(**(**int8)(__ccgo_up(p))) == int32(']') { if k == int32(']') { return BoolInt32(!(inv != 0)) } p = p + 1 } else { - if int32(*(*int8)(unsafe.Pointer(p))) == int32('-') { + if int32(**(**int8)(__ccgo_up(p))) == int32('-') { if k == int32('-') { return BoolInt32(!(inv != 0)) } p = p + 1 } } - *(*Twchar_t)(unsafe.Pointer(bp)) = int32(*(*int8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) + **(**Twchar_t)(__ccgo_up(bp)) = int32(**(**int8)(__ccgo_up(p + uintptr(-Int32FromInt32(1))))) for { - if !(int32(*(*int8)(unsafe.Pointer(p))) != int32(']')) { + if !(int32(**(**int8)(__ccgo_up(p))) != int32(']')) { break } - if int32(*(*int8)(unsafe.Pointer(p))) == int32('-') && int32(*(*int8)(unsafe.Pointer(p + 1))) != int32(']') { + if int32(**(**int8)(__ccgo_up(p))) == int32('-') && int32(**(**int8)(__ccgo_up(p + 1))) != int32(']') { l = Xmbtowc(tls, bp+4, p+uintptr(1), uint32(4)) if l < 0 { return 0 } - if *(*Twchar_t)(unsafe.Pointer(bp)) <= *(*Twchar_t)(unsafe.Pointer(bp + 4)) { - if uint32(Uint32FromInt32(k))-Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))) <= Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp + 4))-*(*Twchar_t)(unsafe.Pointer(bp))) || uint32(Uint32FromInt32(kfold))-Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))) <= Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp + 4))-*(*Twchar_t)(unsafe.Pointer(bp))) { + if **(**Twchar_t)(__ccgo_up(bp)) <= **(**Twchar_t)(__ccgo_up(bp + 4)) { + if uint32(Uint32FromInt32(k))-Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))) <= Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp + 4))-**(**Twchar_t)(__ccgo_up(bp))) || uint32(Uint32FromInt32(kfold))-Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))) <= Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp + 4))-**(**Twchar_t)(__ccgo_up(bp))) { return BoolInt32(!(inv != 0)) } } p = p + uintptr(l-int32(1)) goto _1 } - if int32(*(*int8)(unsafe.Pointer(p))) == int32('[') && (int32(*(*int8)(unsafe.Pointer(p + 1))) == int32(':') || int32(*(*int8)(unsafe.Pointer(p + 1))) == int32('.') || int32(*(*int8)(unsafe.Pointer(p + 1))) == int32('=')) { + if int32(**(**int8)(__ccgo_up(p))) == int32('[') && (int32(**(**int8)(__ccgo_up(p + 1))) == int32(':') || int32(**(**int8)(__ccgo_up(p + 1))) == int32('.') || int32(**(**int8)(__ccgo_up(p + 1))) == int32('=')) { p0 = p + uintptr(2) - z = int32(*(*int8)(unsafe.Pointer(p + 1))) + z = int32(**(**int8)(__ccgo_up(p + 1))) p = p + uintptr(3) - for int32(*(*int8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) != z || int32(*(*int8)(unsafe.Pointer(p))) != int32(']') { + for int32(**(**int8)(__ccgo_up(p + uintptr(-Int32FromInt32(1))))) != z || int32(**(**int8)(__ccgo_up(p))) != int32(']') { p = p + 1 } if z == int32(':') && int32(p-uintptr(1))-int32(p0) < int32(16) { Xmemcpy(tls, bp+8, p0, Uint32FromInt32(int32(p-uintptr(1))-int32(p0))) - (*(*[16]int8)(unsafe.Pointer(bp + 8)))[int32(p-uintptr(1))-int32(p0)] = 0 + (**(**[16]int8)(__ccgo_up(bp + 8)))[int32(p-uintptr(1))-int32(p0)] = 0 if Xiswctype(tls, Uint32FromInt32(k), Xwctype(tls, bp+8)) != 0 || Xiswctype(tls, Uint32FromInt32(kfold), Xwctype(tls, bp+8)) != 0 { return BoolInt32(!(inv != 0)) } } goto _1 } - if Uint32FromInt8(*(*int8)(unsafe.Pointer(p))) < uint32(128) { - *(*Twchar_t)(unsafe.Pointer(bp)) = Int32FromUint8(Uint8FromInt8(*(*int8)(unsafe.Pointer(p)))) + if Uint32FromInt8(**(**int8)(__ccgo_up(p))) < uint32(128) { + **(**Twchar_t)(__ccgo_up(bp)) = Int32FromUint8(Uint8FromInt8(**(**int8)(__ccgo_up(p)))) } else { l1 = Xmbtowc(tls, bp, p, uint32(4)) if l1 < 0 { @@ -128704,7 +128704,7 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { } p = p + uintptr(l1-int32(1)) } - if *(*Twchar_t)(unsafe.Pointer(bp)) == k || *(*Twchar_t)(unsafe.Pointer(bp)) == kfold { + if **(**Twchar_t)(__ccgo_up(bp)) == k || **(**Twchar_t)(__ccgo_up(bp)) == kfold { return BoolInt32(!(inv != 0)) } goto _1 @@ -128727,7 +128727,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, endpat, endstr, k, kfold, p, ptail, s, stail, tailcnt, v2, v6, v9 tailcnt = uint32(0) if flags&int32(FNM_PERIOD) != 0 { - if int32(*(*int8)(unsafe.Pointer(str))) == int32('.') && int32(*(*int8)(unsafe.Pointer(pat))) != int32('.') { + if int32(**(**int8)(__ccgo_up(str))) == int32('.') && int32(**(**int8)(__ccgo_up(pat))) != int32('.') { return int32(FNM_NOMATCH) } } @@ -128750,8 +128750,8 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, } return v2 } - str = str + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 4))) - n = n - *(*Tsize_t)(unsafe.Pointer(bp + 4)) + str = str + uintptr(**(**Tsize_t)(__ccgo_up(bp + 4))) + n = n - **(**Tsize_t)(__ccgo_up(bp + 4)) if flags&int32(FNM_CASEFOLD) != 0 { v2 = _casefold(tls, k) } else { @@ -128767,8 +128767,8 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, return int32(FNM_NOMATCH) } } - pat = pat + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) - m = m - *(*Tsize_t)(unsafe.Pointer(bp)) + pat = pat + uintptr(**(**Tsize_t)(__ccgo_up(bp))) + m = m - **(**Tsize_t)(__ccgo_up(bp)) goto _1 } break @@ -128799,7 +128799,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, goto _5 _5: ; - p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(**(**Tsize_t)(__ccgo_up(bp))) } /* Past this point we need not check for UNMATCHABLE in pat, * because all of pat has already been parsed once. */ @@ -128817,8 +128817,8 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, if !(s > str && tailcnt != 0) { break } - if v9 = Uint32FromInt8(*(*int8)(unsafe.Pointer(s + uintptr(-Int32FromInt32(1))))) < uint32(128); !v9 { - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if v9 = Uint32FromInt8(**(**int8)(__ccgo_up(s + uintptr(-Int32FromInt32(1))))) < uint32(128); !v9 { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v2 = int32(4) } else { v2 = int32(1) @@ -128830,7 +128830,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, for { s = s - 1 v6 = s - if !(uint32(Uint8FromInt8(*(*int8)(unsafe.Pointer(v6))))-uint32(0x80) < uint32(0x40) && s > str) { + if !(uint32(Uint8FromInt8(**(**int8)(__ccgo_up(v6))))-uint32(0x80) < uint32(0x40) && s > str) { break } } @@ -128848,7 +128848,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, p = ptail for { c = _pat_next(tls, p, Uint32FromInt32(int32(endpat)-int32(p)), bp, flags) - p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(**(**Tsize_t)(__ccgo_up(bp))) v2 = _str_next(tls, s, Uint32FromInt32(int32(endstr)-int32(s)), bp+4) k = v2 if v2 <= 0 { @@ -128857,7 +128857,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, } break } - s = s + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 4))) + s = s + uintptr(**(**Tsize_t)(__ccgo_up(bp + 4))) if flags&int32(FNM_CASEFOLD) != 0 { v2 = _casefold(tls, k) } else { @@ -128865,7 +128865,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, } kfold = v2 if c == -int32(3) { - if !(_match_bracket(tls, p-uintptr(*(*Tsize_t)(unsafe.Pointer(bp))), k, kfold) != 0) { + if !(_match_bracket(tls, p-uintptr(**(**Tsize_t)(__ccgo_up(bp))), k, kfold) != 0) { return int32(FNM_NOMATCH) } } else { @@ -128885,7 +128885,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, s = str for { c = _pat_next(tls, p, Uint32FromInt32(int32(endpat)-int32(p)), bp, flags) - p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(**(**Tsize_t)(__ccgo_up(bp))) /* Encountering * completes/commits a component */ if c == -int32(5) { pat = p @@ -128903,7 +128903,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, } kfold = v2 if c == -int32(3) { - if !(_match_bracket(tls, p-uintptr(*(*Tsize_t)(unsafe.Pointer(bp))), k, kfold) != 0) { + if !(_match_bracket(tls, p-uintptr(**(**Tsize_t)(__ccgo_up(bp))), k, kfold) != 0) { break } } else { @@ -128911,7 +128911,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, break } } - s = s + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 4))) + s = s + uintptr(**(**Tsize_t)(__ccgo_up(bp + 4))) goto _14 _14: } @@ -128922,7 +128922,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, * char, or past all invalid bytes otherwise. */ k = _str_next(tls, str, Uint32FromInt32(int32(endstr)-int32(str)), bp+4) if k > 0 { - str = str + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 4))) + str = str + uintptr(**(**Tsize_t)(__ccgo_up(bp + 4))) } else { str = str + 1 for { @@ -128954,7 +128954,7 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { for { s = str for { - if !(*(*int8)(unsafe.Pointer(s)) != 0 && int32(*(*int8)(unsafe.Pointer(s))) != int32('/')) { + if !(**(**int8)(__ccgo_up(s)) != 0 && int32(**(**int8)(__ccgo_up(s))) != int32('/')) { break } goto _2 @@ -128972,9 +128972,9 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { goto _3 _3: ; - p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(**(**Tsize_t)(__ccgo_up(bp))) } - if c != int32(*(*int8)(unsafe.Pointer(s))) && (!(*(*int8)(unsafe.Pointer(s)) != 0) || !(flags&Int32FromInt32(FNM_LEADING_DIR) != 0)) { + if c != int32(**(**int8)(__ccgo_up(s))) && (!(**(**int8)(__ccgo_up(s)) != 0) || !(flags&Int32FromInt32(FNM_LEADING_DIR) != 0)) { return int32(FNM_NOMATCH) } if _fnmatch_internal(tls, pat, Uint32FromInt32(int32(p)-int32(pat)), str, Uint32FromInt32(int32(s)-int32(str)), flags) != 0 { @@ -128984,7 +128984,7 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { return 0 } str = s + uintptr(1) - pat = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + pat = p + uintptr(**(**Tsize_t)(__ccgo_up(bp))) goto _1 _1: } @@ -128992,10 +128992,10 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { if flags&int32(FNM_LEADING_DIR) != 0 { s = str for { - if !(*(*int8)(unsafe.Pointer(s)) != 0) { + if !(**(**int8)(__ccgo_up(s)) != 0) { break } - if int32(*(*int8)(unsafe.Pointer(s))) != int32('/') { + if int32(**(**int8)(__ccgo_up(s))) != int32('/') { goto _5 } if !(_fnmatch_internal(tls, pat, Uint32FromInt32(-Int32FromInt32(1)), str, Uint32FromInt32(int32(s)-int32(str)), flags) != 0) { @@ -129045,14 +129045,14 @@ func _append(tls *TLS, tail uintptr, name uintptr, len1 Tsize_t, mark int32) (r if !(new1 != 0) { return -int32(1) } - (*Tmatch)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tail)))).Fnext = new1 + (*Tmatch)(unsafe.Pointer(**(**uintptr)(__ccgo_up(tail)))).Fnext = new1 (*Tmatch)(unsafe.Pointer(new1)).Fnext = UintptrFromInt32(0) Xmemcpy(tls, new1+4, name, len1+uint32(1)) - if mark != 0 && len1 != 0 && int32(*(*int8)(unsafe.Pointer(name + uintptr(len1-uint32(1))))) != int32('/') { + if mark != 0 && len1 != 0 && int32(**(**int8)(__ccgo_up(name + uintptr(len1-uint32(1))))) != int32('/') { *(*int8)(unsafe.Pointer(new1 + 4 + uintptr(len1))) = int8('/') *(*int8)(unsafe.Pointer(new1 + 4 + uintptr(len1+uint32(1)))) = 0 } - *(*uintptr)(unsafe.Pointer(tail)) = new1 + **(**uintptr)(__ccgo_up(tail)) = new1 return 0 } @@ -129072,15 +129072,15 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag } /* Special-case the remaining pattern being all slashes, in * which case we can use caller-passed type if it's a dir. */ - if *(*int8)(unsafe.Pointer(pat)) != 0 && type1 != int32(DT_DIR) { + if **(**int8)(__ccgo_up(pat)) != 0 && type1 != int32(DT_DIR) { type1 = 0 } - for pos+uint32(1) < uint32(PATH_MAX) && int32(*(*int8)(unsafe.Pointer(pat))) == int32('/') { + for pos+uint32(1) < uint32(PATH_MAX) && int32(**(**int8)(__ccgo_up(pat))) == int32('/') { v1 = pos pos = pos + 1 v2 = pat pat = pat + 1 - *(*int8)(unsafe.Pointer(buf + uintptr(v1))) = *(*int8)(unsafe.Pointer(v2)) + **(**int8)(__ccgo_up(buf + uintptr(v1))) = **(**int8)(__ccgo_up(v2)) } /* Consume maximal [escaped-]literal prefix of pattern, copying * and un-escaping it to the running buffer as we go. */ @@ -129089,10 +129089,10 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag in_bracket = 0 overflow = 0 for { - if !(int32(*(*int8)(unsafe.Pointer(pat + uintptr(i)))) != int32('*') && int32(*(*int8)(unsafe.Pointer(pat + uintptr(i)))) != int32('?') && (!(in_bracket != 0) || int32(*(*int8)(unsafe.Pointer(pat + uintptr(i)))) != int32(']'))) { + if !(int32(**(**int8)(__ccgo_up(pat + uintptr(i)))) != int32('*') && int32(**(**int8)(__ccgo_up(pat + uintptr(i)))) != int32('?') && (!(in_bracket != 0) || int32(**(**int8)(__ccgo_up(pat + uintptr(i)))) != int32(']'))) { break } - if !(*(*int8)(unsafe.Pointer(pat + uintptr(i))) != 0) { + if !(**(**int8)(__ccgo_up(pat + uintptr(i))) != 0) { if overflow != 0 { return 0 } @@ -129103,25 +129103,25 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag i = v4 break } else { - if int32(*(*int8)(unsafe.Pointer(pat + uintptr(i)))) == int32('[') { + if int32(**(**int8)(__ccgo_up(pat + uintptr(i)))) == int32('[') { in_bracket = int32(1) } else { - if int32(*(*int8)(unsafe.Pointer(pat + uintptr(i)))) == int32('\\') && !(flags&Int32FromInt32(GLOB_NOESCAPE) != 0) { + if int32(**(**int8)(__ccgo_up(pat + uintptr(i)))) == int32('\\') && !(flags&Int32FromInt32(GLOB_NOESCAPE) != 0) { /* Backslashes inside a bracket are (at least by * our interpretation) non-special, so if next * char is ']' we have a complete expression. */ - if in_bracket != 0 && int32(*(*int8)(unsafe.Pointer(pat + uintptr(i+int32(1))))) == int32(']') { + if in_bracket != 0 && int32(**(**int8)(__ccgo_up(pat + uintptr(i+int32(1))))) == int32(']') { break } /* Unpaired final backslash never matches. */ - if !(*(*int8)(unsafe.Pointer(pat + uintptr(i+int32(1)))) != 0) { + if !(**(**int8)(__ccgo_up(pat + uintptr(i+int32(1)))) != 0) { return 0 } i = i + 1 } } } - if int32(*(*int8)(unsafe.Pointer(pat + uintptr(i)))) == int32('/') { + if int32(**(**int8)(__ccgo_up(pat + uintptr(i)))) == int32('/') { if overflow != 0 { return 0 } @@ -129139,7 +129139,7 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag if pos+Uint32FromInt32(j+Int32FromInt32(1)) < uint32(PATH_MAX) { v4 = j j = j + 1 - *(*int8)(unsafe.Pointer(buf + uintptr(pos+Uint32FromInt32(v4)))) = *(*int8)(unsafe.Pointer(pat + uintptr(i))) + **(**int8)(__ccgo_up(buf + uintptr(pos+Uint32FromInt32(v4)))) = **(**int8)(__ccgo_up(pat + uintptr(i))) } else { if in_bracket != 0 { overflow = int32(1) @@ -129155,17 +129155,17 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag ; i = i + 1 } - *(*int8)(unsafe.Pointer(buf + uintptr(pos))) = 0 - if !(*(*int8)(unsafe.Pointer(pat)) != 0) { + **(**int8)(__ccgo_up(buf + uintptr(pos))) = 0 + if !(**(**int8)(__ccgo_up(pat)) != 0) { if flags&int32(GLOB_MARK) != 0 && (!(type1 != 0) || type1 == int32(DT_LNK)) && !(Xstat(tls, buf, bp) != 0) { - if (*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFDIR) { + if (**(**Tstat)(__ccgo_up(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFDIR) { type1 = int32(DT_DIR) } else { type1 = int32(DT_REG) } } if !(type1 != 0) && Xlstat(tls, buf, bp) != 0 { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(ENOENT) && ((*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(ENOENT) && ((*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, **(**int32)(__ccgo_up(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0) { return int32(GLOB_ABORTED) } return 0 @@ -129182,7 +129182,7 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag if p2 != 0 && !(flags&Int32FromInt32(GLOB_NOESCAPE) != 0) { p = p2 for { - if !(p > pat && int32(*(*int8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) == int32('\\')) { + if !(p > pat && int32(**(**int8)(__ccgo_up(p + uintptr(-Int32FromInt32(1))))) == int32('\\')) { break } goto _6 @@ -129202,14 +129202,14 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag } dir = Xopendir(tls, v2) if !(dir != 0) { - if (*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0 { + if (*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, **(**int32)(__ccgo_up(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0 { return int32(GLOB_ABORTED) } return 0 } - old_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + old_errno = **(**int32)(__ccgo_up(X__errno_location(tls))) for { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = 0 + **(**int32)(__ccgo_up(X__errno_location(tls))) = 0 v2 = Xreaddir(tls, dir) de = v2 if !(v2 != 0) { @@ -129224,7 +129224,7 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag continue } if p2 != 0 { - *(*int8)(unsafe.Pointer(p2)) = 0 + **(**int8)(__ccgo_up(p2)) = 0 } if flags&int32(GLOB_NOESCAPE) != 0 { v9 = int32(FNM_NOESCAPE) @@ -129242,12 +129242,12 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag } /* With GLOB_PERIOD, don't allow matching . or .. unless * fnmatch would match them with FNM_PERIOD rules in effect. */ - if p2 != 0 && flags&int32(GLOB_PERIOD) != 0 && int32(*(*int8)(unsafe.Pointer(de + 19))) == int32('.') && (!(*(*int8)(unsafe.Pointer(de + 19 + 1)) != 0) || int32(*(*int8)(unsafe.Pointer(de + 19 + 1))) == int32('.') && !(*(*int8)(unsafe.Pointer(de + 19 + 2)) != 0)) && Xfnmatch(tls, pat, de+19, fnm_flags|int32(FNM_PERIOD)) != 0 { + if p2 != 0 && flags&int32(GLOB_PERIOD) != 0 && int32(**(**int8)(__ccgo_up(de + 19))) == int32('.') && (!(**(**int8)(__ccgo_up(de + 19 + 1)) != 0) || int32(**(**int8)(__ccgo_up(de + 19 + 1))) == int32('.') && !(**(**int8)(__ccgo_up(de + 19 + 2)) != 0)) && Xfnmatch(tls, pat, de+19, fnm_flags|int32(FNM_PERIOD)) != 0 { continue } Xmemcpy(tls, buf+uintptr(pos), de+19, l+uint32(1)) if p2 != 0 { - *(*int8)(unsafe.Pointer(p2)) = saved_sep + **(**int8)(__ccgo_up(p2)) = saved_sep } if p2 != 0 { v2 = p2 @@ -129260,15 +129260,15 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag return r } } - readerr = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + readerr = **(**int32)(__ccgo_up(X__errno_location(tls))) if p2 != 0 { - *(*int8)(unsafe.Pointer(p2)) = saved_sep + **(**int8)(__ccgo_up(p2)) = saved_sep } Xclosedir(tls, dir) - if readerr != 0 && ((*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0) { + if readerr != 0 && ((*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, **(**int32)(__ccgo_up(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0) { return int32(GLOB_ABORTED) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = old_errno + **(**int32)(__ccgo_up(X__errno_location(tls))) = old_errno return 0 } @@ -129294,7 +129294,7 @@ func _freelist(tls *TLS, head uintptr) { } func _sort(tls *TLS, a uintptr, b uintptr) (r int32) { - return Xstrcmp(tls, *(*uintptr)(unsafe.Pointer(a)), *(*uintptr)(unsafe.Pointer(b))) + return Xstrcmp(tls, **(**uintptr)(__ccgo_up(a)), **(**uintptr)(__ccgo_up(b))) } func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { @@ -129307,25 +129307,25 @@ func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { var _ /* pw at bp+0 */ Tpasswd var _ /* res at bp+28 */ uintptr _, _, _, _, _, _, _, _, _ = delim, home, i, name_end, p, v1, v10, v2, v4 - p = *(*uintptr)(unsafe.Pointer(pat)) + uintptr(1) + p = **(**uintptr)(__ccgo_up(pat)) + uintptr(1) i = uint32(0) name_end = X__strchrnul(tls, p, int32('/')) - v1 = *(*int8)(unsafe.Pointer(name_end)) + v1 = **(**int8)(__ccgo_up(name_end)) delim = v1 if v1 != 0 { v2 = name_end name_end = name_end + 1 - *(*int8)(unsafe.Pointer(v2)) = 0 + **(**int8)(__ccgo_up(v2)) = 0 } - *(*uintptr)(unsafe.Pointer(pat)) = name_end - if *(*int8)(unsafe.Pointer(p)) != 0 { + **(**uintptr)(__ccgo_up(pat)) = name_end + if **(**int8)(__ccgo_up(p)) != 0 { v2 = UintptrFromInt32(0) } else { v2 = Xgetenv(tls, __ccgo_ts+1310) } home = v2 if !(home != 0) { - if *(*int8)(unsafe.Pointer(p)) != 0 { + if **(**int8)(__ccgo_up(p)) != 0 { v4 = Xgetpwnam_r(tls, p, bp, buf, uint32(PATH_MAX), bp+28) } else { v4 = Xgetpwuid_r(tls, Xgetuid(tls), bp, buf, uint32(PATH_MAX), bp+28) @@ -129344,7 +129344,7 @@ func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { return int32(GLOB_NOSPACE) _7: ; - if !!(*(*uintptr)(unsafe.Pointer(bp + 28)) != 0) { + if !!(**(**uintptr)(__ccgo_up(bp + 28)) != 0) { goto _9 } _6: @@ -129354,26 +129354,26 @@ func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { ; _8: ; - home = (*(*Tpasswd)(unsafe.Pointer(bp))).Fpw_dir + home = (**(**Tpasswd)(__ccgo_up(bp))).Fpw_dir } - for i < Uint32FromInt32(Int32FromInt32(PATH_MAX)-Int32FromInt32(2)) && *(*int8)(unsafe.Pointer(home)) != 0 { + for i < Uint32FromInt32(Int32FromInt32(PATH_MAX)-Int32FromInt32(2)) && **(**int8)(__ccgo_up(home)) != 0 { v10 = i i = i + 1 v2 = home home = home + 1 - *(*int8)(unsafe.Pointer(buf + uintptr(v10))) = *(*int8)(unsafe.Pointer(v2)) + **(**int8)(__ccgo_up(buf + uintptr(v10))) = **(**int8)(__ccgo_up(v2)) } - if *(*int8)(unsafe.Pointer(home)) != 0 { + if **(**int8)(__ccgo_up(home)) != 0 { return int32(GLOB_NOMATCH) } v1 = delim - *(*int8)(unsafe.Pointer(buf + uintptr(i))) = v1 + **(**int8)(__ccgo_up(buf + uintptr(i))) = v1 if v1 != 0 { i = i + 1 v10 = i - *(*int8)(unsafe.Pointer(buf + uintptr(v10))) = 0 + **(**int8)(__ccgo_up(buf + uintptr(v10))) = 0 } - *(*Tsize_t)(unsafe.Pointer(pos)) = i + **(**Tsize_t)(__ccgo_up(pos)) = i return 0 } @@ -129396,10 +129396,10 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint var _ /* s at bp+4108 */ uintptr var _ /* tail at bp+4 */ uintptr _, _, _, _, _, _, _ = cnt, error1, i, offs, p, pathv, v1 - *(*Tmatch)(unsafe.Pointer(bp)) = struct { + **(**Tmatch)(__ccgo_up(bp)) = struct { Fnext uintptr }{} - *(*uintptr)(unsafe.Pointer(bp + 4)) = bp + **(**uintptr)(__ccgo_up(bp + 4)) = bp if flags&int32(GLOB_DOOFFS) != 0 { v1 = (*Tglob_t)(unsafe.Pointer(g)).Fgl_offs } else { @@ -129415,19 +129415,19 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathc = uint32(0) (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv = UintptrFromInt32(0) } - if *(*int8)(unsafe.Pointer(pat)) != 0 { + if **(**int8)(__ccgo_up(pat)) != 0 { p = Xstrdup(tls, pat) if !(p != 0) { return int32(GLOB_NOSPACE) } - (*(*[4096]int8)(unsafe.Pointer(bp + 8)))[0] = 0 - *(*Tsize_t)(unsafe.Pointer(bp + 4104)) = uint32(0) - *(*uintptr)(unsafe.Pointer(bp + 4108)) = p - if flags&(Int32FromInt32(GLOB_TILDE)|Int32FromInt32(GLOB_TILDE_CHECK)) != 0 && int32(*(*int8)(unsafe.Pointer(p))) == int32('~') { + (**(**[4096]int8)(__ccgo_up(bp + 8)))[0] = 0 + **(**Tsize_t)(__ccgo_up(bp + 4104)) = uint32(0) + **(**uintptr)(__ccgo_up(bp + 4108)) = p + if flags&(Int32FromInt32(GLOB_TILDE)|Int32FromInt32(GLOB_TILDE_CHECK)) != 0 && int32(**(**int8)(__ccgo_up(p))) == int32('~') { error1 = _expand_tilde(tls, bp+4108, bp+8, bp+4104) } if !(error1 != 0) { - error1 = _do_glob(tls, bp+8, *(*Tsize_t)(unsafe.Pointer(bp + 4104)), 0, *(*uintptr)(unsafe.Pointer(bp + 4108)), flags, __ccgo_fp_errfunc, bp+4) + error1 = _do_glob(tls, bp+8, **(**Tsize_t)(__ccgo_up(bp + 4104)), 0, **(**uintptr)(__ccgo_up(bp + 4108)), flags, __ccgo_fp_errfunc, bp+4) } Xfree(tls, p) } @@ -129436,20 +129436,20 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint return error1 } cnt = uint32(0) - *(*uintptr)(unsafe.Pointer(bp + 4)) = (*(*Tmatch)(unsafe.Pointer(bp))).Fnext + **(**uintptr)(__ccgo_up(bp + 4)) = (**(**Tmatch)(__ccgo_up(bp))).Fnext for { - if !(*(*uintptr)(unsafe.Pointer(bp + 4)) != 0) { + if !(**(**uintptr)(__ccgo_up(bp + 4)) != 0) { break } goto _2 _2: ; - *(*uintptr)(unsafe.Pointer(bp + 4)) = (*Tmatch)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)))).Fnext + **(**uintptr)(__ccgo_up(bp + 4)) = (*Tmatch)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp + 4)))).Fnext cnt = cnt + 1 } if !(cnt != 0) { if flags&int32(GLOB_NOCHECK) != 0 { - *(*uintptr)(unsafe.Pointer(bp + 4)) = bp + **(**uintptr)(__ccgo_up(bp + 4)) = bp if _append(tls, bp+4, pat, _strlen(tls, pat), 0) != 0 { return int32(GLOB_NOSPACE) } @@ -129479,7 +129479,7 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint if !(i < offs) { break } - *(*uintptr)(unsafe.Pointer((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(i)*4)) = UintptrFromInt32(0) + **(**uintptr)(__ccgo_up((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(i)*4)) = UintptrFromInt32(0) goto _3 _3: ; @@ -129487,20 +129487,20 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint } } i = uint32(0) - *(*uintptr)(unsafe.Pointer(bp + 4)) = (*(*Tmatch)(unsafe.Pointer(bp))).Fnext + **(**uintptr)(__ccgo_up(bp + 4)) = (**(**Tmatch)(__ccgo_up(bp))).Fnext for { if !(i < cnt) { break } - *(*uintptr)(unsafe.Pointer((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(offs+i)*4)) = *(*uintptr)(unsafe.Pointer(bp + 4)) + 4 + **(**uintptr)(__ccgo_up((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(offs+i)*4)) = **(**uintptr)(__ccgo_up(bp + 4)) + 4 goto _4 _4: ; - *(*uintptr)(unsafe.Pointer(bp + 4)) = (*Tmatch)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)))).Fnext + **(**uintptr)(__ccgo_up(bp + 4)) = (*Tmatch)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp + 4)))).Fnext i = i + 1 } - *(*uintptr)(unsafe.Pointer((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(offs+i)*4)) = UintptrFromInt32(0) - *(*Tsize_t)(unsafe.Pointer(g)) += cnt + **(**uintptr)(__ccgo_up((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(offs+i)*4)) = UintptrFromInt32(0) + **(**Tsize_t)(__ccgo_up(g)) += cnt if !(flags&Int32FromInt32(GLOB_NOSORT) != 0) { Xqsort(tls, (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv+uintptr(offs)*4, cnt, uint32(4), __ccgo_fp(_sort)) } @@ -129518,7 +129518,7 @@ func Xglobfree(tls *TLS, g uintptr) { if !(i < (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathc) { break } - Xfree(tls, *(*uintptr)(unsafe.Pointer((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr((*Tglob_t)(unsafe.Pointer(g)).Fgl_offs+i)*4))-uintptr(uint32(UintptrFromInt32(0)+4))) + Xfree(tls, **(**uintptr)(__ccgo_up((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr((*Tglob_t)(unsafe.Pointer(g)).Fgl_offs+i)*4))-uintptr(uint32(UintptrFromInt32(0)+4))) goto _1 _1: ; @@ -129917,7 +129917,7 @@ func _tre_stack_push(tls *TLS, s uintptr, value Ttre_stack_item) (r Treg_errcode var new_size int32 _, _ = new_buffer, new_size if (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr < (*Ttre_stack_t)(unsafe.Pointer(s)).Fsize { - *(*Ttre_stack_item)(unsafe.Pointer((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr((*Ttre_stack_t)(unsafe.Pointer(s)).Fptr)*4)) = value + **(**Ttre_stack_item)(__ccgo_up((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr((*Ttre_stack_t)(unsafe.Pointer(s)).Fptr)*4)) = value (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr = (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr + 1 } else { if (*Ttre_stack_t)(unsafe.Pointer(s)).Fsize >= (*Ttre_stack_t)(unsafe.Pointer(s)).Fmax_size { @@ -129944,7 +129944,7 @@ func _tre_stack_push_int(tls *TLS, s uintptr, value int32) (r Treg_errcode_t) { defer tls.Free(16) var _ /* item at bp+0 */ Ttre_stack_item *(*int32)(unsafe.Pointer(bp)) = value - return _tre_stack_push(tls, s, *(*Ttre_stack_item)(unsafe.Pointer(bp))) + return _tre_stack_push(tls, s, **(**Ttre_stack_item)(__ccgo_up(bp))) } func _tre_stack_push_voidptr(tls *TLS, s uintptr, value uintptr) (r Treg_errcode_t) { @@ -129952,7 +129952,7 @@ func _tre_stack_push_voidptr(tls *TLS, s uintptr, value uintptr) (r Treg_errcode defer tls.Free(16) var _ /* item at bp+0 */ Ttre_stack_item *(*uintptr)(unsafe.Pointer(bp)) = value - return _tre_stack_push(tls, s, *(*Ttre_stack_item)(unsafe.Pointer(bp))) + return _tre_stack_push(tls, s, **(**Ttre_stack_item)(__ccgo_up(bp))) } func _tre_stack_pop_int(tls *TLS, s uintptr) (r int32) { @@ -130062,7 +130062,7 @@ func _tre_expand_macro(tls *TLS, s uintptr) (r uintptr) { _ = i i = 0 for { - if !(_tre_macros[i].Fc != 0 && int32(_tre_macros[i].Fc) != int32(*(*int8)(unsafe.Pointer(s)))) { + if !(_tre_macros[i].Fc != 0 && int32(_tre_macros[i].Fc) != int32(**(**int8)(__ccgo_up(s)))) { break } goto _1 @@ -130079,7 +130079,7 @@ func _tre_compare_lit(tls *TLS, a uintptr, b uintptr) (r int32) { la = a lb = b /* assumes the range of valid code_min is < INT_MAX */ - return (*Ttre_literal_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(la)))).Fcode_min - (*Ttre_literal_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(lb)))).Fcode_min + return (*Ttre_literal_t)(unsafe.Pointer(**(**uintptr)(__ccgo_up(la)))).Fcode_min - (*Ttre_literal_t)(unsafe.Pointer(**(**uintptr)(__ccgo_up(lb)))).Fcode_min } type Tliterals = struct { @@ -130097,7 +130097,7 @@ func _tre_new_lit(tls *TLS, p uintptr) (r uintptr) { if (*Tliterals)(unsafe.Pointer(p)).Fcap1 >= Int32FromInt32(1)< max { @@ -130289,7 +130289,7 @@ func _parse_bracket_terms(tls *TLS, ctx uintptr, s uintptr, ls uintptr, neg uint v6 = neg + 4 v2 = *(*int32)(unsafe.Pointer(v6)) *(*int32)(unsafe.Pointer(v6)) = *(*int32)(unsafe.Pointer(v6)) + 1 - *(*Ttre_ctype_t)(unsafe.Pointer(neg + 8 + uintptr(v2)*4)) = class + **(**Ttre_ctype_t)(__ccgo_up(neg + 8 + uintptr(v2)*4)) = class } else { lit = _tre_new_lit(tls, ls) if !(lit != 0) { @@ -130329,23 +130329,23 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { _, _, _, _, _, _, _, _, _, _, _ = err, i, lit, max, min, n, nc, negmax, negmin, node, v1 node = uintptr(0) nc = uintptr(0) - (*(*Tliterals)(unsafe.Pointer(bp))).Fmem = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem - (*(*Tliterals)(unsafe.Pointer(bp))).Flen1 = 0 - (*(*Tliterals)(unsafe.Pointer(bp))).Fcap1 = int32(32) - (*(*Tliterals)(unsafe.Pointer(bp))).Fa = Xmalloc(tls, Uint32FromInt32((*(*Tliterals)(unsafe.Pointer(bp))).Fcap1)*uint32(4)) - if !((*(*Tliterals)(unsafe.Pointer(bp))).Fa != 0) { + (**(**Tliterals)(__ccgo_up(bp))).Fmem = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem + (**(**Tliterals)(__ccgo_up(bp))).Flen1 = 0 + (**(**Tliterals)(__ccgo_up(bp))).Fcap1 = int32(32) + (**(**Tliterals)(__ccgo_up(bp))).Fa = Xmalloc(tls, Uint32FromInt32((**(**Tliterals)(__ccgo_up(bp))).Fcap1)*uint32(4)) + if !((**(**Tliterals)(__ccgo_up(bp))).Fa != 0) { return int32(REG_ESPACE) } - (*(*Tneg)(unsafe.Pointer(bp + 16))).Flen1 = 0 - (*(*Tneg)(unsafe.Pointer(bp + 16))).Fnegate = BoolInt32(int32(*(*int8)(unsafe.Pointer(s))) == int32('^')) - if (*(*Tneg)(unsafe.Pointer(bp + 16))).Fnegate != 0 { + (**(**Tneg)(__ccgo_up(bp + 16))).Flen1 = 0 + (**(**Tneg)(__ccgo_up(bp + 16))).Fnegate = BoolInt32(int32(**(**int8)(__ccgo_up(s))) == int32('^')) + if (**(**Tneg)(__ccgo_up(bp + 16))).Fnegate != 0 { s = s + 1 } err = _parse_bracket_terms(tls, ctx, s, bp, bp+16) if err != REG_OK { goto parse_bracket_done } - if (*(*Tneg)(unsafe.Pointer(bp + 16))).Fnegate != 0 { + if (**(**Tneg)(__ccgo_up(bp + 16))).Fnegate != 0 { /* * With REG_NEWLINE, POSIX requires that newlines are not matched by * any form of a non-matching list. @@ -130361,7 +130361,7 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition = -int32(1) } /* Sort the array if we need to negate it. */ - Xqsort(tls, (*(*Tliterals)(unsafe.Pointer(bp))).Fa, Uint32FromInt32((*(*Tliterals)(unsafe.Pointer(bp))).Flen1), uint32(4), __ccgo_fp(_tre_compare_lit)) + Xqsort(tls, (**(**Tliterals)(__ccgo_up(bp))).Fa, Uint32FromInt32((**(**Tliterals)(__ccgo_up(bp))).Flen1), uint32(4), __ccgo_fp(_tre_compare_lit)) /* extra lit for the last negated range */ lit = _tre_new_lit(tls, bp) if !(lit != 0) { @@ -130372,14 +130372,14 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max = int32(Int32FromInt32(TRE_CHAR_MAX) + Int32FromInt32(1)) (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition = -int32(1) /* negated classes */ - if (*(*Tneg)(unsafe.Pointer(bp + 16))).Flen1 != 0 { - nc = X__tre_mem_alloc_impl(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, 0, UintptrFromInt32(0), 0, Uint32FromInt32((*(*Tneg)(unsafe.Pointer(bp + 16))).Flen1+Int32FromInt32(1))*uint32(4)) + if (**(**Tneg)(__ccgo_up(bp + 16))).Flen1 != 0 { + nc = X__tre_mem_alloc_impl(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, 0, UintptrFromInt32(0), 0, Uint32FromInt32((**(**Tneg)(__ccgo_up(bp + 16))).Flen1+Int32FromInt32(1))*uint32(4)) if !(nc != 0) { err = int32(REG_ESPACE) goto parse_bracket_done } - Xmemcpy(tls, nc, bp+16+8, Uint32FromInt32((*(*Tneg)(unsafe.Pointer(bp + 16))).Flen1)*uint32(4)) - *(*Ttre_ctype_t)(unsafe.Pointer(nc + uintptr((*(*Tneg)(unsafe.Pointer(bp + 16))).Flen1)*4)) = uint32(0) + Xmemcpy(tls, nc, bp+16+8, Uint32FromInt32((**(**Tneg)(__ccgo_up(bp + 16))).Flen1)*uint32(4)) + **(**Ttre_ctype_t)(__ccgo_up(nc + uintptr((**(**Tneg)(__ccgo_up(bp + 16))).Flen1)*4)) = uint32(0) } } /* Build a union of the items in the array, negated if necessary. */ @@ -130388,13 +130388,13 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { negmax = v1 i = 0 for { - if !(i < (*(*Tliterals)(unsafe.Pointer(bp))).Flen1) { + if !(i < (**(**Tliterals)(__ccgo_up(bp))).Flen1) { break } - lit = *(*uintptr)(unsafe.Pointer((*(*Tliterals)(unsafe.Pointer(bp))).Fa + uintptr(i)*4)) + lit = **(**uintptr)(__ccgo_up((**(**Tliterals)(__ccgo_up(bp))).Fa + uintptr(i)*4)) min = (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min max = (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max - if (*(*Tneg)(unsafe.Pointer(bp + 16))).Fnegate != 0 { + if (**(**Tneg)(__ccgo_up(bp + 16))).Fnegate != 0 { if min <= negmin { /* Overlap. */ if max+int32(1) >= negmin { @@ -130426,22 +130426,22 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { goto parse_bracket_done parse_bracket_done: ; - Xfree(tls, (*(*Tliterals)(unsafe.Pointer(bp))).Fa) + Xfree(tls, (**(**Tliterals)(__ccgo_up(bp))).Fa) (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition + 1 (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = node return err } func _parse_dup_count(tls *TLS, s uintptr, n uintptr) (r uintptr) { - *(*int32)(unsafe.Pointer(n)) = -int32(1) - if !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + **(**int32)(__ccgo_up(n)) = -int32(1) + if !(BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return s } - *(*int32)(unsafe.Pointer(n)) = 0 + **(**int32)(__ccgo_up(n)) = 0 for { - *(*int32)(unsafe.Pointer(n)) = int32(10)**(*int32)(unsafe.Pointer(n)) + (int32(*(*int8)(unsafe.Pointer(s))) - int32('0')) + **(**int32)(__ccgo_up(n)) = int32(10)***(**int32)(__ccgo_up(n)) + (int32(**(**int8)(__ccgo_up(s))) - int32('0')) s = s + 1 - if !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) || *(*int32)(unsafe.Pointer(n)) > int32(RE_DUP_MAX) { + if !(BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) || **(**int32)(__ccgo_up(n)) > int32(RE_DUP_MAX) { break } goto _1 @@ -130459,26 +130459,26 @@ func _parse_dup(tls *TLS, s uintptr, ere int32, pmin uintptr, pmax uintptr) (r u var _ /* min at bp+0 */ int32 _, _, _, _, _ = v1, v2, v3, v4, v5 s = _parse_dup_count(tls, s, bp) - if int32(*(*int8)(unsafe.Pointer(s))) == int32(',') { + if int32(**(**int8)(__ccgo_up(s))) == int32(',') { s = _parse_dup_count(tls, s+uintptr(1), bp+4) } else { - *(*int32)(unsafe.Pointer(bp + 4)) = *(*int32)(unsafe.Pointer(bp)) + **(**int32)(__ccgo_up(bp + 4)) = **(**int32)(__ccgo_up(bp)) } - if v3 = *(*int32)(unsafe.Pointer(bp + 4)) < *(*int32)(unsafe.Pointer(bp)) && *(*int32)(unsafe.Pointer(bp + 4)) >= 0 || *(*int32)(unsafe.Pointer(bp + 4)) > int32(RE_DUP_MAX) || *(*int32)(unsafe.Pointer(bp)) > int32(RE_DUP_MAX) || *(*int32)(unsafe.Pointer(bp)) < 0; !v3 { + if v3 = **(**int32)(__ccgo_up(bp + 4)) < **(**int32)(__ccgo_up(bp)) && **(**int32)(__ccgo_up(bp + 4)) >= 0 || **(**int32)(__ccgo_up(bp + 4)) > int32(RE_DUP_MAX) || **(**int32)(__ccgo_up(bp)) > int32(RE_DUP_MAX) || **(**int32)(__ccgo_up(bp)) < 0; !v3 { if v2 = !(ere != 0); v2 { v1 = s s = s + 1 } } - if v5 = v3 || v2 && int32(*(*int8)(unsafe.Pointer(v1))) != int32('\\'); !v5 { + if v5 = v3 || v2 && int32(**(**int8)(__ccgo_up(v1))) != int32('\\'); !v5 { v4 = s s = s + 1 } - if v5 || int32(*(*int8)(unsafe.Pointer(v4))) != int32('}') { + if v5 || int32(**(**int8)(__ccgo_up(v4))) != int32('}') { return uintptr(0) } - *(*int32)(unsafe.Pointer(pmin)) = *(*int32)(unsafe.Pointer(bp)) - *(*int32)(unsafe.Pointer(pmax)) = *(*int32)(unsafe.Pointer(bp + 4)) + **(**int32)(__ccgo_up(pmin)) = **(**int32)(__ccgo_up(bp)) + **(**int32)(__ccgo_up(pmax)) = **(**int32)(__ccgo_up(bp + 4)) return s } @@ -130541,7 +130541,7 @@ func _parse_atom(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { var _ /* wc at bp+0 */ Twchar_t _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, ere, err, i, len1, node, p, tmp1, tmp11, tmp2, tmp21, v, val, v14, v16 ere = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fcflags & int32(REG_EXTENDED) - switch int32(*(*int8)(unsafe.Pointer(s))) { + switch int32(**(**int8)(__ccgo_up(s))) { case int32('['): goto _1 case int32('\\'): @@ -130583,7 +130583,7 @@ _2: /* extensions: \b, \B, \<, \>, \xHH \x{HHHH} */ s = s + 1 v14 = s - switch int32(*(*int8)(unsafe.Pointer(v14))) { + switch int32(**(**int8)(__ccgo_up(v14))) { case 0: return int32(REG_EESCAPE) case int32('b'): @@ -130598,7 +130598,7 @@ _2: s = s + 1 v = 0 len1 = int32(2) - if int32(*(*int8)(unsafe.Pointer(s))) == int32('{') { + if int32(**(**int8)(__ccgo_up(s))) == int32('{') { len1 = int32(8) s = s + 1 } @@ -130607,7 +130607,7 @@ _2: if !(i < len1 && v < int32(0x110000)) { break } - c = _hexval1(tls, Uint32FromInt8(*(*int8)(unsafe.Pointer(s + uintptr(i))))) + c = _hexval1(tls, Uint32FromInt8(**(**int8)(__ccgo_up(s + uintptr(i))))) if c < 0 { break } @@ -130619,7 +130619,7 @@ _2: } s = s + uintptr(i) if len1 == int32(8) { - if int32(*(*int8)(unsafe.Pointer(s))) != int32('}') { + if int32(**(**int8)(__ccgo_up(s))) != int32('}') { return int32(REG_EBRACE) } s = s + 1 @@ -130650,9 +130650,9 @@ _2: /* fallthrough */ fallthrough default: - if !(ere != 0) && Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-uint32('1') < uint32(9) { + if !(ere != 0) && Uint32FromInt8(**(**int8)(__ccgo_up(s)))-uint32('1') < uint32(9) { /* back reference */ - val = int32(*(*int8)(unsafe.Pointer(s))) - int32('0') + val = int32(**(**int8)(__ccgo_up(s))) - int32('0') v14 = ctx + 24 v16 = *(*int32)(unsafe.Pointer(v14)) *(*int32)(unsafe.Pointer(v14)) = *(*int32)(unsafe.Pointer(v14)) + 1 @@ -130707,7 +130707,7 @@ _4: _5: ; /* '$' is special everywhere in EREs, and at the end of a BRE subexpression. */ - if !(ere != 0) && *(*int8)(unsafe.Pointer(s + 1)) != 0 && (int32(*(*int8)(unsafe.Pointer(s + 1))) != int32('\\') || int32(*(*int8)(unsafe.Pointer(s + 2))) != int32(')') && int32(*(*int8)(unsafe.Pointer(s + 2))) != int32('|')) { + if !(ere != 0) && **(**int8)(__ccgo_up(s + 1)) != 0 && (int32(**(**int8)(__ccgo_up(s + 1))) != int32('\\') || int32(**(**int8)(__ccgo_up(s + 2))) != int32(')') && int32(**(**int8)(__ccgo_up(s + 2))) != int32('|')) { goto parse_literal } node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(2), int32(ASSERT_AT_EOL), -int32(1)) @@ -130743,17 +130743,17 @@ parse_literal: if len1 < 0 { return int32(REG_BADPAT) } - if (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fcflags&int32(REG_ICASE) != 0 && (Xiswupper(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp)))) != 0 || Xiswlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp)))) != 0) { + if (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fcflags&int32(REG_ICASE) != 0 && (Xiswupper(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp)))) != 0 || Xiswlower(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp)))) != 0) { /* multiple opposite case characters are not supported */ - tmp11 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint32(Xtowupper(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))))), Int32FromUint32(Xtowupper(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))))), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) - tmp21 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint32(Xtowlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))))), Int32FromUint32(Xtowlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))))), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) + tmp11 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint32(Xtowupper(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))))), Int32FromUint32(Xtowupper(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))))), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) + tmp21 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint32(Xtowlower(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))))), Int32FromUint32(Xtowlower(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))))), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) if tmp11 != 0 && tmp21 != 0 { node = _tre_ast_new_union(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, tmp11, tmp21) } else { node = uintptr(0) } } else { - node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, *(*Twchar_t)(unsafe.Pointer(bp)), *(*Twchar_t)(unsafe.Pointer(bp)), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) + node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, int32(**(**Twchar_t)(__ccgo_up(bp))), int32(**(**Twchar_t)(__ccgo_up(bp))), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) } (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition + 1 s = s + uintptr(len1) @@ -130795,7 +130795,7 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { return err } for { - if !(ere != 0) && int32(*(*int8)(unsafe.Pointer(s))) == int32('\\') && int32(*(*int8)(unsafe.Pointer(s + 1))) == int32('(') || ere != 0 && int32(*(*int8)(unsafe.Pointer(s))) == int32('(') { + if !(ere != 0) && int32(**(**int8)(__ccgo_up(s))) == int32('\\') && int32(**(**int8)(__ccgo_up(s + 1))) == int32('(') || ere != 0 && int32(**(**int8)(__ccgo_up(s))) == int32('(') { v1 = _tre_stack_push_voidptr(tls, stack, nunion) err = v1 if v1 != REG_OK { @@ -130824,7 +130824,7 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart = s goto _3 } - if !(ere != 0) && int32(*(*int8)(unsafe.Pointer(s))) == int32('\\') && int32(*(*int8)(unsafe.Pointer(s + 1))) == int32(')') || ere != 0 && int32(*(*int8)(unsafe.Pointer(s))) == int32(')') && depth != 0 { + if !(ere != 0) && int32(**(**int8)(__ccgo_up(s))) == int32('\\') && int32(**(**int8)(__ccgo_up(s + 1))) == int32(')') || ere != 0 && int32(**(**int8)(__ccgo_up(s))) == int32(')') && depth != 0 { (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(1), -int32(1), -int32(1)) if !((*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn != 0) { return int32(REG_ESPACE) @@ -130840,52 +130840,52 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { parse_iter: ; for { - if int32(*(*int8)(unsafe.Pointer(s))) != int32('\\') && int32(*(*int8)(unsafe.Pointer(s))) != int32('*') { + if int32(**(**int8)(__ccgo_up(s))) != int32('\\') && int32(**(**int8)(__ccgo_up(s))) != int32('*') { if !(ere != 0) { break } - if int32(*(*int8)(unsafe.Pointer(s))) != int32('+') && int32(*(*int8)(unsafe.Pointer(s))) != int32('?') && int32(*(*int8)(unsafe.Pointer(s))) != int32('{') { + if int32(**(**int8)(__ccgo_up(s))) != int32('+') && int32(**(**int8)(__ccgo_up(s))) != int32('?') && int32(**(**int8)(__ccgo_up(s))) != int32('{') { break } } - if int32(*(*int8)(unsafe.Pointer(s))) == int32('\\') && ere != 0 { + if int32(**(**int8)(__ccgo_up(s))) == int32('\\') && ere != 0 { break } /* extension: treat \+, \? as repetitions in BRE */ - if int32(*(*int8)(unsafe.Pointer(s))) == int32('\\') && int32(*(*int8)(unsafe.Pointer(s + 1))) != int32('+') && int32(*(*int8)(unsafe.Pointer(s + 1))) != int32('?') && int32(*(*int8)(unsafe.Pointer(s + 1))) != int32('{') { + if int32(**(**int8)(__ccgo_up(s))) == int32('\\') && int32(**(**int8)(__ccgo_up(s + 1))) != int32('+') && int32(**(**int8)(__ccgo_up(s + 1))) != int32('?') && int32(**(**int8)(__ccgo_up(s + 1))) != int32('{') { break } - if int32(*(*int8)(unsafe.Pointer(s))) == int32('\\') { + if int32(**(**int8)(__ccgo_up(s))) == int32('\\') { s = s + 1 } /* handle ^* at the start of a BRE. */ - if !(ere != 0) && s == (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart+uintptr(1) && int32(*(*int8)(unsafe.Pointer(s + uintptr(-Int32FromInt32(1))))) == int32('^') { + if !(ere != 0) && s == (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart+uintptr(1) && int32(**(**int8)(__ccgo_up(s + uintptr(-Int32FromInt32(1))))) == int32('^') { break } /* extension: multiple consecutive *+?{,} is unspecified, but (a+)+ has to be supported so accepting a++ makes sense, note however that the RE_DUP_MAX limit can be circumvented: (a{255}){255} uses a lot of memory.. */ - if int32(*(*int8)(unsafe.Pointer(s))) == int32('{') { + if int32(**(**int8)(__ccgo_up(s))) == int32('{') { s = _parse_dup(tls, s+uintptr(1), ere, bp, bp+4) if !(s != 0) { return int32(REG_BADBR) } } else { - *(*int32)(unsafe.Pointer(bp)) = 0 - *(*int32)(unsafe.Pointer(bp + 4)) = -int32(1) - if int32(*(*int8)(unsafe.Pointer(s))) == int32('+') { - *(*int32)(unsafe.Pointer(bp)) = int32(1) + **(**int32)(__ccgo_up(bp)) = 0 + **(**int32)(__ccgo_up(bp + 4)) = -int32(1) + if int32(**(**int8)(__ccgo_up(s))) == int32('+') { + **(**int32)(__ccgo_up(bp)) = int32(1) } - if int32(*(*int8)(unsafe.Pointer(s))) == int32('?') { - *(*int32)(unsafe.Pointer(bp + 4)) = int32(1) + if int32(**(**int8)(__ccgo_up(s))) == int32('?') { + **(**int32)(__ccgo_up(bp + 4)) = int32(1) } s = s + 1 } - if *(*int32)(unsafe.Pointer(bp + 4)) == 0 { + if **(**int32)(__ccgo_up(bp + 4)) == 0 { (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(1), -int32(1), -int32(1)) } else { - (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = _tre_ast_new_iter(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn, *(*int32)(unsafe.Pointer(bp)), *(*int32)(unsafe.Pointer(bp + 4)), 0) + (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = _tre_ast_new_iter(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn, **(**int32)(__ccgo_up(bp)), **(**int32)(__ccgo_up(bp + 4)), 0) } if !((*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn != 0) { return int32(REG_ESPACE) @@ -130894,13 +130894,13 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { _9: } nbranch = _tre_ast_new_catenation(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, nbranch, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn) - if ere != 0 && int32(*(*int8)(unsafe.Pointer(s))) == int32('|') || ere != 0 && int32(*(*int8)(unsafe.Pointer(s))) == int32(')') && depth != 0 || !(ere != 0) && int32(*(*int8)(unsafe.Pointer(s))) == int32('\\') && int32(*(*int8)(unsafe.Pointer(s + 1))) == int32(')') || !(ere != 0) && int32(*(*int8)(unsafe.Pointer(s))) == int32('\\') && int32(*(*int8)(unsafe.Pointer(s + 1))) == int32('|') || !(*(*int8)(unsafe.Pointer(s)) != 0) { + if ere != 0 && int32(**(**int8)(__ccgo_up(s))) == int32('|') || ere != 0 && int32(**(**int8)(__ccgo_up(s))) == int32(')') && depth != 0 || !(ere != 0) && int32(**(**int8)(__ccgo_up(s))) == int32('\\') && int32(**(**int8)(__ccgo_up(s + 1))) == int32(')') || !(ere != 0) && int32(**(**int8)(__ccgo_up(s))) == int32('\\') && int32(**(**int8)(__ccgo_up(s + 1))) == int32('|') || !(**(**int8)(__ccgo_up(s)) != 0) { /* extension: empty branch is unspecified (), (|a), (a|) here they are not rejected but match on empty string */ - c = int32(*(*int8)(unsafe.Pointer(s))) + c = int32(**(**int8)(__ccgo_up(s))) nunion = _tre_ast_new_union(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, nunion, nbranch) nbranch = uintptr(0) - if c == int32('\\') && int32(*(*int8)(unsafe.Pointer(s + 1))) == int32('|') { + if c == int32('\\') && int32(**(**int8)(__ccgo_up(s + 1))) == int32('|') { s = s + uintptr(2) (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart = s } else { @@ -131046,22 +131046,22 @@ func _tre_purge_regset(tls *TLS, regset uintptr, tnfa uintptr, tag int32) { _, _, _ = i, id, start i = 0 for { - if !(*(*int32)(unsafe.Pointer(regset + uintptr(i)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(regset + uintptr(i)*4)) >= 0) { break } - id = *(*int32)(unsafe.Pointer(regset + uintptr(i)*4)) / int32(2) - start = BoolInt32(!(*(*int32)(unsafe.Pointer(regset + uintptr(i)*4))%Int32FromInt32(2) != 0)) + id = **(**int32)(__ccgo_up(regset + uintptr(i)*4)) / int32(2) + start = BoolInt32(!(**(**int32)(__ccgo_up(regset + uintptr(i)*4))%Int32FromInt32(2) != 0)) if start != 0 { - (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id)*12))).Fso_tag = tag + (**(**Ttre_submatch_data_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id)*12))).Fso_tag = tag } else { - (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id)*12))).Feo_tag = tag + (**(**Ttre_submatch_data_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id)*12))).Feo_tag = tag } goto _1 _1: ; i = i + 1 } - *(*int32)(unsafe.Pointer(regset)) = -int32(1) + **(**int32)(__ccgo_up(regset)) = -int32(1) } // C documentation @@ -131090,20 +131090,20 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u direction = int32(_TRE_TAG_MINIMIZE) if !(first_pass != 0) { (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fend_tag = 0 - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags)) = -int32(1) + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags)) = -int32(1) } regset = Xmalloc(tls, uint32(4)*(((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches+uint32(1))*uint32(2))) if regset == UintptrFromInt32(0) { return int32(REG_ESPACE) } - *(*int32)(unsafe.Pointer(regset)) = -int32(1) + **(**int32)(__ccgo_up(regset)) = -int32(1) orig_regset = regset parents = Xmalloc(tls, uint32(4)*((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches+uint32(1))) if parents == UintptrFromInt32(0) { Xfree(tls, regset) return int32(REG_ESPACE) } - *(*int32)(unsafe.Pointer(parents)) = -int32(1) + **(**int32)(__ccgo_up(parents)) = -int32(1) saved_states = Xmalloc(tls, uint32(8)*((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches+uint32(1))) if saved_states == UintptrFromInt32(0) { Xfree(tls, regset) @@ -131115,7 +131115,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u if !(i <= (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches) { break } - (*(*Ttre_tag_states_t)(unsafe.Pointer(saved_states + uintptr(i)*8))).Ftag = -int32(1) + (**(**Ttre_tag_states_t)(__ccgo_up(saved_states + uintptr(i)*8))).Ftag = -int32(1) goto _1 _1: ; @@ -131154,7 +131154,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u /* Add end of this submatch to regset. */ i1 = 0 for { - if !(*(*int32)(unsafe.Pointer(regset + uintptr(i1)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(regset + uintptr(i1)*4)) >= 0) { break } goto _11 @@ -131162,12 +131162,12 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i1 = i1 + 1 } - *(*int32)(unsafe.Pointer(regset + uintptr(i1)*4)) = id*int32(2) + int32(1) - *(*int32)(unsafe.Pointer(regset + uintptr(i1+int32(1))*4)) = -int32(1) + **(**int32)(__ccgo_up(regset + uintptr(i1)*4)) = id*int32(2) + int32(1) + **(**int32)(__ccgo_up(regset + uintptr(i1+int32(1))*4)) = -int32(1) /* Pop this submatch from the parents stack. */ i1 = 0 for { - if !(*(*int32)(unsafe.Pointer(parents + uintptr(i1)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(parents + uintptr(i1)*4)) >= 0) { break } goto _12 @@ -131175,7 +131175,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i1 = i1 + 1 } - *(*int32)(unsafe.Pointer(parents + uintptr(i1-int32(1))*4)) = -int32(1) + **(**int32)(__ccgo_up(parents + uintptr(i1-int32(1))*4)) = -int32(1) goto _10 _3: ; @@ -131185,7 +131185,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u /* Add start of this submatch to regset. */ i2 = 0 for { - if !(*(*int32)(unsafe.Pointer(regset + uintptr(i2)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(regset + uintptr(i2)*4)) >= 0) { break } goto _13 @@ -131193,12 +131193,12 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i2 = i2 + 1 } - *(*int32)(unsafe.Pointer(regset + uintptr(i2)*4)) = id1 * int32(2) - *(*int32)(unsafe.Pointer(regset + uintptr(i2+int32(1))*4)) = -int32(1) + **(**int32)(__ccgo_up(regset + uintptr(i2)*4)) = id1 * int32(2) + **(**int32)(__ccgo_up(regset + uintptr(i2+int32(1))*4)) = -int32(1) if !(first_pass != 0) { i2 = 0 for { - if !(*(*int32)(unsafe.Pointer(parents + uintptr(i2)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(parents + uintptr(i2)*4)) >= 0) { break } goto _14 @@ -131206,26 +131206,26 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i2 = i2 + 1 } - (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id1)*12))).Fparents = UintptrFromInt32(0) + (**(**Ttre_submatch_data_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id1)*12))).Fparents = UintptrFromInt32(0) if i2 > 0 { p = Xmalloc(tls, uint32(4)*Uint32FromInt32(i2+Int32FromInt32(1))) if p == UintptrFromInt32(0) { status = int32(REG_ESPACE) goto _10 } - (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id1)*12))).Fparents = p + (**(**Ttre_submatch_data_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id1)*12))).Fparents = p i2 = 0 for { - if !(*(*int32)(unsafe.Pointer(parents + uintptr(i2)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(parents + uintptr(i2)*4)) >= 0) { break } - *(*int32)(unsafe.Pointer(p + uintptr(i2)*4)) = *(*int32)(unsafe.Pointer(parents + uintptr(i2)*4)) + **(**int32)(__ccgo_up(p + uintptr(i2)*4)) = **(**int32)(__ccgo_up(parents + uintptr(i2)*4)) goto _15 _15: ; i2 = i2 + 1 } - *(*int32)(unsafe.Pointer(p + uintptr(i2)*4)) = -int32(1) + **(**int32)(__ccgo_up(p + uintptr(i2)*4)) = -int32(1) } } /* Add end of this submatch to regset after processing this @@ -131243,16 +131243,16 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u case int32(_LITERAL): lit = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj if !((*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min < Int32FromInt32(0)) || (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min == -int32(4) { - if *(*int32)(unsafe.Pointer(regset)) >= 0 { + if **(**int32)(__ccgo_up(regset)) >= 0 { /* Regset is not empty, so add a tag before the literal or backref. */ if !(first_pass != 0) { status = _tre_add_tag_left(tls, mem, node, tag) - *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = direction + **(**Ttre_tag_direction_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = direction if minimal_tag >= 0 { i3 = 0 for { - if !(*(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3)*4)) >= 0) { break } goto _16 @@ -131260,9 +131260,9 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i3 = i3 + 1 } - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3)*4)) = tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3+int32(1))*4)) = minimal_tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3+int32(2))*4)) = -int32(1) + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3)*4)) = tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3+int32(1))*4)) = minimal_tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) num_minimals = num_minimals + 1 } @@ -131270,7 +131270,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u } else { (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fnum_tags = int32(1) } - *(*int32)(unsafe.Pointer(regset)) = -int32(1) + **(**int32)(__ccgo_up(regset)) = -int32(1) tag = next_tag num_tags = num_tags + 1 next_tag = next_tag + 1 @@ -131330,7 +131330,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u case int32(_ITERATION): iter = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj if first_pass != 0 { - status = _tre_stack_push_int(tls, stack, BoolInt32(*(*int32)(unsafe.Pointer(regset)) >= 0 || int32(uint32(*(*uint8)(unsafe.Pointer(iter + 12))&0x1>>0)) != 0)) + status = _tre_stack_push_int(tls, stack, BoolInt32(**(**int32)(__ccgo_up(regset)) >= 0 || int32(uint32(*(*uint8)(unsafe.Pointer(iter + 12))&0x1>>0)) != 0)) if status != REG_OK { break } @@ -131361,18 +131361,18 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u break } /* Regset is not empty, so add a tag here. */ - if *(*int32)(unsafe.Pointer(regset)) >= 0 || int32(uint32(*(*uint8)(unsafe.Pointer(iter + 12))&0x1>>0)) != 0 { + if **(**int32)(__ccgo_up(regset)) >= 0 || int32(uint32(*(*uint8)(unsafe.Pointer(iter + 12))&0x1>>0)) != 0 { if !(first_pass != 0) { status = _tre_add_tag_left(tls, mem, node, tag) if int32(uint32(*(*uint8)(unsafe.Pointer(iter + 12))&0x1>>0)) != 0 { - *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = int32(_TRE_TAG_MAXIMIZE) + **(**Ttre_tag_direction_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = int32(_TRE_TAG_MAXIMIZE) } else { - *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = direction + **(**Ttre_tag_direction_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = direction } if minimal_tag >= 0 { i4 = 0 for { - if !(*(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4)*4)) >= 0) { break } goto _17 @@ -131380,15 +131380,15 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i4 = i4 + 1 } - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4)*4)) = tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4+int32(1))*4)) = minimal_tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4+int32(2))*4)) = -int32(1) + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4)*4)) = tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4+int32(1))*4)) = minimal_tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) num_minimals = num_minimals + 1 } _tre_purge_regset(tls, regset, tnfa, tag) } - *(*int32)(unsafe.Pointer(regset)) = -int32(1) + **(**int32)(__ccgo_up(regset)) = -int32(1) tag = next_tag num_tags = num_tags + 1 next_tag = next_tag + 1 @@ -131398,7 +131398,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u uni = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj left1 = (*Ttre_union_t)(unsafe.Pointer(uni)).Fleft right1 = (*Ttre_union_t)(unsafe.Pointer(uni)).Fright - if *(*int32)(unsafe.Pointer(regset)) >= 0 { + if **(**int32)(__ccgo_up(regset)) >= 0 { left_tag = next_tag right_tag = next_tag + int32(1) } else { @@ -131418,7 +131418,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u if status != REG_OK { break } - status = _tre_stack_push_int(tls, stack, BoolInt32(*(*int32)(unsafe.Pointer(regset)) >= 0)) + status = _tre_stack_push_int(tls, stack, BoolInt32(**(**int32)(__ccgo_up(regset)) >= 0)) if status != REG_OK { break } @@ -131462,14 +131462,14 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u break } /* Regset is not empty, so add a tag here. */ - if *(*int32)(unsafe.Pointer(regset)) >= 0 { + if **(**int32)(__ccgo_up(regset)) >= 0 { if !(first_pass != 0) { status = _tre_add_tag_left(tls, mem, node, tag) - *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = direction + **(**Ttre_tag_direction_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = direction if minimal_tag >= 0 { i5 = 0 for { - if !(*(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5)*4)) >= 0) { break } goto _18 @@ -131477,15 +131477,15 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i5 = i5 + 1 } - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5)*4)) = tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5+int32(1))*4)) = minimal_tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5+int32(2))*4)) = -int32(1) + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5)*4)) = tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5+int32(1))*4)) = minimal_tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) num_minimals = num_minimals + 1 } _tre_purge_regset(tls, regset, tnfa, tag) } - *(*int32)(unsafe.Pointer(regset)) = -int32(1) + **(**int32)(__ccgo_up(regset)) = -int32(1) tag = next_tag num_tags = num_tags + 1 next_tag = next_tag + 1 @@ -131502,7 +131502,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u /* Push this submatch on the parents stack. */ i6 = 0 for { - if !(*(*int32)(unsafe.Pointer(parents + uintptr(i6)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(parents + uintptr(i6)*4)) >= 0) { break } goto _19 @@ -131510,8 +131510,8 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i6 = i6 + 1 } - *(*int32)(unsafe.Pointer(parents + uintptr(i6)*4)) = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fsubmatch_id - *(*int32)(unsafe.Pointer(parents + uintptr(i6+int32(1))*4)) = -int32(1) + **(**int32)(__ccgo_up(parents + uintptr(i6)*4)) = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fsubmatch_id + **(**int32)(__ccgo_up(parents + uintptr(i6+int32(1))*4)) = -int32(1) } goto _10 /* end case: ADDTAGS_RECURSE */ _4: @@ -131559,7 +131559,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u will be restored at ADDTAGS_AFTER_UNION_RIGHT below. */ _21: ; - if !(*(*int32)(unsafe.Pointer(regset)) >= 0) { + if !(**(**int32)(__ccgo_up(regset)) >= 0) { goto _20 } regset += 4 @@ -131596,11 +131596,11 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u if (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fnum_submatches > 0 { if !(first_pass != 0) { status = _tre_add_tag_right(tls, mem, left2, tag_left) - *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag_left)*4)) = int32(_TRE_TAG_MAXIMIZE) + **(**Ttre_tag_direction_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag_left)*4)) = int32(_TRE_TAG_MAXIMIZE) if status == REG_OK { status = _tre_add_tag_right(tls, mem, right2, tag_right) } - *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag_right)*4)) = int32(_TRE_TAG_MAXIMIZE) + **(**Ttre_tag_direction_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag_right)*4)) = int32(_TRE_TAG_MAXIMIZE) } num_tags = num_tags + int32(2) } @@ -131618,7 +131618,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u if !(first_pass != 0) && minimal_tag >= 0 { i7 = 0 for { - if !(*(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7)*4)) >= 0) { break } goto _23 @@ -131626,9 +131626,9 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i7 = i7 + 1 } - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7)*4)) = tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7+int32(1))*4)) = minimal_tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7+int32(2))*4)) = -int32(1) + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7)*4)) = tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7+int32(1))*4)) = minimal_tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) num_minimals = num_minimals + 1 } @@ -131685,7 +131685,7 @@ func _tre_copy_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, flags i /* XXX - e.g. [ab] has only one position but two nodes, so we are creating holes in the state space here. Not fatal, just wastes memory. */ - pos = pos + *(*int32)(unsafe.Pointer(pos_add)) + pos = pos + **(**int32)(__ccgo_up(pos_add)) num_copied = num_copied + 1 } else { if (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min == -int32(3) && flags&int32(COPY_REMOVE_TAGS) != 0 { @@ -131697,30 +131697,30 @@ func _tre_copy_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, flags i } else { if (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min == -int32(3) && flags&int32(COPY_MAXIMIZE_FIRST_TAG) != 0 && first_tag != 0 { /* Maximize the first tag. */ - *(*Ttre_tag_direction_t)(unsafe.Pointer(tag_directions + uintptr(max)*4)) = int32(_TRE_TAG_MAXIMIZE) + **(**Ttre_tag_direction_t)(__ccgo_up(tag_directions + uintptr(max)*4)) = int32(_TRE_TAG_MAXIMIZE) first_tag = 0 } } } - *(*uintptr)(unsafe.Pointer(result)) = _tre_ast_new_literal(tls, mem, min, max, pos) - if *(*uintptr)(unsafe.Pointer(result)) == UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(result)) = _tre_ast_new_literal(tls, mem, min, max, pos) + if **(**uintptr)(__ccgo_up(result)) == UintptrFromInt32(0) { status = int32(REG_ESPACE) } else { - p = (*Ttre_ast_node_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(result)))).Fobj + p = (*Ttre_ast_node_t)(unsafe.Pointer(**(**uintptr)(__ccgo_up(result)))).Fobj (*Ttre_literal_t)(unsafe.Pointer(p)).Fclass = (*Ttre_literal_t)(unsafe.Pointer(lit)).Fclass (*Ttre_literal_t)(unsafe.Pointer(p)).Fneg_classes = (*Ttre_literal_t)(unsafe.Pointer(lit)).Fneg_classes } - if pos > *(*int32)(unsafe.Pointer(max_pos)) { - *(*int32)(unsafe.Pointer(max_pos)) = pos + if pos > **(**int32)(__ccgo_up(max_pos)) { + **(**int32)(__ccgo_up(max_pos)) = pos } case int32(_UNION): uni = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj - *(*uintptr)(unsafe.Pointer(result)) = _tre_ast_new_union(tls, mem, (*Ttre_union_t)(unsafe.Pointer(uni)).Fleft, (*Ttre_union_t)(unsafe.Pointer(uni)).Fright) - if *(*uintptr)(unsafe.Pointer(result)) == UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(result)) = _tre_ast_new_union(tls, mem, (*Ttre_union_t)(unsafe.Pointer(uni)).Fleft, (*Ttre_union_t)(unsafe.Pointer(uni)).Fright) + if **(**uintptr)(__ccgo_up(result)) == UintptrFromInt32(0) { status = int32(REG_ESPACE) break } - tmp = (*Ttre_ast_node_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(result)))).Fobj + tmp = (*Ttre_ast_node_t)(unsafe.Pointer(**(**uintptr)(__ccgo_up(result)))).Fobj result = tmp status = _tre_stack_push_voidptr(tls, stack, (*Ttre_union_t)(unsafe.Pointer(uni)).Fright) if status != REG_OK { @@ -131748,12 +131748,12 @@ func _tre_copy_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, flags i } case int32(_CATENATION): cat = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj - *(*uintptr)(unsafe.Pointer(result)) = _tre_ast_new_catenation(tls, mem, (*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft, (*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright) - if *(*uintptr)(unsafe.Pointer(result)) == UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(result)) = _tre_ast_new_catenation(tls, mem, (*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft, (*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright) + if **(**uintptr)(__ccgo_up(result)) == UintptrFromInt32(0) { status = int32(REG_ESPACE) break } - tmp1 = (*Ttre_ast_node_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(result)))).Fobj + tmp1 = (*Ttre_ast_node_t)(unsafe.Pointer(**(**uintptr)(__ccgo_up(result)))).Fobj (*Ttre_catenation_t)(unsafe.Pointer(tmp1)).Fleft = UintptrFromInt32(0) (*Ttre_catenation_t)(unsafe.Pointer(tmp1)).Fright = UintptrFromInt32(0) result = tmp1 @@ -131791,12 +131791,12 @@ func _tre_copy_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, flags i if status != REG_OK { break } - *(*uintptr)(unsafe.Pointer(result)) = _tre_ast_new_iter(tls, mem, (*Ttre_iteration_t)(unsafe.Pointer(iter)).Farg, (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmin, (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmax, int32(uint32(*(*uint8)(unsafe.Pointer(iter + 12))&0x1>>0))) - if *(*uintptr)(unsafe.Pointer(result)) == UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(result)) = _tre_ast_new_iter(tls, mem, (*Ttre_iteration_t)(unsafe.Pointer(iter)).Farg, (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmin, (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmax, int32(uint32(*(*uint8)(unsafe.Pointer(iter + 12))&0x1>>0))) + if **(**uintptr)(__ccgo_up(result)) == UintptrFromInt32(0) { status = int32(REG_ESPACE) break } - iter = (*Ttre_ast_node_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(result)))).Fobj + iter = (*Ttre_ast_node_t)(unsafe.Pointer(**(**uintptr)(__ccgo_up(result)))).Fobj result = iter default: break @@ -131804,7 +131804,7 @@ func _tre_copy_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, flags i break } } - *(*int32)(unsafe.Pointer(pos_add)) += num_copied + **(**int32)(__ccgo_up(pos_add)) += num_copied return status } @@ -131832,9 +131832,9 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _status, _status1, bottom, cat, flags, iter, iter1, iter_depth, j, lit, node, pos_add_last, pos_add_save, pos_add_total, seq1, status, symbol, tmp, uni, v2 status = REG_OK bottom = _tre_stack_num_objects(tls, stack) - *(*int32)(unsafe.Pointer(bp)) = 0 + **(**int32)(__ccgo_up(bp)) = 0 pos_add_total = 0 - *(*int32)(unsafe.Pointer(bp + 4)) = 0 + **(**int32)(__ccgo_up(bp + 4)) = 0 iter_depth = 0 _status = _tre_stack_push_voidptr(tls, stack, ast) if _status != REG_OK { @@ -131856,9 +131856,9 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit case int32(_LITERAL): lit = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj if !((*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min < Int32FromInt32(0)) || (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min == -int32(4) { - *(*int32)(unsafe.Pointer(lit + 8)) += *(*int32)(unsafe.Pointer(bp)) - if (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition > *(*int32)(unsafe.Pointer(bp + 4)) { - *(*int32)(unsafe.Pointer(bp + 4)) = (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition + **(**int32)(__ccgo_up(lit + 8)) += **(**int32)(__ccgo_up(bp)) + if (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition > **(**int32)(__ccgo_up(bp + 4)) { + **(**int32)(__ccgo_up(bp + 4)) = (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition } } case int32(_UNION): @@ -131899,7 +131899,7 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit } case int32(_ITERATION): iter = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj - status = _tre_stack_push_int(tls, stack, *(*int32)(unsafe.Pointer(bp))) + status = _tre_stack_push_int(tls, stack, **(**int32)(__ccgo_up(bp))) if status != REG_OK { break } @@ -131923,7 +131923,7 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit then don't increase the `pos' fields of the nodes now, it will get done when expanding. */ if (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmin > int32(1) || (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmax > int32(1) { - *(*int32)(unsafe.Pointer(bp)) = 0 + **(**int32)(__ccgo_up(bp)) = 0 } iter_depth = iter_depth + 1 default: @@ -131931,12 +131931,12 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit } case int32(_EXPAND_AFTER_ITER): iter1 = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj - *(*int32)(unsafe.Pointer(bp)) = _tre_stack_pop_int(tls, stack) - pos_add_last = *(*int32)(unsafe.Pointer(bp)) + **(**int32)(__ccgo_up(bp)) = _tre_stack_pop_int(tls, stack) + pos_add_last = **(**int32)(__ccgo_up(bp)) if (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Fmin > int32(1) || (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Fmax > int32(1) { seq1 = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(bp + 8)) = UintptrFromInt32(0) - pos_add_save = *(*int32)(unsafe.Pointer(bp)) + **(**uintptr)(__ccgo_up(bp + 8)) = UintptrFromInt32(0) + pos_add_save = **(**int32)(__ccgo_up(bp)) /* Create a catenated sequence of copies of the node. */ j = 0 for { @@ -131950,15 +131950,15 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit } /* Remove tags from all but the last copy. */ flags = v2 - pos_add_save = *(*int32)(unsafe.Pointer(bp)) + pos_add_save = **(**int32)(__ccgo_up(bp)) status = _tre_copy_ast(tls, mem, stack, (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Farg, flags, bp, tag_directions, bp+12, bp+4) if status != REG_OK { return status } if seq1 != UintptrFromInt32(0) { - seq1 = _tre_ast_new_catenation(tls, mem, seq1, *(*uintptr)(unsafe.Pointer(bp + 12))) + seq1 = _tre_ast_new_catenation(tls, mem, seq1, **(**uintptr)(__ccgo_up(bp + 12))) } else { - seq1 = *(*uintptr)(unsafe.Pointer(bp + 12)) + seq1 = **(**uintptr)(__ccgo_up(bp + 12)) } if seq1 == UintptrFromInt32(0) { return int32(REG_ESPACE) @@ -131970,13 +131970,13 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit } if (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Fmax == -int32(1) { /* No upper limit. */ - pos_add_save = *(*int32)(unsafe.Pointer(bp)) + pos_add_save = **(**int32)(__ccgo_up(bp)) status = _tre_copy_ast(tls, mem, stack, (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Farg, 0, bp, UintptrFromInt32(0), bp+8, bp+4) if status != REG_OK { return status } - *(*uintptr)(unsafe.Pointer(bp + 8)) = _tre_ast_new_iter(tls, mem, *(*uintptr)(unsafe.Pointer(bp + 8)), 0, -int32(1), 0) - if *(*uintptr)(unsafe.Pointer(bp + 8)) == UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(bp + 8)) = _tre_ast_new_iter(tls, mem, **(**uintptr)(__ccgo_up(bp + 8)), 0, -int32(1), 0) + if **(**uintptr)(__ccgo_up(bp + 8)) == UintptrFromInt32(0) { return int32(REG_ESPACE) } } else { @@ -131985,25 +131985,25 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit if !(j < (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Fmax) { break } - pos_add_save = *(*int32)(unsafe.Pointer(bp)) + pos_add_save = **(**int32)(__ccgo_up(bp)) status = _tre_copy_ast(tls, mem, stack, (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Farg, 0, bp, UintptrFromInt32(0), bp+16, bp+4) if status != REG_OK { return status } - if *(*uintptr)(unsafe.Pointer(bp + 8)) != UintptrFromInt32(0) { - *(*uintptr)(unsafe.Pointer(bp + 8)) = _tre_ast_new_catenation(tls, mem, *(*uintptr)(unsafe.Pointer(bp + 16)), *(*uintptr)(unsafe.Pointer(bp + 8))) + if **(**uintptr)(__ccgo_up(bp + 8)) != UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(bp + 8)) = _tre_ast_new_catenation(tls, mem, **(**uintptr)(__ccgo_up(bp + 16)), **(**uintptr)(__ccgo_up(bp + 8))) } else { - *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 16)) + **(**uintptr)(__ccgo_up(bp + 8)) = **(**uintptr)(__ccgo_up(bp + 16)) } - if *(*uintptr)(unsafe.Pointer(bp + 8)) == UintptrFromInt32(0) { + if **(**uintptr)(__ccgo_up(bp + 8)) == UintptrFromInt32(0) { return int32(REG_ESPACE) } tmp = _tre_ast_new_literal(tls, mem, -int32(1), -int32(1), -int32(1)) if tmp == UintptrFromInt32(0) { return int32(REG_ESPACE) } - *(*uintptr)(unsafe.Pointer(bp + 8)) = _tre_ast_new_union(tls, mem, tmp, *(*uintptr)(unsafe.Pointer(bp + 8))) - if *(*uintptr)(unsafe.Pointer(bp + 8)) == UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(bp + 8)) = _tre_ast_new_union(tls, mem, tmp, **(**uintptr)(__ccgo_up(bp + 8))) + if **(**uintptr)(__ccgo_up(bp + 8)) == UintptrFromInt32(0) { return int32(REG_ESPACE) } goto _3 @@ -132012,12 +132012,12 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit j = j + 1 } } - *(*int32)(unsafe.Pointer(bp)) = pos_add_save + **(**int32)(__ccgo_up(bp)) = pos_add_save if seq1 == UintptrFromInt32(0) { - seq1 = *(*uintptr)(unsafe.Pointer(bp + 8)) + seq1 = **(**uintptr)(__ccgo_up(bp + 8)) } else { - if *(*uintptr)(unsafe.Pointer(bp + 8)) != UintptrFromInt32(0) { - seq1 = _tre_ast_new_catenation(tls, mem, seq1, *(*uintptr)(unsafe.Pointer(bp + 8))) + if **(**uintptr)(__ccgo_up(bp + 8)) != UintptrFromInt32(0) { + seq1 = _tre_ast_new_catenation(tls, mem, seq1, **(**uintptr)(__ccgo_up(bp + 8))) } } if seq1 == UintptrFromInt32(0) { @@ -132027,21 +132027,21 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit (*Ttre_ast_node_t)(unsafe.Pointer(node)).Ftype1 = (*Ttre_ast_node_t)(unsafe.Pointer(seq1)).Ftype1 } iter_depth = iter_depth - 1 - pos_add_total = pos_add_total + (*(*int32)(unsafe.Pointer(bp)) - pos_add_last) + pos_add_total = pos_add_total + (**(**int32)(__ccgo_up(bp)) - pos_add_last) if iter_depth == 0 { - *(*int32)(unsafe.Pointer(bp)) = pos_add_total + **(**int32)(__ccgo_up(bp)) = pos_add_total } default: break } } - *(*int32)(unsafe.Pointer(position)) += pos_add_total + **(**int32)(__ccgo_up(position)) += pos_add_total /* `max_pos' should never be larger than `*position' if the above code works, but just an extra safeguard let's make sure `*position' is set large enough so enough memory will be allocated for the transition table. */ - if *(*int32)(unsafe.Pointer(bp + 4)) > *(*int32)(unsafe.Pointer(position)) { - *(*int32)(unsafe.Pointer(position)) = *(*int32)(unsafe.Pointer(bp + 4)) + if **(**int32)(__ccgo_up(bp + 4)) > **(**int32)(__ccgo_up(position)) { + **(**int32)(__ccgo_up(position)) = **(**int32)(__ccgo_up(bp + 4)) } return status } @@ -132053,9 +132053,9 @@ func _tre_set_empty(tls *TLS, mem Ttre_mem_t) (r uintptr) { if new_set == UintptrFromInt32(0) { return UintptrFromInt32(0) } - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fposition = -int32(1) - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fcode_min = -int32(1) - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fcode_max = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fposition = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fcode_min = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fcode_max = -int32(1) return new_set } @@ -132066,15 +132066,15 @@ func _tre_set_one(tls *TLS, mem Ttre_mem_t, position int32, code_min int32, code if new_set == UintptrFromInt32(0) { return UintptrFromInt32(0) } - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fposition = position - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fcode_min = code_min - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fcode_max = code_max - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fclass = class - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fneg_classes = neg_classes - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fbackref = backref - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + 1*32))).Fposition = -int32(1) - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + 1*32))).Fcode_min = -int32(1) - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + 1*32))).Fcode_max = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fposition = position + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fcode_min = code_min + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fcode_max = code_max + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fclass = class + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fneg_classes = neg_classes + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fbackref = backref + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + 1*32))).Fposition = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + 1*32))).Fcode_min = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + 1*32))).Fcode_max = -int32(1) return new_set } @@ -132084,7 +132084,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u _, _, _, _, _, _, _ = i, j, new_set, new_tags, num_tags, s1, s2 num_tags = 0 for { - if !(tags != UintptrFromInt32(0) && *(*int32)(unsafe.Pointer(tags + uintptr(num_tags)*4)) >= 0) { + if !(tags != UintptrFromInt32(0) && **(**int32)(__ccgo_up(tags + uintptr(num_tags)*4)) >= 0) { break } goto _1 @@ -132094,7 +132094,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u } s1 = 0 for { - if !((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*32))).Fposition >= 0) { + if !((**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*32))).Fposition >= 0) { break } goto _2 @@ -132104,7 +132104,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u } s2 = 0 for { - if !((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*32))).Fposition >= 0) { + if !((**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*32))).Fposition >= 0) { break } goto _3 @@ -132118,22 +132118,22 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u } s1 = 0 for { - if !((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*32))).Fposition >= 0) { + if !((**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*32))).Fposition >= 0) { break } - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*32))).Fposition = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*32))).Fposition - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*32))).Fcode_min = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*32))).Fcode_min - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*32))).Fcode_max = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*32))).Fcode_max - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*32))).Fassertions = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*32))).Fassertions | assertions - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*32))).Fclass = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*32))).Fclass - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*32))).Fneg_classes = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*32))).Fneg_classes - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*32))).Fbackref = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*32))).Fbackref - if (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*32))).Ftags == UintptrFromInt32(0) && tags == UintptrFromInt32(0) { - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*32))).Ftags = UintptrFromInt32(0) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*32))).Fposition = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*32))).Fposition + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*32))).Fcode_min = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*32))).Fcode_min + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*32))).Fcode_max = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*32))).Fcode_max + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*32))).Fassertions = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*32))).Fassertions | assertions + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*32))).Fclass = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*32))).Fclass + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*32))).Fneg_classes = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*32))).Fneg_classes + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*32))).Fbackref = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*32))).Fbackref + if (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*32))).Ftags == UintptrFromInt32(0) && tags == UintptrFromInt32(0) { + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*32))).Ftags = UintptrFromInt32(0) } else { i = 0 for { - if !((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*32))).Ftags != UintptrFromInt32(0) && *(*int32)(unsafe.Pointer((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*32))).Ftags + uintptr(i)*4)) >= 0) { + if !((**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*32))).Ftags != UintptrFromInt32(0) && **(**int32)(__ccgo_up((**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*32))).Ftags + uintptr(i)*4)) >= 0) { break } goto _5 @@ -132150,7 +132150,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u if !(j < i) { break } - *(*int32)(unsafe.Pointer(new_tags + uintptr(j)*4)) = *(*int32)(unsafe.Pointer((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*32))).Ftags + uintptr(j)*4)) + **(**int32)(__ccgo_up(new_tags + uintptr(j)*4)) = **(**int32)(__ccgo_up((**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*32))).Ftags + uintptr(j)*4)) goto _6 _6: ; @@ -132161,14 +132161,14 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u if !(i < num_tags) { break } - *(*int32)(unsafe.Pointer(new_tags + uintptr(j+i)*4)) = *(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) + **(**int32)(__ccgo_up(new_tags + uintptr(j+i)*4)) = **(**int32)(__ccgo_up(tags + uintptr(i)*4)) goto _7 _7: ; i = i + 1 } - *(*int32)(unsafe.Pointer(new_tags + uintptr(j+i)*4)) = -int32(1) - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*32))).Ftags = new_tags + **(**int32)(__ccgo_up(new_tags + uintptr(j+i)*4)) = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*32))).Ftags = new_tags } goto _4 _4: @@ -132177,23 +132177,23 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u } s2 = 0 for { - if !((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*32))).Fposition >= 0) { + if !((**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*32))).Fposition >= 0) { break } - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*32))).Fposition = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*32))).Fposition - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*32))).Fcode_min = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*32))).Fcode_min - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*32))).Fcode_max = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*32))).Fcode_max + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*32))).Fposition = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*32))).Fposition + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*32))).Fcode_min = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*32))).Fcode_min + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*32))).Fcode_max = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*32))).Fcode_max /* XXX - why not | assertions here as well? */ - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*32))).Fassertions = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*32))).Fassertions - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*32))).Fclass = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*32))).Fclass - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*32))).Fneg_classes = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*32))).Fneg_classes - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*32))).Fbackref = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*32))).Fbackref - if (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*32))).Ftags == UintptrFromInt32(0) { - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*32))).Ftags = UintptrFromInt32(0) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*32))).Fassertions = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*32))).Fassertions + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*32))).Fclass = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*32))).Fclass + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*32))).Fneg_classes = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*32))).Fneg_classes + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*32))).Fbackref = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*32))).Fbackref + if (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*32))).Ftags == UintptrFromInt32(0) { + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*32))).Ftags = UintptrFromInt32(0) } else { i = 0 for { - if !(*(*int32)(unsafe.Pointer((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*32))).Ftags + uintptr(i)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*32))).Ftags + uintptr(i)*4)) >= 0) { break } goto _9 @@ -132210,21 +132210,21 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u if !(j < i) { break } - *(*int32)(unsafe.Pointer(new_tags + uintptr(j)*4)) = *(*int32)(unsafe.Pointer((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*32))).Ftags + uintptr(j)*4)) + **(**int32)(__ccgo_up(new_tags + uintptr(j)*4)) = **(**int32)(__ccgo_up((**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*32))).Ftags + uintptr(j)*4)) goto _10 _10: ; j = j + 1 } - *(*int32)(unsafe.Pointer(new_tags + uintptr(j)*4)) = -int32(1) - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*32))).Ftags = new_tags + **(**int32)(__ccgo_up(new_tags + uintptr(j)*4)) = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*32))).Ftags = new_tags } goto _8 _8: ; s2 = s2 + 1 } - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*32))).Fposition = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*32))).Fposition = -int32(1) return new_set } @@ -132242,7 +132242,7 @@ func _tre_match_empty(tls *TLS, stack uintptr, node uintptr, tags uintptr, asser bottom = _tre_stack_num_objects(tls, stack) status = REG_OK if num_tags_seen != 0 { - *(*int32)(unsafe.Pointer(num_tags_seen)) = 0 + **(**int32)(__ccgo_up(num_tags_seen)) = 0 } status = _tre_stack_push_voidptr(tls, stack, node) /* Walk through the tree recursively. */ @@ -132258,10 +132258,10 @@ func _tre_match_empty(tls *TLS, stack uintptr, node uintptr, tags uintptr, asser /* Add the tag to `tags'. */ i = 0 for { - if !(*(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(tags + uintptr(i)*4)) >= 0) { break } - if *(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) == (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max { + if int32(**(**int32)(__ccgo_up(tags + uintptr(i)*4))) == (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max { break } goto _1 @@ -132269,13 +132269,13 @@ func _tre_match_empty(tls *TLS, stack uintptr, node uintptr, tags uintptr, asser ; i = i + 1 } - if *(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) < 0 { - *(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) = (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max - *(*int32)(unsafe.Pointer(tags + uintptr(i+int32(1))*4)) = -int32(1) + if **(**int32)(__ccgo_up(tags + uintptr(i)*4)) < 0 { + **(**int32)(__ccgo_up(tags + uintptr(i)*4)) = (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max + **(**int32)(__ccgo_up(tags + uintptr(i+int32(1))*4)) = -int32(1) } } if num_tags_seen != 0 { - *(*int32)(unsafe.Pointer(num_tags_seen)) = *(*int32)(unsafe.Pointer(num_tags_seen)) + 1 + **(**int32)(__ccgo_up(num_tags_seen)) = **(**int32)(__ccgo_up(num_tags_seen)) + 1 } } case -int32(2): @@ -132519,12 +132519,12 @@ func _tre_compute_nfl(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr) (r return status } /* Allocate arrays for the tags and parameters. */ - tags = Xmalloc(tls, uint32(4)*Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))+Int32FromInt32(1))) + tags = Xmalloc(tls, uint32(4)*Uint32FromInt32(**(**int32)(__ccgo_up(bp))+Int32FromInt32(1))) if !(tags != 0) { return int32(REG_ESPACE) } - *(*int32)(unsafe.Pointer(tags)) = -int32(1) - *(*int32)(unsafe.Pointer(bp + 4)) = 0 + **(**int32)(__ccgo_up(tags)) = -int32(1) + **(**int32)(__ccgo_up(bp + 4)) = 0 /* Second pass with tre_mach_empty() to get the list of tags and parameters. */ status = _tre_match_empty(tls, stack, (*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft, tags, bp+4, UintptrFromInt32(0)) @@ -132532,7 +132532,7 @@ func _tre_compute_nfl(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr) (r Xfree(tls, tags) return status } - (*Ttre_ast_node_t)(unsafe.Pointer(node)).Ffirstpos = _tre_set_union(tls, mem, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright)).Ffirstpos, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft)).Ffirstpos, tags, *(*int32)(unsafe.Pointer(bp + 4))) + (*Ttre_ast_node_t)(unsafe.Pointer(node)).Ffirstpos = _tre_set_union(tls, mem, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright)).Ffirstpos, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft)).Ffirstpos, tags, **(**int32)(__ccgo_up(bp + 4))) Xfree(tls, tags) if !((*Ttre_ast_node_t)(unsafe.Pointer(node)).Ffirstpos != 0) { return int32(REG_ESPACE) @@ -132550,12 +132550,12 @@ func _tre_compute_nfl(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr) (r return status } /* Allocate arrays for the tags and parameters. */ - tags = Xmalloc(tls, uint32(4)*Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))+Int32FromInt32(1))) + tags = Xmalloc(tls, uint32(4)*Uint32FromInt32(**(**int32)(__ccgo_up(bp))+Int32FromInt32(1))) if !(tags != 0) { return int32(REG_ESPACE) } - *(*int32)(unsafe.Pointer(tags)) = -int32(1) - *(*int32)(unsafe.Pointer(bp + 4)) = 0 + **(**int32)(__ccgo_up(tags)) = -int32(1) + **(**int32)(__ccgo_up(bp + 4)) = 0 /* Second pass with tre_mach_empty() to get the list of tags and parameters. */ status = _tre_match_empty(tls, stack, (*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright, tags, bp+4, UintptrFromInt32(0)) @@ -132563,7 +132563,7 @@ func _tre_compute_nfl(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr) (r Xfree(tls, tags) return status } - (*Ttre_ast_node_t)(unsafe.Pointer(node)).Flastpos = _tre_set_union(tls, mem, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft)).Flastpos, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright)).Flastpos, tags, *(*int32)(unsafe.Pointer(bp + 4))) + (*Ttre_ast_node_t)(unsafe.Pointer(node)).Flastpos = _tre_set_union(tls, mem, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft)).Flastpos, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright)).Flastpos, tags, **(**int32)(__ccgo_up(bp + 4))) Xfree(tls, tags) if !((*Ttre_ast_node_t)(unsafe.Pointer(node)).Flastpos != 0) { return int32(REG_ESPACE) @@ -132599,7 +132599,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun prev_p2_pos = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fposition /* Set `trans' to point to the next unused transition from position `p1->position'. */ - trans = transitions + uintptr(*(*int32)(unsafe.Pointer(offs + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)))*32 + trans = transitions + uintptr(**(**int32)(__ccgo_up(offs + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)))*32 for (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fstate != UintptrFromInt32(0) { trans += 32 } @@ -132610,7 +132610,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun the transition from `p1' to `p2'. */ (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fcode_min = Uint32FromInt32((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fcode_min) (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fcode_max = Uint32FromInt32((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fcode_max) - (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fstate = transitions + uintptr(*(*int32)(unsafe.Pointer(offs + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fposition)*4)))*32 + (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fstate = transitions + uintptr(**(**int32)(__ccgo_up(offs + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fposition)*4)))*32 (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fstate_id = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fposition if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fclass != 0 { v1 = int32(ASSERT_CHAR_CLASS) @@ -132625,14 +132625,14 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fassertions = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fassertions | (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fassertions | v1 | v2 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fbackref >= 0 { *(*int32)(unsafe.Pointer(trans + 24)) = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fbackref - *(*int32)(unsafe.Pointer(trans + 20)) |= int32(ASSERT_BACKREF) + **(**int32)(__ccgo_up(trans + 20)) |= int32(ASSERT_BACKREF) } else { *(*Ttre_ctype_t)(unsafe.Pointer(trans + 24)) = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fclass } if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes != UintptrFromInt32(0) { i = 0 for { - if !(*(*Ttre_ctype_t)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes + uintptr(i)*4)) != Uint32FromInt32(0)) { + if !(**(**Ttre_ctype_t)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes + uintptr(i)*4)) != Uint32FromInt32(0)) { break } goto _3 @@ -132646,29 +132646,29 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun } i = 0 for { - if !(*(*Ttre_ctype_t)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes + uintptr(i)*4)) != Uint32FromInt32(0)) { + if !(**(**Ttre_ctype_t)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes + uintptr(i)*4)) != Uint32FromInt32(0)) { break } - *(*Ttre_ctype_t)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes + uintptr(i)*4)) = *(*Ttre_ctype_t)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes + uintptr(i)*4)) + **(**Ttre_ctype_t)(__ccgo_up((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes + uintptr(i)*4)) = **(**Ttre_ctype_t)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes + uintptr(i)*4)) goto _4 _4: ; i = i + 1 } - *(*Ttre_ctype_t)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes + uintptr(i)*4)) = Uint32FromInt32(0) + **(**Ttre_ctype_t)(__ccgo_up((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes + uintptr(i)*4)) = Uint32FromInt32(0) } else { (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes = UintptrFromInt32(0) } /* Find out how many tags this transition has. */ i = 0 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags != UintptrFromInt32(0) { - for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) >= 0 { + for **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) >= 0 { i = i + 1 } } j = 0 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags != UintptrFromInt32(0) { - for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) >= 0 { + for **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) >= 0 { j = j + 1 } } @@ -132685,15 +132685,15 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun } i = 0 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags != UintptrFromInt32(0) { - for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) >= 0 { - *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(i)*4)) = *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) + for **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) >= 0 { + **(**int32)(__ccgo_up((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(i)*4)) = **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) i = i + 1 } } l = i j = 0 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags != UintptrFromInt32(0) { - for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) >= 0 { + for **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) >= 0 { /* Don't add duplicates. */ dup = 0 k = 0 @@ -132701,7 +132701,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun if !(k < i) { break } - if *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(k)*4)) == *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) { + if **(**int32)(__ccgo_up((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(k)*4)) == **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) { dup = int32(1) break } @@ -132713,12 +132713,12 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun if !(dup != 0) { v1 = l l = l + 1 - *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(v1)*4)) = *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) + **(**int32)(__ccgo_up((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(v1)*4)) = **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) } j = j + 1 } } - *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(l)*4)) = -int32(1) + **(**int32)(__ccgo_up((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(l)*4)) = -int32(1) } p2 += 32 } @@ -132730,7 +132730,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun for (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition >= 0 { p2 = orig_p2 for (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fposition >= 0 { - *(*int32)(unsafe.Pointer(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)) = *(*int32)(unsafe.Pointer(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)) + 1 + **(**int32)(__ccgo_up(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)) = **(**int32)(__ccgo_up(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)) + 1 p2 += 32 } p1 += 32 @@ -132821,11 +132821,11 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { } /* Parse the regexp. */ Xmemset(tls, bp, 0, uint32(36)) - (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fmem = mem - (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fstack = stack - (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fstart = regex - (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fcflags = cflags - (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fmax_backref = -int32(1) + (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fmem = mem + (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fstack = stack + (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fstart = regex + (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fcflags = cflags + (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fmax_backref = -int32(1) errcode = _tre_parse(tls, bp) if errcode != REG_OK { errcode = errcode @@ -132833,10 +132833,10 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { goto error_exit } } - (*Tregex_t)(unsafe.Pointer(preg)).Fre_nsub = Uint32FromInt32((*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fsubmatch_id - int32(1)) - tree = (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fn + (*Tregex_t)(unsafe.Pointer(preg)).Fre_nsub = Uint32FromInt32((**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fsubmatch_id - int32(1)) + tree = (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fn /* Referring to nonexistent subexpressions is illegal. */ - if (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fmax_backref > Int32FromUint32((*Tregex_t)(unsafe.Pointer(preg)).Fre_nsub) { + if (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fmax_backref > Int32FromUint32((*Tregex_t)(unsafe.Pointer(preg)).Fre_nsub) { errcode = int32(REG_ESUBREG) if int32(1) != 0 { goto error_exit @@ -132850,9 +132850,9 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { goto error_exit } } - (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fhave_backrefs = BoolInt32((*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fmax_backref >= 0) + (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fhave_backrefs = BoolInt32((**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fmax_backref >= 0) (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fhave_approx = 0 - (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches = Uint32FromInt32((*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fsubmatch_id) + (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches = Uint32FromInt32((**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fsubmatch_id) /* Set up tags for submatch addressing. If REG_NOSUB is set and the regexp does not have back references, this can be skipped. */ if (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fhave_backrefs != 0 || !(cflags&Int32FromInt32(REG_NOSUB) != 0) { @@ -132882,7 +132882,7 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { goto error_exit } } - submatch_data = Xcalloc(tls, Uint32FromInt32((*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fsubmatch_id), uint32(12)) + submatch_data = Xcalloc(tls, Uint32FromInt32((**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fsubmatch_id), uint32(12)) if submatch_data == UintptrFromInt32(0) { errcode = int32(REG_ESPACE) if int32(1) != 0 { @@ -132935,14 +132935,14 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { goto error_exit } } - counts = Xmalloc(tls, uint32(4)*Uint32FromInt32((*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fposition)) + counts = Xmalloc(tls, uint32(4)*Uint32FromInt32((**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fposition)) if counts == UintptrFromInt32(0) { errcode = int32(REG_ESPACE) if int32(1) != 0 { goto error_exit } } - offs = Xmalloc(tls, uint32(4)*Uint32FromInt32((*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fposition)) + offs = Xmalloc(tls, uint32(4)*Uint32FromInt32((**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fposition)) if offs == UintptrFromInt32(0) { errcode = int32(REG_ESPACE) if int32(1) != 0 { @@ -132951,10 +132951,10 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { } i = 0 for { - if !(i < (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fposition) { + if !(i < (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fposition) { break } - *(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) = 0 + **(**int32)(__ccgo_up(counts + uintptr(i)*4)) = 0 goto _3 _3: ; @@ -132964,12 +132964,12 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { add = 0 i = 0 for { - if !(i < (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fposition) { + if !(i < (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fposition) { break } - *(*int32)(unsafe.Pointer(offs + uintptr(i)*4)) = add - add = add + (*(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) + int32(1)) - *(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) = 0 + **(**int32)(__ccgo_up(offs + uintptr(i)*4)) = add + add = add + (**(**int32)(__ccgo_up(counts + uintptr(i)*4)) + int32(1)) + **(**int32)(__ccgo_up(counts + uintptr(i)*4)) = 0 goto _4 _4: ; @@ -133012,15 +133012,15 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { if !((*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fposition >= 0) { break } - (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*32))).Fstate = transitions + uintptr(*(*int32)(unsafe.Pointer(offs + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fposition)*4)))*32 - (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*32))).Fstate_id = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fposition - (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*32))).Ftags = UintptrFromInt32(0) + (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*32))).Fstate = transitions + uintptr(**(**int32)(__ccgo_up(offs + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fposition)*4)))*32 + (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*32))).Fstate_id = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fposition + (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*32))).Ftags = UintptrFromInt32(0) /* Copy the arrays p->tags, and p->params, they are allocated from a tre_mem object. */ if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Ftags != 0 { j = 0 for { - if !(*(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Ftags + uintptr(j)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Ftags + uintptr(j)*4)) >= 0) { break } goto _6 @@ -133028,26 +133028,26 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { ; j = j + 1 } - (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*32))).Ftags = Xmalloc(tls, uint32(4)*Uint32FromInt32(j+Int32FromInt32(1))) - if !((*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*32))).Ftags != 0) { + (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*32))).Ftags = Xmalloc(tls, uint32(4)*Uint32FromInt32(j+Int32FromInt32(1))) + if !((**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*32))).Ftags != 0) { errcode = int32(REG_ESPACE) if int32(1) != 0 { goto error_exit } } - Xmemcpy(tls, (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*32))).Ftags, (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Ftags, uint32(4)*Uint32FromInt32(j+Int32FromInt32(1))) + Xmemcpy(tls, (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*32))).Ftags, (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Ftags, uint32(4)*Uint32FromInt32(j+Int32FromInt32(1))) } - (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*32))).Fassertions = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fassertions + (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*32))).Fassertions = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fassertions i = i + 1 goto _5 _5: ; p += 32 } - (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*32))).Fstate = UintptrFromInt32(0) + (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*32))).Fstate = UintptrFromInt32(0) (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_transitions = Uint32FromInt32(add) - (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ffinal = transitions + uintptr(*(*int32)(unsafe.Pointer(offs + uintptr((*(*Ttre_pos_and_tags_t)(unsafe.Pointer((*Ttre_ast_node_t)(unsafe.Pointer(tree)).Flastpos))).Fposition)*4)))*32 - (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_states = (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fposition + (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ffinal = transitions + uintptr(**(**int32)(__ccgo_up(offs + uintptr((**(**Ttre_pos_and_tags_t)(__ccgo_up((*Ttre_ast_node_t)(unsafe.Pointer(tree)).Flastpos))).Fposition)*4)))*32 + (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_states = (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fposition (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags = cflags X__tre_mem_destroy(tls, mem) _tre_stack_destroy(tls, stack) @@ -133090,12 +133090,12 @@ func Xregfree(tls *TLS, preg uintptr) { if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_transitions) { break } - if (*(*Ttre_tnfa_transition_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*32))).Fstate != 0 { - if (*(*Ttre_tnfa_transition_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*32))).Ftags != 0 { - Xfree(tls, (*(*Ttre_tnfa_transition_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*32))).Ftags) + if (**(**Ttre_tnfa_transition_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*32))).Fstate != 0 { + if (**(**Ttre_tnfa_transition_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*32))).Ftags != 0 { + Xfree(tls, (**(**Ttre_tnfa_transition_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*32))).Ftags) } - if (*(*Ttre_tnfa_transition_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*32))).Fneg_classes != 0 { - Xfree(tls, (*(*Ttre_tnfa_transition_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*32))).Fneg_classes) + if (**(**Ttre_tnfa_transition_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*32))).Fneg_classes != 0 { + Xfree(tls, (**(**Ttre_tnfa_transition_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*32))).Fneg_classes) } } goto _1 @@ -133128,8 +133128,8 @@ func Xregfree(tls *TLS, preg uintptr) { if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches) { break } - if (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(i)*12))).Fparents != 0 { - Xfree(tls, (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(i)*12))).Fparents) + if (**(**Ttre_submatch_data_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(i)*12))).Fparents != 0 { + Xfree(tls, (**(**Ttre_submatch_data_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(i)*12))).Fparents) } goto _3 _3: @@ -133169,7 +133169,7 @@ func Xregerror(tls *TLS, e int32, preg uintptr, buf uintptr, size Tsize_t) (r Ts _ = s s = uintptr(unsafe.Pointer(&_messages)) for { - if !(e != 0 && *(*int8)(unsafe.Pointer(s)) != 0) { + if !(e != 0 && **(**int8)(__ccgo_up(s)) != 0) { break } goto _1 @@ -133178,7 +133178,7 @@ func Xregerror(tls *TLS, e int32, preg uintptr, buf uintptr, size Tsize_t) (r Ts e = e - 1 s = s + uintptr(_strlen(tls, s)+uint32(1)) } - if !(*(*int8)(unsafe.Pointer(s)) != 0) { + if !(**(**int8)(__ccgo_up(s)) != 0) { s = s + 1 } s = X__lctrans_cur(tls, s) @@ -133204,18 +133204,18 @@ func _tre_tag_order(tls *TLS, num_tags int32, tag_directions uintptr, t1 uintptr if !(i < num_tags) { break } - if *(*Ttre_tag_direction_t)(unsafe.Pointer(tag_directions + uintptr(i)*4)) == int32(_TRE_TAG_MINIMIZE) { - if *(*Tregoff_t)(unsafe.Pointer(t1 + uintptr(i)*4)) < *(*Tregoff_t)(unsafe.Pointer(t2 + uintptr(i)*4)) { + if **(**Ttre_tag_direction_t)(__ccgo_up(tag_directions + uintptr(i)*4)) == int32(_TRE_TAG_MINIMIZE) { + if **(**Tregoff_t)(__ccgo_up(t1 + uintptr(i)*4)) < **(**Tregoff_t)(__ccgo_up(t2 + uintptr(i)*4)) { return int32(1) } - if *(*Tregoff_t)(unsafe.Pointer(t1 + uintptr(i)*4)) > *(*Tregoff_t)(unsafe.Pointer(t2 + uintptr(i)*4)) { + if **(**Tregoff_t)(__ccgo_up(t1 + uintptr(i)*4)) > **(**Tregoff_t)(__ccgo_up(t2 + uintptr(i)*4)) { return 0 } } else { - if *(*Tregoff_t)(unsafe.Pointer(t1 + uintptr(i)*4)) > *(*Tregoff_t)(unsafe.Pointer(t2 + uintptr(i)*4)) { + if **(**Tregoff_t)(__ccgo_up(t1 + uintptr(i)*4)) > **(**Tregoff_t)(__ccgo_up(t2 + uintptr(i)*4)) { return int32(1) } - if *(*Tregoff_t)(unsafe.Pointer(t1 + uintptr(i)*4)) < *(*Tregoff_t)(unsafe.Pointer(t2 + uintptr(i)*4)) { + if **(**Tregoff_t)(__ccgo_up(t1 + uintptr(i)*4)) < **(**Tregoff_t)(__ccgo_up(t2 + uintptr(i)*4)) { return 0 } } @@ -133229,8 +133229,8 @@ func _tre_tag_order(tls *TLS, num_tags int32, tag_directions uintptr, t1 uintptr } func _tre_neg_char_classes_match(tls *TLS, classes uintptr, wc Ttre_cint_t, icase int32) (r int32) { - for *(*Ttre_ctype_t)(unsafe.Pointer(classes)) != Uint32FromInt32(0) { - if !(icase != 0) && Xiswctype(tls, wc, *(*Ttre_ctype_t)(unsafe.Pointer(classes))) != 0 || icase != 0 && (Xiswctype(tls, Xtowupper(tls, wc), *(*Ttre_ctype_t)(unsafe.Pointer(classes))) != 0 || Xiswctype(tls, Xtowlower(tls, wc), *(*Ttre_ctype_t)(unsafe.Pointer(classes))) != 0) { + for **(**Ttre_ctype_t)(__ccgo_up(classes)) != Uint32FromInt32(0) { + if !(icase != 0) && Xiswctype(tls, wc, **(**Ttre_ctype_t)(__ccgo_up(classes))) != 0 || icase != 0 && (Xiswctype(tls, Xtowupper(tls, wc), **(**Ttre_ctype_t)(__ccgo_up(classes))) != 0 || Xiswctype(tls, Xtowlower(tls, wc), **(**Ttre_ctype_t)(__ccgo_up(classes))) != 0) { return int32(1) } else { classes += 4 @@ -133283,7 +133283,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = buf, end, i, match_eo, new_match, num_tags, pbytes, pos, pos_add_next, prev_c, rbytes, reach, reach_i, reach_next, reach_next_i, reach_pos, reg_newline, reg_notbol, reg_noteol, ret, skip, start, str_byte, tag_i, tbytes, tmp_buf, tmp_iptr, tmp_tags, total_bytes, trans_i, xbytes, v1, v18, v7 /* State variables required by GET_NEXT_WCHAR. */ prev_c = 0 - *(*Ttre_char_t)(unsafe.Pointer(bp)) = 0 + **(**Ttre_char_t)(__ccgo_up(bp)) = 0 str_byte = string1 pos = -int32(1) pos_add_next = int32(1) @@ -133363,9 +133363,9 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_states) { break } - (*(*Ttre_tnfa_reach_t)(unsafe.Pointer(reach + uintptr(i)*8))).Ftags = tmp_buf + (**(**Ttre_tnfa_reach_t)(__ccgo_up(reach + uintptr(i)*8))).Ftags = tmp_buf tmp_buf = tmp_buf + uintptr(xbytes) - (*(*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next + uintptr(i)*8))).Ftags = tmp_buf + (**(**Ttre_tnfa_reach_t)(__ccgo_up(reach_next + uintptr(i)*8))).Ftags = tmp_buf tmp_buf = tmp_buf + uintptr(xbytes) goto _5 _5: @@ -133377,13 +133377,13 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_states) { break } - (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr(i)*8))).Fpos = -int32(1) + (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr(i)*8))).Fpos = -int32(1) goto _6 _6: ; i = i + 1 } - prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + prev_c = **(**Ttre_char_t)(__ccgo_up(bp)) pos = pos + pos_add_next v7 = Xmbtowc(tls, bp, str_byte, uint32(MB_LEN_MAX)) pos_add_next = v7 @@ -133403,8 +133403,8 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if match_eo < 0 { trans_i = (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Finitial for (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate != UintptrFromInt32(0) { - if (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*8))).Fpos < pos { - if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\000') || reg_noteol != 0) && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0 || !(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) || (*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && *(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\000') && BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) == BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || *(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('\000') || BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) != BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0))) { + if (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*8))).Fpos < pos { + if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (**(**Ttre_char_t)(__ccgo_up(bp)) != int32('\000') || reg_noteol != 0) && (**(**Ttre_char_t)(__ccgo_up(bp)) != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0 || !(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) || (**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && **(**Ttre_char_t)(__ccgo_up(bp)) != int32('\000') && BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) == BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || **(**Ttre_char_t)(__ccgo_up(bp)) == int32('\000') || BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) != BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0))) { trans_i += 32 continue } @@ -133414,7 +133414,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < num_tags) { break } - *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(i)*4)) = -int32(1) + **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(i)*4)) = -int32(1) goto _8 _8: ; @@ -133422,9 +133422,9 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags } tag_i = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags if tag_i != 0 { - for *(*int32)(unsafe.Pointer(tag_i)) >= 0 { - if *(*int32)(unsafe.Pointer(tag_i)) < num_tags { - *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(*(*int32)(unsafe.Pointer(tag_i)))*4)) = pos + for **(**int32)(__ccgo_up(tag_i)) >= 0 { + if **(**int32)(__ccgo_up(tag_i)) < num_tags { + **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(**(**int32)(__ccgo_up(tag_i)))*4)) = pos } tag_i += 4 } @@ -133437,15 +133437,15 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < num_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(i)*4)) = *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(i)*4)) + **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(i)*4)) = **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(i)*4)) goto _9 _9: ; i = i + 1 } } - (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*8))).Fpos = pos - (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*8))).Ftags = reach_next_i + 4 + (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*8))).Fpos = pos + (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*8))).Ftags = reach_next_i + 4 reach_next_i += 8 } trans_i += 32 @@ -133458,10 +133458,10 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags } } /* Check for end of string. */ - if !(*(*Ttre_char_t)(unsafe.Pointer(bp)) != 0) { + if !(**(**Ttre_char_t)(__ccgo_up(bp)) != 0) { break } - prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + prev_c = **(**Ttre_char_t)(__ccgo_up(bp)) pos = pos + pos_add_next v7 = Xmbtowc(tls, bp, str_byte, uint32(MB_LEN_MAX)) pos_add_next = v7 @@ -133491,16 +133491,16 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags skip = 0 i = 0 for { - if !(*(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i)*4)) >= 0) { break } - end = *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i)*4)) - start = *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i+int32(1))*4)) + end = **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i)*4)) + start = **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i+int32(1))*4)) if end >= num_tags { skip = int32(1) break } else { - if *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Ftags + uintptr(start)*4)) == *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(start)*4)) && *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Ftags + uintptr(end)*4)) < *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(end)*4)) { + if **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Ftags + uintptr(start)*4)) == **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(start)*4)) && **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Ftags + uintptr(end)*4)) < **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(end)*4)) { skip = int32(1) break } @@ -133544,7 +133544,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags } /* Does this transition match the input symbol? */ if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fcode_min <= Uint32FromInt32(prev_c) && (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fcode_max >= Uint32FromInt32(prev_c) { - if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\000') || reg_noteol != 0) && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0 || !(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) || (*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && *(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\000') && BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) == BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || *(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('\000') || BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) != BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && !((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&Int32FromInt32(REG_ICASE) != 0) && !(Xiswctype(tls, Uint32FromInt32(prev_c), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 24))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE) != 0 && !(Xiswctype(tls, Xtowlower(tls, Uint32FromInt32(prev_c)), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 24))) != 0) && !(Xiswctype(tls, Xtowupper(tls, Uint32FromInt32(prev_c)), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 24))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS_NEG) != 0 && _tre_neg_char_classes_match(tls, (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fneg_classes, Uint32FromInt32(prev_c), (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE)) != 0)) { + if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (**(**Ttre_char_t)(__ccgo_up(bp)) != int32('\000') || reg_noteol != 0) && (**(**Ttre_char_t)(__ccgo_up(bp)) != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0 || !(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) || (**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && **(**Ttre_char_t)(__ccgo_up(bp)) != int32('\000') && BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) == BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || **(**Ttre_char_t)(__ccgo_up(bp)) == int32('\000') || BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) != BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && !((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&Int32FromInt32(REG_ICASE) != 0) && !(Xiswctype(tls, Uint32FromInt32(prev_c), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 24))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE) != 0 && !(Xiswctype(tls, Xtowlower(tls, Uint32FromInt32(prev_c)), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 24))) != 0) && !(Xiswctype(tls, Xtowupper(tls, Uint32FromInt32(prev_c)), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 24))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS_NEG) != 0 && _tre_neg_char_classes_match(tls, (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fneg_classes, Uint32FromInt32(prev_c), (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE)) != 0)) { goto _14 } /* Compute the tags after this transition. */ @@ -133553,7 +133553,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < num_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(tmp_tags + uintptr(i)*4)) = *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Ftags + uintptr(i)*4)) + **(**Tregoff_t)(__ccgo_up(tmp_tags + uintptr(i)*4)) = **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Ftags + uintptr(i)*4)) goto _15 _15: ; @@ -133561,22 +133561,22 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags } tag_i = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags if tag_i != UintptrFromInt32(0) { - for *(*int32)(unsafe.Pointer(tag_i)) >= 0 { - if *(*int32)(unsafe.Pointer(tag_i)) < num_tags { - *(*Tregoff_t)(unsafe.Pointer(tmp_tags + uintptr(*(*int32)(unsafe.Pointer(tag_i)))*4)) = pos + for **(**int32)(__ccgo_up(tag_i)) >= 0 { + if **(**int32)(__ccgo_up(tag_i)) < num_tags { + **(**Tregoff_t)(__ccgo_up(tmp_tags + uintptr(**(**int32)(__ccgo_up(tag_i)))*4)) = pos } tag_i += 4 } } - if (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*8))).Fpos < pos { + if (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*8))).Fpos < pos { /* Found an unvisited node. */ (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Fstate = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate tmp_iptr = (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags = tmp_tags tmp_tags = tmp_iptr - (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*8))).Fpos = pos - (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*8))).Ftags = reach_next_i + 4 - if (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Fstate == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ffinal && (match_eo == -int32(1) || num_tags > 0 && *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags)) <= *(*Tregoff_t)(unsafe.Pointer(match_tags))) { + (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*8))).Fpos = pos + (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*8))).Ftags = reach_next_i + 4 + if (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Fstate == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ffinal && (match_eo == -int32(1) || num_tags > 0 && **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags)) <= **(**Tregoff_t)(__ccgo_up(match_tags))) { match_eo = pos new_match = int32(1) i = 0 @@ -133584,7 +133584,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < num_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(i)*4)) = *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(i)*4)) + **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(i)*4)) = **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(i)*4)) goto _16 _16: ; @@ -133596,10 +133596,10 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags /* Another path has also reached this state. We choose the winner by examining the tag values for both paths. */ - if _tre_tag_order(tls, num_tags, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions, tmp_tags, *(*uintptr)(unsafe.Pointer((*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*8))).Ftags))) != 0 { + if _tre_tag_order(tls, num_tags, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions, tmp_tags, **(**uintptr)(__ccgo_up((**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*8))).Ftags))) != 0 { /* The new path wins. */ - tmp_iptr = *(*uintptr)(unsafe.Pointer((*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*8))).Ftags)) - *(*uintptr)(unsafe.Pointer((*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*8))).Ftags)) = tmp_tags + tmp_iptr = **(**uintptr)(__ccgo_up((**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*8))).Ftags)) + **(**uintptr)(__ccgo_up((**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*8))).Ftags)) = tmp_tags if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ffinal { match_eo = pos new_match = int32(1) @@ -133608,7 +133608,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < num_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(i)*4)) = *(*Tregoff_t)(unsafe.Pointer(tmp_tags + uintptr(i)*4)) + **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(i)*4)) = **(**Tregoff_t)(__ccgo_up(tmp_tags + uintptr(i)*4)) goto _17 _17: ; @@ -133631,7 +133631,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags } (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Fstate = UintptrFromInt32(0) } - *(*Tregoff_t)(unsafe.Pointer(match_end_ofs)) = match_eo + **(**Tregoff_t)(__ccgo_up(match_end_ofs)) = match_eo if match_eo >= 0 { v18 = REG_OK } else { @@ -133702,7 +133702,7 @@ func _tre_tnfa_run_backtrack(tls *TLS, tnfa uintptr, string1 uintptr, match_tags _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bt, bt_len, empty_br_match, eo, i, i1, i2, i3, i4, match_eo, mem, next_c_start, next_state, next_tags, pmatch, pos, pos_add_next, pos_start, prev_c, reg_newline, reg_notbol, reg_noteol, result, ret, s, s1, so, stack, state, states_seen, str_byte, str_byte_start, tags, tmp, tmp1, trans_i, v20, v3, v6 /* State variables required by GET_NEXT_WCHAR. */ prev_c = 0 - *(*Ttre_char_t)(unsafe.Pointer(bp)) = 0 + **(**Ttre_char_t)(__ccgo_up(bp)) = 0 str_byte = string1 pos = 0 pos_add_next = int32(1) @@ -133756,9 +133756,9 @@ retry: if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(i)*4)) = -int32(1) + **(**Tregoff_t)(__ccgo_up(tags + uintptr(i)*4)) = -int32(1) if match_tags != 0 { - *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(i)*4)) = -int32(1) + **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(i)*4)) = -int32(1) } goto _1 _1: @@ -133770,7 +133770,7 @@ retry: if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_states) { break } - *(*int32)(unsafe.Pointer(states_seen + uintptr(i)*4)) = 0 + **(**int32)(__ccgo_up(states_seen + uintptr(i)*4)) = 0 goto _2 _2: ; @@ -133778,7 +133778,7 @@ retry: } state = UintptrFromInt32(0) pos = pos_start - prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + prev_c = **(**Ttre_char_t)(__ccgo_up(bp)) pos = pos + pos_add_next v3 = Xmbtowc(tls, bp, str_byte, uint32(MB_LEN_MAX)) pos_add_next = v3 @@ -133792,7 +133792,7 @@ retry: } str_byte = str_byte + uintptr(pos_add_next) pos_start = pos - next_c_start = *(*Ttre_char_t)(unsafe.Pointer(bp)) + next_c_start = int32(**(**Ttre_char_t)(__ccgo_up(bp))) str_byte_start = str_byte /* Handle initial states. */ next_tags = UintptrFromInt32(0) @@ -133801,7 +133801,7 @@ retry: if !((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate != 0) { break } - if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\000') || reg_noteol != 0) && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0 || !(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) || (*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && *(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\000') && BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) == BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || *(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('\000') || BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) != BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0))) { + if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (**(**Ttre_char_t)(__ccgo_up(bp)) != int32('\000') || reg_noteol != 0) && (**(**Ttre_char_t)(__ccgo_up(bp)) != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0 || !(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) || (**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && **(**Ttre_char_t)(__ccgo_up(bp)) != int32('\000') && BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) == BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || **(**Ttre_char_t)(__ccgo_up(bp)) == int32('\000') || BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) != BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0))) { goto _4 } if state == UintptrFromInt32(0) { @@ -133850,13 +133850,13 @@ retry: (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstr_byte = str_byte (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate_id = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id - (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fnext_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fnext_c = int32(**(**Ttre_char_t)(__ccgo_up(bp))) i1 = 0 for { if !(i1 < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_tags) { break } - *(*Tregoff_t)(unsafe.Pointer((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(i1)*4)) = *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(i1)*4)) + **(**Tregoff_t)(__ccgo_up((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(i1)*4)) = **(**Tregoff_t)(__ccgo_up(tags + uintptr(i1)*4)) goto _5 _5: ; @@ -133864,10 +133864,10 @@ retry: } tmp = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags if tmp != 0 { - for *(*int32)(unsafe.Pointer(tmp)) >= 0 { + for **(**int32)(__ccgo_up(tmp)) >= 0 { v6 = tmp tmp += 4 - *(*Tregoff_t)(unsafe.Pointer((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(*(*int32)(unsafe.Pointer(v6)))*4)) = pos + **(**Tregoff_t)(__ccgo_up((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(**(**int32)(__ccgo_up(v6)))*4)) = pos } } } @@ -133878,10 +133878,10 @@ retry: } if next_tags != 0 { for { - if !(*(*int32)(unsafe.Pointer(next_tags)) >= 0) { + if !(**(**int32)(__ccgo_up(next_tags)) >= 0) { break } - *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(*(*int32)(unsafe.Pointer(next_tags)))*4)) = pos + **(**Tregoff_t)(__ccgo_up(tags + uintptr(**(**int32)(__ccgo_up(next_tags)))*4)) = pos goto _7 _7: ; @@ -133906,7 +133906,7 @@ _9: if !(i2 < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(i2)*4)) = *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(i2)*4)) + **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(i2)*4)) = **(**Tregoff_t)(__ccgo_up(tags + uintptr(i2)*4)) goto _10 _10: ; @@ -133926,8 +133926,8 @@ _9: /* Get the substring we need to match against. Remember to turn off REG_NOSUB temporarily. */ _tre_fill_pmatch(tls, Uint32FromInt32(bt+int32(1)), pmatch, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags & ^Int32FromInt32(REG_NOSUB), tnfa, tags, pos) - so = (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(bt)*8))).Frm_so - eo = (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(bt)*8))).Frm_eo + so = (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(bt)*8))).Frm_so + eo = (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(bt)*8))).Frm_eo bt_len = eo - so result = Xstrncmp(tls, string1+uintptr(so), str_byte-uintptr(1), Uint32FromInt32(bt_len)) if result == 0 { @@ -133935,15 +133935,15 @@ _9: if bt_len == 0 { empty_br_match = int32(1) } - if empty_br_match != 0 && *(*int32)(unsafe.Pointer(states_seen + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*4)) != 0 { + if empty_br_match != 0 && **(**int32)(__ccgo_up(states_seen + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*4)) != 0 { goto backtrack } - *(*int32)(unsafe.Pointer(states_seen + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*4)) = empty_br_match + **(**int32)(__ccgo_up(states_seen + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*4)) = empty_br_match /* Advance in input string and resync `prev_c', `next_c' and pos. */ str_byte = str_byte + uintptr(bt_len-int32(1)) pos = pos + (bt_len - int32(1)) - prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + prev_c = **(**Ttre_char_t)(__ccgo_up(bp)) pos = pos + pos_add_next v3 = Xmbtowc(tls, bp, str_byte, uint32(MB_LEN_MAX)) pos_add_next = v3 @@ -133961,11 +133961,11 @@ _9: } } else { /* Check for end of string. */ - if *(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('\000') { + if **(**Ttre_char_t)(__ccgo_up(bp)) == int32('\000') { goto backtrack } /* Read the next character. */ - prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + prev_c = **(**Ttre_char_t)(__ccgo_up(bp)) pos = pos + pos_add_next v3 = Xmbtowc(tls, bp, str_byte, uint32(MB_LEN_MAX)) pos_add_next = v3 @@ -133986,7 +133986,7 @@ _9: break } if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fcode_min <= Uint32FromInt32(prev_c) && (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fcode_max >= Uint32FromInt32(prev_c) { - if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\000') || reg_noteol != 0) && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0 || !(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) || (*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && *(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\000') && BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) == BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || *(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('\000') || BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) != BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && !((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&Int32FromInt32(REG_ICASE) != 0) && !(Xiswctype(tls, Uint32FromInt32(prev_c), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 24))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE) != 0 && !(Xiswctype(tls, Xtowlower(tls, Uint32FromInt32(prev_c)), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 24))) != 0) && !(Xiswctype(tls, Xtowupper(tls, Uint32FromInt32(prev_c)), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 24))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS_NEG) != 0 && _tre_neg_char_classes_match(tls, (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fneg_classes, Uint32FromInt32(prev_c), (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE)) != 0)) { + if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (**(**Ttre_char_t)(__ccgo_up(bp)) != int32('\000') || reg_noteol != 0) && (**(**Ttre_char_t)(__ccgo_up(bp)) != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0 || !(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) || (**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && **(**Ttre_char_t)(__ccgo_up(bp)) != int32('\000') && BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) == BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || **(**Ttre_char_t)(__ccgo_up(bp)) == int32('\000') || BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) != BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && !((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&Int32FromInt32(REG_ICASE) != 0) && !(Xiswctype(tls, Uint32FromInt32(prev_c), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 24))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE) != 0 && !(Xiswctype(tls, Xtowlower(tls, Uint32FromInt32(prev_c)), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 24))) != 0) && !(Xiswctype(tls, Xtowupper(tls, Uint32FromInt32(prev_c)), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 24))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS_NEG) != 0 && _tre_neg_char_classes_match(tls, (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fneg_classes, Uint32FromInt32(prev_c), (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE)) != 0)) { goto _13 } if next_state == UintptrFromInt32(0) { @@ -134038,13 +134038,13 @@ _9: (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstr_byte = str_byte (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate_id = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id - (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fnext_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fnext_c = int32(**(**Ttre_char_t)(__ccgo_up(bp))) i3 = 0 for { if !(i3 < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_tags) { break } - *(*Tregoff_t)(unsafe.Pointer((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(i3)*4)) = *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(i3)*4)) + **(**Tregoff_t)(__ccgo_up((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(i3)*4)) = **(**Tregoff_t)(__ccgo_up(tags + uintptr(i3)*4)) goto _14 _14: ; @@ -134052,10 +134052,10 @@ _9: } tmp1 = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags for { - if !(tmp1 != 0 && *(*int32)(unsafe.Pointer(tmp1)) >= 0) { + if !(tmp1 != 0 && **(**int32)(__ccgo_up(tmp1)) >= 0) { break } - *(*Tregoff_t)(unsafe.Pointer((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(*(*int32)(unsafe.Pointer(tmp1)))*4)) = pos + **(**Tregoff_t)(__ccgo_up((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(**(**int32)(__ccgo_up(tmp1)))*4)) = pos goto _15 _15: ; @@ -134075,10 +134075,10 @@ _9: state = next_state /* Update the tag values. */ if next_tags != 0 { - for *(*int32)(unsafe.Pointer(next_tags)) >= 0 { + for **(**int32)(__ccgo_up(next_tags)) >= 0 { v6 = next_tags next_tags += 4 - *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(*(*int32)(unsafe.Pointer(v6)))*4)) = pos + **(**Tregoff_t)(__ccgo_up(tags + uintptr(**(**int32)(__ccgo_up(v6)))*4)) = pos } } goto _17 @@ -134090,18 +134090,18 @@ backtrack: /* A matching transition was not found. Try to backtrack. */ if (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fprev != 0 { if (*Ttre_tnfa_transition_t)(unsafe.Pointer((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate)).Fassertions&int32(ASSERT_BACKREF) != 0 { - *(*int32)(unsafe.Pointer(states_seen + uintptr((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate_id)*4)) = 0 + **(**int32)(__ccgo_up(states_seen + uintptr((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate_id)*4)) = 0 } pos = (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fpos str_byte = (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstr_byte state = (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate - *(*Ttre_char_t)(unsafe.Pointer(bp)) = (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fnext_c + **(**Ttre_char_t)(__ccgo_up(bp)) = (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fnext_c i4 = 0 for { if !(i4 < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(i4)*4)) = *(*Tregoff_t)(unsafe.Pointer((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(i4)*4)) + **(**Tregoff_t)(__ccgo_up(tags + uintptr(i4)*4)) = **(**Tregoff_t)(__ccgo_up((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(i4)*4)) goto _19 _19: ; @@ -134112,10 +134112,10 @@ backtrack: if match_eo < 0 { /* Try starting from a later position in the input string. */ /* Check for end of string. */ - if *(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('\000') { + if **(**Ttre_char_t)(__ccgo_up(bp)) == int32('\000') { goto _8 } - *(*Ttre_char_t)(unsafe.Pointer(bp)) = next_c_start + **(**Ttre_char_t)(__ccgo_up(bp)) = next_c_start str_byte = str_byte_start goto retry } else { @@ -134133,7 +134133,7 @@ _8: v20 = int32(REG_NOMATCH) } ret = v20 - *(*Tregoff_t)(unsafe.Pointer(match_end_ofs)) = match_eo + **(**Tregoff_t)(__ccgo_up(match_end_ofs)) = match_eo goto error_exit error_exit: ; @@ -134168,22 +134168,22 @@ func _tre_fill_pmatch(tls *TLS, nmatch Tsize_t, pmatch uintptr, cflags int32, tn /* Construct submatch offsets from the tags. */ submatch_data = (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data for i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches && i < nmatch { - if (*(*Ttre_submatch_data_t)(unsafe.Pointer(submatch_data + uintptr(i)*12))).Fso_tag == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fend_tag { - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_so = match_eo + if (**(**Ttre_submatch_data_t)(__ccgo_up(submatch_data + uintptr(i)*12))).Fso_tag == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fend_tag { + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*8))).Frm_so = match_eo } else { - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_so = *(*Tregoff_t)(unsafe.Pointer(tags + uintptr((*(*Ttre_submatch_data_t)(unsafe.Pointer(submatch_data + uintptr(i)*12))).Fso_tag)*4)) + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*8))).Frm_so = **(**Tregoff_t)(__ccgo_up(tags + uintptr((**(**Ttre_submatch_data_t)(__ccgo_up(submatch_data + uintptr(i)*12))).Fso_tag)*4)) } - if (*(*Ttre_submatch_data_t)(unsafe.Pointer(submatch_data + uintptr(i)*12))).Feo_tag == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fend_tag { - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_eo = match_eo + if (**(**Ttre_submatch_data_t)(__ccgo_up(submatch_data + uintptr(i)*12))).Feo_tag == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fend_tag { + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*8))).Frm_eo = match_eo } else { - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_eo = *(*Tregoff_t)(unsafe.Pointer(tags + uintptr((*(*Ttre_submatch_data_t)(unsafe.Pointer(submatch_data + uintptr(i)*12))).Feo_tag)*4)) + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*8))).Frm_eo = **(**Tregoff_t)(__ccgo_up(tags + uintptr((**(**Ttre_submatch_data_t)(__ccgo_up(submatch_data + uintptr(i)*12))).Feo_tag)*4)) } /* If either of the endpoints were not used, this submatch was not part of the match. */ - if (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_so == -int32(1) || (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_eo == -int32(1) { + if (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*8))).Frm_so == -int32(1) || (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*8))).Frm_eo == -int32(1) { v1 = -Int32FromInt32(1) - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_eo = v1 - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_so = v1 + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*8))).Frm_eo = v1 + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*8))).Frm_so = v1 } i = i + 1 } @@ -134191,19 +134191,19 @@ func _tre_fill_pmatch(tls *TLS, nmatch Tsize_t, pmatch uintptr, cflags int32, tn submatches. */ i = uint32(0) for i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches && i < nmatch { - if (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_eo == -int32(1) { + if (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*8))).Frm_eo == -int32(1) { } - parents = (*(*Ttre_submatch_data_t)(unsafe.Pointer(submatch_data + uintptr(i)*12))).Fparents + parents = (**(**Ttre_submatch_data_t)(__ccgo_up(submatch_data + uintptr(i)*12))).Fparents if parents != UintptrFromInt32(0) { j = uint32(0) for { - if !(*(*int32)(unsafe.Pointer(parents + uintptr(j)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(parents + uintptr(j)*4)) >= 0) { break } - if (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_so < (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(*(*int32)(unsafe.Pointer(parents + uintptr(j)*4)))*8))).Frm_so || (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_eo > (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(*(*int32)(unsafe.Pointer(parents + uintptr(j)*4)))*8))).Frm_eo { + if (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*8))).Frm_so < (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(**(**int32)(__ccgo_up(parents + uintptr(j)*4)))*8))).Frm_so || (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*8))).Frm_eo > (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(**(**int32)(__ccgo_up(parents + uintptr(j)*4)))*8))).Frm_eo { v1 = -Int32FromInt32(1) - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_eo = v1 - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_so = v1 + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*8))).Frm_eo = v1 + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*8))).Frm_so = v1 } goto _2 _2: @@ -134215,8 +134215,8 @@ func _tre_fill_pmatch(tls *TLS, nmatch Tsize_t, pmatch uintptr, cflags int32, tn } } for i < nmatch { - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_so = -int32(1) - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_eo = -int32(1) + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*8))).Frm_so = -int32(1) + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*8))).Frm_eo = -int32(1) i = i + 1 } } @@ -134257,7 +134257,7 @@ func Xregexec(tls *TLS, preg uintptr, string1 uintptr, nmatch Tsize_t, pmatch ui } if status == REG_OK { /* A match was found, so fill the submatch registers. */ - _tre_fill_pmatch(tls, nmatch, pmatch, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags, tnfa, tags, *(*Tregoff_t)(unsafe.Pointer(bp))) + _tre_fill_pmatch(tls, nmatch, pmatch, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags, tnfa, tags, **(**Tregoff_t)(__ccgo_up(bp))) } if tags != 0 { Xfree(tls, tags) @@ -134375,8 +134375,8 @@ func X__tre_mem_alloc_impl(tls *TLS, mem Ttre_mem_t, provided int32, provided_bl size = size + v1 /* Allocate from current block. */ ptr = (*Ttre_mem_struct)(unsafe.Pointer(mem)).Fptr - *(*uintptr)(unsafe.Pointer(mem + 8)) += uintptr(size) - *(*Tsize_t)(unsafe.Pointer(mem + 12)) -= size + **(**uintptr)(__ccgo_up(mem + 8)) += uintptr(size) + **(**Tsize_t)(__ccgo_up(mem + 12)) -= size /* Set to zero if needed. */ if zero != 0 { Xmemset(tls, ptr, 0, size) @@ -134441,10 +134441,10 @@ func _keyhash(tls *TLS, k uintptr) (r Tsize_t) { _, _, _ = h, p, v1 p = k h = uint32(0) - for *(*uint8)(unsafe.Pointer(p)) != 0 { + for **(**uint8)(__ccgo_up(p)) != 0 { v1 = p p = p + 1 - h = uint32(31)*h + uint32(*(*uint8)(unsafe.Pointer(v1))) + h = uint32(31)*h + uint32(**(**uint8)(__ccgo_up(v1))) } return h } @@ -134497,7 +134497,7 @@ func _resize(tls *TLS, nel Tsize_t, htab uintptr) (r int32) { j = j + 1 i = i + v4 } - *(*TENTRY)(unsafe.Pointer(newe)) = *(*TENTRY)(unsafe.Pointer(e)) + **(**TENTRY)(__ccgo_up(newe)) = **(**TENTRY)(__ccgo_up(e)) } goto _2 _2: @@ -134553,7 +134553,7 @@ func Xhsearch(tls *TLS, item TENTRY, action TACTION) (r uintptr) { defer tls.Free(16) var _ /* e at bp+0 */ uintptr ___hsearch_r(tls, item, action, bp, uintptr(unsafe.Pointer(&_htab))) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func ___hcreate_r(tls *TLS, nel Tsize_t, htab uintptr) (r1 int32) { @@ -134586,14 +134586,14 @@ func ___hsearch_r(tls *TLS, item TENTRY, action TACTION, retval uintptr, htab ui hash = _keyhash(tls, item.Fkey) e = _lookup(tls, item.Fkey, hash, htab) if (*TENTRY)(unsafe.Pointer(e)).Fkey != 0 { - *(*uintptr)(unsafe.Pointer(retval)) = e + **(**uintptr)(__ccgo_up(retval)) = e return int32(1) } if action == int32(_FIND) { - *(*uintptr)(unsafe.Pointer(retval)) = uintptr(0) + **(**uintptr)(__ccgo_up(retval)) = uintptr(0) return 0 } - *(*TENTRY)(unsafe.Pointer(e)) = item + **(**TENTRY)(__ccgo_up(e)) = item v2 = (*Thsearch_data)(unsafe.Pointer(htab)).F__tab + 8 *(*Tsize_t)(unsafe.Pointer(v2)) = *(*Tsize_t)(unsafe.Pointer(v2)) + 1 v1 = *(*Tsize_t)(unsafe.Pointer(v2)) @@ -134601,12 +134601,12 @@ func ___hsearch_r(tls *TLS, item TENTRY, action TACTION, retval uintptr, htab ui if !(_resize(tls, uint32(2)*(*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused, htab) != 0) { (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused = (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused - 1 (*TENTRY)(unsafe.Pointer(e)).Fkey = uintptr(0) - *(*uintptr)(unsafe.Pointer(retval)) = uintptr(0) + **(**uintptr)(__ccgo_up(retval)) = uintptr(0) return 0 } e = _lookup(tls, item.Fkey, hash, htab) } - *(*uintptr)(unsafe.Pointer(retval)) = e + **(**uintptr)(__ccgo_up(retval)) = e return int32(1) } @@ -134666,7 +134666,7 @@ func Xlsearch(tls *TLS, key uintptr, base uintptr, nelp uintptr, width Tsize_t, defer func() {}() v1 = width p = base - n = *(*Tsize_t)(unsafe.Pointer(nelp)) + n = **(**Tsize_t)(__ccgo_up(nelp)) i = uint32(0) for { if !(i < n) { @@ -134680,7 +134680,7 @@ func Xlsearch(tls *TLS, key uintptr, base uintptr, nelp uintptr, width Tsize_t, ; i = i + 1 } - *(*Tsize_t)(unsafe.Pointer(nelp)) = n + uint32(1) + **(**Tsize_t)(__ccgo_up(nelp)) = n + uint32(1) return Xmemcpy(tls, p+uintptr(n)*uintptr(v1), key, width) } @@ -134698,7 +134698,7 @@ func Xlfind(tls *TLS, key uintptr, base uintptr, nelp uintptr, width Tsize_t, __ defer func() {}() v1 = width p = base - n = *(*Tsize_t)(unsafe.Pointer(nelp)) + n = **(**Tsize_t)(__ccgo_up(nelp)) i = uint32(0) for { if !(i < n) { @@ -134737,7 +134737,7 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui if !(rootp != 0) { return uintptr(0) } - n = *(*uintptr)(unsafe.Pointer(rootp)) + n = **(**uintptr)(__ccgo_up(rootp)) i = 0 /* *a[0] is an arbitrary non-null pointer that is returned when the root node is deleted. */ @@ -134758,34 +134758,34 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui v1 = i i = i + 1 a[v1] = n + 4 + BoolUintptr(c > 0)*4 - n = *(*uintptr)(unsafe.Pointer(n + 4 + BoolUintptr(c > 0)*4)) + n = **(**uintptr)(__ccgo_up(n + 4 + BoolUintptr(c > 0)*4)) goto _3 _3: } - parent = *(*uintptr)(unsafe.Pointer(a[i-int32(2)])) - if *(*uintptr)(unsafe.Pointer(n + 4)) != 0 { + parent = **(**uintptr)(__ccgo_up(a[i-int32(2)])) + if **(**uintptr)(__ccgo_up(n + 4)) != 0 { /* free the preceding node instead of the deleted one. */ deleted = n v1 = i i = i + 1 a[v1] = n + 4 - n = *(*uintptr)(unsafe.Pointer(n + 4)) - for *(*uintptr)(unsafe.Pointer(n + 4 + 1*4)) != 0 { + n = **(**uintptr)(__ccgo_up(n + 4)) + for **(**uintptr)(__ccgo_up(n + 4 + 1*4)) != 0 { v1 = i i = i + 1 a[v1] = n + 4 + 1*4 - n = *(*uintptr)(unsafe.Pointer(n + 4 + 1*4)) + n = **(**uintptr)(__ccgo_up(n + 4 + 1*4)) } (*Tnode1)(unsafe.Pointer(deleted)).Fkey = (*Tnode1)(unsafe.Pointer(n)).Fkey - child = *(*uintptr)(unsafe.Pointer(n + 4)) + child = **(**uintptr)(__ccgo_up(n + 4)) } else { - child = *(*uintptr)(unsafe.Pointer(n + 4 + 1*4)) + child = **(**uintptr)(__ccgo_up(n + 4 + 1*4)) } /* freed node has at most one child, move it up and rebalance. */ Xfree(tls, n) i = i - 1 v1 = i - *(*uintptr)(unsafe.Pointer(a[v1])) = child + **(**uintptr)(__ccgo_up(a[v1])) = child for { i = i - 1 v1 = i @@ -134808,8 +134808,8 @@ func Xtdestroy(tls *TLS, root uintptr, __ccgo_fp_freekey uintptr) { if r == uintptr(0) { return } - Xtdestroy(tls, *(*uintptr)(unsafe.Pointer(r + 4)), __ccgo_fp_freekey) - Xtdestroy(tls, *(*uintptr)(unsafe.Pointer(r + 4 + 1*4)), __ccgo_fp_freekey) + Xtdestroy(tls, **(**uintptr)(__ccgo_up(r + 4)), __ccgo_fp_freekey) + Xtdestroy(tls, **(**uintptr)(__ccgo_up(r + 4 + 1*4)), __ccgo_fp_freekey) if __ccgo_fp_freekey != 0 { (*(*func(*TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_freekey})))(tls, (*Tnode1)(unsafe.Pointer(r)).Fkey) } @@ -134829,7 +134829,7 @@ func Xtfind(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r uint if !(rootp != 0) { return uintptr(0) } - n = *(*uintptr)(unsafe.Pointer(rootp)) + n = **(**uintptr)(__ccgo_up(rootp)) for { if !(n != 0) { break @@ -134838,7 +134838,7 @@ func Xtfind(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r uint if !(c != 0) { break } - n = *(*uintptr)(unsafe.Pointer(n + 4 + BoolUintptr(c > 0)*4)) + n = **(**uintptr)(__ccgo_up(n + 4 + BoolUintptr(c > 0)*4)) goto _1 _1: } @@ -134860,11 +134860,11 @@ func _rot(tls *TLS, p uintptr, x uintptr, dir int32) (r int32) { var hx, hz int32 var y, z uintptr _, _, _, _ = hx, hz, y, z - y = *(*uintptr)(unsafe.Pointer(x + 4 + uintptr(dir)*4)) - z = *(*uintptr)(unsafe.Pointer(y + 4 + BoolUintptr(!(dir != 0))*4)) + y = **(**uintptr)(__ccgo_up(x + 4 + uintptr(dir)*4)) + z = **(**uintptr)(__ccgo_up(y + 4 + BoolUintptr(!(dir != 0))*4)) hx = (*Tnode1)(unsafe.Pointer(x)).Fh hz = _height(tls, z) - if hz > _height(tls, *(*uintptr)(unsafe.Pointer(y + 4 + uintptr(dir)*4))) { + if hz > _height(tls, **(**uintptr)(__ccgo_up(y + 4 + uintptr(dir)*4))) { /* * x * / \ dir z @@ -134872,10 +134872,10 @@ func _rot(tls *TLS, p uintptr, x uintptr, dir int32) (r int32) { * z D /| | * / \ A B C D * B C */ - *(*uintptr)(unsafe.Pointer(x + 4 + uintptr(dir)*4)) = *(*uintptr)(unsafe.Pointer(z + 4 + BoolUintptr(!(dir != 0))*4)) - *(*uintptr)(unsafe.Pointer(y + 4 + BoolUintptr(!(dir != 0))*4)) = *(*uintptr)(unsafe.Pointer(z + 4 + uintptr(dir)*4)) - *(*uintptr)(unsafe.Pointer(z + 4 + BoolUintptr(!(dir != 0))*4)) = x - *(*uintptr)(unsafe.Pointer(z + 4 + uintptr(dir)*4)) = y + **(**uintptr)(__ccgo_up(x + 4 + uintptr(dir)*4)) = **(**uintptr)(__ccgo_up(z + 4 + BoolUintptr(!(dir != 0))*4)) + **(**uintptr)(__ccgo_up(y + 4 + BoolUintptr(!(dir != 0))*4)) = **(**uintptr)(__ccgo_up(z + 4 + uintptr(dir)*4)) + **(**uintptr)(__ccgo_up(z + 4 + BoolUintptr(!(dir != 0))*4)) = x + **(**uintptr)(__ccgo_up(z + 4 + uintptr(dir)*4)) = y (*Tnode1)(unsafe.Pointer(x)).Fh = hz (*Tnode1)(unsafe.Pointer(y)).Fh = hz (*Tnode1)(unsafe.Pointer(z)).Fh = hz + int32(1) @@ -134885,13 +134885,13 @@ func _rot(tls *TLS, p uintptr, x uintptr, dir int32) (r int32) { * / \ / * A y --> x D * / \ / * z D A z */ - *(*uintptr)(unsafe.Pointer(x + 4 + uintptr(dir)*4)) = z - *(*uintptr)(unsafe.Pointer(y + 4 + BoolUintptr(!(dir != 0))*4)) = x + **(**uintptr)(__ccgo_up(x + 4 + uintptr(dir)*4)) = z + **(**uintptr)(__ccgo_up(y + 4 + BoolUintptr(!(dir != 0))*4)) = x (*Tnode1)(unsafe.Pointer(x)).Fh = hz + int32(1) (*Tnode1)(unsafe.Pointer(y)).Fh = hz + int32(2) z = y } - *(*uintptr)(unsafe.Pointer(p)) = z + **(**uintptr)(__ccgo_up(p)) = z return (*Tnode1)(unsafe.Pointer(z)).Fh - hx } @@ -134906,9 +134906,9 @@ func X__tsearch_balance(tls *TLS, p uintptr) (r int32) { var h0, h1, old, v1 int32 var n uintptr _, _, _, _, _ = h0, h1, n, old, v1 - n = *(*uintptr)(unsafe.Pointer(p)) - h0 = _height(tls, *(*uintptr)(unsafe.Pointer(n + 4))) - h1 = _height(tls, *(*uintptr)(unsafe.Pointer(n + 4 + 1*4))) + n = **(**uintptr)(__ccgo_up(p)) + h0 = _height(tls, **(**uintptr)(__ccgo_up(n + 4))) + h1 = _height(tls, **(**uintptr)(__ccgo_up(n + 4 + 1*4))) if Uint32FromInt32(h0-h1)+uint32(1) < uint32(3) { old = (*Tnode1)(unsafe.Pointer(n)).Fh if h0 < h1 { @@ -134937,7 +134937,7 @@ func Xtsearch(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r1 u if !(rootp != 0) { return uintptr(0) } - n = *(*uintptr)(unsafe.Pointer(rootp)) + n = **(**uintptr)(__ccgo_up(rootp)) i = 0 v1 = i i = i + 1 @@ -134953,7 +134953,7 @@ func Xtsearch(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r1 u v1 = i i = i + 1 a[v1] = n + 4 + BoolUintptr(c > 0)*4 - n = *(*uintptr)(unsafe.Pointer(n + 4 + BoolUintptr(c > 0)*4)) + n = **(**uintptr)(__ccgo_up(n + 4 + BoolUintptr(c > 0)*4)) goto _2 _2: } @@ -134963,13 +134963,13 @@ func Xtsearch(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r1 u } (*Tnode1)(unsafe.Pointer(r)).Fkey = key v4 = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(r + 4 + 1*4)) = v4 - *(*uintptr)(unsafe.Pointer(r + 4)) = v4 + **(**uintptr)(__ccgo_up(r + 4 + 1*4)) = v4 + **(**uintptr)(__ccgo_up(r + 4)) = v4 (*Tnode1)(unsafe.Pointer(r)).Fh = int32(1) /* insert new node, rebalance ancestors. */ i = i - 1 v1 = i - *(*uintptr)(unsafe.Pointer(a[v1])) = r + **(**uintptr)(__ccgo_up(a[v1])) = r for { if v7 = i != 0; v7 { i = i - 1 @@ -134990,9 +134990,9 @@ func _walk(tls *TLS, r uintptr, __ccgo_fp_action uintptr, d int32) { (*(*func(*TLS, uintptr, TVISIT, int32))(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_action})))(tls, r, int32(_leaf), d) } else { (*(*func(*TLS, uintptr, TVISIT, int32))(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_action})))(tls, r, int32(_preorder), d) - _walk(tls, *(*uintptr)(unsafe.Pointer(r + 4)), __ccgo_fp_action, d+int32(1)) + _walk(tls, **(**uintptr)(__ccgo_up(r + 4)), __ccgo_fp_action, d+int32(1)) (*(*func(*TLS, uintptr, TVISIT, int32))(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_action})))(tls, r, int32(_postorder), d) - _walk(tls, *(*uintptr)(unsafe.Pointer(r + 4 + 1*4)), __ccgo_fp_action, d+int32(1)) + _walk(tls, **(**uintptr)(__ccgo_up(r + 4 + 1*4)), __ccgo_fp_action, d+int32(1)) (*(*func(*TLS, uintptr, TVISIT, int32))(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_action})))(tls, r, int32(_endorder), d) } } @@ -135087,7 +135087,7 @@ func Xpselect(tls *TLS, n int32, rfds uintptr, wfds uintptr, efds uintptr, ts ui var v4 uint64 var _ /* data at bp+24 */ [2]Tsyscall_arg_t _, _, _, _, _, _, _ = ns, r, s, v1, v2, v3, v4 - *(*[2]Tsyscall_arg_t)(unsafe.Pointer(bp + 24)) = [2]Tsyscall_arg_t{ + **(**[2]Tsyscall_arg_t)(__ccgo_up(bp + 24)) = [2]Tsyscall_arg_t{ 0: Int32FromUint32(uint32(mask)), 1: int32(Int32FromInt32(_NSIG) / Int32FromInt32(8)), } @@ -135257,10 +135257,10 @@ func Xgetitimer(tls *TLS, which int32, old uintptr) (r1 int32) { if uint32(8) > uint32(4) { r = int32(X__syscall2(tls, int32(SYS_getitimer), which, int32(bp))) if !(r != 0) { - (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_sec = int64((*(*[4]int32)(unsafe.Pointer(bp)))[0]) - (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_usec = int64((*(*[4]int32)(unsafe.Pointer(bp)))[int32(1)]) - (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_sec = int64((*(*[4]int32)(unsafe.Pointer(bp)))[int32(2)]) - (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_usec = int64((*(*[4]int32)(unsafe.Pointer(bp)))[int32(3)]) + (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_sec = int64((**(**[4]int32)(__ccgo_up(bp)))[0]) + (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_usec = int64((**(**[4]int32)(__ccgo_up(bp)))[int32(1)]) + (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_sec = int64((**(**[4]int32)(__ccgo_up(bp)))[int32(2)]) + (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_usec = int64((**(**[4]int32)(__ccgo_up(bp)))[int32(3)]) } return X__syscall_ret(tls, Uint32FromInt32(r)) } @@ -135281,7 +135281,7 @@ func Xkillpg(tls *TLS, pgid Tpid_t, sig int32) (r int32) { defer func() { trc("-> %v", r) }() } if pgid < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } return Xkill(tls, -pgid, sig) @@ -135317,7 +135317,7 @@ func Xpsignal(tls *TLS, sig int32, msg uintptr) { * not permitted to do so. */ old_locale = (*TFILE)(unsafe.Pointer(f)).Flocale old_mode = (*TFILE)(unsafe.Pointer(f)).Fmode - old_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + old_errno = **(**int32)(__ccgo_up(X__errno_location(tls))) if msg != 0 { v2 = msg } else { @@ -135329,7 +135329,7 @@ func Xpsignal(tls *TLS, sig int32, msg uintptr) { v3 = __ccgo_ts } if Xfprintf(tls, f, __ccgo_ts+987, VaList(bp+8, v2, v3, s)) >= 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = old_errno + **(**int32)(__ccgo_up(X__errno_location(tls))) = old_errno } (*TFILE)(unsafe.Pointer(f)).Fmode = old_mode (*TFILE)(unsafe.Pointer(f)).Flocale = old_locale @@ -135395,10 +135395,10 @@ func Xsetitimer(tls *TLS, which int32, new1 uintptr, old uintptr) (r1 int32) { } r = int32(X__syscall3(tls, int32(SYS_setitimer), which, int32(bp), int32(bp+16))) if !(r != 0) && old != 0 { - (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_sec = int64((*(*[4]int32)(unsafe.Pointer(bp + 16)))[0]) - (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_usec = int64((*(*[4]int32)(unsafe.Pointer(bp + 16)))[int32(1)]) - (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_sec = int64((*(*[4]int32)(unsafe.Pointer(bp + 16)))[int32(2)]) - (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_usec = int64((*(*[4]int32)(unsafe.Pointer(bp + 16)))[int32(3)]) + (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_sec = int64((**(**[4]int32)(__ccgo_up(bp + 16)))[0]) + (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_usec = int64((**(**[4]int32)(__ccgo_up(bp + 16)))[int32(1)]) + (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_sec = int64((**(**[4]int32)(__ccgo_up(bp + 16)))[int32(2)]) + (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_usec = int64((**(**[4]int32)(__ccgo_up(bp + 16)))[int32(3)]) } return X__syscall_ret(tls, Uint32FromInt32(r)) } @@ -135454,11 +135454,11 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old uintptr) (r1 int32) Fv Tuint64_t }{} *(*uint64)(unsafe.Pointer(bp + 8)) = Uint64FromInt32(v2) - if *(*Tuint32_t)(unsafe.Pointer(bp + 8)) != 0 { - _a_or(tls, v3, Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(bp + 8)))) + if **(**Tuint32_t)(__ccgo_up(bp + 8)) != 0 { + _a_or(tls, v3, Int32FromUint32(**(**Tuint32_t)(__ccgo_up(bp + 8)))) } - if *(*Tuint32_t)(unsafe.Pointer(bp + 8 + 1*4)) != 0 { - _a_or(tls, v3+uintptr(1)*4, Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(bp + 8 + 1*4)))) + if **(**Tuint32_t)(__ccgo_up(bp + 8 + 1*4)) != 0 { + _a_or(tls, v3+uintptr(1)*4, Int32FromUint32(**(**Tuint32_t)(__ccgo_up(bp + 8 + 1*4)))) } } /* If pthread_create has not yet been called, @@ -135480,15 +135480,15 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old uintptr) (r1 int32) _a_store(tls, uintptr(unsafe.Pointer(&X__eintr_valid_flag)), int32(1)) } } - (*(*Tk_sigaction)(unsafe.Pointer(bp + 16))).Fhandler = *(*uintptr)(unsafe.Pointer(sa)) - (*(*Tk_sigaction)(unsafe.Pointer(bp + 16))).Fflags = Uint32FromInt32((*Tsigaction)(unsafe.Pointer(sa)).Fsa_flags) - (*(*Tk_sigaction)(unsafe.Pointer(bp + 16))).Fflags |= uint32(SA_RESTORER) + (**(**Tk_sigaction)(__ccgo_up(bp + 16))).Fhandler = *(*uintptr)(unsafe.Pointer(sa)) + (**(**Tk_sigaction)(__ccgo_up(bp + 16))).Fflags = Uint32FromInt32((*Tsigaction)(unsafe.Pointer(sa)).Fsa_flags) + (**(**Tk_sigaction)(__ccgo_up(bp + 16))).Fflags |= uint32(SA_RESTORER) if (*Tsigaction)(unsafe.Pointer(sa)).Fsa_flags&int32(SA_SIGINFO) != 0 { v1 = __ccgo_fp(X__restore_rt) } else { v1 = __ccgo_fp(X__restore) } - (*(*Tk_sigaction)(unsafe.Pointer(bp + 16))).Frestorer = v1 + (**(**Tk_sigaction)(__ccgo_up(bp + 16))).Frestorer = v1 Xmemcpy(tls, bp+16+12, sa+4, Uint32FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))) } if sa != 0 { @@ -135503,8 +135503,8 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old uintptr) (r1 int32) } r = int32(X__syscall4(tls, int32(SYS_rt_sigaction), sig, int32(v1), int32(v3), int32(Int32FromInt32(_NSIG)/Int32FromInt32(8)))) if old != 0 && !(r != 0) { - *(*uintptr)(unsafe.Pointer(old)) = (*(*Tk_sigaction)(unsafe.Pointer(bp + 36))).Fhandler - (*Tsigaction)(unsafe.Pointer(old)).Fsa_flags = Int32FromUint32((*(*Tk_sigaction)(unsafe.Pointer(bp + 36))).Fflags) + *(*uintptr)(unsafe.Pointer(old)) = (**(**Tk_sigaction)(__ccgo_up(bp + 36))).Fhandler + (*Tsigaction)(unsafe.Pointer(old)).Fsa_flags = Int32FromUint32((**(**Tk_sigaction)(__ccgo_up(bp + 36))).Fflags) Xmemcpy(tls, old+4, bp+36+12, Uint32FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))) } return X__syscall_ret(tls, Uint32FromInt32(r)) @@ -135521,7 +135521,7 @@ func X__sigaction(tls *TLS, sig int32, sa uintptr, old uintptr) (r1 int32) { var _ /* set at bp+0 */ [2]uint32 _ = r if Uint32FromInt32(sig)-uint32(32) < uint32(3) || Uint32FromInt32(sig)-uint32(1) >= Uint32FromInt32(Int32FromInt32(_NSIG)-Int32FromInt32(1)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } /* Doing anything with the disposition of SIGABRT requires a lock, @@ -135556,10 +135556,10 @@ func Xsigaddset(tls *TLS, set uintptr, sig int32) (r int32) { _ = s s = Uint32FromInt32(sig - int32(1)) if s >= Uint32FromInt32(Int32FromInt32(_NSIG)-Int32FromInt32(1)) || Uint32FromInt32(sig)-uint32(32) < uint32(3) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } - *(*uint32)(unsafe.Pointer(set + uintptr(s/uint32(8)/uint32(4))*4)) |= uint32(1) << (s & (Uint32FromInt32(8)*Uint32FromInt64(4) - Uint32FromInt32(1))) + **(**uint32)(__ccgo_up(set + uintptr(s/uint32(8)/uint32(4))*4)) |= uint32(1) << (s & (Uint32FromInt32(8)*Uint32FromInt64(4) - Uint32FromInt32(1))) return 0 } @@ -135570,11 +135570,11 @@ func Xsigaltstack(tls *TLS, ss uintptr, old uintptr) (r int32) { } if ss != 0 { if !((*Tstack_t)(unsafe.Pointer(ss)).Fss_flags&Int32FromInt32(SS_DISABLE) != 0) && (*Tstack_t)(unsafe.Pointer(ss)).Fss_size < uint32(MINSIGSTKSZ) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return -int32(1) } if (*Tstack_t)(unsafe.Pointer(ss)).Fss_flags&int32(SS_ONSTACK) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } } @@ -135599,7 +135599,7 @@ func Xsigandset(tls *TLS, dest uintptr, left uintptr, right uintptr) (r1 int32) if !(i < uint32(Uint32FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))/Uint32FromInt64(4))) { break } - *(*uint32)(unsafe.Pointer(d + uintptr(i)*4)) = *(*uint32)(unsafe.Pointer(l + uintptr(i)*4)) & *(*uint32)(unsafe.Pointer(r + uintptr(i)*4)) + **(**uint32)(__ccgo_up(d + uintptr(i)*4)) = **(**uint32)(__ccgo_up(l + uintptr(i)*4)) & **(**uint32)(__ccgo_up(r + uintptr(i)*4)) goto _1 _1: ; @@ -135617,10 +135617,10 @@ func Xsigdelset(tls *TLS, set uintptr, sig int32) (r int32) { _ = s s = Uint32FromInt32(sig - int32(1)) if s >= Uint32FromInt32(Int32FromInt32(_NSIG)-Int32FromInt32(1)) || Uint32FromInt32(sig)-uint32(32) < uint32(3) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } - *(*uint32)(unsafe.Pointer(set + uintptr(s/uint32(8)/uint32(4))*4)) &= ^(Uint32FromUint32(1) << (s & (Uint32FromInt32(8)*Uint32FromInt64(4) - Uint32FromInt32(1)))) + **(**uint32)(__ccgo_up(set + uintptr(s/uint32(8)/uint32(4))*4)) &= ^(Uint32FromUint32(1) << (s & (Uint32FromInt32(8)*Uint32FromInt64(4) - Uint32FromInt32(1)))) return 0 } @@ -135629,13 +135629,13 @@ func Xsigemptyset(tls *TLS, set uintptr) (r int32) { trc("tls=%v set=%v, (%v:)", tls, set, origin(2)) defer func() { trc("-> %v", r) }() } - *(*uint32)(unsafe.Pointer(set)) = uint32(0) + **(**uint32)(__ccgo_up(set)) = uint32(0) if Bool(uint32(4) == uint32(4)) || Bool(int32(_NSIG) > int32(65)) { - *(*uint32)(unsafe.Pointer(set + 1*4)) = uint32(0) + **(**uint32)(__ccgo_up(set + 1*4)) = uint32(0) } if Bool(uint32(4) == uint32(4)) && Bool(int32(_NSIG) > int32(65)) { - *(*uint32)(unsafe.Pointer(set + 2*4)) = uint32(0) - *(*uint32)(unsafe.Pointer(set + 3*4)) = uint32(0) + **(**uint32)(__ccgo_up(set + 2*4)) = uint32(0) + **(**uint32)(__ccgo_up(set + 3*4)) = uint32(0) } return 0 } @@ -135654,11 +135654,11 @@ func Xsigfillset(tls *TLS, set uintptr) (r int32) { trc("tls=%v set=%v, (%v:)", tls, set, origin(2)) defer func() { trc("-> %v", r) }() } - *(*uint32)(unsafe.Pointer(set)) = uint32(0x7fffffff) - *(*uint32)(unsafe.Pointer(set + 1*4)) = uint32(0xfffffffc) + **(**uint32)(__ccgo_up(set)) = uint32(0x7fffffff) + **(**uint32)(__ccgo_up(set + 1*4)) = uint32(0xfffffffc) if int32(_NSIG) > int32(65) { - *(*uint32)(unsafe.Pointer(set + 2*4)) = uint32(0xffffffff) - *(*uint32)(unsafe.Pointer(set + 3*4)) = uint32(0xffffffff) + **(**uint32)(__ccgo_up(set + 2*4)) = uint32(0xffffffff) + **(**uint32)(__ccgo_up(set + 3*4)) = uint32(0xffffffff) } return 0 } @@ -135675,7 +135675,7 @@ func Xsigisemptyset(tls *TLS, set uintptr) (r int32) { if !(i < Uint32FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))/Uint32FromInt64(4)) { break } - if *(*uint32)(unsafe.Pointer(set + uintptr(i)*4)) != 0 { + if **(**uint32)(__ccgo_up(set + uintptr(i)*4)) != 0 { return 0 } goto _1 @@ -135697,7 +135697,7 @@ func Xsigismember(tls *TLS, set uintptr, sig int32) (r int32) { if s >= Uint32FromInt32(Int32FromInt32(_NSIG)-Int32FromInt32(1)) { return 0 } - return BoolInt32(!!(*(*uint32)(unsafe.Pointer(set + uintptr(s/uint32(8)/uint32(4))*4))&(Uint32FromUint32(1)<<(s&(Uint32FromInt32(8)*Uint32FromInt64(4)-Uint32FromInt32(1)))) != 0)) + return BoolInt32(!!(**(**uint32)(__ccgo_up(set + uintptr(s/uint32(8)/uint32(4))*4))&(Uint32FromUint32(1)<<(s&(Uint32FromInt32(8)*Uint32FromInt64(4)-Uint32FromInt32(1)))) != 0)) } func Xsigorset(tls *TLS, dest uintptr, left uintptr, right uintptr) (r1 int32) { @@ -135716,7 +135716,7 @@ func Xsigorset(tls *TLS, dest uintptr, left uintptr, right uintptr) (r1 int32) { if !(i < uint32(Uint32FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))/Uint32FromInt64(4))) { break } - *(*uint32)(unsafe.Pointer(d + uintptr(i)*4)) = *(*uint32)(unsafe.Pointer(l + uintptr(i)*4)) | *(*uint32)(unsafe.Pointer(r + uintptr(i)*4)) + **(**uint32)(__ccgo_up(d + uintptr(i)*4)) = **(**uint32)(__ccgo_up(l + uintptr(i)*4)) | **(**uint32)(__ccgo_up(r + uintptr(i)*4)) goto _1 _1: ; @@ -135744,7 +135744,7 @@ func Xsigprocmask(tls *TLS, how int32, set uintptr, old uintptr) (r1 int32) { if !(r != 0) { return r } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = r + **(**int32)(__ccgo_up(X__errno_location(tls))) = r return -int32(1) } @@ -135760,8 +135760,8 @@ func Xsigqueue(tls *TLS, pid Tpid_t, sig int32, value Tsigval) (r1 int32) { var _ /* si at bp+0 */ Tsiginfo_t _ = r Xmemset(tls, bp, 0, uint32(128)) - (*(*Tsiginfo_t)(unsafe.Pointer(bp))).Fsi_signo = sig - (*(*Tsiginfo_t)(unsafe.Pointer(bp))).Fsi_code = -int32(1) + (**(**Tsiginfo_t)(__ccgo_up(bp))).Fsi_signo = sig + (**(**Tsiginfo_t)(__ccgo_up(bp))).Fsi_code = -int32(1) *(*Tsigval)(unsafe.Pointer(bp + 12 + 8)) = value *(*Tuid_t)(unsafe.Pointer(bp + 12 + 4)) = Xgetuid(tls) X__block_app_sigs(tls, bp+128) @@ -135908,7 +135908,7 @@ func Xsigwait(tls *TLS, mask uintptr, sig uintptr) (r int32) { if Xsigtimedwait(tls, mask, bp, uintptr(0)) < 0 { return -int32(1) } - *(*int32)(unsafe.Pointer(sig)) = (*(*Tsiginfo_t)(unsafe.Pointer(bp))).Fsi_signo + **(**int32)(__ccgo_up(sig)) = (**(**Tsiginfo_t)(__ccgo_up(bp))).Fsi_signo return 0 } @@ -135925,7 +135925,7 @@ func X__xmknod(tls *TLS, ver int32, path uintptr, mode Tmode_t, dev uintptr) (r trc("tls=%v ver=%v path=%v mode=%v dev=%v, (%v:)", tls, ver, path, mode, dev, origin(2)) defer func() { trc("-> %v", r) }() } - return Xmknod(tls, path, mode, *(*Tdev_t)(unsafe.Pointer(dev))) + return Xmknod(tls, path, mode, **(**Tdev_t)(__ccgo_up(dev))) } func X__xmknodat(tls *TLS, ver int32, fd int32, path uintptr, mode Tmode_t, dev uintptr) (r int32) { @@ -135933,7 +135933,7 @@ func X__xmknodat(tls *TLS, ver int32, fd int32, path uintptr, mode Tmode_t, dev trc("tls=%v ver=%v fd=%v path=%v mode=%v dev=%v, (%v:)", tls, ver, fd, path, mode, dev, origin(2)) defer func() { trc("-> %v", r) }() } - return Xmknodat(tls, fd, path, mode, *(*Tdev_t)(unsafe.Pointer(dev))) + return Xmknodat(tls, fd, path, mode, **(**Tdev_t)(__ccgo_up(dev))) } func Xchmod(tls *TLS, path uintptr, mode Tmode_t) (r int32) { @@ -135986,7 +135986,7 @@ func Xfchmodat(tls *TLS, fd int32, path uintptr, mode Tmode_t, flag int32) (r in if Xfstatat(tls, fd, path, bp, flag) != 0 { return -int32(1) } - if (*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { + if (**(**Tstat)(__ccgo_up(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { return X__syscall_ret(tls, Uint32FromInt32(-Int32FromInt32(EOPNOTSUPP))) } v1 = int32(X__syscall3(tls, int32(SYS_openat), fd, int32(path), int32(Int32FromInt32(O_RDONLY)|Int32FromInt32(O_PATH)|Int32FromInt32(O_NOFOLLOW)|Int32FromInt32(O_NOCTTY)|Int32FromInt32(O_CLOEXEC)))) @@ -136000,7 +136000,7 @@ func Xfchmodat(tls *TLS, fd int32, path uintptr, mode Tmode_t, flag int32) (r in X__procfdname(tls, bp+144, Uint32FromInt32(fd2)) ret = Xstat(tls, bp+144, bp) if !(ret != 0) { - if (*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { + if (**(**Tstat)(__ccgo_up(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { ret = X__syscall_ret(tls, Uint32FromInt32(-Int32FromInt32(EOPNOTSUPP))) } else { ret = X__syscall_ret(tls, Uint32FromInt32(X__syscall3(tls, int32(SYS_fchmodat), int32(-Int32FromInt32(100)), int32(bp+144), Int32FromUint32(mode)))) @@ -136080,49 +136080,49 @@ func _fstatat_statx(tls *TLS, fd int32, path uintptr, st uintptr, flag int32) (r if ret != 0 { return ret } - *(*Tstat)(unsafe.Pointer(st)) = Tstat{ - Fst_dev: uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_dev_major)&Uint64FromUint64(0xfffff000)<= 0 && !(*(*int8)(unsafe.Pointer(path)) != 0) { + if flag == int32(AT_EMPTY_PATH) && fd >= 0 && !(**(**int8)(__ccgo_up(path)) != 0) { ret = int32(X__syscall2(tls, int32(SYS_fstat64), fd, int32(bp))) if ret == -int32(EBADF) && X__syscall2(tls, int32(SYS_fcntl64), fd, int32(Int32FromInt32(F_GETFD))) >= 0 { ret = int32(X__syscall4(tls, int32(SYS_fstatat64), fd, int32(path), int32(bp), flag)) @@ -136167,10 +136167,10 @@ func _fstatat_kstat(tls *TLS, fd int32, path uintptr, st uintptr, flag int32) (r } } } else { - if (fd == -int32(100) || int32(*(*int8)(unsafe.Pointer(path))) == int32('/')) && flag == int32(AT_SYMLINK_NOFOLLOW) { + if (fd == -int32(100) || int32(**(**int8)(__ccgo_up(path))) == int32('/')) && flag == int32(AT_SYMLINK_NOFOLLOW) { ret = int32(X__syscall2(tls, int32(SYS_lstat64), int32(path), int32(bp))) } else { - if (fd == -int32(100) || int32(*(*int8)(unsafe.Pointer(path))) == int32('/')) && !(flag != 0) { + if (fd == -int32(100) || int32(**(**int8)(__ccgo_up(path))) == int32('/')) && !(flag != 0) { ret = int32(X__syscall2(tls, int32(SYS_stat64), int32(path), int32(bp))) } else { ret = int32(X__syscall4(tls, int32(SYS_fstatat64), fd, int32(path), int32(bp), flag)) @@ -136180,49 +136180,49 @@ func _fstatat_kstat(tls *TLS, fd int32, path uintptr, st uintptr, flag int32) (r if ret != 0 { return ret } - *(*Tstat)(unsafe.Pointer(st)) = Tstat{ - Fst_dev: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_dev, - Fst_mode: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_mode, - Fst_nlink: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_nlink, - Fst_uid: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_uid, - Fst_gid: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_gid, - Fst_rdev: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_rdev, - Fst_size: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_size, - Fst_blksize: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_blksize, - Fst_blocks: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_blocks, + **(**Tstat)(__ccgo_up(st)) = Tstat{ + Fst_dev: (**(**Tkstat)(__ccgo_up(bp))).Fst_dev, + Fst_mode: (**(**Tkstat)(__ccgo_up(bp))).Fst_mode, + Fst_nlink: (**(**Tkstat)(__ccgo_up(bp))).Fst_nlink, + Fst_uid: (**(**Tkstat)(__ccgo_up(bp))).Fst_uid, + Fst_gid: (**(**Tkstat)(__ccgo_up(bp))).Fst_gid, + Fst_rdev: (**(**Tkstat)(__ccgo_up(bp))).Fst_rdev, + Fst_size: (**(**Tkstat)(__ccgo_up(bp))).Fst_size, + Fst_blksize: (**(**Tkstat)(__ccgo_up(bp))).Fst_blksize, + Fst_blocks: (**(**Tkstat)(__ccgo_up(bp))).Fst_blocks, F__st_atim32: struct { Ftv_sec int32 Ftv_nsec int32 }{ - Ftv_sec: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_atime_sec, - Ftv_nsec: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_atime_nsec, + Ftv_sec: (**(**Tkstat)(__ccgo_up(bp))).Fst_atime_sec, + Ftv_nsec: (**(**Tkstat)(__ccgo_up(bp))).Fst_atime_nsec, }, F__st_mtim32: struct { Ftv_sec int32 Ftv_nsec int32 }{ - Ftv_sec: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_mtime_sec, - Ftv_nsec: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_mtime_nsec, + Ftv_sec: (**(**Tkstat)(__ccgo_up(bp))).Fst_mtime_sec, + Ftv_nsec: (**(**Tkstat)(__ccgo_up(bp))).Fst_mtime_nsec, }, F__st_ctim32: struct { Ftv_sec int32 Ftv_nsec int32 }{ - Ftv_sec: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_ctime_sec, - Ftv_nsec: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_ctime_nsec, + Ftv_sec: (**(**Tkstat)(__ccgo_up(bp))).Fst_ctime_sec, + Ftv_nsec: (**(**Tkstat)(__ccgo_up(bp))).Fst_ctime_nsec, }, - Fst_ino: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_ino, + Fst_ino: (**(**Tkstat)(__ccgo_up(bp))).Fst_ino, Fst_atim: Ttimespec{ - Ftv_sec: int64((*(*Tkstat)(unsafe.Pointer(bp))).Fst_atime_sec), - Ftv_nsec: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_atime_nsec, + Ftv_sec: int64((**(**Tkstat)(__ccgo_up(bp))).Fst_atime_sec), + Ftv_nsec: (**(**Tkstat)(__ccgo_up(bp))).Fst_atime_nsec, }, Fst_mtim: Ttimespec{ - Ftv_sec: int64((*(*Tkstat)(unsafe.Pointer(bp))).Fst_mtime_sec), - Ftv_nsec: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_mtime_nsec, + Ftv_sec: int64((**(**Tkstat)(__ccgo_up(bp))).Fst_mtime_sec), + Ftv_nsec: (**(**Tkstat)(__ccgo_up(bp))).Fst_mtime_nsec, }, Fst_ctim: Ttimespec{ - Ftv_sec: int64((*(*Tkstat)(unsafe.Pointer(bp))).Fst_ctime_sec), - Ftv_nsec: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_ctime_nsec, + Ftv_sec: int64((**(**Tkstat)(__ccgo_up(bp))).Fst_ctime_sec), + Ftv_nsec: (**(**Tkstat)(__ccgo_up(bp))).Fst_ctime_nsec, }, } return 0 @@ -136278,11 +136278,11 @@ func X__futimesat(tls *TLS, dirfd int32, pathname uintptr, times uintptr) (r int if !(i < int32(2)) { break } - if Uint64FromInt64((*(*Ttimeval)(unsafe.Pointer(times + uintptr(i)*16))).Ftv_usec) >= uint64(1000000) { + if Uint64FromInt64((**(**Ttimeval)(__ccgo_up(times + uintptr(i)*16))).Ftv_usec) >= uint64(1000000) { return X__syscall_ret(tls, Uint32FromInt32(-Int32FromInt32(EINVAL))) } - (*(*[2]Ttimespec)(unsafe.Pointer(bp)))[i].Ftv_sec = (*(*Ttimeval)(unsafe.Pointer(times + uintptr(i)*16))).Ftv_sec - (*(*[2]Ttimespec)(unsafe.Pointer(bp)))[i].Ftv_nsec = int32((*(*Ttimeval)(unsafe.Pointer(times + uintptr(i)*16))).Ftv_usec * int64(1000)) + (**(**[2]Ttimespec)(__ccgo_up(bp)))[i].Ftv_sec = (**(**Ttimeval)(__ccgo_up(times + uintptr(i)*16))).Ftv_sec + (**(**[2]Ttimespec)(__ccgo_up(bp)))[i].Ftv_nsec = int32((**(**Ttimeval)(__ccgo_up(times + uintptr(i)*16))).Ftv_usec * int64(1000)) goto _1 _1: ; @@ -136378,7 +136378,7 @@ func Xstat(tls *TLS, path uintptr, buf uintptr) (r int32) { } func ___statfs(tls *TLS, path uintptr, buf uintptr) (r int32) { - *(*Tstatfs)(unsafe.Pointer(buf)) = Tstatfs{} + **(**Tstatfs)(__ccgo_up(buf)) = Tstatfs{} return X__syscall_ret(tls, Uint32FromInt32(X__syscall3(tls, int32(SYS_statfs64), int32(path), Int32FromUint32(Uint32FromInt64(84)), int32(buf)))) } @@ -136387,14 +136387,14 @@ func Xfstatfs(tls *TLS, fd int32, buf uintptr) (r int32) { trc("tls=%v fd=%v buf=%v, (%v:)", tls, fd, buf, origin(2)) defer func() { trc("-> %v", r) }() } - *(*Tstatfs)(unsafe.Pointer(buf)) = Tstatfs{} + **(**Tstatfs)(__ccgo_up(buf)) = Tstatfs{} return X__syscall_ret(tls, Uint32FromInt32(X__syscall3(tls, int32(SYS_fstatfs64), fd, Int32FromUint32(Uint32FromInt64(84)), int32(buf)))) } func _fixup(tls *TLS, out uintptr, in uintptr) { var v1 uint32 _ = v1 - *(*Tstatvfs)(unsafe.Pointer(out)) = Tstatvfs{} + **(**Tstatvfs)(__ccgo_up(out)) = Tstatvfs{} (*Tstatvfs)(unsafe.Pointer(out)).Ff_bsize = (*Tstatfs)(unsafe.Pointer(in)).Ff_bsize if (*Tstatfs)(unsafe.Pointer(in)).Ff_frsize != 0 { v1 = (*Tstatfs)(unsafe.Pointer(in)).Ff_frsize @@ -136408,7 +136408,7 @@ func _fixup(tls *TLS, out uintptr, in uintptr) { (*Tstatvfs)(unsafe.Pointer(out)).Ff_files = (*Tstatfs)(unsafe.Pointer(in)).Ff_files (*Tstatvfs)(unsafe.Pointer(out)).Ff_ffree = (*Tstatfs)(unsafe.Pointer(in)).Ff_ffree (*Tstatvfs)(unsafe.Pointer(out)).Ff_favail = (*Tstatfs)(unsafe.Pointer(in)).Ff_ffree - (*Tstatvfs)(unsafe.Pointer(out)).Ff_fsid = Uint32FromInt32(*(*int32)(unsafe.Pointer(in + 48))) + (*Tstatvfs)(unsafe.Pointer(out)).Ff_fsid = Uint32FromInt32(**(**int32)(__ccgo_up(in + 48))) (*Tstatvfs)(unsafe.Pointer(out)).Ff_flag = (*Tstatfs)(unsafe.Pointer(in)).Ff_flags (*Tstatvfs)(unsafe.Pointer(out)).Ff_namemax = (*Tstatfs)(unsafe.Pointer(in)).Ff_namelen (*Tstatvfs)(unsafe.Pointer(out)).Ff_type = (*Tstatfs)(unsafe.Pointer(in)).Ff_type @@ -136464,7 +136464,7 @@ func Xutimensat(tls *TLS, fd int32, path uintptr, times uintptr, flags int32) (r var tv, v1 uintptr var _ /* tmp at bp+48 */ [4]int32 _, _, _, _, _, _, _, _ = i, ns0, ns1, r, s0, s1, tv, v1 - if times != 0 && (*(*Ttimespec)(unsafe.Pointer(times))).Ftv_nsec == int32(UTIME_NOW) && (*(*Ttimespec)(unsafe.Pointer(times + 1*16))).Ftv_nsec == int32(UTIME_NOW) { + if times != 0 && (**(**Ttimespec)(__ccgo_up(times))).Ftv_nsec == int32(UTIME_NOW) && (**(**Ttimespec)(__ccgo_up(times + 1*16))).Ftv_nsec == int32(UTIME_NOW) { times = uintptr(0) } r = -int32(ENOSYS) @@ -136473,13 +136473,13 @@ func Xutimensat(tls *TLS, fd int32, path uintptr, times uintptr, flags int32) (r ns0 = 0 ns1 = 0 if times != 0 { - ns0 = (*(*Ttimespec)(unsafe.Pointer(times))).Ftv_nsec - ns1 = (*(*Ttimespec)(unsafe.Pointer(times + 1*16))).Ftv_nsec + ns0 = (**(**Ttimespec)(__ccgo_up(times))).Ftv_nsec + ns1 = (**(**Ttimespec)(__ccgo_up(times + 1*16))).Ftv_nsec if !(ns0 == int32(UTIME_NOW) || ns0 == int32(UTIME_OMIT)) { - s0 = (*(*Ttimespec)(unsafe.Pointer(times))).Ftv_sec + s0 = (**(**Ttimespec)(__ccgo_up(times))).Ftv_sec } if !(ns1 == int32(UTIME_NOW) || ns1 == int32(UTIME_OMIT)) { - s1 = (*(*Ttimespec)(unsafe.Pointer(times + 1*16))).Ftv_sec + s1 = (**(**Ttimespec)(__ccgo_up(times + 1*16))).Ftv_sec } } if Bool(false) || !!((Uint64FromInt64(s0)+Uint64FromUint64(0x80000000))>>Int32FromInt32(32) != 0) || !!((Uint64FromInt64(s1)+Uint64FromUint64(0x80000000))>>Int32FromInt32(32) != 0) { @@ -136525,14 +136525,14 @@ func Xutimensat(tls *TLS, fd int32, path uintptr, times uintptr, flags int32) (r if !(i < int32(2)) { break } - if Uint64FromInt32((*(*Ttimespec)(unsafe.Pointer(times + uintptr(i)*16))).Ftv_nsec) >= uint64(1000000000) { - if (*(*Ttimespec)(unsafe.Pointer(times + uintptr(i)*16))).Ftv_nsec == int32(UTIME_NOW) || (*(*Ttimespec)(unsafe.Pointer(times + uintptr(i)*16))).Ftv_nsec == int32(UTIME_OMIT) { + if Uint64FromInt32((**(**Ttimespec)(__ccgo_up(times + uintptr(i)*16))).Ftv_nsec) >= uint64(1000000000) { + if (**(**Ttimespec)(__ccgo_up(times + uintptr(i)*16))).Ftv_nsec == int32(UTIME_NOW) || (**(**Ttimespec)(__ccgo_up(times + uintptr(i)*16))).Ftv_nsec == int32(UTIME_OMIT) { return X__syscall_ret(tls, Uint32FromInt32(-Int32FromInt32(ENOSYS))) } return X__syscall_ret(tls, Uint32FromInt32(-Int32FromInt32(EINVAL))) } - (*(*[4]int32)(unsafe.Pointer(bp + 48)))[int32(2)*i+0] = int32((*(*Ttimespec)(unsafe.Pointer(times + uintptr(i)*16))).Ftv_sec) - (*(*[4]int32)(unsafe.Pointer(bp + 48)))[int32(2)*i+int32(1)] = (*(*Ttimespec)(unsafe.Pointer(times + uintptr(i)*16))).Ftv_nsec / int32(1000) + (**(**[4]int32)(__ccgo_up(bp + 48)))[int32(2)*i+0] = int32((**(**Ttimespec)(__ccgo_up(times + uintptr(i)*16))).Ftv_sec) + (**(**[4]int32)(__ccgo_up(bp + 48)))[int32(2)*i+int32(1)] = (**(**Ttimespec)(__ccgo_up(times + uintptr(i)*16))).Ftv_nsec / int32(1000) goto _3 _3: ; @@ -136567,8 +136567,8 @@ func X__fdopen(tls *TLS, fd int32, mode uintptr) (r uintptr) { var _ /* wsz at bp+0 */ Twinsize _, _, _, _ = f, flags, v1, v2 /* Check for valid initial mode character */ - if !(Xstrchr(tls, __ccgo_ts+1402, int32(*(*int8)(unsafe.Pointer(mode)))) != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if !(Xstrchr(tls, __ccgo_ts+1402, int32(**(**int8)(__ccgo_up(mode)))) != 0) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } /* Allocate FILE+buffer or fail */ @@ -136581,7 +136581,7 @@ func X__fdopen(tls *TLS, fd int32, mode uintptr) (r uintptr) { Xmemset(tls, f, 0, uint32(136)) /* Impose mode restrictions */ if !(Xstrchr(tls, mode, int32('+')) != 0) { - if int32(*(*int8)(unsafe.Pointer(mode))) == int32('r') { + if int32(**(**int8)(__ccgo_up(mode))) == int32('r') { v2 = int32(F_NOWR) } else { v2 = int32(F_NORD) @@ -136593,12 +136593,12 @@ func X__fdopen(tls *TLS, fd int32, mode uintptr) (r uintptr) { X__syscall3(tls, int32(SYS_fcntl64), fd, int32(Int32FromInt32(F_SETFD)), int32(Int32FromInt32(FD_CLOEXEC))) } /* Set append mode on fd if opened for append */ - if int32(*(*int8)(unsafe.Pointer(mode))) == int32('a') { + if int32(**(**int8)(__ccgo_up(mode))) == int32('a') { flags = int32(X__syscall2(tls, int32(SYS_fcntl64), fd, int32(Int32FromInt32(F_GETFL)))) if !(flags&Int32FromInt32(O_APPEND) != 0) { X__syscall3(tls, int32(SYS_fcntl64), fd, int32(Int32FromInt32(F_SETFL)), int32(flags|Int32FromInt32(O_APPEND))) } - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_APP) + **(**uint32)(__ccgo_up(f)) |= uint32(F_APP) } (*TFILE)(unsafe.Pointer(f)).Ffd = fd (*TFILE)(unsafe.Pointer(f)).Fbuf = f + uintptr(136) + uintptr(UNGET) @@ -136638,7 +136638,7 @@ func X__fmodeflags(tls *TLS, mode uintptr) (r int32) { if Xstrchr(tls, mode, int32('+')) != 0 { flags = int32(O_RDWR) } else { - if int32(*(*int8)(unsafe.Pointer(mode))) == int32('r') { + if int32(**(**int8)(__ccgo_up(mode))) == int32('r') { flags = O_RDONLY } else { flags = int32(O_WRONLY) @@ -136650,13 +136650,13 @@ func X__fmodeflags(tls *TLS, mode uintptr) (r int32) { if Xstrchr(tls, mode, int32('e')) != 0 { flags = flags | int32(O_CLOEXEC) } - if int32(*(*int8)(unsafe.Pointer(mode))) != int32('r') { + if int32(**(**int8)(__ccgo_up(mode))) != int32('r') { flags = flags | int32(O_CREAT) } - if int32(*(*int8)(unsafe.Pointer(mode))) == int32('w') { + if int32(**(**int8)(__ccgo_up(mode))) == int32('w') { flags = flags | int32(O_TRUNC) } - if int32(*(*int8)(unsafe.Pointer(mode))) == int32('a') { + if int32(**(**int8)(__ccgo_up(mode))) == int32('a') { flags = flags | int32(O_APPEND) } return flags @@ -136694,22 +136694,22 @@ func X__overflow(tls *TLS, f uintptr, _c int32) (r int32) { var v2, v3 uintptr var _ /* c at bp+0 */ uint8 _, _, _ = v1, v2, v3 - *(*uint8)(unsafe.Pointer(bp)) = Uint8FromInt32(_c) + **(**uint8)(__ccgo_up(bp)) = Uint8FromInt32(_c) if !((*TFILE)(unsafe.Pointer(f)).Fwend != 0) && X__towrite(tls, f) != 0 { return -int32(1) } - if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwend && Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) != (*TFILE)(unsafe.Pointer(f)).Flbf { - v1 = *(*uint8)(unsafe.Pointer(bp)) + if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwend && Int32FromUint8(**(**uint8)(__ccgo_up(bp))) != (*TFILE)(unsafe.Pointer(f)).Flbf { + v1 = **(**uint8)(__ccgo_up(bp)) v3 = f + 20 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - *(*uint8)(unsafe.Pointer(v2)) = v1 + **(**uint8)(__ccgo_up(v2)) = v1 return Int32FromUint8(v1) } if (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fwrite})))(tls, f, bp, uint32(1)) != uint32(1) { return -int32(1) } - return Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) + return Int32FromUint8(**(**uint8)(__ccgo_up(bp))) } func _dummy9(tls *TLS, fd int32) (r int32) { @@ -136747,7 +136747,7 @@ func X__stdio_exit(tls *TLS) { } var f uintptr _ = f - f = *(*uintptr)(unsafe.Pointer(X__ofl_lock(tls))) + f = **(**uintptr)(__ccgo_up(X__ofl_lock(tls))) for { if !(f != 0) { break @@ -136782,7 +136782,7 @@ func X__stdio_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { var v3, v4 uintptr var _ /* iov at bp+0 */ [2]Tiovec _, _, _, _ = cnt, v1, v3, v4 - *(*[2]Tiovec)(unsafe.Pointer(bp)) = [2]Tiovec{ + **(**[2]Tiovec)(__ccgo_up(bp)) = [2]Tiovec{ 0: { Fiov_base: buf, Fiov_len: len1 - BoolUint32(!!((*TFILE)(unsafe.Pointer(f)).Fbuf_size != 0)), @@ -136792,10 +136792,10 @@ func X__stdio_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { Fiov_len: (*TFILE)(unsafe.Pointer(f)).Fbuf_size, }, } - if (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len != 0 { + if (**(**[2]Tiovec)(__ccgo_up(bp)))[0].Fiov_len != 0 { v1 = X__syscall_ret(tls, Uint32FromInt32(X__syscall3(tls, int32(SYS_readv), (*TFILE)(unsafe.Pointer(f)).Ffd, int32(bp), int32(Int32FromInt32(2))))) } else { - v1 = X__syscall_ret(tls, Uint32FromInt32(X__syscall3(tls, int32(SYS_read), (*TFILE)(unsafe.Pointer(f)).Ffd, int32((*(*[2]Tiovec)(unsafe.Pointer(bp)))[int32(1)].Fiov_base), Int32FromUint32((*(*[2]Tiovec)(unsafe.Pointer(bp)))[int32(1)].Fiov_len)))) + v1 = X__syscall_ret(tls, Uint32FromInt32(X__syscall3(tls, int32(SYS_read), (*TFILE)(unsafe.Pointer(f)).Ffd, int32((**(**[2]Tiovec)(__ccgo_up(bp)))[int32(1)].Fiov_base), Int32FromUint32((**(**[2]Tiovec)(__ccgo_up(bp)))[int32(1)].Fiov_len)))) } cnt = v1 if cnt <= 0 { @@ -136804,20 +136804,20 @@ func X__stdio_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { } else { v1 = int32(F_EOF) } - *(*uint32)(unsafe.Pointer(f)) |= Uint32FromInt32(v1) + **(**uint32)(__ccgo_up(f)) |= Uint32FromInt32(v1) return uint32(0) } - if Uint32FromInt32(cnt) <= (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len { + if Uint32FromInt32(cnt) <= (**(**[2]Tiovec)(__ccgo_up(bp)))[0].Fiov_len { return Uint32FromInt32(cnt) } - cnt = Int32FromUint32(uint32(cnt) - (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len) + cnt = Int32FromUint32(uint32(cnt) - (**(**[2]Tiovec)(__ccgo_up(bp)))[0].Fiov_len) (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(cnt) if (*TFILE)(unsafe.Pointer(f)).Fbuf_size != 0 { v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(buf + uintptr(len1-uint32(1)))) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(buf + uintptr(len1-uint32(1)))) = **(**uint8)(__ccgo_up(v3)) } return len1 } @@ -136844,7 +136844,7 @@ func X__stdio_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) var v5 uint32 var _ /* iovs at bp+0 */ [2]Tiovec _, _, _, _, _, _, _ = cnt, iov, iovcnt, rem, v2, v3, v5 - *(*[2]Tiovec)(unsafe.Pointer(bp)) = [2]Tiovec{ + **(**[2]Tiovec)(__ccgo_up(bp)) = [2]Tiovec{ 0: { Fiov_base: (*TFILE)(unsafe.Pointer(f)).Fwbase, Fiov_len: Uint32FromInt32(int32((*TFILE)(unsafe.Pointer(f)).Fwpos) - int32((*TFILE)(unsafe.Pointer(f)).Fwbase)), @@ -136855,7 +136855,7 @@ func X__stdio_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) }, } iov = bp - rem = (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len + (*(*Tiovec)(unsafe.Pointer(iov + 1*8))).Fiov_len + rem = (**(**Tiovec)(__ccgo_up(iov))).Fiov_len + (**(**Tiovec)(__ccgo_up(iov + 1*8))).Fiov_len iovcnt = int32(2) for { cnt = X__syscall_ret(tls, Uint32FromInt32(X__syscall3(tls, int32(SYS_writev), (*TFILE)(unsafe.Pointer(f)).Ffd, int32(iov), iovcnt))) @@ -136872,22 +136872,22 @@ func X__stdio_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) v2 = v3 (*TFILE)(unsafe.Pointer(f)).Fwbase = v2 (*TFILE)(unsafe.Pointer(f)).Fwpos = v2 - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) if iovcnt == int32(2) { v5 = uint32(0) } else { - v5 = len1 - (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len + v5 = len1 - (**(**Tiovec)(__ccgo_up(iov))).Fiov_len } return v5 } rem = rem - Uint32FromInt32(cnt) - if Uint32FromInt32(cnt) > (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len { - cnt = Int32FromUint32(uint32(cnt) - (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len) + if Uint32FromInt32(cnt) > (**(**Tiovec)(__ccgo_up(iov))).Fiov_len { + cnt = Int32FromUint32(uint32(cnt) - (**(**Tiovec)(__ccgo_up(iov))).Fiov_len) iov += 8 iovcnt = iovcnt - 1 } - (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_base = (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_base + uintptr(cnt) - (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len -= Uint32FromInt32(cnt) + (**(**Tiovec)(__ccgo_up(iov))).Fiov_base = (**(**Tiovec)(__ccgo_up(iov))).Fiov_base + uintptr(cnt) + (**(**Tiovec)(__ccgo_up(iov))).Fiov_len -= Uint32FromInt32(cnt) goto _1 _1: } @@ -136917,7 +136917,7 @@ func X__toread(tls *TLS, f uintptr) (r int32) { var v1, v2 uintptr var v4 int32 _, _, _ = v1, v2, v4 - *(*int32)(unsafe.Pointer(f + 72)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) + **(**int32)(__ccgo_up(f + 72)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwbase { (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fwrite})))(tls, f, uintptr(0), uint32(0)) } @@ -136927,7 +136927,7 @@ func X__toread(tls *TLS, f uintptr) (r int32) { (*TFILE)(unsafe.Pointer(f)).Fwbase = v1 (*TFILE)(unsafe.Pointer(f)).Fwpos = v1 if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_NORD) != 0 { - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) return -int32(1) } v1 = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr((*TFILE)(unsafe.Pointer(f)).Fbuf_size) @@ -136955,9 +136955,9 @@ func X__towrite(tls *TLS, f uintptr) (r int32) { } var v1 uintptr _ = v1 - *(*int32)(unsafe.Pointer(f + 72)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) + **(**int32)(__ccgo_up(f + 72)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_NOWR) != 0 { - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) return -int32(1) } /* Clear read buffer (easier than summoning nasal demons) */ @@ -136991,7 +136991,7 @@ func X__uflow(tls *TLS, f uintptr) (r int32) { defer tls.Free(16) var _ /* c at bp+0 */ uint8 if !(X__toread(tls, f) != 0) && (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fread})))(tls, f, bp, uint32(1)) == uint32(1) { - return Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) + return Int32FromUint8(**(**uint8)(__ccgo_up(bp))) } return -int32(1) } @@ -137022,7 +137022,7 @@ func Xclearerr(tls *TLS, f uintptr) { v1 = 0 } __need_unlock = v1 - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^(Int32FromInt32(F_EOF) | Int32FromInt32(F_ERR))) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^(Int32FromInt32(F_EOF) | Int32FromInt32(F_ERR))) if __need_unlock != 0 { ___unlockfile(tls, f) } @@ -137183,7 +137183,7 @@ func X__freadptr(tls *TLS, f uintptr, sizep uintptr) (r uintptr) { if (*TFILE)(unsafe.Pointer(f)).Frpos == (*TFILE)(unsafe.Pointer(f)).Frend { return uintptr(0) } - *(*Tsize_t)(unsafe.Pointer(sizep)) = Uint32FromInt32(int32((*TFILE)(unsafe.Pointer(f)).Frend) - int32((*TFILE)(unsafe.Pointer(f)).Frpos)) + **(**Tsize_t)(__ccgo_up(sizep)) = Uint32FromInt32(int32((*TFILE)(unsafe.Pointer(f)).Frend) - int32((*TFILE)(unsafe.Pointer(f)).Frpos)) return (*TFILE)(unsafe.Pointer(f)).Frpos } @@ -137191,14 +137191,14 @@ func X__freadptrinc(tls *TLS, f uintptr, inc Tsize_t) { if __ccgo_strace { trc("tls=%v f=%v inc=%v, (%v:)", tls, f, inc, origin(2)) } - *(*uintptr)(unsafe.Pointer(f + 4)) += uintptr(inc) + **(**uintptr)(__ccgo_up(f + 4)) += uintptr(inc) } func X__fseterr(tls *TLS, f uintptr) { if __ccgo_strace { trc("tls=%v f=%v, (%v:)", tls, f, origin(2)) } - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) } func _dummy10(tls *TLS, f uintptr) { @@ -137241,8 +137241,8 @@ func Xfclose(tls *TLS, f uintptr) (r1 int32) { if (*TFILE)(unsafe.Pointer(f)).Fnext != 0 { (*TFILE)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Fnext)).Fprev = (*TFILE)(unsafe.Pointer(f)).Fprev } - if *(*uintptr)(unsafe.Pointer(head)) == f { - *(*uintptr)(unsafe.Pointer(head)) = (*TFILE)(unsafe.Pointer(f)).Fnext + if **(**uintptr)(__ccgo_up(head)) == f { + **(**uintptr)(__ccgo_up(head)) = (*TFILE)(unsafe.Pointer(f)).Fnext } X__ofl_unlock(tls) Xfree(tls, (*TFILE)(unsafe.Pointer(f)).Fgetln_buf) @@ -137343,7 +137343,7 @@ func Xfflush(tls *TLS, f uintptr) (r1 int32) { if AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stderr_used))) != 0 { r = r | Xfflush(tls, AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stderr_used)))) } - f = *(*uintptr)(unsafe.Pointer(X__ofl_lock(tls))) + f = **(**uintptr)(__ccgo_up(X__ofl_lock(tls))) for { if !(f != 0) { break @@ -137422,7 +137422,7 @@ func _locking_getc(tls *TLS, f uintptr) (r int32) { v3 = f + 4 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__uflow(tls, f) } @@ -137457,7 +137457,7 @@ func Xfgetc(tls *TLS, f1 uintptr) (r int32) { v6 = v1 + 4 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(v5))) } else { v4 = X__uflow(tls, v1) } @@ -137493,7 +137493,7 @@ func Xfgetln(tls *TLS, f uintptr, plen uintptr) (r uintptr) { v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__uflow(tls, f) } @@ -137506,14 +137506,14 @@ func Xfgetln(tls *TLS, f uintptr, plen uintptr) (r uintptr) { ret = (*TFILE)(unsafe.Pointer(f)).Frpos z = z + 1 v3 = z - *(*Tsize_t)(unsafe.Pointer(plen)) = Uint32FromInt32(int32(v3) - int32(ret)) + **(**Tsize_t)(__ccgo_up(plen)) = Uint32FromInt32(int32(v3) - int32(ret)) (*TFILE)(unsafe.Pointer(f)).Frpos = z } else { *(*[1]Tsize_t)(unsafe.Pointer(bp)) = [1]Tsize_t{} v8 = Xgetline(tls, f+96, bp, f) l = v8 if v8 > 0 { - *(*Tsize_t)(unsafe.Pointer(plen)) = Uint32FromInt32(l) + **(**Tsize_t)(__ccgo_up(plen)) = Uint32FromInt32(l) ret = (*TFILE)(unsafe.Pointer(f)).Fgetln_buf } } @@ -137534,7 +137534,7 @@ func Xfgetpos(tls *TLS, f uintptr, pos uintptr) (r int32) { if off < 0 { return -int32(1) } - *(*int64)(unsafe.Pointer(pos)) = off + **(**int64)(__ccgo_up(pos)) = off return 0 } @@ -137557,14 +137557,14 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { } __need_unlock = v1 if n <= int32(1) { - *(*int32)(unsafe.Pointer(f + 72)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) + **(**int32)(__ccgo_up(f + 72)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) if __need_unlock != 0 { ___unlockfile(tls, f) } if n < int32(1) { return uintptr(0) } - *(*int8)(unsafe.Pointer(s)) = 0 + **(**int8)(__ccgo_up(s)) = 0 return s } n = n - 1 @@ -137584,7 +137584,7 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { } k = v3 Xmemcpy(tls, p, (*TFILE)(unsafe.Pointer(f)).Frpos, k) - *(*uintptr)(unsafe.Pointer(f + 4)) += uintptr(k) + **(**uintptr)(__ccgo_up(f + 4)) += uintptr(k) p = p + uintptr(k) n = Int32FromUint32(uint32(n) - k) if z != 0 || !(n != 0) { @@ -137595,7 +137595,7 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { v7 = f + 4 v6 = *(*uintptr)(unsafe.Pointer(v7)) *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v6))) } else { v2 = X__uflow(tls, f) } @@ -137611,13 +137611,13 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { v8 = int8(c) v6 = p p = p + 1 - *(*int8)(unsafe.Pointer(v6)) = v8 + **(**int8)(__ccgo_up(v6)) = v8 if int32(v8) == int32('\n') { break } } if s != 0 { - *(*int8)(unsafe.Pointer(p)) = 0 + **(**int8)(__ccgo_up(p)) = 0 } if __need_unlock != 0 { ___unlockfile(tls, f) @@ -137647,43 +137647,43 @@ func ___fgetwc_unlocked_internal(tls *TLS, f uintptr) (r Twint_t) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { l = Uint32FromInt32(Xmbtowc(tls, bp, (*TFILE)(unsafe.Pointer(f)).Frpos, Uint32FromInt32(int32((*TFILE)(unsafe.Pointer(f)).Frend)-int32((*TFILE)(unsafe.Pointer(f)).Frpos)))) if l+uint32(1) >= uint32(1) { - *(*uintptr)(unsafe.Pointer(f + 4)) += uintptr(l + BoolUint32(!(l != 0))) /* l==0 means 1 byte, null */ - return Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))) + **(**uintptr)(__ccgo_up(f + 4)) += uintptr(l + BoolUint32(!(l != 0))) /* l==0 means 1 byte, null */ + return Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))) } } /* Convert character byte-by-byte */ - *(*Tmbstate_t)(unsafe.Pointer(bp + 8)) = Tmbstate_t{} + **(**Tmbstate_t)(__ccgo_up(bp + 8)) = Tmbstate_t{} first = int32(1) for cond := true; cond; cond = l == Uint32FromInt32(-Int32FromInt32(2)) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__uflow(tls, f) } v1 = v2 c = v1 - *(*uint8)(unsafe.Pointer(bp + 16)) = Uint8FromInt32(v1) + **(**uint8)(__ccgo_up(bp + 16)) = Uint8FromInt32(v1) if c < 0 { if !(first != 0) { - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EILSEQ) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EILSEQ) } return uint32(0xffffffff) } l = Xmbrtowc(tls, bp, bp+16, uint32(1), bp+8) if l == Uint32FromInt32(-Int32FromInt32(1)) { if !(first != 0) { - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) - Xungetc(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + 16))), f) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) + Xungetc(tls, Int32FromUint8(**(**uint8)(__ccgo_up(bp + 16))), f) } return uint32(0xffffffff) } first = 0 } - return Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))) + return Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))) } func X__fgetwc_unlocked(tls *TLS, f uintptr) (r Twint_t) { @@ -137696,13 +137696,13 @@ func X__fgetwc_unlocked(tls *TLS, f uintptr) (r Twint_t) { var wc Twchar_t _, _, _ = loc, ploc, wc ploc = uintptr(___get_tp(tls)) + 96 - loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) + loc = **(**Tlocale_t)(__ccgo_up(ploc)) if (*TFILE)(unsafe.Pointer(f)).Fmode <= 0 { Xfwide(tls, f, int32(1)) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale + **(**Tlocale_t)(__ccgo_up(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale wc = Int32FromUint32(___fgetwc_unlocked_internal(tls, f)) - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return Uint32FromInt32(wc) } @@ -137774,7 +137774,7 @@ func Xfgetws(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { } v4 = p p += 4 - *(*Twchar_t)(unsafe.Pointer(v4)) = Int32FromUint32(c) + **(**Twchar_t)(__ccgo_up(v4)) = Int32FromUint32(c) if c == uint32('\n') { break } @@ -137783,7 +137783,7 @@ func Xfgetws(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { ; n = n - 1 } - *(*Twchar_t)(unsafe.Pointer(p)) = 0 + **(**Twchar_t)(__ccgo_up(p)) = 0 if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_ERR) != 0 { p = s } @@ -137824,7 +137824,7 @@ func Xfileno(tls *TLS, f uintptr) (r int32) { ___unlockfile(tls, f) } if fd < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EBADF) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EBADF) return -int32(1) } return fd @@ -137877,7 +137877,7 @@ func _mseek(tls *TLS, f uintptr, off Toff_t, whence int32) (r Toff_t) { goto fail fail: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) _1: ; @@ -137885,7 +137885,7 @@ _1: 1: (*Tcookie)(unsafe.Pointer(c)).Fpos, 2: (*Tcookie)(unsafe.Pointer(c)).Flen1, } - base = Int32FromUint32(*(*Tsize_t)(unsafe.Pointer(bp + uintptr(whence)*4))) + base = Int32FromUint32(**(**Tsize_t)(__ccgo_up(bp + uintptr(whence)*4))) if off < int64(-base) || off > int64(Int32FromUint32((*Tcookie)(unsafe.Pointer(c)).Fsize)-base) { goto fail } @@ -137905,10 +137905,10 @@ func _mread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { } if len1 > rem { len1 = rem - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_EOF) + **(**uint32)(__ccgo_up(f)) |= uint32(F_EOF) } Xmemcpy(tls, buf, (*Tcookie)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie)(unsafe.Pointer(c)).Fpos), len1) - *(*Tsize_t)(unsafe.Pointer(c)) += len1 + **(**Tsize_t)(__ccgo_up(c)) += len1 rem = rem - len1 if rem > (*TFILE)(unsafe.Pointer(f)).Fbuf_size { rem = (*TFILE)(unsafe.Pointer(f)).Fbuf_size @@ -137916,7 +137916,7 @@ func _mread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(rem) Xmemcpy(tls, (*TFILE)(unsafe.Pointer(f)).Frpos, (*Tcookie)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie)(unsafe.Pointer(c)).Fpos), rem) - *(*Tsize_t)(unsafe.Pointer(c)) += rem + **(**Tsize_t)(__ccgo_up(c)) += rem return len1 } @@ -137940,14 +137940,14 @@ func _mwrite(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { len1 = rem } Xmemcpy(tls, (*Tcookie)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie)(unsafe.Pointer(c)).Fpos), buf, len1) - *(*Tsize_t)(unsafe.Pointer(c)) += len1 + **(**Tsize_t)(__ccgo_up(c)) += len1 if (*Tcookie)(unsafe.Pointer(c)).Fpos > (*Tcookie)(unsafe.Pointer(c)).Flen1 { (*Tcookie)(unsafe.Pointer(c)).Flen1 = (*Tcookie)(unsafe.Pointer(c)).Fpos if (*Tcookie)(unsafe.Pointer(c)).Flen1 < (*Tcookie)(unsafe.Pointer(c)).Fsize { - *(*uint8)(unsafe.Pointer((*Tcookie)(unsafe.Pointer(c)).Fbuf + uintptr((*Tcookie)(unsafe.Pointer(c)).Flen1))) = uint8(0) + **(**uint8)(__ccgo_up((*Tcookie)(unsafe.Pointer(c)).Fbuf + uintptr((*Tcookie)(unsafe.Pointer(c)).Flen1))) = uint8(0) } else { if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_NORD) != 0 && (*Tcookie)(unsafe.Pointer(c)).Fsize != 0 { - *(*uint8)(unsafe.Pointer((*Tcookie)(unsafe.Pointer(c)).Fbuf + uintptr((*Tcookie)(unsafe.Pointer(c)).Fsize-uint32(1)))) = uint8(0) + **(**uint8)(__ccgo_up((*Tcookie)(unsafe.Pointer(c)).Fbuf + uintptr((*Tcookie)(unsafe.Pointer(c)).Fsize-uint32(1)))) = uint8(0) } } } @@ -137969,12 +137969,12 @@ func Xfmemopen(tls *TLS, buf uintptr, size Tsize_t, mode uintptr) (r uintptr) { var v3 Tsize_t _, _, _, _, _ = f, plus, v1, v2, v3 plus = BoolInt32(!!(Xstrchr(tls, mode, int32('+')) != 0)) - if !(Xstrchr(tls, __ccgo_ts+1402, int32(*(*int8)(unsafe.Pointer(mode)))) != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if !(Xstrchr(tls, __ccgo_ts+1402, int32(**(**int8)(__ccgo_up(mode)))) != 0) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } if !(buf != 0) && size > Uint32FromInt32(Int32FromInt32(INT32_MAX)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return uintptr(0) } if buf != 0 { @@ -137998,25 +137998,25 @@ func Xfmemopen(tls *TLS, buf uintptr, size Tsize_t, mode uintptr) (r uintptr) { } (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fbuf = buf (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fsize = size - (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fmode = int32(*(*int8)(unsafe.Pointer(mode))) + (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fmode = int32(**(**int8)(__ccgo_up(mode))) if !(plus != 0) { - if int32(*(*int8)(unsafe.Pointer(mode))) == int32('r') { + if int32(**(**int8)(__ccgo_up(mode))) == int32('r') { v2 = int32(F_NOWR) } else { v2 = int32(F_NORD) } (*Tmem_FILE)(unsafe.Pointer(f)).Ff.Fflags = Uint32FromInt32(v2) } - if int32(*(*int8)(unsafe.Pointer(mode))) == int32('r') { + if int32(**(**int8)(__ccgo_up(mode))) == int32('r') { (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Flen1 = size } else { - if int32(*(*int8)(unsafe.Pointer(mode))) == int32('a') { + if int32(**(**int8)(__ccgo_up(mode))) == int32('a') { v3 = Xstrnlen(tls, buf, size) (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fpos = v3 (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Flen1 = v3 } else { if plus != 0 { - *(*uint8)(unsafe.Pointer((*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fbuf)) = uint8(0) + **(**uint8)(__ccgo_up((*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fbuf)) = uint8(0) } } } @@ -138039,8 +138039,8 @@ func Xfopen(tls *TLS, filename uintptr, mode uintptr) (r uintptr) { var fd, flags int32 _, _, _ = f, fd, flags /* Check for valid initial mode character */ - if !(Xstrchr(tls, __ccgo_ts+1402, int32(*(*int8)(unsafe.Pointer(mode)))) != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if !(Xstrchr(tls, __ccgo_ts+1402, int32(**(**int8)(__ccgo_up(mode)))) != 0) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } /* Compute the flags to pass to open() */ @@ -138107,7 +138107,7 @@ func _cookieread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { v3 = f + 4 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - *(*uint8)(unsafe.Pointer(buf + uintptr(v1))) = *(*uint8)(unsafe.Pointer(v2)) + **(**uint8)(__ccgo_up(buf + uintptr(v1))) = **(**uint8)(__ccgo_up(v2)) return readlen goto bail bail: @@ -138117,7 +138117,7 @@ bail: } else { v4 = int32(F_ERR) } - *(*uint32)(unsafe.Pointer(f)) |= Uint32FromInt32(v4) + **(**uint32)(__ccgo_up(f)) |= Uint32FromInt32(v4) v2 = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = v2 (*TFILE)(unsafe.Pointer(f)).Frpos = v2 @@ -138147,7 +138147,7 @@ func _cookiewrite(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { v1 = v2 (*TFILE)(unsafe.Pointer(f)).Fwbase = v1 (*TFILE)(unsafe.Pointer(f)).Fwpos = v1 - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) return uint32(0) } return Uint32FromInt32(ret) @@ -138162,18 +138162,18 @@ func _cookieseek(tls *TLS, f uintptr, _off Toff_t, whence int32) (r Toff_t) { _, _ = fc, res fc = (*TFILE)(unsafe.Pointer(f)).Fcookie if Uint32FromInt32(whence) > uint32(2) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) } if !((*Tfcookie)(unsafe.Pointer(fc)).Fiofuncs.Fseek != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOPNOTSUPP) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOPNOTSUPP) return int64(-int32(1)) } res = (*(*func(*TLS, uintptr, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{(*Tfcookie)(unsafe.Pointer(fc)).Fiofuncs.Fseek})))(tls, (*Tfcookie)(unsafe.Pointer(fc)).Fcookie, bp, whence) if res < 0 { return int64(res) } - return *(*Toff_t)(unsafe.Pointer(bp)) + return **(**Toff_t)(__ccgo_up(bp)) } func _cookieclose(tls *TLS, f uintptr) (r int32) { @@ -138195,8 +138195,8 @@ func Xfopencookie(tls *TLS, cookie uintptr, mode uintptr, iofuncs Tcookie_io_fun var v2 int32 _, _, _ = f, v1, v2 /* Check for valid initial mode character */ - if !(Xstrchr(tls, __ccgo_ts+1402, int32(*(*int8)(unsafe.Pointer(mode)))) != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if !(Xstrchr(tls, __ccgo_ts+1402, int32(**(**int8)(__ccgo_up(mode)))) != 0) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } /* Allocate FILE+fcookie+buffer or fail */ @@ -138209,7 +138209,7 @@ func Xfopencookie(tls *TLS, cookie uintptr, mode uintptr, iofuncs Tcookie_io_fun Xmemset(tls, f, 0, uint32(136)) /* Impose mode restrictions */ if !(Xstrchr(tls, mode, int32('+')) != 0) { - if int32(*(*int8)(unsafe.Pointer(mode))) == int32('r') { + if int32(**(**int8)(__ccgo_up(mode))) == int32('r') { v2 = int32(F_NOWR) } else { v2 = int32(F_NORD) @@ -138260,7 +138260,7 @@ func _locking_putc(tls *TLS, c int32, f uintptr) (r int32) { v4 = f + 20 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(v3)) = v2 + **(**uint8)(__ccgo_up(v3)) = v2 v1 = Int32FromUint8(v2) } else { v1 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) @@ -138299,7 +138299,7 @@ func Xfputc(tls *TLS, c1 int32, f1 uintptr) (r int32) { v8 = v2 + 20 v7 = *(*uintptr)(unsafe.Pointer(v8)) *(*uintptr)(unsafe.Pointer(v8)) = *(*uintptr)(unsafe.Pointer(v8)) + 1 - *(*uint8)(unsafe.Pointer(v7)) = v6 + **(**uint8)(__ccgo_up(v7)) = v6 v5 = Int32FromUint8(v6) } else { v5 = X__overflow(tls, v2, Int32FromUint8(Uint8FromInt32(v1))) @@ -138346,18 +138346,18 @@ func X__fputwc_unlocked(tls *TLS, c Twchar_t, f uintptr) (r Twint_t) { var _ /* mbc at bp+0 */ [4]int8 _, _, _, _, _, _, _ = l, loc, ploc, v1, v2, v3, v4 ploc = uintptr(___get_tp(tls)) + 96 - loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) + loc = **(**Tlocale_t)(__ccgo_up(ploc)) if (*TFILE)(unsafe.Pointer(f)).Fmode <= 0 { Xfwide(tls, f, int32(1)) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale + **(**Tlocale_t)(__ccgo_up(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale if BoolInt32(Uint32FromInt32(c) < uint32(128)) != 0 { if Int32FromUint8(Uint8FromInt32(c)) != (*TFILE)(unsafe.Pointer(f)).Flbf && (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwend { v2 = Uint8FromInt32(c) v4 = f + 20 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(v3)) = v2 + **(**uint8)(__ccgo_up(v3)) = v2 v1 = Int32FromUint8(v2) } else { v1 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) @@ -138369,7 +138369,7 @@ func X__fputwc_unlocked(tls *TLS, c Twchar_t, f uintptr) (r Twint_t) { if l < 0 { c = Int32FromUint32(0xffffffff) } else { - *(*uintptr)(unsafe.Pointer(f + 20)) += uintptr(l) + **(**uintptr)(__ccgo_up(f + 20)) += uintptr(l) } } else { l = Xwctomb(tls, bp, c) @@ -138379,9 +138379,9 @@ func X__fputwc_unlocked(tls *TLS, c Twchar_t, f uintptr) (r Twint_t) { } } if Uint32FromInt32(c) == uint32(0xffffffff) { - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return Uint32FromInt32(c) } @@ -138438,7 +138438,7 @@ func Xfputws(tls *TLS, _ws uintptr, f uintptr) (r int32) { _, _, _, _, _, _, _ = __need_unlock, l, loc, ploc, v1, v2, v3 l = uint32(0) ploc = uintptr(___get_tp(tls)) + 96 - loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) + loc = **(**Tlocale_t)(__ccgo_up(ploc)) if AtomicLoadPInt32(f+76) >= 0 { v1 = ___lockfile(tls, f) } else { @@ -138446,9 +138446,9 @@ func Xfputws(tls *TLS, _ws uintptr, f uintptr) (r int32) { } __need_unlock = v1 Xfwide(tls, f, int32(1)) - *(*Tlocale_t)(unsafe.Pointer(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale + **(**Tlocale_t)(__ccgo_up(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale for { - if v3 = *(*uintptr)(unsafe.Pointer(bp)) != 0; v3 { + if v3 = **(**uintptr)(__ccgo_up(bp)) != 0; v3 { v2 = Xwcsrtombs(tls, bp+4, bp, uint32(1024), uintptr(0)) l = v2 } @@ -138459,14 +138459,14 @@ func Xfputws(tls *TLS, _ws uintptr, f uintptr) (r int32) { if __need_unlock != 0 { ___unlockfile(tls, f) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return -int32(1) } } if __need_unlock != 0 { ___unlockfile(tls, f) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return Int32FromUint32(l) /* 0 or -1 */ } @@ -138500,7 +138500,7 @@ func Xfread(tls *TLS, destv uintptr, size Tsize_t, nmemb Tsize_t, f uintptr) (r v1 = 0 } __need_unlock = v1 - *(*int32)(unsafe.Pointer(f + 72)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) + **(**int32)(__ccgo_up(f + 72)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { /* First exhaust the buffer. */ if Uint32FromInt32(int32((*TFILE)(unsafe.Pointer(f)).Frend)-int32((*TFILE)(unsafe.Pointer(f)).Frpos)) < l { @@ -138510,7 +138510,7 @@ func Xfread(tls *TLS, destv uintptr, size Tsize_t, nmemb Tsize_t, f uintptr) (r } k = v2 Xmemcpy(tls, dest, (*TFILE)(unsafe.Pointer(f)).Frpos, k) - *(*uintptr)(unsafe.Pointer(f + 4)) += uintptr(k) + **(**uintptr)(__ccgo_up(f + 4)) += uintptr(k) dest = dest + uintptr(k) l = l - k } @@ -138650,7 +138650,7 @@ func X__fseeko_unlocked(tls *TLS, f uintptr, off Toff_t, whence int32) (r int32) _, _ = v1, v2 /* Fail immediately for invalid whence argument. */ if whence != int32(1) && whence != 0 && whence != int32(2) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } /* Adjust relative offset for unread data in buffer, if any. */ @@ -138678,7 +138678,7 @@ func X__fseeko_unlocked(tls *TLS, f uintptr, off Toff_t, whence int32) (r int32) v1 = UintptrFromInt32(0) (*TFILE)(unsafe.Pointer(f)).Frend = v1 (*TFILE)(unsafe.Pointer(f)).Frpos = v1 - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) return 0 } @@ -138723,7 +138723,7 @@ func Xfsetpos(tls *TLS, f uintptr, pos uintptr) (r int32) { trc("tls=%v f=%v pos=%v, (%v:)", tls, f, pos, origin(2)) defer func() { trc("-> %v", r) }() } - return X__fseeko(tls, f, *(*int64)(unsafe.Pointer(pos)), 0) + return X__fseeko(tls, f, **(**int64)(__ccgo_up(pos)), 0) } /* Support signed or unsigned plain-char */ @@ -138793,7 +138793,7 @@ func Xftell(tls *TLS, f uintptr) (r int32) { _ = pos pos = X__ftello(tls, f) if pos > int64(0x7fffffff) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return -int32(1) } return int32(pos) @@ -138914,7 +138914,7 @@ func Xfwide(tls *TLS, f uintptr, mode int32) (r int32) { __need_unlock = v1 if mode != 0 { if !((*TFILE)(unsafe.Pointer(f)).Flocale != 0) { - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v3 = int32(4) } else { v3 = int32(1) @@ -138974,7 +138974,7 @@ func X__fwritex(tls *TLS, s uintptr, l Tsize_t, f uintptr) (r Tsize_t) { /* Match /^(.*\n|)/ */ i = l for { - if !(i != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(i-uint32(1))))) != int32('\n')) { + if !(i != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(i-uint32(1))))) != int32('\n')) { break } goto _1 @@ -138992,7 +138992,7 @@ func X__fwritex(tls *TLS, s uintptr, l Tsize_t, f uintptr) (r Tsize_t) { } } Xmemcpy(tls, (*TFILE)(unsafe.Pointer(f)).Fwpos, s, l) - *(*uintptr)(unsafe.Pointer(f + 20)) += uintptr(l) + **(**uintptr)(__ccgo_up(f + 20)) += uintptr(l) return l + i } @@ -139068,7 +139068,7 @@ func _locking_getc1(tls *TLS, f uintptr) (r int32) { v3 = f + 4 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__uflow(tls, f) } @@ -139103,7 +139103,7 @@ func Xgetc(tls *TLS, f1 uintptr) (r int32) { v6 = v1 + 4 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(v5))) } else { v4 = X__uflow(tls, v1) } @@ -139136,7 +139136,7 @@ func Xgetc_unlocked(tls *TLS, f uintptr) (r int32) { v3 = f + 4 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__uflow(tls, f) } @@ -139170,7 +139170,7 @@ func _locking_getc2(tls *TLS, f uintptr) (r int32) { v3 = f + 4 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__uflow(tls, f) } @@ -139205,7 +139205,7 @@ func Xgetchar(tls *TLS) (r int32) { v6 = v1 + 4 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(v5))) } else { v4 = X__uflow(tls, v1) } @@ -139230,7 +139230,7 @@ func Xgetchar_unlocked(tls *TLS) (r int32) { v3 = uintptr(unsafe.Pointer(&X__stdin_FILE)) + 4 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__uflow(tls, uintptr(unsafe.Pointer(&X__stdin_FILE))) } @@ -139255,16 +139255,16 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize } __need_unlock = v1 if !(n != 0) || !(s != 0) { - *(*int32)(unsafe.Pointer(f + 72)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**int32)(__ccgo_up(f + 72)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) if __need_unlock != 0 { ___unlockfile(tls, f) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } - if !(*(*uintptr)(unsafe.Pointer(s)) != 0) { - *(*Tsize_t)(unsafe.Pointer(n)) = uint32(0) + if !(**(**uintptr)(__ccgo_up(s)) != 0) { + **(**Tsize_t)(__ccgo_up(n)) = uint32(0) } for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { @@ -139279,36 +139279,36 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize z = uintptr(0) k = uint32(0) } - if i+k >= *(*Tsize_t)(unsafe.Pointer(n)) { + if i+k >= **(**Tsize_t)(__ccgo_up(n)) { m = i + k + uint32(2) if !(z != 0) && m < Uint32FromUint32(0xffffffff)/Uint32FromInt32(4) { m = m + m/uint32(2) } - tmp = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(s)), m) + tmp = Xrealloc(tls, **(**uintptr)(__ccgo_up(s)), m) if !(tmp != 0) { m = i + k + uint32(2) - tmp = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(s)), m) + tmp = Xrealloc(tls, **(**uintptr)(__ccgo_up(s)), m) if !(tmp != 0) { /* Copy as much as fits and ensure no * pushback remains in the FILE buf. */ - k = *(*Tsize_t)(unsafe.Pointer(n)) - i - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(s))+uintptr(i), (*TFILE)(unsafe.Pointer(f)).Frpos, k) - *(*uintptr)(unsafe.Pointer(f + 4)) += uintptr(k) - *(*int32)(unsafe.Pointer(f + 72)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + k = **(**Tsize_t)(__ccgo_up(n)) - i + Xmemcpy(tls, **(**uintptr)(__ccgo_up(s))+uintptr(i), (*TFILE)(unsafe.Pointer(f)).Frpos, k) + **(**uintptr)(__ccgo_up(f + 4)) += uintptr(k) + **(**int32)(__ccgo_up(f + 72)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) if __need_unlock != 0 { ___unlockfile(tls, f) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return -int32(1) } } - *(*uintptr)(unsafe.Pointer(s)) = tmp - *(*Tsize_t)(unsafe.Pointer(n)) = m + **(**uintptr)(__ccgo_up(s)) = tmp + **(**Tsize_t)(__ccgo_up(n)) = m } if k != 0 { - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(s))+uintptr(i), (*TFILE)(unsafe.Pointer(f)).Frpos, k) - *(*uintptr)(unsafe.Pointer(f + 4)) += uintptr(k) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(s))+uintptr(i), (*TFILE)(unsafe.Pointer(f)).Frpos, k) + **(**uintptr)(__ccgo_up(f + 4)) += uintptr(k) i = i + k } if z != 0 { @@ -139318,7 +139318,7 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize v7 = f + 4 v6 = *(*uintptr)(unsafe.Pointer(v7)) *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v6))) } else { v3 = X__uflow(tls, f) } @@ -139335,16 +139335,16 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize } /* If the byte read by getc won't fit without growing the * output buffer, push it back for next iteration. */ - if i+uint32(1) >= *(*Tsize_t)(unsafe.Pointer(n)) { + if i+uint32(1) >= **(**Tsize_t)(__ccgo_up(n)) { v7 = f + 4 *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) - 1 v6 = *(*uintptr)(unsafe.Pointer(v7)) - *(*uint8)(unsafe.Pointer(v6)) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(v6)) = Uint8FromInt32(c) } else { v10 = int8(c) v11 = i i = i + 1 - *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)) + uintptr(v11))) = v10 + **(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)) + uintptr(v11))) = v10 if int32(v10) == delim { break } @@ -139352,7 +139352,7 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize goto _2 _2: } - *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)) + uintptr(i))) = 0 + **(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)) + uintptr(i))) = 0 if __need_unlock != 0 { ___unlockfile(tls, f) } @@ -139396,7 +139396,7 @@ func Xgets(tls *TLS, s uintptr) (r uintptr) { v5 = uintptr(unsafe.Pointer(&X__stdin_FILE)) + 4 v4 = *(*uintptr)(unsafe.Pointer(v5)) *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v4))) } else { v3 = X__uflow(tls, uintptr(unsafe.Pointer(&X__stdin_FILE))) } @@ -139407,9 +139407,9 @@ func Xgets(tls *TLS, s uintptr) (r uintptr) { } v6 = i i = i + 1 - *(*int8)(unsafe.Pointer(s + uintptr(v6))) = int8(c) + **(**int8)(__ccgo_up(s + uintptr(v6))) = int8(c) } - *(*int8)(unsafe.Pointer(s + uintptr(i))) = 0 + **(**int8)(__ccgo_up(s + uintptr(i))) = 0 if c != int32('\n') && (!((*TFILE)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stdin_FILE)))).Fflags&Uint32FromInt32(F_EOF) != 0) || !(i != 0)) { s = uintptr(0) } @@ -139430,7 +139430,7 @@ func Xgetw(tls *TLS, f uintptr) (r int32) { var _ /* x at bp+0 */ int32 _ = v1 if Xfread(tls, bp, uint32(4), uint32(1), f) != 0 { - v1 = *(*int32)(unsafe.Pointer(bp)) + v1 = **(**int32)(__ccgo_up(bp)) } else { v1 = -int32(1) } @@ -139488,11 +139488,11 @@ func X__ofl_add(tls *TLS, f uintptr) (r uintptr) { var head uintptr _ = head head = X__ofl_lock(tls) - (*TFILE)(unsafe.Pointer(f)).Fnext = *(*uintptr)(unsafe.Pointer(head)) - if *(*uintptr)(unsafe.Pointer(head)) != 0 { - (*TFILE)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(head)))).Fprev = f + (*TFILE)(unsafe.Pointer(f)).Fnext = **(**uintptr)(__ccgo_up(head)) + if **(**uintptr)(__ccgo_up(head)) != 0 { + (*TFILE)(unsafe.Pointer(**(**uintptr)(__ccgo_up(head)))).Fprev = f } - *(*uintptr)(unsafe.Pointer(head)) = f + **(**uintptr)(__ccgo_up(head)) = f X__ofl_unlock(tls) return f } @@ -139526,7 +139526,7 @@ func _ms_seek(tls *TLS, f uintptr, off Toff_t, whence int32) (r Toff_t) { goto fail fail: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) _1: ; @@ -139534,7 +139534,7 @@ _1: 1: (*Tcookie1)(unsafe.Pointer(c)).Fpos, 2: (*Tcookie1)(unsafe.Pointer(c)).Flen1, } - base = Int32FromUint32(*(*Tsize_t)(unsafe.Pointer(bp + uintptr(whence)*4))) + base = Int32FromUint32(**(**Tsize_t)(__ccgo_up(bp + uintptr(whence)*4))) if off < int64(-base) || off > int64(int32(0x7fffffff)-base) { goto fail } @@ -139563,16 +139563,16 @@ func _ms_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { } v1 = newbuf (*Tcookie1)(unsafe.Pointer(c)).Fbuf = v1 - *(*uintptr)(unsafe.Pointer((*Tcookie1)(unsafe.Pointer(c)).Fbufp)) = v1 + **(**uintptr)(__ccgo_up((*Tcookie1)(unsafe.Pointer(c)).Fbufp)) = v1 Xmemset(tls, (*Tcookie1)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie1)(unsafe.Pointer(c)).Fspace), 0, len2-(*Tcookie1)(unsafe.Pointer(c)).Fspace) (*Tcookie1)(unsafe.Pointer(c)).Fspace = len2 } Xmemcpy(tls, (*Tcookie1)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie1)(unsafe.Pointer(c)).Fpos), buf, len1) - *(*Tsize_t)(unsafe.Pointer(c + 8)) += len1 + **(**Tsize_t)(__ccgo_up(c + 8)) += len1 if (*Tcookie1)(unsafe.Pointer(c)).Fpos >= (*Tcookie1)(unsafe.Pointer(c)).Flen1 { (*Tcookie1)(unsafe.Pointer(c)).Flen1 = (*Tcookie1)(unsafe.Pointer(c)).Fpos } - *(*Tsize_t)(unsafe.Pointer((*Tcookie1)(unsafe.Pointer(c)).Fsizep)) = (*Tcookie1)(unsafe.Pointer(c)).Fpos + **(**Tsize_t)(__ccgo_up((*Tcookie1)(unsafe.Pointer(c)).Fsizep)) = (*Tcookie1)(unsafe.Pointer(c)).Fpos return len1 } @@ -139605,16 +139605,16 @@ func Xopen_memstream(tls *TLS, bufp uintptr, sizep uintptr) (r uintptr) { (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fbufp = bufp (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fsizep = sizep v5 = Uint32FromInt32(0) - *(*Tsize_t)(unsafe.Pointer(sizep)) = v5 + **(**Tsize_t)(__ccgo_up(sizep)) = v5 v4 = v5 (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fspace = v4 v3 = v4 (*Tms_FILE)(unsafe.Pointer(f)).Fc.Flen1 = v3 (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fpos = v3 v1 = buf - *(*uintptr)(unsafe.Pointer(bufp)) = v1 + **(**uintptr)(__ccgo_up(bufp)) = v1 (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fbuf = v1 - *(*int8)(unsafe.Pointer(buf)) = 0 + **(**int8)(__ccgo_up(buf)) = 0 (*Tms_FILE)(unsafe.Pointer(f)).Ff.Fflags = uint32(F_NORD) (*Tms_FILE)(unsafe.Pointer(f)).Ff.Ffd = -int32(1) (*Tms_FILE)(unsafe.Pointer(f)).Ff.Fbuf = f + 160 @@ -139660,7 +139660,7 @@ func _wms_seek(tls *TLS, f uintptr, off Toff_t, whence int32) (r Toff_t) { goto fail fail: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) _1: ; @@ -139668,7 +139668,7 @@ _1: 1: (*Tcookie2)(unsafe.Pointer(c)).Fpos, 2: (*Tcookie2)(unsafe.Pointer(c)).Flen1, } - base = Int32FromUint32(*(*Tsize_t)(unsafe.Pointer(bp + uintptr(whence)*4))) + base = Int32FromUint32(**(**Tsize_t)(__ccgo_up(bp + uintptr(whence)*4))) if off < int64(-base) || off > int64(Int32FromInt32(0x7fffffff)/Int32FromInt32(4)-base) { goto fail } @@ -139704,7 +139704,7 @@ func _wms_write(tls *TLS, f uintptr, _buf uintptr, len1 Tsize_t) (r Tsize_t) { } v1 = newbuf (*Tcookie2)(unsafe.Pointer(c)).Fbuf = v1 - *(*uintptr)(unsafe.Pointer((*Tcookie2)(unsafe.Pointer(c)).Fbufp)) = v1 + **(**uintptr)(__ccgo_up((*Tcookie2)(unsafe.Pointer(c)).Fbufp)) = v1 Xmemset(tls, (*Tcookie2)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie2)(unsafe.Pointer(c)).Fspace)*4, 0, uint32(4)*(len2-(*Tcookie2)(unsafe.Pointer(c)).Fspace)) (*Tcookie2)(unsafe.Pointer(c)).Fspace = len2 } @@ -139712,11 +139712,11 @@ func _wms_write(tls *TLS, f uintptr, _buf uintptr, len1 Tsize_t) (r Tsize_t) { if len2 == Uint32FromInt32(-Int32FromInt32(1)) { return uint32(0) } - *(*Tsize_t)(unsafe.Pointer(c + 8)) += len2 + **(**Tsize_t)(__ccgo_up(c + 8)) += len2 if (*Tcookie2)(unsafe.Pointer(c)).Fpos >= (*Tcookie2)(unsafe.Pointer(c)).Flen1 { (*Tcookie2)(unsafe.Pointer(c)).Flen1 = (*Tcookie2)(unsafe.Pointer(c)).Fpos } - *(*Tsize_t)(unsafe.Pointer((*Tcookie2)(unsafe.Pointer(c)).Fsizep)) = (*Tcookie2)(unsafe.Pointer(c)).Fpos + **(**Tsize_t)(__ccgo_up((*Tcookie2)(unsafe.Pointer(c)).Fsizep)) = (*Tcookie2)(unsafe.Pointer(c)).Fpos return len1 } @@ -139749,16 +139749,16 @@ func Xopen_wmemstream(tls *TLS, bufp uintptr, sizep uintptr) (r uintptr) { (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fbufp = bufp (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fsizep = sizep v5 = Uint32FromInt32(0) - *(*Tsize_t)(unsafe.Pointer(sizep)) = v5 + **(**Tsize_t)(__ccgo_up(sizep)) = v5 v4 = v5 (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fspace = v4 v3 = v4 (*Twms_FILE)(unsafe.Pointer(f)).Fc.Flen1 = v3 (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fpos = v3 v1 = buf - *(*uintptr)(unsafe.Pointer(bufp)) = v1 + **(**uintptr)(__ccgo_up(bufp)) = v1 (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fbuf = v1 - *(*Twchar_t)(unsafe.Pointer(buf)) = 0 + **(**Twchar_t)(__ccgo_up(buf)) = 0 (*Twms_FILE)(unsafe.Pointer(f)).Ff.Fflags = uint32(F_NORD) (*Twms_FILE)(unsafe.Pointer(f)).Ff.Ffd = -int32(1) (*Twms_FILE)(unsafe.Pointer(f)).Ff.Fbuf = f + 168 @@ -139797,7 +139797,7 @@ func Xpclose(tls *TLS, f uintptr) (r1 int32) { if r < 0 { return X__syscall_ret(tls, Uint32FromInt32(r)) } - return *(*int32)(unsafe.Pointer(bp)) + return **(**int32)(__ccgo_up(bp)) } func Xperror(tls *TLS, msg uintptr) { @@ -139808,7 +139808,7 @@ func Xperror(tls *TLS, msg uintptr) { var errstr, f, old_locale uintptr _, _, _, _, _, _ = __need_unlock, errstr, f, old_locale, old_mode, v1 f = uintptr(unsafe.Pointer(&X__stderr_FILE)) - errstr = Xstrerror(tls, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) + errstr = Xstrerror(tls, **(**int32)(__ccgo_up(X__errno_location(tls)))) if AtomicLoadPInt32(f+76) >= 0 { v1 = ___lockfile(tls, f) } else { @@ -139819,7 +139819,7 @@ func Xperror(tls *TLS, msg uintptr) { * permitted to change them. */ old_locale = (*TFILE)(unsafe.Pointer(f)).Flocale old_mode = (*TFILE)(unsafe.Pointer(f)).Fmode - if msg != 0 && *(*int8)(unsafe.Pointer(msg)) != 0 { + if msg != 0 && **(**int8)(__ccgo_up(msg)) != 0 { Xfwrite(tls, msg, _strlen(tls, msg), uint32(1), f) Xfputc(tls, int32(':'), f) Xfputc(tls, int32(' '), f) @@ -139860,7 +139860,7 @@ func _locking_putc1(tls *TLS, c int32, f uintptr) (r int32) { v4 = f + 20 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(v3)) = v2 + **(**uint8)(__ccgo_up(v3)) = v2 v1 = Int32FromUint8(v2) } else { v1 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) @@ -139899,7 +139899,7 @@ func Xputc(tls *TLS, c1 int32, f1 uintptr) (r int32) { v8 = v2 + 20 v7 = *(*uintptr)(unsafe.Pointer(v8)) *(*uintptr)(unsafe.Pointer(v8)) = *(*uintptr)(unsafe.Pointer(v8)) + 1 - *(*uint8)(unsafe.Pointer(v7)) = v6 + **(**uint8)(__ccgo_up(v7)) = v6 v5 = Int32FromUint8(v6) } else { v5 = X__overflow(tls, v2, Int32FromUint8(Uint8FromInt32(v1))) @@ -139935,7 +139935,7 @@ func Xputc_unlocked(tls *TLS, c int32, f uintptr) (r int32) { v4 = f + 20 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(v3)) = v2 + **(**uint8)(__ccgo_up(v3)) = v2 v1 = Int32FromUint8(v2) } else { v1 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) @@ -139972,7 +139972,7 @@ func _locking_putc2(tls *TLS, c int32, f uintptr) (r int32) { v4 = f + 20 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(v3)) = v2 + **(**uint8)(__ccgo_up(v3)) = v2 v1 = Int32FromUint8(v2) } else { v1 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) @@ -140011,7 +140011,7 @@ func Xputchar(tls *TLS, c1 int32) (r int32) { v8 = v2 + 20 v7 = *(*uintptr)(unsafe.Pointer(v8)) *(*uintptr)(unsafe.Pointer(v8)) = *(*uintptr)(unsafe.Pointer(v8)) + 1 - *(*uint8)(unsafe.Pointer(v7)) = v6 + **(**uint8)(__ccgo_up(v7)) = v6 v5 = Int32FromUint8(v6) } else { v5 = X__overflow(tls, v2, Int32FromUint8(Uint8FromInt32(v1))) @@ -140039,7 +140039,7 @@ func Xputchar_unlocked(tls *TLS, c int32) (r int32) { v4 = uintptr(unsafe.Pointer(&X__stdout_FILE)) + 20 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(v3)) = v2 + **(**uint8)(__ccgo_up(v3)) = v2 v1 = Int32FromUint8(v2) } else { v1 = X__overflow(tls, uintptr(unsafe.Pointer(&X__stdout_FILE)), Int32FromUint8(Uint8FromInt32(c))) @@ -140069,7 +140069,7 @@ func Xputs(tls *TLS, s uintptr) (r1 int32) { v5 = uintptr(unsafe.Pointer(&X__stdout_FILE)) + 20 v4 = *(*uintptr)(unsafe.Pointer(v5)) *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = v3 + **(**uint8)(__ccgo_up(v4)) = v3 v2 = Int32FromUint8(v3) } else { v2 = X__overflow(tls, uintptr(unsafe.Pointer(&X__stdout_FILE)), Int32FromUint8(Uint8FromInt32(Int32FromUint8('\n')))) @@ -140152,7 +140152,7 @@ func Xrewind(tls *TLS, f uintptr) { } __need_unlock = v1 X__fseeko_unlocked(tls, f, 0, 0) - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_ERR)) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^Int32FromInt32(F_ERR)) if __need_unlock != 0 { ___unlockfile(tls, f) } @@ -140242,7 +140242,7 @@ func Xsetvbuf(tls *TLS, f uintptr, buf uintptr, type1 int32, size Tsize_t) (r in return -int32(1) } } - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_SVB) + **(**uint32)(__ccgo_up(f)) |= uint32(F_SVB) return 0 } @@ -140382,14 +140382,14 @@ func Xtempnam(tls *TLS, dir uintptr, pfx uintptr) (r1 uintptr) { pl = _strlen(tls, pfx) l = dl + uint32(1) + pl + uint32(1) + uint32(6) if l >= uint32(PATH_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENAMETOOLONG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENAMETOOLONG) return uintptr(0) } Xmemcpy(tls, bp+1, dir, dl) - (*(*[4096]int8)(unsafe.Pointer(bp + 1)))[dl] = int8('/') + (**(**[4096]int8)(__ccgo_up(bp + 1)))[dl] = int8('/') Xmemcpy(tls, bp+1+uintptr(dl)+uintptr(1), pfx, pl) - (*(*[4096]int8)(unsafe.Pointer(bp + 1)))[dl+uint32(1)+pl] = int8('_') - (*(*[4096]int8)(unsafe.Pointer(bp + 1)))[l] = 0 + (**(**[4096]int8)(__ccgo_up(bp + 1)))[dl+uint32(1)+pl] = int8('_') + (**(**[4096]int8)(__ccgo_up(bp + 1)))[l] = 0 try = 0 for { if !(try < int32(MAXTRIES)) { @@ -140420,7 +140420,7 @@ func Xtmpfile(tls *TLS) (r uintptr) { var fd, try int32 var _ /* s at bp+0 */ [20]int8 _, _, _ = f, fd, try - *(*[20]int8)(unsafe.Pointer(bp)) = [20]int8{'/', 't', 'm', 'p', '/', 't', 'm', 'p', 'f', 'i', 'l', 'e', '_', 'X', 'X', 'X', 'X', 'X', 'X'} + **(**[20]int8)(__ccgo_up(bp)) = [20]int8{'/', 't', 'm', 'p', '/', 't', 'm', 'p', 'f', 'i', 'l', 'e', '_', 'X', 'X', 'X', 'X', 'X', 'X'} try = 0 for { if !(try < int32(MAXTRIES)) { @@ -140455,7 +140455,7 @@ func Xtmpnam(tls *TLS, buf uintptr) (r1 uintptr) { var v2 uintptr var _ /* s at bp+1 */ [19]int8 _, _, _ = r, try, v2 - *(*[19]int8)(unsafe.Pointer(bp + 1)) = [19]int8{'/', 't', 'm', 'p', '/', 't', 'm', 'p', 'n', 'a', 'm', '_', 'X', 'X', 'X', 'X', 'X', 'X'} + **(**[19]int8)(__ccgo_up(bp + 1)) = [19]int8{'/', 't', 'm', 'p', '/', 't', 'm', 'p', 'n', 'a', 'm', '_', 'X', 'X', 'X', 'X', 'X', 'X'} try = 0 for { if !(try < int32(MAXTRIES)) { @@ -140511,8 +140511,8 @@ func Xungetc(tls *TLS, c int32, f uintptr) (r int32) { v3 = f + 4 *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) - 1 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(c) - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) + **(**uint8)(__ccgo_up(v2)) = Uint8FromInt32(c) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) if __need_unlock != 0 { ___unlockfile(tls, f) } @@ -140533,7 +140533,7 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { var _ /* mbc at bp+0 */ [4]uint8 _, _, _, _, _, _, _, _ = __need_unlock, l, loc, ploc, v1, v3, v4, v5 ploc = uintptr(___get_tp(tls)) + 96 - loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) + loc = **(**Tlocale_t)(__ccgo_up(ploc)) if AtomicLoadPInt32(f+76) >= 0 { v1 = ___lockfile(tls, f) } else { @@ -140543,7 +140543,7 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { if (*TFILE)(unsafe.Pointer(f)).Fmode <= 0 { Xfwide(tls, f, int32(1)) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale + **(**Tlocale_t)(__ccgo_up(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale if !((*TFILE)(unsafe.Pointer(f)).Frpos != 0) { X__toread(tls, f) } @@ -140555,24 +140555,24 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { if __need_unlock != 0 { ___unlockfile(tls, f) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return uint32(0xffffffff) } if BoolInt32(c < uint32(128)) != 0 { v5 = f + 4 *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) - 1 v4 = *(*uintptr)(unsafe.Pointer(v5)) - *(*uint8)(unsafe.Pointer(v4)) = uint8(c) + **(**uint8)(__ccgo_up(v4)) = uint8(c) } else { v4 = f + 4 *(*uintptr)(unsafe.Pointer(v4)) -= uintptr(l) Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(v4)), bp, Uint32FromInt32(l)) } - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) if __need_unlock != 0 { ___unlockfile(tls, f) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return c } @@ -140591,12 +140591,12 @@ func Xvasprintf(tls *TLS, s uintptr, fmt uintptr, ap Tva_list) (r int32) { _ = ap2 if v2 = l < 0; !v2 { v1 = Xmalloc(tls, Uint32FromInt32(l)+uint32(1)) - *(*uintptr)(unsafe.Pointer(s)) = v1 + **(**uintptr)(__ccgo_up(s)) = v1 } if v2 || !(v1 != 0) { return -int32(1) } - return Xvsnprintf(tls, *(*uintptr)(unsafe.Pointer(s)), Uint32FromInt32(l)+uint32(1), fmt, ap) + return Xvsnprintf(tls, **(**uintptr)(__ccgo_up(s)), Uint32FromInt32(l)+uint32(1), fmt, ap) } func Xvdprintf(tls *TLS, fd int32, fmt uintptr, ap Tva_list) (r int32) { @@ -140607,7 +140607,7 @@ func Xvdprintf(tls *TLS, fd int32, fmt uintptr, ap Tva_list) (r int32) { bp := tls.Alloc(144) defer tls.Free(144) var _ /* f at bp+0 */ TFILE - *(*TFILE)(unsafe.Pointer(bp)) = TFILE{ + **(**TFILE)(__ccgo_up(bp)) = TFILE{ Fwrite: __ccgo_fp(X__stdio_write), Fbuf: fmt, Ffd: fd, @@ -140774,41 +140774,41 @@ type Targ = struct { func _pop_arg(tls *TLS, arg uintptr, type1 int32, ap uintptr) { switch type1 { case int32(_PTR): - *(*uintptr)(unsafe.Pointer(arg)) = VaUintptr(&*(*Tva_list)(unsafe.Pointer(ap))) + *(*uintptr)(unsafe.Pointer(arg)) = VaUintptr(&**(**Tva_list)(__ccgo_up(ap))) case int32(_INT): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_UINT): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint32(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint32(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_LONG): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_ULONG): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint32(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint32(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_ULLONG): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&**(**Tva_list)(__ccgo_up(ap))) case int32(_SHORT): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt16(int16(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt16(int16(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_USHORT): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint16FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint16FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_CHAR): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt8(int8(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt8(int8(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_UCHAR): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint8FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint8FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_LLONG): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_SIZET): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint32(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint32(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_IMAX): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_UMAX): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&**(**Tva_list)(__ccgo_up(ap))) case int32(_PDIFF): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_UIPTR): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(uint32(VaUintptr(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(uint32(VaUintptr(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_DBL): - *(*float64)(unsafe.Pointer(arg)) = float64(VaFloat64(&*(*Tva_list)(unsafe.Pointer(ap)))) + *(*float64)(unsafe.Pointer(arg)) = float64(VaFloat64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_LDBL): - *(*float64)(unsafe.Pointer(arg)) = VaFloat64(&*(*Tva_list)(unsafe.Pointer(ap))) + *(*float64)(unsafe.Pointer(arg)) = VaFloat64(&**(**Tva_list)(__ccgo_up(ap))) } } @@ -140858,7 +140858,7 @@ func _fmt_x(tls *TLS, x Tuintmax_t, s uintptr, lower int32) (r uintptr) { } s = s - 1 v2 = s - *(*int8)(unsafe.Pointer(v2)) = int8(int32(_xdigits1[x&uint64(15)]) | lower) + **(**int8)(__ccgo_up(v2)) = int8(int32(_xdigits1[x&uint64(15)]) | lower) goto _1 _1: ; @@ -140876,7 +140876,7 @@ func _fmt_o(tls *TLS, x Tuintmax_t, s uintptr) (r uintptr) { } s = s - 1 v2 = s - *(*int8)(unsafe.Pointer(v2)) = Int8FromUint64(uint64('0') + x&uint64(7)) + **(**int8)(__ccgo_up(v2)) = Int8FromUint64(uint64('0') + x&uint64(7)) goto _1 _1: ; @@ -140895,7 +140895,7 @@ func _fmt_u(tls *TLS, x Tuintmax_t, s uintptr) (r uintptr) { } s = s - 1 v2 = s - *(*int8)(unsafe.Pointer(v2)) = Int8FromUint64(uint64('0') + x%uint64(10)) + **(**int8)(__ccgo_up(v2)) = Int8FromUint64(uint64('0') + x%uint64(10)) goto _1 _1: ; @@ -140908,7 +140908,7 @@ func _fmt_u(tls *TLS, x Tuintmax_t, s uintptr) (r uintptr) { } s = s - 1 v2 = s - *(*int8)(unsafe.Pointer(v2)) = Int8FromUint32(uint32('0') + y%uint32(10)) + **(**int8)(__ccgo_up(v2)) = Int8FromUint32(uint32('0') + y%uint32(10)) goto _3 _3: ; @@ -140942,7 +140942,7 @@ func _fmt_fp(tls *TLS, f uintptr, y float64, w int32, p int32, fl int32, t int32 var _ /* e2 at bp+512 */ int32 var _ /* ebuf0 at bp+538 */ [12]int8 _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, b, carry, carry1, d, e, ebuf, estr, i, j, l, need, pl, prefix, r, re, rm, round, round1, s, s1, s2, s3, s4, sh, sh1, small, x, x1, x2, z, v1, v5, v6, v7, v8, v9 - *(*int32)(unsafe.Pointer(bp + 512)) = 0 + **(**int32)(__ccgo_up(bp + 512)) = 0 prefix = __ccgo_ts + 1419 ebuf = bp + 538 + uintptr(Uint32FromInt32(3)*Uint32FromInt64(4)) pl = int32(1) @@ -140996,7 +140996,7 @@ _4: } y = float64(Xfrexpl(tls, y, bp+512) * Float64FromInt32(2)) if y != 0 { - *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) - 1 + **(**int32)(__ccgo_up(bp + 512)) = **(**int32)(__ccgo_up(bp + 512)) - 1 } if t|int32(32) == int32('a') { round = Float64FromFloat64(8) @@ -141019,7 +141019,7 @@ _4: } round = round * Float64FromInt32(16) } - if int32(*(*int8)(unsafe.Pointer(prefix))) == int32('-') { + if int32(**(**int8)(__ccgo_up(prefix))) == int32('-') { y = -y y = y - round y = y + round @@ -141029,39 +141029,39 @@ _4: y = y - round } } - if *(*int32)(unsafe.Pointer(bp + 512)) < 0 { - v7 = -*(*int32)(unsafe.Pointer(bp + 512)) + if **(**int32)(__ccgo_up(bp + 512)) < 0 { + v7 = -**(**int32)(__ccgo_up(bp + 512)) } else { - v7 = *(*int32)(unsafe.Pointer(bp + 512)) + v7 = **(**int32)(__ccgo_up(bp + 512)) } estr = _fmt_u(tls, Uint64FromInt32(v7), ebuf) if estr == ebuf { estr = estr - 1 v5 = estr - *(*int8)(unsafe.Pointer(v5)) = int8('0') + **(**int8)(__ccgo_up(v5)) = int8('0') } estr = estr - 1 v5 = estr - if *(*int32)(unsafe.Pointer(bp + 512)) < 0 { + if **(**int32)(__ccgo_up(bp + 512)) < 0 { v7 = int32('-') } else { v7 = int32('+') } - *(*int8)(unsafe.Pointer(v5)) = int8(v7) + **(**int8)(__ccgo_up(v5)) = int8(v7) estr = estr - 1 v5 = estr - *(*int8)(unsafe.Pointer(v5)) = int8(t + (Int32FromUint8('p') - Int32FromUint8('a'))) + **(**int8)(__ccgo_up(v5)) = int8(t + (Int32FromUint8('p') - Int32FromUint8('a'))) s = bp + 516 for cond := true; cond; cond = y != 0 { x = int32(y) v5 = s s = s + 1 - *(*int8)(unsafe.Pointer(v5)) = int8(int32(_xdigits1[x]) | t&int32(32)) + **(**int8)(__ccgo_up(v5)) = int8(int32(_xdigits1[x]) | t&int32(32)) y = float64(Float64FromInt32(16) * (y - float64(x))) if int32(s)-t__predefined_ptrdiff_t(bp+516) == int32(1) && (y != 0 || p > 0 || Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0) { v5 = s s = s + 1 - *(*int8)(unsafe.Pointer(v5)) = int8('.') + **(**int8)(__ccgo_up(v5)) = int8('.') } } if p > Int32FromInt32(INT_MAX)-Int32FromInt32(2)-(int32(ebuf)-int32(estr))-pl { @@ -141091,9 +141091,9 @@ _4: } if y != 0 { y = y * Float64FromFloat64(2.68435456e+08) - *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) - int32(28) + **(**int32)(__ccgo_up(bp + 512)) = **(**int32)(__ccgo_up(bp + 512)) - int32(28) } - if *(*int32)(unsafe.Pointer(bp + 512)) < 0 { + if **(**int32)(__ccgo_up(bp + 512)) < 0 { v6 = bp + 8 z = v6 v5 = v6 @@ -141107,17 +141107,17 @@ _4: a = v5 } for cond := true; cond; cond = y != 0 { - *(*Tuint32_t)(unsafe.Pointer(z)) = uint32(y) + **(**Tuint32_t)(__ccgo_up(z)) = uint32(y) v5 = z z += 4 - y = float64(Float64FromInt32(1000000000) * (y - float64(*(*Tuint32_t)(unsafe.Pointer(v5))))) + y = float64(Float64FromInt32(1000000000) * (y - float64(**(**Tuint32_t)(__ccgo_up(v5))))) } - for *(*int32)(unsafe.Pointer(bp + 512)) > 0 { + for **(**int32)(__ccgo_up(bp + 512)) > 0 { carry = uint32(0) - if int32(29) < *(*int32)(unsafe.Pointer(bp + 512)) { + if int32(29) < **(**int32)(__ccgo_up(bp + 512)) { v7 = int32(29) } else { - v7 = *(*int32)(unsafe.Pointer(bp + 512)) + v7 = **(**int32)(__ccgo_up(bp + 512)) } sh = v7 d = z - uintptr(1)*4 @@ -141125,8 +141125,8 @@ _4: if !(d >= a) { break } - x1 = uint64(*(*Tuint32_t)(unsafe.Pointer(d)))< a && !(*(*Tuint32_t)(unsafe.Pointer(z + uintptr(-Int32FromInt32(1))*4)) != 0) { + for z > a && !(**(**Tuint32_t)(__ccgo_up(z + uintptr(-Int32FromInt32(1))*4)) != 0) { z -= 4 } - *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) - sh + **(**int32)(__ccgo_up(bp + 512)) = **(**int32)(__ccgo_up(bp + 512)) - sh } - for *(*int32)(unsafe.Pointer(bp + 512)) < 0 { + for **(**int32)(__ccgo_up(bp + 512)) < 0 { carry1 = uint32(0) - if int32(9) < -*(*int32)(unsafe.Pointer(bp + 512)) { + if int32(9) < -**(**int32)(__ccgo_up(bp + 512)) { v7 = int32(9) } else { - v7 = -*(*int32)(unsafe.Pointer(bp + 512)) + v7 = -**(**int32)(__ccgo_up(bp + 512)) } sh1 = v7 need = Int32FromUint32(uint32(1) + (Uint32FromInt32(p)+Uint32FromInt32(LDBL_MANT_DIG)/Uint32FromUint32(3)+uint32(8))/uint32(9)) @@ -141157,21 +141157,21 @@ _4: if !(d < z) { break } - rm = *(*Tuint32_t)(unsafe.Pointer(d)) & Uint32FromInt32(int32(1)<>sh1 + carry1 + rm = **(**Tuint32_t)(__ccgo_up(d)) & Uint32FromInt32(int32(1)<>sh1 + carry1 carry1 = Uint32FromInt32(Int32FromInt32(1000000000)>>sh1) * rm goto _26 _26: ; d += 4 } - if !(*(*Tuint32_t)(unsafe.Pointer(a)) != 0) { + if !(**(**Tuint32_t)(__ccgo_up(a)) != 0) { a += 4 } if carry1 != 0 { v5 = z z += 4 - *(*Tuint32_t)(unsafe.Pointer(v5)) = carry1 + **(**Tuint32_t)(__ccgo_up(v5)) = carry1 } /* Avoid (slow!) computation past requested precision */ if t|int32(32) == int32('f') { @@ -141183,13 +141183,13 @@ _4: if (int32(z)-int32(b))/4 > need { z = b + uintptr(need)*4 } - *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) + sh1 + **(**int32)(__ccgo_up(bp + 512)) = **(**int32)(__ccgo_up(bp + 512)) + sh1 } if a < z { i = int32(10) e = Int32FromInt32(9) * ((int32(r) - int32(a)) / 4) for { - if !(*(*Tuint32_t)(unsafe.Pointer(a)) >= Uint32FromInt32(i)) { + if !(**(**Tuint32_t)(__ccgo_up(a)) >= Uint32FromInt32(i)) { break } goto _29 @@ -141220,11 +141220,11 @@ _4: i = i * int32(10) j = j + 1 } - x2 = *(*Tuint32_t)(unsafe.Pointer(d)) % Uint32FromInt32(i) + x2 = **(**Tuint32_t)(__ccgo_up(d)) % Uint32FromInt32(i) /* Are there any significant digits past j? */ if x2 != 0 || d+uintptr(1)*4 != z { round1 = Float64FromInt32(2) / Float64FromFloat64(2.22044604925031308085e-16) - if *(*Tuint32_t)(unsafe.Pointer(d))/Uint32FromInt32(i)&uint32(1) != 0 || i == int32(1000000000) && d > a && *(*Tuint32_t)(unsafe.Pointer(d + uintptr(-Int32FromInt32(1))*4))&uint32(1) != 0 { + if **(**Tuint32_t)(__ccgo_up(d))/Uint32FromInt32(i)&uint32(1) != 0 || i == int32(1000000000) && d > a && **(**Tuint32_t)(__ccgo_up(d + uintptr(-Int32FromInt32(1))*4))&uint32(1) != 0 { round1 = round1 + Float64FromInt32(2) } if x2 < Uint32FromInt32(i/int32(2)) { @@ -141236,29 +141236,29 @@ _4: small = Float64FromFloat64(1.5) } } - if pl != 0 && int32(*(*int8)(unsafe.Pointer(prefix))) == int32('-') { + if pl != 0 && int32(**(**int8)(__ccgo_up(prefix))) == int32('-') { round1 = round1 * float64(-Int32FromInt32(1)) small = small * float64(-Int32FromInt32(1)) } - *(*Tuint32_t)(unsafe.Pointer(d)) -= x2 + **(**Tuint32_t)(__ccgo_up(d)) -= x2 /* Decide whether to round by probing round+small */ if round1+small != round1 { - *(*Tuint32_t)(unsafe.Pointer(d)) = *(*Tuint32_t)(unsafe.Pointer(d)) + Uint32FromInt32(i) - for *(*Tuint32_t)(unsafe.Pointer(d)) > uint32(999999999) { + **(**Tuint32_t)(__ccgo_up(d)) = **(**Tuint32_t)(__ccgo_up(d)) + Uint32FromInt32(i) + for **(**Tuint32_t)(__ccgo_up(d)) > uint32(999999999) { v5 = d d -= 4 - *(*Tuint32_t)(unsafe.Pointer(v5)) = uint32(0) + **(**Tuint32_t)(__ccgo_up(v5)) = uint32(0) if d < a { a -= 4 v5 = a - *(*Tuint32_t)(unsafe.Pointer(v5)) = uint32(0) + **(**Tuint32_t)(__ccgo_up(v5)) = uint32(0) } - *(*Tuint32_t)(unsafe.Pointer(d)) = *(*Tuint32_t)(unsafe.Pointer(d)) + 1 + **(**Tuint32_t)(__ccgo_up(d)) = **(**Tuint32_t)(__ccgo_up(d)) + 1 } i = int32(10) e = Int32FromInt32(9) * ((int32(r) - int32(a)) / 4) for { - if !(*(*Tuint32_t)(unsafe.Pointer(a)) >= Uint32FromInt32(i)) { + if !(**(**Tuint32_t)(__ccgo_up(a)) >= Uint32FromInt32(i)) { break } goto _33 @@ -141274,7 +141274,7 @@ _4: } } for { - if !(z > a && !(*(*Tuint32_t)(unsafe.Pointer(z + uintptr(-Int32FromInt32(1))*4)) != 0)) { + if !(z > a && !(**(**Tuint32_t)(__ccgo_up(z + uintptr(-Int32FromInt32(1))*4)) != 0)) { break } goto _34 @@ -141295,11 +141295,11 @@ _4: } if !(Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0) { /* Count trailing zeros in last place */ - if z > a && *(*Tuint32_t)(unsafe.Pointer(z + uintptr(-Int32FromInt32(1))*4)) != 0 { + if z > a && **(**Tuint32_t)(__ccgo_up(z + uintptr(-Int32FromInt32(1))*4)) != 0 { i = int32(10) j = Int32FromInt32(0) for { - if !(*(*Tuint32_t)(unsafe.Pointer(z + uintptr(-Int32FromInt32(1))*4))%Uint32FromInt32(i) == uint32(0)) { + if !(**(**Tuint32_t)(__ccgo_up(z + uintptr(-Int32FromInt32(1))*4))%Uint32FromInt32(i) == uint32(0)) { break } goto _35 @@ -141369,7 +141369,7 @@ _4: for int32(ebuf)-int32(estr) < int32(2) { estr = estr - 1 v5 = estr - *(*int8)(unsafe.Pointer(v5)) = int8('0') + **(**int8)(__ccgo_up(v5)) = int8('0') } estr = estr - 1 v5 = estr @@ -141378,10 +141378,10 @@ _4: } else { v7 = int32('+') } - *(*int8)(unsafe.Pointer(v5)) = int8(v7) + **(**int8)(__ccgo_up(v5)) = int8(v7) estr = estr - 1 v5 = estr - *(*int8)(unsafe.Pointer(v5)) = int8(t) + **(**int8)(__ccgo_up(v5)) = int8(t) if int32(ebuf)-int32(estr) > int32(INT_MAX)-l { return -int32(1) } @@ -141402,18 +141402,18 @@ _4: if !(d <= r) { break } - s2 = _fmt_u(tls, uint64(*(*Tuint32_t)(unsafe.Pointer(d))), bp+516+uintptr(9)) + s2 = _fmt_u(tls, uint64(**(**Tuint32_t)(__ccgo_up(d))), bp+516+uintptr(9)) if d != a { for s2 > bp+516 { s2 = s2 - 1 v5 = s2 - *(*int8)(unsafe.Pointer(v5)) = int8('0') + **(**int8)(__ccgo_up(v5)) = int8('0') } } else { if s2 == bp+516+uintptr(9) { s2 = s2 - 1 v5 = s2 - *(*int8)(unsafe.Pointer(v5)) = int8('0') + **(**int8)(__ccgo_up(v5)) = int8('0') } } _out(tls, f, s2, Uint32FromInt32(int32(bp+516+uintptr(9))-int32(s2))) @@ -141429,11 +141429,11 @@ _4: if !(d < z && p > 0) { break } - s3 = _fmt_u(tls, uint64(*(*Tuint32_t)(unsafe.Pointer(d))), bp+516+uintptr(9)) + s3 = _fmt_u(tls, uint64(**(**Tuint32_t)(__ccgo_up(d))), bp+516+uintptr(9)) for s3 > bp+516 { s3 = s3 - 1 v5 = s3 - *(*int8)(unsafe.Pointer(v5)) = int8('0') + **(**int8)(__ccgo_up(v5)) = int8('0') } if int32(9) < p { v7 = int32(9) @@ -141457,17 +141457,17 @@ _4: if !(d < z && p >= 0) { break } - s4 = _fmt_u(tls, uint64(*(*Tuint32_t)(unsafe.Pointer(d))), bp+516+uintptr(9)) + s4 = _fmt_u(tls, uint64(**(**Tuint32_t)(__ccgo_up(d))), bp+516+uintptr(9)) if s4 == bp+516+uintptr(9) { s4 = s4 - 1 v5 = s4 - *(*int8)(unsafe.Pointer(v5)) = int8('0') + **(**int8)(__ccgo_up(v5)) = int8('0') } if d != a { for s4 > bp+516 { s4 = s4 - 1 v5 = s4 - *(*int8)(unsafe.Pointer(v5)) = int8('0') + **(**int8)(__ccgo_up(v5)) = int8('0') } } else { v5 = s4 @@ -141506,18 +141506,18 @@ func _getint(tls *TLS, s uintptr) (r int32) { _ = i i = 0 for { - if !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-uint32('0') < uint32(10)) != 0) { break } - if Uint32FromInt32(i) > Uint32FromInt32(INT_MAX)/Uint32FromUint32(10) || int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-int32('0') > int32(INT_MAX)-int32(10)*i { + if Uint32FromInt32(i) > Uint32FromInt32(INT_MAX)/Uint32FromUint32(10) || int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-int32('0') > int32(INT_MAX)-int32(10)*i { i = -int32(1) } else { - i = int32(10)*i + (int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s))))) - int32('0')) + i = int32(10)*i + (int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(s))))) - int32('0')) } goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s)) = *(*uintptr)(unsafe.Pointer(s)) + 1 + **(**uintptr)(__ccgo_up(s)) = **(**uintptr)(__ccgo_up(s)) + 1 } return i } @@ -141536,7 +141536,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, var _ /* s at bp+0 */ uintptr var _ /* wc at bp+40 */ [2]Twchar_t _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argpos, cnt, fl, i, l, l10n, p, pl, prefix, ps, st, t, w, ws, xp, z, v31, v45, v5, v6, v8 - *(*uintptr)(unsafe.Pointer(bp)) = fmt + **(**uintptr)(__ccgo_up(bp)) = fmt l10n = uint32(0) cnt = 0 l = 0 @@ -141549,30 +141549,30 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } /* Update output count, end loop when fmt is exhausted */ cnt = cnt + l - if !(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) != 0) { + if !(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))) != 0) { break } /* Handle literal text and %% format specifiers */ - a = *(*uintptr)(unsafe.Pointer(bp)) + a = **(**uintptr)(__ccgo_up(bp)) for { - if !(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) != 0 && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32('%')) { + if !(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))) != 0 && int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) != int32('%')) { break } goto _2 _2: ; - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 } - z = *(*uintptr)(unsafe.Pointer(bp)) + z = **(**uintptr)(__ccgo_up(bp)) for { - if !(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('%') && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1))) == int32('%')) { + if !(int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) == int32('%') && int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1))) == int32('%')) { break } goto _3 _3: ; z = z + 1 - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(2) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + uintptr(2) } if int32(z)-int32(a) > int32(INT_MAX)-cnt { goto overflow @@ -141584,46 +141584,46 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if l != 0 { goto _1 } - if BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))-uint32('0') < uint32(10)) != 0 && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2))) == int32('$') { + if BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1)))-uint32('0') < uint32(10)) != 0 && int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 2))) == int32('$') { l10n = uint32(1) - argpos = int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1))) - int32('0') - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(3) + argpos = int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1))) - int32('0') + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + uintptr(3) } else { argpos = -int32(1) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 } /* Read modifier flags */ fl = uint32(0) for { - if !(Uint32FromInt8(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-uint32(' ') < uint32(32) && (Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('0')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('\'')-Int32FromUint8(' ')))&(uint32(1)<<(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-int32(' '))) != 0) { + if !(Uint32FromInt8(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))))-uint32(' ') < uint32(32) && (Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('0')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('\'')-Int32FromUint8(' ')))&(uint32(1)<<(int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))))-int32(' '))) != 0) { break } - fl = fl | uint32(1)<<(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-int32(' ')) + fl = fl | uint32(1)<<(int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))))-int32(' ')) goto _4 _4: ; - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 } /* Read field width */ - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('*') { - if BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))-uint32('0') < uint32(10)) != 0 && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2))) == int32('$') { + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) == int32('*') { + if BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1)))-uint32('0') < uint32(10)) != 0 && int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 2))) == int32('$') { l10n = uint32(1) if !(f != 0) { - *(*int32)(unsafe.Pointer(nl_type + uintptr(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))-int32('0'))*4)) = int32(_INT) + **(**int32)(__ccgo_up(nl_type + uintptr(int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1)))-int32('0'))*4)) = int32(_INT) w = Int32FromInt32(0) } else { - w = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))-int32('0'))*8))) + w = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1)))-int32('0'))*8))) } - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(3) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + uintptr(3) } else { if !(l10n != 0) { if f != 0 { - v5 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) + v5 = VaInt32(&**(**Tva_list)(__ccgo_up(ap))) } else { v5 = 0 } w = v5 - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 } else { goto inval } @@ -141640,32 +141640,32 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } } /* Read precision */ - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('.') && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1))) == int32('*') { - if BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2)))-uint32('0') < uint32(10)) != 0 && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 3))) == int32('$') { + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) == int32('.') && int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1))) == int32('*') { + if BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 2)))-uint32('0') < uint32(10)) != 0 && int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 3))) == int32('$') { if !(f != 0) { - *(*int32)(unsafe.Pointer(nl_type + uintptr(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2)))-int32('0'))*4)) = int32(_INT) + **(**int32)(__ccgo_up(nl_type + uintptr(int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 2)))-int32('0'))*4)) = int32(_INT) p = Int32FromInt32(0) } else { - p = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2)))-int32('0'))*8))) + p = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 2)))-int32('0'))*8))) } - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(4) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + uintptr(4) } else { if !(l10n != 0) { if f != 0 { - v5 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) + v5 = VaInt32(&**(**Tva_list)(__ccgo_up(ap))) } else { v5 = 0 } p = v5 - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(2) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + uintptr(2) } else { goto inval } } xp = BoolInt32(p >= 0) } else { - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('.') { - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) == int32('.') { + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 p = _getint(tls, bp) xp = int32(1) } else { @@ -141676,13 +141676,13 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, /* Format specifier state machine */ st = uint32(0) for cond := true; cond; cond = st-uint32(1) < uint32(_STOP) { - if Uint32FromInt8(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-uint32('A') > Uint32FromInt32(Int32FromUint8('z')-Int32FromUint8('A')) { + if Uint32FromInt8(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))))-uint32('A') > Uint32FromInt32(Int32FromUint8('z')-Int32FromUint8('A')) { goto inval } ps = st - v8 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - st = uint32(*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_states)) + uintptr(st)*58 + uintptr(int32(*(*int8)(unsafe.Pointer(v8)))-int32('A'))))) + v8 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + st = uint32(**(**uint8)(__ccgo_up(uintptr(unsafe.Pointer(&_states)) + uintptr(st)*58 + uintptr(int32(**(**int8)(__ccgo_up(v8)))-int32('A'))))) } if !(st != 0) { goto inval @@ -141695,9 +141695,9 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } else { if argpos >= 0 { if !(f != 0) { - *(*int32)(unsafe.Pointer(nl_type + uintptr(argpos)*4)) = Int32FromUint32(st) + **(**int32)(__ccgo_up(nl_type + uintptr(argpos)*4)) = Int32FromUint32(st) } else { - *(*Targ)(unsafe.Pointer(bp + 8)) = *(*Targ)(unsafe.Pointer(nl_arg + uintptr(argpos)*8)) + **(**Targ)(__ccgo_up(bp + 8)) = **(**Targ)(__ccgo_up(nl_arg + uintptr(argpos)*8)) } } else { if f != 0 { @@ -141717,7 +141717,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, z = bp + 16 + uintptr(24) prefix = __ccgo_ts + 1450 pl = 0 - t = int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + uintptr(-Int32FromInt32(1))))) + t = int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + uintptr(-Int32FromInt32(1))))) /* Transform ls,lc -> S,C */ if ps != 0 && t&int32(15) == int32(3) { t = t & ^Int32FromInt32(32) @@ -141775,19 +141775,19 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, ; switch ps { case uint32(_BARE): - *(*int32)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))))) = cnt + **(**int32)(__ccgo_up(*(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))))) = cnt case uint32(_LPRE): - *(*int32)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))))) = cnt + **(**int32)(__ccgo_up(*(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))))) = cnt case uint32(_LLPRE): - *(*int64)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))))) = int64(cnt) + **(**int64)(__ccgo_up(*(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))))) = int64(cnt) case uint32(_HPRE): - *(*uint16)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))))) = Uint16FromInt32(cnt) + **(**uint16)(__ccgo_up(*(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))))) = Uint16FromInt32(cnt) case uint32(_HHPRE): - *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))))) = Uint8FromInt32(cnt) + **(**uint8)(__ccgo_up(*(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))))) = Uint8FromInt32(cnt) case uint32(_ZTPRE): - *(*Tsize_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))))) = Uint32FromInt32(cnt) + **(**Tsize_t)(__ccgo_up(*(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))))) = Uint32FromInt32(cnt) case uint32(_JPRE): - *(*Tuintmax_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))))) = Uint64FromInt32(cnt) + **(**Tuintmax_t)(__ccgo_up(*(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))))) = Uint64FromInt32(cnt) break } goto _1 @@ -141873,7 +141873,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, p = v5 v8 = z - uintptr(v5) a = v8 - *(*int8)(unsafe.Pointer(v8)) = Int8FromUint64(*(*Tuintmax_t)(unsafe.Pointer(bp + 8))) + **(**int8)(__ccgo_up(v8)) = Int8FromUint64(*(*Tuintmax_t)(unsafe.Pointer(bp + 8))) fl = fl & ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) goto _30 _19: @@ -141881,14 +141881,14 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if !(int32(1) != 0) { goto _37 } - a = Xstrerror(tls, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) + a = Xstrerror(tls, **(**int32)(__ccgo_up(X__errno_location(tls)))) goto _38 _37: ; _18: ; - if *(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))) != 0 { - v8 = *(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))) + if *(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))) != 0 { + v8 = *(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))) } else { v8 = __ccgo_ts + 1460 } @@ -141901,7 +141901,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, v5 = p } z = a + uintptr(Xstrnlen(tls, a, Uint32FromInt32(v5))) - if p < 0 && *(*int8)(unsafe.Pointer(z)) != 0 { + if p < 0 && **(**int8)(__ccgo_up(z)) != 0 { goto overflow } p = int32(z) - int32(a) @@ -141912,21 +141912,21 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if !(*(*Tuintmax_t)(unsafe.Pointer(bp + 8)) != 0) { goto narrow_c } - (*(*[2]Twchar_t)(unsafe.Pointer(bp + 40)))[0] = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(bp + 8))) - (*(*[2]Twchar_t)(unsafe.Pointer(bp + 40)))[int32(1)] = 0 - *(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))) = bp + 40 + (**(**[2]Twchar_t)(__ccgo_up(bp + 40)))[0] = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(bp + 8))) + (**(**[2]Twchar_t)(__ccgo_up(bp + 40)))[int32(1)] = 0 + *(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))) = bp + 40 p = -int32(1) _21: ; - ws = *(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))) + ws = *(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))) v5 = Int32FromInt32(0) l = v5 i = Uint32FromInt32(v5) for { - if v45 = i < Uint32FromInt32(p) && *(*Twchar_t)(unsafe.Pointer(ws)) != 0; v45 { + if v45 = i < Uint32FromInt32(p) && **(**Twchar_t)(__ccgo_up(ws)) != 0; v45 { v8 = ws ws += 4 - v6 = Xwctomb(tls, bp+48, *(*Twchar_t)(unsafe.Pointer(v8))) + v6 = Xwctomb(tls, bp+48, **(**Twchar_t)(__ccgo_up(v8))) l = v6 } if !(v45 && v6 >= 0 && Uint32FromInt32(l) <= Uint32FromInt32(p)-i) { @@ -141945,13 +141945,13 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } p = Int32FromUint32(i) _pad3(tls, f, int8(' '), w, p, Int32FromUint32(fl)) - ws = *(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))) + ws = *(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))) i = uint32(0) for { - if v45 = i < 0+Uint32FromInt32(p) && *(*Twchar_t)(unsafe.Pointer(ws)) != 0; v45 { + if v45 = i < 0+Uint32FromInt32(p) && **(**Twchar_t)(__ccgo_up(ws)) != 0; v45 { v8 = ws ws += 4 - v5 = Xwctomb(tls, bp+48, *(*Twchar_t)(unsafe.Pointer(v8))) + v5 = Xwctomb(tls, bp+48, **(**Twchar_t)(__ccgo_up(v8))) l = v5 } if !(v45 && i+Uint32FromInt32(v5) <= Uint32FromInt32(p)) { @@ -142027,17 +142027,17 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } i = uint32(1) for { - if !(i <= uint32(NL_ARGMAX) && *(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)) != 0) { + if !(i <= uint32(NL_ARGMAX) && **(**int32)(__ccgo_up(nl_type + uintptr(i)*4)) != 0) { break } - _pop_arg(tls, nl_arg+uintptr(i)*8, *(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)), ap) + _pop_arg(tls, nl_arg+uintptr(i)*8, **(**int32)(__ccgo_up(nl_type + uintptr(i)*4)), ap) goto _51 _51: ; i = i + 1 } for { - if !(i <= uint32(NL_ARGMAX) && !(*(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)) != 0)) { + if !(i <= uint32(NL_ARGMAX) && !(**(**int32)(__ccgo_up(nl_type + uintptr(i)*4)) != 0)) { break } goto _52 @@ -142052,12 +142052,12 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto inval inval: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) goto overflow overflow: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return -int32(1) } @@ -142075,12 +142075,12 @@ func Xvfprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { var _ /* nl_arg at bp+44 */ [10]Targ var _ /* nl_type at bp+4 */ [10]int32 _, _, _, _, _, _, _ = __need_unlock, olderr, ret, saved_buf, v1, v2, v3 - *(*[10]int32)(unsafe.Pointer(bp + 4)) = [10]int32{} + **(**[10]int32)(__ccgo_up(bp + 4)) = [10]int32{} saved_buf = uintptr(0) /* the copy allows passing va_list* even if va_list is an array */ - *(*Tva_list)(unsafe.Pointer(bp)) = ap + **(**Tva_list)(__ccgo_up(bp)) = ap if _printf_core(tls, uintptr(0), fmt, bp, bp+44, bp+4) < 0 { - _ = *(*Tva_list)(unsafe.Pointer(bp)) + _ = **(**Tva_list)(__ccgo_up(bp)) return -int32(1) } if AtomicLoadPInt32(f+76) >= 0 { @@ -142090,7 +142090,7 @@ func Xvfprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } __need_unlock = v1 olderr = Int32FromUint32((*TFILE)(unsafe.Pointer(f)).Fflags & uint32(F_ERR)) - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_ERR)) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^Int32FromInt32(F_ERR)) if !((*TFILE)(unsafe.Pointer(f)).Fbuf_size != 0) { saved_buf = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Fbuf = bp + 124 @@ -142122,11 +142122,11 @@ func Xvfprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_ERR) != 0 { ret = -int32(1) } - *(*uint32)(unsafe.Pointer(f)) |= Uint32FromInt32(olderr) + **(**uint32)(__ccgo_up(f)) |= Uint32FromInt32(olderr) if __need_unlock != 0 { ___unlockfile(tls, f) } - _ = *(*Tva_list)(unsafe.Pointer(bp)) + _ = **(**Tva_list)(__ccgo_up(bp)) return ret } @@ -142143,15 +142143,15 @@ func _store_int(tls *TLS, dest uintptr, size int32, i uint64) { } switch size { case -int32(2): - *(*int8)(unsafe.Pointer(dest)) = Int8FromUint64(i) + **(**int8)(__ccgo_up(dest)) = Int8FromUint64(i) case -int32(1): - *(*int16)(unsafe.Pointer(dest)) = Int16FromUint64(i) + **(**int16)(__ccgo_up(dest)) = Int16FromUint64(i) case SIZE_def: - *(*int32)(unsafe.Pointer(dest)) = Int32FromUint64(i) + **(**int32)(__ccgo_up(dest)) = Int32FromUint64(i) case int32(SIZE_l): - *(*int32)(unsafe.Pointer(dest)) = Int32FromUint64(i) + **(**int32)(__ccgo_up(dest)) = Int32FromUint64(i) case int32(SIZE_ll): - *(*int64)(unsafe.Pointer(dest)) = Int64FromUint64(i) + **(**int64)(__ccgo_up(dest)) = Int64FromUint64(i) break } } @@ -142214,17 +142214,17 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } p = fmt for { - if !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if !(**(**uint8)(__ccgo_up(p)) != 0) { break } alloc = 0 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v3 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _5 _5: if v3 != 0 { for { - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) v6 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _8 _8: @@ -142239,7 +142239,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v11 = f + 4 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v1 = X__shgetc(tls, f) } @@ -142257,16 +142257,16 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { pos = pos + ((*TFILE)(unsafe.Pointer(f)).Fshcnt + int64(int32((*TFILE)(unsafe.Pointer(f)).Frpos)-int32((*TFILE)(unsafe.Pointer(f)).Fbuf))) goto _2 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32('%') || Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('%') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) != int32('%') || Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) == int32('%') { X__shlim(tls, f, int64(Int32FromInt32(0))) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('%') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('%') { p = p + 1 for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v11 = f + 4 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v3 = X__shgetc(tls, f) } @@ -142285,13 +142285,13 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v11 = f + 4 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v1 = X__shgetc(tls, f) } c = v1 } - if c != Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) { + if c != Int32FromUint8(**(**uint8)(__ccgo_up(p))) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } @@ -142304,12 +142304,12 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { goto _2 } p = p + 1 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('*') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('*') { dest = uintptr(0) p = p + 1 } else { - if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('$') { - dest = _arg_n(tls, ap, Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))-int32('0'))) + if BoolInt32(uint32(**(**uint8)(__ccgo_up(p)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) == int32('$') { + dest = _arg_n(tls, ap, Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(p)))-int32('0'))) p = p + uintptr(2) } else { dest = VaUintptr(&ap) @@ -142317,16 +142317,16 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } width = 0 for { - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p)))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(p)))-uint32('0') < uint32(10)) != 0) { break } - width = int32(10)*width + Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - int32('0') + width = int32(10)*width + Int32FromUint8(**(**uint8)(__ccgo_up(p))) - int32('0') goto _25 _25: ; p = p + 1 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('m') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('m') { wcs = uintptr(0) s = uintptr(0) alloc = BoolInt32(!!(dest != 0)) @@ -142337,16 +142337,16 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { size = SIZE_def v10 = p p = p + 1 - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(v10))) { case int32('h'): - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('h') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('h') { p = p + 1 size = -Int32FromInt32(2) } else { size = -int32(1) } case int32('l'): - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('l') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('l') { p = p + 1 size = Int32FromInt32(SIZE_ll) } else { @@ -142405,7 +142405,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { default: goto fmt_fail } - t = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + t = Int32FromUint8(**(**uint8)(__ccgo_up(p))) /* C or S */ if t&int32(0x2f) == int32(3) { t = t | int32(32) @@ -142429,7 +142429,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v11 = f + 4 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v1 = X__shgetc(tls, f) } @@ -142451,7 +142451,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v11 = f + 4 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v1 = X__shgetc(tls, f) } @@ -142508,58 +142508,58 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { ; if t == int32('c') || t == int32('s') { Xmemset(tls, bp+16, -int32(1), uint32(257)) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[0] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[0] = uint8(0) if t == int32('s') { - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\t')] = uint8(0) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\n')] = uint8(0) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\v')] = uint8(0) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\f')] = uint8(0) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\r')] = uint8(0) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8(' ')] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\t')] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\n')] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\v')] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\f')] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\r')] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8(' ')] = uint8(0) } } else { p = p + 1 v10 = p - if Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) == int32('^') { + if Int32FromUint8(**(**uint8)(__ccgo_up(v10))) == int32('^') { p = p + 1 invert = Int32FromInt32(1) } else { invert = 0 } Xmemset(tls, bp+16, invert, uint32(257)) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[0] = uint8(0) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') { + (**(**[257]uint8)(__ccgo_up(bp + 16)))[0] = uint8(0) + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('-') { p = p + 1 - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('-')] = Uint8FromInt32(Int32FromInt32(1) - invert) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('-')] = Uint8FromInt32(Int32FromInt32(1) - invert) } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32(']') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32(']') { p = p + 1 - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8(']')] = Uint8FromInt32(Int32FromInt32(1) - invert) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8(']')] = Uint8FromInt32(Int32FromInt32(1) - invert) } } for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32(']')) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(p))) != int32(']')) { break } - if !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if !(**(**uint8)(__ccgo_up(p)) != 0) { goto fmt_fail } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') && *(*uint8)(unsafe.Pointer(p + 1)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) != int32(']') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('-') && **(**uint8)(__ccgo_up(p + 1)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) != int32(']') { v10 = p p = p + 1 - c = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10 + uintptr(-Int32FromInt32(1))))) + c = Int32FromUint8(**(**uint8)(__ccgo_up(v10 + uintptr(-Int32FromInt32(1))))) for { - if !(c < Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))) { + if !(c < Int32FromUint8(**(**uint8)(__ccgo_up(p)))) { break } - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[int32(1)+c] = Uint8FromInt32(int32(1) - invert) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[int32(1)+c] = Uint8FromInt32(int32(1) - invert) goto _57 _57: ; c = c + 1 } } - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[int32(1)+Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))] = Uint8FromInt32(int32(1) - invert) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[int32(1)+Int32FromUint8(**(**uint8)(__ccgo_up(p)))] = Uint8FromInt32(int32(1) - invert) goto _56 _56: ; @@ -142584,19 +142584,19 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } else { wcs = dest } - *(*Tmbstate_t)(unsafe.Pointer(bp + 8)) = Tmbstate_t{} + **(**Tmbstate_t)(__ccgo_up(bp + 8)) = Tmbstate_t{} for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v11 = f + 4 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v3 = X__shgetc(tls, f) } v1 = v3 c = v1 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { + if !((**(**[257]uint8)(__ccgo_up(bp + 16)))[v1+int32(1)] != 0) { break } *(*int8)(unsafe.Pointer(bp)) = int8(c) @@ -142609,7 +142609,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if wcs != 0 { v64 = i i = i + 1 - *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(v64)*4)) = *(*Twchar_t)(unsafe.Pointer(bp + 276)) + **(**Twchar_t)(__ccgo_up(wcs + uintptr(v64)*4)) = **(**Twchar_t)(__ccgo_up(bp + 276)) } if alloc != 0 && i == k { k = k + (k + uint32(1)) @@ -142634,18 +142634,18 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v11 = f + 4 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v3 = X__shgetc(tls, f) } v1 = v3 c = v1 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { + if !((**(**[257]uint8)(__ccgo_up(bp + 16)))[v1+int32(1)] != 0) { break } v64 = i i = i + 1 - *(*int8)(unsafe.Pointer(s + uintptr(v64))) = int8(c) + **(**int8)(__ccgo_up(s + uintptr(v64))) = int8(c) if i == k { k = k + (k + uint32(1)) tmp1 = Xrealloc(tls, s, k) @@ -142664,18 +142664,18 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v17 = f + 4 v11 = *(*uintptr)(unsafe.Pointer(v17)) *(*uintptr)(unsafe.Pointer(v17)) = *(*uintptr)(unsafe.Pointer(v17)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v11))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v11))) } else { v3 = X__shgetc(tls, f) } v1 = v3 c = v1 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { + if !((**(**[257]uint8)(__ccgo_up(bp + 16)))[v1+int32(1)] != 0) { break } v64 = i i = i + 1 - *(*int8)(unsafe.Pointer(s + uintptr(v64))) = int8(c) + **(**int8)(__ccgo_up(s + uintptr(v64))) = int8(c) } } else { for { @@ -142683,13 +142683,13 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v11 = f + 4 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v3 = X__shgetc(tls, f) } v1 = v3 c = v1 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { + if !((**(**[257]uint8)(__ccgo_up(bp + 16)))[v1+int32(1)] != 0) { break } } @@ -142707,17 +142707,17 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } if alloc != 0 { if size == int32(SIZE_l) { - *(*uintptr)(unsafe.Pointer(dest)) = wcs + **(**uintptr)(__ccgo_up(dest)) = wcs } else { - *(*uintptr)(unsafe.Pointer(dest)) = s + **(**uintptr)(__ccgo_up(dest)) = s } } if t != int32('c') { if wcs != 0 { - *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) = 0 + **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) = 0 } if s != 0 { - *(*int8)(unsafe.Pointer(s + uintptr(i))) = 0 + **(**int8)(__ccgo_up(s + uintptr(i))) = 0 } } goto _54 @@ -142750,7 +142750,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { goto match_fail } if t == int32('p') && dest != 0 { - *(*uintptr)(unsafe.Pointer(dest)) = uintptr(uint32(x)) + **(**uintptr)(__ccgo_up(dest)) = uintptr(uint32(x)) } else { _store_int(tls, dest, size, x) } @@ -142778,11 +142778,11 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if dest != 0 { switch size { case SIZE_def: - *(*float32)(unsafe.Pointer(dest)) = float32(y) + **(**float32)(__ccgo_up(dest)) = float32(y) case int32(SIZE_l): - *(*float64)(unsafe.Pointer(dest)) = y + **(**float64)(__ccgo_up(dest)) = y case int32(SIZE_L): - *(*float64)(unsafe.Pointer(dest)) = y + **(**float64)(__ccgo_up(dest)) = y break } } @@ -142948,41 +142948,41 @@ var _states1 = [8][58]uint8{ func _pop_arg1(tls *TLS, arg uintptr, type1 int32, ap uintptr) { switch type1 { case int32(_PTR): - *(*uintptr)(unsafe.Pointer(arg)) = VaUintptr(&*(*Tva_list)(unsafe.Pointer(ap))) + *(*uintptr)(unsafe.Pointer(arg)) = VaUintptr(&**(**Tva_list)(__ccgo_up(ap))) case int32(_INT): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_UINT): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint32(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint32(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_LONG): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_ULONG): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint32(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint32(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_ULLONG): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&**(**Tva_list)(__ccgo_up(ap))) case int32(_SHORT): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt16(int16(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt16(int16(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_USHORT): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint16FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint16FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_CHAR): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt8(int8(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt8(int8(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_UCHAR): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint8FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint8FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_LLONG): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_SIZET): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint32(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint32(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_IMAX): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_UMAX): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&**(**Tva_list)(__ccgo_up(ap))) case int32(_PDIFF): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_UIPTR): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(uint32(VaUintptr(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(uint32(VaUintptr(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_DBL): - *(*float64)(unsafe.Pointer(arg)) = float64(VaFloat64(&*(*Tva_list)(unsafe.Pointer(ap)))) + *(*float64)(unsafe.Pointer(arg)) = float64(VaFloat64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_LDBL): - *(*float64)(unsafe.Pointer(arg)) = VaFloat64(&*(*Tva_list)(unsafe.Pointer(ap))) + *(*float64)(unsafe.Pointer(arg)) = VaFloat64(&**(**Tva_list)(__ccgo_up(ap))) } } @@ -142998,7 +142998,7 @@ func _out1(tls *TLS, f uintptr, s uintptr, l Tsize_t) { } v2 = s s += 4 - Xfputwc(tls, *(*Twchar_t)(unsafe.Pointer(v2)), f) + Xfputwc(tls, **(**Twchar_t)(__ccgo_up(v2)), f) } } @@ -143016,18 +143016,18 @@ func _getint1(tls *TLS, s uintptr) (r int32) { _ = i i = 0 for { - if !(BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-uint32('0') < uint32(10)) != 0) { break } - if Uint32FromInt32(i) > Uint32FromInt32(INT_MAX)/Uint32FromUint32(10) || *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s))))-int32('0') > int32(INT_MAX)-int32(10)*i { + if Uint32FromInt32(i) > Uint32FromInt32(INT_MAX)/Uint32FromUint32(10) || **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(s))))-int32('0') > int32(INT_MAX)-int32(10)*i { i = -int32(1) } else { - i = int32(10)*i + (*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))) - int32('0')) + i = int32(int32(10)*i + (**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))) - int32('0'))) } goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s)) += 4 + **(**uintptr)(__ccgo_up(s)) += 4 } return i } @@ -143058,7 +143058,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, var _ /* s at bp+4 */ uintptr var _ /* wc at bp+32 */ Twchar_t _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argpos, bs, cnt, fl, i, l, l10n, p, ps, st, t, w, xp, z, v15, v5, v6, v7, v8, v9 - *(*uintptr)(unsafe.Pointer(bp + 4)) = fmt + **(**uintptr)(__ccgo_up(bp + 4)) = fmt l10n = uint32(0) cnt = 0 l = 0 @@ -143071,30 +143071,30 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } /* Update output count, end loop when fmt is exhausted */ cnt = cnt + l - if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)))) != 0) { + if !(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4)))) != 0) { break } /* Handle literal text and %% format specifiers */ - a = *(*uintptr)(unsafe.Pointer(bp + 4)) + a = **(**uintptr)(__ccgo_up(bp + 4)) for { - if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)))) != 0 && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)))) != int32('%')) { + if !(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4)))) != 0 && **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4)))) != int32('%')) { break } goto _2 _2: ; - *(*uintptr)(unsafe.Pointer(bp + 4)) += 4 + **(**uintptr)(__ccgo_up(bp + 4)) += 4 } - z = *(*uintptr)(unsafe.Pointer(bp + 4)) + z = **(**uintptr)(__ccgo_up(bp + 4)) for { - if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)))) == int32('%') && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)) + 1*4)) == int32('%')) { + if !(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4)))) == int32('%') && **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4)) + 1*4)) == int32('%')) { break } goto _3 _3: ; z += 4 - *(*uintptr)(unsafe.Pointer(bp + 4)) = *(*uintptr)(unsafe.Pointer(bp + 4)) + uintptr(2)*4 + **(**uintptr)(__ccgo_up(bp + 4)) = **(**uintptr)(__ccgo_up(bp + 4)) + uintptr(2)*4 } if (int32(z)-int32(a))/4 > int32(INT_MAX)-cnt { goto overflow @@ -143106,42 +143106,42 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if l != 0 { goto _1 } - if BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)) + 1*4)))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)) + 2*4)) == int32('$') { + if BoolInt32(Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4)) + 1*4)))-uint32('0') < uint32(10)) != 0 && **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4)) + 2*4)) == int32('$') { l10n = uint32(1) - argpos = *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)) + 1*4)) - int32('0') - *(*uintptr)(unsafe.Pointer(bp + 4)) = *(*uintptr)(unsafe.Pointer(bp + 4)) + uintptr(3)*4 + argpos = int32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4)) + 1*4)) - int32('0')) + **(**uintptr)(__ccgo_up(bp + 4)) = **(**uintptr)(__ccgo_up(bp + 4)) + uintptr(3)*4 } else { argpos = -int32(1) - *(*uintptr)(unsafe.Pointer(bp + 4)) += 4 + **(**uintptr)(__ccgo_up(bp + 4)) += 4 } /* Read modifier flags */ fl = uint32(0) for { - if !(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)))))-uint32(' ') < uint32(32) && (Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('0')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('\'')-Int32FromUint8(' ')))&(uint32(1)<<(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4))))-int32(' '))) != 0) { + if !(Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4)))))-uint32(' ') < uint32(32) && (Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('0')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('\'')-Int32FromUint8(' ')))&(uint32(1)<<(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4))))-int32(' '))) != 0) { break } - fl = fl | uint32(1)<<(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4))))-int32(' ')) + fl = fl | uint32(1)<<(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4))))-int32(' ')) goto _4 _4: ; - *(*uintptr)(unsafe.Pointer(bp + 4)) += 4 + **(**uintptr)(__ccgo_up(bp + 4)) += 4 } /* Read field width */ - if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)))) == int32('*') { - if BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)) + 1*4)))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)) + 2*4)) == int32('$') { + if **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4)))) == int32('*') { + if BoolInt32(Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4)) + 1*4)))-uint32('0') < uint32(10)) != 0 && **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4)) + 2*4)) == int32('$') { l10n = uint32(1) - *(*int32)(unsafe.Pointer(nl_type + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)) + 1*4))-int32('0'))*4)) = int32(_INT) - w = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)) + 1*4))-int32('0'))*8))) - *(*uintptr)(unsafe.Pointer(bp + 4)) = *(*uintptr)(unsafe.Pointer(bp + 4)) + uintptr(3)*4 + **(**int32)(__ccgo_up(nl_type + uintptr(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4)) + 1*4))-int32('0'))*4)) = int32(_INT) + w = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4)) + 1*4))-int32('0'))*8))) + **(**uintptr)(__ccgo_up(bp + 4)) = **(**uintptr)(__ccgo_up(bp + 4)) + uintptr(3)*4 } else { if !(l10n != 0) { if f != 0 { - v5 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) + v5 = VaInt32(&**(**Tva_list)(__ccgo_up(ap))) } else { v5 = 0 } w = v5 - *(*uintptr)(unsafe.Pointer(bp + 4)) += 4 + **(**uintptr)(__ccgo_up(bp + 4)) += 4 } else { goto inval } @@ -143158,28 +143158,28 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } } /* Read precision */ - if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)))) == int32('.') && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)) + 1*4)) == int32('*') { - if BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)) + 2*4)))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)) + 3*4)) == int32('$') { - *(*int32)(unsafe.Pointer(nl_type + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)) + 2*4))-int32('0'))*4)) = int32(_INT) - p = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)) + 2*4))-int32('0'))*8))) - *(*uintptr)(unsafe.Pointer(bp + 4)) = *(*uintptr)(unsafe.Pointer(bp + 4)) + uintptr(4)*4 + if **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4)))) == int32('.') && **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4)) + 1*4)) == int32('*') { + if BoolInt32(Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4)) + 2*4)))-uint32('0') < uint32(10)) != 0 && **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4)) + 3*4)) == int32('$') { + **(**int32)(__ccgo_up(nl_type + uintptr(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4)) + 2*4))-int32('0'))*4)) = int32(_INT) + p = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4)) + 2*4))-int32('0'))*8))) + **(**uintptr)(__ccgo_up(bp + 4)) = **(**uintptr)(__ccgo_up(bp + 4)) + uintptr(4)*4 } else { if !(l10n != 0) { if f != 0 { - v5 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) + v5 = VaInt32(&**(**Tva_list)(__ccgo_up(ap))) } else { v5 = 0 } p = v5 - *(*uintptr)(unsafe.Pointer(bp + 4)) = *(*uintptr)(unsafe.Pointer(bp + 4)) + uintptr(2)*4 + **(**uintptr)(__ccgo_up(bp + 4)) = **(**uintptr)(__ccgo_up(bp + 4)) + uintptr(2)*4 } else { goto inval } } xp = BoolInt32(p >= 0) } else { - if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)))) == int32('.') { - *(*uintptr)(unsafe.Pointer(bp + 4)) += 4 + if **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4)))) == int32('.') { + **(**uintptr)(__ccgo_up(bp + 4)) += 4 p = _getint1(tls, bp+4) xp = int32(1) } else { @@ -143190,13 +143190,13 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, /* Format specifier state machine */ st = uint32(0) for cond := true; cond; cond = st-uint32(1) < uint32(_STOP) { - if Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)))))-uint32('A') > Uint32FromInt32(Int32FromUint8('z')-Int32FromUint8('A')) { + if Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4)))))-uint32('A') > Uint32FromInt32(Int32FromUint8('z')-Int32FromUint8('A')) { goto inval } ps = st - v8 = *(*uintptr)(unsafe.Pointer(bp + 4)) - *(*uintptr)(unsafe.Pointer(bp + 4)) += 4 - st = uint32(*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_states1)) + uintptr(st)*58 + uintptr(*(*Twchar_t)(unsafe.Pointer(v8))-int32('A'))))) + v8 = **(**uintptr)(__ccgo_up(bp + 4)) + **(**uintptr)(__ccgo_up(bp + 4)) += 4 + st = uint32(**(**uint8)(__ccgo_up(uintptr(unsafe.Pointer(&_states1)) + uintptr(st)*58 + uintptr(**(**Twchar_t)(__ccgo_up(v8))-int32('A'))))) } if !(st != 0) { goto inval @@ -143208,8 +143208,8 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } } else { if argpos >= 0 { - *(*int32)(unsafe.Pointer(nl_type + uintptr(argpos)*4)) = Int32FromUint32(st) - *(*Targ)(unsafe.Pointer(bp + 8)) = *(*Targ)(unsafe.Pointer(nl_arg + uintptr(argpos)*8)) + **(**int32)(__ccgo_up(nl_type + uintptr(argpos)*4)) = Int32FromUint32(st) + **(**Targ)(__ccgo_up(bp + 8)) = **(**Targ)(__ccgo_up(nl_arg + uintptr(argpos)*8)) } else { if f != 0 { _pop_arg1(tls, bp+8, Int32FromUint32(st), ap) @@ -143225,7 +143225,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_ERR) != 0 { return -int32(1) } - t = *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)) + uintptr(-Int32FromInt32(1))*4)) + t = int32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4)) + uintptr(-Int32FromInt32(1))*4))) if ps != 0 && t&int32(15) == int32(3) { t = t & ^Int32FromInt32(32) } @@ -143233,19 +143233,19 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, case int32('n'): switch ps { case uint32(_BARE): - *(*int32)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))))) = cnt + **(**int32)(__ccgo_up(*(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))))) = cnt case uint32(_LPRE): - *(*int32)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))))) = cnt + **(**int32)(__ccgo_up(*(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))))) = cnt case uint32(_LLPRE): - *(*int64)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))))) = int64(cnt) + **(**int64)(__ccgo_up(*(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))))) = int64(cnt) case uint32(_HPRE): - *(*uint16)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))))) = Uint16FromInt32(cnt) + **(**uint16)(__ccgo_up(*(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))))) = Uint16FromInt32(cnt) case uint32(_HHPRE): - *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))))) = Uint8FromInt32(cnt) + **(**uint8)(__ccgo_up(*(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))))) = Uint8FromInt32(cnt) case uint32(_ZTPRE): - *(*Tsize_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))))) = Uint32FromInt32(cnt) + **(**Tsize_t)(__ccgo_up(*(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))))) = Uint32FromInt32(cnt) case uint32(_JPRE): - *(*Tuintmax_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))))) = Uint64FromInt32(cnt) + **(**Tuintmax_t)(__ccgo_up(*(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))))) = Uint64FromInt32(cnt) break } goto _1 @@ -143267,14 +143267,14 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, l = w goto _1 case int32('S'): - a = *(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))) + a = *(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))) if p < 0 { v5 = int32(INT_MAX) } else { v5 = p } z = a + uintptr(Xwcsnlen(tls, a, Uint32FromInt32(v5)))*4 - if p < 0 && *(*Twchar_t)(unsafe.Pointer(z)) != 0 { + if p < 0 && **(**Twchar_t)(__ccgo_up(z)) != 0 { goto overflow } p = (int32(z) - int32(a)) / 4 @@ -143287,13 +143287,13 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, l = w goto _1 case int32('m'): - *(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))) = Xstrerror(tls, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) + *(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))) = Xstrerror(tls, **(**int32)(__ccgo_up(X__errno_location(tls)))) fallthrough case int32('s'): - if !(*(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))) != 0) { - *(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))) = __ccgo_ts + 1460 + if !(*(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))) != 0) { + *(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))) = __ccgo_ts + 1460 } - bs = *(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))) + bs = *(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))) v5 = Int32FromInt32(0) l = v5 i = v5 @@ -143319,7 +143319,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if i < 0 { return -int32(1) } - if p < 0 && *(*int8)(unsafe.Pointer(bs)) != 0 { + if p < 0 && **(**int8)(__ccgo_up(bs)) != 0 { goto overflow } p = l @@ -143327,7 +143327,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, w = p } _pad4(tls, f, w-p, Int32FromUint32(fl)) - bs = *(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))) + bs = *(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))) for { v5 = l l = l - 1 @@ -143380,17 +143380,17 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } i = int32(1) for { - if !(i <= int32(NL_ARGMAX) && *(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)) != 0) { + if !(i <= int32(NL_ARGMAX) && **(**int32)(__ccgo_up(nl_type + uintptr(i)*4)) != 0) { break } - _pop_arg1(tls, nl_arg+uintptr(i)*8, *(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)), ap) + _pop_arg1(tls, nl_arg+uintptr(i)*8, **(**int32)(__ccgo_up(nl_type + uintptr(i)*4)), ap) goto _17 _17: ; i = i + 1 } for { - if !(i <= int32(NL_ARGMAX) && !(*(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)) != 0)) { + if !(i <= int32(NL_ARGMAX) && !(**(**int32)(__ccgo_up(nl_type + uintptr(i)*4)) != 0)) { break } goto _18 @@ -143405,12 +143405,12 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto inval inval: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) goto overflow overflow: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return -int32(1) } @@ -143426,11 +143426,11 @@ func Xvfwprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { var _ /* nl_arg at bp+44 */ [10]Targ var _ /* nl_type at bp+4 */ [10]int32 _, _, _, _ = __need_unlock, olderr, ret, v1 - *(*[10]int32)(unsafe.Pointer(bp + 4)) = [10]int32{} + **(**[10]int32)(__ccgo_up(bp + 4)) = [10]int32{} /* the copy allows passing va_list* even if va_list is an array */ - *(*Tva_list)(unsafe.Pointer(bp)) = ap + **(**Tva_list)(__ccgo_up(bp)) = ap if _wprintf_core(tls, uintptr(0), fmt, bp, bp+44, bp+4) < 0 { - _ = *(*Tva_list)(unsafe.Pointer(bp)) + _ = **(**Tva_list)(__ccgo_up(bp)) return -int32(1) } if AtomicLoadPInt32(f+76) >= 0 { @@ -143441,16 +143441,16 @@ func Xvfwprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { __need_unlock = v1 Xfwide(tls, f, int32(1)) olderr = Int32FromUint32((*TFILE)(unsafe.Pointer(f)).Fflags & uint32(F_ERR)) - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_ERR)) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^Int32FromInt32(F_ERR)) ret = _wprintf_core(tls, f, fmt, bp, bp+44, bp+4) if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_ERR) != 0 { ret = -int32(1) } - *(*uint32)(unsafe.Pointer(f)) |= Uint32FromInt32(olderr) + **(**uint32)(__ccgo_up(f)) |= Uint32FromInt32(olderr) if __need_unlock != 0 { ___unlockfile(tls, f) } - _ = *(*Tva_list)(unsafe.Pointer(bp)) + _ = **(**Tva_list)(__ccgo_up(bp)) return ret } @@ -143460,15 +143460,15 @@ func _store_int1(tls *TLS, dest uintptr, size int32, i uint64) { } switch size { case -int32(2): - *(*int8)(unsafe.Pointer(dest)) = Int8FromUint64(i) + **(**int8)(__ccgo_up(dest)) = Int8FromUint64(i) case -int32(1): - *(*int16)(unsafe.Pointer(dest)) = Int16FromUint64(i) + **(**int16)(__ccgo_up(dest)) = Int16FromUint64(i) case SIZE_def: - *(*int32)(unsafe.Pointer(dest)) = Int32FromUint64(i) + **(**int32)(__ccgo_up(dest)) = Int32FromUint64(i) case int32(SIZE_l): - *(*int32)(unsafe.Pointer(dest)) = Int32FromUint64(i) + **(**int32)(__ccgo_up(dest)) = Int32FromUint64(i) case int32(SIZE_ll): - *(*int64)(unsafe.Pointer(dest)) = Int64FromUint64(i) + **(**int64)(__ccgo_up(dest)) = Int64FromUint64(i) break } } @@ -143500,13 +143500,13 @@ func _in_set(tls *TLS, set uintptr, c int32) (r int32) { var p, v3 uintptr _, _, _ = j, p, v3 p = set - if *(*Twchar_t)(unsafe.Pointer(p)) == int32('-') { + if **(**Twchar_t)(__ccgo_up(p)) == int32('-') { if c == int32('-') { return int32(1) } p += 4 } else { - if *(*Twchar_t)(unsafe.Pointer(p)) == int32(']') { + if **(**Twchar_t)(__ccgo_up(p)) == int32(']') { if c == int32(']') { return int32(1) } @@ -143514,15 +143514,15 @@ func _in_set(tls *TLS, set uintptr, c int32) (r int32) { } } for { - if !(*(*Twchar_t)(unsafe.Pointer(p)) != 0 && *(*Twchar_t)(unsafe.Pointer(p)) != int32(']')) { + if !(**(**Twchar_t)(__ccgo_up(p)) != 0 && **(**Twchar_t)(__ccgo_up(p)) != int32(']')) { break } - if *(*Twchar_t)(unsafe.Pointer(p)) == int32('-') && *(*Twchar_t)(unsafe.Pointer(p + 1*4)) != 0 && *(*Twchar_t)(unsafe.Pointer(p + 1*4)) != int32(']') { + if **(**Twchar_t)(__ccgo_up(p)) == int32('-') && **(**Twchar_t)(__ccgo_up(p + 1*4)) != 0 && **(**Twchar_t)(__ccgo_up(p + 1*4)) != int32(']') { v3 = p p += 4 - j = *(*Twchar_t)(unsafe.Pointer(v3 + uintptr(-Int32FromInt32(1))*4)) + j = int32(**(**Twchar_t)(__ccgo_up(v3 + uintptr(-Int32FromInt32(1))*4))) for { - if !(j < *(*Twchar_t)(unsafe.Pointer(p))) { + if !(j < **(**Twchar_t)(__ccgo_up(p))) { break } if c == j { @@ -143534,7 +143534,7 @@ func _in_set(tls *TLS, set uintptr, c int32) (r int32) { j = j + 1 } } - if c == *(*Twchar_t)(unsafe.Pointer(p)) { + if c == **(**Twchar_t)(__ccgo_up(p)) { return int32(1) } goto _1 @@ -143572,20 +143572,20 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { Xfwide(tls, f, int32(1)) p = fmt for { - if !(*(*Twchar_t)(unsafe.Pointer(p)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(p)) != 0) { break } alloc = 0 - if Xiswspace(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(p)))) != 0 { - for Xiswspace(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(p + 1*4)))) != 0 { + if Xiswspace(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(p)))) != 0 { + for Xiswspace(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(p + 1*4)))) != 0 { p += 4 } for { - if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { + if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(**(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 4 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) + v4 = uint32(**(**uint8)(__ccgo_up(v5))) } else { v4 = Xgetwc(tls, f) } @@ -143600,21 +143600,21 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v6 = f + 4 *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 v5 = *(*uintptr)(unsafe.Pointer(v6)) - _ = *(*uint8)(unsafe.Pointer(v5)) + _ = **(**uint8)(__ccgo_up(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } goto _2 } - if *(*Twchar_t)(unsafe.Pointer(p)) != int32('%') || *(*Twchar_t)(unsafe.Pointer(p + 1*4)) == int32('%') { - if *(*Twchar_t)(unsafe.Pointer(p)) == int32('%') { + if **(**Twchar_t)(__ccgo_up(p)) != int32('%') || **(**Twchar_t)(__ccgo_up(p + 1*4)) == int32('%') { + if **(**Twchar_t)(__ccgo_up(p)) == int32('%') { p += 4 for { - if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { + if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(**(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 4 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) + v4 = uint32(**(**uint8)(__ccgo_up(v5))) } else { v4 = Xgetwc(tls, f) } @@ -143626,22 +143626,22 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { pos = pos + 1 } } else { - if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { + if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(**(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 4 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) + v4 = uint32(**(**uint8)(__ccgo_up(v5))) } else { v4 = Xgetwc(tls, f) } c = Int32FromUint32(v4) } - if c != *(*Twchar_t)(unsafe.Pointer(p)) { + if c != **(**Twchar_t)(__ccgo_up(p)) { if (*TFILE)(unsafe.Pointer(f)).Frend != 0 && Uint32FromInt32(c) < uint32(128) { v6 = f + 4 *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 v5 = *(*uintptr)(unsafe.Pointer(v6)) - _ = *(*uint8)(unsafe.Pointer(v5)) + _ = **(**uint8)(__ccgo_up(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -143654,12 +143654,12 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { goto _2 } p += 4 - if *(*Twchar_t)(unsafe.Pointer(p)) == int32('*') { + if **(**Twchar_t)(__ccgo_up(p)) == int32('*') { dest = uintptr(0) p += 4 } else { - if BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(p)))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(p + 1*4)) == int32('$') { - dest = _arg_n1(tls, ap, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(p))-int32('0'))) + if BoolInt32(Uint32FromInt32(**(**Twchar_t)(__ccgo_up(p)))-uint32('0') < uint32(10)) != 0 && **(**Twchar_t)(__ccgo_up(p + 1*4)) == int32('$') { + dest = _arg_n1(tls, ap, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(p))-int32('0'))) p = p + uintptr(2)*4 } else { dest = VaUintptr(&ap) @@ -143667,16 +143667,16 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } width = 0 for { - if !(BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(p)))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(Uint32FromInt32(**(**Twchar_t)(__ccgo_up(p)))-uint32('0') < uint32(10)) != 0) { break } - width = int32(10)*width + *(*Twchar_t)(unsafe.Pointer(p)) - int32('0') + width = int32(int32(10)*width + **(**Twchar_t)(__ccgo_up(p)) - int32('0')) goto _18 _18: ; p += 4 } - if *(*Twchar_t)(unsafe.Pointer(p)) == int32('m') { + if **(**Twchar_t)(__ccgo_up(p)) == int32('m') { wcs = uintptr(0) s = uintptr(0) alloc = BoolInt32(!!(dest != 0)) @@ -143687,16 +143687,16 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { size = SIZE_def v5 = p p += 4 - switch *(*Twchar_t)(unsafe.Pointer(v5)) { + switch **(**Twchar_t)(__ccgo_up(v5)) { case int32('h'): - if *(*Twchar_t)(unsafe.Pointer(p)) == int32('h') { + if **(**Twchar_t)(__ccgo_up(p)) == int32('h') { p += 4 size = -Int32FromInt32(2) } else { size = -int32(1) } case int32('l'): - if *(*Twchar_t)(unsafe.Pointer(p)) == int32('l') { + if **(**Twchar_t)(__ccgo_up(p)) == int32('l') { p += 4 size = Int32FromInt32(SIZE_ll) } else { @@ -143755,7 +143755,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { default: goto fmt_fail } - t = *(*Twchar_t)(unsafe.Pointer(p)) + t = int32(**(**Twchar_t)(__ccgo_up(p))) /* Transform S,C -> ls,lc */ if t&int32(0x2f) == int32(3) { size = int32(SIZE_l) @@ -143764,11 +143764,11 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if t != int32('n') { if t != int32('[') && t|int32(32) != int32('c') { for { - if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { + if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(**(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 4 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) + v4 = uint32(**(**uint8)(__ccgo_up(v5))) } else { v4 = Xgetwc(tls, f) } @@ -143780,11 +143780,11 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { pos = pos + 1 } } else { - if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { + if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(**(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 4 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) + v4 = uint32(**(**uint8)(__ccgo_up(v5))) } else { v4 = Xgetwc(tls, f) } @@ -143797,7 +143797,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v6 = f + 4 *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 v5 = *(*uintptr)(unsafe.Pointer(v6)) - _ = *(*uint8)(unsafe.Pointer(v5)) + _ = **(**uint8)(__ccgo_up(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -143825,18 +143825,18 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } else { p += 4 v5 = p - if *(*Twchar_t)(unsafe.Pointer(v5)) == int32('^') { + if **(**Twchar_t)(__ccgo_up(v5)) == int32('^') { p += 4 invert = Int32FromInt32(1) } else { invert = 0 } set = p - if *(*Twchar_t)(unsafe.Pointer(p)) == int32(']') { + if **(**Twchar_t)(__ccgo_up(p)) == int32(']') { p += 4 } - for *(*Twchar_t)(unsafe.Pointer(p)) != int32(']') { - if !(*(*Twchar_t)(unsafe.Pointer(p)) != 0) { + for **(**Twchar_t)(__ccgo_up(p)) != int32(']') { + if !(**(**Twchar_t)(__ccgo_up(p)) != 0) { goto fmt_fail } p += 4 @@ -143880,11 +143880,11 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } } for width != 0 { - if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { + if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(**(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 4 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) + v4 = uint32(**(**uint8)(__ccgo_up(v5))) } else { v4 = Xgetwc(tls, f) } @@ -143899,7 +143899,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if wcs != 0 { v37 = i i = i + 1 - *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(v37)*4)) = c + **(**Twchar_t)(__ccgo_up(wcs + uintptr(v37)*4)) = c if alloc != 0 && i == k { k = k + (k + uint32(1)) tmp1 = Xrealloc(tls, wcs, k*uint32(4)) @@ -143939,7 +143939,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v6 = f + 4 *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 v5 = *(*uintptr)(unsafe.Pointer(v6)) - _ = *(*uint8)(unsafe.Pointer(v5)) + _ = **(**uint8)(__ccgo_up(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -143949,17 +143949,17 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } if alloc != 0 { if size == int32(SIZE_l) { - *(*uintptr)(unsafe.Pointer(dest)) = wcs + **(**uintptr)(__ccgo_up(dest)) = wcs } else { - *(*uintptr)(unsafe.Pointer(dest)) = s + **(**uintptr)(__ccgo_up(dest)) = s } } if t != int32('c') { if wcs != 0 { - *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) = 0 + **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) = 0 } if s != 0 { - *(*int8)(unsafe.Pointer(s + uintptr(i))) = 0 + **(**int8)(__ccgo_up(s + uintptr(i))) = 0 } } case int32('d'): @@ -143995,7 +143995,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { width = 0 } Xsnprintf(tls, bp+8, uint32(22), __ccgo_ts+1503, VaList(bp+40, int32(1)+BoolInt32(!(dest != 0)), __ccgo_ts+1521, width, uintptr(unsafe.Pointer(&_size_pfx))+uintptr(size+int32(2))*3, t)) - *(*Toff_t)(unsafe.Pointer(bp)) = 0 + **(**Toff_t)(__ccgo_up(bp)) = 0 if dest != 0 { v5 = dest } else { @@ -144004,11 +144004,11 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if Xfscanf(tls, f, bp+8, VaList(bp+40, v5, bp)) == -int32(1) { goto input_fail } else { - if !(*(*Toff_t)(unsafe.Pointer(bp)) != 0) { + if !(**(**Toff_t)(__ccgo_up(bp)) != 0) { goto match_fail } } - pos = pos + *(*Toff_t)(unsafe.Pointer(bp)) + pos = pos + **(**Toff_t)(__ccgo_up(bp)) default: goto fmt_fail } @@ -144134,8 +144134,8 @@ func _sn_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { k = v1 if k != 0 { Xmemcpy(tls, (*Tcookie3)(unsafe.Pointer(c)).Fs, (*TFILE)(unsafe.Pointer(f)).Fwbase, k) - *(*uintptr)(unsafe.Pointer(c)) += uintptr(k) - *(*Tsize_t)(unsafe.Pointer(c + 4)) -= k + **(**uintptr)(__ccgo_up(c)) += uintptr(k) + **(**Tsize_t)(__ccgo_up(c + 4)) -= k } if (*Tcookie3)(unsafe.Pointer(c)).Fn < l { v1 = (*Tcookie3)(unsafe.Pointer(c)).Fn @@ -144145,10 +144145,10 @@ func _sn_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { k = v1 if k != 0 { Xmemcpy(tls, (*Tcookie3)(unsafe.Pointer(c)).Fs, s, k) - *(*uintptr)(unsafe.Pointer(c)) += uintptr(k) - *(*Tsize_t)(unsafe.Pointer(c + 4)) -= k + **(**uintptr)(__ccgo_up(c)) += uintptr(k) + **(**Tsize_t)(__ccgo_up(c + 4)) -= k } - *(*int8)(unsafe.Pointer((*Tcookie3)(unsafe.Pointer(c)).Fs)) = 0 + **(**int8)(__ccgo_up((*Tcookie3)(unsafe.Pointer(c)).Fs)) = 0 v3 = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Fwbase = v3 (*TFILE)(unsafe.Pointer(f)).Fwpos = v3 @@ -144180,18 +144180,18 @@ func Xvsnprintf(tls *TLS, s uintptr, n Tsize_t, fmt uintptr, ap Tva_list) (r int } else { v2 = uint32(0) } - *(*Tcookie3)(unsafe.Pointer(bp + 8)) = Tcookie3{ + **(**Tcookie3)(__ccgo_up(bp + 8)) = Tcookie3{ Fs: v1, Fn: v2, } - *(*TFILE)(unsafe.Pointer(bp + 16)) = TFILE{ + **(**TFILE)(__ccgo_up(bp + 16)) = TFILE{ Fwrite: __ccgo_fp(_sn_write), Fbuf: bp, Flock: -int32(1), Flbf: -int32(1), Fcookie: bp + 8, } - *(*int8)(unsafe.Pointer((*(*Tcookie3)(unsafe.Pointer(bp + 8))).Fs)) = 0 + **(**int8)(__ccgo_up((**(**Tcookie3)(__ccgo_up(bp + 8))).Fs)) = 0 return Xvfprintf(tls, bp+16, fmt, ap) } @@ -144240,7 +144240,7 @@ func Xvsscanf(tls *TLS, s uintptr, fmt uintptr, ap Tva_list) (r int32) { bp := tls.Alloc(144) defer tls.Free(144) var _ /* f at bp+0 */ TFILE - *(*TFILE)(unsafe.Pointer(bp)) = TFILE{ + **(**TFILE)(__ccgo_up(bp)) = TFILE{ Fread: __ccgo_fp(_string_read), Fbuf: s, Flock: -int32(1), @@ -144290,14 +144290,14 @@ func _sw_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { (*Tcookie4)(unsafe.Pointer(c)).Fl = (*Tcookie4)(unsafe.Pointer(c)).Fl - 1 (*Tcookie4)(unsafe.Pointer(c)).Fws += 4 } - *(*Twchar_t)(unsafe.Pointer((*Tcookie4)(unsafe.Pointer(c)).Fws)) = 0 + **(**Twchar_t)(__ccgo_up((*Tcookie4)(unsafe.Pointer(c)).Fws)) = 0 if i < 0 { v4 = UintptrFromInt32(0) (*TFILE)(unsafe.Pointer(f)).Fwend = v4 v3 = v4 (*TFILE)(unsafe.Pointer(f)).Fwbase = v3 (*TFILE)(unsafe.Pointer(f)).Fwpos = v3 - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) return Uint32FromInt32(i) } (*TFILE)(unsafe.Pointer(f)).Fwend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr((*TFILE)(unsafe.Pointer(f)).Fbuf_size) @@ -144319,11 +144319,11 @@ func Xvswprintf(tls *TLS, s uintptr, n Tsize_t, fmt uintptr, ap Tva_list) (r1 in var _ /* c at bp+256 */ Tcookie4 var _ /* f at bp+264 */ TFILE _, _ = r, v1 - *(*Tcookie4)(unsafe.Pointer(bp + 256)) = Tcookie4{ + **(**Tcookie4)(__ccgo_up(bp + 256)) = Tcookie4{ Fws: s, Fl: n - uint32(1), } - *(*TFILE)(unsafe.Pointer(bp + 264)) = TFILE{ + **(**TFILE)(__ccgo_up(bp + 264)) = TFILE{ Fwrite: __ccgo_fp(_sw_write), Fbuf: bp, Fbuf_size: uint32(256), @@ -144351,8 +144351,8 @@ func _wstring_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { var v1, v2 uintptr var _ /* src at bp+0 */ uintptr _, _, _ = k, v1, v2 - *(*uintptr)(unsafe.Pointer(bp)) = (*TFILE)(unsafe.Pointer(f)).Fcookie - if !(*(*uintptr)(unsafe.Pointer(bp)) != 0) { + **(**uintptr)(__ccgo_up(bp)) = (*TFILE)(unsafe.Pointer(f)).Fcookie + if !(**(**uintptr)(__ccgo_up(bp)) != 0) { return uint32(0) } k = Xwcsrtombs(tls, (*TFILE)(unsafe.Pointer(f)).Fbuf, bp, (*TFILE)(unsafe.Pointer(f)).Fbuf_size, uintptr(0)) @@ -144364,14 +144364,14 @@ func _wstring_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { } (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(k) - (*TFILE)(unsafe.Pointer(f)).Fcookie = *(*uintptr)(unsafe.Pointer(bp)) + (*TFILE)(unsafe.Pointer(f)).Fcookie = **(**uintptr)(__ccgo_up(bp)) if !(len1 != 0) || !(k != 0) { return uint32(0) } v2 = f + 4 v1 = *(*uintptr)(unsafe.Pointer(v2)) *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(v2)) + 1 - *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v1)) + **(**uint8)(__ccgo_up(buf)) = **(**uint8)(__ccgo_up(v1)) return uint32(1) } @@ -144384,7 +144384,7 @@ func Xvswscanf(tls *TLS, s uintptr, fmt uintptr, ap Tva_list) (r int32) { defer tls.Free(400) var _ /* buf at bp+0 */ [256]uint8 var _ /* f at bp+256 */ TFILE - *(*TFILE)(unsafe.Pointer(bp + 256)) = TFILE{ + **(**TFILE)(__ccgo_up(bp + 256)) = TFILE{ Fread: __ccgo_fp(_wstring_read), Fbuf: bp, Fbuf_size: uint32(256), @@ -144496,7 +144496,7 @@ func Xatoi(tls *TLS, s uintptr) (r int32) { n = 0 neg = 0 for { - v1 = int32(*(*int8)(unsafe.Pointer(s))) + v1 = int32(**(**int8)(__ccgo_up(s))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _3 _3: @@ -144505,7 +144505,7 @@ func Xatoi(tls *TLS, s uintptr) (r int32) { } s = s + 1 } - switch int32(*(*int8)(unsafe.Pointer(s))) { + switch int32(**(**int8)(__ccgo_up(s))) { case int32('-'): neg = int32(1) fallthrough @@ -144513,10 +144513,10 @@ func Xatoi(tls *TLS, s uintptr) (r int32) { s = s + 1 } /* Compute n as a negative number to avoid overflow on INT_MIN */ - for BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { + for BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(s)))-uint32('0') < uint32(10)) != 0 { v4 = s s = s + 1 - n = int32(10)*n - (int32(*(*int8)(unsafe.Pointer(v4))) - int32('0')) + n = int32(10)*n - (int32(**(**int8)(__ccgo_up(v4))) - int32('0')) } if neg != 0 { v1 = n @@ -144537,7 +144537,7 @@ func Xatol(tls *TLS, s uintptr) (r int32) { n = 0 neg = 0 for { - v1 = int32(*(*int8)(unsafe.Pointer(s))) + v1 = int32(**(**int8)(__ccgo_up(s))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _3 _3: @@ -144546,7 +144546,7 @@ func Xatol(tls *TLS, s uintptr) (r int32) { } s = s + 1 } - switch int32(*(*int8)(unsafe.Pointer(s))) { + switch int32(**(**int8)(__ccgo_up(s))) { case int32('-'): neg = int32(1) fallthrough @@ -144554,10 +144554,10 @@ func Xatol(tls *TLS, s uintptr) (r int32) { s = s + 1 } /* Compute n as a negative number to avoid overflow on LONG_MIN */ - for BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { + for BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(s)))-uint32('0') < uint32(10)) != 0 { v4 = s s = s + 1 - n = int32(10)*n - int32(int32(*(*int8)(unsafe.Pointer(v4)))-Int32FromUint8('0')) + n = int32(10)*n - int32(int32(**(**int8)(__ccgo_up(v4)))-Int32FromUint8('0')) } if neg != 0 { v1 = n @@ -144579,7 +144579,7 @@ func Xatoll(tls *TLS, s uintptr) (r int64) { n = 0 neg = 0 for { - v1 = int32(*(*int8)(unsafe.Pointer(s))) + v1 = int32(**(**int8)(__ccgo_up(s))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _3 _3: @@ -144588,7 +144588,7 @@ func Xatoll(tls *TLS, s uintptr) (r int64) { } s = s + 1 } - switch int32(*(*int8)(unsafe.Pointer(s))) { + switch int32(**(**int8)(__ccgo_up(s))) { case int32('-'): neg = int32(1) fallthrough @@ -144596,10 +144596,10 @@ func Xatoll(tls *TLS, s uintptr) (r int64) { s = s + 1 } /* Compute n as a negative number to avoid overflow on LLONG_MIN */ - for BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { + for BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(s)))-uint32('0') < uint32(10)) != 0 { v4 = s s = s + 1 - n = int64(10)*n - int64(int32(*(*int8)(unsafe.Pointer(v4)))-Int32FromUint8('0')) + n = int64(10)*n - int64(int32(**(**int8)(__ccgo_up(v4)))-Int32FromUint8('0')) } if neg != 0 { v5 = n @@ -144661,24 +144661,24 @@ func Xecvt(tls *TLS, x float64, n int32, dp uintptr, sign uintptr) (r uintptr) { n = int32(15) } Xsprintf(tls, bp, __ccgo_ts+1524, VaList(bp+40, n-int32(1), x)) - v1 = BoolInt32(int32((*(*[32]int8)(unsafe.Pointer(bp)))[0]) == Int32FromUint8('-')) - *(*int32)(unsafe.Pointer(sign)) = v1 + v1 = BoolInt32(int32((**(**[32]int8)(__ccgo_up(bp)))[0]) == Int32FromUint8('-')) + **(**int32)(__ccgo_up(sign)) = v1 i = v1 j = 0 for { - if !(int32((*(*[32]int8)(unsafe.Pointer(bp)))[i]) != int32('e')) { + if !(int32((**(**[32]int8)(__ccgo_up(bp)))[i]) != int32('e')) { break } - _buf8[j] = (*(*[32]int8)(unsafe.Pointer(bp)))[i] + _buf8[j] = (**(**[32]int8)(__ccgo_up(bp)))[i] goto _2 _2: ; v1 = i i = i + 1 - j = j + BoolInt32(int32((*(*[32]int8)(unsafe.Pointer(bp)))[v1]) != int32('.')) + j = j + BoolInt32(int32((**(**[32]int8)(__ccgo_up(bp)))[v1]) != int32('.')) } _buf8[j] = 0 - *(*int32)(unsafe.Pointer(dp)) = Xatoi(tls, bp+uintptr(i)+uintptr(1)) + int32(1) + **(**int32)(__ccgo_up(dp)) = Xatoi(tls, bp+uintptr(i)+uintptr(1)) + int32(1) return uintptr(unsafe.Pointer(&_buf8)) } @@ -144698,15 +144698,15 @@ func Xfcvt(tls *TLS, x float64, n int32, dp uintptr, sign uintptr) (r uintptr) { n = int32(1400) } Xsprintf(tls, bp, __ccgo_ts+1529, VaList(bp+1512, n, x)) - i = BoolInt32(int32((*(*[1500]int8)(unsafe.Pointer(bp)))[0]) == int32('-')) - if int32((*(*[1500]int8)(unsafe.Pointer(bp)))[i]) == int32('0') { + i = BoolInt32(int32((**(**[1500]int8)(__ccgo_up(bp)))[0]) == int32('-')) + if int32((**(**[1500]int8)(__ccgo_up(bp)))[i]) == int32('0') { lz = Int32FromUint32(Xstrspn(tls, bp+uintptr(i)+uintptr(2), __ccgo_ts+1497)) } else { lz = -Int32FromUint32(Xstrcspn(tls, bp+uintptr(i), __ccgo_ts+483)) } if n <= lz { - *(*int32)(unsafe.Pointer(sign)) = i - *(*int32)(unsafe.Pointer(dp)) = int32(1) + **(**int32)(__ccgo_up(sign)) = i + **(**int32)(__ccgo_up(dp)) = int32(1) if Uint32FromInt32(n) > uint32(14) { n = int32(14) } @@ -144811,13 +144811,13 @@ func _pntz(tls *TLS, p uintptr) (r1 int32) { var v1, v5 uint32 var v8 bool _, _, _, _, _, _, _ = r, v1, v2, v4, v5, v6, v8 - v1 = uint32(*(*Tsize_t)(unsafe.Pointer(p)) - Uint32FromInt32(1)) + v1 = uint32(**(**Tsize_t)(__ccgo_up(p)) - Uint32FromInt32(1)) v2 = _a_ctz_32(tls, v1) goto _3 _3: r = v2 if v8 = r != 0; !v8 { - v5 = *(*Tsize_t)(unsafe.Pointer(p + 1*4)) + v5 = uint32(**(**Tsize_t)(__ccgo_up(p + 1*4))) v6 = _a_ctz_32(tls, v5) goto _7 _7: @@ -144841,7 +144841,7 @@ func _cycle(tls *TLS, width Tsize_t, ar uintptr, n int32) { if n < int32(2) { return } - *(*uintptr)(unsafe.Pointer(ar + uintptr(n)*4)) = bp + **(**uintptr)(__ccgo_up(ar + uintptr(n)*4)) = bp for width != 0 { if uint32(256) < width { v1 = uint32(256) @@ -144849,14 +144849,14 @@ func _cycle(tls *TLS, width Tsize_t, ar uintptr, n int32) { v1 = width } l = v1 - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(ar + uintptr(n)*4)), *(*uintptr)(unsafe.Pointer(ar)), l) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(ar + uintptr(n)*4)), **(**uintptr)(__ccgo_up(ar)), l) i = 0 for { if !(i < n) { break } - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(ar + uintptr(i)*4)), *(*uintptr)(unsafe.Pointer(ar + uintptr(i+int32(1))*4)), l) - *(*uintptr)(unsafe.Pointer(ar + uintptr(i)*4)) += uintptr(l) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(ar + uintptr(i)*4)), **(**uintptr)(__ccgo_up(ar + uintptr(i+int32(1))*4)), l) + **(**uintptr)(__ccgo_up(ar + uintptr(i)*4)) += uintptr(l) goto _2 _2: ; @@ -144872,23 +144872,23 @@ func _cycle(tls *TLS, width Tsize_t, ar uintptr, n int32) { func _shl(tls *TLS, p uintptr, n int32) { if Uint32FromInt32(n) >= Uint32FromInt32(8)*Uint32FromInt64(4) { n = Int32FromUint32(uint32(n) - Uint32FromInt32(8)*Uint32FromInt64(4)) - *(*Tsize_t)(unsafe.Pointer(p + 1*4)) = *(*Tsize_t)(unsafe.Pointer(p)) - *(*Tsize_t)(unsafe.Pointer(p)) = uint32(0) + **(**Tsize_t)(__ccgo_up(p + 1*4)) = **(**Tsize_t)(__ccgo_up(p)) + **(**Tsize_t)(__ccgo_up(p)) = uint32(0) } - *(*Tsize_t)(unsafe.Pointer(p + 1*4)) <<= Uint32FromInt32(n) - *(*Tsize_t)(unsafe.Pointer(p + 1*4)) |= *(*Tsize_t)(unsafe.Pointer(p)) >> (Uint32FromInt64(4)*Uint32FromInt32(8) - Uint32FromInt32(n)) - *(*Tsize_t)(unsafe.Pointer(p)) <<= Uint32FromInt32(n) + **(**Tsize_t)(__ccgo_up(p + 1*4)) <<= Uint32FromInt32(n) + **(**Tsize_t)(__ccgo_up(p + 1*4)) |= **(**Tsize_t)(__ccgo_up(p)) >> (Uint32FromInt64(4)*Uint32FromInt32(8) - Uint32FromInt32(n)) + **(**Tsize_t)(__ccgo_up(p)) <<= Uint32FromInt32(n) } func _shr(tls *TLS, p uintptr, n int32) { if Uint32FromInt32(n) >= Uint32FromInt32(8)*Uint32FromInt64(4) { n = Int32FromUint32(uint32(n) - Uint32FromInt32(8)*Uint32FromInt64(4)) - *(*Tsize_t)(unsafe.Pointer(p)) = *(*Tsize_t)(unsafe.Pointer(p + 1*4)) - *(*Tsize_t)(unsafe.Pointer(p + 1*4)) = uint32(0) + **(**Tsize_t)(__ccgo_up(p)) = **(**Tsize_t)(__ccgo_up(p + 1*4)) + **(**Tsize_t)(__ccgo_up(p + 1*4)) = uint32(0) } - *(*Tsize_t)(unsafe.Pointer(p)) >>= Uint32FromInt32(n) - *(*Tsize_t)(unsafe.Pointer(p)) |= *(*Tsize_t)(unsafe.Pointer(p + 1*4)) << (Uint32FromInt64(4)*Uint32FromInt32(8) - Uint32FromInt32(n)) - *(*Tsize_t)(unsafe.Pointer(p + 1*4)) >>= Uint32FromInt32(n) + **(**Tsize_t)(__ccgo_up(p)) >>= Uint32FromInt32(n) + **(**Tsize_t)(__ccgo_up(p)) |= **(**Tsize_t)(__ccgo_up(p + 1*4)) << (Uint32FromInt64(4)*Uint32FromInt32(8) - Uint32FromInt32(n)) + **(**Tsize_t)(__ccgo_up(p + 1*4)) >>= Uint32FromInt32(n) } func _sift(tls *TLS, head uintptr, width Tsize_t, __ccgo_fp_cmp Tcmpfun, arg uintptr, pshift int32, lp uintptr) { @@ -144899,23 +144899,23 @@ func _sift(tls *TLS, head uintptr, width Tsize_t, __ccgo_fp_cmp Tcmpfun, arg uin var _ /* ar at bp+0 */ [57]uintptr _, _, _, _ = i, lf, rt, v1 i = int32(1) - (*(*[57]uintptr)(unsafe.Pointer(bp)))[0] = head + (**(**[57]uintptr)(__ccgo_up(bp)))[0] = head for pshift > int32(1) { rt = head - uintptr(width) - lf = head - uintptr(width) - uintptr(*(*Tsize_t)(unsafe.Pointer(lp + uintptr(pshift-int32(2))*4))) - if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, (*(*[57]uintptr)(unsafe.Pointer(bp)))[0], lf, arg) >= 0 && (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, (*(*[57]uintptr)(unsafe.Pointer(bp)))[0], rt, arg) >= 0 { + lf = head - uintptr(width) - uintptr(**(**Tsize_t)(__ccgo_up(lp + uintptr(pshift-int32(2))*4))) + if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, (**(**[57]uintptr)(__ccgo_up(bp)))[0], lf, arg) >= 0 && (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, (**(**[57]uintptr)(__ccgo_up(bp)))[0], rt, arg) >= 0 { break } if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, lf, rt, arg) >= 0 { v1 = i i = i + 1 - (*(*[57]uintptr)(unsafe.Pointer(bp)))[v1] = lf + (**(**[57]uintptr)(__ccgo_up(bp)))[v1] = lf head = lf pshift = pshift - int32(1) } else { v1 = i i = i + 1 - (*(*[57]uintptr)(unsafe.Pointer(bp)))[v1] = rt + (**(**[57]uintptr)(__ccgo_up(bp)))[v1] = rt head = rt pshift = pshift - int32(2) } @@ -144932,24 +144932,24 @@ func _trinkle(tls *TLS, head uintptr, width Tsize_t, __ccgo_fp_cmp Tcmpfun, arg var _ /* p at bp+0 */ [2]Tsize_t _, _, _, _, _, _ = i, lf, rt, stepson, trail, v1 i = int32(1) - (*(*[2]Tsize_t)(unsafe.Pointer(bp)))[0] = *(*Tsize_t)(unsafe.Pointer(pp)) - (*(*[2]Tsize_t)(unsafe.Pointer(bp)))[int32(1)] = *(*Tsize_t)(unsafe.Pointer(pp + 1*4)) - (*(*[57]uintptr)(unsafe.Pointer(bp + 8)))[0] = head - for (*(*[2]Tsize_t)(unsafe.Pointer(bp)))[0] != uint32(1) || (*(*[2]Tsize_t)(unsafe.Pointer(bp)))[int32(1)] != uint32(0) { - stepson = head - uintptr(*(*Tsize_t)(unsafe.Pointer(lp + uintptr(pshift)*4))) - if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, stepson, (*(*[57]uintptr)(unsafe.Pointer(bp + 8)))[0], arg) <= 0 { + (**(**[2]Tsize_t)(__ccgo_up(bp)))[0] = **(**Tsize_t)(__ccgo_up(pp)) + (**(**[2]Tsize_t)(__ccgo_up(bp)))[int32(1)] = **(**Tsize_t)(__ccgo_up(pp + 1*4)) + (**(**[57]uintptr)(__ccgo_up(bp + 8)))[0] = head + for (**(**[2]Tsize_t)(__ccgo_up(bp)))[0] != uint32(1) || (**(**[2]Tsize_t)(__ccgo_up(bp)))[int32(1)] != uint32(0) { + stepson = head - uintptr(**(**Tsize_t)(__ccgo_up(lp + uintptr(pshift)*4))) + if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, stepson, (**(**[57]uintptr)(__ccgo_up(bp + 8)))[0], arg) <= 0 { break } if !(trusty != 0) && pshift > int32(1) { rt = head - uintptr(width) - lf = head - uintptr(width) - uintptr(*(*Tsize_t)(unsafe.Pointer(lp + uintptr(pshift-int32(2))*4))) + lf = head - uintptr(width) - uintptr(**(**Tsize_t)(__ccgo_up(lp + uintptr(pshift-int32(2))*4))) if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, rt, stepson, arg) >= 0 || (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, lf, stepson, arg) >= 0 { break } } v1 = i i = i + 1 - (*(*[57]uintptr)(unsafe.Pointer(bp + 8)))[v1] = stepson + (**(**[57]uintptr)(__ccgo_up(bp + 8)))[v1] = stepson head = stepson trail = _pntz(tls, bp) _shr(tls, bp, trail) @@ -144977,7 +144977,7 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm var _ /* p at bp+192 */ [2]Tsize_t _, _, _, _, _, _, _, _ = head, high, i, pshift, size, trail, v2, v3 size = width * nel - *(*[2]Tsize_t)(unsafe.Pointer(bp + 192)) = [2]Tsize_t{ + **(**[2]Tsize_t)(__ccgo_up(bp + 192)) = [2]Tsize_t{ 0: uint32(1), } pshift = int32(1) @@ -144988,12 +144988,12 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm high = head + uintptr(size) - uintptr(width) /* Precompute Leonardo numbers, scaled by element width */ v2 = width - (*(*[48]Tsize_t)(unsafe.Pointer(bp)))[int32(1)] = v2 - (*(*[48]Tsize_t)(unsafe.Pointer(bp)))[0] = v2 + (**(**[48]Tsize_t)(__ccgo_up(bp)))[int32(1)] = v2 + (**(**[48]Tsize_t)(__ccgo_up(bp)))[0] = v2 i = Uint32FromInt32(2) for { - v3 = (*(*[48]Tsize_t)(unsafe.Pointer(bp)))[i-uint32(2)] + (*(*[48]Tsize_t)(unsafe.Pointer(bp)))[i-uint32(1)] + width - (*(*[48]Tsize_t)(unsafe.Pointer(bp)))[i] = v3 + v3 = (**(**[48]Tsize_t)(__ccgo_up(bp)))[i-uint32(2)] + (**(**[48]Tsize_t)(__ccgo_up(bp)))[i-uint32(1)] + width + (**(**[48]Tsize_t)(__ccgo_up(bp)))[i] = v3 if !(v3 < size) { break } @@ -145003,12 +145003,12 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm i = i + 1 } for head < high { - if (*(*[2]Tsize_t)(unsafe.Pointer(bp + 192)))[0]&uint32(3) == uint32(3) { + if (**(**[2]Tsize_t)(__ccgo_up(bp + 192)))[0]&uint32(3) == uint32(3) { _sift(tls, head, width, __ccgo_fp_cmp, arg, pshift, bp) _shr(tls, bp+192, int32(2)) pshift = pshift + int32(2) } else { - if (*(*[48]Tsize_t)(unsafe.Pointer(bp)))[pshift-int32(1)] >= Uint32FromInt32(int32(high)-int32(head)) { + if (**(**[48]Tsize_t)(__ccgo_up(bp)))[pshift-int32(1)] >= Uint32FromInt32(int32(high)-int32(head)) { _trinkle(tls, head, width, __ccgo_fp_cmp, arg, bp+192, pshift, 0, bp) } else { _sift(tls, head, width, __ccgo_fp_cmp, arg, pshift, bp) @@ -145021,11 +145021,11 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm pshift = int32(1) } } - *(*Tsize_t)(unsafe.Pointer(bp + 192)) |= uint32(1) + **(**Tsize_t)(__ccgo_up(bp + 192)) |= uint32(1) head = head + uintptr(width) } _trinkle(tls, head, width, __ccgo_fp_cmp, arg, bp+192, pshift, 0, bp) - for pshift != int32(1) || (*(*[2]Tsize_t)(unsafe.Pointer(bp + 192)))[0] != uint32(1) || (*(*[2]Tsize_t)(unsafe.Pointer(bp + 192)))[int32(1)] != uint32(0) { + for pshift != int32(1) || (**(**[2]Tsize_t)(__ccgo_up(bp + 192)))[0] != uint32(1) || (**(**[2]Tsize_t)(__ccgo_up(bp + 192)))[int32(1)] != uint32(0) { if pshift <= int32(1) { trail = _pntz(tls, bp+192) _shr(tls, bp+192, trail) @@ -145033,11 +145033,11 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm } else { _shl(tls, bp+192, int32(2)) pshift = pshift - int32(2) - *(*Tsize_t)(unsafe.Pointer(bp + 192)) ^= uint32(7) + **(**Tsize_t)(__ccgo_up(bp + 192)) ^= uint32(7) _shr(tls, bp+192, int32(1)) - _trinkle(tls, head-uintptr((*(*[48]Tsize_t)(unsafe.Pointer(bp)))[pshift])-uintptr(width), width, __ccgo_fp_cmp, arg, bp+192, pshift+int32(1), int32(1), bp) + _trinkle(tls, head-uintptr((**(**[48]Tsize_t)(__ccgo_up(bp)))[pshift])-uintptr(width), width, __ccgo_fp_cmp, arg, bp+192, pshift+int32(1), int32(1), bp) _shl(tls, bp+192, int32(1)) - *(*Tsize_t)(unsafe.Pointer(bp + 192)) |= uint32(1) + **(**Tsize_t)(__ccgo_up(bp + 192)) |= uint32(1) _trinkle(tls, head-uintptr(width), width, __ccgo_fp_cmp, arg, bp+192, pshift, int32(1), bp) } head = head - uintptr(width) @@ -145087,7 +145087,7 @@ func _strtox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { } else { v1 = s } - *(*uintptr)(unsafe.Pointer(p)) = v1 + **(**uintptr)(__ccgo_up(p)) = v1 } return y } @@ -145132,7 +145132,7 @@ func _strtox1(tls *TLS, s uintptr, p uintptr, base int32, lim uint64) (r uint64) y = X__intscan(tls, bp, Uint32FromInt32(base), int32(1), lim) if p != 0 { cnt = Uint32FromInt64((*TFILE)(unsafe.Pointer(bp)).Fshcnt + int64(int32((*TFILE)(unsafe.Pointer(bp)).Frpos)-int32((*TFILE)(unsafe.Pointer(bp)).Fbuf))) - *(*uintptr)(unsafe.Pointer(p)) = s + uintptr(cnt) + **(**uintptr)(__ccgo_up(p)) = s + uintptr(cnt) } return y } @@ -145243,20 +145243,20 @@ func _do_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { var v2 int32 _, _, _, _, _ = i, wcs, v2, v3, v4 wcs = (*TFILE)(unsafe.Pointer(f)).Fcookie - if !(*(*Twchar_t)(unsafe.Pointer(wcs)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(wcs)) != 0) { wcs = __ccgo_ts + 1555 } i = uint32(0) for { - if !(i < (*TFILE)(unsafe.Pointer(f)).Fbuf_size && *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) != 0) { + if !(i < (*TFILE)(unsafe.Pointer(f)).Fbuf_size && **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) != 0) { break } - if *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) < int32(128) { - v2 = *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) + if **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) < int32(128) { + v2 = **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) } else { v2 = int32('@') } - *(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(i))) = Uint8FromInt32(v2) + **(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(i))) = Uint8FromInt32(v2) goto _1 _1: ; @@ -145269,7 +145269,7 @@ func _do_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(buf)) = **(**uint8)(__ccgo_up(v3)) return uint32(1) } return uint32(0) @@ -145285,20 +145285,20 @@ func _wcstox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { var _ /* f at bp+64 */ TFILE _, _, _, _, _ = cnt, t, y, v1, v2 t = s - *(*TFILE)(unsafe.Pointer(bp + 64)) = TFILE{} - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fflags = uint32(0) + **(**TFILE)(__ccgo_up(bp + 64)) = TFILE{} + (**(**TFILE)(__ccgo_up(bp + 64))).Fflags = uint32(0) v2 = bp + UintptrFromInt32(4) - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fbuf = v2 + (**(**TFILE)(__ccgo_up(bp + 64))).Fbuf = v2 v1 = v2 - (*(*TFILE)(unsafe.Pointer(bp + 64))).Frend = v1 - (*(*TFILE)(unsafe.Pointer(bp + 64))).Frpos = v1 - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fbuf_size = Uint32FromInt64(64) - Uint32FromInt32(4) + (**(**TFILE)(__ccgo_up(bp + 64))).Frend = v1 + (**(**TFILE)(__ccgo_up(bp + 64))).Frpos = v1 + (**(**TFILE)(__ccgo_up(bp + 64))).Fbuf_size = Uint32FromInt64(64) - Uint32FromInt32(4) AtomicStorePInt32(bp+64+76, -int32(1)) - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fread = __ccgo_fp(_do_read) - for Xiswspace(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(t)))) != 0 { + (**(**TFILE)(__ccgo_up(bp + 64))).Fread = __ccgo_fp(_do_read) + for Xiswspace(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(t)))) != 0 { t += 4 } - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fcookie = t + (**(**TFILE)(__ccgo_up(bp + 64))).Fcookie = t X__shlim(tls, bp+64, int64(Int32FromInt32(0))) y = X__floatscan(tls, bp+64, prec, int32(1)) if p != 0 { @@ -145308,7 +145308,7 @@ func _wcstox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { } else { v1 = s } - *(*uintptr)(unsafe.Pointer(p)) = v1 + **(**uintptr)(__ccgo_up(p)) = v1 } return y } @@ -145347,20 +145347,20 @@ func _do_read1(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { var v2 int32 _, _, _, _, _ = i, wcs, v2, v3, v4 wcs = (*TFILE)(unsafe.Pointer(f)).Fcookie - if !(*(*Twchar_t)(unsafe.Pointer(wcs)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(wcs)) != 0) { wcs = __ccgo_ts + 1555 } i = uint32(0) for { - if !(i < (*TFILE)(unsafe.Pointer(f)).Fbuf_size && *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) != 0) { + if !(i < (*TFILE)(unsafe.Pointer(f)).Fbuf_size && **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) != 0) { break } - if *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) < int32(128) { - v2 = *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) + if **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) < int32(128) { + v2 = **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) } else { v2 = int32('@') } - *(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(i))) = Uint8FromInt32(v2) + **(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(i))) = Uint8FromInt32(v2) goto _1 _1: ; @@ -145373,7 +145373,7 @@ func _do_read1(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(buf)) = **(**uint8)(__ccgo_up(v3)) return uint32(1) } return uint32(0) @@ -145389,20 +145389,20 @@ func _wcstox1(tls *TLS, s uintptr, p uintptr, base int32, lim uint64) (r uint64) var _ /* f at bp+64 */ TFILE _, _, _, _, _ = cnt, t, y, v1, v2 t = s - *(*TFILE)(unsafe.Pointer(bp + 64)) = TFILE{} - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fflags = uint32(0) + **(**TFILE)(__ccgo_up(bp + 64)) = TFILE{} + (**(**TFILE)(__ccgo_up(bp + 64))).Fflags = uint32(0) v2 = bp + UintptrFromInt32(4) - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fbuf = v2 + (**(**TFILE)(__ccgo_up(bp + 64))).Fbuf = v2 v1 = v2 - (*(*TFILE)(unsafe.Pointer(bp + 64))).Frend = v1 - (*(*TFILE)(unsafe.Pointer(bp + 64))).Frpos = v1 - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fbuf_size = Uint32FromInt64(64) - Uint32FromInt32(4) + (**(**TFILE)(__ccgo_up(bp + 64))).Frend = v1 + (**(**TFILE)(__ccgo_up(bp + 64))).Frpos = v1 + (**(**TFILE)(__ccgo_up(bp + 64))).Fbuf_size = Uint32FromInt64(64) - Uint32FromInt32(4) AtomicStorePInt32(bp+64+76, -int32(1)) - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fread = __ccgo_fp(_do_read1) - for Xiswspace(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(t)))) != 0 { + (**(**TFILE)(__ccgo_up(bp + 64))).Fread = __ccgo_fp(_do_read1) + for Xiswspace(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(t)))) != 0 { t += 4 } - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fcookie = t + (**(**TFILE)(__ccgo_up(bp + 64))).Fcookie = t X__shlim(tls, bp+64, int64(Int32FromInt32(0))) y = X__intscan(tls, bp+64, Uint32FromInt32(base), int32(1), lim) if p != 0 { @@ -145412,7 +145412,7 @@ func _wcstox1(tls *TLS, s uintptr, p uintptr, base int32, lim uint64) (r uint64) } else { v1 = s } - *(*uintptr)(unsafe.Pointer(p)) = v1 + **(**uintptr)(__ccgo_up(p)) = v1 } return y } @@ -145531,8 +145531,8 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt if uint32(s)&(Uint32FromInt64(4)-Uint32FromInt32(1)) == uint32(d)&(Uint32FromInt64(4)-Uint32FromInt32(1)) { for { if v3 = uint32(s)&(Uint32FromInt64(4)-Uint32FromInt32(1)) != 0 && n != 0; v3 { - v2 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v2 + v2 = **(**uint8)(__ccgo_up(s)) + **(**uint8)(__ccgo_up(d)) = v2 } if !(v3 && Int32FromUint8(v2) != c) { break @@ -145551,10 +145551,10 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt wd = d ws = s for { - if !(n >= uint32(4) && !((*(*uint32)(unsafe.Pointer(ws))^k-Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)) & ^(*(*uint32)(unsafe.Pointer(ws))^k) & (Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)*Uint32FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { + if !(n >= uint32(4) && !((**(**uint32)(__ccgo_up(ws))^k-Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)) & ^(**(**uint32)(__ccgo_up(ws))^k) & (Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)*Uint32FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { break } - *(*uint32)(unsafe.Pointer(wd)) = *(*uint32)(unsafe.Pointer(ws)) + **(**uint32)(__ccgo_up(wd)) = **(**uint32)(__ccgo_up(ws)) goto _4 _4: ; @@ -145567,8 +145567,8 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt } for { if v3 = n != 0; v3 { - v2 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v2 + v2 = **(**uint8)(__ccgo_up(s)) + **(**uint8)(__ccgo_up(d)) = v2 } if !(v3 && Int32FromUint8(v2) != c) { break @@ -145611,7 +145611,7 @@ func Xmemchr(tls *TLS, src uintptr, c int32, n Tsize_t) (r uintptr) { s = src c = Int32FromUint8(Uint8FromInt32(c)) for { - if !(uint32(s)&(Uint32FromInt64(4)-Uint32FromInt32(1)) != 0 && n != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != c) { + if !(uint32(s)&(Uint32FromInt64(4)-Uint32FromInt32(1)) != 0 && n != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != c) { break } goto _1 @@ -145620,11 +145620,11 @@ func Xmemchr(tls *TLS, src uintptr, c int32, n Tsize_t) (r uintptr) { s = s + 1 n = n - 1 } - if n != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != c { + if n != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != c { k = Uint32FromInt32(-Int32FromInt32(1)) / Uint32FromInt32(UCHAR_MAX) * Uint32FromInt32(c) w = s for { - if !(n >= Uint32FromInt64(4) && !((*(*uint32)(unsafe.Pointer(w))^k-Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)) & ^(*(*uint32)(unsafe.Pointer(w))^k) & (Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)*Uint32FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { + if !(n >= Uint32FromInt64(4) && !((**(**uint32)(__ccgo_up(w))^k-Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)) & ^(**(**uint32)(__ccgo_up(w))^k) & (Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)*Uint32FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { break } goto _2 @@ -145636,7 +145636,7 @@ func Xmemchr(tls *TLS, src uintptr, c int32, n Tsize_t) (r uintptr) { s = w } for { - if !(n != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != c) { + if !(n != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != c) { break } goto _3 @@ -145664,7 +145664,7 @@ func Xmemcmp(tls *TLS, vl uintptr, vr uintptr, n Tsize_t) (r1 int32) { l = vl r = vr for { - if !(n != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))) { + if !(n != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(l))) == Int32FromUint8(**(**uint8)(__ccgo_up(r)))) { break } goto _1 @@ -145675,7 +145675,7 @@ func Xmemcmp(tls *TLS, vl uintptr, vr uintptr, n Tsize_t) (r1 int32) { r = r + 1 } if n != 0 { - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(l))) - Int32FromUint8(**(**uint8)(__ccgo_up(r))) } else { v2 = 0 } @@ -145703,7 +145703,7 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) goto _1 _1: ; @@ -145714,10 +145714,10 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { if !(n >= uint32(16)) { break } - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(0))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(4))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(4))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(8))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(8))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(12))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(12))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(0))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(0))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(4))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(4))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(8))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(8))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(12))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(12))) goto _4 _4: ; @@ -145726,13 +145726,13 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { n = n - uint32(16) } if n&uint32(8) != 0 { - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(0))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(4))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(4))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(0))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(0))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(4))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(4))) d = d + uintptr(8) s = s + uintptr(8) } if n&uint32(4) != 0 { - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(0))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(0))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(0))) d = d + uintptr(4) s = s + uintptr(4) } @@ -145741,50 +145741,50 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) } if n&uint32(1) != 0 { - *(*uint8)(unsafe.Pointer(d)) = *(*uint8)(unsafe.Pointer(s)) + **(**uint8)(__ccgo_up(d)) = **(**uint8)(__ccgo_up(s)) } return dest } if n >= uint32(32) { switch uint32(d) % Uint32FromInt32(4) { case uint32(1): - w = *(*uint32)(unsafe.Pointer(s)) + w = **(**uint32)(__ccgo_up(s)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) n = n - uint32(3) for { if !(n >= uint32(17)) { break } - x = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(1))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = w>>Int32FromInt32(24) | x<>Int32FromInt32(24) | w<>Int32FromInt32(24) | x<>Int32FromInt32(24) | w<>Int32FromInt32(24) | x<>Int32FromInt32(24) | w<>Int32FromInt32(24) | x<>Int32FromInt32(24) | w<= uint32(18)) { break } - x = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(2))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = w>>Int32FromInt32(16) | x<>Int32FromInt32(16) | w<>Int32FromInt32(16) | x<>Int32FromInt32(16) | w<>Int32FromInt32(16) | x<>Int32FromInt32(16) | w<>Int32FromInt32(16) | x<>Int32FromInt32(16) | w<= uint32(19)) { break } - x = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(3))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = w>>Int32FromInt32(8) | x<>Int32FromInt32(8) | w<>Int32FromInt32(8) | x<>Int32FromInt32(8) | w<>Int32FromInt32(8) | x<>Int32FromInt32(8) | w<>Int32FromInt32(8) | x<>Int32FromInt32(8) | w< Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(ip+k)))) > Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(jp+k)))) { jp = jp + k k = uint32(1) p = jp - ip @@ -146186,7 +146186,7 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin p = v2 k = v2 for jp+k < l { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(ip+k)))) == Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(jp+k)))) { if k == p { jp = jp + p k = uint32(1) @@ -146194,7 +146194,7 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin k = k + 1 } } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) < Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(ip+k)))) < Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(jp+k)))) { jp = jp + k k = uint32(1) p = jp - ip @@ -146233,8 +146233,8 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin return uintptr(0) } /* Check last byte first; advance by shift on mismatch */ - if (*(*[8]Tsize_t)(unsafe.Pointer(bp)))[uint32(*(*uint8)(unsafe.Pointer(h + uintptr(l-uint32(1)))))/(Uint32FromInt32(8)*Uint32FromInt64(4))]&(Uint32FromInt32(1)<<(uint32(*(*uint8)(unsafe.Pointer(h + uintptr(l-uint32(1)))))%(Uint32FromInt32(8)*Uint32FromInt64(4)))) != 0 { - k = l - shift[*(*uint8)(unsafe.Pointer(h + uintptr(l-uint32(1))))] + if (**(**[8]Tsize_t)(__ccgo_up(bp)))[uint32(**(**uint8)(__ccgo_up(h + uintptr(l-uint32(1)))))/(Uint32FromInt32(8)*Uint32FromInt64(4))]&(Uint32FromInt32(1)<<(uint32(**(**uint8)(__ccgo_up(h + uintptr(l-uint32(1)))))%(Uint32FromInt32(8)*Uint32FromInt64(4)))) != 0 { + k = l - shift[**(**uint8)(__ccgo_up(h + uintptr(l-uint32(1))))] if k != 0 { if k < mem { k = mem @@ -146256,7 +146256,7 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin } k = v8 for { - if !(k < l && Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(h + uintptr(k))))) { + if !(k < l && Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(k)))) == Int32FromUint8(**(**uint8)(__ccgo_up(h + uintptr(k))))) { break } goto _10 @@ -146272,7 +146272,7 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin /* Compare left half */ k = ms + uint32(1) for { - if !(k > mem && Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(k-uint32(1))))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(h + uintptr(k-uint32(1)))))) { + if !(k > mem && Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(k-uint32(1))))) == Int32FromUint8(**(**uint8)(__ccgo_up(h + uintptr(k-uint32(1)))))) { break } goto _12 @@ -146309,7 +146309,7 @@ func Xmemmem(tls *TLS, h0 uintptr, k Tsize_t, n0 uintptr, l Tsize_t) (r uintptr) return uintptr(0) } /* Use faster algorithms for short needles */ - h = Xmemchr(tls, h0, Int32FromUint8(*(*uint8)(unsafe.Pointer(n))), k) + h = Xmemchr(tls, h0, Int32FromUint8(**(**uint8)(__ccgo_up(n))), k) if !(h != 0) || l == uint32(1) { return h } @@ -146361,13 +146361,13 @@ func Xmemmove(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { d = d + 1 v3 = s s = s + 1 - *(*int8)(unsafe.Pointer(v2)) = *(*int8)(unsafe.Pointer(v3)) + **(**int8)(__ccgo_up(v2)) = **(**int8)(__ccgo_up(v3)) } for { if !(n >= Uint32FromInt64(4)) { break } - *(*TWT)(unsafe.Pointer(d)) = *(*TWT)(unsafe.Pointer(s)) + **(**TWT)(__ccgo_up(d)) = **(**TWT)(__ccgo_up(s)) goto _4 _4: ; @@ -146384,7 +146384,7 @@ func Xmemmove(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { d = d + 1 v3 = s s = s + 1 - *(*int8)(unsafe.Pointer(v2)) = *(*int8)(unsafe.Pointer(v3)) + **(**int8)(__ccgo_up(v2)) = **(**int8)(__ccgo_up(v3)) goto _5 _5: ; @@ -146398,16 +146398,16 @@ func Xmemmove(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { if !(v1 != 0) { return dest } - *(*int8)(unsafe.Pointer(d + uintptr(n))) = *(*int8)(unsafe.Pointer(s + uintptr(n))) + **(**int8)(__ccgo_up(d + uintptr(n))) = **(**int8)(__ccgo_up(s + uintptr(n))) } for n >= Uint32FromInt64(4) { n = n - Uint32FromInt64(4) - *(*TWT)(unsafe.Pointer(d + uintptr(n))) = *(*TWT)(unsafe.Pointer(s + uintptr(n))) + **(**TWT)(__ccgo_up(d + uintptr(n))) = **(**TWT)(__ccgo_up(s + uintptr(n))) } } for n != 0 { n = n - 1 - *(*int8)(unsafe.Pointer(d + uintptr(n))) = *(*int8)(unsafe.Pointer(s + uintptr(n))) + **(**int8)(__ccgo_up(d + uintptr(n))) = **(**int8)(__ccgo_up(s + uintptr(n))) } } return dest @@ -146437,7 +146437,7 @@ func X__memrchr(tls *TLS, m uintptr, c int32, n Tsize_t) (r uintptr) { if !(v1 != 0) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(n)))) == c { + if Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(n)))) == c { return s + uintptr(n) } } @@ -146469,20 +146469,20 @@ func Xmemset(tls *TLS, dest uintptr, c int32, n Tsize_t) (r uintptr) { if !(n != 0) { return dest } - *(*uint8)(unsafe.Pointer(s)) = Uint8FromInt32(c) - *(*uint8)(unsafe.Pointer(s + uintptr(n-uint32(1)))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s)) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + uintptr(n-uint32(1)))) = Uint8FromInt32(c) if n <= uint32(2) { return dest } - *(*uint8)(unsafe.Pointer(s + 1)) = Uint8FromInt32(c) - *(*uint8)(unsafe.Pointer(s + 2)) = Uint8FromInt32(c) - *(*uint8)(unsafe.Pointer(s + uintptr(n-uint32(2)))) = Uint8FromInt32(c) - *(*uint8)(unsafe.Pointer(s + uintptr(n-uint32(3)))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + 1)) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + 2)) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + uintptr(n-uint32(2)))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + uintptr(n-uint32(3)))) = Uint8FromInt32(c) if n <= uint32(6) { return dest } - *(*uint8)(unsafe.Pointer(s + 3)) = Uint8FromInt32(c) - *(*uint8)(unsafe.Pointer(s + uintptr(n-uint32(4)))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + 3)) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + uintptr(n-uint32(4)))) = Uint8FromInt32(c) if n <= uint32(8) { return dest } @@ -146500,26 +146500,26 @@ func Xmemset(tls *TLS, dest uintptr, c int32, n Tsize_t) (r uintptr) { * As in the initial byte-based head/tail fill, each * conditional below ensures that the subsequent offsets * are valid (e.g. !(n<=24) implies n>=28). */ - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(0))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(4))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(0))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(4))) = c32 if n <= uint32(8) { return dest } - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(4))) = c32 - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(8))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(12))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(8))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(4))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(8))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(12))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(8))) = c32 if n <= uint32(24) { return dest } - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(12))) = c32 - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(16))) = c32 - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(20))) = c32 - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(24))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(28))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(24))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(20))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(16))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(12))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(16))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(20))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(24))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(28))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(24))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(20))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(16))) = c32 /* Align to a multiple of 8 so we can fill 64 bits at a time, * and avoid writing the same bytes twice as much as is * practical without introducing additional branching. */ @@ -146534,10 +146534,10 @@ func Xmemset(tls *TLS, dest uintptr, c int32, n Tsize_t) (r uintptr) { if !(n >= uint32(32)) { break } - *(*uint64)(unsafe.Pointer(s + UintptrFromInt32(0))) = c64 - *(*uint64)(unsafe.Pointer(s + UintptrFromInt32(8))) = c64 - *(*uint64)(unsafe.Pointer(s + UintptrFromInt32(16))) = c64 - *(*uint64)(unsafe.Pointer(s + UintptrFromInt32(24))) = c64 + **(**uint64)(__ccgo_up(s + UintptrFromInt32(0))) = c64 + **(**uint64)(__ccgo_up(s + UintptrFromInt32(8))) = c64 + **(**uint64)(__ccgo_up(s + UintptrFromInt32(16))) = c64 + **(**uint64)(__ccgo_up(s + UintptrFromInt32(24))) = c64 goto _1 _1: ; @@ -146579,8 +146579,8 @@ func X__stpcpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { if !(uint32(s)%Uint32FromInt64(4) != 0) { break } - v2 = *(*int8)(unsafe.Pointer(s)) - *(*int8)(unsafe.Pointer(d)) = v2 + v2 = **(**int8)(__ccgo_up(s)) + **(**int8)(__ccgo_up(d)) = v2 if !(v2 != 0) { return d } @@ -146593,7 +146593,7 @@ func X__stpcpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { wd = d ws = s for { - if !!((*(*uint32)(unsafe.Pointer(ws))-Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)) & ^*(*uint32)(unsafe.Pointer(ws)) & (Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)*Uint32FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0) { + if !!((**(**uint32)(__ccgo_up(ws))-Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)) & ^**(**uint32)(__ccgo_up(ws)) & (Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)*Uint32FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0) { break } goto _3 @@ -146603,14 +146603,14 @@ func X__stpcpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { wd += 4 v5 = ws ws += 4 - *(*uint32)(unsafe.Pointer(v4)) = *(*uint32)(unsafe.Pointer(v5)) + **(**uint32)(__ccgo_up(v4)) = **(**uint32)(__ccgo_up(v5)) } d = wd s = ws } for { - v2 = *(*int8)(unsafe.Pointer(s)) - *(*int8)(unsafe.Pointer(d)) = v2 + v2 = **(**int8)(__ccgo_up(s)) + **(**int8)(__ccgo_up(d)) = v2 if !(v2 != 0) { break } @@ -146663,8 +146663,8 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { if uint32(s)&(Uint32FromInt64(4)-Uint32FromInt32(1)) == uint32(d)&(Uint32FromInt64(4)-Uint32FromInt32(1)) { for { if v3 = uint32(s)&(Uint32FromInt64(4)-Uint32FromInt32(1)) != 0 && n != 0; v3 { - v2 = *(*int8)(unsafe.Pointer(s)) - *(*int8)(unsafe.Pointer(d)) = v2 + v2 = **(**int8)(__ccgo_up(s)) + **(**int8)(__ccgo_up(d)) = v2 } if !(v3 && v2 != 0) { break @@ -146676,16 +146676,16 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { s = s + 1 d = d + 1 } - if !(n != 0) || !(*(*int8)(unsafe.Pointer(s)) != 0) { + if !(n != 0) || !(**(**int8)(__ccgo_up(s)) != 0) { goto tail } wd = d ws = s for { - if !(n >= uint32(4) && !((*(*uint32)(unsafe.Pointer(ws))-Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)) & ^*(*uint32)(unsafe.Pointer(ws)) & (Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)*Uint32FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { + if !(n >= uint32(4) && !((**(**uint32)(__ccgo_up(ws))-Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)) & ^**(**uint32)(__ccgo_up(ws)) & (Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)*Uint32FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { break } - *(*uint32)(unsafe.Pointer(wd)) = *(*uint32)(unsafe.Pointer(ws)) + **(**uint32)(__ccgo_up(wd)) = **(**uint32)(__ccgo_up(ws)) goto _4 _4: ; @@ -146698,8 +146698,8 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { } for { if v3 = n != 0; v3 { - v2 = *(*int8)(unsafe.Pointer(s)) - *(*int8)(unsafe.Pointer(d)) = v2 + v2 = **(**int8)(__ccgo_up(s)) + **(**int8)(__ccgo_up(d)) = v2 } if !(v3 && v2 != 0) { break @@ -146745,7 +146745,7 @@ func Xstrcasecmp(tls *TLS, _l uintptr, _r uintptr) (r1 int32) { l = _l r = _r for { - if !(*(*uint8)(unsafe.Pointer(l)) != 0 && *(*uint8)(unsafe.Pointer(r)) != 0 && (Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) || Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(l)))) == Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))))) { + if !(**(**uint8)(__ccgo_up(l)) != 0 && **(**uint8)(__ccgo_up(r)) != 0 && (Int32FromUint8(**(**uint8)(__ccgo_up(l))) == Int32FromUint8(**(**uint8)(__ccgo_up(r))) || Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(l)))) == Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(r)))))) { break } goto _1 @@ -146754,7 +146754,7 @@ func Xstrcasecmp(tls *TLS, _l uintptr, _r uintptr) (r1 int32) { l = l + 1 r = r + 1 } - return Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(l)))) - Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))) + return Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(l)))) - Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(r)))) } func X__strcasecmp_l(tls *TLS, l uintptr, r uintptr, loc Tlocale_t) (r1 int32) { @@ -146782,7 +146782,7 @@ func Xstrcasestr(tls *TLS, h uintptr, n uintptr) (r uintptr) { _ = l l = _strlen(tls, n) for { - if !(*(*int8)(unsafe.Pointer(h)) != 0) { + if !(**(**int8)(__ccgo_up(h)) != 0) { break } if !(Xstrncasecmp(tls, h, n, l) != 0) { @@ -146813,7 +146813,7 @@ func Xstrchr(tls *TLS, s uintptr, c int32) (r1 uintptr) { var r, v1 uintptr _, _ = r, v1 r = X__strchrnul(tls, s, c) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) == Int32FromUint8(Uint8FromInt32(c)) { + if Int32FromUint8(**(**uint8)(__ccgo_up(r))) == Int32FromUint8(Uint8FromInt32(c)) { v1 = r } else { v1 = uintptr(0) @@ -146848,7 +146848,7 @@ func X__strchrnul(tls *TLS, s uintptr, c int32) (r uintptr) { if !(uint32(s)%Uint32FromInt64(4) != 0) { break } - if !(*(*int8)(unsafe.Pointer(s)) != 0) || Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == c { + if !(**(**int8)(__ccgo_up(s)) != 0) || Int32FromUint8(**(**uint8)(__ccgo_up(s))) == c { return s } goto _1 @@ -146859,7 +146859,7 @@ func X__strchrnul(tls *TLS, s uintptr, c int32) (r uintptr) { k = Uint32FromInt32(-Int32FromInt32(1)) / Uint32FromInt32(UCHAR_MAX) * Uint32FromInt32(c) w = s for { - if !(!((*(*uint32)(unsafe.Pointer(w))-Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)) & ^*(*uint32)(unsafe.Pointer(w)) & (Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)*Uint32FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0) && !((*(*uint32)(unsafe.Pointer(w))^k-Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)) & ^(*(*uint32)(unsafe.Pointer(w))^k) & (Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)*Uint32FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { + if !(!((**(**uint32)(__ccgo_up(w))-Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)) & ^**(**uint32)(__ccgo_up(w)) & (Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)*Uint32FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0) && !((**(**uint32)(__ccgo_up(w))^k-Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)) & ^(**(**uint32)(__ccgo_up(w))^k) & (Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)*Uint32FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { break } goto _2 @@ -146869,7 +146869,7 @@ func X__strchrnul(tls *TLS, s uintptr, c int32) (r uintptr) { } s = w for { - if !(*(*int8)(unsafe.Pointer(s)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != c) { + if !(**(**int8)(__ccgo_up(s)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != c) { break } goto _3 @@ -146903,7 +146903,7 @@ func Xstrcmp(tls *TLS, l uintptr, r uintptr) (r1 int32) { defer func() { trc("-> %v", r1) }() } for { - if !(int32(*(*int8)(unsafe.Pointer(l))) == int32(*(*int8)(unsafe.Pointer(r))) && *(*int8)(unsafe.Pointer(l)) != 0) { + if !(int32(**(**int8)(__ccgo_up(l))) == int32(**(**int8)(__ccgo_up(r))) && **(**int8)(__ccgo_up(l)) != 0) { break } goto _1 @@ -146912,7 +146912,7 @@ func Xstrcmp(tls *TLS, l uintptr, r uintptr) (r1 int32) { l = l + 1 r = r + 1 } - return Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) + return Int32FromUint8(**(**uint8)(__ccgo_up(l))) - Int32FromUint8(**(**uint8)(__ccgo_up(r))) } func Xstrcpy(tls *TLS, dest uintptr, src uintptr) (r uintptr) { @@ -146936,14 +146936,14 @@ func Xstrcspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { var _ /* byteset at bp+0 */ [8]Tsize_t _, _, _ = a, v2, v3 a = s - if !(*(*int8)(unsafe.Pointer(c)) != 0) || !(*(*int8)(unsafe.Pointer(c + 1)) != 0) { - return Uint32FromInt32(int32(X__strchrnul(tls, s, int32(*(*int8)(unsafe.Pointer(c))))) - int32(a)) + if !(**(**int8)(__ccgo_up(c)) != 0) || !(**(**int8)(__ccgo_up(c + 1)) != 0) { + return Uint32FromInt32(int32(X__strchrnul(tls, s, int32(**(**int8)(__ccgo_up(c))))) - int32(a)) } Xmemset(tls, bp, 0, uint32(32)) for { - if v3 = *(*int8)(unsafe.Pointer(c)) != 0; v3 { - v2 = bp + uintptr(uint32(*(*uint8)(unsafe.Pointer(c)))/(Uint32FromInt32(8)*Uint32FromInt64(4)))*4 - *(*Tsize_t)(unsafe.Pointer(v2)) |= Uint32FromInt32(1) << (uint32(*(*uint8)(unsafe.Pointer(c))) % (Uint32FromInt32(8) * Uint32FromInt64(4))) + if v3 = **(**int8)(__ccgo_up(c)) != 0; v3 { + v2 = bp + uintptr(uint32(**(**uint8)(__ccgo_up(c)))/(Uint32FromInt32(8)*Uint32FromInt64(4)))*4 + *(*Tsize_t)(unsafe.Pointer(v2)) |= Uint32FromInt32(1) << (uint32(**(**uint8)(__ccgo_up(c))) % (Uint32FromInt32(8) * Uint32FromInt64(4))) } if !(v3 && *(*Tsize_t)(unsafe.Pointer(v2)) != 0) { break @@ -146954,7 +146954,7 @@ func Xstrcspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { c = c + 1 } for { - if !(*(*int8)(unsafe.Pointer(s)) != 0 && !((*(*[8]Tsize_t)(unsafe.Pointer(bp)))[uint32(*(*uint8)(unsafe.Pointer(s)))/(Uint32FromInt32(8)*Uint32FromInt64(4))]&(Uint32FromInt32(1)<<(uint32(*(*uint8)(unsafe.Pointer(s)))%(Uint32FromInt32(8)*Uint32FromInt64(4)))) != 0)) { + if !(**(**int8)(__ccgo_up(s)) != 0 && !((**(**[8]Tsize_t)(__ccgo_up(bp)))[uint32(**(**uint8)(__ccgo_up(s)))/(Uint32FromInt32(8)*Uint32FromInt64(4))]&(Uint32FromInt32(1)<<(uint32(**(**uint8)(__ccgo_up(s)))%(Uint32FromInt32(8)*Uint32FromInt64(4)))) != 0)) { break } goto _4 @@ -146994,7 +146994,7 @@ func Xstrerror_r(tls *TLS, err int32, buf uintptr, buflen Tsize_t) (r int32) { if l >= buflen { if buflen != 0 { Xmemcpy(tls, buf, msg, buflen-uint32(1)) - *(*int8)(unsafe.Pointer(buf + uintptr(buflen-uint32(1)))) = 0 + **(**int8)(__ccgo_up(buf + uintptr(buflen-uint32(1)))) = 0 } return int32(ERANGE) } @@ -147054,8 +147054,8 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { if uint32(s)&(Uint32FromInt64(4)-Uint32FromInt32(1)) == uint32(d)&(Uint32FromInt64(4)-Uint32FromInt32(1)) { for { if v4 = uint32(s)&(Uint32FromInt64(4)-Uint32FromInt32(1)) != 0 && n != 0; v4 { - v3 = *(*int8)(unsafe.Pointer(s)) - *(*int8)(unsafe.Pointer(d)) = v3 + v3 = **(**int8)(__ccgo_up(s)) + **(**int8)(__ccgo_up(d)) = v3 } if !(v4 && v3 != 0) { break @@ -147067,14 +147067,14 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { s = s + 1 d = d + 1 } - if n != 0 && *(*int8)(unsafe.Pointer(s)) != 0 { + if n != 0 && **(**int8)(__ccgo_up(s)) != 0 { wd = d ws = s for { - if !(n >= uint32(4) && !((*(*uint32)(unsafe.Pointer(ws))-Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)) & ^*(*uint32)(unsafe.Pointer(ws)) & (Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)*Uint32FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { + if !(n >= uint32(4) && !((**(**uint32)(__ccgo_up(ws))-Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)) & ^**(**uint32)(__ccgo_up(ws)) & (Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)*Uint32FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { break } - *(*Tsize_t)(unsafe.Pointer(wd)) = *(*uint32)(unsafe.Pointer(ws)) + **(**Tsize_t)(__ccgo_up(wd)) = **(**uint32)(__ccgo_up(ws)) goto _5 _5: ; @@ -147088,8 +147088,8 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { } for { if v4 = n != 0; v4 { - v3 = *(*int8)(unsafe.Pointer(s)) - *(*int8)(unsafe.Pointer(d)) = v3 + v3 = **(**int8)(__ccgo_up(s)) + **(**int8)(__ccgo_up(d)) = v3 } if !(v4 && v3 != 0) { break @@ -147101,7 +147101,7 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { s = s + 1 d = d + 1 } - *(*int8)(unsafe.Pointer(d)) = 0 + **(**int8)(__ccgo_up(d)) = 0 goto finish finish: ; @@ -147127,7 +147127,7 @@ func Xstrncasecmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { return 0 } for { - if !(*(*uint8)(unsafe.Pointer(l)) != 0 && *(*uint8)(unsafe.Pointer(r)) != 0 && n != 0 && (Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) || Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(l)))) == Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))))) { + if !(**(**uint8)(__ccgo_up(l)) != 0 && **(**uint8)(__ccgo_up(r)) != 0 && n != 0 && (Int32FromUint8(**(**uint8)(__ccgo_up(l))) == Int32FromUint8(**(**uint8)(__ccgo_up(r))) || Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(l)))) == Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(r)))))) { break } goto _2 @@ -147137,7 +147137,7 @@ func Xstrncasecmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { r = r + 1 n = n - 1 } - return Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(l)))) - Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))) + return Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(l)))) - Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(r)))) } func X__strncasecmp_l(tls *TLS, l uintptr, r uintptr, n Tsize_t, loc Tlocale_t) (r1 int32) { @@ -147165,17 +147165,17 @@ func Xstrncat(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { _, _, _ = a, v1, v2 a = d d = d + uintptr(_strlen(tls, d)) - for n != 0 && *(*int8)(unsafe.Pointer(s)) != 0 { + for n != 0 && **(**int8)(__ccgo_up(s)) != 0 { n = n - 1 v1 = d d = d + 1 v2 = s s = s + 1 - *(*int8)(unsafe.Pointer(v1)) = *(*int8)(unsafe.Pointer(v2)) + **(**int8)(__ccgo_up(v1)) = **(**int8)(__ccgo_up(v2)) } v1 = d d = d + 1 - *(*int8)(unsafe.Pointer(v1)) = 0 + **(**int8)(__ccgo_up(v1)) = 0 return a } @@ -147195,7 +147195,7 @@ func Xstrncmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { return 0 } for { - if !(*(*uint8)(unsafe.Pointer(l)) != 0 && *(*uint8)(unsafe.Pointer(r)) != 0 && n != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))) { + if !(**(**uint8)(__ccgo_up(l)) != 0 && **(**uint8)(__ccgo_up(r)) != 0 && n != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(l))) == Int32FromUint8(**(**uint8)(__ccgo_up(r)))) { break } goto _2 @@ -147205,7 +147205,7 @@ func Xstrncmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { r = r + 1 n = n - 1 } - return Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) + return Int32FromUint8(**(**uint8)(__ccgo_up(l))) - Int32FromUint8(**(**uint8)(__ccgo_up(r))) } func Xstrncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { @@ -147231,7 +147231,7 @@ func Xstrndup(tls *TLS, s uintptr, n Tsize_t) (r uintptr) { return UintptrFromInt32(0) } Xmemcpy(tls, d, s, l) - *(*int8)(unsafe.Pointer(d + uintptr(l))) = 0 + **(**int8)(__ccgo_up(d + uintptr(l))) = 0 return d } @@ -147260,7 +147260,7 @@ func Xstrpbrk(tls *TLS, s uintptr, b uintptr) (r uintptr) { var v1 uintptr _ = v1 s = s + uintptr(Xstrcspn(tls, s, b)) - if *(*int8)(unsafe.Pointer(s)) != 0 { + if **(**int8)(__ccgo_up(s)) != 0 { v1 = s } else { v1 = uintptr(0) @@ -147283,19 +147283,19 @@ func Xstrsep(tls *TLS, str uintptr, sep uintptr) (r uintptr) { } var end, s, v1 uintptr _, _, _ = end, s, v1 - s = *(*uintptr)(unsafe.Pointer(str)) + s = **(**uintptr)(__ccgo_up(str)) if !(s != 0) { return UintptrFromInt32(0) } end = s + uintptr(Xstrcspn(tls, s, sep)) - if *(*int8)(unsafe.Pointer(end)) != 0 { + if **(**int8)(__ccgo_up(end)) != 0 { v1 = end end = end + 1 - *(*int8)(unsafe.Pointer(v1)) = 0 + **(**int8)(__ccgo_up(v1)) = 0 } else { end = uintptr(0) } - *(*uintptr)(unsafe.Pointer(str)) = end + **(**uintptr)(__ccgo_up(str)) = end return s } @@ -147321,7 +147321,7 @@ func Xstrsignal(tls *TLS, signum int32) (r uintptr) { break } for { - if !(*(*int8)(unsafe.Pointer(s)) != 0) { + if !(**(**int8)(__ccgo_up(s)) != 0) { break } goto _3 @@ -147349,13 +147349,13 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { var _ /* byteset at bp+0 */ [8]Tsize_t _, _, _ = a, v3, v4 a = s - *(*[8]Tsize_t)(unsafe.Pointer(bp)) = [8]Tsize_t{} - if !(*(*int8)(unsafe.Pointer(c)) != 0) { + **(**[8]Tsize_t)(__ccgo_up(bp)) = [8]Tsize_t{} + if !(**(**int8)(__ccgo_up(c)) != 0) { return uint32(0) } - if !(*(*int8)(unsafe.Pointer(c + 1)) != 0) { + if !(**(**int8)(__ccgo_up(c + 1)) != 0) { for { - if !(int32(*(*int8)(unsafe.Pointer(s))) == int32(*(*int8)(unsafe.Pointer(c)))) { + if !(int32(**(**int8)(__ccgo_up(s))) == int32(**(**int8)(__ccgo_up(c)))) { break } goto _1 @@ -147366,9 +147366,9 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { return Uint32FromInt32(int32(s) - int32(a)) } for { - if v4 = *(*int8)(unsafe.Pointer(c)) != 0; v4 { - v3 = bp + uintptr(uint32(*(*uint8)(unsafe.Pointer(c)))/(Uint32FromInt32(8)*Uint32FromInt64(4)))*4 - *(*Tsize_t)(unsafe.Pointer(v3)) |= Uint32FromInt32(1) << (uint32(*(*uint8)(unsafe.Pointer(c))) % (Uint32FromInt32(8) * Uint32FromInt64(4))) + if v4 = **(**int8)(__ccgo_up(c)) != 0; v4 { + v3 = bp + uintptr(uint32(**(**uint8)(__ccgo_up(c)))/(Uint32FromInt32(8)*Uint32FromInt64(4)))*4 + *(*Tsize_t)(unsafe.Pointer(v3)) |= Uint32FromInt32(1) << (uint32(**(**uint8)(__ccgo_up(c))) % (Uint32FromInt32(8) * Uint32FromInt64(4))) } if !(v4 && *(*Tsize_t)(unsafe.Pointer(v3)) != 0) { break @@ -147379,7 +147379,7 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { c = c + 1 } for { - if !(*(*int8)(unsafe.Pointer(s)) != 0 && (*(*[8]Tsize_t)(unsafe.Pointer(bp)))[uint32(*(*uint8)(unsafe.Pointer(s)))/(Uint32FromInt32(8)*Uint32FromInt64(4))]&(Uint32FromInt32(1)<<(uint32(*(*uint8)(unsafe.Pointer(s)))%(Uint32FromInt32(8)*Uint32FromInt64(4)))) != 0) { + if !(**(**int8)(__ccgo_up(s)) != 0 && (**(**[8]Tsize_t)(__ccgo_up(bp)))[uint32(**(**uint8)(__ccgo_up(s)))/(Uint32FromInt32(8)*Uint32FromInt64(4))]&(Uint32FromInt32(1)<<(uint32(**(**uint8)(__ccgo_up(s)))%(Uint32FromInt32(8)*Uint32FromInt64(4)))) != 0) { break } goto _5 @@ -147394,11 +147394,11 @@ func _twobyte_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { var hw, nw Tuint16_t var v2 uintptr _, _, _ = hw, nw, v2 - nw = Uint16FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(n)))< Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(ip+k)))) > Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(jp+k)))) { jp = jp + k k = uint32(1) p = jp - ip @@ -147532,7 +147532,7 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { p = v2 k = v2 for jp+k < l { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(ip+k)))) == Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(jp+k)))) { if k == p { jp = jp + p k = uint32(1) @@ -147540,7 +147540,7 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { k = k + 1 } } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) < Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(ip+k)))) < Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(jp+k)))) { jp = jp + k k = uint32(1) p = jp - ip @@ -147591,8 +147591,8 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { } } /* Check last byte first; advance by shift on mismatch */ - if (*(*[8]Tsize_t)(unsafe.Pointer(bp)))[uint32(*(*uint8)(unsafe.Pointer(h + uintptr(l-uint32(1)))))/(Uint32FromInt32(8)*Uint32FromInt64(4))]&(Uint32FromInt32(1)<<(uint32(*(*uint8)(unsafe.Pointer(h + uintptr(l-uint32(1)))))%(Uint32FromInt32(8)*Uint32FromInt64(4)))) != 0 { - k = l - shift[*(*uint8)(unsafe.Pointer(h + uintptr(l-uint32(1))))] + if (**(**[8]Tsize_t)(__ccgo_up(bp)))[uint32(**(**uint8)(__ccgo_up(h + uintptr(l-uint32(1)))))/(Uint32FromInt32(8)*Uint32FromInt64(4))]&(Uint32FromInt32(1)<<(uint32(**(**uint8)(__ccgo_up(h + uintptr(l-uint32(1)))))%(Uint32FromInt32(8)*Uint32FromInt64(4)))) != 0 { + k = l - shift[**(**uint8)(__ccgo_up(h + uintptr(l-uint32(1))))] if k != 0 { if k < mem { k = mem @@ -147614,7 +147614,7 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { } k = v8 for { - if !(*(*uint8)(unsafe.Pointer(n + uintptr(k))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(h + uintptr(k))))) { + if !(**(**uint8)(__ccgo_up(n + uintptr(k))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(k)))) == Int32FromUint8(**(**uint8)(__ccgo_up(h + uintptr(k))))) { break } goto _10 @@ -147622,7 +147622,7 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { ; k = k + 1 } - if *(*uint8)(unsafe.Pointer(n + uintptr(k))) != 0 { + if **(**uint8)(__ccgo_up(n + uintptr(k))) != 0 { h = h + uintptr(k-ms) mem = uint32(0) goto _9 @@ -147630,7 +147630,7 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { /* Compare left half */ k = ms + uint32(1) for { - if !(k > mem && Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(k-uint32(1))))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(h + uintptr(k-uint32(1)))))) { + if !(k > mem && Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(k-uint32(1))))) == Int32FromUint8(**(**uint8)(__ccgo_up(h + uintptr(k-uint32(1)))))) { break } goto _12 @@ -147655,30 +147655,30 @@ func Xstrstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { defer func() { trc("-> %v", r) }() } /* Return immediately on empty needle */ - if !(*(*int8)(unsafe.Pointer(n)) != 0) { + if !(**(**int8)(__ccgo_up(n)) != 0) { return h } /* Use faster algorithms for short needles */ - h = Xstrchr(tls, h, int32(*(*int8)(unsafe.Pointer(n)))) - if !(h != 0) || !(*(*int8)(unsafe.Pointer(n + 1)) != 0) { + h = Xstrchr(tls, h, int32(**(**int8)(__ccgo_up(n)))) + if !(h != 0) || !(**(**int8)(__ccgo_up(n + 1)) != 0) { return h } - if !(*(*int8)(unsafe.Pointer(h + 1)) != 0) { + if !(**(**int8)(__ccgo_up(h + 1)) != 0) { return uintptr(0) } - if !(*(*int8)(unsafe.Pointer(n + 2)) != 0) { + if !(**(**int8)(__ccgo_up(n + 2)) != 0) { return _twobyte_strstr(tls, h, n) } - if !(*(*int8)(unsafe.Pointer(h + 2)) != 0) { + if !(**(**int8)(__ccgo_up(h + 2)) != 0) { return uintptr(0) } - if !(*(*int8)(unsafe.Pointer(n + 3)) != 0) { + if !(**(**int8)(__ccgo_up(n + 3)) != 0) { return _threebyte_strstr(tls, h, n) } - if !(*(*int8)(unsafe.Pointer(h + 3)) != 0) { + if !(**(**int8)(__ccgo_up(h + 3)) != 0) { return uintptr(0) } - if !(*(*int8)(unsafe.Pointer(n + 4)) != 0) { + if !(**(**int8)(__ccgo_up(n + 4)) != 0) { return _fourbyte_strstr(tls, h, n) } return _twoway_strstr(tls, h, n) @@ -147700,16 +147700,16 @@ func Xstrtok(tls *TLS, s uintptr, sep uintptr) (r uintptr) { return UintptrFromInt32(0) } s = s + uintptr(Xstrspn(tls, s, sep)) - if !(*(*int8)(unsafe.Pointer(s)) != 0) { + if !(**(**int8)(__ccgo_up(s)) != 0) { v1 = UintptrFromInt32(0) _p2 = v1 return v1 } _p2 = s + uintptr(Xstrcspn(tls, s, sep)) - if *(*int8)(unsafe.Pointer(_p2)) != 0 { + if **(**int8)(__ccgo_up(_p2)) != 0 { v1 = _p2 _p2 = _p2 + 1 - *(*int8)(unsafe.Pointer(v1)) = 0 + **(**int8)(__ccgo_up(v1)) = 0 } else { _p2 = uintptr(0) } @@ -147727,26 +147727,26 @@ func Xstrtok_r(tls *TLS, s uintptr, sep uintptr, p uintptr) (r uintptr) { var v2 bool _, _, _ = v1, v2, v3 if v2 = !(s != 0); v2 { - v1 = *(*uintptr)(unsafe.Pointer(p)) + v1 = **(**uintptr)(__ccgo_up(p)) s = v1 } if v2 && !(v1 != 0) { return UintptrFromInt32(0) } s = s + uintptr(Xstrspn(tls, s, sep)) - if !(*(*int8)(unsafe.Pointer(s)) != 0) { + if !(**(**int8)(__ccgo_up(s)) != 0) { v1 = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(p)) = v1 + **(**uintptr)(__ccgo_up(p)) = v1 return v1 } - *(*uintptr)(unsafe.Pointer(p)) = s + uintptr(Xstrcspn(tls, s, sep)) - if *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)))) != 0 { + **(**uintptr)(__ccgo_up(p)) = s + uintptr(Xstrcspn(tls, s, sep)) + if **(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)))) != 0 { v3 = p v1 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - *(*int8)(unsafe.Pointer(v1)) = 0 + **(**int8)(__ccgo_up(v1)) = 0 } else { - *(*uintptr)(unsafe.Pointer(p)) = uintptr(0) + **(**uintptr)(__ccgo_up(p)) = uintptr(0) } return s } @@ -147769,10 +147769,10 @@ func Xstrverscmp(tls *TLS, l0 uintptr, r0 uintptr) (r1 int32) { i = v2 dp = v2 for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(l + uintptr(i)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(r + uintptr(i))))) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(l + uintptr(i)))) == Int32FromUint8(**(**uint8)(__ccgo_up(r + uintptr(i))))) { break } - c = Int32FromUint8(*(*uint8)(unsafe.Pointer(l + uintptr(i)))) + c = Int32FromUint8(**(**uint8)(__ccgo_up(l + uintptr(i)))) if !(c != 0) { return 0 } @@ -147789,15 +147789,15 @@ func Xstrverscmp(tls *TLS, l0 uintptr, r0 uintptr) (r1 int32) { ; i = i + 1 } - if Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(l + uintptr(dp))))-int32('1')) < uint32(9) && Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(r + uintptr(dp))))-int32('1')) < uint32(9) { + if Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(l + uintptr(dp))))-int32('1')) < uint32(9) && Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(r + uintptr(dp))))-int32('1')) < uint32(9) { /* If we're looking at non-degenerate digit sequences starting * with nonzero digits, longest digit string is greater. */ j = i for { - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(l + uintptr(j))))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(l + uintptr(j))))-uint32('0') < uint32(10)) != 0) { break } - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(r + uintptr(j))))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(r + uintptr(j))))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return int32(1) } goto _3 @@ -147805,17 +147805,17 @@ func Xstrverscmp(tls *TLS, l0 uintptr, r0 uintptr) (r1 int32) { ; j = j + 1 } - if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(r + uintptr(j))))-uint32('0') < uint32(10)) != 0 { + if BoolInt32(uint32(**(**uint8)(__ccgo_up(r + uintptr(j))))-uint32('0') < uint32(10)) != 0 { return -int32(1) } } else { - if z != 0 && dp < i && (BoolInt32(uint32(*(*uint8)(unsafe.Pointer(l + uintptr(i))))-uint32('0') < uint32(10)) != 0 || BoolInt32(uint32(*(*uint8)(unsafe.Pointer(r + uintptr(i))))-uint32('0') < uint32(10)) != 0) { + if z != 0 && dp < i && (BoolInt32(uint32(**(**uint8)(__ccgo_up(l + uintptr(i))))-uint32('0') < uint32(10)) != 0 || BoolInt32(uint32(**(**uint8)(__ccgo_up(r + uintptr(i))))-uint32('0') < uint32(10)) != 0) { /* Otherwise, if common prefix of digit sequence is * all zeros, digits order less than non-digits. */ - return Int32FromUint8(Uint8FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(l + uintptr(i))))-Int32FromUint8('0'))) - Int32FromUint8(Uint8FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(r + uintptr(i))))-Int32FromUint8('0'))) + return Int32FromUint8(Uint8FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(l + uintptr(i))))-Int32FromUint8('0'))) - Int32FromUint8(Uint8FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(r + uintptr(i))))-Int32FromUint8('0'))) } } - return Int32FromUint8(*(*uint8)(unsafe.Pointer(l + uintptr(i)))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r + uintptr(i)))) + return Int32FromUint8(**(**uint8)(__ccgo_up(l + uintptr(i)))) - Int32FromUint8(**(**uint8)(__ccgo_up(r + uintptr(i)))) } func Xswab(tls *TLS, _src uintptr, _dest uintptr, n Tssize_t) { @@ -147830,8 +147830,8 @@ func Xswab(tls *TLS, _src uintptr, _dest uintptr, n Tssize_t) { if !(n > int32(1)) { break } - *(*int8)(unsafe.Pointer(dest)) = *(*int8)(unsafe.Pointer(src + 1)) - *(*int8)(unsafe.Pointer(dest + 1)) = *(*int8)(unsafe.Pointer(src)) + **(**int8)(__ccgo_up(dest)) = **(**int8)(__ccgo_up(src + 1)) + **(**int8)(__ccgo_up(dest + 1)) = **(**int8)(__ccgo_up(src)) dest = dest + uintptr(2) src = src + uintptr(2) goto _1 @@ -147893,7 +147893,7 @@ func Xwcschr(tls *TLS, s uintptr, c Twchar_t) (r uintptr) { return s + uintptr(Xwcslen(tls, s))*4 } for { - if !(*(*Twchar_t)(unsafe.Pointer(s)) != 0 && *(*Twchar_t)(unsafe.Pointer(s)) != c) { + if !(**(**Twchar_t)(__ccgo_up(s)) != 0 && **(**Twchar_t)(__ccgo_up(s)) != c) { break } goto _1 @@ -147901,7 +147901,7 @@ func Xwcschr(tls *TLS, s uintptr, c Twchar_t) (r uintptr) { ; s += 4 } - if *(*Twchar_t)(unsafe.Pointer(s)) != 0 { + if **(**Twchar_t)(__ccgo_up(s)) != 0 { v2 = s } else { v2 = uintptr(0) @@ -147917,7 +147917,7 @@ func Xwcscmp(tls *TLS, l uintptr, r uintptr) (r1 int32) { var v2 int32 _ = v2 for { - if !(*(*Twchar_t)(unsafe.Pointer(l)) == *(*Twchar_t)(unsafe.Pointer(r)) && *(*Twchar_t)(unsafe.Pointer(l)) != 0 && *(*Twchar_t)(unsafe.Pointer(r)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(l)) == **(**Twchar_t)(__ccgo_up(r)) && **(**Twchar_t)(__ccgo_up(l)) != 0 && **(**Twchar_t)(__ccgo_up(r)) != 0) { break } goto _1 @@ -147926,10 +147926,10 @@ func Xwcscmp(tls *TLS, l uintptr, r uintptr) (r1 int32) { l += 4 r += 4 } - if *(*Twchar_t)(unsafe.Pointer(l)) < *(*Twchar_t)(unsafe.Pointer(r)) { + if **(**Twchar_t)(__ccgo_up(l)) < **(**Twchar_t)(__ccgo_up(r)) { v2 = -int32(1) } else { - v2 = BoolInt32(*(*Twchar_t)(unsafe.Pointer(l)) > *(*Twchar_t)(unsafe.Pointer(r))) + v2 = BoolInt32(**(**Twchar_t)(__ccgo_up(l)) > **(**Twchar_t)(__ccgo_up(r))) } return v2 } @@ -147946,10 +147946,10 @@ func Xwcscpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { for { v2 = s s += 4 - v1 = *(*Twchar_t)(unsafe.Pointer(v2)) + v1 = **(**Twchar_t)(__ccgo_up(v2)) v3 = d d += 4 - *(*Twchar_t)(unsafe.Pointer(v3)) = v1 + **(**Twchar_t)(__ccgo_up(v3)) = v1 if !(v1 != 0) { break } @@ -147965,13 +147965,13 @@ func Xwcscspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { var a, v2, v3 uintptr var v1 uint32 _, _, _, _ = a, v1, v2, v3 - if !(*(*Twchar_t)(unsafe.Pointer(c)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(c)) != 0) { return Xwcslen(tls, s) } - if !(*(*Twchar_t)(unsafe.Pointer(c + 1*4)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(c + 1*4)) != 0) { v3 = s a = v3 - v2 = Xwcschr(tls, v3, *(*Twchar_t)(unsafe.Pointer(c))) + v2 = Xwcschr(tls, v3, **(**Twchar_t)(__ccgo_up(c))) s = v2 if v2 != 0 { v1 = Uint32FromInt32((int32(s) - int32(a)) / 4) @@ -147982,7 +147982,7 @@ func Xwcscspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { } a = s for { - if !(*(*Twchar_t)(unsafe.Pointer(s)) != 0 && !(Xwcschr(tls, c, *(*Twchar_t)(unsafe.Pointer(s))) != 0)) { + if !(**(**Twchar_t)(__ccgo_up(s)) != 0 && !(Xwcschr(tls, c, **(**Twchar_t)(__ccgo_up(s))) != 0)) { break } goto _4 @@ -148018,7 +148018,7 @@ func Xwcslen(tls *TLS, s uintptr) (r Tsize_t) { _ = a a = s for { - if !(*(*Twchar_t)(unsafe.Pointer(s)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(s)) != 0) { break } goto _1 @@ -148042,7 +148042,7 @@ func Xwcsncasecmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { return 0 } for { - if !(*(*Twchar_t)(unsafe.Pointer(l)) != 0 && *(*Twchar_t)(unsafe.Pointer(r)) != 0 && n != 0 && (*(*Twchar_t)(unsafe.Pointer(l)) == *(*Twchar_t)(unsafe.Pointer(r)) || Xtowlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(l)))) == Xtowlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(r)))))) { + if !(**(**Twchar_t)(__ccgo_up(l)) != 0 && **(**Twchar_t)(__ccgo_up(r)) != 0 && n != 0 && (**(**Twchar_t)(__ccgo_up(l)) == **(**Twchar_t)(__ccgo_up(r)) || Xtowlower(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(l)))) == Xtowlower(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(r)))))) { break } goto _2 @@ -148052,7 +148052,7 @@ func Xwcsncasecmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { r += 4 n = n - 1 } - return Int32FromUint32(Xtowlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(l)))) - Xtowlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(r))))) + return Int32FromUint32(Xtowlower(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(l)))) - Xtowlower(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(r))))) } func Xwcsncasecmp_l(tls *TLS, l uintptr, r uintptr, n Tsize_t, locale Tlocale_t) (r1 int32) { @@ -148072,17 +148072,17 @@ func Xwcsncat(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { _, _, _ = a, v1, v2 a = d d = d + uintptr(Xwcslen(tls, d))*4 - for n != 0 && *(*Twchar_t)(unsafe.Pointer(s)) != 0 { + for n != 0 && **(**Twchar_t)(__ccgo_up(s)) != 0 { n = n - 1 v1 = d d += 4 v2 = s s += 4 - *(*Twchar_t)(unsafe.Pointer(v1)) = *(*Twchar_t)(unsafe.Pointer(v2)) + **(**Twchar_t)(__ccgo_up(v1)) = **(**Twchar_t)(__ccgo_up(v2)) } v1 = d d += 4 - *(*Twchar_t)(unsafe.Pointer(v1)) = 0 + **(**Twchar_t)(__ccgo_up(v1)) = 0 return a } @@ -148094,7 +148094,7 @@ func Xwcsncmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { var v2, v3 int32 _, _ = v2, v3 for { - if !(n != 0 && *(*Twchar_t)(unsafe.Pointer(l)) == *(*Twchar_t)(unsafe.Pointer(r)) && *(*Twchar_t)(unsafe.Pointer(l)) != 0 && *(*Twchar_t)(unsafe.Pointer(r)) != 0) { + if !(n != 0 && **(**Twchar_t)(__ccgo_up(l)) == **(**Twchar_t)(__ccgo_up(r)) && **(**Twchar_t)(__ccgo_up(l)) != 0 && **(**Twchar_t)(__ccgo_up(r)) != 0) { break } goto _1 @@ -148105,10 +148105,10 @@ func Xwcsncmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { r += 4 } if n != 0 { - if *(*Twchar_t)(unsafe.Pointer(l)) < *(*Twchar_t)(unsafe.Pointer(r)) { + if **(**Twchar_t)(__ccgo_up(l)) < **(**Twchar_t)(__ccgo_up(r)) { v3 = -int32(1) } else { - v3 = BoolInt32(*(*Twchar_t)(unsafe.Pointer(l)) > *(*Twchar_t)(unsafe.Pointer(r))) + v3 = BoolInt32(**(**Twchar_t)(__ccgo_up(l)) > **(**Twchar_t)(__ccgo_up(r))) } v2 = v3 } else { @@ -148125,13 +148125,13 @@ func Xwcsncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { var a, v1, v2 uintptr _, _, _ = a, v1, v2 a = d - for n != 0 && *(*Twchar_t)(unsafe.Pointer(s)) != 0 { + for n != 0 && **(**Twchar_t)(__ccgo_up(s)) != 0 { n = n - 1 v1 = d d += 4 v2 = s s += 4 - *(*Twchar_t)(unsafe.Pointer(v1)) = *(*Twchar_t)(unsafe.Pointer(v2)) + **(**Twchar_t)(__ccgo_up(v1)) = **(**Twchar_t)(__ccgo_up(v2)) } Xwmemset(tls, d, 0, n) return a @@ -148159,7 +148159,7 @@ func Xwcspbrk(tls *TLS, s uintptr, b uintptr) (r uintptr) { var v1 uintptr _ = v1 s = s + uintptr(Xwcscspn(tls, s, b))*4 - if *(*Twchar_t)(unsafe.Pointer(s)) != 0 { + if **(**Twchar_t)(__ccgo_up(s)) != 0 { v1 = s } else { v1 = UintptrFromInt32(0) @@ -148176,7 +148176,7 @@ func Xwcsrchr(tls *TLS, s uintptr, c Twchar_t) (r uintptr) { _, _ = p, v2 p = s + uintptr(Xwcslen(tls, s))*4 for { - if !(p >= s && *(*Twchar_t)(unsafe.Pointer(p)) != c) { + if !(p >= s && **(**Twchar_t)(__ccgo_up(p)) != c) { break } goto _1 @@ -148201,7 +148201,7 @@ func Xwcsspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { _ = a a = s for { - if !(*(*Twchar_t)(unsafe.Pointer(s)) != 0 && Xwcschr(tls, c, *(*Twchar_t)(unsafe.Pointer(s))) != 0) { + if !(**(**Twchar_t)(__ccgo_up(s)) != 0 && Xwcschr(tls, c, **(**Twchar_t)(__ccgo_up(s))) != 0) { break } goto _1 @@ -148220,7 +148220,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { /* Computing length of needle */ l = uint32(0) for { - if !(*(*Twchar_t)(unsafe.Pointer(n + uintptr(l)*4)) != 0 && *(*Twchar_t)(unsafe.Pointer(h + uintptr(l)*4)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(n + uintptr(l)*4)) != 0 && **(**Twchar_t)(__ccgo_up(h + uintptr(l)*4)) != 0) { break } goto _1 @@ -148228,7 +148228,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { ; l = l + 1 } - if *(*Twchar_t)(unsafe.Pointer(n + uintptr(l)*4)) != 0 { + if **(**Twchar_t)(__ccgo_up(n + uintptr(l)*4)) != 0 { return uintptr(0) } /* hit the end of h */ /* Compute maximal suffix */ @@ -148238,7 +148238,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { p = v2 k = v2 for jp+k < l { - if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) == *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { + if **(**Twchar_t)(__ccgo_up(n + uintptr(ip+k)*4)) == **(**Twchar_t)(__ccgo_up(n + uintptr(jp+k)*4)) { if k == p { jp = jp + p k = uint32(1) @@ -148246,7 +148246,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { k = k + 1 } } else { - if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) > *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { + if **(**Twchar_t)(__ccgo_up(n + uintptr(ip+k)*4)) > **(**Twchar_t)(__ccgo_up(n + uintptr(jp+k)*4)) { jp = jp + k k = uint32(1) p = jp - ip @@ -148269,7 +148269,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { p = v2 k = v2 for jp+k < l { - if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) == *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { + if **(**Twchar_t)(__ccgo_up(n + uintptr(ip+k)*4)) == **(**Twchar_t)(__ccgo_up(n + uintptr(jp+k)*4)) { if k == p { jp = jp + p k = uint32(1) @@ -148277,7 +148277,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { k = k + 1 } } else { - if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) < *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { + if **(**Twchar_t)(__ccgo_up(n + uintptr(ip+k)*4)) < **(**Twchar_t)(__ccgo_up(n + uintptr(jp+k)*4)) { jp = jp + k k = uint32(1) p = jp - ip @@ -148335,7 +148335,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { } k = v8 for { - if !(*(*Twchar_t)(unsafe.Pointer(n + uintptr(k)*4)) != 0 && *(*Twchar_t)(unsafe.Pointer(n + uintptr(k)*4)) == *(*Twchar_t)(unsafe.Pointer(h + uintptr(k)*4))) { + if !(**(**Twchar_t)(__ccgo_up(n + uintptr(k)*4)) != 0 && **(**Twchar_t)(__ccgo_up(n + uintptr(k)*4)) == **(**Twchar_t)(__ccgo_up(h + uintptr(k)*4))) { break } goto _10 @@ -148343,7 +148343,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { ; k = k + 1 } - if *(*Twchar_t)(unsafe.Pointer(n + uintptr(k)*4)) != 0 { + if **(**Twchar_t)(__ccgo_up(n + uintptr(k)*4)) != 0 { h = h + uintptr(k-ms)*4 mem = uint32(0) goto _9 @@ -148351,7 +148351,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { /* Compare left half */ k = ms + uint32(1) for { - if !(k > mem && *(*Twchar_t)(unsafe.Pointer(n + uintptr(k-uint32(1))*4)) == *(*Twchar_t)(unsafe.Pointer(h + uintptr(k-uint32(1))*4))) { + if !(k > mem && **(**Twchar_t)(__ccgo_up(n + uintptr(k-uint32(1))*4)) == **(**Twchar_t)(__ccgo_up(h + uintptr(k-uint32(1))*4))) { break } goto _12 @@ -148376,18 +148376,18 @@ func Xwcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { defer func() { trc("-> %v", r) }() } /* Return immediately on empty needle or haystack */ - if !(*(*Twchar_t)(unsafe.Pointer(n)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(n)) != 0) { return h } - if !(*(*Twchar_t)(unsafe.Pointer(h)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(h)) != 0) { return uintptr(0) } /* Use faster algorithms for short needles */ - h = Xwcschr(tls, h, *(*Twchar_t)(unsafe.Pointer(n))) - if !(h != 0) || !(*(*Twchar_t)(unsafe.Pointer(n + 1*4)) != 0) { + h = Xwcschr(tls, h, **(**Twchar_t)(__ccgo_up(n))) + if !(h != 0) || !(**(**Twchar_t)(__ccgo_up(n + 1*4)) != 0) { return h } - if !(*(*Twchar_t)(unsafe.Pointer(h + 1*4)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(h + 1*4)) != 0) { return uintptr(0) } return _twoway_wcsstr(tls, h, n) @@ -148402,26 +148402,26 @@ func Xwcstok(tls *TLS, s uintptr, sep uintptr, p uintptr) (r uintptr) { var v2 bool _, _, _ = v1, v2, v3 if v2 = !(s != 0); v2 { - v1 = *(*uintptr)(unsafe.Pointer(p)) + v1 = **(**uintptr)(__ccgo_up(p)) s = v1 } if v2 && !(v1 != 0) { return UintptrFromInt32(0) } s = s + uintptr(Xwcsspn(tls, s, sep))*4 - if !(*(*Twchar_t)(unsafe.Pointer(s)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(s)) != 0) { v1 = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(p)) = v1 + **(**uintptr)(__ccgo_up(p)) = v1 return v1 } - *(*uintptr)(unsafe.Pointer(p)) = s + uintptr(Xwcscspn(tls, s, sep))*4 - if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)))) != 0 { + **(**uintptr)(__ccgo_up(p)) = s + uintptr(Xwcscspn(tls, s, sep))*4 + if **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(p)))) != 0 { v3 = p v1 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) += 4 - *(*Twchar_t)(unsafe.Pointer(v1)) = 0 + **(**Twchar_t)(__ccgo_up(v1)) = 0 } else { - *(*uintptr)(unsafe.Pointer(p)) = uintptr(0) + **(**uintptr)(__ccgo_up(p)) = uintptr(0) } return s } @@ -148442,7 +148442,7 @@ func Xwmemchr(tls *TLS, s uintptr, c Twchar_t, n Tsize_t) (r uintptr) { var v2 uintptr _ = v2 for { - if !(n != 0 && *(*Twchar_t)(unsafe.Pointer(s)) != c) { + if !(n != 0 && **(**Twchar_t)(__ccgo_up(s)) != c) { break } goto _1 @@ -148467,7 +148467,7 @@ func Xwmemcmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { var v2, v3 int32 _, _ = v2, v3 for { - if !(n != 0 && *(*Twchar_t)(unsafe.Pointer(l)) == *(*Twchar_t)(unsafe.Pointer(r))) { + if !(n != 0 && **(**Twchar_t)(__ccgo_up(l)) == **(**Twchar_t)(__ccgo_up(r))) { break } goto _1 @@ -148478,10 +148478,10 @@ func Xwmemcmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { r += 4 } if n != 0 { - if *(*Twchar_t)(unsafe.Pointer(l)) < *(*Twchar_t)(unsafe.Pointer(r)) { + if **(**Twchar_t)(__ccgo_up(l)) < **(**Twchar_t)(__ccgo_up(r)) { v3 = -int32(1) } else { - v3 = BoolInt32(*(*Twchar_t)(unsafe.Pointer(l)) > *(*Twchar_t)(unsafe.Pointer(r))) + v3 = BoolInt32(**(**Twchar_t)(__ccgo_up(l)) > **(**Twchar_t)(__ccgo_up(r))) } v2 = v3 } else { @@ -148509,7 +148509,7 @@ func Xwmemcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { d += 4 v3 = s s += 4 - *(*Twchar_t)(unsafe.Pointer(v2)) = *(*Twchar_t)(unsafe.Pointer(v3)) + **(**Twchar_t)(__ccgo_up(v2)) = **(**Twchar_t)(__ccgo_up(v3)) } return a } @@ -148533,7 +148533,7 @@ func Xwmemmove(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { if !(v1 != 0) { break } - *(*Twchar_t)(unsafe.Pointer(d + uintptr(n)*4)) = *(*Twchar_t)(unsafe.Pointer(s + uintptr(n)*4)) + **(**Twchar_t)(__ccgo_up(d + uintptr(n)*4)) = **(**Twchar_t)(__ccgo_up(s + uintptr(n)*4)) } } else { for { @@ -148546,7 +148546,7 @@ func Xwmemmove(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { d += 4 v4 = s s += 4 - *(*Twchar_t)(unsafe.Pointer(v3)) = *(*Twchar_t)(unsafe.Pointer(v4)) + **(**Twchar_t)(__ccgo_up(v3)) = **(**Twchar_t)(__ccgo_up(v4)) } } return d0 @@ -148569,7 +148569,7 @@ func Xwmemset(tls *TLS, d uintptr, c Twchar_t, n Tsize_t) (r uintptr) { } v2 = d d += 4 - *(*Twchar_t)(unsafe.Pointer(v2)) = c + **(**Twchar_t)(__ccgo_up(v2)) = c } return ret } @@ -148585,7 +148585,7 @@ func Xmkdtemp(tls *TLS, template uintptr) (r uintptr) { l = _strlen(tls, template) retries = int32(100) if l < uint32(6) || Xmemcmp(tls, template+uintptr(l)-uintptr(6), __ccgo_ts+1563, uint32(6)) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } for { @@ -148598,7 +148598,7 @@ func Xmkdtemp(tls *TLS, template uintptr) (r uintptr) { ; retries = retries - 1 v1 = retries - if !(v1 != 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EEXIST)) { + if !(v1 != 0 && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EEXIST)) { break } } @@ -148626,7 +148626,7 @@ func X__mkostemps(tls *TLS, template uintptr, len1 int32, flags int32) (r int32) _, _, _, _ = fd, l, retries, v1 l = _strlen(tls, template) if l < uint32(6) || Uint32FromInt32(len1) > l-uint32(6) || Xmemcmp(tls, template+uintptr(l)-uintptr(len1)-uintptr(6), __ccgo_ts+1563, uint32(6)) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } flags = flags - flags&(Int32FromInt32(03)|Int32FromInt32(O_PATH)) @@ -148643,7 +148643,7 @@ func X__mkostemps(tls *TLS, template uintptr, len1 int32, flags int32) (r int32) ; retries = retries - 1 v1 = retries - if !(v1 != 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EEXIST)) { + if !(v1 != 0 && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EEXIST)) { break } } @@ -148689,15 +148689,15 @@ func Xmktemp(tls *TLS, template uintptr) (r uintptr) { l = _strlen(tls, template) retries = int32(100) if l < uint32(6) || Xmemcmp(tls, template+uintptr(l)-uintptr(6), __ccgo_ts+1563, uint32(6)) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) - *(*int8)(unsafe.Pointer(template)) = 0 + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) + **(**int8)(__ccgo_up(template)) = 0 return template } for { ___randname(tls, template+uintptr(l)-uintptr(6)) if Xstat(tls, template, bp) != 0 { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(ENOENT) { - *(*int8)(unsafe.Pointer(template)) = 0 + if **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(ENOENT) { + **(**int8)(__ccgo_up(template)) = 0 } return template } @@ -148710,8 +148710,8 @@ func Xmktemp(tls *TLS, template uintptr) (r uintptr) { break } } - *(*int8)(unsafe.Pointer(template)) = 0 - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EEXIST) + **(**int8)(__ccgo_up(template)) = 0 + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EEXIST) return template } @@ -148735,13 +148735,13 @@ func Xcfmakeraw(tls *TLS, t uintptr) { if __ccgo_strace { trc("tls=%v t=%v, (%v:)", tls, t, origin(2)) } - *(*Ttcflag_t)(unsafe.Pointer(t)) &= Uint32FromInt32(^(Int32FromInt32(IGNBRK) | Int32FromInt32(BRKINT) | Int32FromInt32(PARMRK) | Int32FromInt32(ISTRIP) | Int32FromInt32(INLCR) | Int32FromInt32(IGNCR) | Int32FromInt32(ICRNL) | Int32FromInt32(IXON))) - *(*Ttcflag_t)(unsafe.Pointer(t + 4)) &= Uint32FromInt32(^Int32FromInt32(OPOST)) - *(*Ttcflag_t)(unsafe.Pointer(t + 12)) &= Uint32FromInt32(^(Int32FromInt32(ECHO) | Int32FromInt32(ECHONL) | Int32FromInt32(ICANON) | Int32FromInt32(ISIG) | Int32FromInt32(IEXTEN))) - *(*Ttcflag_t)(unsafe.Pointer(t + 8)) &= Uint32FromInt32(^(Int32FromInt32(CSIZE) | Int32FromInt32(PARENB))) - *(*Ttcflag_t)(unsafe.Pointer(t + 8)) |= uint32(CS8) - *(*Tcc_t)(unsafe.Pointer(t + 17 + 6)) = uint8(1) - *(*Tcc_t)(unsafe.Pointer(t + 17 + 5)) = uint8(0) + **(**Ttcflag_t)(__ccgo_up(t)) &= Uint32FromInt32(^(Int32FromInt32(IGNBRK) | Int32FromInt32(BRKINT) | Int32FromInt32(PARMRK) | Int32FromInt32(ISTRIP) | Int32FromInt32(INLCR) | Int32FromInt32(IGNCR) | Int32FromInt32(ICRNL) | Int32FromInt32(IXON))) + **(**Ttcflag_t)(__ccgo_up(t + 4)) &= Uint32FromInt32(^Int32FromInt32(OPOST)) + **(**Ttcflag_t)(__ccgo_up(t + 12)) &= Uint32FromInt32(^(Int32FromInt32(ECHO) | Int32FromInt32(ECHONL) | Int32FromInt32(ICANON) | Int32FromInt32(ISIG) | Int32FromInt32(IEXTEN))) + **(**Ttcflag_t)(__ccgo_up(t + 8)) &= Uint32FromInt32(^(Int32FromInt32(CSIZE) | Int32FromInt32(PARENB))) + **(**Ttcflag_t)(__ccgo_up(t + 8)) |= uint32(CS8) + **(**Tcc_t)(__ccgo_up(t + 17 + 6)) = uint8(1) + **(**Tcc_t)(__ccgo_up(t + 17 + 5)) = uint8(0) } func Xcfsetospeed(tls *TLS, tio uintptr, speed Tspeed_t) (r int32) { @@ -148750,11 +148750,11 @@ func Xcfsetospeed(tls *TLS, tio uintptr, speed Tspeed_t) (r int32) { defer func() { trc("-> %v", r) }() } if speed&Uint32FromInt32(^Int32FromInt32(CBAUD)) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } - *(*Ttcflag_t)(unsafe.Pointer(tio + 8)) &= Uint32FromInt32(^Int32FromInt32(CBAUD)) - *(*Ttcflag_t)(unsafe.Pointer(tio + 8)) |= speed + **(**Ttcflag_t)(__ccgo_up(tio + 8)) &= Uint32FromInt32(^Int32FromInt32(CBAUD)) + **(**Ttcflag_t)(__ccgo_up(tio + 8)) |= speed return 0 } @@ -148833,7 +148833,7 @@ func Xtcgetsid(tls *TLS, fd int32) (r Tpid_t) { if Xioctl(tls, fd, int32(TIOCGSID), VaList(bp+16, bp)) < 0 { return -int32(1) } - return *(*int32)(unsafe.Pointer(bp)) + return **(**int32)(__ccgo_up(bp)) } func Xtcgetwinsize(tls *TLS, fd int32, wsz uintptr) (r int32) { @@ -148863,7 +148863,7 @@ func Xtcsetattr(tls *TLS, fd int32, act int32, tio uintptr) (r int32) { bp := tls.Alloc(16) defer tls.Free(16) if act < 0 || act > int32(2) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } return Xioctl(tls, fd, int32(TCSETS)+act, VaList(bp+8, tio)) @@ -148894,8 +148894,8 @@ func X__map_file(tls *TLS, pathname uintptr, size uintptr) (r uintptr) { return uintptr(0) } if !(X__fstat(tls, fd, bp) != 0) { - map1 = X__mmap(tls, uintptr(0), Uint32FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_size), int32(PROT_READ), int32(MAP_SHARED), fd, 0) - *(*Tsize_t)(unsafe.Pointer(size)) = Uint32FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_size) + map1 = X__mmap(tls, uintptr(0), Uint32FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_size), int32(PROT_READ), int32(MAP_SHARED), fd, 0) + **(**Tsize_t)(__ccgo_up(size)) = Uint32FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_size) } X__syscall1(tls, int32(SYS_close), fd) if map1 == uintptr(-Int32FromInt32(1)) { @@ -149067,7 +149067,7 @@ func X__tm_to_secs(tls *TLS, tm uintptr) (r int64) { year = year + int64(adj) } t = X__year_to_secs(tls, year, bp) - t = t + int64(X__month_to_secs(tls, month, *(*int32)(unsafe.Pointer(bp)))) + t = t + int64(X__month_to_secs(tls, month, **(**int32)(__ccgo_up(bp)))) t = t + int64(86400)*int64((*Ttm)(unsafe.Pointer(tm)).Ftm_mday-Int32FromInt32(1)) t = t + int64(3600)*int64((*Ttm)(unsafe.Pointer(tm)).Ftm_hour) t = t + int64(60)*int64((*Ttm)(unsafe.Pointer(tm)).Ftm_min) @@ -149101,14 +149101,14 @@ func _getint2(tls *TLS, p uintptr) (r int32) { _ = x x = uint32(0) for { - if !(Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)))))-int32('0')) < uint32(10)) { + if !(Uint32FromInt32(int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)))))-int32('0')) < uint32(10)) { break } - x = Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)))))-int32('0')) + uint32(10)*x + x = Uint32FromInt32(int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)))))-int32('0')) + uint32(10)*x goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 } return Int32FromUint32(x) } @@ -149117,20 +149117,20 @@ func _getoff(tls *TLS, p uintptr) (r int32) { var neg, off, v1 int32 _, _, _ = neg, off, v1 neg = 0 - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('-') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) == int32('-') { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 neg = int32(1) } else { - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('+') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) == int32('+') { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 } } off = int32(3600) * _getint2(tls, p) - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32(':') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) == int32(':') { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 off = off + int32(60)*_getint2(tls, p) - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32(':') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) == int32(':') { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 off = off + _getint2(tls, p) } } @@ -149145,61 +149145,61 @@ func _getoff(tls *TLS, p uintptr) (r int32) { func _getrule(tls *TLS, p uintptr, rule uintptr) { var r, v1 int32 _, _ = r, v1 - v1 = int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) - *(*int32)(unsafe.Pointer(rule)) = v1 + v1 = int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) + **(**int32)(__ccgo_up(rule)) = v1 r = v1 if r != int32('M') { if r == int32('J') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 } else { - *(*int32)(unsafe.Pointer(rule)) = 0 + **(**int32)(__ccgo_up(rule)) = 0 } - *(*int32)(unsafe.Pointer(rule + 1*4)) = _getint2(tls, p) + **(**int32)(__ccgo_up(rule + 1*4)) = _getint2(tls, p) } else { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 - *(*int32)(unsafe.Pointer(rule + 1*4)) = _getint2(tls, p) - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 - *(*int32)(unsafe.Pointer(rule + 2*4)) = _getint2(tls, p) - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 - *(*int32)(unsafe.Pointer(rule + 3*4)) = _getint2(tls, p) + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 + **(**int32)(__ccgo_up(rule + 1*4)) = _getint2(tls, p) + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 + **(**int32)(__ccgo_up(rule + 2*4)) = _getint2(tls, p) + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 + **(**int32)(__ccgo_up(rule + 3*4)) = _getint2(tls, p) } - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('/') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 - *(*int32)(unsafe.Pointer(rule + 4*4)) = _getoff(tls, p) + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) == int32('/') { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 + **(**int32)(__ccgo_up(rule + 4*4)) = _getoff(tls, p) } else { - *(*int32)(unsafe.Pointer(rule + 4*4)) = int32(7200) + **(**int32)(__ccgo_up(rule + 4*4)) = int32(7200) } } func _getname(tls *TLS, d uintptr, p uintptr) { var i, v3 int32 _, _ = i, v3 - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('<') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) == int32('<') { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 i = 0 for { - if !(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))) != 0 && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i)))) != int32('>')) { + if !(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)) + uintptr(i))) != 0 && int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)) + uintptr(i)))) != int32('>')) { break } if i < int32(TZNAME_MAX) { - *(*int8)(unsafe.Pointer(d + uintptr(i))) = *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))) + **(**int8)(__ccgo_up(d + uintptr(i))) = **(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)) + uintptr(i))) } goto _1 _1: ; i = i + 1 } - if *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))) != 0 { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + if **(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)) + uintptr(i))) != 0 { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 } } else { i = 0 for { - if !(Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))))|int32(32)-int32('a')) < uint32(26)) { + if !(Uint32FromInt32(int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)) + uintptr(i))))|int32(32)-int32('a')) < uint32(26)) { break } if i < int32(TZNAME_MAX) { - *(*int8)(unsafe.Pointer(d + uintptr(i))) = *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))) + **(**int8)(__ccgo_up(d + uintptr(i))) = **(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)) + uintptr(i))) } goto _2 _2: @@ -149207,17 +149207,17 @@ func _getname(tls *TLS, d uintptr, p uintptr) { i = i + 1 } } - *(*uintptr)(unsafe.Pointer(p)) += uintptr(i) + **(**uintptr)(__ccgo_up(p)) += uintptr(i) if i < int32(TZNAME_MAX) { v3 = i } else { v3 = int32(TZNAME_MAX) } - *(*int8)(unsafe.Pointer(d + uintptr(v3))) = 0 + **(**int8)(__ccgo_up(d + uintptr(v3))) = 0 } func _zi_read32(tls *TLS, z uintptr) (r Tuint32_t) { - return uint32(*(*uint8)(unsafe.Pointer(z)))< Uint32FromInt32(Int32FromInt32(PATH_MAX)+Int32FromInt32(1)) { - *(*uintptr)(unsafe.Pointer(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) + **(**uintptr)(__ccgo_up(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) i = Uint32FromInt32(3) } if i >= _old_tz_size { @@ -149299,13 +149299,13 @@ func _do_tzset(tls *TLS) { _old_tz = Xmalloc(tls, _old_tz_size) } if _old_tz != 0 { - Xmemcpy(tls, _old_tz, *(*uintptr)(unsafe.Pointer(bp + 288)), i+uint32(1)) + Xmemcpy(tls, _old_tz, **(**uintptr)(__ccgo_up(bp + 288)), i+uint32(1)) } posix_form = 0 - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) != int32(':') { - *(*uintptr)(unsafe.Pointer(bp + 292)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) != int32(':') { + **(**uintptr)(__ccgo_up(bp + 292)) = **(**uintptr)(__ccgo_up(bp + 288)) _getname(tls, bp+301, bp+292) - if *(*uintptr)(unsafe.Pointer(bp + 292)) != *(*uintptr)(unsafe.Pointer(bp + 288)) && (int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 292))))) == int32('+') || int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 292))))) == int32('-') || BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 292)))))-uint32('0') < uint32(10)) != 0 || !(Xstrcmp(tls, bp+301, __ccgo_ts+1588) != 0) || !(Xstrcmp(tls, bp+301, __ccgo_ts+1592) != 0)) { + if **(**uintptr)(__ccgo_up(bp + 292)) != **(**uintptr)(__ccgo_up(bp + 288)) && (int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 292))))) == int32('+') || int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 292))))) == int32('-') || BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 292)))))-uint32('0') < uint32(10)) != 0 || !(Xstrcmp(tls, bp+301, __ccgo_ts+1588) != 0) || !(Xstrcmp(tls, bp+301, __ccgo_ts+1592) != 0)) { posix_form = int32(1) } } @@ -149313,21 +149313,21 @@ func _do_tzset(tls *TLS) { * pathame beginning with "."; in secure mode, only the * standard path will be searched. */ if !(posix_form != 0) { - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32(':') { - *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32(':') { + **(**uintptr)(__ccgo_up(bp + 288)) = **(**uintptr)(__ccgo_up(bp + 288)) + 1 } - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32('/') || int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32('.') { - if !(X__libc.Fsecure != 0) || !(Xstrcmp(tls, *(*uintptr)(unsafe.Pointer(bp + 288)), __ccgo_ts+1573) != 0) { - map1 = X__map_file(tls, *(*uintptr)(unsafe.Pointer(bp + 288)), uintptr(unsafe.Pointer(&_map_size))) + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32('/') || int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32('.') { + if !(X__libc.Fsecure != 0) || !(Xstrcmp(tls, **(**uintptr)(__ccgo_up(bp + 288)), __ccgo_ts+1573) != 0) { + map1 = X__map_file(tls, **(**uintptr)(__ccgo_up(bp + 288)), uintptr(unsafe.Pointer(&_map_size))) } } else { - l = _strlen(tls, *(*uintptr)(unsafe.Pointer(bp + 288))) - if l <= uint32(NAME_MAX) && !(Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp + 288)), int32('.')) != 0) { - Xmemcpy(tls, pathname, *(*uintptr)(unsafe.Pointer(bp + 288)), l+uint32(1)) - *(*int8)(unsafe.Pointer(pathname + uintptr(l))) = 0 + l = _strlen(tls, **(**uintptr)(__ccgo_up(bp + 288))) + if l <= uint32(NAME_MAX) && !(Xstrchr(tls, **(**uintptr)(__ccgo_up(bp + 288)), int32('.')) != 0) { + Xmemcpy(tls, pathname, **(**uintptr)(__ccgo_up(bp + 288)), l+uint32(1)) + **(**int8)(__ccgo_up(pathname + uintptr(l))) = 0 try = uintptr(unsafe.Pointer(&_search)) for { - if !(!(map1 != 0) && *(*int8)(unsafe.Pointer(try)) != 0) { + if !(!(map1 != 0) && **(**int8)(__ccgo_up(try)) != 0) { break } l = _strlen(tls, try) @@ -149341,18 +149341,18 @@ func _do_tzset(tls *TLS) { } } if !(map1 != 0) { - *(*uintptr)(unsafe.Pointer(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) + **(**uintptr)(__ccgo_up(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) } } if map1 != 0 && (_map_size < uint32(44) || Xmemcmp(tls, map1, __ccgo_ts+1596, uint32(4)) != 0) { X__munmap(tls, map1, _map_size) map1 = uintptr(0) - *(*uintptr)(unsafe.Pointer(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) + **(**uintptr)(__ccgo_up(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) } _zi = map1 if map1 != 0 { scale = int32(2) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(map1 + 4))) != int32('1') { + if Int32FromUint8(**(**uint8)(__ccgo_up(map1 + 4))) != int32('1') { *(*[6]uint8)(unsafe.Pointer(bp)) = [6]uint8{ 0: uint8(1), 1: uint8(1), @@ -149371,18 +149371,18 @@ func _do_tzset(tls *TLS) { _types = _index + uintptr(_zi_read32(tls, _trans-uintptr(12))) _abbrevs = _types + uintptr(uint32(6)*_zi_read32(tls, _trans-uintptr(8))) _abbrevs_end = _abbrevs + uintptr(_zi_read32(tls, _trans-uintptr(4))) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(_zi + uintptr(_map_size-uint32(1))))) == int32('\n') { - *(*uintptr)(unsafe.Pointer(bp + 288)) = _zi + uintptr(_map_size) - uintptr(2) + if Int32FromUint8(**(**uint8)(__ccgo_up(_zi + uintptr(_map_size-uint32(1))))) == int32('\n') { + **(**uintptr)(__ccgo_up(bp + 288)) = _zi + uintptr(_map_size) - uintptr(2) for { - if !(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) != int32('\n')) { + if !(int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) != int32('\n')) { break } goto _4 _4: ; - *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) - 1 + **(**uintptr)(__ccgo_up(bp + 288)) = **(**uintptr)(__ccgo_up(bp + 288)) - 1 } - *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 + **(**uintptr)(__ccgo_up(bp + 288)) = **(**uintptr)(__ccgo_up(bp + 288)) + 1 } else { v5 = UintptrFromInt32(0) Xtzname[int32(1)] = v5 @@ -149397,12 +149397,12 @@ func _do_tzset(tls *TLS) { if !(p1 < _abbrevs) { break } - if !(*(*uint8)(unsafe.Pointer(p1 + 4)) != 0) && !(Xtzname[0] != 0) { - Xtzname[0] = _abbrevs + uintptr(*(*uint8)(unsafe.Pointer(p1 + 5))) + if !(**(**uint8)(__ccgo_up(p1 + 4)) != 0) && !(Xtzname[0] != 0) { + Xtzname[0] = _abbrevs + uintptr(**(**uint8)(__ccgo_up(p1 + 5))) Xtimezone = Int32FromUint32(-_zi_read32(tls, p1)) } - if *(*uint8)(unsafe.Pointer(p1 + 4)) != 0 && !(Xtzname[int32(1)] != 0) { - Xtzname[int32(1)] = _abbrevs + uintptr(*(*uint8)(unsafe.Pointer(p1 + 5))) + if **(**uint8)(__ccgo_up(p1 + 4)) != 0 && !(Xtzname[int32(1)] != 0) { + Xtzname[int32(1)] = _abbrevs + uintptr(**(**uint8)(__ccgo_up(p1 + 5))) _dst_off = Int32FromUint32(-_zi_read32(tls, p1)) Xdaylight = int32(1) } @@ -149424,8 +149424,8 @@ func _do_tzset(tls *TLS) { return } } - if !(*(*uintptr)(unsafe.Pointer(bp + 288)) != 0) { - *(*uintptr)(unsafe.Pointer(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) + if !(**(**uintptr)(__ccgo_up(bp + 288)) != 0) { + **(**uintptr)(__ccgo_up(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) } _getname(tls, uintptr(unsafe.Pointer(&_std_name)), bp+288) Xtzname[0] = uintptr(unsafe.Pointer(&_std_name)) @@ -149434,7 +149434,7 @@ func _do_tzset(tls *TLS) { Xtzname[int32(1)] = uintptr(unsafe.Pointer(&_dst_name)) if _dst_name[0] != 0 { Xdaylight = int32(1) - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32('+') || int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32('-') || Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288)))))-int32('0')) < uint32(10) { + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32('+') || int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32('-') || Uint32FromInt32(int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288)))))-int32('0')) < uint32(10) { _dst_off = _getoff(tls, bp+288) } else { _dst_off = Xtimezone - int32(3600) @@ -149443,12 +149443,12 @@ func _do_tzset(tls *TLS) { Xdaylight = 0 _dst_off = Xtimezone } - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32(',') { - *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32(',') { + **(**uintptr)(__ccgo_up(bp + 288)) = **(**uintptr)(__ccgo_up(bp + 288)) + 1 _getrule(tls, bp+288, uintptr(unsafe.Pointer(&_r0))) } - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32(',') { - *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32(',') { + **(**uintptr)(__ccgo_up(bp + 288)) = **(**uintptr)(__ccgo_up(bp + 288)) + 1 _getrule(tls, bp+288, uintptr(unsafe.Pointer(&_r12))) } } @@ -149469,7 +149469,7 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { n = Uint32FromInt32((int32(_index) - int32(_trans)) >> scale) if !(n != 0) { if alt != 0 { - *(*Tsize_t)(unsafe.Pointer(alt)) = uint32(0) + **(**Tsize_t)(__ccgo_up(alt)) = uint32(0) } return uint32(0) } @@ -149483,7 +149483,7 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { x = Uint64FromInt32(Int32FromUint64(x)) } if local != 0 { - off = Int32FromUint32(_zi_read32(tls, _types+uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(m-uint32(1)))))))) + off = Int32FromUint32(_zi_read32(tls, _types+uintptr(int32(6)*Int32FromUint8(**(**uint8)(__ccgo_up(_index + uintptr(m-uint32(1)))))))) } if t-int64(off) < Int64FromUint64(x) { n = n / uint32(2) @@ -149512,7 +149512,7 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { if !(i != 0) { break } - if !(*(*uint8)(unsafe.Pointer(_types + uintptr(i-uint32(6)+uint32(4)))) != 0) { + if !(**(**uint8)(__ccgo_up(_types + uintptr(i-uint32(6)+uint32(4)))) != 0) { j = i - uint32(6) } goto _1 @@ -149527,24 +149527,24 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { * and the index-zero (after transition) type as the alt. */ if t-int64(off) < Int64FromUint64(x) { if alt != 0 { - *(*Tsize_t)(unsafe.Pointer(alt)) = uint32(*(*uint8)(unsafe.Pointer(_index))) + **(**Tsize_t)(__ccgo_up(alt)) = uint32(**(**uint8)(__ccgo_up(_index))) } return j / uint32(6) } } /* Try to find a neighboring opposite-DST-status rule. */ if alt != 0 { - if a != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(_types + uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(a-uint32(1)))))+int32(4))))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(_types + uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(a))))+int32(4))))) { - *(*Tsize_t)(unsafe.Pointer(alt)) = uint32(*(*uint8)(unsafe.Pointer(_index + uintptr(a-uint32(1))))) + if a != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(_types + uintptr(int32(6)*Int32FromUint8(**(**uint8)(__ccgo_up(_index + uintptr(a-uint32(1)))))+int32(4))))) != Int32FromUint8(**(**uint8)(__ccgo_up(_types + uintptr(int32(6)*Int32FromUint8(**(**uint8)(__ccgo_up(_index + uintptr(a))))+int32(4))))) { + **(**Tsize_t)(__ccgo_up(alt)) = uint32(**(**uint8)(__ccgo_up(_index + uintptr(a-uint32(1))))) } else { - if a+uint32(1) < n && Int32FromUint8(*(*uint8)(unsafe.Pointer(_types + uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(a+uint32(1)))))+int32(4))))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(_types + uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(a))))+int32(4))))) { - *(*Tsize_t)(unsafe.Pointer(alt)) = uint32(*(*uint8)(unsafe.Pointer(_index + uintptr(a+uint32(1))))) + if a+uint32(1) < n && Int32FromUint8(**(**uint8)(__ccgo_up(_types + uintptr(int32(6)*Int32FromUint8(**(**uint8)(__ccgo_up(_index + uintptr(a+uint32(1)))))+int32(4))))) != Int32FromUint8(**(**uint8)(__ccgo_up(_types + uintptr(int32(6)*Int32FromUint8(**(**uint8)(__ccgo_up(_index + uintptr(a))))+int32(4))))) { + **(**Tsize_t)(__ccgo_up(alt)) = uint32(**(**uint8)(__ccgo_up(_index + uintptr(a+uint32(1))))) } else { - *(*Tsize_t)(unsafe.Pointer(alt)) = uint32(*(*uint8)(unsafe.Pointer(_index + uintptr(a)))) + **(**Tsize_t)(__ccgo_up(alt)) = uint32(**(**uint8)(__ccgo_up(_index + uintptr(a)))) } } } - return uint32(*(*uint8)(unsafe.Pointer(_index + uintptr(a)))) + return uint32(**(**uint8)(__ccgo_up(_index + uintptr(a)))) } func _days_in_month1(tls *TLS, m int32, is_leap int32) (r int32) { @@ -149566,28 +149566,28 @@ func _rule_to_secs(tls *TLS, rule uintptr, year int32) (r int64) { var _ /* is_leap at bp+0 */ int32 _, _, _, _, _, _, _ = d, days, m, n, t, wday, x t = X__year_to_secs(tls, int64(year), bp) - if *(*int32)(unsafe.Pointer(rule)) != int32('M') { - x = *(*int32)(unsafe.Pointer(rule + 1*4)) - if *(*int32)(unsafe.Pointer(rule)) == int32('J') && (x < int32(60) || !(*(*int32)(unsafe.Pointer(bp)) != 0)) { + if **(**int32)(__ccgo_up(rule)) != int32('M') { + x = **(**int32)(__ccgo_up(rule + 1*4)) + if **(**int32)(__ccgo_up(rule)) == int32('J') && (x < int32(60) || !(**(**int32)(__ccgo_up(bp)) != 0)) { x = x - 1 } t = t + int64(int32(86400)*x) } else { - m = *(*int32)(unsafe.Pointer(rule + 1*4)) - n = *(*int32)(unsafe.Pointer(rule + 2*4)) - d = *(*int32)(unsafe.Pointer(rule + 3*4)) - t = t + int64(X__month_to_secs(tls, m-int32(1), *(*int32)(unsafe.Pointer(bp)))) + m = **(**int32)(__ccgo_up(rule + 1*4)) + n = **(**int32)(__ccgo_up(rule + 2*4)) + d = **(**int32)(__ccgo_up(rule + 3*4)) + t = t + int64(X__month_to_secs(tls, m-int32(1), **(**int32)(__ccgo_up(bp)))) wday = int32((t+int64(Int32FromInt32(4)*Int32FromInt32(86400)))%int64(Int32FromInt32(7)*Int32FromInt32(86400))) / int32(86400) days = d - wday if days < 0 { days = days + int32(7) } - if n == int32(5) && days+int32(28) >= _days_in_month1(tls, m, *(*int32)(unsafe.Pointer(bp))) { + if n == int32(5) && days+int32(28) >= _days_in_month1(tls, m, **(**int32)(__ccgo_up(bp))) { n = int32(4) } t = t + int64(int32(86400)*(days+int32(7)*(n-int32(1)))) } - t = t + int64(*(*int32)(unsafe.Pointer(rule + 4*4))) + t = t + int64(**(**int32)(__ccgo_up(rule + 4*4))) return t } @@ -149613,11 +149613,11 @@ func X__secs_to_zone(tls *TLS, t int64, local int32, isdst uintptr, offset uintp if _zi != 0 { i = _scan_trans(tls, t, local, bp) if i != Uint32FromInt32(-Int32FromInt32(1)) { - *(*int32)(unsafe.Pointer(isdst)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(_types + uintptr(uint32(6)*i+uint32(4))))) - *(*int32)(unsafe.Pointer(offset)) = int32(Int32FromUint32(_zi_read32(tls, _types+uintptr(uint32(6)*i)))) - *(*uintptr)(unsafe.Pointer(zonename)) = _abbrevs + uintptr(*(*uint8)(unsafe.Pointer(_types + uintptr(uint32(6)*i+uint32(5))))) + **(**int32)(__ccgo_up(isdst)) = Int32FromUint8(**(**uint8)(__ccgo_up(_types + uintptr(uint32(6)*i+uint32(4))))) + **(**int32)(__ccgo_up(offset)) = int32(Int32FromUint32(_zi_read32(tls, _types+uintptr(uint32(6)*i)))) + **(**uintptr)(__ccgo_up(zonename)) = _abbrevs + uintptr(**(**uint8)(__ccgo_up(_types + uintptr(uint32(6)*i+uint32(5))))) if oppoff != 0 { - *(*int32)(unsafe.Pointer(oppoff)) = int32(Int32FromUint32(_zi_read32(tls, _types+uintptr(uint32(6)**(*Tsize_t)(unsafe.Pointer(bp)))))) + **(**int32)(__ccgo_up(oppoff)) = int32(Int32FromUint32(_zi_read32(tls, _types+uintptr(uint32(6)***(**Tsize_t)(__ccgo_up(bp)))))) } ___unlock(tls, uintptr(unsafe.Pointer(&_lock4))) return @@ -149655,23 +149655,23 @@ func X__secs_to_zone(tls *TLS, t int64, local int32, isdst uintptr, offset uintp goto std std: ; - *(*int32)(unsafe.Pointer(isdst)) = 0 - *(*int32)(unsafe.Pointer(offset)) = -Xtimezone + **(**int32)(__ccgo_up(isdst)) = 0 + **(**int32)(__ccgo_up(offset)) = -Xtimezone if oppoff != 0 { - *(*int32)(unsafe.Pointer(oppoff)) = -_dst_off + **(**int32)(__ccgo_up(oppoff)) = -_dst_off } - *(*uintptr)(unsafe.Pointer(zonename)) = Xtzname[0] + **(**uintptr)(__ccgo_up(zonename)) = Xtzname[0] ___unlock(tls, uintptr(unsafe.Pointer(&_lock4))) return goto dst dst: ; - *(*int32)(unsafe.Pointer(isdst)) = int32(1) - *(*int32)(unsafe.Pointer(offset)) = -_dst_off + **(**int32)(__ccgo_up(isdst)) = int32(1) + **(**int32)(__ccgo_up(offset)) = -_dst_off if oppoff != 0 { - *(*int32)(unsafe.Pointer(oppoff)) = -Xtimezone + **(**int32)(__ccgo_up(oppoff)) = -Xtimezone } - *(*uintptr)(unsafe.Pointer(zonename)) = Xtzname[int32(1)] + **(**uintptr)(__ccgo_up(zonename)) = Xtzname[int32(1)] ___unlock(tls, uintptr(unsafe.Pointer(&_lock4))) } @@ -149714,11 +149714,11 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { if !((y-Int32FromInt32(68))&Int32FromInt32(3) != 0) { leaps = leaps - 1 if is_leap != 0 { - *(*int32)(unsafe.Pointer(is_leap)) = int32(1) + **(**int32)(__ccgo_up(is_leap)) = int32(1) } } else { if is_leap != 0 { - *(*int32)(unsafe.Pointer(is_leap)) = 0 + **(**int32)(__ccgo_up(is_leap)) = 0 } } return int64(int32(31536000)*(y-int32(70)) + int32(86400)*leaps) @@ -149733,7 +149733,7 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { rem = rem + int32(400) } if !(rem != 0) { - *(*int32)(unsafe.Pointer(is_leap)) = int32(1) + **(**int32)(__ccgo_up(is_leap)) = int32(1) centuries = 0 leaps1 = 0 } else { @@ -149754,15 +149754,15 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { } } if !(rem != 0) { - *(*int32)(unsafe.Pointer(is_leap)) = 0 + **(**int32)(__ccgo_up(is_leap)) = 0 leaps1 = 0 } else { leaps1 = Int32FromUint32(Uint32FromInt32(rem) / uint32(4)) rem = Int32FromUint32(uint32(rem) % Uint32FromUint32(4)) - *(*int32)(unsafe.Pointer(is_leap)) = BoolInt32(!(rem != 0)) + **(**int32)(__ccgo_up(is_leap)) = BoolInt32(!(rem != 0)) } } - leaps1 = leaps1 + (int32(97)*cycles + int32(24)*centuries - *(*int32)(unsafe.Pointer(is_leap))) + leaps1 = leaps1 + (int32(97)*cycles + int32(24)*centuries - **(**int32)(__ccgo_up(is_leap))) return (year-int64(100))*int64(31536000) + int64(leaps1)*int64(86400) + int64(946684800) + int64(86400) } @@ -149824,10 +149824,10 @@ func Xclock(tls *TLS) (r Tclock_t) { if X__clock_gettime(tls, int32(CLOCK_PROCESS_CPUTIME_ID), bp) != 0 { return -int32(1) } - if (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec > int64(Int32FromInt32(0x7fffffff)/Int32FromInt32(1000000)) || int64((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_nsec/int32(1000)) > int64(0x7fffffff)-int64(1000000)*(*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec { + if (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec > int64(Int32FromInt32(0x7fffffff)/Int32FromInt32(1000000)) || int64((**(**Ttimespec)(__ccgo_up(bp))).Ftv_nsec/int32(1000)) > int64(0x7fffffff)-int64(1000000)*(**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec { return -int32(1) } - return int32((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec*int64(1000000) + int64((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_nsec/int32(1000))) + return int32((**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec*int64(1000000) + int64((**(**Ttimespec)(__ccgo_up(bp))).Ftv_nsec/int32(1000))) } func Xclock_getcpuclockid(tls *TLS, pid Tpid_t, clk uintptr) (r int32) { @@ -149849,7 +149849,7 @@ func Xclock_getcpuclockid(tls *TLS, pid Tpid_t, clk uintptr) (r int32) { if ret != 0 { return -ret } - *(*Tclockid_t)(unsafe.Pointer(clk)) = id + **(**Tclockid_t)(__ccgo_up(clk)) = id return 0 } @@ -149867,8 +149867,8 @@ func Xclock_getres(tls *TLS, clk Tclockid_t, ts uintptr) (r1 int32) { if Int32FromInt32(__NR_timer_create)+Int32FromInt32(7) != int32(SYS_clock_getres_time64) { r = int32(X__syscall2(tls, int32(Int32FromInt32(__NR_timer_create)+Int32FromInt32(7)), clk, int32(bp))) if !(r != 0) && ts != 0 { - (*Ttimespec)(unsafe.Pointer(ts)).Ftv_sec = int64((*(*[2]int32)(unsafe.Pointer(bp)))[0]) - (*Ttimespec)(unsafe.Pointer(ts)).Ftv_nsec = (*(*[2]int32)(unsafe.Pointer(bp)))[int32(1)] + (*Ttimespec)(unsafe.Pointer(ts)).Ftv_sec = int64((**(**[2]int32)(__ccgo_up(bp)))[0]) + (*Ttimespec)(unsafe.Pointer(ts)).Ftv_nsec = (**(**[2]int32)(__ccgo_up(bp)))[int32(1)] } return X__syscall_ret(tls, Uint32FromInt32(r)) } @@ -149897,11 +149897,11 @@ func X__clock_gettime(tls *TLS, clk Tclockid_t, ts uintptr) (r1 int32) { r = int32(X__syscall2(tls, int32(Int32FromInt32(__NR_timer_create)+Int32FromInt32(6)), clk, int32(bp))) if r == -int32(ENOSYS) && clk == CLOCK_REALTIME { r = int32(X__syscall2(tls, int32(SYS_gettimeofday_time32), int32(bp), int32(Int32FromInt32(0)))) - *(*int32)(unsafe.Pointer(bp + 1*4)) *= int32(1000) + **(**int32)(__ccgo_up(bp + 1*4)) *= int32(1000) } if !(r != 0) { - (*Ttimespec)(unsafe.Pointer(ts)).Ftv_sec = int64((*(*[2]int32)(unsafe.Pointer(bp)))[0]) - (*Ttimespec)(unsafe.Pointer(ts)).Ftv_nsec = (*(*[2]int32)(unsafe.Pointer(bp)))[int32(1)] + (*Ttimespec)(unsafe.Pointer(ts)).Ftv_sec = int64((**(**[2]int32)(__ccgo_up(bp)))[0]) + (*Ttimespec)(unsafe.Pointer(ts)).Ftv_nsec = (**(**[2]int32)(__ccgo_up(bp)))[int32(1)] return r } return X__syscall_ret(tls, Uint32FromInt32(r)) @@ -149955,7 +149955,7 @@ func X__clock_nanosleep(tls *TLS, clk Tclockid_t, flags int32, req uintptr, rem } else { v2 = uint64(0x7fffffff) + (0+Uint64FromInt64(s))>>int32(63) } - *(*[2]int32)(unsafe.Pointer(bp + 16)) = [2]int32{ + **(**[2]int32)(__ccgo_up(bp + 16)) = [2]int32{ 0: int32(Int32FromUint64(v2)), 1: ns, } @@ -149965,8 +149965,8 @@ func X__clock_nanosleep(tls *TLS, clk Tclockid_t, flags int32, req uintptr, rem r = int32(___syscall_cp(tls, int32(Int32FromInt32(__NR_timer_create)+Int32FromInt32(8)), clk, flags, int32(bp+16), int32(bp+16), 0, 0)) } if r == -int32(EINTR) && rem != 0 && !(flags&Int32FromInt32(TIMER_ABSTIME) != 0) { - (*Ttimespec)(unsafe.Pointer(rem)).Ftv_sec = int64((*(*[2]int32)(unsafe.Pointer(bp + 16)))[0]) + extra - (*Ttimespec)(unsafe.Pointer(rem)).Ftv_nsec = (*(*[2]int32)(unsafe.Pointer(bp + 16)))[int32(1)] + (*Ttimespec)(unsafe.Pointer(rem)).Ftv_sec = int64((**(**[2]int32)(__ccgo_up(bp + 16)))[0]) + extra + (*Ttimespec)(unsafe.Pointer(rem)).Ftv_nsec = (**(**[2]int32)(__ccgo_up(bp + 16)))[int32(1)] } return -r } @@ -150071,8 +150071,8 @@ func Xftime(tls *TLS, tp uintptr) (r int32) { var _ /* ts at bp+0 */ Ttimespec _ = v1 Xclock_gettime(tls, CLOCK_REALTIME, bp) - (*Ttimeb)(unsafe.Pointer(tp)).Ftime = (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec - (*Ttimeb)(unsafe.Pointer(tp)).Fmillitm = Uint16FromInt32((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_nsec / int32(1000000)) + (*Ttimeb)(unsafe.Pointer(tp)).Ftime = (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec + (*Ttimeb)(unsafe.Pointer(tp)).Fmillitm = Uint16FromInt32((**(**Ttimespec)(__ccgo_up(bp))).Ftv_nsec / int32(1000000)) v1 = Int16FromInt32(0) (*Ttimeb)(unsafe.Pointer(tp)).Fdstflag = v1 (*Ttimeb)(unsafe.Pointer(tp)).Ftimezone = v1 @@ -150100,7 +150100,7 @@ func Xgetdate(tls *TLS, s uintptr) (r uintptr) { } f = Xfopen(tls, datemsk, __ccgo_ts+315) if !(f != 0) { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENOMEM) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENOMEM) { Xgetdate_err = int32(6) } else { Xgetdate_err = int32(2) @@ -150109,7 +150109,7 @@ func Xgetdate(tls *TLS, s uintptr) (r uintptr) { } for Xfgets(tls, bp, int32(100), f) != 0 { p = Xstrptime(tls, s, bp, uintptr(unsafe.Pointer(&_tmbuf))) - if p != 0 && !(*(*int8)(unsafe.Pointer(p)) != 0) { + if p != 0 && !(**(**int8)(__ccgo_up(p)) != 0) { ret = uintptr(unsafe.Pointer(&_tmbuf)) goto out } @@ -150125,7 +150125,7 @@ out: if f != 0 { Xfclose(tls, f) } - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 100)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 100)), uintptr(0)) return ret } @@ -150143,8 +150143,8 @@ func Xgettimeofday(tls *TLS, tv uintptr, tz uintptr) (r int32) { return 0 } Xclock_gettime(tls, CLOCK_REALTIME, bp) - (*Ttimeval)(unsafe.Pointer(tv)).Ftv_sec = (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec - (*Ttimeval)(unsafe.Pointer(tv)).Ftv_usec = int64((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_nsec / int32(1000)) + (*Ttimeval)(unsafe.Pointer(tv)).Ftv_sec = (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec + (*Ttimeval)(unsafe.Pointer(tv)).Ftv_usec = int64(int32((**(**Ttimespec)(__ccgo_up(bp))).Ftv_nsec) / int32(1000)) return 0 } @@ -150163,8 +150163,8 @@ func X__gmtime_r(tls *TLS, t uintptr, tm uintptr) (r uintptr) { trc("tls=%v t=%v tm=%v, (%v:)", tls, t, tm, origin(2)) defer func() { trc("-> %v", r) }() } - if X__secs_to_tm(tls, *(*Ttime_t)(unsafe.Pointer(t)), tm) < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + if X__secs_to_tm(tls, **(**Ttime_t)(__ccgo_up(t)), tm) < 0 { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return uintptr(0) } (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst = 0 @@ -150207,13 +150207,13 @@ func X__localtime_r(tls *TLS, t uintptr, tm uintptr) (r uintptr) { } /* Reject time_t values whose year would overflow int because * __secs_to_zone cannot safely handle them. */ - if *(*Ttime_t)(unsafe.Pointer(t)) < int64(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff))*Int64FromInt64(31622400) || *(*Ttime_t)(unsafe.Pointer(t)) > Int64FromInt32(INT_MAX)*Int64FromInt64(31622400) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + if **(**Ttime_t)(__ccgo_up(t)) < int64(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff))*Int64FromInt64(31622400) || **(**Ttime_t)(__ccgo_up(t)) > Int64FromInt32(INT_MAX)*Int64FromInt64(31622400) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return uintptr(0) } - X__secs_to_zone(tls, *(*Ttime_t)(unsafe.Pointer(t)), 0, tm+32, tm+36, uintptr(0), tm+40) - if X__secs_to_tm(tls, *(*Ttime_t)(unsafe.Pointer(t))+int64((*Ttm)(unsafe.Pointer(tm)).F__tm_gmtoff), tm) < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + X__secs_to_zone(tls, **(**Ttime_t)(__ccgo_up(t)), 0, tm+32, tm+36, uintptr(0), tm+40) + if X__secs_to_tm(tls, **(**Ttime_t)(__ccgo_up(t))+int64((*Ttm)(unsafe.Pointer(tm)).F__tm_gmtoff), tm) < 0 { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return uintptr(0) } return tm @@ -150249,23 +150249,23 @@ func Xmktime(tls *TLS, tm uintptr) (r Ttime_t) { _ = t t = X__tm_to_secs(tls, tm) X__secs_to_zone(tls, t, int32(1), bp+32, bp+36, bp+44, bp+40) - if (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst >= 0 && (*(*Ttm)(unsafe.Pointer(bp))).Ftm_isdst != (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst { - t = t - int64(*(*int32)(unsafe.Pointer(bp + 44))-(*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff) + if (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst >= 0 && (**(**Ttm)(__ccgo_up(bp))).Ftm_isdst != (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst { + t = t - int64(**(**int32)(__ccgo_up(bp + 44))-(**(**Ttm)(__ccgo_up(bp))).F__tm_gmtoff) } - t = t - int64((*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff) + t = t - int64((**(**Ttm)(__ccgo_up(bp))).F__tm_gmtoff) if t != t { goto error } X__secs_to_zone(tls, t, 0, bp+32, bp+36, bp+44, bp+40) - if X__secs_to_tm(tls, t+int64((*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff), bp) < 0 { + if X__secs_to_tm(tls, t+int64((**(**Ttm)(__ccgo_up(bp))).F__tm_gmtoff), bp) < 0 { goto error } - *(*Ttm)(unsafe.Pointer(tm)) = *(*Ttm)(unsafe.Pointer(bp)) + **(**Ttm)(__ccgo_up(tm)) = **(**Ttm)(__ccgo_up(bp)) return t goto error error: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return int64(-int32(1)) } @@ -150426,7 +150426,7 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc val = int64((*Ttm)(unsafe.Pointer(tm)).Ftm_min) goto number case int32('n'): - *(*Tsize_t)(unsafe.Pointer(l)) = uint32(1) + **(**Tsize_t)(__ccgo_up(l)) = uint32(1) return __ccgo_ts + 301 case int32('p'): if (*Ttm)(unsafe.Pointer(tm)).Ftm_hour >= int32(12) { @@ -150445,20 +150445,20 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc item = v1 fmt = X__nl_langinfo_l(tls, item, loc) d = s - *(*Tsize_t)(unsafe.Pointer(l)) = uint32(0) + **(**Tsize_t)(__ccgo_up(l)) = uint32(0) for { - if !(*(*int8)(unsafe.Pointer(fmt)) != 0) { + if !(**(**int8)(__ccgo_up(fmt)) != 0) { break } v4 = d d = d + 1 v5 = fmt fmt = fmt + 1 - *(*int8)(unsafe.Pointer(v4)) = int8(Xtolower(tls, int32(*(*int8)(unsafe.Pointer(v5))))) + **(**int8)(__ccgo_up(v4)) = int8(Xtolower(tls, int32(**(**int8)(__ccgo_up(v5))))) goto _3 _3: ; - *(*Tsize_t)(unsafe.Pointer(l)) = *(*Tsize_t)(unsafe.Pointer(l)) + 1 + **(**Tsize_t)(__ccgo_up(l)) = **(**Tsize_t)(__ccgo_up(l)) + 1 } return s case int32('r'): @@ -150475,7 +150475,7 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc val = int64((*Ttm)(unsafe.Pointer(tm)).Ftm_sec) goto number case int32('t'): - *(*Tsize_t)(unsafe.Pointer(l)) = uint32(1) + **(**Tsize_t)(__ccgo_up(l)) = uint32(1) return __ccgo_ts + 1315 case int32('T'): fmt = __ccgo_ts + 1665 @@ -150517,27 +150517,27 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc case int32('Y'): val = int64((*Ttm)(unsafe.Pointer(tm)).Ftm_year) + int64(1900) if val >= int64(10000) { - *(*Tsize_t)(unsafe.Pointer(l)) = Uint32FromInt32(Xsnprintf(tls, s, uint32(100), __ccgo_ts+1674, VaList(bp+8, val))) + **(**Tsize_t)(__ccgo_up(l)) = Uint32FromInt32(Xsnprintf(tls, s, uint32(100), __ccgo_ts+1674, VaList(bp+8, val))) return s } width = int32(4) goto number case int32('z'): if (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst < 0 { - *(*Tsize_t)(unsafe.Pointer(l)) = uint32(0) + **(**Tsize_t)(__ccgo_up(l)) = uint32(0) return __ccgo_ts } - *(*Tsize_t)(unsafe.Pointer(l)) = Uint32FromInt32(Xsnprintf(tls, s, uint32(100), __ccgo_ts+1680, VaList(bp+8, (*Ttm)(unsafe.Pointer(tm)).F__tm_gmtoff/int32(3600)*int32(100)+(*Ttm)(unsafe.Pointer(tm)).F__tm_gmtoff%int32(3600)/int32(60)))) + **(**Tsize_t)(__ccgo_up(l)) = Uint32FromInt32(Xsnprintf(tls, s, uint32(100), __ccgo_ts+1680, VaList(bp+8, (*Ttm)(unsafe.Pointer(tm)).F__tm_gmtoff/int32(3600)*int32(100)+(*Ttm)(unsafe.Pointer(tm)).F__tm_gmtoff%int32(3600)/int32(60)))) return s case int32('Z'): if (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst < 0 { - *(*Tsize_t)(unsafe.Pointer(l)) = uint32(0) + **(**Tsize_t)(__ccgo_up(l)) = uint32(0) return __ccgo_ts } fmt = X__tm_to_tzname(tls, tm) goto string case int32('%'): - *(*Tsize_t)(unsafe.Pointer(l)) = uint32(1) + **(**Tsize_t)(__ccgo_up(l)) = uint32(1) return __ccgo_ts + 348 default: return uintptr(0) @@ -150552,13 +150552,13 @@ number: } switch v1 { case int32('-'): - *(*Tsize_t)(unsafe.Pointer(l)) = Uint32FromInt32(Xsnprintf(tls, s, uint32(100), __ccgo_ts+1687, VaList(bp+8, val))) + **(**Tsize_t)(__ccgo_up(l)) = Uint32FromInt32(Xsnprintf(tls, s, uint32(100), __ccgo_ts+1687, VaList(bp+8, val))) case int32('_'): - *(*Tsize_t)(unsafe.Pointer(l)) = Uint32FromInt32(Xsnprintf(tls, s, uint32(100), __ccgo_ts+1692, VaList(bp+8, width, val))) + **(**Tsize_t)(__ccgo_up(l)) = Uint32FromInt32(Xsnprintf(tls, s, uint32(100), __ccgo_ts+1692, VaList(bp+8, width, val))) case int32('0'): fallthrough default: - *(*Tsize_t)(unsafe.Pointer(l)) = Uint32FromInt32(Xsnprintf(tls, s, uint32(100), __ccgo_ts+1698, VaList(bp+8, width, val))) + **(**Tsize_t)(__ccgo_up(l)) = Uint32FromInt32(Xsnprintf(tls, s, uint32(100), __ccgo_ts+1698, VaList(bp+8, width, val))) break } return s @@ -150569,7 +150569,7 @@ nl_strcat: goto string string: ; - *(*Tsize_t)(unsafe.Pointer(l)) = _strlen(tls, fmt) + **(**Tsize_t)(__ccgo_up(l)) = _strlen(tls, fmt) return fmt goto nl_strftime nl_strftime: @@ -150578,8 +150578,8 @@ nl_strftime: goto recu_strftime recu_strftime: ; - *(*Tsize_t)(unsafe.Pointer(l)) = X__strftime_l(tls, s, uint32(100), fmt, tm, loc) - if !(*(*Tsize_t)(unsafe.Pointer(l)) != 0) { + **(**Tsize_t)(__ccgo_up(l)) = X__strftime_l(tls, s, uint32(100), fmt, tm, loc) + if !(**(**Tsize_t)(__ccgo_up(l)) != 0) { return uintptr(0) } return s @@ -150606,46 +150606,46 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl if !(l < n) { break } - if !(*(*int8)(unsafe.Pointer(f)) != 0) { - *(*int8)(unsafe.Pointer(s + uintptr(l))) = 0 + if !(**(**int8)(__ccgo_up(f)) != 0) { + **(**int8)(__ccgo_up(s + uintptr(l))) = 0 return l } - if int32(*(*int8)(unsafe.Pointer(f))) != int32('%') { + if int32(**(**int8)(__ccgo_up(f))) != int32('%') { v2 = l l = l + 1 - *(*int8)(unsafe.Pointer(s + uintptr(v2))) = *(*int8)(unsafe.Pointer(f)) + **(**int8)(__ccgo_up(s + uintptr(v2))) = **(**int8)(__ccgo_up(f)) goto _1 } f = f + 1 pad = 0 - if int32(*(*int8)(unsafe.Pointer(f))) == int32('-') || int32(*(*int8)(unsafe.Pointer(f))) == int32('_') || int32(*(*int8)(unsafe.Pointer(f))) == int32('0') { + if int32(**(**int8)(__ccgo_up(f))) == int32('-') || int32(**(**int8)(__ccgo_up(f))) == int32('_') || int32(**(**int8)(__ccgo_up(f))) == int32('0') { v3 = f f = f + 1 - pad = int32(*(*int8)(unsafe.Pointer(v3))) + pad = int32(**(**int8)(__ccgo_up(v3))) } - v4 = BoolInt32(int32(*(*int8)(unsafe.Pointer(f))) == Int32FromUint8('+')) + v4 = BoolInt32(int32(**(**int8)(__ccgo_up(f))) == Int32FromUint8('+')) plus = v4 if v4 != 0 { f = f + 1 } - if BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(f)))-uint32('0') < uint32(10)) != 0 { + if BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(f)))-uint32('0') < uint32(10)) != 0 { width = Xstrtoul(tls, f, bp+104, int32(10)) } else { width = uint32(0) - *(*uintptr)(unsafe.Pointer(bp + 104)) = f + **(**uintptr)(__ccgo_up(bp + 104)) = f } - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 104))))) == int32('C') || int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 104))))) == int32('F') || int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 104))))) == int32('G') || int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 104))))) == int32('Y') { - if !(width != 0) && *(*uintptr)(unsafe.Pointer(bp + 104)) != f { + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 104))))) == int32('C') || int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 104))))) == int32('F') || int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 104))))) == int32('G') || int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 104))))) == int32('Y') { + if !(width != 0) && **(**uintptr)(__ccgo_up(bp + 104)) != f { width = uint32(1) } } else { width = uint32(0) } - f = *(*uintptr)(unsafe.Pointer(bp + 104)) - if int32(*(*int8)(unsafe.Pointer(f))) == int32('E') || int32(*(*int8)(unsafe.Pointer(f))) == int32('O') { + f = **(**uintptr)(__ccgo_up(bp + 104)) + if int32(**(**int8)(__ccgo_up(f))) == int32('E') || int32(**(**int8)(__ccgo_up(f))) == int32('O') { f = f + 1 } - t = X__strftime_fmt_1(tls, bp+4, bp, int32(*(*int8)(unsafe.Pointer(f))), tm, loc, pad) + t = X__strftime_fmt_1(tls, bp+4, bp, int32(**(**int8)(__ccgo_up(f))), tm, loc, pad) if !(t != 0) { break } @@ -150653,26 +150653,26 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl /* Trim off any sign and leading zeros, then * count remaining digits to determine behavior * for the + flag. */ - if int32(*(*int8)(unsafe.Pointer(t))) == int32('+') || int32(*(*int8)(unsafe.Pointer(t))) == int32('-') { + if int32(**(**int8)(__ccgo_up(t))) == int32('+') || int32(**(**int8)(__ccgo_up(t))) == int32('-') { t = t + 1 - *(*Tsize_t)(unsafe.Pointer(bp)) = *(*Tsize_t)(unsafe.Pointer(bp)) - 1 + **(**Tsize_t)(__ccgo_up(bp)) = **(**Tsize_t)(__ccgo_up(bp)) - 1 } for { - if !(int32(*(*int8)(unsafe.Pointer(t))) == int32('0') && Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(t + 1)))-int32('0')) < uint32(10)) { + if !(int32(**(**int8)(__ccgo_up(t))) == int32('0') && Uint32FromInt32(int32(**(**int8)(__ccgo_up(t + 1)))-int32('0')) < uint32(10)) { break } goto _5 _5: ; t = t + 1 - *(*Tsize_t)(unsafe.Pointer(bp)) = *(*Tsize_t)(unsafe.Pointer(bp)) - 1 + **(**Tsize_t)(__ccgo_up(bp)) = **(**Tsize_t)(__ccgo_up(bp)) - 1 } - if width < *(*Tsize_t)(unsafe.Pointer(bp)) { - width = *(*Tsize_t)(unsafe.Pointer(bp)) + if width < uint32(**(**Tsize_t)(__ccgo_up(bp))) { + width = uint32(**(**Tsize_t)(__ccgo_up(bp))) } d = uint32(0) for { - if !(Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(t + uintptr(d))))-int32('0')) < uint32(10)) { + if !(Uint32FromInt32(int32(**(**int8)(__ccgo_up(t + uintptr(d))))-int32('0')) < uint32(10)) { break } goto _6 @@ -150683,41 +150683,41 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl if (*Ttm)(unsafe.Pointer(tm)).Ftm_year < -int32(1900) { v2 = l l = l + 1 - *(*int8)(unsafe.Pointer(s + uintptr(v2))) = int8('-') + **(**int8)(__ccgo_up(s + uintptr(v2))) = int8('-') width = width - 1 } else { if v9 = plus != 0; v9 { - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 104))))) == int32('C') { + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 104))))) == int32('C') { v4 = int32(3) } else { v4 = int32(5) } } - if v9 && d+(width-*(*Tsize_t)(unsafe.Pointer(bp))) >= Uint32FromInt32(v4) { + if v9 && d+(width-uint32(**(**Tsize_t)(__ccgo_up(bp)))) >= Uint32FromInt32(v4) { v2 = l l = l + 1 - *(*int8)(unsafe.Pointer(s + uintptr(v2))) = int8('+') + **(**int8)(__ccgo_up(s + uintptr(v2))) = int8('+') width = width - 1 } } for { - if !(width > *(*Tsize_t)(unsafe.Pointer(bp)) && l < n) { + if !(width > uint32(**(**Tsize_t)(__ccgo_up(bp))) && l < n) { break } v2 = l l = l + 1 - *(*int8)(unsafe.Pointer(s + uintptr(v2))) = int8('0') + **(**int8)(__ccgo_up(s + uintptr(v2))) = int8('0') goto _11 _11: ; width = width - 1 } } - if *(*Tsize_t)(unsafe.Pointer(bp)) > n-l { - *(*Tsize_t)(unsafe.Pointer(bp)) = n - l + if **(**Tsize_t)(__ccgo_up(bp)) > n-l { + **(**Tsize_t)(__ccgo_up(bp)) = n - l } - Xmemcpy(tls, s+uintptr(l), t, *(*Tsize_t)(unsafe.Pointer(bp))) - l = l + *(*Tsize_t)(unsafe.Pointer(bp)) + Xmemcpy(tls, s+uintptr(l), t, **(**Tsize_t)(__ccgo_up(bp))) + l = l + **(**Tsize_t)(__ccgo_up(bp)) goto _1 _1: ; @@ -150727,7 +150727,7 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl if l == n { l = n - uint32(1) } - *(*int8)(unsafe.Pointer(s + uintptr(l))) = 0 + **(**int8)(__ccgo_up(s + uintptr(l))) = 0 } return uint32(0) } @@ -150765,18 +150765,18 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { var _ /* relyear at bp+8 */ int32 _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = adj, dest, ex, i, len1, min, neg, range1, w, want_century, v1, v2, v5, v6, v8, v9 want_century = 0 - *(*int32)(unsafe.Pointer(bp + 4)) = 0 - *(*int32)(unsafe.Pointer(bp + 8)) = 0 - for *(*int8)(unsafe.Pointer(f)) != 0 { - if int32(*(*int8)(unsafe.Pointer(f))) != int32('%') { - v1 = int32(*(*int8)(unsafe.Pointer(f))) + **(**int32)(__ccgo_up(bp + 4)) = 0 + **(**int32)(__ccgo_up(bp + 8)) = 0 + for **(**int8)(__ccgo_up(f)) != 0 { + if int32(**(**int8)(__ccgo_up(f))) != int32('%') { + v1 = int32(**(**int8)(__ccgo_up(f))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _3 _3: if v2 != 0 { for { - if v8 = *(*int8)(unsafe.Pointer(s)) != 0; v8 { - v5 = int32(*(*int8)(unsafe.Pointer(s))) + if v8 = **(**int8)(__ccgo_up(s)) != 0; v8 { + v5 = int32(**(**int8)(__ccgo_up(s))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _7 _7: @@ -150790,7 +150790,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { s = s + 1 } } else { - if int32(*(*int8)(unsafe.Pointer(s))) != int32(*(*int8)(unsafe.Pointer(f))) { + if int32(**(**int8)(__ccgo_up(s))) != int32(**(**int8)(__ccgo_up(f))) { return uintptr(0) } else { s = s + 1 @@ -150800,19 +150800,19 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { continue } f = f + 1 - if int32(*(*int8)(unsafe.Pointer(f))) == int32('+') { + if int32(**(**int8)(__ccgo_up(f))) == int32('+') { f = f + 1 } - if BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(f)))-uint32('0') < uint32(10)) != 0 { + if BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(f)))-uint32('0') < uint32(10)) != 0 { w = Int32FromUint32(Xstrtoul(tls, f, bp+12, int32(10))) - f = *(*uintptr)(unsafe.Pointer(bp + 12)) + f = **(**uintptr)(__ccgo_up(bp + 12)) } else { w = -int32(1) } adj = 0 v9 = f f = f + 1 - switch int32(*(*int8)(unsafe.Pointer(v9))) { + switch int32(**(**int8)(__ccgo_up(v9))) { case int32('A'): goto _10 case int32('a'): @@ -150963,8 +150963,8 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { ; _44: ; - if v8 = *(*int8)(unsafe.Pointer(s)) != 0; v8 { - v1 = int32(*(*int8)(unsafe.Pointer(s))) + if v8 = **(**int8)(__ccgo_up(s)) != 0; v8 { + v1 = int32(**(**int8)(__ccgo_up(s))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _47 _47: @@ -150986,15 +150986,15 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { ex = Xnl_langinfo(tls, int32(AM_STR)) len1 = _strlen(tls, ex) if !(Xstrncasecmp(tls, s, ex, len1) != 0) { - *(*int32)(unsafe.Pointer(tm + 8)) %= int32(12) + **(**int32)(__ccgo_up(tm + 8)) %= int32(12) s = s + uintptr(len1) goto _41 } ex = Xnl_langinfo(tls, int32(PM_STR)) len1 = _strlen(tls, ex) if !(Xstrncasecmp(tls, s, ex, len1) != 0) { - *(*int32)(unsafe.Pointer(tm + 8)) %= int32(12) - *(*int32)(unsafe.Pointer(tm + 8)) += int32(12) + **(**int32)(__ccgo_up(tm + 8)) %= int32(12) + **(**int32)(__ccgo_up(tm + 8)) += int32(12) s = s + uintptr(len1) goto _41 } @@ -151074,7 +151074,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { ; v9 = s s = s + 1 - if int32(*(*int8)(unsafe.Pointer(v9))) != int32('%') { + if int32(**(**int8)(__ccgo_up(v9))) != int32('%') { return uintptr(0) } goto _41 @@ -151084,27 +151084,27 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { goto numeric_range numeric_range: ; - if !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + if !(BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } - *(*int32)(unsafe.Pointer(dest)) = 0 + **(**int32)(__ccgo_up(dest)) = 0 i = int32(1) for { - if !(i <= min+range1 && BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0) { + if !(i <= min+range1 && BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(s)))-uint32('0') < uint32(10)) != 0) { break } v9 = s s = s + 1 - *(*int32)(unsafe.Pointer(dest)) = *(*int32)(unsafe.Pointer(dest))*int32(10) + int32(*(*int8)(unsafe.Pointer(v9))) - int32('0') + **(**int32)(__ccgo_up(dest)) = **(**int32)(__ccgo_up(dest))*int32(10) + int32(**(**int8)(__ccgo_up(v9))) - int32('0') goto _50 _50: ; i = i * int32(10) } - if Uint32FromInt32(*(*int32)(unsafe.Pointer(dest))-min) >= Uint32FromInt32(range1) { + if Uint32FromInt32(**(**int32)(__ccgo_up(dest))-min) >= Uint32FromInt32(range1) { return uintptr(0) } - *(*int32)(unsafe.Pointer(dest)) -= adj + **(**int32)(__ccgo_up(dest)) -= adj switch int32(dest) - int32(tm) { case Int32FromUint32(uint32(UintptrFromInt32(0) + 28)): } @@ -151113,36 +151113,36 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { numeric_digits: ; neg = 0 - if int32(*(*int8)(unsafe.Pointer(s))) == int32('+') { + if int32(**(**int8)(__ccgo_up(s))) == int32('+') { s = s + 1 } else { - if int32(*(*int8)(unsafe.Pointer(s))) == int32('-') { + if int32(**(**int8)(__ccgo_up(s))) == int32('-') { neg = int32(1) s = s + 1 } } - if !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + if !(BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } v1 = Int32FromInt32(0) i = v1 - *(*int32)(unsafe.Pointer(dest)) = v1 + **(**int32)(__ccgo_up(dest)) = v1 for { - if !(i < w && BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0) { + if !(i < w && BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(s)))-uint32('0') < uint32(10)) != 0) { break } v9 = s s = s + 1 - *(*int32)(unsafe.Pointer(dest)) = *(*int32)(unsafe.Pointer(dest))*int32(10) + int32(*(*int8)(unsafe.Pointer(v9))) - int32('0') + **(**int32)(__ccgo_up(dest)) = **(**int32)(__ccgo_up(dest))*int32(10) + int32(**(**int8)(__ccgo_up(v9))) - int32('0') goto _52 _52: ; i = i + 1 } if neg != 0 { - *(*int32)(unsafe.Pointer(dest)) = -*(*int32)(unsafe.Pointer(dest)) + **(**int32)(__ccgo_up(dest)) = -**(**int32)(__ccgo_up(dest)) } - *(*int32)(unsafe.Pointer(dest)) -= adj + **(**int32)(__ccgo_up(dest)) -= adj goto update goto symbolic_range symbolic_range: @@ -151158,7 +151158,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { goto _55 } s = s + uintptr(len1) - *(*int32)(unsafe.Pointer(dest)) = i % range1 + **(**int32)(__ccgo_up(dest)) = i % range1 break goto _55 _55: @@ -151176,12 +151176,12 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { _41: } if want_century != 0 { - (*Ttm)(unsafe.Pointer(tm)).Ftm_year = *(*int32)(unsafe.Pointer(bp + 8)) + (*Ttm)(unsafe.Pointer(tm)).Ftm_year = **(**int32)(__ccgo_up(bp + 8)) if want_century&int32(2) != 0 { - *(*int32)(unsafe.Pointer(tm + 20)) += *(*int32)(unsafe.Pointer(bp + 4))*int32(100) - int32(1900) + **(**int32)(__ccgo_up(tm + 20)) += **(**int32)(__ccgo_up(bp + 4))*int32(100) - int32(1900) } else { if (*Ttm)(unsafe.Pointer(tm)).Ftm_year <= int32(68) { - *(*int32)(unsafe.Pointer(tm + 20)) += int32(100) + **(**int32)(__ccgo_up(tm + 20)) += int32(100) } } } @@ -151198,9 +151198,9 @@ func Xtime(tls *TLS, t uintptr) (r Ttime_t) { var _ /* ts at bp+0 */ Ttimespec X__clock_gettime(tls, CLOCK_REALTIME, bp) if t != 0 { - *(*Ttime_t)(unsafe.Pointer(t)) = (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec + **(**Ttime_t)(__ccgo_up(t)) = (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec } - return (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec + return (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec } func Xtimegm(tls *TLS, tm uintptr) (r Ttime_t) { @@ -151215,10 +151215,10 @@ func Xtimegm(tls *TLS, tm uintptr) (r Ttime_t) { _ = t t = X__tm_to_secs(tls, tm) if X__secs_to_tm(tls, t, bp) < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return int64(-int32(1)) } - *(*Ttm1)(unsafe.Pointer(tm)) = *(*Ttm1)(unsafe.Pointer(bp)) + **(**Ttm1)(__ccgo_up(tm)) = **(**Ttm1)(__ccgo_up(bp)) (*Ttm1)(unsafe.Pointer(tm)).Ftm_isdst = 0 (*Ttm1)(unsafe.Pointer(tm)).Ftm_gmtoff = 0 (*Ttm1)(unsafe.Pointer(tm)).Ftm_zone = uintptr(unsafe.Pointer(&X__utc)) @@ -151279,10 +151279,10 @@ func Xtimer_gettime(tls *TLS, t Ttimer_t, val uintptr) (r1 int32) { } r = int32(X__syscall2(tls, int32(Int32FromInt32(__NR_timer_create)+Int32FromInt32(2)), int32(t), int32(bp))) if !(r != 0) { - (*Titimerspec)(unsafe.Pointer(val)).Fit_interval.Ftv_sec = int64((*(*[4]int32)(unsafe.Pointer(bp)))[0]) - (*Titimerspec)(unsafe.Pointer(val)).Fit_interval.Ftv_nsec = (*(*[4]int32)(unsafe.Pointer(bp)))[int32(1)] - (*Titimerspec)(unsafe.Pointer(val)).Fit_value.Ftv_sec = int64((*(*[4]int32)(unsafe.Pointer(bp)))[int32(2)]) - (*Titimerspec)(unsafe.Pointer(val)).Fit_value.Ftv_nsec = (*(*[4]int32)(unsafe.Pointer(bp)))[int32(3)] + (*Titimerspec)(unsafe.Pointer(val)).Fit_interval.Ftv_sec = int64((**(**[4]int32)(__ccgo_up(bp)))[0]) + (*Titimerspec)(unsafe.Pointer(val)).Fit_interval.Ftv_nsec = (**(**[4]int32)(__ccgo_up(bp)))[int32(1)] + (*Titimerspec)(unsafe.Pointer(val)).Fit_value.Ftv_sec = int64((**(**[4]int32)(__ccgo_up(bp)))[int32(2)]) + (*Titimerspec)(unsafe.Pointer(val)).Fit_value.Ftv_nsec = (**(**[4]int32)(__ccgo_up(bp)))[int32(3)] } return X__syscall_ret(tls, Uint32FromInt32(r)) return X__syscall_ret(tls, Uint32FromInt32(X__syscall2(tls, int32(Int32FromInt32(__NR_timer_create)+Int32FromInt32(2)), int32(t), int32(val)))) @@ -151332,10 +151332,10 @@ func Xtimer_settime(tls *TLS, t Ttimer_t, flags int32, val uintptr, old uintptr) } r = int32(X__syscall4(tls, int32(Int32FromInt32(__NR_timer_create)+Int32FromInt32(1)), int32(t), flags, int32(bp+32), int32(bp+48))) if !(r != 0) && old != 0 { - (*Titimerspec)(unsafe.Pointer(old)).Fit_interval.Ftv_sec = int64((*(*[4]int32)(unsafe.Pointer(bp + 48)))[0]) - (*Titimerspec)(unsafe.Pointer(old)).Fit_interval.Ftv_nsec = (*(*[4]int32)(unsafe.Pointer(bp + 48)))[int32(1)] - (*Titimerspec)(unsafe.Pointer(old)).Fit_value.Ftv_sec = int64((*(*[4]int32)(unsafe.Pointer(bp + 48)))[int32(2)]) - (*Titimerspec)(unsafe.Pointer(old)).Fit_value.Ftv_nsec = (*(*[4]int32)(unsafe.Pointer(bp + 48)))[int32(3)] + (*Titimerspec)(unsafe.Pointer(old)).Fit_interval.Ftv_sec = int64((**(**[4]int32)(__ccgo_up(bp + 48)))[0]) + (*Titimerspec)(unsafe.Pointer(old)).Fit_interval.Ftv_nsec = (**(**[4]int32)(__ccgo_up(bp + 48)))[int32(1)] + (*Titimerspec)(unsafe.Pointer(old)).Fit_value.Ftv_sec = int64((**(**[4]int32)(__ccgo_up(bp + 48)))[int32(2)]) + (*Titimerspec)(unsafe.Pointer(old)).Fit_value.Ftv_nsec = (**(**[4]int32)(__ccgo_up(bp + 48)))[int32(3)] } return X__syscall_ret(tls, Uint32FromInt32(r)) return X__syscall_ret(tls, Uint32FromInt32(X__syscall4(tls, int32(Int32FromInt32(__NR_timer_create)+Int32FromInt32(1)), int32(t), flags, int32(val), int32(old)))) @@ -151430,92 +151430,92 @@ func X__wcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl if !(l < n) { break } - if !(*(*Twchar_t)(unsafe.Pointer(f)) != 0) { - *(*Twchar_t)(unsafe.Pointer(s + uintptr(l)*4)) = 0 + if !(**(**Twchar_t)(__ccgo_up(f)) != 0) { + **(**Twchar_t)(__ccgo_up(s + uintptr(l)*4)) = 0 return l } - if *(*Twchar_t)(unsafe.Pointer(f)) != int32('%') { + if **(**Twchar_t)(__ccgo_up(f)) != int32('%') { v2 = l l = l + 1 - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = *(*Twchar_t)(unsafe.Pointer(f)) + **(**Twchar_t)(__ccgo_up(s + uintptr(v2)*4)) = **(**Twchar_t)(__ccgo_up(f)) goto _1 } f += 4 pad = 0 - if *(*Twchar_t)(unsafe.Pointer(f)) == int32('-') || *(*Twchar_t)(unsafe.Pointer(f)) == int32('_') || *(*Twchar_t)(unsafe.Pointer(f)) == int32('0') { + if **(**Twchar_t)(__ccgo_up(f)) == int32('-') || **(**Twchar_t)(__ccgo_up(f)) == int32('_') || **(**Twchar_t)(__ccgo_up(f)) == int32('0') { v3 = f f += 4 - pad = *(*Twchar_t)(unsafe.Pointer(v3)) + pad = int32(**(**Twchar_t)(__ccgo_up(v3))) } - v4 = BoolInt32(*(*Twchar_t)(unsafe.Pointer(f)) == Int32FromUint8('+')) + v4 = BoolInt32(**(**Twchar_t)(__ccgo_up(f)) == Int32FromUint8('+')) plus = v4 if v4 != 0 { f += 4 } width = Xwcstoul(tls, f, bp+504, int32(10)) - if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 504)))) == int32('C') || *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 504)))) == int32('F') || *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 504)))) == int32('G') || *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 504)))) == int32('Y') { - if !(width != 0) && *(*uintptr)(unsafe.Pointer(bp + 504)) != f { + if **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 504)))) == int32('C') || **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 504)))) == int32('F') || **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 504)))) == int32('G') || **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 504)))) == int32('Y') { + if !(width != 0) && **(**uintptr)(__ccgo_up(bp + 504)) != f { width = uint32(1) } } else { width = uint32(0) } - f = *(*uintptr)(unsafe.Pointer(bp + 504)) - if *(*Twchar_t)(unsafe.Pointer(f)) == int32('E') || *(*Twchar_t)(unsafe.Pointer(f)) == int32('O') { + f = **(**uintptr)(__ccgo_up(bp + 504)) + if **(**Twchar_t)(__ccgo_up(f)) == int32('E') || **(**Twchar_t)(__ccgo_up(f)) == int32('O') { f += 4 } - t_mb = X__strftime_fmt_1(tls, bp+4, bp, *(*Twchar_t)(unsafe.Pointer(f)), tm, loc, pad) + t_mb = X__strftime_fmt_1(tls, bp+4, bp, int32(**(**Twchar_t)(__ccgo_up(f))), tm, loc, pad) if !(t_mb != 0) { break } - *(*Tsize_t)(unsafe.Pointer(bp)) = Xmbstowcs(tls, bp+104, t_mb, Uint32FromInt64(400)/Uint32FromInt64(4)) - if *(*Tsize_t)(unsafe.Pointer(bp)) == Uint32FromInt32(-Int32FromInt32(1)) { + **(**Tsize_t)(__ccgo_up(bp)) = Xmbstowcs(tls, bp+104, t_mb, Uint32FromInt64(400)/Uint32FromInt64(4)) + if **(**Tsize_t)(__ccgo_up(bp)) == Uint32FromInt32(-Int32FromInt32(1)) { return uint32(0) } t = bp + 104 if width != 0 { for { - if !(*(*Twchar_t)(unsafe.Pointer(t)) == int32('+') || *(*Twchar_t)(unsafe.Pointer(t)) == int32('-') || *(*Twchar_t)(unsafe.Pointer(t)) == int32('0') && *(*Twchar_t)(unsafe.Pointer(t + 1*4)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(t)) == int32('+') || **(**Twchar_t)(__ccgo_up(t)) == int32('-') || **(**Twchar_t)(__ccgo_up(t)) == int32('0') && **(**Twchar_t)(__ccgo_up(t + 1*4)) != 0) { break } goto _5 _5: ; t += 4 - *(*Tsize_t)(unsafe.Pointer(bp)) = *(*Tsize_t)(unsafe.Pointer(bp)) - 1 + **(**Tsize_t)(__ccgo_up(bp)) = **(**Tsize_t)(__ccgo_up(bp)) - 1 } width = width - 1 if plus != 0 && (*Ttm)(unsafe.Pointer(tm)).Ftm_year >= Int32FromInt32(10000)-Int32FromInt32(1900) { v2 = l l = l + 1 - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = int32('+') + **(**Twchar_t)(__ccgo_up(s + uintptr(v2)*4)) = int32('+') } else { if (*Ttm)(unsafe.Pointer(tm)).Ftm_year < -int32(1900) { v2 = l l = l + 1 - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = int32('-') + **(**Twchar_t)(__ccgo_up(s + uintptr(v2)*4)) = int32('-') } else { width = width + 1 } } for { - if !(width > *(*Tsize_t)(unsafe.Pointer(bp)) && l < n) { + if !(width > uint32(**(**Tsize_t)(__ccgo_up(bp))) && l < n) { break } v2 = l l = l + 1 - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = int32('0') + **(**Twchar_t)(__ccgo_up(s + uintptr(v2)*4)) = int32('0') goto _8 _8: ; width = width - 1 } } - if *(*Tsize_t)(unsafe.Pointer(bp)) >= n-l { - *(*Tsize_t)(unsafe.Pointer(bp)) = n - l + if **(**Tsize_t)(__ccgo_up(bp)) >= n-l { + **(**Tsize_t)(__ccgo_up(bp)) = n - l } - Xwmemcpy(tls, s+uintptr(l)*4, t, *(*Tsize_t)(unsafe.Pointer(bp))) - l = l + *(*Tsize_t)(unsafe.Pointer(bp)) + Xwmemcpy(tls, s+uintptr(l)*4, t, **(**Tsize_t)(__ccgo_up(bp))) + l = l + **(**Tsize_t)(__ccgo_up(bp)) goto _1 _1: ; @@ -151525,7 +151525,7 @@ func X__wcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl if l == n { l = n - uint32(1) } - *(*Twchar_t)(unsafe.Pointer(s + uintptr(l)*4)) = 0 + **(**Twchar_t)(__ccgo_up(s + uintptr(l)*4)) = 0 } return uint32(0) } @@ -151578,14 +151578,14 @@ func Xalarm(tls *TLS, seconds uint32) (r uint32) { defer tls.Free(64) var _ /* it at bp+0 */ Titimerval var _ /* old at bp+32 */ Titimerval - *(*Titimerval)(unsafe.Pointer(bp)) = Titimerval{ + **(**Titimerval)(__ccgo_up(bp)) = Titimerval{ Fit_value: Ttimeval{ Ftv_sec: Int64FromUint32(seconds), }, } - *(*Titimerval)(unsafe.Pointer(bp + 32)) = Titimerval{} + **(**Titimerval)(__ccgo_up(bp + 32)) = Titimerval{} Xsetitimer(tls, ITIMER_REAL, bp, bp+32) - return Uint32FromInt64((*(*Titimerval)(unsafe.Pointer(bp + 32))).Fit_value.Ftv_sec + BoolInt64(!!((*(*Titimerval)(unsafe.Pointer(bp + 32))).Fit_value.Ftv_usec != 0))) + return Uint32FromInt64((**(**Titimerval)(__ccgo_up(bp + 32))).Fit_value.Ftv_sec + BoolInt64(!!((**(**Titimerval)(__ccgo_up(bp + 32))).Fit_value.Ftv_usec != 0))) } func Xchdir(tls *TLS, path uintptr) (r int32) { @@ -151726,7 +151726,7 @@ func _checker(tls *TLS, p uintptr) (r int32) { if X__syscall2(tls, int32(SYS_setregid32), X__syscall0(tls, int32(SYS_getegid32)), int32(-Int32FromInt32(1))) != 0 || X__syscall2(tls, int32(SYS_setreuid32), X__syscall0(tls, int32(SYS_geteuid32)), int32(-Int32FromInt32(1))) != 0 { X__syscall1(tls, int32(SYS_exit), int32(Int32FromInt32(1))) } - *(*int32)(unsafe.Pointer(bp)) = int32(X__syscall4(tls, int32(SYS_faccessat), (*Tctx1)(unsafe.Pointer(c)).Ffd, int32((*Tctx1)(unsafe.Pointer(c)).Ffilename), (*Tctx1)(unsafe.Pointer(c)).Famode, int32(Int32FromInt32(0)))) + **(**int32)(__ccgo_up(bp)) = int32(X__syscall4(tls, int32(SYS_faccessat), (*Tctx1)(unsafe.Pointer(c)).Ffd, int32((*Tctx1)(unsafe.Pointer(c)).Ffilename), (*Tctx1)(unsafe.Pointer(c)).Famode, int32(Int32FromInt32(0)))) X__syscall3(tls, int32(SYS_write), (*Tctx1)(unsafe.Pointer(c)).Fp, int32(bp), Int32FromUint32(Uint32FromInt64(4))) return 0 } @@ -151840,7 +151840,7 @@ func Xgetcwd(tls *TLS, buf uintptr, size Tsize_t) (r uintptr) { size = v1 } else { if !(size != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } } @@ -151848,8 +151848,8 @@ func Xgetcwd(tls *TLS, buf uintptr, size Tsize_t) (r uintptr) { if ret < 0 { return uintptr(0) } - if ret == 0 || int32(*(*int8)(unsafe.Pointer(buf))) != int32('/') { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOENT) + if ret == 0 || int32(**(**int8)(__ccgo_up(buf))) != int32('/') { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOENT) return uintptr(0) } if buf == tmp { @@ -151913,8 +151913,8 @@ func Xgethostname(tls *TLS, name uintptr, len1 Tsize_t) (r int32) { i = uint32(0) for { if v3 = i < len1; v3 { - v2 = *(*int8)(unsafe.Pointer(bp + 65 + uintptr(i))) - *(*int8)(unsafe.Pointer(name + uintptr(i))) = v2 + v2 = **(**int8)(__ccgo_up(bp + 65 + uintptr(i))) + **(**int8)(__ccgo_up(name + uintptr(i))) = v2 } if !(v3 && v2 != 0) { break @@ -151925,7 +151925,7 @@ func Xgethostname(tls *TLS, name uintptr, len1 Tsize_t) (r int32) { i = i + 1 } if i != 0 && i == len1 { - *(*int8)(unsafe.Pointer(name + uintptr(i-uint32(1)))) = 0 + **(**int8)(__ccgo_up(name + uintptr(i-uint32(1)))) = 0 } return 0 } @@ -152018,8 +152018,8 @@ func Xisatty(tls *TLS, fd int32) (r1 int32) { if r == uint32(0) { return int32(1) } - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(EBADF) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOTTY) + if **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(EBADF) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOTTY) } return 0 } @@ -152061,7 +152061,7 @@ func X__lseek(tls *TLS, fd int32, offset Toff_t, whence int32) (r Toff_t) { if X__syscall_ret(tls, Uint32FromInt32(X__syscall5(tls, int32(SYS__llseek), fd, int32(offset>>Int32FromInt32(32)), int32(offset), int32(bp), whence))) != 0 { v1 = int64(-int32(1)) } else { - v1 = *(*Toff_t)(unsafe.Pointer(bp)) + v1 = **(**Toff_t)(__ccgo_up(bp)) } return v1 } @@ -152094,8 +152094,8 @@ func Xnice(tls *TLS, inc int32) (r int32) { prio = -int32(NZERO) } if Xsetpriority(tls, PRIO_PROCESS, uint32(0), prio) != 0 { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EACCES) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EPERM) + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EACCES) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EPERM) } return -int32(1) } else { @@ -152142,12 +152142,12 @@ func Xpipe2(tls *TLS, fd uintptr, flag int32) (r int32) { return ret } if flag&int32(O_CLOEXEC) != 0 { - X__syscall3(tls, int32(SYS_fcntl64), *(*int32)(unsafe.Pointer(fd)), int32(Int32FromInt32(F_SETFD)), int32(Int32FromInt32(FD_CLOEXEC))) - X__syscall3(tls, int32(SYS_fcntl64), *(*int32)(unsafe.Pointer(fd + 1*4)), int32(Int32FromInt32(F_SETFD)), int32(Int32FromInt32(FD_CLOEXEC))) + X__syscall3(tls, int32(SYS_fcntl64), int32(**(**int32)(__ccgo_up(fd))), int32(Int32FromInt32(F_SETFD)), int32(Int32FromInt32(FD_CLOEXEC))) + X__syscall3(tls, int32(SYS_fcntl64), int32(**(**int32)(__ccgo_up(fd + 1*4))), int32(Int32FromInt32(F_SETFD)), int32(Int32FromInt32(FD_CLOEXEC))) } if flag&int32(O_NONBLOCK) != 0 { - X__syscall3(tls, int32(SYS_fcntl64), *(*int32)(unsafe.Pointer(fd)), int32(Int32FromInt32(F_SETFL)), int32(Int32FromInt32(O_NONBLOCK))) - X__syscall3(tls, int32(SYS_fcntl64), *(*int32)(unsafe.Pointer(fd + 1*4)), int32(Int32FromInt32(F_SETFL)), int32(Int32FromInt32(O_NONBLOCK))) + X__syscall3(tls, int32(SYS_fcntl64), int32(**(**int32)(__ccgo_up(fd))), int32(Int32FromInt32(F_SETFL)), int32(Int32FromInt32(O_NONBLOCK))) + X__syscall3(tls, int32(SYS_fcntl64), int32(**(**int32)(__ccgo_up(fd + 1*4))), int32(Int32FromInt32(F_SETFL)), int32(Int32FromInt32(O_NONBLOCK))) } return 0 } @@ -152346,7 +152346,7 @@ func X__setxid(tls *TLS, nr int32, id int32, eid int32, sid int32) (r int32) { _ = v1 /* ret is initially nonzero so that failure of the first thread does not * trigger the safety kill above. */ - *(*Tctx2)(unsafe.Pointer(bp)) = Tctx2{ + **(**Tctx2)(__ccgo_up(bp)) = Tctx2{ Fid: id, Feid: eid, Fsid: sid, @@ -152354,10 +152354,10 @@ func X__setxid(tls *TLS, nr int32, id int32, eid int32, sid int32) (r int32) { Fret: int32(1), } ___synccall(tls, __ccgo_fp(_do_setxid), bp) - if (*(*Tctx2)(unsafe.Pointer(bp))).Fret > 0 { + if (**(**Tctx2)(__ccgo_up(bp))).Fret > 0 { v1 = -int32(EAGAIN) } else { - v1 = (*(*Tctx2)(unsafe.Pointer(bp))).Fret + v1 = (**(**Tctx2)(__ccgo_up(bp))).Fret } return X__syscall_ret(tls, Uint32FromInt32(v1)) } @@ -152370,11 +152370,11 @@ func Xsleep(tls *TLS, seconds uint32) (r uint32) { bp := tls.Alloc(16) defer tls.Free(16) var _ /* tv at bp+0 */ Ttimespec - *(*Ttimespec)(unsafe.Pointer(bp)) = Ttimespec{ + **(**Ttimespec)(__ccgo_up(bp)) = Ttimespec{ Ftv_sec: Int64FromUint32(seconds), } if Xnanosleep(tls, bp, bp) != 0 { - return Uint32FromInt64((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec) + return Uint32FromInt64((**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec) } return uint32(0) } @@ -152413,7 +152413,7 @@ func Xtcgetpgrp(tls *TLS, fd int32) (r Tpid_t) { if Xioctl(tls, fd, int32(TIOCGPGRP), VaList(bp+16, bp)) < 0 { return -int32(1) } - return *(*int32)(unsafe.Pointer(bp)) + return **(**int32)(__ccgo_up(bp)) } func Xtcsetpgrp(tls *TLS, fd int32, pgrp Tpid_t) (r int32) { @@ -152424,7 +152424,7 @@ func Xtcsetpgrp(tls *TLS, fd int32, pgrp Tpid_t) (r int32) { bp := tls.Alloc(32) defer tls.Free(32) var _ /* pgrp_int at bp+0 */ int32 - *(*int32)(unsafe.Pointer(bp)) = pgrp + **(**int32)(__ccgo_up(bp)) = pgrp return Xioctl(tls, fd, int32(TIOCSPGRP), VaList(bp+16, bp)) } @@ -152455,7 +152455,7 @@ func Xttyname(tls *TLS, fd int32) (r uintptr) { v1 = Xttyname_r(tls, fd, uintptr(unsafe.Pointer(&_buf10)), uint32(32)) result = v1 if v1 != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = result + **(**int32)(__ccgo_up(X__errno_location(tls))) = result return UintptrFromInt32(0) } return uintptr(unsafe.Pointer(&_buf10)) @@ -152476,22 +152476,22 @@ func Xttyname_r(tls *TLS, fd int32, name uintptr, size Tsize_t) (r int32) { var _ /* st2 at bp+144 */ Tstat _ = l if !(Xisatty(tls, fd) != 0) { - return *(*int32)(unsafe.Pointer(X__errno_location(tls))) + return **(**int32)(__ccgo_up(X__errno_location(tls))) } X__procfdname(tls, bp+288, Uint32FromInt32(fd)) l = Xreadlink(tls, bp+288, name, size) if l < 0 { - return *(*int32)(unsafe.Pointer(X__errno_location(tls))) + return **(**int32)(__ccgo_up(X__errno_location(tls))) } else { if Uint32FromInt32(l) == size { return int32(ERANGE) } } - *(*int8)(unsafe.Pointer(name + uintptr(l))) = 0 + **(**int8)(__ccgo_up(name + uintptr(l))) = 0 if Xstat(tls, name, bp) != 0 || Xfstat(tls, fd, bp+144) != 0 { - return *(*int32)(unsafe.Pointer(X__errno_location(tls))) + return **(**int32)(__ccgo_up(X__errno_location(tls))) } - if (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev != (*(*Tstat)(unsafe.Pointer(bp + 144))).Fst_dev || (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino != (*(*Tstat)(unsafe.Pointer(bp + 144))).Fst_ino { + if (**(**Tstat)(__ccgo_up(bp))).Fst_dev != (**(**Tstat)(__ccgo_up(bp + 144))).Fst_dev || (**(**Tstat)(__ccgo_up(bp))).Fst_ino != (**(**Tstat)(__ccgo_up(bp + 144))).Fst_ino { return int32(ENODEV) } return 0 @@ -152506,7 +152506,7 @@ func Xualarm(tls *TLS, value uint32, interval uint32) (r uint32) { defer tls.Free(64) var _ /* it at bp+0 */ Titimerval var _ /* it_old at bp+32 */ Titimerval - *(*Titimerval)(unsafe.Pointer(bp)) = Titimerval{ + **(**Titimerval)(__ccgo_up(bp)) = Titimerval{ Fit_interval: Ttimeval{ Ftv_usec: Int64FromUint32(interval), }, @@ -152515,7 +152515,7 @@ func Xualarm(tls *TLS, value uint32, interval uint32) (r uint32) { }, } Xsetitimer(tls, ITIMER_REAL, bp, bp+32) - return Uint32FromInt64((*(*Titimerval)(unsafe.Pointer(bp + 32))).Fit_value.Ftv_sec*int64(1000000) + (*(*Titimerval)(unsafe.Pointer(bp + 32))).Fit_value.Ftv_usec) + return Uint32FromInt64((**(**Titimerval)(__ccgo_up(bp + 32))).Fit_value.Ftv_sec*int64(1000000) + (**(**Titimerval)(__ccgo_up(bp + 32))).Fit_value.Ftv_usec) } func Xunlink(tls *TLS, path uintptr) (r int32) { @@ -152542,7 +152542,7 @@ func Xusleep(tls *TLS, useconds uint32) (r int32) { bp := tls.Alloc(16) defer tls.Free(16) var _ /* tv at bp+0 */ Ttimespec - *(*Ttimespec)(unsafe.Pointer(bp)) = Ttimespec{ + **(**Ttimespec)(__ccgo_up(bp)) = Ttimespec{ Ftv_sec: Int64FromUint32(useconds / uint32(1000000)), Ftv_nsec: Int32FromUint32(useconds % uint32(1000000) * uint32(1000)), } @@ -152670,8 +152670,8 @@ func X__adjtime32(tls *TLS, in32 uintptr, out32 uintptr) (r1 int32) { /* We can't range-check the result because success was already * committed by the above call. */ if out32 != 0 { - (*Ttimeval32)(unsafe.Pointer(out32)).Ftv_sec = int32((*(*Ttimeval)(unsafe.Pointer(bp + 16))).Ftv_sec) - (*Ttimeval32)(unsafe.Pointer(out32)).Ftv_usec = int32((*(*Ttimeval)(unsafe.Pointer(bp + 16))).Ftv_usec) + (*Ttimeval32)(unsafe.Pointer(out32)).Ftv_sec = int32((**(**Ttimeval)(__ccgo_up(bp + 16))).Ftv_sec) + (*Ttimeval32)(unsafe.Pointer(out32)).Ftv_usec = int32((**(**Ttimeval)(__ccgo_up(bp + 16))).Ftv_usec) } return r } @@ -152718,7 +152718,7 @@ func X__clock_adjtime32(tls *TLS, clock_id Tclockid_t, tx32 uintptr) (r1 int32) var r int32 var _ /* utx at bp+0 */ Ttimex _ = r - *(*Ttimex)(unsafe.Pointer(bp)) = Ttimex{ + **(**Ttimex)(__ccgo_up(bp)) = Ttimex{ Fmodes: (*Ttimex32)(unsafe.Pointer(tx32)).Fmodes, Foffset: (*Ttimex32)(unsafe.Pointer(tx32)).Foffset, Ffreq: (*Ttimex32)(unsafe.Pointer(tx32)).Ffreq, @@ -152747,27 +152747,27 @@ func X__clock_adjtime32(tls *TLS, clock_id Tclockid_t, tx32 uintptr) (r1 int32) if r < 0 { return r } - (*Ttimex32)(unsafe.Pointer(tx32)).Fmodes = (*(*Ttimex)(unsafe.Pointer(bp))).Fmodes - (*Ttimex32)(unsafe.Pointer(tx32)).Foffset = (*(*Ttimex)(unsafe.Pointer(bp))).Foffset - (*Ttimex32)(unsafe.Pointer(tx32)).Ffreq = (*(*Ttimex)(unsafe.Pointer(bp))).Ffreq - (*Ttimex32)(unsafe.Pointer(tx32)).Fmaxerror = (*(*Ttimex)(unsafe.Pointer(bp))).Fmaxerror - (*Ttimex32)(unsafe.Pointer(tx32)).Festerror = (*(*Ttimex)(unsafe.Pointer(bp))).Festerror - (*Ttimex32)(unsafe.Pointer(tx32)).Fstatus = (*(*Ttimex)(unsafe.Pointer(bp))).Fstatus - (*Ttimex32)(unsafe.Pointer(tx32)).Fconstant = (*(*Ttimex)(unsafe.Pointer(bp))).Fconstant - (*Ttimex32)(unsafe.Pointer(tx32)).Fprecision = (*(*Ttimex)(unsafe.Pointer(bp))).Fprecision - (*Ttimex32)(unsafe.Pointer(tx32)).Ftolerance = (*(*Ttimex)(unsafe.Pointer(bp))).Ftolerance - (*Ttimex32)(unsafe.Pointer(tx32)).Ftime.Ftv_sec = int32((*(*Ttimex)(unsafe.Pointer(bp))).Ftime.Ftv_sec) - (*Ttimex32)(unsafe.Pointer(tx32)).Ftime.Ftv_usec = int32((*(*Ttimex)(unsafe.Pointer(bp))).Ftime.Ftv_usec) - (*Ttimex32)(unsafe.Pointer(tx32)).Ftick = (*(*Ttimex)(unsafe.Pointer(bp))).Ftick - (*Ttimex32)(unsafe.Pointer(tx32)).Fppsfreq = (*(*Ttimex)(unsafe.Pointer(bp))).Fppsfreq - (*Ttimex32)(unsafe.Pointer(tx32)).Fjitter = (*(*Ttimex)(unsafe.Pointer(bp))).Fjitter - (*Ttimex32)(unsafe.Pointer(tx32)).Fshift = (*(*Ttimex)(unsafe.Pointer(bp))).Fshift - (*Ttimex32)(unsafe.Pointer(tx32)).Fstabil = (*(*Ttimex)(unsafe.Pointer(bp))).Fstabil - (*Ttimex32)(unsafe.Pointer(tx32)).Fjitcnt = (*(*Ttimex)(unsafe.Pointer(bp))).Fjitcnt - (*Ttimex32)(unsafe.Pointer(tx32)).Fcalcnt = (*(*Ttimex)(unsafe.Pointer(bp))).Fcalcnt - (*Ttimex32)(unsafe.Pointer(tx32)).Ferrcnt = (*(*Ttimex)(unsafe.Pointer(bp))).Ferrcnt - (*Ttimex32)(unsafe.Pointer(tx32)).Fstbcnt = (*(*Ttimex)(unsafe.Pointer(bp))).Fstbcnt - (*Ttimex32)(unsafe.Pointer(tx32)).Ftai = (*(*Ttimex)(unsafe.Pointer(bp))).Ftai + (*Ttimex32)(unsafe.Pointer(tx32)).Fmodes = (**(**Ttimex)(__ccgo_up(bp))).Fmodes + (*Ttimex32)(unsafe.Pointer(tx32)).Foffset = (**(**Ttimex)(__ccgo_up(bp))).Foffset + (*Ttimex32)(unsafe.Pointer(tx32)).Ffreq = (**(**Ttimex)(__ccgo_up(bp))).Ffreq + (*Ttimex32)(unsafe.Pointer(tx32)).Fmaxerror = (**(**Ttimex)(__ccgo_up(bp))).Fmaxerror + (*Ttimex32)(unsafe.Pointer(tx32)).Festerror = (**(**Ttimex)(__ccgo_up(bp))).Festerror + (*Ttimex32)(unsafe.Pointer(tx32)).Fstatus = (**(**Ttimex)(__ccgo_up(bp))).Fstatus + (*Ttimex32)(unsafe.Pointer(tx32)).Fconstant = (**(**Ttimex)(__ccgo_up(bp))).Fconstant + (*Ttimex32)(unsafe.Pointer(tx32)).Fprecision = (**(**Ttimex)(__ccgo_up(bp))).Fprecision + (*Ttimex32)(unsafe.Pointer(tx32)).Ftolerance = (**(**Ttimex)(__ccgo_up(bp))).Ftolerance + (*Ttimex32)(unsafe.Pointer(tx32)).Ftime.Ftv_sec = int32((**(**Ttimex)(__ccgo_up(bp))).Ftime.Ftv_sec) + (*Ttimex32)(unsafe.Pointer(tx32)).Ftime.Ftv_usec = int32((**(**Ttimex)(__ccgo_up(bp))).Ftime.Ftv_usec) + (*Ttimex32)(unsafe.Pointer(tx32)).Ftick = (**(**Ttimex)(__ccgo_up(bp))).Ftick + (*Ttimex32)(unsafe.Pointer(tx32)).Fppsfreq = (**(**Ttimex)(__ccgo_up(bp))).Fppsfreq + (*Ttimex32)(unsafe.Pointer(tx32)).Fjitter = (**(**Ttimex)(__ccgo_up(bp))).Fjitter + (*Ttimex32)(unsafe.Pointer(tx32)).Fshift = (**(**Ttimex)(__ccgo_up(bp))).Fshift + (*Ttimex32)(unsafe.Pointer(tx32)).Fstabil = (**(**Ttimex)(__ccgo_up(bp))).Fstabil + (*Ttimex32)(unsafe.Pointer(tx32)).Fjitcnt = (**(**Ttimex)(__ccgo_up(bp))).Fjitcnt + (*Ttimex32)(unsafe.Pointer(tx32)).Fcalcnt = (**(**Ttimex)(__ccgo_up(bp))).Fcalcnt + (*Ttimex32)(unsafe.Pointer(tx32)).Ferrcnt = (**(**Ttimex)(__ccgo_up(bp))).Ferrcnt + (*Ttimex32)(unsafe.Pointer(tx32)).Fstbcnt = (**(**Ttimex)(__ccgo_up(bp))).Fstbcnt + (*Ttimex32)(unsafe.Pointer(tx32)).Ftai = (**(**Ttimex)(__ccgo_up(bp))).Ftai return r } @@ -152783,8 +152783,8 @@ func X__clock_getres_time32(tls *TLS, clk Tclockid_t, ts32 uintptr) (r1 int32) { _ = r r = Xclock_getres(tls, clk, bp) if !(r != 0) && ts32 != 0 { - (*Ttimespec32)(unsafe.Pointer(ts32)).Ftv_sec = int32((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec) - (*Ttimespec32)(unsafe.Pointer(ts32)).Ftv_nsec = (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_nsec + (*Ttimespec32)(unsafe.Pointer(ts32)).Ftv_sec = int32((**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec) + (*Ttimespec32)(unsafe.Pointer(ts32)).Ftv_nsec = (**(**Ttimespec)(__ccgo_up(bp))).Ftv_nsec } return r } @@ -152803,12 +152803,12 @@ func X__clock_gettime32(tls *TLS, clk Tclockid_t, ts32 uintptr) (r1 int32) { if r != 0 { return r } - if (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec < int64(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff)) || (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec > int64(Int32FromInt32(INT32_MAX)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + if (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec < int64(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff)) || (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec > int64(Int32FromInt32(INT32_MAX)) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return -int32(1) } - (*Ttimespec32)(unsafe.Pointer(ts32)).Ftv_sec = int32((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec) - (*Ttimespec32)(unsafe.Pointer(ts32)).Ftv_nsec = (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_nsec + (*Ttimespec32)(unsafe.Pointer(ts32)).Ftv_sec = int32((**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec) + (*Ttimespec32)(unsafe.Pointer(ts32)).Ftv_nsec = (**(**Ttimespec)(__ccgo_up(bp))).Ftv_nsec return 0 } @@ -152828,8 +152828,8 @@ func X__clock_nanosleep_time32(tls *TLS, clk Tclockid_t, flags int32, req32 uint } ret = Xclock_nanosleep(tls, clk, flags, bp, bp+16) if ret == int32(EINTR) && rem32 != 0 && !(flags&Int32FromInt32(TIMER_ABSTIME) != 0) { - (*Ttimespec32)(unsafe.Pointer(rem32)).Ftv_sec = int32((*(*Ttimespec)(unsafe.Pointer(bp + 16))).Ftv_sec) - (*Ttimespec32)(unsafe.Pointer(rem32)).Ftv_nsec = (*(*Ttimespec)(unsafe.Pointer(bp + 16))).Ftv_nsec + (*Ttimespec32)(unsafe.Pointer(rem32)).Ftv_sec = int32((**(**Ttimespec)(__ccgo_up(bp + 16))).Ftv_sec) + (*Ttimespec32)(unsafe.Pointer(rem32)).Ftv_nsec = (**(**Ttimespec)(__ccgo_up(bp + 16))).Ftv_nsec } return ret } @@ -152855,7 +152855,7 @@ func X__ctime32(tls *TLS, t uintptr) (r uintptr) { } bp := tls.Alloc(16) defer tls.Free(16) - *(*Ttime_t)(unsafe.Pointer(bp)) = int64(*(*Ttime32_t)(unsafe.Pointer(t))) + *(*Ttime_t)(unsafe.Pointer(bp)) = int64(**(**Ttime32_t)(__ccgo_up(t))) return Xctime(tls, bp) } @@ -152866,7 +152866,7 @@ func X__ctime32_r(tls *TLS, t uintptr, buf uintptr) (r uintptr) { } bp := tls.Alloc(16) defer tls.Free(16) - *(*Ttime_t)(unsafe.Pointer(bp)) = int64(*(*Ttime32_t)(unsafe.Pointer(t))) + *(*Ttime_t)(unsafe.Pointer(bp)) = int64(**(**Ttime32_t)(__ccgo_up(t))) return Xctime_r(tls, bp, buf) } @@ -152930,14 +152930,14 @@ func X__ftime32(tls *TLS, tp uintptr) (r int32) { if Xftime(tls, bp) < 0 { return -int32(1) } - if (*(*Ttimeb)(unsafe.Pointer(bp))).Ftime < int64(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff)) || (*(*Ttimeb)(unsafe.Pointer(bp))).Ftime > int64(Int32FromInt32(INT32_MAX)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + if (**(**Ttimeb)(__ccgo_up(bp))).Ftime < int64(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff)) || (**(**Ttimeb)(__ccgo_up(bp))).Ftime > int64(Int32FromInt32(INT32_MAX)) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return -int32(1) } - (*Ttimeb32)(unsafe.Pointer(tp)).Ftime = int32((*(*Ttimeb)(unsafe.Pointer(bp))).Ftime) - (*Ttimeb32)(unsafe.Pointer(tp)).Fmillitm = (*(*Ttimeb)(unsafe.Pointer(bp))).Fmillitm - (*Ttimeb32)(unsafe.Pointer(tp)).Ftimezone = (*(*Ttimeb)(unsafe.Pointer(bp))).Ftimezone - (*Ttimeb32)(unsafe.Pointer(tp)).Fdstflag = (*(*Ttimeb)(unsafe.Pointer(bp))).Fdstflag + (*Ttimeb32)(unsafe.Pointer(tp)).Ftime = int32((**(**Ttimeb)(__ccgo_up(bp))).Ftime) + (*Ttimeb32)(unsafe.Pointer(tp)).Fmillitm = (**(**Ttimeb)(__ccgo_up(bp))).Fmillitm + (*Ttimeb32)(unsafe.Pointer(tp)).Ftimezone = (**(**Ttimeb)(__ccgo_up(bp))).Ftimezone + (*Ttimeb32)(unsafe.Pointer(tp)).Fdstflag = (**(**Ttimeb)(__ccgo_up(bp))).Fdstflag return 0 } @@ -152955,12 +152955,12 @@ func X__futimens_time32(tls *TLS, fd int32, times32 uintptr) (r int32) { } else { *(*[2]Ttimespec)(unsafe.Pointer(bp)) = [2]Ttimespec{ 0: { - Ftv_sec: int64((*(*Ttimespec32)(unsafe.Pointer(times32))).Ftv_sec), - Ftv_nsec: (*(*Ttimespec32)(unsafe.Pointer(times32))).Ftv_nsec, + Ftv_sec: int64((**(**Ttimespec32)(__ccgo_up(times32))).Ftv_sec), + Ftv_nsec: (**(**Ttimespec32)(__ccgo_up(times32))).Ftv_nsec, }, 1: { - Ftv_sec: int64((*(*Ttimespec32)(unsafe.Pointer(times32 + 1*8))).Ftv_sec), - Ftv_nsec: (*(*Ttimespec32)(unsafe.Pointer(times32 + 1*8))).Ftv_nsec, + Ftv_sec: int64((**(**Ttimespec32)(__ccgo_up(times32 + 1*8))).Ftv_sec), + Ftv_nsec: (**(**Ttimespec32)(__ccgo_up(times32 + 1*8))).Ftv_nsec, }, } v1 = bp @@ -152982,12 +152982,12 @@ func X__futimes_time32(tls *TLS, fd int32, times32 uintptr) (r int32) { } else { *(*[2]Ttimeval)(unsafe.Pointer(bp)) = [2]Ttimeval{ 0: { - Ftv_sec: int64((*(*Ttimeval32)(unsafe.Pointer(times32))).Ftv_sec), - Ftv_usec: int64((*(*Ttimeval32)(unsafe.Pointer(times32))).Ftv_usec), + Ftv_sec: int64((**(**Ttimeval32)(__ccgo_up(times32))).Ftv_sec), + Ftv_usec: int64((**(**Ttimeval32)(__ccgo_up(times32))).Ftv_usec), }, 1: { - Ftv_sec: int64((*(*Ttimeval32)(unsafe.Pointer(times32 + 1*8))).Ftv_sec), - Ftv_usec: int64((*(*Ttimeval32)(unsafe.Pointer(times32 + 1*8))).Ftv_usec), + Ftv_sec: int64((**(**Ttimeval32)(__ccgo_up(times32 + 1*8))).Ftv_sec), + Ftv_usec: int64((**(**Ttimeval32)(__ccgo_up(times32 + 1*8))).Ftv_usec), }, } v1 = bp @@ -153009,12 +153009,12 @@ func X__futimesat_time32(tls *TLS, dirfd int32, pathname uintptr, times32 uintpt } else { *(*[2]Ttimeval)(unsafe.Pointer(bp)) = [2]Ttimeval{ 0: { - Ftv_sec: int64((*(*Ttimeval32)(unsafe.Pointer(times32))).Ftv_sec), - Ftv_usec: int64((*(*Ttimeval32)(unsafe.Pointer(times32))).Ftv_usec), + Ftv_sec: int64((**(**Ttimeval32)(__ccgo_up(times32))).Ftv_sec), + Ftv_usec: int64((**(**Ttimeval32)(__ccgo_up(times32))).Ftv_usec), }, 1: { - Ftv_sec: int64((*(*Ttimeval32)(unsafe.Pointer(times32 + 1*8))).Ftv_sec), - Ftv_usec: int64((*(*Ttimeval32)(unsafe.Pointer(times32 + 1*8))).Ftv_usec), + Ftv_sec: int64((**(**Ttimeval32)(__ccgo_up(times32 + 1*8))).Ftv_sec), + Ftv_usec: int64((**(**Ttimeval32)(__ccgo_up(times32 + 1*8))).Ftv_usec), }, } v1 = bp @@ -153036,10 +153036,10 @@ func X__getitimer_time32(tls *TLS, which int32, old32 uintptr) (r1 int32) { if r != 0 { return r } - (*Titimerval32)(unsafe.Pointer(old32)).Fit_interval.Ftv_sec = int32((*(*Titimerval)(unsafe.Pointer(bp))).Fit_interval.Ftv_sec) - (*Titimerval32)(unsafe.Pointer(old32)).Fit_interval.Ftv_usec = int32((*(*Titimerval)(unsafe.Pointer(bp))).Fit_interval.Ftv_usec) - (*Titimerval32)(unsafe.Pointer(old32)).Fit_value.Ftv_sec = int32((*(*Titimerval)(unsafe.Pointer(bp))).Fit_value.Ftv_sec) - (*Titimerval32)(unsafe.Pointer(old32)).Fit_value.Ftv_usec = int32((*(*Titimerval)(unsafe.Pointer(bp))).Fit_value.Ftv_usec) + (*Titimerval32)(unsafe.Pointer(old32)).Fit_interval.Ftv_sec = int32((**(**Titimerval)(__ccgo_up(bp))).Fit_interval.Ftv_sec) + (*Titimerval32)(unsafe.Pointer(old32)).Fit_interval.Ftv_usec = int32((**(**Titimerval)(__ccgo_up(bp))).Fit_interval.Ftv_usec) + (*Titimerval32)(unsafe.Pointer(old32)).Fit_value.Ftv_sec = int32((**(**Titimerval)(__ccgo_up(bp))).Fit_value.Ftv_sec) + (*Titimerval32)(unsafe.Pointer(old32)).Fit_value.Ftv_usec = int32((**(**Titimerval)(__ccgo_up(bp))).Fit_value.Ftv_usec) return 0 } @@ -153074,10 +153074,10 @@ func X__getrusage_time32(tls *TLS, who int32, usage uintptr) (r1 int32) { _ = r r = Xgetrusage(tls, who, bp) if !(r != 0) { - (*Tcompat_rusage)(unsafe.Pointer(usage)).Fru_utime.Ftv_sec = int32((*(*Trusage)(unsafe.Pointer(bp))).Fru_utime.Ftv_sec) - (*Tcompat_rusage)(unsafe.Pointer(usage)).Fru_utime.Ftv_usec = int32((*(*Trusage)(unsafe.Pointer(bp))).Fru_utime.Ftv_usec) - (*Tcompat_rusage)(unsafe.Pointer(usage)).Fru_stime.Ftv_sec = int32((*(*Trusage)(unsafe.Pointer(bp))).Fru_stime.Ftv_sec) - (*Tcompat_rusage)(unsafe.Pointer(usage)).Fru_stime.Ftv_usec = int32((*(*Trusage)(unsafe.Pointer(bp))).Fru_stime.Ftv_usec) + (*Tcompat_rusage)(unsafe.Pointer(usage)).Fru_utime.Ftv_sec = int32((**(**Trusage)(__ccgo_up(bp))).Fru_utime.Ftv_sec) + (*Tcompat_rusage)(unsafe.Pointer(usage)).Fru_utime.Ftv_usec = int32((**(**Trusage)(__ccgo_up(bp))).Fru_utime.Ftv_usec) + (*Tcompat_rusage)(unsafe.Pointer(usage)).Fru_stime.Ftv_sec = int32((**(**Trusage)(__ccgo_up(bp))).Fru_stime.Ftv_sec) + (*Tcompat_rusage)(unsafe.Pointer(usage)).Fru_stime.Ftv_usec = int32((**(**Trusage)(__ccgo_up(bp))).Fru_stime.Ftv_usec) Xmemcpy(tls, usage+16, bp+32, Uint32FromInt64(72)-uint32(UintptrFromInt32(0)+16)) } return r @@ -153100,12 +153100,12 @@ func X__gettimeofday_time32(tls *TLS, tv32 uintptr, tz uintptr) (r1 int32) { if r != 0 { return r } - if (*(*Ttimeval)(unsafe.Pointer(bp))).Ftv_sec < int64(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff)) || (*(*Ttimeval)(unsafe.Pointer(bp))).Ftv_sec > int64(Int32FromInt32(INT32_MAX)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + if (**(**Ttimeval)(__ccgo_up(bp))).Ftv_sec < int64(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff)) || (**(**Ttimeval)(__ccgo_up(bp))).Ftv_sec > int64(Int32FromInt32(INT32_MAX)) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return -int32(1) } - (*Ttimeval32)(unsafe.Pointer(tv32)).Ftv_sec = int32((*(*Ttimeval)(unsafe.Pointer(bp))).Ftv_sec) - (*Ttimeval32)(unsafe.Pointer(tv32)).Ftv_usec = int32((*(*Ttimeval)(unsafe.Pointer(bp))).Ftv_usec) + (*Ttimeval32)(unsafe.Pointer(tv32)).Ftv_sec = int32((**(**Ttimeval)(__ccgo_up(bp))).Ftv_sec) + (*Ttimeval32)(unsafe.Pointer(tv32)).Ftv_usec = int32((**(**Ttimeval)(__ccgo_up(bp))).Ftv_usec) return 0 } @@ -153116,7 +153116,7 @@ func X__gmtime32(tls *TLS, t uintptr) (r uintptr) { } bp := tls.Alloc(16) defer tls.Free(16) - *(*Ttime_t)(unsafe.Pointer(bp)) = int64(*(*Ttime32_t)(unsafe.Pointer(t))) + *(*Ttime_t)(unsafe.Pointer(bp)) = int64(**(**Ttime32_t)(__ccgo_up(t))) return Xgmtime(tls, bp) } @@ -153127,7 +153127,7 @@ func X__gmtime32_r(tls *TLS, t uintptr, tm uintptr) (r uintptr) { } bp := tls.Alloc(16) defer tls.Free(16) - *(*Ttime_t)(unsafe.Pointer(bp)) = int64(*(*Ttime32_t)(unsafe.Pointer(t))) + *(*Ttime_t)(unsafe.Pointer(bp)) = int64(**(**Ttime32_t)(__ccgo_up(t))) return Xgmtime_r(tls, bp, tm) } @@ -153138,7 +153138,7 @@ func X__localtime32(tls *TLS, t uintptr) (r uintptr) { } bp := tls.Alloc(16) defer tls.Free(16) - *(*Ttime_t)(unsafe.Pointer(bp)) = int64(*(*Ttime32_t)(unsafe.Pointer(t))) + *(*Ttime_t)(unsafe.Pointer(bp)) = int64(**(**Ttime32_t)(__ccgo_up(t))) return Xlocaltime(tls, bp) } @@ -153149,7 +153149,7 @@ func X__localtime32_r(tls *TLS, t uintptr, tm uintptr) (r uintptr) { } bp := tls.Alloc(16) defer tls.Free(16) - *(*Ttime_t)(unsafe.Pointer(bp)) = int64(*(*Ttime32_t)(unsafe.Pointer(t))) + *(*Ttime_t)(unsafe.Pointer(bp)) = int64(**(**Ttime32_t)(__ccgo_up(t))) return Xlocaltime_r(tls, bp, tm) } @@ -153184,12 +153184,12 @@ func X__lutimes_time32(tls *TLS, path uintptr, times32 uintptr) (r int32) { } else { *(*[2]Ttimeval)(unsafe.Pointer(bp)) = [2]Ttimeval{ 0: { - Ftv_sec: int64((*(*Ttimeval32)(unsafe.Pointer(times32))).Ftv_sec), - Ftv_usec: int64((*(*Ttimeval32)(unsafe.Pointer(times32))).Ftv_usec), + Ftv_sec: int64((**(**Ttimeval32)(__ccgo_up(times32))).Ftv_sec), + Ftv_usec: int64((**(**Ttimeval32)(__ccgo_up(times32))).Ftv_usec), }, 1: { - Ftv_sec: int64((*(*Ttimeval32)(unsafe.Pointer(times32 + 1*8))).Ftv_sec), - Ftv_usec: int64((*(*Ttimeval32)(unsafe.Pointer(times32 + 1*8))).Ftv_usec), + Ftv_sec: int64((**(**Ttimeval32)(__ccgo_up(times32 + 1*8))).Ftv_sec), + Ftv_usec: int64((**(**Ttimeval32)(__ccgo_up(times32 + 1*8))).Ftv_usec), }, } v1 = bp @@ -153207,13 +153207,13 @@ func X__mktime32(tls *TLS, tm uintptr) (r Ttime32_t) { var t Ttime_t var _ /* tmp at bp+0 */ Ttm _ = t - *(*Ttm)(unsafe.Pointer(bp)) = *(*Ttm)(unsafe.Pointer(tm)) + **(**Ttm)(__ccgo_up(bp)) = **(**Ttm)(__ccgo_up(tm)) t = Xmktime(tls, bp) if t < int64(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff)) || t > int64(Int32FromInt32(INT32_MAX)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return -int32(1) } - *(*Ttm)(unsafe.Pointer(tm)) = *(*Ttm)(unsafe.Pointer(bp)) + **(**Ttm)(__ccgo_up(tm)) = **(**Ttm)(__ccgo_up(bp)) return int32(t) } @@ -153232,9 +153232,9 @@ func X__nanosleep_time32(tls *TLS, req32 uintptr, rem32 uintptr) (r int32) { Ftv_nsec: (*Ttimespec32)(unsafe.Pointer(req32)).Ftv_nsec, } ret = Xnanosleep(tls, bp, bp+16) - if ret < 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EINTR) && rem32 != 0 { - (*Ttimespec32)(unsafe.Pointer(rem32)).Ftv_sec = int32((*(*Ttimespec)(unsafe.Pointer(bp + 16))).Ftv_sec) - (*Ttimespec32)(unsafe.Pointer(rem32)).Ftv_nsec = (*(*Ttimespec)(unsafe.Pointer(bp + 16))).Ftv_nsec + if ret < 0 && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EINTR) && rem32 != 0 { + (*Ttimespec32)(unsafe.Pointer(rem32)).Ftv_sec = int32((**(**Ttimespec)(__ccgo_up(bp + 16))).Ftv_sec) + (*Ttimespec32)(unsafe.Pointer(rem32)).Ftv_nsec = (**(**Ttimespec)(__ccgo_up(bp + 16))).Ftv_nsec } return ret } @@ -153373,10 +153373,10 @@ func X__setitimer_time32(tls *TLS, which int32, new32 uintptr, old32 uintptr) (r * Since these are relative times, values large enough to overflow * don't make sense anyway. */ if old32 != 0 { - (*Titimerval32)(unsafe.Pointer(old32)).Fit_interval.Ftv_sec = int32((*(*Titimerval)(unsafe.Pointer(bp + 32))).Fit_interval.Ftv_sec) - (*Titimerval32)(unsafe.Pointer(old32)).Fit_interval.Ftv_usec = int32((*(*Titimerval)(unsafe.Pointer(bp + 32))).Fit_interval.Ftv_usec) - (*Titimerval32)(unsafe.Pointer(old32)).Fit_value.Ftv_sec = int32((*(*Titimerval)(unsafe.Pointer(bp + 32))).Fit_value.Ftv_sec) - (*Titimerval32)(unsafe.Pointer(old32)).Fit_value.Ftv_usec = int32((*(*Titimerval)(unsafe.Pointer(bp + 32))).Fit_value.Ftv_usec) + (*Titimerval32)(unsafe.Pointer(old32)).Fit_interval.Ftv_sec = int32((**(**Titimerval)(__ccgo_up(bp + 32))).Fit_interval.Ftv_sec) + (*Titimerval32)(unsafe.Pointer(old32)).Fit_interval.Ftv_usec = int32((**(**Titimerval)(__ccgo_up(bp + 32))).Fit_interval.Ftv_usec) + (*Titimerval32)(unsafe.Pointer(old32)).Fit_value.Ftv_sec = int32((**(**Titimerval)(__ccgo_up(bp + 32))).Fit_value.Ftv_sec) + (*Titimerval32)(unsafe.Pointer(old32)).Fit_value.Ftv_usec = int32((**(**Titimerval)(__ccgo_up(bp + 32))).Fit_value.Ftv_usec) } return 0 } @@ -153447,7 +153447,7 @@ func X__stime32(tls *TLS, t uintptr) (r int32) { } bp := tls.Alloc(16) defer tls.Free(16) - *(*Ttime_t)(unsafe.Pointer(bp)) = int64(*(*Ttime32_t)(unsafe.Pointer(t))) + *(*Ttime_t)(unsafe.Pointer(bp)) = int64(**(**Ttime32_t)(__ccgo_up(t))) return Xstime(tls, bp) } @@ -153460,11 +153460,11 @@ func X__time32(tls *TLS, p uintptr) (r Ttime32_t) { _ = t t = Xtime(tls, uintptr(0)) if t < int64(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff)) || t > int64(Int32FromInt32(INT32_MAX)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return -int32(1) } if p != 0 { - *(*Ttime32_t)(unsafe.Pointer(p)) = int32(t) + **(**Ttime32_t)(__ccgo_up(p)) = int32(t) } return int32(t) } @@ -153478,7 +153478,7 @@ func X__time32gm(tls *TLS, tm uintptr) (r Ttime32_t) { _ = t t = Xtimegm(tls, tm) if t < int64(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff)) || t > int64(Int32FromInt32(INT32_MAX)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return -int32(1) } return int32(t) @@ -153499,10 +153499,10 @@ func X__timer_gettime32(tls *TLS, t Ttimer_t, val32 uintptr) (r1 int32) { return r } /* No range checking for consistency with settime */ - (*Titimerspec32)(unsafe.Pointer(val32)).Fit_interval.Ftv_sec = int32((*(*Titimerspec)(unsafe.Pointer(bp))).Fit_interval.Ftv_sec) - (*Titimerspec32)(unsafe.Pointer(val32)).Fit_interval.Ftv_nsec = (*(*Titimerspec)(unsafe.Pointer(bp))).Fit_interval.Ftv_nsec - (*Titimerspec32)(unsafe.Pointer(val32)).Fit_value.Ftv_sec = int32((*(*Titimerspec)(unsafe.Pointer(bp))).Fit_value.Ftv_sec) - (*Titimerspec32)(unsafe.Pointer(val32)).Fit_value.Ftv_nsec = (*(*Titimerspec)(unsafe.Pointer(bp))).Fit_value.Ftv_nsec + (*Titimerspec32)(unsafe.Pointer(val32)).Fit_interval.Ftv_sec = int32((**(**Titimerspec)(__ccgo_up(bp))).Fit_interval.Ftv_sec) + (*Titimerspec32)(unsafe.Pointer(val32)).Fit_interval.Ftv_nsec = (**(**Titimerspec)(__ccgo_up(bp))).Fit_interval.Ftv_nsec + (*Titimerspec32)(unsafe.Pointer(val32)).Fit_value.Ftv_sec = int32((**(**Titimerspec)(__ccgo_up(bp))).Fit_value.Ftv_sec) + (*Titimerspec32)(unsafe.Pointer(val32)).Fit_value.Ftv_nsec = (**(**Titimerspec)(__ccgo_up(bp))).Fit_value.Ftv_nsec return 0 } @@ -153541,10 +153541,10 @@ func X__timer_settime32(tls *TLS, t Ttimer_t, flags int32, val32 uintptr, old32 * Since these are relative times, values large enough to overflow * don't make sense anyway. */ if old32 != 0 { - (*Titimerspec32)(unsafe.Pointer(old32)).Fit_interval.Ftv_sec = int32((*(*Titimerspec)(unsafe.Pointer(bp + 32))).Fit_interval.Ftv_sec) - (*Titimerspec32)(unsafe.Pointer(old32)).Fit_interval.Ftv_nsec = (*(*Titimerspec)(unsafe.Pointer(bp + 32))).Fit_interval.Ftv_nsec - (*Titimerspec32)(unsafe.Pointer(old32)).Fit_value.Ftv_sec = int32((*(*Titimerspec)(unsafe.Pointer(bp + 32))).Fit_value.Ftv_sec) - (*Titimerspec32)(unsafe.Pointer(old32)).Fit_value.Ftv_nsec = (*(*Titimerspec)(unsafe.Pointer(bp + 32))).Fit_value.Ftv_nsec + (*Titimerspec32)(unsafe.Pointer(old32)).Fit_interval.Ftv_sec = int32((**(**Titimerspec)(__ccgo_up(bp + 32))).Fit_interval.Ftv_sec) + (*Titimerspec32)(unsafe.Pointer(old32)).Fit_interval.Ftv_nsec = (**(**Titimerspec)(__ccgo_up(bp + 32))).Fit_interval.Ftv_nsec + (*Titimerspec32)(unsafe.Pointer(old32)).Fit_value.Ftv_sec = int32((**(**Titimerspec)(__ccgo_up(bp + 32))).Fit_value.Ftv_sec) + (*Titimerspec32)(unsafe.Pointer(old32)).Fit_value.Ftv_nsec = (**(**Titimerspec)(__ccgo_up(bp + 32))).Fit_value.Ftv_nsec } return 0 } @@ -153564,10 +153564,10 @@ func X__timerfd_gettime32(tls *TLS, t int32, val32 uintptr) (r1 int32) { return r } /* No range checking for consistency with settime */ - (*Titimerspec32)(unsafe.Pointer(val32)).Fit_interval.Ftv_sec = int32((*(*Titimerspec)(unsafe.Pointer(bp))).Fit_interval.Ftv_sec) - (*Titimerspec32)(unsafe.Pointer(val32)).Fit_interval.Ftv_nsec = (*(*Titimerspec)(unsafe.Pointer(bp))).Fit_interval.Ftv_nsec - (*Titimerspec32)(unsafe.Pointer(val32)).Fit_value.Ftv_sec = int32((*(*Titimerspec)(unsafe.Pointer(bp))).Fit_value.Ftv_sec) - (*Titimerspec32)(unsafe.Pointer(val32)).Fit_value.Ftv_nsec = (*(*Titimerspec)(unsafe.Pointer(bp))).Fit_value.Ftv_nsec + (*Titimerspec32)(unsafe.Pointer(val32)).Fit_interval.Ftv_sec = int32((**(**Titimerspec)(__ccgo_up(bp))).Fit_interval.Ftv_sec) + (*Titimerspec32)(unsafe.Pointer(val32)).Fit_interval.Ftv_nsec = (**(**Titimerspec)(__ccgo_up(bp))).Fit_interval.Ftv_nsec + (*Titimerspec32)(unsafe.Pointer(val32)).Fit_value.Ftv_sec = int32((**(**Titimerspec)(__ccgo_up(bp))).Fit_value.Ftv_sec) + (*Titimerspec32)(unsafe.Pointer(val32)).Fit_value.Ftv_nsec = (**(**Titimerspec)(__ccgo_up(bp))).Fit_value.Ftv_nsec return 0 } @@ -153606,10 +153606,10 @@ func X__timerfd_settime32(tls *TLS, t int32, flags int32, val32 uintptr, old32 u * Since these are relative times, values large enough to overflow * don't make sense anyway. */ if old32 != 0 { - (*Titimerspec32)(unsafe.Pointer(old32)).Fit_interval.Ftv_sec = int32((*(*Titimerspec)(unsafe.Pointer(bp + 32))).Fit_interval.Ftv_sec) - (*Titimerspec32)(unsafe.Pointer(old32)).Fit_interval.Ftv_nsec = (*(*Titimerspec)(unsafe.Pointer(bp + 32))).Fit_interval.Ftv_nsec - (*Titimerspec32)(unsafe.Pointer(old32)).Fit_value.Ftv_sec = int32((*(*Titimerspec)(unsafe.Pointer(bp + 32))).Fit_value.Ftv_sec) - (*Titimerspec32)(unsafe.Pointer(old32)).Fit_value.Ftv_nsec = (*(*Titimerspec)(unsafe.Pointer(bp + 32))).Fit_value.Ftv_nsec + (*Titimerspec32)(unsafe.Pointer(old32)).Fit_interval.Ftv_sec = int32((**(**Titimerspec)(__ccgo_up(bp + 32))).Fit_interval.Ftv_sec) + (*Titimerspec32)(unsafe.Pointer(old32)).Fit_interval.Ftv_nsec = (**(**Titimerspec)(__ccgo_up(bp + 32))).Fit_interval.Ftv_nsec + (*Titimerspec32)(unsafe.Pointer(old32)).Fit_value.Ftv_sec = int32((**(**Titimerspec)(__ccgo_up(bp + 32))).Fit_value.Ftv_sec) + (*Titimerspec32)(unsafe.Pointer(old32)).Fit_value.Ftv_nsec = (**(**Titimerspec)(__ccgo_up(bp + 32))).Fit_value.Ftv_nsec } return 0 } @@ -153628,12 +153628,12 @@ func X__timespec_get_time32(tls *TLS, ts32 uintptr, base int32) (r1 int32) { if !(r != 0) { return r } - if (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec < int64(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff)) || (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec > int64(Int32FromInt32(INT32_MAX)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + if (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec < int64(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff)) || (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec > int64(Int32FromInt32(INT32_MAX)) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return 0 } - (*Ttimespec32)(unsafe.Pointer(ts32)).Ftv_sec = int32((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec) - (*Ttimespec32)(unsafe.Pointer(ts32)).Ftv_nsec = (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_nsec + (*Ttimespec32)(unsafe.Pointer(ts32)).Ftv_sec = int32((**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec) + (*Ttimespec32)(unsafe.Pointer(ts32)).Ftv_nsec = (**(**Ttimespec)(__ccgo_up(bp))).Ftv_nsec return r } @@ -153677,12 +153677,12 @@ func X__utimensat_time32(tls *TLS, fd int32, path uintptr, times32 uintptr, flag } else { *(*[2]Ttimespec)(unsafe.Pointer(bp)) = [2]Ttimespec{ 0: { - Ftv_sec: int64((*(*Ttimespec32)(unsafe.Pointer(times32))).Ftv_sec), - Ftv_nsec: (*(*Ttimespec32)(unsafe.Pointer(times32))).Ftv_nsec, + Ftv_sec: int64((**(**Ttimespec32)(__ccgo_up(times32))).Ftv_sec), + Ftv_nsec: (**(**Ttimespec32)(__ccgo_up(times32))).Ftv_nsec, }, 1: { - Ftv_sec: int64((*(*Ttimespec32)(unsafe.Pointer(times32 + 1*8))).Ftv_sec), - Ftv_nsec: (*(*Ttimespec32)(unsafe.Pointer(times32 + 1*8))).Ftv_nsec, + Ftv_sec: int64((**(**Ttimespec32)(__ccgo_up(times32 + 1*8))).Ftv_sec), + Ftv_nsec: (**(**Ttimespec32)(__ccgo_up(times32 + 1*8))).Ftv_nsec, }, } v1 = bp @@ -153704,12 +153704,12 @@ func X__utimes_time32(tls *TLS, path uintptr, times32 uintptr) (r int32) { } else { *(*[2]Ttimeval)(unsafe.Pointer(bp)) = [2]Ttimeval{ 0: { - Ftv_sec: int64((*(*Ttimeval32)(unsafe.Pointer(times32))).Ftv_sec), - Ftv_usec: int64((*(*Ttimeval32)(unsafe.Pointer(times32))).Ftv_usec), + Ftv_sec: int64((**(**Ttimeval32)(__ccgo_up(times32))).Ftv_sec), + Ftv_usec: int64((**(**Ttimeval32)(__ccgo_up(times32))).Ftv_usec), }, 1: { - Ftv_sec: int64((*(*Ttimeval32)(unsafe.Pointer(times32 + 1*8))).Ftv_sec), - Ftv_usec: int64((*(*Ttimeval32)(unsafe.Pointer(times32 + 1*8))).Ftv_usec), + Ftv_sec: int64((**(**Ttimeval32)(__ccgo_up(times32 + 1*8))).Ftv_sec), + Ftv_usec: int64((**(**Ttimeval32)(__ccgo_up(times32 + 1*8))).Ftv_usec), }, } v1 = bp @@ -153735,10 +153735,10 @@ func X__wait3_time32(tls *TLS, status uintptr, options int32, usage uintptr) (r1 } r = Xwait3(tls, status, options, v1) if !(r != 0) && usage != 0 { - (*Tcompat_rusage)(unsafe.Pointer(usage)).Fru_utime.Ftv_sec = int32((*(*Trusage)(unsafe.Pointer(bp))).Fru_utime.Ftv_sec) - (*Tcompat_rusage)(unsafe.Pointer(usage)).Fru_utime.Ftv_usec = int32((*(*Trusage)(unsafe.Pointer(bp))).Fru_utime.Ftv_usec) - (*Tcompat_rusage)(unsafe.Pointer(usage)).Fru_stime.Ftv_sec = int32((*(*Trusage)(unsafe.Pointer(bp))).Fru_stime.Ftv_sec) - (*Tcompat_rusage)(unsafe.Pointer(usage)).Fru_stime.Ftv_usec = int32((*(*Trusage)(unsafe.Pointer(bp))).Fru_stime.Ftv_usec) + (*Tcompat_rusage)(unsafe.Pointer(usage)).Fru_utime.Ftv_sec = int32((**(**Trusage)(__ccgo_up(bp))).Fru_utime.Ftv_sec) + (*Tcompat_rusage)(unsafe.Pointer(usage)).Fru_utime.Ftv_usec = int32((**(**Trusage)(__ccgo_up(bp))).Fru_utime.Ftv_usec) + (*Tcompat_rusage)(unsafe.Pointer(usage)).Fru_stime.Ftv_sec = int32((**(**Trusage)(__ccgo_up(bp))).Fru_stime.Ftv_sec) + (*Tcompat_rusage)(unsafe.Pointer(usage)).Fru_stime.Ftv_usec = int32((**(**Trusage)(__ccgo_up(bp))).Fru_stime.Ftv_usec) Xmemcpy(tls, usage+16, bp+32, Uint32FromInt64(72)-uint32(UintptrFromInt32(0)+16)) } return r @@ -153762,10 +153762,10 @@ func X__wait4_time32(tls *TLS, pid Tpid_t, status uintptr, options int32, usage } r = Xwait4(tls, pid, status, options, v1) if !(r != 0) && usage != 0 { - (*Tcompat_rusage)(unsafe.Pointer(usage)).Fru_utime.Ftv_sec = int32((*(*Trusage)(unsafe.Pointer(bp))).Fru_utime.Ftv_sec) - (*Tcompat_rusage)(unsafe.Pointer(usage)).Fru_utime.Ftv_usec = int32((*(*Trusage)(unsafe.Pointer(bp))).Fru_utime.Ftv_usec) - (*Tcompat_rusage)(unsafe.Pointer(usage)).Fru_stime.Ftv_sec = int32((*(*Trusage)(unsafe.Pointer(bp))).Fru_stime.Ftv_sec) - (*Tcompat_rusage)(unsafe.Pointer(usage)).Fru_stime.Ftv_usec = int32((*(*Trusage)(unsafe.Pointer(bp))).Fru_stime.Ftv_usec) + (*Tcompat_rusage)(unsafe.Pointer(usage)).Fru_utime.Ftv_sec = int32((**(**Trusage)(__ccgo_up(bp))).Fru_utime.Ftv_sec) + (*Tcompat_rusage)(unsafe.Pointer(usage)).Fru_utime.Ftv_usec = int32((**(**Trusage)(__ccgo_up(bp))).Fru_utime.Ftv_usec) + (*Tcompat_rusage)(unsafe.Pointer(usage)).Fru_stime.Ftv_sec = int32((**(**Trusage)(__ccgo_up(bp))).Fru_stime.Ftv_sec) + (*Tcompat_rusage)(unsafe.Pointer(usage)).Fru_stime.Ftv_usec = int32((**(**Trusage)(__ccgo_up(bp))).Fru_stime.Ftv_usec) Xmemcpy(tls, usage+16, bp+32, Uint32FromInt64(72)-uint32(UintptrFromInt32(0)+16)) } return r @@ -153776,6 +153776,10 @@ func __ccgo_fp(f interface{}) uintptr { return (*iface)(unsafe.Pointer(&f))[1] } +func __ccgo_up(n uintptr) unsafe.Pointer { + return unsafe.Pointer(&n) +} + var X__abort_lock [1]int32 var X__at_quick_exit_lockptr = uintptr(unsafe.Pointer(&_lock)) diff --git a/vendor/modernc.org/libc/ccgo_linux_amd64.go b/vendor/modernc.org/libc/ccgo_linux_amd64.go index 518666a4d9..3c063fa803 100644 --- a/vendor/modernc.org/libc/ccgo_linux_amd64.go +++ b/vendor/modernc.org/libc/ccgo_linux_amd64.go @@ -574,7 +574,7 @@ func ___frexp_exp(tls *TLS, x float64, expt uintptr) (r float64) { */ exp_x = Xexp(tls, x-_kln2) hx = uint32(*(*Tuint64_t)(unsafe.Pointer(&exp_x)) >> int32(32)) - *(*int32)(unsafe.Pointer(expt)) = Int32FromUint32(hx>>Int32FromInt32(20) - Uint32FromInt32(Int32FromInt32(0x3ff)+Int32FromInt32(1023)) + _k) + **(**int32)(__ccgo_up(expt)) = Int32FromUint32(hx>>Int32FromInt32(20) - Uint32FromInt32(Int32FromInt32(0x3ff)+Int32FromInt32(1023)) + _k) v1 = uint64(hx&Uint32FromInt32(0xfffff)|Uint32FromInt32((Int32FromInt32(0x3ff)+Int32FromInt32(1023))<>Int32FromInt32(23) - Uint32FromInt32(Int32FromInt32(0x7f)+Int32FromInt32(127)) + _k1) + **(**int32)(__ccgo_up(expt)) = Int32FromUint32(hx>>Int32FromInt32(23) - Uint32FromInt32(Int32FromInt32(0x7f)+Int32FromInt32(127)) + _k1) v1 = hx&uint32(0x7fffff) | Uint32FromInt32((Int32FromInt32(0x7f)+Int32FromInt32(127))< uint32(35) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uint64(0) } } @@ -3307,7 +3307,7 @@ func Xfpathconf(tls *TLS, fd int32, name int32) (r int64) { defer func() { trc("-> %v", r) }() } if Uint64FromInt32(name) >= Uint64FromInt64(42)/Uint64FromInt64(2) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) } return int64(_values[name]) @@ -7456,7 +7456,7 @@ func Xsysconf(tls *TLS, name int32) (r int64) { var _ /* si at bp+144 */ Tsysinfo _, _, _, _, _, _, _ = cnt, i, mem, val, v1, v3, v5 if Uint64FromInt32(name) >= Uint64FromInt64(502)/Uint64FromInt64(2) || !(_values1[name] != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) } else { if int32(_values1[name]) >= -int32(1) { @@ -7464,13 +7464,13 @@ func Xsysconf(tls *TLS, name int32) (r int64) { } else { if int32(_values1[name]) < -int32(256) { Xgetrlimit(tls, int32(_values1[name])&int32(16383), bp) - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur == ^Uint64FromUint64(0) { + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur == ^Uint64FromUint64(0) { return int64(-int32(1)) } - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur > uint64(0x7fffffffffffffff) { + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur > uint64(0x7fffffffffffffff) { v1 = uint64(0x7fffffffffffffff) } else { - v1 = (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur + v1 = (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur } return Int64FromUint64(v1) } @@ -7492,7 +7492,7 @@ func Xsysconf(tls *TLS, name int32) (r int64) { case (-Int32FromInt32(256) | Int32FromInt32(6)) & Int32FromInt32(255): fallthrough case (-Int32FromInt32(256) | Int32FromInt32(7)) & Int32FromInt32(255): - *(*[128]uint8)(unsafe.Pointer(bp + 16)) = [128]uint8{ + **(**[128]uint8)(__ccgo_up(bp + 16)) = [128]uint8{ 0: uint8(1), } X__syscall3(tls, int64(SYS_sched_getaffinity), int64(Int32FromInt32(0)), Int64FromUint64(Uint64FromInt64(128)), int64(bp+16)) @@ -7504,14 +7504,14 @@ func Xsysconf(tls *TLS, name int32) (r int64) { break } for { - if !((*(*[128]uint8)(unsafe.Pointer(bp + 16)))[i] != 0) { + if !((**(**[128]uint8)(__ccgo_up(bp + 16)))[i] != 0) { break } goto _4 _4: ; v5 = bp + 16 + uintptr(i) - *(*uint8)(unsafe.Pointer(v5)) = uint8(int32(*(*uint8)(unsafe.Pointer(v5))) & (Int32FromUint8((*(*[128]uint8)(unsafe.Pointer(bp + 16)))[i]) - Int32FromInt32(1))) + *(*uint8)(unsafe.Pointer(v5)) = uint8(int32(*(*uint8)(unsafe.Pointer(v5))) & (Int32FromUint8((**(**[128]uint8)(__ccgo_up(bp + 16)))[i]) - Int32FromInt32(1))) cnt = cnt + 1 } goto _2 @@ -7524,15 +7524,15 @@ func Xsysconf(tls *TLS, name int32) (r int64) { fallthrough case (-Int32FromInt32(256) | Int32FromInt32(9)) & Int32FromInt32(255): X__lsysinfo(tls, bp+144) - if !((*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fmem_unit != 0) { - (*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fmem_unit = uint32(1) + if !((**(**Tsysinfo)(__ccgo_up(bp + 144))).Fmem_unit != 0) { + (**(**Tsysinfo)(__ccgo_up(bp + 144))).Fmem_unit = uint32(1) } if name == int32(_SC_PHYS_PAGES) { - mem = (*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Ftotalram + mem = uint64((**(**Tsysinfo)(__ccgo_up(bp + 144))).Ftotalram) } else { - mem = (*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Ffreeram + (*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fbufferram + mem = uint64((**(**Tsysinfo)(__ccgo_up(bp + 144))).Ffreeram + (**(**Tsysinfo)(__ccgo_up(bp + 144))).Fbufferram) } - mem = mem * uint64((*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fmem_unit) + mem = mem * uint64((**(**Tsysinfo)(__ccgo_up(bp + 144))).Fmem_unit) mem = mem / uint64(PAGESIZE) if mem > uint64(0x7fffffffffffffff) { v1 = uint64(0x7fffffffffffffff) @@ -8932,7 +8932,7 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { for cond := true; cond; cond = dptr < end { v1 = sptr sptr = sptr + 1 - tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = uint32(**(**uint8)(__ccgo_up(v1))) tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) @@ -8944,7 +8944,7 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { c1 = tmp v1 = sptr sptr = sptr + 1 - tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = uint32(**(**uint8)(__ccgo_up(v1))) tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) @@ -8956,13 +8956,13 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { c2 = tmp v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(c1<>int32(4)) + **(**uint8)(__ccgo_up(v1)) = uint8(c1<>int32(4)) if dptr >= end { break } v1 = sptr sptr = sptr + 1 - tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = uint32(**(**uint8)(__ccgo_up(v1))) tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) @@ -8974,13 +8974,13 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { c3 = tmp v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(c2&uint32(0x0F)<>int32(2)) + **(**uint8)(__ccgo_up(v1)) = uint8(c2&uint32(0x0F)<>int32(2)) if dptr >= end { break } v1 = sptr sptr = sptr + 1 - tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = uint32(**(**uint8)(__ccgo_up(v1))) tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) @@ -8992,7 +8992,7 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { c4 = tmp v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(c3&uint32(0x03)<>int32(2)] + **(**uint8)(__ccgo_up(v1)) = _BF_itoa64[c1>>int32(2)] c1 = c1 & uint32(0x03) << int32(4) if sptr >= end { v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] + **(**uint8)(__ccgo_up(v1)) = _BF_itoa64[c1] break } v1 = sptr sptr = sptr + 1 - c2 = uint32(*(*uint8)(unsafe.Pointer(v1))) + c2 = uint32(**(**uint8)(__ccgo_up(v1))) c1 = c1 | c2>>int32(4) v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] + **(**uint8)(__ccgo_up(v1)) = _BF_itoa64[c1] c1 = c2 & uint32(0x0f) << int32(2) if sptr >= end { v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] + **(**uint8)(__ccgo_up(v1)) = _BF_itoa64[c1] break } v1 = sptr sptr = sptr + 1 - c2 = uint32(*(*uint8)(unsafe.Pointer(v1))) + c2 = uint32(**(**uint8)(__ccgo_up(v1))) c1 = c1 | c2>>int32(6) v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] + **(**uint8)(__ccgo_up(v1)) = _BF_itoa64[c1] v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c2&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _BF_itoa64[c2&uint32(0x3f)] } } @@ -9053,11 +9053,11 @@ func _BF_swap(tls *TLS, x uintptr, count int32) { v1 = int32(1) if *(*int8)(unsafe.Pointer(&v1)) != 0 { for { - tmp = *(*TBF_word)(unsafe.Pointer(x)) + tmp = **(**TBF_word)(__ccgo_up(x)) tmp = tmp<>Int32FromInt32(16) v4 = x x += 4 - *(*TBF_word)(unsafe.Pointer(v4)) = tmp&uint32(0x00FF00FF)<>Int32FromInt32(8)&uint32(0x00FF00FF) + **(**TBF_word)(__ccgo_up(v4)) = tmp&uint32(0x00FF00FF)<>Int32FromInt32(8)&uint32(0x00FF00FF) goto _3 _3: ; @@ -9077,7 +9077,7 @@ func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, e _, _, _, _, _, _, _ = i, ptr, tmp1, tmp2, tmp3, tmp4, v2 ptr = start for cond := true; cond; cond = ptr < end { - L = L ^ *(*TBF_word)(unsafe.Pointer(ctx)) + L = L ^ **(**TBF_word)(__ccgo_up(ctx)) i = 0 for { if !(i < int32(16)) { @@ -9089,12 +9089,12 @@ func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, e tmp3 = L >> int32(16) tmp3 = tmp3 & uint32(0xFF) tmp4 = L >> int32(24) - tmp1 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 3*1024 + uintptr(tmp1)*4)) - tmp2 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 2*1024 + uintptr(tmp2)*4)) - tmp3 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 1*1024 + uintptr(tmp3)*4)) - tmp3 = tmp3 + *(*TBF_word)(unsafe.Pointer(ctx + 72 + uintptr(tmp4)*4)) + tmp1 = **(**TBF_word)(__ccgo_up(ctx + 72 + 3*1024 + uintptr(tmp1)*4)) + tmp2 = **(**TBF_word)(__ccgo_up(ctx + 72 + 2*1024 + uintptr(tmp2)*4)) + tmp3 = **(**TBF_word)(__ccgo_up(ctx + 72 + 1*1024 + uintptr(tmp3)*4)) + tmp3 = tmp3 + **(**TBF_word)(__ccgo_up(ctx + 72 + uintptr(tmp4)*4)) tmp3 = tmp3 ^ tmp2 - R = R ^ *(*TBF_word)(unsafe.Pointer(ctx + uintptr(i+int32(1))*4)) + R = R ^ **(**TBF_word)(__ccgo_up(ctx + uintptr(i+int32(1))*4)) tmp3 = tmp3 + tmp1 R = R ^ tmp3 tmp1 = R & uint32(0xFF) @@ -9103,12 +9103,12 @@ func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, e tmp3 = R >> int32(16) tmp3 = tmp3 & uint32(0xFF) tmp4 = R >> int32(24) - tmp1 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 3*1024 + uintptr(tmp1)*4)) - tmp2 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 2*1024 + uintptr(tmp2)*4)) - tmp3 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 1*1024 + uintptr(tmp3)*4)) - tmp3 = tmp3 + *(*TBF_word)(unsafe.Pointer(ctx + 72 + uintptr(tmp4)*4)) + tmp1 = **(**TBF_word)(__ccgo_up(ctx + 72 + 3*1024 + uintptr(tmp1)*4)) + tmp2 = **(**TBF_word)(__ccgo_up(ctx + 72 + 2*1024 + uintptr(tmp2)*4)) + tmp3 = **(**TBF_word)(__ccgo_up(ctx + 72 + 1*1024 + uintptr(tmp3)*4)) + tmp3 = tmp3 + **(**TBF_word)(__ccgo_up(ctx + 72 + uintptr(tmp4)*4)) tmp3 = tmp3 ^ tmp2 - L = L ^ *(*TBF_word)(unsafe.Pointer(ctx + uintptr(i+int32(1)+int32(1))*4)) + L = L ^ **(**TBF_word)(__ccgo_up(ctx + uintptr(i+int32(1)+int32(1))*4)) tmp3 = tmp3 + tmp1 L = L ^ tmp3 goto _1 @@ -9118,13 +9118,13 @@ func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, e } tmp4 = R R = L - L = tmp4 ^ *(*TBF_word)(unsafe.Pointer(ctx + uintptr(Int32FromInt32(BF_N)+Int32FromInt32(1))*4)) + L = tmp4 ^ **(**TBF_word)(__ccgo_up(ctx + uintptr(Int32FromInt32(BF_N)+Int32FromInt32(1))*4)) v2 = ptr ptr += 4 - *(*TBF_word)(unsafe.Pointer(v2)) = L + **(**TBF_word)(__ccgo_up(v2)) = L v2 = ptr ptr += 4 - *(*TBF_word)(unsafe.Pointer(v2)) = R + **(**TBF_word)(__ccgo_up(v2)) = R } return L } @@ -9184,17 +9184,17 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags break } v1 = Uint32FromInt32(0) - (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)] = v1 - (*(*[2]TBF_word)(unsafe.Pointer(bp)))[0] = v1 + (**(**[2]TBF_word)(__ccgo_up(bp)))[int32(1)] = v1 + (**(**[2]TBF_word)(__ccgo_up(bp)))[0] = v1 j = uint32(0) for { if !(j < uint32(4)) { break } - *(*TBF_word)(unsafe.Pointer(bp)) <<= uint32(8) - *(*TBF_word)(unsafe.Pointer(bp)) |= uint32(Uint8FromInt8(*(*int8)(unsafe.Pointer(ptr)))) /* correct */ - *(*TBF_word)(unsafe.Pointer(bp + 1*4)) <<= uint32(8) - *(*TBF_word)(unsafe.Pointer(bp + 1*4)) |= Uint32FromInt8(*(*int8)(unsafe.Pointer(ptr))) /* bug */ + **(**TBF_word)(__ccgo_up(bp)) <<= uint32(8) + **(**TBF_word)(__ccgo_up(bp)) |= uint32(Uint8FromInt8(**(**int8)(__ccgo_up(ptr)))) /* correct */ + **(**TBF_word)(__ccgo_up(bp + 1*4)) <<= uint32(8) + **(**TBF_word)(__ccgo_up(bp + 1*4)) |= Uint32FromInt8(int8(**(**int8)(__ccgo_up(ptr)))) /* bug */ /* * Sign extension in the first char has no effect - nothing to overwrite yet, * and those extra 24 bits will be fully shifted out of the 32-bit word. For @@ -9202,9 +9202,9 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags * extension in tmp[1] occurs. Once this flag is set, it remains set. */ if j != 0 { - sign = sign | (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)]&uint32(0x80) + sign = sign | (**(**[2]TBF_word)(__ccgo_up(bp)))[int32(1)]&uint32(0x80) } - if !(*(*int8)(unsafe.Pointer(ptr)) != 0) { + if !(**(**int8)(__ccgo_up(ptr)) != 0) { ptr = key } else { ptr = ptr + 1 @@ -9214,9 +9214,9 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags ; j = j + 1 } - diff = diff | ((*(*[2]TBF_word)(unsafe.Pointer(bp)))[0] ^ (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)]) /* Non-zero on any differences */ - *(*TBF_word)(unsafe.Pointer(expanded + uintptr(i)*4)) = (*(*[2]TBF_word)(unsafe.Pointer(bp)))[bug] - *(*TBF_word)(unsafe.Pointer(initial + uintptr(i)*4)) = *(*TBF_word)(unsafe.Pointer(uintptr(unsafe.Pointer(&_BF_init_state)) + uintptr(i)*4)) ^ (*(*[2]TBF_word)(unsafe.Pointer(bp)))[bug] + diff = diff | ((**(**[2]TBF_word)(__ccgo_up(bp)))[0] ^ (**(**[2]TBF_word)(__ccgo_up(bp)))[int32(1)]) /* Non-zero on any differences */ + **(**TBF_word)(__ccgo_up(expanded + uintptr(i)*4)) = (**(**[2]TBF_word)(__ccgo_up(bp)))[bug] + **(**TBF_word)(__ccgo_up(initial + uintptr(i)*4)) = **(**TBF_word)(__ccgo_up(uintptr(unsafe.Pointer(&_BF_init_state)) + uintptr(i)*4)) ^ (**(**[2]TBF_word)(__ccgo_up(bp)))[bug] goto _2 _2: ; @@ -9247,7 +9247,7 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags * state that could be directly specified by a password to the buggy algorithm * (and to the fully correct one as well, but that's a side-effect). */ - *(*TBF_word)(unsafe.Pointer(initial)) ^= sign + **(**TBF_word)(__ccgo_up(initial)) ^= sign } var _flags_by_subtype = [26]uint8{ @@ -9274,28 +9274,28 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w } } _, _, _, _, _, _, _, _, _, _, _, _ = L, L1, R, count, done, i, ptr, tmp1, tmp2, tmp3, tmp4, v1 - if int32(*(*int8)(unsafe.Pointer(setting))) != int32('$') || int32(*(*int8)(unsafe.Pointer(setting + 1))) != int32('2') || Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(setting + 2)))-int32('a')) > uint32(25) || !(_flags_by_subtype[int32(*(*int8)(unsafe.Pointer(setting + 2)))-int32('a')] != 0) || int32(*(*int8)(unsafe.Pointer(setting + 3))) != int32('$') || Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(setting + 4)))-int32('0')) > uint32(1) || Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(setting + 5)))-int32('0')) > uint32(9) || int32(*(*int8)(unsafe.Pointer(setting + 6))) != int32('$') { + if int32(**(**int8)(__ccgo_up(setting))) != int32('$') || int32(**(**int8)(__ccgo_up(setting + 1))) != int32('2') || Uint32FromInt32(int32(**(**int8)(__ccgo_up(setting + 2)))-int32('a')) > uint32(25) || !(_flags_by_subtype[int32(**(**int8)(__ccgo_up(setting + 2)))-int32('a')] != 0) || int32(**(**int8)(__ccgo_up(setting + 3))) != int32('$') || Uint32FromInt32(int32(**(**int8)(__ccgo_up(setting + 4)))-int32('0')) > uint32(1) || Uint32FromInt32(int32(**(**int8)(__ccgo_up(setting + 5)))-int32('0')) > uint32(9) || int32(**(**int8)(__ccgo_up(setting + 6))) != int32('$') { return UintptrFromInt32(0) } - count = Uint32FromInt32(1) << ((int32(*(*int8)(unsafe.Pointer(setting + 4)))-int32('0'))*int32(10) + (int32(*(*int8)(unsafe.Pointer(setting + 5))) - int32('0'))) + count = Uint32FromInt32(1) << ((int32(**(**int8)(__ccgo_up(setting + 4)))-int32('0'))*int32(10) + (int32(**(**int8)(__ccgo_up(setting + 5))) - int32('0'))) if count < min || _BF_decode(tls, bp+4240, setting+7, int32(16)) != 0 { return UintptrFromInt32(0) } _BF_swap(tls, bp+4240, int32(4)) - _BF_set_key(tls, key, bp+4168, bp, _flags_by_subtype[int32(*(*int8)(unsafe.Pointer(setting + 2)))-int32('a')]) + _BF_set_key(tls, key, bp+4168, bp, _flags_by_subtype[int32(**(**int8)(__ccgo_up(setting + 2)))-int32('a')]) Xmemcpy(tls, bp+72, uintptr(unsafe.Pointer(&_BF_init_state))+72, uint64(4096)) L = uint32(0) R = uint32(0) ptr = bp for cond := true; cond; cond = int32(1) != 0 { - L = _BF_encrypt(tls, bp, L^*(*TBF_word)(unsafe.Pointer(bp + 4240)), R^*(*TBF_word)(unsafe.Pointer(bp + 4240 + 1*4)), ptr, ptr) - R = *(*TBF_word)(unsafe.Pointer(ptr + UintptrFromInt32(1)*4)) + L = _BF_encrypt(tls, bp, L^**(**TBF_word)(__ccgo_up(bp + 4240)), R^**(**TBF_word)(__ccgo_up(bp + 4240 + 1*4)), ptr, ptr) + R = **(**TBF_word)(__ccgo_up(ptr + UintptrFromInt32(1)*4)) ptr = ptr + uintptr(2)*4 if ptr >= bp+uintptr(Int32FromInt32(BF_N)+Int32FromInt32(2)+Int32FromInt32(4)*Int32FromInt32(0x100))*4 { break } - L = _BF_encrypt(tls, bp, L^*(*TBF_word)(unsafe.Pointer(bp + 4240 + 2*4)), R^*(*TBF_word)(unsafe.Pointer(bp + 4240 + 3*4)), ptr, ptr) - R = *(*TBF_word)(unsafe.Pointer(ptr + UintptrFromInt32(1)*4)) + L = _BF_encrypt(tls, bp, L^**(**TBF_word)(__ccgo_up(bp + 4240 + 2*4)), R^**(**TBF_word)(__ccgo_up(bp + 4240 + 3*4)), ptr, ptr) + R = **(**TBF_word)(__ccgo_up(ptr + UintptrFromInt32(1)*4)) ptr = ptr + uintptr(2)*4 } for { @@ -9304,8 +9304,8 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w if !(i < Int32FromInt32(BF_N)+Int32FromInt32(2)) { break } - *(*TBF_word)(unsafe.Pointer(bp + uintptr(i)*4)) ^= *(*TBF_word)(unsafe.Pointer(bp + 4168 + uintptr(i)*4)) - *(*TBF_word)(unsafe.Pointer(bp + uintptr(i+int32(1))*4)) ^= *(*TBF_word)(unsafe.Pointer(bp + 4168 + uintptr(i+int32(1))*4)) + **(**TBF_word)(__ccgo_up(bp + uintptr(i)*4)) ^= **(**TBF_word)(__ccgo_up(bp + 4168 + uintptr(i)*4)) + **(**TBF_word)(__ccgo_up(bp + uintptr(i+int32(1))*4)) ^= **(**TBF_word)(__ccgo_up(bp + 4168 + uintptr(i+int32(1))*4)) goto _3 _3: ; @@ -9318,26 +9318,26 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w break } done = int32(1) - tmp1 = *(*TBF_word)(unsafe.Pointer(bp + 4240)) - tmp2 = *(*TBF_word)(unsafe.Pointer(bp + 4240 + 1*4)) - tmp3 = *(*TBF_word)(unsafe.Pointer(bp + 4240 + 2*4)) - tmp4 = *(*TBF_word)(unsafe.Pointer(bp + 4240 + 3*4)) + tmp1 = **(**TBF_word)(__ccgo_up(bp + 4240)) + tmp2 = **(**TBF_word)(__ccgo_up(bp + 4240 + 1*4)) + tmp3 = **(**TBF_word)(__ccgo_up(bp + 4240 + 2*4)) + tmp4 = **(**TBF_word)(__ccgo_up(bp + 4240 + 3*4)) i = 0 for { if !(i < int32(BF_N)) { break } - *(*TBF_word)(unsafe.Pointer(bp + uintptr(i)*4)) ^= tmp1 - *(*TBF_word)(unsafe.Pointer(bp + uintptr(i+int32(1))*4)) ^= tmp2 - *(*TBF_word)(unsafe.Pointer(bp + uintptr(i+int32(2))*4)) ^= tmp3 - *(*TBF_word)(unsafe.Pointer(bp + uintptr(i+int32(3))*4)) ^= tmp4 + **(**TBF_word)(__ccgo_up(bp + uintptr(i)*4)) ^= tmp1 + **(**TBF_word)(__ccgo_up(bp + uintptr(i+int32(1))*4)) ^= tmp2 + **(**TBF_word)(__ccgo_up(bp + uintptr(i+int32(2))*4)) ^= tmp3 + **(**TBF_word)(__ccgo_up(bp + uintptr(i+int32(3))*4)) ^= tmp4 goto _4 _4: ; i = i + int32(4) } - *(*TBF_word)(unsafe.Pointer(bp + 16*4)) ^= tmp1 - *(*TBF_word)(unsafe.Pointer(bp + 17*4)) ^= tmp2 + **(**TBF_word)(__ccgo_up(bp + 16*4)) ^= tmp1 + **(**TBF_word)(__ccgo_up(bp + 17*4)) ^= tmp2 } goto _2 _2: @@ -9354,10 +9354,10 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w break } L1 = _BF_magic_w[i] - (*(*[2]TBF_word)(unsafe.Pointer(bp + 4264)))[int32(1)] = _BF_magic_w[i+int32(1)] + (**(**[2]TBF_word)(__ccgo_up(bp + 4264)))[int32(1)] = _BF_magic_w[i+int32(1)] count = uint32(64) for { - L1 = _BF_encrypt(tls, bp, L1, (*(*[2]TBF_word)(unsafe.Pointer(bp + 4264)))[int32(1)], bp+4264, bp+4264) + L1 = _BF_encrypt(tls, bp, L1, (**(**[2]TBF_word)(__ccgo_up(bp + 4264)))[int32(1)], bp+4264, bp+4264) goto _7 _7: ; @@ -9367,20 +9367,20 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w break } } - *(*TBF_word)(unsafe.Pointer(bp + 4240 + uintptr(i)*4)) = L1 - *(*TBF_word)(unsafe.Pointer(bp + 4240 + uintptr(i+int32(1))*4)) = (*(*[2]TBF_word)(unsafe.Pointer(bp + 4264)))[int32(1)] + **(**TBF_word)(__ccgo_up(bp + 4240 + uintptr(i)*4)) = L1 + **(**TBF_word)(__ccgo_up(bp + 4240 + uintptr(i+int32(1))*4)) = (**(**[2]TBF_word)(__ccgo_up(bp + 4264)))[int32(1)] goto _5 _5: ; i = i + int32(2) } Xmemcpy(tls, output, setting, Uint64FromInt32(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1))) - *(*int8)(unsafe.Pointer(output + uintptr(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1)))) = Int8FromUint8(_BF_itoa64[Int32FromUint8(_BF_atoi64[int32(*(*int8)(unsafe.Pointer(setting + uintptr(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1)))))-int32(0x20)])&int32(0x30)]) + **(**int8)(__ccgo_up(output + uintptr(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1)))) = Int8FromUint8(_BF_itoa64[Int32FromUint8(_BF_atoi64[int32(**(**int8)(__ccgo_up(setting + uintptr(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1)))))-int32(0x20)])&int32(0x30)]) /* This has to be bug-compatible with the original implementation, so * only encode 23 of the 24 bytes. :-) */ _BF_swap(tls, bp+4240, int32(6)) _BF_encode(tls, output+uintptr(Int32FromInt32(7)+Int32FromInt32(22)), bp+4240, int32(23)) - *(*int8)(unsafe.Pointer(output + uintptr(Int32FromInt32(7)+Int32FromInt32(22)+Int32FromInt32(31)))) = int8('\000') + **(**int8)(__ccgo_up(output + uintptr(Int32FromInt32(7)+Int32FromInt32(22)+Int32FromInt32(31)))) = int8('\000') return output } @@ -9439,19 +9439,19 @@ func X__crypt_blowfish(tls *TLS, key uintptr, setting uintptr, output uintptr) ( */ Xmemcpy(tls, bp, test_setting, uint64(30)) if retval != 0 { - flags = uint32(_flags_by_subtype[int32(*(*int8)(unsafe.Pointer(setting + 2)))-int32('a')]) + flags = uint32(_flags_by_subtype[int32(**(**int8)(__ccgo_up(setting + 2)))-int32('a')]) test_hash = uintptr(unsafe.Pointer(&_test_hashes)) + uintptr(flags&uint32(1))*34 - *(*int8)(unsafe.Pointer(bp + 2)) = *(*int8)(unsafe.Pointer(setting + 2)) + **(**int8)(__ccgo_up(bp + 2)) = **(**int8)(__ccgo_up(setting + 2)) } Xmemset(tls, bp+30, int32(0x55), uint64(63)) - *(*int8)(unsafe.Pointer(bp + 30 + uintptr(Uint64FromInt64(63)-Uint64FromInt32(1)))) = 0 + **(**int8)(__ccgo_up(bp + 30 + uintptr(Uint64FromInt64(63)-Uint64FromInt32(1)))) = 0 p = _BF_crypt(tls, test_key, bp, bp+30, uint32(1)) ok = BoolInt32(p == bp+30 && !(Xmemcmp(tls, p, bp, Uint64FromInt32(Int32FromInt32(7)+Int32FromInt32(22))) != 0) && !(Xmemcmp(tls, p+uintptr(Int32FromInt32(7)+Int32FromInt32(22)), test_hash, Uint64FromInt32(Int32FromInt32(31)+Int32FromInt32(1)+Int32FromInt32(1)+Int32FromInt32(1))) != 0)) k = __ccgo_ts + 58 - _BF_set_key(tls, k, bp+96, bp+168, uint8(2)) /* $2a$ */ - _BF_set_key(tls, k, bp+240, bp+312, uint8(4)) /* $2y$ */ - *(*TBF_word)(unsafe.Pointer(bp + 168)) ^= uint32(0x10000) /* undo the safety (for comparison) */ - ok = BoolInt32(ok != 0 && (*(*TBF_key)(unsafe.Pointer(bp + 168)))[0] == uint32(0xdb9c59bc) && (*(*TBF_key)(unsafe.Pointer(bp + 240)))[int32(17)] == uint32(0x33343500) && !(Xmemcmp(tls, bp+96, bp+240, uint64(72)) != 0) && !(Xmemcmp(tls, bp+168, bp+312, uint64(72)) != 0)) + _BF_set_key(tls, k, bp+96, bp+168, uint8(2)) /* $2a$ */ + _BF_set_key(tls, k, bp+240, bp+312, uint8(4)) /* $2y$ */ + **(**TBF_word)(__ccgo_up(bp + 168)) ^= uint32(0x10000) /* undo the safety (for comparison) */ + ok = BoolInt32(ok != 0 && (**(**TBF_key)(__ccgo_up(bp + 168)))[0] == uint32(0xdb9c59bc) && (**(**TBF_key)(__ccgo_up(bp + 240)))[int32(17)] == uint32(0x33343500) && !(Xmemcmp(tls, bp+96, bp+240, uint64(72)) != 0) && !(Xmemcmp(tls, bp+168, bp+312, uint64(72)) != 0)) if ok != 0 && retval != 0 { return retval } @@ -11301,8 +11301,8 @@ func X__des_setkey(tls *TLS, key uintptr, ekey uintptr) { var i, ibit, j, round, shifts uint32 var k0, k1, kl, kr, rawkey0, rawkey1, t0, t1, v1 Tuint32_t _, _, _, _, _, _, _, _, _, _, _, _, _, _ = i, ibit, j, k0, k1, kl, kr, rawkey0, rawkey1, round, shifts, t0, t1, v1 - rawkey0 = uint32(*(*uint8)(unsafe.Pointer(key + 3))) | uint32(*(*uint8)(unsafe.Pointer(key + 2)))<>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskl)) + uintptr(i+uint32(4))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4))) - k1 = k1 | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j)*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) + k0 = k0 | (**(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_key_perm_maskl)) + uintptr(i)*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_key_perm_maskl)) + uintptr(i+uint32(4))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4))) + k1 = k1 | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j)*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) ibit = ibit - uint32(4) - k1 = k1 | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j+uint32(1))*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(i+uint32(8))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4))) + k1 = k1 | (**(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j+uint32(1))*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(i+uint32(8))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4))) goto _2 _2: ; @@ -11347,19 +11347,19 @@ func X__des_setkey(tls *TLS, key uintptr, ekey uintptr) { if !(i < uint32(4)) { break } - kl = kl | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskl0)) + uintptr(i)*32 + uintptr(t0>>ibit&uint32(7))*4)) - kr = kr | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskr0)) + uintptr(i)*32 + uintptr(t1>>ibit&uint32(7))*4)) + kl = kl | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_comp_maskl0)) + uintptr(i)*32 + uintptr(t0>>ibit&uint32(7))*4)) + kr = kr | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_comp_maskr0)) + uintptr(i)*32 + uintptr(t1>>ibit&uint32(7))*4)) ibit = ibit - uint32(4) - kl = kl | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskl1)) + uintptr(i)*64 + uintptr(t0>>ibit&uint32(0xf))*4)) - kr = kr | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskr1)) + uintptr(i)*64 + uintptr(t1>>ibit&uint32(0xf))*4)) + kl = kl | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_comp_maskl1)) + uintptr(i)*64 + uintptr(t0>>ibit&uint32(0xf))*4)) + kr = kr | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_comp_maskr1)) + uintptr(i)*64 + uintptr(t1>>ibit&uint32(0xf))*4)) ibit = ibit - uint32(3) goto _5 _5: ; i = i + 1 } - *(*Tuint32_t)(unsafe.Pointer(ekey + uintptr(round)*4)) = kl - *(*Tuint32_t)(unsafe.Pointer(ekey + 64 + uintptr(round)*4)) = kr + **(**Tuint32_t)(__ccgo_up(ekey + uintptr(round)*4)) = kl + **(**Tuint32_t)(__ccgo_up(ekey + 64 + uintptr(round)*4)) = kr goto _3 _3: ; @@ -11393,8 +11393,8 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui if !(i < uint32(8)) { break } - l = l | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4))) - r = r | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4))) + l = l | (**(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4))) + r = r | (**(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4))) goto _2 _2: ; @@ -11432,15 +11432,15 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui f = (r48l ^ r48r) & saltbits v5 = kl kl += 4 - r48l = r48l ^ (f ^ *(*Tuint32_t)(unsafe.Pointer(v5))) + r48l = r48l ^ (f ^ **(**Tuint32_t)(__ccgo_up(v5))) v5 = kr kr += 4 - r48r = r48r ^ (f ^ *(*Tuint32_t)(unsafe.Pointer(v5))) + r48r = r48r ^ (f ^ **(**Tuint32_t)(__ccgo_up(v5))) /* * Do S-box lookups (which shrink it back to 32 bits) * and do the P-box permutation at the same time. */ - f = *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + uintptr(r48l>>int32(18))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 1*256 + uintptr(r48l>>Int32FromInt32(12)&uint32(0x3f))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 2*256 + uintptr(r48l>>Int32FromInt32(6)&uint32(0x3f))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 3*256 + uintptr(r48l&uint32(0x3f))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 4*256 + uintptr(r48r>>int32(18))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 5*256 + uintptr(r48r>>Int32FromInt32(12)&uint32(0x3f))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 6*256 + uintptr(r48r>>Int32FromInt32(6)&uint32(0x3f))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 7*256 + uintptr(r48r&uint32(0x3f))*4)) + f = **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + uintptr(r48l>>int32(18))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 1*256 + uintptr(r48l>>Int32FromInt32(12)&uint32(0x3f))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 2*256 + uintptr(r48l>>Int32FromInt32(6)&uint32(0x3f))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 3*256 + uintptr(r48l&uint32(0x3f))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 4*256 + uintptr(r48r>>int32(18))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 5*256 + uintptr(r48r>>Int32FromInt32(12)&uint32(0x3f))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 6*256 + uintptr(r48r>>Int32FromInt32(6)&uint32(0x3f))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 7*256 + uintptr(r48r&uint32(0x3f))*4)) /* * Now that we've permuted things, complete f(). */ @@ -11463,17 +11463,17 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui if !(i1 < uint32(4)) { break } - ro = ro | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4))) + ro = ro | (**(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4))) ibit1 = ibit1 - uint32(4) - lo = lo | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4))) + lo = lo | (**(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4))) goto _8 _8: ; i1 = i1 + 1 ibit1 = ibit1 - uint32(4) } - *(*Tuint32_t)(unsafe.Pointer(l_out)) = lo - *(*Tuint32_t)(unsafe.Pointer(r_out)) = ro + **(**Tuint32_t)(__ccgo_up(l_out)) = lo + **(**Tuint32_t)(__ccgo_up(r_out)) = ro } func _des_cipher(tls *TLS, in uintptr, out uintptr, count Tuint32_t, saltbits Tuint32_t, ekey uintptr) { @@ -11483,17 +11483,17 @@ func _des_cipher(tls *TLS, in uintptr, out uintptr, count Tuint32_t, saltbits Tu var _ /* l_out at bp+0 */ Tuint32_t var _ /* r_out at bp+4 */ Tuint32_t _, _ = rawl, rawr - rawl = uint32(*(*uint8)(unsafe.Pointer(in + 3))) | uint32(*(*uint8)(unsafe.Pointer(in + 2)))<> int32(24)) - *(*uint8)(unsafe.Pointer(out + 1)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp)) >> int32(16)) - *(*uint8)(unsafe.Pointer(out + 2)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp)) >> int32(8)) - *(*uint8)(unsafe.Pointer(out + 3)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp))) - *(*uint8)(unsafe.Pointer(out + 4)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp + 4)) >> int32(24)) - *(*uint8)(unsafe.Pointer(out + 5)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp + 4)) >> int32(16)) - *(*uint8)(unsafe.Pointer(out + 6)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp + 4)) >> int32(8)) - *(*uint8)(unsafe.Pointer(out + 7)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp + 4))) + **(**uint8)(__ccgo_up(out)) = uint8(**(**Tuint32_t)(__ccgo_up(bp)) >> int32(24)) + **(**uint8)(__ccgo_up(out + 1)) = uint8(**(**Tuint32_t)(__ccgo_up(bp)) >> int32(16)) + **(**uint8)(__ccgo_up(out + 2)) = uint8(**(**Tuint32_t)(__ccgo_up(bp)) >> int32(8)) + **(**uint8)(__ccgo_up(out + 3)) = uint8(**(**Tuint32_t)(__ccgo_up(bp))) + **(**uint8)(__ccgo_up(out + 4)) = uint8(**(**Tuint32_t)(__ccgo_up(bp + 4)) >> int32(24)) + **(**uint8)(__ccgo_up(out + 5)) = uint8(**(**Tuint32_t)(__ccgo_up(bp + 4)) >> int32(16)) + **(**uint8)(__ccgo_up(out + 6)) = uint8(**(**Tuint32_t)(__ccgo_up(bp + 4)) >> int32(8)) + **(**uint8)(__ccgo_up(out + 7)) = uint8(**(**Tuint32_t)(__ccgo_up(bp + 4))) } func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uintptr) (r uintptr) { @@ -11517,13 +11517,13 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin for q <= bp+128+uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) { v1 = q q = q + 1 - *(*uint8)(unsafe.Pointer(v1)) = Uint8FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(key))) << int32(1)) - if *(*uint8)(unsafe.Pointer(key)) != 0 { + **(**uint8)(__ccgo_up(v1)) = Uint8FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(key))) << int32(1)) + if **(**uint8)(__ccgo_up(key)) != 0 { key = key + 1 } } X__des_setkey(tls, bp+128, bp) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(setting))) == int32('_') { + if Int32FromUint8(**(**uint8)(__ccgo_up(setting))) == int32('_') { /* * "new"-style: * setting - underscore, 4 chars of count, 4 chars of salt @@ -11535,8 +11535,8 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin if !(i < uint32(5)) { break } - value = _ascii_to_bin(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(i))))) - if Int32FromUint8(_ascii64[value]) != Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(i)))) { + value = _ascii_to_bin(tls, Int32FromUint8(**(**uint8)(__ccgo_up(setting + uintptr(i))))) + if Int32FromUint8(_ascii64[value]) != Int32FromUint8(**(**uint8)(__ccgo_up(setting + uintptr(i)))) { return UintptrFromInt32(0) } count = count | value<<((i-uint32(1))*uint32(6)) @@ -11554,8 +11554,8 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin if !(i < uint32(9)) { break } - value1 = _ascii_to_bin(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(i))))) - if Int32FromUint8(_ascii64[value1]) != Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(i)))) { + value1 = _ascii_to_bin(tls, Int32FromUint8(**(**uint8)(__ccgo_up(setting + uintptr(i))))) + if Int32FromUint8(_ascii64[value1]) != Int32FromUint8(**(**uint8)(__ccgo_up(setting + uintptr(i)))) { return UintptrFromInt32(0) } salt = salt | value1<<((i-uint32(5))*uint32(6)) @@ -11564,7 +11564,7 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin ; i = i + 1 } - for *(*uint8)(unsafe.Pointer(key)) != 0 { + for **(**uint8)(__ccgo_up(key)) != 0 { /* * Encrypt the key with itself. */ @@ -11573,18 +11573,18 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin * And XOR with the next 8 characters of the key. */ q = bp + 128 - for q <= bp+128+uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) && *(*uint8)(unsafe.Pointer(key)) != 0 { + for q <= bp+128+uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) && **(**uint8)(__ccgo_up(key)) != 0 { v4 = q q = q + 1 v1 = v4 v5 = key key = key + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(int32(*(*uint8)(unsafe.Pointer(v1))) ^ Int32FromUint8(*(*uint8)(unsafe.Pointer(v5)))<> int32(8) + l = **(**Tuint32_t)(__ccgo_up(bp + 136)) >> int32(8) v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l&uint32(0x3f)] - l = *(*Tuint32_t)(unsafe.Pointer(bp + 136))<>Int32FromInt32(16)&uint32(0xffff) + **(**uint8)(__ccgo_up(v1)) = _ascii64[l&uint32(0x3f)] + l = **(**Tuint32_t)(__ccgo_up(bp + 136))<>Int32FromInt32(16)&uint32(0xffff) v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l&uint32(0x3f)] - l = *(*Tuint32_t)(unsafe.Pointer(bp + 140)) << int32(2) + **(**uint8)(__ccgo_up(v1)) = _ascii64[l&uint32(0x3f)] + l = **(**Tuint32_t)(__ccgo_up(bp + 140)) << int32(2) v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l&uint32(0x3f)] - *(*uint8)(unsafe.Pointer(p)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = _ascii64[l&uint32(0x3f)] + **(**uint8)(__ccgo_up(p)) = uint8(0) return output } @@ -11661,7 +11661,7 @@ func X__crypt_des(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uin test_key = __ccgo_ts + 72 test_setting = __ccgo_ts + 93 test_hash = __ccgo_ts + 103 - if int32(*(*int8)(unsafe.Pointer(setting))) != int32('_') { + if int32(**(**int8)(__ccgo_up(setting))) != int32('_') { test_setting = __ccgo_ts + 124 test_hash = __ccgo_ts + 127 } @@ -11680,7 +11680,7 @@ func X__crypt_des(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uin if p != 0 && !(Xstrcmp(tls, p, test_hash) != 0) && retval != 0 { return retval } - if int32(*(*int8)(unsafe.Pointer(setting))) == int32('*') { + if int32(**(**int8)(__ccgo_up(setting))) == int32('*') { v1 = __ccgo_ts + 141 } else { v1 = __ccgo_ts + 70 @@ -11781,80 +11781,80 @@ func _processblock(tls *TLS, s uintptr, buf uintptr) { if !(i < uint32(16)) { break } - (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] = uint32(*(*Tuint8_t)(unsafe.Pointer(buf + uintptr(uint32(4)*i)))) - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(i)*4)) |= uint32(*(*Tuint8_t)(unsafe.Pointer(buf + uintptr(uint32(4)*i+uint32(1))))) << int32(8) - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(i)*4)) |= uint32(*(*Tuint8_t)(unsafe.Pointer(buf + uintptr(uint32(4)*i+uint32(2))))) << int32(16) - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(i)*4)) |= uint32(*(*Tuint8_t)(unsafe.Pointer(buf + uintptr(uint32(4)*i+uint32(3))))) << int32(24) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[i] = uint32(**(**Tuint8_t)(__ccgo_up(buf + uintptr(uint32(4)*i)))) + **(**Tuint32_t)(__ccgo_up(bp + uintptr(i)*4)) |= uint32(**(**Tuint8_t)(__ccgo_up(buf + uintptr(uint32(4)*i+uint32(1))))) << int32(8) + **(**Tuint32_t)(__ccgo_up(bp + uintptr(i)*4)) |= uint32(**(**Tuint8_t)(__ccgo_up(buf + uintptr(uint32(4)*i+uint32(2))))) << int32(16) + **(**Tuint32_t)(__ccgo_up(bp + uintptr(i)*4)) |= uint32(**(**Tuint8_t)(__ccgo_up(buf + uintptr(uint32(4)*i+uint32(3))))) << int32(24) goto _1 _1: ; i = i + 1 } - a = *(*Tuint32_t)(unsafe.Pointer(s + 8)) - b = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) - c = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 2*4)) - d = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) + a = **(**Tuint32_t)(__ccgo_up(s + 8)) + b = **(**Tuint32_t)(__ccgo_up(s + 8 + 1*4)) + c = **(**Tuint32_t)(__ccgo_up(s + 8 + 2*4)) + d = **(**Tuint32_t)(__ccgo_up(s + 8 + 3*4)) i = uint32(0) for i < uint32(16) { - a = a + (d ^ b&(c^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) + a = a + (d ^ b&(c^d) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[i] + _tab[i]) a = _rol(tls, a, int32(7)) + b i = i + 1 - d = d + (c ^ a&(b^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) + d = d + (c ^ a&(b^c) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[i] + _tab[i]) d = _rol(tls, d, int32(12)) + a i = i + 1 - c = c + (b ^ d&(a^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) + c = c + (b ^ d&(a^b) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[i] + _tab[i]) c = _rol(tls, c, int32(17)) + d i = i + 1 - b = b + (a ^ c&(d^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) + b = b + (a ^ c&(d^a) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[i] + _tab[i]) b = _rol(tls, b, int32(22)) + c i = i + 1 } for i < uint32(32) { - a = a + (c ^ d&(c^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) + a = a + (c ^ d&(c^b) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) a = _rol(tls, a, int32(5)) + b i = i + 1 - d = d + (b ^ c&(b^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) + d = d + (b ^ c&(b^a) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) d = _rol(tls, d, int32(9)) + a i = i + 1 - c = c + (a ^ b&(a^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) + c = c + (a ^ b&(a^d) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) c = _rol(tls, c, int32(14)) + d i = i + 1 - b = b + (d ^ a&(d^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) + b = b + (d ^ a&(d^c) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) b = _rol(tls, b, int32(20)) + c i = i + 1 } for i < uint32(48) { - a = a + (b ^ c ^ d + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) + a = a + (b ^ c ^ d + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) a = _rol(tls, a, int32(4)) + b i = i + 1 - d = d + (a ^ b ^ c + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) + d = d + (a ^ b ^ c + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) d = _rol(tls, d, int32(11)) + a i = i + 1 - c = c + (d ^ a ^ b + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) + c = c + (d ^ a ^ b + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) c = _rol(tls, c, int32(16)) + d i = i + 1 - b = b + (c ^ d ^ a + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) + b = b + (c ^ d ^ a + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) b = _rol(tls, b, int32(23)) + c i = i + 1 } for i < uint32(64) { - a = a + (c ^ (b | ^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) + a = a + (c ^ (b | ^d) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) a = _rol(tls, a, int32(6)) + b i = i + 1 - d = d + (b ^ (a | ^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) + d = d + (b ^ (a | ^c) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) d = _rol(tls, d, int32(10)) + a i = i + 1 - c = c + (a ^ (d | ^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) + c = c + (a ^ (d | ^b) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) c = _rol(tls, c, int32(15)) + d i = i + 1 - b = b + (d ^ (c | ^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) + b = b + (d ^ (c | ^a) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) b = _rol(tls, b, int32(21)) + c i = i + 1 } - *(*Tuint32_t)(unsafe.Pointer(s + 8)) += a - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) += b - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 2*4)) += c - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) += d + **(**Tuint32_t)(__ccgo_up(s + 8)) += a + **(**Tuint32_t)(__ccgo_up(s + 8 + 1*4)) += b + **(**Tuint32_t)(__ccgo_up(s + 8 + 2*4)) += c + **(**Tuint32_t)(__ccgo_up(s + 8 + 3*4)) += d } func _pad(tls *TLS, s uintptr) { @@ -11863,31 +11863,31 @@ func _pad(tls *TLS, s uintptr) { r = uint32((*Tmd5)(unsafe.Pointer(s)).Flen1 % uint64(64)) v1 = r r = r + 1 - *(*Tuint8_t)(unsafe.Pointer(s + 24 + uintptr(v1))) = uint8(0x80) + **(**Tuint8_t)(__ccgo_up(s + 24 + uintptr(v1))) = uint8(0x80) if r > uint32(56) { Xmemset(tls, s+24+uintptr(r), 0, uint64(uint32(64)-r)) r = uint32(0) _processblock(tls, s, s+24) } Xmemset(tls, s+24+uintptr(r), 0, uint64(uint32(56)-r)) - *(*Tuint64_t)(unsafe.Pointer(s)) *= uint64(8) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 56)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 57)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(8)) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 58)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(16)) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 59)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(24)) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 60)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(32)) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 61)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(40)) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 62)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(48)) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 63)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(56)) + **(**Tuint64_t)(__ccgo_up(s)) *= uint64(8) + **(**Tuint8_t)(__ccgo_up(s + 24 + 56)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1) + **(**Tuint8_t)(__ccgo_up(s + 24 + 57)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(8)) + **(**Tuint8_t)(__ccgo_up(s + 24 + 58)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(16)) + **(**Tuint8_t)(__ccgo_up(s + 24 + 59)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(24)) + **(**Tuint8_t)(__ccgo_up(s + 24 + 60)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(32)) + **(**Tuint8_t)(__ccgo_up(s + 24 + 61)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(40)) + **(**Tuint8_t)(__ccgo_up(s + 24 + 62)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(48)) + **(**Tuint8_t)(__ccgo_up(s + 24 + 63)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(56)) _processblock(tls, s, s+24) } func _md5_init(tls *TLS, s uintptr) { (*Tmd5)(unsafe.Pointer(s)).Flen1 = uint64(0) - *(*Tuint32_t)(unsafe.Pointer(s + 8)) = uint32(0x67452301) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) = uint32(0xefcdab89) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 2*4)) = uint32(0x98badcfe) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) = uint32(0x10325476) + **(**Tuint32_t)(__ccgo_up(s + 8)) = uint32(0x67452301) + **(**Tuint32_t)(__ccgo_up(s + 8 + 1*4)) = uint32(0xefcdab89) + **(**Tuint32_t)(__ccgo_up(s + 8 + 2*4)) = uint32(0x98badcfe) + **(**Tuint32_t)(__ccgo_up(s + 8 + 3*4)) = uint32(0x10325476) } func _md5_sum(tls *TLS, s uintptr, md uintptr) { @@ -11899,10 +11899,10 @@ func _md5_sum(tls *TLS, s uintptr, md uintptr) { if !(i < int32(4)) { break } - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4))) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i+int32(1)))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4)) >> int32(8)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i+int32(2)))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4)) >> int32(16)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i+int32(3)))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4)) >> int32(24)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4))) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i+int32(1)))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4)) >> int32(8)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i+int32(2)))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4)) >> int32(16)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i+int32(3)))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4)) >> int32(24)) goto _1 _1: ; @@ -11916,7 +11916,7 @@ func _md5_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { _, _ = p, r p = m r = uint32((*Tmd5)(unsafe.Pointer(s)).Flen1 % uint64(64)) - *(*Tuint64_t)(unsafe.Pointer(s)) += len1 + **(**Tuint64_t)(__ccgo_up(s)) += len1 if r != 0 { if len1 < uint64(uint32(64)-r) { Xmemcpy(tls, s+24+uintptr(r), p, len1) @@ -11983,7 +11983,7 @@ func _to64(tls *TLS, s uintptr, u uint32, n int32) (r uintptr) { } v2 = s s = s + 1 - *(*int8)(unsafe.Pointer(v2)) = Int8FromUint8(_b64[u%uint32(64)]) + **(**int8)(__ccgo_up(v2)) = Int8FromUint8(_b64[u%uint32(64)]) u = u / uint32(64) } return s @@ -12009,7 +12009,7 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt salt = setting + uintptr(3) i = uint32(0) for { - if !(i < uint32(SALT_MAX) && *(*int8)(unsafe.Pointer(salt + uintptr(i))) != 0 && int32(*(*int8)(unsafe.Pointer(salt + uintptr(i)))) != int32('$')) { + if !(i < uint32(SALT_MAX) && **(**int8)(__ccgo_up(salt + uintptr(i))) != 0 && int32(**(**int8)(__ccgo_up(salt + uintptr(i)))) != int32('$')) { break } goto _1 @@ -12040,7 +12040,7 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt i = uint32(uint64(i) - Uint64FromInt64(16)) } _md5_update(tls, bp, bp+88, uint64(i)) - (*(*[16]uint8)(unsafe.Pointer(bp + 88)))[0] = uint8(0) + (**(**[16]uint8)(__ccgo_up(bp + 88)))[0] = uint8(0) i = klen for { if !(i != 0) { @@ -12091,20 +12091,20 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt p = output + uintptr(3) + uintptr(slen) v5 = p p = p + 1 - *(*int8)(unsafe.Pointer(v5)) = int8('$') + **(**int8)(__ccgo_up(v5)) = int8('$') i = uint32(0) for { if !(i < uint32(5)) { break } - p = _to64(tls, p, Uint32FromInt32(Int32FromUint8((*(*[16]uint8)(unsafe.Pointer(bp + 88)))[*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_perm)) + uintptr(i)*3))])<>Int32FromInt32(10) + (*(*[64]Tuint32_t)(unsafe.Pointer(bp)))[i-int32(7)] + (_ror(tls, (*(*[64]Tuint32_t)(unsafe.Pointer(bp)))[i-int32(15)], int32(7)) ^ _ror(tls, (*(*[64]Tuint32_t)(unsafe.Pointer(bp)))[i-int32(15)], int32(18)) ^ (*(*[64]Tuint32_t)(unsafe.Pointer(bp)))[i-int32(15)]>>Int32FromInt32(3)) + (*(*[64]Tuint32_t)(unsafe.Pointer(bp)))[i-int32(16)] + (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i] = _ror(tls, (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(2)], int32(17)) ^ _ror(tls, (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(2)], int32(19)) ^ (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(2)]>>Int32FromInt32(10) + (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(7)] + (_ror(tls, (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(15)], int32(7)) ^ _ror(tls, (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(15)], int32(18)) ^ (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(15)]>>Int32FromInt32(3)) + (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(16)] goto _2 _2: ; i = i + 1 } - a = *(*Tuint32_t)(unsafe.Pointer(s + 8)) - b = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) - c = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 2*4)) - d = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) - e = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 4*4)) - f = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 5*4)) - g = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 6*4)) - h = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 7*4)) + a = **(**Tuint32_t)(__ccgo_up(s + 8)) + b = **(**Tuint32_t)(__ccgo_up(s + 8 + 1*4)) + c = **(**Tuint32_t)(__ccgo_up(s + 8 + 2*4)) + d = **(**Tuint32_t)(__ccgo_up(s + 8 + 3*4)) + e = **(**Tuint32_t)(__ccgo_up(s + 8 + 4*4)) + f = **(**Tuint32_t)(__ccgo_up(s + 8 + 5*4)) + g = **(**Tuint32_t)(__ccgo_up(s + 8 + 6*4)) + h = **(**Tuint32_t)(__ccgo_up(s + 8 + 7*4)) i = 0 for { if !(i < int32(64)) { break } - t1 = h + (_ror(tls, e, int32(6)) ^ _ror(tls, e, int32(11)) ^ _ror(tls, e, int32(25))) + (g ^ e&(f^g)) + _K[i] + (*(*[64]Tuint32_t)(unsafe.Pointer(bp)))[i] + t1 = h + (_ror(tls, e, int32(6)) ^ _ror(tls, e, int32(11)) ^ _ror(tls, e, int32(25))) + (g ^ e&(f^g)) + _K[i] + (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i] t2 = _ror(tls, a, int32(2)) ^ _ror(tls, a, int32(13)) ^ _ror(tls, a, int32(22)) + (a&b | c&(a|b)) h = g g = f @@ -12341,14 +12341,14 @@ func _processblock1(tls *TLS, s uintptr, buf uintptr) { ; i = i + 1 } - *(*Tuint32_t)(unsafe.Pointer(s + 8)) += a - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) += b - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 2*4)) += c - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) += d - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 4*4)) += e - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 5*4)) += f - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 6*4)) += g - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 7*4)) += h + **(**Tuint32_t)(__ccgo_up(s + 8)) += a + **(**Tuint32_t)(__ccgo_up(s + 8 + 1*4)) += b + **(**Tuint32_t)(__ccgo_up(s + 8 + 2*4)) += c + **(**Tuint32_t)(__ccgo_up(s + 8 + 3*4)) += d + **(**Tuint32_t)(__ccgo_up(s + 8 + 4*4)) += e + **(**Tuint32_t)(__ccgo_up(s + 8 + 5*4)) += f + **(**Tuint32_t)(__ccgo_up(s + 8 + 6*4)) += g + **(**Tuint32_t)(__ccgo_up(s + 8 + 7*4)) += h } func _pad1(tls *TLS, s uintptr) { @@ -12357,35 +12357,35 @@ func _pad1(tls *TLS, s uintptr) { r = uint32((*Tsha256)(unsafe.Pointer(s)).Flen1 % uint64(64)) v1 = r r = r + 1 - *(*Tuint8_t)(unsafe.Pointer(s + 40 + uintptr(v1))) = uint8(0x80) + **(**Tuint8_t)(__ccgo_up(s + 40 + uintptr(v1))) = uint8(0x80) if r > uint32(56) { Xmemset(tls, s+40+uintptr(r), 0, uint64(uint32(64)-r)) r = uint32(0) _processblock1(tls, s, s+40) } Xmemset(tls, s+40+uintptr(r), 0, uint64(uint32(56)-r)) - *(*Tuint64_t)(unsafe.Pointer(s)) *= uint64(8) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 56)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(56)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 57)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(48)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 58)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(40)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 59)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(32)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 60)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(24)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 61)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(16)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 62)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(8)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 63)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1) + **(**Tuint64_t)(__ccgo_up(s)) *= uint64(8) + **(**Tuint8_t)(__ccgo_up(s + 40 + 56)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(56)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 57)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(48)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 58)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(40)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 59)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(32)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 60)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(24)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 61)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(16)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 62)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(8)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 63)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1) _processblock1(tls, s, s+40) } func _sha256_init(tls *TLS, s uintptr) { (*Tsha256)(unsafe.Pointer(s)).Flen1 = uint64(0) - *(*Tuint32_t)(unsafe.Pointer(s + 8)) = uint32(0x6a09e667) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) = uint32(0xbb67ae85) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 2*4)) = uint32(0x3c6ef372) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) = uint32(0xa54ff53a) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 4*4)) = uint32(0x510e527f) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 5*4)) = uint32(0x9b05688c) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 6*4)) = uint32(0x1f83d9ab) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 7*4)) = uint32(0x5be0cd19) + **(**Tuint32_t)(__ccgo_up(s + 8)) = uint32(0x6a09e667) + **(**Tuint32_t)(__ccgo_up(s + 8 + 1*4)) = uint32(0xbb67ae85) + **(**Tuint32_t)(__ccgo_up(s + 8 + 2*4)) = uint32(0x3c6ef372) + **(**Tuint32_t)(__ccgo_up(s + 8 + 3*4)) = uint32(0xa54ff53a) + **(**Tuint32_t)(__ccgo_up(s + 8 + 4*4)) = uint32(0x510e527f) + **(**Tuint32_t)(__ccgo_up(s + 8 + 5*4)) = uint32(0x9b05688c) + **(**Tuint32_t)(__ccgo_up(s + 8 + 6*4)) = uint32(0x1f83d9ab) + **(**Tuint32_t)(__ccgo_up(s + 8 + 7*4)) = uint32(0x5be0cd19) } func _sha256_sum(tls *TLS, s uintptr, md uintptr) { @@ -12397,10 +12397,10 @@ func _sha256_sum(tls *TLS, s uintptr, md uintptr) { if !(i < int32(8)) { break } - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4)) >> int32(24)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i+int32(1)))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4)) >> int32(16)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i+int32(2)))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4)) >> int32(8)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i+int32(3)))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4))) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4)) >> int32(24)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i+int32(1)))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4)) >> int32(16)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i+int32(2)))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4)) >> int32(8)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i+int32(3)))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4))) goto _1 _1: ; @@ -12414,7 +12414,7 @@ func _sha256_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { _, _ = p, r p = m r = uint32((*Tsha256)(unsafe.Pointer(s)).Flen1 % uint64(64)) - *(*Tuint64_t)(unsafe.Pointer(s)) += len1 + **(**Tuint64_t)(__ccgo_up(s)) += len1 if r != 0 { if len1 < uint64(uint32(64)-r) { Xmemcpy(tls, s+40+uintptr(r), p, len1) @@ -12453,7 +12453,7 @@ func _to641(tls *TLS, s uintptr, u uint32, n int32) (r uintptr) { } v2 = s s = s + 1 - *(*int8)(unsafe.Pointer(v2)) = Int8FromUint8(_b641[u%uint32(64)]) + **(**int8)(__ccgo_up(v2)) = Int8FromUint8(_b641[u%uint32(64)]) u = u / uint32(64) } return s @@ -12496,7 +12496,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui var _ /* rounds at bp+200 */ [20]int8 var _ /* smd at bp+168 */ [32]uint8 _, _, _, _, _, _, _ = i, klen, p, r, salt, slen, u - *(*[20]int8)(unsafe.Pointer(bp + 200)) = [20]int8{} + **(**[20]int8)(__ccgo_up(bp + 200)) = [20]int8{} /* reject large keys */ klen = uint32(Xstrnlen(tls, key, Uint64FromInt32(Int32FromInt32(KEY_MAX1)+Int32FromInt32(1)))) if klen > uint32(KEY_MAX1) { @@ -12522,14 +12522,14 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui * the host's value of ULONG_MAX. */ salt = salt + uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) - if !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(salt)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + if !(BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(salt)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } u = Xstrtoul(tls, salt, bp+224, int32(10)) - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 224))))) != int32('$') { + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 224))))) != int32('$') { return uintptr(0) } - salt = *(*uintptr)(unsafe.Pointer(bp + 224)) + uintptr(1) + salt = **(**uintptr)(__ccgo_up(bp + 224)) + uintptr(1) if u < uint64(ROUNDS_MIN) { r = uint32(ROUNDS_MIN) } else { @@ -12544,11 +12544,11 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui } i = uint32(0) for { - if !(i < uint32(SALT_MAX1) && *(*int8)(unsafe.Pointer(salt + uintptr(i))) != 0 && int32(*(*int8)(unsafe.Pointer(salt + uintptr(i)))) != int32('$')) { + if !(i < uint32(SALT_MAX1) && **(**int8)(__ccgo_up(salt + uintptr(i))) != 0 && int32(**(**int8)(__ccgo_up(salt + uintptr(i)))) != int32('$')) { break } /* reject characters that interfere with /etc/shadow parsing */ - if int32(*(*int8)(unsafe.Pointer(salt + uintptr(i)))) == int32('\n') || int32(*(*int8)(unsafe.Pointer(salt + uintptr(i)))) == int32(':') { + if int32(**(**int8)(__ccgo_up(salt + uintptr(i)))) == int32('\n') || int32(**(**int8)(__ccgo_up(salt + uintptr(i)))) == int32(':') { return uintptr(0) } goto _1 @@ -12602,7 +12602,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui _sha256_init(tls, bp) i = uint32(0) for { - if !(i < Uint32FromInt32(int32(16)+Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp + 104)))[0]))) { + if !(i < Uint32FromInt32(int32(16)+Int32FromUint8((**(**[32]uint8)(__ccgo_up(bp + 104)))[0]))) { break } _sha256_update(tls, bp, salt, uint64(slen)) @@ -12649,14 +12649,14 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui if !(i < uint32(10)) { break } - p = _to641(tls, p, Uint32FromInt32(Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp + 104)))[*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_perm1)) + uintptr(i)*3))])<>Int32FromInt32(6) + (*(*[80]Tuint64_t)(unsafe.Pointer(bp)))[i-int32(7)] + (_ror1(tls, (*(*[80]Tuint64_t)(unsafe.Pointer(bp)))[i-int32(15)], int32(1)) ^ _ror1(tls, (*(*[80]Tuint64_t)(unsafe.Pointer(bp)))[i-int32(15)], int32(8)) ^ (*(*[80]Tuint64_t)(unsafe.Pointer(bp)))[i-int32(15)]>>Int32FromInt32(7)) + (*(*[80]Tuint64_t)(unsafe.Pointer(bp)))[i-int32(16)] + (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i] = _ror1(tls, (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(2)], int32(19)) ^ _ror1(tls, (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(2)], int32(61)) ^ (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(2)]>>Int32FromInt32(6) + (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(7)] + (_ror1(tls, (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(15)], int32(1)) ^ _ror1(tls, (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(15)], int32(8)) ^ (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(15)]>>Int32FromInt32(7)) + (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(16)] goto _2 _2: ; i = i + 1 } - a = *(*Tuint64_t)(unsafe.Pointer(s + 8)) - b = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 1*8)) - c = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 2*8)) - d = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 3*8)) - e = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 4*8)) - f = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 5*8)) - g = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 6*8)) - h = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 7*8)) + a = **(**Tuint64_t)(__ccgo_up(s + 8)) + b = **(**Tuint64_t)(__ccgo_up(s + 8 + 1*8)) + c = **(**Tuint64_t)(__ccgo_up(s + 8 + 2*8)) + d = **(**Tuint64_t)(__ccgo_up(s + 8 + 3*8)) + e = **(**Tuint64_t)(__ccgo_up(s + 8 + 4*8)) + f = **(**Tuint64_t)(__ccgo_up(s + 8 + 5*8)) + g = **(**Tuint64_t)(__ccgo_up(s + 8 + 6*8)) + h = **(**Tuint64_t)(__ccgo_up(s + 8 + 7*8)) i = 0 for { if !(i < int32(80)) { break } - t1 = h + (_ror1(tls, e, int32(14)) ^ _ror1(tls, e, int32(18)) ^ _ror1(tls, e, int32(41))) + (g ^ e&(f^g)) + _K1[i] + (*(*[80]Tuint64_t)(unsafe.Pointer(bp)))[i] + t1 = h + (_ror1(tls, e, int32(14)) ^ _ror1(tls, e, int32(18)) ^ _ror1(tls, e, int32(41))) + (g ^ e&(f^g)) + _K1[i] + (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i] t2 = _ror1(tls, a, int32(28)) ^ _ror1(tls, a, int32(34)) ^ _ror1(tls, a, int32(39)) + (a&b | c&(a|b)) h = g g = f @@ -12896,14 +12896,14 @@ func _processblock2(tls *TLS, s uintptr, buf uintptr) { ; i = i + 1 } - *(*Tuint64_t)(unsafe.Pointer(s + 8)) += a - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 1*8)) += b - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 2*8)) += c - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 3*8)) += d - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 4*8)) += e - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 5*8)) += f - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 6*8)) += g - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 7*8)) += h + **(**Tuint64_t)(__ccgo_up(s + 8)) += a + **(**Tuint64_t)(__ccgo_up(s + 8 + 1*8)) += b + **(**Tuint64_t)(__ccgo_up(s + 8 + 2*8)) += c + **(**Tuint64_t)(__ccgo_up(s + 8 + 3*8)) += d + **(**Tuint64_t)(__ccgo_up(s + 8 + 4*8)) += e + **(**Tuint64_t)(__ccgo_up(s + 8 + 5*8)) += f + **(**Tuint64_t)(__ccgo_up(s + 8 + 6*8)) += g + **(**Tuint64_t)(__ccgo_up(s + 8 + 7*8)) += h } func _pad2(tls *TLS, s uintptr) { @@ -12912,35 +12912,35 @@ func _pad2(tls *TLS, s uintptr) { r = uint32((*Tsha512)(unsafe.Pointer(s)).Flen1 % uint64(128)) v1 = r r = r + 1 - *(*Tuint8_t)(unsafe.Pointer(s + 72 + uintptr(v1))) = uint8(0x80) + **(**Tuint8_t)(__ccgo_up(s + 72 + uintptr(v1))) = uint8(0x80) if r > uint32(112) { Xmemset(tls, s+72+uintptr(r), 0, uint64(uint32(128)-r)) r = uint32(0) _processblock2(tls, s, s+72) } Xmemset(tls, s+72+uintptr(r), 0, uint64(uint32(120)-r)) - *(*Tuint64_t)(unsafe.Pointer(s)) *= uint64(8) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 120)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(56)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 121)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(48)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 122)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(40)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 123)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(32)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 124)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(24)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 125)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(16)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 126)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(8)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 127)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1) + **(**Tuint64_t)(__ccgo_up(s)) *= uint64(8) + **(**Tuint8_t)(__ccgo_up(s + 72 + 120)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(56)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 121)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(48)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 122)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(40)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 123)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(32)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 124)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(24)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 125)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(16)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 126)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(8)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 127)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1) _processblock2(tls, s, s+72) } func _sha512_init(tls *TLS, s uintptr) { (*Tsha512)(unsafe.Pointer(s)).Flen1 = uint64(0) - *(*Tuint64_t)(unsafe.Pointer(s + 8)) = uint64(0x6a09e667f3bcc908) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 1*8)) = uint64(0xbb67ae8584caa73b) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 2*8)) = uint64(0x3c6ef372fe94f82b) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 3*8)) = uint64(0xa54ff53a5f1d36f1) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 4*8)) = uint64(0x510e527fade682d1) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 5*8)) = uint64(0x9b05688c2b3e6c1f) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 6*8)) = uint64(0x1f83d9abfb41bd6b) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 7*8)) = uint64(0x5be0cd19137e2179) + **(**Tuint64_t)(__ccgo_up(s + 8)) = uint64(0x6a09e667f3bcc908) + **(**Tuint64_t)(__ccgo_up(s + 8 + 1*8)) = uint64(0xbb67ae8584caa73b) + **(**Tuint64_t)(__ccgo_up(s + 8 + 2*8)) = uint64(0x3c6ef372fe94f82b) + **(**Tuint64_t)(__ccgo_up(s + 8 + 3*8)) = uint64(0xa54ff53a5f1d36f1) + **(**Tuint64_t)(__ccgo_up(s + 8 + 4*8)) = uint64(0x510e527fade682d1) + **(**Tuint64_t)(__ccgo_up(s + 8 + 5*8)) = uint64(0x9b05688c2b3e6c1f) + **(**Tuint64_t)(__ccgo_up(s + 8 + 6*8)) = uint64(0x1f83d9abfb41bd6b) + **(**Tuint64_t)(__ccgo_up(s + 8 + 7*8)) = uint64(0x5be0cd19137e2179) } func _sha512_sum(tls *TLS, s uintptr, md uintptr) { @@ -12952,14 +12952,14 @@ func _sha512_sum(tls *TLS, s uintptr, md uintptr) { if !(i < int32(8)) { break } - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(56)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(1)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(48)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(2)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(40)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(3)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(32)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(4)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(24)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(5)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(16)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(6)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(8)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(7)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8))) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(56)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(1)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(48)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(2)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(40)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(3)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(32)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(4)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(24)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(5)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(16)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(6)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(8)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(7)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8))) goto _1 _1: ; @@ -12973,7 +12973,7 @@ func _sha512_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { _, _ = p, r p = m r = uint32((*Tsha512)(unsafe.Pointer(s)).Flen1 % uint64(128)) - *(*Tuint64_t)(unsafe.Pointer(s)) += len1 + **(**Tuint64_t)(__ccgo_up(s)) += len1 if r != 0 { if len1 < uint64(uint32(128)-r) { Xmemcpy(tls, s+72+uintptr(r), p, len1) @@ -13012,7 +13012,7 @@ func _to642(tls *TLS, s uintptr, u uint32, n int32) (r uintptr) { } v2 = s s = s + 1 - *(*int8)(unsafe.Pointer(v2)) = Int8FromUint8(_b642[u%uint32(64)]) + **(**int8)(__ccgo_up(v2)) = Int8FromUint8(_b642[u%uint32(64)]) u = u / uint32(64) } return s @@ -13055,11 +13055,11 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui var _ /* rounds at bp+392 */ [20]int8 var _ /* smd at bp+328 */ [64]uint8 _, _, _, _, _, _, _ = i, klen, p, r, salt, slen, u - *(*[20]int8)(unsafe.Pointer(bp + 392)) = [20]int8{} + **(**[20]int8)(__ccgo_up(bp + 392)) = [20]int8{} /* reject large keys */ i = uint32(0) for { - if !(i <= uint32(KEY_MAX1) && *(*int8)(unsafe.Pointer(key + uintptr(i))) != 0) { + if !(i <= uint32(KEY_MAX1) && **(**int8)(__ccgo_up(key + uintptr(i))) != 0) { break } goto _1 @@ -13091,14 +13091,14 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui * the host's value of ULONG_MAX. */ salt = salt + uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) - if !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(salt)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + if !(BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(salt)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } u = Xstrtoul(tls, salt, bp+416, int32(10)) - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 416))))) != int32('$') { + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 416))))) != int32('$') { return uintptr(0) } - salt = *(*uintptr)(unsafe.Pointer(bp + 416)) + uintptr(1) + salt = **(**uintptr)(__ccgo_up(bp + 416)) + uintptr(1) if u < uint64(ROUNDS_MIN) { r = uint32(ROUNDS_MIN) } else { @@ -13113,11 +13113,11 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui } i = uint32(0) for { - if !(i < uint32(SALT_MAX1) && *(*int8)(unsafe.Pointer(salt + uintptr(i))) != 0 && int32(*(*int8)(unsafe.Pointer(salt + uintptr(i)))) != int32('$')) { + if !(i < uint32(SALT_MAX1) && **(**int8)(__ccgo_up(salt + uintptr(i))) != 0 && int32(**(**int8)(__ccgo_up(salt + uintptr(i)))) != int32('$')) { break } /* reject characters that interfere with /etc/shadow parsing */ - if int32(*(*int8)(unsafe.Pointer(salt + uintptr(i)))) == int32('\n') || int32(*(*int8)(unsafe.Pointer(salt + uintptr(i)))) == int32(':') { + if int32(**(**int8)(__ccgo_up(salt + uintptr(i)))) == int32('\n') || int32(**(**int8)(__ccgo_up(salt + uintptr(i)))) == int32(':') { return uintptr(0) } goto _2 @@ -13171,7 +13171,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui _sha512_init(tls, bp) i = uint32(0) for { - if !(i < Uint32FromInt32(int32(16)+Int32FromUint8((*(*[64]uint8)(unsafe.Pointer(bp + 200)))[0]))) { + if !(i < Uint32FromInt32(int32(16)+Int32FromUint8((**(**[64]uint8)(__ccgo_up(bp + 200)))[0]))) { break } _sha512_update(tls, bp, salt, uint64(slen)) @@ -13218,14 +13218,14 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui if !(i < uint32(21)) { break } - p = _to642(tls, p, Uint32FromInt32(Int32FromUint8((*(*[64]uint8)(unsafe.Pointer(bp + 200)))[*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_perm2)) + uintptr(i)*3))])<= 0) { break } v3 = bp + uintptr(i) - *(*uint8)(unsafe.Pointer(v3)) = uint8(uint32(*(*uint8)(unsafe.Pointer(v3))) | Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(key)))&Int32FromInt32(1))<= 0) { break } - *(*Tuint32_t)(unsafe.Pointer(bp + 128 + uintptr(i)*4)) |= Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(p)))&Int32FromInt32(1)) << j + **(**Tuint32_t)(__ccgo_up(bp + 128 + uintptr(i)*4)) |= Uint32FromInt32(int32(**(**int8)(__ccgo_up(p)))&Int32FromInt32(1)) << j goto _2 _2: ; @@ -13443,15 +13443,15 @@ func Xencrypt(tls *TLS, block uintptr, edflag int32) { if !(i < int32(16)) { break } - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(i)*4)) = *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&___encrypt_key)) + uintptr(int32(15)-i)*4)) - *(*Tuint32_t)(unsafe.Pointer(bp + 64 + uintptr(i)*4)) = *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&___encrypt_key)) + 64 + uintptr(int32(15)-i)*4)) + **(**Tuint32_t)(__ccgo_up(bp + uintptr(i)*4)) = **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&___encrypt_key)) + uintptr(int32(15)-i)*4)) + **(**Tuint32_t)(__ccgo_up(bp + 64 + uintptr(i)*4)) = **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&___encrypt_key)) + 64 + uintptr(int32(15)-i)*4)) goto _3 _3: ; i = i + 1 } } - X__do_des(tls, (*(*[2]Tuint32_t)(unsafe.Pointer(bp + 128)))[0], (*(*[2]Tuint32_t)(unsafe.Pointer(bp + 128)))[int32(1)], bp+128, bp+128+uintptr(1)*4, uint32(1), uint32(0), key) + X__do_des(tls, (**(**[2]Tuint32_t)(__ccgo_up(bp + 128)))[0], (**(**[2]Tuint32_t)(__ccgo_up(bp + 128)))[int32(1)], bp+128, bp+128+uintptr(1)*4, uint32(1), uint32(0), key) p = block i = 0 for { @@ -13465,7 +13465,7 @@ func Xencrypt(tls *TLS, block uintptr, edflag int32) { } v6 = p p = p + 1 - *(*int8)(unsafe.Pointer(v6)) = Int8FromUint32((*(*[2]Tuint32_t)(unsafe.Pointer(bp + 128)))[i] >> j & uint32(1)) + **(**int8)(__ccgo_up(v6)) = Int8FromUint32((**(**[2]Tuint32_t)(__ccgo_up(bp + 128)))[i] >> j & uint32(1)) goto _5 _5: ; @@ -13940,7 +13940,7 @@ func X__ctype_get_mb_cur_max(tls *TLS) (r Tsize_t) { } var v1 int32 _ = v1 - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v1 = int32(4) } else { v1 = int32(1) @@ -17504,10 +17504,10 @@ func Xwctype(tls *TLS, s uintptr) (r Twctype_t) { i = int32(1) p = uintptr(unsafe.Pointer(&_names)) for { - if !(*(*int8)(unsafe.Pointer(p)) != 0) { + if !(**(**int8)(__ccgo_up(p)) != 0) { break } - if int32(*(*int8)(unsafe.Pointer(s))) == int32(*(*int8)(unsafe.Pointer(p))) && !(Xstrcmp(tls, s, p) != 0) { + if int32(**(**int8)(__ccgo_up(s))) == int32(**(**int8)(__ccgo_up(p))) && !(Xstrcmp(tls, s, p) != 0) { return Uint64FromInt32(i) } goto _1 @@ -22253,9 +22253,9 @@ func _casemap(tls *TLS, c uint32, dir int32) (r1 int32) { xn = Uint32FromInt32(rd & int32(0xff)) xb = Uint32FromInt32(rd) >> int32(8) for xn != 0 { - try = uint32(*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_exceptions)) + uintptr(xb+xn/uint32(2))*2))) + try = uint32(**(**uint8)(__ccgo_up(uintptr(unsafe.Pointer(&_exceptions)) + uintptr(xb+xn/uint32(2))*2))) if try == c { - r = _rules[*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_exceptions)) + uintptr(xb+xn/uint32(2))*2 + 1))] + r = _rules[**(**uint8)(__ccgo_up(uintptr(unsafe.Pointer(&_exceptions)) + uintptr(xb+xn/uint32(2))*2 + 1))] rt = Uint32FromInt32(r & int32(255)) rd = r >> int32(8) if rt < uint32(2) { @@ -22348,8 +22348,8 @@ func Xwcswidth(tls *TLS, wcs uintptr, n Tsize_t) (r int32) { for { v2 = n n = n - 1 - if v4 = v2 != 0 && *(*Twchar_t)(unsafe.Pointer(wcs)) != 0; v4 { - v3 = Xwcwidth(tls, *(*Twchar_t)(unsafe.Pointer(wcs))) + if v4 = v2 != 0 && **(**Twchar_t)(__ccgo_up(wcs)) != 0; v4 { + v3 = Xwcwidth(tls, **(**Twchar_t)(__ccgo_up(wcs))) k = v3 } if !(v4 && v3 >= 0) { @@ -24549,7 +24549,7 @@ func Xalphasort(tls *TLS, a uintptr, b uintptr) (r int32) { trc("tls=%v a=%v b=%v, (%v:)", tls, a, b, origin(2)) defer func() { trc("-> %v", r) }() } - return Xstrcoll(tls, *(*uintptr)(unsafe.Pointer(a))+19, *(*uintptr)(unsafe.Pointer(b))+19) + return Xstrcoll(tls, **(**uintptr)(__ccgo_up(a))+19, **(**uintptr)(__ccgo_up(b))+19) } type TDIR = struct { @@ -24717,11 +24717,11 @@ func Xfdopendir(tls *TLS, fd int32) (r uintptr) { return uintptr(0) } if Xfcntl(tls, fd, int32(F_GETFL), 0)&int32(O_PATH) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EBADF) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EBADF) return uintptr(0) } - if !((*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&Uint32FromInt32(S_IFMT) == Uint32FromInt32(S_IFDIR)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOTDIR) + if !((**(**Tstat)(__ccgo_up(bp))).Fst_mode&Uint32FromInt32(S_IFMT) == Uint32FromInt32(S_IFDIR)) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOTDIR) return uintptr(0) } v1 = Xcalloc(tls, uint64(1), uint64(2072)) @@ -24856,7 +24856,7 @@ func Xreaddir(tls *TLS, dir uintptr) (r uintptr) { len1 = int32(X__syscall3(tls, int64(SYS_getdents64), int64((*TDIR)(unsafe.Pointer(dir)).Ffd), int64(dir+24), Int64FromUint64(Uint64FromInt64(2048)))) if len1 <= 0 { if len1 < 0 && len1 != -int32(ENOENT) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = -len1 + **(**int32)(__ccgo_up(X__errno_location(tls))) = -len1 } return uintptr(0) } @@ -24864,7 +24864,7 @@ func Xreaddir(tls *TLS, dir uintptr) (r uintptr) { (*TDIR)(unsafe.Pointer(dir)).Fbuf_pos = 0 } de = dir + 24 + uintptr((*TDIR)(unsafe.Pointer(dir)).Fbuf_pos) - *(*int32)(unsafe.Pointer(dir + 12)) += Int32FromUint16((*Tdirent)(unsafe.Pointer(de)).Fd_reclen) + **(**int32)(__ccgo_up(dir + 12)) += Int32FromUint16((*Tdirent)(unsafe.Pointer(de)).Fd_reclen) (*TDIR)(unsafe.Pointer(dir)).Ftell = (*Tdirent)(unsafe.Pointer(de)).Fd_off return de } @@ -24877,24 +24877,24 @@ func Xreaddir_r(tls *TLS, dir uintptr, buf uintptr, result uintptr) (r int32) { var de uintptr var errno_save, ret, v1 int32 _, _, _, _ = de, errno_save, ret, v1 - errno_save = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + errno_save = **(**int32)(__ccgo_up(X__errno_location(tls))) ___lock(tls, dir+20) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = 0 + **(**int32)(__ccgo_up(X__errno_location(tls))) = 0 de = Xreaddir(tls, dir) - v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = **(**int32)(__ccgo_up(X__errno_location(tls))) ret = v1 if v1 != 0 { ___unlock(tls, dir+20) return ret } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = errno_save + **(**int32)(__ccgo_up(X__errno_location(tls))) = errno_save if de != 0 { Xmemcpy(tls, buf, de, uint64((*Tdirent)(unsafe.Pointer(de)).Fd_reclen)) } else { buf = UintptrFromInt32(0) } ___unlock(tls, dir+20) - *(*uintptr)(unsafe.Pointer(result)) = buf + **(**uintptr)(__ccgo_up(result)) = buf return 0 } @@ -24930,12 +24930,12 @@ func Xscandir(tls *TLS, path uintptr, res uintptr, __ccgo_fp_sel uintptr, __ccgo names = uintptr(0) cnt = uint64(0) len1 = uint64(0) - old_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + old_errno = **(**int32)(__ccgo_up(X__errno_location(tls))) if !(d != 0) { return -int32(1) } for { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = 0 + **(**int32)(__ccgo_up(X__errno_location(tls))) = 0 v1 = Xreaddir(tls, d) de = v1 if !(v1 != 0) { @@ -24955,16 +24955,16 @@ func Xscandir(tls *TLS, path uintptr, res uintptr, __ccgo_fp_sel uintptr, __ccgo } names = tmp } - *(*uintptr)(unsafe.Pointer(names + uintptr(cnt)*8)) = Xmalloc(tls, uint64((*Tdirent)(unsafe.Pointer(de)).Fd_reclen)) - if !(*(*uintptr)(unsafe.Pointer(names + uintptr(cnt)*8)) != 0) { + **(**uintptr)(__ccgo_up(names + uintptr(cnt)*8)) = Xmalloc(tls, uint64((*Tdirent)(unsafe.Pointer(de)).Fd_reclen)) + if !(**(**uintptr)(__ccgo_up(names + uintptr(cnt)*8)) != 0) { break } v2 = cnt cnt = cnt + 1 - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(names + uintptr(v2)*8)), de, uint64((*Tdirent)(unsafe.Pointer(de)).Fd_reclen)) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(names + uintptr(v2)*8)), de, uint64((*Tdirent)(unsafe.Pointer(de)).Fd_reclen)) } Xclosedir(tls, d) - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != 0 { + if **(**int32)(__ccgo_up(X__errno_location(tls))) != 0 { if names != 0 { for { v2 = cnt @@ -24972,17 +24972,17 @@ func Xscandir(tls *TLS, path uintptr, res uintptr, __ccgo_fp_sel uintptr, __ccgo if !(v2 > uint64(0)) { break } - Xfree(tls, *(*uintptr)(unsafe.Pointer(names + uintptr(cnt)*8))) + Xfree(tls, **(**uintptr)(__ccgo_up(names + uintptr(cnt)*8))) } } Xfree(tls, names) return -int32(1) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = old_errno + **(**int32)(__ccgo_up(X__errno_location(tls))) = old_errno if __ccgo_fp_cmp != 0 { Xqsort(tls, names, cnt, uint64(8), __ccgo_fp_cmp) } - *(*uintptr)(unsafe.Pointer(res)) = names + **(**uintptr)(__ccgo_up(res)) = names return Int32FromUint64(cnt) } @@ -25013,7 +25013,7 @@ func Xversionsort(tls *TLS, a uintptr, b uintptr) (r int32) { trc("tls=%v a=%v b=%v, (%v:)", tls, a, b, origin(2)) defer func() { trc("-> %v", r) }() } - return Xstrverscmp(tls, *(*uintptr)(unsafe.Pointer(a))+19, *(*uintptr)(unsafe.Pointer(b))+19) + return Xstrverscmp(tls, **(**uintptr)(__ccgo_up(a))+19, **(**uintptr)(__ccgo_up(b))+19) } func X__reset_tls(tls *TLS) { @@ -25025,7 +25025,7 @@ func X__reset_tls(tls *TLS) { var self Tpthread_t _, _, _, _, _ = i, mem, n, p, self self = uintptr(___get_tp(tls)) - n = *(*Tuintptr_t)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(self)).Fdtv)) + n = **(**Tuintptr_t)(__ccgo_up((*t__pthread)(unsafe.Pointer(self)).Fdtv)) if n != 0 { p = X__libc.Ftls_head i = Uint64FromInt32(1) @@ -25033,7 +25033,7 @@ func X__reset_tls(tls *TLS) { if !(i <= n) { break } - mem = uintptr(*(*Tuintptr_t)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(self)).Fdtv + uintptr(i)*8)) - Uint64FromInt32(DTP_OFFSET)) + mem = uintptr(**(**Tuintptr_t)(__ccgo_up((*t__pthread)(unsafe.Pointer(self)).Fdtv + uintptr(i)*8)) - Uint64FromInt32(DTP_OFFSET)) Xmemcpy(tls, mem, (*Ttls_module)(unsafe.Pointer(p)).Fimage, (*Ttls_module)(unsafe.Pointer(p)).Flen1) Xmemset(tls, mem+uintptr((*Ttls_module)(unsafe.Pointer(p)).Flen1), 0, (*Ttls_module)(unsafe.Pointer(p)).Fsize-(*Ttls_module)(unsafe.Pointer(p)).Flen1) goto _1 @@ -25059,7 +25059,7 @@ func X__init_ssp(tls *TLS, entropy uintptr) { * The NULL byte is on the second byte so that off-by-ones can * still be detected. Endianness is taken care of * automatically. */ - *(*int8)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stack_chk_guard)) + 1)) = 0 + **(**int8)(__ccgo_up(uintptr(unsafe.Pointer(&X__stack_chk_guard)) + 1)) = 0 (*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Fcanary = X__stack_chk_guard } @@ -25095,10 +25095,10 @@ func Xclearenv(tls *TLS) (r int32) { e = Xenviron Xenviron = uintptr(0) if e != 0 { - for *(*uintptr)(unsafe.Pointer(e)) != 0 { + for **(**uintptr)(__ccgo_up(e)) != 0 { v1 = e e += 8 - X__env_rm_add(tls, *(*uintptr)(unsafe.Pointer(v1)), uintptr(0)) + X__env_rm_add(tls, **(**uintptr)(__ccgo_up(v1)), uintptr(0)) } } return 0 @@ -25113,14 +25113,14 @@ func Xgetenv(tls *TLS, name uintptr) (r uintptr) { var l Tsize_t _, _ = e, l l = Uint64FromInt64(int64(X__strchrnul(tls, name, int32('='))) - int64(name)) - if l != 0 && !(*(*int8)(unsafe.Pointer(name + uintptr(l))) != 0) && Xenviron != 0 { + if l != 0 && !(**(**int8)(__ccgo_up(name + uintptr(l))) != 0) && Xenviron != 0 { e = Xenviron for { - if !(*(*uintptr)(unsafe.Pointer(e)) != 0) { + if !(**(**uintptr)(__ccgo_up(e)) != 0) { break } - if !(Xstrncmp(tls, name, *(*uintptr)(unsafe.Pointer(e)), l) != 0) && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(e)) + uintptr(l)))) == int32('=') { - return *(*uintptr)(unsafe.Pointer(e)) + uintptr(l) + uintptr(1) + if !(Xstrncmp(tls, name, **(**uintptr)(__ccgo_up(e)), l) != 0) && int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(e)) + uintptr(l)))) == int32('=') { + return **(**uintptr)(__ccgo_up(e)) + uintptr(l) + uintptr(1) } goto _1 _1: @@ -25146,12 +25146,12 @@ func X__putenv(tls *TLS, s uintptr, l Tsize_t, r uintptr) (r1 int32) { if Xenviron != 0 { e = Xenviron for { - if !(*(*uintptr)(unsafe.Pointer(e)) != 0) { + if !(**(**uintptr)(__ccgo_up(e)) != 0) { break } - if !(Xstrncmp(tls, s, *(*uintptr)(unsafe.Pointer(e)), l+uint64(1)) != 0) { - tmp = *(*uintptr)(unsafe.Pointer(e)) - *(*uintptr)(unsafe.Pointer(e)) = s + if !(Xstrncmp(tls, s, **(**uintptr)(__ccgo_up(e)), l+uint64(1)) != 0) { + tmp = **(**uintptr)(__ccgo_up(e)) + **(**uintptr)(__ccgo_up(e)) = s X__env_rm_add(tls, tmp, r) return 0 } @@ -25177,8 +25177,8 @@ func X__putenv(tls *TLS, s uintptr, l Tsize_t, r uintptr) (r1 int32) { } Xfree(tls, _oldenv) } - *(*uintptr)(unsafe.Pointer(newenv + uintptr(i)*8)) = s - *(*uintptr)(unsafe.Pointer(newenv + uintptr(i+uint64(1))*8)) = uintptr(0) + **(**uintptr)(__ccgo_up(newenv + uintptr(i)*8)) = s + **(**uintptr)(__ccgo_up(newenv + uintptr(i+uint64(1))*8)) = uintptr(0) v2 = newenv _oldenv = v2 Xenviron = v2 @@ -25203,7 +25203,7 @@ func Xputenv(tls *TLS, s uintptr) (r int32) { var l Tsize_t _ = l l = Uint64FromInt64(int64(X__strchrnul(tls, s, int32('='))) - int64(s)) - if !(l != 0) || !(*(*int8)(unsafe.Pointer(s + uintptr(l))) != 0) { + if !(l != 0) || !(**(**int8)(__ccgo_up(s + uintptr(l))) != 0) { return Xunsetenv(tls, s) } return X__putenv(tls, s, l, uintptr(0)) @@ -25248,13 +25248,13 @@ func X__env_rm_add(tls *TLS, old uintptr, new1 uintptr) { if !(i < _env_alloced_n) { break } - if *(*uintptr)(unsafe.Pointer(_env_alloced + uintptr(i)*8)) == old { - *(*uintptr)(unsafe.Pointer(_env_alloced + uintptr(i)*8)) = new1 + if **(**uintptr)(__ccgo_up(_env_alloced + uintptr(i)*8)) == old { + **(**uintptr)(__ccgo_up(_env_alloced + uintptr(i)*8)) = new1 Xfree(tls, old) return } else { - if !(*(*uintptr)(unsafe.Pointer(_env_alloced + uintptr(i)*8)) != 0) && new1 != 0 { - *(*uintptr)(unsafe.Pointer(_env_alloced + uintptr(i)*8)) = new1 + if !(**(**uintptr)(__ccgo_up(_env_alloced + uintptr(i)*8)) != 0) && new1 != 0 { + **(**uintptr)(__ccgo_up(_env_alloced + uintptr(i)*8)) = new1 new1 = uintptr(0) } } @@ -25274,7 +25274,7 @@ func X__env_rm_add(tls *TLS, old uintptr, new1 uintptr) { _env_alloced = v2 v3 = _env_alloced_n _env_alloced_n = _env_alloced_n + 1 - *(*uintptr)(unsafe.Pointer(v2 + uintptr(v3)*8)) = new1 + **(**uintptr)(__ccgo_up(v2 + uintptr(v3)*8)) = new1 } var _env_alloced uintptr @@ -25294,8 +25294,8 @@ func Xsetenv(tls *TLS, var1 uintptr, value uintptr, overwrite int32) (r int32) { v1 = Uint64FromInt64(int64(X__strchrnul(tls, var1, int32('='))) - int64(var1)) l1 = v1 } - if v2 || !(v1 != 0) || *(*int8)(unsafe.Pointer(var1 + uintptr(l1))) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if v2 || !(v1 != 0) || **(**int8)(__ccgo_up(var1 + uintptr(l1))) != 0 { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } if !(overwrite != 0) && Xgetenv(tls, var1) != 0 { @@ -25307,7 +25307,7 @@ func Xsetenv(tls *TLS, var1 uintptr, value uintptr, overwrite int32) (r int32) { return -int32(1) } Xmemcpy(tls, s, var1, l1) - *(*int8)(unsafe.Pointer(s + uintptr(l1))) = int8('=') + **(**int8)(__ccgo_up(s + uintptr(l1))) = int8('=') Xmemcpy(tls, s+uintptr(l1)+uintptr(1), value, l2+uint64(1)) return X__putenv(tls, s, l1, s) } @@ -25324,24 +25324,24 @@ func Xunsetenv(tls *TLS, name uintptr) (r int32) { var l Tsize_t _, _, _, _ = e, eo, l, v2 l = Uint64FromInt64(int64(X__strchrnul(tls, name, int32('='))) - int64(name)) - if !(l != 0) || *(*int8)(unsafe.Pointer(name + uintptr(l))) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if !(l != 0) || **(**int8)(__ccgo_up(name + uintptr(l))) != 0 { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } if Xenviron != 0 { e = Xenviron eo = e for { - if !(*(*uintptr)(unsafe.Pointer(e)) != 0) { + if !(**(**uintptr)(__ccgo_up(e)) != 0) { break } - if !(Xstrncmp(tls, name, *(*uintptr)(unsafe.Pointer(e)), l) != 0) && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(e)) + uintptr(l)))) == int32('=') { - X__env_rm_add(tls, *(*uintptr)(unsafe.Pointer(e)), uintptr(0)) + if !(Xstrncmp(tls, name, **(**uintptr)(__ccgo_up(e)), l) != 0) && int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(e)) + uintptr(l)))) == int32('=') { + X__env_rm_add(tls, **(**uintptr)(__ccgo_up(e)), uintptr(0)) } else { if eo != e { v2 = eo eo += 8 - *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(e)) + **(**uintptr)(__ccgo_up(v2)) = **(**uintptr)(__ccgo_up(e)) } else { eo += 8 } @@ -25352,7 +25352,7 @@ func Xunsetenv(tls *TLS, name uintptr) (r int32) { e += 8 } if eo != e { - *(*uintptr)(unsafe.Pointer(eo)) = uintptr(0) + **(**uintptr)(__ccgo_up(eo)) = uintptr(0) } } return 0 @@ -25662,7 +25662,7 @@ func X__strerror_l(tls *TLS, e int32, loc Tlocale_t) (r uintptr) { e = 0 } s = uintptr(unsafe.Pointer(&_errmsgstr)) + uintptr(_errmsgidx[e]) - return X__lctrans(tls, s, *(*uintptr)(unsafe.Pointer(loc + 5*8))) + return X__lctrans(tls, s, **(**uintptr)(__ccgo_up(loc + 5*8))) } func Xstrerror(tls *TLS, e int32) (r uintptr) { @@ -25799,10 +25799,10 @@ func Xfcntl(tls *TLS, fd int32, cmd int32, va uintptr) (r int32) { if ret != 0 { return int32(X__syscall_ret(tls, Uint64FromInt32(ret))) } - if (*(*Tf_owner_ex)(unsafe.Pointer(bp))).Ftype1 == int32(F_OWNER_PGRP) { - v1 = -(*(*Tf_owner_ex)(unsafe.Pointer(bp))).Fpid + if (**(**Tf_owner_ex)(__ccgo_up(bp))).Ftype1 == int32(F_OWNER_PGRP) { + v1 = -(**(**Tf_owner_ex)(__ccgo_up(bp))).Fpid } else { - v1 = (*(*Tf_owner_ex)(unsafe.Pointer(bp))).Fpid + v1 = (**(**Tf_owner_ex)(__ccgo_up(bp))).Fpid } return v1 } @@ -26063,7 +26063,7 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26074,7 +26074,7 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26104,7 +26104,7 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26123,7 +26123,7 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26140,7 +26140,7 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26193,7 +26193,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__shgetc(tls, f) } @@ -26205,7 +26205,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__shgetc(tls, f) } @@ -26223,14 +26223,14 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__shgetc(tls, f) } c = v2 } } - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0] = uint32(0) + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[0] = uint32(0) for { if !(Uint32FromInt32(c-int32('0')) < uint32(10) || c == int32('.')) { break @@ -26248,9 +26248,9 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, lnz = int32(dc) } if j != 0 { - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k]*uint32(10) + Uint32FromInt32(c) - uint32('0') + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] = (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k]*uint32(10) + Uint32FromInt32(c) - uint32('0') } else { - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] = Uint32FromInt32(c - int32('0')) + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] = Uint32FromInt32(c - int32('0')) } j = j + 1 v2 = j @@ -26263,7 +26263,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, dc = dc + 1 if c != int32('0') { lnz = (Int32FromInt32(KMAX) - Int32FromInt32(4)) * Int32FromInt32(9) - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(Int32FromInt32(KMAX)-Int32FromInt32(4))*4)) |= uint32(1) + **(**Tuint32_t)(__ccgo_up(bp + uintptr(Int32FromInt32(KMAX)-Int32FromInt32(4))*4)) |= uint32(1) } } } @@ -26274,7 +26274,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__shgetc(tls, f) } @@ -26305,24 +26305,24 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, } } if !(gotdig != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) X__shlim(tls, f, int64(Int32FromInt32(0))) return Float64FromInt32(0) } /* Handle zero specially to avoid nasty special cases later */ - if !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0] != 0) { + if !((**(**[128]Tuint32_t)(__ccgo_up(bp)))[0] != 0) { return float64(float64(sign) * float64(0)) } /* Optimize small integers (w/no exponent) and over/under-flow */ - if lrp == dc && dc < int64(10) && (bits > int32(30) || (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0]>>bits == uint32(0)) { - return float64(float64(sign) * float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0])) + if lrp == dc && dc < int64(10) && (bits > int32(30) || (**(**[128]Tuint32_t)(__ccgo_up(bp)))[0]>>bits == uint32(0)) { + return float64(float64(sign) * float64((**(**[128]Tuint32_t)(__ccgo_up(bp)))[0])) } if lrp > int64(-emin/int32(2)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return float64(float64(float64(sign)*Float64FromFloat64(1.79769313486231570815e+308)) * Float64FromFloat64(1.79769313486231570815e+308)) } if lrp < int64(emin-Int32FromInt32(2)*Int32FromInt32(LDBL_MANT_DIG)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return float64(float64(float64(sign)*Float64FromFloat64(2.22507385850720138309e-308)) * Float64FromFloat64(2.22507385850720138309e-308)) } /* Align incomplete final B1B digit */ @@ -26331,7 +26331,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if !(j < int32(9)) { break } - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(k)*4)) *= uint32(10) + **(**Tuint32_t)(__ccgo_up(bp + uintptr(k)*4)) *= uint32(10) goto _17 _17: ; @@ -26347,19 +26347,19 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, /* Optimize small to mid-size integers (even in exp. notation) */ if lnz < int32(9) && lnz <= rp && rp < int32(18) { if rp == int32(9) { - return float64(float64(sign) * float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0])) + return float64(float64(sign) * float64((**(**[128]Tuint32_t)(__ccgo_up(bp)))[0])) } if rp < int32(9) { - return float64(float64(sign)*float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0])) / float64(_p10s[int32(8)-rp]) + return float64(float64(sign)*float64((**(**[128]Tuint32_t)(__ccgo_up(bp)))[0])) / float64(_p10s[int32(8)-rp]) } bitlim = bits - int32(3)*(rp-Int32FromInt32(9)) - if bitlim > int32(30) || (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0]>>bitlim == uint32(0) { - return float64(float64(float64(sign)*float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0])) * float64(_p10s[rp-int32(10)])) + if bitlim > int32(30) || (**(**[128]Tuint32_t)(__ccgo_up(bp)))[0]>>bitlim == uint32(0) { + return float64(float64(float64(sign)*float64((**(**[128]Tuint32_t)(__ccgo_up(bp)))[0])) * float64(_p10s[rp-int32(10)])) } } /* Drop trailing zeros */ for { - if !!((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[z-int32(1)] != 0) { + if !!((**(**[128]Tuint32_t)(__ccgo_up(bp)))[z-int32(1)] != 0) { break } goto _18 @@ -26382,10 +26382,10 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if !(k != z) { break } - tmp = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] % Uint32FromInt32(p10) - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k]/Uint32FromInt32(p10) + carry + tmp = (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] % Uint32FromInt32(p10) + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] = (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k]/Uint32FromInt32(p10) + carry carry = Uint32FromInt32(int32(1000000000)/p10) * tmp - if k == a && !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] != 0) { + if k == a && !((**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] != 0) { a = (a + int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) rp = rp - int32(9) } @@ -26397,25 +26397,25 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if carry != 0 { v2 = z z = z + 1 - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v2] = carry + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[v2] = carry } rp = rp + (int32(9) - rpm9) } /* Upscale until desired number of bits are left of radix point */ - for rp < Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) || rp == Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) && (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[a] < _th[0] { + for rp < Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) || rp == Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) && (**(**[128]Tuint32_t)(__ccgo_up(bp)))[a] < _th[0] { carry1 = uint32(0) e2 = e2 - int32(29) k = (z - int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) for { - tmp1 = uint64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k])< uint64(1000000000) { carry1 = uint32(tmp1 / uint64(1000000000)) - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] = uint32(tmp1 % uint64(1000000000)) + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] = uint32(tmp1 % uint64(1000000000)) } else { carry1 = uint32(0) - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] = uint32(tmp1) + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] = uint32(tmp1) } - if k == (z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) && k != a && !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] != 0) { + if k == (z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) && k != a && !((**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] != 0) { z = k } if k == a { @@ -26431,9 +26431,9 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, a = (a - int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) if a == z { z = (z - int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr((z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)))*4)) |= (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[z] + **(**Tuint32_t)(__ccgo_up(bp + uintptr((z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)))*4)) |= (**(**[128]Tuint32_t)(__ccgo_up(bp)))[z] } - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[a] = carry1 + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[a] = carry1 } } /* Downscale until exactly number of bits are left of radix point */ @@ -26446,11 +26446,11 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, break } k = (a + i) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) - if k == z || (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] < _th[i] { + if k == z || (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] < _th[i] { i = int32(LD_B1B_DIG) break } - if (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))] > _th[i] { + if (**(**[128]Tuint32_t)(__ccgo_up(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))] > _th[i] { break } goto _24 @@ -26471,10 +26471,10 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if !(k != z) { break } - tmp2 = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] & Uint32FromInt32(int32(1)<>sh + carry2 + tmp2 = (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] & Uint32FromInt32(int32(1)<>sh + carry2 carry2 = Uint32FromInt32(Int32FromInt32(1000000000)>>sh) * tmp2 - if k == a && !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] != 0) { + if k == a && !((**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] != 0) { a = (a + int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) i = i - 1 rp = rp - int32(9) @@ -26486,10 +26486,10 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, } if carry2 != 0 { if (z+int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) != a { - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[z] = carry2 + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[z] = carry2 z = (z + int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) } else { - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr((z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)))*4)) |= uint32(1) + **(**Tuint32_t)(__ccgo_up(bp + uintptr((z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)))*4)) |= uint32(1) } } goto _23 @@ -26506,9 +26506,9 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if (a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1)) == z { v6 = (z + Int32FromInt32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) z = v6 - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v6-int32(1)] = uint32(0) + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[v6-int32(1)] = uint32(0) } - y = float64(Float64FromFloat64(1e+09)*y) + float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))]) + y = float64(Float64FromFloat64(1e+09)*y) + float64((**(**[128]Tuint32_t)(__ccgo_up(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))]) goto _26 _26: ; @@ -26532,7 +26532,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, } /* Process tail of decimal input so it can affect rounding */ if (a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1)) != z { - t = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))] + t = (**(**[128]Tuint32_t)(__ccgo_up(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))] if t < uint32(500000000) && (t != 0 || (a+i+int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) != z) { frac = frac + float64(float64(0.25)*float64(sign)) } else { @@ -26563,7 +26563,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, e2 = e2 + 1 } if e2+int32(LDBL_MANT_DIG) > emax || denormal != 0 && frac != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) } } return Xscalbnl(tls, y, e2) @@ -26606,7 +26606,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26624,7 +26624,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26636,7 +26636,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26655,7 +26655,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26702,7 +26702,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26756,11 +26756,11 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 return float64(float64(sign) * float64(0)) } if e2 > int64(-emin) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return float64(float64(float64(sign)*Float64FromFloat64(1.79769313486231570815e+308)) * Float64FromFloat64(1.79769313486231570815e+308)) } if e2 < int64(emin-Int32FromInt32(2)*Int32FromInt32(LDBL_MANT_DIG)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return float64(float64(float64(sign)*Float64FromFloat64(2.22507385850720138309e-308)) * Float64FromFloat64(2.22507385850720138309e-308)) } for x < uint32(0x80000000) { @@ -26789,7 +26789,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 y = bias + float64(float64(sign)*float64(x)) + float64(float64(sign)*y) y = y - bias if !(y != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) } return Xscalbnl(tls, y, int32(e2)) } @@ -26822,7 +26822,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__shgetc(tls, f) } @@ -26842,7 +26842,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -26850,7 +26850,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { } i = uint64(0) for { - if !(i < uint64(8) && c|int32(32) == int32(*(*int8)(unsafe.Pointer(__ccgo_ts + 313 + uintptr(i))))) { + if !(i < uint64(8) && c|int32(32) == int32(**(**int8)(__ccgo_up(__ccgo_ts + 313 + uintptr(i))))) { break } if i < uint64(7) { @@ -26858,7 +26858,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -26894,7 +26894,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { if !(i != 0) { i = uint64(0) for { - if !(i < uint64(3) && c|int32(32) == int32(*(*int8)(unsafe.Pointer(__ccgo_ts + 322 + uintptr(i))))) { + if !(i < uint64(3) && c|int32(32) == int32(**(**int8)(__ccgo_up(__ccgo_ts + 322 + uintptr(i))))) { break } if i < uint64(2) { @@ -26902,7 +26902,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -26919,7 +26919,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -26935,7 +26935,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -26950,7 +26950,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if !(pok != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) X__shlim(tls, f, int64(Int32FromInt32(0))) return Float64FromInt32(0) } @@ -26976,7 +26976,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) X__shlim(tls, f, int64(Int32FromInt32(0))) return Float64FromInt32(0) } @@ -26985,7 +26985,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27276,7 +27276,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint val = uintptr(unsafe.Pointer(&_table6)) + uintptr(1) neg = 0 if base > uint32(36) || base == uint32(1) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uint64(0) } for { @@ -27284,7 +27284,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__shgetc(tls, f) } @@ -27304,7 +27304,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27315,7 +27315,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27325,12 +27325,12 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } c = v1 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) >= int32(16) { + if Int32FromUint8(**(**uint8)(__ccgo_up(val + uintptr(c)))) >= int32(16) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } @@ -27353,12 +27353,12 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint if base == uint32(0) { base = uint32(10) } - if uint32(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) >= base { + if uint32(**(**uint8)(__ccgo_up(val + uintptr(c)))) >= base { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } X__shlim(tls, f, int64(Int32FromInt32(0))) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uint64(0) } } @@ -27376,7 +27376,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27395,7 +27395,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27406,13 +27406,13 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint } } else { if !(base&(base-Uint32FromInt32(1)) != 0) { - bs = int32(*(*int8)(unsafe.Pointer(__ccgo_ts + 326 + uintptr(uint32(0x17)*base>>int32(5)&uint32(7))))) + bs = int32(**(**int8)(__ccgo_up(__ccgo_ts + 326 + uintptr(uint32(0x17)*base>>int32(5)&uint32(7))))) x = uint32(0) for { - if !(uint32(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) < base && x <= Uint32FromUint32(0xffffffff)/Uint32FromInt32(32)) { + if !(uint32(**(**uint8)(__ccgo_up(val + uintptr(c)))) < base && x <= Uint32FromUint32(0xffffffff)/Uint32FromInt32(32)) { break } - x = x<>bs) { + if !(uint32(**(**uint8)(__ccgo_up(val + uintptr(c)))) < base && y <= (Uint64FromUint64(2)*Uint64FromInt64(0x7fffffffffffffff)+Uint64FromInt32(1))>>bs) { break } - y = y<= lim { if !(lim&Uint64FromInt32(1) != 0) && !(neg != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return lim - uint64(1) } else { if y > lim { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return lim } } @@ -27539,8 +27539,8 @@ func X__procfdname(tls *TLS, buf uintptr, fd uint32) { _, _, _, _ = i, j, v2, v5 i = uint32(0) for { - v2 = *(*int8)(unsafe.Pointer(__ccgo_ts + 335 + uintptr(i))) - *(*int8)(unsafe.Pointer(buf + uintptr(i))) = v2 + v2 = **(**int8)(__ccgo_up(__ccgo_ts + 335 + uintptr(i))) + **(**int8)(__ccgo_up(buf + uintptr(i))) = v2 if !(v2 != 0) { break } @@ -27550,8 +27550,8 @@ func X__procfdname(tls *TLS, buf uintptr, fd uint32) { i = i + 1 } if !(fd != 0) { - *(*int8)(unsafe.Pointer(buf + uintptr(i))) = int8('0') - *(*int8)(unsafe.Pointer(buf + uintptr(i+uint32(1)))) = 0 + **(**int8)(__ccgo_up(buf + uintptr(i))) = int8('0') + **(**int8)(__ccgo_up(buf + uintptr(i+uint32(1)))) = 0 return } j = fd @@ -27565,14 +27565,14 @@ func X__procfdname(tls *TLS, buf uintptr, fd uint32) { j = j / uint32(10) i = i + 1 } - *(*int8)(unsafe.Pointer(buf + uintptr(i))) = 0 + **(**int8)(__ccgo_up(buf + uintptr(i))) = 0 for { if !(fd != 0) { break } i = i - 1 v5 = i - *(*int8)(unsafe.Pointer(buf + uintptr(v5))) = Int8FromUint32(uint32('0') + fd%uint32(10)) + **(**int8)(__ccgo_up(buf + uintptr(v5))) = Int8FromUint32(uint32('0') + fd%uint32(10)) goto _4 _4: ; @@ -27627,7 +27627,7 @@ func X__shgetc(tls *TLS, f uintptr) (r int32) { } (*TFILE)(unsafe.Pointer(f)).Fshcnt = int64((*TFILE)(unsafe.Pointer(f)).Fbuf) - int64((*TFILE)(unsafe.Pointer(f)).Frpos) + cnt if (*TFILE)(unsafe.Pointer(f)).Frpos <= (*TFILE)(unsafe.Pointer(f)).Fbuf { - *(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos + uintptr(-Int32FromInt32(1)))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos + uintptr(-Int32FromInt32(1)))) = Uint8FromInt32(c) } return c } @@ -27638,7 +27638,7 @@ func X__syscall_ret(tls *TLS, r uint64) (r1 int64) { defer func() { trc("-> %v", r1) }() } if r > -Uint64FromUint64(4096) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = Int32FromUint64(-r) + **(**int32)(__ccgo_up(X__errno_location(tls))) = Int32FromUint64(-r) return int64(-int32(1)) } return Int64FromUint64(r) @@ -27713,7 +27713,7 @@ func Xftok(tls *TLS, path uintptr, id int32) (r Tkey_t) { if Xstat(tls, path, bp) < 0 { return -int32(1) } - return Int32FromUint64((*(*Tstat)(unsafe.Pointer(bp))).Fst_ino&Uint64FromInt32(0xffff) | (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev&Uint64FromInt32(0xff)< int64(1000) || (*Ttimeval)(unsafe.Pointer(in)).Ftv_usec > int64(1000000000) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } - (*(*Ttimex)(unsafe.Pointer(bp))).Foffset = (*Ttimeval)(unsafe.Pointer(in)).Ftv_sec*int64(1000000) + (*Ttimeval)(unsafe.Pointer(in)).Ftv_usec - (*(*Ttimex)(unsafe.Pointer(bp))).Fmodes = uint32(ADJ_OFFSET_SINGLESHOT) + (**(**Ttimex)(__ccgo_up(bp))).Foffset = (*Ttimeval)(unsafe.Pointer(in)).Ftv_sec*int64(1000000) + (*Ttimeval)(unsafe.Pointer(in)).Ftv_usec + (**(**Ttimex)(__ccgo_up(bp))).Fmodes = uint32(ADJ_OFFSET_SINGLESHOT) } if Xadjtimex(tls, bp) < 0 { return -int32(1) } if out != 0 { - (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec = (*(*Ttimex)(unsafe.Pointer(bp))).Foffset / int64(1000000) - v1 = (*(*Ttimex)(unsafe.Pointer(bp))).Foffset % Int64FromInt32(1000000) + (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec = (**(**Ttimex)(__ccgo_up(bp))).Foffset / int64(1000000) + v1 = (**(**Ttimex)(__ccgo_up(bp))).Foffset % Int64FromInt32(1000000) (*Ttimeval)(unsafe.Pointer(out)).Ftv_usec = v1 if v1 < 0 { (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec = (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec - 1 - *(*Tsuseconds_t)(unsafe.Pointer(out + 8)) += int64(1000000) + **(**Tsuseconds_t)(__ccgo_up(out + 8)) += int64(1000000) } } return 0 @@ -29168,7 +29168,7 @@ func Xclock_adjtime(tls *TLS, clock_id Tclockid_t, utx uintptr) (r1 int32) { _ = r r = -int32(ENOSYS) if uint64(8) > uint64(8) { - *(*Tktimex)(unsafe.Pointer(bp)) = Tktimex{ + **(**Tktimex)(__ccgo_up(bp)) = Tktimex{ Fmodes: (*Ttimex)(unsafe.Pointer(utx)).Fmodes, Foffset: (*Ttimex)(unsafe.Pointer(utx)).Foffset, Ffreq: (*Ttimex)(unsafe.Pointer(utx)).Ffreq, @@ -29197,27 +29197,27 @@ func Xclock_adjtime(tls *TLS, clock_id Tclockid_t, utx uintptr) (r1 int32) { r = int32(X__syscall2(tls, int64(SYS_clock_adjtime), int64(clock_id), int64(bp))) } if r >= 0 { - (*Ttimex)(unsafe.Pointer(utx)).Fmodes = (*(*Tktimex)(unsafe.Pointer(bp))).Fmodes - (*Ttimex)(unsafe.Pointer(utx)).Foffset = (*(*Tktimex)(unsafe.Pointer(bp))).Foffset - (*Ttimex)(unsafe.Pointer(utx)).Ffreq = (*(*Tktimex)(unsafe.Pointer(bp))).Ffreq - (*Ttimex)(unsafe.Pointer(utx)).Fmaxerror = (*(*Tktimex)(unsafe.Pointer(bp))).Fmaxerror - (*Ttimex)(unsafe.Pointer(utx)).Festerror = (*(*Tktimex)(unsafe.Pointer(bp))).Festerror - (*Ttimex)(unsafe.Pointer(utx)).Fstatus = (*(*Tktimex)(unsafe.Pointer(bp))).Fstatus - (*Ttimex)(unsafe.Pointer(utx)).Fconstant = (*(*Tktimex)(unsafe.Pointer(bp))).Fconstant - (*Ttimex)(unsafe.Pointer(utx)).Fprecision = (*(*Tktimex)(unsafe.Pointer(bp))).Fprecision - (*Ttimex)(unsafe.Pointer(utx)).Ftolerance = (*(*Tktimex)(unsafe.Pointer(bp))).Ftolerance - (*Ttimex)(unsafe.Pointer(utx)).Ftime.Ftv_sec = (*(*Tktimex)(unsafe.Pointer(bp))).Ftime_sec - (*Ttimex)(unsafe.Pointer(utx)).Ftime.Ftv_usec = (*(*Tktimex)(unsafe.Pointer(bp))).Ftime_usec - (*Ttimex)(unsafe.Pointer(utx)).Ftick = (*(*Tktimex)(unsafe.Pointer(bp))).Ftick - (*Ttimex)(unsafe.Pointer(utx)).Fppsfreq = (*(*Tktimex)(unsafe.Pointer(bp))).Fppsfreq - (*Ttimex)(unsafe.Pointer(utx)).Fjitter = (*(*Tktimex)(unsafe.Pointer(bp))).Fjitter - (*Ttimex)(unsafe.Pointer(utx)).Fshift = (*(*Tktimex)(unsafe.Pointer(bp))).Fshift - (*Ttimex)(unsafe.Pointer(utx)).Fstabil = (*(*Tktimex)(unsafe.Pointer(bp))).Fstabil - (*Ttimex)(unsafe.Pointer(utx)).Fjitcnt = (*(*Tktimex)(unsafe.Pointer(bp))).Fjitcnt - (*Ttimex)(unsafe.Pointer(utx)).Fcalcnt = (*(*Tktimex)(unsafe.Pointer(bp))).Fcalcnt - (*Ttimex)(unsafe.Pointer(utx)).Ferrcnt = (*(*Tktimex)(unsafe.Pointer(bp))).Ferrcnt - (*Ttimex)(unsafe.Pointer(utx)).Fstbcnt = (*(*Tktimex)(unsafe.Pointer(bp))).Fstbcnt - (*Ttimex)(unsafe.Pointer(utx)).Ftai = (*(*Tktimex)(unsafe.Pointer(bp))).Ftai + (*Ttimex)(unsafe.Pointer(utx)).Fmodes = (**(**Tktimex)(__ccgo_up(bp))).Fmodes + (*Ttimex)(unsafe.Pointer(utx)).Foffset = (**(**Tktimex)(__ccgo_up(bp))).Foffset + (*Ttimex)(unsafe.Pointer(utx)).Ffreq = (**(**Tktimex)(__ccgo_up(bp))).Ffreq + (*Ttimex)(unsafe.Pointer(utx)).Fmaxerror = (**(**Tktimex)(__ccgo_up(bp))).Fmaxerror + (*Ttimex)(unsafe.Pointer(utx)).Festerror = (**(**Tktimex)(__ccgo_up(bp))).Festerror + (*Ttimex)(unsafe.Pointer(utx)).Fstatus = (**(**Tktimex)(__ccgo_up(bp))).Fstatus + (*Ttimex)(unsafe.Pointer(utx)).Fconstant = (**(**Tktimex)(__ccgo_up(bp))).Fconstant + (*Ttimex)(unsafe.Pointer(utx)).Fprecision = (**(**Tktimex)(__ccgo_up(bp))).Fprecision + (*Ttimex)(unsafe.Pointer(utx)).Ftolerance = (**(**Tktimex)(__ccgo_up(bp))).Ftolerance + (*Ttimex)(unsafe.Pointer(utx)).Ftime.Ftv_sec = (**(**Tktimex)(__ccgo_up(bp))).Ftime_sec + (*Ttimex)(unsafe.Pointer(utx)).Ftime.Ftv_usec = (**(**Tktimex)(__ccgo_up(bp))).Ftime_usec + (*Ttimex)(unsafe.Pointer(utx)).Ftick = (**(**Tktimex)(__ccgo_up(bp))).Ftick + (*Ttimex)(unsafe.Pointer(utx)).Fppsfreq = (**(**Tktimex)(__ccgo_up(bp))).Fppsfreq + (*Ttimex)(unsafe.Pointer(utx)).Fjitter = (**(**Tktimex)(__ccgo_up(bp))).Fjitter + (*Ttimex)(unsafe.Pointer(utx)).Fshift = (**(**Tktimex)(__ccgo_up(bp))).Fshift + (*Ttimex)(unsafe.Pointer(utx)).Fstabil = (**(**Tktimex)(__ccgo_up(bp))).Fstabil + (*Ttimex)(unsafe.Pointer(utx)).Fjitcnt = (**(**Tktimex)(__ccgo_up(bp))).Fjitcnt + (*Ttimex)(unsafe.Pointer(utx)).Fcalcnt = (**(**Tktimex)(__ccgo_up(bp))).Fcalcnt + (*Ttimex)(unsafe.Pointer(utx)).Ferrcnt = (**(**Tktimex)(__ccgo_up(bp))).Ferrcnt + (*Ttimex)(unsafe.Pointer(utx)).Fstbcnt = (**(**Tktimex)(__ccgo_up(bp))).Fstbcnt + (*Ttimex)(unsafe.Pointer(utx)).Ftai = (**(**Tktimex)(__ccgo_up(bp))).Ftai } return int32(X__syscall_ret(tls, Uint64FromInt32(r))) } @@ -30287,12 +30287,12 @@ func Xprlimit(tls *TLS, pid Tpid_t, resource int32, new_limit uintptr, old_limit var _ /* tmp at bp+0 */ Trlimit _ = r if new_limit != 0 && Bool(^Uint64FromUint64(0) != ^Uint64FromUint64(0)) { - *(*Trlimit)(unsafe.Pointer(bp)) = *(*Trlimit)(unsafe.Pointer(new_limit)) - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur >= ^Uint64FromUint64(0) { - (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur = ^Uint64FromUint64(0) + **(**Trlimit)(__ccgo_up(bp)) = **(**Trlimit)(__ccgo_up(new_limit)) + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur >= ^Uint64FromUint64(0) { + (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur = ^Uint64FromUint64(0) } - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_max >= ^Uint64FromUint64(0) { - (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_max = ^Uint64FromUint64(0) + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_max >= ^Uint64FromUint64(0) { + (**(**Trlimit)(__ccgo_up(bp))).Frlim_max = ^Uint64FromUint64(0) } new_limit = bp } @@ -30489,7 +30489,7 @@ func Xptrace(tls *TLS, req int32, va uintptr) (r int64) { if ret < 0 || Uint32FromInt32(req)-uint32(1) >= uint32(3) { return ret } - return *(*int64)(unsafe.Pointer(bp)) + return **(**int64)(__ccgo_up(bp)) } func Xpwritev2(tls *TLS, fd int32, iov uintptr, count int32, ofs Toff_t, flags int32) (r Tssize_t) { @@ -30801,22 +30801,22 @@ func Xstatx(tls *TLS, dirfd int32, path uintptr, flags int32, mask uint32, stx u if ret != 0 { return ret } - (*Tstatx)(unsafe.Pointer(stx)).Fstx_dev_major = uint32((*(*Tstat)(unsafe.Pointer(bp))).Fst_dev>>Int32FromInt32(31)>>Int32FromInt32(1)&Uint64FromUint32(0xfffff000) | (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev>>Int32FromInt32(8)&Uint64FromInt32(0x00000fff)) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_dev_minor = uint32((*(*Tstat)(unsafe.Pointer(bp))).Fst_dev>>Int32FromInt32(12)&Uint64FromUint32(0xffffff00) | (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev&Uint64FromInt32(0x000000ff)) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_ino = (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino - (*Tstatx)(unsafe.Pointer(stx)).Fstx_mode = uint16((*(*Tstat)(unsafe.Pointer(bp))).Fst_mode) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_nlink = uint32((*(*Tstat)(unsafe.Pointer(bp))).Fst_nlink) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_uid = (*(*Tstat)(unsafe.Pointer(bp))).Fst_uid - (*Tstatx)(unsafe.Pointer(stx)).Fstx_gid = (*(*Tstat)(unsafe.Pointer(bp))).Fst_gid - (*Tstatx)(unsafe.Pointer(stx)).Fstx_size = Uint64FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_size) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_blksize = Uint32FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_blksize) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_blocks = Uint64FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_blocks) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_atime.Ftv_sec = (*(*Tstat)(unsafe.Pointer(bp))).Fst_atim.Ftv_sec - (*Tstatx)(unsafe.Pointer(stx)).Fstx_atime.Ftv_nsec = Uint32FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_atim.Ftv_nsec) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_mtime.Ftv_sec = (*(*Tstat)(unsafe.Pointer(bp))).Fst_mtim.Ftv_sec - (*Tstatx)(unsafe.Pointer(stx)).Fstx_mtime.Ftv_nsec = Uint32FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_mtim.Ftv_nsec) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_ctime.Ftv_sec = (*(*Tstat)(unsafe.Pointer(bp))).Fst_ctim.Ftv_sec - (*Tstatx)(unsafe.Pointer(stx)).Fstx_ctime.Ftv_nsec = Uint32FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_ctim.Ftv_nsec) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_dev_major = uint32((**(**Tstat)(__ccgo_up(bp))).Fst_dev>>Int32FromInt32(31)>>Int32FromInt32(1)&Uint64FromUint32(0xfffff000) | (**(**Tstat)(__ccgo_up(bp))).Fst_dev>>Int32FromInt32(8)&Uint64FromInt32(0x00000fff)) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_dev_minor = uint32((**(**Tstat)(__ccgo_up(bp))).Fst_dev>>Int32FromInt32(12)&Uint64FromUint32(0xffffff00) | (**(**Tstat)(__ccgo_up(bp))).Fst_dev&Uint64FromInt32(0x000000ff)) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_ino = (**(**Tstat)(__ccgo_up(bp))).Fst_ino + (*Tstatx)(unsafe.Pointer(stx)).Fstx_mode = uint16((**(**Tstat)(__ccgo_up(bp))).Fst_mode) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_nlink = uint32((**(**Tstat)(__ccgo_up(bp))).Fst_nlink) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_uid = (**(**Tstat)(__ccgo_up(bp))).Fst_uid + (*Tstatx)(unsafe.Pointer(stx)).Fstx_gid = (**(**Tstat)(__ccgo_up(bp))).Fst_gid + (*Tstatx)(unsafe.Pointer(stx)).Fstx_size = Uint64FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_size) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_blksize = Uint32FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_blksize) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_blocks = Uint64FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_blocks) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_atime.Ftv_sec = (**(**Tstat)(__ccgo_up(bp))).Fst_atim.Ftv_sec + (*Tstatx)(unsafe.Pointer(stx)).Fstx_atime.Ftv_nsec = Uint32FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_atim.Ftv_nsec) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_mtime.Ftv_sec = (**(**Tstat)(__ccgo_up(bp))).Fst_mtim.Ftv_sec + (*Tstatx)(unsafe.Pointer(stx)).Fstx_mtime.Ftv_nsec = Uint32FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_mtim.Ftv_nsec) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_ctime.Ftv_sec = (**(**Tstat)(__ccgo_up(bp))).Fst_ctim.Ftv_sec + (*Tstatx)(unsafe.Pointer(stx)).Fstx_ctime.Ftv_nsec = Uint32FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_ctim.Ftv_nsec) (*Tstatx)(unsafe.Pointer(stx)).Fstx_btime = Tstatx_timestamp{} (*Tstatx)(unsafe.Pointer(stx)).Fstx_mask = uint32(0x7ff) return 0 @@ -30830,8 +30830,8 @@ func Xstime(tls *TLS, t uintptr) (r int32) { bp := tls.Alloc(16) defer tls.Free(16) var _ /* tv at bp+0 */ Ttimeval - *(*Ttimeval)(unsafe.Pointer(bp)) = Ttimeval{ - Ftv_sec: *(*Ttime_t)(unsafe.Pointer(t)), + **(**Ttimeval)(__ccgo_up(bp)) = Ttimeval{ + Ftv_sec: **(**Ttime_t)(__ccgo_up(t)), } return Xsettimeofday(tls, bp, UintptrFromInt32(0)) } @@ -31096,12 +31096,12 @@ func Xwait4(tls *TLS, pid Tpid_t, status uintptr, options int32, ru uintptr) (r1 if r > 0 && ru != 0 && Bool(uint64(8) > uint64(8)) { Xmemcpy(tls, bp, dest, Uint64FromInt32(4)*Uint64FromInt64(8)) (*Trusage)(unsafe.Pointer(ru)).Fru_utime = Ttimeval{ - Ftv_sec: (*(*[4]int64)(unsafe.Pointer(bp)))[0], - Ftv_usec: (*(*[4]int64)(unsafe.Pointer(bp)))[int32(1)], + Ftv_sec: (**(**[4]int64)(__ccgo_up(bp)))[0], + Ftv_usec: (**(**[4]int64)(__ccgo_up(bp)))[int32(1)], } (*Trusage)(unsafe.Pointer(ru)).Fru_stime = Ttimeval{ - Ftv_sec: (*(*[4]int64)(unsafe.Pointer(bp)))[int32(2)], - Ftv_usec: (*(*[4]int64)(unsafe.Pointer(bp)))[int32(3)], + Ftv_sec: (**(**[4]int64)(__ccgo_up(bp)))[int32(2)], + Ftv_usec: (**(**[4]int64)(__ccgo_up(bp)))[int32(3)], } } return int32(X__syscall_ret(tls, Uint64FromInt32(r))) @@ -31224,7 +31224,7 @@ func X__lctrans_cur(tls *TLS, msg uintptr) (r uintptr) { trc("tls=%v msg=%v, (%v:)", tls, msg, origin(2)) defer func() { trc("-> %v", r) }() } - return X__lctrans_impl(tls, msg, *(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale + 5*8))) + return X__lctrans_impl(tls, msg, **(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale + 5*8))) } func _swapc(tls *TLS, x Tuint32_t, c int32) (r Tuint32_t) { @@ -31248,27 +31248,27 @@ func X__mo_lookup(tls *TLS, p uintptr, size Tsize_t, s uintptr) (r uintptr) { var sign, sw int32 _, _, _, _, _, _, _, _, _, _, _ = b, mo, n, o, ol, os, sign, sw, t, tl, ts mo = p - sw = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(mo)) - uint32(0x950412de)) + sw = Int32FromUint32(**(**Tuint32_t)(__ccgo_up(mo)) - uint32(0x950412de)) b = uint32(0) - n = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + 2*4)), sw) - o = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + 3*4)), sw) - t = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + 4*4)), sw) + n = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + 2*4)), sw) + o = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + 3*4)), sw) + t = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + 4*4)), sw) if uint64(n) >= size/uint64(4) || uint64(o) >= size-uint64(uint32(4)*n) || uint64(t) >= size-uint64(uint32(4)*n) || (o|t)%uint32(4) != 0 { return uintptr(0) } o = o / uint32(4) t = t / uint32(4) for { - ol = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + uintptr(o+uint32(2)*(b+n/uint32(2)))*4)), sw) - os = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + uintptr(o+uint32(2)*(b+n/uint32(2))+uint32(1))*4)), sw) - if uint64(os) >= size || uint64(ol) >= size-uint64(os) || *(*int8)(unsafe.Pointer(p + uintptr(os+ol))) != 0 { + ol = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + uintptr(o+uint32(2)*(b+n/uint32(2)))*4)), sw) + os = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + uintptr(o+uint32(2)*(b+n/uint32(2))+uint32(1))*4)), sw) + if uint64(os) >= size || uint64(ol) >= size-uint64(os) || **(**int8)(__ccgo_up(p + uintptr(os+ol))) != 0 { return uintptr(0) } sign = Xstrcmp(tls, s, p+uintptr(os)) if !(sign != 0) { - tl = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + uintptr(t+uint32(2)*(b+n/uint32(2)))*4)), sw) - ts = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + uintptr(t+uint32(2)*(b+n/uint32(2))+uint32(1))*4)), sw) - if uint64(ts) >= size || uint64(tl) >= size-uint64(ts) || *(*int8)(unsafe.Pointer(p + uintptr(ts+tl))) != 0 { + tl = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + uintptr(t+uint32(2)*(b+n/uint32(2)))*4)), sw) + ts = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + uintptr(t+uint32(2)*(b+n/uint32(2))+uint32(1))*4)), sw) + if uint64(ts) >= size || uint64(tl) >= size-uint64(ts) || **(**int8)(__ccgo_up(p + uintptr(ts+tl))) != 0 { return uintptr(0) } return p + uintptr(ts) @@ -31298,7 +31298,7 @@ func Xbind_textdomain_codeset(tls *TLS, domainname uintptr, codeset uintptr) (r defer func() { trc("-> %v", r) }() } if codeset != 0 && Xstrcasecmp(tls, codeset, __ccgo_ts+388) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) } return UintptrFromInt32(0) } @@ -31326,7 +31326,7 @@ func Xcatclose(tls *TLS, catd Tnl_catd) (r int32) { var v1, v2 Tuint32_t _, _, _ = map1, v1, v2 map1 = catd - v1 = *(*Tuint32_t)(unsafe.Pointer(map1 + UintptrFromInt32(8))) + v1 = **(**Tuint32_t)(__ccgo_up(map1 + UintptrFromInt32(8))) v2 = v1>>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v4>>int32(8)&uint32(0xff00) | v4<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v4>>int32(8)&uint32(0xff00) | v4<>int32(24) | v7>>int32(8)&uint32(0xff00) | v7<>int32(24) | v10>>int32(8)&uint32(0xff00) | v10<>int32(24) | v13>>int32(8)&uint32(0xff00) | v13<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v4>>int32(8)&uint32(0xff00) | v4<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v5>>int32(8)&uint32(0xff00) | v5< uint64(NAME_MAX) || dirlen >= uint64(PATH_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } ___lock(tls, uintptr(unsafe.Pointer(&_lock1))) @@ -31805,7 +31805,7 @@ func Xdcngettext(tls *TLS, domainname uintptr, msgid1 uintptr, msgid2 uintptr, n _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = alt_modlen, catlen, catname, csp, dirlen, dirname, domlen, l, lm, loc, loclen, locname, locp, map1, modlen, modname, name, np, old_cats, old_errno, p1, plural, q, r, rem, rule, trans, v11, v12, v21, v3, v5, v6, v8 defer func() { Xrealloc(tls, name, 0) }() loc = (*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale - old_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + old_errno = **(**int32)(__ccgo_up(X__errno_location(tls))) /* match gnu gettext behaviour */ if !(msgid1 != 0) { goto notrans @@ -31836,14 +31836,14 @@ func Xdcngettext(tls *TLS, domainname uintptr, msgid1 uintptr, msgid2 uintptr, n if !(q != 0) { goto notrans } - lm = *(*uintptr)(unsafe.Pointer(loc + uintptr(category)*8)) + lm = **(**uintptr)(__ccgo_up(loc + uintptr(category)*8)) if !!(lm != 0) { goto _2 } goto notrans notrans: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = old_errno + **(**int32)(__ccgo_up(X__errno_location(tls))) = old_errno if n == uint64(1) { v3 = msgid1 } else { @@ -31916,21 +31916,21 @@ _2: } p1 = Xcalloc(tls, uint64(64), uint64(1)) if !(p1 != 0) { - X__munmap(tls, map1, *(*Tsize_t)(unsafe.Pointer(bp))) + X__munmap(tls, map1, **(**Tsize_t)(__ccgo_up(bp))) goto notrans } (*Tmsgcat)(unsafe.Pointer(p1)).Fcat = category (*Tmsgcat)(unsafe.Pointer(p1)).Fbinding = q (*Tmsgcat)(unsafe.Pointer(p1)).Flm = lm (*Tmsgcat)(unsafe.Pointer(p1)).Fmap1 = map1 - (*Tmsgcat)(unsafe.Pointer(p1)).Fmap_size = *(*Tsize_t)(unsafe.Pointer(bp)) + (*Tmsgcat)(unsafe.Pointer(p1)).Fmap_size = **(**Tsize_t)(__ccgo_up(bp)) rule = __ccgo_ts + 462 np = uint64(2) r = X__mo_lookup(tls, (*Tmsgcat)(unsafe.Pointer(p1)).Fmap1, (*Tmsgcat)(unsafe.Pointer(p1)).Fmap_size, __ccgo_ts) for r != 0 && Xstrncmp(tls, r, __ccgo_ts+468, uint64(13)) != 0 { - *(*uintptr)(unsafe.Pointer(bp + 8)) = Xstrchr(tls, r, int32('\n')) - if *(*uintptr)(unsafe.Pointer(bp + 8)) != 0 { - v3 = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(1) + **(**uintptr)(__ccgo_up(bp + 8)) = Xstrchr(tls, r, int32('\n')) + if **(**uintptr)(__ccgo_up(bp + 8)) != 0 { + v3 = **(**uintptr)(__ccgo_up(bp + 8)) + uintptr(1) } else { v3 = uintptr(0) } @@ -31939,7 +31939,7 @@ _2: if r != 0 { r = r + uintptr(13) for { - v11 = int32(*(*int8)(unsafe.Pointer(r))) + v11 = int32(**(**int8)(__ccgo_up(r))) v12 = BoolInt32(v11 == int32(' ') || Uint32FromInt32(v11)-uint32('\t') < uint32(5)) goto _13 _13: @@ -31950,15 +31950,15 @@ _2: } if !(Xstrncmp(tls, r, __ccgo_ts+482, uint64(9)) != 0) { np = Xstrtoul(tls, r+uintptr(9), bp+8, int32(10)) - r = *(*uintptr)(unsafe.Pointer(bp + 8)) + r = **(**uintptr)(__ccgo_up(bp + 8)) } - for *(*int8)(unsafe.Pointer(r)) != 0 && int32(*(*int8)(unsafe.Pointer(r))) != int32(';') { + for **(**int8)(__ccgo_up(r)) != 0 && int32(**(**int8)(__ccgo_up(r))) != int32(';') { r = r + 1 } - if *(*int8)(unsafe.Pointer(r)) != 0 { + if **(**int8)(__ccgo_up(r)) != 0 { r = r + 1 for { - v11 = int32(*(*int8)(unsafe.Pointer(r))) + v11 = int32(**(**int8)(__ccgo_up(r))) v12 = BoolInt32(v11 == int32(' ') || Uint32FromInt32(v11)-uint32('\t') < uint32(5)) goto _16 _16: @@ -32020,7 +32020,7 @@ _2: trans = trans + uintptr(l+uint64(1)) } } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = old_errno + **(**int32)(__ccgo_up(X__errno_location(tls))) = old_errno return trans } @@ -32064,7 +32064,7 @@ func X__duplocale(tls *TLS, old Tlocale_t) (r Tlocale_t) { if old == uintptr(-Int32FromInt32(1)) { old = uintptr(unsafe.Pointer(&X__libc)) + 56 } - *(*t__locale_struct)(unsafe.Pointer(new1)) = *(*t__locale_struct)(unsafe.Pointer(old)) + **(**t__locale_struct)(__ccgo_up(new1)) = **(**t__locale_struct)(__ccgo_up(old)) return new1 } @@ -98238,13 +98238,13 @@ var _rev_jis = [6879]uint16{ func _fuzzycmp(tls *TLS, a uintptr, b uintptr) (r int32) { for { - if !(*(*uint8)(unsafe.Pointer(a)) != 0 && *(*uint8)(unsafe.Pointer(b)) != 0) { + if !(**(**uint8)(__ccgo_up(a)) != 0 && **(**uint8)(__ccgo_up(b)) != 0) { break } - for *(*uint8)(unsafe.Pointer(a)) != 0 && uint32(*(*uint8)(unsafe.Pointer(a)))|uint32(32)-uint32('a') > uint32(26) && Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(a)))-int32('0')) > uint32(10) { + for **(**uint8)(__ccgo_up(a)) != 0 && uint32(**(**uint8)(__ccgo_up(a)))|uint32(32)-uint32('a') > uint32(26) && Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(a)))-int32('0')) > uint32(10) { a = a + 1 } - if uint32(*(*uint8)(unsafe.Pointer(a)))|uint32(32) != uint32(*(*uint8)(unsafe.Pointer(b))) { + if uint32(**(**uint8)(__ccgo_up(a)))|uint32(32) != uint32(**(**uint8)(__ccgo_up(b))) { return int32(1) } goto _1 @@ -98253,23 +98253,23 @@ func _fuzzycmp(tls *TLS, a uintptr, b uintptr) (r int32) { a = a + 1 b = b + 1 } - return BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(a))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(b)))) + return BoolInt32(Int32FromUint8(**(**uint8)(__ccgo_up(a))) != Int32FromUint8(**(**uint8)(__ccgo_up(b)))) } func _find_charmap(tls *TLS, name uintptr) (r Tsize_t) { var s uintptr _ = s - if !(*(*int8)(unsafe.Pointer(name)) != 0) { + if !(**(**int8)(__ccgo_up(name)) != 0) { name = uintptr(unsafe.Pointer(&_charmaps)) } /* "utf8" */ s = uintptr(unsafe.Pointer(&_charmaps)) for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { break } if !(_fuzzycmp(tls, name, s) != 0) { for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { break } goto _2 @@ -98280,11 +98280,11 @@ func _find_charmap(tls *TLS, name uintptr) (r Tsize_t) { return Uint64FromInt64(int64(s+uintptr(1)) - t__predefined_ptrdiff_t(uintptr(unsafe.Pointer(&_charmaps)))) } s = s + uintptr(_strlen(tls, s)+uint64(1)) - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) > int32(0200) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { + if Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) > int32(0200) { s = s + uintptr(2) } else { - s = s + uintptr(uint32(2)+(uint32(64)-uint32(*(*uint8)(unsafe.Pointer(s + 1))))*uint32(5)) + s = s + uintptr(uint32(2)+(uint32(64)-uint32(**(**uint8)(__ccgo_up(s + 1))))*uint32(5)) } } goto _1 @@ -98327,7 +98327,7 @@ func Xiconv_open(tls *TLS, to uintptr, from uintptr) (r Ticonv_t) { f = v2 } if v3 || v2 == Uint64FromInt32(-Int32FromInt32(1)) || Int32FromUint8(_charmaps[t]) >= int32(0330) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(-Int32FromInt32(1)) } cd = _combine_to_from(tls, t, f) @@ -98352,26 +98352,26 @@ func Xiconv_open(tls *TLS, to uintptr, from uintptr) (r Ticonv_t) { func _get_16(tls *TLS, s uintptr, e int32) (r uint32) { e = e & int32(1) - return Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(e))))<> int32(8)) - *(*uint8)(unsafe.Pointer(s + uintptr(int32(1)-e))) = uint8(c) + **(**uint8)(__ccgo_up(s + uintptr(e))) = uint8(c >> int32(8)) + **(**uint8)(__ccgo_up(s + uintptr(int32(1)-e))) = uint8(c) } func _get_32(tls *TLS, s uintptr, e int32) (r uint32) { e = e & int32(3) - return (uint32(*(*uint8)(unsafe.Pointer(s + uintptr(e))))+0)<> int32(24)) - *(*uint8)(unsafe.Pointer(s + uintptr(e^int32(1)))) = uint8(c >> int32(16)) - *(*uint8)(unsafe.Pointer(s + uintptr(e^int32(2)))) = uint8(c >> int32(8)) - *(*uint8)(unsafe.Pointer(s + uintptr(e^int32(3)))) = uint8(c) + **(**uint8)(__ccgo_up(s + uintptr(e^0))) = uint8(c >> int32(24)) + **(**uint8)(__ccgo_up(s + uintptr(e^int32(1)))) = uint8(c >> int32(16)) + **(**uint8)(__ccgo_up(s + uintptr(e^int32(2)))) = uint8(c >> int32(8)) + **(**uint8)(__ccgo_up(s + uintptr(e^int32(3)))) = uint8(c) } /* Adapt as needed */ @@ -98379,11 +98379,11 @@ func _put_32(tls *TLS, s uintptr, c uint32, e int32) { func _legacy_map(tls *TLS, map1 uintptr, c uint32) (r uint32) { var x, v1 uint32 _, _ = x, v1 - if c < Uint32FromInt32(int32(4)*Int32FromUint8(*(*uint8)(unsafe.Pointer(map1 + uintptr(-Int32FromInt32(1)))))) { + if c < Uint32FromInt32(int32(4)*Int32FromUint8(**(**uint8)(__ccgo_up(map1 + uintptr(-Int32FromInt32(1)))))) { return c } - x = c - Uint32FromInt32(int32(4)*Int32FromUint8(*(*uint8)(unsafe.Pointer(map1 + uintptr(-Int32FromInt32(1)))))) - x = Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(map1 + uintptr(x*uint32(5)/uint32(4)))))>>(uint32(2)*x%uint32(8)) | Int32FromUint8(*(*uint8)(unsafe.Pointer(map1 + uintptr(x*uint32(5)/uint32(4)+uint32(1)))))<<(uint32(8)-uint32(2)*x%uint32(8))&int32(1023)) + x = c - Uint32FromInt32(int32(4)*Int32FromUint8(**(**uint8)(__ccgo_up(map1 + uintptr(-Int32FromInt32(1)))))) + x = Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(map1 + uintptr(x*uint32(5)/uint32(4)))))>>(uint32(2)*x%uint32(8)) | Int32FromUint8(**(**uint8)(__ccgo_up(map1 + uintptr(x*uint32(5)/uint32(4)+uint32(1)))))<<(uint32(8)-uint32(2)*x%uint32(8))&int32(1023)) if x < uint32(256) { v1 = x } else { @@ -98400,7 +98400,7 @@ func _uni_to_jis(tls *TLS, c uint32) (r uint32) { for { i = nel / uint32(2) j = uint32(_rev_jis[b+i]) - d = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(j/uint32(256))*188 + uintptr(j%uint32(256))*2))) + d = uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(j/uint32(256))*188 + uintptr(j%uint32(256))*2))) if d == c { return j + uint32(0x2121) } else { @@ -98453,20 +98453,20 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui from = uint32(_extract_from(tls, cd)) map1 = uintptr(unsafe.Pointer(&_charmaps)) + uintptr(from) + uintptr(1) tomap = uintptr(unsafe.Pointer(&_charmaps)) + uintptr(to) + uintptr(1) - *(*Tmbstate_t)(unsafe.Pointer(bp + 24)) = Tmbstate_t{} - type1 = *(*uint8)(unsafe.Pointer(map1 + uintptr(-Int32FromInt32(1)))) - totype = *(*uint8)(unsafe.Pointer(tomap + uintptr(-Int32FromInt32(1)))) + **(**Tmbstate_t)(__ccgo_up(bp + 24)) = Tmbstate_t{} + type1 = **(**uint8)(__ccgo_up(map1 + uintptr(-Int32FromInt32(1)))) + totype = **(**uint8)(__ccgo_up(tomap + uintptr(-Int32FromInt32(1)))) ploc = uintptr(___get_tp(tls)) + 168 - loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) - if !(in != 0) || !(*(*uintptr)(unsafe.Pointer(in)) != 0) || !(*(*Tsize_t)(unsafe.Pointer(inb)) != 0) { + loc = **(**Tlocale_t)(__ccgo_up(ploc)) + if !(in != 0) || !(**(**uintptr)(__ccgo_up(in)) != 0) || !(**(**Tsize_t)(__ccgo_up(inb)) != 0) { return uint64(0) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = uintptr(unsafe.Pointer(&X__c_dot_utf8_locale)) + **(**Tlocale_t)(__ccgo_up(ploc)) = uintptr(unsafe.Pointer(&X__c_dot_utf8_locale)) for { - if !(*(*Tsize_t)(unsafe.Pointer(inb)) != 0) { + if !(**(**Tsize_t)(__ccgo_up(inb)) != 0) { break } - c = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in))))) + c = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in))))) l = uint64(1) switch Int32FromUint8(type1) { case int32(UTF_8): @@ -98518,14 +98518,14 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if c < uint32(128) { goto _23 } - l = Xmbrtowc(tls, bp+32, *(*uintptr)(unsafe.Pointer(in)), *(*Tsize_t)(unsafe.Pointer(inb)), bp+24) + l = Xmbrtowc(tls, bp+32, **(**uintptr)(__ccgo_up(in)), **(**Tsize_t)(__ccgo_up(inb)), bp+24) if l == Uint64FromInt32(-Int32FromInt32(1)) { goto ilseq } if l == Uint64FromInt32(-Int32FromInt32(2)) { goto starved } - c = Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp + 32))) + c = Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp + 32))) goto _23 _3: ; @@ -98536,10 +98536,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui _4: ; l = uint64(4) - if *(*Tsize_t)(unsafe.Pointer(inb)) < l { + if **(**Tsize_t)(__ccgo_up(inb)) < l { goto starved } - c = Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in))))) + c = Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(in))))) if !(0 != 0) { goto _24 } @@ -98548,10 +98548,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui _5: ; l = uint64(4) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(4) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(4) { goto starved } - c = _get_32(tls, *(*uintptr)(unsafe.Pointer(in)), Int32FromUint8(type1)) + c = _get_32(tls, **(**uintptr)(__ccgo_up(in)), Int32FromUint8(type1)) _24: ; if c-uint32(0xd800) < uint32(0x800) || c >= uint32(0x110000) { @@ -98567,10 +98567,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui _7: ; l = uint64(2) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(2) { goto starved } - c = _get_16(tls, *(*uintptr)(unsafe.Pointer(in)), Int32FromUint8(type1)) + c = _get_16(tls, **(**uintptr)(__ccgo_up(in)), Int32FromUint8(type1)) if c-Uint32FromInt32(0xdc00) < uint32(0x400) { goto ilseq } @@ -98579,10 +98579,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto ilseq } l = uint64(4) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(4) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(4) { goto starved } - d = _get_16(tls, *(*uintptr)(unsafe.Pointer(in))+UintptrFromInt32(2), Int32FromUint8(type1)) + d = _get_16(tls, **(**uintptr)(__ccgo_up(in))+UintptrFromInt32(2), Int32FromUint8(type1)) if d-Uint32FromInt32(0xdc00) >= uint32(0x400) { goto ilseq } @@ -98595,10 +98595,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui ; l = uint64(0) if !((*Tstateful_cd)(unsafe.Pointer(scd)).Fstate != 0) { - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(2) { goto starved } - c = _get_16(tls, *(*uintptr)(unsafe.Pointer(in)), 0) + c = _get_16(tls, **(**uintptr)(__ccgo_up(in)), 0) if Int32FromUint8(type1) == int32(UCS2) { if c == uint32(0xfffe) { v26 = int32(UCS2LE) @@ -98625,10 +98625,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui ; l = uint64(0) if !((*Tstateful_cd)(unsafe.Pointer(scd)).Fstate != 0) { - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(4) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(4) { goto starved } - c = _get_32(tls, *(*uintptr)(unsafe.Pointer(in)), 0) + c = _get_32(tls, **(**uintptr)(__ccgo_up(in)), 0) if c == uint32(0xfffe0000) { v25 = int32(UTF_32LE) } else { @@ -98651,10 +98651,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _23 } l = uint64(2) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(2) { goto starved } - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(1)))) if c-uint32(129) <= Uint32FromInt32(Int32FromInt32(159)-Int32FromInt32(129)) { c = c - uint32(129) } else { @@ -98682,7 +98682,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if c >= uint32(84) { goto ilseq } - c = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(c)*188 + uintptr(d)*2))) + c = uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(c)*188 + uintptr(d)*2))) if !(c != 0) { goto ilseq } @@ -98693,10 +98693,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _23 } l = uint64(2) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(2) { goto starved } - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(1)))) if c == uint32(0x8e) { c = d if c-uint32(0xa1) > Uint32FromInt32(Int32FromInt32(0xdf)-Int32FromInt32(0xa1)) { @@ -98710,7 +98710,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if c >= uint32(84) || d >= uint32(94) { goto ilseq } - c = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(c)*188 + uintptr(d)*2))) + c = uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(c)*188 + uintptr(d)*2))) if !(c != 0) { goto ilseq } @@ -98722,11 +98722,11 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } if c == uint32('\033') { l = uint64(3) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(3) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(3) { goto starved } - c = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(2)))) + c = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(1)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(2)))) if c != uint32('(') && c != uint32('$') { goto ilseq } @@ -98761,16 +98761,16 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui fallthrough case uint32(3): l = uint64(2) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(2) { goto starved } - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(1)))) c = c - uint32(0x21) d = d - uint32(0x21) if c >= uint32(84) || d >= uint32(94) { goto ilseq } - c = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(c)*188 + uintptr(d)*2))) + c = uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(c)*188 + uintptr(d)*2))) if !(c != 0) { goto ilseq } @@ -98808,10 +98808,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto ilseq } l = uint64(2) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(2) { goto starved } - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(1)))) if d < uint32(0xa1) && Int32FromUint8(type1) == int32(GB2312) { goto ilseq } @@ -98820,16 +98820,16 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto ilseq } l = uint64(4) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(4) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(4) { goto starved } c = (uint32(10)*c + d - uint32('0')) * uint32(1260) - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(2)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(2)))) if d-uint32(0x81) > uint32(126) { goto ilseq } c = c + uint32(10)*(d-uint32(0x81)) - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(3)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(3)))) if d-uint32('0') > uint32(9) { goto ilseq } @@ -98851,7 +98851,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if !(j < int32(190)) { break } - if uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_gb18030)) + uintptr(i)*380 + uintptr(j)*2)))-d <= c-d { + if uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_gb18030)) + uintptr(i)*380 + uintptr(j)*2)))-d <= c-d { k = k + 1 } goto _31 @@ -98875,7 +98875,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if d > uint32(63) { d = d - 1 } - c = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_gb18030)) + uintptr(c)*380 + uintptr(d)*2))) + c = uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_gb18030)) + uintptr(c)*380 + uintptr(d)*2))) goto _23 _20: ; @@ -98883,10 +98883,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _23 } l = uint64(2) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(2) { goto starved } - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(1)))) if d-uint32(0x40) >= Uint32FromInt32(Int32FromInt32(0xff)-Int32FromInt32(0x40)) || d-uint32(0x7f) < Uint32FromInt32(Int32FromInt32(0xa1)-Int32FromInt32(0x7f)) { goto ilseq } @@ -98909,21 +98909,21 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui * range in the hkscs table then hard-coded * here. Ugly, yes. */ if c/uint32(256) == uint32(0xdc) { - *(*uintptr)(unsafe.Pointer(bp + 48)) = bp + 40 + **(**uintptr)(__ccgo_up(bp + 48)) = bp + 40 *(*uintptr)(unsafe.Pointer(bp)) = __ccgo_ts + 511 + uintptr(c%uint32(256)) *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint64(4) *(*Tsize_t)(unsafe.Pointer(bp + 16)) = uint64(8) tmpx = Xiconv(tls, _combine_to_from(tls, uint64(to), _find_charmap(tls, __ccgo_ts+528)), bp, bp+8, bp+48, bp+16) - tmplen = Uint64FromInt64(int64(*(*uintptr)(unsafe.Pointer(bp + 48))) - t__predefined_ptrdiff_t(bp+40)) - if tmplen > *(*Tsize_t)(unsafe.Pointer(outb)) { + tmplen = Uint64FromInt64(int64(**(**uintptr)(__ccgo_up(bp + 48))) - t__predefined_ptrdiff_t(bp+40)) + if tmplen > **(**Tsize_t)(__ccgo_up(outb)) { goto toobig } if tmpx != 0 { x = x + 1 } - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(out)), bp+40, tmplen) - *(*uintptr)(unsafe.Pointer(out)) += uintptr(tmplen) - *(*Tsize_t)(unsafe.Pointer(outb)) -= tmplen + Xmemcpy(tls, **(**uintptr)(__ccgo_up(out)), bp+40, tmplen) + **(**uintptr)(__ccgo_up(out)) += uintptr(tmplen) + **(**Tsize_t)(__ccgo_up(outb)) -= tmplen goto _1 } if !(c != 0) { @@ -98932,7 +98932,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _23 } c = c - uint32(0xa1) - c = Uint32FromInt32(Int32FromUint16(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_big5)) + uintptr(c)*314 + uintptr(d)*2))) | BoolInt32(c == uint32(0x27) && (d == uint32(0x3a) || d == uint32(0x3c) || d == uint32(0x42)))<= uint32(93) || d >= uint32(94) { @@ -98990,7 +98990,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if !(j1 < int32(94)) { break } - if uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ksc)) + uintptr(i1)*188 + uintptr(j1)*2)))-d <= c-d { + if uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_ksc)) + uintptr(i1)*188 + uintptr(j1)*2)))-d <= c-d { k = k + 1 } goto _34 @@ -99010,7 +99010,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } goto _23 } - c = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ksc)) + uintptr(c)*188 + uintptr(d)*2))) + c = uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_ksc)) + uintptr(c)*188 + uintptr(d)*2))) if !(c != 0) { goto ilseq } @@ -99063,26 +99063,26 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _51 _35: ; - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(4) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(4) { goto toobig } - *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(out)))) = Int32FromUint32(c) - *(*uintptr)(unsafe.Pointer(out)) += uintptr(4) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(4) + **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(out)))) = Int32FromUint32(c) + **(**uintptr)(__ccgo_up(out)) += uintptr(4) + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(4) goto _51 _36: ; - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(4) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(4) { k = Uint64FromInt32(Xwctomb(tls, bp+56, Int32FromUint32(c))) - if *(*Tsize_t)(unsafe.Pointer(outb)) < k { + if **(**Tsize_t)(__ccgo_up(outb)) < k { goto toobig } - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(out)), bp+56, k) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(out)), bp+56, k) } else { - k = Uint64FromInt32(Xwctomb(tls, *(*uintptr)(unsafe.Pointer(out)), Int32FromUint32(c))) + k = Uint64FromInt32(Xwctomb(tls, **(**uintptr)(__ccgo_up(out)), Int32FromUint32(c))) } - *(*uintptr)(unsafe.Pointer(out)) += uintptr(k) - *(*Tsize_t)(unsafe.Pointer(outb)) -= k + **(**uintptr)(__ccgo_up(out)) += uintptr(k) + **(**Tsize_t)(__ccgo_up(outb)) -= k goto _51 _37: ; @@ -99098,7 +99098,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui ; _38: ; - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(1) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(1) { goto toobig } if !(c < uint32(256) && c == _legacy_map(tls, tomap, c)) { @@ -99107,14 +99107,14 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto revout revout: ; - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(1) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(1) { goto toobig } v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = Int8FromUint32(c) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(1) + **(**int8)(__ccgo_up(v54)) = Int8FromUint32(c) + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(1) goto _51 _53: ; @@ -99156,7 +99156,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if !(c != 0) { goto subst } - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(2) { goto toobig } d = c % uint32(256) @@ -99169,7 +99169,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } else { v25 = int32(176) } - *(*int8)(unsafe.Pointer(v54)) = Int8FromUint32((c+uint32(1))/uint32(2) + Uint32FromInt32(v25)) + **(**int8)(__ccgo_up(v54)) = Int8FromUint32((c+uint32(1))/uint32(2) + Uint32FromInt32(v25)) v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 @@ -99178,8 +99178,8 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } else { v62 = d + uint32(126) } - *(*int8)(unsafe.Pointer(v54)) = Int8FromUint32(v62) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(2) + **(**int8)(__ccgo_up(v54)) = Int8FromUint32(v62) + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(2) goto _51 _40: ; @@ -99194,18 +99194,18 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if !(c != 0) { goto subst } - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(2) { goto toobig } v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = Int8FromUint32(c/uint32(256) + uint32(0x80)) + **(**int8)(__ccgo_up(v54)) = Int8FromUint32(c/uint32(256) + uint32(0x80)) v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = Int8FromUint32(c%uint32(256) + uint32(0x80)) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(2) + **(**int8)(__ccgo_up(v54)) = Int8FromUint32(c%uint32(256) + uint32(0x80)) + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(2) goto _51 _41: ; @@ -99213,102 +99213,102 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto revout } if c-uint32(0xff61) <= Uint32FromInt32(Int32FromInt32(0xdf)-Int32FromInt32(0xa1)) || c == uint32(0xa5) || c == uint32(0x203e) { - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(7) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(7) { goto toobig } v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = int8('\033') + **(**int8)(__ccgo_up(v54)) = int8('\033') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = int8('(') + **(**int8)(__ccgo_up(v54)) = int8('(') if c == uint32(0xa5) { v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = int8('J') + **(**int8)(__ccgo_up(v54)) = int8('J') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = int8('\\') + **(**int8)(__ccgo_up(v54)) = int8('\\') } else { if c == uint32(0x203e) { v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = int8('J') + **(**int8)(__ccgo_up(v54)) = int8('J') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = int8('~') + **(**int8)(__ccgo_up(v54)) = int8('~') } else { v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = int8('I') + **(**int8)(__ccgo_up(v54)) = int8('I') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = Int8FromUint32(c - uint32(0xff61) + uint32(0x21)) + **(**int8)(__ccgo_up(v54)) = Int8FromUint32(c - uint32(0xff61) + uint32(0x21)) } } v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = int8('\033') + **(**int8)(__ccgo_up(v54)) = int8('\033') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = int8('(') + **(**int8)(__ccgo_up(v54)) = int8('(') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = int8('B') - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(7) + **(**int8)(__ccgo_up(v54)) = int8('B') + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(7) goto _51 } c = _uni_to_jis(tls, c) if !(c != 0) { goto subst } - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(8) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(8) { goto toobig } v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = int8('\033') + **(**int8)(__ccgo_up(v54)) = int8('\033') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = int8('$') + **(**int8)(__ccgo_up(v54)) = int8('$') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = int8('B') + **(**int8)(__ccgo_up(v54)) = int8('B') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = Int8FromUint32(c / uint32(256)) + **(**int8)(__ccgo_up(v54)) = Int8FromUint32(c / uint32(256)) v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = Int8FromUint32(c % uint32(256)) + **(**int8)(__ccgo_up(v54)) = Int8FromUint32(c % uint32(256)) v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = int8('\033') + **(**int8)(__ccgo_up(v54)) = int8('\033') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = int8('(') + **(**int8)(__ccgo_up(v54)) = int8('(') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = int8('B') - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(8) + **(**int8)(__ccgo_up(v54)) = int8('B') + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(8) goto _51 _42: ; @@ -99327,22 +99327,22 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if c >= uint32(0x10000) { c = uint32(0xFFFD) } - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(2) { goto toobig } - _put_16(tls, *(*uintptr)(unsafe.Pointer(out)), c, Int32FromUint8(totype)) - *(*uintptr)(unsafe.Pointer(out)) += uintptr(2) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(2) + _put_16(tls, **(**uintptr)(__ccgo_up(out)), c, Int32FromUint8(totype)) + **(**uintptr)(__ccgo_up(out)) += uintptr(2) + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(2) goto _51 } - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(4) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(4) { goto toobig } c = c - uint32(0x10000) - _put_16(tls, *(*uintptr)(unsafe.Pointer(out)), c>>int32(10)|uint32(0xd800), Int32FromUint8(totype)) - _put_16(tls, *(*uintptr)(unsafe.Pointer(out))+UintptrFromInt32(2), c&uint32(0x3ff)|uint32(0xdc00), Int32FromUint8(totype)) - *(*uintptr)(unsafe.Pointer(out)) += uintptr(4) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(4) + _put_16(tls, **(**uintptr)(__ccgo_up(out)), c>>int32(10)|uint32(0xd800), Int32FromUint8(totype)) + _put_16(tls, **(**uintptr)(__ccgo_up(out))+UintptrFromInt32(2), c&uint32(0x3ff)|uint32(0xdc00), Int32FromUint8(totype)) + **(**uintptr)(__ccgo_up(out)) += uintptr(4) + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(4) goto _51 _48: ; @@ -99351,22 +99351,22 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui ; _49: ; - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(4) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(4) { goto toobig } - _put_32(tls, *(*uintptr)(unsafe.Pointer(out)), c, Int32FromUint8(totype)) - *(*uintptr)(unsafe.Pointer(out)) += uintptr(4) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(4) + _put_32(tls, **(**uintptr)(__ccgo_up(out)), c, Int32FromUint8(totype)) + **(**uintptr)(__ccgo_up(out)) += uintptr(4) + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(4) goto _51 _51: ; goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(in)) += uintptr(l) - *(*Tsize_t)(unsafe.Pointer(inb)) -= l + **(**uintptr)(__ccgo_up(in)) += uintptr(l) + **(**Tsize_t)(__ccgo_up(inb)) -= l } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return x goto ilseq ilseq: @@ -99388,8 +99388,8 @@ starved: goto end end: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = err - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**int32)(__ccgo_up(X__errno_location(tls))) = err + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return x } @@ -99420,7 +99420,7 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { cat = item >> int32(16) idx = item & int32(65535) if item == int32(CODESET) { - if *(*uintptr)(unsafe.Pointer(loc)) != 0 { + if **(**uintptr)(__ccgo_up(loc)) != 0 { v1 = __ccgo_ts + 388 } else { v1 = __ccgo_ts + 533 @@ -99429,8 +99429,8 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { } /* _NL_LOCALE_NAME extension */ if idx == int32(65535) && cat < int32(LC_ALL) { - if *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*8)) != 0 { - v1 = *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*8)) + 16 + if **(**uintptr)(__ccgo_up(loc + uintptr(cat)*8)) != 0 { + v1 = **(**uintptr)(__ccgo_up(loc + uintptr(cat)*8)) + 16 } else { v1 = __ccgo_ts + 539 } @@ -99465,7 +99465,7 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { break } for { - if !(*(*int8)(unsafe.Pointer(str)) != 0) { + if !(**(**int8)(__ccgo_up(str)) != 0) { break } goto _4 @@ -99479,8 +99479,8 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { idx = idx - 1 str = str + 1 } - if cat != int32(LC_NUMERIC) && *(*int8)(unsafe.Pointer(str)) != 0 { - str = X__lctrans(tls, str, *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*8))) + if cat != int32(LC_NUMERIC) && **(**int8)(__ccgo_up(str)) != 0 { + str = X__lctrans(tls, str, **(**uintptr)(__ccgo_up(loc + uintptr(cat)*8))) } return str } @@ -99553,18 +99553,18 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = builtin, l, map1, n, new1, p, path, z, v1, v2, v3, v4, v5, v6, v7 new1 = uintptr(0) path = uintptr(0) - if !(*(*int8)(unsafe.Pointer(val)) != 0) { + if !(**(**int8)(__ccgo_up(val)) != 0) { v1 = Xgetenv(tls, __ccgo_ts+541) val = v1 - if v3 = v1 != 0 && *(*int8)(unsafe.Pointer(val)) != 0; !v3 { + if v3 = v1 != 0 && **(**int8)(__ccgo_up(val)) != 0; !v3 { v2 = Xgetenv(tls, uintptr(unsafe.Pointer(&_envvars))+uintptr(cat)*12) val = v2 } - if v5 = v3 || v2 != 0 && *(*int8)(unsafe.Pointer(val)) != 0; !v5 { + if v5 = v3 || v2 != 0 && **(**int8)(__ccgo_up(val)) != 0; !v5 { v4 = Xgetenv(tls, __ccgo_ts+402) val = v4 } - if v7 = v5 || v4 != 0 && *(*int8)(unsafe.Pointer(val)) != 0; !v7 { + if v7 = v5 || v4 != 0 && **(**int8)(__ccgo_up(val)) != 0; !v7 { v6 = __ccgo_ts + 548 val = v6 } @@ -99573,7 +99573,7 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { /* Limit name length and forbid leading dot or any slashes. */ n = uint64(0) for { - if !(n < uint64(LOCALE_NAME_MAX) && *(*int8)(unsafe.Pointer(val + uintptr(n))) != 0 && int32(*(*int8)(unsafe.Pointer(val + uintptr(n)))) != int32('/')) { + if !(n < uint64(LOCALE_NAME_MAX) && **(**int8)(__ccgo_up(val + uintptr(n))) != 0 && int32(**(**int8)(__ccgo_up(val + uintptr(n)))) != int32('/')) { break } goto _8 @@ -99581,12 +99581,12 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { ; n = n + 1 } - if int32(*(*int8)(unsafe.Pointer(val))) == int32('.') || *(*int8)(unsafe.Pointer(val + uintptr(n))) != 0 { + if int32(**(**int8)(__ccgo_up(val))) == int32('.') || **(**int8)(__ccgo_up(val + uintptr(n))) != 0 { val = __ccgo_ts + 548 } - builtin = BoolInt32(int32(*(*int8)(unsafe.Pointer(val))) == int32('C') && !(*(*int8)(unsafe.Pointer(val + 1)) != 0) || !(Xstrcmp(tls, val, __ccgo_ts+548) != 0) || !(Xstrcmp(tls, val, __ccgo_ts+556) != 0)) + builtin = BoolInt32(int32(**(**int8)(__ccgo_up(val))) == int32('C') && !(**(**int8)(__ccgo_up(val + 1)) != 0) || !(Xstrcmp(tls, val, __ccgo_ts+548) != 0) || !(Xstrcmp(tls, val, __ccgo_ts+556) != 0)) if builtin != 0 { - if cat == LC_CTYPE && int32(*(*int8)(unsafe.Pointer(val + 1))) == int32('.') { + if cat == LC_CTYPE && int32(**(**int8)(__ccgo_up(val + 1))) == int32('.') { return uintptr(unsafe.Pointer(&X__c_dot_utf8)) } return uintptr(0) @@ -99610,7 +99610,7 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { /* FIXME: add a default path? */ if path != 0 { for { - if !(*(*int8)(unsafe.Pointer(path)) != 0) { + if !(**(**int8)(__ccgo_up(path)) != 0) { break } z = X__strchrnul(tls, path, int32(':')) @@ -99619,20 +99619,20 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { goto _10 } Xmemcpy(tls, bp, path, l) - (*(*[256]int8)(unsafe.Pointer(bp)))[l] = int8('/') + (**(**[256]int8)(__ccgo_up(bp)))[l] = int8('/') Xmemcpy(tls, bp+uintptr(l)+uintptr(1), val, n) - (*(*[256]int8)(unsafe.Pointer(bp)))[l+uint64(1)+n] = 0 + (**(**[256]int8)(__ccgo_up(bp)))[l+uint64(1)+n] = 0 map1 = X__map_file(tls, bp, bp+256) if map1 != 0 { new1 = Xmalloc(tls, uint64(48)) if !(new1 != 0) { - X__munmap(tls, map1, *(*Tsize_t)(unsafe.Pointer(bp + 256))) + X__munmap(tls, map1, **(**Tsize_t)(__ccgo_up(bp + 256))) break } (*t__locale_map)(unsafe.Pointer(new1)).Fmap1 = map1 - (*t__locale_map)(unsafe.Pointer(new1)).Fmap_size = *(*Tsize_t)(unsafe.Pointer(bp + 256)) + (*t__locale_map)(unsafe.Pointer(new1)).Fmap_size = **(**Tsize_t)(__ccgo_up(bp + 256)) Xmemcpy(tls, new1+16, val, n) - *(*int8)(unsafe.Pointer(new1 + 16 + uintptr(n))) = 0 + **(**int8)(__ccgo_up(new1 + 16 + uintptr(n))) = 0 (*t__locale_map)(unsafe.Pointer(new1)).Fnext = AtomicLoadPUintptr(uintptr(unsafe.Pointer(&_loc_head))) AtomicStorePUintptr(uintptr(unsafe.Pointer(&_loc_head)), new1) break @@ -99640,7 +99640,7 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { goto _10 _10: ; - path = z + BoolUintptr(!!(*(*int8)(unsafe.Pointer(z)) != 0)) + path = z + BoolUintptr(!!(**(**int8)(__ccgo_up(z)) != 0)) } } /* If no locale definition was found, make a locale map @@ -99655,7 +99655,7 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { (*t__locale_map)(unsafe.Pointer(new1)).Fmap1 = X__c_dot_utf8.Fmap1 (*t__locale_map)(unsafe.Pointer(new1)).Fmap_size = X__c_dot_utf8.Fmap_size Xmemcpy(tls, new1+16, val, n) - *(*int8)(unsafe.Pointer(new1 + 16 + uintptr(n))) = 0 + **(**int8)(__ccgo_up(new1 + 16 + uintptr(n))) = 0 (*t__locale_map)(unsafe.Pointer(new1)).Fnext = AtomicLoadPUintptr(uintptr(unsafe.Pointer(&_loc_head))) AtomicStorePUintptr(uintptr(unsafe.Pointer(&_loc_head)), new1) } @@ -99739,7 +99739,7 @@ func _do_newlocale(tls *TLS, mask int32, name uintptr, loc Tlocale_t) (r Tlocale break } if !(mask&(Int32FromInt32(1)<,< are accepted with or without = */ - if i < int32(6) && int32(*(*int8)(unsafe.Pointer(s + 1))) == int32(_opch2[i]) { + if i < int32(6) && int32(**(**int8)(__ccgo_up(s + 1))) == int32(_opch2[i]) { (*Tst)(unsafe.Pointer(st)).Fop = i return s + uintptr(2) } @@ -100045,12 +100045,12 @@ func _evalexpr(tls *TLS, st uintptr, s uintptr, d int32) (r uintptr) { return __ccgo_ts } s = _evalbinop(tls, st, s, 0, d) - if int32(*(*int8)(unsafe.Pointer(s))) != int32('?') { + if int32(**(**int8)(__ccgo_up(s))) != int32('?') { return s } a = (*Tst)(unsafe.Pointer(st)).Fr s = _evalexpr(tls, st, s+uintptr(1), d) - if int32(*(*int8)(unsafe.Pointer(s))) != int32(':') { + if int32(**(**int8)(__ccgo_up(s))) != int32(':') { return __ccgo_ts } b = (*Tst)(unsafe.Pointer(st)).Fr @@ -100074,10 +100074,10 @@ func X__pleval(tls *TLS, s uintptr, n uint64) (r uint64) { var v1 uint64 var _ /* st at bp+0 */ Tst _ = v1 - (*(*Tst)(unsafe.Pointer(bp))).Fn = n + (**(**Tst)(__ccgo_up(bp))).Fn = n s = _evalexpr(tls, bp, s, int32(100)) - if int32(*(*int8)(unsafe.Pointer(s))) == int32(';') { - v1 = (*(*Tst)(unsafe.Pointer(bp))).Fr + if int32(**(**int8)(__ccgo_up(s))) == int32(';') { + v1 = (**(**Tst)(__ccgo_up(bp))).Fr } else { v1 = Uint64FromInt32(-Int32FromInt32(1)) } @@ -100110,7 +100110,7 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { * on the format, so it can easily be changed if needed. */ if cat == int32(LC_ALL) { if name != 0 { - *(*[24]int8)(unsafe.Pointer(bp + 48)) = [24]int8{'C', '.', 'U', 'T', 'F', '-', '8'} + **(**[24]int8)(__ccgo_up(bp + 48)) = [24]int8{'C', '.', 'U', 'T', 'F', '-', '8'} p = name i = 0 for { @@ -100120,8 +100120,8 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { z = X__strchrnul(tls, p, int32(';')) if int64(z)-int64(p) <= int64(LOCALE_NAME_MAX) { Xmemcpy(tls, bp+48, p, Uint64FromInt64(int64(z)-int64(p))) - (*(*[24]int8)(unsafe.Pointer(bp + 48)))[int64(z)-int64(p)] = 0 - if *(*int8)(unsafe.Pointer(z)) != 0 { + (**(**[24]int8)(__ccgo_up(bp + 48)))[int64(z)-int64(p)] = 0 + if **(**int8)(__ccgo_up(z)) != 0 { p = z + uintptr(1) } } @@ -100130,13 +100130,13 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { ___unlock(tls, uintptr(unsafe.Pointer(&X__locale_lock))) return uintptr(0) } - *(*uintptr)(unsafe.Pointer(bp + uintptr(i)*8)) = lm + **(**uintptr)(__ccgo_up(bp + uintptr(i)*8)) = lm goto _1 _1: ; i = i + 1 } - X__libc.Fglobal_locale = *(*t__locale_struct)(unsafe.Pointer(bp)) + X__libc.Fglobal_locale = **(**t__locale_struct)(__ccgo_up(bp)) } s = uintptr(unsafe.Pointer(&_buf1)) same = 0 @@ -100145,8 +100145,8 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { if !(i < int32(LC_ALL)) { break } - lm1 = *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 56 + uintptr(i)*8)) - if lm1 == *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 56)) { + lm1 = **(**uintptr)(__ccgo_up(uintptr(unsafe.Pointer(&X__libc)) + 56 + uintptr(i)*8)) + if lm1 == **(**uintptr)(__ccgo_up(uintptr(unsafe.Pointer(&X__libc)) + 56)) { same = same + 1 } if lm1 != 0 { @@ -100157,7 +100157,7 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { part1 = v3 l = _strlen(tls, part1) Xmemcpy(tls, s, part1, l) - *(*int8)(unsafe.Pointer(s + uintptr(l))) = int8(';') + **(**int8)(__ccgo_up(s + uintptr(l))) = int8(';') s = s + uintptr(l+uint64(1)) goto _2 _2: @@ -100166,7 +100166,7 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { } s = s - 1 v3 = s - *(*int8)(unsafe.Pointer(v3)) = 0 + **(**int8)(__ccgo_up(v3)) = 0 ___unlock(tls, uintptr(unsafe.Pointer(&X__locale_lock))) if same == int32(LC_ALL) { v3 = part1 @@ -100181,9 +100181,9 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { ___unlock(tls, uintptr(unsafe.Pointer(&X__locale_lock))) return uintptr(0) } - *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 56 + uintptr(cat)*8)) = lm + **(**uintptr)(__ccgo_up(uintptr(unsafe.Pointer(&X__libc)) + 56 + uintptr(cat)*8)) = lm } else { - lm = *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 56 + uintptr(cat)*8)) + lm = **(**uintptr)(__ccgo_up(uintptr(unsafe.Pointer(&X__libc)) + 56 + uintptr(cat)*8)) } if lm != 0 { v3 = lm + 16 @@ -100230,10 +100230,10 @@ func _vstrfmon_l(tls *TLS, s uintptr, n Tsize_t, loc Tlocale_t, fmt uintptr, ap s0 = s _3: ; - if !(n != 0 && *(*int8)(unsafe.Pointer(fmt)) != 0) { + if !(n != 0 && **(**int8)(__ccgo_up(fmt)) != 0) { goto _1 } - if !(int32(*(*int8)(unsafe.Pointer(fmt))) != int32('%')) { + if !(int32(**(**int8)(__ccgo_up(fmt))) != int32('%')) { goto _4 } goto literal @@ -100243,13 +100243,13 @@ literal: s = s + 1 v6 = fmt fmt = fmt + 1 - *(*int8)(unsafe.Pointer(v5)) = *(*int8)(unsafe.Pointer(v6)) + **(**int8)(__ccgo_up(v5)) = **(**int8)(__ccgo_up(v6)) n = n - 1 goto _2 _4: ; fmt = fmt + 1 - if int32(*(*int8)(unsafe.Pointer(fmt))) == int32('%') { + if int32(**(**int8)(__ccgo_up(fmt))) == int32('%') { goto literal } fill = int32(' ') @@ -100258,11 +100258,11 @@ _4: nosym = 0 left = 0 for { - switch int32(*(*int8)(unsafe.Pointer(fmt))) { + switch int32(**(**int8)(__ccgo_up(fmt))) { case int32('='): fmt = fmt + 1 v5 = fmt - fill = int32(*(*int8)(unsafe.Pointer(v5))) + fill = int32(**(**int8)(__ccgo_up(v5))) goto _7 case int32('^'): nogrp = int32(1) @@ -100287,10 +100287,10 @@ _4: } fw = 0 for { - if !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(fmt)))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(fmt)))-uint32('0') < uint32(10)) != 0) { break } - fw = int32(10)*fw + (int32(*(*int8)(unsafe.Pointer(fmt))) - int32('0')) + fw = int32(10)*fw + (int32(**(**int8)(__ccgo_up(fmt))) - int32('0')) goto _9 _9: ; @@ -100298,28 +100298,28 @@ _4: } lp = 0 rp = int32(2) - if int32(*(*int8)(unsafe.Pointer(fmt))) == int32('#') { + if int32(**(**int8)(__ccgo_up(fmt))) == int32('#') { lp = 0 fmt = fmt + 1 for { - if !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(fmt)))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(fmt)))-uint32('0') < uint32(10)) != 0) { break } - lp = int32(10)*lp + (int32(*(*int8)(unsafe.Pointer(fmt))) - int32('0')) + lp = int32(10)*lp + (int32(**(**int8)(__ccgo_up(fmt))) - int32('0')) goto _10 _10: ; fmt = fmt + 1 } } - if int32(*(*int8)(unsafe.Pointer(fmt))) == int32('.') { + if int32(**(**int8)(__ccgo_up(fmt))) == int32('.') { rp = 0 fmt = fmt + 1 for { - if !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(fmt)))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(fmt)))-uint32('0') < uint32(10)) != 0) { break } - rp = int32(10)*rp + (int32(*(*int8)(unsafe.Pointer(fmt))) - int32('0')) + rp = int32(10)*rp + (int32(**(**int8)(__ccgo_up(fmt))) - int32('0')) goto _11 _11: ; @@ -100328,7 +100328,7 @@ _4: } v5 = fmt fmt = fmt + 1 - intl = BoolInt32(int32(*(*int8)(unsafe.Pointer(v5))) == int32('i')) + intl = BoolInt32(int32(**(**int8)(__ccgo_up(v5))) == int32('i')) w = lp + int32(1) + rp if !(left != 0) && fw > w { w = fw @@ -100336,7 +100336,7 @@ _4: x = VaFloat64(&ap) l = Uint64FromInt32(Xsnprintf(tls, s, n, __ccgo_ts+577, VaList(bp+8, w, rp, x))) if l >= n { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(E2BIG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(E2BIG) return int64(-int32(1)) } s = s + uintptr(l) @@ -100501,7 +100501,7 @@ func Xtextdomain(tls *TLS, domainname uintptr) (r uintptr) { } domlen = _strlen(tls, domainname) if domlen > uint64(NAME_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } if !(_current_domain != 0) { @@ -100611,7 +100611,7 @@ func X__wcsxfrm_l(tls *TLS, dest uintptr, src uintptr, n Tsize_t, loc Tlocale_t) } else { if n != 0 { Xwmemcpy(tls, dest, src, n-uint64(1)) - *(*Twchar_t)(unsafe.Pointer(dest + uintptr(n-uint64(1))*4)) = 0 + **(**Twchar_t)(__ccgo_up(dest + uintptr(n-uint64(1))*4)) = 0 } } return l @@ -100642,7 +100642,7 @@ func Xreallocarray(tls *TLS, ptr uintptr, m Tsize_t, n Tsize_t) (r uintptr) { defer func() { trc("-> %v", r) }() } if n != 0 && m > Uint64FromInt32(-Int32FromInt32(1))/n { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return uintptr(0) } return Xrealloc(tls, ptr, m*n) @@ -101035,25 +101035,25 @@ func X__rem_pio2(tls *TLS, x float64, y uintptr) (r1 int32) { if ix <= uint32(0x4002d97c) { /* |x| ~<= 3pi/4 */ if !(sign != 0) { z = x - _pio2_1 /* one round good to 85 bits */ - *(*float64)(unsafe.Pointer(y)) = z - _pio2_1t - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) - _pio2_1t + **(**float64)(__ccgo_up(y)) = z - _pio2_1t + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) - _pio2_1t return int32(1) } else { z = x + _pio2_1 - *(*float64)(unsafe.Pointer(y)) = z + _pio2_1t - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) + _pio2_1t + **(**float64)(__ccgo_up(y)) = z + _pio2_1t + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) + _pio2_1t return -int32(1) } } else { if !(sign != 0) { z = x - float64(Float64FromInt32(2)*_pio2_1) - *(*float64)(unsafe.Pointer(y)) = z - Tdouble_t(Float64FromInt32(2)*_pio2_1t) - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) - Tdouble_t(Float64FromInt32(2)*_pio2_1t) + **(**float64)(__ccgo_up(y)) = z - Tdouble_t(Float64FromInt32(2)*_pio2_1t) + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) - Tdouble_t(Float64FromInt32(2)*_pio2_1t) return int32(2) } else { z = x + float64(Float64FromInt32(2)*_pio2_1) - *(*float64)(unsafe.Pointer(y)) = z + Tdouble_t(Float64FromInt32(2)*_pio2_1t) - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) + Tdouble_t(Float64FromInt32(2)*_pio2_1t) + **(**float64)(__ccgo_up(y)) = z + Tdouble_t(Float64FromInt32(2)*_pio2_1t) + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) + Tdouble_t(Float64FromInt32(2)*_pio2_1t) return -int32(2) } } @@ -101065,13 +101065,13 @@ func X__rem_pio2(tls *TLS, x float64, y uintptr) (r1 int32) { } if !(sign != 0) { z = x - float64(Float64FromInt32(3)*_pio2_1) - *(*float64)(unsafe.Pointer(y)) = z - Tdouble_t(Float64FromInt32(3)*_pio2_1t) - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) - Tdouble_t(Float64FromInt32(3)*_pio2_1t) + **(**float64)(__ccgo_up(y)) = z - Tdouble_t(Float64FromInt32(3)*_pio2_1t) + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) - Tdouble_t(Float64FromInt32(3)*_pio2_1t) return int32(3) } else { z = x + float64(Float64FromInt32(3)*_pio2_1) - *(*float64)(unsafe.Pointer(y)) = z + Tdouble_t(Float64FromInt32(3)*_pio2_1t) - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) + Tdouble_t(Float64FromInt32(3)*_pio2_1t) + **(**float64)(__ccgo_up(y)) = z + Tdouble_t(Float64FromInt32(3)*_pio2_1t) + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) + Tdouble_t(Float64FromInt32(3)*_pio2_1t) return -int32(3) } } else { @@ -101080,13 +101080,13 @@ func X__rem_pio2(tls *TLS, x float64, y uintptr) (r1 int32) { } if !(sign != 0) { z = x - float64(Float64FromInt32(4)*_pio2_1) - *(*float64)(unsafe.Pointer(y)) = z - Tdouble_t(Float64FromInt32(4)*_pio2_1t) - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) - Tdouble_t(Float64FromInt32(4)*_pio2_1t) + **(**float64)(__ccgo_up(y)) = z - Tdouble_t(Float64FromInt32(4)*_pio2_1t) + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) - Tdouble_t(Float64FromInt32(4)*_pio2_1t) return int32(4) } else { z = x + float64(Float64FromInt32(4)*_pio2_1) - *(*float64)(unsafe.Pointer(y)) = z + Tdouble_t(Float64FromInt32(4)*_pio2_1t) - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) + Tdouble_t(Float64FromInt32(4)*_pio2_1t) + **(**float64)(__ccgo_up(y)) = z + Tdouble_t(Float64FromInt32(4)*_pio2_1t) + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) + Tdouble_t(Float64FromInt32(4)*_pio2_1t) return -int32(4) } } @@ -101116,8 +101116,8 @@ medium: w = Tdouble_t(fn * _pio2_1t) } } - *(*float64)(unsafe.Pointer(y)) = r - w - *(*float64)(unsafe.Pointer(bp)) = *(*float64)(unsafe.Pointer(y)) + **(**float64)(__ccgo_up(y)) = r - w + *(*float64)(unsafe.Pointer(bp)) = **(**float64)(__ccgo_up(y)) ey = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(52) & uint64(0x7ff)) ex = Int32FromUint32(ix >> int32(20)) if ex-ey > int32(16) { /* 2nd round, good to 118 bits */ @@ -101125,18 +101125,18 @@ medium: w = Tdouble_t(fn * _pio2_2) r = t - w w = Tdouble_t(fn*_pio2_2t) - (t - r - w) - *(*float64)(unsafe.Pointer(y)) = r - w - *(*float64)(unsafe.Pointer(bp)) = *(*float64)(unsafe.Pointer(y)) + **(**float64)(__ccgo_up(y)) = r - w + *(*float64)(unsafe.Pointer(bp)) = **(**float64)(__ccgo_up(y)) ey = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(52) & uint64(0x7ff)) if ex-ey > int32(49) { /* 3rd round, good to 151 bits, covers all cases */ t = r w = Tdouble_t(fn * _pio2_3) r = t - w w = Tdouble_t(fn*_pio2_3t) - (t - r - w) - *(*float64)(unsafe.Pointer(y)) = r - w + **(**float64)(__ccgo_up(y)) = r - w } } - *(*float64)(unsafe.Pointer(y + 1*8)) = r - *(*float64)(unsafe.Pointer(y)) - w + **(**float64)(__ccgo_up(y + 1*8)) = r - **(**float64)(__ccgo_up(y)) - w return n _1: ; @@ -101145,8 +101145,8 @@ _1: */ if ix >= uint32(0x7ff00000) { /* x is inf or NaN */ v2 = x - x - *(*float64)(unsafe.Pointer(y + 1*8)) = v2 - *(*float64)(unsafe.Pointer(y)) = v2 + **(**float64)(__ccgo_up(y + 1*8)) = v2 + **(**float64)(__ccgo_up(y)) = v2 return 0 } /* set z = scalbn(|x|,-ilogb(x)+23) */ @@ -101159,26 +101159,26 @@ _1: if !(i < int32(2)) { break } - (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i] = float64(int32(z)) - z = Tdouble_t((z - (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i]) * float64(1.6777216e+07)) + (**(**[3]float64)(__ccgo_up(bp + 8)))[i] = float64(int32(z)) + z = Tdouble_t((z - (**(**[3]float64)(__ccgo_up(bp + 8)))[i]) * float64(1.6777216e+07)) goto _3 _3: ; i = i + 1 } - (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i] = z + (**(**[3]float64)(__ccgo_up(bp + 8)))[i] = z /* skip zero terms, first term is non-zero */ - for (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i] == float64(0) { + for (**(**[3]float64)(__ccgo_up(bp + 8)))[i] == float64(0) { i = i - 1 } n = X__rem_pio2_large(tls, bp+8, bp+32, Int32FromUint32(ix>>Int32FromInt32(20))-(Int32FromInt32(0x3ff)+Int32FromInt32(23)), i+int32(1), int32(1)) if sign != 0 { - *(*float64)(unsafe.Pointer(y)) = -(*(*[2]float64)(unsafe.Pointer(bp + 32)))[0] - *(*float64)(unsafe.Pointer(y + 1*8)) = -(*(*[2]float64)(unsafe.Pointer(bp + 32)))[int32(1)] + **(**float64)(__ccgo_up(y)) = -(**(**[2]float64)(__ccgo_up(bp + 32)))[0] + **(**float64)(__ccgo_up(y + 1*8)) = -(**(**[2]float64)(__ccgo_up(bp + 32)))[int32(1)] return -n } - *(*float64)(unsafe.Pointer(y)) = (*(*[2]float64)(unsafe.Pointer(bp + 32)))[0] - *(*float64)(unsafe.Pointer(y + 1*8)) = (*(*[2]float64)(unsafe.Pointer(bp + 32)))[int32(1)] + **(**float64)(__ccgo_up(y)) = (**(**[2]float64)(__ccgo_up(bp + 32)))[0] + **(**float64)(__ccgo_up(y + 1*8)) = (**(**[2]float64)(__ccgo_up(bp + 32)))[int32(1)] return n } @@ -101340,7 +101340,7 @@ func X__rem_pio2_large(tls *TLS, x uintptr, y uintptr, e0 int32, nx int32, prec if !(j <= jx) { break } - fw = fw + float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8))*f[jx+i-j]) + fw = fw + float64(**(**float64)(__ccgo_up(x + uintptr(j)*8))*f[jx+i-j]) goto _4 _4: ; @@ -101365,7 +101365,7 @@ recompute: break } fw = float64(int32(float64(Float64FromFloat64(5.960464477539063e-08) * z))) - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] = int32(z - float64(Float64FromFloat64(1.6777216e+07)*fw)) + (**(**[20]Tint32_t)(__ccgo_up(bp)))[i] = int32(z - float64(Float64FromFloat64(1.6777216e+07)*fw)) z = q[j-int32(1)] + fw goto _5 _5: @@ -101380,13 +101380,13 @@ recompute: z = z - float64(n) ih = 0 if q0 > 0 { /* need iq[jz-1] to determine n */ - i = (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz-int32(1)] >> (int32(24) - q0) + i = (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz-int32(1)] >> (int32(24) - q0) n = n + i - *(*Tint32_t)(unsafe.Pointer(bp + uintptr(jz-int32(1))*4)) -= i << (int32(24) - q0) - ih = (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz-int32(1)] >> (int32(23) - q0) + **(**Tint32_t)(__ccgo_up(bp + uintptr(jz-int32(1))*4)) -= i << (int32(24) - q0) + ih = (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz-int32(1)] >> (int32(23) - q0) } else { if q0 == 0 { - ih = (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz-int32(1)] >> int32(23) + ih = (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz-int32(1)] >> int32(23) } else { if z >= float64(0.5) { ih = int32(2) @@ -101401,14 +101401,14 @@ recompute: if !(i < jz) { break } /* compute 1-q */ - j = (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] + j = (**(**[20]Tint32_t)(__ccgo_up(bp)))[i] if carry == 0 { if j != 0 { carry = int32(1) - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] = int32(0x1000000) - j + (**(**[20]Tint32_t)(__ccgo_up(bp)))[i] = int32(0x1000000) - j } } else { - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] = int32(0xffffff) - j + (**(**[20]Tint32_t)(__ccgo_up(bp)))[i] = int32(0xffffff) - j } goto _6 _6: @@ -101418,9 +101418,9 @@ recompute: if q0 > 0 { /* rare case: chance is 1 in 12 */ switch q0 { case int32(1): - *(*Tint32_t)(unsafe.Pointer(bp + uintptr(jz-int32(1))*4)) &= int32(0x7fffff) + **(**Tint32_t)(__ccgo_up(bp + uintptr(jz-int32(1))*4)) &= int32(0x7fffff) case int32(2): - *(*Tint32_t)(unsafe.Pointer(bp + uintptr(jz-int32(1))*4)) &= int32(0x3fffff) + **(**Tint32_t)(__ccgo_up(bp + uintptr(jz-int32(1))*4)) &= int32(0x3fffff) break } } @@ -101439,7 +101439,7 @@ recompute: if !(i >= jk) { break } - j = j | (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] + j = j | (**(**[20]Tint32_t)(__ccgo_up(bp)))[i] goto _7 _7: ; @@ -101448,7 +101448,7 @@ recompute: if j == 0 { /* need recomputation */ k = int32(1) for { - if !((*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jk-k] == 0) { + if !((**(**[20]Tint32_t)(__ccgo_up(bp)))[jk-k] == 0) { break } goto _8 @@ -101468,7 +101468,7 @@ recompute: if !(j <= jx) { break } - fw = fw + float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8))*f[jx+i-j]) + fw = fw + float64(**(**float64)(__ccgo_up(x + uintptr(j)*8))*f[jx+i-j]) goto _10 _10: ; @@ -101488,7 +101488,7 @@ recompute: if z == float64(0) { jz = jz - int32(1) q0 = q0 - int32(24) - for (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] == 0 { + for (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz] == 0 { jz = jz - 1 q0 = q0 - int32(24) } @@ -101496,12 +101496,12 @@ recompute: z = Xscalbn(tls, z, -q0) if z >= float64(1.6777216e+07) { fw = float64(int32(float64(Float64FromFloat64(5.960464477539063e-08) * z))) - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(z - float64(Float64FromFloat64(1.6777216e+07)*fw)) + (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz] = int32(z - float64(Float64FromFloat64(1.6777216e+07)*fw)) jz = jz + int32(1) q0 = q0 + int32(24) - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(fw) + (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz] = int32(fw) } else { - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(z) + (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz] = int32(z) } } /* convert integer "bit" chunk to floating-point value */ @@ -101511,7 +101511,7 @@ recompute: if !(i >= 0) { break } - q[i] = float64(fw * float64((*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i])) + q[i] = float64(fw * float64((**(**[20]Tint32_t)(__ccgo_up(bp)))[i])) fw = fw * float64(5.960464477539063e-08) goto _11 _11: @@ -101536,7 +101536,7 @@ recompute: ; k = k + 1 } - (*(*[20]float64)(unsafe.Pointer(bp + 80)))[jz-i] = fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[jz-i] = fw goto _12 _12: ; @@ -101562,7 +101562,7 @@ _14: if !(i >= 0) { break } - fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[i] goto _19 _19: ; @@ -101573,7 +101573,7 @@ _14: } else { v2 = -fw } - *(*float64)(unsafe.Pointer(y)) = v2 + **(**float64)(__ccgo_up(y)) = v2 goto _18 _16: ; @@ -101585,7 +101585,7 @@ _15: if !(i >= 0) { break } - fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[i] goto _21 _21: ; @@ -101598,14 +101598,14 @@ _15: } else { v2 = -fw } - *(*float64)(unsafe.Pointer(y)) = v2 - fw = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[0] - fw + **(**float64)(__ccgo_up(y)) = v2 + fw = (**(**[20]float64)(__ccgo_up(bp + 80)))[0] - fw i = int32(1) for { if !(i <= jz) { break } - fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[i] goto _23 _23: ; @@ -101616,7 +101616,7 @@ _15: } else { v2 = -fw } - *(*float64)(unsafe.Pointer(y + 1*8)) = v2 + **(**float64)(__ccgo_up(y + 1*8)) = v2 goto _18 _17: ; /* painful */ @@ -101626,9 +101626,9 @@ _27: if !(i > 0) { goto _25 } - fw = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i-int32(1)] + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] - *(*float64)(unsafe.Pointer(bp + 80 + uintptr(i)*8)) += (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i-int32(1)] - fw - (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i-int32(1)] = fw + fw = (**(**[20]float64)(__ccgo_up(bp + 80)))[i-int32(1)] + (**(**[20]float64)(__ccgo_up(bp + 80)))[i] + **(**float64)(__ccgo_up(bp + 80 + uintptr(i)*8)) += (**(**[20]float64)(__ccgo_up(bp + 80)))[i-int32(1)] - fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[i-int32(1)] = fw goto _26 _26: ; @@ -101642,9 +101642,9 @@ _25: if !(i > int32(1)) { break } - fw = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i-int32(1)] + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] - *(*float64)(unsafe.Pointer(bp + 80 + uintptr(i)*8)) += (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i-int32(1)] - fw - (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i-int32(1)] = fw + fw = (**(**[20]float64)(__ccgo_up(bp + 80)))[i-int32(1)] + (**(**[20]float64)(__ccgo_up(bp + 80)))[i] + **(**float64)(__ccgo_up(bp + 80 + uintptr(i)*8)) += (**(**[20]float64)(__ccgo_up(bp + 80)))[i-int32(1)] - fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[i-int32(1)] = fw goto _28 _28: ; @@ -101656,20 +101656,20 @@ _25: if !(i >= int32(2)) { break } - fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[i] goto _29 _29: ; i = i - 1 } if ih == 0 { - *(*float64)(unsafe.Pointer(y)) = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[0] - *(*float64)(unsafe.Pointer(y + 1*8)) = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[int32(1)] - *(*float64)(unsafe.Pointer(y + 2*8)) = fw + **(**float64)(__ccgo_up(y)) = (**(**[20]float64)(__ccgo_up(bp + 80)))[0] + **(**float64)(__ccgo_up(y + 1*8)) = (**(**[20]float64)(__ccgo_up(bp + 80)))[int32(1)] + **(**float64)(__ccgo_up(y + 2*8)) = fw } else { - *(*float64)(unsafe.Pointer(y)) = -(*(*[20]float64)(unsafe.Pointer(bp + 80)))[0] - *(*float64)(unsafe.Pointer(y + 1*8)) = -(*(*[20]float64)(unsafe.Pointer(bp + 80)))[int32(1)] - *(*float64)(unsafe.Pointer(y + 2*8)) = -fw + **(**float64)(__ccgo_up(y)) = -(**(**[20]float64)(__ccgo_up(bp + 80)))[0] + **(**float64)(__ccgo_up(y + 1*8)) = -(**(**[20]float64)(__ccgo_up(bp + 80)))[int32(1)] + **(**float64)(__ccgo_up(y + 2*8)) = -fw } _18: ; @@ -101723,36 +101723,36 @@ func X__rem_pio2f(tls *TLS, x float32, y uintptr) (r int32) { /* Use a specialized rint() to get fn. */ fn = Tdouble_t(float64(x)*_invpio21) + _toint1 - _toint1 n = int32(fn) - *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) + **(**float64)(__ccgo_up(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) /* Matters with directed rounding. */ - if *(*float64)(unsafe.Pointer(y)) < -_pio41 { + if **(**float64)(__ccgo_up(y)) < -_pio41 { n = n - 1 fn = fn - 1 - *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) + **(**float64)(__ccgo_up(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) } else { - if *(*float64)(unsafe.Pointer(y)) > _pio41 { + if **(**float64)(__ccgo_up(y)) > _pio41 { n = n + 1 fn = fn + 1 - *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) + **(**float64)(__ccgo_up(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) } } return n } if ix >= uint32(0x7f800000) { /* x is inf or NaN */ - *(*float64)(unsafe.Pointer(y)) = float64(x - x) + **(**float64)(__ccgo_up(y)) = float64(x - x) return 0 } /* scale x into [2^23, 2^24-1] */ sign = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(bp)) >> int32(31)) e0 = Int32FromUint32(ix>>Int32FromInt32(23) - Uint32FromInt32(Int32FromInt32(0x7f)+Int32FromInt32(23))) /* e0 = ilogb(|x|)-23, positive */ *(*Tuint32_t)(unsafe.Pointer(bp)) = ix - Uint32FromInt32(e0<>int32(52)&uint64(0x7ff) < Uint64FromInt32(Int32FromInt32(0x3ff)+Int32FromInt32(4)) { if !(y != 0) { - return _p10[int32(*(*float64)(unsafe.Pointer(bp)))+int32(15)] + return _p10[int32(**(**float64)(__ccgo_up(bp)))+int32(15)] } y = Xexp2(tls, float64(float64(3.321928094887362)*y)) - return float64(y * _p10[int32(*(*float64)(unsafe.Pointer(bp)))+int32(15)]) + return float64(y * _p10[int32(**(**float64)(__ccgo_up(bp)))+int32(15)]) } return Xpow(tls, float64(10), x) } @@ -104401,14 +104401,14 @@ func Xexp10f(tls *TLS, x float32) (r float32) { Fi [0]Tuint32_t Ff float32 }{} - *(*float32)(unsafe.Pointer(bp + 4)) = *(*float32)(unsafe.Pointer(bp)) + *(*float32)(unsafe.Pointer(bp + 4)) = **(**float32)(__ccgo_up(bp)) /* fabsf(n) < 8 without raising invalid on nan */ if *(*Tuint32_t)(unsafe.Pointer(bp + 4))>>int32(23)&uint32(0xff) < Uint32FromInt32(Int32FromInt32(0x7f)+Int32FromInt32(3)) { if !(y != 0) { - return _p101[int32(*(*float32)(unsafe.Pointer(bp)))+int32(7)] + return _p101[int32(**(**float32)(__ccgo_up(bp)))+int32(7)] } y = Xexp2f(tls, float32(Float32FromFloat32(3.321928094887362)*y)) - return float32(y * _p101[int32(*(*float32)(unsafe.Pointer(bp)))+int32(7)]) + return float32(y * _p101[int32(**(**float32)(__ccgo_up(bp)))+int32(7)]) } return float32(Xexp2(tls, float64(float64(3.321928094887362)*float64(x)))) } @@ -104572,16 +104572,16 @@ _5: /* 2^(k/N) ~= scale * (1 + tail). */ idx = uint64(2) * (ki % Uint64FromInt32(Int32FromInt32(1)<>Int32FromInt32(32) + BoolUint64(t1 > *(*Tuint64_t)(unsafe.Pointer(lo))) + **(**Tuint64_t)(__ccgo_up(lo)) = t1 + t2<>Int32FromInt32(32) + BoolUint64(t1 > **(**Tuint64_t)(__ccgo_up(lo))) } func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { @@ -105486,11 +105486,11 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { if d == 0 { } else { if d < int32(64) { - *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = *(*Tuint64_t)(unsafe.Pointer(bp))<<(int32(64)-d) | *(*Tuint64_t)(unsafe.Pointer(bp + 8))>>d | BoolUint64(!!(*(*Tuint64_t)(unsafe.Pointer(bp + 8))<<(Int32FromInt32(64)-d) != 0)) - *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp)) >> d + **(**Tuint64_t)(__ccgo_up(bp + 8)) = **(**Tuint64_t)(__ccgo_up(bp))<<(int32(64)-d) | **(**Tuint64_t)(__ccgo_up(bp + 8))>>d | BoolUint64(!!(**(**Tuint64_t)(__ccgo_up(bp + 8))<<(Int32FromInt32(64)-d) != 0)) + **(**Tuint64_t)(__ccgo_up(bp)) = **(**Tuint64_t)(__ccgo_up(bp)) >> d } else { - *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = uint64(1) - *(*Tuint64_t)(unsafe.Pointer(bp)) = uint64(0) + **(**Tuint64_t)(__ccgo_up(bp + 8)) = uint64(1) + **(**Tuint64_t)(__ccgo_up(bp)) = uint64(0) } } } @@ -105513,24 +105513,24 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { nonzero = int32(1) if samesign != 0 { /* r += z */ - *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) + zlo - *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp)) + (zhi + BoolUint64(*(*Tuint64_t)(unsafe.Pointer(bp + 8)) < zlo)) + **(**Tuint64_t)(__ccgo_up(bp + 8)) = **(**Tuint64_t)(__ccgo_up(bp + 8)) + zlo + **(**Tuint64_t)(__ccgo_up(bp)) = **(**Tuint64_t)(__ccgo_up(bp)) + (zhi + BoolUint64(**(**Tuint64_t)(__ccgo_up(bp + 8)) < zlo)) } else { /* r -= z */ - t = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) - *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) - zlo - *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp)) - zhi - BoolUint64(t < *(*Tuint64_t)(unsafe.Pointer(bp + 8))) - if *(*Tuint64_t)(unsafe.Pointer(bp))>>int32(63) != 0 { - *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = -*(*Tuint64_t)(unsafe.Pointer(bp + 8)) - *(*Tuint64_t)(unsafe.Pointer(bp)) = -*(*Tuint64_t)(unsafe.Pointer(bp)) - BoolUint64(!!(*(*Tuint64_t)(unsafe.Pointer(bp + 8)) != 0)) + t = **(**Tuint64_t)(__ccgo_up(bp + 8)) + **(**Tuint64_t)(__ccgo_up(bp + 8)) = **(**Tuint64_t)(__ccgo_up(bp + 8)) - zlo + **(**Tuint64_t)(__ccgo_up(bp)) = **(**Tuint64_t)(__ccgo_up(bp)) - zhi - BoolUint64(t < **(**Tuint64_t)(__ccgo_up(bp + 8))) + if **(**Tuint64_t)(__ccgo_up(bp))>>int32(63) != 0 { + **(**Tuint64_t)(__ccgo_up(bp + 8)) = -**(**Tuint64_t)(__ccgo_up(bp + 8)) + **(**Tuint64_t)(__ccgo_up(bp)) = -**(**Tuint64_t)(__ccgo_up(bp)) - BoolUint64(!!(**(**Tuint64_t)(__ccgo_up(bp + 8)) != 0)) sign = BoolInt32(!(sign != 0)) } - nonzero = BoolInt32(!!(*(*Tuint64_t)(unsafe.Pointer(bp)) != 0)) + nonzero = BoolInt32(!!(**(**Tuint64_t)(__ccgo_up(bp)) != 0)) } /* set rhi to top 63bit of the result (last bit is sticky) */ if nonzero != 0 { e = e + int32(64) - v1 = *(*Tuint64_t)(unsafe.Pointer(bp)) + v1 = **(**Tuint64_t)(__ccgo_up(bp)) // __asm__( "bsr %1,%0 ; xor $63,%0" : "=r"(x) : "r"(x) ); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 121, __ccgo_ts+583) v2 = Int32FromUint64(v1) @@ -105538,10 +105538,10 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { _3: d = v2 - int32(1) /* note: d > 0 */ - *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp))<>(int32(64)-d) | BoolUint64(!!(*(*Tuint64_t)(unsafe.Pointer(bp + 8))<>(int32(64)-d) | BoolUint64(!!(**(**Tuint64_t)(__ccgo_up(bp + 8))<>int32(1) | *(*Tuint64_t)(unsafe.Pointer(bp + 8))&uint64(1) + **(**Tuint64_t)(__ccgo_up(bp)) = **(**Tuint64_t)(__ccgo_up(bp + 8))>>int32(1) | **(**Tuint64_t)(__ccgo_up(bp + 8))&uint64(1) } else { - *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) << d + **(**Tuint64_t)(__ccgo_up(bp)) = **(**Tuint64_t)(__ccgo_up(bp + 8)) << d } } else { /* exact +-0 */ @@ -105560,7 +105560,7 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { } e = e - d /* convert to double */ - i = Int64FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp))) /* i is in [1<<62,(1<<63)-1] */ + i = Int64FromUint64(**(**Tuint64_t)(__ccgo_up(bp))) /* i is in [1<<62,(1<<63)-1] */ if sign != 0 { i = -i } @@ -105581,8 +105581,8 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { } /* one bit is lost when scaled, add another top bit to only round once at conversion if it is inexact */ - if *(*Tuint64_t)(unsafe.Pointer(bp))<>int32(1) | *(*Tuint64_t)(unsafe.Pointer(bp))&uint64(1) | Uint64FromUint64(1)<>int32(1)|**(**Tuint64_t)(__ccgo_up(bp))&uint64(1)) | Uint64FromUint64(1)<>d | BoolUint64(!!(*(*Tuint64_t)(unsafe.Pointer(bp))<<(Int32FromInt32(64)-d) != 0))) << d) + i = Int64FromUint64((**(**Tuint64_t)(__ccgo_up(bp))>>d | BoolUint64(!!(**(**Tuint64_t)(__ccgo_up(bp))<<(Int32FromInt32(64)-d) != 0))) << d) if sign != 0 { i = -i } @@ -106182,9 +106182,9 @@ func Xfrexp(tls *TLS, x float64, e uintptr) (r float64) { if !(ee != 0) { if x != 0 { x = Xfrexp(tls, float64(x*float64(1.8446744073709552e+19)), e) - *(*int32)(unsafe.Pointer(e)) -= int32(64) + **(**int32)(__ccgo_up(e)) -= int32(64) } else { - *(*int32)(unsafe.Pointer(e)) = 0 + **(**int32)(__ccgo_up(e)) = 0 } return x } else { @@ -106192,7 +106192,7 @@ func Xfrexp(tls *TLS, x float64, e uintptr) (r float64) { return x } } - *(*int32)(unsafe.Pointer(e)) = ee - int32(0x3fe) + **(**int32)(__ccgo_up(e)) = ee - int32(0x3fe) v1 = bp *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & Uint64FromUint64(0x800fffffffffffff)) v1 = bp @@ -106226,9 +106226,9 @@ func Xfrexpf(tls *TLS, x float32, e uintptr) (r float32) { if !(ee != 0) { if x != 0 { x = Xfrexpf(tls, float32(float64(x)*float64(1.8446744073709552e+19)), e) - *(*int32)(unsafe.Pointer(e)) -= int32(64) + **(**int32)(__ccgo_up(e)) -= int32(64) } else { - *(*int32)(unsafe.Pointer(e)) = 0 + **(**int32)(__ccgo_up(e)) = 0 } return x } else { @@ -106236,7 +106236,7 @@ func Xfrexpf(tls *TLS, x float32, e uintptr) (r float32) { return x } } - *(*int32)(unsafe.Pointer(e)) = ee - int32(0x7e) + **(**int32)(__ccgo_up(e)) = ee - int32(0x7e) v1 = bp *(*Tuint32_t)(unsafe.Pointer(v1)) = Tuint32_t(uint64(*(*Tuint32_t)(unsafe.Pointer(v1))) & Uint64FromUint64(0x807fffff)) v1 = bp @@ -106260,8 +106260,8 @@ func _sq(tls *TLS, hi uintptr, lo uintptr, x float64) { xc = Tdouble_t(x * (Float64FromFloat64(1.34217728e+08) + Float64FromInt32(1))) xh = x - xc + xc xl = x - xh - *(*Tdouble_t)(unsafe.Pointer(hi)) = Tdouble_t(x * x) - *(*Tdouble_t)(unsafe.Pointer(lo)) = Tdouble_t(xh*xh) - *(*Tdouble_t)(unsafe.Pointer(hi)) + Tdouble_t(Tdouble_t(Float64FromInt32(2)*xh)*xl) + Tdouble_t(xl*xl) + **(**Tdouble_t)(__ccgo_up(hi)) = Tdouble_t(x * x) + **(**Tdouble_t)(__ccgo_up(lo)) = Tdouble_t(xh*xh) - **(**Tdouble_t)(__ccgo_up(hi)) + Tdouble_t(Tdouble_t(Float64FromInt32(2)*xh)*xl) + Tdouble_t(xl*xl) } func Xhypot(tls *TLS, x float64, y float64) (r float64) { @@ -106313,21 +106313,21 @@ func Xhypot(tls *TLS, x float64, y float64) (r float64) { v1 = bp + 8 *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & (-Uint64FromUint64(1) >> Int32FromInt32(1))) if *(*Tuint64_t)(unsafe.Pointer(bp)) < *(*Tuint64_t)(unsafe.Pointer(bp + 8)) { - ut = *(*struct { + ut = **(**struct { Fi [0]Tuint64_t Ff float64 - })(unsafe.Pointer(bp)) - *(*struct { + })(__ccgo_up(bp)) + **(**struct { Fi [0]Tuint64_t Ff float64 - })(unsafe.Pointer(bp)) = *(*struct { + })(__ccgo_up(bp)) = **(**struct { Fi [0]Tuint64_t Ff float64 - })(unsafe.Pointer(bp + 8)) - *(*struct { + })(__ccgo_up(bp + 8)) + **(**struct { Fi [0]Tuint64_t Ff float64 - })(unsafe.Pointer(bp + 8)) = ut + })(__ccgo_up(bp + 8)) = ut } /* special cases */ ex = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(52)) @@ -106362,7 +106362,7 @@ func Xhypot(tls *TLS, x float64, y float64) (r float64) { } _sq(tls, bp+16, bp+24, x) _sq(tls, bp+32, bp+40, y) - return float64(z * Xsqrt(tls, *(*Tdouble_t)(unsafe.Pointer(bp + 40))+*(*Tdouble_t)(unsafe.Pointer(bp + 24))+*(*Tdouble_t)(unsafe.Pointer(bp + 32))+*(*Tdouble_t)(unsafe.Pointer(bp + 16)))) + return float64(z * Xsqrt(tls, **(**Tdouble_t)(__ccgo_up(bp + 40))+**(**Tdouble_t)(__ccgo_up(bp + 24))+**(**Tdouble_t)(__ccgo_up(bp + 32))+**(**Tdouble_t)(__ccgo_up(bp + 16)))) } func Xhypotf(tls *TLS, x float32, y float32) (r float32) { @@ -106405,21 +106405,21 @@ func Xhypotf(tls *TLS, x float32, y float32) (r float32) { *(*Tuint32_t)(unsafe.Pointer(bp)) &= -Uint32FromUint32(1) >> Int32FromInt32(1) *(*Tuint32_t)(unsafe.Pointer(bp + 4)) &= -Uint32FromUint32(1) >> Int32FromInt32(1) if *(*Tuint32_t)(unsafe.Pointer(bp)) < *(*Tuint32_t)(unsafe.Pointer(bp + 4)) { - ut = *(*struct { + ut = **(**struct { Fi [0]Tuint32_t Ff float32 - })(unsafe.Pointer(bp)) - *(*struct { + })(__ccgo_up(bp)) + **(**struct { Fi [0]Tuint32_t Ff float32 - })(unsafe.Pointer(bp)) = *(*struct { + })(__ccgo_up(bp)) = **(**struct { Fi [0]Tuint32_t Ff float32 - })(unsafe.Pointer(bp + 4)) - *(*struct { + })(__ccgo_up(bp + 4)) + **(**struct { Fi [0]Tuint32_t Ff float32 - })(unsafe.Pointer(bp + 4)) = ut + })(__ccgo_up(bp + 4)) = ut } x = *(*float32)(unsafe.Pointer(bp)) y = *(*float32)(unsafe.Pointer(bp + 4)) @@ -106847,8 +106847,8 @@ func _pzero(tls *TLS, x float64) (r1 float64) { } } z = float64(1) / float64(x*x) - r = *(*float64)(unsafe.Pointer(p)) + float64(z*(*(*float64)(unsafe.Pointer(p + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 4*8))+float64(z**(*float64)(unsafe.Pointer(p + 5*8))))))))))) - s = float64(1) + float64(z*(*(*float64)(unsafe.Pointer(q))+float64(z*(*(*float64)(unsafe.Pointer(q + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 3*8))+float64(z**(*float64)(unsafe.Pointer(q + 4*8))))))))))) + r = **(**float64)(__ccgo_up(p)) + float64(z*(**(**float64)(__ccgo_up(p + 1*8))+float64(z*(**(**float64)(__ccgo_up(p + 2*8))+float64(z*(**(**float64)(__ccgo_up(p + 3*8))+float64(z*(**(**float64)(__ccgo_up(p + 4*8))+float64(z***(**float64)(__ccgo_up(p + 5*8))))))))))) + s = float64(1) + float64(z*(**(**float64)(__ccgo_up(q))+float64(z*(**(**float64)(__ccgo_up(q + 1*8))+float64(z*(**(**float64)(__ccgo_up(q + 2*8))+float64(z*(**(**float64)(__ccgo_up(q + 3*8))+float64(z***(**float64)(__ccgo_up(q + 4*8))))))))))) return float64(1) + r/s } @@ -106955,8 +106955,8 @@ func _qzero(tls *TLS, x float64) (r1 float64) { } } z = float64(1) / float64(x*x) - r = *(*float64)(unsafe.Pointer(p)) + float64(z*(*(*float64)(unsafe.Pointer(p + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 4*8))+float64(z**(*float64)(unsafe.Pointer(p + 5*8))))))))))) - s = float64(1) + float64(z*(*(*float64)(unsafe.Pointer(q))+float64(z*(*(*float64)(unsafe.Pointer(q + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 4*8))+float64(z**(*float64)(unsafe.Pointer(q + 5*8))))))))))))) + r = **(**float64)(__ccgo_up(p)) + float64(z*(**(**float64)(__ccgo_up(p + 1*8))+float64(z*(**(**float64)(__ccgo_up(p + 2*8))+float64(z*(**(**float64)(__ccgo_up(p + 3*8))+float64(z*(**(**float64)(__ccgo_up(p + 4*8))+float64(z***(**float64)(__ccgo_up(p + 5*8))))))))))) + s = float64(1) + float64(z*(**(**float64)(__ccgo_up(q))+float64(z*(**(**float64)(__ccgo_up(q + 1*8))+float64(z*(**(**float64)(__ccgo_up(q + 2*8))+float64(z*(**(**float64)(__ccgo_up(q + 3*8))+float64(z*(**(**float64)(__ccgo_up(q + 4*8))+float64(z***(**float64)(__ccgo_up(q + 5*8))))))))))))) return (-Float64FromFloat64(0.125) + r/s) / x } @@ -107180,8 +107180,8 @@ func _pzerof(tls *TLS, x float32) (r1 float32) { } } z = Float32FromFloat32(1) / float32(x*x) - r = *(*float32)(unsafe.Pointer(p)) + float32(z*(*(*float32)(unsafe.Pointer(p + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 3*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 4*4))+float32(z**(*float32)(unsafe.Pointer(p + 5*4))))))))))) - s = Float32FromFloat32(1) + float32(z*(*(*float32)(unsafe.Pointer(q))+float32(z*(*(*float32)(unsafe.Pointer(q + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 3*4))+float32(z**(*float32)(unsafe.Pointer(q + 4*4))))))))))) + r = **(**float32)(__ccgo_up(p)) + float32(z*(**(**float32)(__ccgo_up(p + 1*4))+float32(z*(**(**float32)(__ccgo_up(p + 2*4))+float32(z*(**(**float32)(__ccgo_up(p + 3*4))+float32(z*(**(**float32)(__ccgo_up(p + 4*4))+float32(z***(**float32)(__ccgo_up(p + 5*4))))))))))) + s = Float32FromFloat32(1) + float32(z*(**(**float32)(__ccgo_up(q))+float32(z*(**(**float32)(__ccgo_up(q + 1*4))+float32(z*(**(**float32)(__ccgo_up(q + 2*4))+float32(z*(**(**float32)(__ccgo_up(q + 3*4))+float32(z***(**float32)(__ccgo_up(q + 4*4))))))))))) return Float32FromFloat32(1) + r/s } @@ -107288,8 +107288,8 @@ func _qzerof(tls *TLS, x float32) (r1 float32) { } } z = Float32FromFloat32(1) / float32(x*x) - r = *(*float32)(unsafe.Pointer(p)) + float32(z*(*(*float32)(unsafe.Pointer(p + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 3*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 4*4))+float32(z**(*float32)(unsafe.Pointer(p + 5*4))))))))))) - s = Float32FromFloat32(1) + float32(z*(*(*float32)(unsafe.Pointer(q))+float32(z*(*(*float32)(unsafe.Pointer(q + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 3*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 4*4))+float32(z**(*float32)(unsafe.Pointer(q + 5*4))))))))))))) + r = **(**float32)(__ccgo_up(p)) + float32(z*(**(**float32)(__ccgo_up(p + 1*4))+float32(z*(**(**float32)(__ccgo_up(p + 2*4))+float32(z*(**(**float32)(__ccgo_up(p + 3*4))+float32(z*(**(**float32)(__ccgo_up(p + 4*4))+float32(z***(**float32)(__ccgo_up(p + 5*4))))))))))) + s = Float32FromFloat32(1) + float32(z*(**(**float32)(__ccgo_up(q))+float32(z*(**(**float32)(__ccgo_up(q + 1*4))+float32(z*(**(**float32)(__ccgo_up(q + 2*4))+float32(z*(**(**float32)(__ccgo_up(q + 3*4))+float32(z*(**(**float32)(__ccgo_up(q + 4*4))+float32(z***(**float32)(__ccgo_up(q + 5*4))))))))))))) return (-Float32FromFloat32(0.125) + r/s) / x } @@ -107526,8 +107526,8 @@ func _pone(tls *TLS, x float64) (r1 float64) { } } z = float64(1) / float64(x*x) - r = *(*float64)(unsafe.Pointer(p)) + float64(z*(*(*float64)(unsafe.Pointer(p + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 4*8))+float64(z**(*float64)(unsafe.Pointer(p + 5*8))))))))))) - s = float64(1) + float64(z*(*(*float64)(unsafe.Pointer(q))+float64(z*(*(*float64)(unsafe.Pointer(q + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 3*8))+float64(z**(*float64)(unsafe.Pointer(q + 4*8))))))))))) + r = **(**float64)(__ccgo_up(p)) + float64(z*(**(**float64)(__ccgo_up(p + 1*8))+float64(z*(**(**float64)(__ccgo_up(p + 2*8))+float64(z*(**(**float64)(__ccgo_up(p + 3*8))+float64(z*(**(**float64)(__ccgo_up(p + 4*8))+float64(z***(**float64)(__ccgo_up(p + 5*8))))))))))) + s = float64(1) + float64(z*(**(**float64)(__ccgo_up(q))+float64(z*(**(**float64)(__ccgo_up(q + 1*8))+float64(z*(**(**float64)(__ccgo_up(q + 2*8))+float64(z*(**(**float64)(__ccgo_up(q + 3*8))+float64(z***(**float64)(__ccgo_up(q + 4*8))))))))))) return float64(1) + r/s } @@ -107633,8 +107633,8 @@ func _qone(tls *TLS, x float64) (r1 float64) { } } z = float64(1) / float64(x*x) - r = *(*float64)(unsafe.Pointer(p)) + float64(z*(*(*float64)(unsafe.Pointer(p + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 4*8))+float64(z**(*float64)(unsafe.Pointer(p + 5*8))))))))))) - s = float64(1) + float64(z*(*(*float64)(unsafe.Pointer(q))+float64(z*(*(*float64)(unsafe.Pointer(q + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 4*8))+float64(z**(*float64)(unsafe.Pointer(q + 5*8))))))))))))) + r = **(**float64)(__ccgo_up(p)) + float64(z*(**(**float64)(__ccgo_up(p + 1*8))+float64(z*(**(**float64)(__ccgo_up(p + 2*8))+float64(z*(**(**float64)(__ccgo_up(p + 3*8))+float64(z*(**(**float64)(__ccgo_up(p + 4*8))+float64(z***(**float64)(__ccgo_up(p + 5*8))))))))))) + s = float64(1) + float64(z*(**(**float64)(__ccgo_up(q))+float64(z*(**(**float64)(__ccgo_up(q + 1*8))+float64(z*(**(**float64)(__ccgo_up(q + 2*8))+float64(z*(**(**float64)(__ccgo_up(q + 3*8))+float64(z*(**(**float64)(__ccgo_up(q + 4*8))+float64(z***(**float64)(__ccgo_up(q + 5*8))))))))))))) return (float64(0.375) + r/s) / x } @@ -107857,8 +107857,8 @@ func _ponef(tls *TLS, x float32) (r1 float32) { } } z = Float32FromFloat32(1) / float32(x*x) - r = *(*float32)(unsafe.Pointer(p)) + float32(z*(*(*float32)(unsafe.Pointer(p + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 3*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 4*4))+float32(z**(*float32)(unsafe.Pointer(p + 5*4))))))))))) - s = Float32FromFloat32(1) + float32(z*(*(*float32)(unsafe.Pointer(q))+float32(z*(*(*float32)(unsafe.Pointer(q + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 3*4))+float32(z**(*float32)(unsafe.Pointer(q + 4*4))))))))))) + r = **(**float32)(__ccgo_up(p)) + float32(z*(**(**float32)(__ccgo_up(p + 1*4))+float32(z*(**(**float32)(__ccgo_up(p + 2*4))+float32(z*(**(**float32)(__ccgo_up(p + 3*4))+float32(z*(**(**float32)(__ccgo_up(p + 4*4))+float32(z***(**float32)(__ccgo_up(p + 5*4))))))))))) + s = Float32FromFloat32(1) + float32(z*(**(**float32)(__ccgo_up(q))+float32(z*(**(**float32)(__ccgo_up(q + 1*4))+float32(z*(**(**float32)(__ccgo_up(q + 2*4))+float32(z*(**(**float32)(__ccgo_up(q + 3*4))+float32(z***(**float32)(__ccgo_up(q + 4*4))))))))))) return Float32FromFloat32(1) + r/s } @@ -107964,8 +107964,8 @@ func _qonef(tls *TLS, x float32) (r1 float32) { } } z = Float32FromFloat32(1) / float32(x*x) - r = *(*float32)(unsafe.Pointer(p)) + float32(z*(*(*float32)(unsafe.Pointer(p + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 3*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 4*4))+float32(z**(*float32)(unsafe.Pointer(p + 5*4))))))))))) - s = Float32FromFloat32(1) + float32(z*(*(*float32)(unsafe.Pointer(q))+float32(z*(*(*float32)(unsafe.Pointer(q + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 3*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 4*4))+float32(z**(*float32)(unsafe.Pointer(q + 5*4))))))))))))) + r = **(**float32)(__ccgo_up(p)) + float32(z*(**(**float32)(__ccgo_up(p + 1*4))+float32(z*(**(**float32)(__ccgo_up(p + 2*4))+float32(z*(**(**float32)(__ccgo_up(p + 3*4))+float32(z*(**(**float32)(__ccgo_up(p + 4*4))+float32(z***(**float32)(__ccgo_up(p + 5*4))))))))))) + s = Float32FromFloat32(1) + float32(z*(**(**float32)(__ccgo_up(q))+float32(z*(**(**float32)(__ccgo_up(q + 1*4))+float32(z*(**(**float32)(__ccgo_up(q + 2*4))+float32(z*(**(**float32)(__ccgo_up(q + 3*4))+float32(z*(**(**float32)(__ccgo_up(q + 4*4))+float32(z***(**float32)(__ccgo_up(q + 5*4))))))))))))) return (Float32FromFloat32(0.375) + r/s) / x } @@ -108646,7 +108646,7 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { }{} *(*float64)(unsafe.Pointer(bp)) = x /* purge off +-inf, NaN, +-0, tiny and negative arguments */ - *(*int32)(unsafe.Pointer(signgamp)) = int32(1) + **(**int32)(__ccgo_up(signgamp)) = int32(1) sign = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(63)) ix = uint32(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(32) & uint64(0x7fffffff)) if ix >= uint32(0x7ff00000) { @@ -108655,7 +108655,7 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { if ix < Uint32FromInt32((Int32FromInt32(0x3ff)-Int32FromInt32(70))< float64(0) { - *(*int32)(unsafe.Pointer(signgamp)) = -int32(1) + **(**int32)(__ccgo_up(signgamp)) = -int32(1) } else { t = -t } @@ -108903,7 +108903,7 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { }{} *(*float32)(unsafe.Pointer(bp)) = x /* purge off +-inf, NaN, +-0, tiny and negative arguments */ - *(*int32)(unsafe.Pointer(signgamp)) = int32(1) + **(**int32)(__ccgo_up(signgamp)) = int32(1) sign = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(bp)) >> int32(31)) ix = *(*Tuint32_t)(unsafe.Pointer(bp)) & uint32(0x7fffffff) if ix >= uint32(0x7f800000) { @@ -108911,7 +108911,7 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { } if ix < uint32(0x35000000) { /* |x| < 2**-21, return -log(|x|) */ if sign != 0 { - *(*int32)(unsafe.Pointer(signgamp)) = -int32(1) + **(**int32)(__ccgo_up(signgamp)) = -int32(1) x = -x } return -Xlogf(tls, x) @@ -108923,7 +108923,7 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { return Float32FromFloat32(1) / (x - x) } if t > Float32FromFloat32(0) { - *(*int32)(unsafe.Pointer(signgamp)) = -int32(1) + **(**int32)(__ccgo_up(signgamp)) = -int32(1) } else { t = -t } @@ -109154,15 +109154,15 @@ func Xlog(tls *TLS, x1 float64) (r1 float64) { r = x1 - float64(1) r2 = Tdouble_t(r * r) r3 = Tdouble_t(r * r2) - y1 = Tdouble_t(r3 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 1*8)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 2*8))) + float64(r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 3*8))) + float64(r3*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 4*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 5*8)))+float64(r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 6*8)))+float64(r3*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 7*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 8*8)))+float64(r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 9*8)))+float64(r3**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 10*8))))))))) + y1 = Tdouble_t(r3 * (**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 1*8)) + float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 2*8))) + float64(r2***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 3*8))) + float64(r3*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 4*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 5*8)))+float64(r2***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 6*8)))+float64(r3*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 7*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 8*8)))+float64(r2***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 9*8)))+float64(r3***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 10*8))))))))) /* Worst-case error is around 0.507 ULP. */ w = Tdouble_t(r * float64(1.34217728e+08)) rhi = r + w - w rlo = r - rhi - w = Tdouble_t(Tdouble_t(rhi*rhi) * *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56))) /* B[0] == -0.5. */ + w = Tdouble_t(Tdouble_t(rhi*rhi) * **(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56))) /* B[0] == -0.5. */ hi = r + w lo = r - hi + w - lo = lo + Tdouble_t(float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56))*rlo)*(rhi+r)) + lo = lo + Tdouble_t(float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56))*rlo)*(rhi+r)) y1 = y1 + lo y1 = y1 + hi y = y1 @@ -109195,25 +109195,25 @@ func Xlog(tls *TLS, x1 float64) (r1 float64) { i = Int32FromUint64(tmp >> (Int32FromInt32(52) - Int32FromInt32(LOG_TABLE_BITS)) % Uint64FromInt32(Int32FromInt32(1)<> int32(52)) /* arithmetic shift */ iz = uint64(ix - tmp&(Uint64FromUint64(0xfff)< 0x1p-4: 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma). */ - y1 = lo + Tdouble_t(r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16))) + Tdouble_t(Tdouble_t(r*r2)*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 1*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 2*8)))+float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 3*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 4*8))))))) + hi + y1 = lo + Tdouble_t(r2***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 16))) + Tdouble_t(Tdouble_t(r*r2)*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 1*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 2*8)))+float64(r2*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 3*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 4*8))))))) + hi y = y1 v1 = y goto _11 @@ -109674,10 +109674,10 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { r2 = Tdouble_t(r * r) /* rounding error: 0x1p-62. */ r4 = Tdouble_t(r2 * r2) /* Worst-case error is less than 0.54 ULP (0.55 ULP without fma). */ - p = Tdouble_t(r2 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 1*8))))) + p = Tdouble_t(r2 * (**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64)) + float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 1*8))))) y1 = hi + p lo = lo + (hi - y1 + p) - lo = lo + Tdouble_t(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 2*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 3*8)))+float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 4*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 5*8)))))+float64(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 6*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 7*8)))+float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 8*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 9*8))))))))) + lo = lo + Tdouble_t(r4*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 2*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 3*8)))+float64(r2*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 4*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 5*8)))))+float64(r4*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 6*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 7*8)))+float64(r2*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 8*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 9*8))))))))) y1 = y1 + lo y = y1 v1 = y @@ -109709,24 +109709,24 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { i = Int32FromUint64(tmp >> (Int32FromInt32(52) - Int32FromInt32(LOG2_TABLE_BITS)) % Uint64FromInt32(Int32FromInt32(1)<> int32(52)) /* arithmetic shift */ iz = uint64(ix - tmp&(Uint64FromUint64(0xfff)< 0x1p-4: 0.547 ULP (0.550 ULP without fma). ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma). */ - p = *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 1*8))) + float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 2*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 3*8))))) + float64(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 4*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 5*8))))) + p = **(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 16)) + float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 1*8))) + float64(r2*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 2*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 3*8))))) + float64(r4*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 4*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 5*8))))) y1 = lo + Tdouble_t(r2*p) + hi y = y1 v1 = y @@ -109819,23 +109819,23 @@ func Xlog2f(tls *TLS, x1 float32) (r1 float32) { top = tmp & uint32(0xff800000) iz = ix - top k = Int32FromUint32(tmp) >> int32(23) /* arithmetic shift */ - invc = (*(*struct { + invc = (**(**struct { Finvc float64 Flogc float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + uintptr(i)*16))).Finvc - logc = (*(*struct { + })(__ccgo_up(uintptr(unsafe.Pointer(&X__log2f_data)) + uintptr(i)*16))).Finvc + logc = (**(**struct { Finvc float64 Flogc float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + uintptr(i)*16))).Flogc + })(__ccgo_up(uintptr(unsafe.Pointer(&X__log2f_data)) + uintptr(i)*16))).Flogc z = float64(*(*float32)(unsafe.Pointer(&iz))) /* log2(x) = log1p(z/c-1)/ln2 + log2(c) + k */ r = Tdouble_t(z*invc) - Float64FromInt32(1) y0 = logc + float64(k) /* Pipelined polynomial evaluation to approximate log1p(r)/ln2. */ r2 = Tdouble_t(r * r) - y1 = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 1*8))*r) + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 2*8)) - y1 = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256))*r2) + y1 - p = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 3*8))*r) + y0 + y1 = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 1*8))*r) + **(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 2*8)) + y1 = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2f_data)) + 256))*r2) + y1 + p = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 3*8))*r) + y0 y1 = Tdouble_t(y1*r2) + p y = float32(y1) v1 = y @@ -110012,22 +110012,22 @@ func Xlogf(tls *TLS, x1 float32) (r1 float32) { i = Int32FromUint32(tmp >> (Int32FromInt32(23) - Int32FromInt32(LOGF_TABLE_BITS)) % Uint32FromInt32(Int32FromInt32(1)<> int32(23) /* arithmetic shift */ iz = ix - tmp&uint32(0xff800000) - invc = (*(*struct { + invc = (**(**struct { Finvc float64 Flogc float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + uintptr(i)*16))).Finvc - logc = (*(*struct { + })(__ccgo_up(uintptr(unsafe.Pointer(&X__logf_data)) + uintptr(i)*16))).Finvc + logc = (**(**struct { Finvc float64 Flogc float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + uintptr(i)*16))).Flogc + })(__ccgo_up(uintptr(unsafe.Pointer(&X__logf_data)) + uintptr(i)*16))).Flogc z = float64(*(*float32)(unsafe.Pointer(&iz))) /* log(x) = log1p(z/c-1) + log(c) + k*Ln2 */ r = Tdouble_t(z*invc) - Float64FromInt32(1) y0 = logc + Tdouble_t(float64(k)*X__logf_data.Fln2) /* Pipelined polynomial evaluation to approximate log1p(r). */ r2 = Tdouble_t(r * r) - y1 = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + 264 + 1*8))*r) + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + 264 + 2*8)) - y1 = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + 264))*r2) + y1 + y1 = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__logf_data)) + 264 + 1*8))*r) + **(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__logf_data)) + 264 + 2*8)) + y1 = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__logf_data)) + 264))*r2) + y1 y1 = Tdouble_t(y1*r2) + (y0 + r) y = float32(y1) v1 = y @@ -110152,7 +110152,7 @@ func Xmodf(tls *TLS, x float64, iptr uintptr) (r float64) { e = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp))>>Int32FromInt32(52)&Uint64FromInt32(0x7ff)) - int32(0x3ff) /* no fractional part */ if e >= int32(52) { - *(*float64)(unsafe.Pointer(iptr)) = x + **(**float64)(__ccgo_up(iptr)) = x if e == int32(0x400) && *(*Tuint64_t)(unsafe.Pointer(bp))<> Int32FromInt32(12) >> e) if *(*Tuint64_t)(unsafe.Pointer(bp))&mask == uint64(0) { - *(*float64)(unsafe.Pointer(iptr)) = x + **(**float64)(__ccgo_up(iptr)) = x v1 = bp *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & (Uint64FromUint64(1) << Int32FromInt32(63))) return *(*float64)(unsafe.Pointer(bp)) } *(*Tuint64_t)(unsafe.Pointer(bp)) &= ^mask - *(*float64)(unsafe.Pointer(iptr)) = *(*float64)(unsafe.Pointer(bp)) + **(**float64)(__ccgo_up(iptr)) = *(*float64)(unsafe.Pointer(bp)) return x - *(*float64)(unsafe.Pointer(bp)) } @@ -110204,7 +110204,7 @@ func Xmodff(tls *TLS, x float32, iptr uintptr) (r float32) { e = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(bp))>>Int32FromInt32(23)&Uint32FromInt32(0xff)) - int32(0x7f) /* no fractional part */ if e >= int32(23) { - *(*float32)(unsafe.Pointer(iptr)) = x + **(**float32)(__ccgo_up(iptr)) = x if e == int32(0x80) && *(*Tuint32_t)(unsafe.Pointer(bp))<> e) if *(*Tuint32_t)(unsafe.Pointer(bp))&mask == uint32(0) { - *(*float32)(unsafe.Pointer(iptr)) = x + **(**float32)(__ccgo_up(iptr)) = x *(*Tuint32_t)(unsafe.Pointer(bp)) &= uint32(0x80000000) return *(*float32)(unsafe.Pointer(bp)) } *(*Tuint32_t)(unsafe.Pointer(bp)) &= ^mask - *(*float32)(unsafe.Pointer(iptr)) = *(*float32)(unsafe.Pointer(bp)) + **(**float32)(__ccgo_up(iptr)) = *(*float32)(unsafe.Pointer(bp)) return x - *(*float32)(unsafe.Pointer(bp)) } @@ -110239,7 +110239,7 @@ func Xmodfl(tls *TLS, x float64, iptr uintptr) (r1 float64) { var _ /* d at bp+0 */ float64 _ = r r = Xmodf(tls, x, bp) - *(*float64)(unsafe.Pointer(iptr)) = *(*float64)(unsafe.Pointer(bp)) + **(**float64)(__ccgo_up(iptr)) = float64(**(**float64)(__ccgo_up(bp))) return r } @@ -110641,24 +110641,24 @@ func _log_inline(tls *TLS, ix Tuint64_t, tail uintptr) (r1 Tdouble_t) { z = *(*float64)(unsafe.Pointer(&iz)) kd = float64(k) /* log(x) = k*Ln2 + log(c) + log1p(z/c-1). */ - invc = (*(*struct { + invc = (**(**struct { Finvc float64 Fpad float64 Flogc float64 Flogctail float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Finvc - logc = (*(*struct { + })(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Finvc + logc = (**(**struct { Finvc float64 Fpad float64 Flogc float64 Flogctail float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Flogc - logctail = (*(*struct { + })(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Flogc + logctail = (**(**struct { Finvc float64 Fpad float64 Flogc float64 Flogctail float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Flogctail + })(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Flogctail v1 = uint64((iz + Uint64FromUint64(1)<> (Int32FromInt32(23) - Int32FromInt32(POWF_SCALE_BITS)) /* arithmetic shift */ - invc = (*(*struct { + invc = (**(**struct { Finvc float64 Flogc float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + uintptr(i)*16))).Finvc - logc = (*(*struct { + })(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + uintptr(i)*16))).Finvc + logc = (**(**struct { Finvc float64 Flogc float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + uintptr(i)*16))).Flogc + })(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + uintptr(i)*16))).Flogc z = float64(*(*float32)(unsafe.Pointer(&iz))) /* log2(x) = log1p(z/c-1)/ln2 + log2(c) + k */ r = Tdouble_t(z*invc) - Float64FromInt32(1) y0 = logc + float64(k) /* Pipelined polynomial evaluation to approximate log1p(r)/ln2. */ r2 = Tdouble_t(r * r) - y = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256))*r) + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 1*8)) - p = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 2*8))*r) + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 3*8)) + y = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256))*r) + **(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 1*8)) + p = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 2*8))*r) + **(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 3*8)) r4 = Tdouble_t(r2 * r2) - q = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 4*8))*r) + y0 + q = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 4*8))*r) + y0 q = Tdouble_t(p*r2) + q y = Tdouble_t(y*r4) + q return y @@ -111084,13 +111084,13 @@ _2: kd = kd - X__exp2f_data.Fshift_scaled /* k/N */ r = xd - kd /* exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1) */ - t = *(*Tuint64_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + uintptr(ki%Uint64FromInt32(Int32FromInt32(1)<> int32(63)) sy = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp + 16)) >> int32(63)) uxi = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) - *(*int32)(unsafe.Pointer(quo)) = 0 + **(**int32)(__ccgo_up(quo)) = 0 if v3 = *(*Tuint64_t)(unsafe.Pointer(bp + 16))<> int32(31)) sy = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(bp + 8)) >> int32(31)) uxi = *(*Tuint32_t)(unsafe.Pointer(bp + 4)) - *(*int32)(unsafe.Pointer(quo)) = 0 + **(**int32)(__ccgo_up(quo)) = 0 if v3 = *(*Tuint32_t)(unsafe.Pointer(bp + 8))<= uint32(0x7ff00000) { v1 = x3 - x3 - *(*float64)(unsafe.Pointer(cos)) = v1 - *(*float64)(unsafe.Pointer(sin)) = v1 + **(**float64)(__ccgo_up(cos)) = v1 + **(**float64)(__ccgo_up(sin)) = v1 return } /* argument reduction needed */ n = Uint32FromInt32(X__rem_pio2(tls, x3, bp)) - s = X__sin(tls, (*(*[2]float64)(unsafe.Pointer(bp)))[0], (*(*[2]float64)(unsafe.Pointer(bp)))[int32(1)], int32(1)) - c = X__cos(tls, (*(*[2]float64)(unsafe.Pointer(bp)))[0], (*(*[2]float64)(unsafe.Pointer(bp)))[int32(1)]) + s = X__sin(tls, (**(**[2]float64)(__ccgo_up(bp)))[0], (**(**[2]float64)(__ccgo_up(bp)))[int32(1)], int32(1)) + c = X__cos(tls, (**(**[2]float64)(__ccgo_up(bp)))[0], (**(**[2]float64)(__ccgo_up(bp)))[int32(1)]) switch n & Uint32FromInt32(3) { case uint32(0): - *(*float64)(unsafe.Pointer(sin)) = s - *(*float64)(unsafe.Pointer(cos)) = c + **(**float64)(__ccgo_up(sin)) = s + **(**float64)(__ccgo_up(cos)) = c case uint32(1): - *(*float64)(unsafe.Pointer(sin)) = c - *(*float64)(unsafe.Pointer(cos)) = -s + **(**float64)(__ccgo_up(sin)) = c + **(**float64)(__ccgo_up(cos)) = -s case uint32(2): - *(*float64)(unsafe.Pointer(sin)) = -s - *(*float64)(unsafe.Pointer(cos)) = -c + **(**float64)(__ccgo_up(sin)) = -s + **(**float64)(__ccgo_up(cos)) = -c case uint32(3): fallthrough default: - *(*float64)(unsafe.Pointer(sin)) = -c - *(*float64)(unsafe.Pointer(cos)) = s + **(**float64)(__ccgo_up(sin)) = -c + **(**float64)(__ccgo_up(cos)) = s break } } @@ -112331,23 +112331,23 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { y2 = float64(v1) } } - *(*float32)(unsafe.Pointer(sin)) = x3 - *(*float32)(unsafe.Pointer(cos)) = Float32FromFloat32(1) + **(**float32)(__ccgo_up(sin)) = x3 + **(**float32)(__ccgo_up(cos)) = Float32FromFloat32(1) return } - *(*float32)(unsafe.Pointer(sin)) = X__sindf(tls, float64(x3)) - *(*float32)(unsafe.Pointer(cos)) = X__cosdf(tls, float64(x3)) + **(**float32)(__ccgo_up(sin)) = X__sindf(tls, float64(x3)) + **(**float32)(__ccgo_up(cos)) = X__cosdf(tls, float64(x3)) return } /* |x| ~<= 5*pi/4 */ if ix <= uint32(0x407b53d1) { if ix <= uint32(0x4016cbe3) { /* |x| ~<= 3pi/4 */ if sign != 0 { - *(*float32)(unsafe.Pointer(sin)) = -X__cosdf(tls, float64(x3)+_s1pio2) - *(*float32)(unsafe.Pointer(cos)) = X__sindf(tls, float64(x3)+_s1pio2) + **(**float32)(__ccgo_up(sin)) = -X__cosdf(tls, float64(x3)+_s1pio2) + **(**float32)(__ccgo_up(cos)) = X__sindf(tls, float64(x3)+_s1pio2) } else { - *(*float32)(unsafe.Pointer(sin)) = X__cosdf(tls, _s1pio2-float64(x3)) - *(*float32)(unsafe.Pointer(cos)) = X__sindf(tls, _s1pio2-float64(x3)) + **(**float32)(__ccgo_up(sin)) = X__cosdf(tls, _s1pio2-float64(x3)) + **(**float32)(__ccgo_up(cos)) = X__sindf(tls, _s1pio2-float64(x3)) } return } @@ -112357,24 +112357,24 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { } else { v4 = float64(x3) - _s2pio2 } - *(*float32)(unsafe.Pointer(sin)) = -X__sindf(tls, v4) + **(**float32)(__ccgo_up(sin)) = -X__sindf(tls, v4) if sign != 0 { v4 = float64(x3) + _s2pio2 } else { v4 = float64(x3) - _s2pio2 } - *(*float32)(unsafe.Pointer(cos)) = -X__cosdf(tls, v4) + **(**float32)(__ccgo_up(cos)) = -X__cosdf(tls, v4) return } /* |x| ~<= 9*pi/4 */ if ix <= uint32(0x40e231d5) { if ix <= uint32(0x40afeddf) { /* |x| ~<= 7*pi/4 */ if sign != 0 { - *(*float32)(unsafe.Pointer(sin)) = X__cosdf(tls, float64(x3)+_s3pio2) - *(*float32)(unsafe.Pointer(cos)) = -X__sindf(tls, float64(x3)+_s3pio2) + **(**float32)(__ccgo_up(sin)) = X__cosdf(tls, float64(x3)+_s3pio2) + **(**float32)(__ccgo_up(cos)) = -X__sindf(tls, float64(x3)+_s3pio2) } else { - *(*float32)(unsafe.Pointer(sin)) = -X__cosdf(tls, float64(x3)-_s3pio2) - *(*float32)(unsafe.Pointer(cos)) = X__sindf(tls, float64(x3)-_s3pio2) + **(**float32)(__ccgo_up(sin)) = -X__cosdf(tls, float64(x3)-_s3pio2) + **(**float32)(__ccgo_up(cos)) = X__sindf(tls, float64(x3)-_s3pio2) } return } @@ -112383,41 +112383,41 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { } else { v4 = float64(x3) - _s4pio2 } - *(*float32)(unsafe.Pointer(sin)) = X__sindf(tls, v4) + **(**float32)(__ccgo_up(sin)) = X__sindf(tls, v4) if sign != 0 { v4 = float64(x3) + _s4pio2 } else { v4 = float64(x3) - _s4pio2 } - *(*float32)(unsafe.Pointer(cos)) = X__cosdf(tls, v4) + **(**float32)(__ccgo_up(cos)) = X__cosdf(tls, v4) return } /* sin(Inf or NaN) is NaN */ if ix >= uint32(0x7f800000) { v1 = x3 - x3 - *(*float32)(unsafe.Pointer(cos)) = v1 - *(*float32)(unsafe.Pointer(sin)) = v1 + **(**float32)(__ccgo_up(cos)) = v1 + **(**float32)(__ccgo_up(sin)) = v1 return } /* general argument reduction needed */ n = Uint32FromInt32(X__rem_pio2f(tls, x3, bp)) - s = X__sindf(tls, *(*float64)(unsafe.Pointer(bp))) - c = X__cosdf(tls, *(*float64)(unsafe.Pointer(bp))) + s = X__sindf(tls, **(**float64)(__ccgo_up(bp))) + c = X__cosdf(tls, **(**float64)(__ccgo_up(bp))) switch n & Uint32FromInt32(3) { case uint32(0): - *(*float32)(unsafe.Pointer(sin)) = s - *(*float32)(unsafe.Pointer(cos)) = c + **(**float32)(__ccgo_up(sin)) = s + **(**float32)(__ccgo_up(cos)) = c case uint32(1): - *(*float32)(unsafe.Pointer(sin)) = c - *(*float32)(unsafe.Pointer(cos)) = -s + **(**float32)(__ccgo_up(sin)) = c + **(**float32)(__ccgo_up(cos)) = -s case uint32(2): - *(*float32)(unsafe.Pointer(sin)) = -s - *(*float32)(unsafe.Pointer(cos)) = -c + **(**float32)(__ccgo_up(sin)) = -s + **(**float32)(__ccgo_up(cos)) = -c case uint32(3): fallthrough default: - *(*float32)(unsafe.Pointer(sin)) = -c - *(*float32)(unsafe.Pointer(cos)) = s + **(**float32)(__ccgo_up(sin)) = -c + **(**float32)(__ccgo_up(cos)) = s break } } @@ -112433,8 +112433,8 @@ func Xsincosl(tls *TLS, x float64, sin uintptr, cos uintptr) { var _ /* cosd at bp+8 */ float64 var _ /* sind at bp+0 */ float64 Xsincos(tls, x, bp, bp+8) - *(*float64)(unsafe.Pointer(sin)) = *(*float64)(unsafe.Pointer(bp)) - *(*float64)(unsafe.Pointer(cos)) = *(*float64)(unsafe.Pointer(bp + 8)) + **(**float64)(__ccgo_up(sin)) = float64(**(**float64)(__ccgo_up(bp))) + **(**float64)(__ccgo_up(cos)) = float64(**(**float64)(__ccgo_up(bp + 8))) } const M_PI_27 = 1.5707963267948966 @@ -112533,13 +112533,13 @@ func Xsinf(tls *TLS, x3 float32) (r float32) { n = X__rem_pio2f(tls, x3, bp) switch n & Int32FromInt32(3) { case 0: - return X__sindf(tls, *(*float64)(unsafe.Pointer(bp))) + return X__sindf(tls, **(**float64)(__ccgo_up(bp))) case int32(1): - return X__cosdf(tls, *(*float64)(unsafe.Pointer(bp))) + return X__cosdf(tls, **(**float64)(__ccgo_up(bp))) case int32(2): - return X__sindf(tls, -*(*float64)(unsafe.Pointer(bp))) + return X__sindf(tls, -**(**float64)(__ccgo_up(bp))) default: - return -X__cosdf(tls, *(*float64)(unsafe.Pointer(bp))) + return -X__cosdf(tls, **(**float64)(__ccgo_up(bp))) } return r } @@ -112985,7 +112985,7 @@ func Xtan(tls *TLS, x3 float64) (r float64) { } /* argument reduction */ n = Uint32FromInt32(X__rem_pio2(tls, x3, bp)) - return X__tan(tls, (*(*[2]float64)(unsafe.Pointer(bp)))[0], (*(*[2]float64)(unsafe.Pointer(bp)))[int32(1)], Int32FromUint32(n&uint32(1))) + return X__tan(tls, (**(**[2]float64)(__ccgo_up(bp)))[0], (**(**[2]float64)(__ccgo_up(bp)))[int32(1)], Int32FromUint32(n&uint32(1))) } const M_PI_29 = 1.5707963267948966 @@ -113086,7 +113086,7 @@ func Xtanf(tls *TLS, x3 float32) (r float32) { } /* argument reduction */ n = Uint32FromInt32(X__rem_pio2f(tls, x3, bp)) - return X__tandf(tls, *(*float64)(unsafe.Pointer(bp)), Int32FromUint32(n&uint32(1))) + return X__tandf(tls, **(**float64)(__ccgo_up(bp)), Int32FromUint32(n&uint32(1))) } const M_PI_210 = 0 @@ -113626,10 +113626,10 @@ func Xa64l(tls *TLS, s uintptr) (r int64) { x = uint32(0) e = 0 for { - if !(e < int32(36) && *(*int8)(unsafe.Pointer(s)) != 0) { + if !(e < int32(36) && **(**int8)(__ccgo_up(s)) != 0) { break } - d = Xstrchr(tls, uintptr(unsafe.Pointer(&_digits)), int32(*(*int8)(unsafe.Pointer(s)))) + d = Xstrchr(tls, uintptr(unsafe.Pointer(&_digits)), int32(**(**int8)(__ccgo_up(s)))) if !(d != 0) { break } @@ -113657,14 +113657,14 @@ func Xl64a(tls *TLS, x0 int64) (r uintptr) { if !(x != 0) { break } - *(*int8)(unsafe.Pointer(p)) = _digits[x&uint32(63)] + **(**int8)(__ccgo_up(p)) = _digits[x&uint32(63)] goto _1 _1: ; p = p + 1 x = x >> uint32(6) } - *(*int8)(unsafe.Pointer(p)) = 0 + **(**int8)(__ccgo_up(p)) = 0 return uintptr(unsafe.Pointer(&_s)) } @@ -113677,22 +113677,22 @@ func Xbasename(tls *TLS, s uintptr) (r uintptr) { } var i Tsize_t _ = i - if !(s != 0) || !(*(*int8)(unsafe.Pointer(s)) != 0) { + if !(s != 0) || !(**(**int8)(__ccgo_up(s)) != 0) { return __ccgo_ts + 575 } i = _strlen(tls, s) - uint64(1) for { - if !(i != 0 && int32(*(*int8)(unsafe.Pointer(s + uintptr(i)))) == int32('/')) { + if !(i != 0 && int32(**(**int8)(__ccgo_up(s + uintptr(i)))) == int32('/')) { break } - *(*int8)(unsafe.Pointer(s + uintptr(i))) = 0 + **(**int8)(__ccgo_up(s + uintptr(i))) = 0 goto _1 _1: ; i = i - 1 } for { - if !(i != 0 && int32(*(*int8)(unsafe.Pointer(s + uintptr(i-uint64(1))))) != int32('/')) { + if !(i != 0 && int32(**(**int8)(__ccgo_up(s + uintptr(i-uint64(1))))) != int32('/')) { break } goto _2 @@ -113718,12 +113718,12 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { } var i Tsize_t _ = i - if !(s != 0) || !(*(*int8)(unsafe.Pointer(s)) != 0) { + if !(s != 0) || !(**(**int8)(__ccgo_up(s)) != 0) { return __ccgo_ts + 575 } i = _strlen(tls, s) - uint64(1) for { - if !(int32(*(*int8)(unsafe.Pointer(s + uintptr(i)))) == int32('/')) { + if !(int32(**(**int8)(__ccgo_up(s + uintptr(i)))) == int32('/')) { break } if !(i != 0) { @@ -113735,7 +113735,7 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { i = i - 1 } for { - if !(int32(*(*int8)(unsafe.Pointer(s + uintptr(i)))) != int32('/')) { + if !(int32(**(**int8)(__ccgo_up(s + uintptr(i)))) != int32('/')) { break } if !(i != 0) { @@ -113747,7 +113747,7 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { i = i - 1 } for { - if !(int32(*(*int8)(unsafe.Pointer(s + uintptr(i)))) == int32('/')) { + if !(int32(**(**int8)(__ccgo_up(s + uintptr(i)))) == int32('/')) { break } if !(i != 0) { @@ -113758,7 +113758,7 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { ; i = i - 1 } - *(*int8)(unsafe.Pointer(s + uintptr(i+uint64(1)))) = 0 + **(**int8)(__ccgo_up(s + uintptr(i+uint64(1)))) = 0 return s } @@ -113846,10 +113846,10 @@ func __strcolcmp(tls *TLS, lstr uintptr, bstr uintptr) (r int32) { var i Tsize_t _ = i i = uint64(0) - for *(*int8)(unsafe.Pointer(lstr + uintptr(i))) != 0 && *(*int8)(unsafe.Pointer(bstr + uintptr(i))) != 0 && int32(*(*int8)(unsafe.Pointer(bstr + uintptr(i)))) == int32(*(*int8)(unsafe.Pointer(lstr + uintptr(i)))) { + for **(**int8)(__ccgo_up(lstr + uintptr(i))) != 0 && **(**int8)(__ccgo_up(bstr + uintptr(i))) != 0 && int32(**(**int8)(__ccgo_up(bstr + uintptr(i)))) == int32(**(**int8)(__ccgo_up(lstr + uintptr(i)))) { i = i + 1 } - if *(*int8)(unsafe.Pointer(lstr + uintptr(i))) != 0 || *(*int8)(unsafe.Pointer(bstr + uintptr(i))) != 0 && int32(*(*int8)(unsafe.Pointer(bstr + uintptr(i)))) != int32(':') { + if **(**int8)(__ccgo_up(lstr + uintptr(i))) != 0 || **(**int8)(__ccgo_up(bstr + uintptr(i))) != 0 && int32(**(**int8)(__ccgo_up(bstr + uintptr(i)))) != int32(':') { return int32(1) } return 0 @@ -113947,7 +113947,7 @@ func Xfmtmsg(tls *TLS, classification int64, label uintptr, severity int32, text } } if classification&int64(MM_PRINT) != 0 { - for cmsg != 0 && *(*int8)(unsafe.Pointer(cmsg)) != 0 { + for cmsg != 0 && **(**int8)(__ccgo_up(cmsg)) != 0 { i = 0 for { if !(msgs[i] != 0) { @@ -114023,7 +114023,7 @@ func Xfmtmsg(tls *TLS, classification int64, label uintptr, severity int32, text if ret&(Int32FromInt32(MM_NOCON)|Int32FromInt32(MM_NOMSG)) == Int32FromInt32(MM_NOCON)|Int32FromInt32(MM_NOMSG) { ret = -int32(1) } - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) return ret } @@ -114039,7 +114039,7 @@ func Xget_current_dir_name(tls *TLS) (r uintptr) { var _ /* b at bp+144 */ Tstat _ = res res = Xgetenv(tls, __ccgo_ts+709) - if res != 0 && *(*int8)(unsafe.Pointer(res)) != 0 && !(Xstat(tls, res, bp) != 0) && !(Xstat(tls, __ccgo_ts+575, bp+144) != 0) && (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev == (*(*Tstat)(unsafe.Pointer(bp + 144))).Fst_dev && (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino == (*(*Tstat)(unsafe.Pointer(bp + 144))).Fst_ino { + if res != 0 && **(**int8)(__ccgo_up(res)) != 0 && !(Xstat(tls, res, bp) != 0) && !(Xstat(tls, __ccgo_ts+575, bp+144) != 0) && (**(**Tstat)(__ccgo_up(bp))).Fst_dev == (**(**Tstat)(__ccgo_up(bp + 144))).Fst_dev && (**(**Tstat)(__ccgo_up(bp))).Fst_ino == (**(**Tstat)(__ccgo_up(bp + 144))).Fst_ino { return Xstrdup(tls, res) } return Xgetcwd(tls, uintptr(0), uint64(0)) @@ -114057,18 +114057,18 @@ func X__getauxval(tls *TLS, item uint64) (r uint64) { return Uint64FromInt8(X__libc.Fsecure) } for { - if !(*(*Tsize_t)(unsafe.Pointer(auxv)) != 0) { + if !(**(**Tsize_t)(__ccgo_up(auxv)) != 0) { break } - if *(*Tsize_t)(unsafe.Pointer(auxv)) == item { - return *(*Tsize_t)(unsafe.Pointer(auxv + 1*8)) + if **(**Tsize_t)(__ccgo_up(auxv)) == item { + return **(**Tsize_t)(__ccgo_up(auxv + 1*8)) } goto _1 _1: ; auxv = auxv + uintptr(2)*8 } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOENT) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOENT) return uint64(0) } @@ -114099,7 +114099,7 @@ func Xgetdomainname(tls *TLS, name uintptr, len1 Tsize_t) (r int32) { var _ /* temp at bp+0 */ Tutsname Xuname(tls, bp) if !(len1 != 0) || _strlen(tls, bp+325) >= len1 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } Xstrcpy(tls, name, bp+325) @@ -114120,14 +114120,14 @@ func Xgetentropy(tls *TLS, buffer uintptr, len1 Tsize_t) (r int32) { ret = 0 pos = buffer if len1 > uint64(256) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EIO) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EIO) return -int32(1) } _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp) for len1 != 0 { ret = int32(Xgetrandom(tls, pos, len1, uint32(0))) if ret < 0 { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EINTR) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EINTR) { continue } else { break @@ -114137,7 +114137,7 @@ func Xgetentropy(tls *TLS, buffer uintptr, len1 Tsize_t) (r int32) { len1 = len1 - Uint64FromInt32(ret) ret = 0 } - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) return ret } @@ -114191,46 +114191,46 @@ func Xgetopt(tls *TLS, argc int32, argv uintptr, optstring uintptr) (r int32) { X__optpos = 0 Xoptind = int32(1) } - if Xoptind >= argc || !(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) != 0) { + if Xoptind >= argc || !(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) != 0) { return -int32(1) } - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))))) != int32('-') { - if int32(*(*int8)(unsafe.Pointer(optstring))) == int32('-') { + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8))))) != int32('-') { + if int32(**(**int8)(__ccgo_up(optstring))) == int32('-') { v1 = Xoptind Xoptind = Xoptind + 1 - Xoptarg = *(*uintptr)(unsafe.Pointer(argv + uintptr(v1)*8)) + Xoptarg = **(**uintptr)(__ccgo_up(argv + uintptr(v1)*8)) return int32(1) } return -int32(1) } - if !(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1)) != 0) { + if !(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + 1)) != 0) { return -int32(1) } - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1))) == int32('-') && !(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 2)) != 0) { + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + 1))) == int32('-') && !(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + 2)) != 0) { Xoptind = Xoptind + 1 return -Int32FromInt32(1) } if !(X__optpos != 0) { X__optpos = X__optpos + 1 } - v1 = Xmbtowc(tls, bp, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))+uintptr(X__optpos), uint64(MB_LEN_MAX)) + v1 = Xmbtowc(tls, bp, **(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8))+uintptr(X__optpos), uint64(MB_LEN_MAX)) k = v1 if v1 < 0 { k = int32(1) - *(*Twchar_t)(unsafe.Pointer(bp)) = int32(0xfffd) /* replacement char */ + **(**Twchar_t)(__ccgo_up(bp)) = int32(0xfffd) /* replacement char */ } - optchar = *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + uintptr(X__optpos) + optchar = **(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + uintptr(X__optpos) X__optpos = X__optpos + k - if !(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + uintptr(X__optpos))) != 0) { + if !(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + uintptr(X__optpos))) != 0) { Xoptind = Xoptind + 1 X__optpos = 0 } - if int32(*(*int8)(unsafe.Pointer(optstring))) == int32('-') || int32(*(*int8)(unsafe.Pointer(optstring))) == int32('+') { + if int32(**(**int8)(__ccgo_up(optstring))) == int32('-') || int32(**(**int8)(__ccgo_up(optstring))) == int32('+') { optstring = optstring + 1 } i = 0 - *(*Twchar_t)(unsafe.Pointer(bp + 4)) = 0 - for cond := true; cond; cond = l != 0 && *(*Twchar_t)(unsafe.Pointer(bp + 4)) != *(*Twchar_t)(unsafe.Pointer(bp)) { + **(**Twchar_t)(__ccgo_up(bp + 4)) = 0 + for cond := true; cond; cond = l != 0 && **(**Twchar_t)(__ccgo_up(bp + 4)) != **(**Twchar_t)(__ccgo_up(bp)) { l = Xmbtowc(tls, bp+4, optstring+uintptr(i), uint64(MB_LEN_MAX)) if l > 0 { i = i + l @@ -114238,36 +114238,36 @@ func Xgetopt(tls *TLS, argc int32, argv uintptr, optstring uintptr) (r int32) { i = i + 1 } } - if *(*Twchar_t)(unsafe.Pointer(bp + 4)) != *(*Twchar_t)(unsafe.Pointer(bp)) || *(*Twchar_t)(unsafe.Pointer(bp)) == int32(':') { - Xoptopt = *(*Twchar_t)(unsafe.Pointer(bp)) - if int32(*(*int8)(unsafe.Pointer(optstring))) != int32(':') && Xopterr != 0 { - X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), __ccgo_ts+713, optchar, Uint64FromInt32(k)) + if **(**Twchar_t)(__ccgo_up(bp + 4)) != **(**Twchar_t)(__ccgo_up(bp)) || **(**Twchar_t)(__ccgo_up(bp)) == int32(':') { + Xoptopt = **(**Twchar_t)(__ccgo_up(bp)) + if int32(**(**int8)(__ccgo_up(optstring))) != int32(':') && Xopterr != 0 { + X__getopt_msg(tls, **(**uintptr)(__ccgo_up(argv)), __ccgo_ts+713, optchar, Uint64FromInt32(k)) } return int32('?') } - if int32(*(*int8)(unsafe.Pointer(optstring + uintptr(i)))) == int32(':') { + if int32(**(**int8)(__ccgo_up(optstring + uintptr(i)))) == int32(':') { Xoptarg = uintptr(0) - if int32(*(*int8)(unsafe.Pointer(optstring + uintptr(i+int32(1))))) != int32(':') || X__optpos != 0 { + if int32(**(**int8)(__ccgo_up(optstring + uintptr(i+int32(1))))) != int32(':') || X__optpos != 0 { v1 = Xoptind Xoptind = Xoptind + 1 - Xoptarg = *(*uintptr)(unsafe.Pointer(argv + uintptr(v1)*8)) + Xoptarg = **(**uintptr)(__ccgo_up(argv + uintptr(v1)*8)) if X__optpos != 0 { Xoptarg = Xoptarg + uintptr(X__optpos) } X__optpos = 0 } if Xoptind > argc { - Xoptopt = *(*Twchar_t)(unsafe.Pointer(bp)) - if int32(*(*int8)(unsafe.Pointer(optstring))) == int32(':') { + Xoptopt = **(**Twchar_t)(__ccgo_up(bp)) + if int32(**(**int8)(__ccgo_up(optstring))) == int32(':') { return int32(':') } if Xopterr != 0 { - X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), __ccgo_ts+737, optchar, Uint64FromInt32(k)) + X__getopt_msg(tls, **(**uintptr)(__ccgo_up(argv)), __ccgo_ts+737, optchar, Uint64FromInt32(k)) } return int32('?') } } - return *(*Twchar_t)(unsafe.Pointer(bp)) + return **(**Twchar_t)(__ccgo_up(bp)) } func X__posix_getopt(tls *TLS, argc int32, argv uintptr, optstring uintptr) (r int32) { @@ -114294,19 +114294,19 @@ func _permute(tls *TLS, argv uintptr, dest int32, src int32) { var i int32 _, _, _ = av, i, tmp av = argv - tmp = *(*uintptr)(unsafe.Pointer(av + uintptr(src)*8)) + tmp = **(**uintptr)(__ccgo_up(av + uintptr(src)*8)) i = src for { if !(i > dest) { break } - *(*uintptr)(unsafe.Pointer(av + uintptr(i)*8)) = *(*uintptr)(unsafe.Pointer(av + uintptr(i-int32(1))*8)) + **(**uintptr)(__ccgo_up(av + uintptr(i)*8)) = **(**uintptr)(__ccgo_up(av + uintptr(i-int32(1))*8)) goto _1 _1: ; i = i - 1 } - *(*uintptr)(unsafe.Pointer(av + uintptr(dest)*8)) = tmp + **(**uintptr)(__ccgo_up(av + uintptr(dest)*8)) = tmp } func ___getopt_long(tls *TLS, argc int32, argv uintptr, optstring uintptr, longopts uintptr, idx uintptr, longonly int32) (r int32) { @@ -114317,17 +114317,17 @@ func ___getopt_long(tls *TLS, argc int32, argv uintptr, optstring uintptr, longo X__optpos = 0 Xoptind = int32(1) } - if Xoptind >= argc || !(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) != 0) { + if Xoptind >= argc || !(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) != 0) { return -int32(1) } skipped = Xoptind - if int32(*(*int8)(unsafe.Pointer(optstring))) != int32('+') && int32(*(*int8)(unsafe.Pointer(optstring))) != int32('-') { + if int32(**(**int8)(__ccgo_up(optstring))) != int32('+') && int32(**(**int8)(__ccgo_up(optstring))) != int32('-') { i = Xoptind for { - if i >= argc || !(*(*uintptr)(unsafe.Pointer(argv + uintptr(i)*8)) != 0) { + if i >= argc || !(**(**uintptr)(__ccgo_up(argv + uintptr(i)*8)) != 0) { return -int32(1) } - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(i)*8))))) == int32('-') && *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(i)*8)) + 1)) != 0 { + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(i)*8))))) == int32('-') && **(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(i)*8)) + 1)) != 0 { break } goto _1 @@ -114362,31 +114362,31 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, var cnt, colon, i, j, l, match, v2 int32 _, _, _, _, _, _, _, _, _, _, _, _ = arg, cnt, colon, i, j, l, match, name, opt, start, v2, v5 Xoptarg = uintptr(0) - if longopts != 0 && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))))) == int32('-') && (longonly != 0 && *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1)) != 0 && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1))) != int32('-') || int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1))) == int32('-') && *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 2)) != 0) { - colon = BoolInt32(int32(*(*int8)(unsafe.Pointer(optstring + BoolUintptr(int32(*(*int8)(unsafe.Pointer(optstring))) == int32('+') || int32(*(*int8)(unsafe.Pointer(optstring))) == int32('-'))))) == int32(':')) - start = *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + uintptr(1) + if longopts != 0 && int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8))))) == int32('-') && (longonly != 0 && **(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + 1)) != 0 && int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + 1))) != int32('-') || int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + 1))) == int32('-') && **(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + 2)) != 0) { + colon = BoolInt32(int32(**(**int8)(__ccgo_up(optstring + BoolUintptr(int32(**(**int8)(__ccgo_up(optstring))) == int32('+') || int32(**(**int8)(__ccgo_up(optstring))) == int32('-'))))) == int32(':')) + start = **(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + uintptr(1) v2 = Int32FromInt32(0) i = v2 cnt = v2 for { - if !((*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname != 0) { + if !((**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fname != 0) { break } - name = (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname + name = (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fname opt = start - if int32(*(*int8)(unsafe.Pointer(opt))) == int32('-') { + if int32(**(**int8)(__ccgo_up(opt))) == int32('-') { opt = opt + 1 } - for *(*int8)(unsafe.Pointer(opt)) != 0 && int32(*(*int8)(unsafe.Pointer(opt))) != int32('=') && int32(*(*int8)(unsafe.Pointer(opt))) == int32(*(*int8)(unsafe.Pointer(name))) { + for **(**int8)(__ccgo_up(opt)) != 0 && int32(**(**int8)(__ccgo_up(opt))) != int32('=') && int32(**(**int8)(__ccgo_up(opt))) == int32(**(**int8)(__ccgo_up(name))) { name = name + 1 opt = opt + 1 } - if *(*int8)(unsafe.Pointer(opt)) != 0 && int32(*(*int8)(unsafe.Pointer(opt))) != int32('=') { + if **(**int8)(__ccgo_up(opt)) != 0 && int32(**(**int8)(__ccgo_up(opt))) != int32('=') { goto _1 } arg = opt match = i - if !(*(*int8)(unsafe.Pointer(name)) != 0) { + if !(**(**int8)(__ccgo_up(name)) != 0) { cnt = int32(1) break } @@ -114400,12 +114400,12 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, l = int32(int64(arg) - int64(start)) i = 0 for { - if !(*(*int8)(unsafe.Pointer(optstring + uintptr(i))) != 0) { + if !(**(**int8)(__ccgo_up(optstring + uintptr(i))) != 0) { break } j = 0 for { - if !(j < l && int32(*(*int8)(unsafe.Pointer(start + uintptr(j)))) == int32(*(*int8)(unsafe.Pointer(optstring + uintptr(i+j))))) { + if !(j < l && int32(**(**int8)(__ccgo_up(start + uintptr(j)))) == int32(**(**int8)(__ccgo_up(optstring + uintptr(i+j))))) { break } goto _4 @@ -114427,44 +114427,44 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, i = match opt = arg Xoptind = Xoptind + 1 - if int32(*(*int8)(unsafe.Pointer(opt))) == int32('=') { - if !((*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fhas_arg != 0) { - Xoptopt = (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fval + if int32(**(**int8)(__ccgo_up(opt))) == int32('=') { + if !((**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fhas_arg != 0) { + Xoptopt = (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fval if colon != 0 || !(Xopterr != 0) { return int32('?') } - X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), __ccgo_ts+769, (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname, _strlen(tls, (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname)) + X__getopt_msg(tls, **(**uintptr)(__ccgo_up(argv)), __ccgo_ts+769, (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fname, _strlen(tls, (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fname)) return int32('?') } Xoptarg = opt + uintptr(1) } else { - if (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fhas_arg == int32(required_argument) { - v5 = *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + if (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fhas_arg == int32(required_argument) { + v5 = **(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) Xoptarg = v5 if !(v5 != 0) { - Xoptopt = (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fval + Xoptopt = (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fval if colon != 0 { return int32(':') } if !(Xopterr != 0) { return int32('?') } - X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), __ccgo_ts+737, (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname, _strlen(tls, (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname)) + X__getopt_msg(tls, **(**uintptr)(__ccgo_up(argv)), __ccgo_ts+737, (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fname, _strlen(tls, (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fname)) return int32('?') } Xoptind = Xoptind + 1 } } if idx != 0 { - *(*int32)(unsafe.Pointer(idx)) = i + **(**int32)(__ccgo_up(idx)) = i } - if (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fflag != 0 { - *(*int32)(unsafe.Pointer((*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fflag)) = (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fval + if (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fflag != 0 { + **(**int32)(__ccgo_up((**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fflag)) = (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fval return 0 } - return (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fval + return (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fval } - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1))) == int32('-') { + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + 1))) == int32('-') { Xoptopt = 0 if !(colon != 0) && Xopterr != 0 { if cnt != 0 { @@ -114472,7 +114472,7 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, } else { v5 = __ccgo_ts + 713 } - X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), v5, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))+uintptr(2), _strlen(tls, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))+uintptr(2))) + X__getopt_msg(tls, **(**uintptr)(__ccgo_up(argv)), v5, **(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8))+uintptr(2), _strlen(tls, **(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8))+uintptr(2))) } Xoptind = Xoptind + 1 return int32('?') @@ -114547,22 +114547,22 @@ func Xgetrlimit(tls *TLS, resource int32, rlim uintptr) (r int32) { (*Trlimit)(unsafe.Pointer(rlim)).Frlim_max = ^Uint64FromUint64(0) } } - if !(ret != 0) || *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(ENOSYS) { + if !(ret != 0) || **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(ENOSYS) { return ret } if X__syscall_ret(tls, Uint64FromInt64(X__syscall2(tls, int64(SYS_getrlimit), int64(resource), int64(bp)))) < 0 { return -int32(1) } - if (*(*[2]uint64)(unsafe.Pointer(bp)))[0] == -Uint64FromUint64(1) { + if (**(**[2]uint64)(__ccgo_up(bp)))[0] == -Uint64FromUint64(1) { v1 = ^Uint64FromUint64(0) } else { - v1 = (*(*[2]uint64)(unsafe.Pointer(bp)))[0] + v1 = (**(**[2]uint64)(__ccgo_up(bp)))[0] } (*Trlimit)(unsafe.Pointer(rlim)).Frlim_cur = v1 - if (*(*[2]uint64)(unsafe.Pointer(bp)))[int32(1)] == -Uint64FromUint64(1) { + if (**(**[2]uint64)(__ccgo_up(bp)))[int32(1)] == -Uint64FromUint64(1) { v1 = ^Uint64FromUint64(0) } else { - v1 = (*(*[2]uint64)(unsafe.Pointer(bp)))[int32(1)] + v1 = (**(**[2]uint64)(__ccgo_up(bp)))[int32(1)] } (*Trlimit)(unsafe.Pointer(rlim)).Frlim_max = v1 if (*Trlimit)(unsafe.Pointer(rlim)).Frlim_cur >= ^Uint64FromUint64(0) { @@ -114590,12 +114590,12 @@ func Xgetrusage(tls *TLS, who int32, ru uintptr) (r1 int32) { if !(r != 0) && Bool(uint64(8) > uint64(8)) { Xmemcpy(tls, bp, dest, Uint64FromInt32(4)*Uint64FromInt64(8)) (*Trusage)(unsafe.Pointer(ru)).Fru_utime = Ttimeval{ - Ftv_sec: (*(*[4]int64)(unsafe.Pointer(bp)))[0], - Ftv_usec: (*(*[4]int64)(unsafe.Pointer(bp)))[int32(1)], + Ftv_sec: (**(**[4]int64)(__ccgo_up(bp)))[0], + Ftv_usec: (**(**[4]int64)(__ccgo_up(bp)))[int32(1)], } (*Trusage)(unsafe.Pointer(ru)).Fru_stime = Ttimeval{ - Ftv_sec: (*(*[4]int64)(unsafe.Pointer(bp)))[int32(2)], - Ftv_usec: (*(*[4]int64)(unsafe.Pointer(bp)))[int32(3)], + Ftv_sec: (**(**[4]int64)(__ccgo_up(bp)))[int32(2)], + Ftv_usec: (**(**[4]int64)(__ccgo_up(bp)))[int32(3)], } } return int32(X__syscall_ret(tls, Uint64FromInt32(r))) @@ -114610,30 +114610,30 @@ func Xgetsubopt(tls *TLS, opt uintptr, keys uintptr, val uintptr) (r int32) { var l Tsize_t var s, v1, v2 uintptr _, _, _, _, _ = i, l, s, v1, v2 - s = *(*uintptr)(unsafe.Pointer(opt)) - *(*uintptr)(unsafe.Pointer(val)) = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(opt)) = Xstrchr(tls, s, int32(',')) - if *(*uintptr)(unsafe.Pointer(opt)) != 0 { + s = **(**uintptr)(__ccgo_up(opt)) + **(**uintptr)(__ccgo_up(val)) = UintptrFromInt32(0) + **(**uintptr)(__ccgo_up(opt)) = Xstrchr(tls, s, int32(',')) + if **(**uintptr)(__ccgo_up(opt)) != 0 { v2 = opt v1 = *(*uintptr)(unsafe.Pointer(v2)) *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(v2)) + 1 - *(*int8)(unsafe.Pointer(v1)) = 0 + **(**int8)(__ccgo_up(v1)) = 0 } else { - *(*uintptr)(unsafe.Pointer(opt)) = s + uintptr(_strlen(tls, s)) + **(**uintptr)(__ccgo_up(opt)) = s + uintptr(_strlen(tls, s)) } i = 0 for { - if !(*(*uintptr)(unsafe.Pointer(keys + uintptr(i)*8)) != 0) { + if !(**(**uintptr)(__ccgo_up(keys + uintptr(i)*8)) != 0) { break } - l = _strlen(tls, *(*uintptr)(unsafe.Pointer(keys + uintptr(i)*8))) - if Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(keys + uintptr(i)*8)), s, l) != 0 { + l = _strlen(tls, **(**uintptr)(__ccgo_up(keys + uintptr(i)*8))) + if Xstrncmp(tls, **(**uintptr)(__ccgo_up(keys + uintptr(i)*8)), s, l) != 0 { goto _3 } - if int32(*(*int8)(unsafe.Pointer(s + uintptr(l)))) == int32('=') { - *(*uintptr)(unsafe.Pointer(val)) = s + uintptr(l) + uintptr(1) + if int32(**(**int8)(__ccgo_up(s + uintptr(l)))) == int32('=') { + **(**uintptr)(__ccgo_up(val)) = s + uintptr(l) + uintptr(1) } else { - if *(*int8)(unsafe.Pointer(s + uintptr(l))) != 0 { + if **(**int8)(__ccgo_up(s + uintptr(l))) != 0 { goto _3 } } @@ -114922,7 +114922,7 @@ func _convert_ioctl_struct(tls *TLS, map1 uintptr, old uintptr, new1 uintptr, di if !(i < Int32FromUint8((*Tioctl_compat_map)(unsafe.Pointer(map1)).Fnoffs)) { break } - ts_offset = Int32FromUint8(*(*uint8)(unsafe.Pointer(map1 + 12 + uintptr(i)))) + ts_offset = Int32FromUint8(**(**uint8)(__ccgo_up(map1 + 12 + uintptr(i)))) len1 = ts_offset - old_offset if dir == int32(W) { Xmemcpy(tls, old+uintptr(old_offset), new1+uintptr(new_offset), Uint64FromInt32(len1)) @@ -114940,11 +114940,11 @@ func _convert_ioctl_struct(tls *TLS, map1 uintptr, old uintptr, new1 uintptr, di new_offset = new_offset + (align-int32(1))&-new_offset if dir == int32(W) { Xmemcpy(tls, bp, new1+uintptr(new_offset), uint64(8)) - *(*int64)(unsafe.Pointer(bp + 8)) = *(*int64)(unsafe.Pointer(bp)) + **(**int64)(__ccgo_up(bp + 8)) = int64(**(**int64)(__ccgo_up(bp))) Xmemcpy(tls, old+uintptr(old_offset), bp+8, uint64(8)) } else { Xmemcpy(tls, bp+8, old+uintptr(old_offset), uint64(8)) - *(*int64)(unsafe.Pointer(bp)) = *(*int64)(unsafe.Pointer(bp + 8)) + **(**int64)(__ccgo_up(bp)) = int64(**(**int64)(__ccgo_up(bp + 8))) Xmemcpy(tls, new1+uintptr(new_offset), bp, uint64(8)) } new_offset = Int32FromUint64(uint64(new_offset) + Uint64FromInt64(8)) @@ -115022,31 +115022,31 @@ func Xlockf(tls *TLS, fd int32, op int32, size Toff_t) (r int32) { bp := tls.Alloc(48) defer tls.Free(48) var _ /* l at bp+0 */ Tflock - *(*Tflock)(unsafe.Pointer(bp)) = Tflock{ + **(**Tflock)(__ccgo_up(bp)) = Tflock{ Fl_type: int16(F_WRLCK), Fl_whence: int16(1), Fl_len: size, } switch op { case int32(F_TEST): - (*(*Tflock)(unsafe.Pointer(bp))).Fl_type = F_RDLCK + (**(**Tflock)(__ccgo_up(bp))).Fl_type = F_RDLCK if Xfcntl(tls, fd, int32(F_GETLK), VaList(bp+40, bp)) < 0 { return -int32(1) } - if int32((*(*Tflock)(unsafe.Pointer(bp))).Fl_type) == int32(F_UNLCK) || (*(*Tflock)(unsafe.Pointer(bp))).Fl_pid == Xgetpid(tls) { + if int32((**(**Tflock)(__ccgo_up(bp))).Fl_type) == int32(F_UNLCK) || (**(**Tflock)(__ccgo_up(bp))).Fl_pid == Xgetpid(tls) { return 0 } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EACCES) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EACCES) return -int32(1) case F_ULOCK: - (*(*Tflock)(unsafe.Pointer(bp))).Fl_type = int16(F_UNLCK) + (**(**Tflock)(__ccgo_up(bp))).Fl_type = int16(F_UNLCK) fallthrough case int32(F_TLOCK): return Xfcntl(tls, fd, int32(F_SETLK), VaList(bp+40, bp)) case int32(F_LOCK): return Xfcntl(tls, fd, int32(F_SETLKW), VaList(bp+40, bp)) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } @@ -115148,23 +115148,23 @@ func _unescape_ent(tls *TLS, beg uintptr) (r uintptr) { _, _, _, _, _, _, _ = cval, dest, i, src, val, v1, v2 dest = beg src = beg - for *(*int8)(unsafe.Pointer(src)) != 0 { + for **(**int8)(__ccgo_up(src)) != 0 { cval = uint8(0) - if int32(*(*int8)(unsafe.Pointer(src))) != int32('\\') { + if int32(**(**int8)(__ccgo_up(src))) != int32('\\') { v1 = dest dest = dest + 1 v2 = src src = src + 1 - *(*int8)(unsafe.Pointer(v1)) = *(*int8)(unsafe.Pointer(v2)) + **(**int8)(__ccgo_up(v1)) = **(**int8)(__ccgo_up(v2)) continue } - if int32(*(*int8)(unsafe.Pointer(src + 1))) == int32('\\') { + if int32(**(**int8)(__ccgo_up(src + 1))) == int32('\\') { src = src + 1 v1 = dest dest = dest + 1 v2 = src src = src + 1 - *(*int8)(unsafe.Pointer(v1)) = *(*int8)(unsafe.Pointer(v2)) + **(**int8)(__ccgo_up(v1)) = **(**int8)(__ccgo_up(v2)) continue } val = src + uintptr(1) @@ -115173,11 +115173,11 @@ func _unescape_ent(tls *TLS, beg uintptr) (r uintptr) { if !(i < int32(3)) { break } - if int32(*(*int8)(unsafe.Pointer(val))) >= int32('0') && int32(*(*int8)(unsafe.Pointer(val))) <= int32('7') { + if int32(**(**int8)(__ccgo_up(val))) >= int32('0') && int32(**(**int8)(__ccgo_up(val))) <= int32('7') { cval = Uint8FromInt32(int32(cval) << Int32FromInt32(3)) v1 = val val = val + 1 - cval = Uint8FromInt32(int32(cval) + (int32(*(*int8)(unsafe.Pointer(v1))) - Int32FromUint8('0'))) + cval = Uint8FromInt32(int32(cval) + (int32(**(**int8)(__ccgo_up(v1))) - Int32FromUint8('0'))) } else { break } @@ -115189,17 +115189,17 @@ func _unescape_ent(tls *TLS, beg uintptr) (r uintptr) { if cval != 0 { v1 = dest dest = dest + 1 - *(*int8)(unsafe.Pointer(v1)) = Int8FromUint8(cval) + **(**int8)(__ccgo_up(v1)) = Int8FromUint8(cval) src = val } else { v1 = dest dest = dest + 1 v2 = src src = src + 1 - *(*int8)(unsafe.Pointer(v1)) = *(*int8)(unsafe.Pointer(v2)) + **(**int8)(__ccgo_up(v1)) = **(**int8)(__ccgo_up(v2)) } } - *(*int8)(unsafe.Pointer(dest)) = 0 + **(**int8)(__ccgo_up(dest)) = 0 return beg } @@ -115217,7 +115217,7 @@ func Xgetmntent_r(tls *TLS, f uintptr, mnt uintptr, linebuf uintptr, buflen int3 use_internal = BoolInt32(linebuf == uintptr(unsafe.Pointer(&_internal_buf))) (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_freq = 0 (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_passno = 0 - for cond := true; cond; cond = int32(*(*int8)(unsafe.Pointer(linebuf + uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[0])))) == int32('#') || Uint64FromInt32((*(*[8]int32)(unsafe.Pointer(bp)))[int32(1)]) == len1 { + for cond := true; cond; cond = int32(**(**int8)(__ccgo_up(linebuf + uintptr((**(**[8]int32)(__ccgo_up(bp)))[0])))) == int32('#') || Uint64FromInt32((**(**[8]int32)(__ccgo_up(bp)))[int32(1)]) == len1 { if use_internal != 0 { Xgetline(tls, uintptr(unsafe.Pointer(&_internal_buf)), uintptr(unsafe.Pointer(&_internal_bufsize)), f) linebuf = _internal_buf @@ -115229,7 +115229,7 @@ func Xgetmntent_r(tls *TLS, f uintptr, mnt uintptr, linebuf uintptr, buflen int3 } if !(Xstrchr(tls, linebuf, int32('\n')) != 0) { Xfscanf(tls, f, __ccgo_ts+830, 0) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return uintptr(0) } len1 = _strlen(tls, linebuf) @@ -115241,7 +115241,7 @@ func Xgetmntent_r(tls *TLS, f uintptr, mnt uintptr, linebuf uintptr, buflen int3 if !(i < Uint64FromInt64(32)/Uint64FromInt64(4)) { break } - (*(*[8]int32)(unsafe.Pointer(bp)))[i] = Int32FromUint64(len1) + (**(**[8]int32)(__ccgo_up(bp)))[i] = Int32FromUint64(len1) goto _1 _1: ; @@ -115249,14 +115249,14 @@ func Xgetmntent_r(tls *TLS, f uintptr, mnt uintptr, linebuf uintptr, buflen int3 } Xsscanf(tls, linebuf, __ccgo_ts+842, VaList(bp+40, bp, bp+uintptr(1)*4, bp+uintptr(2)*4, bp+uintptr(3)*4, bp+uintptr(4)*4, bp+uintptr(5)*4, bp+uintptr(6)*4, bp+uintptr(7)*4, mnt+32, mnt+36)) } - *(*int8)(unsafe.Pointer(linebuf + uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(1)]))) = 0 - *(*int8)(unsafe.Pointer(linebuf + uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(3)]))) = 0 - *(*int8)(unsafe.Pointer(linebuf + uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(5)]))) = 0 - *(*int8)(unsafe.Pointer(linebuf + uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(7)]))) = 0 - (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_fsname = _unescape_ent(tls, linebuf+uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[0])) - (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_dir = _unescape_ent(tls, linebuf+uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(2)])) - (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_type = _unescape_ent(tls, linebuf+uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(4)])) - (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_opts = _unescape_ent(tls, linebuf+uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(6)])) + **(**int8)(__ccgo_up(linebuf + uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(1)]))) = 0 + **(**int8)(__ccgo_up(linebuf + uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(3)]))) = 0 + **(**int8)(__ccgo_up(linebuf + uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(5)]))) = 0 + **(**int8)(__ccgo_up(linebuf + uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(7)]))) = 0 + (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_fsname = _unescape_ent(tls, linebuf+uintptr((**(**[8]int32)(__ccgo_up(bp)))[0])) + (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_dir = _unescape_ent(tls, linebuf+uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(2)])) + (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_type = _unescape_ent(tls, linebuf+uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(4)])) + (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_opts = _unescape_ent(tls, linebuf+uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(6)])) return mnt } @@ -115313,39 +115313,39 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag var _ /* st at bp+0 */ Tstat _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, de, dfd, err, j, k, l, r, type1, v1, v10, v2, v3, v8 l = _strlen(tls, path) - if l != 0 && int32(*(*int8)(unsafe.Pointer(path + uintptr(l-uint64(1))))) == int32('/') { + if l != 0 && int32(**(**int8)(__ccgo_up(path + uintptr(l-uint64(1))))) == int32('/') { v1 = l - uint64(1) } else { v1 = l } j = v1 v2 = Uint64FromInt32(0) - (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino = v2 - (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev = v2 + (**(**Tstat)(__ccgo_up(bp))).Fst_ino = v2 + (**(**Tstat)(__ccgo_up(bp))).Fst_dev = v2 if flags&int32(FTW_PHYS) != 0 { v3 = Xlstat(tls, path, bp) } else { v3 = BoolInt32(Xstat(tls, path, bp) < 0) } if v3 != 0 { - if !(flags&Int32FromInt32(FTW_PHYS) != 0) && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENOENT) && !(Xlstat(tls, path, bp) != 0) { + if !(flags&Int32FromInt32(FTW_PHYS) != 0) && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENOENT) && !(Xlstat(tls, path, bp) != 0) { type1 = int32(FTW_SLN) } else { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(EACCES) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(EACCES) { return -int32(1) } else { type1 = int32(FTW_NS) } } } else { - if (*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFDIR) { + if (**(**Tstat)(__ccgo_up(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFDIR) { if flags&int32(FTW_DEPTH) != 0 { type1 = int32(FTW_DP) } else { type1 = int32(FTW_D) } } else { - if (*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { + if (**(**Tstat)(__ccgo_up(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { if flags&int32(FTW_PHYS) != 0 { type1 = int32(FTW_SL) } else { @@ -115356,26 +115356,26 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag } } } - if flags&int32(FTW_MOUNT) != 0 && h != 0 && type1 != int32(FTW_NS) && (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev != (*Thistory)(unsafe.Pointer(h)).Fdev { + if flags&int32(FTW_MOUNT) != 0 && h != 0 && type1 != int32(FTW_NS) && (**(**Tstat)(__ccgo_up(bp))).Fst_dev != (*Thistory)(unsafe.Pointer(h)).Fdev { return 0 } - (*(*Thistory)(unsafe.Pointer(bp + 144))).Fchain = h - (*(*Thistory)(unsafe.Pointer(bp + 144))).Fdev = (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev - (*(*Thistory)(unsafe.Pointer(bp + 144))).Fino = (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino + (**(**Thistory)(__ccgo_up(bp + 144))).Fchain = h + (**(**Thistory)(__ccgo_up(bp + 144))).Fdev = (**(**Tstat)(__ccgo_up(bp))).Fst_dev + (**(**Thistory)(__ccgo_up(bp + 144))).Fino = (**(**Tstat)(__ccgo_up(bp))).Fst_ino if h != 0 { v3 = (*Thistory)(unsafe.Pointer(h)).Flevel + int32(1) } else { v3 = 0 } - (*(*Thistory)(unsafe.Pointer(bp + 144))).Flevel = v3 - (*(*Thistory)(unsafe.Pointer(bp + 144))).Fbase = Int32FromUint64(j + uint64(1)) - (*(*TFTW)(unsafe.Pointer(bp + 176))).Flevel = (*(*Thistory)(unsafe.Pointer(bp + 144))).Flevel + (**(**Thistory)(__ccgo_up(bp + 144))).Flevel = v3 + (**(**Thistory)(__ccgo_up(bp + 144))).Fbase = Int32FromUint64(j + uint64(1)) + (**(**TFTW)(__ccgo_up(bp + 176))).Flevel = (**(**Thistory)(__ccgo_up(bp + 144))).Flevel if h != 0 { - (*(*TFTW)(unsafe.Pointer(bp + 176))).Fbase = (*Thistory)(unsafe.Pointer(h)).Fbase + (**(**TFTW)(__ccgo_up(bp + 176))).Fbase = (*Thistory)(unsafe.Pointer(h)).Fbase } else { k = j for { - if !(k != 0 && int32(*(*int8)(unsafe.Pointer(path + uintptr(k)))) == int32('/')) { + if !(k != 0 && int32(**(**int8)(__ccgo_up(path + uintptr(k)))) == int32('/')) { break } goto _5 @@ -115384,7 +115384,7 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag k = k - 1 } for { - if !(k != 0 && int32(*(*int8)(unsafe.Pointer(path + uintptr(k-uint64(1))))) != int32('/')) { + if !(k != 0 && int32(**(**int8)(__ccgo_up(path + uintptr(k-uint64(1))))) != int32('/')) { break } goto _6 @@ -115392,11 +115392,11 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag ; k = k - 1 } - (*(*TFTW)(unsafe.Pointer(bp + 176))).Fbase = Int32FromUint64(k) + (**(**TFTW)(__ccgo_up(bp + 176))).Fbase = Int32FromUint64(k) } if type1 == int32(FTW_D) || type1 == int32(FTW_DP) { dfd = Xopen(tls, path, O_RDONLY, 0) - err = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + err = **(**int32)(__ccgo_up(X__errno_location(tls))) if dfd < 0 && err == int32(EACCES) { type1 = int32(FTW_DNR) } @@ -115415,7 +115415,7 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag if !(h != 0) { break } - if (*Thistory)(unsafe.Pointer(h)).Fdev == (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev && (*Thistory)(unsafe.Pointer(h)).Fino == (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino { + if (*Thistory)(unsafe.Pointer(h)).Fdev == (**(**Tstat)(__ccgo_up(bp))).Fst_dev && (*Thistory)(unsafe.Pointer(h)).Fino == (**(**Tstat)(__ccgo_up(bp))).Fst_ino { return 0 } goto _9 @@ -115425,7 +115425,7 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag } if (type1 == int32(FTW_D) || type1 == int32(FTW_DP)) && fd_limit != 0 { if dfd < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = err + **(**int32)(__ccgo_up(X__errno_location(tls))) = err return -int32(1) } d = Xfdopendir(tls, dfd) @@ -115436,15 +115436,15 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag if !(v10 != 0) { break } - if int32(*(*int8)(unsafe.Pointer(de + 19))) == int32('.') && (!(*(*int8)(unsafe.Pointer(de + 19 + 1)) != 0) || int32(*(*int8)(unsafe.Pointer(de + 19 + 1))) == int32('.') && !(*(*int8)(unsafe.Pointer(de + 19 + 2)) != 0)) { + if int32(**(**int8)(__ccgo_up(de + 19))) == int32('.') && (!(**(**int8)(__ccgo_up(de + 19 + 1)) != 0) || int32(**(**int8)(__ccgo_up(de + 19 + 1))) == int32('.') && !(**(**int8)(__ccgo_up(de + 19 + 2)) != 0)) { continue } if _strlen(tls, de+19) >= uint64(PATH_MAX)-l { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENAMETOOLONG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENAMETOOLONG) Xclosedir(tls, d) return -int32(1) } - *(*int8)(unsafe.Pointer(path + uintptr(j))) = int8('/') + **(**int8)(__ccgo_up(path + uintptr(j))) = int8('/') Xstrcpy(tls, path+uintptr(j)+uintptr(1), de+19) v3 = _do_nftw(tls, path, __ccgo_fp_fn, fd_limit-int32(1), flags, bp+144) r = v3 @@ -115459,7 +115459,7 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag return -int32(1) } } - *(*int8)(unsafe.Pointer(path + uintptr(l))) = 0 + **(**int8)(__ccgo_up(path + uintptr(l))) = 0 if v8 = flags&int32(FTW_DEPTH) != 0; v8 { v3 = (*(*func(*TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_fn})))(tls, path, bp, type1, bp+176) r = v3 @@ -115489,13 +115489,13 @@ func Xnftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flags i } l = _strlen(tls, path) if l > uint64(PATH_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENAMETOOLONG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENAMETOOLONG) return -int32(1) } Xmemcpy(tls, bp+4, path, l+uint64(1)) _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp) r = _do_nftw(tls, bp+4, __ccgo_fp_fn, fd_limit, flags, UintptrFromInt32(0)) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) return r } @@ -115513,7 +115513,7 @@ func Xopenpty(tls *TLS, pm uintptr, ps uintptr, name uintptr, tio uintptr, ws ui var _ /* cs at bp+4 */ int32 var _ /* n at bp+0 */ int32 _, _, _ = m, s, v1 - *(*int32)(unsafe.Pointer(bp)) = 0 + **(**int32)(__ccgo_up(bp)) = 0 m = Xopen(tls, __ccgo_ts+916, Int32FromInt32(O_RDWR)|Int32FromInt32(O_NOCTTY), 0) if m < 0 { return -int32(1) @@ -115525,7 +115525,7 @@ func Xopenpty(tls *TLS, pm uintptr, ps uintptr, name uintptr, tio uintptr, ws ui if !(name != 0) { name = bp + 8 } - Xsnprintf(tls, name, uint64(20), __ccgo_ts+926, VaList(bp+40, *(*int32)(unsafe.Pointer(bp)))) + Xsnprintf(tls, name, uint64(20), __ccgo_ts+926, VaList(bp+40, **(**int32)(__ccgo_up(bp)))) v1 = Xopen(tls, name, Int32FromInt32(O_RDWR)|Int32FromInt32(O_NOCTTY), 0) s = v1 if v1 < 0 { @@ -115537,15 +115537,15 @@ func Xopenpty(tls *TLS, pm uintptr, ps uintptr, name uintptr, tio uintptr, ws ui if ws != 0 { Xioctl(tls, s, int32(TIOCSWINSZ), VaList(bp+40, ws)) } - *(*int32)(unsafe.Pointer(pm)) = m - *(*int32)(unsafe.Pointer(ps)) = s - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 4)), uintptr(0)) + **(**int32)(__ccgo_up(pm)) = m + **(**int32)(__ccgo_up(ps)) = s + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 4)), uintptr(0)) return 0 goto fail fail: ; Xclose(tls, m) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 4)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 4)), uintptr(0)) return -int32(1) } @@ -115558,7 +115558,7 @@ func Xptsname(tls *TLS, fd int32) (r uintptr) { _ = err err = X__ptsname_r(tls, fd, uintptr(unsafe.Pointer(&_buf2)), uint64(22)) if err != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = err + **(**int32)(__ccgo_up(X__errno_location(tls))) = err return uintptr(0) } return uintptr(unsafe.Pointer(&_buf2)) @@ -115574,8 +115574,8 @@ func Xposix_openpt(tls *TLS, flags int32) (r1 int32) { var r int32 _ = r r = Xopen(tls, __ccgo_ts+916, flags, 0) - if r < 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENOSPC) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EAGAIN) + if r < 0 && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENOSPC) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EAGAIN) } return r } @@ -115596,7 +115596,7 @@ func Xunlockpt(tls *TLS, fd int32) (r int32) { bp := tls.Alloc(32) defer tls.Free(32) var _ /* unlock at bp+0 */ int32 - *(*int32)(unsafe.Pointer(bp)) = 0 + **(**int32)(__ccgo_up(bp)) = 0 return Xioctl(tls, fd, int32(TIOCSPTLCK), VaList(bp+16, bp)) } @@ -115618,7 +115618,7 @@ func X__ptsname_r(tls *TLS, fd int32, buf uintptr, len1 Tsize_t) (r int32) { if v1 != 0 { return -err } - if Uint64FromInt32(Xsnprintf(tls, buf, len1, __ccgo_ts+926, VaList(bp+16, *(*int32)(unsafe.Pointer(bp))))) >= len1 { + if Uint64FromInt32(Xsnprintf(tls, buf, len1, __ccgo_ts+926, VaList(bp+16, **(**int32)(__ccgo_up(bp))))) >= len1 { return int32(ERANGE) } return 0 @@ -115636,7 +115636,7 @@ func _slash_len(tls *TLS, s uintptr) (r Tsize_t) { var s0 uintptr _ = s0 s0 = s - for int32(*(*int8)(unsafe.Pointer(s))) == int32('/') { + for int32(**(**int8)(__ccgo_up(s))) == int32('/') { s = s + 1 } return Uint64FromInt64(int64(s) - int64(s0)) @@ -115660,12 +115660,12 @@ func Xrealpath(tls *TLS, filename uintptr, resolved uintptr) (r uintptr) { nup = uint64(0) check_dir = 0 if !(filename != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } l = Xstrnlen(tls, filename, uint64(4097)) if !(l != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOENT) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOENT) return uintptr(0) } if l >= uint64(PATH_MAX) { @@ -115685,19 +115685,19 @@ _3: ; /* If stack starts with /, the whole component is / or // * and the output state must be reset. */ - if int32((*(*[4097]int8)(unsafe.Pointer(bp)))[p]) == int32('/') { + if int32((**(**[4097]int8)(__ccgo_up(bp)))[p]) == int32('/') { check_dir = 0 nup = uint64(0) q = uint64(0) v4 = q q = q + 1 - (*(*[4096]int8)(unsafe.Pointer(bp + 4097)))[v4] = int8('/') + (**(**[4096]int8)(__ccgo_up(bp + 4097)))[v4] = int8('/') p = p + 1 /* Initial // is special. */ - if int32((*(*[4097]int8)(unsafe.Pointer(bp)))[p]) == int32('/') && int32((*(*[4097]int8)(unsafe.Pointer(bp)))[p+uint64(1)]) != int32('/') { + if int32((**(**[4097]int8)(__ccgo_up(bp)))[p]) == int32('/') && int32((**(**[4097]int8)(__ccgo_up(bp)))[p+uint64(1)]) != int32('/') { v4 = q q = q + 1 - (*(*[4096]int8)(unsafe.Pointer(bp + 4097)))[v4] = int8('/') + (**(**[4096]int8)(__ccgo_up(bp + 4097)))[v4] = int8('/') } goto _2 } @@ -115709,30 +115709,30 @@ _3: goto _1 } /* Skip any . component but preserve check_dir status. */ - if l == uint64(1) && int32((*(*[4097]int8)(unsafe.Pointer(bp)))[p]) == int32('.') { + if l == uint64(1) && int32((**(**[4097]int8)(__ccgo_up(bp)))[p]) == int32('.') { p = p + l goto _2 } /* Copy next component onto output at least temporarily, to * call readlink, but wait to advance output position until * determining it's not a link. */ - if q != 0 && int32((*(*[4096]int8)(unsafe.Pointer(bp + 4097)))[q-uint64(1)]) != int32('/') { + if q != 0 && int32((**(**[4096]int8)(__ccgo_up(bp + 4097)))[q-uint64(1)]) != int32('/') { if !(p != 0) { goto toolong } p = p - 1 v4 = p - (*(*[4097]int8)(unsafe.Pointer(bp)))[v4] = int8('/') + (**(**[4097]int8)(__ccgo_up(bp)))[v4] = int8('/') l = l + 1 } if q+l >= uint64(PATH_MAX) { goto toolong } Xmemcpy(tls, bp+4097+uintptr(q), bp+uintptr(p), l) - (*(*[4096]int8)(unsafe.Pointer(bp + 4097)))[q+l] = 0 + (**(**[4096]int8)(__ccgo_up(bp + 4097)))[q+l] = 0 p = p + l up = 0 - if l0 == uint64(2) && int32((*(*[4097]int8)(unsafe.Pointer(bp)))[p-uint64(2)]) == int32('.') && int32((*(*[4097]int8)(unsafe.Pointer(bp)))[p-uint64(1)]) == int32('.') { + if l0 == uint64(2) && int32((**(**[4097]int8)(__ccgo_up(bp)))[p-uint64(2)]) == int32('.') && int32((**(**[4097]int8)(__ccgo_up(bp)))[p-uint64(1)]) == int32('.') { up = int32(1) /* Any non-.. path components we could cancel start * after nup repetitions of the 3-byte string "../"; @@ -115754,13 +115754,13 @@ _3: goto toolong } if !(k != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOENT) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOENT) return uintptr(0) } if !(k < 0) { goto _8 } - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(EINVAL) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(EINVAL) { return uintptr(0) } goto skip_readlink @@ -115768,10 +115768,10 @@ skip_readlink: ; check_dir = 0 if up != 0 { - for q != 0 && int32((*(*[4096]int8)(unsafe.Pointer(bp + 4097)))[q-uint64(1)]) != int32('/') { + for q != 0 && int32((**(**[4096]int8)(__ccgo_up(bp + 4097)))[q-uint64(1)]) != int32('/') { q = q - 1 } - if q > uint64(1) && (q > uint64(2) || int32((*(*[4096]int8)(unsafe.Pointer(bp + 4097)))[0]) != int32('/')) { + if q > uint64(1) && (q > uint64(2) || int32((**(**[4096]int8)(__ccgo_up(bp + 4097)))[0]) != int32('/')) { q = q - 1 } goto _2 @@ -115779,20 +115779,20 @@ skip_readlink: if l0 != 0 { q = q + l } - check_dir = int32((*(*[4097]int8)(unsafe.Pointer(bp)))[p]) + check_dir = int32((**(**[4097]int8)(__ccgo_up(bp)))[p]) goto _2 _8: ; cnt = cnt + 1 v4 = cnt if v4 == uint64(SYMLOOP_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ELOOP) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ELOOP) return uintptr(0) } /* If link contents end in /, strip any slashes already on * stack to avoid /->// or //->/// or spurious toolong. */ - if int32((*(*[4097]int8)(unsafe.Pointer(bp)))[k-int64(1)]) == int32('/') { - for int32((*(*[4097]int8)(unsafe.Pointer(bp)))[p]) == int32('/') { + if int32((**(**[4097]int8)(__ccgo_up(bp)))[k-int64(1)]) == int32('/') { + for int32((**(**[4097]int8)(__ccgo_up(bp)))[p]) == int32('/') { p = p + 1 } } @@ -115809,8 +115809,8 @@ _2: goto _1 _1: ; - (*(*[4096]int8)(unsafe.Pointer(bp + 4097)))[q] = 0 - if int32((*(*[4096]int8)(unsafe.Pointer(bp + 4097)))[0]) != int32('/') { + (**(**[4096]int8)(__ccgo_up(bp + 4097)))[q] = 0 + if int32((**(**[4096]int8)(__ccgo_up(bp + 4097)))[0]) != int32('/') { if !(Xgetcwd(tls, bp, uint64(4097)) != 0) { return uintptr(0) } @@ -115823,7 +115823,7 @@ _1: if !(v4 != 0) { break } - for l > uint64(1) && int32((*(*[4097]int8)(unsafe.Pointer(bp)))[l-uint64(1)]) != int32('/') { + for l > uint64(1) && int32((**(**[4097]int8)(__ccgo_up(bp)))[l-uint64(1)]) != int32('/') { l = l - 1 } if l > uint64(1) { @@ -115834,10 +115834,10 @@ _1: p = p + 1 } } - if q-p != 0 && int32((*(*[4097]int8)(unsafe.Pointer(bp)))[l-uint64(1)]) != int32('/') { + if q-p != 0 && int32((**(**[4097]int8)(__ccgo_up(bp)))[l-uint64(1)]) != int32('/') { v4 = l l = l + 1 - (*(*[4097]int8)(unsafe.Pointer(bp)))[v4] = int8('/') + (**(**[4097]int8)(__ccgo_up(bp)))[v4] = int8('/') } if l+(q-p)+uint64(1) >= uint64(PATH_MAX) { goto toolong @@ -115854,7 +115854,7 @@ _1: goto toolong toolong: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENAMETOOLONG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENAMETOOLONG) return uintptr(0) } @@ -115903,12 +115903,12 @@ func Xsetrlimit(tls *TLS, resource int32, rlim uintptr) (r int32) { var _ /* tmp at bp+0 */ Trlimit _, _, _ = ret, v1, v2 if ^Uint64FromUint64(0) != ^Uint64FromUint64(0) { - *(*Trlimit)(unsafe.Pointer(bp)) = *(*Trlimit)(unsafe.Pointer(rlim)) - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur >= ^Uint64FromUint64(0) { - (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur = ^Uint64FromUint64(0) + **(**Trlimit)(__ccgo_up(bp)) = **(**Trlimit)(__ccgo_up(rlim)) + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur >= ^Uint64FromUint64(0) { + (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur = ^Uint64FromUint64(0) } - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_max >= ^Uint64FromUint64(0) { - (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_max = ^Uint64FromUint64(0) + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_max >= ^Uint64FromUint64(0) { + (**(**Trlimit)(__ccgo_up(bp))).Frlim_max = ^Uint64FromUint64(0) } rlim = bp } @@ -115926,7 +115926,7 @@ func Xsetrlimit(tls *TLS, resource int32, rlim uintptr) (r int32) { } else { v2 = ^Uint64FromUint64(0) } - *(*Tctx)(unsafe.Pointer(bp + 16)) = Tctx{ + **(**Tctx)(__ccgo_up(bp + 16)) = Tctx{ Flim: [2]uint64{ 0: v1, 1: v2, @@ -115935,9 +115935,9 @@ func Xsetrlimit(tls *TLS, resource int32, rlim uintptr) (r int32) { Ferr: -int32(1), } ___synccall(tls, __ccgo_fp(_do_setrlimit), bp+16) - if (*(*Tctx)(unsafe.Pointer(bp + 16))).Ferr != 0 { - if (*(*Tctx)(unsafe.Pointer(bp + 16))).Ferr > 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = (*(*Tctx)(unsafe.Pointer(bp + 16))).Ferr + if (**(**Tctx)(__ccgo_up(bp + 16))).Ferr != 0 { + if (**(**Tctx)(__ccgo_up(bp + 16))).Ferr > 0 { + **(**int32)(__ccgo_up(X__errno_location(tls))) = (**(**Tctx)(__ccgo_up(bp + 16))).Ferr } return -int32(1) } @@ -116317,7 +116317,7 @@ func Xcloselog(tls *TLS) { Xclose(tls, _log_fd) _log_fd = -int32(1) ___unlock(tls, uintptr(unsafe.Pointer(&_lock2))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) } func ___openlog(tls *TLS) { @@ -116351,7 +116351,7 @@ func Xopenlog(tls *TLS, ident uintptr, opt int32, facility int32) { ___openlog(tls) } ___unlock(tls, uintptr(unsafe.Pointer(&_lock2))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) } func _is_lost_conn(tls *TLS, e int32) (r int32) { @@ -116368,14 +116368,14 @@ func __vsyslog(tls *TLS, priority int32, message uintptr, ap Tva_list) { var _ /* timebuf at bp+0 */ [16]int8 var _ /* tm at bp+24 */ Ttm _, _, _, _, _, _ = errno_save, fd, l, l2, pid, v1 - errno_save = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + errno_save = **(**int32)(__ccgo_up(X__errno_location(tls))) if _log_fd < 0 { ___openlog(tls) } if !(priority&Int32FromInt32(LOG_FACMASK) != 0) { priority = priority | _log_facility } - *(*Ttime_t)(unsafe.Pointer(bp + 16)) = Xtime(tls, UintptrFromInt32(0)) + **(**Ttime_t)(__ccgo_up(bp + 16)) = Xtime(tls, UintptrFromInt32(0)) Xgmtime_r(tls, bp+16, bp+24) Xstrftime_l(tls, bp, uint64(16), __ccgo_ts+938, bp+24, uintptr(unsafe.Pointer(&X__c_locale))) if _log_opt&int32(LOG_PID) != 0 { @@ -116385,7 +116385,7 @@ func __vsyslog(tls *TLS, priority int32, message uintptr, ap Tva_list) { } pid = v1 l = Xsnprintf(tls, bp+80, uint64(1024), __ccgo_ts+947, VaList(bp+1120, priority, bp, bp+1104, uintptr(unsafe.Pointer(&_log_ident)), __ccgo_ts+969+BoolUintptr(!(pid != 0)), pid, __ccgo_ts+971+BoolUintptr(!(pid != 0)))) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = errno_save + **(**int32)(__ccgo_up(X__errno_location(tls))) = errno_save l2 = Xvsnprintf(tls, bp+80+uintptr(l), uint64(1024)-Uint64FromInt32(l), message, ap) if l2 >= 0 { if Uint64FromInt32(l2) >= uint64(1024)-Uint64FromInt32(l) { @@ -116393,20 +116393,20 @@ func __vsyslog(tls *TLS, priority int32, message uintptr, ap Tva_list) { } else { l = l + l2 } - if int32((*(*[1024]int8)(unsafe.Pointer(bp + 80)))[l-int32(1)]) != int32('\n') { + if int32((**(**[1024]int8)(__ccgo_up(bp + 80)))[l-int32(1)]) != int32('\n') { v1 = l l = l + 1 - (*(*[1024]int8)(unsafe.Pointer(bp + 80)))[v1] = int8('\n') + (**(**[1024]int8)(__ccgo_up(bp + 80)))[v1] = int8('\n') } - if Xsend(tls, _log_fd, bp+80, Uint64FromInt32(l), 0) < 0 && (!(_is_lost_conn(tls, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) != 0) || Xconnect(tls, _log_fd, uintptr(unsafe.Pointer(&_log_addr)), uint32(12)) < 0 || Xsend(tls, _log_fd, bp+80, Uint64FromInt32(l), 0) < 0) && _log_opt&int32(LOG_CONS) != 0 { + if Xsend(tls, _log_fd, bp+80, Uint64FromInt32(l), 0) < 0 && (!(_is_lost_conn(tls, **(**int32)(__ccgo_up(X__errno_location(tls)))) != 0) || Xconnect(tls, _log_fd, uintptr(unsafe.Pointer(&_log_addr)), uint32(12)) < 0 || Xsend(tls, _log_fd, bp+80, Uint64FromInt32(l), 0) < 0) && _log_opt&int32(LOG_CONS) != 0 { fd = Xopen(tls, __ccgo_ts+666, Int32FromInt32(O_WRONLY)|Int32FromInt32(O_NOCTTY)|Int32FromInt32(O_CLOEXEC), 0) if fd >= 0 { - Xdprintf(tls, fd, __ccgo_ts+973, VaList(bp+1120, l-*(*int32)(unsafe.Pointer(bp + 1104)), bp+80+uintptr(*(*int32)(unsafe.Pointer(bp + 1104))))) + Xdprintf(tls, fd, __ccgo_ts+973, VaList(bp+1120, l-**(**int32)(__ccgo_up(bp + 1104)), bp+80+uintptr(**(**int32)(__ccgo_up(bp + 1104))))) Xclose(tls, fd) } } if _log_opt&int32(LOG_PERROR) != 0 { - Xdprintf(tls, int32(2), __ccgo_ts+973, VaList(bp+1120, l-*(*int32)(unsafe.Pointer(bp + 1104)), bp+80+uintptr(*(*int32)(unsafe.Pointer(bp + 1104))))) + Xdprintf(tls, int32(2), __ccgo_ts+973, VaList(bp+1120, l-**(**int32)(__ccgo_up(bp + 1104)), bp+80+uintptr(**(**int32)(__ccgo_up(bp + 1104))))) } } } @@ -116422,7 +116422,7 @@ func ___vsyslog(tls *TLS, priority int32, message uintptr, ap Tva_list) { ___lock(tls, uintptr(unsafe.Pointer(&_lock2))) __vsyslog(tls, priority, message, ap) ___unlock(tls, uintptr(unsafe.Pointer(&_lock2))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) } func Xsyslog(tls *TLS, priority int32, message uintptr, va uintptr) { @@ -116507,11 +116507,11 @@ func X__mmap(tls *TLS, start uintptr, len1 Tsize_t, prot int32, flags int32, fd var ret int64 _ = ret if Uint64FromInt64(off)&(-Uint64FromUint64(0x2000)<<(Uint64FromInt32(8)*Uint64FromInt64(8)-Uint64FromInt32(1))|(Uint64FromUint64(4096)-Uint64FromInt32(1))) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(-Int32FromInt32(1)) } if len1 >= Uint64FromInt64(Int64FromInt64(INT64_MAX)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return uintptr(-Int32FromInt32(1)) } if flags&int32(MAP_FIXED) != 0 { @@ -116566,7 +116566,7 @@ func X__mremap(tls *TLS, old_addr uintptr, old_len Tsize_t, new_len Tsize_t, fla _, _ = ap, new_addr new_addr = uintptr(0) if new_len >= Uint64FromInt64(Int64FromInt64(INT64_MAX)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return uintptr(-Int32FromInt32(1)) } if flags&int32(MREMAP_FIXED) != 0 { @@ -116648,17 +116648,17 @@ func X__shm_mapname(tls *TLS, name uintptr, buf uintptr) (r uintptr) { } var p, v1 uintptr _, _ = p, v1 - for int32(*(*int8)(unsafe.Pointer(name))) == int32('/') { + for int32(**(**int8)(__ccgo_up(name))) == int32('/') { name = name + 1 } v1 = X__strchrnul(tls, name, int32('/')) p = v1 - if *(*int8)(unsafe.Pointer(v1)) != 0 || p == name || int64(p)-int64(name) <= int64(2) && int32(*(*int8)(unsafe.Pointer(name))) == int32('.') && int32(*(*int8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) == int32('.') { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if **(**int8)(__ccgo_up(v1)) != 0 || p == name || int64(p)-int64(name) <= int64(2) && int32(**(**int8)(__ccgo_up(name))) == int32('.') && int32(**(**int8)(__ccgo_up(p + uintptr(-Int32FromInt32(1))))) == int32('.') { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } if int64(p)-int64(name) > int64(NAME_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENAMETOOLONG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENAMETOOLONG) return uintptr(0) } Xmemcpy(tls, buf, __ccgo_ts+978, uint64(9)) @@ -116685,7 +116685,7 @@ func Xshm_open(tls *TLS, name uintptr, flag int32, mode Tmode_t) (r int32) { } _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp) fd = Xopen(tls, name, flag|int32(O_NOFOLLOW)|int32(O_CLOEXEC)|int32(O_NONBLOCK), VaList(bp+280, mode)) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) return fd } @@ -116723,7 +116723,7 @@ func Xbtowc(tls *TLS, c int32) (r Twint_t) { if Uint32FromInt32(b) < uint32(128) { v1 = Uint32FromInt32(b) } else { - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v3 = int32(4) } else { v3 = int32(1) @@ -116755,22 +116755,22 @@ func Xc16rtomb(tls *TLS, s uintptr, c16 Tchar16_t, ps uintptr) (r Tsize_t) { } x = ps if !(s != 0) { - if *(*uint32)(unsafe.Pointer(x)) != 0 { + if **(**uint32)(__ccgo_up(x)) != 0 { goto ilseq } return uint64(1) } - if !(*(*uint32)(unsafe.Pointer(x)) != 0) && uint32(c16)-uint32(0xd800) < uint32(0x400) { - *(*uint32)(unsafe.Pointer(x)) = Uint32FromInt32((Int32FromUint16(c16) - int32(0xd7c0)) << int32(10)) + if !(**(**uint32)(__ccgo_up(x)) != 0) && uint32(c16)-uint32(0xd800) < uint32(0x400) { + **(**uint32)(__ccgo_up(x)) = Uint32FromInt32((Int32FromUint16(c16) - int32(0xd7c0)) << int32(10)) return uint64(0) } - if *(*uint32)(unsafe.Pointer(x)) != 0 { + if **(**uint32)(__ccgo_up(x)) != 0 { if uint32(c16)-uint32(0xdc00) >= uint32(0x400) { goto ilseq } else { - wc = Int32FromUint32(*(*uint32)(unsafe.Pointer(x)) + uint32(c16) - uint32(0xdc00)) + wc = Int32FromUint32(**(**uint32)(__ccgo_up(x)) + uint32(c16) - uint32(0xdc00)) } - *(*uint32)(unsafe.Pointer(x)) = uint32(0) + **(**uint32)(__ccgo_up(x)) = uint32(0) } else { wc = Int32FromUint16(c16) } @@ -116778,8 +116778,8 @@ func Xc16rtomb(tls *TLS, s uintptr, c16 Tchar16_t, ps uintptr) (r Tsize_t) { goto ilseq ilseq: ; - *(*uint32)(unsafe.Pointer(x)) = uint32(0) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EILSEQ) + **(**uint32)(__ccgo_up(x)) = uint32(0) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EILSEQ) return Uint64FromInt32(-Int32FromInt32(1)) } @@ -116838,21 +116838,21 @@ func Xmbrtoc16(tls *TLS, pc16 uintptr, s uintptr, n Tsize_t, ps uintptr) (r Tsiz } /* mbrtowc states for partial UTF-8 characters have the high bit set; * we use nonzero states without high bit for pending surrogates. */ - if Int32FromUint32(*(*uint32)(unsafe.Pointer(pending))) > 0 { + if Int32FromUint32(**(**uint32)(__ccgo_up(pending))) > 0 { if pc16 != 0 { - *(*Tchar16_t)(unsafe.Pointer(pc16)) = uint16(*(*uint32)(unsafe.Pointer(pending))) + **(**Tchar16_t)(__ccgo_up(pc16)) = uint16(**(**uint32)(__ccgo_up(pending))) } - *(*uint32)(unsafe.Pointer(pending)) = uint32(0) + **(**uint32)(__ccgo_up(pending)) = uint32(0) return Uint64FromInt32(-Int32FromInt32(3)) } ret = Xmbrtowc(tls, bp, s, n, ps) if ret <= uint64(4) { - if *(*Twchar_t)(unsafe.Pointer(bp)) >= int32(0x10000) { - *(*uint32)(unsafe.Pointer(pending)) = Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))&int32(0x3ff) + int32(0xdc00)) - *(*Twchar_t)(unsafe.Pointer(bp)) = int32(0xd7c0) + *(*Twchar_t)(unsafe.Pointer(bp))>>Int32FromInt32(10) + if **(**Twchar_t)(__ccgo_up(bp)) >= int32(0x10000) { + **(**uint32)(__ccgo_up(pending)) = Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))&int32(0x3ff) + int32(0xdc00)) + **(**Twchar_t)(__ccgo_up(bp)) = int32(0xd7c0) + **(**Twchar_t)(__ccgo_up(bp))>>Int32FromInt32(10) } if pc16 != 0 { - *(*Tchar16_t)(unsafe.Pointer(pc16)) = Uint16FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))) + **(**Tchar16_t)(__ccgo_up(pc16)) = Uint16FromInt32(**(**Twchar_t)(__ccgo_up(bp))) } } return ret @@ -116878,7 +116878,7 @@ func Xmbrtoc32(tls *TLS, pc32 uintptr, s uintptr, n Tsize_t, ps uintptr) (r Tsiz } ret = Xmbrtowc(tls, bp, s, n, ps) if ret <= uint64(4) && pc32 != 0 { - *(*Tchar32_t)(unsafe.Pointer(pc32)) = Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))) + **(**Tchar32_t)(__ccgo_up(pc32)) = Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))) } return ret } @@ -116904,7 +116904,7 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize if !(st != 0) { st = uintptr(unsafe.Pointer(&_internal_state3)) } - c = *(*uint32)(unsafe.Pointer(st)) + c = **(**uint32)(__ccgo_up(st)) if !(s != 0) { if c != 0 { goto ilseq @@ -116919,30 +116919,30 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize return Uint64FromInt32(-Int32FromInt32(2)) } if !(c != 0) { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) < int32(0x80) { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) - *(*Twchar_t)(unsafe.Pointer(wc)) = v1 + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) < int32(0x80) { + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(s))) + **(**Twchar_t)(__ccgo_up(wc)) = v1 return BoolUint64(!!(v1 != 0)) } - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v2 = int32(4) } else { v2 = int32(1) } if v2 == int32(1) { - *(*Twchar_t)(unsafe.Pointer(wc)) = Int32FromInt32(0xdfff) & int32(Int8FromUint8(*(*uint8)(unsafe.Pointer(s)))) + **(**Twchar_t)(__ccgo_up(wc)) = Int32FromInt32(0xdfff) & int32(Int8FromUint8(**(**uint8)(__ccgo_up(s)))) return Uint64FromInt32(1) } - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { goto ilseq } v3 = s s = s + 1 - c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v3)))-uint32(0xc2)] + c = X__fsmu8[uint32(**(**uint8)(__ccgo_up(v3)))-uint32(0xc2)] n = n - 1 } if n != 0 { - if (Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { + if (Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { goto ilseq } goto loop @@ -116950,27 +116950,27 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize ; v3 = s s = s + 1 - c = c<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { goto ilseq } goto loop } } - *(*uint32)(unsafe.Pointer(st)) = c + **(**uint32)(__ccgo_up(st)) = c return Uint64FromInt32(-Int32FromInt32(2)) goto ilseq ilseq: ; - *(*uint32)(unsafe.Pointer(st)) = uint32(0) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EILSEQ) + **(**uint32)(__ccgo_up(st)) = uint32(0) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EILSEQ) return Uint64FromInt32(-Int32FromInt32(1)) } @@ -116981,7 +116981,7 @@ func Xmbsinit(tls *TLS, st uintptr) (r int32) { trc("tls=%v st=%v, (%v:)", tls, st, origin(2)) defer func() { trc("-> %v", r) }() } - return BoolInt32(!(st != 0) || !(*(*uint32)(unsafe.Pointer(st)) != 0)) + return BoolInt32(!(st != 0) || !(**(**uint32)(__ccgo_up(st)) != 0)) } func Xmbsnrtowcs(tls *TLS, wcs uintptr, src uintptr, n Tsize_t, wn Tsize_t, st uintptr) (r Tsize_t) { @@ -116999,7 +116999,7 @@ func Xmbsnrtowcs(tls *TLS, wcs uintptr, src uintptr, n Tsize_t, wn Tsize_t, st u var _ /* wbuf at bp+0 */ [256]Twchar_t _, _, _, _, _, _, _, _ = cnt, l, n2, tmp_s, ws, v1, v2, v3 cnt = uint64(0) - *(*uintptr)(unsafe.Pointer(bp + 1024)) = *(*uintptr)(unsafe.Pointer(src)) + **(**uintptr)(__ccgo_up(bp + 1024)) = **(**uintptr)(__ccgo_up(src)) if !(wcs != 0) { ws = bp wn = Uint64FromInt64(1024) / Uint64FromInt64(4) @@ -117010,7 +117010,7 @@ func Xmbsnrtowcs(tls *TLS, wcs uintptr, src uintptr, n Tsize_t, wn Tsize_t, st u * that mbsrtowcs never reads more than n input bytes. thus * we can use mbsrtowcs as long as it's practical.. */ for { - if v2 = *(*uintptr)(unsafe.Pointer(bp + 1024)) != 0 && wn != 0; v2 { + if v2 = **(**uintptr)(__ccgo_up(bp + 1024)) != 0 && wn != 0; v2 { v1 = n / Uint64FromInt32(4) n2 = v1 } @@ -117020,7 +117020,7 @@ func Xmbsnrtowcs(tls *TLS, wcs uintptr, src uintptr, n Tsize_t, wn Tsize_t, st u if n2 >= wn { n2 = wn } - tmp_s = *(*uintptr)(unsafe.Pointer(bp + 1024)) + tmp_s = **(**uintptr)(__ccgo_up(bp + 1024)) l = Xmbsrtowcs(tls, ws, bp+1024, n2, st) if !(l+Uint64FromInt32(1) != 0) { cnt = l @@ -117031,31 +117031,31 @@ func Xmbsnrtowcs(tls *TLS, wcs uintptr, src uintptr, n Tsize_t, wn Tsize_t, st u ws = ws + uintptr(l)*4 wn = wn - l } - if *(*uintptr)(unsafe.Pointer(bp + 1024)) != 0 { - v3 = n - Uint64FromInt64(int64(*(*uintptr)(unsafe.Pointer(bp + 1024)))-int64(tmp_s)) + if **(**uintptr)(__ccgo_up(bp + 1024)) != 0 { + v3 = n - Uint64FromInt64(int64(**(**uintptr)(__ccgo_up(bp + 1024)))-int64(tmp_s)) } else { v3 = uint64(0) } n = v3 cnt = cnt + l } - if *(*uintptr)(unsafe.Pointer(bp + 1024)) != 0 { + if **(**uintptr)(__ccgo_up(bp + 1024)) != 0 { for wn != 0 && n != 0 { - l = Xmbrtowc(tls, ws, *(*uintptr)(unsafe.Pointer(bp + 1024)), n, st) + l = Xmbrtowc(tls, ws, **(**uintptr)(__ccgo_up(bp + 1024)), n, st) if l+uint64(2) <= uint64(2) { if !(l+Uint64FromInt32(1) != 0) { cnt = l break } if !(l != 0) { - *(*uintptr)(unsafe.Pointer(bp + 1024)) = uintptr(0) + **(**uintptr)(__ccgo_up(bp + 1024)) = uintptr(0) break } /* have to roll back partial character */ - *(*uint32)(unsafe.Pointer(st)) = uint32(0) + **(**uint32)(__ccgo_up(st)) = uint32(0) break } - *(*uintptr)(unsafe.Pointer(bp + 1024)) = *(*uintptr)(unsafe.Pointer(bp + 1024)) + uintptr(l) + **(**uintptr)(__ccgo_up(bp + 1024)) = **(**uintptr)(__ccgo_up(bp + 1024)) + uintptr(l) n = n - l /* safe - this loop runs fewer than sizeof(wbuf)/8 times */ ws += 4 @@ -117064,7 +117064,7 @@ func Xmbsnrtowcs(tls *TLS, wcs uintptr, src uintptr, n Tsize_t, wn Tsize_t, st u } } if wcs != 0 { - *(*uintptr)(unsafe.Pointer(src)) = *(*uintptr)(unsafe.Pointer(bp + 1024)) + **(**uintptr)(__ccgo_up(src)) = **(**uintptr)(__ccgo_up(bp + 1024)) } return cnt } @@ -117080,22 +117080,22 @@ func Xmbsrtowcs(tls *TLS, ws uintptr, src uintptr, wn Tsize_t, st uintptr) (r Ts var v2 bool var v3 int32 _, _, _, _, _, _, _, _ = c, s, wn0, v1, v2, v3, v5, v6 - s = *(*uintptr)(unsafe.Pointer(src)) + s = **(**uintptr)(__ccgo_up(src)) wn0 = wn c = uint32(0) if v2 = st != 0; v2 { - v1 = *(*uint32)(unsafe.Pointer(st)) + v1 = **(**uint32)(__ccgo_up(st)) c = v1 } if v2 && v1 != 0 { if ws != 0 { - *(*uint32)(unsafe.Pointer(st)) = uint32(0) + **(**uint32)(__ccgo_up(st)) = uint32(0) goto resume } else { goto resume0 } } - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v3 = int32(4) } else { v3 = int32(1) @@ -117106,24 +117106,24 @@ func Xmbsrtowcs(tls *TLS, ws uintptr, src uintptr, wn Tsize_t, st uintptr) (r Ts } for { if !(wn != 0) { - *(*uintptr)(unsafe.Pointer(src)) = s + **(**uintptr)(__ccgo_up(src)) = s return wn0 } - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { break } v5 = s s = s + 1 - c = uint32(*(*uint8)(unsafe.Pointer(v5))) + c = uint32(**(**uint8)(__ccgo_up(v5))) v5 = ws ws += 4 - *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromInt32(0xdfff) & int32(Int8FromUint32(c)) + **(**Twchar_t)(__ccgo_up(v5)) = Int32FromInt32(0xdfff) & int32(Int8FromUint32(c)) wn = wn - 1 goto _4 _4: } - *(*Twchar_t)(unsafe.Pointer(ws)) = 0 - *(*uintptr)(unsafe.Pointer(src)) = uintptr(0) + **(**Twchar_t)(__ccgo_up(ws)) = 0 + **(**uintptr)(__ccgo_up(src)) = uintptr(0) return wn0 - wn } if !!(ws != 0) { @@ -117131,39 +117131,39 @@ func Xmbsrtowcs(tls *TLS, ws uintptr, src uintptr, wn Tsize_t, st uintptr) (r Ts } _11: ; - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) && uint64(s)%uint64(4) == uint64(0) { - for !((*(*uint32)(unsafe.Pointer(s))|(*(*uint32)(unsafe.Pointer(s))-Uint32FromInt32(0x01010101)))&Uint32FromUint32(0x80808080) != 0) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(1) < uint32(0x7f) && uint64(s)%uint64(4) == uint64(0) { + for !((**(**uint32)(__ccgo_up(s))|(**(**uint32)(__ccgo_up(s))-Uint32FromInt32(0x01010101)))&Uint32FromUint32(0x80808080) != 0) { s = s + uintptr(4) wn = wn - uint64(4) } } - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(1) < uint32(0x7f) { s = s + 1 wn = wn - 1 goto _10 } - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { goto _9 } v5 = s s = s + 1 - c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v5)))-uint32(0xc2)] + c = X__fsmu8[uint32(**(**uint8)(__ccgo_up(v5)))-uint32(0xc2)] goto resume0 resume0: ; - if (Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { + if (Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { s = s - 1 goto _9 } s = s + 1 if c&(Uint32FromUint32(1)<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { s = s - uintptr(2) goto _9 } s = s + 1 if c&(Uint32FromUint32(1)<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { s = s - uintptr(3) goto _9 } @@ -117185,80 +117185,80 @@ _7: _15: ; if !(wn != 0) { - *(*uintptr)(unsafe.Pointer(src)) = s + **(**uintptr)(__ccgo_up(src)) = s return wn0 } - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) && uint64(s)%uint64(4) == uint64(0) { - for wn >= uint64(5) && !((*(*uint32)(unsafe.Pointer(s))|(*(*uint32)(unsafe.Pointer(s))-Uint32FromInt32(0x01010101)))&Uint32FromUint32(0x80808080) != 0) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(1) < uint32(0x7f) && uint64(s)%uint64(4) == uint64(0) { + for wn >= uint64(5) && !((**(**uint32)(__ccgo_up(s))|(**(**uint32)(__ccgo_up(s))-Uint32FromInt32(0x01010101)))&Uint32FromUint32(0x80808080) != 0) { v5 = ws ws += 4 v6 = s s = s + 1 - *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + **(**Twchar_t)(__ccgo_up(v5)) = Int32FromUint8(**(**uint8)(__ccgo_up(v6))) v5 = ws ws += 4 v6 = s s = s + 1 - *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + **(**Twchar_t)(__ccgo_up(v5)) = Int32FromUint8(**(**uint8)(__ccgo_up(v6))) v5 = ws ws += 4 v6 = s s = s + 1 - *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + **(**Twchar_t)(__ccgo_up(v5)) = Int32FromUint8(**(**uint8)(__ccgo_up(v6))) v5 = ws ws += 4 v6 = s s = s + 1 - *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + **(**Twchar_t)(__ccgo_up(v5)) = Int32FromUint8(**(**uint8)(__ccgo_up(v6))) wn = wn - uint64(4) } } - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(1) < uint32(0x7f) { v5 = ws ws += 4 v6 = s s = s + 1 - *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + **(**Twchar_t)(__ccgo_up(v5)) = Int32FromUint8(**(**uint8)(__ccgo_up(v6))) wn = wn - 1 goto _14 } - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { goto _13 } v5 = s s = s + 1 - c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v5)))-uint32(0xc2)] + c = X__fsmu8[uint32(**(**uint8)(__ccgo_up(v5)))-uint32(0xc2)] goto resume resume: ; - if (Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { + if (Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { s = s - 1 goto _13 } v5 = s s = s + 1 - c = c<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { s = s - uintptr(2) goto _13 } v5 = s s = s + 1 - c = c<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { s = s - uintptr(3) goto _13 } v5 = s s = s + 1 - c = c< Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { goto ilseq } v3 = s s = s + 1 - c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v3)))-uint32(0xc2)] + c = X__fsmu8[uint32(**(**uint8)(__ccgo_up(v3)))-uint32(0xc2)] /* Avoid excessive checks against n: If shifting the state n-1 * times does not clear the high bit, then the value of n is * insufficient to read a character */ if n < uint64(4) && c<<(uint64(6)*n-uint64(6))&(Uint32FromUint32(1)<>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { + if (Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { goto ilseq } v3 = s s = s + 1 - c = c<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { goto ilseq } v3 = s s = s + 1 - c = c<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { goto ilseq } v3 = s s = s + 1 - *(*Twchar_t)(unsafe.Pointer(wc)) = Int32FromUint32(c<>Int32FromInt32(6)) - *(*int8)(unsafe.Pointer(s)) = int8(int32(0x80) | wc&int32(0x3f)) + **(**int8)(__ccgo_up(v2)) = int8(int32(0xc0) | wc>>Int32FromInt32(6)) + **(**int8)(__ccgo_up(s)) = int8(int32(0x80) | wc&int32(0x3f)) return uint64(2) } else { if Uint32FromInt32(wc) < uint32(0xd800) || Uint32FromInt32(wc)-uint32(0xe000) < uint32(0x2000) { v2 = s s = s + 1 - *(*int8)(unsafe.Pointer(v2)) = int8(int32(0xe0) | wc>>Int32FromInt32(12)) + **(**int8)(__ccgo_up(v2)) = int8(int32(0xe0) | wc>>Int32FromInt32(12)) v2 = s s = s + 1 - *(*int8)(unsafe.Pointer(v2)) = int8(int32(0x80) | wc>>Int32FromInt32(6)&int32(0x3f)) - *(*int8)(unsafe.Pointer(s)) = int8(int32(0x80) | wc&int32(0x3f)) + **(**int8)(__ccgo_up(v2)) = int8(int32(0x80) | wc>>Int32FromInt32(6)&int32(0x3f)) + **(**int8)(__ccgo_up(s)) = int8(int32(0x80) | wc&int32(0x3f)) return uint64(3) } else { if Uint32FromInt32(wc)-uint32(0x10000) < uint32(0x100000) { v2 = s s = s + 1 - *(*int8)(unsafe.Pointer(v2)) = int8(int32(0xf0) | wc>>Int32FromInt32(18)) + **(**int8)(__ccgo_up(v2)) = int8(int32(0xf0) | wc>>Int32FromInt32(18)) v2 = s s = s + 1 - *(*int8)(unsafe.Pointer(v2)) = int8(int32(0x80) | wc>>Int32FromInt32(12)&int32(0x3f)) + **(**int8)(__ccgo_up(v2)) = int8(int32(0x80) | wc>>Int32FromInt32(12)&int32(0x3f)) v2 = s s = s + 1 - *(*int8)(unsafe.Pointer(v2)) = int8(int32(0x80) | wc>>Int32FromInt32(6)&int32(0x3f)) - *(*int8)(unsafe.Pointer(s)) = int8(int32(0x80) | wc&int32(0x3f)) + **(**int8)(__ccgo_up(v2)) = int8(int32(0x80) | wc>>Int32FromInt32(6)&int32(0x3f)) + **(**int8)(__ccgo_up(s)) = int8(int32(0x80) | wc&int32(0x3f)) return uint64(4) } } } } } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EILSEQ) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EILSEQ) return Uint64FromInt32(-Int32FromInt32(1)) } @@ -117455,7 +117455,7 @@ func Xwcsnrtombs(tls *TLS, dst uintptr, wcs uintptr, wn Tsize_t, n Tsize_t, st u var ws, v1 uintptr var _ /* tmp at bp+0 */ [4]int8 _, _, _, _ = cnt, l, ws, v1 - ws = *(*uintptr)(unsafe.Pointer(wcs)) + ws = **(**uintptr)(__ccgo_up(wcs)) cnt = uint64(0) if !(dst != 0) { n = uint64(0) @@ -117466,7 +117466,7 @@ func Xwcsnrtombs(tls *TLS, dst uintptr, wcs uintptr, wn Tsize_t, n Tsize_t, st u } else { v1 = dst } - l = Xwcrtomb(tls, v1, *(*Twchar_t)(unsafe.Pointer(ws)), uintptr(0)) + l = Xwcrtomb(tls, v1, **(**Twchar_t)(__ccgo_up(ws)), uintptr(0)) if l == Uint64FromInt32(-Int32FromInt32(1)) { cnt = Uint64FromInt32(-Int32FromInt32(1)) break @@ -117481,7 +117481,7 @@ func Xwcsnrtombs(tls *TLS, dst uintptr, wcs uintptr, wn Tsize_t, n Tsize_t, st u dst = dst + uintptr(l) n = n - l } - if !(*(*Twchar_t)(unsafe.Pointer(ws)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(ws)) != 0) { ws = uintptr(0) break } @@ -117490,7 +117490,7 @@ func Xwcsnrtombs(tls *TLS, dst uintptr, wcs uintptr, wn Tsize_t, n Tsize_t, st u cnt = cnt + l } if dst != 0 { - *(*uintptr)(unsafe.Pointer(wcs)) = ws + **(**uintptr)(__ccgo_up(wcs)) = ws } return cnt } @@ -117509,13 +117509,13 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize N = n if !(s != 0) { n = uint64(0) - ws2 = *(*uintptr)(unsafe.Pointer(ws)) + ws2 = **(**uintptr)(__ccgo_up(ws)) for { - if !(*(*Twchar_t)(unsafe.Pointer(ws2)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(ws2)) != 0) { break } - if Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(ws2))) >= uint32(0x80) { - l = Xwcrtomb(tls, bp, *(*Twchar_t)(unsafe.Pointer(ws2)), uintptr(0)) + if Uint32FromInt32(**(**Twchar_t)(__ccgo_up(ws2))) >= uint32(0x80) { + l = Xwcrtomb(tls, bp, **(**Twchar_t)(__ccgo_up(ws2)), uintptr(0)) if !(l+Uint64FromInt32(1) != 0) { return Uint64FromInt32(-Int32FromInt32(1)) } @@ -117531,13 +117531,13 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize return n } for n >= uint64(4) { - if Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))))-uint32(1) >= uint32(0x7f) { - if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))) != 0) { - *(*int8)(unsafe.Pointer(s)) = 0 - *(*uintptr)(unsafe.Pointer(ws)) = uintptr(0) + if Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))))-uint32(1) >= uint32(0x7f) { + if !(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))) != 0) { + **(**int8)(__ccgo_up(s)) = 0 + **(**uintptr)(__ccgo_up(ws)) = uintptr(0) return N - n } - l = Xwcrtomb(tls, s, *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))), uintptr(0)) + l = Xwcrtomb(tls, s, **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))), uintptr(0)) if !(l+Uint64FromInt32(1) != 0) { return Uint64FromInt32(-Int32FromInt32(1)) } @@ -117546,35 +117546,35 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize } else { v2 = s s = s + 1 - *(*int8)(unsafe.Pointer(v2)) = int8(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) + **(**int8)(__ccgo_up(v2)) = int8(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws))))) n = n - 1 } - *(*uintptr)(unsafe.Pointer(ws)) += 4 + **(**uintptr)(__ccgo_up(ws)) += 4 } for n != 0 { - if Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))))-uint32(1) >= uint32(0x7f) { - if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))) != 0) { - *(*int8)(unsafe.Pointer(s)) = 0 - *(*uintptr)(unsafe.Pointer(ws)) = uintptr(0) + if Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))))-uint32(1) >= uint32(0x7f) { + if !(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))) != 0) { + **(**int8)(__ccgo_up(s)) = 0 + **(**uintptr)(__ccgo_up(ws)) = uintptr(0) return N - n } - l = Xwcrtomb(tls, bp, *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))), uintptr(0)) + l = Xwcrtomb(tls, bp, **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))), uintptr(0)) if !(l+Uint64FromInt32(1) != 0) { return Uint64FromInt32(-Int32FromInt32(1)) } if l > n { return N - n } - Xwcrtomb(tls, s, *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))), uintptr(0)) + Xwcrtomb(tls, s, **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))), uintptr(0)) s = s + uintptr(l) n = n - l } else { v2 = s s = s + 1 - *(*int8)(unsafe.Pointer(v2)) = int8(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) + **(**int8)(__ccgo_up(v2)) = int8(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws))))) n = n - 1 } - *(*uintptr)(unsafe.Pointer(ws)) += 4 + **(**uintptr)(__ccgo_up(ws)) += 4 } return N } @@ -117600,7 +117600,7 @@ func Xwctob(tls *TLS, c Twint_t) (r int32) { if c < uint32(128) { return Int32FromUint32(c) } - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v1 = int32(4) } else { v1 = int32(1) @@ -117698,11 +117698,11 @@ func Xaccept4(tls *TLS, fd int32, addr uintptr, len1 uintptr, flg int32) (r1 int goto _9 _9: ret = int32(X__syscall_ret(tls, Uint64FromInt64(v8))) - if ret >= 0 || *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(ENOSYS) && *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(EINVAL) { + if ret >= 0 || **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(ENOSYS) && **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(EINVAL) { return ret } if flg & ^(Int32FromInt32(SOCK_CLOEXEC)|Int32FromInt32(SOCK_NONBLOCK)) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } ret = Xaccept(tls, fd, addr, len1) @@ -118674,13 +118674,13 @@ func _getoffs(tls *TLS, offs uintptr, base uintptr, s uintptr) (r int32) { _, _ = i, v2 i = 0 for { - for Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))&int32(0xc0) != 0 { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))&int32(0xc0) != int32(0xc0) { + for Int32FromUint8(**(**uint8)(__ccgo_up(s)))&int32(0xc0) != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(s)))&int32(0xc0) != int32(0xc0) { return 0 } - s = base + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))&Int32FromInt32(0x3f)<= int64(0x4000) { @@ -118688,8 +118688,8 @@ func _getoffs(tls *TLS, offs uintptr, base uintptr, s uintptr) (r int32) { } v2 = i i = i + 1 - *(*int16)(unsafe.Pointer(offs + uintptr(v2)*2)) = int16(int64(s) - int64(base)) - s = s + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))+int32(1)) + **(**int16)(__ccgo_up(offs + uintptr(v2)*2)) = int16(int64(s) - int64(base)) + s = s + uintptr(Int32FromUint8(**(**uint8)(__ccgo_up(s)))+int32(1)) goto _1 _1: } @@ -118707,7 +118707,7 @@ func _getlens(tls *TLS, lens uintptr, s uintptr, l int32) (r int32) { k = 0 for { for { - if !(j < l && int32(*(*int8)(unsafe.Pointer(s + uintptr(j)))) != int32('.')) { + if !(j < l && int32(**(**int8)(__ccgo_up(s + uintptr(j)))) != int32('.')) { break } goto _2 @@ -118720,7 +118720,7 @@ func _getlens(tls *TLS, lens uintptr, s uintptr, l int32) (r int32) { } v3 = i i = i + 1 - *(*uint8)(unsafe.Pointer(lens + uintptr(v3))) = Uint8FromInt32(j - k) + **(**uint8)(__ccgo_up(lens + uintptr(v3))) = Uint8FromInt32(j - k) if j == l { return i } @@ -118750,15 +118750,15 @@ func _match(tls *TLS, offset uintptr, base uintptr, dn uintptr, end uintptr, len for { nlen = nlen - 1 v2 = nlen - l = Int32FromUint8(*(*uint8)(unsafe.Pointer(lens + uintptr(v2)))) + l = Int32FromUint8(**(**uint8)(__ccgo_up(lens + uintptr(v2)))) noff = noff - 1 v2 = noff - o = int32((*(*[128]int16)(unsafe.Pointer(bp)))[v2]) + o = int32((**(**[128]int16)(__ccgo_up(bp)))[v2]) end = end - uintptr(l) - if l != Int32FromUint8(*(*uint8)(unsafe.Pointer(base + uintptr(o)))) || Xmemcmp(tls, base+uintptr(o)+uintptr(1), end, Uint64FromInt32(l)) != 0 { + if l != Int32FromUint8(**(**uint8)(__ccgo_up(base + uintptr(o)))) || Xmemcmp(tls, base+uintptr(o)+uintptr(1), end, Uint64FromInt32(l)) != 0 { return m } - *(*int32)(unsafe.Pointer(offset)) = o + **(**int32)(__ccgo_up(offset)) = o m = m + l if nlen != 0 { m = m + 1 @@ -118789,14 +118789,14 @@ func Xdn_comp(tls *TLS, src uintptr, dst uintptr, space int32, dnptrs uintptr, l m = 0 bestlen = 0 l = Xstrnlen(tls, src, uint64(255)) - if l != 0 && int32(*(*int8)(unsafe.Pointer(src + uintptr(l-uint64(1))))) == int32('.') { + if l != 0 && int32(**(**int8)(__ccgo_up(src + uintptr(l-uint64(1))))) == int32('.') { l = l - 1 } if l > uint64(253) || space <= 0 { return -int32(1) } if !(l != 0) { - *(*uint8)(unsafe.Pointer(dst)) = uint8(0) + **(**uint8)(__ccgo_up(dst)) = uint8(0) return int32(1) } end = src + uintptr(l) @@ -118805,16 +118805,16 @@ func Xdn_comp(tls *TLS, src uintptr, dst uintptr, space int32, dnptrs uintptr, l return -int32(1) } p = dnptrs - if p != 0 && *(*uintptr)(unsafe.Pointer(p)) != 0 { + if p != 0 && **(**uintptr)(__ccgo_up(p)) != 0 { p += 8 for { - if !(*(*uintptr)(unsafe.Pointer(p)) != 0) { + if !(**(**uintptr)(__ccgo_up(p)) != 0) { break } - m = _match(tls, bp, *(*uintptr)(unsafe.Pointer(dnptrs)), *(*uintptr)(unsafe.Pointer(p)), end, bp+4, n) + m = _match(tls, bp, **(**uintptr)(__ccgo_up(dnptrs)), **(**uintptr)(__ccgo_up(p)), end, bp+4, n) if m > bestlen { bestlen = m - bestoff = *(*int32)(unsafe.Pointer(bp)) + bestoff = **(**int32)(__ccgo_up(bp)) if Uint64FromInt32(m) == l { break } @@ -118837,37 +118837,37 @@ func Xdn_comp(tls *TLS, src uintptr, dst uintptr, space int32, dnptrs uintptr, l if !(Uint64FromInt32(i) < l-Uint64FromInt32(bestlen)) { break } - *(*uint8)(unsafe.Pointer(dst + uintptr(i))) = (*(*[127]uint8)(unsafe.Pointer(bp + 4)))[j] + **(**uint8)(__ccgo_up(dst + uintptr(i))) = (**(**[127]uint8)(__ccgo_up(bp + 4)))[j] goto _2 _2: ; v3 = j j = j + 1 - i = i + (Int32FromUint8((*(*[127]uint8)(unsafe.Pointer(bp + 4)))[v3]) + int32(1)) + i = i + (Int32FromUint8((**(**[127]uint8)(__ccgo_up(bp + 4)))[v3]) + int32(1)) } /* add tail */ if bestlen != 0 { v3 = i i = i + 1 - *(*uint8)(unsafe.Pointer(dst + uintptr(v3))) = Uint8FromInt32(int32(0xc0) | bestoff>>int32(8)) + **(**uint8)(__ccgo_up(dst + uintptr(v3))) = Uint8FromInt32(int32(0xc0) | bestoff>>int32(8)) v3 = i i = i + 1 - *(*uint8)(unsafe.Pointer(dst + uintptr(v3))) = Uint8FromInt32(bestoff) + **(**uint8)(__ccgo_up(dst + uintptr(v3))) = Uint8FromInt32(bestoff) } else { v3 = i i = i + 1 - *(*uint8)(unsafe.Pointer(dst + uintptr(v3))) = uint8(0) + **(**uint8)(__ccgo_up(dst + uintptr(v3))) = uint8(0) } /* save dst pointer */ - if i > int32(2) && lastdnptr != 0 && dnptrs != 0 && *(*uintptr)(unsafe.Pointer(dnptrs)) != 0 { - for *(*uintptr)(unsafe.Pointer(p)) != 0 { + if i > int32(2) && lastdnptr != 0 && dnptrs != 0 && **(**uintptr)(__ccgo_up(dnptrs)) != 0 { + for **(**uintptr)(__ccgo_up(p)) != 0 { p += 8 } if p+uintptr(1)*8 < lastdnptr { v8 = p p += 8 - *(*uintptr)(unsafe.Pointer(v8)) = dst - *(*uintptr)(unsafe.Pointer(p)) = uintptr(0) + **(**uintptr)(__ccgo_up(v8)) = dst + **(**uintptr)(__ccgo_up(p)) = uintptr(0) } } return i @@ -118900,11 +118900,11 @@ func X__dn_expand(tls *TLS, base uintptr, end uintptr, src uintptr, dest uintptr break } /* loop invariants: p= int64(end)-int64(p) || int64(j) >= int64(dend)-int64(dest) { return -int32(1) } @@ -118935,10 +118935,10 @@ func X__dn_expand(tls *TLS, base uintptr, end uintptr, src uintptr, dest uintptr dest = dest + 1 v4 = p p = p + 1 - *(*int8)(unsafe.Pointer(v3)) = Int8FromUint8(*(*uint8)(unsafe.Pointer(v4))) + **(**int8)(__ccgo_up(v3)) = Int8FromUint8(**(**uint8)(__ccgo_up(v4))) } } else { - *(*int8)(unsafe.Pointer(dest)) = 0 + **(**int8)(__ccgo_up(dest)) = 0 if len1 < 0 { len1 = int32(int64(p+uintptr(1)) - int64(src)) } @@ -118970,20 +118970,20 @@ func Xdn_skipname(tls *TLS, s uintptr, end uintptr) (r int32) { _ = p p = s for p < end { - if !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if !(**(**uint8)(__ccgo_up(p)) != 0) { return int32(int64(p) - int64(s) + int64(1)) } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) >= int32(192) { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) >= int32(192) { if p+uintptr(1) < end { return int32(int64(p) - int64(s) + int64(2)) } else { break } } else { - if int64(end)-int64(p) < int64(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))+int32(1)) { + if int64(end)-int64(p) < int64(Int32FromUint8(**(**uint8)(__ccgo_up(p)))+int32(1)) { break } else { - p = p + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))+int32(1)) + p = p + uintptr(Int32FromUint8(**(**uint8)(__ccgo_up(p)))+int32(1)) } } } @@ -119099,25 +119099,25 @@ func X__dns_parse(tls *TLS, r uintptr, rlen int32, __ccgo_fp_callback uintptr, c if rlen < int32(12) { return -int32(1) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 3)))&int32(15) != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(r + 3)))&int32(15) != 0 { return 0 } p = r + uintptr(12) - qdcount = Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 4)))*int32(256) + Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 5))) - ancount = Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 6)))*int32(256) + Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 7))) + qdcount = Int32FromUint8(**(**uint8)(__ccgo_up(r + 4)))*int32(256) + Int32FromUint8(**(**uint8)(__ccgo_up(r + 5))) + ancount = Int32FromUint8(**(**uint8)(__ccgo_up(r + 6)))*int32(256) + Int32FromUint8(**(**uint8)(__ccgo_up(r + 7))) for { v1 = qdcount qdcount = qdcount - 1 if !(v1 != 0) { break } - for int64(p)-int64(r) < int64(rlen) && uint32(*(*uint8)(unsafe.Pointer(p)))-uint32(1) < uint32(127) { + for int64(p)-int64(r) < int64(rlen) && uint32(**(**uint8)(__ccgo_up(p)))-uint32(1) < uint32(127) { p = p + 1 } if p > r+uintptr(rlen)-uintptr(6) { return -int32(1) } - p = p + uintptr(int32(5)+BoolInt32(!!(*(*uint8)(unsafe.Pointer(p)) != 0))) + p = p + uintptr(int32(5)+BoolInt32(!!(**(**uint8)(__ccgo_up(p)) != 0))) } for { v1 = ancount @@ -119125,18 +119125,18 @@ func X__dns_parse(tls *TLS, r uintptr, rlen int32, __ccgo_fp_callback uintptr, c if !(v1 != 0) { break } - for int64(p)-int64(r) < int64(rlen) && uint32(*(*uint8)(unsafe.Pointer(p)))-uint32(1) < uint32(127) { + for int64(p)-int64(r) < int64(rlen) && uint32(**(**uint8)(__ccgo_up(p)))-uint32(1) < uint32(127) { p = p + 1 } if p > r+uintptr(rlen)-uintptr(12) { return -int32(1) } - p = p + uintptr(int32(1)+BoolInt32(!!(*(*uint8)(unsafe.Pointer(p)) != 0))) - len1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 8)))*int32(256) + Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 9))) + p = p + uintptr(int32(1)+BoolInt32(!!(**(**uint8)(__ccgo_up(p)) != 0))) + len1 = Int32FromUint8(**(**uint8)(__ccgo_up(p + 8)))*int32(256) + Int32FromUint8(**(**uint8)(__ccgo_up(p + 9))) if int64(len1+int32(10)) > int64(r+uintptr(rlen))-int64(p) { return -int32(1) } - if (*(*func(*TLS, uintptr, int32, uintptr, int32, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_callback})))(tls, ctx, Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))), p+uintptr(10), len1, r, rlen) < 0 { + if (*(*func(*TLS, uintptr, int32, uintptr, int32, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_callback})))(tls, ctx, Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))), p+uintptr(10), len1, r, rlen) < 0 { return -int32(1) } p = p + uintptr(int32(10)+len1) @@ -119478,27 +119478,27 @@ func Xether_aton_r(tls *TLS, x uintptr, p_a uintptr) (r uintptr) { break } if ii != 0 { - if int32(*(*int8)(unsafe.Pointer(x))) != int32(':') { + if int32(**(**int8)(__ccgo_up(x))) != int32(':') { return uintptr(0) } else { x = x + 1 } } n = Xstrtoul(tls, x, bp+8, int32(16)) - x = *(*uintptr)(unsafe.Pointer(bp + 8)) + x = **(**uintptr)(__ccgo_up(bp + 8)) if n > uint64(0xFF) { return uintptr(0) } /* bad byte */ - *(*Tuint8_t)(unsafe.Pointer(bp + uintptr(ii))) = uint8(n) + **(**Tuint8_t)(__ccgo_up(bp + uintptr(ii))) = uint8(n) goto _1 _1: ; ii = ii + 1 } - if int32(*(*int8)(unsafe.Pointer(x))) != 0 { + if int32(**(**int8)(__ccgo_up(x))) != 0 { return uintptr(0) } /* bad format */ - *(*Tether_addr)(unsafe.Pointer(p_a)) = *(*Tether_addr)(unsafe.Pointer(bp)) + **(**Tether_addr)(__ccgo_up(p_a)) = **(**Tether_addr)(__ccgo_up(bp)) return p_a } @@ -119533,7 +119533,7 @@ func Xether_ntoa_r(tls *TLS, p_a uintptr, x uintptr) (r uintptr) { } else { v2 = __ccgo_ts + 993 } - x = x + uintptr(Xsprintf(tls, x, v2, VaList(bp+8, Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(p_a + uintptr(ii))))))) + x = x + uintptr(Xsprintf(tls, x, v2, VaList(bp+8, Int32FromUint8(**(**Tuint8_t)(__ccgo_up(p_a + uintptr(ii))))))) goto _1 _1: ; @@ -119618,11 +119618,11 @@ func Xgai_strerror(tls *TLS, ecode int32) (r uintptr) { s = uintptr(unsafe.Pointer(&_msgs)) ecode = ecode + 1 for { - if !(ecode != 0 && *(*int8)(unsafe.Pointer(s)) != 0) { + if !(ecode != 0 && **(**int8)(__ccgo_up(s)) != 0) { break } for { - if !(*(*int8)(unsafe.Pointer(s)) != 0) { + if !(**(**int8)(__ccgo_up(s)) != 0) { break } goto _2 @@ -119636,7 +119636,7 @@ func Xgai_strerror(tls *TLS, ecode int32) (r uintptr) { ecode = ecode + 1 s = s + 1 } - if !(*(*int8)(unsafe.Pointer(s)) != 0) { + if !(**(**int8)(__ccgo_up(s)) != 0) { s = s + 1 } return X__lctrans_cur(tls, s) @@ -119712,15 +119712,15 @@ func Xgetaddrinfo(tls *TLS, host uintptr, serv uintptr, hint uintptr, res uintpt if s >= 0 { _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp+1608) r = Xconnect(tls, s, ta[i], tl[i]) - saved_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 1608)), uintptr(0)) + saved_errno = **(**int32)(__ccgo_up(X__errno_location(tls))) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 1608)), uintptr(0)) Xclose(tls, s) if !(r != 0) { goto _1 } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = saved_errno + **(**int32)(__ccgo_up(X__errno_location(tls))) = saved_errno } - switch *(*int32)(unsafe.Pointer(X__errno_location(tls))) { + switch **(**int32)(__ccgo_up(X__errno_location(tls))) { case int32(EADDRNOTAVAIL): fallthrough case int32(EAFNOSUPPORT): @@ -119778,32 +119778,32 @@ func Xgetaddrinfo(tls *TLS, host uintptr, serv uintptr, hint uintptr, res uintpt if !(j < nservs) { break } - (*(*Taibuf)(unsafe.Pointer(out + uintptr(k)*88))).Fslot = int16(k) - if (*(*[48]Taddress)(unsafe.Pointer(bp + 8)))[i].Ffamily == int32(PF_INET) { + (**(**Taibuf)(__ccgo_up(out + uintptr(k)*88))).Fslot = int16(k) + if (**(**[48]Taddress)(__ccgo_up(bp + 8)))[i].Ffamily == int32(PF_INET) { v5 = uint64(16) } else { v5 = uint64(28) } - (*(*Taibuf)(unsafe.Pointer(out + uintptr(k)*88))).Fai = Taddrinfo{ - Fai_family: (*(*[48]Taddress)(unsafe.Pointer(bp + 8)))[i].Ffamily, - Fai_socktype: Int32FromUint8((*(*[2]Tservice)(unsafe.Pointer(bp)))[j].Fsocktype), - Fai_protocol: Int32FromUint8((*(*[2]Tservice)(unsafe.Pointer(bp)))[j].Fproto), + (**(**Taibuf)(__ccgo_up(out + uintptr(k)*88))).Fai = Taddrinfo{ + Fai_family: (**(**[48]Taddress)(__ccgo_up(bp + 8)))[i].Ffamily, + Fai_socktype: Int32FromUint8((**(**[2]Tservice)(__ccgo_up(bp)))[j].Fsocktype), + Fai_protocol: Int32FromUint8((**(**[2]Tservice)(__ccgo_up(bp)))[j].Fproto), Fai_addrlen: uint32(v5), Fai_addr: out + uintptr(k)*88 + 48, Fai_canonname: outcanon, } if k != 0 { - (*(*Taibuf)(unsafe.Pointer(out + uintptr(k-int32(1))*88))).Fai.Fai_next = out + uintptr(k)*88 + (**(**Taibuf)(__ccgo_up(out + uintptr(k-int32(1))*88))).Fai.Fai_next = out + uintptr(k)*88 } - switch (*(*[48]Taddress)(unsafe.Pointer(bp + 8)))[i].Ffamily { + switch (**(**[48]Taddress)(__ccgo_up(bp + 8)))[i].Ffamily { case int32(PF_INET): *(*Tsa_family_t)(unsafe.Pointer(out + uintptr(k)*88 + 48)) = uint16(PF_INET) - *(*Tin_port_t)(unsafe.Pointer(out + uintptr(k)*88 + 48 + 2)) = Xhtons(tls, (*(*[2]Tservice)(unsafe.Pointer(bp)))[j].Fport) + *(*Tin_port_t)(unsafe.Pointer(out + uintptr(k)*88 + 48 + 2)) = Xhtons(tls, (**(**[2]Tservice)(__ccgo_up(bp)))[j].Fport) Xmemcpy(tls, out+uintptr(k)*88+48+4, bp+8+uintptr(i)*28+8, uint64(4)) case int32(PF_INET6): *(*Tsa_family_t)(unsafe.Pointer(out + uintptr(k)*88 + 48)) = uint16(PF_INET6) - *(*Tin_port_t)(unsafe.Pointer(out + uintptr(k)*88 + 48 + 2)) = Xhtons(tls, (*(*[2]Tservice)(unsafe.Pointer(bp)))[j].Fport) - *(*Tuint32_t)(unsafe.Pointer(out + uintptr(k)*88 + 48 + 24)) = (*(*[48]Taddress)(unsafe.Pointer(bp + 8)))[i].Fscopeid + *(*Tin_port_t)(unsafe.Pointer(out + uintptr(k)*88 + 48 + 2)) = Xhtons(tls, (**(**[2]Tservice)(__ccgo_up(bp)))[j].Fport) + *(*Tuint32_t)(unsafe.Pointer(out + uintptr(k)*88 + 48 + 24)) = (**(**[48]Taddress)(__ccgo_up(bp + 8)))[i].Fscopeid Xmemcpy(tls, out+uintptr(k)*88+48+8, bp+8+uintptr(i)*28+8, uint64(16)) break } @@ -119818,8 +119818,8 @@ func Xgetaddrinfo(tls *TLS, host uintptr, serv uintptr, hint uintptr, res uintpt ; i = i + 1 } - (*(*Taibuf)(unsafe.Pointer(out))).Fref = int16(nais) - *(*uintptr)(unsafe.Pointer(res)) = out + (**(**Taibuf)(__ccgo_up(out))).Fref = int16(nais) + **(**uintptr)(__ccgo_up(res)) = out return 0 } @@ -119950,12 +119950,12 @@ func Xgethostbyaddr(tls *TLS, a uintptr, l Tsocklen_t, af int32) (r uintptr) { size = size + (size + uint64(1)) _h = Xmalloc(tls, size) if !(_h != 0) { - *(*int32)(unsafe.Pointer(X__h_errno_location(tls))) = int32(NO_RECOVERY) + **(**int32)(__ccgo_up(X__h_errno_location(tls))) = int32(NO_RECOVERY) return uintptr(0) } err = Xgethostbyaddr_r(tls, a, l, af, _h, _h+UintptrFromInt32(1)*32, size-uint64(32), bp, X__h_errno_location(tls)) } - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } var _h uintptr @@ -119992,7 +119992,7 @@ func Xgethostbyaddr_r(tls *TLS, a uintptr, l Tsocklen_t, af int32, h uintptr, bu v1 = uint64(16) } sl = uint32(v1) - *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) + **(**uintptr)(__ccgo_up(res)) = uintptr(0) /* Load address argument into sockaddr structure */ if af == int32(PF_INET6) && l == uint32(16) { Xmemcpy(tls, bp+8, a, uint64(16)) @@ -120000,7 +120000,7 @@ func Xgethostbyaddr_r(tls *TLS, a uintptr, l Tsocklen_t, af int32, h uintptr, bu if af == int32(PF_INET) && l == uint32(4) { Xmemcpy(tls, bp+4, a, uint64(4)) } else { - *(*int32)(unsafe.Pointer(err)) = int32(NO_RECOVERY) + **(**int32)(__ccgo_up(err)) = int32(NO_RECOVERY) return int32(EINVAL) } } @@ -120018,33 +120018,33 @@ func Xgethostbyaddr_r(tls *TLS, a uintptr, l Tsocklen_t, af int32, h uintptr, bu buf = buf + uintptr(Uint64FromInt32(2)*Uint64FromInt64(8)) (*Thostent)(unsafe.Pointer(h)).Fh_aliases = buf buf = buf + uintptr(Uint64FromInt32(2)*Uint64FromInt64(8)) - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list)) = buf - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list)), a, uint64(l)) + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_addr_list)) = buf + Xmemcpy(tls, **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_addr_list)), a, uint64(l)) buf = buf + uintptr(l) - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + 1*8)) = uintptr(0) - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) = buf - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = uintptr(0) + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + 1*8)) = uintptr(0) + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) = buf + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = uintptr(0) switch Xgetnameinfo(tls, bp, sl, buf, uint32(buflen), uintptr(0), uint32(0), 0) { case -int32(3): - *(*int32)(unsafe.Pointer(err)) = int32(TRY_AGAIN) + **(**int32)(__ccgo_up(err)) = int32(TRY_AGAIN) return int32(EAGAIN) case -int32(12): return int32(ERANGE) default: fallthrough case -int32(4): - *(*int32)(unsafe.Pointer(err)) = int32(NO_RECOVERY) + **(**int32)(__ccgo_up(err)) = int32(NO_RECOVERY) return int32(EBADMSG) case -int32(11): - *(*int32)(unsafe.Pointer(err)) = int32(NO_RECOVERY) - return *(*int32)(unsafe.Pointer(X__errno_location(tls))) + **(**int32)(__ccgo_up(err)) = int32(NO_RECOVERY) + return **(**int32)(__ccgo_up(X__errno_location(tls))) case 0: break } (*Thostent)(unsafe.Pointer(h)).Fh_addrtype = af (*Thostent)(unsafe.Pointer(h)).Fh_length = Int32FromUint32(l) - (*Thostent)(unsafe.Pointer(h)).Fh_name = *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) - *(*uintptr)(unsafe.Pointer(res)) = h + (*Thostent)(unsafe.Pointer(h)).Fh_name = **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) + **(**uintptr)(__ccgo_up(res)) = h return 0 } @@ -120073,12 +120073,12 @@ func Xgethostbyname2(tls *TLS, name uintptr, af int32) (r uintptr) { size = size + (size + uint64(1)) _h1 = Xmalloc(tls, size) if !(_h1 != 0) { - *(*int32)(unsafe.Pointer(X__h_errno_location(tls))) = int32(NO_RECOVERY) + **(**int32)(__ccgo_up(X__h_errno_location(tls))) = int32(NO_RECOVERY) return uintptr(0) } err = Xgethostbyname2_r(tls, name, af, _h1, _h1+UintptrFromInt32(1)*32, size-uint64(32), bp, X__h_errno_location(tls)) } - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } var _h1 uintptr @@ -120096,27 +120096,27 @@ func Xgethostbyname2_r(tls *TLS, name uintptr, af int32, h uintptr, buf uintptr, var _ /* addrs at bp+0 */ [48]Taddress var _ /* canon at bp+1344 */ [256]int8 _, _, _, _, _, _ = align, cnt, i, need, v1, v3 - *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) + **(**uintptr)(__ccgo_up(res)) = uintptr(0) cnt = X__lookup_name(tls, bp, bp+1344, name, af, int32(AI_CANONNAME)) if cnt < 0 { switch cnt { case -int32(2): - *(*int32)(unsafe.Pointer(err)) = int32(HOST_NOT_FOUND) + **(**int32)(__ccgo_up(err)) = int32(HOST_NOT_FOUND) return 0 case -int32(5): - *(*int32)(unsafe.Pointer(err)) = int32(NO_DATA) + **(**int32)(__ccgo_up(err)) = int32(NO_DATA) return 0 case -int32(3): - *(*int32)(unsafe.Pointer(err)) = int32(TRY_AGAIN) + **(**int32)(__ccgo_up(err)) = int32(TRY_AGAIN) return int32(EAGAIN) default: fallthrough case -int32(4): - *(*int32)(unsafe.Pointer(err)) = int32(NO_RECOVERY) + **(**int32)(__ccgo_up(err)) = int32(NO_RECOVERY) return int32(EBADMSG) case -int32(11): - *(*int32)(unsafe.Pointer(err)) = int32(NO_RECOVERY) - return *(*int32)(unsafe.Pointer(X__errno_location(tls))) + **(**int32)(__ccgo_up(err)) = int32(NO_RECOVERY) + return **(**int32)(__ccgo_up(X__errno_location(tls))) } } (*Thostent)(unsafe.Pointer(h)).Fh_addrtype = af @@ -120146,29 +120146,29 @@ func Xgethostbyname2_r(tls *TLS, name uintptr, af int32, h uintptr, buf uintptr, if !(i < cnt) { break } - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)) = buf + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)) = buf buf = buf + uintptr((*Thostent)(unsafe.Pointer(h)).Fh_length) - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)), bp+uintptr(i)*28+8, Uint64FromInt32((*Thostent)(unsafe.Pointer(h)).Fh_length)) + Xmemcpy(tls, **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)), bp+uintptr(i)*28+8, Uint64FromInt32((*Thostent)(unsafe.Pointer(h)).Fh_length)) goto _2 _2: ; i = i + 1 } - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)) = uintptr(0) + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)) = uintptr(0) v3 = buf - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) = v3 + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) = v3 (*Thostent)(unsafe.Pointer(h)).Fh_name = v3 Xstrcpy(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name, bp+1344) buf = buf + uintptr(_strlen(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name)+uint64(1)) if Xstrcmp(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name, name) != 0 { - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = buf - Xstrcpy(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)), name) - buf = buf + uintptr(_strlen(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)))+uint64(1)) + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = buf + Xstrcpy(tls, **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)), name) + buf = buf + uintptr(_strlen(tls, **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)))+uint64(1)) } else { - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = uintptr(0) + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = uintptr(0) } - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 2*8)) = uintptr(0) - *(*uintptr)(unsafe.Pointer(res)) = h + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 2*8)) = uintptr(0) + **(**uintptr)(__ccgo_up(res)) = h return 0 } @@ -120397,7 +120397,7 @@ func _copy_addr(tls *TLS, r uintptr, af int32, sa uintptr, addr uintptr, addrlen case int32(PF_INET6): dst = sa + 8 len1 = int32(16) - if Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(addr))) == int32(0xfe) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(addr + 1)))&int32(0xc0) == int32(0x80) || Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(addr))) == int32(0xff) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(addr + 1)))&int32(0xf) == int32(0x2) { + if Int32FromUint8(**(**Tuint8_t)(__ccgo_up(addr))) == int32(0xfe) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(addr + 1)))&int32(0xc0) == int32(0x80) || Int32FromUint8(**(**Tuint8_t)(__ccgo_up(addr))) == int32(0xff) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(addr + 1)))&int32(0xf) == int32(0x2) { (*(*Tsockaddr_in6)(unsafe.Pointer(sa))).Fsin6_scope_id = Uint32FromInt32(ifindex) } default: @@ -120408,7 +120408,7 @@ func _copy_addr(tls *TLS, r uintptr, af int32, sa uintptr, addr uintptr, addrlen } (*Tsockany)(unsafe.Pointer(sa)).Fsa.Fsa_family = Uint16FromInt32(af) Xmemcpy(tls, dst, addr, Uint64FromInt32(len1)) - *(*uintptr)(unsafe.Pointer(r)) = sa + **(**uintptr)(__ccgo_up(r)) = sa } func _gen_netmask(tls *TLS, r uintptr, af int32, sa uintptr, prefixlen int32) { @@ -120417,7 +120417,7 @@ func _gen_netmask(tls *TLS, r uintptr, af int32, sa uintptr, prefixlen int32) { var i, v1 int32 var _ /* addr at bp+0 */ [16]Tuint8_t _, _ = i, v1 - *(*[16]Tuint8_t)(unsafe.Pointer(bp)) = [16]Tuint8_t{} + **(**[16]Tuint8_t)(__ccgo_up(bp)) = [16]Tuint8_t{} if Uint64FromInt32(prefixlen) > Uint64FromInt32(8)*Uint64FromInt64(16) { prefixlen = Int32FromUint64(Uint64FromInt32(8) * Uint64FromInt64(16)) } @@ -120426,7 +120426,7 @@ func _gen_netmask(tls *TLS, r uintptr, af int32, sa uintptr, prefixlen int32) { if Uint64FromInt32(i) < uint64(16) { v1 = i i = i + 1 - (*(*[16]Tuint8_t)(unsafe.Pointer(bp)))[v1] = Uint8FromInt32(int32(0xff) << (int32(8) - prefixlen%int32(8))) + (**(**[16]Tuint8_t)(__ccgo_up(bp)))[v1] = Uint8FromInt32(int32(0xff) << (int32(8) - prefixlen%int32(8))) } _copy_addr(tls, r, af, sa, bp, uint64(16), 0) } @@ -120440,7 +120440,7 @@ func _copy_lladdr(tls *TLS, r uintptr, sa uintptr, addr uintptr, addrlen Tsize_t (*(*Tsockaddr_ll_hack)(unsafe.Pointer(sa))).Fsll_hatype = hatype (*(*Tsockaddr_ll_hack)(unsafe.Pointer(sa))).Fsll_halen = uint8(addrlen) Xmemcpy(tls, sa+12, addr, addrlen) - *(*uintptr)(unsafe.Pointer(r)) = sa + **(**uintptr)(__ccgo_up(r)) = sa } func _netlink_msg_to_ifaddr(tls *TLS, pctx uintptr, h uintptr) (r int32) { @@ -120469,7 +120469,7 @@ func _netlink_msg_to_ifaddr(tls *TLS, pctx uintptr, h uintptr) (r int32) { rta = rta + uintptr((Int32FromUint16((*Trtattr)(unsafe.Pointer(rta)).Frta_len)+Int32FromInt32(3)) & ^Int32FromInt32(3)) } } else { - ifs0 = *(*uintptr)(unsafe.Pointer(ctx + 16 + uintptr((*Tifaddrmsg)(unsafe.Pointer(ifa)).Fifa_index%uint32(IFADDRS_HASH_SIZE))*8)) + ifs0 = **(**uintptr)(__ccgo_up(ctx + 16 + uintptr((*Tifaddrmsg)(unsafe.Pointer(ifa)).Fifa_index%uint32(IFADDRS_HASH_SIZE))*8)) for { if !(ifs0 != 0) { break @@ -120520,8 +120520,8 @@ func _netlink_msg_to_ifaddr(tls *TLS, pctx uintptr, h uintptr) (r int32) { } if (*Tifaddrs_storage)(unsafe.Pointer(ifs)).Fifa.Fifa_name != 0 { bucket = (*Tifaddrs_storage)(unsafe.Pointer(ifs)).Findex % uint32(IFADDRS_HASH_SIZE) - (*Tifaddrs_storage)(unsafe.Pointer(ifs)).Fhash_next = *(*uintptr)(unsafe.Pointer(ctx + 16 + uintptr(bucket)*8)) - *(*uintptr)(unsafe.Pointer(ctx + 16 + uintptr(bucket)*8)) = ifs + (*Tifaddrs_storage)(unsafe.Pointer(ifs)).Fhash_next = **(**uintptr)(__ccgo_up(ctx + 16 + uintptr(bucket)*8)) + **(**uintptr)(__ccgo_up(ctx + 16 + uintptr(bucket)*8)) = ifs } } else { (*Tifaddrs_storage)(unsafe.Pointer(ifs)).Fifa.Fifa_name = (*Tifaddrs_storage)(unsafe.Pointer(ifs0)).Fifa.Fifa_name @@ -120596,7 +120596,7 @@ func Xgetifaddrs(tls *TLS, ifap uintptr) (r1 int32) { Xmemset(tls, ctx, 0, uint64(528)) r = X__rtnetlink_enumerate(tls, PF_UNSPEC, PF_UNSPEC, __ccgo_fp(_netlink_msg_to_ifaddr), ctx) if r == 0 { - *(*uintptr)(unsafe.Pointer(ifap)) = (*Tifaddrs_ctx)(unsafe.Pointer(ctx)).Ffirst + **(**uintptr)(__ccgo_up(ifap)) = (*Tifaddrs_ctx)(unsafe.Pointer(ctx)).Ffirst } else { Xfreeifaddrs(tls, (*Tifaddrs_ctx)(unsafe.Pointer(ctx)).Ffirst) } @@ -120611,11 +120611,11 @@ func _itoa(tls *TLS, p uintptr, x uint32) (r uintptr) { p = p + uintptr(Uint64FromInt32(3)*Uint64FromInt64(4)) p = p - 1 v1 = p - *(*int8)(unsafe.Pointer(v1)) = 0 + **(**int8)(__ccgo_up(v1)) = 0 for cond := true; cond; cond = x != 0 { p = p - 1 v1 = p - *(*int8)(unsafe.Pointer(v1)) = Int8FromUint32(uint32('0') + x%uint32(10)) + **(**int8)(__ccgo_up(v1)) = Int8FromUint32(uint32('0') + x%uint32(10)) x = x / uint32(10) } return p @@ -120624,7 +120624,7 @@ func _itoa(tls *TLS, p uintptr, x uint32) (r uintptr) { func _mkptr4(tls *TLS, s uintptr, ip uintptr) { bp := tls.Alloc(48) defer tls.Free(48) - Xsprintf(tls, s, __ccgo_ts+999, VaList(bp+8, Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + 3))), Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + 2))), Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + 1))), Int32FromUint8(*(*uint8)(unsafe.Pointer(ip))))) + Xsprintf(tls, s, __ccgo_ts+999, VaList(bp+8, Int32FromUint8(**(**uint8)(__ccgo_up(ip + 3))), Int32FromUint8(**(**uint8)(__ccgo_up(ip + 2))), Int32FromUint8(**(**uint8)(__ccgo_up(ip + 1))), Int32FromUint8(**(**uint8)(__ccgo_up(ip))))) } func _mkptr6(tls *TLS, s uintptr, ip uintptr) { @@ -120638,16 +120638,16 @@ func _mkptr6(tls *TLS, s uintptr, ip uintptr) { } v2 = s s = s + 1 - *(*int8)(unsafe.Pointer(v2)) = _xdigits[Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + uintptr(i))))&int32(15)] + **(**int8)(__ccgo_up(v2)) = _xdigits[Int32FromUint8(**(**uint8)(__ccgo_up(ip + uintptr(i))))&int32(15)] v2 = s s = s + 1 - *(*int8)(unsafe.Pointer(v2)) = int8('.') + **(**int8)(__ccgo_up(v2)) = int8('.') v2 = s s = s + 1 - *(*int8)(unsafe.Pointer(v2)) = _xdigits[Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + uintptr(i))))>>int32(4)] + **(**int8)(__ccgo_up(v2)) = _xdigits[Int32FromUint8(**(**uint8)(__ccgo_up(ip + uintptr(i))))>>int32(4)] v2 = s s = s + 1 - *(*int8)(unsafe.Pointer(v2)) = int8('.') + **(**int8)(__ccgo_up(v2)) = int8('.') goto _1 _1: ; @@ -120685,13 +120685,13 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int if v1 != 0 { v2 = p p = p + 1 - *(*int8)(unsafe.Pointer(v2)) = int8('\n') - *(*int8)(unsafe.Pointer(p)) = Int8FromInt32(0) + **(**int8)(__ccgo_up(v2)) = int8('\n') + **(**int8)(__ccgo_up(p)) = Int8FromInt32(0) } p = bp for { - if v7 = *(*int8)(unsafe.Pointer(p)) != 0; v7 { - v4 = int32(*(*int8)(unsafe.Pointer(p))) + if v7 = **(**int8)(__ccgo_up(p)) != 0; v7 { + v4 = int32(**(**int8)(__ccgo_up(p))) v5 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _6 _6: @@ -120704,26 +120704,26 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int ; p = p + 1 } - if !(*(*int8)(unsafe.Pointer(p)) != 0) { + if !(**(**int8)(__ccgo_up(p)) != 0) { continue } v1 = p p = p + 1 - *(*int8)(unsafe.Pointer(v1)) = 0 + **(**int8)(__ccgo_up(v1)) = 0 if X__lookup_ipliteral(tls, bp+1560, bp, PF_UNSPEC) <= 0 { continue } - if (*(*Taddress)(unsafe.Pointer(bp + 1560))).Ffamily == int32(PF_INET) { + if (**(**Taddress)(__ccgo_up(bp + 1560))).Ffamily == int32(PF_INET) { Xmemcpy(tls, bp+1560+8+uintptr(12), bp+1560+8, uint64(4)) Xmemcpy(tls, bp+1560+8, __ccgo_ts+1044, uint64(12)) - (*(*Taddress)(unsafe.Pointer(bp + 1560))).Fscopeid = uint32(0) + (**(**Taddress)(__ccgo_up(bp + 1560))).Fscopeid = uint32(0) } - if Xmemcmp(tls, a, bp+1560+8, uint64(16)) != 0 || (*(*Taddress)(unsafe.Pointer(bp + 1560))).Fscopeid != scopeid { + if Xmemcmp(tls, a, bp+1560+8, uint64(16)) != 0 || (**(**Taddress)(__ccgo_up(bp + 1560))).Fscopeid != scopeid { continue } for { - if v7 = *(*int8)(unsafe.Pointer(p)) != 0; v7 { - v4 = int32(*(*int8)(unsafe.Pointer(p))) + if v7 = **(**int8)(__ccgo_up(p)) != 0; v7 { + v4 = int32(**(**int8)(__ccgo_up(p))) v5 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _12 _12: @@ -120738,8 +120738,8 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int } z = p for { - if v7 = *(*int8)(unsafe.Pointer(z)) != 0; v7 { - v4 = int32(*(*int8)(unsafe.Pointer(z))) + if v7 = **(**int8)(__ccgo_up(z)) != 0; v7 { + v4 = int32(**(**int8)(__ccgo_up(z))) v5 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _17 _17: @@ -120752,7 +120752,7 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int ; z = z + 1 } - *(*int8)(unsafe.Pointer(z)) = 0 + **(**int8)(__ccgo_up(z)) = 0 if int64(z)-int64(p) < int64(256) { Xmemcpy(tls, buf, p, Uint64FromInt64(int64(z)-int64(p)+int64(1))) break @@ -120783,13 +120783,13 @@ func _reverse_services(tls *TLS, buf uintptr, port int32, dgram int32) { if v1 != 0 { v2 = p p = p + 1 - *(*int8)(unsafe.Pointer(v2)) = int8('\n') - *(*int8)(unsafe.Pointer(p)) = Int8FromInt32(0) + **(**int8)(__ccgo_up(v2)) = int8('\n') + **(**int8)(__ccgo_up(p)) = Int8FromInt32(0) } p = bp for { - if v7 = *(*int8)(unsafe.Pointer(p)) != 0; v7 { - v4 = int32(*(*int8)(unsafe.Pointer(p))) + if v7 = **(**int8)(__ccgo_up(p)) != 0; v7 { + v4 = int32(**(**int8)(__ccgo_up(p))) v5 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _6 _6: @@ -120802,20 +120802,20 @@ func _reverse_services(tls *TLS, buf uintptr, port int32, dgram int32) { ; p = p + 1 } - if !(*(*int8)(unsafe.Pointer(p)) != 0) { + if !(**(**int8)(__ccgo_up(p)) != 0) { continue } v1 = p p = p + 1 - *(*int8)(unsafe.Pointer(v1)) = 0 + **(**int8)(__ccgo_up(v1)) = 0 svport = Xstrtoul(tls, p, bp+128, int32(10)) - if svport != Uint64FromInt32(port) || *(*uintptr)(unsafe.Pointer(bp + 128)) == p { + if svport != Uint64FromInt32(port) || **(**uintptr)(__ccgo_up(bp + 128)) == p { continue } - if dgram != 0 && Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(bp + 128)), __ccgo_ts+1071, uint64(4)) != 0 { + if dgram != 0 && Xstrncmp(tls, **(**uintptr)(__ccgo_up(bp + 128)), __ccgo_ts+1071, uint64(4)) != 0 { continue } - if !(dgram != 0) && Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(bp + 128)), __ccgo_ts+1076, uint64(4)) != 0 { + if !(dgram != 0) && Xstrncmp(tls, **(**uintptr)(__ccgo_up(bp + 128)), __ccgo_ts+1076, uint64(4)) != 0 { continue } if int64(p)-t__predefined_ptrdiff_t(bp) > int64(32) { @@ -120832,7 +120832,7 @@ func _dns_parse_callback(tls *TLS, c uintptr, rr int32, data uintptr, len1 int32 return 0 } if X__dn_expand(tls, packet, packet+uintptr(plen), data, c, int32(256)) <= 0 { - *(*int8)(unsafe.Pointer(c)) = 0 + **(**int8)(__ccgo_up(c)) = 0 } return 0 } @@ -120878,15 +120878,15 @@ func Xgetnameinfo(tls *TLS, sa uintptr, sl Tsocklen_t, node uintptr, nodelen Tso return -int32(6) } if node != 0 && nodelen != 0 { - (*(*[256]int8)(unsafe.Pointer(bp + 78)))[0] = 0 + (**(**[256]int8)(__ccgo_up(bp + 78)))[0] = 0 if !(flags&Int32FromInt32(NI_NUMERICHOST) != 0) { _reverse_hosts(tls, bp+78, a, scopeid, af) } - if !(*(*int8)(unsafe.Pointer(bp + 78)) != 0) && !(flags&Int32FromInt32(NI_NUMERICHOST) != 0) { + if !(**(**int8)(__ccgo_up(bp + 78)) != 0) && !(flags&Int32FromInt32(NI_NUMERICHOST) != 0) { qlen = X__res_mkquery(tls, 0, bp, int32(1), int32(RR_PTR), uintptr(0), 0, uintptr(0), bp+347, int32(96)) - (*(*[96]uint8)(unsafe.Pointer(bp + 347)))[int32(3)] = uint8(0) /* don't need AD flag */ + (**(**[96]uint8)(__ccgo_up(bp + 347)))[int32(3)] = uint8(0) /* don't need AD flag */ rlen = X__res_send(tls, bp+347, qlen, bp+443, int32(512)) - (*(*[256]int8)(unsafe.Pointer(bp + 78)))[0] = 0 + (**(**[256]int8)(__ccgo_up(bp + 78)))[0] = 0 if rlen > 0 { if Uint64FromInt32(rlen) > uint64(512) { rlen = int32(512) @@ -120894,14 +120894,14 @@ func Xgetnameinfo(tls *TLS, sa uintptr, sl Tsocklen_t, node uintptr, nodelen Tso X__dns_parse(tls, bp+443, rlen, __ccgo_fp(_dns_parse_callback), bp+78) } } - if !(*(*int8)(unsafe.Pointer(bp + 78)) != 0) { + if !(**(**int8)(__ccgo_up(bp + 78)) != 0) { if flags&int32(NI_NAMEREQD) != 0 { return -int32(2) } Xinet_ntop(tls, af, a, bp+78, uint32(256)) if scopeid != 0 { p = uintptr(0) - if !(flags&Int32FromInt32(NI_NUMERICSCOPE) != 0) && (Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a))) == int32(0xfe) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 1)))&int32(0xc0) == int32(0x80) || Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a))) == int32(0xff) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 1)))&int32(0xf) == int32(0x2)) { + if !(flags&Int32FromInt32(NI_NUMERICSCOPE) != 0) && (Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a))) == int32(0xfe) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 1)))&int32(0xc0) == int32(0x80) || Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a))) == int32(0xff) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 1)))&int32(0xf) == int32(0x2)) { p = Xif_indextoname(tls, scopeid, bp+955+uintptr(1)) } if !(p != 0) { @@ -120909,7 +120909,7 @@ func Xgetnameinfo(tls *TLS, sa uintptr, sl Tsocklen_t, node uintptr, nodelen Tso } p = p - 1 v1 = p - *(*int8)(unsafe.Pointer(v1)) = int8('%') + **(**int8)(__ccgo_up(v1)) = int8('%') Xstrcat(tls, bp+78, p) } } @@ -120921,11 +120921,11 @@ func Xgetnameinfo(tls *TLS, sa uintptr, sl Tsocklen_t, node uintptr, nodelen Tso if serv != 0 && servlen != 0 { p1 = bp + 78 port = Int32FromUint16(Xntohs(tls, (*Tsockaddr_in)(unsafe.Pointer(sa)).Fsin_port)) - (*(*[256]int8)(unsafe.Pointer(bp + 78)))[0] = 0 + (**(**[256]int8)(__ccgo_up(bp + 78)))[0] = 0 if !(flags&Int32FromInt32(NI_NUMERICSERV) != 0) { _reverse_services(tls, bp+78, port, flags&int32(NI_DGRAM)) } - if !(*(*int8)(unsafe.Pointer(p1)) != 0) { + if !(**(**int8)(__ccgo_up(p1)) != 0) { p1 = _itoa(tls, bp+334, Uint32FromInt32(port)) } if _strlen(tls, p1) >= uint64(servlen) { @@ -121000,11 +121000,11 @@ func Xgetservbyname_r(tls *TLS, name uintptr, prots uintptr, se uintptr, buf uin var _ /* end at bp+8 */ uintptr var _ /* servs at bp+0 */ [2]Tservice _, _, _, _ = align, cnt, proto, v1 - *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) + **(**uintptr)(__ccgo_up(res)) = uintptr(0) /* Don't treat numeric port number strings as service records. */ - *(*uintptr)(unsafe.Pointer(bp + 8)) = __ccgo_ts + **(**uintptr)(__ccgo_up(bp + 8)) = __ccgo_ts Xstrtoul(tls, name, bp+8, int32(10)) - if !(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) != 0) { + if !(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) != 0) { return int32(ENOENT) } /* Align buffer */ @@ -121039,16 +121039,16 @@ func Xgetservbyname_r(tls *TLS, name uintptr, prots uintptr, se uintptr, buf uin } (*Tservent)(unsafe.Pointer(se)).Fs_name = name (*Tservent)(unsafe.Pointer(se)).Fs_aliases = buf - *(*uintptr)(unsafe.Pointer((*Tservent)(unsafe.Pointer(se)).Fs_aliases)) = (*Tservent)(unsafe.Pointer(se)).Fs_name - *(*uintptr)(unsafe.Pointer((*Tservent)(unsafe.Pointer(se)).Fs_aliases + 1*8)) = uintptr(0) - (*Tservent)(unsafe.Pointer(se)).Fs_port = Int32FromUint16(Xhtons(tls, (*(*[2]Tservice)(unsafe.Pointer(bp)))[0].Fport)) - if Int32FromUint8((*(*[2]Tservice)(unsafe.Pointer(bp)))[0].Fproto) == int32(IPPROTO_TCP) { + **(**uintptr)(__ccgo_up((*Tservent)(unsafe.Pointer(se)).Fs_aliases)) = (*Tservent)(unsafe.Pointer(se)).Fs_name + **(**uintptr)(__ccgo_up((*Tservent)(unsafe.Pointer(se)).Fs_aliases + 1*8)) = uintptr(0) + (*Tservent)(unsafe.Pointer(se)).Fs_port = Int32FromUint16(Xhtons(tls, (**(**[2]Tservice)(__ccgo_up(bp)))[0].Fport)) + if Int32FromUint8((**(**[2]Tservice)(__ccgo_up(bp)))[0].Fproto) == int32(IPPROTO_TCP) { v1 = __ccgo_ts + 1081 } else { v1 = __ccgo_ts + 1085 } (*Tservent)(unsafe.Pointer(se)).Fs_proto = v1 - *(*uintptr)(unsafe.Pointer(res)) = se + **(**uintptr)(__ccgo_up(res)) = se return 0 } @@ -121128,7 +121128,7 @@ _9: if true { break } - if uint64(*(*Tsocklen_t)(unsafe.Pointer(optlen))) < uint64(16) { + if uint64(**(**Tsocklen_t)(__ccgo_up(optlen))) < uint64(16) { return int32(X__syscall_ret(tls, Uint64FromInt32(-Int32FromInt32(EINVAL)))) } if optname == int32(SO_RCVTIMEO) { @@ -121165,9 +121165,9 @@ _9: break } tv = optval - (*Ttimeval)(unsafe.Pointer(tv)).Ftv_sec = (*(*[2]int64)(unsafe.Pointer(bp + 8)))[0] - (*Ttimeval)(unsafe.Pointer(tv)).Ftv_usec = (*(*[2]int64)(unsafe.Pointer(bp + 8)))[int32(1)] - *(*Tsocklen_t)(unsafe.Pointer(optlen)) = uint32(16) + (*Ttimeval)(unsafe.Pointer(tv)).Ftv_sec = (**(**[2]int64)(__ccgo_up(bp + 8)))[0] + (*Ttimeval)(unsafe.Pointer(tv)).Ftv_usec = (**(**[2]int64)(__ccgo_up(bp + 8)))[int32(1)] + **(**Tsocklen_t)(__ccgo_up(optlen)) = uint32(16) case int32(SO_TIMESTAMP): fallthrough case int32(SO_TIMESTAMPNS): @@ -121237,7 +121237,7 @@ func Xherror(tls *TLS, msg uintptr) { } else { v2 = __ccgo_ts } - Xfprintf(tls, uintptr(unsafe.Pointer(&X__stderr_FILE)), __ccgo_ts+1089, VaList(bp+8, v1, v2, Xhstrerror(tls, *(*int32)(unsafe.Pointer(X__h_errno_location(tls)))))) + Xfprintf(tls, uintptr(unsafe.Pointer(&X__stderr_FILE)), __ccgo_ts+1089, VaList(bp+8, v1, v2, Xhstrerror(tls, **(**int32)(__ccgo_up(X__h_errno_location(tls)))))) } var _msgs1 = [84]int8{'H', 'o', 's', 't', ' ', 'n', 'o', 't', ' ', 'f', 'o', 'u', 'n', 'd', 0, 'T', 'r', 'y', ' ', 'a', 'g', 'a', 'i', 'n', 0, 'N', 'o', 'n', '-', 'r', 'e', 'c', 'o', 'v', 'e', 'r', 'a', 'b', 'l', 'e', ' ', 'e', 'r', 'r', 'o', 'r', 0, 'A', 'd', 'd', 'r', 'e', 's', 's', ' ', 'n', 'o', 't', ' ', 'a', 'v', 'a', 'i', 'l', 'a', 'b', 'l', 'e', 0, 0, 'U', 'n', 'k', 'n', 'o', 'w', 'n', ' ', 'e', 'r', 'r', 'o', 'r'} @@ -121252,11 +121252,11 @@ func Xhstrerror(tls *TLS, ecode int32) (r uintptr) { s = uintptr(unsafe.Pointer(&_msgs1)) ecode = ecode - 1 for { - if !(ecode != 0 && *(*int8)(unsafe.Pointer(s)) != 0) { + if !(ecode != 0 && **(**int8)(__ccgo_up(s)) != 0) { break } for { - if !(*(*int8)(unsafe.Pointer(s)) != 0) { + if !(**(**int8)(__ccgo_up(s)) != 0) { break } goto _2 @@ -121270,7 +121270,7 @@ func Xhstrerror(tls *TLS, ecode int32) (r uintptr) { ecode = ecode - 1 s = s + 1 } - if !(*(*int8)(unsafe.Pointer(s)) != 0) { + if !(**(**int8)(__ccgo_up(s)) != 0) { s = s + 1 } return X__lctrans_cur(tls, s) @@ -121358,8 +121358,8 @@ func Xif_indextoname(tls *TLS, index uint32, name uintptr) (r1 uintptr) { r = Xioctl(tls, fd, int32(SIOCGIFNAME), VaList(bp+48, bp)) X__syscall1(tls, int64(SYS_close), int64(fd)) if r < 0 { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENODEV) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENXIO) + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENODEV) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENXIO) } return uintptr(0) } @@ -121412,7 +121412,7 @@ func _netlink_msg_to_nameindex(tls *TLS, pctx uintptr, h uintptr) (r int32) { } /* suppress duplicates */ bucket = index % int32(IFADDRS_HASH_SIZE) - i = *(*uint32)(unsafe.Pointer(ctx + 24 + uintptr(bucket)*4)) + i = **(**uint32)(__ccgo_up(ctx + 24 + uintptr(bucket)*4)) for i != 0 { map1 = (*Tifnameindexctx)(unsafe.Pointer(ctx)).Flist + uintptr(i-uint32(1))*28 if (*Tifnamemap)(unsafe.Pointer(map1)).Findex == Uint32FromInt32(index) && Int32FromUint8((*Tifnamemap)(unsafe.Pointer(map1)).Fnamelen) == namelen && Xmemcmp(tls, map1+9, rta+UintptrFromInt64(4), Uint64FromInt32(namelen)) == 0 { @@ -121441,10 +121441,10 @@ func _netlink_msg_to_nameindex(tls *TLS, pctx uintptr, h uintptr) (r int32) { (*Tifnamemap)(unsafe.Pointer(map1)).Findex = Uint32FromInt32(index) (*Tifnamemap)(unsafe.Pointer(map1)).Fnamelen = Uint8FromInt32(namelen) Xmemcpy(tls, map1+9, rta+UintptrFromInt64(4), Uint64FromInt32(namelen)) - *(*uint32)(unsafe.Pointer(ctx + 8)) += Uint32FromInt32(namelen + int32(1)) + **(**uint32)(__ccgo_up(ctx + 8)) += Uint32FromInt32(namelen + int32(1)) (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum = (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum + 1 - (*Tifnamemap)(unsafe.Pointer(map1)).Fhash_next = *(*uint32)(unsafe.Pointer(ctx + 24 + uintptr(bucket)*4)) - *(*uint32)(unsafe.Pointer(ctx + 24 + uintptr(bucket)*4)) = (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum + (*Tifnamemap)(unsafe.Pointer(map1)).Fhash_next = **(**uint32)(__ccgo_up(ctx + 24 + uintptr(bucket)*4)) + **(**uint32)(__ccgo_up(ctx + 24 + uintptr(bucket)*4)) = (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum return 0 goto _1 _1: @@ -121491,7 +121491,7 @@ func Xif_nameindex(tls *TLS) (r uintptr) { p = p + uintptr((*Tifnamemap)(unsafe.Pointer(s)).Fnamelen) v2 = p p = p + 1 - *(*int8)(unsafe.Pointer(v2)) = 0 + **(**int8)(__ccgo_up(v2)) = 0 goto _1 _1: ; @@ -121504,9 +121504,9 @@ func Xif_nameindex(tls *TLS) (r uintptr) { goto err err: ; - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 280)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 280)), uintptr(0)) Xfree(tls, (*Tifnameindexctx)(unsafe.Pointer(ctx)).Flist) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOBUFS) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOBUFS) return ifs } @@ -121547,7 +121547,7 @@ func Xinet_addr(tls *TLS, p uintptr) (r Tin_addr_t) { if !(X__inet_aton(tls, p, bp) != 0) { return Uint32FromInt32(-Int32FromInt32(1)) } - return (*(*Tin_addr)(unsafe.Pointer(bp))).Fs_addr + return (**(**Tin_addr)(__ccgo_up(bp))).Fs_addr } func X__inet_aton(tls *TLS, s0 uintptr, dest uintptr) (r int32) { @@ -121564,20 +121564,20 @@ func X__inet_aton(tls *TLS, s0 uintptr, dest uintptr) (r int32) { _, _, _ = d, i, s s = s0 d = dest - *(*[4]uint64)(unsafe.Pointer(bp)) = [4]uint64{} + **(**[4]uint64)(__ccgo_up(bp)) = [4]uint64{} i = 0 for { if !(i < int32(4)) { break } - (*(*[4]uint64)(unsafe.Pointer(bp)))[i] = Xstrtoul(tls, s, bp+32, 0) - if *(*uintptr)(unsafe.Pointer(bp + 32)) == s || *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)))) != 0 && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32))))) != int32('.') || !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + (**(**[4]uint64)(__ccgo_up(bp)))[i] = Xstrtoul(tls, s, bp+32, 0) + if **(**uintptr)(__ccgo_up(bp + 32)) == s || **(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 32)))) != 0 && int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 32))))) != int32('.') || !(BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return 0 } - if !(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)))) != 0) { + if !(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 32)))) != 0) { break } - s = *(*uintptr)(unsafe.Pointer(bp + 32)) + uintptr(1) + s = **(**uintptr)(__ccgo_up(bp + 32)) + uintptr(1) goto _1 _1: ; @@ -121588,26 +121588,26 @@ func X__inet_aton(tls *TLS, s0 uintptr, dest uintptr) (r int32) { } switch i { case 0: - (*(*[4]uint64)(unsafe.Pointer(bp)))[int32(1)] = (*(*[4]uint64)(unsafe.Pointer(bp)))[0] & uint64(0xffffff) - *(*uint64)(unsafe.Pointer(bp)) >>= uint64(24) + (**(**[4]uint64)(__ccgo_up(bp)))[int32(1)] = (**(**[4]uint64)(__ccgo_up(bp)))[0] & uint64(0xffffff) + **(**uint64)(__ccgo_up(bp)) >>= uint64(24) fallthrough case int32(1): - (*(*[4]uint64)(unsafe.Pointer(bp)))[int32(2)] = (*(*[4]uint64)(unsafe.Pointer(bp)))[int32(1)] & uint64(0xffff) - *(*uint64)(unsafe.Pointer(bp + 1*8)) >>= uint64(16) + (**(**[4]uint64)(__ccgo_up(bp)))[int32(2)] = (**(**[4]uint64)(__ccgo_up(bp)))[int32(1)] & uint64(0xffff) + **(**uint64)(__ccgo_up(bp + 1*8)) >>= uint64(16) fallthrough case int32(2): - (*(*[4]uint64)(unsafe.Pointer(bp)))[int32(3)] = (*(*[4]uint64)(unsafe.Pointer(bp)))[int32(2)] & uint64(0xff) - *(*uint64)(unsafe.Pointer(bp + 2*8)) >>= uint64(8) + (**(**[4]uint64)(__ccgo_up(bp)))[int32(3)] = (**(**[4]uint64)(__ccgo_up(bp)))[int32(2)] & uint64(0xff) + **(**uint64)(__ccgo_up(bp + 2*8)) >>= uint64(8) } i = 0 for { if !(i < int32(4)) { break } - if (*(*[4]uint64)(unsafe.Pointer(bp)))[i] > uint64(255) { + if (**(**[4]uint64)(__ccgo_up(bp)))[i] > uint64(255) { return 0 } - *(*uint8)(unsafe.Pointer(d + uintptr(i))) = uint8((*(*[4]uint64)(unsafe.Pointer(bp)))[i]) + **(**uint8)(__ccgo_up(d + uintptr(i))) = uint8((**(**[4]uint64)(__ccgo_up(bp)))[i]) goto _2 _2: ; @@ -121696,7 +121696,7 @@ func Xinet_ntoa(tls *TLS, _in Tin_addr) (r uintptr) { var a uintptr _ = a a = bp - Xsnprintf(tls, uintptr(unsafe.Pointer(&_buf4)), uint64(16), __ccgo_ts+1097, VaList(bp+16, Int32FromUint8(*(*uint8)(unsafe.Pointer(a))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 1))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 2))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 3))))) + Xsnprintf(tls, uintptr(unsafe.Pointer(&_buf4)), uint64(16), __ccgo_ts+1097, VaList(bp+16, Int32FromUint8(**(**uint8)(__ccgo_up(a))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 1))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 2))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 3))))) return uintptr(unsafe.Pointer(&_buf4)) } @@ -121717,14 +121717,14 @@ func Xinet_ntop(tls *TLS, af int32, a0 uintptr, s uintptr, l Tsocklen_t) (r uint a = a0 switch af { case int32(PF_INET): - if Uint32FromInt32(Xsnprintf(tls, s, uint64(l), __ccgo_ts+1097, VaList(bp+112, Int32FromUint8(*(*uint8)(unsafe.Pointer(a))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 1))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 2))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 3)))))) < l { + if Uint32FromInt32(Xsnprintf(tls, s, uint64(l), __ccgo_ts+1097, VaList(bp+112, Int32FromUint8(**(**uint8)(__ccgo_up(a))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 1))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 2))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 3)))))) < l { return s } case int32(PF_INET6): if Xmemcmp(tls, a, __ccgo_ts+1044, uint64(12)) != 0 { - Xsnprintf(tls, bp, uint64(100), __ccgo_ts+1109, VaList(bp+112, int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 1))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 2)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 3))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 4)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 5))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 6)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 7))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 8)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 9))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 10)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 11))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 12)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 13))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 14)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 15))))) + Xsnprintf(tls, bp, uint64(100), __ccgo_ts+1109, VaList(bp+112, int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 1))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 2)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 3))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 4)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 5))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 6)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 7))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 8)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 9))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 10)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 11))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 12)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 13))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 14)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 15))))) } else { - Xsnprintf(tls, bp, uint64(100), __ccgo_ts+1133, VaList(bp+112, int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 1))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 2)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 3))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 4)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 5))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 6)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 7))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 8)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 9))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 10)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 11))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 12))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 13))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 14))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 15))))) + Xsnprintf(tls, bp, uint64(100), __ccgo_ts+1133, VaList(bp+112, int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 1))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 2)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 3))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 4)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 5))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 6)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 7))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 8)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 9))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 10)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 11))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 12))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 13))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 14))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 15))))) } /* Replace longest /(^0|:)[:0]{2,}/ with "::" */ v2 = Int32FromInt32(0) @@ -121732,10 +121732,10 @@ func Xinet_ntop(tls *TLS, af int32, a0 uintptr, s uintptr, l Tsocklen_t) (r uint i = v2 max = Int32FromInt32(2) for { - if !((*(*[100]int8)(unsafe.Pointer(bp)))[i] != 0) { + if !((**(**[100]int8)(__ccgo_up(bp)))[i] != 0) { break } - if i != 0 && int32((*(*[100]int8)(unsafe.Pointer(bp)))[i]) != int32(':') { + if i != 0 && int32((**(**[100]int8)(__ccgo_up(bp)))[i]) != int32(':') { goto _1 } j = Int32FromUint64(Xstrspn(tls, bp+uintptr(i), __ccgo_ts+1163)) @@ -121750,8 +121750,8 @@ func Xinet_ntop(tls *TLS, af int32, a0 uintptr, s uintptr, l Tsocklen_t) (r uint } if max > int32(3) { v3 = Int8FromUint8(':') - (*(*[100]int8)(unsafe.Pointer(bp)))[best+int32(1)] = v3 - (*(*[100]int8)(unsafe.Pointer(bp)))[best] = v3 + (**(**[100]int8)(__ccgo_up(bp)))[best+int32(1)] = v3 + (**(**[100]int8)(__ccgo_up(bp)))[best] = v3 Xmemmove(tls, bp+uintptr(best)+uintptr(2), bp+uintptr(best)+uintptr(max), Uint64FromInt32(i-best-max+int32(1))) } if _strlen(tls, bp) < uint64(l) { @@ -121759,10 +121759,10 @@ func Xinet_ntop(tls *TLS, af int32, a0 uintptr, s uintptr, l Tsocklen_t) (r uint return s } default: - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EAFNOSUPPORT) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EAFNOSUPPORT) return uintptr(0) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOSPC) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOSPC) return uintptr(0) } @@ -121802,23 +121802,23 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { j = v3 v = v3 for { - if !(j < int32(3) && BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s + uintptr(j))))-uint32('0') < uint32(10)) != 0) { + if !(j < int32(3) && BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(s + uintptr(j))))-uint32('0') < uint32(10)) != 0) { break } - v = int32(10)*v + int32(*(*int8)(unsafe.Pointer(s + uintptr(j)))) - int32('0') + v = int32(10)*v + int32(**(**int8)(__ccgo_up(s + uintptr(j)))) - int32('0') goto _2 _2: ; j = j + 1 } - if j == 0 || j > int32(1) && int32(*(*int8)(unsafe.Pointer(s))) == int32('0') || v > int32(255) { + if j == 0 || j > int32(1) && int32(**(**int8)(__ccgo_up(s))) == int32('0') || v > int32(255) { return 0 } - *(*uint8)(unsafe.Pointer(a + uintptr(i))) = Uint8FromInt32(v) - if int32(*(*int8)(unsafe.Pointer(s + uintptr(j)))) == 0 && i == int32(3) { + **(**uint8)(__ccgo_up(a + uintptr(i))) = Uint8FromInt32(v) + if int32(**(**int8)(__ccgo_up(s + uintptr(j)))) == 0 && i == int32(3) { return int32(1) } - if int32(*(*int8)(unsafe.Pointer(s + uintptr(j)))) != int32('.') { + if int32(**(**int8)(__ccgo_up(s + uintptr(j)))) != int32('.') { return 0 } s = s + uintptr(j+int32(1)) @@ -121830,25 +121830,25 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { return 0 } else { if af != int32(PF_INET6) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EAFNOSUPPORT) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EAFNOSUPPORT) return -int32(1) } } - if v5 = int32(*(*int8)(unsafe.Pointer(s))) == int32(':'); v5 { + if v5 = int32(**(**int8)(__ccgo_up(s))) == int32(':'); v5 { s = s + 1 v4 = s } - if v5 && int32(*(*int8)(unsafe.Pointer(v4))) != int32(':') { + if v5 && int32(**(**int8)(__ccgo_up(v4))) != int32(':') { return 0 } i = 0 for { - if int32(*(*int8)(unsafe.Pointer(s))) == int32(':') && brk < 0 { + if int32(**(**int8)(__ccgo_up(s))) == int32(':') && brk < 0 { brk = i - (*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[i&int32(7)] = uint16(0) + (**(**[8]Tuint16_t)(__ccgo_up(bp)))[i&int32(7)] = uint16(0) s = s + 1 v4 = s - if !(*(*int8)(unsafe.Pointer(v4)) != 0) { + if !(**(**int8)(__ccgo_up(v4)) != 0) { break } if i == int32(7) { @@ -121861,7 +121861,7 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { v = v3 for { if v5 = j < int32(4); v5 { - v9 = _hexval(tls, Uint32FromInt8(*(*int8)(unsafe.Pointer(s + uintptr(j))))) + v9 = _hexval(tls, Uint32FromInt8(**(**int8)(__ccgo_up(s + uintptr(j))))) d = v9 } if !(v5 && v9 >= 0) { @@ -121876,20 +121876,20 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { if j == 0 { return 0 } - (*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[i&int32(7)] = Uint16FromInt32(v) - if !(*(*int8)(unsafe.Pointer(s + uintptr(j))) != 0) && (brk >= 0 || i == int32(7)) { + (**(**[8]Tuint16_t)(__ccgo_up(bp)))[i&int32(7)] = Uint16FromInt32(v) + if !(**(**int8)(__ccgo_up(s + uintptr(j))) != 0) && (brk >= 0 || i == int32(7)) { break } if i == int32(7) { return 0 } - if int32(*(*int8)(unsafe.Pointer(s + uintptr(j)))) != int32(':') { - if int32(*(*int8)(unsafe.Pointer(s + uintptr(j)))) != int32('.') || i < int32(6) && brk < 0 { + if int32(**(**int8)(__ccgo_up(s + uintptr(j)))) != int32(':') { + if int32(**(**int8)(__ccgo_up(s + uintptr(j)))) != int32('.') || i < int32(6) && brk < 0 { return 0 } need_v4 = int32(1) i = i + 1 - (*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[i&int32(7)] = uint16(0) + (**(**[8]Tuint16_t)(__ccgo_up(bp)))[i&int32(7)] = uint16(0) break } s = s + uintptr(j+int32(1)) @@ -121905,7 +121905,7 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { if !(j < int32(7)-i) { break } - (*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[brk+j] = uint16(0) + (**(**[8]Tuint16_t)(__ccgo_up(bp)))[brk+j] = uint16(0) goto _12 _12: ; @@ -121919,10 +121919,10 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { } v4 = a a = a + 1 - *(*uint8)(unsafe.Pointer(v4)) = Uint8FromInt32(Int32FromUint16((*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[j]) >> int32(8)) + **(**uint8)(__ccgo_up(v4)) = Uint8FromInt32(Int32FromUint16((**(**[8]Tuint16_t)(__ccgo_up(bp)))[j]) >> int32(8)) v4 = a a = a + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8((*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[j]) + **(**uint8)(__ccgo_up(v4)) = uint8((**(**[8]Tuint16_t)(__ccgo_up(bp)))[j]) goto _13 _13: ; @@ -121985,15 +121985,15 @@ func X__lookup_ipliteral(tls *TLS, buf uintptr, name uintptr, family int32) (r i return -int32(5) } Xmemcpy(tls, buf+8, bp, uint64(4)) - (*(*Taddress)(unsafe.Pointer(buf))).Ffamily = int32(PF_INET) - (*(*Taddress)(unsafe.Pointer(buf))).Fscopeid = uint32(0) + (**(**Taddress)(__ccgo_up(buf))).Ffamily = int32(PF_INET) + (**(**Taddress)(__ccgo_up(buf))).Fscopeid = uint32(0) return int32(1) } p = Xstrchr(tls, name, int32('%')) scopeid = uint64(0) if p != 0 && int64(p)-int64(name) < int64(64) { Xmemcpy(tls, bp+20, name, Uint64FromInt64(int64(p)-int64(name))) - (*(*[64]int8)(unsafe.Pointer(bp + 20)))[int64(p)-int64(name)] = 0 + (**(**[64]int8)(__ccgo_up(bp + 20)))[int64(p)-int64(name)] = 0 name = bp + 20 } if Xinet_pton(tls, int32(PF_INET6), name, bp+4) <= 0 { @@ -122003,17 +122003,17 @@ func X__lookup_ipliteral(tls *TLS, buf uintptr, name uintptr, family int32) (r i return -int32(5) } Xmemcpy(tls, buf+8, bp+4, uint64(16)) - (*(*Taddress)(unsafe.Pointer(buf))).Ffamily = int32(PF_INET6) + (**(**Taddress)(__ccgo_up(buf))).Ffamily = int32(PF_INET6) if p != 0 { p = p + 1 v1 = p - if BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(v1)))-uint32('0') < uint32(10)) != 0 { + if BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(v1)))-uint32('0') < uint32(10)) != 0 { scopeid = Xstrtoull(tls, p, bp+88, int32(10)) } else { - *(*uintptr)(unsafe.Pointer(bp + 88)) = p - uintptr(1) + **(**uintptr)(__ccgo_up(bp + 88)) = p - uintptr(1) } - if *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 88)))) != 0 { - if !(Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(bp + 4))) == int32(0xfe) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(bp + 4 + 1)))&int32(0xc0) == int32(0x80)) && !(Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(bp + 4))) == int32(0xff) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(bp + 4 + 1)))&int32(0xf) == int32(0x2)) { + if **(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 88)))) != 0 { + if !(Int32FromUint8(**(**Tuint8_t)(__ccgo_up(bp + 4))) == int32(0xfe) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(bp + 4 + 1)))&int32(0xc0) == int32(0x80)) && !(Int32FromUint8(**(**Tuint8_t)(__ccgo_up(bp + 4))) == int32(0xff) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(bp + 4 + 1)))&int32(0xf) == int32(0x2)) { return -int32(2) } scopeid = uint64(Xif_nametoindex(tls, p)) @@ -122025,7 +122025,7 @@ func X__lookup_ipliteral(tls *TLS, buf uintptr, name uintptr, family int32) (r i return -int32(2) } } - (*(*Taddress)(unsafe.Pointer(buf))).Fscopeid = uint32(scopeid) + (**(**Taddress)(__ccgo_up(buf))).Fscopeid = uint32(scopeid) return int32(1) } @@ -122049,7 +122049,7 @@ func _is_valid_hostname(tls *TLS, host uintptr) (r int32) { } s = host for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) >= int32(0x80) || Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('.') || Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('-') || Xisalnum(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))) != 0) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(s))) >= int32(0x80) || Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('.') || Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('-') || Xisalnum(tls, Int32FromUint8(**(**uint8)(__ccgo_up(s)))) != 0) { break } goto _1 @@ -122057,7 +122057,7 @@ func _is_valid_hostname(tls *TLS, host uintptr) (r int32) { ; s = s + 1 } - return BoolInt32(!(*(*uint8)(unsafe.Pointer(s)) != 0)) + return BoolInt32(!(**(**uint8)(__ccgo_up(s)) != 0)) } func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags int32) (r int32) { @@ -122071,14 +122071,14 @@ func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags in if family != int32(PF_INET6) { v1 = cnt cnt = cnt + 1 - *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ + **(**Taddress)(__ccgo_up(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET), } } if family != int32(PF_INET) { v1 = cnt cnt = cnt + 1 - *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ + **(**Taddress)(__ccgo_up(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET6), } } @@ -122086,7 +122086,7 @@ func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags in if family != int32(PF_INET6) { v1 = cnt cnt = cnt + 1 - *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ + **(**Taddress)(__ccgo_up(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET), Faddr: [16]Tuint8_t{ 0: uint8(127), @@ -122097,7 +122097,7 @@ func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags in if family != int32(PF_INET) { v1 = cnt cnt = cnt + 1 - *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ + **(**Taddress)(__ccgo_up(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET6), Faddr: [16]Tuint8_t{ 15: uint8(1), @@ -122129,7 +122129,7 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family have_canon = 0 f = X__fopen_rb_ca(tls, __ccgo_ts+1033, bp+1544, bp+512, uint64(1032)) if !(f != 0) { - switch *(*int32)(unsafe.Pointer(X__errno_location(tls))) { + switch **(**int32)(__ccgo_up(X__errno_location(tls))) { case int32(ENOENT): fallthrough case int32(ENOTDIR): @@ -122146,21 +122146,21 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family if v1 != 0 { v2 = p p = p + 1 - *(*int8)(unsafe.Pointer(v2)) = int8('\n') - *(*int8)(unsafe.Pointer(p)) = Int8FromInt32(0) + **(**int8)(__ccgo_up(v2)) = int8('\n') + **(**int8)(__ccgo_up(p)) = Int8FromInt32(0) } p = bp + uintptr(1) for { v1 = Xstrstr(tls, p, name) p = v1 if v12 = v1 != 0; v12 { - v5 = int32(*(*int8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) + v5 = int32(**(**int8)(__ccgo_up(p + uintptr(-Int32FromInt32(1))))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _7 _7: ; if v11 = !(v6 != 0); !v11 { - v8 = int32(*(*int8)(unsafe.Pointer(p + uintptr(l)))) + v8 = int32(**(**int8)(__ccgo_up(p + uintptr(l)))) v9 = BoolInt32(v8 == int32(' ') || Uint32FromInt32(v8)-uint32('\t') < uint32(5)) goto _10 _10: @@ -122180,8 +122180,8 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family /* Isolate IP address to parse */ p = bp for { - if v11 = *(*int8)(unsafe.Pointer(p)) != 0; v11 { - v5 = int32(*(*int8)(unsafe.Pointer(p))) + if v11 = **(**int8)(__ccgo_up(p)) != 0; v11 { + v5 = int32(**(**int8)(__ccgo_up(p))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _16 _16: @@ -122196,7 +122196,7 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family } v1 = p p = p + 1 - *(*int8)(unsafe.Pointer(v1)) = 0 + **(**int8)(__ccgo_up(v1)) = 0 switch _name_from_numeric(tls, buf+uintptr(cnt)*28, bp, family) { case int32(1): cnt = cnt + 1 @@ -122211,8 +122211,8 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family } /* Extract first name as canonical name */ for { - if v11 = *(*int8)(unsafe.Pointer(p)) != 0; v11 { - v5 = int32(*(*int8)(unsafe.Pointer(p))) + if v11 = **(**int8)(__ccgo_up(p)) != 0; v11 { + v5 = int32(**(**int8)(__ccgo_up(p))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _22 _22: @@ -122227,8 +122227,8 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family } z = p for { - if v11 = *(*int8)(unsafe.Pointer(z)) != 0; v11 { - v5 = int32(*(*int8)(unsafe.Pointer(z))) + if v11 = **(**int8)(__ccgo_up(z)) != 0; v11 { + v5 = int32(**(**int8)(__ccgo_up(z))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _27 _27: @@ -122241,7 +122241,7 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family ; z = z + 1 } - *(*int8)(unsafe.Pointer(z)) = 0 + **(**int8)(__ccgo_up(z)) = 0 if _is_valid_hostname(tls, p) != 0 { have_canon = int32(1) Xmemcpy(tls, canon, p, Uint64FromInt64(int64(z)-int64(p)+int64(1))) @@ -122296,8 +122296,8 @@ func _dns_parse_callback1(tls *TLS, c uintptr, rr int32, data uintptr, len1 int3 family = int32(PF_INET6) break } - (*(*Taddress)(unsafe.Pointer((*Tdpc_ctx)(unsafe.Pointer(ctx)).Faddrs + uintptr((*Tdpc_ctx)(unsafe.Pointer(ctx)).Fcnt)*28))).Ffamily = family - (*(*Taddress)(unsafe.Pointer((*Tdpc_ctx)(unsafe.Pointer(ctx)).Faddrs + uintptr((*Tdpc_ctx)(unsafe.Pointer(ctx)).Fcnt)*28))).Fscopeid = uint32(0) + (**(**Taddress)(__ccgo_up((*Tdpc_ctx)(unsafe.Pointer(ctx)).Faddrs + uintptr((*Tdpc_ctx)(unsafe.Pointer(ctx)).Fcnt)*28))).Ffamily = family + (**(**Taddress)(__ccgo_up((*Tdpc_ctx)(unsafe.Pointer(ctx)).Faddrs + uintptr((*Tdpc_ctx)(unsafe.Pointer(ctx)).Fcnt)*28))).Fscopeid = uint32(0) v2 = ctx + 16 v1 = *(*int32)(unsafe.Pointer(v2)) *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) + 1 @@ -122318,16 +122318,16 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i var _ /* qlens at bp+10192 */ [2]int32 var _ /* qp at bp+10160 */ [2]uintptr _, _, _ = i, nq, qtypes - *(*[2]uintptr)(unsafe.Pointer(bp + 10160)) = [2]uintptr{ + **(**[2]uintptr)(__ccgo_up(bp + 10160)) = [2]uintptr{ 0: bp, 1: bp + 1*280, } - *(*[2]uintptr)(unsafe.Pointer(bp + 10176)) = [2]uintptr{ + **(**[2]uintptr)(__ccgo_up(bp + 10176)) = [2]uintptr{ 0: bp + 560, 1: bp + 560 + 1*4800, } nq = 0 - *(*Tdpc_ctx)(unsafe.Pointer(bp + 10208)) = Tdpc_ctx{ + **(**Tdpc_ctx)(__ccgo_up(bp + 10208)) = Tdpc_ctx{ Faddrs: buf, Fcanon: canon, } @@ -122337,15 +122337,15 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i break } if family != _afrr[i].Faf { - (*(*[2]int32)(unsafe.Pointer(bp + 10192)))[nq] = X__res_mkquery(tls, 0, name, int32(1), _afrr[i].Frr, uintptr(0), 0, uintptr(0), bp+uintptr(nq)*280, int32(280)) - if (*(*[2]int32)(unsafe.Pointer(bp + 10192)))[nq] == -int32(1) { + (**(**[2]int32)(__ccgo_up(bp + 10192)))[nq] = X__res_mkquery(tls, 0, name, int32(1), _afrr[i].Frr, uintptr(0), 0, uintptr(0), bp+uintptr(nq)*280, int32(280)) + if (**(**[2]int32)(__ccgo_up(bp + 10192)))[nq] == -int32(1) { return 0 } qtypes[nq] = _afrr[i].Frr - *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280 + 3)) = uint8(0) /* don't need AD flag */ + **(**uint8)(__ccgo_up(bp + uintptr(nq)*280 + 3)) = uint8(0) /* don't need AD flag */ /* Ensure query IDs are distinct. */ - if nq != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) { - *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280)) = *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280)) + 1 + if nq != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(bp + uintptr(nq)*280))) == Int32FromUint8(**(**uint8)(__ccgo_up(bp))) { + **(**uint8)(__ccgo_up(bp + uintptr(nq)*280)) = **(**uint8)(__ccgo_up(bp + uintptr(nq)*280)) + 1 } nq = nq + 1 } @@ -122362,13 +122362,13 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if !(i < nq) { break } - if (*(*[2]int32)(unsafe.Pointer(bp + 10200)))[i] < int32(4) || Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + 560 + uintptr(i)*4800 + 3)))&int32(15) == int32(2) { + if (**(**[2]int32)(__ccgo_up(bp + 10200)))[i] < int32(4) || Int32FromUint8(**(**uint8)(__ccgo_up(bp + 560 + uintptr(i)*4800 + 3)))&int32(15) == int32(2) { return -int32(3) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + 560 + uintptr(i)*4800 + 3)))&int32(15) == int32(3) { + if Int32FromUint8(**(**uint8)(__ccgo_up(bp + 560 + uintptr(i)*4800 + 3)))&int32(15) == int32(3) { return 0 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + 560 + uintptr(i)*4800 + 3)))&int32(15) != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(bp + 560 + uintptr(i)*4800 + 3)))&int32(15) != 0 { return -int32(4) } goto _2 @@ -122381,18 +122381,18 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if !(i >= 0) { break } - (*(*Tdpc_ctx)(unsafe.Pointer(bp + 10208))).Frrtype = qtypes[i] - if Uint64FromInt32((*(*[2]int32)(unsafe.Pointer(bp + 10200)))[i]) > uint64(4800) { - (*(*[2]int32)(unsafe.Pointer(bp + 10200)))[i] = int32(4800) + (**(**Tdpc_ctx)(__ccgo_up(bp + 10208))).Frrtype = qtypes[i] + if Uint64FromInt32((**(**[2]int32)(__ccgo_up(bp + 10200)))[i]) > uint64(4800) { + (**(**[2]int32)(__ccgo_up(bp + 10200)))[i] = int32(4800) } - X__dns_parse(tls, bp+560+uintptr(i)*4800, (*(*[2]int32)(unsafe.Pointer(bp + 10200)))[i], __ccgo_fp(_dns_parse_callback1), bp+10208) + X__dns_parse(tls, bp+560+uintptr(i)*4800, (**(**[2]int32)(__ccgo_up(bp + 10200)))[i], __ccgo_fp(_dns_parse_callback1), bp+10208) goto _3 _3: ; i = i - 1 } - if (*(*Tdpc_ctx)(unsafe.Pointer(bp + 10208))).Fcnt != 0 { - return (*(*Tdpc_ctx)(unsafe.Pointer(bp + 10208))).Fcnt + if (**(**Tdpc_ctx)(__ccgo_up(bp + 10208))).Fcnt != 0 { + return (**(**Tdpc_ctx)(__ccgo_up(bp + 10208))).Fcnt } return -int32(5) } @@ -122430,10 +122430,10 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f l = v2 dots = v2 for { - if !(*(*int8)(unsafe.Pointer(name + uintptr(l))) != 0) { + if !(**(**int8)(__ccgo_up(name + uintptr(l))) != 0) { break } - if int32(*(*int8)(unsafe.Pointer(name + uintptr(l)))) == int32('.') { + if int32(**(**int8)(__ccgo_up(name + uintptr(l)))) == int32('.') { dots = dots + 1 } goto _1 @@ -122441,14 +122441,14 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f ; l = l + 1 } - if dots >= uint64((*(*Tresolvconf)(unsafe.Pointer(bp + 256))).Fndots) || int32(*(*int8)(unsafe.Pointer(name + uintptr(l-uint64(1))))) == int32('.') { - *(*int8)(unsafe.Pointer(bp)) = 0 + if dots >= uint64((**(**Tresolvconf)(__ccgo_up(bp + 256))).Fndots) || int32(**(**int8)(__ccgo_up(name + uintptr(l-uint64(1))))) == int32('.') { + **(**int8)(__ccgo_up(bp)) = 0 } /* Strip final dot for canon, fail if multiple trailing dots. */ - if int32(*(*int8)(unsafe.Pointer(name + uintptr(l-uint64(1))))) == int32('.') { + if int32(**(**int8)(__ccgo_up(name + uintptr(l-uint64(1))))) == int32('.') { l = l - 1 } - if !(l != 0) || int32(*(*int8)(unsafe.Pointer(name + uintptr(l-uint64(1))))) == int32('.') { + if !(l != 0) || int32(**(**int8)(__ccgo_up(name + uintptr(l-uint64(1))))) == int32('.') { return -int32(2) } /* This can never happen; the caller already checked length. */ @@ -122460,14 +122460,14 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f * name is not a CNAME record) and serves as a buffer for passing * the full requested name to name_from_dns. */ Xmemcpy(tls, canon, name, l) - *(*int8)(unsafe.Pointer(canon + uintptr(l))) = int8('.') + **(**int8)(__ccgo_up(canon + uintptr(l))) = int8('.') p = bp for { - if !(*(*int8)(unsafe.Pointer(p)) != 0) { + if !(**(**int8)(__ccgo_up(p)) != 0) { break } for { - v5 = int32(*(*int8)(unsafe.Pointer(p))) + v5 = int32(**(**int8)(__ccgo_up(p))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _7 _7: @@ -122481,8 +122481,8 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f } z = p for { - if v12 = *(*int8)(unsafe.Pointer(z)) != 0; v12 { - v5 = int32(*(*int8)(unsafe.Pointer(z))) + if v12 = **(**int8)(__ccgo_up(z)) != 0; v12 { + v5 = int32(**(**int8)(__ccgo_up(z))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _11 _11: @@ -122500,7 +122500,7 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f } if Uint64FromInt64(int64(z)-int64(p)) < uint64(256)-l-uint64(1) { Xmemcpy(tls, canon+uintptr(l)+uintptr(1), p, Uint64FromInt64(int64(z)-int64(p))) - *(*int8)(unsafe.Pointer(canon + uintptr(Uint64FromInt64(int64(z)-int64(p)+int64(1))+l))) = 0 + **(**int8)(__ccgo_up(canon + uintptr(Uint64FromInt64(int64(z)-int64(p)+int64(1))+l))) = 0 cnt = _name_from_dns(tls, buf, canon, canon, family, bp+256) if cnt != 0 { return cnt @@ -122511,7 +122511,7 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f ; p = z } - *(*int8)(unsafe.Pointer(canon + uintptr(l))) = 0 + **(**int8)(__ccgo_up(canon + uintptr(l))) = 0 return _name_from_dns(tls, buf, canon, name, family, bp+256) } @@ -122572,7 +122572,7 @@ func _policyof(tls *TLS, a uintptr) (r uintptr) { if Xmemcmp(tls, a, uintptr(unsafe.Pointer(&_defpolicy))+uintptr(i)*20, uint64(_defpolicy[i].Flen1)) != 0 { goto _1 } - if Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + uintptr(_defpolicy[i].Flen1))))&Int32FromUint8(_defpolicy[i].Fmask) != Int32FromUint8(*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_defpolicy)) + uintptr(i)*20 + uintptr(_defpolicy[i].Flen1)))) { + if Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + uintptr(_defpolicy[i].Flen1))))&Int32FromUint8(_defpolicy[i].Fmask) != Int32FromUint8(**(**uint8)(__ccgo_up(uintptr(unsafe.Pointer(&_defpolicy)) + uintptr(i)*20 + uintptr(_defpolicy[i].Flen1)))) { goto _1 } return uintptr(unsafe.Pointer(&_defpolicy)) + uintptr(i)*20 @@ -122589,16 +122589,16 @@ func _labelof(tls *TLS, a uintptr) (r int32) { } func _scopeof(tls *TLS, a uintptr) (r int32) { - if Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a))) == int32(0xff) { - return Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 1))) & int32(15) + if Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a))) == int32(0xff) { + return Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 1))) & int32(15) } - if Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a))) == int32(0xfe) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 1)))&int32(0xc0) == int32(0x80) { + if Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a))) == int32(0xfe) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 1)))&int32(0xc0) == int32(0x80) { return int32(2) } - if *(*Tuint32_t)(unsafe.Pointer(a)) == uint32(0) && *(*Tuint32_t)(unsafe.Pointer(a + 1*4)) == uint32(0) && *(*Tuint32_t)(unsafe.Pointer(a + 2*4)) == uint32(0) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 12))) == 0 && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 13))) == 0 && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 14))) == 0 && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 15))) == int32(1) { + if **(**Tuint32_t)(__ccgo_up(a)) == uint32(0) && **(**Tuint32_t)(__ccgo_up(a + 1*4)) == uint32(0) && **(**Tuint32_t)(__ccgo_up(a + 2*4)) == uint32(0) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 12))) == 0 && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 13))) == 0 && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 14))) == 0 && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 15))) == int32(1) { return int32(2) } - if Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a))) == int32(0xfe) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 1)))&int32(0xc0) == int32(0xc0) { + if Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a))) == int32(0xfe) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 1)))&int32(0xc0) == int32(0xc0) { return int32(5) } return int32(14) @@ -122609,7 +122609,7 @@ func _prefixmatch(tls *TLS, s uintptr, d uintptr) (r int32) { _ = i i = uint32(0) for { - if !(i < uint32(128) && !((Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(s + uintptr(i/uint32(8)))))^Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(d + uintptr(i/uint32(8))))))&(Int32FromInt32(128)>>(i%Uint32FromInt32(8))) != 0)) { + if !(i < uint32(128) && !((Int32FromUint8(**(**Tuint8_t)(__ccgo_up(s + uintptr(i/uint32(8)))))^Int32FromUint8(**(**Tuint8_t)(__ccgo_up(d + uintptr(i/uint32(8))))))&(Int32FromInt32(128)>>(i%Uint32FromInt32(8))) != 0)) { break } goto _1 @@ -122647,7 +122647,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i var _ /* salen at bp+92 */ Tsocklen_t _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cnt, da, dalen, dlabel, dpolicy, dprec, dscope, family1, fd, i, j, key, l, prefixlen, sa, v1 cnt = 0 - *(*int8)(unsafe.Pointer(canon)) = 0 + **(**int8)(__ccgo_up(canon)) = 0 if name != 0 { /* reject empty name and check len so it fits into temp bufs */ l = Xstrnlen(tls, name, uint64(255)) @@ -122691,7 +122691,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i /* If any v6 results exist, remove v4 results. */ i = 0 for { - if !(i < cnt && (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily != int32(PF_INET6)) { + if !(i < cnt && (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Ffamily != int32(PF_INET6)) { break } goto _2 @@ -122705,10 +122705,10 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if !(i < cnt) { break } - if (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily == int32(PF_INET6) { + if (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Ffamily == int32(PF_INET6) { v1 = j j = j + 1 - *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = *(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28)) + **(**Taddress)(__ccgo_up(buf + uintptr(v1)*28)) = **(**Taddress)(__ccgo_up(buf + uintptr(i)*28)) } goto _3 _3: @@ -122726,12 +122726,12 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if !(i < cnt) { break } - if (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily != int32(PF_INET) { + if (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Ffamily != int32(PF_INET) { goto _6 } Xmemcpy(tls, buf+uintptr(i)*28+8+uintptr(12), buf+uintptr(i)*28+8, uint64(4)) Xmemcpy(tls, buf+uintptr(i)*28+8, __ccgo_ts+1044, uint64(12)) - (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily = int32(PF_INET6) + (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Ffamily = int32(PF_INET6) goto _6 _6: ; @@ -122748,7 +122748,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if !(i < cnt) { break } - if (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily != int32(PF_INET) { + if (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Ffamily != int32(PF_INET) { break } goto _7 @@ -122770,16 +122770,16 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if !(i < cnt) { break } - family1 = (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily + family1 = (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Ffamily key = 0 - *(*Tsockaddr_in6)(unsafe.Pointer(bp + 4)) = Tsockaddr_in6{} - *(*Tsockaddr_in6)(unsafe.Pointer(bp + 32)) = Tsockaddr_in6{ + **(**Tsockaddr_in6)(__ccgo_up(bp + 4)) = Tsockaddr_in6{} + **(**Tsockaddr_in6)(__ccgo_up(bp + 32)) = Tsockaddr_in6{ Fsin6_family: uint16(PF_INET6), Fsin6_port: uint16(65535), - Fsin6_scope_id: (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Fscopeid, + Fsin6_scope_id: (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Fscopeid, } - *(*Tsockaddr_in)(unsafe.Pointer(bp + 60)) = Tsockaddr_in{} - *(*Tsockaddr_in)(unsafe.Pointer(bp + 76)) = Tsockaddr_in{ + **(**Tsockaddr_in)(__ccgo_up(bp + 60)) = Tsockaddr_in{} + **(**Tsockaddr_in)(__ccgo_up(bp + 76)) = Tsockaddr_in{ Fsin_family: uint16(PF_INET), Fsin_port: uint16(65535), } @@ -122788,7 +122788,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i da = bp + 32 dalen = uint32(28) sa = bp + 4 - *(*Tsocklen_t)(unsafe.Pointer(bp + 92)) = uint32(28) + **(**Tsocklen_t)(__ccgo_up(bp + 92)) = uint32(28) } else { Xmemcpy(tls, bp+4+8, __ccgo_ts+1044, uint64(12)) Xmemcpy(tls, bp+32+8+uintptr(12), buf+uintptr(i)*28+8, uint64(4)) @@ -122798,7 +122798,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i da = bp + 76 dalen = uint32(16) sa = bp + 60 - *(*Tsocklen_t)(unsafe.Pointer(bp + 92)) = uint32(16) + **(**Tsocklen_t)(__ccgo_up(bp + 92)) = uint32(16) } dpolicy = _policyof(tls, bp+32+8) dscope = _scopeof(tls, bp+32+8) @@ -122828,14 +122828,14 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i key = key | (int32(15)-dscope)< uint64(65535) { return -int32(8) } if proto != int32(IPPROTO_UDP) { - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fport = uint16(port) - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_STREAM) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fport = uint16(port) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_STREAM) v1 = cnt cnt = cnt + 1 - (*(*Tservice)(unsafe.Pointer(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_TCP) + (**(**Tservice)(__ccgo_up(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_TCP) } if proto != int32(IPPROTO_TCP) { - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fport = uint16(port) - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_DGRAM) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fport = uint16(port) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_DGRAM) v1 = cnt cnt = cnt + 1 - (*(*Tservice)(unsafe.Pointer(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_UDP) + (**(**Tservice)(__ccgo_up(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_UDP) } return cnt } @@ -122921,7 +122921,7 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i l = _strlen(tls, name) f = X__fopen_rb_ca(tls, __ccgo_ts+1057, bp+1168, bp+136, uint64(1032)) if !(f != 0) { - switch *(*int32)(unsafe.Pointer(X__errno_location(tls))) { + switch **(**int32)(__ccgo_up(X__errno_location(tls))) { case int32(ENOENT): fallthrough case int32(ENOTDIR): @@ -122938,8 +122938,8 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i if v3 != 0 { v4 = p p = p + 1 - *(*int8)(unsafe.Pointer(v4)) = int8('\n') - *(*int8)(unsafe.Pointer(p)) = Int8FromInt32(0) + **(**int8)(__ccgo_up(v4)) = int8('\n') + **(**int8)(__ccgo_up(p)) = Int8FromInt32(0) } /* Find service name */ p = bp @@ -122950,7 +122950,7 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i break } if v10 = p > bp; v10 { - v1 = int32(*(*int8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) + v1 = int32(**(**int8)(__ccgo_up(p + uintptr(-Int32FromInt32(1))))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _9 _9: @@ -122958,8 +122958,8 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i if v10 && !(v2 != 0) { goto _5 } - if v10 = *(*int8)(unsafe.Pointer(p + uintptr(l))) != 0; v10 { - v1 = int32(*(*int8)(unsafe.Pointer(p + uintptr(l)))) + if v10 = **(**int8)(__ccgo_up(p + uintptr(l))) != 0; v10 { + v1 = int32(**(**int8)(__ccgo_up(p + uintptr(l)))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _13 _13: @@ -122979,8 +122979,8 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i /* Skip past canonical name at beginning of line */ p = bp for { - if v10 = *(*int8)(unsafe.Pointer(p)) != 0; v10 { - v1 = int32(*(*int8)(unsafe.Pointer(p))) + if v10 = **(**int8)(__ccgo_up(p)) != 0; v10 { + v1 = int32(**(**int8)(__ccgo_up(p))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _18 _18: @@ -122994,28 +122994,28 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i p = p + 1 } port = Xstrtoul(tls, p, bp+128, int32(10)) - if port > uint64(65535) || *(*uintptr)(unsafe.Pointer(bp + 128)) == p { + if port > uint64(65535) || **(**uintptr)(__ccgo_up(bp + 128)) == p { continue } - if !(Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(bp + 128)), __ccgo_ts+1071, uint64(4)) != 0) { + if !(Xstrncmp(tls, **(**uintptr)(__ccgo_up(bp + 128)), __ccgo_ts+1071, uint64(4)) != 0) { if proto == int32(IPPROTO_TCP) { continue } - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fport = uint16(port) - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_DGRAM) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fport = uint16(port) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_DGRAM) v1 = cnt cnt = cnt + 1 - (*(*Tservice)(unsafe.Pointer(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_UDP) + (**(**Tservice)(__ccgo_up(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_UDP) } - if !(Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(bp + 128)), __ccgo_ts+1076, uint64(4)) != 0) { + if !(Xstrncmp(tls, **(**uintptr)(__ccgo_up(bp + 128)), __ccgo_ts+1076, uint64(4)) != 0) { if proto == int32(IPPROTO_UDP) { continue } - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fport = uint16(port) - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_STREAM) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fport = uint16(port) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_STREAM) v1 = cnt cnt = cnt + 1 - (*(*Tservice)(unsafe.Pointer(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_TCP) + (**(**Tservice)(__ccgo_up(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_TCP) } } X__fclose_ca(tls, f) @@ -123045,58 +123045,58 @@ func ___netlink_enumerate(tls *TLS, fd int32, seq uint32, type1 int32, af int32, (*(*struct { Fnlh Tnlmsghdr Fg Trtgenmsg - })(unsafe.Pointer(&*(*struct { + })(unsafe.Pointer(&**(**struct { Freq [0]struct { Fnlh Tnlmsghdr Fg Trtgenmsg } Freply [0]Tnlmsghdr Fbuf [8192]Tuint8_t - })(unsafe.Pointer(bp))))).Fnlh.Fnlmsg_len = uint32(20) + })(__ccgo_up(bp))))).Fnlh.Fnlmsg_len = uint32(20) (*(*struct { Fnlh Tnlmsghdr Fg Trtgenmsg - })(unsafe.Pointer(&*(*struct { + })(unsafe.Pointer(&**(**struct { Freq [0]struct { Fnlh Tnlmsghdr Fg Trtgenmsg } Freply [0]Tnlmsghdr Fbuf [8192]Tuint8_t - })(unsafe.Pointer(bp))))).Fnlh.Fnlmsg_type = Uint16FromInt32(type1) + })(__ccgo_up(bp))))).Fnlh.Fnlmsg_type = Uint16FromInt32(type1) (*(*struct { Fnlh Tnlmsghdr Fg Trtgenmsg - })(unsafe.Pointer(&*(*struct { + })(unsafe.Pointer(&**(**struct { Freq [0]struct { Fnlh Tnlmsghdr Fg Trtgenmsg } Freply [0]Tnlmsghdr Fbuf [8192]Tuint8_t - })(unsafe.Pointer(bp))))).Fnlh.Fnlmsg_flags = Uint16FromInt32(Int32FromInt32(NLM_F_ROOT) | Int32FromInt32(NLM_F_MATCH) | Int32FromInt32(NLM_F_REQUEST)) + })(__ccgo_up(bp))))).Fnlh.Fnlmsg_flags = Uint16FromInt32(Int32FromInt32(NLM_F_ROOT) | Int32FromInt32(NLM_F_MATCH) | Int32FromInt32(NLM_F_REQUEST)) (*(*struct { Fnlh Tnlmsghdr Fg Trtgenmsg - })(unsafe.Pointer(&*(*struct { + })(unsafe.Pointer(&**(**struct { Freq [0]struct { Fnlh Tnlmsghdr Fg Trtgenmsg } Freply [0]Tnlmsghdr Fbuf [8192]Tuint8_t - })(unsafe.Pointer(bp))))).Fnlh.Fnlmsg_seq = seq + })(__ccgo_up(bp))))).Fnlh.Fnlmsg_seq = seq (*(*struct { Fnlh Tnlmsghdr Fg Trtgenmsg - })(unsafe.Pointer(&*(*struct { + })(unsafe.Pointer(&**(**struct { Freq [0]struct { Fnlh Tnlmsghdr Fg Trtgenmsg } Freply [0]Tnlmsghdr Fbuf [8192]Tuint8_t - })(unsafe.Pointer(bp))))).Fg.Frtgen_family = Uint8FromInt32(af) + })(__ccgo_up(bp))))).Fg.Frtgen_family = Uint8FromInt32(af) r = int32(Xsend(tls, fd, bp, uint64(20), 0)) if r < 0 { return r @@ -123172,7 +123172,7 @@ func Xns_get16(tls *TLS, cp uintptr) (r uint32) { trc("tls=%v cp=%v, (%v:)", tls, cp, origin(2)) defer func() { trc("-> %v", r) }() } - return Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(cp)))< %v", r) }() } - return uint64(uint32(*(*uint8)(unsafe.Pointer(cp)))<> int32(8)) + **(**uint8)(__ccgo_up(v1)) = uint8(s >> int32(8)) v1 = cp cp = cp + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(s) + **(**uint8)(__ccgo_up(v1)) = uint8(s) } func Xns_put32(tls *TLS, l uint64, cp uintptr) { @@ -123205,16 +123205,16 @@ func Xns_put32(tls *TLS, l uint64, cp uintptr) { _ = v1 v1 = cp cp = cp + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(l >> int32(24)) + **(**uint8)(__ccgo_up(v1)) = uint8(l >> int32(24)) v1 = cp cp = cp + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(l >> int32(16)) + **(**uint8)(__ccgo_up(v1)) = uint8(l >> int32(16)) v1 = cp cp = cp + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(l >> int32(8)) + **(**uint8)(__ccgo_up(v1)) = uint8(l >> int32(8)) v1 = cp cp = cp + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(l) + **(**uint8)(__ccgo_up(v1)) = uint8(l) } func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int32) { @@ -123239,7 +123239,7 @@ func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int3 break } msg = msg + uintptr(2) - *(*Tuint16_t)(unsafe.Pointer(handle + 20 + uintptr(i)*2)) = uint16(Xns_get16(tls, msg-uintptr(2))) + **(**Tuint16_t)(__ccgo_up(handle + 20 + uintptr(i)*2)) = uint16(Xns_get16(tls, msg-uintptr(2))) goto _1 _1: ; @@ -123250,15 +123250,15 @@ func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int3 if !(i < int32(_ns_s_max)) { break } - if *(*Tuint16_t)(unsafe.Pointer(handle + 20 + uintptr(i)*2)) != 0 { - *(*uintptr)(unsafe.Pointer(handle + 32 + uintptr(i)*8)) = msg - r = Xns_skiprr(tls, msg, (*Tns_msg)(unsafe.Pointer(handle)).F_eom, i, Int32FromUint16(*(*Tuint16_t)(unsafe.Pointer(handle + 20 + uintptr(i)*2)))) + if **(**Tuint16_t)(__ccgo_up(handle + 20 + uintptr(i)*2)) != 0 { + **(**uintptr)(__ccgo_up(handle + 32 + uintptr(i)*8)) = msg + r = Xns_skiprr(tls, msg, (*Tns_msg)(unsafe.Pointer(handle)).F_eom, i, Int32FromUint16(**(**Tuint16_t)(__ccgo_up(handle + 20 + uintptr(i)*2)))) if r < 0 { return -int32(1) } msg = msg + uintptr(r) } else { - *(*uintptr)(unsafe.Pointer(handle + 32 + uintptr(i)*8)) = UintptrFromInt32(0) + **(**uintptr)(__ccgo_up(handle + 32 + uintptr(i)*8)) = UintptrFromInt32(0) } goto _2 _2: @@ -123275,7 +123275,7 @@ func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int3 goto bad bad: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EMSGSIZE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EMSGSIZE) return -int32(1) } @@ -123319,7 +123319,7 @@ func Xns_skiprr(tls *TLS, ptr uintptr, eom uintptr, section Tns_sect, count int3 goto bad bad: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EMSGSIZE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EMSGSIZE) return -int32(1) } @@ -123337,31 +123337,31 @@ func Xns_parserr(tls *TLS, handle uintptr, section Tns_sect, rrnum int32, rr uin if section != (*Tns_msg)(unsafe.Pointer(handle)).F_sect { (*Tns_msg)(unsafe.Pointer(handle)).F_sect = section (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum = 0 - (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr = *(*uintptr)(unsafe.Pointer(handle + 32 + uintptr(section)*8)) + (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr = **(**uintptr)(__ccgo_up(handle + 32 + uintptr(section)*8)) } if rrnum == -int32(1) { rrnum = (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum } - if rrnum < 0 || rrnum >= Int32FromUint16(*(*Tuint16_t)(unsafe.Pointer(handle + 20 + uintptr(section)*2))) { + if rrnum < 0 || rrnum >= Int32FromUint16(**(**Tuint16_t)(__ccgo_up(handle + 20 + uintptr(section)*2))) { goto bad } if rrnum < (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum { (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum = 0 - (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr = *(*uintptr)(unsafe.Pointer(handle + 32 + uintptr(section)*8)) + (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr = **(**uintptr)(__ccgo_up(handle + 32 + uintptr(section)*8)) } if rrnum > (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum { r = Xns_skiprr(tls, (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr, (*Tns_msg)(unsafe.Pointer(handle)).F_eom, section, rrnum-(*Tns_msg)(unsafe.Pointer(handle)).F_rrnum) if r < 0 { return -int32(1) } - *(*uintptr)(unsafe.Pointer(handle + 72)) += uintptr(r) + **(**uintptr)(__ccgo_up(handle + 72)) += uintptr(r) (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum = rrnum } r = Xns_name_uncompress(tls, (*Tns_msg)(unsafe.Pointer(handle)).F_msg, (*Tns_msg)(unsafe.Pointer(handle)).F_eom, (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr, rr, uint64(NS_MAXDNAME)) if r < 0 { return -int32(1) } - *(*uintptr)(unsafe.Pointer(handle + 72)) += uintptr(r) + **(**uintptr)(__ccgo_up(handle + 72)) += uintptr(r) if int64(Int32FromInt32(2)*Int32FromInt32(NS_INT16SZ)) > int64((*Tns_msg)(unsafe.Pointer(handle)).F_eom)-int64((*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr) { goto size } @@ -123385,14 +123385,14 @@ func Xns_parserr(tls *TLS, handle uintptr, section Tns_sect, rrnum int32, rr uin goto size } (*Tns_rr)(unsafe.Pointer(rr)).Frdata = (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr - *(*uintptr)(unsafe.Pointer(handle + 72)) += uintptr((*Tns_rr)(unsafe.Pointer(rr)).Frdlength) + **(**uintptr)(__ccgo_up(handle + 72)) += uintptr((*Tns_rr)(unsafe.Pointer(rr)).Frdlength) } else { (*Tns_rr)(unsafe.Pointer(rr)).Fttl = uint32(0) (*Tns_rr)(unsafe.Pointer(rr)).Frdlength = uint16(0) (*Tns_rr)(unsafe.Pointer(rr)).Frdata = UintptrFromInt32(0) } (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum = (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum + 1 - if (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum > Int32FromUint16(*(*Tuint16_t)(unsafe.Pointer(handle + 20 + uintptr(section)*2))) { + if (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum > Int32FromUint16(**(**Tuint16_t)(__ccgo_up(handle + 20 + uintptr(section)*2))) { (*Tns_msg)(unsafe.Pointer(handle)).F_sect = section + int32(1) if (*Tns_msg)(unsafe.Pointer(handle)).F_sect == int32(_ns_s_max) { (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum = -int32(1) @@ -123405,12 +123405,12 @@ func Xns_parserr(tls *TLS, handle uintptr, section Tns_sect, rrnum int32, rr uin goto bad bad: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENODEV) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENODEV) return -int32(1) goto size size: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EMSGSIZE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EMSGSIZE) return -int32(1) } @@ -123423,7 +123423,7 @@ func Xns_name_uncompress(tls *TLS, msg uintptr, eom uintptr, src uintptr, dst ui _ = r r = Xdn_expand(tls, msg, eom, src, dst, Int32FromUint64(dstsiz)) if r < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EMSGSIZE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EMSGSIZE) } return r } @@ -123668,9 +123668,9 @@ func X__convert_scm_timestamps(tls *TLS, msg uintptr, csize Tsocklen_t) { common: ; Xmemcpy(tls, bp, cmsg+UintptrFromInt32(1)*16, uint64(8)) - (*(*[2]int64)(unsafe.Pointer(bp + 8)))[0] = *(*int64)(unsafe.Pointer(bp)) + (**(**[2]int64)(__ccgo_up(bp + 8)))[0] = int64(**(**int64)(__ccgo_up(bp))) Xmemcpy(tls, bp, cmsg+UintptrFromInt32(1)*16+uintptr(8), uint64(8)) - (*(*[2]int64)(unsafe.Pointer(bp + 8)))[int32(1)] = *(*int64)(unsafe.Pointer(bp)) + (**(**[2]int64)(__ccgo_up(bp + 8)))[int32(1)] = int64(**(**int64)(__ccgo_up(bp))) goto _5 _5: } @@ -123689,7 +123689,7 @@ func X__convert_scm_timestamps(tls *TLS, msg uintptr, csize Tsocklen_t) { return } if (Uint64FromInt64(16)+Uint64FromInt64(8)-Uint64FromInt32(1)) & ^(Uint64FromInt64(8)-Uint64FromInt32(1)) + (Uint64FromInt64(16)+Uint64FromInt64(8)-Uint64FromInt32(1)) & ^(Uint64FromInt64(8)-Uint64FromInt32(1)) > uint64(csize-(*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_controllen) { - *(*int32)(unsafe.Pointer(msg + 48)) |= int32(MSG_CTRUNC) + **(**int32)(__ccgo_up(msg + 48)) |= int32(MSG_CTRUNC) return } v2 = msg + 40 @@ -123724,10 +123724,10 @@ func Xrecvmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r2 Tssize_t) { orig_controllen = (*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_controllen orig = msg if msg != 0 { - *(*Tmsghdr)(unsafe.Pointer(bp)) = *(*Tmsghdr)(unsafe.Pointer(msg)) + **(**Tmsghdr)(__ccgo_up(bp)) = **(**Tmsghdr)(__ccgo_up(msg)) v1 = Int32FromInt32(0) - (*(*Tmsghdr)(unsafe.Pointer(bp))).F__pad2 = v1 - (*(*Tmsghdr)(unsafe.Pointer(bp))).F__pad1 = v1 + (**(**Tmsghdr)(__ccgo_up(bp))).F__pad2 = v1 + (**(**Tmsghdr)(__ccgo_up(bp))).F__pad1 = v1 msg = bp } v1 = int32(SYS_recvmsg) @@ -123755,7 +123755,7 @@ _10: X__convert_scm_timestamps(tls, msg, orig_controllen) } if orig != 0 { - *(*Tmsghdr)(unsafe.Pointer(orig)) = *(*Tmsghdr)(unsafe.Pointer(bp)) + **(**Tmsghdr)(__ccgo_up(orig)) = **(**Tmsghdr)(__ccgo_up(bp)) } return r1 } @@ -123781,10 +123781,10 @@ func X__res_mkquery(tls *TLS, op int32, dname uintptr, class int32, type1 int32, var _ /* ts at bp+280 */ Ttimespec _, _, _, _, _ = i, id, j, l, n l = Xstrnlen(tls, dname, uint64(255)) - if l != 0 && int32(*(*int8)(unsafe.Pointer(dname + uintptr(l-uint64(1))))) == int32('.') { + if l != 0 && int32(**(**int8)(__ccgo_up(dname + uintptr(l-uint64(1))))) == int32('.') { l = l - 1 } - if l != 0 && int32(*(*int8)(unsafe.Pointer(dname + uintptr(l-uint64(1))))) == int32('.') { + if l != 0 && int32(**(**int8)(__ccgo_up(dname + uintptr(l-uint64(1))))) == int32('.') { return -int32(1) } n = Int32FromUint64(uint64(17) + l + BoolUint64(!!(l != 0))) @@ -123793,18 +123793,18 @@ func X__res_mkquery(tls *TLS, op int32, dname uintptr, class int32, type1 int32, } /* Construct query template - ID will be filled later */ Xmemset(tls, bp, 0, Uint64FromInt32(n)) - (*(*[280]uint8)(unsafe.Pointer(bp)))[int32(2)] = Uint8FromInt32(op*int32(8) + int32(1)) - (*(*[280]uint8)(unsafe.Pointer(bp)))[int32(3)] = uint8(32) /* AD */ - (*(*[280]uint8)(unsafe.Pointer(bp)))[int32(5)] = uint8(1) + (**(**[280]uint8)(__ccgo_up(bp)))[int32(2)] = Uint8FromInt32(op*int32(8) + int32(1)) + (**(**[280]uint8)(__ccgo_up(bp)))[int32(3)] = uint8(32) /* AD */ + (**(**[280]uint8)(__ccgo_up(bp)))[int32(5)] = uint8(1) Xmemcpy(tls, bp+uintptr(13), dname, l) i = int32(13) for { - if !((*(*[280]uint8)(unsafe.Pointer(bp)))[i] != 0) { + if !((**(**[280]uint8)(__ccgo_up(bp)))[i] != 0) { break } j = i for { - if !((*(*[280]uint8)(unsafe.Pointer(bp)))[j] != 0 && Int32FromUint8((*(*[280]uint8)(unsafe.Pointer(bp)))[j]) != int32('.')) { + if !((**(**[280]uint8)(__ccgo_up(bp)))[j] != 0 && Int32FromUint8((**(**[280]uint8)(__ccgo_up(bp)))[j]) != int32('.')) { break } goto _2 @@ -123815,19 +123815,19 @@ func X__res_mkquery(tls *TLS, op int32, dname uintptr, class int32, type1 int32, if Uint32FromInt32(j-i)-uint32(1) > uint32(62) { return -int32(1) } - (*(*[280]uint8)(unsafe.Pointer(bp)))[i-int32(1)] = Uint8FromInt32(j - i) + (**(**[280]uint8)(__ccgo_up(bp)))[i-int32(1)] = Uint8FromInt32(j - i) goto _1 _1: ; i = j + int32(1) } - (*(*[280]uint8)(unsafe.Pointer(bp)))[i+int32(1)] = Uint8FromInt32(type1) - (*(*[280]uint8)(unsafe.Pointer(bp)))[i+int32(3)] = Uint8FromInt32(class) + (**(**[280]uint8)(__ccgo_up(bp)))[i+int32(1)] = Uint8FromInt32(type1) + (**(**[280]uint8)(__ccgo_up(bp)))[i+int32(3)] = Uint8FromInt32(class) /* Make a reasonably unpredictable id */ Xclock_gettime(tls, CLOCK_REALTIME, bp+280) - id = Int32FromUint64((Uint64FromInt64((*(*Ttimespec)(unsafe.Pointer(bp + 280))).Ftv_nsec) + Uint64FromInt64((*(*Ttimespec)(unsafe.Pointer(bp + 280))).Ftv_nsec)/uint64(65536)) & uint64(0xffff)) - (*(*[280]uint8)(unsafe.Pointer(bp)))[0] = Uint8FromInt32(id / int32(256)) - (*(*[280]uint8)(unsafe.Pointer(bp)))[int32(1)] = Uint8FromInt32(id) + id = Int32FromUint64((Uint64FromInt64((**(**Ttimespec)(__ccgo_up(bp + 280))).Ftv_nsec) + Uint64FromInt64((**(**Ttimespec)(__ccgo_up(bp + 280))).Ftv_nsec)/uint64(65536)) & uint64(0xffff)) + (**(**[280]uint8)(__ccgo_up(bp)))[0] = Uint8FromInt32(id / int32(256)) + (**(**[280]uint8)(__ccgo_up(bp)))[int32(1)] = Uint8FromInt32(id) Xmemcpy(tls, buf, bp, Uint64FromInt32(n)) return n } @@ -123944,11 +123944,11 @@ func _cleanup(tls *TLS, p uintptr) { pfd = p i = 0 for { - if !((*(*Tpollfd)(unsafe.Pointer(pfd + uintptr(i)*8))).Ffd >= -int32(1)) { + if !((**(**Tpollfd)(__ccgo_up(pfd + uintptr(i)*8))).Ffd >= -int32(1)) { break } - if (*(*Tpollfd)(unsafe.Pointer(pfd + uintptr(i)*8))).Ffd >= 0 { - X__syscall1(tls, int64(SYS_close), int64((*(*Tpollfd)(unsafe.Pointer(pfd + uintptr(i)*8))).Ffd)) + if (**(**Tpollfd)(__ccgo_up(pfd + uintptr(i)*8))).Ffd >= 0 { + X__syscall1(tls, int64(SYS_close), int64((**(**Tpollfd)(__ccgo_up(pfd + uintptr(i)*8))).Ffd)) } goto _1 _1: @@ -123961,10 +123961,10 @@ func _mtime(tls *TLS) (r uint64) { bp := tls.Alloc(16) defer tls.Free(16) var _ /* ts at bp+0 */ Ttimespec - if Xclock_gettime(tls, int32(CLOCK_MONOTONIC), bp) < 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENOSYS) { + if Xclock_gettime(tls, int32(CLOCK_MONOTONIC), bp) < 0 && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENOSYS) { Xclock_gettime(tls, CLOCK_REALTIME, bp) } - return Uint64FromInt64((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec)*uint64(1000) + Uint64FromInt64((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_nsec/int64(1000000)) + return Uint64FromInt64((**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec)*uint64(1000) + Uint64FromInt64((**(**Ttimespec)(__ccgo_up(bp))).Ftv_nsec/int64(1000000)) } func _start_tcp(tls *TLS, pfd uintptr, family int32, sa uintptr, sl Tsocklen_t, q uintptr, ql int32) (r1 int32) { @@ -123987,7 +123987,7 @@ func _start_tcp(tls *TLS, pfd uintptr, family int32, sa uintptr, sl Tsocklen_t, Fiov_len: Uint64FromInt32(ql), }, } - *(*Tmsghdr)(unsafe.Pointer(bp + 40)) = Tmsghdr{ + **(**Tmsghdr)(__ccgo_up(bp + 40)) = Tmsghdr{ Fmsg_name: sa, Fmsg_namelen: sl, Fmsg_iov: bp, @@ -124005,12 +124005,12 @@ func _start_tcp(tls *TLS, pfd uintptr, family int32, sa uintptr, sl Tsocklen_t, if r >= 0 { return r } - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EINPROGRESS) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EINPROGRESS) { return 0 } } r = Xconnect(tls, fd, sa, sl) - if !(r != 0) || *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EINPROGRESS) { + if !(r != 0) || **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EINPROGRESS) { return 0 } Xclose(tls, fd) @@ -124029,7 +124029,7 @@ func _step_mh(tls *TLS, mh uintptr, n Tsize_t) { return } (*Tiovec)(unsafe.Pointer((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov)).Fiov_base = (*Tiovec)(unsafe.Pointer((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov)).Fiov_base + uintptr(n) - *(*Tsize_t)(unsafe.Pointer((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov + 8)) -= n + **(**Tsize_t)(__ccgo_up((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov + 8)) -= n } /* Internal contract for __res_msend[_rc]: asize must be >=512, nqueries @@ -124081,11 +124081,11 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a F__ccgo_pad2 [12]byte }{} *(*uint16)(unsafe.Pointer(bp + 88)) = uint16(0) - *(*[3]struct { + **(**[3]struct { Fsin6 [0]Tsockaddr_in6 Fsin Tsockaddr_in F__ccgo_pad2 [12]byte - })(unsafe.Pointer(bp + 116)) = [3]struct { + })(__ccgo_up(bp + 116)) = [3]struct { Fsin6 [0]Tsockaddr_in6 Fsin Tsockaddr_in F__ccgo_pad2 [12]byte @@ -124112,16 +124112,16 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a iplit = conf + uintptr(nns)*28 if (*Taddress)(unsafe.Pointer(iplit)).Ffamily == int32(PF_INET) { Xmemcpy(tls, bp+116+uintptr(nns)*28+4, iplit+8, uint64(4)) - (*(*[3]struct { + (**(**[3]struct { Fsin6 [0]Tsockaddr_in6 Fsin Tsockaddr_in F__ccgo_pad2 [12]byte - })(unsafe.Pointer(bp + 116)))[nns].Fsin.Fsin_port = Xhtons(tls, uint16(53)) - (*(*[3]struct { + })(__ccgo_up(bp + 116)))[nns].Fsin.Fsin_port = Xhtons(tls, uint16(53)) + (**(**[3]struct { Fsin6 [0]Tsockaddr_in6 Fsin Tsockaddr_in F__ccgo_pad2 [12]byte - })(unsafe.Pointer(bp + 116)))[nns].Fsin.Fsin_family = uint16(PF_INET) + })(__ccgo_up(bp + 116)))[nns].Fsin.Fsin_family = uint16(PF_INET) } else { sl = uint32(28) Xmemcpy(tls, bp+116+uintptr(nns)*28+8, iplit+8, uint64(16)) @@ -124139,10 +124139,10 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a /* Get local address and open/bind a socket */ fd = Xsocket(tls, family, Int32FromInt32(SOCK_DGRAM)|Int32FromInt32(SOCK_CLOEXEC)|Int32FromInt32(SOCK_NONBLOCK), 0) /* Handle case where system lacks IPv6 support */ - if fd < 0 && family == int32(PF_INET6) && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EAFNOSUPPORT) { + if fd < 0 && family == int32(PF_INET6) && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EAFNOSUPPORT) { i = 0 for { - if !(i < nns && (*(*Taddress)(unsafe.Pointer(conf + uintptr(nns)*28))).Ffamily == int32(PF_INET6)) { + if !(i < nns && (**(**Taddress)(__ccgo_up(conf + uintptr(nns)*28))).Ffamily == int32(PF_INET6)) { break } goto _7 @@ -124151,7 +124151,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a i = i + 1 } if i == nns { - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 200)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 200)), uintptr(0)) return -int32(1) } fd = Xsocket(tls, int32(PF_INET), Int32FromInt32(SOCK_DGRAM)|Int32FromInt32(SOCK_CLOEXEC)|Int32FromInt32(SOCK_NONBLOCK), 0) @@ -124167,11 +124167,11 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a if !(i < nns) { break } - if Int32FromUint16((*(*[3]struct { + if Int32FromUint16((**(**[3]struct { Fsin6 [0]Tsockaddr_in6 Fsin Tsockaddr_in F__ccgo_pad2 [12]byte - })(unsafe.Pointer(bp + 116)))[i].Fsin.Fsin_family) != int32(PF_INET) { + })(__ccgo_up(bp + 116)))[i].Fsin.Fsin_family) != int32(PF_INET) { goto _8 } Xmemcpy(tls, bp+116+uintptr(i)*28+8+uintptr(12), bp+116+uintptr(i)*28+4, uint64(4)) @@ -124185,16 +124185,16 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a i = i + 1 } } - (*(*struct { + (**(**struct { Fsin6 [0]Tsockaddr_in6 Fsin Tsockaddr_in F__ccgo_pad2 [12]byte - })(unsafe.Pointer(bp + 88))).Fsin.Fsin_family = Uint16FromInt32(family) + })(__ccgo_up(bp + 88))).Fsin.Fsin_family = Uint16FromInt32(family) if fd < 0 || Xbind(tls, fd, bp+88, sl) < 0 { if fd >= 0 { Xclose(tls, fd) } - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 200)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 200)), uintptr(0)) return -int32(1) } /* Past this point, there are no errors. Each individual query will @@ -124215,7 +124215,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), nqueries*8))).Fevents = int16(POLLIN) (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), (nqueries+int32(1))*8))).Ffd = -int32(2) __pthread_cleanup_push(tls, bp+208, __ccgo_fp(_cleanup), pfd) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 200)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 200)), uintptr(0)) Xmemset(tls, alens, 0, uint64(4)*Uint64FromInt32(nqueries)) retry_interval = timeout / attempts next = 0 @@ -124231,7 +124231,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a * have an accepted answer. */ i = 0 for { - if !(i < nqueries && *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) > 0) { + if !(i < nqueries && **(**int32)(__ccgo_up(alens + uintptr(i)*4)) > 0) { break } goto _12 @@ -124249,13 +124249,13 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a if !(i < nqueries) { break } - if !(*(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) != 0) { + if !(**(**int32)(__ccgo_up(alens + uintptr(i)*4)) != 0) { j = 0 for { if !(j < nns) { break } - Xsendto(tls, fd, *(*uintptr)(unsafe.Pointer(queries + uintptr(i)*8)), Uint64FromInt32(*(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))), int32(MSG_NOSIGNAL), bp+116+uintptr(j)*28, sl) + Xsendto(tls, fd, **(**uintptr)(__ccgo_up(queries + uintptr(i)*8)), Uint64FromInt32(**(**int32)(__ccgo_up(qlens + uintptr(i)*4))), int32(MSG_NOSIGNAL), bp+116+uintptr(j)*28, sl) goto _14 _14: ; @@ -124277,11 +124277,11 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a for next < nqueries { *(*[1]Tiovec)(unsafe.Pointer(bp + 8)) = [1]Tiovec{ 0: { - Fiov_base: *(*uintptr)(unsafe.Pointer(answers + uintptr(next)*8)), + Fiov_base: **(**uintptr)(__ccgo_up(answers + uintptr(next)*8)), Fiov_len: Uint64FromInt32(asize), }, } - *(*Tmsghdr)(unsafe.Pointer(bp + 232)) = Tmsghdr{ + **(**Tmsghdr)(__ccgo_up(bp + 232)) = Tmsghdr{ Fmsg_name: bp + 88, Fmsg_namelen: sl, Fmsg_iov: bp + 8, @@ -124312,7 +124312,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a /* Find which query this answer goes with, if any */ i = next for { - if !(i < nqueries && (Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(answers + uintptr(next)*8))))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(queries + uintptr(i)*8))))) || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(answers + uintptr(next)*8)) + 1))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(queries + uintptr(i)*8)) + 1))))) { + if !(i < nqueries && (Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(answers + uintptr(next)*8))))) != Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(queries + uintptr(i)*8))))) || Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(answers + uintptr(next)*8)) + 1))) != Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(queries + uintptr(i)*8)) + 1))))) { break } goto _16 @@ -124323,13 +124323,13 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a if i == nqueries { continue } - if *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) != 0 { + if **(**int32)(__ccgo_up(alens + uintptr(i)*4)) != 0 { continue } /* Only accept positive or negative responses; * retry immediately on server failure, and ignore * all other codes such as refusal. */ - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(answers + uintptr(next)*8)) + 3))) & Int32FromInt32(15) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(answers + uintptr(next)*8)) + 3))) & Int32FromInt32(15) { case 0: fallthrough case int32(3): @@ -124339,7 +124339,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a servfail_retry = servfail_retry - 1 } if v18 && v6 != 0 { - Xsendto(tls, fd, *(*uintptr)(unsafe.Pointer(queries + uintptr(i)*8)), Uint64FromInt32(*(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))), int32(MSG_NOSIGNAL), bp+116+uintptr(j)*28, sl) + Xsendto(tls, fd, **(**uintptr)(__ccgo_up(queries + uintptr(i)*8)), Uint64FromInt32(**(**int32)(__ccgo_up(qlens + uintptr(i)*4))), int32(MSG_NOSIGNAL), bp+116+uintptr(j)*28, sl) } fallthrough default: @@ -124347,10 +124347,10 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a } /* Store answer in the right slot, or update next * available temp slot if it's already in place. */ - *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) = rlen + **(**int32)(__ccgo_up(alens + uintptr(i)*4)) = rlen if i == next { for { - if !(next < nqueries && *(*int32)(unsafe.Pointer(alens + uintptr(next)*4)) != 0) { + if !(next < nqueries && **(**int32)(__ccgo_up(alens + uintptr(next)*4)) != 0) { break } goto _19 @@ -124359,18 +124359,18 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a next = next + 1 } } else { - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(answers + uintptr(i)*8)), *(*uintptr)(unsafe.Pointer(answers + uintptr(next)*8)), Uint64FromInt32(rlen)) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(answers + uintptr(i)*8)), **(**uintptr)(__ccgo_up(answers + uintptr(next)*8)), Uint64FromInt32(rlen)) } /* Ignore further UDP if all slots full or TCP-mode */ if next == nqueries { (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), nqueries*8))).Fevents = 0 } /* If answer is truncated (TC bit), fallback to TCP */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(answers + uintptr(i)*8)) + 2)))&int32(2) != 0 || (*(*Tmsghdr)(unsafe.Pointer(bp + 232))).Fmsg_flags&int32(MSG_TRUNC) != 0 { - *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) = -int32(1) + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(answers + uintptr(i)*8)) + 2)))&int32(2) != 0 || (**(**Tmsghdr)(__ccgo_up(bp + 232))).Fmsg_flags&int32(MSG_TRUNC) != 0 { + **(**int32)(__ccgo_up(alens + uintptr(i)*4)) = -int32(1) _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), uintptr(0)) - r = _start_tcp(tls, pfd+uintptr(i)*8, family, bp+116+uintptr(j)*28, sl, *(*uintptr)(unsafe.Pointer(queries + uintptr(i)*8)), *(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 200)), uintptr(0)) + r = _start_tcp(tls, pfd+uintptr(i)*8, family, bp+116+uintptr(j)*28, sl, **(**uintptr)(__ccgo_up(queries + uintptr(i)*8)), **(**int32)(__ccgo_up(qlens + uintptr(i)*4))) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 200)), uintptr(0)) if r >= 0 { *(*int32)(unsafe.Add(unsafe.Pointer(qpos), i*4)) = r *(*int32)(unsafe.Add(unsafe.Pointer(apos), i*4)) = 0 @@ -124385,8 +124385,8 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a } if int32((*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), i*8))).Frevents)&int32(POLLOUT) != 0 { *(*[2]Tuint8_t)(unsafe.Pointer(bp + 52)) = [2]Tuint8_t{ - 0: Uint8FromInt32(*(*int32)(unsafe.Pointer(qlens + uintptr(i)*4)) >> int32(8)), - 1: Uint8FromInt32(*(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))), + 0: Uint8FromInt32(**(**int32)(__ccgo_up(qlens + uintptr(i)*4)) >> int32(8)), + 1: Uint8FromInt32(**(**int32)(__ccgo_up(qlens + uintptr(i)*4))), } *(*[2]Tiovec)(unsafe.Pointer(bp + 24)) = [2]Tiovec{ 0: { @@ -124394,11 +124394,11 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a Fiov_len: uint64(2), }, 1: { - Fiov_base: *(*uintptr)(unsafe.Pointer(queries + uintptr(i)*8)), - Fiov_len: Uint64FromInt32(*(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))), + Fiov_base: **(**uintptr)(__ccgo_up(queries + uintptr(i)*8)), + Fiov_len: Uint64FromInt32(**(**int32)(__ccgo_up(qlens + uintptr(i)*4))), }, } - *(*Tmsghdr)(unsafe.Pointer(bp + 288)) = Tmsghdr{ + **(**Tmsghdr)(__ccgo_up(bp + 288)) = Tmsghdr{ Fmsg_iov: bp + 24, Fmsg_iovlen: int32(2), } @@ -124407,8 +124407,8 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a if r < 0 { goto out } - *(*int32)(unsafe.Pointer(qpos + uintptr(i)*4)) += r - if *(*int32)(unsafe.Add(unsafe.Pointer(qpos), i*4)) == *(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))+int32(2) { + **(**int32)(__ccgo_up(qpos + uintptr(i)*4)) += r + if *(*int32)(unsafe.Add(unsafe.Pointer(qpos), i*4)) == **(**int32)(__ccgo_up(qlens + uintptr(i)*4))+int32(2) { (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), i*8))).Fevents = int16(POLLIN) } } @@ -124429,11 +124429,11 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a Fiov_len: uint64(2), }, 1: { - Fiov_base: *(*uintptr)(unsafe.Pointer(answers + uintptr(i)*8)), + Fiov_base: **(**uintptr)(__ccgo_up(answers + uintptr(i)*8)), Fiov_len: Uint64FromInt32(asize), }, } - *(*Tmsghdr)(unsafe.Pointer(bp + 344)) = Tmsghdr{ + **(**Tmsghdr)(__ccgo_up(bp + 344)) = Tmsghdr{ Fmsg_iov: bp + 56, Fmsg_iovlen: int32(2), } @@ -124442,25 +124442,25 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a if r <= 0 { goto out } - *(*int32)(unsafe.Pointer(apos + uintptr(i)*4)) += r + **(**int32)(__ccgo_up(apos + uintptr(i)*4)) += r if *(*int32)(unsafe.Add(unsafe.Pointer(apos), i*4)) < int32(2) { goto _21 } - alen = Int32FromUint8(*(*uint8)(unsafe.Pointer(alen_buf + uintptr(i)*2)))*int32(256) + Int32FromUint8(*(*uint8)(unsafe.Pointer(alen_buf + uintptr(i)*2 + 1))) + alen = Int32FromUint8(**(**uint8)(__ccgo_up(alen_buf + uintptr(i)*2)))*int32(256) + Int32FromUint8(**(**uint8)(__ccgo_up(alen_buf + uintptr(i)*2 + 1))) if alen < int32(13) { goto out } if *(*int32)(unsafe.Add(unsafe.Pointer(apos), i*4)) < alen+int32(2) && *(*int32)(unsafe.Add(unsafe.Pointer(apos), i*4)) < asize+int32(2) { goto _21 } - rcode = Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(answers + uintptr(i)*8)) + 3))) & int32(15) + rcode = Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(answers + uintptr(i)*8)) + 3))) & int32(15) if rcode != 0 && rcode != int32(3) { goto out } /* Storing the length here commits the accepted answer. * Immediately close TCP socket so as not to consume * resources we no longer need. */ - *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) = alen + **(**int32)(__ccgo_up(alens + uintptr(i)*4)) = alen X__syscall1(tls, int64(SYS_close), int64((*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), i*8))).Ffd)) (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), i*8))).Ffd = -int32(1) } @@ -124484,8 +124484,8 @@ out: if !(i < nqueries) { break } - if *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) < 0 { - *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) = 0 + if **(**int32)(__ccgo_up(alens + uintptr(i)*4)) < 0 { + **(**int32)(__ccgo_up(alens + uintptr(i)*4)) = 0 } goto _22 _22: @@ -124523,23 +124523,23 @@ func X__res_send(tls *TLS, _msg uintptr, _msglen int32, _answer uintptr, _anslen var r, v1 int32 var _ /* buf at bp+28 */ [512]uint8 _, _ = r, v1 - if *(*int32)(unsafe.Pointer(bp + 24)) < int32(512) { - r = X__res_send(tls, *(*uintptr)(unsafe.Pointer(bp)), *(*int32)(unsafe.Pointer(bp + 8)), bp+28, int32(512)) + if **(**int32)(__ccgo_up(bp + 24)) < int32(512) { + r = X__res_send(tls, **(**uintptr)(__ccgo_up(bp)), **(**int32)(__ccgo_up(bp + 8)), bp+28, int32(512)) if r >= 0 { - if r < *(*int32)(unsafe.Pointer(bp + 24)) { + if r < **(**int32)(__ccgo_up(bp + 24)) { v1 = r } else { - v1 = *(*int32)(unsafe.Pointer(bp + 24)) + v1 = **(**int32)(__ccgo_up(bp + 24)) } - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(bp + 16)), bp+28, Uint64FromInt32(v1)) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(bp + 16)), bp+28, Uint64FromInt32(v1)) } return r } - r = X__res_msend(tls, int32(1), bp, bp+8, bp+16, bp+24, *(*int32)(unsafe.Pointer(bp + 24))) - if r < 0 || !(*(*int32)(unsafe.Pointer(bp + 24)) != 0) { + r = X__res_msend(tls, int32(1), bp, bp+8, bp+16, bp+24, **(**int32)(__ccgo_up(bp + 24))) + if r < 0 || !(**(**int32)(__ccgo_up(bp + 24)) != 0) { v1 = -int32(1) } else { - v1 = *(*int32)(unsafe.Pointer(bp + 24)) + v1 = **(**int32)(__ccgo_up(bp + 24)) } return v1 } @@ -124586,11 +124586,11 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ (*Tresolvconf)(unsafe.Pointer(conf)).Ftimeout = uint32(5) (*Tresolvconf)(unsafe.Pointer(conf)).Fattempts = uint32(2) if search != 0 { - *(*int8)(unsafe.Pointer(search)) = 0 + **(**int8)(__ccgo_up(search)) = 0 } f = X__fopen_rb_ca(tls, __ccgo_ts+1166, bp+512, bp+256, uint64(256)) if !(f != 0) { - switch *(*int32)(unsafe.Pointer(X__errno_location(tls))) { + switch **(**int32)(__ccgo_up(X__errno_location(tls))) { case int32(ENOENT): fallthrough case int32(ENOTDIR): @@ -124609,17 +124609,17 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ continue } if v4 = !(Xstrncmp(tls, bp, __ccgo_ts+1183, uint64(7)) != 0); v4 { - v1 = int32((*(*[256]int8)(unsafe.Pointer(bp)))[int32(7)]) + v1 = int32((**(**[256]int8)(__ccgo_up(bp)))[int32(7)]) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _3 _3: } if v4 && v2 != 0 { p = Xstrstr(tls, bp, __ccgo_ts+1191) - if p != 0 && BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(p + 6)))-uint32('0') < uint32(10)) != 0 { + if p != 0 && BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(p + 6)))-uint32('0') < uint32(10)) != 0 { p = p + uintptr(6) x = Xstrtoul(tls, p, bp+744, int32(10)) - if *(*uintptr)(unsafe.Pointer(bp + 744)) != p { + if **(**uintptr)(__ccgo_up(bp + 744)) != p { if x > uint64(15) { v5 = uint64(15) } else { @@ -124629,10 +124629,10 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ } } p = Xstrstr(tls, bp, __ccgo_ts+1198) - if p != 0 && BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(p + 9)))-uint32('0') < uint32(10)) != 0 { + if p != 0 && BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(p + 9)))-uint32('0') < uint32(10)) != 0 { p = p + uintptr(9) x1 = Xstrtoul(tls, p, bp+744, int32(10)) - if *(*uintptr)(unsafe.Pointer(bp + 744)) != p { + if **(**uintptr)(__ccgo_up(bp + 744)) != p { if x1 > uint64(10) { v5 = uint64(10) } else { @@ -124642,10 +124642,10 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ } } p = Xstrstr(tls, bp, __ccgo_ts+1208) - if p != 0 && (BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(p + 8)))-uint32('0') < uint32(10)) != 0 || int32(*(*int8)(unsafe.Pointer(p + 8))) == int32('.')) { + if p != 0 && (BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(p + 8)))-uint32('0') < uint32(10)) != 0 || int32(**(**int8)(__ccgo_up(p + 8))) == int32('.')) { p = p + uintptr(8) x2 = Xstrtoul(tls, p, bp+744, int32(10)) - if *(*uintptr)(unsafe.Pointer(bp + 744)) != p { + if **(**uintptr)(__ccgo_up(bp + 744)) != p { if x2 > uint64(60) { v5 = uint64(60) } else { @@ -124657,7 +124657,7 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ continue } if v4 = !(Xstrncmp(tls, bp, __ccgo_ts+1217, uint64(10)) != 0); v4 { - v1 = int32((*(*[256]int8)(unsafe.Pointer(bp)))[int32(10)]) + v1 = int32((**(**[256]int8)(__ccgo_up(bp)))[int32(10)]) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _10 _10: @@ -124668,7 +124668,7 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ } p = bp + uintptr(11) for { - v1 = int32(*(*int8)(unsafe.Pointer(p))) + v1 = int32(**(**int8)(__ccgo_up(p))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _15 _15: @@ -124680,10 +124680,10 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ ; p = p + 1 } - *(*uintptr)(unsafe.Pointer(bp + 744)) = p + **(**uintptr)(__ccgo_up(bp + 744)) = p for { - if v4 = *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 744)))) != 0; v4 { - v1 = int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 744))))) + if v4 = **(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 744)))) != 0; v4 { + v1 = int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 744))))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _19 _19: @@ -124694,9 +124694,9 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ goto _16 _16: ; - *(*uintptr)(unsafe.Pointer(bp + 744)) = *(*uintptr)(unsafe.Pointer(bp + 744)) + 1 + **(**uintptr)(__ccgo_up(bp + 744)) = **(**uintptr)(__ccgo_up(bp + 744)) + 1 } - *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 744)))) = 0 + **(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 744)))) = 0 if X__lookup_ipliteral(tls, conf+uintptr(nns)*28, p, PF_UNSPEC) > 0 { nns = nns + 1 } @@ -124706,7 +124706,7 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ continue } if v4 = Xstrncmp(tls, bp, __ccgo_ts+1228, uint64(6)) != 0 && Xstrncmp(tls, bp, __ccgo_ts+1235, uint64(6)) != 0; !v4 { - v1 = int32((*(*[256]int8)(unsafe.Pointer(bp)))[int32(6)]) + v1 = int32((**(**[256]int8)(__ccgo_up(bp)))[int32(6)]) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _23 _23: @@ -124716,7 +124716,7 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ } p = bp + uintptr(7) for { - v1 = int32(*(*int8)(unsafe.Pointer(p))) + v1 = int32(**(**int8)(__ccgo_up(p))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _28 _28: @@ -124782,7 +124782,7 @@ func Xsendmmsg(tls *TLS, fd int32, msgvec uintptr, vlen uint32, flags uint32) (r if r < 0 { goto error } - (*(*Tmmsghdr)(unsafe.Pointer(msgvec + uintptr(i)*64))).Fmsg_len = Uint32FromInt64(r) + (**(**Tmmsghdr)(__ccgo_up(msgvec + uintptr(i)*64))).Fmsg_len = Uint32FromInt64(r) goto _1 _1: ; @@ -124815,18 +124815,18 @@ func Xsendmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r1 Tssize_t) { var _ /* h at bp+0 */ Tmsghdr _, _, _, _, _, _, _, _, _, _, _ = c1, r, v1, v10, v11, v12, v3, v6, v7, v8, v9 if msg != 0 { - *(*Tmsghdr)(unsafe.Pointer(bp)) = *(*Tmsghdr)(unsafe.Pointer(msg)) + **(**Tmsghdr)(__ccgo_up(bp)) = **(**Tmsghdr)(__ccgo_up(msg)) v1 = Int32FromInt32(0) - (*(*Tmsghdr)(unsafe.Pointer(bp))).F__pad2 = v1 - (*(*Tmsghdr)(unsafe.Pointer(bp))).F__pad1 = v1 + (**(**Tmsghdr)(__ccgo_up(bp))).F__pad2 = v1 + (**(**Tmsghdr)(__ccgo_up(bp))).F__pad1 = v1 msg = bp - if (*(*Tmsghdr)(unsafe.Pointer(bp))).Fmsg_controllen != 0 { - if uint64((*(*Tmsghdr)(unsafe.Pointer(bp))).Fmsg_controllen) > uint64(1056) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + if (**(**Tmsghdr)(__ccgo_up(bp))).Fmsg_controllen != 0 { + if uint64((**(**Tmsghdr)(__ccgo_up(bp))).Fmsg_controllen) > uint64(1056) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return int64(-int32(1)) } - Xmemcpy(tls, bp+56, (*(*Tmsghdr)(unsafe.Pointer(bp))).Fmsg_control, uint64((*(*Tmsghdr)(unsafe.Pointer(bp))).Fmsg_controllen)) - (*(*Tmsghdr)(unsafe.Pointer(bp))).Fmsg_control = bp + 56 + Xmemcpy(tls, bp+56, (**(**Tmsghdr)(__ccgo_up(bp))).Fmsg_control, uint64((**(**Tmsghdr)(__ccgo_up(bp))).Fmsg_controllen)) + (**(**Tmsghdr)(__ccgo_up(bp))).Fmsg_control = bp + 56 if uint64((*Tmsghdr)(unsafe.Pointer(bp)).Fmsg_controllen) >= uint64(16) { v3 = (*Tmsghdr)(unsafe.Pointer(bp)).Fmsg_control } else { @@ -125099,7 +125099,7 @@ func Xsockatmark(tls *TLS, s int32) (r int32) { if Xioctl(tls, s, int32(SIOCATMARK), VaList(bp+16, bp)) < 0 { return -int32(1) } - return *(*int32)(unsafe.Pointer(bp)) + return **(**int32)(__ccgo_up(bp)) } func Xsocket(tls *TLS, domain int32, type1 int32, protocol int32) (r1 int32) { @@ -125197,7 +125197,7 @@ func Xsocketpair(tls *TLS, domain int32, type1 int32, protocol int32, fd uintptr goto _9 _9: r1 = int32(X__syscall_ret(tls, Uint64FromInt64(v8))) - if r1 < 0 && (*(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EINVAL) || *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EPROTONOSUPPORT)) && type1&(Int32FromInt32(SOCK_CLOEXEC)|Int32FromInt32(SOCK_NONBLOCK)) != 0 { + if r1 < 0 && (**(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EINVAL) || **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EPROTONOSUPPORT)) && type1&(Int32FromInt32(SOCK_CLOEXEC)|Int32FromInt32(SOCK_NONBLOCK)) != 0 { v10 = int32(SYS_socketpair) _ = int32(__SC_socketpair) v11 = int64(domain) @@ -125223,12 +125223,12 @@ _9: return r1 } if type1&int32(SOCK_CLOEXEC) != 0 { - X__syscall3(tls, int64(SYS_fcntl), int64(*(*int32)(unsafe.Pointer(fd))), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) - X__syscall3(tls, int64(SYS_fcntl), int64(*(*int32)(unsafe.Pointer(fd + 1*4))), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) + X__syscall3(tls, int64(SYS_fcntl), int64(**(**int32)(__ccgo_up(fd))), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) + X__syscall3(tls, int64(SYS_fcntl), int64(**(**int32)(__ccgo_up(fd + 1*4))), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) } if type1&int32(SOCK_NONBLOCK) != 0 { - X__syscall3(tls, int64(SYS_fcntl), int64(*(*int32)(unsafe.Pointer(fd))), int64(Int32FromInt32(F_SETFL)), int64(Int32FromInt32(O_NONBLOCK))) - X__syscall3(tls, int64(SYS_fcntl), int64(*(*int32)(unsafe.Pointer(fd + 1*4))), int64(Int32FromInt32(F_SETFL)), int64(Int32FromInt32(O_NONBLOCK))) + X__syscall3(tls, int64(SYS_fcntl), int64(**(**int32)(__ccgo_up(fd))), int64(Int32FromInt32(F_SETFL)), int64(Int32FromInt32(O_NONBLOCK))) + X__syscall3(tls, int64(SYS_fcntl), int64(**(**int32)(__ccgo_up(fd + 1*4))), int64(Int32FromInt32(F_SETFL)), int64(Int32FromInt32(O_NONBLOCK))) } } return r1 @@ -125265,10 +125265,10 @@ func Xfgetgrent(tls *TLS, f uintptr) (r uintptr) { var _ /* nmem at bp+16 */ Tsize_t var _ /* res at bp+0 */ uintptr var _ /* size at bp+8 */ Tsize_t - *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint64(0) - *(*Tsize_t)(unsafe.Pointer(bp + 16)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp + 8)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp + 16)) = uint64(0) X__getgrent_a(tls, f, uintptr(unsafe.Pointer(&_gr)), uintptr(unsafe.Pointer(&_line1)), bp+8, uintptr(unsafe.Pointer(&_mem)), bp+16, bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } var _line1 uintptr @@ -125286,9 +125286,9 @@ func Xfgetpwent(tls *TLS, f uintptr) (r uintptr) { defer tls.Free(16) var _ /* res at bp+8 */ uintptr var _ /* size at bp+0 */ Tsize_t - *(*Tsize_t)(unsafe.Pointer(bp)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp)) = uint64(0) X__getpwent_a(tls, f, uintptr(unsafe.Pointer(&_pw)), uintptr(unsafe.Pointer(&_line2)), bp, bp+8) - return *(*uintptr)(unsafe.Pointer(bp + 8)) + return **(**uintptr)(__ccgo_up(bp + 8)) } var _line2 uintptr @@ -125334,11 +125334,11 @@ func _itoa1(tls *TLS, p uintptr, x Tuint32_t) (r uintptr) { p = p + uintptr(11) p = p - 1 v1 = p - *(*int8)(unsafe.Pointer(v1)) = 0 + **(**int8)(__ccgo_up(v1)) = 0 for cond := true; cond; cond = x != 0 { p = p - 1 v1 = p - *(*int8)(unsafe.Pointer(v1)) = Int8FromUint32(uint32('0') + x%uint32(10)) + **(**int8)(__ccgo_up(v1)) = Int8FromUint32(uint32('0') + x%uint32(10)) x = x / uint32(10) } return p @@ -125363,36 +125363,36 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz var _ /* swap at bp+40 */ int32 _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, grlist_len, i, key, len1, ptr, req, rv, tmp, tmp1, v1, v10, v5, v6 rv = 0 - *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) + **(**uintptr)(__ccgo_up(res)) = uintptr(0) _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp) f = Xfopen(tls, __ccgo_ts+1252, __ccgo_ts+381) if !(f != 0) { - rv = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + rv = **(**int32)(__ccgo_up(X__errno_location(tls))) goto done } for { v1 = X__getgrent_a(tls, f, gr, buf, size, mem, nmem, res) rv = v1 - if !(!(v1 != 0) && *(*uintptr)(unsafe.Pointer(res)) != 0) { + if !(!(v1 != 0) && **(**uintptr)(__ccgo_up(res)) != 0) { break } - if name != 0 && !(Xstrcmp(tls, name, (*Tgroup)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(res)))).Fgr_name) != 0) || !(name != 0) && (*Tgroup)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(res)))).Fgr_gid == gid { + if name != 0 && !(Xstrcmp(tls, name, (*Tgroup)(unsafe.Pointer(**(**uintptr)(__ccgo_up(res)))).Fgr_name) != 0) || !(name != 0) && (*Tgroup)(unsafe.Pointer(**(**uintptr)(__ccgo_up(res)))).Fgr_gid == gid { break } } Xfclose(tls, f) - if !(*(*uintptr)(unsafe.Pointer(res)) != 0) && (rv == 0 || rv == int32(ENOENT) || rv == int32(ENOTDIR)) { + if !(**(**uintptr)(__ccgo_up(res)) != 0) && (rv == 0 || rv == int32(ENOENT) || rv == int32(ENOTDIR)) { if name != 0 { v1 = int32(GETGRBYNAME) } else { v1 = int32(GETGRBYGID) } req = v1 - *(*[6]Tint32_t)(unsafe.Pointer(bp + 4)) = [6]Tint32_t{} + **(**[6]Tint32_t)(__ccgo_up(bp + 4)) = [6]Tint32_t{} len1 = uint64(0) grlist_len = uint64(0) - *(*[11]int8)(unsafe.Pointer(bp + 28)) = [11]int8{} - *(*int32)(unsafe.Pointer(bp + 40)) = 0 + **(**[11]int8)(__ccgo_up(bp + 28)) = [11]int8{} + **(**int32)(__ccgo_up(bp + 40)) = 0 if name != 0 { key = name } else { @@ -125404,116 +125404,116 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz } f = X__nscd_query(tls, req, key, bp+4, uint64(24), bp+40) if !(f != 0) { - rv = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + rv = **(**int32)(__ccgo_up(X__errno_location(tls))) goto done } - if !((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRFOUND)] != 0) { + if !((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRFOUND)] != 0) { rv = 0 goto cleanup_f } - if !((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRNAMELEN)] != 0) || !((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRPASSWDLEN)] != 0) { + if !((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRNAMELEN)] != 0) || !((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRPASSWDLEN)] != 0) { rv = int32(EIO) goto cleanup_f } - if Uint64FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRNAMELEN)]) > uint64(0xffffffffffffffff)-Uint64FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRPASSWDLEN)]) { + if Uint64FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRNAMELEN)]) > uint64(0xffffffffffffffff)-Uint64FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRPASSWDLEN)]) { rv = int32(ENOMEM) goto cleanup_f } - len1 = Uint64FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRNAMELEN)] + (*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRPASSWDLEN)]) + len1 = Uint64FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRNAMELEN)] + (**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRPASSWDLEN)]) i = 0 for { - if !(i < (*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)]) { + if !(i < (**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)]) { break } if Xfread(tls, bp+44, uint64(4), uint64(1), f) < uint64(1) { if Xferror(tls, f) != 0 { - v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = **(**int32)(__ccgo_up(X__errno_location(tls))) } else { v1 = int32(EIO) } rv = v1 goto cleanup_f } - if *(*int32)(unsafe.Pointer(bp + 40)) != 0 { - v5 = *(*Tuint32_t)(unsafe.Pointer(bp + 44)) + if **(**int32)(__ccgo_up(bp + 40)) != 0 { + v5 = **(**Tuint32_t)(__ccgo_up(bp + 44)) v6 = v5>>int32(24) | v5>>int32(8)&uint32(0xff00) | v5< uint64(0xffffffffffffffff)-grlist_len || uint64(*(*Tuint32_t)(unsafe.Pointer(bp + 44))) > uint64(0xffffffffffffffff)-len1 { + if uint64(**(**Tuint32_t)(__ccgo_up(bp + 44))) > uint64(0xffffffffffffffff)-grlist_len || uint64(**(**Tuint32_t)(__ccgo_up(bp + 44))) > uint64(0xffffffffffffffff)-len1 { rv = int32(ENOMEM) goto cleanup_f } - len1 = len1 + uint64(*(*Tuint32_t)(unsafe.Pointer(bp + 44))) - grlist_len = grlist_len + uint64(*(*Tuint32_t)(unsafe.Pointer(bp + 44))) + len1 = len1 + uint64(**(**Tuint32_t)(__ccgo_up(bp + 44))) + grlist_len = grlist_len + uint64(**(**Tuint32_t)(__ccgo_up(bp + 44))) goto _3 _3: ; i = i + 1 } - if len1 > *(*Tsize_t)(unsafe.Pointer(size)) || !(*(*uintptr)(unsafe.Pointer(buf)) != 0) { - tmp = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(buf)), len1) + if len1 > **(**Tsize_t)(__ccgo_up(size)) || !(**(**uintptr)(__ccgo_up(buf)) != 0) { + tmp = Xrealloc(tls, **(**uintptr)(__ccgo_up(buf)), len1) if !(tmp != 0) { - rv = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + rv = **(**int32)(__ccgo_up(X__errno_location(tls))) goto cleanup_f } - *(*uintptr)(unsafe.Pointer(buf)) = tmp - *(*Tsize_t)(unsafe.Pointer(size)) = len1 + **(**uintptr)(__ccgo_up(buf)) = tmp + **(**Tsize_t)(__ccgo_up(size)) = len1 } - if !(Xfread(tls, *(*uintptr)(unsafe.Pointer(buf)), len1, uint64(1), f) != 0) { + if !(Xfread(tls, **(**uintptr)(__ccgo_up(buf)), len1, uint64(1), f) != 0) { if Xferror(tls, f) != 0 { - v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = **(**int32)(__ccgo_up(X__errno_location(tls))) } else { v1 = int32(EIO) } rv = v1 goto cleanup_f } - if Uint64FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)]+int32(1)) > *(*Tsize_t)(unsafe.Pointer(nmem)) { - if Uint64FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)]+int32(1)) > Uint64FromUint64(0xffffffffffffffff)/Uint64FromInt64(8) { + if Uint64FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)]+int32(1)) > **(**Tsize_t)(__ccgo_up(nmem)) { + if Uint64FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)]+int32(1)) > Uint64FromUint64(0xffffffffffffffff)/Uint64FromInt64(8) { rv = int32(ENOMEM) goto cleanup_f } - tmp1 = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(mem)), Uint64FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)]+Int32FromInt32(1))*uint64(8)) + tmp1 = Xrealloc(tls, **(**uintptr)(__ccgo_up(mem)), Uint64FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)]+Int32FromInt32(1))*uint64(8)) if !(tmp1 != 0) { - rv = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + rv = **(**int32)(__ccgo_up(X__errno_location(tls))) goto cleanup_f } - *(*uintptr)(unsafe.Pointer(mem)) = tmp1 - *(*Tsize_t)(unsafe.Pointer(nmem)) = Uint64FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)] + int32(1)) + **(**uintptr)(__ccgo_up(mem)) = tmp1 + **(**Tsize_t)(__ccgo_up(nmem)) = Uint64FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)] + int32(1)) } - if (*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)] != 0 { - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)))) = *(*uintptr)(unsafe.Pointer(buf)) + uintptr((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRNAMELEN)]) + uintptr((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRPASSWDLEN)]) - ptr = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)))) + if (**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)] != 0 { + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)))) = **(**uintptr)(__ccgo_up(buf)) + uintptr((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRNAMELEN)]) + uintptr((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRPASSWDLEN)]) + ptr = **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)))) i = Int32FromInt32(0) for { - if !(ptr != *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem))))+uintptr(grlist_len)) { + if !(ptr != **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem))))+uintptr(grlist_len)) { break } - if !(*(*int8)(unsafe.Pointer(ptr)) != 0) { + if !(**(**int8)(__ccgo_up(ptr)) != 0) { i = i + 1 v10 = i - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v10)*8)) = ptr + uintptr(1) + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)) + uintptr(v10)*8)) = ptr + uintptr(1) } goto _9 _9: ; ptr = ptr + 1 } - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(i)*8)) = uintptr(0) - if i != (*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)] { + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)) + uintptr(i)*8)) = uintptr(0) + if i != (**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)] { rv = int32(EIO) goto cleanup_f } } else { - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)))) = uintptr(0) + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)))) = uintptr(0) } - (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = *(*uintptr)(unsafe.Pointer(buf)) - (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = (*Tgroup)(unsafe.Pointer(gr)).Fgr_name + uintptr((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRNAMELEN)]) - (*Tgroup)(unsafe.Pointer(gr)).Fgr_gid = Uint32FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRGID)]) - (*Tgroup)(unsafe.Pointer(gr)).Fgr_mem = *(*uintptr)(unsafe.Pointer(mem)) - if *(*int8)(unsafe.Pointer((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd + uintptr(-Int32FromInt32(1)))) != 0 || *(*int8)(unsafe.Pointer((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd + uintptr((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRPASSWDLEN)]-int32(1)))) != 0 { + (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = **(**uintptr)(__ccgo_up(buf)) + (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = (*Tgroup)(unsafe.Pointer(gr)).Fgr_name + uintptr((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRNAMELEN)]) + (*Tgroup)(unsafe.Pointer(gr)).Fgr_gid = Uint32FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRGID)]) + (*Tgroup)(unsafe.Pointer(gr)).Fgr_mem = **(**uintptr)(__ccgo_up(mem)) + if **(**int8)(__ccgo_up((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd + uintptr(-Int32FromInt32(1)))) != 0 || **(**int8)(__ccgo_up((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd + uintptr((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRPASSWDLEN)]-int32(1)))) != 0 { rv = int32(EIO) goto cleanup_f } @@ -125521,7 +125521,7 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz rv = int32(EIO) goto cleanup_f } - *(*uintptr)(unsafe.Pointer(res)) = gr + **(**uintptr)(__ccgo_up(res)) = gr goto cleanup_f cleanup_f: ; @@ -125531,9 +125531,9 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz goto done done: ; - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) if rv != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = rv + **(**int32)(__ccgo_up(X__errno_location(tls))) = rv } return rv } @@ -125549,42 +125549,42 @@ func _getgr_r(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, size var _ /* mem at bp+16 */ uintptr var _ /* nmem at bp+24 */ Tsize_t _, _ = i, rv - *(*uintptr)(unsafe.Pointer(bp)) = uintptr(0) - *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint64(0) - *(*uintptr)(unsafe.Pointer(bp + 16)) = uintptr(0) - *(*Tsize_t)(unsafe.Pointer(bp + 24)) = uint64(0) + **(**uintptr)(__ccgo_up(bp)) = uintptr(0) + **(**Tsize_t)(__ccgo_up(bp + 8)) = uint64(0) + **(**uintptr)(__ccgo_up(bp + 16)) = uintptr(0) + **(**Tsize_t)(__ccgo_up(bp + 24)) = uint64(0) rv = 0 _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp+32) rv = X__getgr_a(tls, name, gid, gr, bp, bp+8, bp+16, bp+24, res) - if *(*uintptr)(unsafe.Pointer(res)) != 0 && size < *(*Tsize_t)(unsafe.Pointer(bp + 8))+(*(*Tsize_t)(unsafe.Pointer(bp + 24))+uint64(1))*uint64(8)+uint64(32) { - *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) + if **(**uintptr)(__ccgo_up(res)) != 0 && size < **(**Tsize_t)(__ccgo_up(bp + 8))+(**(**Tsize_t)(__ccgo_up(bp + 24))+uint64(1))*uint64(8)+uint64(32) { + **(**uintptr)(__ccgo_up(res)) = uintptr(0) rv = int32(ERANGE) } - if *(*uintptr)(unsafe.Pointer(res)) != 0 { + if **(**uintptr)(__ccgo_up(res)) != 0 { buf = buf + uintptr((uint64(16)-uint64(buf))%uint64(16)) (*Tgroup)(unsafe.Pointer(gr)).Fgr_mem = buf - buf = buf + uintptr((*(*Tsize_t)(unsafe.Pointer(bp + 24))+uint64(1))*uint64(8)) - Xmemcpy(tls, buf, *(*uintptr)(unsafe.Pointer(bp)), *(*Tsize_t)(unsafe.Pointer(bp + 8))) - (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = uintptr(int64((*Tgroup)(unsafe.Pointer(gr)).Fgr_name)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf - (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = uintptr(int64((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf + buf = buf + uintptr((**(**Tsize_t)(__ccgo_up(bp + 24))+uint64(1))*uint64(8)) + Xmemcpy(tls, buf, **(**uintptr)(__ccgo_up(bp)), **(**Tsize_t)(__ccgo_up(bp + 8))) + (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = uintptr(int64((*Tgroup)(unsafe.Pointer(gr)).Fgr_name)-int64(**(**uintptr)(__ccgo_up(bp)))) + buf + (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = uintptr(int64((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd)-int64(**(**uintptr)(__ccgo_up(bp)))) + buf i = uint64(0) for { - if !(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + uintptr(i)*8)) != 0) { + if !(**(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 16)) + uintptr(i)*8)) != 0) { break } - *(*uintptr)(unsafe.Pointer((*Tgroup)(unsafe.Pointer(gr)).Fgr_mem + uintptr(i)*8)) = uintptr(int64(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + uintptr(i)*8)))-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf + **(**uintptr)(__ccgo_up((*Tgroup)(unsafe.Pointer(gr)).Fgr_mem + uintptr(i)*8)) = uintptr(int64(**(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 16)) + uintptr(i)*8)))-int64(**(**uintptr)(__ccgo_up(bp)))) + buf goto _1 _1: ; i = i + 1 } - *(*uintptr)(unsafe.Pointer((*Tgroup)(unsafe.Pointer(gr)).Fgr_mem + uintptr(i)*8)) = uintptr(0) + **(**uintptr)(__ccgo_up((*Tgroup)(unsafe.Pointer(gr)).Fgr_mem + uintptr(i)*8)) = uintptr(0) } - Xfree(tls, *(*uintptr)(unsafe.Pointer(bp + 16))) - Xfree(tls, *(*uintptr)(unsafe.Pointer(bp))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 32)), uintptr(0)) + Xfree(tls, **(**uintptr)(__ccgo_up(bp + 16))) + Xfree(tls, **(**uintptr)(__ccgo_up(bp))) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 32)), uintptr(0)) if rv != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = rv + **(**int32)(__ccgo_up(X__errno_location(tls))) = rv } return rv } @@ -125630,8 +125630,8 @@ func Xgetgrent(tls *TLS) (r uintptr) { var _ /* nmem at bp+16 */ Tsize_t var _ /* res at bp+0 */ uintptr var _ /* size at bp+8 */ Tsize_t - *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint64(0) - *(*Tsize_t)(unsafe.Pointer(bp + 16)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp + 8)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp + 16)) = uint64(0) if !(_f1 != 0) { _f1 = Xfopen(tls, __ccgo_ts+1252, __ccgo_ts+381) } @@ -125639,7 +125639,7 @@ func Xgetgrent(tls *TLS) (r uintptr) { return uintptr(0) } X__getgrent_a(tls, _f1, uintptr(unsafe.Pointer(&_gr1)), uintptr(unsafe.Pointer(&_line3)), bp+8, uintptr(unsafe.Pointer(&_mem1)), bp+16, bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func Xgetgrgid(tls *TLS, gid Tgid_t) (r uintptr) { @@ -125652,10 +125652,10 @@ func Xgetgrgid(tls *TLS, gid Tgid_t) (r uintptr) { var _ /* nmem at bp+16 */ Tsize_t var _ /* res at bp+0 */ uintptr var _ /* size at bp+8 */ Tsize_t - *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint64(0) - *(*Tsize_t)(unsafe.Pointer(bp + 16)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp + 8)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp + 16)) = uint64(0) X__getgr_a(tls, uintptr(0), gid, uintptr(unsafe.Pointer(&_gr1)), uintptr(unsafe.Pointer(&_line3)), bp+8, uintptr(unsafe.Pointer(&_mem1)), bp+16, bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func Xgetgrnam(tls *TLS, name uintptr) (r uintptr) { @@ -125668,10 +125668,10 @@ func Xgetgrnam(tls *TLS, name uintptr) (r uintptr) { var _ /* nmem at bp+16 */ Tsize_t var _ /* res at bp+0 */ uintptr var _ /* size at bp+8 */ Tsize_t - *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint64(0) - *(*Tsize_t)(unsafe.Pointer(bp + 16)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp + 8)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp + 16)) = uint64(0) X__getgr_a(tls, name, uint32(0), uintptr(unsafe.Pointer(&_gr1)), uintptr(unsafe.Pointer(&_line3)), bp+8, uintptr(unsafe.Pointer(&_mem1)), bp+16, bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func Xendgrent(tls *TLS) { @@ -125686,14 +125686,14 @@ func _atou(tls *TLS, s uintptr) (r uint32) { _ = x x = uint32(0) for { - if !(Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-int32('0')) < uint32(10)) { + if !(Uint32FromInt32(int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-int32('0')) < uint32(10)) { break } - x = uint32(10)*x + Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-Int32FromUint8('0')) + x = uint32(10)*x + Uint32FromInt32(int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-Int32FromUint8('0')) goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s)) = *(*uintptr)(unsafe.Pointer(s)) + 1 + **(**uintptr)(__ccgo_up(s)) = **(**uintptr)(__ccgo_up(s)) + 1 } return x } @@ -125719,107 +125719,107 @@ func X__getgrent_a(tls *TLS, f uintptr, gr uintptr, line uintptr, size uintptr, l = v2 if v2 < 0 { if Xferror(tls, f) != 0 { - v3 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v3 = **(**int32)(__ccgo_up(X__errno_location(tls))) } else { v3 = 0 } rv = v3 - Xfree(tls, *(*uintptr)(unsafe.Pointer(line))) - *(*uintptr)(unsafe.Pointer(line)) = uintptr(0) + Xfree(tls, **(**uintptr)(__ccgo_up(line))) + **(**uintptr)(__ccgo_up(line)) = uintptr(0) gr = uintptr(0) goto end } - *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(line)) + uintptr(l-int64(1)))) = 0 - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(line)) - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(line)) + uintptr(l-int64(1)))) = 0 + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(line)) + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = v4 - v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v4 + v4 = Xstrchr(tls, **(**uintptr)(__ccgo_up(bp)), int32(':')) + **(**uintptr)(__ccgo_up(bp)) = v4 if !(v4 != 0) { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*int8)(unsafe.Pointer(v4)) = 0 - (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = *(*uintptr)(unsafe.Pointer(bp)) - v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v4 + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**int8)(__ccgo_up(v4)) = 0 + (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = **(**uintptr)(__ccgo_up(bp)) + v4 = Xstrchr(tls, **(**uintptr)(__ccgo_up(bp)), int32(':')) + **(**uintptr)(__ccgo_up(bp)) = v4 if !(v4 != 0) { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*int8)(unsafe.Pointer(v4)) = 0 + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**int8)(__ccgo_up(v4)) = 0 (*Tgroup)(unsafe.Pointer(gr)).Fgr_gid = _atou(tls, bp) - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32(':') { + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) != int32(':') { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*int8)(unsafe.Pointer(v4)) = 0 - mems = *(*uintptr)(unsafe.Pointer(bp)) + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**int8)(__ccgo_up(v4)) = 0 + mems = **(**uintptr)(__ccgo_up(bp)) break goto _1 _1: } - *(*Tsize_t)(unsafe.Pointer(nmem)) = BoolUint64(!!(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) != 0)) + **(**Tsize_t)(__ccgo_up(nmem)) = BoolUint64(!!(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))) != 0)) for { - if !(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) != 0) { + if !(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))) != 0) { break } - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32(',') { - *(*Tsize_t)(unsafe.Pointer(nmem)) = *(*Tsize_t)(unsafe.Pointer(nmem)) + 1 + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) == int32(',') { + **(**Tsize_t)(__ccgo_up(nmem)) = **(**Tsize_t)(__ccgo_up(nmem)) + 1 } goto _10 _10: ; - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - } - Xfree(tls, *(*uintptr)(unsafe.Pointer(mem))) - *(*uintptr)(unsafe.Pointer(mem)) = Xcalloc(tls, uint64(8), *(*Tsize_t)(unsafe.Pointer(nmem))+uint64(1)) - if !(*(*uintptr)(unsafe.Pointer(mem)) != 0) { - rv = *(*int32)(unsafe.Pointer(X__errno_location(tls))) - Xfree(tls, *(*uintptr)(unsafe.Pointer(line))) - *(*uintptr)(unsafe.Pointer(line)) = uintptr(0) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + } + Xfree(tls, **(**uintptr)(__ccgo_up(mem))) + **(**uintptr)(__ccgo_up(mem)) = Xcalloc(tls, uint64(8), **(**Tsize_t)(__ccgo_up(nmem))+uint64(1)) + if !(**(**uintptr)(__ccgo_up(mem)) != 0) { + rv = **(**int32)(__ccgo_up(X__errno_location(tls))) + Xfree(tls, **(**uintptr)(__ccgo_up(line))) + **(**uintptr)(__ccgo_up(line)) = uintptr(0) gr = uintptr(0) goto end } - if *(*int8)(unsafe.Pointer(mems)) != 0 { - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)))) = mems - *(*uintptr)(unsafe.Pointer(bp)) = mems + if **(**int8)(__ccgo_up(mems)) != 0 { + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)))) = mems + **(**uintptr)(__ccgo_up(bp)) = mems i = Uint64FromInt32(0) for { - if !(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) != 0) { + if !(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))) != 0) { break } - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32(',') { - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*int8)(unsafe.Pointer(v4)) = 0 + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) == int32(',') { + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**int8)(__ccgo_up(v4)) = 0 i = i + 1 v13 = i - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v13)*8)) = *(*uintptr)(unsafe.Pointer(bp)) + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)) + uintptr(v13)*8)) = **(**uintptr)(__ccgo_up(bp)) } goto _11 _11: ; - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 } i = i + 1 v13 = i - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v13)*8)) = uintptr(0) + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)) + uintptr(v13)*8)) = uintptr(0) } else { - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)))) = uintptr(0) + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)))) = uintptr(0) } - (*Tgroup)(unsafe.Pointer(gr)).Fgr_mem = *(*uintptr)(unsafe.Pointer(mem)) + (*Tgroup)(unsafe.Pointer(gr)).Fgr_mem = **(**uintptr)(__ccgo_up(mem)) goto end end: ; - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 8)), uintptr(0)) - *(*uintptr)(unsafe.Pointer(res)) = gr + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 8)), uintptr(0)) + **(**uintptr)(__ccgo_up(res)) = gr if rv != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = rv + **(**int32)(__ccgo_up(X__errno_location(tls))) = rv } return rv } @@ -125848,44 +125848,44 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, i, n, nbytes, nlim, nscdbuf, ret, rv, v1, v14, v3, v4, v6, v9 ret = -int32(1) n = int64(1) - *(*int32)(unsafe.Pointer(bp + 40)) = 0 + **(**int32)(__ccgo_up(bp + 40)) = 0 nscdbuf = uintptr(0) - *(*uintptr)(unsafe.Pointer(bp + 56)) = uintptr(0) - *(*uintptr)(unsafe.Pointer(bp + 64)) = uintptr(0) - *(*Tsize_t)(unsafe.Pointer(bp + 72)) = uint64(0) - nlim = *(*int32)(unsafe.Pointer(ngroups)) + **(**uintptr)(__ccgo_up(bp + 56)) = uintptr(0) + **(**uintptr)(__ccgo_up(bp + 64)) = uintptr(0) + **(**Tsize_t)(__ccgo_up(bp + 72)) = uint64(0) + nlim = **(**int32)(__ccgo_up(ngroups)) if nlim >= int32(1) { v1 = groups groups += 4 - *(*Tgid_t)(unsafe.Pointer(v1)) = gid + **(**Tgid_t)(__ccgo_up(v1)) = gid } f = X__nscd_query(tls, int32(GETINITGR), user, bp+44, uint64(12), bp+40) if !(f != 0) { goto cleanup } - if (*(*[3]Tint32_t)(unsafe.Pointer(bp + 44)))[int32(INITGRFOUND)] != 0 { - nscdbuf = Xcalloc(tls, Uint64FromInt32((*(*[3]Tint32_t)(unsafe.Pointer(bp + 44)))[int32(INITGRNGRPS)]), uint64(4)) + if (**(**[3]Tint32_t)(__ccgo_up(bp + 44)))[int32(INITGRFOUND)] != 0 { + nscdbuf = Xcalloc(tls, Uint64FromInt32((**(**[3]Tint32_t)(__ccgo_up(bp + 44)))[int32(INITGRNGRPS)]), uint64(4)) if !(nscdbuf != 0) { goto cleanup } - nbytes = uint64(4) * Uint64FromInt32((*(*[3]Tint32_t)(unsafe.Pointer(bp + 44)))[int32(INITGRNGRPS)]) + nbytes = uint64(4) * Uint64FromInt32((**(**[3]Tint32_t)(__ccgo_up(bp + 44)))[int32(INITGRNGRPS)]) if nbytes != 0 && !(Xfread(tls, nscdbuf, nbytes, uint64(1), f) != 0) { if !(Xferror(tls, f) != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EIO) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EIO) } goto cleanup } - if *(*int32)(unsafe.Pointer(bp + 40)) != 0 { + if **(**int32)(__ccgo_up(bp + 40)) != 0 { i = 0 for { - if !(i < int64((*(*[3]Tint32_t)(unsafe.Pointer(bp + 44)))[int32(INITGRNGRPS)])) { + if !(i < int64((**(**[3]Tint32_t)(__ccgo_up(bp + 44)))[int32(INITGRNGRPS)])) { break } - v3 = *(*Tuint32_t)(unsafe.Pointer(nscdbuf + uintptr(i)*4)) + v3 = **(**Tuint32_t)(__ccgo_up(nscdbuf + uintptr(i)*4)) v4 = v3>>int32(24) | v3>>int32(8)&uint32(0xff00) | v3<= Uint64FromUint64(0xffffffffffffffff)/Uint64FromInt32(8) { + if Uint64FromInt32((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWNAMELEN)]|(**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWPASSWDLEN)]|(**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWGECOSLEN)]|(**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWDIRLEN)]|(**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWSHELLLEN)]) >= Uint64FromUint64(0xffffffffffffffff)/Uint64FromInt32(8) { rv = int32(ENOMEM) goto cleanup_f } - len1 = Uint64FromInt32((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWNAMELEN)] + (*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWPASSWDLEN)] + (*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWGECOSLEN)] + (*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWDIRLEN)] + (*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWSHELLLEN)]) - if len1 > *(*Tsize_t)(unsafe.Pointer(size)) || !(*(*uintptr)(unsafe.Pointer(buf)) != 0) { - tmp = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(buf)), len1) + len1 = Uint64FromInt32((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWNAMELEN)] + (**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWPASSWDLEN)] + (**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWGECOSLEN)] + (**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWDIRLEN)] + (**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWSHELLLEN)]) + if len1 > **(**Tsize_t)(__ccgo_up(size)) || !(**(**uintptr)(__ccgo_up(buf)) != 0) { + tmp = Xrealloc(tls, **(**uintptr)(__ccgo_up(buf)), len1) if !(tmp != 0) { - rv = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + rv = **(**int32)(__ccgo_up(X__errno_location(tls))) goto cleanup_f } - *(*uintptr)(unsafe.Pointer(buf)) = tmp - *(*Tsize_t)(unsafe.Pointer(size)) = len1 + **(**uintptr)(__ccgo_up(buf)) = tmp + **(**Tsize_t)(__ccgo_up(size)) = len1 } - if !(Xfread(tls, *(*uintptr)(unsafe.Pointer(buf)), len1, uint64(1), f) != 0) { + if !(Xfread(tls, **(**uintptr)(__ccgo_up(buf)), len1, uint64(1), f) != 0) { if Xferror(tls, f) != 0 { - v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = **(**int32)(__ccgo_up(X__errno_location(tls))) } else { v1 = int32(EIO) } rv = v1 goto cleanup_f } - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = *(*uintptr)(unsafe.Pointer(buf)) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name + uintptr((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWNAMELEN)]) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd + uintptr((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWPASSWDLEN)]) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos + uintptr((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWGECOSLEN)]) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir + uintptr((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWDIRLEN)]) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_uid = Uint32FromInt32((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWUID)]) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gid = Uint32FromInt32((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWGID)]) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = **(**uintptr)(__ccgo_up(buf)) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name + uintptr((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWNAMELEN)]) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd + uintptr((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWPASSWDLEN)]) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos + uintptr((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWGECOSLEN)]) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir + uintptr((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWDIRLEN)]) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_uid = Uint32FromInt32((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWUID)]) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gid = Uint32FromInt32((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWGID)]) /* Don't assume that nscd made sure to null terminate strings. * It's supposed to, but malicious nscd should be ignored * rather than causing a crash. */ - if *(*int8)(unsafe.Pointer((*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd + uintptr(-Int32FromInt32(1)))) != 0 || *(*int8)(unsafe.Pointer((*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos + uintptr(-Int32FromInt32(1)))) != 0 || *(*int8)(unsafe.Pointer((*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir + uintptr(-Int32FromInt32(1)))) != 0 || *(*int8)(unsafe.Pointer((*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell + uintptr((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWSHELLLEN)]-int32(1)))) != 0 { + if **(**int8)(__ccgo_up((*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd + uintptr(-Int32FromInt32(1)))) != 0 || **(**int8)(__ccgo_up((*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos + uintptr(-Int32FromInt32(1)))) != 0 || **(**int8)(__ccgo_up((*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir + uintptr(-Int32FromInt32(1)))) != 0 || **(**int8)(__ccgo_up((*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell + uintptr((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWSHELLLEN)]-int32(1)))) != 0 { rv = int32(EIO) goto cleanup_f } @@ -126121,7 +126121,7 @@ func X__getpw_a(tls *TLS, name uintptr, uid Tuid_t, pw uintptr, buf uintptr, siz rv = int32(EIO) goto cleanup_f } - *(*uintptr)(unsafe.Pointer(res)) = pw + **(**uintptr)(__ccgo_up(res)) = pw goto cleanup_f cleanup_f: ; @@ -126131,9 +126131,9 @@ func X__getpw_a(tls *TLS, name uintptr, uid Tuid_t, pw uintptr, buf uintptr, siz goto done done: ; - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 4)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 4)), uintptr(0)) if rv != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = rv + **(**int32)(__ccgo_up(X__errno_location(tls))) = rv } return rv } @@ -126146,27 +126146,27 @@ func _getpw_r(tls *TLS, name uintptr, uid Tuid_t, pw uintptr, buf uintptr, size var _ /* len at bp+8 */ Tsize_t var _ /* line at bp+0 */ uintptr _ = rv - *(*uintptr)(unsafe.Pointer(bp)) = uintptr(0) - *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint64(0) + **(**uintptr)(__ccgo_up(bp)) = uintptr(0) + **(**Tsize_t)(__ccgo_up(bp + 8)) = uint64(0) rv = 0 _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp+16) rv = X__getpw_a(tls, name, uid, pw, bp, bp+8, res) - if *(*uintptr)(unsafe.Pointer(res)) != 0 && size < *(*Tsize_t)(unsafe.Pointer(bp + 8)) { - *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) + if **(**uintptr)(__ccgo_up(res)) != 0 && size < **(**Tsize_t)(__ccgo_up(bp + 8)) { + **(**uintptr)(__ccgo_up(res)) = uintptr(0) rv = int32(ERANGE) } - if *(*uintptr)(unsafe.Pointer(res)) != 0 { - Xmemcpy(tls, buf, *(*uintptr)(unsafe.Pointer(bp)), *(*Tsize_t)(unsafe.Pointer(bp + 8))) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_name)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf + if **(**uintptr)(__ccgo_up(res)) != 0 { + Xmemcpy(tls, buf, **(**uintptr)(__ccgo_up(bp)), **(**Tsize_t)(__ccgo_up(bp + 8))) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_name)-int64(**(**uintptr)(__ccgo_up(bp)))) + buf + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd)-int64(**(**uintptr)(__ccgo_up(bp)))) + buf + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos)-int64(**(**uintptr)(__ccgo_up(bp)))) + buf + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir)-int64(**(**uintptr)(__ccgo_up(bp)))) + buf + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell)-int64(**(**uintptr)(__ccgo_up(bp)))) + buf } - Xfree(tls, *(*uintptr)(unsafe.Pointer(bp))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 16)), uintptr(0)) + Xfree(tls, **(**uintptr)(__ccgo_up(bp))) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 16)), uintptr(0)) if rv != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = rv + **(**int32)(__ccgo_up(X__errno_location(tls))) = rv } return rv } @@ -126217,7 +126217,7 @@ func Xgetpwent(tls *TLS) (r uintptr) { return uintptr(0) } X__getpwent_a(tls, _f2, uintptr(unsafe.Pointer(&_pw1)), uintptr(unsafe.Pointer(&_line4)), uintptr(unsafe.Pointer(&_size)), bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func Xgetpwuid(tls *TLS, uid Tuid_t) (r uintptr) { @@ -126229,7 +126229,7 @@ func Xgetpwuid(tls *TLS, uid Tuid_t) (r uintptr) { defer tls.Free(16) var _ /* res at bp+0 */ uintptr X__getpw_a(tls, uintptr(0), uid, uintptr(unsafe.Pointer(&_pw1)), uintptr(unsafe.Pointer(&_line4)), uintptr(unsafe.Pointer(&_size)), bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func Xgetpwnam(tls *TLS, name uintptr) (r uintptr) { @@ -126241,7 +126241,7 @@ func Xgetpwnam(tls *TLS, name uintptr) (r uintptr) { defer tls.Free(16) var _ /* res at bp+0 */ uintptr X__getpw_a(tls, name, uint32(0), uintptr(unsafe.Pointer(&_pw1)), uintptr(unsafe.Pointer(&_line4)), uintptr(unsafe.Pointer(&_size)), bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func Xendpwent(tls *TLS) { @@ -126256,14 +126256,14 @@ func _atou1(tls *TLS, s uintptr) (r uint32) { _ = x x = uint32(0) for { - if !(Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-int32('0')) < uint32(10)) { + if !(Uint32FromInt32(int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-int32('0')) < uint32(10)) { break } - x = uint32(10)*x + Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-Int32FromUint8('0')) + x = uint32(10)*x + Uint32FromInt32(int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-Int32FromUint8('0')) goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s)) = *(*uintptr)(unsafe.Pointer(s)) + 1 + **(**uintptr)(__ccgo_up(s)) = **(**uintptr)(__ccgo_up(s)) + 1 } return x } @@ -126288,79 +126288,79 @@ func X__getpwent_a(tls *TLS, f uintptr, pw uintptr, line uintptr, size uintptr, l = v2 if v2 < 0 { if Xferror(tls, f) != 0 { - v3 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v3 = **(**int32)(__ccgo_up(X__errno_location(tls))) } else { v3 = 0 } rv = v3 - Xfree(tls, *(*uintptr)(unsafe.Pointer(line))) - *(*uintptr)(unsafe.Pointer(line)) = uintptr(0) + Xfree(tls, **(**uintptr)(__ccgo_up(line))) + **(**uintptr)(__ccgo_up(line)) = uintptr(0) pw = uintptr(0) break } - *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(line)) + uintptr(l-int64(1)))) = 0 - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(line)) - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(line)) + uintptr(l-int64(1)))) = 0 + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(line)) + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = v4 - v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v4 + v4 = Xstrchr(tls, **(**uintptr)(__ccgo_up(bp)), int32(':')) + **(**uintptr)(__ccgo_up(bp)) = v4 if !(v4 != 0) { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*int8)(unsafe.Pointer(v4)) = 0 - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = *(*uintptr)(unsafe.Pointer(bp)) - v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v4 + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**int8)(__ccgo_up(v4)) = 0 + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = **(**uintptr)(__ccgo_up(bp)) + v4 = Xstrchr(tls, **(**uintptr)(__ccgo_up(bp)), int32(':')) + **(**uintptr)(__ccgo_up(bp)) = v4 if !(v4 != 0) { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*int8)(unsafe.Pointer(v4)) = 0 + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**int8)(__ccgo_up(v4)) = 0 (*Tpasswd)(unsafe.Pointer(pw)).Fpw_uid = _atou1(tls, bp) - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32(':') { + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) != int32(':') { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*int8)(unsafe.Pointer(v4)) = 0 + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**int8)(__ccgo_up(v4)) = 0 (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gid = _atou1(tls, bp) - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32(':') { + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) != int32(':') { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*int8)(unsafe.Pointer(v4)) = 0 - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = *(*uintptr)(unsafe.Pointer(bp)) - v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v4 + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**int8)(__ccgo_up(v4)) = 0 + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = **(**uintptr)(__ccgo_up(bp)) + v4 = Xstrchr(tls, **(**uintptr)(__ccgo_up(bp)), int32(':')) + **(**uintptr)(__ccgo_up(bp)) = v4 if !(v4 != 0) { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*int8)(unsafe.Pointer(v4)) = 0 - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = *(*uintptr)(unsafe.Pointer(bp)) - v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v4 + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**int8)(__ccgo_up(v4)) = 0 + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = **(**uintptr)(__ccgo_up(bp)) + v4 = Xstrchr(tls, **(**uintptr)(__ccgo_up(bp)), int32(':')) + **(**uintptr)(__ccgo_up(bp)) = v4 if !(v4 != 0) { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*int8)(unsafe.Pointer(v4)) = 0 - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = *(*uintptr)(unsafe.Pointer(bp)) + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**int8)(__ccgo_up(v4)) = 0 + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = **(**uintptr)(__ccgo_up(bp)) break goto _1 _1: } - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 8)), uintptr(0)) - *(*uintptr)(unsafe.Pointer(res)) = pw + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 8)), uintptr(0)) + **(**uintptr)(__ccgo_up(res)) = pw if rv != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = rv + **(**int32)(__ccgo_up(X__errno_location(tls))) = rv } return rv } @@ -126424,7 +126424,7 @@ func X__nscd_query(tls *TLS, req Tint32_t, key uintptr, buf uintptr, len1 Tsize_ var _ /* req_buf at bp+32 */ [3]Tint32_t _, _, _, _, _, _, _ = errno_save, f, fd, i, v1, v3, v4 f = uintptr(0) - *(*[3]Tint32_t)(unsafe.Pointer(bp + 32)) = [3]Tint32_t{ + **(**[3]Tint32_t)(__ccgo_up(bp + 32)) = [3]Tint32_t{ 0: int32(NSCDVERSION), 1: req, 2: Int32FromUint64(Xstrnlen(tls, key, uint64(LOGIN_NAME_MAX)) + uint64(1)), @@ -126439,23 +126439,23 @@ func X__nscd_query(tls *TLS, req Tint32_t, key uintptr, buf uintptr, len1 Tsize_ Fiov_len: _strlen(tls, key) + uint64(1), }, } - *(*Tmsghdr)(unsafe.Pointer(bp + 48)) = Tmsghdr{ + **(**Tmsghdr)(__ccgo_up(bp + 48)) = Tmsghdr{ Fmsg_iov: bp, Fmsg_iovlen: int32(2), } - errno_save = *(*int32)(unsafe.Pointer(X__errno_location(tls))) - *(*int32)(unsafe.Pointer(swap)) = 0 + errno_save = **(**int32)(__ccgo_up(X__errno_location(tls))) + **(**int32)(__ccgo_up(swap)) = 0 goto retry retry: ; Xmemset(tls, buf, 0, len1) - *(*Tint32_t)(unsafe.Pointer(buf)) = int32(NSCDVERSION) + **(**Tint32_t)(__ccgo_up(buf)) = int32(NSCDVERSION) fd = Xsocket(tls, int32(PF_LOCAL), Int32FromInt32(SOCK_STREAM)|Int32FromInt32(SOCK_CLOEXEC), 0) if fd < 0 { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EAFNOSUPPORT) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EAFNOSUPPORT) { f = Xfopen(tls, __ccgo_ts+1275, __ccgo_ts+1285) if f != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = errno_save + **(**int32)(__ccgo_up(X__errno_location(tls))) = errno_save } return f } @@ -126467,7 +126467,7 @@ retry: Xclose(tls, fd) return uintptr(0) } - if (*(*[3]Tint32_t)(unsafe.Pointer(bp + 32)))[int32(2)] > int32(LOGIN_NAME_MAX) { + if (**(**[3]Tint32_t)(__ccgo_up(bp + 32)))[int32(2)] > int32(LOGIN_NAME_MAX) { return f } if Xconnect(tls, fd, uintptr(unsafe.Pointer(&_addr)), uint32(24)) < 0 { @@ -126475,8 +126475,8 @@ retry: * result and the caller is responsible for calling * fclose on the (unconnected) socket. The value of * errno must be left unchanged in this case. */ - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EACCES) || *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ECONNREFUSED) || *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENOENT) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = errno_save + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EACCES) || **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ECONNREFUSED) || **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENOENT) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = errno_save return f } goto error @@ -126493,41 +126493,41 @@ retry: if Xferror(tls, f) != 0 { goto error } - if !(*(*int32)(unsafe.Pointer(swap)) != 0) { + if !(**(**int32)(__ccgo_up(swap)) != 0) { Xfclose(tls, f) i = uint64(0) for { if !(i < Uint64FromInt64(12)/Uint64FromInt64(4)) { break } - v3 = Uint32FromInt32((*(*[3]Tint32_t)(unsafe.Pointer(bp + 32)))[i]) + v3 = Uint32FromInt32((**(**[3]Tint32_t)(__ccgo_up(bp + 32)))[i]) v4 = v3>>int32(24) | v3>>int32(8)&uint32(0xff00) | v3<>int32(24) | v3>>int32(8)&uint32(0xff00) | v3<> int32(16)) - *(*uint16)(unsafe.Pointer(xi + 2*2)) = uint16(x >> int32(32)) + x = uint64(uint32(**(**uint16)(__ccgo_up(xi)))|(uint32(**(**uint16)(__ccgo_up(xi + 1*2)))+0)<> int32(16)) + **(**uint16)(__ccgo_up(xi + 2*2)) = uint16(x >> int32(32)) return x & uint64(0xffffffffffff) } @@ -126837,8 +126837,8 @@ func Xrand_r(tls *TLS, seed uintptr) (r int32) { } var v1 uint32 _ = v1 - v1 = *(*uint32)(unsafe.Pointer(seed))*Uint32FromInt32(1103515245) + Uint32FromInt32(12345) - *(*uint32)(unsafe.Pointer(seed)) = v1 + v1 = **(**uint32)(__ccgo_up(seed))*Uint32FromInt32(1103515245) + Uint32FromInt32(12345) + **(**uint32)(__ccgo_up(seed)) = v1 return Int32FromUint32(_temper(tls, v1) / uint32(2)) } @@ -126897,15 +126897,15 @@ func _lcg64(tls *TLS, x Tuint64_t) (r Tuint64_t) { } func _savestate(tls *TLS) (r uintptr) { - *(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(-Int32FromInt32(1))*4)) = Uint32FromInt32(_n<> int32(16)) - _i = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(-Int32FromInt32(1))*4)) >> Int32FromInt32(8) & uint32(0xff)) - _j = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(-Int32FromInt32(1))*4)) & uint32(0xff)) + _n = Int32FromUint32(**(**Tuint32_t)(__ccgo_up(_x1 + uintptr(-Int32FromInt32(1))*4)) >> int32(16)) + _i = Int32FromUint32(**(**Tuint32_t)(__ccgo_up(_x1 + uintptr(-Int32FromInt32(1))*4)) >> Int32FromInt32(8) & uint32(0xff)) + _j = Int32FromUint32(**(**Tuint32_t)(__ccgo_up(_x1 + uintptr(-Int32FromInt32(1))*4)) & uint32(0xff)) } func ___srandom(tls *TLS, seed uint32) { @@ -126914,7 +126914,7 @@ func ___srandom(tls *TLS, seed uint32) { _, _, _ = k, s, v1 s = uint64(seed) if _n == 0 { - *(*Tuint32_t)(unsafe.Pointer(_x1)) = uint32(s) + **(**Tuint32_t)(__ccgo_up(_x1)) = uint32(s) return } if _n == int32(31) || _n == int32(7) { @@ -126930,14 +126930,14 @@ func ___srandom(tls *TLS, seed uint32) { break } s = _lcg64(tls, s) - *(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(k)*4)) = uint32(s >> int32(32)) + **(**Tuint32_t)(__ccgo_up(_x1 + uintptr(k)*4)) = uint32(s >> int32(32)) goto _2 _2: ; k = k + 1 } /* make sure x contains at least one odd number */ - *(*Tuint32_t)(unsafe.Pointer(_x1)) |= uint32(1) + **(**Tuint32_t)(__ccgo_up(_x1)) |= uint32(1) } func Xsrandom(tls *TLS, seed uint32) { @@ -127010,13 +127010,13 @@ func Xrandom(tls *TLS) (r int64) { _, _, _ = k, v1, v2 ___lock(tls, uintptr(unsafe.Pointer(&_lock3))) if _n == 0 { - v1 = _lcg31(tls, *(*Tuint32_t)(unsafe.Pointer(_x1))) - *(*Tuint32_t)(unsafe.Pointer(_x1)) = v1 + v1 = _lcg31(tls, **(**Tuint32_t)(__ccgo_up(_x1))) + **(**Tuint32_t)(__ccgo_up(_x1)) = v1 k = Int64FromUint32(v1) goto end } - *(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(_i)*4)) += *(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(_j)*4)) - k = Int64FromUint32(*(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(_i)*4)) >> int32(1)) + **(**Tuint32_t)(__ccgo_up(_x1 + uintptr(_i)*4)) += **(**Tuint32_t)(__ccgo_up(_x1 + uintptr(_j)*4)) + k = Int64FromUint32(**(**Tuint32_t)(__ccgo_up(_x1 + uintptr(_i)*4)) >> int32(1)) _i = _i + 1 v2 = _i if v2 == _n { @@ -127222,8 +127222,8 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { defer func() { Xrealloc(tls, b, 0) }() path = Xgetenv(tls, __ccgo_ts+1378) seen_eacces = 0 - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOENT) - if !(*(*int8)(unsafe.Pointer(file)) != 0) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOENT) + if !(**(**int8)(__ccgo_up(file)) != 0) { return -int32(1) } if Xstrchr(tls, file, int32('/')) != 0 { @@ -127234,7 +127234,7 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { } k = Xstrnlen(tls, file, Uint64FromInt32(Int32FromInt32(NAME_MAX)+Int32FromInt32(1))) if k > uint64(NAME_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENAMETOOLONG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENAMETOOLONG) return -int32(1) } l = Xstrnlen(tls, path, Uint64FromInt32(Int32FromInt32(PATH_MAX)-Int32FromInt32(1))) + uint64(1) @@ -127246,7 +127246,7 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { if Uint64FromInt64(int64(z)-int64(p)) >= l { v3 = z z = z + 1 - if !(*(*int8)(unsafe.Pointer(v3)) != 0) { + if !(**(**int8)(__ccgo_up(v3)) != 0) { break } goto _1 @@ -127255,7 +127255,7 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { *(*int8)(unsafe.Add(unsafe.Pointer(b), int64(z)-int64(p))) = int8('/') Xmemcpy(tls, b+uintptr(int64(z)-int64(p))+BoolUintptr(z > p), file, k+uint64(1)) Xexecve(tls, b, argv, envp) - switch *(*int32)(unsafe.Pointer(X__errno_location(tls))) { + switch **(**int32)(__ccgo_up(X__errno_location(tls))) { case int32(EACCES): seen_eacces = int32(1) fallthrough @@ -127267,7 +127267,7 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { } v3 = z z = z + 1 - if !(*(*int8)(unsafe.Pointer(v3)) != 0) { + if !(**(**int8)(__ccgo_up(v3)) != 0) { break } goto _1 @@ -127276,7 +127276,7 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { p = z } if seen_eacces != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EACCES) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EACCES) } return -int32(1) } @@ -127313,8 +127313,8 @@ func Xfexecve(tls *TLS, fd int32, argv uintptr, envp uintptr) (r1 int32) { } X__procfdname(tls, bp, Uint32FromInt32(fd)) Xexecve(tls, bp, argv, envp) - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENOENT) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EBADF) + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENOENT) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EBADF) } return -int32(1) } @@ -127551,7 +127551,7 @@ func Xposix_spawnattr_getflags(tls *TLS, attr uintptr, flags uintptr) (r int32) trc("tls=%v attr=%v flags=%v, (%v:)", tls, attr, flags, origin(2)) defer func() { trc("-> %v", r) }() } - *(*int16)(unsafe.Pointer(flags)) = int16((*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__flags) + **(**int16)(__ccgo_up(flags)) = int16((*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__flags) return 0 } @@ -127560,7 +127560,7 @@ func Xposix_spawnattr_getpgroup(tls *TLS, attr uintptr, pgrp uintptr) (r int32) trc("tls=%v attr=%v pgrp=%v, (%v:)", tls, attr, pgrp, origin(2)) defer func() { trc("-> %v", r) }() } - *(*Tpid_t)(unsafe.Pointer(pgrp)) = (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__pgrp + **(**Tpid_t)(__ccgo_up(pgrp)) = (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__pgrp return 0 } @@ -127569,7 +127569,7 @@ func Xposix_spawnattr_getsigdefault(tls *TLS, attr uintptr, def uintptr) (r int3 trc("tls=%v attr=%v def=%v, (%v:)", tls, attr, def, origin(2)) defer func() { trc("-> %v", r) }() } - *(*Tsigset_t)(unsafe.Pointer(def)) = (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__def + **(**Tsigset_t)(__ccgo_up(def)) = (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__def return 0 } @@ -127578,7 +127578,7 @@ func Xposix_spawnattr_getsigmask(tls *TLS, attr uintptr, mask uintptr) (r int32) trc("tls=%v attr=%v mask=%v, (%v:)", tls, attr, mask, origin(2)) defer func() { trc("-> %v", r) }() } - *(*Tsigset_t)(unsafe.Pointer(mask)) = (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__mask + **(**Tsigset_t)(__ccgo_up(mask)) = (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__mask return 0 } @@ -127587,7 +127587,7 @@ func Xposix_spawnattr_init(tls *TLS, attr uintptr) (r int32) { trc("tls=%v attr=%v, (%v:)", tls, attr, origin(2)) defer func() { trc("-> %v", r) }() } - *(*Tposix_spawnattr_t)(unsafe.Pointer(attr)) = Tposix_spawnattr_t{} + **(**Tposix_spawnattr_t)(__ccgo_up(attr)) = Tposix_spawnattr_t{} return 0 } @@ -127652,7 +127652,7 @@ func Xposix_spawnattr_setsigdefault(tls *TLS, attr uintptr, def uintptr) (r int3 trc("tls=%v attr=%v def=%v, (%v:)", tls, attr, def, origin(2)) defer func() { trc("-> %v", r) }() } - (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__def = *(*Tsigset_t)(unsafe.Pointer(def)) + (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__def = **(**Tsigset_t)(__ccgo_up(def)) return 0 } @@ -127661,7 +127661,7 @@ func Xposix_spawnattr_setsigmask(tls *TLS, attr uintptr, mask uintptr) (r int32) trc("tls=%v attr=%v mask=%v, (%v:)", tls, attr, mask, origin(2)) defer func() { trc("-> %v", r) }() } - (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__mask = *(*Tsigset_t)(unsafe.Pointer(mask)) + (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__mask = **(**Tsigset_t)(__ccgo_up(mask)) return 0 } @@ -127719,20 +127719,20 @@ func _str_next(tls *TLS, str uintptr, n Tsize_t, step uintptr) (r int32) { var _ /* wc at bp+0 */ Twchar_t _ = k if !(n != 0) { - *(*Tsize_t)(unsafe.Pointer(step)) = uint64(0) + **(**Tsize_t)(__ccgo_up(step)) = uint64(0) return 0 } - if Uint32FromInt8(*(*int8)(unsafe.Pointer(str))) >= uint32(128) { + if Uint32FromInt8(**(**int8)(__ccgo_up(str))) >= uint32(128) { k = Xmbtowc(tls, bp, str, n) if k < 0 { - *(*Tsize_t)(unsafe.Pointer(step)) = uint64(1) + **(**Tsize_t)(__ccgo_up(step)) = uint64(1) return -int32(1) } - *(*Tsize_t)(unsafe.Pointer(step)) = Uint64FromInt32(k) - return *(*Twchar_t)(unsafe.Pointer(bp)) + **(**Tsize_t)(__ccgo_up(step)) = Uint64FromInt32(k) + return **(**Twchar_t)(__ccgo_up(bp)) } - *(*Tsize_t)(unsafe.Pointer(step)) = uint64(1) - return int32(*(*int8)(unsafe.Pointer(str))) + **(**Tsize_t)(__ccgo_up(step)) = uint64(1) + return int32(**(**int8)(__ccgo_up(str))) } func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r int32) { @@ -127743,43 +127743,43 @@ func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r i var _ /* wc at bp+0 */ Twchar_t _, _, _, _ = esc, k, k1, z esc = 0 - if !(m != 0) || !(*(*int8)(unsafe.Pointer(pat)) != 0) { - *(*Tsize_t)(unsafe.Pointer(step)) = uint64(0) + if !(m != 0) || !(**(**int8)(__ccgo_up(pat)) != 0) { + **(**Tsize_t)(__ccgo_up(step)) = uint64(0) return END } - *(*Tsize_t)(unsafe.Pointer(step)) = uint64(1) - if int32(*(*int8)(unsafe.Pointer(pat))) == int32('\\') && *(*int8)(unsafe.Pointer(pat + 1)) != 0 && !(flags&Int32FromInt32(FNM_NOESCAPE) != 0) { - *(*Tsize_t)(unsafe.Pointer(step)) = uint64(2) + **(**Tsize_t)(__ccgo_up(step)) = uint64(1) + if int32(**(**int8)(__ccgo_up(pat))) == int32('\\') && **(**int8)(__ccgo_up(pat + 1)) != 0 && !(flags&Int32FromInt32(FNM_NOESCAPE) != 0) { + **(**Tsize_t)(__ccgo_up(step)) = uint64(2) pat = pat + 1 esc = int32(1) goto escaped } - if int32(*(*int8)(unsafe.Pointer(pat))) == int32('[') { + if int32(**(**int8)(__ccgo_up(pat))) == int32('[') { k = uint64(1) if k < m { - if int32(*(*int8)(unsafe.Pointer(pat + uintptr(k)))) == int32('^') || int32(*(*int8)(unsafe.Pointer(pat + uintptr(k)))) == int32('!') { + if int32(**(**int8)(__ccgo_up(pat + uintptr(k)))) == int32('^') || int32(**(**int8)(__ccgo_up(pat + uintptr(k)))) == int32('!') { k = k + 1 } } if k < m { - if int32(*(*int8)(unsafe.Pointer(pat + uintptr(k)))) == int32(']') { + if int32(**(**int8)(__ccgo_up(pat + uintptr(k)))) == int32(']') { k = k + 1 } } for { - if !(k < m && *(*int8)(unsafe.Pointer(pat + uintptr(k))) != 0 && int32(*(*int8)(unsafe.Pointer(pat + uintptr(k)))) != int32(']')) { + if !(k < m && **(**int8)(__ccgo_up(pat + uintptr(k))) != 0 && int32(**(**int8)(__ccgo_up(pat + uintptr(k)))) != int32(']')) { break } - if k+uint64(1) < m && *(*int8)(unsafe.Pointer(pat + uintptr(k+uint64(1)))) != 0 && int32(*(*int8)(unsafe.Pointer(pat + uintptr(k)))) == int32('[') && (int32(*(*int8)(unsafe.Pointer(pat + uintptr(k+uint64(1))))) == int32(':') || int32(*(*int8)(unsafe.Pointer(pat + uintptr(k+uint64(1))))) == int32('.') || int32(*(*int8)(unsafe.Pointer(pat + uintptr(k+uint64(1))))) == int32('=')) { - z = int32(*(*int8)(unsafe.Pointer(pat + uintptr(k+uint64(1))))) + if k+uint64(1) < m && **(**int8)(__ccgo_up(pat + uintptr(k+uint64(1)))) != 0 && int32(**(**int8)(__ccgo_up(pat + uintptr(k)))) == int32('[') && (int32(**(**int8)(__ccgo_up(pat + uintptr(k+uint64(1))))) == int32(':') || int32(**(**int8)(__ccgo_up(pat + uintptr(k+uint64(1))))) == int32('.') || int32(**(**int8)(__ccgo_up(pat + uintptr(k+uint64(1))))) == int32('=')) { + z = int32(**(**int8)(__ccgo_up(pat + uintptr(k+uint64(1))))) k = k + uint64(2) - if k < m && *(*int8)(unsafe.Pointer(pat + uintptr(k))) != 0 { + if k < m && **(**int8)(__ccgo_up(pat + uintptr(k))) != 0 { k = k + 1 } - for k < m && *(*int8)(unsafe.Pointer(pat + uintptr(k))) != 0 && (int32(*(*int8)(unsafe.Pointer(pat + uintptr(k-uint64(1))))) != z || int32(*(*int8)(unsafe.Pointer(pat + uintptr(k)))) != int32(']')) { + for k < m && **(**int8)(__ccgo_up(pat + uintptr(k))) != 0 && (int32(**(**int8)(__ccgo_up(pat + uintptr(k-uint64(1))))) != z || int32(**(**int8)(__ccgo_up(pat + uintptr(k)))) != int32(']')) { k = k + 1 } - if k == m || !(*(*int8)(unsafe.Pointer(pat + uintptr(k))) != 0) { + if k == m || !(**(**int8)(__ccgo_up(pat + uintptr(k))) != 0) { break } } @@ -127788,32 +127788,32 @@ func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r i ; k = k + 1 } - if k == m || !(*(*int8)(unsafe.Pointer(pat + uintptr(k))) != 0) { - *(*Tsize_t)(unsafe.Pointer(step)) = uint64(1) + if k == m || !(**(**int8)(__ccgo_up(pat + uintptr(k))) != 0) { + **(**Tsize_t)(__ccgo_up(step)) = uint64(1) return int32('[') } - *(*Tsize_t)(unsafe.Pointer(step)) = k + uint64(1) + **(**Tsize_t)(__ccgo_up(step)) = k + uint64(1) return -int32(3) } - if int32(*(*int8)(unsafe.Pointer(pat))) == int32('*') { + if int32(**(**int8)(__ccgo_up(pat))) == int32('*') { return -int32(5) } - if int32(*(*int8)(unsafe.Pointer(pat))) == int32('?') { + if int32(**(**int8)(__ccgo_up(pat))) == int32('?') { return -int32(4) } goto escaped escaped: ; - if Uint32FromInt8(*(*int8)(unsafe.Pointer(pat))) >= uint32(128) { + if Uint32FromInt8(**(**int8)(__ccgo_up(pat))) >= uint32(128) { k1 = Xmbtowc(tls, bp, pat, m) if k1 < 0 { - *(*Tsize_t)(unsafe.Pointer(step)) = uint64(0) + **(**Tsize_t)(__ccgo_up(step)) = uint64(0) return -int32(2) } - *(*Tsize_t)(unsafe.Pointer(step)) = Uint64FromInt32(k1 + esc) - return *(*Twchar_t)(unsafe.Pointer(bp)) + **(**Tsize_t)(__ccgo_up(step)) = Uint64FromInt32(k1 + esc) + return **(**Twchar_t)(__ccgo_up(bp)) } - return int32(*(*int8)(unsafe.Pointer(pat))) + return int32(**(**int8)(__ccgo_up(pat))) } func _casefold(tls *TLS, k int32) (r int32) { @@ -127840,59 +127840,59 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { _, _, _, _, _ = inv, l, l1, p0, z inv = 0 p = p + 1 - if int32(*(*int8)(unsafe.Pointer(p))) == int32('^') || int32(*(*int8)(unsafe.Pointer(p))) == int32('!') { + if int32(**(**int8)(__ccgo_up(p))) == int32('^') || int32(**(**int8)(__ccgo_up(p))) == int32('!') { inv = int32(1) p = p + 1 } - if int32(*(*int8)(unsafe.Pointer(p))) == int32(']') { + if int32(**(**int8)(__ccgo_up(p))) == int32(']') { if k == int32(']') { return BoolInt32(!(inv != 0)) } p = p + 1 } else { - if int32(*(*int8)(unsafe.Pointer(p))) == int32('-') { + if int32(**(**int8)(__ccgo_up(p))) == int32('-') { if k == int32('-') { return BoolInt32(!(inv != 0)) } p = p + 1 } } - *(*Twchar_t)(unsafe.Pointer(bp)) = int32(*(*int8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) + **(**Twchar_t)(__ccgo_up(bp)) = int32(**(**int8)(__ccgo_up(p + uintptr(-Int32FromInt32(1))))) for { - if !(int32(*(*int8)(unsafe.Pointer(p))) != int32(']')) { + if !(int32(**(**int8)(__ccgo_up(p))) != int32(']')) { break } - if int32(*(*int8)(unsafe.Pointer(p))) == int32('-') && int32(*(*int8)(unsafe.Pointer(p + 1))) != int32(']') { + if int32(**(**int8)(__ccgo_up(p))) == int32('-') && int32(**(**int8)(__ccgo_up(p + 1))) != int32(']') { l = Xmbtowc(tls, bp+4, p+uintptr(1), uint64(4)) if l < 0 { return 0 } - if *(*Twchar_t)(unsafe.Pointer(bp)) <= *(*Twchar_t)(unsafe.Pointer(bp + 4)) { - if Uint32FromInt32(k)-Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))) <= Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp + 4))-*(*Twchar_t)(unsafe.Pointer(bp))) || Uint32FromInt32(kfold)-Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))) <= Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp + 4))-*(*Twchar_t)(unsafe.Pointer(bp))) { + if **(**Twchar_t)(__ccgo_up(bp)) <= **(**Twchar_t)(__ccgo_up(bp + 4)) { + if Uint32FromInt32(k)-Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))) <= Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp + 4))-**(**Twchar_t)(__ccgo_up(bp))) || Uint32FromInt32(kfold)-Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))) <= Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp + 4))-**(**Twchar_t)(__ccgo_up(bp))) { return BoolInt32(!(inv != 0)) } } p = p + uintptr(l-int32(1)) goto _1 } - if int32(*(*int8)(unsafe.Pointer(p))) == int32('[') && (int32(*(*int8)(unsafe.Pointer(p + 1))) == int32(':') || int32(*(*int8)(unsafe.Pointer(p + 1))) == int32('.') || int32(*(*int8)(unsafe.Pointer(p + 1))) == int32('=')) { + if int32(**(**int8)(__ccgo_up(p))) == int32('[') && (int32(**(**int8)(__ccgo_up(p + 1))) == int32(':') || int32(**(**int8)(__ccgo_up(p + 1))) == int32('.') || int32(**(**int8)(__ccgo_up(p + 1))) == int32('=')) { p0 = p + uintptr(2) - z = int32(*(*int8)(unsafe.Pointer(p + 1))) + z = int32(**(**int8)(__ccgo_up(p + 1))) p = p + uintptr(3) - for int32(*(*int8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) != z || int32(*(*int8)(unsafe.Pointer(p))) != int32(']') { + for int32(**(**int8)(__ccgo_up(p + uintptr(-Int32FromInt32(1))))) != z || int32(**(**int8)(__ccgo_up(p))) != int32(']') { p = p + 1 } if z == int32(':') && int64(p-uintptr(1))-int64(p0) < int64(16) { Xmemcpy(tls, bp+8, p0, Uint64FromInt64(int64(p-uintptr(1))-int64(p0))) - (*(*[16]int8)(unsafe.Pointer(bp + 8)))[int64(p-uintptr(1))-int64(p0)] = 0 + (**(**[16]int8)(__ccgo_up(bp + 8)))[int64(p-uintptr(1))-int64(p0)] = 0 if Xiswctype(tls, Uint32FromInt32(k), Xwctype(tls, bp+8)) != 0 || Xiswctype(tls, Uint32FromInt32(kfold), Xwctype(tls, bp+8)) != 0 { return BoolInt32(!(inv != 0)) } } goto _1 } - if Uint32FromInt8(*(*int8)(unsafe.Pointer(p))) < uint32(128) { - *(*Twchar_t)(unsafe.Pointer(bp)) = Int32FromUint8(Uint8FromInt8(*(*int8)(unsafe.Pointer(p)))) + if Uint32FromInt8(**(**int8)(__ccgo_up(p))) < uint32(128) { + **(**Twchar_t)(__ccgo_up(bp)) = Int32FromUint8(Uint8FromInt8(**(**int8)(__ccgo_up(p)))) } else { l1 = Xmbtowc(tls, bp, p, uint64(4)) if l1 < 0 { @@ -127900,7 +127900,7 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { } p = p + uintptr(l1-int32(1)) } - if *(*Twchar_t)(unsafe.Pointer(bp)) == k || *(*Twchar_t)(unsafe.Pointer(bp)) == kfold { + if **(**Twchar_t)(__ccgo_up(bp)) == k || **(**Twchar_t)(__ccgo_up(bp)) == kfold { return BoolInt32(!(inv != 0)) } goto _1 @@ -127923,7 +127923,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, endpat, endstr, k, kfold, p, ptail, s, stail, tailcnt, v2, v6, v9 tailcnt = uint64(0) if flags&int32(FNM_PERIOD) != 0 { - if int32(*(*int8)(unsafe.Pointer(str))) == int32('.') && int32(*(*int8)(unsafe.Pointer(pat))) != int32('.') { + if int32(**(**int8)(__ccgo_up(str))) == int32('.') && int32(**(**int8)(__ccgo_up(pat))) != int32('.') { return int32(FNM_NOMATCH) } } @@ -127946,8 +127946,8 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, } return v2 } - str = str + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) - n = n - *(*Tsize_t)(unsafe.Pointer(bp + 8)) + str = str + uintptr(**(**Tsize_t)(__ccgo_up(bp + 8))) + n = n - **(**Tsize_t)(__ccgo_up(bp + 8)) if flags&int32(FNM_CASEFOLD) != 0 { v2 = _casefold(tls, k) } else { @@ -127963,8 +127963,8 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, return int32(FNM_NOMATCH) } } - pat = pat + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) - m = m - *(*Tsize_t)(unsafe.Pointer(bp)) + pat = pat + uintptr(**(**Tsize_t)(__ccgo_up(bp))) + m = m - **(**Tsize_t)(__ccgo_up(bp)) goto _1 } break @@ -127995,7 +127995,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, goto _5 _5: ; - p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(**(**Tsize_t)(__ccgo_up(bp))) } /* Past this point we need not check for UNMATCHABLE in pat, * because all of pat has already been parsed once. */ @@ -128013,8 +128013,8 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, if !(s > str && tailcnt != 0) { break } - if v9 = Uint32FromInt8(*(*int8)(unsafe.Pointer(s + uintptr(-Int32FromInt32(1))))) < uint32(128); !v9 { - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if v9 = Uint32FromInt8(**(**int8)(__ccgo_up(s + uintptr(-Int32FromInt32(1))))) < uint32(128); !v9 { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v2 = int32(4) } else { v2 = int32(1) @@ -128026,7 +128026,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, for { s = s - 1 v6 = s - if !(uint32(Uint8FromInt8(*(*int8)(unsafe.Pointer(v6))))-uint32(0x80) < uint32(0x40) && s > str) { + if !(uint32(Uint8FromInt8(**(**int8)(__ccgo_up(v6))))-uint32(0x80) < uint32(0x40) && s > str) { break } } @@ -128044,7 +128044,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, p = ptail for { c = _pat_next(tls, p, Uint64FromInt64(int64(endpat)-int64(p)), bp, flags) - p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(**(**Tsize_t)(__ccgo_up(bp))) v2 = _str_next(tls, s, Uint64FromInt64(int64(endstr)-int64(s)), bp+8) k = v2 if v2 <= 0 { @@ -128053,7 +128053,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, } break } - s = s + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) + s = s + uintptr(**(**Tsize_t)(__ccgo_up(bp + 8))) if flags&int32(FNM_CASEFOLD) != 0 { v2 = _casefold(tls, k) } else { @@ -128061,7 +128061,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, } kfold = v2 if c == -int32(3) { - if !(_match_bracket(tls, p-uintptr(*(*Tsize_t)(unsafe.Pointer(bp))), k, kfold) != 0) { + if !(_match_bracket(tls, p-uintptr(**(**Tsize_t)(__ccgo_up(bp))), k, kfold) != 0) { return int32(FNM_NOMATCH) } } else { @@ -128081,7 +128081,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, s = str for { c = _pat_next(tls, p, Uint64FromInt64(int64(endpat)-int64(p)), bp, flags) - p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(**(**Tsize_t)(__ccgo_up(bp))) /* Encountering * completes/commits a component */ if c == -int32(5) { pat = p @@ -128099,7 +128099,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, } kfold = v2 if c == -int32(3) { - if !(_match_bracket(tls, p-uintptr(*(*Tsize_t)(unsafe.Pointer(bp))), k, kfold) != 0) { + if !(_match_bracket(tls, p-uintptr(**(**Tsize_t)(__ccgo_up(bp))), k, kfold) != 0) { break } } else { @@ -128107,7 +128107,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, break } } - s = s + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) + s = s + uintptr(**(**Tsize_t)(__ccgo_up(bp + 8))) goto _14 _14: } @@ -128118,7 +128118,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, * char, or past all invalid bytes otherwise. */ k = _str_next(tls, str, Uint64FromInt64(int64(endstr)-int64(str)), bp+8) if k > 0 { - str = str + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) + str = str + uintptr(**(**Tsize_t)(__ccgo_up(bp + 8))) } else { str = str + 1 for { @@ -128150,7 +128150,7 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { for { s = str for { - if !(*(*int8)(unsafe.Pointer(s)) != 0 && int32(*(*int8)(unsafe.Pointer(s))) != int32('/')) { + if !(**(**int8)(__ccgo_up(s)) != 0 && int32(**(**int8)(__ccgo_up(s))) != int32('/')) { break } goto _2 @@ -128168,9 +128168,9 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { goto _3 _3: ; - p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(**(**Tsize_t)(__ccgo_up(bp))) } - if c != int32(*(*int8)(unsafe.Pointer(s))) && (!(*(*int8)(unsafe.Pointer(s)) != 0) || !(flags&Int32FromInt32(FNM_LEADING_DIR) != 0)) { + if c != int32(**(**int8)(__ccgo_up(s))) && (!(**(**int8)(__ccgo_up(s)) != 0) || !(flags&Int32FromInt32(FNM_LEADING_DIR) != 0)) { return int32(FNM_NOMATCH) } if _fnmatch_internal(tls, pat, Uint64FromInt64(int64(p)-int64(pat)), str, Uint64FromInt64(int64(s)-int64(str)), flags) != 0 { @@ -128180,7 +128180,7 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { return 0 } str = s + uintptr(1) - pat = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + pat = p + uintptr(**(**Tsize_t)(__ccgo_up(bp))) goto _1 _1: } @@ -128188,10 +128188,10 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { if flags&int32(FNM_LEADING_DIR) != 0 { s = str for { - if !(*(*int8)(unsafe.Pointer(s)) != 0) { + if !(**(**int8)(__ccgo_up(s)) != 0) { break } - if int32(*(*int8)(unsafe.Pointer(s))) != int32('/') { + if int32(**(**int8)(__ccgo_up(s))) != int32('/') { goto _5 } if !(_fnmatch_internal(tls, pat, Uint64FromInt32(-Int32FromInt32(1)), str, Uint64FromInt64(int64(s)-int64(str)), flags) != 0) { @@ -128241,14 +128241,14 @@ func _append(tls *TLS, tail uintptr, name uintptr, len1 Tsize_t, mark int32) (r if !(new1 != 0) { return -int32(1) } - (*Tmatch)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tail)))).Fnext = new1 + (*Tmatch)(unsafe.Pointer(**(**uintptr)(__ccgo_up(tail)))).Fnext = new1 (*Tmatch)(unsafe.Pointer(new1)).Fnext = UintptrFromInt32(0) Xmemcpy(tls, new1+8, name, len1+uint64(1)) - if mark != 0 && len1 != 0 && int32(*(*int8)(unsafe.Pointer(name + uintptr(len1-uint64(1))))) != int32('/') { + if mark != 0 && len1 != 0 && int32(**(**int8)(__ccgo_up(name + uintptr(len1-uint64(1))))) != int32('/') { *(*int8)(unsafe.Pointer(new1 + 8 + uintptr(len1))) = int8('/') *(*int8)(unsafe.Pointer(new1 + 8 + uintptr(len1+uint64(1)))) = 0 } - *(*uintptr)(unsafe.Pointer(tail)) = new1 + **(**uintptr)(__ccgo_up(tail)) = new1 return 0 } @@ -128268,15 +128268,15 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag } /* Special-case the remaining pattern being all slashes, in * which case we can use caller-passed type if it's a dir. */ - if *(*int8)(unsafe.Pointer(pat)) != 0 && type1 != int32(DT_DIR) { + if **(**int8)(__ccgo_up(pat)) != 0 && type1 != int32(DT_DIR) { type1 = 0 } - for pos+uint64(1) < uint64(PATH_MAX) && int32(*(*int8)(unsafe.Pointer(pat))) == int32('/') { + for pos+uint64(1) < uint64(PATH_MAX) && int32(**(**int8)(__ccgo_up(pat))) == int32('/') { v1 = pos pos = pos + 1 v2 = pat pat = pat + 1 - *(*int8)(unsafe.Pointer(buf + uintptr(v1))) = *(*int8)(unsafe.Pointer(v2)) + **(**int8)(__ccgo_up(buf + uintptr(v1))) = **(**int8)(__ccgo_up(v2)) } /* Consume maximal [escaped-]literal prefix of pattern, copying * and un-escaping it to the running buffer as we go. */ @@ -128285,10 +128285,10 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag in_bracket = 0 overflow = 0 for { - if !(int32(*(*int8)(unsafe.Pointer(pat + uintptr(i)))) != int32('*') && int32(*(*int8)(unsafe.Pointer(pat + uintptr(i)))) != int32('?') && (!(in_bracket != 0) || int32(*(*int8)(unsafe.Pointer(pat + uintptr(i)))) != int32(']'))) { + if !(int32(**(**int8)(__ccgo_up(pat + uintptr(i)))) != int32('*') && int32(**(**int8)(__ccgo_up(pat + uintptr(i)))) != int32('?') && (!(in_bracket != 0) || int32(**(**int8)(__ccgo_up(pat + uintptr(i)))) != int32(']'))) { break } - if !(*(*int8)(unsafe.Pointer(pat + uintptr(i))) != 0) { + if !(**(**int8)(__ccgo_up(pat + uintptr(i))) != 0) { if overflow != 0 { return 0 } @@ -128299,25 +128299,25 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag i = v4 break } else { - if int32(*(*int8)(unsafe.Pointer(pat + uintptr(i)))) == int32('[') { + if int32(**(**int8)(__ccgo_up(pat + uintptr(i)))) == int32('[') { in_bracket = int32(1) } else { - if int32(*(*int8)(unsafe.Pointer(pat + uintptr(i)))) == int32('\\') && !(flags&Int32FromInt32(GLOB_NOESCAPE) != 0) { + if int32(**(**int8)(__ccgo_up(pat + uintptr(i)))) == int32('\\') && !(flags&Int32FromInt32(GLOB_NOESCAPE) != 0) { /* Backslashes inside a bracket are (at least by * our interpretation) non-special, so if next * char is ']' we have a complete expression. */ - if in_bracket != 0 && int32(*(*int8)(unsafe.Pointer(pat + uintptr(i+int64(1))))) == int32(']') { + if in_bracket != 0 && int32(**(**int8)(__ccgo_up(pat + uintptr(i+int64(1))))) == int32(']') { break } /* Unpaired final backslash never matches. */ - if !(*(*int8)(unsafe.Pointer(pat + uintptr(i+int64(1)))) != 0) { + if !(**(**int8)(__ccgo_up(pat + uintptr(i+int64(1)))) != 0) { return 0 } i = i + 1 } } } - if int32(*(*int8)(unsafe.Pointer(pat + uintptr(i)))) == int32('/') { + if int32(**(**int8)(__ccgo_up(pat + uintptr(i)))) == int32('/') { if overflow != 0 { return 0 } @@ -128335,7 +128335,7 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag if pos+Uint64FromInt64(j+Int64FromInt32(1)) < uint64(PATH_MAX) { v4 = j j = j + 1 - *(*int8)(unsafe.Pointer(buf + uintptr(pos+Uint64FromInt64(v4)))) = *(*int8)(unsafe.Pointer(pat + uintptr(i))) + **(**int8)(__ccgo_up(buf + uintptr(pos+Uint64FromInt64(v4)))) = **(**int8)(__ccgo_up(pat + uintptr(i))) } else { if in_bracket != 0 { overflow = int32(1) @@ -128351,17 +128351,17 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag ; i = i + 1 } - *(*int8)(unsafe.Pointer(buf + uintptr(pos))) = 0 - if !(*(*int8)(unsafe.Pointer(pat)) != 0) { + **(**int8)(__ccgo_up(buf + uintptr(pos))) = 0 + if !(**(**int8)(__ccgo_up(pat)) != 0) { if flags&int32(GLOB_MARK) != 0 && (!(type1 != 0) || type1 == int32(DT_LNK)) && !(Xstat(tls, buf, bp) != 0) { - if (*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFDIR) { + if (**(**Tstat)(__ccgo_up(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFDIR) { type1 = int32(DT_DIR) } else { type1 = int32(DT_REG) } } if !(type1 != 0) && Xlstat(tls, buf, bp) != 0 { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(ENOENT) && ((*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(ENOENT) && ((*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, **(**int32)(__ccgo_up(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0) { return int32(GLOB_ABORTED) } return 0 @@ -128378,7 +128378,7 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag if p2 != 0 && !(flags&Int32FromInt32(GLOB_NOESCAPE) != 0) { p = p2 for { - if !(p > pat && int32(*(*int8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) == int32('\\')) { + if !(p > pat && int32(**(**int8)(__ccgo_up(p + uintptr(-Int32FromInt32(1))))) == int32('\\')) { break } goto _6 @@ -128398,14 +128398,14 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag } dir = Xopendir(tls, v2) if !(dir != 0) { - if (*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0 { + if (*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, **(**int32)(__ccgo_up(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0 { return int32(GLOB_ABORTED) } return 0 } - old_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + old_errno = **(**int32)(__ccgo_up(X__errno_location(tls))) for { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = 0 + **(**int32)(__ccgo_up(X__errno_location(tls))) = 0 v2 = Xreaddir(tls, dir) de = v2 if !(v2 != 0) { @@ -128420,7 +128420,7 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag continue } if p2 != 0 { - *(*int8)(unsafe.Pointer(p2)) = 0 + **(**int8)(__ccgo_up(p2)) = 0 } if flags&int32(GLOB_NOESCAPE) != 0 { v9 = int32(FNM_NOESCAPE) @@ -128438,12 +128438,12 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag } /* With GLOB_PERIOD, don't allow matching . or .. unless * fnmatch would match them with FNM_PERIOD rules in effect. */ - if p2 != 0 && flags&int32(GLOB_PERIOD) != 0 && int32(*(*int8)(unsafe.Pointer(de + 19))) == int32('.') && (!(*(*int8)(unsafe.Pointer(de + 19 + 1)) != 0) || int32(*(*int8)(unsafe.Pointer(de + 19 + 1))) == int32('.') && !(*(*int8)(unsafe.Pointer(de + 19 + 2)) != 0)) && Xfnmatch(tls, pat, de+19, fnm_flags|int32(FNM_PERIOD)) != 0 { + if p2 != 0 && flags&int32(GLOB_PERIOD) != 0 && int32(**(**int8)(__ccgo_up(de + 19))) == int32('.') && (!(**(**int8)(__ccgo_up(de + 19 + 1)) != 0) || int32(**(**int8)(__ccgo_up(de + 19 + 1))) == int32('.') && !(**(**int8)(__ccgo_up(de + 19 + 2)) != 0)) && Xfnmatch(tls, pat, de+19, fnm_flags|int32(FNM_PERIOD)) != 0 { continue } Xmemcpy(tls, buf+uintptr(pos), de+19, l+uint64(1)) if p2 != 0 { - *(*int8)(unsafe.Pointer(p2)) = saved_sep + **(**int8)(__ccgo_up(p2)) = saved_sep } if p2 != 0 { v2 = p2 @@ -128456,15 +128456,15 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag return r } } - readerr = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + readerr = **(**int32)(__ccgo_up(X__errno_location(tls))) if p2 != 0 { - *(*int8)(unsafe.Pointer(p2)) = saved_sep + **(**int8)(__ccgo_up(p2)) = saved_sep } Xclosedir(tls, dir) - if readerr != 0 && ((*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0) { + if readerr != 0 && ((*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, **(**int32)(__ccgo_up(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0) { return int32(GLOB_ABORTED) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = old_errno + **(**int32)(__ccgo_up(X__errno_location(tls))) = old_errno return 0 } @@ -128490,7 +128490,7 @@ func _freelist(tls *TLS, head uintptr) { } func _sort(tls *TLS, a uintptr, b uintptr) (r int32) { - return Xstrcmp(tls, *(*uintptr)(unsafe.Pointer(a)), *(*uintptr)(unsafe.Pointer(b))) + return Xstrcmp(tls, **(**uintptr)(__ccgo_up(a)), **(**uintptr)(__ccgo_up(b))) } func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { @@ -128503,25 +128503,25 @@ func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { var _ /* pw at bp+0 */ Tpasswd var _ /* res at bp+48 */ uintptr _, _, _, _, _, _, _, _, _ = delim, home, i, name_end, p, v1, v10, v2, v4 - p = *(*uintptr)(unsafe.Pointer(pat)) + uintptr(1) + p = **(**uintptr)(__ccgo_up(pat)) + uintptr(1) i = uint64(0) name_end = X__strchrnul(tls, p, int32('/')) - v1 = *(*int8)(unsafe.Pointer(name_end)) + v1 = **(**int8)(__ccgo_up(name_end)) delim = v1 if v1 != 0 { v2 = name_end name_end = name_end + 1 - *(*int8)(unsafe.Pointer(v2)) = 0 + **(**int8)(__ccgo_up(v2)) = 0 } - *(*uintptr)(unsafe.Pointer(pat)) = name_end - if *(*int8)(unsafe.Pointer(p)) != 0 { + **(**uintptr)(__ccgo_up(pat)) = name_end + if **(**int8)(__ccgo_up(p)) != 0 { v2 = UintptrFromInt32(0) } else { v2 = Xgetenv(tls, __ccgo_ts+1412) } home = v2 if !(home != 0) { - if *(*int8)(unsafe.Pointer(p)) != 0 { + if **(**int8)(__ccgo_up(p)) != 0 { v4 = Xgetpwnam_r(tls, p, bp, buf, uint64(PATH_MAX), bp+48) } else { v4 = Xgetpwuid_r(tls, Xgetuid(tls), bp, buf, uint64(PATH_MAX), bp+48) @@ -128540,7 +128540,7 @@ func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { return int32(GLOB_NOSPACE) _7: ; - if !!(*(*uintptr)(unsafe.Pointer(bp + 48)) != 0) { + if !!(**(**uintptr)(__ccgo_up(bp + 48)) != 0) { goto _9 } _6: @@ -128550,26 +128550,26 @@ func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { ; _8: ; - home = (*(*Tpasswd)(unsafe.Pointer(bp))).Fpw_dir + home = (**(**Tpasswd)(__ccgo_up(bp))).Fpw_dir } - for i < Uint64FromInt32(Int32FromInt32(PATH_MAX)-Int32FromInt32(2)) && *(*int8)(unsafe.Pointer(home)) != 0 { + for i < Uint64FromInt32(Int32FromInt32(PATH_MAX)-Int32FromInt32(2)) && **(**int8)(__ccgo_up(home)) != 0 { v10 = i i = i + 1 v2 = home home = home + 1 - *(*int8)(unsafe.Pointer(buf + uintptr(v10))) = *(*int8)(unsafe.Pointer(v2)) + **(**int8)(__ccgo_up(buf + uintptr(v10))) = **(**int8)(__ccgo_up(v2)) } - if *(*int8)(unsafe.Pointer(home)) != 0 { + if **(**int8)(__ccgo_up(home)) != 0 { return int32(GLOB_NOMATCH) } v1 = delim - *(*int8)(unsafe.Pointer(buf + uintptr(i))) = v1 + **(**int8)(__ccgo_up(buf + uintptr(i))) = v1 if v1 != 0 { i = i + 1 v10 = i - *(*int8)(unsafe.Pointer(buf + uintptr(v10))) = 0 + **(**int8)(__ccgo_up(buf + uintptr(v10))) = 0 } - *(*Tsize_t)(unsafe.Pointer(pos)) = i + **(**Tsize_t)(__ccgo_up(pos)) = i return 0 } @@ -128592,10 +128592,10 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint var _ /* s at bp+4120 */ uintptr var _ /* tail at bp+8 */ uintptr _, _, _, _, _, _, _ = cnt, error1, i, offs, p, pathv, v1 - *(*Tmatch)(unsafe.Pointer(bp)) = struct { + **(**Tmatch)(__ccgo_up(bp)) = struct { Fnext uintptr }{} - *(*uintptr)(unsafe.Pointer(bp + 8)) = bp + **(**uintptr)(__ccgo_up(bp + 8)) = bp if flags&int32(GLOB_DOOFFS) != 0 { v1 = (*Tglob_t)(unsafe.Pointer(g)).Fgl_offs } else { @@ -128611,19 +128611,19 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathc = uint64(0) (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv = UintptrFromInt32(0) } - if *(*int8)(unsafe.Pointer(pat)) != 0 { + if **(**int8)(__ccgo_up(pat)) != 0 { p = Xstrdup(tls, pat) if !(p != 0) { return int32(GLOB_NOSPACE) } - (*(*[4096]int8)(unsafe.Pointer(bp + 16)))[0] = 0 - *(*Tsize_t)(unsafe.Pointer(bp + 4112)) = uint64(0) - *(*uintptr)(unsafe.Pointer(bp + 4120)) = p - if flags&(Int32FromInt32(GLOB_TILDE)|Int32FromInt32(GLOB_TILDE_CHECK)) != 0 && int32(*(*int8)(unsafe.Pointer(p))) == int32('~') { + (**(**[4096]int8)(__ccgo_up(bp + 16)))[0] = 0 + **(**Tsize_t)(__ccgo_up(bp + 4112)) = uint64(0) + **(**uintptr)(__ccgo_up(bp + 4120)) = p + if flags&(Int32FromInt32(GLOB_TILDE)|Int32FromInt32(GLOB_TILDE_CHECK)) != 0 && int32(**(**int8)(__ccgo_up(p))) == int32('~') { error1 = _expand_tilde(tls, bp+4120, bp+16, bp+4112) } if !(error1 != 0) { - error1 = _do_glob(tls, bp+16, *(*Tsize_t)(unsafe.Pointer(bp + 4112)), 0, *(*uintptr)(unsafe.Pointer(bp + 4120)), flags, __ccgo_fp_errfunc, bp+8) + error1 = _do_glob(tls, bp+16, **(**Tsize_t)(__ccgo_up(bp + 4112)), 0, **(**uintptr)(__ccgo_up(bp + 4120)), flags, __ccgo_fp_errfunc, bp+8) } Xfree(tls, p) } @@ -128632,20 +128632,20 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint return error1 } cnt = uint64(0) - *(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*Tmatch)(unsafe.Pointer(bp))).Fnext + **(**uintptr)(__ccgo_up(bp + 8)) = (**(**Tmatch)(__ccgo_up(bp))).Fnext for { - if !(*(*uintptr)(unsafe.Pointer(bp + 8)) != 0) { + if !(**(**uintptr)(__ccgo_up(bp + 8)) != 0) { break } goto _2 _2: ; - *(*uintptr)(unsafe.Pointer(bp + 8)) = (*Tmatch)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fnext + **(**uintptr)(__ccgo_up(bp + 8)) = (*Tmatch)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp + 8)))).Fnext cnt = cnt + 1 } if !(cnt != 0) { if flags&int32(GLOB_NOCHECK) != 0 { - *(*uintptr)(unsafe.Pointer(bp + 8)) = bp + **(**uintptr)(__ccgo_up(bp + 8)) = bp if _append(tls, bp+8, pat, _strlen(tls, pat), 0) != 0 { return int32(GLOB_NOSPACE) } @@ -128675,7 +128675,7 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint if !(i < offs) { break } - *(*uintptr)(unsafe.Pointer((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(i)*8)) = UintptrFromInt32(0) + **(**uintptr)(__ccgo_up((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(i)*8)) = UintptrFromInt32(0) goto _3 _3: ; @@ -128683,20 +128683,20 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint } } i = uint64(0) - *(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*Tmatch)(unsafe.Pointer(bp))).Fnext + **(**uintptr)(__ccgo_up(bp + 8)) = (**(**Tmatch)(__ccgo_up(bp))).Fnext for { if !(i < cnt) { break } - *(*uintptr)(unsafe.Pointer((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(offs+i)*8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + **(**uintptr)(__ccgo_up((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(offs+i)*8)) = **(**uintptr)(__ccgo_up(bp + 8)) + 8 goto _4 _4: ; - *(*uintptr)(unsafe.Pointer(bp + 8)) = (*Tmatch)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fnext + **(**uintptr)(__ccgo_up(bp + 8)) = (*Tmatch)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp + 8)))).Fnext i = i + 1 } - *(*uintptr)(unsafe.Pointer((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(offs+i)*8)) = UintptrFromInt32(0) - *(*Tsize_t)(unsafe.Pointer(g)) += cnt + **(**uintptr)(__ccgo_up((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(offs+i)*8)) = UintptrFromInt32(0) + **(**Tsize_t)(__ccgo_up(g)) += cnt if !(flags&Int32FromInt32(GLOB_NOSORT) != 0) { Xqsort(tls, (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv+uintptr(offs)*8, cnt, uint64(8), __ccgo_fp(_sort)) } @@ -128714,7 +128714,7 @@ func Xglobfree(tls *TLS, g uintptr) { if !(i < (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathc) { break } - Xfree(tls, *(*uintptr)(unsafe.Pointer((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr((*Tglob_t)(unsafe.Pointer(g)).Fgl_offs+i)*8))-uintptr(uint64(UintptrFromInt32(0)+8))) + Xfree(tls, **(**uintptr)(__ccgo_up((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr((*Tglob_t)(unsafe.Pointer(g)).Fgl_offs+i)*8))-uintptr(uint64(UintptrFromInt32(0)+8))) goto _1 _1: ; @@ -129113,7 +129113,7 @@ func _tre_stack_push(tls *TLS, s uintptr, value Ttre_stack_item) (r Treg_errcode var new_size int32 _, _ = new_buffer, new_size if (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr < (*Ttre_stack_t)(unsafe.Pointer(s)).Fsize { - *(*Ttre_stack_item)(unsafe.Pointer((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr((*Ttre_stack_t)(unsafe.Pointer(s)).Fptr)*8)) = value + **(**Ttre_stack_item)(__ccgo_up((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr((*Ttre_stack_t)(unsafe.Pointer(s)).Fptr)*8)) = value (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr = (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr + 1 } else { if (*Ttre_stack_t)(unsafe.Pointer(s)).Fsize >= (*Ttre_stack_t)(unsafe.Pointer(s)).Fmax_size { @@ -129147,7 +129147,7 @@ func _tre_stack_push_voidptr(tls *TLS, s uintptr, value uintptr) (r Treg_errcode defer tls.Free(16) var _ /* item at bp+0 */ Ttre_stack_item *(*uintptr)(unsafe.Pointer(bp)) = value - return _tre_stack_push(tls, s, *(*Ttre_stack_item)(unsafe.Pointer(bp))) + return _tre_stack_push(tls, s, **(**Ttre_stack_item)(__ccgo_up(bp))) } func _tre_stack_pop_int(tls *TLS, s uintptr) (r int32) { @@ -129157,7 +129157,7 @@ func _tre_stack_pop_int(tls *TLS, s uintptr) (r int32) { v2 = s + 12 *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) - 1 v1 = *(*int32)(unsafe.Pointer(v2)) - return *(*int32)(unsafe.Pointer(&*(*Ttre_stack_item)(unsafe.Pointer((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr(v1)*8)))) + return *(*int32)(unsafe.Pointer(&**(**Ttre_stack_item)(__ccgo_up((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr(v1)*8)))) } func _tre_stack_pop_voidptr(tls *TLS, s uintptr) (r uintptr) { @@ -129257,7 +129257,7 @@ func _tre_expand_macro(tls *TLS, s uintptr) (r uintptr) { _ = i i = 0 for { - if !(_tre_macros[i].Fc != 0 && int32(_tre_macros[i].Fc) != int32(*(*int8)(unsafe.Pointer(s)))) { + if !(_tre_macros[i].Fc != 0 && int32(_tre_macros[i].Fc) != int32(**(**int8)(__ccgo_up(s)))) { break } goto _1 @@ -129274,7 +129274,7 @@ func _tre_compare_lit(tls *TLS, a uintptr, b uintptr) (r int32) { la = a lb = b /* assumes the range of valid code_min is < INT_MAX */ - return int32((*Ttre_literal_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(la)))).Fcode_min - (*Ttre_literal_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(lb)))).Fcode_min) + return int32((*Ttre_literal_t)(unsafe.Pointer(**(**uintptr)(__ccgo_up(la)))).Fcode_min - (*Ttre_literal_t)(unsafe.Pointer(**(**uintptr)(__ccgo_up(lb)))).Fcode_min) } type Tliterals = struct { @@ -129292,7 +129292,7 @@ func _tre_new_lit(tls *TLS, p uintptr) (r uintptr) { if (*Tliterals)(unsafe.Pointer(p)).Fcap1 >= Int32FromInt32(1)< max { @@ -129484,7 +129484,7 @@ func _parse_bracket_terms(tls *TLS, ctx uintptr, s uintptr, ls uintptr, neg uint v6 = neg + 4 v2 = *(*int32)(unsafe.Pointer(v6)) *(*int32)(unsafe.Pointer(v6)) = *(*int32)(unsafe.Pointer(v6)) + 1 - *(*Ttre_ctype_t)(unsafe.Pointer(neg + 8 + uintptr(v2)*8)) = class + **(**Ttre_ctype_t)(__ccgo_up(neg + 8 + uintptr(v2)*8)) = class } else { lit = _tre_new_lit(tls, ls) if !(lit != 0) { @@ -129524,23 +129524,23 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { _, _, _, _, _, _, _, _, _, _, _ = err, i, lit, max, min, n, nc, negmax, negmin, node, v1 node = uintptr(0) nc = uintptr(0) - (*(*Tliterals)(unsafe.Pointer(bp))).Fmem = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem - (*(*Tliterals)(unsafe.Pointer(bp))).Flen1 = 0 - (*(*Tliterals)(unsafe.Pointer(bp))).Fcap1 = int32(32) - (*(*Tliterals)(unsafe.Pointer(bp))).Fa = Xmalloc(tls, Uint64FromInt32((*(*Tliterals)(unsafe.Pointer(bp))).Fcap1)*uint64(8)) - if !((*(*Tliterals)(unsafe.Pointer(bp))).Fa != 0) { + (**(**Tliterals)(__ccgo_up(bp))).Fmem = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem + (**(**Tliterals)(__ccgo_up(bp))).Flen1 = 0 + (**(**Tliterals)(__ccgo_up(bp))).Fcap1 = int32(32) + (**(**Tliterals)(__ccgo_up(bp))).Fa = Xmalloc(tls, Uint64FromInt32((**(**Tliterals)(__ccgo_up(bp))).Fcap1)*uint64(8)) + if !((**(**Tliterals)(__ccgo_up(bp))).Fa != 0) { return int32(REG_ESPACE) } - (*(*Tneg)(unsafe.Pointer(bp + 24))).Flen1 = 0 - (*(*Tneg)(unsafe.Pointer(bp + 24))).Fnegate = BoolInt32(int32(*(*int8)(unsafe.Pointer(s))) == int32('^')) - if (*(*Tneg)(unsafe.Pointer(bp + 24))).Fnegate != 0 { + (**(**Tneg)(__ccgo_up(bp + 24))).Flen1 = 0 + (**(**Tneg)(__ccgo_up(bp + 24))).Fnegate = BoolInt32(int32(**(**int8)(__ccgo_up(s))) == int32('^')) + if (**(**Tneg)(__ccgo_up(bp + 24))).Fnegate != 0 { s = s + 1 } err = _parse_bracket_terms(tls, ctx, s, bp, bp+24) if err != REG_OK { goto parse_bracket_done } - if (*(*Tneg)(unsafe.Pointer(bp + 24))).Fnegate != 0 { + if (**(**Tneg)(__ccgo_up(bp + 24))).Fnegate != 0 { /* * With REG_NEWLINE, POSIX requires that newlines are not matched by * any form of a non-matching list. @@ -129556,7 +129556,7 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition = -int32(1) } /* Sort the array if we need to negate it. */ - Xqsort(tls, (*(*Tliterals)(unsafe.Pointer(bp))).Fa, Uint64FromInt32((*(*Tliterals)(unsafe.Pointer(bp))).Flen1), uint64(8), __ccgo_fp(_tre_compare_lit)) + Xqsort(tls, (**(**Tliterals)(__ccgo_up(bp))).Fa, Uint64FromInt32((**(**Tliterals)(__ccgo_up(bp))).Flen1), uint64(8), __ccgo_fp(_tre_compare_lit)) /* extra lit for the last negated range */ lit = _tre_new_lit(tls, bp) if !(lit != 0) { @@ -129567,14 +129567,14 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max = int64(Int32FromInt32(TRE_CHAR_MAX) + Int32FromInt32(1)) (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition = -int32(1) /* negated classes */ - if (*(*Tneg)(unsafe.Pointer(bp + 24))).Flen1 != 0 { - nc = X__tre_mem_alloc_impl(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, 0, UintptrFromInt32(0), 0, Uint64FromInt32((*(*Tneg)(unsafe.Pointer(bp + 24))).Flen1+Int32FromInt32(1))*uint64(8)) + if (**(**Tneg)(__ccgo_up(bp + 24))).Flen1 != 0 { + nc = X__tre_mem_alloc_impl(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, 0, UintptrFromInt32(0), 0, Uint64FromInt32((**(**Tneg)(__ccgo_up(bp + 24))).Flen1+Int32FromInt32(1))*uint64(8)) if !(nc != 0) { err = int32(REG_ESPACE) goto parse_bracket_done } - Xmemcpy(tls, nc, bp+24+8, Uint64FromInt32((*(*Tneg)(unsafe.Pointer(bp + 24))).Flen1)*uint64(8)) - *(*Ttre_ctype_t)(unsafe.Pointer(nc + uintptr((*(*Tneg)(unsafe.Pointer(bp + 24))).Flen1)*8)) = uint64(0) + Xmemcpy(tls, nc, bp+24+8, Uint64FromInt32((**(**Tneg)(__ccgo_up(bp + 24))).Flen1)*uint64(8)) + **(**Ttre_ctype_t)(__ccgo_up(nc + uintptr((**(**Tneg)(__ccgo_up(bp + 24))).Flen1)*8)) = uint64(0) } } /* Build a union of the items in the array, negated if necessary. */ @@ -129583,13 +129583,13 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { negmax = v1 i = 0 for { - if !(i < (*(*Tliterals)(unsafe.Pointer(bp))).Flen1) { + if !(i < (**(**Tliterals)(__ccgo_up(bp))).Flen1) { break } - lit = *(*uintptr)(unsafe.Pointer((*(*Tliterals)(unsafe.Pointer(bp))).Fa + uintptr(i)*8)) + lit = **(**uintptr)(__ccgo_up((**(**Tliterals)(__ccgo_up(bp))).Fa + uintptr(i)*8)) min = int32((*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min) max = int32((*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max) - if (*(*Tneg)(unsafe.Pointer(bp + 24))).Fnegate != 0 { + if (**(**Tneg)(__ccgo_up(bp + 24))).Fnegate != 0 { if min <= negmin { /* Overlap. */ if max+int32(1) >= negmin { @@ -129621,22 +129621,22 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { goto parse_bracket_done parse_bracket_done: ; - Xfree(tls, (*(*Tliterals)(unsafe.Pointer(bp))).Fa) + Xfree(tls, (**(**Tliterals)(__ccgo_up(bp))).Fa) (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition + 1 (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = node return err } func _parse_dup_count(tls *TLS, s uintptr, n uintptr) (r uintptr) { - *(*int32)(unsafe.Pointer(n)) = -int32(1) - if !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + **(**int32)(__ccgo_up(n)) = -int32(1) + if !(BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return s } - *(*int32)(unsafe.Pointer(n)) = 0 + **(**int32)(__ccgo_up(n)) = 0 for { - *(*int32)(unsafe.Pointer(n)) = int32(10)**(*int32)(unsafe.Pointer(n)) + (int32(*(*int8)(unsafe.Pointer(s))) - int32('0')) + **(**int32)(__ccgo_up(n)) = int32(10)***(**int32)(__ccgo_up(n)) + (int32(**(**int8)(__ccgo_up(s))) - int32('0')) s = s + 1 - if !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) || *(*int32)(unsafe.Pointer(n)) > int32(RE_DUP_MAX) { + if !(BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) || **(**int32)(__ccgo_up(n)) > int32(RE_DUP_MAX) { break } goto _1 @@ -129654,26 +129654,26 @@ func _parse_dup(tls *TLS, s uintptr, ere int32, pmin uintptr, pmax uintptr) (r u var _ /* min at bp+0 */ int32 _, _, _, _, _ = v1, v2, v3, v4, v5 s = _parse_dup_count(tls, s, bp) - if int32(*(*int8)(unsafe.Pointer(s))) == int32(',') { + if int32(**(**int8)(__ccgo_up(s))) == int32(',') { s = _parse_dup_count(tls, s+uintptr(1), bp+4) } else { - *(*int32)(unsafe.Pointer(bp + 4)) = *(*int32)(unsafe.Pointer(bp)) + **(**int32)(__ccgo_up(bp + 4)) = **(**int32)(__ccgo_up(bp)) } - if v3 = *(*int32)(unsafe.Pointer(bp + 4)) < *(*int32)(unsafe.Pointer(bp)) && *(*int32)(unsafe.Pointer(bp + 4)) >= 0 || *(*int32)(unsafe.Pointer(bp + 4)) > int32(RE_DUP_MAX) || *(*int32)(unsafe.Pointer(bp)) > int32(RE_DUP_MAX) || *(*int32)(unsafe.Pointer(bp)) < 0; !v3 { + if v3 = **(**int32)(__ccgo_up(bp + 4)) < **(**int32)(__ccgo_up(bp)) && **(**int32)(__ccgo_up(bp + 4)) >= 0 || **(**int32)(__ccgo_up(bp + 4)) > int32(RE_DUP_MAX) || **(**int32)(__ccgo_up(bp)) > int32(RE_DUP_MAX) || **(**int32)(__ccgo_up(bp)) < 0; !v3 { if v2 = !(ere != 0); v2 { v1 = s s = s + 1 } } - if v5 = v3 || v2 && int32(*(*int8)(unsafe.Pointer(v1))) != int32('\\'); !v5 { + if v5 = v3 || v2 && int32(**(**int8)(__ccgo_up(v1))) != int32('\\'); !v5 { v4 = s s = s + 1 } - if v5 || int32(*(*int8)(unsafe.Pointer(v4))) != int32('}') { + if v5 || int32(**(**int8)(__ccgo_up(v4))) != int32('}') { return uintptr(0) } - *(*int32)(unsafe.Pointer(pmin)) = *(*int32)(unsafe.Pointer(bp)) - *(*int32)(unsafe.Pointer(pmax)) = *(*int32)(unsafe.Pointer(bp + 4)) + **(**int32)(__ccgo_up(pmin)) = **(**int32)(__ccgo_up(bp)) + **(**int32)(__ccgo_up(pmax)) = **(**int32)(__ccgo_up(bp + 4)) return s } @@ -129736,7 +129736,7 @@ func _parse_atom(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { var _ /* wc at bp+0 */ Twchar_t _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, ere, err, i, len1, node, p, tmp1, tmp11, tmp2, tmp21, v, val, v14, v16 ere = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fcflags & int32(REG_EXTENDED) - switch int32(*(*int8)(unsafe.Pointer(s))) { + switch int32(**(**int8)(__ccgo_up(s))) { case int32('['): goto _1 case int32('\\'): @@ -129778,7 +129778,7 @@ _2: /* extensions: \b, \B, \<, \>, \xHH \x{HHHH} */ s = s + 1 v14 = s - switch int32(*(*int8)(unsafe.Pointer(v14))) { + switch int32(**(**int8)(__ccgo_up(v14))) { case 0: return int32(REG_EESCAPE) case int32('b'): @@ -129793,7 +129793,7 @@ _2: s = s + 1 v = 0 len1 = int32(2) - if int32(*(*int8)(unsafe.Pointer(s))) == int32('{') { + if int32(**(**int8)(__ccgo_up(s))) == int32('{') { len1 = int32(8) s = s + 1 } @@ -129802,7 +129802,7 @@ _2: if !(i < len1 && v < int32(0x110000)) { break } - c = _hexval1(tls, Uint32FromInt8(*(*int8)(unsafe.Pointer(s + uintptr(i))))) + c = _hexval1(tls, Uint32FromInt8(**(**int8)(__ccgo_up(s + uintptr(i))))) if c < 0 { break } @@ -129814,7 +129814,7 @@ _2: } s = s + uintptr(i) if len1 == int32(8) { - if int32(*(*int8)(unsafe.Pointer(s))) != int32('}') { + if int32(**(**int8)(__ccgo_up(s))) != int32('}') { return int32(REG_EBRACE) } s = s + 1 @@ -129845,9 +129845,9 @@ _2: /* fallthrough */ fallthrough default: - if !(ere != 0) && Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-uint32('1') < uint32(9) { + if !(ere != 0) && Uint32FromInt8(**(**int8)(__ccgo_up(s)))-uint32('1') < uint32(9) { /* back reference */ - val = int32(*(*int8)(unsafe.Pointer(s))) - int32('0') + val = int32(**(**int8)(__ccgo_up(s))) - int32('0') v14 = ctx + 44 v16 = *(*int32)(unsafe.Pointer(v14)) *(*int32)(unsafe.Pointer(v14)) = *(*int32)(unsafe.Pointer(v14)) + 1 @@ -129902,7 +129902,7 @@ _4: _5: ; /* '$' is special everywhere in EREs, and at the end of a BRE subexpression. */ - if !(ere != 0) && *(*int8)(unsafe.Pointer(s + 1)) != 0 && (int32(*(*int8)(unsafe.Pointer(s + 1))) != int32('\\') || int32(*(*int8)(unsafe.Pointer(s + 2))) != int32(')') && int32(*(*int8)(unsafe.Pointer(s + 2))) != int32('|')) { + if !(ere != 0) && **(**int8)(__ccgo_up(s + 1)) != 0 && (int32(**(**int8)(__ccgo_up(s + 1))) != int32('\\') || int32(**(**int8)(__ccgo_up(s + 2))) != int32(')') && int32(**(**int8)(__ccgo_up(s + 2))) != int32('|')) { goto parse_literal } node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(2), int32(ASSERT_AT_EOL), -int32(1)) @@ -129938,17 +129938,17 @@ parse_literal: if len1 < 0 { return int32(REG_BADPAT) } - if (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fcflags&int32(REG_ICASE) != 0 && (Xiswupper(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp)))) != 0 || Xiswlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp)))) != 0) { + if (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fcflags&int32(REG_ICASE) != 0 && (Xiswupper(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp)))) != 0 || Xiswlower(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp)))) != 0) { /* multiple opposite case characters are not supported */ - tmp11 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint32(Xtowupper(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))))), Int32FromUint32(Xtowupper(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))))), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) - tmp21 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint32(Xtowlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))))), Int32FromUint32(Xtowlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))))), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) + tmp11 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint32(Xtowupper(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))))), Int32FromUint32(Xtowupper(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))))), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) + tmp21 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint32(Xtowlower(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))))), Int32FromUint32(Xtowlower(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))))), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) if tmp11 != 0 && tmp21 != 0 { node = _tre_ast_new_union(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, tmp11, tmp21) } else { node = uintptr(0) } } else { - node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, *(*Twchar_t)(unsafe.Pointer(bp)), *(*Twchar_t)(unsafe.Pointer(bp)), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) + node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, **(**Twchar_t)(__ccgo_up(bp)), **(**Twchar_t)(__ccgo_up(bp)), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) } (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition + 1 s = s + uintptr(len1) @@ -129990,7 +129990,7 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { return err } for { - if !(ere != 0) && int32(*(*int8)(unsafe.Pointer(s))) == int32('\\') && int32(*(*int8)(unsafe.Pointer(s + 1))) == int32('(') || ere != 0 && int32(*(*int8)(unsafe.Pointer(s))) == int32('(') { + if !(ere != 0) && int32(**(**int8)(__ccgo_up(s))) == int32('\\') && int32(**(**int8)(__ccgo_up(s + 1))) == int32('(') || ere != 0 && int32(**(**int8)(__ccgo_up(s))) == int32('(') { v1 = _tre_stack_push_voidptr(tls, stack, nunion) err = v1 if v1 != REG_OK { @@ -130019,7 +130019,7 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart = s goto _3 } - if !(ere != 0) && int32(*(*int8)(unsafe.Pointer(s))) == int32('\\') && int32(*(*int8)(unsafe.Pointer(s + 1))) == int32(')') || ere != 0 && int32(*(*int8)(unsafe.Pointer(s))) == int32(')') && depth != 0 { + if !(ere != 0) && int32(**(**int8)(__ccgo_up(s))) == int32('\\') && int32(**(**int8)(__ccgo_up(s + 1))) == int32(')') || ere != 0 && int32(**(**int8)(__ccgo_up(s))) == int32(')') && depth != 0 { (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(1), -int32(1), -int32(1)) if !((*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn != 0) { return int32(REG_ESPACE) @@ -130035,52 +130035,52 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { parse_iter: ; for { - if int32(*(*int8)(unsafe.Pointer(s))) != int32('\\') && int32(*(*int8)(unsafe.Pointer(s))) != int32('*') { + if int32(**(**int8)(__ccgo_up(s))) != int32('\\') && int32(**(**int8)(__ccgo_up(s))) != int32('*') { if !(ere != 0) { break } - if int32(*(*int8)(unsafe.Pointer(s))) != int32('+') && int32(*(*int8)(unsafe.Pointer(s))) != int32('?') && int32(*(*int8)(unsafe.Pointer(s))) != int32('{') { + if int32(**(**int8)(__ccgo_up(s))) != int32('+') && int32(**(**int8)(__ccgo_up(s))) != int32('?') && int32(**(**int8)(__ccgo_up(s))) != int32('{') { break } } - if int32(*(*int8)(unsafe.Pointer(s))) == int32('\\') && ere != 0 { + if int32(**(**int8)(__ccgo_up(s))) == int32('\\') && ere != 0 { break } /* extension: treat \+, \? as repetitions in BRE */ - if int32(*(*int8)(unsafe.Pointer(s))) == int32('\\') && int32(*(*int8)(unsafe.Pointer(s + 1))) != int32('+') && int32(*(*int8)(unsafe.Pointer(s + 1))) != int32('?') && int32(*(*int8)(unsafe.Pointer(s + 1))) != int32('{') { + if int32(**(**int8)(__ccgo_up(s))) == int32('\\') && int32(**(**int8)(__ccgo_up(s + 1))) != int32('+') && int32(**(**int8)(__ccgo_up(s + 1))) != int32('?') && int32(**(**int8)(__ccgo_up(s + 1))) != int32('{') { break } - if int32(*(*int8)(unsafe.Pointer(s))) == int32('\\') { + if int32(**(**int8)(__ccgo_up(s))) == int32('\\') { s = s + 1 } /* handle ^* at the start of a BRE. */ - if !(ere != 0) && s == (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart+uintptr(1) && int32(*(*int8)(unsafe.Pointer(s + uintptr(-Int32FromInt32(1))))) == int32('^') { + if !(ere != 0) && s == (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart+uintptr(1) && int32(**(**int8)(__ccgo_up(s + uintptr(-Int32FromInt32(1))))) == int32('^') { break } /* extension: multiple consecutive *+?{,} is unspecified, but (a+)+ has to be supported so accepting a++ makes sense, note however that the RE_DUP_MAX limit can be circumvented: (a{255}){255} uses a lot of memory.. */ - if int32(*(*int8)(unsafe.Pointer(s))) == int32('{') { + if int32(**(**int8)(__ccgo_up(s))) == int32('{') { s = _parse_dup(tls, s+uintptr(1), ere, bp, bp+4) if !(s != 0) { return int32(REG_BADBR) } } else { - *(*int32)(unsafe.Pointer(bp)) = 0 - *(*int32)(unsafe.Pointer(bp + 4)) = -int32(1) - if int32(*(*int8)(unsafe.Pointer(s))) == int32('+') { - *(*int32)(unsafe.Pointer(bp)) = int32(1) + **(**int32)(__ccgo_up(bp)) = 0 + **(**int32)(__ccgo_up(bp + 4)) = -int32(1) + if int32(**(**int8)(__ccgo_up(s))) == int32('+') { + **(**int32)(__ccgo_up(bp)) = int32(1) } - if int32(*(*int8)(unsafe.Pointer(s))) == int32('?') { - *(*int32)(unsafe.Pointer(bp + 4)) = int32(1) + if int32(**(**int8)(__ccgo_up(s))) == int32('?') { + **(**int32)(__ccgo_up(bp + 4)) = int32(1) } s = s + 1 } - if *(*int32)(unsafe.Pointer(bp + 4)) == 0 { + if **(**int32)(__ccgo_up(bp + 4)) == 0 { (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(1), -int32(1), -int32(1)) } else { - (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = _tre_ast_new_iter(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn, *(*int32)(unsafe.Pointer(bp)), *(*int32)(unsafe.Pointer(bp + 4)), 0) + (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = _tre_ast_new_iter(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn, **(**int32)(__ccgo_up(bp)), **(**int32)(__ccgo_up(bp + 4)), 0) } if !((*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn != 0) { return int32(REG_ESPACE) @@ -130089,13 +130089,13 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { _9: } nbranch = _tre_ast_new_catenation(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, nbranch, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn) - if ere != 0 && int32(*(*int8)(unsafe.Pointer(s))) == int32('|') || ere != 0 && int32(*(*int8)(unsafe.Pointer(s))) == int32(')') && depth != 0 || !(ere != 0) && int32(*(*int8)(unsafe.Pointer(s))) == int32('\\') && int32(*(*int8)(unsafe.Pointer(s + 1))) == int32(')') || !(ere != 0) && int32(*(*int8)(unsafe.Pointer(s))) == int32('\\') && int32(*(*int8)(unsafe.Pointer(s + 1))) == int32('|') || !(*(*int8)(unsafe.Pointer(s)) != 0) { + if ere != 0 && int32(**(**int8)(__ccgo_up(s))) == int32('|') || ere != 0 && int32(**(**int8)(__ccgo_up(s))) == int32(')') && depth != 0 || !(ere != 0) && int32(**(**int8)(__ccgo_up(s))) == int32('\\') && int32(**(**int8)(__ccgo_up(s + 1))) == int32(')') || !(ere != 0) && int32(**(**int8)(__ccgo_up(s))) == int32('\\') && int32(**(**int8)(__ccgo_up(s + 1))) == int32('|') || !(**(**int8)(__ccgo_up(s)) != 0) { /* extension: empty branch is unspecified (), (|a), (a|) here they are not rejected but match on empty string */ - c = int32(*(*int8)(unsafe.Pointer(s))) + c = int32(**(**int8)(__ccgo_up(s))) nunion = _tre_ast_new_union(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, nunion, nbranch) nbranch = uintptr(0) - if c == int32('\\') && int32(*(*int8)(unsafe.Pointer(s + 1))) == int32('|') { + if c == int32('\\') && int32(**(**int8)(__ccgo_up(s + 1))) == int32('|') { s = s + uintptr(2) (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart = s } else { @@ -130241,22 +130241,22 @@ func _tre_purge_regset(tls *TLS, regset uintptr, tnfa uintptr, tag int32) { _, _, _ = i, id, start i = 0 for { - if !(*(*int32)(unsafe.Pointer(regset + uintptr(i)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(regset + uintptr(i)*4)) >= 0) { break } - id = *(*int32)(unsafe.Pointer(regset + uintptr(i)*4)) / int32(2) - start = BoolInt32(!(*(*int32)(unsafe.Pointer(regset + uintptr(i)*4))%Int32FromInt32(2) != 0)) + id = **(**int32)(__ccgo_up(regset + uintptr(i)*4)) / int32(2) + start = BoolInt32(!(**(**int32)(__ccgo_up(regset + uintptr(i)*4))%Int32FromInt32(2) != 0)) if start != 0 { - (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id)*16))).Fso_tag = tag + (**(**Ttre_submatch_data_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id)*16))).Fso_tag = tag } else { - (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id)*16))).Feo_tag = tag + (**(**Ttre_submatch_data_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id)*16))).Feo_tag = tag } goto _1 _1: ; i = i + 1 } - *(*int32)(unsafe.Pointer(regset)) = -int32(1) + **(**int32)(__ccgo_up(regset)) = -int32(1) } // C documentation @@ -130285,20 +130285,20 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u direction = int32(_TRE_TAG_MINIMIZE) if !(first_pass != 0) { (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fend_tag = 0 - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags)) = -int32(1) + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags)) = -int32(1) } regset = Xmalloc(tls, uint64(4)*uint64(((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches+Uint32FromInt32(1))*Uint32FromInt32(2))) if regset == UintptrFromInt32(0) { return int32(REG_ESPACE) } - *(*int32)(unsafe.Pointer(regset)) = -int32(1) + **(**int32)(__ccgo_up(regset)) = -int32(1) orig_regset = regset parents = Xmalloc(tls, uint64(4)*uint64((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches+Uint32FromInt32(1))) if parents == UintptrFromInt32(0) { Xfree(tls, regset) return int32(REG_ESPACE) } - *(*int32)(unsafe.Pointer(parents)) = -int32(1) + **(**int32)(__ccgo_up(parents)) = -int32(1) saved_states = Xmalloc(tls, uint64(8)*uint64((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches+Uint32FromInt32(1))) if saved_states == UintptrFromInt32(0) { Xfree(tls, regset) @@ -130310,7 +130310,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u if !(i <= (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches) { break } - (*(*Ttre_tag_states_t)(unsafe.Pointer(saved_states + uintptr(i)*8))).Ftag = -int32(1) + (**(**Ttre_tag_states_t)(__ccgo_up(saved_states + uintptr(i)*8))).Ftag = -int32(1) goto _1 _1: ; @@ -130349,7 +130349,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u /* Add end of this submatch to regset. */ i1 = 0 for { - if !(*(*int32)(unsafe.Pointer(regset + uintptr(i1)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(regset + uintptr(i1)*4)) >= 0) { break } goto _11 @@ -130357,12 +130357,12 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i1 = i1 + 1 } - *(*int32)(unsafe.Pointer(regset + uintptr(i1)*4)) = id*int32(2) + int32(1) - *(*int32)(unsafe.Pointer(regset + uintptr(i1+int32(1))*4)) = -int32(1) + **(**int32)(__ccgo_up(regset + uintptr(i1)*4)) = id*int32(2) + int32(1) + **(**int32)(__ccgo_up(regset + uintptr(i1+int32(1))*4)) = -int32(1) /* Pop this submatch from the parents stack. */ i1 = 0 for { - if !(*(*int32)(unsafe.Pointer(parents + uintptr(i1)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(parents + uintptr(i1)*4)) >= 0) { break } goto _12 @@ -130370,7 +130370,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i1 = i1 + 1 } - *(*int32)(unsafe.Pointer(parents + uintptr(i1-int32(1))*4)) = -int32(1) + **(**int32)(__ccgo_up(parents + uintptr(i1-int32(1))*4)) = -int32(1) goto _10 _3: ; @@ -130380,7 +130380,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u /* Add start of this submatch to regset. */ i2 = 0 for { - if !(*(*int32)(unsafe.Pointer(regset + uintptr(i2)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(regset + uintptr(i2)*4)) >= 0) { break } goto _13 @@ -130388,12 +130388,12 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i2 = i2 + 1 } - *(*int32)(unsafe.Pointer(regset + uintptr(i2)*4)) = id1 * int32(2) - *(*int32)(unsafe.Pointer(regset + uintptr(i2+int32(1))*4)) = -int32(1) + **(**int32)(__ccgo_up(regset + uintptr(i2)*4)) = id1 * int32(2) + **(**int32)(__ccgo_up(regset + uintptr(i2+int32(1))*4)) = -int32(1) if !(first_pass != 0) { i2 = 0 for { - if !(*(*int32)(unsafe.Pointer(parents + uintptr(i2)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(parents + uintptr(i2)*4)) >= 0) { break } goto _14 @@ -130401,26 +130401,26 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i2 = i2 + 1 } - (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id1)*16))).Fparents = UintptrFromInt32(0) + (**(**Ttre_submatch_data_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id1)*16))).Fparents = UintptrFromInt32(0) if i2 > 0 { p = Xmalloc(tls, uint64(4)*Uint64FromInt32(i2+Int32FromInt32(1))) if p == UintptrFromInt32(0) { status = int32(REG_ESPACE) goto _10 } - (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id1)*16))).Fparents = p + (**(**Ttre_submatch_data_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id1)*16))).Fparents = p i2 = 0 for { - if !(*(*int32)(unsafe.Pointer(parents + uintptr(i2)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(parents + uintptr(i2)*4)) >= 0) { break } - *(*int32)(unsafe.Pointer(p + uintptr(i2)*4)) = *(*int32)(unsafe.Pointer(parents + uintptr(i2)*4)) + **(**int32)(__ccgo_up(p + uintptr(i2)*4)) = **(**int32)(__ccgo_up(parents + uintptr(i2)*4)) goto _15 _15: ; i2 = i2 + 1 } - *(*int32)(unsafe.Pointer(p + uintptr(i2)*4)) = -int32(1) + **(**int32)(__ccgo_up(p + uintptr(i2)*4)) = -int32(1) } } /* Add end of this submatch to regset after processing this @@ -130438,16 +130438,16 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u case int32(_LITERAL): lit = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj if !((*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min < Int64FromInt32(0)) || (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min == int64(-int32(4)) { - if *(*int32)(unsafe.Pointer(regset)) >= 0 { + if **(**int32)(__ccgo_up(regset)) >= 0 { /* Regset is not empty, so add a tag before the literal or backref. */ if !(first_pass != 0) { status = _tre_add_tag_left(tls, mem, node, tag) - *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = direction + **(**Ttre_tag_direction_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = direction if minimal_tag >= 0 { i3 = 0 for { - if !(*(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3)*4)) >= 0) { break } goto _16 @@ -130455,9 +130455,9 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i3 = i3 + 1 } - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3)*4)) = tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3+int32(1))*4)) = minimal_tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3+int32(2))*4)) = -int32(1) + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3)*4)) = tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3+int32(1))*4)) = minimal_tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) num_minimals = num_minimals + 1 } @@ -130465,7 +130465,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u } else { (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fnum_tags = int32(1) } - *(*int32)(unsafe.Pointer(regset)) = -int32(1) + **(**int32)(__ccgo_up(regset)) = -int32(1) tag = next_tag num_tags = num_tags + 1 next_tag = next_tag + 1 @@ -130525,7 +130525,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u case int32(_ITERATION): iter = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj if first_pass != 0 { - status = _tre_stack_push_int(tls, stack, BoolInt32(*(*int32)(unsafe.Pointer(regset)) >= 0 || int32(uint32(*(*uint8)(unsafe.Pointer(iter + 16))&0x1>>0)) != 0)) + status = _tre_stack_push_int(tls, stack, BoolInt32(**(**int32)(__ccgo_up(regset)) >= 0 || int32(uint32(*(*uint8)(unsafe.Pointer(iter + 16))&0x1>>0)) != 0)) if status != REG_OK { break } @@ -130556,18 +130556,18 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u break } /* Regset is not empty, so add a tag here. */ - if *(*int32)(unsafe.Pointer(regset)) >= 0 || int32(uint32(*(*uint8)(unsafe.Pointer(iter + 16))&0x1>>0)) != 0 { + if **(**int32)(__ccgo_up(regset)) >= 0 || int32(uint32(*(*uint8)(unsafe.Pointer(iter + 16))&0x1>>0)) != 0 { if !(first_pass != 0) { status = _tre_add_tag_left(tls, mem, node, tag) if int32(uint32(*(*uint8)(unsafe.Pointer(iter + 16))&0x1>>0)) != 0 { - *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = int32(_TRE_TAG_MAXIMIZE) + **(**Ttre_tag_direction_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = int32(_TRE_TAG_MAXIMIZE) } else { - *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = direction + **(**Ttre_tag_direction_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = direction } if minimal_tag >= 0 { i4 = 0 for { - if !(*(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4)*4)) >= 0) { break } goto _17 @@ -130575,15 +130575,15 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i4 = i4 + 1 } - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4)*4)) = tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4+int32(1))*4)) = minimal_tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4+int32(2))*4)) = -int32(1) + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4)*4)) = tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4+int32(1))*4)) = minimal_tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) num_minimals = num_minimals + 1 } _tre_purge_regset(tls, regset, tnfa, tag) } - *(*int32)(unsafe.Pointer(regset)) = -int32(1) + **(**int32)(__ccgo_up(regset)) = -int32(1) tag = next_tag num_tags = num_tags + 1 next_tag = next_tag + 1 @@ -130593,7 +130593,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u uni = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj left1 = (*Ttre_union_t)(unsafe.Pointer(uni)).Fleft right1 = (*Ttre_union_t)(unsafe.Pointer(uni)).Fright - if *(*int32)(unsafe.Pointer(regset)) >= 0 { + if **(**int32)(__ccgo_up(regset)) >= 0 { left_tag = next_tag right_tag = next_tag + int32(1) } else { @@ -130613,7 +130613,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u if status != REG_OK { break } - status = _tre_stack_push_int(tls, stack, BoolInt32(*(*int32)(unsafe.Pointer(regset)) >= 0)) + status = _tre_stack_push_int(tls, stack, BoolInt32(**(**int32)(__ccgo_up(regset)) >= 0)) if status != REG_OK { break } @@ -130657,14 +130657,14 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u break } /* Regset is not empty, so add a tag here. */ - if *(*int32)(unsafe.Pointer(regset)) >= 0 { + if **(**int32)(__ccgo_up(regset)) >= 0 { if !(first_pass != 0) { status = _tre_add_tag_left(tls, mem, node, tag) - *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = direction + **(**Ttre_tag_direction_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = direction if minimal_tag >= 0 { i5 = 0 for { - if !(*(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5)*4)) >= 0) { break } goto _18 @@ -130672,15 +130672,15 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i5 = i5 + 1 } - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5)*4)) = tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5+int32(1))*4)) = minimal_tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5+int32(2))*4)) = -int32(1) + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5)*4)) = tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5+int32(1))*4)) = minimal_tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) num_minimals = num_minimals + 1 } _tre_purge_regset(tls, regset, tnfa, tag) } - *(*int32)(unsafe.Pointer(regset)) = -int32(1) + **(**int32)(__ccgo_up(regset)) = -int32(1) tag = next_tag num_tags = num_tags + 1 next_tag = next_tag + 1 @@ -130697,7 +130697,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u /* Push this submatch on the parents stack. */ i6 = 0 for { - if !(*(*int32)(unsafe.Pointer(parents + uintptr(i6)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(parents + uintptr(i6)*4)) >= 0) { break } goto _19 @@ -130705,8 +130705,8 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i6 = i6 + 1 } - *(*int32)(unsafe.Pointer(parents + uintptr(i6)*4)) = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fsubmatch_id - *(*int32)(unsafe.Pointer(parents + uintptr(i6+int32(1))*4)) = -int32(1) + **(**int32)(__ccgo_up(parents + uintptr(i6)*4)) = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fsubmatch_id + **(**int32)(__ccgo_up(parents + uintptr(i6+int32(1))*4)) = -int32(1) } goto _10 /* end case: ADDTAGS_RECURSE */ _4: @@ -130754,7 +130754,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u will be restored at ADDTAGS_AFTER_UNION_RIGHT below. */ _21: ; - if !(*(*int32)(unsafe.Pointer(regset)) >= 0) { + if !(**(**int32)(__ccgo_up(regset)) >= 0) { goto _20 } regset += 4 @@ -130791,11 +130791,11 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u if (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fnum_submatches > 0 { if !(first_pass != 0) { status = _tre_add_tag_right(tls, mem, left2, tag_left) - *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag_left)*4)) = int32(_TRE_TAG_MAXIMIZE) + **(**Ttre_tag_direction_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag_left)*4)) = int32(_TRE_TAG_MAXIMIZE) if status == REG_OK { status = _tre_add_tag_right(tls, mem, right2, tag_right) } - *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag_right)*4)) = int32(_TRE_TAG_MAXIMIZE) + **(**Ttre_tag_direction_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag_right)*4)) = int32(_TRE_TAG_MAXIMIZE) } num_tags = num_tags + int32(2) } @@ -130813,7 +130813,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u if !(first_pass != 0) && minimal_tag >= 0 { i7 = 0 for { - if !(*(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7)*4)) >= 0) { break } goto _23 @@ -130821,9 +130821,9 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i7 = i7 + 1 } - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7)*4)) = tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7+int32(1))*4)) = minimal_tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7+int32(2))*4)) = -int32(1) + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7)*4)) = tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7+int32(1))*4)) = minimal_tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) num_minimals = num_minimals + 1 } @@ -130880,7 +130880,7 @@ func _tre_copy_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, flags i /* XXX - e.g. [ab] has only one position but two nodes, so we are creating holes in the state space here. Not fatal, just wastes memory. */ - pos = pos + *(*int32)(unsafe.Pointer(pos_add)) + pos = pos + **(**int32)(__ccgo_up(pos_add)) num_copied = num_copied + 1 } else { if (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min == int64(-int32(3)) && flags&int32(COPY_REMOVE_TAGS) != 0 { @@ -130892,30 +130892,30 @@ func _tre_copy_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, flags i } else { if (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min == int64(-int32(3)) && flags&int32(COPY_MAXIMIZE_FIRST_TAG) != 0 && first_tag != 0 { /* Maximize the first tag. */ - *(*Ttre_tag_direction_t)(unsafe.Pointer(tag_directions + uintptr(max)*4)) = int32(_TRE_TAG_MAXIMIZE) + **(**Ttre_tag_direction_t)(__ccgo_up(tag_directions + uintptr(max)*4)) = int32(_TRE_TAG_MAXIMIZE) first_tag = 0 } } } - *(*uintptr)(unsafe.Pointer(result)) = _tre_ast_new_literal(tls, mem, min, max, pos) - if *(*uintptr)(unsafe.Pointer(result)) == UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(result)) = _tre_ast_new_literal(tls, mem, min, max, pos) + if **(**uintptr)(__ccgo_up(result)) == UintptrFromInt32(0) { status = int32(REG_ESPACE) } else { - p = (*Ttre_ast_node_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(result)))).Fobj + p = (*Ttre_ast_node_t)(unsafe.Pointer(**(**uintptr)(__ccgo_up(result)))).Fobj (*Ttre_literal_t)(unsafe.Pointer(p)).Fclass = (*Ttre_literal_t)(unsafe.Pointer(lit)).Fclass (*Ttre_literal_t)(unsafe.Pointer(p)).Fneg_classes = (*Ttre_literal_t)(unsafe.Pointer(lit)).Fneg_classes } - if pos > *(*int32)(unsafe.Pointer(max_pos)) { - *(*int32)(unsafe.Pointer(max_pos)) = pos + if pos > **(**int32)(__ccgo_up(max_pos)) { + **(**int32)(__ccgo_up(max_pos)) = pos } case int32(_UNION): uni = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj - *(*uintptr)(unsafe.Pointer(result)) = _tre_ast_new_union(tls, mem, (*Ttre_union_t)(unsafe.Pointer(uni)).Fleft, (*Ttre_union_t)(unsafe.Pointer(uni)).Fright) - if *(*uintptr)(unsafe.Pointer(result)) == UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(result)) = _tre_ast_new_union(tls, mem, (*Ttre_union_t)(unsafe.Pointer(uni)).Fleft, (*Ttre_union_t)(unsafe.Pointer(uni)).Fright) + if **(**uintptr)(__ccgo_up(result)) == UintptrFromInt32(0) { status = int32(REG_ESPACE) break } - tmp = (*Ttre_ast_node_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(result)))).Fobj + tmp = (*Ttre_ast_node_t)(unsafe.Pointer(**(**uintptr)(__ccgo_up(result)))).Fobj result = tmp status = _tre_stack_push_voidptr(tls, stack, (*Ttre_union_t)(unsafe.Pointer(uni)).Fright) if status != REG_OK { @@ -130943,12 +130943,12 @@ func _tre_copy_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, flags i } case int32(_CATENATION): cat = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj - *(*uintptr)(unsafe.Pointer(result)) = _tre_ast_new_catenation(tls, mem, (*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft, (*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright) - if *(*uintptr)(unsafe.Pointer(result)) == UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(result)) = _tre_ast_new_catenation(tls, mem, (*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft, (*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright) + if **(**uintptr)(__ccgo_up(result)) == UintptrFromInt32(0) { status = int32(REG_ESPACE) break } - tmp1 = (*Ttre_ast_node_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(result)))).Fobj + tmp1 = (*Ttre_ast_node_t)(unsafe.Pointer(**(**uintptr)(__ccgo_up(result)))).Fobj (*Ttre_catenation_t)(unsafe.Pointer(tmp1)).Fleft = UintptrFromInt32(0) (*Ttre_catenation_t)(unsafe.Pointer(tmp1)).Fright = UintptrFromInt32(0) result = tmp1 @@ -130986,12 +130986,12 @@ func _tre_copy_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, flags i if status != REG_OK { break } - *(*uintptr)(unsafe.Pointer(result)) = _tre_ast_new_iter(tls, mem, (*Ttre_iteration_t)(unsafe.Pointer(iter)).Farg, (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmin, (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmax, int32(uint32(*(*uint8)(unsafe.Pointer(iter + 16))&0x1>>0))) - if *(*uintptr)(unsafe.Pointer(result)) == UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(result)) = _tre_ast_new_iter(tls, mem, (*Ttre_iteration_t)(unsafe.Pointer(iter)).Farg, (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmin, (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmax, int32(uint32(*(*uint8)(unsafe.Pointer(iter + 16))&0x1>>0))) + if **(**uintptr)(__ccgo_up(result)) == UintptrFromInt32(0) { status = int32(REG_ESPACE) break } - iter = (*Ttre_ast_node_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(result)))).Fobj + iter = (*Ttre_ast_node_t)(unsafe.Pointer(**(**uintptr)(__ccgo_up(result)))).Fobj result = iter default: break @@ -130999,7 +130999,7 @@ func _tre_copy_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, flags i break } } - *(*int32)(unsafe.Pointer(pos_add)) += num_copied + **(**int32)(__ccgo_up(pos_add)) += num_copied return status } @@ -131027,9 +131027,9 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _status, _status1, bottom, cat, flags, iter, iter1, iter_depth, j, lit, node, pos_add_last, pos_add_save, pos_add_total, seq1, status, symbol, tmp, uni, v2 status = REG_OK bottom = _tre_stack_num_objects(tls, stack) - *(*int32)(unsafe.Pointer(bp)) = 0 + **(**int32)(__ccgo_up(bp)) = 0 pos_add_total = 0 - *(*int32)(unsafe.Pointer(bp + 4)) = 0 + **(**int32)(__ccgo_up(bp + 4)) = 0 iter_depth = 0 _status = _tre_stack_push_voidptr(tls, stack, ast) if _status != REG_OK { @@ -131051,9 +131051,9 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit case int32(_LITERAL): lit = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj if !((*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min < Int64FromInt32(0)) || (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min == int64(-int32(4)) { - *(*int32)(unsafe.Pointer(lit + 16)) += *(*int32)(unsafe.Pointer(bp)) - if (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition > *(*int32)(unsafe.Pointer(bp + 4)) { - *(*int32)(unsafe.Pointer(bp + 4)) = (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition + **(**int32)(__ccgo_up(lit + 16)) += **(**int32)(__ccgo_up(bp)) + if (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition > **(**int32)(__ccgo_up(bp + 4)) { + **(**int32)(__ccgo_up(bp + 4)) = (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition } } case int32(_UNION): @@ -131094,7 +131094,7 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit } case int32(_ITERATION): iter = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj - status = _tre_stack_push_int(tls, stack, *(*int32)(unsafe.Pointer(bp))) + status = _tre_stack_push_int(tls, stack, **(**int32)(__ccgo_up(bp))) if status != REG_OK { break } @@ -131118,7 +131118,7 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit then don't increase the `pos' fields of the nodes now, it will get done when expanding. */ if (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmin > int32(1) || (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmax > int32(1) { - *(*int32)(unsafe.Pointer(bp)) = 0 + **(**int32)(__ccgo_up(bp)) = 0 } iter_depth = iter_depth + 1 default: @@ -131126,12 +131126,12 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit } case int32(_EXPAND_AFTER_ITER): iter1 = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj - *(*int32)(unsafe.Pointer(bp)) = _tre_stack_pop_int(tls, stack) - pos_add_last = *(*int32)(unsafe.Pointer(bp)) + **(**int32)(__ccgo_up(bp)) = _tre_stack_pop_int(tls, stack) + pos_add_last = **(**int32)(__ccgo_up(bp)) if (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Fmin > int32(1) || (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Fmax > int32(1) { seq1 = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(bp + 8)) = UintptrFromInt32(0) - pos_add_save = *(*int32)(unsafe.Pointer(bp)) + **(**uintptr)(__ccgo_up(bp + 8)) = UintptrFromInt32(0) + pos_add_save = **(**int32)(__ccgo_up(bp)) /* Create a catenated sequence of copies of the node. */ j = 0 for { @@ -131145,15 +131145,15 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit } /* Remove tags from all but the last copy. */ flags = v2 - pos_add_save = *(*int32)(unsafe.Pointer(bp)) + pos_add_save = **(**int32)(__ccgo_up(bp)) status = _tre_copy_ast(tls, mem, stack, (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Farg, flags, bp, tag_directions, bp+16, bp+4) if status != REG_OK { return status } if seq1 != UintptrFromInt32(0) { - seq1 = _tre_ast_new_catenation(tls, mem, seq1, *(*uintptr)(unsafe.Pointer(bp + 16))) + seq1 = _tre_ast_new_catenation(tls, mem, seq1, **(**uintptr)(__ccgo_up(bp + 16))) } else { - seq1 = *(*uintptr)(unsafe.Pointer(bp + 16)) + seq1 = **(**uintptr)(__ccgo_up(bp + 16)) } if seq1 == UintptrFromInt32(0) { return int32(REG_ESPACE) @@ -131165,13 +131165,13 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit } if (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Fmax == -int32(1) { /* No upper limit. */ - pos_add_save = *(*int32)(unsafe.Pointer(bp)) + pos_add_save = **(**int32)(__ccgo_up(bp)) status = _tre_copy_ast(tls, mem, stack, (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Farg, 0, bp, UintptrFromInt32(0), bp+8, bp+4) if status != REG_OK { return status } - *(*uintptr)(unsafe.Pointer(bp + 8)) = _tre_ast_new_iter(tls, mem, *(*uintptr)(unsafe.Pointer(bp + 8)), 0, -int32(1), 0) - if *(*uintptr)(unsafe.Pointer(bp + 8)) == UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(bp + 8)) = _tre_ast_new_iter(tls, mem, **(**uintptr)(__ccgo_up(bp + 8)), 0, -int32(1), 0) + if **(**uintptr)(__ccgo_up(bp + 8)) == UintptrFromInt32(0) { return int32(REG_ESPACE) } } else { @@ -131180,25 +131180,25 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit if !(j < (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Fmax) { break } - pos_add_save = *(*int32)(unsafe.Pointer(bp)) + pos_add_save = **(**int32)(__ccgo_up(bp)) status = _tre_copy_ast(tls, mem, stack, (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Farg, 0, bp, UintptrFromInt32(0), bp+24, bp+4) if status != REG_OK { return status } - if *(*uintptr)(unsafe.Pointer(bp + 8)) != UintptrFromInt32(0) { - *(*uintptr)(unsafe.Pointer(bp + 8)) = _tre_ast_new_catenation(tls, mem, *(*uintptr)(unsafe.Pointer(bp + 24)), *(*uintptr)(unsafe.Pointer(bp + 8))) + if **(**uintptr)(__ccgo_up(bp + 8)) != UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(bp + 8)) = _tre_ast_new_catenation(tls, mem, **(**uintptr)(__ccgo_up(bp + 24)), **(**uintptr)(__ccgo_up(bp + 8))) } else { - *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 24)) + **(**uintptr)(__ccgo_up(bp + 8)) = **(**uintptr)(__ccgo_up(bp + 24)) } - if *(*uintptr)(unsafe.Pointer(bp + 8)) == UintptrFromInt32(0) { + if **(**uintptr)(__ccgo_up(bp + 8)) == UintptrFromInt32(0) { return int32(REG_ESPACE) } tmp = _tre_ast_new_literal(tls, mem, -int32(1), -int32(1), -int32(1)) if tmp == UintptrFromInt32(0) { return int32(REG_ESPACE) } - *(*uintptr)(unsafe.Pointer(bp + 8)) = _tre_ast_new_union(tls, mem, tmp, *(*uintptr)(unsafe.Pointer(bp + 8))) - if *(*uintptr)(unsafe.Pointer(bp + 8)) == UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(bp + 8)) = _tre_ast_new_union(tls, mem, tmp, **(**uintptr)(__ccgo_up(bp + 8))) + if **(**uintptr)(__ccgo_up(bp + 8)) == UintptrFromInt32(0) { return int32(REG_ESPACE) } goto _3 @@ -131207,12 +131207,12 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit j = j + 1 } } - *(*int32)(unsafe.Pointer(bp)) = pos_add_save + **(**int32)(__ccgo_up(bp)) = pos_add_save if seq1 == UintptrFromInt32(0) { - seq1 = *(*uintptr)(unsafe.Pointer(bp + 8)) + seq1 = **(**uintptr)(__ccgo_up(bp + 8)) } else { - if *(*uintptr)(unsafe.Pointer(bp + 8)) != UintptrFromInt32(0) { - seq1 = _tre_ast_new_catenation(tls, mem, seq1, *(*uintptr)(unsafe.Pointer(bp + 8))) + if **(**uintptr)(__ccgo_up(bp + 8)) != UintptrFromInt32(0) { + seq1 = _tre_ast_new_catenation(tls, mem, seq1, **(**uintptr)(__ccgo_up(bp + 8))) } } if seq1 == UintptrFromInt32(0) { @@ -131222,21 +131222,21 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit (*Ttre_ast_node_t)(unsafe.Pointer(node)).Ftype1 = (*Ttre_ast_node_t)(unsafe.Pointer(seq1)).Ftype1 } iter_depth = iter_depth - 1 - pos_add_total = pos_add_total + (*(*int32)(unsafe.Pointer(bp)) - pos_add_last) + pos_add_total = pos_add_total + (**(**int32)(__ccgo_up(bp)) - pos_add_last) if iter_depth == 0 { - *(*int32)(unsafe.Pointer(bp)) = pos_add_total + **(**int32)(__ccgo_up(bp)) = pos_add_total } default: break } } - *(*int32)(unsafe.Pointer(position)) += pos_add_total + **(**int32)(__ccgo_up(position)) += pos_add_total /* `max_pos' should never be larger than `*position' if the above code works, but just an extra safeguard let's make sure `*position' is set large enough so enough memory will be allocated for the transition table. */ - if *(*int32)(unsafe.Pointer(bp + 4)) > *(*int32)(unsafe.Pointer(position)) { - *(*int32)(unsafe.Pointer(position)) = *(*int32)(unsafe.Pointer(bp + 4)) + if **(**int32)(__ccgo_up(bp + 4)) > **(**int32)(__ccgo_up(position)) { + **(**int32)(__ccgo_up(position)) = **(**int32)(__ccgo_up(bp + 4)) } return status } @@ -131248,9 +131248,9 @@ func _tre_set_empty(tls *TLS, mem Ttre_mem_t) (r uintptr) { if new_set == UintptrFromInt32(0) { return UintptrFromInt32(0) } - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fposition = -int32(1) - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fcode_min = -int32(1) - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fcode_max = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fposition = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fcode_min = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fcode_max = -int32(1) return new_set } @@ -131261,15 +131261,15 @@ func _tre_set_one(tls *TLS, mem Ttre_mem_t, position int32, code_min int32, code if new_set == UintptrFromInt32(0) { return UintptrFromInt32(0) } - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fposition = position - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fcode_min = code_min - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fcode_max = code_max - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fclass = class - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fneg_classes = neg_classes - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fbackref = backref - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + 1*56))).Fposition = -int32(1) - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + 1*56))).Fcode_min = -int32(1) - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + 1*56))).Fcode_max = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fposition = position + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fcode_min = code_min + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fcode_max = code_max + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fclass = class + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fneg_classes = neg_classes + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fbackref = backref + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + 1*56))).Fposition = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + 1*56))).Fcode_min = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + 1*56))).Fcode_max = -int32(1) return new_set } @@ -131279,7 +131279,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u _, _, _, _, _, _, _ = i, j, new_set, new_tags, num_tags, s1, s2 num_tags = 0 for { - if !(tags != UintptrFromInt32(0) && *(*int32)(unsafe.Pointer(tags + uintptr(num_tags)*4)) >= 0) { + if !(tags != UintptrFromInt32(0) && **(**int32)(__ccgo_up(tags + uintptr(num_tags)*4)) >= 0) { break } goto _1 @@ -131289,7 +131289,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u } s1 = 0 for { - if !((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fposition >= 0) { + if !((**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fposition >= 0) { break } goto _2 @@ -131299,7 +131299,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u } s2 = 0 for { - if !((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fposition >= 0) { + if !((**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fposition >= 0) { break } goto _3 @@ -131313,22 +131313,22 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u } s1 = 0 for { - if !((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fposition >= 0) { + if !((**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fposition >= 0) { break } - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Fposition = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fposition - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Fcode_min = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fcode_min - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Fcode_max = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fcode_max - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Fassertions = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fassertions | assertions - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Fclass = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fclass - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Fneg_classes = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fneg_classes - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Fbackref = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fbackref - if (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Ftags == UintptrFromInt32(0) && tags == UintptrFromInt32(0) { - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Ftags = UintptrFromInt32(0) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Fposition = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fposition + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Fcode_min = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fcode_min + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Fcode_max = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fcode_max + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Fassertions = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fassertions | assertions + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Fclass = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fclass + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Fneg_classes = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fneg_classes + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Fbackref = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fbackref + if (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Ftags == UintptrFromInt32(0) && tags == UintptrFromInt32(0) { + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Ftags = UintptrFromInt32(0) } else { i = 0 for { - if !((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Ftags != UintptrFromInt32(0) && *(*int32)(unsafe.Pointer((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Ftags + uintptr(i)*4)) >= 0) { + if !((**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Ftags != UintptrFromInt32(0) && **(**int32)(__ccgo_up((**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Ftags + uintptr(i)*4)) >= 0) { break } goto _5 @@ -131345,7 +131345,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u if !(j < i) { break } - *(*int32)(unsafe.Pointer(new_tags + uintptr(j)*4)) = *(*int32)(unsafe.Pointer((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Ftags + uintptr(j)*4)) + **(**int32)(__ccgo_up(new_tags + uintptr(j)*4)) = **(**int32)(__ccgo_up((**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Ftags + uintptr(j)*4)) goto _6 _6: ; @@ -131356,14 +131356,14 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u if !(i < num_tags) { break } - *(*int32)(unsafe.Pointer(new_tags + uintptr(j+i)*4)) = *(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) + **(**int32)(__ccgo_up(new_tags + uintptr(j+i)*4)) = **(**int32)(__ccgo_up(tags + uintptr(i)*4)) goto _7 _7: ; i = i + 1 } - *(*int32)(unsafe.Pointer(new_tags + uintptr(j+i)*4)) = -int32(1) - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Ftags = new_tags + **(**int32)(__ccgo_up(new_tags + uintptr(j+i)*4)) = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Ftags = new_tags } goto _4 _4: @@ -131372,23 +131372,23 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u } s2 = 0 for { - if !((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fposition >= 0) { + if !((**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fposition >= 0) { break } - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fposition = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fposition - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fcode_min = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fcode_min - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fcode_max = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fcode_max + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Fposition = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fposition + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Fcode_min = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fcode_min + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Fcode_max = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fcode_max /* XXX - why not | assertions here as well? */ - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fassertions = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fassertions - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fclass = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fclass - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fneg_classes = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fneg_classes - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fbackref = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fbackref - if (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Ftags == UintptrFromInt32(0) { - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Ftags = UintptrFromInt32(0) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Fassertions = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fassertions + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Fclass = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fclass + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Fneg_classes = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fneg_classes + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Fbackref = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fbackref + if (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Ftags == UintptrFromInt32(0) { + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Ftags = UintptrFromInt32(0) } else { i = 0 for { - if !(*(*int32)(unsafe.Pointer((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Ftags + uintptr(i)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Ftags + uintptr(i)*4)) >= 0) { break } goto _9 @@ -131405,21 +131405,21 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u if !(j < i) { break } - *(*int32)(unsafe.Pointer(new_tags + uintptr(j)*4)) = *(*int32)(unsafe.Pointer((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Ftags + uintptr(j)*4)) + **(**int32)(__ccgo_up(new_tags + uintptr(j)*4)) = **(**int32)(__ccgo_up((**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Ftags + uintptr(j)*4)) goto _10 _10: ; j = j + 1 } - *(*int32)(unsafe.Pointer(new_tags + uintptr(j)*4)) = -int32(1) - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Ftags = new_tags + **(**int32)(__ccgo_up(new_tags + uintptr(j)*4)) = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Ftags = new_tags } goto _8 _8: ; s2 = s2 + 1 } - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fposition = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Fposition = -int32(1) return new_set } @@ -131437,7 +131437,7 @@ func _tre_match_empty(tls *TLS, stack uintptr, node uintptr, tags uintptr, asser bottom = _tre_stack_num_objects(tls, stack) status = REG_OK if num_tags_seen != 0 { - *(*int32)(unsafe.Pointer(num_tags_seen)) = 0 + **(**int32)(__ccgo_up(num_tags_seen)) = 0 } status = _tre_stack_push_voidptr(tls, stack, node) /* Walk through the tree recursively. */ @@ -131453,10 +131453,10 @@ func _tre_match_empty(tls *TLS, stack uintptr, node uintptr, tags uintptr, asser /* Add the tag to `tags'. */ i = 0 for { - if !(*(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(tags + uintptr(i)*4)) >= 0) { break } - if int64(*(*int32)(unsafe.Pointer(tags + uintptr(i)*4))) == (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max { + if int64(**(**int32)(__ccgo_up(tags + uintptr(i)*4))) == (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max { break } goto _1 @@ -131464,13 +131464,13 @@ func _tre_match_empty(tls *TLS, stack uintptr, node uintptr, tags uintptr, asser ; i = i + 1 } - if *(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) < 0 { - *(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) = int32((*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max) - *(*int32)(unsafe.Pointer(tags + uintptr(i+int32(1))*4)) = -int32(1) + if **(**int32)(__ccgo_up(tags + uintptr(i)*4)) < 0 { + **(**int32)(__ccgo_up(tags + uintptr(i)*4)) = int32((*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max) + **(**int32)(__ccgo_up(tags + uintptr(i+int32(1))*4)) = -int32(1) } } if num_tags_seen != 0 { - *(*int32)(unsafe.Pointer(num_tags_seen)) = *(*int32)(unsafe.Pointer(num_tags_seen)) + 1 + **(**int32)(__ccgo_up(num_tags_seen)) = **(**int32)(__ccgo_up(num_tags_seen)) + 1 } } case int64(-int32(2)): @@ -131714,12 +131714,12 @@ func _tre_compute_nfl(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr) (r return status } /* Allocate arrays for the tags and parameters. */ - tags = Xmalloc(tls, uint64(4)*Uint64FromInt32(*(*int32)(unsafe.Pointer(bp))+Int32FromInt32(1))) + tags = Xmalloc(tls, uint64(4)*Uint64FromInt32(**(**int32)(__ccgo_up(bp))+Int32FromInt32(1))) if !(tags != 0) { return int32(REG_ESPACE) } - *(*int32)(unsafe.Pointer(tags)) = -int32(1) - *(*int32)(unsafe.Pointer(bp + 4)) = 0 + **(**int32)(__ccgo_up(tags)) = -int32(1) + **(**int32)(__ccgo_up(bp + 4)) = 0 /* Second pass with tre_mach_empty() to get the list of tags and parameters. */ status = _tre_match_empty(tls, stack, (*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft, tags, bp+4, UintptrFromInt32(0)) @@ -131727,7 +131727,7 @@ func _tre_compute_nfl(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr) (r Xfree(tls, tags) return status } - (*Ttre_ast_node_t)(unsafe.Pointer(node)).Ffirstpos = _tre_set_union(tls, mem, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright)).Ffirstpos, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft)).Ffirstpos, tags, *(*int32)(unsafe.Pointer(bp + 4))) + (*Ttre_ast_node_t)(unsafe.Pointer(node)).Ffirstpos = _tre_set_union(tls, mem, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright)).Ffirstpos, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft)).Ffirstpos, tags, **(**int32)(__ccgo_up(bp + 4))) Xfree(tls, tags) if !((*Ttre_ast_node_t)(unsafe.Pointer(node)).Ffirstpos != 0) { return int32(REG_ESPACE) @@ -131745,12 +131745,12 @@ func _tre_compute_nfl(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr) (r return status } /* Allocate arrays for the tags and parameters. */ - tags = Xmalloc(tls, uint64(4)*Uint64FromInt32(*(*int32)(unsafe.Pointer(bp))+Int32FromInt32(1))) + tags = Xmalloc(tls, uint64(4)*Uint64FromInt32(**(**int32)(__ccgo_up(bp))+Int32FromInt32(1))) if !(tags != 0) { return int32(REG_ESPACE) } - *(*int32)(unsafe.Pointer(tags)) = -int32(1) - *(*int32)(unsafe.Pointer(bp + 4)) = 0 + **(**int32)(__ccgo_up(tags)) = -int32(1) + **(**int32)(__ccgo_up(bp + 4)) = 0 /* Second pass with tre_mach_empty() to get the list of tags and parameters. */ status = _tre_match_empty(tls, stack, (*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright, tags, bp+4, UintptrFromInt32(0)) @@ -131758,7 +131758,7 @@ func _tre_compute_nfl(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr) (r Xfree(tls, tags) return status } - (*Ttre_ast_node_t)(unsafe.Pointer(node)).Flastpos = _tre_set_union(tls, mem, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft)).Flastpos, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright)).Flastpos, tags, *(*int32)(unsafe.Pointer(bp + 4))) + (*Ttre_ast_node_t)(unsafe.Pointer(node)).Flastpos = _tre_set_union(tls, mem, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft)).Flastpos, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright)).Flastpos, tags, **(**int32)(__ccgo_up(bp + 4))) Xfree(tls, tags) if !((*Ttre_ast_node_t)(unsafe.Pointer(node)).Flastpos != 0) { return int32(REG_ESPACE) @@ -131794,7 +131794,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun prev_p2_pos = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fposition /* Set `trans' to point to the next unused transition from position `p1->position'. */ - trans = transitions + uintptr(*(*int32)(unsafe.Pointer(offs + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)))*56 + trans = transitions + uintptr(**(**int32)(__ccgo_up(offs + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)))*56 for (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fstate != UintptrFromInt32(0) { trans += 56 } @@ -131805,7 +131805,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun the transition from `p1' to `p2'. */ (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fcode_min = Uint32FromInt32((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fcode_min) (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fcode_max = Uint32FromInt32((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fcode_max) - (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fstate = transitions + uintptr(*(*int32)(unsafe.Pointer(offs + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fposition)*4)))*56 + (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fstate = transitions + uintptr(**(**int32)(__ccgo_up(offs + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fposition)*4)))*56 (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fstate_id = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fposition if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fclass != 0 { v1 = int32(ASSERT_CHAR_CLASS) @@ -131820,14 +131820,14 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fassertions = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fassertions | (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fassertions | v1 | v2 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fbackref >= 0 { *(*int32)(unsafe.Pointer(&(*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fu)) = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fbackref - *(*int32)(unsafe.Pointer(trans + 32)) |= int32(ASSERT_BACKREF) + **(**int32)(__ccgo_up(trans + 32)) |= int32(ASSERT_BACKREF) } else { *(*Ttre_ctype_t)(unsafe.Pointer(trans + 40)) = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fclass } if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes != UintptrFromInt32(0) { i = 0 for { - if !(*(*Ttre_ctype_t)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes + uintptr(i)*8)) != Uint64FromInt32(0)) { + if !(**(**Ttre_ctype_t)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes + uintptr(i)*8)) != Uint64FromInt32(0)) { break } goto _3 @@ -131841,29 +131841,29 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun } i = 0 for { - if !(*(*Ttre_ctype_t)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes + uintptr(i)*8)) != Uint64FromInt32(0)) { + if !(**(**Ttre_ctype_t)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes + uintptr(i)*8)) != Uint64FromInt32(0)) { break } - *(*Ttre_ctype_t)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes + uintptr(i)*8)) = *(*Ttre_ctype_t)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes + uintptr(i)*8)) + **(**Ttre_ctype_t)(__ccgo_up((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes + uintptr(i)*8)) = **(**Ttre_ctype_t)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes + uintptr(i)*8)) goto _4 _4: ; i = i + 1 } - *(*Ttre_ctype_t)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes + uintptr(i)*8)) = Uint64FromInt32(0) + **(**Ttre_ctype_t)(__ccgo_up((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes + uintptr(i)*8)) = Uint64FromInt32(0) } else { (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes = UintptrFromInt32(0) } /* Find out how many tags this transition has. */ i = 0 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags != UintptrFromInt32(0) { - for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) >= 0 { + for **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) >= 0 { i = i + 1 } } j = 0 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags != UintptrFromInt32(0) { - for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) >= 0 { + for **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) >= 0 { j = j + 1 } } @@ -131880,15 +131880,15 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun } i = 0 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags != UintptrFromInt32(0) { - for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) >= 0 { - *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(i)*4)) = *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) + for **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) >= 0 { + **(**int32)(__ccgo_up((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(i)*4)) = **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) i = i + 1 } } l = i j = 0 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags != UintptrFromInt32(0) { - for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) >= 0 { + for **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) >= 0 { /* Don't add duplicates. */ dup = 0 k = 0 @@ -131896,7 +131896,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun if !(k < i) { break } - if *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(k)*4)) == *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) { + if **(**int32)(__ccgo_up((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(k)*4)) == **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) { dup = int32(1) break } @@ -131908,12 +131908,12 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun if !(dup != 0) { v1 = l l = l + 1 - *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(v1)*4)) = *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) + **(**int32)(__ccgo_up((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(v1)*4)) = **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) } j = j + 1 } } - *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(l)*4)) = -int32(1) + **(**int32)(__ccgo_up((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(l)*4)) = -int32(1) } p2 += 56 } @@ -131925,7 +131925,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun for (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition >= 0 { p2 = orig_p2 for (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fposition >= 0 { - *(*int32)(unsafe.Pointer(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)) = *(*int32)(unsafe.Pointer(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)) + 1 + **(**int32)(__ccgo_up(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)) = **(**int32)(__ccgo_up(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)) + 1 p2 += 56 } p1 += 56 @@ -132016,11 +132016,11 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { } /* Parse the regexp. */ Xmemset(tls, bp, 0, uint64(56)) - (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fmem = mem - (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fstack = stack - (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fstart = regex - (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fcflags = cflags - (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fmax_backref = -int32(1) + (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fmem = mem + (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fstack = stack + (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fstart = regex + (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fcflags = cflags + (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fmax_backref = -int32(1) errcode = _tre_parse(tls, bp) if errcode != REG_OK { errcode = errcode @@ -132028,10 +132028,10 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { goto error_exit } } - (*Tregex_t)(unsafe.Pointer(preg)).Fre_nsub = Uint64FromInt32((*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fsubmatch_id - int32(1)) - tree = (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fn + (*Tregex_t)(unsafe.Pointer(preg)).Fre_nsub = Uint64FromInt32((**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fsubmatch_id - int32(1)) + tree = (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fn /* Referring to nonexistent subexpressions is illegal. */ - if (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fmax_backref > Int32FromUint64((*Tregex_t)(unsafe.Pointer(preg)).Fre_nsub) { + if (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fmax_backref > Int32FromUint64((*Tregex_t)(unsafe.Pointer(preg)).Fre_nsub) { errcode = int32(REG_ESUBREG) if int32(1) != 0 { goto error_exit @@ -132045,9 +132045,9 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { goto error_exit } } - (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fhave_backrefs = BoolInt32((*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fmax_backref >= 0) + (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fhave_backrefs = BoolInt32((**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fmax_backref >= 0) (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fhave_approx = 0 - (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches = Uint32FromInt32((*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fsubmatch_id) + (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches = Uint32FromInt32((**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fsubmatch_id) /* Set up tags for submatch addressing. If REG_NOSUB is set and the regexp does not have back references, this can be skipped. */ if (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fhave_backrefs != 0 || !(cflags&Int32FromInt32(REG_NOSUB) != 0) { @@ -132077,7 +132077,7 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { goto error_exit } } - submatch_data = Xcalloc(tls, uint64(Uint32FromInt32((*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fsubmatch_id)), uint64(16)) + submatch_data = Xcalloc(tls, uint64(Uint32FromInt32((**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fsubmatch_id)), uint64(16)) if submatch_data == UintptrFromInt32(0) { errcode = int32(REG_ESPACE) if int32(1) != 0 { @@ -132130,14 +132130,14 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { goto error_exit } } - counts = Xmalloc(tls, uint64(4)*Uint64FromInt32((*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fposition)) + counts = Xmalloc(tls, uint64(4)*Uint64FromInt32((**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fposition)) if counts == UintptrFromInt32(0) { errcode = int32(REG_ESPACE) if int32(1) != 0 { goto error_exit } } - offs = Xmalloc(tls, uint64(4)*Uint64FromInt32((*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fposition)) + offs = Xmalloc(tls, uint64(4)*Uint64FromInt32((**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fposition)) if offs == UintptrFromInt32(0) { errcode = int32(REG_ESPACE) if int32(1) != 0 { @@ -132146,10 +132146,10 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { } i = 0 for { - if !(i < (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fposition) { + if !(i < (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fposition) { break } - *(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) = 0 + **(**int32)(__ccgo_up(counts + uintptr(i)*4)) = 0 goto _3 _3: ; @@ -132159,12 +132159,12 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { add = 0 i = 0 for { - if !(i < (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fposition) { + if !(i < (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fposition) { break } - *(*int32)(unsafe.Pointer(offs + uintptr(i)*4)) = add - add = add + (*(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) + int32(1)) - *(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) = 0 + **(**int32)(__ccgo_up(offs + uintptr(i)*4)) = add + add = add + (**(**int32)(__ccgo_up(counts + uintptr(i)*4)) + int32(1)) + **(**int32)(__ccgo_up(counts + uintptr(i)*4)) = 0 goto _4 _4: ; @@ -132207,15 +132207,15 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { if !((*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fposition >= 0) { break } - (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Fstate = transitions + uintptr(*(*int32)(unsafe.Pointer(offs + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fposition)*4)))*56 - (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Fstate_id = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fposition - (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Ftags = UintptrFromInt32(0) + (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*56))).Fstate = transitions + uintptr(**(**int32)(__ccgo_up(offs + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fposition)*4)))*56 + (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*56))).Fstate_id = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fposition + (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*56))).Ftags = UintptrFromInt32(0) /* Copy the arrays p->tags, and p->params, they are allocated from a tre_mem object. */ if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Ftags != 0 { j = 0 for { - if !(*(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Ftags + uintptr(j)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Ftags + uintptr(j)*4)) >= 0) { break } goto _6 @@ -132223,26 +132223,26 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { ; j = j + 1 } - (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Ftags = Xmalloc(tls, uint64(4)*Uint64FromInt32(j+Int32FromInt32(1))) - if !((*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Ftags != 0) { + (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*56))).Ftags = Xmalloc(tls, uint64(4)*Uint64FromInt32(j+Int32FromInt32(1))) + if !((**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*56))).Ftags != 0) { errcode = int32(REG_ESPACE) if int32(1) != 0 { goto error_exit } } - Xmemcpy(tls, (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Ftags, (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Ftags, uint64(4)*Uint64FromInt32(j+Int32FromInt32(1))) + Xmemcpy(tls, (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*56))).Ftags, (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Ftags, uint64(4)*Uint64FromInt32(j+Int32FromInt32(1))) } - (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Fassertions = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fassertions + (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*56))).Fassertions = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fassertions i = i + 1 goto _5 _5: ; p += 56 } - (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Fstate = UintptrFromInt32(0) + (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*56))).Fstate = UintptrFromInt32(0) (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_transitions = Uint32FromInt32(add) - (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ffinal = transitions + uintptr(*(*int32)(unsafe.Pointer(offs + uintptr((*(*Ttre_pos_and_tags_t)(unsafe.Pointer((*Ttre_ast_node_t)(unsafe.Pointer(tree)).Flastpos))).Fposition)*4)))*56 - (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_states = (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fposition + (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ffinal = transitions + uintptr(**(**int32)(__ccgo_up(offs + uintptr((**(**Ttre_pos_and_tags_t)(__ccgo_up((*Ttre_ast_node_t)(unsafe.Pointer(tree)).Flastpos))).Fposition)*4)))*56 + (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_states = (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fposition (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags = cflags X__tre_mem_destroy(tls, mem) _tre_stack_destroy(tls, stack) @@ -132285,12 +132285,12 @@ func Xregfree(tls *TLS, preg uintptr) { if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_transitions) { break } - if (*(*Ttre_tnfa_transition_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Fstate != 0 { - if (*(*Ttre_tnfa_transition_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Ftags != 0 { - Xfree(tls, (*(*Ttre_tnfa_transition_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Ftags) + if (**(**Ttre_tnfa_transition_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Fstate != 0 { + if (**(**Ttre_tnfa_transition_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Ftags != 0 { + Xfree(tls, (**(**Ttre_tnfa_transition_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Ftags) } - if (*(*Ttre_tnfa_transition_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Fneg_classes != 0 { - Xfree(tls, (*(*Ttre_tnfa_transition_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Fneg_classes) + if (**(**Ttre_tnfa_transition_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Fneg_classes != 0 { + Xfree(tls, (**(**Ttre_tnfa_transition_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Fneg_classes) } } goto _1 @@ -132323,8 +132323,8 @@ func Xregfree(tls *TLS, preg uintptr) { if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches) { break } - if (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(i)*16))).Fparents != 0 { - Xfree(tls, (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(i)*16))).Fparents) + if (**(**Ttre_submatch_data_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(i)*16))).Fparents != 0 { + Xfree(tls, (**(**Ttre_submatch_data_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(i)*16))).Fparents) } goto _3 _3: @@ -132364,7 +132364,7 @@ func Xregerror(tls *TLS, e int32, preg uintptr, buf uintptr, size Tsize_t) (r Ts _ = s s = uintptr(unsafe.Pointer(&_messages)) for { - if !(e != 0 && *(*int8)(unsafe.Pointer(s)) != 0) { + if !(e != 0 && **(**int8)(__ccgo_up(s)) != 0) { break } goto _1 @@ -132373,7 +132373,7 @@ func Xregerror(tls *TLS, e int32, preg uintptr, buf uintptr, size Tsize_t) (r Ts e = e - 1 s = s + uintptr(_strlen(tls, s)+uint64(1)) } - if !(*(*int8)(unsafe.Pointer(s)) != 0) { + if !(**(**int8)(__ccgo_up(s)) != 0) { s = s + 1 } s = X__lctrans_cur(tls, s) @@ -132399,18 +132399,18 @@ func _tre_tag_order(tls *TLS, num_tags int32, tag_directions uintptr, t1 uintptr if !(i < num_tags) { break } - if *(*Ttre_tag_direction_t)(unsafe.Pointer(tag_directions + uintptr(i)*4)) == int32(_TRE_TAG_MINIMIZE) { - if *(*Tregoff_t)(unsafe.Pointer(t1 + uintptr(i)*8)) < *(*Tregoff_t)(unsafe.Pointer(t2 + uintptr(i)*8)) { + if **(**Ttre_tag_direction_t)(__ccgo_up(tag_directions + uintptr(i)*4)) == int32(_TRE_TAG_MINIMIZE) { + if **(**Tregoff_t)(__ccgo_up(t1 + uintptr(i)*8)) < **(**Tregoff_t)(__ccgo_up(t2 + uintptr(i)*8)) { return int32(1) } - if *(*Tregoff_t)(unsafe.Pointer(t1 + uintptr(i)*8)) > *(*Tregoff_t)(unsafe.Pointer(t2 + uintptr(i)*8)) { + if **(**Tregoff_t)(__ccgo_up(t1 + uintptr(i)*8)) > **(**Tregoff_t)(__ccgo_up(t2 + uintptr(i)*8)) { return 0 } } else { - if *(*Tregoff_t)(unsafe.Pointer(t1 + uintptr(i)*8)) > *(*Tregoff_t)(unsafe.Pointer(t2 + uintptr(i)*8)) { + if **(**Tregoff_t)(__ccgo_up(t1 + uintptr(i)*8)) > **(**Tregoff_t)(__ccgo_up(t2 + uintptr(i)*8)) { return int32(1) } - if *(*Tregoff_t)(unsafe.Pointer(t1 + uintptr(i)*8)) < *(*Tregoff_t)(unsafe.Pointer(t2 + uintptr(i)*8)) { + if **(**Tregoff_t)(__ccgo_up(t1 + uintptr(i)*8)) < **(**Tregoff_t)(__ccgo_up(t2 + uintptr(i)*8)) { return 0 } } @@ -132424,8 +132424,8 @@ func _tre_tag_order(tls *TLS, num_tags int32, tag_directions uintptr, t1 uintptr } func _tre_neg_char_classes_match(tls *TLS, classes uintptr, wc Ttre_cint_t, icase int32) (r int32) { - for *(*Ttre_ctype_t)(unsafe.Pointer(classes)) != Uint64FromInt32(0) { - if !(icase != 0) && Xiswctype(tls, wc, *(*Ttre_ctype_t)(unsafe.Pointer(classes))) != 0 || icase != 0 && (Xiswctype(tls, Xtowupper(tls, wc), *(*Ttre_ctype_t)(unsafe.Pointer(classes))) != 0 || Xiswctype(tls, Xtowlower(tls, wc), *(*Ttre_ctype_t)(unsafe.Pointer(classes))) != 0) { + for **(**Ttre_ctype_t)(__ccgo_up(classes)) != Uint64FromInt32(0) { + if !(icase != 0) && Xiswctype(tls, wc, **(**Ttre_ctype_t)(__ccgo_up(classes))) != 0 || icase != 0 && (Xiswctype(tls, Xtowupper(tls, wc), **(**Ttre_ctype_t)(__ccgo_up(classes))) != 0 || Xiswctype(tls, Xtowlower(tls, wc), **(**Ttre_ctype_t)(__ccgo_up(classes))) != 0) { return int32(1) } else { classes += 8 @@ -132478,7 +132478,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = buf, end, i, match_eo, new_match, num_tags, pbytes, pos, pos_add_next, prev_c, rbytes, reach, reach_i, reach_next, reach_next_i, reach_pos, reg_newline, reg_notbol, reg_noteol, ret, skip, start, str_byte, tag_i, tbytes, tmp_buf, tmp_iptr, tmp_tags, total_bytes, trans_i, xbytes, v1, v18, v7 /* State variables required by GET_NEXT_WCHAR. */ prev_c = 0 - *(*Ttre_char_t)(unsafe.Pointer(bp)) = 0 + **(**Ttre_char_t)(__ccgo_up(bp)) = 0 str_byte = string1 pos = int64(-int32(1)) pos_add_next = int64(1) @@ -132558,9 +132558,9 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_states) { break } - (*(*Ttre_tnfa_reach_t)(unsafe.Pointer(reach + uintptr(i)*16))).Ftags = tmp_buf + (**(**Ttre_tnfa_reach_t)(__ccgo_up(reach + uintptr(i)*16))).Ftags = tmp_buf tmp_buf = tmp_buf + uintptr(xbytes) - (*(*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next + uintptr(i)*16))).Ftags = tmp_buf + (**(**Ttre_tnfa_reach_t)(__ccgo_up(reach_next + uintptr(i)*16))).Ftags = tmp_buf tmp_buf = tmp_buf + uintptr(xbytes) goto _5 _5: @@ -132572,13 +132572,13 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_states) { break } - (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr(i)*16))).Fpos = int64(-int32(1)) + (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr(i)*16))).Fpos = int64(-int32(1)) goto _6 _6: ; i = i + 1 } - prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + prev_c = **(**Ttre_char_t)(__ccgo_up(bp)) pos = pos + pos_add_next v7 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) pos_add_next = v7 @@ -132598,8 +132598,8 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if match_eo < 0 { trans_i = (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Finitial for (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate != UintptrFromInt32(0) { - if (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos < pos { - if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\000') || reg_noteol != 0) && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0 || !(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) || (*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && *(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\000') && BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) == BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || *(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('\000') || BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) != BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0))) { + if (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos < pos { + if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (**(**Ttre_char_t)(__ccgo_up(bp)) != int32('\000') || reg_noteol != 0) && (**(**Ttre_char_t)(__ccgo_up(bp)) != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0 || !(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) || (**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && **(**Ttre_char_t)(__ccgo_up(bp)) != int32('\000') && BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) == BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || **(**Ttre_char_t)(__ccgo_up(bp)) == int32('\000') || BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) != BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0))) { trans_i += 56 continue } @@ -132609,7 +132609,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < num_tags) { break } - *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(i)*8)) = int64(-int32(1)) + **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(i)*8)) = int64(-int32(1)) goto _8 _8: ; @@ -132617,9 +132617,9 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags } tag_i = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags if tag_i != 0 { - for *(*int32)(unsafe.Pointer(tag_i)) >= 0 { - if *(*int32)(unsafe.Pointer(tag_i)) < num_tags { - *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(*(*int32)(unsafe.Pointer(tag_i)))*8)) = pos + for **(**int32)(__ccgo_up(tag_i)) >= 0 { + if **(**int32)(__ccgo_up(tag_i)) < num_tags { + **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(**(**int32)(__ccgo_up(tag_i)))*8)) = pos } tag_i += 4 } @@ -132632,15 +132632,15 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < num_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(i)*8)) = *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(i)*8)) + **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(i)*8)) = **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(i)*8)) goto _9 _9: ; i = i + 1 } } - (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos = pos - (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags = reach_next_i + 8 + (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos = pos + (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags = reach_next_i + 8 reach_next_i += 16 } trans_i += 56 @@ -132653,10 +132653,10 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags } } /* Check for end of string. */ - if !(*(*Ttre_char_t)(unsafe.Pointer(bp)) != 0) { + if !(**(**Ttre_char_t)(__ccgo_up(bp)) != 0) { break } - prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + prev_c = **(**Ttre_char_t)(__ccgo_up(bp)) pos = pos + pos_add_next v7 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) pos_add_next = v7 @@ -132686,16 +132686,16 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags skip = 0 i = 0 for { - if !(*(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i)*4)) >= 0) { break } - end = *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i)*4)) - start = *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i+int32(1))*4)) + end = **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i)*4)) + start = **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i+int32(1))*4)) if end >= num_tags { skip = int32(1) break } else { - if *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Ftags + uintptr(start)*8)) == *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(start)*8)) && *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Ftags + uintptr(end)*8)) < *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(end)*8)) { + if **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Ftags + uintptr(start)*8)) == **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(start)*8)) && **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Ftags + uintptr(end)*8)) < **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(end)*8)) { skip = int32(1) break } @@ -132739,7 +132739,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags } /* Does this transition match the input symbol? */ if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fcode_min <= Uint32FromInt32(prev_c) && (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fcode_max >= Uint32FromInt32(prev_c) { - if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\000') || reg_noteol != 0) && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0 || !(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) || (*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && *(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\000') && BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) == BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || *(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('\000') || BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) != BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && !((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&Int32FromInt32(REG_ICASE) != 0) && !(Xiswctype(tls, Uint32FromInt32(prev_c), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE) != 0 && !(Xiswctype(tls, Xtowlower(tls, Uint32FromInt32(prev_c)), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) && !(Xiswctype(tls, Xtowupper(tls, Uint32FromInt32(prev_c)), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS_NEG) != 0 && _tre_neg_char_classes_match(tls, (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fneg_classes, Uint32FromInt32(prev_c), (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE)) != 0)) { + if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (**(**Ttre_char_t)(__ccgo_up(bp)) != int32('\000') || reg_noteol != 0) && (**(**Ttre_char_t)(__ccgo_up(bp)) != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0 || !(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) || (**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && **(**Ttre_char_t)(__ccgo_up(bp)) != int32('\000') && BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) == BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || **(**Ttre_char_t)(__ccgo_up(bp)) == int32('\000') || BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) != BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && !((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&Int32FromInt32(REG_ICASE) != 0) && !(Xiswctype(tls, Uint32FromInt32(prev_c), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE) != 0 && !(Xiswctype(tls, Xtowlower(tls, Uint32FromInt32(prev_c)), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) && !(Xiswctype(tls, Xtowupper(tls, Uint32FromInt32(prev_c)), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS_NEG) != 0 && _tre_neg_char_classes_match(tls, (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fneg_classes, Uint32FromInt32(prev_c), (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE)) != 0)) { goto _14 } /* Compute the tags after this transition. */ @@ -132748,7 +132748,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < num_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(tmp_tags + uintptr(i)*8)) = *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Ftags + uintptr(i)*8)) + **(**Tregoff_t)(__ccgo_up(tmp_tags + uintptr(i)*8)) = **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Ftags + uintptr(i)*8)) goto _15 _15: ; @@ -132756,22 +132756,22 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags } tag_i = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags if tag_i != UintptrFromInt32(0) { - for *(*int32)(unsafe.Pointer(tag_i)) >= 0 { - if *(*int32)(unsafe.Pointer(tag_i)) < num_tags { - *(*Tregoff_t)(unsafe.Pointer(tmp_tags + uintptr(*(*int32)(unsafe.Pointer(tag_i)))*8)) = pos + for **(**int32)(__ccgo_up(tag_i)) >= 0 { + if **(**int32)(__ccgo_up(tag_i)) < num_tags { + **(**Tregoff_t)(__ccgo_up(tmp_tags + uintptr(**(**int32)(__ccgo_up(tag_i)))*8)) = pos } tag_i += 4 } } - if (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos < pos { + if (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos < pos { /* Found an unvisited node. */ (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Fstate = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate tmp_iptr = (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags = tmp_tags tmp_tags = tmp_iptr - (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos = pos - (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags = reach_next_i + 8 - if (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Fstate == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ffinal && (match_eo == int64(-int32(1)) || num_tags > 0 && *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags)) <= *(*Tregoff_t)(unsafe.Pointer(match_tags))) { + (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos = pos + (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags = reach_next_i + 8 + if (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Fstate == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ffinal && (match_eo == int64(-int32(1)) || num_tags > 0 && **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags)) <= **(**Tregoff_t)(__ccgo_up(match_tags))) { match_eo = pos new_match = int32(1) i = 0 @@ -132779,7 +132779,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < num_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(i)*8)) = *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(i)*8)) + **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(i)*8)) = **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(i)*8)) goto _16 _16: ; @@ -132791,10 +132791,10 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags /* Another path has also reached this state. We choose the winner by examining the tag values for both paths. */ - if _tre_tag_order(tls, num_tags, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions, tmp_tags, *(*uintptr)(unsafe.Pointer((*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags))) != 0 { + if _tre_tag_order(tls, num_tags, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions, tmp_tags, **(**uintptr)(__ccgo_up((**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags))) != 0 { /* The new path wins. */ - tmp_iptr = *(*uintptr)(unsafe.Pointer((*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags)) - *(*uintptr)(unsafe.Pointer((*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags)) = tmp_tags + tmp_iptr = **(**uintptr)(__ccgo_up((**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags)) + **(**uintptr)(__ccgo_up((**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags)) = tmp_tags if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ffinal { match_eo = pos new_match = int32(1) @@ -132803,7 +132803,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < num_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(i)*8)) = *(*Tregoff_t)(unsafe.Pointer(tmp_tags + uintptr(i)*8)) + **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(i)*8)) = **(**Tregoff_t)(__ccgo_up(tmp_tags + uintptr(i)*8)) goto _17 _17: ; @@ -132826,7 +132826,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags } (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Fstate = UintptrFromInt32(0) } - *(*Tregoff_t)(unsafe.Pointer(match_end_ofs)) = match_eo + **(**Tregoff_t)(__ccgo_up(match_end_ofs)) = match_eo if match_eo >= 0 { v18 = REG_OK } else { @@ -132897,7 +132897,7 @@ func _tre_tnfa_run_backtrack(tls *TLS, tnfa uintptr, string1 uintptr, match_tags _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bt, bt_len, empty_br_match, eo, i, i1, i2, i3, i4, match_eo, mem, next_c_start, next_state, next_tags, pmatch, pos, pos_add_next, pos_start, prev_c, reg_newline, reg_notbol, reg_noteol, result, ret, s, s1, so, stack, state, states_seen, str_byte, str_byte_start, tags, tmp, tmp1, trans_i, v20, v3, v6 /* State variables required by GET_NEXT_WCHAR. */ prev_c = 0 - *(*Ttre_char_t)(unsafe.Pointer(bp)) = 0 + **(**Ttre_char_t)(__ccgo_up(bp)) = 0 str_byte = string1 pos = 0 pos_add_next = int64(1) @@ -132951,9 +132951,9 @@ retry: if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(i)*8)) = int64(-int32(1)) + **(**Tregoff_t)(__ccgo_up(tags + uintptr(i)*8)) = int64(-int32(1)) if match_tags != 0 { - *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(i)*8)) = int64(-int32(1)) + **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(i)*8)) = int64(-int32(1)) } goto _1 _1: @@ -132965,7 +132965,7 @@ retry: if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_states) { break } - *(*int32)(unsafe.Pointer(states_seen + uintptr(i)*4)) = 0 + **(**int32)(__ccgo_up(states_seen + uintptr(i)*4)) = 0 goto _2 _2: ; @@ -132973,7 +132973,7 @@ retry: } state = UintptrFromInt32(0) pos = pos_start - prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + prev_c = **(**Ttre_char_t)(__ccgo_up(bp)) pos = pos + pos_add_next v3 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) pos_add_next = v3 @@ -132987,7 +132987,7 @@ retry: } str_byte = str_byte + uintptr(pos_add_next) pos_start = pos - next_c_start = *(*Ttre_char_t)(unsafe.Pointer(bp)) + next_c_start = **(**Ttre_char_t)(__ccgo_up(bp)) str_byte_start = str_byte /* Handle initial states. */ next_tags = UintptrFromInt32(0) @@ -132996,7 +132996,7 @@ retry: if !((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate != 0) { break } - if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\000') || reg_noteol != 0) && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0 || !(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) || (*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && *(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\000') && BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) == BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || *(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('\000') || BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) != BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0))) { + if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (**(**Ttre_char_t)(__ccgo_up(bp)) != int32('\000') || reg_noteol != 0) && (**(**Ttre_char_t)(__ccgo_up(bp)) != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0 || !(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) || (**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && **(**Ttre_char_t)(__ccgo_up(bp)) != int32('\000') && BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) == BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || **(**Ttre_char_t)(__ccgo_up(bp)) == int32('\000') || BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) != BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0))) { goto _4 } if state == UintptrFromInt32(0) { @@ -133045,13 +133045,13 @@ retry: (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstr_byte = str_byte (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate_id = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id - (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fnext_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fnext_c = **(**Ttre_char_t)(__ccgo_up(bp)) i1 = 0 for { if !(i1 < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_tags) { break } - *(*Tregoff_t)(unsafe.Pointer((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(i1)*8)) = *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(i1)*8)) + **(**Tregoff_t)(__ccgo_up((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(i1)*8)) = **(**Tregoff_t)(__ccgo_up(tags + uintptr(i1)*8)) goto _5 _5: ; @@ -133059,10 +133059,10 @@ retry: } tmp = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags if tmp != 0 { - for *(*int32)(unsafe.Pointer(tmp)) >= 0 { + for **(**int32)(__ccgo_up(tmp)) >= 0 { v6 = tmp tmp += 4 - *(*Tregoff_t)(unsafe.Pointer((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(*(*int32)(unsafe.Pointer(v6)))*8)) = pos + **(**Tregoff_t)(__ccgo_up((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(**(**int32)(__ccgo_up(v6)))*8)) = pos } } } @@ -133073,10 +133073,10 @@ retry: } if next_tags != 0 { for { - if !(*(*int32)(unsafe.Pointer(next_tags)) >= 0) { + if !(**(**int32)(__ccgo_up(next_tags)) >= 0) { break } - *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(*(*int32)(unsafe.Pointer(next_tags)))*8)) = pos + **(**Tregoff_t)(__ccgo_up(tags + uintptr(**(**int32)(__ccgo_up(next_tags)))*8)) = pos goto _7 _7: ; @@ -133101,7 +133101,7 @@ _9: if !(i2 < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(i2)*8)) = *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(i2)*8)) + **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(i2)*8)) = **(**Tregoff_t)(__ccgo_up(tags + uintptr(i2)*8)) goto _10 _10: ; @@ -133121,8 +133121,8 @@ _9: /* Get the substring we need to match against. Remember to turn off REG_NOSUB temporarily. */ _tre_fill_pmatch(tls, Uint64FromInt32(bt+int32(1)), pmatch, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags & ^Int32FromInt32(REG_NOSUB), tnfa, tags, pos) - so = (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(bt)*16))).Frm_so - eo = (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(bt)*16))).Frm_eo + so = (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(bt)*16))).Frm_so + eo = (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(bt)*16))).Frm_eo bt_len = eo - so result = Xstrncmp(tls, string1+uintptr(so), str_byte-uintptr(1), Uint64FromInt64(bt_len)) if result == 0 { @@ -133130,15 +133130,15 @@ _9: if bt_len == 0 { empty_br_match = int32(1) } - if empty_br_match != 0 && *(*int32)(unsafe.Pointer(states_seen + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*4)) != 0 { + if empty_br_match != 0 && **(**int32)(__ccgo_up(states_seen + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*4)) != 0 { goto backtrack } - *(*int32)(unsafe.Pointer(states_seen + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*4)) = empty_br_match + **(**int32)(__ccgo_up(states_seen + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*4)) = empty_br_match /* Advance in input string and resync `prev_c', `next_c' and pos. */ str_byte = str_byte + uintptr(bt_len-int64(1)) pos = pos + (bt_len - int64(1)) - prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + prev_c = **(**Ttre_char_t)(__ccgo_up(bp)) pos = pos + pos_add_next v3 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) pos_add_next = v3 @@ -133156,11 +133156,11 @@ _9: } } else { /* Check for end of string. */ - if *(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('\000') { + if **(**Ttre_char_t)(__ccgo_up(bp)) == int32('\000') { goto backtrack } /* Read the next character. */ - prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + prev_c = **(**Ttre_char_t)(__ccgo_up(bp)) pos = pos + pos_add_next v3 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) pos_add_next = v3 @@ -133181,7 +133181,7 @@ _9: break } if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fcode_min <= Uint32FromInt32(prev_c) && (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fcode_max >= Uint32FromInt32(prev_c) { - if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\000') || reg_noteol != 0) && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0 || !(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) || (*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && *(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\000') && BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) == BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || *(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('\000') || BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) != BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && !((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&Int32FromInt32(REG_ICASE) != 0) && !(Xiswctype(tls, Uint32FromInt32(prev_c), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE) != 0 && !(Xiswctype(tls, Xtowlower(tls, Uint32FromInt32(prev_c)), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) && !(Xiswctype(tls, Xtowupper(tls, Uint32FromInt32(prev_c)), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS_NEG) != 0 && _tre_neg_char_classes_match(tls, (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fneg_classes, Uint32FromInt32(prev_c), (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE)) != 0)) { + if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (**(**Ttre_char_t)(__ccgo_up(bp)) != int32('\000') || reg_noteol != 0) && (**(**Ttre_char_t)(__ccgo_up(bp)) != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0 || !(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) || (**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && **(**Ttre_char_t)(__ccgo_up(bp)) != int32('\000') && BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) == BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || **(**Ttre_char_t)(__ccgo_up(bp)) == int32('\000') || BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) != BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && !((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&Int32FromInt32(REG_ICASE) != 0) && !(Xiswctype(tls, Uint32FromInt32(prev_c), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE) != 0 && !(Xiswctype(tls, Xtowlower(tls, Uint32FromInt32(prev_c)), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) && !(Xiswctype(tls, Xtowupper(tls, Uint32FromInt32(prev_c)), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS_NEG) != 0 && _tre_neg_char_classes_match(tls, (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fneg_classes, Uint32FromInt32(prev_c), (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE)) != 0)) { goto _13 } if next_state == UintptrFromInt32(0) { @@ -133233,13 +133233,13 @@ _9: (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstr_byte = str_byte (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate_id = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id - (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fnext_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fnext_c = **(**Ttre_char_t)(__ccgo_up(bp)) i3 = 0 for { if !(i3 < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_tags) { break } - *(*Tregoff_t)(unsafe.Pointer((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(i3)*8)) = *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(i3)*8)) + **(**Tregoff_t)(__ccgo_up((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(i3)*8)) = **(**Tregoff_t)(__ccgo_up(tags + uintptr(i3)*8)) goto _14 _14: ; @@ -133247,10 +133247,10 @@ _9: } tmp1 = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags for { - if !(tmp1 != 0 && *(*int32)(unsafe.Pointer(tmp1)) >= 0) { + if !(tmp1 != 0 && **(**int32)(__ccgo_up(tmp1)) >= 0) { break } - *(*Tregoff_t)(unsafe.Pointer((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(*(*int32)(unsafe.Pointer(tmp1)))*8)) = pos + **(**Tregoff_t)(__ccgo_up((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(**(**int32)(__ccgo_up(tmp1)))*8)) = pos goto _15 _15: ; @@ -133270,10 +133270,10 @@ _9: state = next_state /* Update the tag values. */ if next_tags != 0 { - for *(*int32)(unsafe.Pointer(next_tags)) >= 0 { + for **(**int32)(__ccgo_up(next_tags)) >= 0 { v6 = next_tags next_tags += 4 - *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(*(*int32)(unsafe.Pointer(v6)))*8)) = pos + **(**Tregoff_t)(__ccgo_up(tags + uintptr(**(**int32)(__ccgo_up(v6)))*8)) = pos } } goto _17 @@ -133285,18 +133285,18 @@ backtrack: /* A matching transition was not found. Try to backtrack. */ if (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fprev != 0 { if (*Ttre_tnfa_transition_t)(unsafe.Pointer((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate)).Fassertions&int32(ASSERT_BACKREF) != 0 { - *(*int32)(unsafe.Pointer(states_seen + uintptr((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate_id)*4)) = 0 + **(**int32)(__ccgo_up(states_seen + uintptr((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate_id)*4)) = 0 } pos = (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fpos str_byte = (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstr_byte state = (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate - *(*Ttre_char_t)(unsafe.Pointer(bp)) = (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fnext_c + **(**Ttre_char_t)(__ccgo_up(bp)) = (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fnext_c i4 = 0 for { if !(i4 < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(i4)*8)) = *(*Tregoff_t)(unsafe.Pointer((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(i4)*8)) + **(**Tregoff_t)(__ccgo_up(tags + uintptr(i4)*8)) = **(**Tregoff_t)(__ccgo_up((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(i4)*8)) goto _19 _19: ; @@ -133307,10 +133307,10 @@ backtrack: if match_eo < 0 { /* Try starting from a later position in the input string. */ /* Check for end of string. */ - if *(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('\000') { + if **(**Ttre_char_t)(__ccgo_up(bp)) == int32('\000') { goto _8 } - *(*Ttre_char_t)(unsafe.Pointer(bp)) = next_c_start + **(**Ttre_char_t)(__ccgo_up(bp)) = next_c_start str_byte = str_byte_start goto retry } else { @@ -133328,7 +133328,7 @@ _8: v20 = int32(REG_NOMATCH) } ret = v20 - *(*Tregoff_t)(unsafe.Pointer(match_end_ofs)) = match_eo + **(**Tregoff_t)(__ccgo_up(match_end_ofs)) = match_eo goto error_exit error_exit: ; @@ -133363,22 +133363,22 @@ func _tre_fill_pmatch(tls *TLS, nmatch Tsize_t, pmatch uintptr, cflags int32, tn /* Construct submatch offsets from the tags. */ submatch_data = (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data for i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches && uint64(i) < nmatch { - if (*(*Ttre_submatch_data_t)(unsafe.Pointer(submatch_data + uintptr(i)*16))).Fso_tag == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fend_tag { - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = match_eo + if (**(**Ttre_submatch_data_t)(__ccgo_up(submatch_data + uintptr(i)*16))).Fso_tag == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fend_tag { + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_so = match_eo } else { - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = *(*Tregoff_t)(unsafe.Pointer(tags + uintptr((*(*Ttre_submatch_data_t)(unsafe.Pointer(submatch_data + uintptr(i)*16))).Fso_tag)*8)) + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_so = **(**Tregoff_t)(__ccgo_up(tags + uintptr((**(**Ttre_submatch_data_t)(__ccgo_up(submatch_data + uintptr(i)*16))).Fso_tag)*8)) } - if (*(*Ttre_submatch_data_t)(unsafe.Pointer(submatch_data + uintptr(i)*16))).Feo_tag == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fend_tag { - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = match_eo + if (**(**Ttre_submatch_data_t)(__ccgo_up(submatch_data + uintptr(i)*16))).Feo_tag == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fend_tag { + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_eo = match_eo } else { - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = *(*Tregoff_t)(unsafe.Pointer(tags + uintptr((*(*Ttre_submatch_data_t)(unsafe.Pointer(submatch_data + uintptr(i)*16))).Feo_tag)*8)) + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_eo = **(**Tregoff_t)(__ccgo_up(tags + uintptr((**(**Ttre_submatch_data_t)(__ccgo_up(submatch_data + uintptr(i)*16))).Feo_tag)*8)) } /* If either of the endpoints were not used, this submatch was not part of the match. */ - if (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so == int64(-int32(1)) || (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo == int64(-int32(1)) { + if (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_so == int64(-int32(1)) || (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_eo == int64(-int32(1)) { v1 = int64(-Int32FromInt32(1)) - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = v1 - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = v1 + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_eo = v1 + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_so = v1 } i = i + 1 } @@ -133386,19 +133386,19 @@ func _tre_fill_pmatch(tls *TLS, nmatch Tsize_t, pmatch uintptr, cflags int32, tn submatches. */ i = uint32(0) for i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches && uint64(i) < nmatch { - if (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo == int64(-int32(1)) { + if (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_eo == int64(-int32(1)) { } - parents = (*(*Ttre_submatch_data_t)(unsafe.Pointer(submatch_data + uintptr(i)*16))).Fparents + parents = (**(**Ttre_submatch_data_t)(__ccgo_up(submatch_data + uintptr(i)*16))).Fparents if parents != UintptrFromInt32(0) { j = uint32(0) for { - if !(*(*int32)(unsafe.Pointer(parents + uintptr(j)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(parents + uintptr(j)*4)) >= 0) { break } - if (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so < (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(*(*int32)(unsafe.Pointer(parents + uintptr(j)*4)))*16))).Frm_so || (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo > (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(*(*int32)(unsafe.Pointer(parents + uintptr(j)*4)))*16))).Frm_eo { + if (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_so < (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(**(**int32)(__ccgo_up(parents + uintptr(j)*4)))*16))).Frm_so || (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_eo > (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(**(**int32)(__ccgo_up(parents + uintptr(j)*4)))*16))).Frm_eo { v1 = int64(-Int32FromInt32(1)) - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = v1 - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = v1 + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_eo = v1 + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_so = v1 } goto _2 _2: @@ -133410,8 +133410,8 @@ func _tre_fill_pmatch(tls *TLS, nmatch Tsize_t, pmatch uintptr, cflags int32, tn } } for uint64(i) < nmatch { - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = int64(-int32(1)) - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = int64(-int32(1)) + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_so = int64(-int32(1)) + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_eo = int64(-int32(1)) i = i + 1 } } @@ -133452,7 +133452,7 @@ func Xregexec(tls *TLS, preg uintptr, string1 uintptr, nmatch Tsize_t, pmatch ui } if status == REG_OK { /* A match was found, so fill the submatch registers. */ - _tre_fill_pmatch(tls, nmatch, pmatch, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags, tnfa, tags, *(*Tregoff_t)(unsafe.Pointer(bp))) + _tre_fill_pmatch(tls, nmatch, pmatch, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags, tnfa, tags, **(**Tregoff_t)(__ccgo_up(bp))) } if tags != 0 { Xfree(tls, tags) @@ -133570,8 +133570,8 @@ func X__tre_mem_alloc_impl(tls *TLS, mem Ttre_mem_t, provided int32, provided_bl size = size + v1 /* Allocate from current block. */ ptr = (*Ttre_mem_struct)(unsafe.Pointer(mem)).Fptr - *(*uintptr)(unsafe.Pointer(mem + 16)) += uintptr(size) - *(*Tsize_t)(unsafe.Pointer(mem + 24)) -= size + **(**uintptr)(__ccgo_up(mem + 16)) += uintptr(size) + **(**Tsize_t)(__ccgo_up(mem + 24)) -= size /* Set to zero if needed. */ if zero != 0 { Xmemset(tls, ptr, 0, size) @@ -133636,10 +133636,10 @@ func _keyhash(tls *TLS, k uintptr) (r Tsize_t) { _, _, _ = h, p, v1 p = k h = uint64(0) - for *(*uint8)(unsafe.Pointer(p)) != 0 { + for **(**uint8)(__ccgo_up(p)) != 0 { v1 = p p = p + 1 - h = uint64(31)*h + uint64(*(*uint8)(unsafe.Pointer(v1))) + h = uint64(31)*h + uint64(**(**uint8)(__ccgo_up(v1))) } return h } @@ -133692,7 +133692,7 @@ func _resize(tls *TLS, nel Tsize_t, htab uintptr) (r int32) { j = j + 1 i = i + v4 } - *(*TENTRY)(unsafe.Pointer(newe)) = *(*TENTRY)(unsafe.Pointer(e)) + **(**TENTRY)(__ccgo_up(newe)) = **(**TENTRY)(__ccgo_up(e)) } goto _2 _2: @@ -133748,7 +133748,7 @@ func Xhsearch(tls *TLS, item TENTRY, action TACTION) (r uintptr) { defer tls.Free(16) var _ /* e at bp+0 */ uintptr ___hsearch_r(tls, item, action, bp, uintptr(unsafe.Pointer(&_htab))) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func ___hcreate_r(tls *TLS, nel Tsize_t, htab uintptr) (r1 int32) { @@ -133781,14 +133781,14 @@ func ___hsearch_r(tls *TLS, item TENTRY, action TACTION, retval uintptr, htab ui hash = _keyhash(tls, item.Fkey) e = _lookup(tls, item.Fkey, hash, htab) if (*TENTRY)(unsafe.Pointer(e)).Fkey != 0 { - *(*uintptr)(unsafe.Pointer(retval)) = e + **(**uintptr)(__ccgo_up(retval)) = e return int32(1) } if action == int32(_FIND) { - *(*uintptr)(unsafe.Pointer(retval)) = uintptr(0) + **(**uintptr)(__ccgo_up(retval)) = uintptr(0) return 0 } - *(*TENTRY)(unsafe.Pointer(e)) = item + **(**TENTRY)(__ccgo_up(e)) = item v2 = (*Thsearch_data)(unsafe.Pointer(htab)).F__tab + 16 *(*Tsize_t)(unsafe.Pointer(v2)) = *(*Tsize_t)(unsafe.Pointer(v2)) + 1 v1 = *(*Tsize_t)(unsafe.Pointer(v2)) @@ -133796,12 +133796,12 @@ func ___hsearch_r(tls *TLS, item TENTRY, action TACTION, retval uintptr, htab ui if !(_resize(tls, uint64(2)*(*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused, htab) != 0) { (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused = (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused - 1 (*TENTRY)(unsafe.Pointer(e)).Fkey = uintptr(0) - *(*uintptr)(unsafe.Pointer(retval)) = uintptr(0) + **(**uintptr)(__ccgo_up(retval)) = uintptr(0) return 0 } e = _lookup(tls, item.Fkey, hash, htab) } - *(*uintptr)(unsafe.Pointer(retval)) = e + **(**uintptr)(__ccgo_up(retval)) = e return int32(1) } @@ -133861,7 +133861,7 @@ func Xlsearch(tls *TLS, key uintptr, base uintptr, nelp uintptr, width Tsize_t, defer func() {}() v1 = width p = base - n = *(*Tsize_t)(unsafe.Pointer(nelp)) + n = **(**Tsize_t)(__ccgo_up(nelp)) i = uint64(0) for { if !(i < n) { @@ -133875,7 +133875,7 @@ func Xlsearch(tls *TLS, key uintptr, base uintptr, nelp uintptr, width Tsize_t, ; i = i + 1 } - *(*Tsize_t)(unsafe.Pointer(nelp)) = n + uint64(1) + **(**Tsize_t)(__ccgo_up(nelp)) = n + uint64(1) return Xmemcpy(tls, p+uintptr(n)*uintptr(v1), key, width) } @@ -133893,7 +133893,7 @@ func Xlfind(tls *TLS, key uintptr, base uintptr, nelp uintptr, width Tsize_t, __ defer func() {}() v1 = width p = base - n = *(*Tsize_t)(unsafe.Pointer(nelp)) + n = **(**Tsize_t)(__ccgo_up(nelp)) i = uint64(0) for { if !(i < n) { @@ -133932,7 +133932,7 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui if !(rootp != 0) { return uintptr(0) } - n = *(*uintptr)(unsafe.Pointer(rootp)) + n = **(**uintptr)(__ccgo_up(rootp)) i = 0 /* *a[0] is an arbitrary non-null pointer that is returned when the root node is deleted. */ @@ -133953,34 +133953,34 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui v1 = i i = i + 1 a[v1] = n + 8 + BoolUintptr(c > 0)*8 - n = *(*uintptr)(unsafe.Pointer(n + 8 + BoolUintptr(c > 0)*8)) + n = **(**uintptr)(__ccgo_up(n + 8 + BoolUintptr(c > 0)*8)) goto _3 _3: } - parent = *(*uintptr)(unsafe.Pointer(a[i-int32(2)])) - if *(*uintptr)(unsafe.Pointer(n + 8)) != 0 { + parent = **(**uintptr)(__ccgo_up(a[i-int32(2)])) + if **(**uintptr)(__ccgo_up(n + 8)) != 0 { /* free the preceding node instead of the deleted one. */ deleted = n v1 = i i = i + 1 a[v1] = n + 8 - n = *(*uintptr)(unsafe.Pointer(n + 8)) - for *(*uintptr)(unsafe.Pointer(n + 8 + 1*8)) != 0 { + n = **(**uintptr)(__ccgo_up(n + 8)) + for **(**uintptr)(__ccgo_up(n + 8 + 1*8)) != 0 { v1 = i i = i + 1 a[v1] = n + 8 + 1*8 - n = *(*uintptr)(unsafe.Pointer(n + 8 + 1*8)) + n = **(**uintptr)(__ccgo_up(n + 8 + 1*8)) } (*Tnode1)(unsafe.Pointer(deleted)).Fkey = (*Tnode1)(unsafe.Pointer(n)).Fkey - child = *(*uintptr)(unsafe.Pointer(n + 8)) + child = **(**uintptr)(__ccgo_up(n + 8)) } else { - child = *(*uintptr)(unsafe.Pointer(n + 8 + 1*8)) + child = **(**uintptr)(__ccgo_up(n + 8 + 1*8)) } /* freed node has at most one child, move it up and rebalance. */ Xfree(tls, n) i = i - 1 v1 = i - *(*uintptr)(unsafe.Pointer(a[v1])) = child + **(**uintptr)(__ccgo_up(a[v1])) = child for { i = i - 1 v1 = i @@ -134003,8 +134003,8 @@ func Xtdestroy(tls *TLS, root uintptr, __ccgo_fp_freekey uintptr) { if r == uintptr(0) { return } - Xtdestroy(tls, *(*uintptr)(unsafe.Pointer(r + 8)), __ccgo_fp_freekey) - Xtdestroy(tls, *(*uintptr)(unsafe.Pointer(r + 8 + 1*8)), __ccgo_fp_freekey) + Xtdestroy(tls, **(**uintptr)(__ccgo_up(r + 8)), __ccgo_fp_freekey) + Xtdestroy(tls, **(**uintptr)(__ccgo_up(r + 8 + 1*8)), __ccgo_fp_freekey) if __ccgo_fp_freekey != 0 { (*(*func(*TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_freekey})))(tls, (*Tnode1)(unsafe.Pointer(r)).Fkey) } @@ -134024,7 +134024,7 @@ func Xtfind(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r uint if !(rootp != 0) { return uintptr(0) } - n = *(*uintptr)(unsafe.Pointer(rootp)) + n = **(**uintptr)(__ccgo_up(rootp)) for { if !(n != 0) { break @@ -134033,7 +134033,7 @@ func Xtfind(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r uint if !(c != 0) { break } - n = *(*uintptr)(unsafe.Pointer(n + 8 + BoolUintptr(c > 0)*8)) + n = **(**uintptr)(__ccgo_up(n + 8 + BoolUintptr(c > 0)*8)) goto _1 _1: } @@ -134055,11 +134055,11 @@ func _rot(tls *TLS, p uintptr, x uintptr, dir int32) (r int32) { var hx, hz int32 var y, z uintptr _, _, _, _ = hx, hz, y, z - y = *(*uintptr)(unsafe.Pointer(x + 8 + uintptr(dir)*8)) - z = *(*uintptr)(unsafe.Pointer(y + 8 + BoolUintptr(!(dir != 0))*8)) + y = **(**uintptr)(__ccgo_up(x + 8 + uintptr(dir)*8)) + z = **(**uintptr)(__ccgo_up(y + 8 + BoolUintptr(!(dir != 0))*8)) hx = (*Tnode1)(unsafe.Pointer(x)).Fh hz = _height(tls, z) - if hz > _height(tls, *(*uintptr)(unsafe.Pointer(y + 8 + uintptr(dir)*8))) { + if hz > _height(tls, **(**uintptr)(__ccgo_up(y + 8 + uintptr(dir)*8))) { /* * x * / \ dir z @@ -134067,10 +134067,10 @@ func _rot(tls *TLS, p uintptr, x uintptr, dir int32) (r int32) { * z D /| | * / \ A B C D * B C */ - *(*uintptr)(unsafe.Pointer(x + 8 + uintptr(dir)*8)) = *(*uintptr)(unsafe.Pointer(z + 8 + BoolUintptr(!(dir != 0))*8)) - *(*uintptr)(unsafe.Pointer(y + 8 + BoolUintptr(!(dir != 0))*8)) = *(*uintptr)(unsafe.Pointer(z + 8 + uintptr(dir)*8)) - *(*uintptr)(unsafe.Pointer(z + 8 + BoolUintptr(!(dir != 0))*8)) = x - *(*uintptr)(unsafe.Pointer(z + 8 + uintptr(dir)*8)) = y + **(**uintptr)(__ccgo_up(x + 8 + uintptr(dir)*8)) = **(**uintptr)(__ccgo_up(z + 8 + BoolUintptr(!(dir != 0))*8)) + **(**uintptr)(__ccgo_up(y + 8 + BoolUintptr(!(dir != 0))*8)) = **(**uintptr)(__ccgo_up(z + 8 + uintptr(dir)*8)) + **(**uintptr)(__ccgo_up(z + 8 + BoolUintptr(!(dir != 0))*8)) = x + **(**uintptr)(__ccgo_up(z + 8 + uintptr(dir)*8)) = y (*Tnode1)(unsafe.Pointer(x)).Fh = hz (*Tnode1)(unsafe.Pointer(y)).Fh = hz (*Tnode1)(unsafe.Pointer(z)).Fh = hz + int32(1) @@ -134080,13 +134080,13 @@ func _rot(tls *TLS, p uintptr, x uintptr, dir int32) (r int32) { * / \ / * A y --> x D * / \ / * z D A z */ - *(*uintptr)(unsafe.Pointer(x + 8 + uintptr(dir)*8)) = z - *(*uintptr)(unsafe.Pointer(y + 8 + BoolUintptr(!(dir != 0))*8)) = x + **(**uintptr)(__ccgo_up(x + 8 + uintptr(dir)*8)) = z + **(**uintptr)(__ccgo_up(y + 8 + BoolUintptr(!(dir != 0))*8)) = x (*Tnode1)(unsafe.Pointer(x)).Fh = hz + int32(1) (*Tnode1)(unsafe.Pointer(y)).Fh = hz + int32(2) z = y } - *(*uintptr)(unsafe.Pointer(p)) = z + **(**uintptr)(__ccgo_up(p)) = z return (*Tnode1)(unsafe.Pointer(z)).Fh - hx } @@ -134101,9 +134101,9 @@ func X__tsearch_balance(tls *TLS, p uintptr) (r int32) { var h0, h1, old, v1 int32 var n uintptr _, _, _, _, _ = h0, h1, n, old, v1 - n = *(*uintptr)(unsafe.Pointer(p)) - h0 = _height(tls, *(*uintptr)(unsafe.Pointer(n + 8))) - h1 = _height(tls, *(*uintptr)(unsafe.Pointer(n + 8 + 1*8))) + n = **(**uintptr)(__ccgo_up(p)) + h0 = _height(tls, **(**uintptr)(__ccgo_up(n + 8))) + h1 = _height(tls, **(**uintptr)(__ccgo_up(n + 8 + 1*8))) if Uint32FromInt32(h0-h1)+uint32(1) < uint32(3) { old = (*Tnode1)(unsafe.Pointer(n)).Fh if h0 < h1 { @@ -134132,7 +134132,7 @@ func Xtsearch(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r1 u if !(rootp != 0) { return uintptr(0) } - n = *(*uintptr)(unsafe.Pointer(rootp)) + n = **(**uintptr)(__ccgo_up(rootp)) i = 0 v1 = i i = i + 1 @@ -134148,7 +134148,7 @@ func Xtsearch(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r1 u v1 = i i = i + 1 a[v1] = n + 8 + BoolUintptr(c > 0)*8 - n = *(*uintptr)(unsafe.Pointer(n + 8 + BoolUintptr(c > 0)*8)) + n = **(**uintptr)(__ccgo_up(n + 8 + BoolUintptr(c > 0)*8)) goto _2 _2: } @@ -134158,13 +134158,13 @@ func Xtsearch(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r1 u } (*Tnode1)(unsafe.Pointer(r)).Fkey = key v4 = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(r + 8 + 1*8)) = v4 - *(*uintptr)(unsafe.Pointer(r + 8)) = v4 + **(**uintptr)(__ccgo_up(r + 8 + 1*8)) = v4 + **(**uintptr)(__ccgo_up(r + 8)) = v4 (*Tnode1)(unsafe.Pointer(r)).Fh = int32(1) /* insert new node, rebalance ancestors. */ i = i - 1 v1 = i - *(*uintptr)(unsafe.Pointer(a[v1])) = r + **(**uintptr)(__ccgo_up(a[v1])) = r for { if v7 = i != 0; v7 { i = i - 1 @@ -134185,9 +134185,9 @@ func _walk(tls *TLS, r uintptr, __ccgo_fp_action uintptr, d int32) { (*(*func(*TLS, uintptr, TVISIT, int32))(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_action})))(tls, r, int32(_leaf), d) } else { (*(*func(*TLS, uintptr, TVISIT, int32))(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_action})))(tls, r, int32(_preorder), d) - _walk(tls, *(*uintptr)(unsafe.Pointer(r + 8)), __ccgo_fp_action, d+int32(1)) + _walk(tls, **(**uintptr)(__ccgo_up(r + 8)), __ccgo_fp_action, d+int32(1)) (*(*func(*TLS, uintptr, TVISIT, int32))(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_action})))(tls, r, int32(_postorder), d) - _walk(tls, *(*uintptr)(unsafe.Pointer(r + 8 + 1*8)), __ccgo_fp_action, d+int32(1)) + _walk(tls, **(**uintptr)(__ccgo_up(r + 8 + 1*8)), __ccgo_fp_action, d+int32(1)) (*(*func(*TLS, uintptr, TVISIT, int32))(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_action})))(tls, r, int32(_endorder), d) } } @@ -134256,7 +134256,7 @@ func Xpselect(tls *TLS, n int32, rfds uintptr, wfds uintptr, efds uintptr, ts ui var v3 uintptr var _ /* data at bp+16 */ [2]Tsyscall_arg_t _, _, _, _, _ = ns, s, v1, v2, v3 - *(*[2]Tsyscall_arg_t)(unsafe.Pointer(bp + 16)) = [2]Tsyscall_arg_t{ + **(**[2]Tsyscall_arg_t)(__ccgo_up(bp + 16)) = [2]Tsyscall_arg_t{ 0: Int64FromUint64(uint64(mask)), 1: int64(Int32FromInt32(_NSIG) / Int32FromInt32(8)), } @@ -134375,10 +134375,10 @@ func Xgetitimer(tls *TLS, which int32, old uintptr) (r1 int32) { if uint64(8) > uint64(8) { r = int32(X__syscall2(tls, int64(SYS_getitimer), int64(which), int64(bp))) if !(r != 0) { - (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_sec = (*(*[4]int64)(unsafe.Pointer(bp)))[0] - (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_usec = (*(*[4]int64)(unsafe.Pointer(bp)))[int32(1)] - (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_sec = (*(*[4]int64)(unsafe.Pointer(bp)))[int32(2)] - (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_usec = (*(*[4]int64)(unsafe.Pointer(bp)))[int32(3)] + (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_sec = (**(**[4]int64)(__ccgo_up(bp)))[0] + (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_usec = (**(**[4]int64)(__ccgo_up(bp)))[int32(1)] + (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_sec = (**(**[4]int64)(__ccgo_up(bp)))[int32(2)] + (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_usec = (**(**[4]int64)(__ccgo_up(bp)))[int32(3)] } return int32(X__syscall_ret(tls, Uint64FromInt32(r))) } @@ -134399,7 +134399,7 @@ func Xkillpg(tls *TLS, pgid Tpid_t, sig int32) (r int32) { defer func() { trc("-> %v", r) }() } if pgid < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } return Xkill(tls, -pgid, sig) @@ -134435,7 +134435,7 @@ func Xpsignal(tls *TLS, sig int32, msg uintptr) { * not permitted to do so. */ old_locale = (*TFILE)(unsafe.Pointer(f)).Flocale old_mode = (*TFILE)(unsafe.Pointer(f)).Fmode - old_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + old_errno = **(**int32)(__ccgo_up(X__errno_location(tls))) if msg != 0 { v2 = msg } else { @@ -134447,7 +134447,7 @@ func Xpsignal(tls *TLS, sig int32, msg uintptr) { v3 = __ccgo_ts } if Xfprintf(tls, f, __ccgo_ts+1089, VaList(bp+8, v2, v3, s)) >= 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = old_errno + **(**int32)(__ccgo_up(X__errno_location(tls))) = old_errno } (*TFILE)(unsafe.Pointer(f)).Fmode = old_mode (*TFILE)(unsafe.Pointer(f)).Flocale = old_locale @@ -134514,10 +134514,10 @@ func Xsetitimer(tls *TLS, which int32, new1 uintptr, old uintptr) (r1 int32) { } r = int32(X__syscall3(tls, int64(SYS_setitimer), int64(which), int64(bp), int64(bp+32))) if !(r != 0) && old != 0 { - (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_sec = (*(*[4]int64)(unsafe.Pointer(bp + 32)))[0] - (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_usec = (*(*[4]int64)(unsafe.Pointer(bp + 32)))[int32(1)] - (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_sec = (*(*[4]int64)(unsafe.Pointer(bp + 32)))[int32(2)] - (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_usec = (*(*[4]int64)(unsafe.Pointer(bp + 32)))[int32(3)] + (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_sec = (**(**[4]int64)(__ccgo_up(bp + 32)))[0] + (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_usec = (**(**[4]int64)(__ccgo_up(bp + 32)))[int32(1)] + (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_sec = (**(**[4]int64)(__ccgo_up(bp + 32)))[int32(2)] + (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_usec = (**(**[4]int64)(__ccgo_up(bp + 32)))[int32(3)] } return int32(X__syscall_ret(tls, Uint64FromInt32(r))) } @@ -134596,15 +134596,15 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old uintptr) (r1 int32) X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 88, __ccgo_ts+1504) } } - (*(*Tk_sigaction)(unsafe.Pointer(bp + 8))).Fhandler = *(*uintptr)(unsafe.Pointer(sa)) - (*(*Tk_sigaction)(unsafe.Pointer(bp + 8))).Fflags = Uint64FromInt32((*Tsigaction)(unsafe.Pointer(sa)).Fsa_flags) - (*(*Tk_sigaction)(unsafe.Pointer(bp + 8))).Fflags |= uint64(SA_RESTORER) + (**(**Tk_sigaction)(__ccgo_up(bp + 8))).Fhandler = *(*uintptr)(unsafe.Pointer(sa)) + (**(**Tk_sigaction)(__ccgo_up(bp + 8))).Fflags = Uint64FromInt32((*Tsigaction)(unsafe.Pointer(sa)).Fsa_flags) + (**(**Tk_sigaction)(__ccgo_up(bp + 8))).Fflags |= uint64(SA_RESTORER) if (*Tsigaction)(unsafe.Pointer(sa)).Fsa_flags&int32(SA_SIGINFO) != 0 { v1 = __ccgo_fp(X__restore_rt) } else { v1 = __ccgo_fp(X__restore_rt) } - (*(*Tk_sigaction)(unsafe.Pointer(bp + 8))).Frestorer = v1 + (**(**Tk_sigaction)(__ccgo_up(bp + 8))).Frestorer = v1 Xmemcpy(tls, bp+8+24, sa+8, Uint64FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))) } if sa != 0 { @@ -134619,8 +134619,8 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old uintptr) (r1 int32) } r = int32(X__syscall4(tls, int64(SYS_rt_sigaction), int64(sig), int64(v1), int64(v3), int64(Int32FromInt32(_NSIG)/Int32FromInt32(8)))) if old != 0 && !(r != 0) { - *(*uintptr)(unsafe.Pointer(old)) = (*(*Tk_sigaction)(unsafe.Pointer(bp + 40))).Fhandler - (*Tsigaction)(unsafe.Pointer(old)).Fsa_flags = Int32FromUint64((*(*Tk_sigaction)(unsafe.Pointer(bp + 40))).Fflags) + *(*uintptr)(unsafe.Pointer(old)) = (**(**Tk_sigaction)(__ccgo_up(bp + 40))).Fhandler + (*Tsigaction)(unsafe.Pointer(old)).Fsa_flags = Int32FromUint64((**(**Tk_sigaction)(__ccgo_up(bp + 40))).Fflags) Xmemcpy(tls, old+8, bp+40+24, Uint64FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))) } return int32(X__syscall_ret(tls, Uint64FromInt32(r))) @@ -134637,7 +134637,7 @@ func X__sigaction(tls *TLS, sig int32, sa uintptr, old uintptr) (r1 int32) { var _ /* set at bp+0 */ [1]uint64 _ = r if Uint32FromInt32(sig)-uint32(32) < uint32(3) || Uint32FromInt32(sig)-uint32(1) >= Uint32FromInt32(Int32FromInt32(_NSIG)-Int32FromInt32(1)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } /* Doing anything with the disposition of SIGABRT requires a lock, @@ -134672,10 +134672,10 @@ func Xsigaddset(tls *TLS, set uintptr, sig int32) (r int32) { _ = s s = Uint32FromInt32(sig - int32(1)) if s >= Uint32FromInt32(Int32FromInt32(_NSIG)-Int32FromInt32(1)) || Uint32FromInt32(sig)-uint32(32) < uint32(3) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } - *(*uint64)(unsafe.Pointer(set + uintptr(uint64(s/uint32(8))/uint64(8))*8)) |= uint64(1) << (uint64(s) & (Uint64FromInt32(8)*Uint64FromInt64(8) - Uint64FromInt32(1))) + **(**uint64)(__ccgo_up(set + uintptr(uint64(s/uint32(8))/uint64(8))*8)) |= uint64(1) << (uint64(s) & (Uint64FromInt32(8)*Uint64FromInt64(8) - Uint64FromInt32(1))) return 0 } @@ -134686,11 +134686,11 @@ func Xsigaltstack(tls *TLS, ss uintptr, old uintptr) (r int32) { } if ss != 0 { if !((*Tstack_t)(unsafe.Pointer(ss)).Fss_flags&Int32FromInt32(SS_DISABLE) != 0) && (*Tstack_t)(unsafe.Pointer(ss)).Fss_size < uint64(MINSIGSTKSZ) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return -int32(1) } if (*Tstack_t)(unsafe.Pointer(ss)).Fss_flags&int32(SS_ONSTACK) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } } @@ -134715,7 +134715,7 @@ func Xsigandset(tls *TLS, dest uintptr, left uintptr, right uintptr) (r1 int32) if !(i < Uint64FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))/Uint64FromInt64(8)) { break } - *(*uint64)(unsafe.Pointer(d + uintptr(i)*8)) = *(*uint64)(unsafe.Pointer(l + uintptr(i)*8)) & *(*uint64)(unsafe.Pointer(r + uintptr(i)*8)) + **(**uint64)(__ccgo_up(d + uintptr(i)*8)) = **(**uint64)(__ccgo_up(l + uintptr(i)*8)) & **(**uint64)(__ccgo_up(r + uintptr(i)*8)) goto _1 _1: ; @@ -134733,10 +134733,10 @@ func Xsigdelset(tls *TLS, set uintptr, sig int32) (r int32) { _ = s s = Uint32FromInt32(sig - int32(1)) if s >= Uint32FromInt32(Int32FromInt32(_NSIG)-Int32FromInt32(1)) || Uint32FromInt32(sig)-uint32(32) < uint32(3) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } - *(*uint64)(unsafe.Pointer(set + uintptr(uint64(s/uint32(8))/uint64(8))*8)) &= ^(Uint64FromUint64(1) << (uint64(s) & (Uint64FromInt32(8)*Uint64FromInt64(8) - Uint64FromInt32(1)))) + **(**uint64)(__ccgo_up(set + uintptr(uint64(s/uint32(8))/uint64(8))*8)) &= ^(Uint64FromUint64(1) << (uint64(s) & (Uint64FromInt32(8)*Uint64FromInt64(8) - Uint64FromInt32(1)))) return 0 } @@ -134745,13 +134745,13 @@ func Xsigemptyset(tls *TLS, set uintptr) (r int32) { trc("tls=%v set=%v, (%v:)", tls, set, origin(2)) defer func() { trc("-> %v", r) }() } - *(*uint64)(unsafe.Pointer(set)) = uint64(0) + **(**uint64)(__ccgo_up(set)) = uint64(0) if Bool(uint64(8) == uint64(4)) || Bool(int32(_NSIG) > int32(65)) { - *(*uint64)(unsafe.Pointer(set + 1*8)) = uint64(0) + **(**uint64)(__ccgo_up(set + 1*8)) = uint64(0) } if Bool(uint64(8) == uint64(4)) && Bool(int32(_NSIG) > int32(65)) { - *(*uint64)(unsafe.Pointer(set + 2*8)) = uint64(0) - *(*uint64)(unsafe.Pointer(set + 3*8)) = uint64(0) + **(**uint64)(__ccgo_up(set + 2*8)) = uint64(0) + **(**uint64)(__ccgo_up(set + 3*8)) = uint64(0) } return 0 } @@ -134770,9 +134770,9 @@ func Xsigfillset(tls *TLS, set uintptr) (r int32) { trc("tls=%v set=%v, (%v:)", tls, set, origin(2)) defer func() { trc("-> %v", r) }() } - *(*uint64)(unsafe.Pointer(set)) = uint64(0xfffffffc7fffffff) + **(**uint64)(__ccgo_up(set)) = uint64(0xfffffffc7fffffff) if int32(_NSIG) > int32(65) { - *(*uint64)(unsafe.Pointer(set + 1*8)) = uint64(0xffffffffffffffff) + **(**uint64)(__ccgo_up(set + 1*8)) = uint64(0xffffffffffffffff) } return 0 } @@ -134789,7 +134789,7 @@ func Xsigisemptyset(tls *TLS, set uintptr) (r int32) { if !(i < Uint64FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))/Uint64FromInt64(8)) { break } - if *(*uint64)(unsafe.Pointer(set + uintptr(i)*8)) != 0 { + if **(**uint64)(__ccgo_up(set + uintptr(i)*8)) != 0 { return 0 } goto _1 @@ -134811,7 +134811,7 @@ func Xsigismember(tls *TLS, set uintptr, sig int32) (r int32) { if s >= Uint32FromInt32(Int32FromInt32(_NSIG)-Int32FromInt32(1)) { return 0 } - return BoolInt32(!!(*(*uint64)(unsafe.Pointer(set + uintptr(uint64(s/uint32(8))/uint64(8))*8))&(Uint64FromUint64(1)<<(uint64(s)&(Uint64FromInt32(8)*Uint64FromInt64(8)-Uint64FromInt32(1)))) != 0)) + return BoolInt32(!!(**(**uint64)(__ccgo_up(set + uintptr(uint64(s/uint32(8))/uint64(8))*8))&(Uint64FromUint64(1)<<(uint64(s)&(Uint64FromInt32(8)*Uint64FromInt64(8)-Uint64FromInt32(1)))) != 0)) } func Xsigorset(tls *TLS, dest uintptr, left uintptr, right uintptr) (r1 int32) { @@ -134830,7 +134830,7 @@ func Xsigorset(tls *TLS, dest uintptr, left uintptr, right uintptr) (r1 int32) { if !(i < Uint64FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))/Uint64FromInt64(8)) { break } - *(*uint64)(unsafe.Pointer(d + uintptr(i)*8)) = *(*uint64)(unsafe.Pointer(l + uintptr(i)*8)) | *(*uint64)(unsafe.Pointer(r + uintptr(i)*8)) + **(**uint64)(__ccgo_up(d + uintptr(i)*8)) = **(**uint64)(__ccgo_up(l + uintptr(i)*8)) | **(**uint64)(__ccgo_up(r + uintptr(i)*8)) goto _1 _1: ; @@ -134858,7 +134858,7 @@ func Xsigprocmask(tls *TLS, how int32, set uintptr, old uintptr) (r1 int32) { if !(r != 0) { return r } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = r + **(**int32)(__ccgo_up(X__errno_location(tls))) = r return -int32(1) } @@ -134874,8 +134874,8 @@ func Xsigqueue(tls *TLS, pid Tpid_t, sig int32, value Tsigval) (r1 int32) { var _ /* si at bp+0 */ Tsiginfo_t _ = r Xmemset(tls, bp, 0, uint64(128)) - (*(*Tsiginfo_t)(unsafe.Pointer(bp))).Fsi_signo = sig - (*(*Tsiginfo_t)(unsafe.Pointer(bp))).Fsi_code = -int32(1) + (**(**Tsiginfo_t)(__ccgo_up(bp))).Fsi_signo = sig + (**(**Tsiginfo_t)(__ccgo_up(bp))).Fsi_code = -int32(1) *(*Tsigval)(unsafe.Pointer(bp + 16 + 8)) = value *(*Tuid_t)(unsafe.Pointer(bp + 16 + 4)) = Xgetuid(tls) X__block_app_sigs(tls, bp+128) @@ -134971,7 +134971,7 @@ func Xsigwait(tls *TLS, mask uintptr, sig uintptr) (r int32) { if Xsigtimedwait(tls, mask, bp, uintptr(0)) < 0 { return -int32(1) } - *(*int32)(unsafe.Pointer(sig)) = (*(*Tsiginfo_t)(unsafe.Pointer(bp))).Fsi_signo + **(**int32)(__ccgo_up(sig)) = (**(**Tsiginfo_t)(__ccgo_up(bp))).Fsi_signo return 0 } @@ -135020,7 +135020,7 @@ func X__xmknod(tls *TLS, ver int32, path uintptr, mode Tmode_t, dev uintptr) (r trc("tls=%v ver=%v path=%v mode=%v dev=%v, (%v:)", tls, ver, path, mode, dev, origin(2)) defer func() { trc("-> %v", r) }() } - return Xmknod(tls, path, mode, *(*Tdev_t)(unsafe.Pointer(dev))) + return Xmknod(tls, path, mode, **(**Tdev_t)(__ccgo_up(dev))) } func X__xmknodat(tls *TLS, ver int32, fd int32, path uintptr, mode Tmode_t, dev uintptr) (r int32) { @@ -135028,7 +135028,7 @@ func X__xmknodat(tls *TLS, ver int32, fd int32, path uintptr, mode Tmode_t, dev trc("tls=%v ver=%v fd=%v path=%v mode=%v dev=%v, (%v:)", tls, ver, fd, path, mode, dev, origin(2)) defer func() { trc("-> %v", r) }() } - return Xmknodat(tls, fd, path, mode, *(*Tdev_t)(unsafe.Pointer(dev))) + return Xmknodat(tls, fd, path, mode, **(**Tdev_t)(__ccgo_up(dev))) } func Xchmod(tls *TLS, path uintptr, mode Tmode_t) (r int32) { @@ -135081,7 +135081,7 @@ func Xfchmodat(tls *TLS, fd int32, path uintptr, mode Tmode_t, flag int32) (r in if Xfstatat(tls, fd, path, bp, flag) != 0 { return -int32(1) } - if (*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { + if (**(**Tstat)(__ccgo_up(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { return int32(X__syscall_ret(tls, Uint64FromInt32(-Int32FromInt32(EOPNOTSUPP)))) } v1 = int32(X__syscall3(tls, int64(SYS_openat), int64(fd), int64(path), int64(Int32FromInt32(O_RDONLY)|Int32FromInt32(O_PATH)|Int32FromInt32(O_NOFOLLOW)|Int32FromInt32(O_NOCTTY)|Int32FromInt32(O_CLOEXEC)))) @@ -135095,7 +135095,7 @@ func Xfchmodat(tls *TLS, fd int32, path uintptr, mode Tmode_t, flag int32) (r in X__procfdname(tls, bp+144, Uint32FromInt32(fd2)) ret = Xstat(tls, bp+144, bp) if !(ret != 0) { - if (*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { + if (**(**Tstat)(__ccgo_up(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { ret = int32(X__syscall_ret(tls, Uint64FromInt32(-Int32FromInt32(EOPNOTSUPP)))) } else { ret = int32(X__syscall_ret(tls, Uint64FromInt64(X__syscall3(tls, int64(SYS_fchmodat), int64(-Int32FromInt32(100)), int64(bp+144), Int64FromUint32(mode))))) @@ -135175,28 +135175,28 @@ func _fstatat_statx(tls *TLS, fd int32, path uintptr, st uintptr, flag int32) (r if ret != 0 { return ret } - *(*Tstat)(unsafe.Pointer(st)) = Tstat{ - Fst_dev: uint64(uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_dev_major)&Uint64FromUint64(0xfffff000)<= 0 && !(*(*int8)(unsafe.Pointer(path)) != 0) { + if flag == int32(AT_EMPTY_PATH) && fd >= 0 && !(**(**int8)(__ccgo_up(path)) != 0) { ret = int32(X__syscall2(tls, int64(SYS_fstat), int64(fd), int64(bp))) if ret == -int32(EBADF) && X__syscall2(tls, int64(SYS_fcntl), int64(fd), int64(Int32FromInt32(F_GETFD))) >= 0 { ret = int32(X__syscall4(tls, int64(SYS_newfstatat), int64(fd), int64(path), int64(bp), int64(flag))) @@ -135240,10 +135240,10 @@ func _fstatat_kstat(tls *TLS, fd int32, path uintptr, st uintptr, flag int32) (r } } } else { - if (fd == -int32(100) || int32(*(*int8)(unsafe.Pointer(path))) == int32('/')) && flag == int32(AT_SYMLINK_NOFOLLOW) { + if (fd == -int32(100) || int32(**(**int8)(__ccgo_up(path))) == int32('/')) && flag == int32(AT_SYMLINK_NOFOLLOW) { ret = int32(X__syscall2(tls, int64(SYS_lstat), int64(path), int64(bp))) } else { - if (fd == -int32(100) || int32(*(*int8)(unsafe.Pointer(path))) == int32('/')) && !(flag != 0) { + if (fd == -int32(100) || int32(**(**int8)(__ccgo_up(path))) == int32('/')) && !(flag != 0) { ret = int32(X__syscall2(tls, int64(SYS_stat), int64(path), int64(bp))) } else { ret = int32(X__syscall4(tls, int64(SYS_newfstatat), int64(fd), int64(path), int64(bp), int64(flag))) @@ -135253,28 +135253,28 @@ func _fstatat_kstat(tls *TLS, fd int32, path uintptr, st uintptr, flag int32) (r if ret != 0 { return ret } - *(*Tstat)(unsafe.Pointer(st)) = Tstat{ - Fst_dev: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_dev, - Fst_ino: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_ino, - Fst_nlink: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_nlink, - Fst_mode: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_mode, - Fst_uid: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_uid, - Fst_gid: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_gid, - Fst_rdev: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_rdev, - Fst_size: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_size, - Fst_blksize: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_blksize, - Fst_blocks: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_blocks, + **(**Tstat)(__ccgo_up(st)) = Tstat{ + Fst_dev: (**(**Tkstat)(__ccgo_up(bp))).Fst_dev, + Fst_ino: (**(**Tkstat)(__ccgo_up(bp))).Fst_ino, + Fst_nlink: (**(**Tkstat)(__ccgo_up(bp))).Fst_nlink, + Fst_mode: (**(**Tkstat)(__ccgo_up(bp))).Fst_mode, + Fst_uid: (**(**Tkstat)(__ccgo_up(bp))).Fst_uid, + Fst_gid: (**(**Tkstat)(__ccgo_up(bp))).Fst_gid, + Fst_rdev: (**(**Tkstat)(__ccgo_up(bp))).Fst_rdev, + Fst_size: (**(**Tkstat)(__ccgo_up(bp))).Fst_size, + Fst_blksize: (**(**Tkstat)(__ccgo_up(bp))).Fst_blksize, + Fst_blocks: (**(**Tkstat)(__ccgo_up(bp))).Fst_blocks, Fst_atim: Ttimespec{ - Ftv_sec: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_atime_sec, - Ftv_nsec: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_atime_nsec, + Ftv_sec: (**(**Tkstat)(__ccgo_up(bp))).Fst_atime_sec, + Ftv_nsec: (**(**Tkstat)(__ccgo_up(bp))).Fst_atime_nsec, }, Fst_mtim: Ttimespec{ - Ftv_sec: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_mtime_sec, - Ftv_nsec: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_mtime_nsec, + Ftv_sec: (**(**Tkstat)(__ccgo_up(bp))).Fst_mtime_sec, + Ftv_nsec: (**(**Tkstat)(__ccgo_up(bp))).Fst_mtime_nsec, }, Fst_ctim: Ttimespec{ - Ftv_sec: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_ctime_sec, - Ftv_nsec: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_ctime_nsec, + Ftv_sec: (**(**Tkstat)(__ccgo_up(bp))).Fst_ctime_sec, + Ftv_nsec: (**(**Tkstat)(__ccgo_up(bp))).Fst_ctime_nsec, }, } return 0 @@ -135330,11 +135330,11 @@ func X__futimesat(tls *TLS, dirfd int32, pathname uintptr, times uintptr) (r int if !(i < int32(2)) { break } - if Uint64FromInt64((*(*Ttimeval)(unsafe.Pointer(times + uintptr(i)*16))).Ftv_usec) >= uint64(1000000) { + if Uint64FromInt64((**(**Ttimeval)(__ccgo_up(times + uintptr(i)*16))).Ftv_usec) >= uint64(1000000) { return int32(X__syscall_ret(tls, Uint64FromInt32(-Int32FromInt32(EINVAL)))) } - (*(*[2]Ttimespec)(unsafe.Pointer(bp)))[i].Ftv_sec = (*(*Ttimeval)(unsafe.Pointer(times + uintptr(i)*16))).Ftv_sec - (*(*[2]Ttimespec)(unsafe.Pointer(bp)))[i].Ftv_nsec = (*(*Ttimeval)(unsafe.Pointer(times + uintptr(i)*16))).Ftv_usec * int64(1000) + (**(**[2]Ttimespec)(__ccgo_up(bp)))[i].Ftv_sec = (**(**Ttimeval)(__ccgo_up(times + uintptr(i)*16))).Ftv_sec + (**(**[2]Ttimespec)(__ccgo_up(bp)))[i].Ftv_nsec = (**(**Ttimeval)(__ccgo_up(times + uintptr(i)*16))).Ftv_usec * int64(1000) goto _1 _1: ; @@ -135430,7 +135430,7 @@ func Xstat(tls *TLS, path uintptr, buf uintptr) (r int32) { } func ___statfs(tls *TLS, path uintptr, buf uintptr) (r int32) { - *(*Tstatfs)(unsafe.Pointer(buf)) = Tstatfs{} + **(**Tstatfs)(__ccgo_up(buf)) = Tstatfs{} return int32(X__syscall_ret(tls, Uint64FromInt64(X__syscall2(tls, int64(SYS_statfs), int64(path), int64(buf))))) } @@ -135439,14 +135439,14 @@ func Xfstatfs(tls *TLS, fd int32, buf uintptr) (r int32) { trc("tls=%v fd=%v buf=%v, (%v:)", tls, fd, buf, origin(2)) defer func() { trc("-> %v", r) }() } - *(*Tstatfs)(unsafe.Pointer(buf)) = Tstatfs{} + **(**Tstatfs)(__ccgo_up(buf)) = Tstatfs{} return int32(X__syscall_ret(tls, Uint64FromInt64(X__syscall2(tls, int64(SYS_fstatfs), int64(fd), int64(buf))))) } func _fixup(tls *TLS, out uintptr, in uintptr) { var v1 uint64 _ = v1 - *(*Tstatvfs)(unsafe.Pointer(out)) = Tstatvfs{} + **(**Tstatvfs)(__ccgo_up(out)) = Tstatvfs{} (*Tstatvfs)(unsafe.Pointer(out)).Ff_bsize = (*Tstatfs)(unsafe.Pointer(in)).Ff_bsize if (*Tstatfs)(unsafe.Pointer(in)).Ff_frsize != 0 { v1 = (*Tstatfs)(unsafe.Pointer(in)).Ff_frsize @@ -135460,7 +135460,7 @@ func _fixup(tls *TLS, out uintptr, in uintptr) { (*Tstatvfs)(unsafe.Pointer(out)).Ff_files = (*Tstatfs)(unsafe.Pointer(in)).Ff_files (*Tstatvfs)(unsafe.Pointer(out)).Ff_ffree = (*Tstatfs)(unsafe.Pointer(in)).Ff_ffree (*Tstatvfs)(unsafe.Pointer(out)).Ff_favail = (*Tstatfs)(unsafe.Pointer(in)).Ff_ffree - (*Tstatvfs)(unsafe.Pointer(out)).Ff_fsid = Uint64FromInt32(*(*int32)(unsafe.Pointer(in + 56))) + (*Tstatvfs)(unsafe.Pointer(out)).Ff_fsid = Uint64FromInt32(**(**int32)(__ccgo_up(in + 56))) (*Tstatvfs)(unsafe.Pointer(out)).Ff_flag = (*Tstatfs)(unsafe.Pointer(in)).Ff_flags (*Tstatvfs)(unsafe.Pointer(out)).Ff_namemax = (*Tstatfs)(unsafe.Pointer(in)).Ff_namelen (*Tstatvfs)(unsafe.Pointer(out)).Ff_type = uint32((*Tstatfs)(unsafe.Pointer(in)).Ff_type) @@ -135515,7 +135515,7 @@ func Xutimensat(tls *TLS, fd int32, path uintptr, times uintptr, flags int32) (r var tv uintptr var _ /* tmp at bp+0 */ [4]int64 _, _, _ = i, r, tv - if times != 0 && (*(*Ttimespec)(unsafe.Pointer(times))).Ftv_nsec == int64(UTIME_NOW) && (*(*Ttimespec)(unsafe.Pointer(times + 1*16))).Ftv_nsec == int64(UTIME_NOW) { + if times != 0 && (**(**Ttimespec)(__ccgo_up(times))).Ftv_nsec == int64(UTIME_NOW) && (**(**Ttimespec)(__ccgo_up(times + 1*16))).Ftv_nsec == int64(UTIME_NOW) { times = uintptr(0) } r = int32(X__syscall4(tls, int64(SYS_utimensat), int64(fd), int64(path), int64(times), int64(flags))) @@ -135530,14 +135530,14 @@ func Xutimensat(tls *TLS, fd int32, path uintptr, times uintptr, flags int32) (r if !(i < int32(2)) { break } - if Uint64FromInt64((*(*Ttimespec)(unsafe.Pointer(times + uintptr(i)*16))).Ftv_nsec) >= uint64(1000000000) { - if (*(*Ttimespec)(unsafe.Pointer(times + uintptr(i)*16))).Ftv_nsec == int64(UTIME_NOW) || (*(*Ttimespec)(unsafe.Pointer(times + uintptr(i)*16))).Ftv_nsec == int64(UTIME_OMIT) { + if Uint64FromInt64((**(**Ttimespec)(__ccgo_up(times + uintptr(i)*16))).Ftv_nsec) >= uint64(1000000000) { + if (**(**Ttimespec)(__ccgo_up(times + uintptr(i)*16))).Ftv_nsec == int64(UTIME_NOW) || (**(**Ttimespec)(__ccgo_up(times + uintptr(i)*16))).Ftv_nsec == int64(UTIME_OMIT) { return int32(X__syscall_ret(tls, Uint64FromInt32(-Int32FromInt32(ENOSYS)))) } return int32(X__syscall_ret(tls, Uint64FromInt32(-Int32FromInt32(EINVAL)))) } - (*(*[4]int64)(unsafe.Pointer(bp)))[int32(2)*i+0] = (*(*Ttimespec)(unsafe.Pointer(times + uintptr(i)*16))).Ftv_sec - (*(*[4]int64)(unsafe.Pointer(bp)))[int32(2)*i+int32(1)] = (*(*Ttimespec)(unsafe.Pointer(times + uintptr(i)*16))).Ftv_nsec / int64(1000) + (**(**[4]int64)(__ccgo_up(bp)))[int32(2)*i+0] = (**(**Ttimespec)(__ccgo_up(times + uintptr(i)*16))).Ftv_sec + (**(**[4]int64)(__ccgo_up(bp)))[int32(2)*i+int32(1)] = (**(**Ttimespec)(__ccgo_up(times + uintptr(i)*16))).Ftv_nsec / int64(1000) goto _1 _1: ; @@ -135572,8 +135572,8 @@ func X__fdopen(tls *TLS, fd int32, mode uintptr) (r uintptr) { var _ /* wsz at bp+0 */ Twinsize _, _, _, _ = f, flags, v1, v2 /* Check for valid initial mode character */ - if !(Xstrchr(tls, __ccgo_ts+1521, int32(*(*int8)(unsafe.Pointer(mode)))) != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if !(Xstrchr(tls, __ccgo_ts+1521, int32(**(**int8)(__ccgo_up(mode)))) != 0) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } /* Allocate FILE+buffer or fail */ @@ -135586,7 +135586,7 @@ func X__fdopen(tls *TLS, fd int32, mode uintptr) (r uintptr) { Xmemset(tls, f, 0, uint64(232)) /* Impose mode restrictions */ if !(Xstrchr(tls, mode, int32('+')) != 0) { - if int32(*(*int8)(unsafe.Pointer(mode))) == int32('r') { + if int32(**(**int8)(__ccgo_up(mode))) == int32('r') { v2 = int32(F_NOWR) } else { v2 = int32(F_NORD) @@ -135598,12 +135598,12 @@ func X__fdopen(tls *TLS, fd int32, mode uintptr) (r uintptr) { X__syscall3(tls, int64(SYS_fcntl), int64(fd), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) } /* Set append mode on fd if opened for append */ - if int32(*(*int8)(unsafe.Pointer(mode))) == int32('a') { + if int32(**(**int8)(__ccgo_up(mode))) == int32('a') { flags = int32(X__syscall2(tls, int64(SYS_fcntl), int64(fd), int64(Int32FromInt32(F_GETFL)))) if !(flags&Int32FromInt32(O_APPEND) != 0) { X__syscall3(tls, int64(SYS_fcntl), int64(fd), int64(Int32FromInt32(F_SETFL)), int64(flags|Int32FromInt32(O_APPEND))) } - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_APP) + **(**uint32)(__ccgo_up(f)) |= uint32(F_APP) } (*TFILE)(unsafe.Pointer(f)).Ffd = fd (*TFILE)(unsafe.Pointer(f)).Fbuf = f + uintptr(232) + uintptr(UNGET) @@ -135643,7 +135643,7 @@ func X__fmodeflags(tls *TLS, mode uintptr) (r int32) { if Xstrchr(tls, mode, int32('+')) != 0 { flags = int32(O_RDWR) } else { - if int32(*(*int8)(unsafe.Pointer(mode))) == int32('r') { + if int32(**(**int8)(__ccgo_up(mode))) == int32('r') { flags = O_RDONLY } else { flags = int32(O_WRONLY) @@ -135655,13 +135655,13 @@ func X__fmodeflags(tls *TLS, mode uintptr) (r int32) { if Xstrchr(tls, mode, int32('e')) != 0 { flags = flags | int32(O_CLOEXEC) } - if int32(*(*int8)(unsafe.Pointer(mode))) != int32('r') { + if int32(**(**int8)(__ccgo_up(mode))) != int32('r') { flags = flags | int32(O_CREAT) } - if int32(*(*int8)(unsafe.Pointer(mode))) == int32('w') { + if int32(**(**int8)(__ccgo_up(mode))) == int32('w') { flags = flags | int32(O_TRUNC) } - if int32(*(*int8)(unsafe.Pointer(mode))) == int32('a') { + if int32(**(**int8)(__ccgo_up(mode))) == int32('a') { flags = flags | int32(O_APPEND) } return flags @@ -135699,22 +135699,22 @@ func X__overflow(tls *TLS, f uintptr, _c int32) (r int32) { var v2, v3 uintptr var _ /* c at bp+0 */ uint8 _, _, _ = v1, v2, v3 - *(*uint8)(unsafe.Pointer(bp)) = Uint8FromInt32(_c) + **(**uint8)(__ccgo_up(bp)) = Uint8FromInt32(_c) if !((*TFILE)(unsafe.Pointer(f)).Fwend != 0) && X__towrite(tls, f) != 0 { return -int32(1) } - if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwend && Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) != (*TFILE)(unsafe.Pointer(f)).Flbf { - v1 = *(*uint8)(unsafe.Pointer(bp)) + if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwend && Int32FromUint8(**(**uint8)(__ccgo_up(bp))) != (*TFILE)(unsafe.Pointer(f)).Flbf { + v1 = **(**uint8)(__ccgo_up(bp)) v3 = f + 40 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - *(*uint8)(unsafe.Pointer(v2)) = v1 + **(**uint8)(__ccgo_up(v2)) = v1 return Int32FromUint8(v1) } if (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fwrite})))(tls, f, bp, uint64(1)) != uint64(1) { return -int32(1) } - return Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) + return Int32FromUint8(**(**uint8)(__ccgo_up(bp))) } func _dummy9(tls *TLS, fd int32) (r int32) { @@ -135752,7 +135752,7 @@ func X__stdio_exit(tls *TLS) { } var f uintptr _ = f - f = *(*uintptr)(unsafe.Pointer(X__ofl_lock(tls))) + f = **(**uintptr)(__ccgo_up(X__ofl_lock(tls))) for { if !(f != 0) { break @@ -135788,7 +135788,7 @@ func X__stdio_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { var v3, v4 uintptr var _ /* iov at bp+0 */ [2]Tiovec _, _, _, _, _ = cnt, v1, v2, v3, v4 - *(*[2]Tiovec)(unsafe.Pointer(bp)) = [2]Tiovec{ + **(**[2]Tiovec)(__ccgo_up(bp)) = [2]Tiovec{ 0: { Fiov_base: buf, Fiov_len: len1 - BoolUint64(!!((*TFILE)(unsafe.Pointer(f)).Fbuf_size != 0)), @@ -135798,10 +135798,10 @@ func X__stdio_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { Fiov_len: (*TFILE)(unsafe.Pointer(f)).Fbuf_size, }, } - if (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len != 0 { + if (**(**[2]Tiovec)(__ccgo_up(bp)))[0].Fiov_len != 0 { v1 = X__syscall_ret(tls, Uint64FromInt64(X__syscall3(tls, int64(SYS_readv), int64((*TFILE)(unsafe.Pointer(f)).Ffd), int64(bp), int64(Int32FromInt32(2))))) } else { - v1 = X__syscall_ret(tls, Uint64FromInt64(X__syscall3(tls, SYS_read, int64((*TFILE)(unsafe.Pointer(f)).Ffd), int64((*(*[2]Tiovec)(unsafe.Pointer(bp)))[int32(1)].Fiov_base), Int64FromUint64((*(*[2]Tiovec)(unsafe.Pointer(bp)))[int32(1)].Fiov_len)))) + v1 = X__syscall_ret(tls, Uint64FromInt64(X__syscall3(tls, SYS_read, int64((*TFILE)(unsafe.Pointer(f)).Ffd), int64((**(**[2]Tiovec)(__ccgo_up(bp)))[int32(1)].Fiov_base), Int64FromUint64((**(**[2]Tiovec)(__ccgo_up(bp)))[int32(1)].Fiov_len)))) } cnt = v1 if cnt <= 0 { @@ -135810,20 +135810,20 @@ func X__stdio_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { } else { v2 = int32(F_EOF) } - *(*uint32)(unsafe.Pointer(f)) |= Uint32FromInt32(v2) + **(**uint32)(__ccgo_up(f)) |= Uint32FromInt32(v2) return uint64(0) } - if Uint64FromInt64(cnt) <= (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len { + if Uint64FromInt64(cnt) <= (**(**[2]Tiovec)(__ccgo_up(bp)))[0].Fiov_len { return Uint64FromInt64(cnt) } - cnt = Int64FromUint64(uint64(cnt) - (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len) + cnt = Int64FromUint64(uint64(cnt) - (**(**[2]Tiovec)(__ccgo_up(bp)))[0].Fiov_len) (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(cnt) if (*TFILE)(unsafe.Pointer(f)).Fbuf_size != 0 { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(buf + uintptr(len1-uint64(1)))) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(buf + uintptr(len1-uint64(1)))) = **(**uint8)(__ccgo_up(v3)) } return len1 } @@ -135850,7 +135850,7 @@ func X__stdio_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) var v5 uint64 var _ /* iovs at bp+0 */ [2]Tiovec _, _, _, _, _, _, _ = cnt, iov, iovcnt, rem, v2, v3, v5 - *(*[2]Tiovec)(unsafe.Pointer(bp)) = [2]Tiovec{ + **(**[2]Tiovec)(__ccgo_up(bp)) = [2]Tiovec{ 0: { Fiov_base: (*TFILE)(unsafe.Pointer(f)).Fwbase, Fiov_len: Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Fwpos) - int64((*TFILE)(unsafe.Pointer(f)).Fwbase)), @@ -135861,7 +135861,7 @@ func X__stdio_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) }, } iov = bp - rem = (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len + (*(*Tiovec)(unsafe.Pointer(iov + 1*16))).Fiov_len + rem = (**(**Tiovec)(__ccgo_up(iov))).Fiov_len + (**(**Tiovec)(__ccgo_up(iov + 1*16))).Fiov_len iovcnt = int32(2) for { cnt = X__syscall_ret(tls, Uint64FromInt64(X__syscall3(tls, int64(SYS_writev), int64((*TFILE)(unsafe.Pointer(f)).Ffd), int64(iov), int64(iovcnt)))) @@ -135878,22 +135878,22 @@ func X__stdio_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) v2 = v3 (*TFILE)(unsafe.Pointer(f)).Fwbase = v2 (*TFILE)(unsafe.Pointer(f)).Fwpos = v2 - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) if iovcnt == int32(2) { v5 = uint64(0) } else { - v5 = len1 - (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len + v5 = len1 - (**(**Tiovec)(__ccgo_up(iov))).Fiov_len } return v5 } rem = rem - Uint64FromInt64(cnt) - if Uint64FromInt64(cnt) > (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len { - cnt = Int64FromUint64(uint64(cnt) - (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len) + if Uint64FromInt64(cnt) > (**(**Tiovec)(__ccgo_up(iov))).Fiov_len { + cnt = Int64FromUint64(uint64(cnt) - (**(**Tiovec)(__ccgo_up(iov))).Fiov_len) iov += 16 iovcnt = iovcnt - 1 } - (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_base = (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_base + uintptr(cnt) - (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len -= Uint64FromInt64(cnt) + (**(**Tiovec)(__ccgo_up(iov))).Fiov_base = (**(**Tiovec)(__ccgo_up(iov))).Fiov_base + uintptr(cnt) + (**(**Tiovec)(__ccgo_up(iov))).Fiov_len -= Uint64FromInt64(cnt) goto _1 _1: } @@ -135923,7 +135923,7 @@ func X__toread(tls *TLS, f uintptr) (r int32) { var v1, v2 uintptr var v4 int32 _, _, _ = v1, v2, v4 - *(*int32)(unsafe.Pointer(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) + **(**int32)(__ccgo_up(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwbase { (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fwrite})))(tls, f, uintptr(0), uint64(0)) } @@ -135933,7 +135933,7 @@ func X__toread(tls *TLS, f uintptr) (r int32) { (*TFILE)(unsafe.Pointer(f)).Fwbase = v1 (*TFILE)(unsafe.Pointer(f)).Fwpos = v1 if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_NORD) != 0 { - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) return -int32(1) } v1 = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr((*TFILE)(unsafe.Pointer(f)).Fbuf_size) @@ -135961,9 +135961,9 @@ func X__towrite(tls *TLS, f uintptr) (r int32) { } var v1 uintptr _ = v1 - *(*int32)(unsafe.Pointer(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) + **(**int32)(__ccgo_up(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_NOWR) != 0 { - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) return -int32(1) } /* Clear read buffer (easier than summoning nasal demons) */ @@ -135997,7 +135997,7 @@ func X__uflow(tls *TLS, f uintptr) (r int32) { defer tls.Free(16) var _ /* c at bp+0 */ uint8 if !(X__toread(tls, f) != 0) && (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fread})))(tls, f, bp, uint64(1)) == uint64(1) { - return Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) + return Int32FromUint8(**(**uint8)(__ccgo_up(bp))) } return -int32(1) } @@ -136028,7 +136028,7 @@ func Xclearerr(tls *TLS, f uintptr) { v1 = 0 } __need_unlock = v1 - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^(Int32FromInt32(F_EOF) | Int32FromInt32(F_ERR))) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^(Int32FromInt32(F_EOF) | Int32FromInt32(F_ERR))) if __need_unlock != 0 { ___unlockfile(tls, f) } @@ -136189,7 +136189,7 @@ func X__freadptr(tls *TLS, f uintptr, sizep uintptr) (r uintptr) { if (*TFILE)(unsafe.Pointer(f)).Frpos == (*TFILE)(unsafe.Pointer(f)).Frend { return uintptr(0) } - *(*Tsize_t)(unsafe.Pointer(sizep)) = Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Frend) - int64((*TFILE)(unsafe.Pointer(f)).Frpos)) + **(**Tsize_t)(__ccgo_up(sizep)) = Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Frend) - int64((*TFILE)(unsafe.Pointer(f)).Frpos)) return (*TFILE)(unsafe.Pointer(f)).Frpos } @@ -136197,14 +136197,14 @@ func X__freadptrinc(tls *TLS, f uintptr, inc Tsize_t) { if __ccgo_strace { trc("tls=%v f=%v inc=%v, (%v:)", tls, f, inc, origin(2)) } - *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(inc) + **(**uintptr)(__ccgo_up(f + 8)) += uintptr(inc) } func X__fseterr(tls *TLS, f uintptr) { if __ccgo_strace { trc("tls=%v f=%v, (%v:)", tls, f, origin(2)) } - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) } func _dummy10(tls *TLS, f uintptr) { @@ -136247,8 +136247,8 @@ func Xfclose(tls *TLS, f uintptr) (r1 int32) { if (*TFILE)(unsafe.Pointer(f)).Fnext != 0 { (*TFILE)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Fnext)).Fprev = (*TFILE)(unsafe.Pointer(f)).Fprev } - if *(*uintptr)(unsafe.Pointer(head)) == f { - *(*uintptr)(unsafe.Pointer(head)) = (*TFILE)(unsafe.Pointer(f)).Fnext + if **(**uintptr)(__ccgo_up(head)) == f { + **(**uintptr)(__ccgo_up(head)) = (*TFILE)(unsafe.Pointer(f)).Fnext } X__ofl_unlock(tls) Xfree(tls, (*TFILE)(unsafe.Pointer(f)).Fgetln_buf) @@ -136349,7 +136349,7 @@ func Xfflush(tls *TLS, f uintptr) (r1 int32) { if AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stderr_used))) != 0 { r = r | Xfflush(tls, AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stderr_used)))) } - f = *(*uintptr)(unsafe.Pointer(X__ofl_lock(tls))) + f = **(**uintptr)(__ccgo_up(X__ofl_lock(tls))) for { if !(f != 0) { break @@ -136437,7 +136437,7 @@ _3: v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v5))) } else { v1 = X__uflow(tls, f) } @@ -136481,7 +136481,7 @@ func Xfgetc(tls *TLS, f1 uintptr) (r int32) { v6 = v1 + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(v5))) } else { v4 = X__uflow(tls, v1) } @@ -136517,7 +136517,7 @@ func Xfgetln(tls *TLS, f uintptr, plen uintptr) (r uintptr) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__uflow(tls, f) } @@ -136530,14 +136530,14 @@ func Xfgetln(tls *TLS, f uintptr, plen uintptr) (r uintptr) { ret = (*TFILE)(unsafe.Pointer(f)).Frpos z = z + 1 v3 = z - *(*Tsize_t)(unsafe.Pointer(plen)) = Uint64FromInt64(int64(v3) - int64(ret)) + **(**Tsize_t)(__ccgo_up(plen)) = Uint64FromInt64(int64(v3) - int64(ret)) (*TFILE)(unsafe.Pointer(f)).Frpos = z } else { *(*[1]Tsize_t)(unsafe.Pointer(bp)) = [1]Tsize_t{} v8 = Xgetline(tls, f+168, bp, f) l = v8 if v8 > 0 { - *(*Tsize_t)(unsafe.Pointer(plen)) = Uint64FromInt64(l) + **(**Tsize_t)(__ccgo_up(plen)) = Uint64FromInt64(l) ret = (*TFILE)(unsafe.Pointer(f)).Fgetln_buf } } @@ -136558,7 +136558,7 @@ func Xfgetpos(tls *TLS, f uintptr, pos uintptr) (r int32) { if off < 0 { return -int32(1) } - *(*int64)(unsafe.Pointer(pos)) = off + **(**int64)(__ccgo_up(pos)) = off return 0 } @@ -136582,14 +136582,14 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { } __need_unlock = v1 if n <= int32(1) { - *(*int32)(unsafe.Pointer(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) + **(**int32)(__ccgo_up(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) if __need_unlock != 0 { ___unlockfile(tls, f) } if n < int32(1) { return uintptr(0) } - *(*int8)(unsafe.Pointer(s)) = 0 + **(**int8)(__ccgo_up(s)) = 0 return s } n = n - 1 @@ -136609,7 +136609,7 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { } k = v3 Xmemcpy(tls, p, (*TFILE)(unsafe.Pointer(f)).Frpos, k) - *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(k) + **(**uintptr)(__ccgo_up(f + 8)) += uintptr(k) p = p + uintptr(k) n = Int32FromUint64(uint64(n) - k) if z != 0 || !(n != 0) { @@ -136620,7 +136620,7 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { v7 = f + 8 v6 = *(*uintptr)(unsafe.Pointer(v7)) *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) + 1 - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(v6))) } else { v4 = X__uflow(tls, f) } @@ -136636,13 +136636,13 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { v8 = int8(c) v6 = p p = p + 1 - *(*int8)(unsafe.Pointer(v6)) = v8 + **(**int8)(__ccgo_up(v6)) = v8 if int32(v8) == int32('\n') { break } } if s != 0 { - *(*int8)(unsafe.Pointer(p)) = 0 + **(**int8)(__ccgo_up(p)) = 0 } if __need_unlock != 0 { ___unlockfile(tls, f) @@ -136672,43 +136672,43 @@ func ___fgetwc_unlocked_internal(tls *TLS, f uintptr) (r Twint_t) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { l = Uint64FromInt32(Xmbtowc(tls, bp, (*TFILE)(unsafe.Pointer(f)).Frpos, Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Frend)-int64((*TFILE)(unsafe.Pointer(f)).Frpos)))) if l+uint64(1) >= uint64(1) { - *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(l + BoolUint64(!(l != 0))) /* l==0 means 1 byte, null */ - return Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))) + **(**uintptr)(__ccgo_up(f + 8)) += uintptr(l + BoolUint64(!(l != 0))) /* l==0 means 1 byte, null */ + return Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))) } } /* Convert character byte-by-byte */ - *(*Tmbstate_t)(unsafe.Pointer(bp + 8)) = Tmbstate_t{} + **(**Tmbstate_t)(__ccgo_up(bp + 8)) = Tmbstate_t{} first = int32(1) for cond := true; cond; cond = l == Uint64FromInt32(-Int32FromInt32(2)) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__uflow(tls, f) } v1 = v2 c = v1 - *(*uint8)(unsafe.Pointer(bp + 16)) = Uint8FromInt32(v1) + **(**uint8)(__ccgo_up(bp + 16)) = Uint8FromInt32(v1) if c < 0 { if !(first != 0) { - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EILSEQ) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EILSEQ) } return uint32(0xffffffff) } l = Xmbrtowc(tls, bp, bp+16, uint64(1), bp+8) if l == Uint64FromInt32(-Int32FromInt32(1)) { if !(first != 0) { - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) - Xungetc(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + 16))), f) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) + Xungetc(tls, Int32FromUint8(**(**uint8)(__ccgo_up(bp + 16))), f) } return uint32(0xffffffff) } first = 0 } - return Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))) + return Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))) } func X__fgetwc_unlocked(tls *TLS, f uintptr) (r Twint_t) { @@ -136721,13 +136721,13 @@ func X__fgetwc_unlocked(tls *TLS, f uintptr) (r Twint_t) { var wc Twchar_t _, _, _ = loc, ploc, wc ploc = uintptr(___get_tp(tls)) + 168 - loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) + loc = **(**Tlocale_t)(__ccgo_up(ploc)) if (*TFILE)(unsafe.Pointer(f)).Fmode <= 0 { Xfwide(tls, f, int32(1)) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale + **(**Tlocale_t)(__ccgo_up(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale wc = Int32FromUint32(___fgetwc_unlocked_internal(tls, f)) - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return Uint32FromInt32(wc) } @@ -136799,7 +136799,7 @@ func Xfgetws(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { } v4 = p p += 4 - *(*Twchar_t)(unsafe.Pointer(v4)) = Int32FromUint32(c) + **(**Twchar_t)(__ccgo_up(v4)) = Int32FromUint32(c) if c == uint32('\n') { break } @@ -136808,7 +136808,7 @@ func Xfgetws(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { ; n = n - 1 } - *(*Twchar_t)(unsafe.Pointer(p)) = 0 + **(**Twchar_t)(__ccgo_up(p)) = 0 if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_ERR) != 0 { p = s } @@ -136849,7 +136849,7 @@ func Xfileno(tls *TLS, f uintptr) (r int32) { ___unlockfile(tls, f) } if fd < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EBADF) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EBADF) return -int32(1) } return fd @@ -136902,7 +136902,7 @@ func _mseek(tls *TLS, f uintptr, off Toff_t, whence int32) (r Toff_t) { goto fail fail: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) _1: ; @@ -136910,7 +136910,7 @@ _1: 1: (*Tcookie)(unsafe.Pointer(c)).Fpos, 2: (*Tcookie)(unsafe.Pointer(c)).Flen1, } - base = Int64FromUint64(*(*Tsize_t)(unsafe.Pointer(bp + uintptr(whence)*8))) + base = Int64FromUint64(**(**Tsize_t)(__ccgo_up(bp + uintptr(whence)*8))) if off < -base || off > Int64FromUint64((*Tcookie)(unsafe.Pointer(c)).Fsize)-base { goto fail } @@ -136930,10 +136930,10 @@ func _mread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { } if len1 > rem { len1 = rem - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_EOF) + **(**uint32)(__ccgo_up(f)) |= uint32(F_EOF) } Xmemcpy(tls, buf, (*Tcookie)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie)(unsafe.Pointer(c)).Fpos), len1) - *(*Tsize_t)(unsafe.Pointer(c)) += len1 + **(**Tsize_t)(__ccgo_up(c)) += len1 rem = rem - len1 if rem > (*TFILE)(unsafe.Pointer(f)).Fbuf_size { rem = (*TFILE)(unsafe.Pointer(f)).Fbuf_size @@ -136941,7 +136941,7 @@ func _mread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(rem) Xmemcpy(tls, (*TFILE)(unsafe.Pointer(f)).Frpos, (*Tcookie)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie)(unsafe.Pointer(c)).Fpos), rem) - *(*Tsize_t)(unsafe.Pointer(c)) += rem + **(**Tsize_t)(__ccgo_up(c)) += rem return len1 } @@ -136965,14 +136965,14 @@ func _mwrite(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { len1 = rem } Xmemcpy(tls, (*Tcookie)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie)(unsafe.Pointer(c)).Fpos), buf, len1) - *(*Tsize_t)(unsafe.Pointer(c)) += len1 + **(**Tsize_t)(__ccgo_up(c)) += len1 if (*Tcookie)(unsafe.Pointer(c)).Fpos > (*Tcookie)(unsafe.Pointer(c)).Flen1 { (*Tcookie)(unsafe.Pointer(c)).Flen1 = (*Tcookie)(unsafe.Pointer(c)).Fpos if (*Tcookie)(unsafe.Pointer(c)).Flen1 < (*Tcookie)(unsafe.Pointer(c)).Fsize { - *(*uint8)(unsafe.Pointer((*Tcookie)(unsafe.Pointer(c)).Fbuf + uintptr((*Tcookie)(unsafe.Pointer(c)).Flen1))) = uint8(0) + **(**uint8)(__ccgo_up((*Tcookie)(unsafe.Pointer(c)).Fbuf + uintptr((*Tcookie)(unsafe.Pointer(c)).Flen1))) = uint8(0) } else { if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_NORD) != 0 && (*Tcookie)(unsafe.Pointer(c)).Fsize != 0 { - *(*uint8)(unsafe.Pointer((*Tcookie)(unsafe.Pointer(c)).Fbuf + uintptr((*Tcookie)(unsafe.Pointer(c)).Fsize-uint64(1)))) = uint8(0) + **(**uint8)(__ccgo_up((*Tcookie)(unsafe.Pointer(c)).Fbuf + uintptr((*Tcookie)(unsafe.Pointer(c)).Fsize-uint64(1)))) = uint8(0) } } } @@ -136994,12 +136994,12 @@ func Xfmemopen(tls *TLS, buf uintptr, size Tsize_t, mode uintptr) (r uintptr) { var v3 Tsize_t _, _, _, _, _ = f, plus, v1, v2, v3 plus = BoolInt32(!!(Xstrchr(tls, mode, int32('+')) != 0)) - if !(Xstrchr(tls, __ccgo_ts+1521, int32(*(*int8)(unsafe.Pointer(mode)))) != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if !(Xstrchr(tls, __ccgo_ts+1521, int32(**(**int8)(__ccgo_up(mode)))) != 0) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } if !(buf != 0) && size > Uint64FromInt64(Int64FromInt64(INT64_MAX)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return uintptr(0) } if buf != 0 { @@ -137023,25 +137023,25 @@ func Xfmemopen(tls *TLS, buf uintptr, size Tsize_t, mode uintptr) (r uintptr) { } (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fbuf = buf (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fsize = size - (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fmode = int32(*(*int8)(unsafe.Pointer(mode))) + (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fmode = int32(**(**int8)(__ccgo_up(mode))) if !(plus != 0) { - if int32(*(*int8)(unsafe.Pointer(mode))) == int32('r') { + if int32(**(**int8)(__ccgo_up(mode))) == int32('r') { v2 = int32(F_NOWR) } else { v2 = int32(F_NORD) } (*Tmem_FILE)(unsafe.Pointer(f)).Ff.Fflags = Uint32FromInt32(v2) } - if int32(*(*int8)(unsafe.Pointer(mode))) == int32('r') { + if int32(**(**int8)(__ccgo_up(mode))) == int32('r') { (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Flen1 = size } else { - if int32(*(*int8)(unsafe.Pointer(mode))) == int32('a') { + if int32(**(**int8)(__ccgo_up(mode))) == int32('a') { v3 = Xstrnlen(tls, buf, size) (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fpos = v3 (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Flen1 = v3 } else { if plus != 0 { - *(*uint8)(unsafe.Pointer((*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fbuf)) = uint8(0) + **(**uint8)(__ccgo_up((*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fbuf)) = uint8(0) } } } @@ -137064,8 +137064,8 @@ func Xfopen(tls *TLS, filename uintptr, mode uintptr) (r uintptr) { var fd, flags int32 _, _, _ = f, fd, flags /* Check for valid initial mode character */ - if !(Xstrchr(tls, __ccgo_ts+1521, int32(*(*int8)(unsafe.Pointer(mode)))) != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if !(Xstrchr(tls, __ccgo_ts+1521, int32(**(**int8)(__ccgo_up(mode)))) != 0) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } /* Compute the flags to pass to open() */ @@ -137132,7 +137132,7 @@ func _cookieread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - *(*uint8)(unsafe.Pointer(buf + uintptr(v1))) = *(*uint8)(unsafe.Pointer(v2)) + **(**uint8)(__ccgo_up(buf + uintptr(v1))) = **(**uint8)(__ccgo_up(v2)) return readlen goto bail bail: @@ -137142,7 +137142,7 @@ bail: } else { v4 = int32(F_ERR) } - *(*uint32)(unsafe.Pointer(f)) |= Uint32FromInt32(v4) + **(**uint32)(__ccgo_up(f)) |= Uint32FromInt32(v4) v2 = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = v2 (*TFILE)(unsafe.Pointer(f)).Frpos = v2 @@ -137172,7 +137172,7 @@ func _cookiewrite(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { v1 = v2 (*TFILE)(unsafe.Pointer(f)).Fwbase = v1 (*TFILE)(unsafe.Pointer(f)).Fwpos = v1 - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) return uint64(0) } return Uint64FromInt64(ret) @@ -137187,18 +137187,18 @@ func _cookieseek(tls *TLS, f uintptr, _off Toff_t, whence int32) (r Toff_t) { _, _ = fc, res fc = (*TFILE)(unsafe.Pointer(f)).Fcookie if Uint32FromInt32(whence) > uint32(2) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) } if !((*Tfcookie)(unsafe.Pointer(fc)).Fiofuncs.Fseek != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOPNOTSUPP) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOPNOTSUPP) return int64(-int32(1)) } res = (*(*func(*TLS, uintptr, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{(*Tfcookie)(unsafe.Pointer(fc)).Fiofuncs.Fseek})))(tls, (*Tfcookie)(unsafe.Pointer(fc)).Fcookie, bp, whence) if res < 0 { return int64(res) } - return *(*Toff_t)(unsafe.Pointer(bp)) + return **(**Toff_t)(__ccgo_up(bp)) } func _cookieclose(tls *TLS, f uintptr) (r int32) { @@ -137220,8 +137220,8 @@ func Xfopencookie(tls *TLS, cookie uintptr, mode uintptr, iofuncs Tcookie_io_fun var v2 int32 _, _, _ = f, v1, v2 /* Check for valid initial mode character */ - if !(Xstrchr(tls, __ccgo_ts+1521, int32(*(*int8)(unsafe.Pointer(mode)))) != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if !(Xstrchr(tls, __ccgo_ts+1521, int32(**(**int8)(__ccgo_up(mode)))) != 0) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } /* Allocate FILE+fcookie+buffer or fail */ @@ -137234,7 +137234,7 @@ func Xfopencookie(tls *TLS, cookie uintptr, mode uintptr, iofuncs Tcookie_io_fun Xmemset(tls, f, 0, uint64(232)) /* Impose mode restrictions */ if !(Xstrchr(tls, mode, int32('+')) != 0) { - if int32(*(*int8)(unsafe.Pointer(mode))) == int32('r') { + if int32(**(**int8)(__ccgo_up(mode))) == int32('r') { v2 = int32(F_NOWR) } else { v2 = int32(F_NORD) @@ -137294,7 +137294,7 @@ _3: v7 = f + 40 v6 = *(*uintptr)(unsafe.Pointer(v7)) *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) + 1 - *(*uint8)(unsafe.Pointer(v6)) = v5 + **(**uint8)(__ccgo_up(v6)) = v5 v1 = Int32FromUint8(v5) } else { v1 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) @@ -137342,7 +137342,7 @@ func Xfputc(tls *TLS, c1 int32, f1 uintptr) (r int32) { v8 = v2 + 40 v7 = *(*uintptr)(unsafe.Pointer(v8)) *(*uintptr)(unsafe.Pointer(v8)) = *(*uintptr)(unsafe.Pointer(v8)) + 1 - *(*uint8)(unsafe.Pointer(v7)) = v6 + **(**uint8)(__ccgo_up(v7)) = v6 v5 = Int32FromUint8(v6) } else { v5 = X__overflow(tls, v2, Int32FromUint8(Uint8FromInt32(v1))) @@ -137389,18 +137389,18 @@ func X__fputwc_unlocked(tls *TLS, c Twchar_t, f uintptr) (r Twint_t) { var _ /* mbc at bp+0 */ [4]int8 _, _, _, _, _, _, _ = l, loc, ploc, v1, v2, v3, v4 ploc = uintptr(___get_tp(tls)) + 168 - loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) + loc = **(**Tlocale_t)(__ccgo_up(ploc)) if (*TFILE)(unsafe.Pointer(f)).Fmode <= 0 { Xfwide(tls, f, int32(1)) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale + **(**Tlocale_t)(__ccgo_up(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale if BoolInt32(Uint32FromInt32(c) < uint32(128)) != 0 { if Int32FromUint8(Uint8FromInt32(c)) != (*TFILE)(unsafe.Pointer(f)).Flbf && (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwend { v2 = Uint8FromInt32(c) v4 = f + 40 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(v3)) = v2 + **(**uint8)(__ccgo_up(v3)) = v2 v1 = Int32FromUint8(v2) } else { v1 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) @@ -137412,7 +137412,7 @@ func X__fputwc_unlocked(tls *TLS, c Twchar_t, f uintptr) (r Twint_t) { if l < 0 { c = Int32FromUint32(0xffffffff) } else { - *(*uintptr)(unsafe.Pointer(f + 40)) += uintptr(l) + **(**uintptr)(__ccgo_up(f + 40)) += uintptr(l) } } else { l = Xwctomb(tls, bp, c) @@ -137422,9 +137422,9 @@ func X__fputwc_unlocked(tls *TLS, c Twchar_t, f uintptr) (r Twint_t) { } } if Uint32FromInt32(c) == uint32(0xffffffff) { - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return Uint32FromInt32(c) } @@ -137481,7 +137481,7 @@ func Xfputws(tls *TLS, _ws uintptr, f uintptr) (r int32) { _, _, _, _, _, _, _ = __need_unlock, l, loc, ploc, v1, v2, v3 l = uint64(0) ploc = uintptr(___get_tp(tls)) + 168 - loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) + loc = **(**Tlocale_t)(__ccgo_up(ploc)) if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) } else { @@ -137489,9 +137489,9 @@ func Xfputws(tls *TLS, _ws uintptr, f uintptr) (r int32) { } __need_unlock = v1 Xfwide(tls, f, int32(1)) - *(*Tlocale_t)(unsafe.Pointer(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale + **(**Tlocale_t)(__ccgo_up(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale for { - if v3 = *(*uintptr)(unsafe.Pointer(bp)) != 0; v3 { + if v3 = **(**uintptr)(__ccgo_up(bp)) != 0; v3 { v2 = Xwcsrtombs(tls, bp+8, bp, uint64(1024), uintptr(0)) l = v2 } @@ -137502,14 +137502,14 @@ func Xfputws(tls *TLS, _ws uintptr, f uintptr) (r int32) { if __need_unlock != 0 { ___unlockfile(tls, f) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return -int32(1) } } if __need_unlock != 0 { ___unlockfile(tls, f) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return Int32FromUint64(l) /* 0 or -1 */ } @@ -137543,7 +137543,7 @@ func Xfread(tls *TLS, destv uintptr, size Tsize_t, nmemb Tsize_t, f uintptr) (r v1 = 0 } __need_unlock = v1 - *(*int32)(unsafe.Pointer(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) + **(**int32)(__ccgo_up(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { /* First exhaust the buffer. */ if Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Frend)-int64((*TFILE)(unsafe.Pointer(f)).Frpos)) < l { @@ -137553,7 +137553,7 @@ func Xfread(tls *TLS, destv uintptr, size Tsize_t, nmemb Tsize_t, f uintptr) (r } k = v2 Xmemcpy(tls, dest, (*TFILE)(unsafe.Pointer(f)).Frpos, k) - *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(k) + **(**uintptr)(__ccgo_up(f + 8)) += uintptr(k) dest = dest + uintptr(k) l = l - k } @@ -137693,7 +137693,7 @@ func X__fseeko_unlocked(tls *TLS, f uintptr, off Toff_t, whence int32) (r int32) _, _ = v1, v2 /* Fail immediately for invalid whence argument. */ if whence != int32(1) && whence != 0 && whence != int32(2) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } /* Adjust relative offset for unread data in buffer, if any. */ @@ -137721,7 +137721,7 @@ func X__fseeko_unlocked(tls *TLS, f uintptr, off Toff_t, whence int32) (r int32) v1 = UintptrFromInt32(0) (*TFILE)(unsafe.Pointer(f)).Frend = v1 (*TFILE)(unsafe.Pointer(f)).Frpos = v1 - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) return 0 } @@ -137766,7 +137766,7 @@ func Xfsetpos(tls *TLS, f uintptr, pos uintptr) (r int32) { trc("tls=%v f=%v pos=%v, (%v:)", tls, f, pos, origin(2)) defer func() { trc("-> %v", r) }() } - return X__fseeko(tls, f, *(*int64)(unsafe.Pointer(pos)), 0) + return X__fseeko(tls, f, int64(**(**int64)(__ccgo_up(pos))), 0) } /* Support signed or unsigned plain-char */ @@ -137836,7 +137836,7 @@ func Xftell(tls *TLS, f uintptr) (r int64) { _ = pos pos = X__ftello(tls, f) if pos > int64(0x7fffffffffffffff) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return int64(-int32(1)) } return pos @@ -137973,7 +137973,7 @@ func Xfwide(tls *TLS, f uintptr, mode int32) (r int32) { __need_unlock = v1 if mode != 0 { if !((*TFILE)(unsafe.Pointer(f)).Flocale != 0) { - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v3 = int32(4) } else { v3 = int32(1) @@ -138033,7 +138033,7 @@ func X__fwritex(tls *TLS, s uintptr, l Tsize_t, f uintptr) (r Tsize_t) { /* Match /^(.*\n|)/ */ i = l for { - if !(i != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(i-uint64(1))))) != int32('\n')) { + if !(i != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(i-uint64(1))))) != int32('\n')) { break } goto _1 @@ -138051,7 +138051,7 @@ func X__fwritex(tls *TLS, s uintptr, l Tsize_t, f uintptr) (r Tsize_t) { } } Xmemcpy(tls, (*TFILE)(unsafe.Pointer(f)).Fwpos, s, l) - *(*uintptr)(unsafe.Pointer(f + 40)) += uintptr(l) + **(**uintptr)(__ccgo_up(f + 40)) += uintptr(l) return l + i } @@ -138136,7 +138136,7 @@ _3: v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v5))) } else { v1 = X__uflow(tls, f) } @@ -138180,7 +138180,7 @@ func Xgetc(tls *TLS, f1 uintptr) (r int32) { v6 = v1 + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(v5))) } else { v4 = X__uflow(tls, v1) } @@ -138213,7 +138213,7 @@ func Xgetc_unlocked(tls *TLS, f uintptr) (r int32) { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__uflow(tls, f) } @@ -138256,7 +138256,7 @@ _3: v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v5))) } else { v1 = X__uflow(tls, f) } @@ -138300,7 +138300,7 @@ func Xgetchar(tls *TLS) (r int32) { v6 = v1 + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(v5))) } else { v4 = X__uflow(tls, v1) } @@ -138325,7 +138325,7 @@ func Xgetchar_unlocked(tls *TLS) (r int32) { v3 = uintptr(unsafe.Pointer(&X__stdin_FILE)) + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__uflow(tls, uintptr(unsafe.Pointer(&X__stdin_FILE))) } @@ -138351,16 +138351,16 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize } __need_unlock = v1 if !(n != 0) || !(s != 0) { - *(*int32)(unsafe.Pointer(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**int32)(__ccgo_up(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) if __need_unlock != 0 { ___unlockfile(tls, f) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) } - if !(*(*uintptr)(unsafe.Pointer(s)) != 0) { - *(*Tsize_t)(unsafe.Pointer(n)) = uint64(0) + if !(**(**uintptr)(__ccgo_up(s)) != 0) { + **(**Tsize_t)(__ccgo_up(n)) = uint64(0) } for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { @@ -138375,36 +138375,36 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize z = uintptr(0) k = uint64(0) } - if i+k >= *(*Tsize_t)(unsafe.Pointer(n)) { + if i+k >= **(**Tsize_t)(__ccgo_up(n)) { m = i + k + uint64(2) if !(z != 0) && m < Uint64FromUint64(0xffffffffffffffff)/Uint64FromInt32(4) { m = m + m/uint64(2) } - tmp = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(s)), m) + tmp = Xrealloc(tls, **(**uintptr)(__ccgo_up(s)), m) if !(tmp != 0) { m = i + k + uint64(2) - tmp = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(s)), m) + tmp = Xrealloc(tls, **(**uintptr)(__ccgo_up(s)), m) if !(tmp != 0) { /* Copy as much as fits and ensure no * pushback remains in the FILE buf. */ - k = *(*Tsize_t)(unsafe.Pointer(n)) - i - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(s))+uintptr(i), (*TFILE)(unsafe.Pointer(f)).Frpos, k) - *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(k) - *(*int32)(unsafe.Pointer(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + k = **(**Tsize_t)(__ccgo_up(n)) - i + Xmemcpy(tls, **(**uintptr)(__ccgo_up(s))+uintptr(i), (*TFILE)(unsafe.Pointer(f)).Frpos, k) + **(**uintptr)(__ccgo_up(f + 8)) += uintptr(k) + **(**int32)(__ccgo_up(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) if __need_unlock != 0 { ___unlockfile(tls, f) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return int64(-int32(1)) } } - *(*uintptr)(unsafe.Pointer(s)) = tmp - *(*Tsize_t)(unsafe.Pointer(n)) = m + **(**uintptr)(__ccgo_up(s)) = tmp + **(**Tsize_t)(__ccgo_up(n)) = m } if k != 0 { - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(s))+uintptr(i), (*TFILE)(unsafe.Pointer(f)).Frpos, k) - *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(k) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(s))+uintptr(i), (*TFILE)(unsafe.Pointer(f)).Frpos, k) + **(**uintptr)(__ccgo_up(f + 8)) += uintptr(k) i = i + k } if z != 0 { @@ -138414,7 +138414,7 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize v7 = f + 8 v6 = *(*uintptr)(unsafe.Pointer(v7)) *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) + 1 - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(v6))) } else { v4 = X__uflow(tls, f) } @@ -138431,16 +138431,16 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize } /* If the byte read by getc won't fit without growing the * output buffer, push it back for next iteration. */ - if i+uint64(1) >= *(*Tsize_t)(unsafe.Pointer(n)) { + if i+uint64(1) >= **(**Tsize_t)(__ccgo_up(n)) { v7 = f + 8 *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) - 1 v6 = *(*uintptr)(unsafe.Pointer(v7)) - *(*uint8)(unsafe.Pointer(v6)) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(v6)) = Uint8FromInt32(c) } else { v10 = int8(c) v11 = i i = i + 1 - *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)) + uintptr(v11))) = v10 + **(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)) + uintptr(v11))) = v10 if int32(v10) == delim { break } @@ -138448,7 +138448,7 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize goto _2 _2: } - *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)) + uintptr(i))) = 0 + **(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)) + uintptr(i))) = 0 if __need_unlock != 0 { ___unlockfile(tls, f) } @@ -138492,7 +138492,7 @@ func Xgets(tls *TLS, s uintptr) (r uintptr) { v5 = uintptr(unsafe.Pointer(&X__stdin_FILE)) + 8 v4 = *(*uintptr)(unsafe.Pointer(v5)) *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v4))) } else { v3 = X__uflow(tls, uintptr(unsafe.Pointer(&X__stdin_FILE))) } @@ -138503,9 +138503,9 @@ func Xgets(tls *TLS, s uintptr) (r uintptr) { } v6 = i i = i + 1 - *(*int8)(unsafe.Pointer(s + uintptr(v6))) = int8(c) + **(**int8)(__ccgo_up(s + uintptr(v6))) = int8(c) } - *(*int8)(unsafe.Pointer(s + uintptr(i))) = 0 + **(**int8)(__ccgo_up(s + uintptr(i))) = 0 if c != int32('\n') && (!((*TFILE)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stdin_FILE)))).Fflags&Uint32FromInt32(F_EOF) != 0) || !(i != 0)) { s = uintptr(0) } @@ -138526,7 +138526,7 @@ func Xgetw(tls *TLS, f uintptr) (r int32) { var _ /* x at bp+0 */ int32 _ = v1 if Xfread(tls, bp, uint64(4), uint64(1), f) != 0 { - v1 = *(*int32)(unsafe.Pointer(bp)) + v1 = **(**int32)(__ccgo_up(bp)) } else { v1 = -int32(1) } @@ -138584,11 +138584,11 @@ func X__ofl_add(tls *TLS, f uintptr) (r uintptr) { var head uintptr _ = head head = X__ofl_lock(tls) - (*TFILE)(unsafe.Pointer(f)).Fnext = *(*uintptr)(unsafe.Pointer(head)) - if *(*uintptr)(unsafe.Pointer(head)) != 0 { - (*TFILE)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(head)))).Fprev = f + (*TFILE)(unsafe.Pointer(f)).Fnext = **(**uintptr)(__ccgo_up(head)) + if **(**uintptr)(__ccgo_up(head)) != 0 { + (*TFILE)(unsafe.Pointer(**(**uintptr)(__ccgo_up(head)))).Fprev = f } - *(*uintptr)(unsafe.Pointer(head)) = f + **(**uintptr)(__ccgo_up(head)) = f X__ofl_unlock(tls) return f } @@ -138622,7 +138622,7 @@ func _ms_seek(tls *TLS, f uintptr, off Toff_t, whence int32) (r Toff_t) { goto fail fail: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) _1: ; @@ -138630,7 +138630,7 @@ _1: 1: (*Tcookie1)(unsafe.Pointer(c)).Fpos, 2: (*Tcookie1)(unsafe.Pointer(c)).Flen1, } - base = Int64FromUint64(*(*Tsize_t)(unsafe.Pointer(bp + uintptr(whence)*8))) + base = Int64FromUint64(**(**Tsize_t)(__ccgo_up(bp + uintptr(whence)*8))) if off < -base || off > int64(0x7fffffffffffffff)-base { goto fail } @@ -138659,16 +138659,16 @@ func _ms_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { } v1 = newbuf (*Tcookie1)(unsafe.Pointer(c)).Fbuf = v1 - *(*uintptr)(unsafe.Pointer((*Tcookie1)(unsafe.Pointer(c)).Fbufp)) = v1 + **(**uintptr)(__ccgo_up((*Tcookie1)(unsafe.Pointer(c)).Fbufp)) = v1 Xmemset(tls, (*Tcookie1)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie1)(unsafe.Pointer(c)).Fspace), 0, len2-(*Tcookie1)(unsafe.Pointer(c)).Fspace) (*Tcookie1)(unsafe.Pointer(c)).Fspace = len2 } Xmemcpy(tls, (*Tcookie1)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie1)(unsafe.Pointer(c)).Fpos), buf, len1) - *(*Tsize_t)(unsafe.Pointer(c + 16)) += len1 + **(**Tsize_t)(__ccgo_up(c + 16)) += len1 if (*Tcookie1)(unsafe.Pointer(c)).Fpos >= (*Tcookie1)(unsafe.Pointer(c)).Flen1 { (*Tcookie1)(unsafe.Pointer(c)).Flen1 = (*Tcookie1)(unsafe.Pointer(c)).Fpos } - *(*Tsize_t)(unsafe.Pointer((*Tcookie1)(unsafe.Pointer(c)).Fsizep)) = (*Tcookie1)(unsafe.Pointer(c)).Fpos + **(**Tsize_t)(__ccgo_up((*Tcookie1)(unsafe.Pointer(c)).Fsizep)) = (*Tcookie1)(unsafe.Pointer(c)).Fpos return len1 } @@ -138701,16 +138701,16 @@ func Xopen_memstream(tls *TLS, bufp uintptr, sizep uintptr) (r uintptr) { (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fbufp = bufp (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fsizep = sizep v5 = Uint64FromInt32(0) - *(*Tsize_t)(unsafe.Pointer(sizep)) = v5 + **(**Tsize_t)(__ccgo_up(sizep)) = v5 v4 = v5 (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fspace = v4 v3 = v4 (*Tms_FILE)(unsafe.Pointer(f)).Fc.Flen1 = v3 (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fpos = v3 v1 = buf - *(*uintptr)(unsafe.Pointer(bufp)) = v1 + **(**uintptr)(__ccgo_up(bufp)) = v1 (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fbuf = v1 - *(*int8)(unsafe.Pointer(buf)) = 0 + **(**int8)(__ccgo_up(buf)) = 0 (*Tms_FILE)(unsafe.Pointer(f)).Ff.Fflags = uint32(F_NORD) (*Tms_FILE)(unsafe.Pointer(f)).Ff.Ffd = -int32(1) (*Tms_FILE)(unsafe.Pointer(f)).Ff.Fbuf = f + 280 @@ -138756,7 +138756,7 @@ func _wms_seek(tls *TLS, f uintptr, off Toff_t, whence int32) (r Toff_t) { goto fail fail: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) _1: ; @@ -138764,7 +138764,7 @@ _1: 1: (*Tcookie2)(unsafe.Pointer(c)).Fpos, 2: (*Tcookie2)(unsafe.Pointer(c)).Flen1, } - base = Int64FromUint64(*(*Tsize_t)(unsafe.Pointer(bp + uintptr(whence)*8))) + base = Int64FromUint64(**(**Tsize_t)(__ccgo_up(bp + uintptr(whence)*8))) if off < -base || off > Int64FromInt64(0x7fffffffffffffff)/Int64FromInt32(4)-base { goto fail } @@ -138800,7 +138800,7 @@ func _wms_write(tls *TLS, f uintptr, _buf uintptr, len1 Tsize_t) (r Tsize_t) { } v1 = newbuf (*Tcookie2)(unsafe.Pointer(c)).Fbuf = v1 - *(*uintptr)(unsafe.Pointer((*Tcookie2)(unsafe.Pointer(c)).Fbufp)) = v1 + **(**uintptr)(__ccgo_up((*Tcookie2)(unsafe.Pointer(c)).Fbufp)) = v1 Xmemset(tls, (*Tcookie2)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie2)(unsafe.Pointer(c)).Fspace)*4, 0, uint64(4)*(len2-(*Tcookie2)(unsafe.Pointer(c)).Fspace)) (*Tcookie2)(unsafe.Pointer(c)).Fspace = len2 } @@ -138808,11 +138808,11 @@ func _wms_write(tls *TLS, f uintptr, _buf uintptr, len1 Tsize_t) (r Tsize_t) { if len2 == Uint64FromInt32(-Int32FromInt32(1)) { return uint64(0) } - *(*Tsize_t)(unsafe.Pointer(c + 16)) += len2 + **(**Tsize_t)(__ccgo_up(c + 16)) += len2 if (*Tcookie2)(unsafe.Pointer(c)).Fpos >= (*Tcookie2)(unsafe.Pointer(c)).Flen1 { (*Tcookie2)(unsafe.Pointer(c)).Flen1 = (*Tcookie2)(unsafe.Pointer(c)).Fpos } - *(*Tsize_t)(unsafe.Pointer((*Tcookie2)(unsafe.Pointer(c)).Fsizep)) = (*Tcookie2)(unsafe.Pointer(c)).Fpos + **(**Tsize_t)(__ccgo_up((*Tcookie2)(unsafe.Pointer(c)).Fsizep)) = (*Tcookie2)(unsafe.Pointer(c)).Fpos return len1 } @@ -138845,16 +138845,16 @@ func Xopen_wmemstream(tls *TLS, bufp uintptr, sizep uintptr) (r uintptr) { (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fbufp = bufp (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fsizep = sizep v5 = Uint64FromInt32(0) - *(*Tsize_t)(unsafe.Pointer(sizep)) = v5 + **(**Tsize_t)(__ccgo_up(sizep)) = v5 v4 = v5 (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fspace = v4 v3 = v4 (*Twms_FILE)(unsafe.Pointer(f)).Fc.Flen1 = v3 (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fpos = v3 v1 = buf - *(*uintptr)(unsafe.Pointer(bufp)) = v1 + **(**uintptr)(__ccgo_up(bufp)) = v1 (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fbuf = v1 - *(*Twchar_t)(unsafe.Pointer(buf)) = 0 + **(**Twchar_t)(__ccgo_up(buf)) = 0 (*Twms_FILE)(unsafe.Pointer(f)).Ff.Fflags = uint32(F_NORD) (*Twms_FILE)(unsafe.Pointer(f)).Ff.Ffd = -int32(1) (*Twms_FILE)(unsafe.Pointer(f)).Ff.Fbuf = f + 288 @@ -138893,7 +138893,7 @@ func Xpclose(tls *TLS, f uintptr) (r1 int32) { if r < 0 { return int32(X__syscall_ret(tls, Uint64FromInt32(r))) } - return *(*int32)(unsafe.Pointer(bp)) + return **(**int32)(__ccgo_up(bp)) } func Xperror(tls *TLS, msg uintptr) { @@ -138904,7 +138904,7 @@ func Xperror(tls *TLS, msg uintptr) { var errstr, f, old_locale uintptr _, _, _, _, _, _ = __need_unlock, errstr, f, old_locale, old_mode, v1 f = uintptr(unsafe.Pointer(&X__stderr_FILE)) - errstr = Xstrerror(tls, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) + errstr = Xstrerror(tls, **(**int32)(__ccgo_up(X__errno_location(tls)))) if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) } else { @@ -138915,7 +138915,7 @@ func Xperror(tls *TLS, msg uintptr) { * permitted to change them. */ old_locale = (*TFILE)(unsafe.Pointer(f)).Flocale old_mode = (*TFILE)(unsafe.Pointer(f)).Fmode - if msg != 0 && *(*int8)(unsafe.Pointer(msg)) != 0 { + if msg != 0 && **(**int8)(__ccgo_up(msg)) != 0 { Xfwrite(tls, msg, _strlen(tls, msg), uint64(1), f) Xfputc(tls, int32(':'), f) Xfputc(tls, int32(' '), f) @@ -138965,7 +138965,7 @@ _3: v7 = f + 40 v6 = *(*uintptr)(unsafe.Pointer(v7)) *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) + 1 - *(*uint8)(unsafe.Pointer(v6)) = v5 + **(**uint8)(__ccgo_up(v6)) = v5 v1 = Int32FromUint8(v5) } else { v1 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) @@ -139013,7 +139013,7 @@ func Xputc(tls *TLS, c1 int32, f1 uintptr) (r int32) { v8 = v2 + 40 v7 = *(*uintptr)(unsafe.Pointer(v8)) *(*uintptr)(unsafe.Pointer(v8)) = *(*uintptr)(unsafe.Pointer(v8)) + 1 - *(*uint8)(unsafe.Pointer(v7)) = v6 + **(**uint8)(__ccgo_up(v7)) = v6 v5 = Int32FromUint8(v6) } else { v5 = X__overflow(tls, v2, Int32FromUint8(Uint8FromInt32(v1))) @@ -139049,7 +139049,7 @@ func Xputc_unlocked(tls *TLS, c int32, f uintptr) (r int32) { v4 = f + 40 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(v3)) = v2 + **(**uint8)(__ccgo_up(v3)) = v2 v1 = Int32FromUint8(v2) } else { v1 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) @@ -139095,7 +139095,7 @@ _3: v7 = f + 40 v6 = *(*uintptr)(unsafe.Pointer(v7)) *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) + 1 - *(*uint8)(unsafe.Pointer(v6)) = v5 + **(**uint8)(__ccgo_up(v6)) = v5 v1 = Int32FromUint8(v5) } else { v1 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) @@ -139143,7 +139143,7 @@ func Xputchar(tls *TLS, c1 int32) (r int32) { v8 = v2 + 40 v7 = *(*uintptr)(unsafe.Pointer(v8)) *(*uintptr)(unsafe.Pointer(v8)) = *(*uintptr)(unsafe.Pointer(v8)) + 1 - *(*uint8)(unsafe.Pointer(v7)) = v6 + **(**uint8)(__ccgo_up(v7)) = v6 v5 = Int32FromUint8(v6) } else { v5 = X__overflow(tls, v2, Int32FromUint8(Uint8FromInt32(v1))) @@ -139171,7 +139171,7 @@ func Xputchar_unlocked(tls *TLS, c int32) (r int32) { v4 = uintptr(unsafe.Pointer(&X__stdout_FILE)) + 40 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(v3)) = v2 + **(**uint8)(__ccgo_up(v3)) = v2 v1 = Int32FromUint8(v2) } else { v1 = X__overflow(tls, uintptr(unsafe.Pointer(&X__stdout_FILE)), Int32FromUint8(Uint8FromInt32(c))) @@ -139201,7 +139201,7 @@ func Xputs(tls *TLS, s uintptr) (r1 int32) { v5 = uintptr(unsafe.Pointer(&X__stdout_FILE)) + 40 v4 = *(*uintptr)(unsafe.Pointer(v5)) *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = v3 + **(**uint8)(__ccgo_up(v4)) = v3 v2 = Int32FromUint8(v3) } else { v2 = X__overflow(tls, uintptr(unsafe.Pointer(&X__stdout_FILE)), Int32FromUint8(Uint8FromInt32(Int32FromUint8('\n')))) @@ -139284,7 +139284,7 @@ func Xrewind(tls *TLS, f uintptr) { } __need_unlock = v1 X__fseeko_unlocked(tls, f, 0, 0) - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_ERR)) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^Int32FromInt32(F_ERR)) if __need_unlock != 0 { ___unlockfile(tls, f) } @@ -139374,7 +139374,7 @@ func Xsetvbuf(tls *TLS, f uintptr, buf uintptr, type1 int32, size Tsize_t) (r in return -int32(1) } } - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_SVB) + **(**uint32)(__ccgo_up(f)) |= uint32(F_SVB) return 0 } @@ -139514,14 +139514,14 @@ func Xtempnam(tls *TLS, dir uintptr, pfx uintptr) (r1 uintptr) { pl = _strlen(tls, pfx) l = dl + uint64(1) + pl + uint64(1) + uint64(6) if l >= uint64(PATH_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENAMETOOLONG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENAMETOOLONG) return uintptr(0) } Xmemcpy(tls, bp+1, dir, dl) - (*(*[4096]int8)(unsafe.Pointer(bp + 1)))[dl] = int8('/') + (**(**[4096]int8)(__ccgo_up(bp + 1)))[dl] = int8('/') Xmemcpy(tls, bp+1+uintptr(dl)+uintptr(1), pfx, pl) - (*(*[4096]int8)(unsafe.Pointer(bp + 1)))[dl+uint64(1)+pl] = int8('_') - (*(*[4096]int8)(unsafe.Pointer(bp + 1)))[l] = 0 + (**(**[4096]int8)(__ccgo_up(bp + 1)))[dl+uint64(1)+pl] = int8('_') + (**(**[4096]int8)(__ccgo_up(bp + 1)))[l] = 0 try = 0 for { if !(try < int32(MAXTRIES)) { @@ -139552,7 +139552,7 @@ func Xtmpfile(tls *TLS) (r uintptr) { var fd, try int32 var _ /* s at bp+0 */ [20]int8 _, _, _ = f, fd, try - *(*[20]int8)(unsafe.Pointer(bp)) = [20]int8{'/', 't', 'm', 'p', '/', 't', 'm', 'p', 'f', 'i', 'l', 'e', '_', 'X', 'X', 'X', 'X', 'X', 'X'} + **(**[20]int8)(__ccgo_up(bp)) = [20]int8{'/', 't', 'm', 'p', '/', 't', 'm', 'p', 'f', 'i', 'l', 'e', '_', 'X', 'X', 'X', 'X', 'X', 'X'} try = 0 for { if !(try < int32(MAXTRIES)) { @@ -139587,7 +139587,7 @@ func Xtmpnam(tls *TLS, buf uintptr) (r1 uintptr) { var v2 uintptr var _ /* s at bp+1 */ [19]int8 _, _, _ = r, try, v2 - *(*[19]int8)(unsafe.Pointer(bp + 1)) = [19]int8{'/', 't', 'm', 'p', '/', 't', 'm', 'p', 'n', 'a', 'm', '_', 'X', 'X', 'X', 'X', 'X', 'X'} + **(**[19]int8)(__ccgo_up(bp + 1)) = [19]int8{'/', 't', 'm', 'p', '/', 't', 'm', 'p', 'n', 'a', 'm', '_', 'X', 'X', 'X', 'X', 'X', 'X'} try = 0 for { if !(try < int32(MAXTRIES)) { @@ -139643,8 +139643,8 @@ func Xungetc(tls *TLS, c int32, f uintptr) (r int32) { v3 = f + 8 *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) - 1 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(c) - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) + **(**uint8)(__ccgo_up(v2)) = Uint8FromInt32(c) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) if __need_unlock != 0 { ___unlockfile(tls, f) } @@ -139665,7 +139665,7 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { var _ /* mbc at bp+0 */ [4]uint8 _, _, _, _, _, _, _, _ = __need_unlock, l, loc, ploc, v1, v3, v4, v5 ploc = uintptr(___get_tp(tls)) + 168 - loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) + loc = **(**Tlocale_t)(__ccgo_up(ploc)) if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) } else { @@ -139675,7 +139675,7 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { if (*TFILE)(unsafe.Pointer(f)).Fmode <= 0 { Xfwide(tls, f, int32(1)) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale + **(**Tlocale_t)(__ccgo_up(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale if !((*TFILE)(unsafe.Pointer(f)).Frpos != 0) { X__toread(tls, f) } @@ -139687,24 +139687,24 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { if __need_unlock != 0 { ___unlockfile(tls, f) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return uint32(0xffffffff) } if BoolInt32(c < uint32(128)) != 0 { v5 = f + 8 *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) - 1 v4 = *(*uintptr)(unsafe.Pointer(v5)) - *(*uint8)(unsafe.Pointer(v4)) = uint8(c) + **(**uint8)(__ccgo_up(v4)) = uint8(c) } else { v4 = f + 8 *(*uintptr)(unsafe.Pointer(v4)) -= uintptr(l) Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(v4)), bp, Uint64FromInt32(l)) } - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) if __need_unlock != 0 { ___unlockfile(tls, f) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return c } @@ -139723,12 +139723,12 @@ func Xvasprintf(tls *TLS, s uintptr, fmt uintptr, ap Tva_list) (r int32) { _ = ap2 if v2 = l < 0; !v2 { v1 = Xmalloc(tls, uint64(Uint32FromInt32(l)+uint32(1))) - *(*uintptr)(unsafe.Pointer(s)) = v1 + **(**uintptr)(__ccgo_up(s)) = v1 } if v2 || !(v1 != 0) { return -int32(1) } - return Xvsnprintf(tls, *(*uintptr)(unsafe.Pointer(s)), uint64(Uint32FromInt32(l)+uint32(1)), fmt, ap) + return Xvsnprintf(tls, **(**uintptr)(__ccgo_up(s)), uint64(Uint32FromInt32(l)+uint32(1)), fmt, ap) } func Xvdprintf(tls *TLS, fd int32, fmt uintptr, ap Tva_list) (r int32) { @@ -139739,7 +139739,7 @@ func Xvdprintf(tls *TLS, fd int32, fmt uintptr, ap Tva_list) (r int32) { bp := tls.Alloc(240) defer tls.Free(240) var _ /* f at bp+0 */ TFILE - *(*TFILE)(unsafe.Pointer(bp)) = TFILE{ + **(**TFILE)(__ccgo_up(bp)) = TFILE{ Fwrite: __ccgo_fp(X__stdio_write), Fbuf: fmt, Ffd: fd, @@ -139906,41 +139906,41 @@ type Targ = struct { func _pop_arg(tls *TLS, arg uintptr, type1 int32, ap uintptr) { switch type1 { case int32(_PTR): - *(*uintptr)(unsafe.Pointer(arg)) = VaUintptr(&*(*Tva_list)(unsafe.Pointer(ap))) + *(*uintptr)(unsafe.Pointer(arg)) = VaUintptr(&**(**Tva_list)(__ccgo_up(ap))) case int32(_INT): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_UINT): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint32(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint32(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_LONG): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_ULONG): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&**(**Tva_list)(__ccgo_up(ap))) case int32(_ULLONG): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_SHORT): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt16(int16(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt16(int16(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_USHORT): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint16FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint16FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_CHAR): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt8(int8(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt8(int8(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_UCHAR): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint8FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint8FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_LLONG): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_SIZET): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&**(**Tva_list)(__ccgo_up(ap))) case int32(_IMAX): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_UMAX): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&**(**Tva_list)(__ccgo_up(ap))) case int32(_PDIFF): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_UIPTR): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUintptr(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUintptr(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_DBL): - *(*float64)(unsafe.Pointer(arg)) = float64(VaFloat64(&*(*Tva_list)(unsafe.Pointer(ap)))) + *(*float64)(unsafe.Pointer(arg)) = float64(VaFloat64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_LDBL): - *(*float64)(unsafe.Pointer(arg)) = VaFloat64(&*(*Tva_list)(unsafe.Pointer(ap))) + *(*float64)(unsafe.Pointer(arg)) = VaFloat64(&**(**Tva_list)(__ccgo_up(ap))) } } @@ -139990,7 +139990,7 @@ func _fmt_x(tls *TLS, x Tuintmax_t, s uintptr, lower int32) (r uintptr) { } s = s - 1 v2 = s - *(*int8)(unsafe.Pointer(v2)) = int8(int32(_xdigits1[x&uint64(15)]) | lower) + **(**int8)(__ccgo_up(v2)) = int8(int32(_xdigits1[x&uint64(15)]) | lower) goto _1 _1: ; @@ -140008,7 +140008,7 @@ func _fmt_o(tls *TLS, x Tuintmax_t, s uintptr) (r uintptr) { } s = s - 1 v2 = s - *(*int8)(unsafe.Pointer(v2)) = Int8FromUint64(uint64('0') + x&uint64(7)) + **(**int8)(__ccgo_up(v2)) = Int8FromUint64(uint64('0') + x&uint64(7)) goto _1 _1: ; @@ -140027,7 +140027,7 @@ func _fmt_u(tls *TLS, x Tuintmax_t, s uintptr) (r uintptr) { } s = s - 1 v2 = s - *(*int8)(unsafe.Pointer(v2)) = Int8FromUint64(uint64('0') + x%uint64(10)) + **(**int8)(__ccgo_up(v2)) = Int8FromUint64(uint64('0') + x%uint64(10)) goto _1 _1: ; @@ -140040,7 +140040,7 @@ func _fmt_u(tls *TLS, x Tuintmax_t, s uintptr) (r uintptr) { } s = s - 1 v2 = s - *(*int8)(unsafe.Pointer(v2)) = Int8FromUint64(uint64('0') + y%uint64(10)) + **(**int8)(__ccgo_up(v2)) = Int8FromUint64(uint64('0') + y%uint64(10)) goto _3 _3: ; @@ -140075,7 +140075,7 @@ func _fmt_fp(tls *TLS, f uintptr, y float64, w int32, p int32, fl int32, t int32 var _ /* e2 at bp+512 */ int32 var _ /* ebuf0 at bp+538 */ [12]int8 _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, b, carry, carry1, d, e, ebuf, estr, i, j, l, need, pl, prefix, r, re, rm, round, round1, s, s1, s2, s3, s4, sh, sh1, small, x, x1, x2, z, v1, v36, v37, v38, v5, v6, v7 - *(*int32)(unsafe.Pointer(bp + 512)) = 0 + **(**int32)(__ccgo_up(bp + 512)) = 0 prefix = __ccgo_ts + 1603 ebuf = bp + 538 + uintptr(Uint64FromInt32(3)*Uint64FromInt64(4)) pl = int32(1) @@ -140129,7 +140129,7 @@ _4: } y = float64(Xfrexpl(tls, y, bp+512) * Float64FromInt32(2)) if y != 0 { - *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) - 1 + **(**int32)(__ccgo_up(bp + 512)) = **(**int32)(__ccgo_up(bp + 512)) - 1 } if t|int32(32) == int32('a') { round = Float64FromFloat64(8) @@ -140152,7 +140152,7 @@ _4: } round = round * Float64FromInt32(16) } - if int32(*(*int8)(unsafe.Pointer(prefix))) == int32('-') { + if int32(**(**int8)(__ccgo_up(prefix))) == int32('-') { y = -y y = y - round y = y + round @@ -140162,39 +140162,39 @@ _4: y = y - round } } - if *(*int32)(unsafe.Pointer(bp + 512)) < 0 { - v7 = -*(*int32)(unsafe.Pointer(bp + 512)) + if **(**int32)(__ccgo_up(bp + 512)) < 0 { + v7 = -**(**int32)(__ccgo_up(bp + 512)) } else { - v7 = *(*int32)(unsafe.Pointer(bp + 512)) + v7 = **(**int32)(__ccgo_up(bp + 512)) } estr = _fmt_u(tls, Uint64FromInt32(v7), ebuf) if estr == ebuf { estr = estr - 1 v5 = estr - *(*int8)(unsafe.Pointer(v5)) = int8('0') + **(**int8)(__ccgo_up(v5)) = int8('0') } estr = estr - 1 v5 = estr - if *(*int32)(unsafe.Pointer(bp + 512)) < 0 { + if **(**int32)(__ccgo_up(bp + 512)) < 0 { v7 = int32('-') } else { v7 = int32('+') } - *(*int8)(unsafe.Pointer(v5)) = int8(v7) + **(**int8)(__ccgo_up(v5)) = int8(v7) estr = estr - 1 v5 = estr - *(*int8)(unsafe.Pointer(v5)) = int8(t + (Int32FromUint8('p') - Int32FromUint8('a'))) + **(**int8)(__ccgo_up(v5)) = int8(t + (Int32FromUint8('p') - Int32FromUint8('a'))) s = bp + 516 for cond := true; cond; cond = y != 0 { x = int32(y) v5 = s s = s + 1 - *(*int8)(unsafe.Pointer(v5)) = int8(int32(_xdigits1[x]) | t&int32(32)) + **(**int8)(__ccgo_up(v5)) = int8(int32(_xdigits1[x]) | t&int32(32)) y = float64(Float64FromInt32(16) * (y - float64(x))) if int64(s)-t__predefined_ptrdiff_t(bp+516) == int64(1) && (y != 0 || p > 0 || Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0) { v5 = s s = s + 1 - *(*int8)(unsafe.Pointer(v5)) = int8('.') + **(**int8)(__ccgo_up(v5)) = int8('.') } } if int64(p) > int64(Int32FromInt32(INT_MAX)-Int32FromInt32(2))-(int64(ebuf)-int64(estr))-int64(pl) { @@ -140224,9 +140224,9 @@ _4: } if y != 0 { y = y * Float64FromFloat64(2.68435456e+08) - *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) - int32(28) + **(**int32)(__ccgo_up(bp + 512)) = **(**int32)(__ccgo_up(bp + 512)) - int32(28) } - if *(*int32)(unsafe.Pointer(bp + 512)) < 0 { + if **(**int32)(__ccgo_up(bp + 512)) < 0 { v6 = bp + 8 z = v6 v5 = v6 @@ -140240,17 +140240,17 @@ _4: a = v5 } for cond := true; cond; cond = y != 0 { - *(*Tuint32_t)(unsafe.Pointer(z)) = uint32(y) + **(**Tuint32_t)(__ccgo_up(z)) = uint32(y) v5 = z z += 4 - y = float64(Float64FromInt32(1000000000) * (y - float64(*(*Tuint32_t)(unsafe.Pointer(v5))))) + y = float64(Float64FromInt32(1000000000) * (y - float64(**(**Tuint32_t)(__ccgo_up(v5))))) } - for *(*int32)(unsafe.Pointer(bp + 512)) > 0 { + for **(**int32)(__ccgo_up(bp + 512)) > 0 { carry = uint32(0) - if int32(29) < *(*int32)(unsafe.Pointer(bp + 512)) { + if int32(29) < **(**int32)(__ccgo_up(bp + 512)) { v7 = int32(29) } else { - v7 = *(*int32)(unsafe.Pointer(bp + 512)) + v7 = **(**int32)(__ccgo_up(bp + 512)) } sh = v7 d = z - uintptr(1)*4 @@ -140258,8 +140258,8 @@ _4: if !(d >= a) { break } - x1 = uint64(*(*Tuint32_t)(unsafe.Pointer(d)))< a && !(*(*Tuint32_t)(unsafe.Pointer(z + uintptr(-Int32FromInt32(1))*4)) != 0) { + for z > a && !(**(**Tuint32_t)(__ccgo_up(z + uintptr(-Int32FromInt32(1))*4)) != 0) { z -= 4 } - *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) - sh + **(**int32)(__ccgo_up(bp + 512)) = **(**int32)(__ccgo_up(bp + 512)) - sh } - for *(*int32)(unsafe.Pointer(bp + 512)) < 0 { + for **(**int32)(__ccgo_up(bp + 512)) < 0 { carry1 = uint32(0) - if int32(9) < -*(*int32)(unsafe.Pointer(bp + 512)) { + if int32(9) < -**(**int32)(__ccgo_up(bp + 512)) { v7 = int32(9) } else { - v7 = -*(*int32)(unsafe.Pointer(bp + 512)) + v7 = -**(**int32)(__ccgo_up(bp + 512)) } sh1 = v7 need = Int32FromUint32(uint32(1) + (Uint32FromInt32(p)+Uint32FromInt32(LDBL_MANT_DIG)/Uint32FromUint32(3)+uint32(8))/uint32(9)) @@ -140290,21 +140290,21 @@ _4: if !(d < z) { break } - rm = *(*Tuint32_t)(unsafe.Pointer(d)) & Uint32FromInt32(int32(1)<>sh1 + carry1 + rm = **(**Tuint32_t)(__ccgo_up(d)) & Uint32FromInt32(int32(1)<>sh1 + carry1 carry1 = Uint32FromInt32(Int32FromInt32(1000000000)>>sh1) * rm goto _26 _26: ; d += 4 } - if !(*(*Tuint32_t)(unsafe.Pointer(a)) != 0) { + if !(**(**Tuint32_t)(__ccgo_up(a)) != 0) { a += 4 } if carry1 != 0 { v5 = z z += 4 - *(*Tuint32_t)(unsafe.Pointer(v5)) = carry1 + **(**Tuint32_t)(__ccgo_up(v5)) = carry1 } /* Avoid (slow!) computation past requested precision */ if t|int32(32) == int32('f') { @@ -140316,13 +140316,13 @@ _4: if (int64(z)-int64(b))/4 > int64(need) { z = b + uintptr(need)*4 } - *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) + sh1 + **(**int32)(__ccgo_up(bp + 512)) = **(**int32)(__ccgo_up(bp + 512)) + sh1 } if a < z { i = int32(10) e = int32(Int64FromInt32(9) * ((int64(r) - int64(a)) / 4)) for { - if !(*(*Tuint32_t)(unsafe.Pointer(a)) >= Uint32FromInt32(i)) { + if !(**(**Tuint32_t)(__ccgo_up(a)) >= Uint32FromInt32(i)) { break } goto _29 @@ -140353,11 +140353,11 @@ _4: i = i * int32(10) j = j + 1 } - x2 = *(*Tuint32_t)(unsafe.Pointer(d)) % Uint32FromInt32(i) + x2 = **(**Tuint32_t)(__ccgo_up(d)) % Uint32FromInt32(i) /* Are there any significant digits past j? */ if x2 != 0 || d+uintptr(1)*4 != z { round1 = Float64FromInt32(2) / Float64FromFloat64(2.22044604925031308085e-16) - if *(*Tuint32_t)(unsafe.Pointer(d))/Uint32FromInt32(i)&uint32(1) != 0 || i == int32(1000000000) && d > a && *(*Tuint32_t)(unsafe.Pointer(d + uintptr(-Int32FromInt32(1))*4))&uint32(1) != 0 { + if **(**Tuint32_t)(__ccgo_up(d))/Uint32FromInt32(i)&uint32(1) != 0 || i == int32(1000000000) && d > a && **(**Tuint32_t)(__ccgo_up(d + uintptr(-Int32FromInt32(1))*4))&uint32(1) != 0 { round1 = round1 + Float64FromInt32(2) } if x2 < Uint32FromInt32(i/int32(2)) { @@ -140369,29 +140369,29 @@ _4: small = Float64FromFloat64(1.5) } } - if pl != 0 && int32(*(*int8)(unsafe.Pointer(prefix))) == int32('-') { + if pl != 0 && int32(**(**int8)(__ccgo_up(prefix))) == int32('-') { round1 = round1 * float64(-Int32FromInt32(1)) small = small * float64(-Int32FromInt32(1)) } - *(*Tuint32_t)(unsafe.Pointer(d)) -= x2 + **(**Tuint32_t)(__ccgo_up(d)) -= x2 /* Decide whether to round by probing round+small */ if round1+small != round1 { - *(*Tuint32_t)(unsafe.Pointer(d)) = *(*Tuint32_t)(unsafe.Pointer(d)) + Uint32FromInt32(i) - for *(*Tuint32_t)(unsafe.Pointer(d)) > uint32(999999999) { + **(**Tuint32_t)(__ccgo_up(d)) = **(**Tuint32_t)(__ccgo_up(d)) + Uint32FromInt32(i) + for **(**Tuint32_t)(__ccgo_up(d)) > uint32(999999999) { v5 = d d -= 4 - *(*Tuint32_t)(unsafe.Pointer(v5)) = uint32(0) + **(**Tuint32_t)(__ccgo_up(v5)) = uint32(0) if d < a { a -= 4 v5 = a - *(*Tuint32_t)(unsafe.Pointer(v5)) = uint32(0) + **(**Tuint32_t)(__ccgo_up(v5)) = uint32(0) } - *(*Tuint32_t)(unsafe.Pointer(d)) = *(*Tuint32_t)(unsafe.Pointer(d)) + 1 + **(**Tuint32_t)(__ccgo_up(d)) = **(**Tuint32_t)(__ccgo_up(d)) + 1 } i = int32(10) e = int32(Int64FromInt32(9) * ((int64(r) - int64(a)) / 4)) for { - if !(*(*Tuint32_t)(unsafe.Pointer(a)) >= Uint32FromInt32(i)) { + if !(**(**Tuint32_t)(__ccgo_up(a)) >= Uint32FromInt32(i)) { break } goto _33 @@ -140407,7 +140407,7 @@ _4: } } for { - if !(z > a && !(*(*Tuint32_t)(unsafe.Pointer(z + uintptr(-Int32FromInt32(1))*4)) != 0)) { + if !(z > a && !(**(**Tuint32_t)(__ccgo_up(z + uintptr(-Int32FromInt32(1))*4)) != 0)) { break } goto _34 @@ -140428,11 +140428,11 @@ _4: } if !(Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0) { /* Count trailing zeros in last place */ - if z > a && *(*Tuint32_t)(unsafe.Pointer(z + uintptr(-Int32FromInt32(1))*4)) != 0 { + if z > a && **(**Tuint32_t)(__ccgo_up(z + uintptr(-Int32FromInt32(1))*4)) != 0 { i = int32(10) j = Int32FromInt32(0) for { - if !(*(*Tuint32_t)(unsafe.Pointer(z + uintptr(-Int32FromInt32(1))*4))%Uint32FromInt32(i) == uint32(0)) { + if !(**(**Tuint32_t)(__ccgo_up(z + uintptr(-Int32FromInt32(1))*4))%Uint32FromInt32(i) == uint32(0)) { break } goto _35 @@ -140502,7 +140502,7 @@ _4: for int64(ebuf)-int64(estr) < int64(2) { estr = estr - 1 v5 = estr - *(*int8)(unsafe.Pointer(v5)) = int8('0') + **(**int8)(__ccgo_up(v5)) = int8('0') } estr = estr - 1 v5 = estr @@ -140511,10 +140511,10 @@ _4: } else { v7 = int32('+') } - *(*int8)(unsafe.Pointer(v5)) = int8(v7) + **(**int8)(__ccgo_up(v5)) = int8(v7) estr = estr - 1 v5 = estr - *(*int8)(unsafe.Pointer(v5)) = int8(t) + **(**int8)(__ccgo_up(v5)) = int8(t) if int64(ebuf)-int64(estr) > int64(int32(INT_MAX)-l) { return -int32(1) } @@ -140535,18 +140535,18 @@ _4: if !(d <= r) { break } - s2 = _fmt_u(tls, uint64(*(*Tuint32_t)(unsafe.Pointer(d))), bp+516+uintptr(9)) + s2 = _fmt_u(tls, uint64(**(**Tuint32_t)(__ccgo_up(d))), bp+516+uintptr(9)) if d != a { for s2 > bp+516 { s2 = s2 - 1 v5 = s2 - *(*int8)(unsafe.Pointer(v5)) = int8('0') + **(**int8)(__ccgo_up(v5)) = int8('0') } } else { if s2 == bp+516+uintptr(9) { s2 = s2 - 1 v5 = s2 - *(*int8)(unsafe.Pointer(v5)) = int8('0') + **(**int8)(__ccgo_up(v5)) = int8('0') } } _out(tls, f, s2, Uint64FromInt64(int64(bp+516+uintptr(9))-int64(s2))) @@ -140562,11 +140562,11 @@ _4: if !(d < z && p > 0) { break } - s3 = _fmt_u(tls, uint64(*(*Tuint32_t)(unsafe.Pointer(d))), bp+516+uintptr(9)) + s3 = _fmt_u(tls, uint64(**(**Tuint32_t)(__ccgo_up(d))), bp+516+uintptr(9)) for s3 > bp+516 { s3 = s3 - 1 v5 = s3 - *(*int8)(unsafe.Pointer(v5)) = int8('0') + **(**int8)(__ccgo_up(v5)) = int8('0') } if int32(9) < p { v7 = int32(9) @@ -140590,17 +140590,17 @@ _4: if !(d < z && p >= 0) { break } - s4 = _fmt_u(tls, uint64(*(*Tuint32_t)(unsafe.Pointer(d))), bp+516+uintptr(9)) + s4 = _fmt_u(tls, uint64(**(**Tuint32_t)(__ccgo_up(d))), bp+516+uintptr(9)) if s4 == bp+516+uintptr(9) { s4 = s4 - 1 v5 = s4 - *(*int8)(unsafe.Pointer(v5)) = int8('0') + **(**int8)(__ccgo_up(v5)) = int8('0') } if d != a { for s4 > bp+516 { s4 = s4 - 1 v5 = s4 - *(*int8)(unsafe.Pointer(v5)) = int8('0') + **(**int8)(__ccgo_up(v5)) = int8('0') } } else { v5 = s4 @@ -140639,18 +140639,18 @@ func _getint(tls *TLS, s uintptr) (r int32) { _ = i i = 0 for { - if !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-uint32('0') < uint32(10)) != 0) { break } - if Uint32FromInt32(i) > Uint32FromInt32(INT_MAX)/Uint32FromUint32(10) || int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-int32('0') > int32(INT_MAX)-int32(10)*i { + if Uint32FromInt32(i) > Uint32FromInt32(INT_MAX)/Uint32FromUint32(10) || int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-int32('0') > int32(INT_MAX)-int32(10)*i { i = -int32(1) } else { - i = int32(10)*i + (int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s))))) - int32('0')) + i = int32(10)*i + (int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(s))))) - int32('0')) } goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s)) = *(*uintptr)(unsafe.Pointer(s)) + 1 + **(**uintptr)(__ccgo_up(s)) = **(**uintptr)(__ccgo_up(s)) + 1 } return i } @@ -140671,7 +140671,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, var _ /* s at bp+0 */ uintptr var _ /* wc at bp+40 */ [2]Twchar_t _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argpos, cnt, fl, i, l, l10n, p, pl, prefix, ps, st, t, w, ws, xp, z, v31, v34, v45, v5, v6, v8 - *(*uintptr)(unsafe.Pointer(bp)) = fmt + **(**uintptr)(__ccgo_up(bp)) = fmt l10n = uint32(0) cnt = 0 l = 0 @@ -140684,30 +140684,30 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } /* Update output count, end loop when fmt is exhausted */ cnt = cnt + l - if !(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) != 0) { + if !(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))) != 0) { break } /* Handle literal text and %% format specifiers */ - a = *(*uintptr)(unsafe.Pointer(bp)) + a = **(**uintptr)(__ccgo_up(bp)) for { - if !(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) != 0 && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32('%')) { + if !(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))) != 0 && int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) != int32('%')) { break } goto _2 _2: ; - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 } - z = *(*uintptr)(unsafe.Pointer(bp)) + z = **(**uintptr)(__ccgo_up(bp)) for { - if !(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('%') && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1))) == int32('%')) { + if !(int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) == int32('%') && int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1))) == int32('%')) { break } goto _3 _3: ; z = z + 1 - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(2) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + uintptr(2) } if int64(z)-int64(a) > int64(int32(INT_MAX)-cnt) { goto overflow @@ -140719,46 +140719,46 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if l != 0 { goto _1 } - if BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))-uint32('0') < uint32(10)) != 0 && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2))) == int32('$') { + if BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1)))-uint32('0') < uint32(10)) != 0 && int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 2))) == int32('$') { l10n = uint32(1) - argpos = int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1))) - int32('0') - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(3) + argpos = int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1))) - int32('0') + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + uintptr(3) } else { argpos = -int32(1) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 } /* Read modifier flags */ fl = uint32(0) for { - if !(Uint32FromInt8(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-uint32(' ') < uint32(32) && (Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('0')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('\'')-Int32FromUint8(' ')))&(uint32(1)<<(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-int32(' '))) != 0) { + if !(Uint32FromInt8(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))))-uint32(' ') < uint32(32) && (Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('0')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('\'')-Int32FromUint8(' ')))&(uint32(1)<<(int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))))-int32(' '))) != 0) { break } - fl = fl | uint32(1)<<(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-int32(' ')) + fl = fl | uint32(1)<<(int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))))-int32(' ')) goto _4 _4: ; - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 } /* Read field width */ - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('*') { - if BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))-uint32('0') < uint32(10)) != 0 && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2))) == int32('$') { + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) == int32('*') { + if BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1)))-uint32('0') < uint32(10)) != 0 && int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 2))) == int32('$') { l10n = uint32(1) if !(f != 0) { - *(*int32)(unsafe.Pointer(nl_type + uintptr(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))-int32('0'))*4)) = int32(_INT) + **(**int32)(__ccgo_up(nl_type + uintptr(int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1)))-int32('0'))*4)) = int32(_INT) w = Int32FromInt32(0) } else { - w = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))-int32('0'))*8))) + w = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1)))-int32('0'))*8))) } - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(3) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + uintptr(3) } else { if !(l10n != 0) { if f != 0 { - v5 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) + v5 = VaInt32(&**(**Tva_list)(__ccgo_up(ap))) } else { v5 = 0 } w = v5 - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 } else { goto inval } @@ -140775,32 +140775,32 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } } /* Read precision */ - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('.') && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1))) == int32('*') { - if BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2)))-uint32('0') < uint32(10)) != 0 && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 3))) == int32('$') { + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) == int32('.') && int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1))) == int32('*') { + if BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 2)))-uint32('0') < uint32(10)) != 0 && int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 3))) == int32('$') { if !(f != 0) { - *(*int32)(unsafe.Pointer(nl_type + uintptr(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2)))-int32('0'))*4)) = int32(_INT) + **(**int32)(__ccgo_up(nl_type + uintptr(int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 2)))-int32('0'))*4)) = int32(_INT) p = Int32FromInt32(0) } else { - p = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2)))-int32('0'))*8))) + p = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 2)))-int32('0'))*8))) } - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(4) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + uintptr(4) } else { if !(l10n != 0) { if f != 0 { - v5 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) + v5 = VaInt32(&**(**Tva_list)(__ccgo_up(ap))) } else { v5 = 0 } p = v5 - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(2) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + uintptr(2) } else { goto inval } } xp = BoolInt32(p >= 0) } else { - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('.') { - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) == int32('.') { + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 p = _getint(tls, bp) xp = int32(1) } else { @@ -140811,13 +140811,13 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, /* Format specifier state machine */ st = uint32(0) for cond := true; cond; cond = st-uint32(1) < uint32(_STOP) { - if Uint32FromInt8(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-uint32('A') > Uint32FromInt32(Int32FromUint8('z')-Int32FromUint8('A')) { + if Uint32FromInt8(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))))-uint32('A') > Uint32FromInt32(Int32FromUint8('z')-Int32FromUint8('A')) { goto inval } ps = st - v8 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - st = uint32(*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_states)) + uintptr(st)*58 + uintptr(int32(*(*int8)(unsafe.Pointer(v8)))-int32('A'))))) + v8 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + st = uint32(**(**uint8)(__ccgo_up(uintptr(unsafe.Pointer(&_states)) + uintptr(st)*58 + uintptr(int32(**(**int8)(__ccgo_up(v8)))-int32('A'))))) } if !(st != 0) { goto inval @@ -140830,9 +140830,9 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } else { if argpos >= 0 { if !(f != 0) { - *(*int32)(unsafe.Pointer(nl_type + uintptr(argpos)*4)) = Int32FromUint32(st) + **(**int32)(__ccgo_up(nl_type + uintptr(argpos)*4)) = Int32FromUint32(st) } else { - *(*Targ)(unsafe.Pointer(bp + 8)) = *(*Targ)(unsafe.Pointer(nl_arg + uintptr(argpos)*8)) + **(**Targ)(__ccgo_up(bp + 8)) = **(**Targ)(__ccgo_up(nl_arg + uintptr(argpos)*8)) } } else { if f != 0 { @@ -140852,7 +140852,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, z = bp + 16 + uintptr(24) prefix = __ccgo_ts + 1634 pl = 0 - t = int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + uintptr(-Int32FromInt32(1))))) + t = int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + uintptr(-Int32FromInt32(1))))) /* Transform ls,lc -> S,C */ if ps != 0 && t&int32(15) == int32(3) { t = t & ^Int32FromInt32(32) @@ -140910,19 +140910,19 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, ; switch ps { case uint32(_BARE): - *(*int32)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) = cnt + **(**int32)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 8)))) = cnt case uint32(_LPRE): - *(*int64)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) = int64(cnt) + **(**int64)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 8)))) = int64(cnt) case uint32(_LLPRE): - *(*int64)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) = int64(cnt) + **(**int64)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 8)))) = int64(cnt) case uint32(_HPRE): - *(*uint16)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) = Uint16FromInt32(cnt) + **(**uint16)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 8)))) = Uint16FromInt32(cnt) case uint32(_HHPRE): - *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) = Uint8FromInt32(cnt) + **(**uint8)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 8)))) = Uint8FromInt32(cnt) case uint32(_ZTPRE): - *(*Tsize_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) = Uint64FromInt32(cnt) + **(**Tsize_t)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 8)))) = Uint64FromInt32(cnt) case uint32(_JPRE): - *(*Tuintmax_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) = Uint64FromInt32(cnt) + **(**Tuintmax_t)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 8)))) = Uint64FromInt32(cnt) break } goto _1 @@ -141008,7 +141008,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, p = v5 v8 = z - uintptr(v5) a = v8 - *(*int8)(unsafe.Pointer(v8)) = Int8FromUint64(*(*Tuintmax_t)(unsafe.Pointer(bp + 8))) + **(**int8)(__ccgo_up(v8)) = Int8FromUint64(*(*Tuintmax_t)(unsafe.Pointer(bp + 8))) fl = fl & ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) goto _30 _19: @@ -141016,7 +141016,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if !(int32(1) != 0) { goto _37 } - a = Xstrerror(tls, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) + a = Xstrerror(tls, **(**int32)(__ccgo_up(X__errno_location(tls)))) goto _38 _37: ; @@ -141036,7 +141036,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, v5 = p } z = a + uintptr(Xstrnlen(tls, a, Uint64FromInt32(v5))) - if p < 0 && *(*int8)(unsafe.Pointer(z)) != 0 { + if p < 0 && **(**int8)(__ccgo_up(z)) != 0 { goto overflow } p = int32(int64(z) - int64(a)) @@ -141047,8 +141047,8 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if !(*(*Tuintmax_t)(unsafe.Pointer(bp + 8)) != 0) { goto narrow_c } - (*(*[2]Twchar_t)(unsafe.Pointer(bp + 40)))[0] = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(bp + 8))) - (*(*[2]Twchar_t)(unsafe.Pointer(bp + 40)))[int32(1)] = 0 + (**(**[2]Twchar_t)(__ccgo_up(bp + 40)))[0] = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(bp + 8))) + (**(**[2]Twchar_t)(__ccgo_up(bp + 40)))[int32(1)] = 0 *(*uintptr)(unsafe.Pointer(bp + 8)) = bp + 40 p = -int32(1) _21: @@ -141058,10 +141058,10 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, l = v5 i = Uint64FromInt32(v5) for { - if v45 = i < Uint64FromInt32(p) && *(*Twchar_t)(unsafe.Pointer(ws)) != 0; v45 { + if v45 = i < Uint64FromInt32(p) && **(**Twchar_t)(__ccgo_up(ws)) != 0; v45 { v8 = ws ws += 4 - v6 = Xwctomb(tls, bp+48, *(*Twchar_t)(unsafe.Pointer(v8))) + v6 = Xwctomb(tls, bp+48, **(**Twchar_t)(__ccgo_up(v8))) l = v6 } if !(v45 && v6 >= 0 && Uint64FromInt32(l) <= Uint64FromInt32(p)-i) { @@ -141083,10 +141083,10 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, ws = *(*uintptr)(unsafe.Pointer(bp + 8)) i = uint64(0) for { - if v45 = i < uint64(0+Uint32FromInt32(p)) && *(*Twchar_t)(unsafe.Pointer(ws)) != 0; v45 { + if v45 = i < uint64(0+Uint32FromInt32(p)) && **(**Twchar_t)(__ccgo_up(ws)) != 0; v45 { v8 = ws ws += 4 - v5 = Xwctomb(tls, bp+48, *(*Twchar_t)(unsafe.Pointer(v8))) + v5 = Xwctomb(tls, bp+48, **(**Twchar_t)(__ccgo_up(v8))) l = v5 } if !(v45 && i+Uint64FromInt32(v5) <= Uint64FromInt32(p)) { @@ -141162,17 +141162,17 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } i = uint64(1) for { - if !(i <= uint64(NL_ARGMAX) && *(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)) != 0) { + if !(i <= uint64(NL_ARGMAX) && **(**int32)(__ccgo_up(nl_type + uintptr(i)*4)) != 0) { break } - _pop_arg(tls, nl_arg+uintptr(i)*8, *(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)), ap) + _pop_arg(tls, nl_arg+uintptr(i)*8, **(**int32)(__ccgo_up(nl_type + uintptr(i)*4)), ap) goto _51 _51: ; i = i + 1 } for { - if !(i <= uint64(NL_ARGMAX) && !(*(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)) != 0)) { + if !(i <= uint64(NL_ARGMAX) && !(**(**int32)(__ccgo_up(nl_type + uintptr(i)*4)) != 0)) { break } goto _52 @@ -141187,12 +141187,12 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto inval inval: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) goto overflow overflow: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return -int32(1) } @@ -141210,12 +141210,12 @@ func Xvfprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { var _ /* nl_arg at bp+48 */ [10]Targ var _ /* nl_type at bp+8 */ [10]int32 _, _, _, _, _, _, _ = __need_unlock, olderr, ret, saved_buf, v1, v2, v3 - *(*[10]int32)(unsafe.Pointer(bp + 8)) = [10]int32{} + **(**[10]int32)(__ccgo_up(bp + 8)) = [10]int32{} saved_buf = uintptr(0) /* the copy allows passing va_list* even if va_list is an array */ - *(*Tva_list)(unsafe.Pointer(bp)) = ap + **(**Tva_list)(__ccgo_up(bp)) = ap if _printf_core(tls, uintptr(0), fmt, bp, bp+48, bp+8) < 0 { - _ = *(*Tva_list)(unsafe.Pointer(bp)) + _ = **(**Tva_list)(__ccgo_up(bp)) return -int32(1) } if AtomicLoadPInt32(f+140) >= 0 { @@ -141225,7 +141225,7 @@ func Xvfprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } __need_unlock = v1 olderr = Int32FromUint32((*TFILE)(unsafe.Pointer(f)).Fflags & uint32(F_ERR)) - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_ERR)) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^Int32FromInt32(F_ERR)) if !((*TFILE)(unsafe.Pointer(f)).Fbuf_size != 0) { saved_buf = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Fbuf = bp + 128 @@ -141257,11 +141257,11 @@ func Xvfprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_ERR) != 0 { ret = -int32(1) } - *(*uint32)(unsafe.Pointer(f)) |= Uint32FromInt32(olderr) + **(**uint32)(__ccgo_up(f)) |= Uint32FromInt32(olderr) if __need_unlock != 0 { ___unlockfile(tls, f) } - _ = *(*Tva_list)(unsafe.Pointer(bp)) + _ = **(**Tva_list)(__ccgo_up(bp)) return ret } @@ -141278,15 +141278,15 @@ func _store_int(tls *TLS, dest uintptr, size int32, i uint64) { } switch size { case -int32(2): - *(*int8)(unsafe.Pointer(dest)) = Int8FromUint64(i) + **(**int8)(__ccgo_up(dest)) = Int8FromUint64(i) case -int32(1): - *(*int16)(unsafe.Pointer(dest)) = Int16FromUint64(i) + **(**int16)(__ccgo_up(dest)) = Int16FromUint64(i) case SIZE_def: - *(*int32)(unsafe.Pointer(dest)) = Int32FromUint64(i) + **(**int32)(__ccgo_up(dest)) = Int32FromUint64(i) case int32(SIZE_l): - *(*int64)(unsafe.Pointer(dest)) = Int64FromUint64(i) + **(**int64)(__ccgo_up(dest)) = Int64FromUint64(i) case int32(SIZE_ll): - *(*int64)(unsafe.Pointer(dest)) = Int64FromUint64(i) + **(**int64)(__ccgo_up(dest)) = Int64FromUint64(i) break } } @@ -141349,17 +141349,17 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } p = fmt for { - if !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if !(**(**uint8)(__ccgo_up(p)) != 0) { break } alloc = 0 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v3 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _5 _5: if v3 != 0 { for { - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) v6 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _8 _8: @@ -141374,7 +141374,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v1 = X__shgetc(tls, f) } @@ -141392,16 +141392,16 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { pos = pos + ((*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf))) goto _2 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32('%') || Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('%') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) != int32('%') || Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) == int32('%') { X__shlim(tls, f, int64(Int32FromInt32(0))) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('%') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('%') { p = p + 1 for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v3 = X__shgetc(tls, f) } @@ -141420,13 +141420,13 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v1 = X__shgetc(tls, f) } c = v1 } - if c != Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) { + if c != Int32FromUint8(**(**uint8)(__ccgo_up(p))) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } @@ -141439,12 +141439,12 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { goto _2 } p = p + 1 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('*') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('*') { dest = uintptr(0) p = p + 1 } else { - if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('$') { - dest = _arg_n(tls, ap, Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))-int32('0'))) + if BoolInt32(uint32(**(**uint8)(__ccgo_up(p)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) == int32('$') { + dest = _arg_n(tls, ap, Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(p)))-int32('0'))) p = p + uintptr(2) } else { dest = VaUintptr(&ap) @@ -141452,16 +141452,16 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } width = 0 for { - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p)))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(p)))-uint32('0') < uint32(10)) != 0) { break } - width = int32(10)*width + Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - int32('0') + width = int32(10)*width + Int32FromUint8(**(**uint8)(__ccgo_up(p))) - int32('0') goto _25 _25: ; p = p + 1 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('m') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('m') { wcs = uintptr(0) s = uintptr(0) alloc = BoolInt32(!!(dest != 0)) @@ -141472,16 +141472,16 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { size = SIZE_def v10 = p p = p + 1 - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(v10))) { case int32('h'): - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('h') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('h') { p = p + 1 size = -Int32FromInt32(2) } else { size = -int32(1) } case int32('l'): - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('l') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('l') { p = p + 1 size = Int32FromInt32(SIZE_ll) } else { @@ -141540,7 +141540,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { default: goto fmt_fail } - t = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + t = Int32FromUint8(**(**uint8)(__ccgo_up(p))) /* C or S */ if t&int32(0x2f) == int32(3) { t = t | int32(32) @@ -141564,7 +141564,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v1 = X__shgetc(tls, f) } @@ -141586,7 +141586,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v1 = X__shgetc(tls, f) } @@ -141643,58 +141643,58 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { ; if t == int32('c') || t == int32('s') { Xmemset(tls, bp+16, -int32(1), uint64(257)) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[0] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[0] = uint8(0) if t == int32('s') { - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\t')] = uint8(0) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\n')] = uint8(0) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\v')] = uint8(0) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\f')] = uint8(0) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\r')] = uint8(0) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8(' ')] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\t')] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\n')] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\v')] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\f')] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\r')] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8(' ')] = uint8(0) } } else { p = p + 1 v10 = p - if Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) == int32('^') { + if Int32FromUint8(**(**uint8)(__ccgo_up(v10))) == int32('^') { p = p + 1 invert = Int32FromInt32(1) } else { invert = 0 } Xmemset(tls, bp+16, invert, uint64(257)) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[0] = uint8(0) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') { + (**(**[257]uint8)(__ccgo_up(bp + 16)))[0] = uint8(0) + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('-') { p = p + 1 - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('-')] = Uint8FromInt32(Int32FromInt32(1) - invert) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('-')] = Uint8FromInt32(Int32FromInt32(1) - invert) } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32(']') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32(']') { p = p + 1 - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8(']')] = Uint8FromInt32(Int32FromInt32(1) - invert) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8(']')] = Uint8FromInt32(Int32FromInt32(1) - invert) } } for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32(']')) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(p))) != int32(']')) { break } - if !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if !(**(**uint8)(__ccgo_up(p)) != 0) { goto fmt_fail } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') && *(*uint8)(unsafe.Pointer(p + 1)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) != int32(']') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('-') && **(**uint8)(__ccgo_up(p + 1)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) != int32(']') { v10 = p p = p + 1 - c = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10 + uintptr(-Int32FromInt32(1))))) + c = Int32FromUint8(**(**uint8)(__ccgo_up(v10 + uintptr(-Int32FromInt32(1))))) for { - if !(c < Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))) { + if !(c < Int32FromUint8(**(**uint8)(__ccgo_up(p)))) { break } - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[int32(1)+c] = Uint8FromInt32(int32(1) - invert) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[int32(1)+c] = Uint8FromInt32(int32(1) - invert) goto _57 _57: ; c = c + 1 } } - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[int32(1)+Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))] = Uint8FromInt32(int32(1) - invert) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[int32(1)+Int32FromUint8(**(**uint8)(__ccgo_up(p)))] = Uint8FromInt32(int32(1) - invert) goto _56 _56: ; @@ -141719,19 +141719,19 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } else { wcs = dest } - *(*Tmbstate_t)(unsafe.Pointer(bp + 8)) = Tmbstate_t{} + **(**Tmbstate_t)(__ccgo_up(bp + 8)) = Tmbstate_t{} for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v3 = X__shgetc(tls, f) } v1 = v3 c = v1 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { + if !((**(**[257]uint8)(__ccgo_up(bp + 16)))[v1+int32(1)] != 0) { break } *(*int8)(unsafe.Pointer(bp)) = int8(c) @@ -141744,7 +141744,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if wcs != 0 { v64 = i i = i + 1 - *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(v64)*4)) = *(*Twchar_t)(unsafe.Pointer(bp + 276)) + **(**Twchar_t)(__ccgo_up(wcs + uintptr(v64)*4)) = **(**Twchar_t)(__ccgo_up(bp + 276)) } if alloc != 0 && i == k { k = k + (k + uint64(1)) @@ -141769,18 +141769,18 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v3 = X__shgetc(tls, f) } v1 = v3 c = v1 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { + if !((**(**[257]uint8)(__ccgo_up(bp + 16)))[v1+int32(1)] != 0) { break } v64 = i i = i + 1 - *(*int8)(unsafe.Pointer(s + uintptr(v64))) = int8(c) + **(**int8)(__ccgo_up(s + uintptr(v64))) = int8(c) if i == k { k = k + (k + uint64(1)) tmp1 = Xrealloc(tls, s, k) @@ -141799,18 +141799,18 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v17 = f + 8 v11 = *(*uintptr)(unsafe.Pointer(v17)) *(*uintptr)(unsafe.Pointer(v17)) = *(*uintptr)(unsafe.Pointer(v17)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v11))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v11))) } else { v3 = X__shgetc(tls, f) } v1 = v3 c = v1 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { + if !((**(**[257]uint8)(__ccgo_up(bp + 16)))[v1+int32(1)] != 0) { break } v64 = i i = i + 1 - *(*int8)(unsafe.Pointer(s + uintptr(v64))) = int8(c) + **(**int8)(__ccgo_up(s + uintptr(v64))) = int8(c) } } else { for { @@ -141818,13 +141818,13 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v3 = X__shgetc(tls, f) } v1 = v3 c = v1 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { + if !((**(**[257]uint8)(__ccgo_up(bp + 16)))[v1+int32(1)] != 0) { break } } @@ -141842,17 +141842,17 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } if alloc != 0 { if size == int32(SIZE_l) { - *(*uintptr)(unsafe.Pointer(dest)) = wcs + **(**uintptr)(__ccgo_up(dest)) = wcs } else { - *(*uintptr)(unsafe.Pointer(dest)) = s + **(**uintptr)(__ccgo_up(dest)) = s } } if t != int32('c') { if wcs != 0 { - *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) = 0 + **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) = 0 } if s != 0 { - *(*int8)(unsafe.Pointer(s + uintptr(i))) = 0 + **(**int8)(__ccgo_up(s + uintptr(i))) = 0 } } goto _54 @@ -141885,7 +141885,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { goto match_fail } if t == int32('p') && dest != 0 { - *(*uintptr)(unsafe.Pointer(dest)) = uintptr(x) + **(**uintptr)(__ccgo_up(dest)) = uintptr(x) } else { _store_int(tls, dest, size, x) } @@ -141913,11 +141913,11 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if dest != 0 { switch size { case SIZE_def: - *(*float32)(unsafe.Pointer(dest)) = float32(y) + **(**float32)(__ccgo_up(dest)) = float32(y) case int32(SIZE_l): - *(*float64)(unsafe.Pointer(dest)) = y + **(**float64)(__ccgo_up(dest)) = y case int32(SIZE_L): - *(*float64)(unsafe.Pointer(dest)) = y + **(**float64)(__ccgo_up(dest)) = y break } } @@ -142083,41 +142083,41 @@ var _states1 = [8][58]uint8{ func _pop_arg1(tls *TLS, arg uintptr, type1 int32, ap uintptr) { switch type1 { case int32(_PTR): - *(*uintptr)(unsafe.Pointer(arg)) = VaUintptr(&*(*Tva_list)(unsafe.Pointer(ap))) + *(*uintptr)(unsafe.Pointer(arg)) = VaUintptr(&**(**Tva_list)(__ccgo_up(ap))) case int32(_INT): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_UINT): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint32(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint32(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_LONG): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_ULONG): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&**(**Tva_list)(__ccgo_up(ap))) case int32(_ULLONG): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_SHORT): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt16(int16(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt16(int16(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_USHORT): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint16FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint16FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_CHAR): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt8(int8(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt8(int8(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_UCHAR): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint8FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint8FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_LLONG): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_SIZET): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&**(**Tva_list)(__ccgo_up(ap))) case int32(_IMAX): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_UMAX): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&**(**Tva_list)(__ccgo_up(ap))) case int32(_PDIFF): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_UIPTR): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUintptr(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUintptr(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_DBL): - *(*float64)(unsafe.Pointer(arg)) = float64(VaFloat64(&*(*Tva_list)(unsafe.Pointer(ap)))) + *(*float64)(unsafe.Pointer(arg)) = float64(VaFloat64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_LDBL): - *(*float64)(unsafe.Pointer(arg)) = VaFloat64(&*(*Tva_list)(unsafe.Pointer(ap))) + *(*float64)(unsafe.Pointer(arg)) = VaFloat64(&**(**Tva_list)(__ccgo_up(ap))) } } @@ -142133,7 +142133,7 @@ func _out1(tls *TLS, f uintptr, s uintptr, l Tsize_t) { } v2 = s s += 4 - Xfputwc(tls, *(*Twchar_t)(unsafe.Pointer(v2)), f) + Xfputwc(tls, **(**Twchar_t)(__ccgo_up(v2)), f) } } @@ -142151,18 +142151,18 @@ func _getint1(tls *TLS, s uintptr) (r int32) { _ = i i = 0 for { - if !(BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-uint32('0') < uint32(10)) != 0) { break } - if Uint32FromInt32(i) > Uint32FromInt32(INT_MAX)/Uint32FromUint32(10) || *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s))))-int32('0') > int32(INT_MAX)-int32(10)*i { + if Uint32FromInt32(i) > Uint32FromInt32(INT_MAX)/Uint32FromUint32(10) || **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(s))))-int32('0') > int32(INT_MAX)-int32(10)*i { i = -int32(1) } else { - i = int32(10)*i + (*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))) - int32('0')) + i = int32(10)*i + (**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))) - int32('0')) } goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s)) += 4 + **(**uintptr)(__ccgo_up(s)) += 4 } return i } @@ -142193,7 +142193,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, var _ /* s at bp+8 */ uintptr var _ /* wc at bp+40 */ Twchar_t _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argpos, bs, cnt, fl, i, l, l10n, p, ps, st, t, w, xp, z, v15, v5, v6, v7, v8, v9 - *(*uintptr)(unsafe.Pointer(bp + 8)) = fmt + **(**uintptr)(__ccgo_up(bp + 8)) = fmt l10n = uint32(0) cnt = 0 l = 0 @@ -142206,30 +142206,30 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } /* Update output count, end loop when fmt is exhausted */ cnt = cnt + l - if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) != 0) { + if !(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) != 0) { break } /* Handle literal text and %% format specifiers */ - a = *(*uintptr)(unsafe.Pointer(bp + 8)) + a = **(**uintptr)(__ccgo_up(bp + 8)) for { - if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) != 0 && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) != int32('%')) { + if !(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) != 0 && **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) != int32('%')) { break } goto _2 _2: ; - *(*uintptr)(unsafe.Pointer(bp + 8)) += 4 + **(**uintptr)(__ccgo_up(bp + 8)) += 4 } - z = *(*uintptr)(unsafe.Pointer(bp + 8)) + z = **(**uintptr)(__ccgo_up(bp + 8)) for { - if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) == int32('%') && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4)) == int32('%')) { + if !(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) == int32('%') && **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 1*4)) == int32('%')) { break } goto _3 _3: ; z += 4 - *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(2)*4 + **(**uintptr)(__ccgo_up(bp + 8)) = **(**uintptr)(__ccgo_up(bp + 8)) + uintptr(2)*4 } if (int64(z)-int64(a))/4 > int64(int32(INT_MAX)-cnt) { goto overflow @@ -142241,42 +142241,42 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if l != 0 { goto _1 } - if BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4)))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4)) == int32('$') { + if BoolInt32(Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 1*4)))-uint32('0') < uint32(10)) != 0 && **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 2*4)) == int32('$') { l10n = uint32(1) - argpos = *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4)) - int32('0') - *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(3)*4 + argpos = **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 1*4)) - int32('0') + **(**uintptr)(__ccgo_up(bp + 8)) = **(**uintptr)(__ccgo_up(bp + 8)) + uintptr(3)*4 } else { argpos = -int32(1) - *(*uintptr)(unsafe.Pointer(bp + 8)) += 4 + **(**uintptr)(__ccgo_up(bp + 8)) += 4 } /* Read modifier flags */ fl = uint32(0) for { - if !(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))))-uint32(' ') < uint32(32) && (Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('0')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('\'')-Int32FromUint8(' ')))&(uint32(1)<<(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8))))-int32(' '))) != 0) { + if !(Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))))-uint32(' ') < uint32(32) && (Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('0')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('\'')-Int32FromUint8(' ')))&(uint32(1)<<(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8))))-int32(' '))) != 0) { break } - fl = fl | uint32(1)<<(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8))))-int32(' ')) + fl = fl | uint32(1)<<(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8))))-int32(' ')) goto _4 _4: ; - *(*uintptr)(unsafe.Pointer(bp + 8)) += 4 + **(**uintptr)(__ccgo_up(bp + 8)) += 4 } /* Read field width */ - if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) == int32('*') { - if BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4)))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4)) == int32('$') { + if **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) == int32('*') { + if BoolInt32(Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 1*4)))-uint32('0') < uint32(10)) != 0 && **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 2*4)) == int32('$') { l10n = uint32(1) - *(*int32)(unsafe.Pointer(nl_type + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4))-int32('0'))*4)) = int32(_INT) - w = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4))-int32('0'))*8))) - *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(3)*4 + **(**int32)(__ccgo_up(nl_type + uintptr(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 1*4))-int32('0'))*4)) = int32(_INT) + w = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 1*4))-int32('0'))*8))) + **(**uintptr)(__ccgo_up(bp + 8)) = **(**uintptr)(__ccgo_up(bp + 8)) + uintptr(3)*4 } else { if !(l10n != 0) { if f != 0 { - v5 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) + v5 = VaInt32(&**(**Tva_list)(__ccgo_up(ap))) } else { v5 = 0 } w = v5 - *(*uintptr)(unsafe.Pointer(bp + 8)) += 4 + **(**uintptr)(__ccgo_up(bp + 8)) += 4 } else { goto inval } @@ -142293,28 +142293,28 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } } /* Read precision */ - if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) == int32('.') && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4)) == int32('*') { - if BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4)))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 3*4)) == int32('$') { - *(*int32)(unsafe.Pointer(nl_type + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4))-int32('0'))*4)) = int32(_INT) - p = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4))-int32('0'))*8))) - *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(4)*4 + if **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) == int32('.') && **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 1*4)) == int32('*') { + if BoolInt32(Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 2*4)))-uint32('0') < uint32(10)) != 0 && **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 3*4)) == int32('$') { + **(**int32)(__ccgo_up(nl_type + uintptr(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 2*4))-int32('0'))*4)) = int32(_INT) + p = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 2*4))-int32('0'))*8))) + **(**uintptr)(__ccgo_up(bp + 8)) = **(**uintptr)(__ccgo_up(bp + 8)) + uintptr(4)*4 } else { if !(l10n != 0) { if f != 0 { - v5 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) + v5 = VaInt32(&**(**Tva_list)(__ccgo_up(ap))) } else { v5 = 0 } p = v5 - *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(2)*4 + **(**uintptr)(__ccgo_up(bp + 8)) = **(**uintptr)(__ccgo_up(bp + 8)) + uintptr(2)*4 } else { goto inval } } xp = BoolInt32(p >= 0) } else { - if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) == int32('.') { - *(*uintptr)(unsafe.Pointer(bp + 8)) += 4 + if **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) == int32('.') { + **(**uintptr)(__ccgo_up(bp + 8)) += 4 p = _getint1(tls, bp+8) xp = int32(1) } else { @@ -142325,13 +142325,13 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, /* Format specifier state machine */ st = uint32(0) for cond := true; cond; cond = st-uint32(1) < uint32(_STOP) { - if Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))))-uint32('A') > Uint32FromInt32(Int32FromUint8('z')-Int32FromUint8('A')) { + if Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))))-uint32('A') > Uint32FromInt32(Int32FromUint8('z')-Int32FromUint8('A')) { goto inval } ps = st - v8 = *(*uintptr)(unsafe.Pointer(bp + 8)) - *(*uintptr)(unsafe.Pointer(bp + 8)) += 4 - st = uint32(*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_states1)) + uintptr(st)*58 + uintptr(*(*Twchar_t)(unsafe.Pointer(v8))-int32('A'))))) + v8 = **(**uintptr)(__ccgo_up(bp + 8)) + **(**uintptr)(__ccgo_up(bp + 8)) += 4 + st = uint32(**(**uint8)(__ccgo_up(uintptr(unsafe.Pointer(&_states1)) + uintptr(st)*58 + uintptr(**(**Twchar_t)(__ccgo_up(v8))-int32('A'))))) } if !(st != 0) { goto inval @@ -142343,8 +142343,8 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } } else { if argpos >= 0 { - *(*int32)(unsafe.Pointer(nl_type + uintptr(argpos)*4)) = Int32FromUint32(st) - *(*Targ)(unsafe.Pointer(bp + 16)) = *(*Targ)(unsafe.Pointer(nl_arg + uintptr(argpos)*8)) + **(**int32)(__ccgo_up(nl_type + uintptr(argpos)*4)) = Int32FromUint32(st) + **(**Targ)(__ccgo_up(bp + 16)) = **(**Targ)(__ccgo_up(nl_arg + uintptr(argpos)*8)) } else { if f != 0 { _pop_arg1(tls, bp+16, Int32FromUint32(st), ap) @@ -142360,7 +142360,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_ERR) != 0 { return -int32(1) } - t = *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(-Int32FromInt32(1))*4)) + t = **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + uintptr(-Int32FromInt32(1))*4)) if ps != 0 && t&int32(15) == int32(3) { t = t & ^Int32FromInt32(32) } @@ -142368,19 +142368,19 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, case int32('n'): switch ps { case uint32(_BARE): - *(*int32)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))) = cnt + **(**int32)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 16)))) = cnt case uint32(_LPRE): - *(*int64)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))) = int64(cnt) + **(**int64)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 16)))) = int64(cnt) case uint32(_LLPRE): - *(*int64)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))) = int64(cnt) + **(**int64)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 16)))) = int64(cnt) case uint32(_HPRE): - *(*uint16)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))) = Uint16FromInt32(cnt) + **(**uint16)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 16)))) = Uint16FromInt32(cnt) case uint32(_HHPRE): - *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))) = Uint8FromInt32(cnt) + **(**uint8)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 16)))) = Uint8FromInt32(cnt) case uint32(_ZTPRE): - *(*Tsize_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))) = Uint64FromInt32(cnt) + **(**Tsize_t)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 16)))) = Uint64FromInt32(cnt) case uint32(_JPRE): - *(*Tuintmax_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))) = Uint64FromInt32(cnt) + **(**Tuintmax_t)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 16)))) = Uint64FromInt32(cnt) break } goto _1 @@ -142409,7 +142409,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, v5 = p } z = a + uintptr(Xwcsnlen(tls, a, Uint64FromInt32(v5)))*4 - if p < 0 && *(*Twchar_t)(unsafe.Pointer(z)) != 0 { + if p < 0 && **(**Twchar_t)(__ccgo_up(z)) != 0 { goto overflow } p = int32((int64(z) - int64(a)) / 4) @@ -142422,7 +142422,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, l = w goto _1 case int32('m'): - *(*uintptr)(unsafe.Pointer(bp + 16)) = Xstrerror(tls, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) + *(*uintptr)(unsafe.Pointer(bp + 16)) = Xstrerror(tls, **(**int32)(__ccgo_up(X__errno_location(tls)))) fallthrough case int32('s'): if !(*(*uintptr)(unsafe.Pointer(bp + 16)) != 0) { @@ -142454,7 +142454,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if i < 0 { return -int32(1) } - if p < 0 && *(*int8)(unsafe.Pointer(bs)) != 0 { + if p < 0 && **(**int8)(__ccgo_up(bs)) != 0 { goto overflow } p = l @@ -142515,17 +142515,17 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } i = int32(1) for { - if !(i <= int32(NL_ARGMAX) && *(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)) != 0) { + if !(i <= int32(NL_ARGMAX) && **(**int32)(__ccgo_up(nl_type + uintptr(i)*4)) != 0) { break } - _pop_arg1(tls, nl_arg+uintptr(i)*8, *(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)), ap) + _pop_arg1(tls, nl_arg+uintptr(i)*8, **(**int32)(__ccgo_up(nl_type + uintptr(i)*4)), ap) goto _17 _17: ; i = i + 1 } for { - if !(i <= int32(NL_ARGMAX) && !(*(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)) != 0)) { + if !(i <= int32(NL_ARGMAX) && !(**(**int32)(__ccgo_up(nl_type + uintptr(i)*4)) != 0)) { break } goto _18 @@ -142540,12 +142540,12 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto inval inval: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) goto overflow overflow: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return -int32(1) } @@ -142561,11 +142561,11 @@ func Xvfwprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { var _ /* nl_arg at bp+48 */ [10]Targ var _ /* nl_type at bp+8 */ [10]int32 _, _, _, _ = __need_unlock, olderr, ret, v1 - *(*[10]int32)(unsafe.Pointer(bp + 8)) = [10]int32{} + **(**[10]int32)(__ccgo_up(bp + 8)) = [10]int32{} /* the copy allows passing va_list* even if va_list is an array */ - *(*Tva_list)(unsafe.Pointer(bp)) = ap + **(**Tva_list)(__ccgo_up(bp)) = ap if _wprintf_core(tls, uintptr(0), fmt, bp, bp+48, bp+8) < 0 { - _ = *(*Tva_list)(unsafe.Pointer(bp)) + _ = **(**Tva_list)(__ccgo_up(bp)) return -int32(1) } if AtomicLoadPInt32(f+140) >= 0 { @@ -142576,16 +142576,16 @@ func Xvfwprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { __need_unlock = v1 Xfwide(tls, f, int32(1)) olderr = Int32FromUint32((*TFILE)(unsafe.Pointer(f)).Fflags & uint32(F_ERR)) - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_ERR)) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^Int32FromInt32(F_ERR)) ret = _wprintf_core(tls, f, fmt, bp, bp+48, bp+8) if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_ERR) != 0 { ret = -int32(1) } - *(*uint32)(unsafe.Pointer(f)) |= Uint32FromInt32(olderr) + **(**uint32)(__ccgo_up(f)) |= Uint32FromInt32(olderr) if __need_unlock != 0 { ___unlockfile(tls, f) } - _ = *(*Tva_list)(unsafe.Pointer(bp)) + _ = **(**Tva_list)(__ccgo_up(bp)) return ret } @@ -142595,15 +142595,15 @@ func _store_int1(tls *TLS, dest uintptr, size int32, i uint64) { } switch size { case -int32(2): - *(*int8)(unsafe.Pointer(dest)) = Int8FromUint64(i) + **(**int8)(__ccgo_up(dest)) = Int8FromUint64(i) case -int32(1): - *(*int16)(unsafe.Pointer(dest)) = Int16FromUint64(i) + **(**int16)(__ccgo_up(dest)) = Int16FromUint64(i) case SIZE_def: - *(*int32)(unsafe.Pointer(dest)) = Int32FromUint64(i) + **(**int32)(__ccgo_up(dest)) = Int32FromUint64(i) case int32(SIZE_l): - *(*int64)(unsafe.Pointer(dest)) = Int64FromUint64(i) + **(**int64)(__ccgo_up(dest)) = Int64FromUint64(i) case int32(SIZE_ll): - *(*int64)(unsafe.Pointer(dest)) = Int64FromUint64(i) + **(**int64)(__ccgo_up(dest)) = Int64FromUint64(i) break } } @@ -142635,13 +142635,13 @@ func _in_set(tls *TLS, set uintptr, c int32) (r int32) { var p, v3 uintptr _, _, _ = j, p, v3 p = set - if *(*Twchar_t)(unsafe.Pointer(p)) == int32('-') { + if **(**Twchar_t)(__ccgo_up(p)) == int32('-') { if c == int32('-') { return int32(1) } p += 4 } else { - if *(*Twchar_t)(unsafe.Pointer(p)) == int32(']') { + if **(**Twchar_t)(__ccgo_up(p)) == int32(']') { if c == int32(']') { return int32(1) } @@ -142649,15 +142649,15 @@ func _in_set(tls *TLS, set uintptr, c int32) (r int32) { } } for { - if !(*(*Twchar_t)(unsafe.Pointer(p)) != 0 && *(*Twchar_t)(unsafe.Pointer(p)) != int32(']')) { + if !(**(**Twchar_t)(__ccgo_up(p)) != 0 && **(**Twchar_t)(__ccgo_up(p)) != int32(']')) { break } - if *(*Twchar_t)(unsafe.Pointer(p)) == int32('-') && *(*Twchar_t)(unsafe.Pointer(p + 1*4)) != 0 && *(*Twchar_t)(unsafe.Pointer(p + 1*4)) != int32(']') { + if **(**Twchar_t)(__ccgo_up(p)) == int32('-') && **(**Twchar_t)(__ccgo_up(p + 1*4)) != 0 && **(**Twchar_t)(__ccgo_up(p + 1*4)) != int32(']') { v3 = p p += 4 - j = *(*Twchar_t)(unsafe.Pointer(v3 + uintptr(-Int32FromInt32(1))*4)) + j = **(**Twchar_t)(__ccgo_up(v3 + uintptr(-Int32FromInt32(1))*4)) for { - if !(j < *(*Twchar_t)(unsafe.Pointer(p))) { + if !(j < **(**Twchar_t)(__ccgo_up(p))) { break } if c == j { @@ -142669,7 +142669,7 @@ func _in_set(tls *TLS, set uintptr, c int32) (r int32) { j = j + 1 } } - if c == *(*Twchar_t)(unsafe.Pointer(p)) { + if c == **(**Twchar_t)(__ccgo_up(p)) { return int32(1) } goto _1 @@ -142707,20 +142707,20 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { Xfwide(tls, f, int32(1)) p = fmt for { - if !(*(*Twchar_t)(unsafe.Pointer(p)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(p)) != 0) { break } alloc = 0 - if Xiswspace(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(p)))) != 0 { - for Xiswspace(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(p + 1*4)))) != 0 { + if Xiswspace(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(p)))) != 0 { + for Xiswspace(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(p + 1*4)))) != 0 { p += 4 } for { - if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { + if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(**(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) + v4 = uint32(**(**uint8)(__ccgo_up(v5))) } else { v4 = Xgetwc(tls, f) } @@ -142735,21 +142735,21 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v6 = f + 8 *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 v5 = *(*uintptr)(unsafe.Pointer(v6)) - _ = *(*uint8)(unsafe.Pointer(v5)) + _ = **(**uint8)(__ccgo_up(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } goto _2 } - if *(*Twchar_t)(unsafe.Pointer(p)) != int32('%') || *(*Twchar_t)(unsafe.Pointer(p + 1*4)) == int32('%') { - if *(*Twchar_t)(unsafe.Pointer(p)) == int32('%') { + if **(**Twchar_t)(__ccgo_up(p)) != int32('%') || **(**Twchar_t)(__ccgo_up(p + 1*4)) == int32('%') { + if **(**Twchar_t)(__ccgo_up(p)) == int32('%') { p += 4 for { - if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { + if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(**(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) + v4 = uint32(**(**uint8)(__ccgo_up(v5))) } else { v4 = Xgetwc(tls, f) } @@ -142761,22 +142761,22 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { pos = pos + 1 } } else { - if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { + if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(**(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) + v4 = uint32(**(**uint8)(__ccgo_up(v5))) } else { v4 = Xgetwc(tls, f) } c = Int32FromUint32(v4) } - if c != *(*Twchar_t)(unsafe.Pointer(p)) { + if c != **(**Twchar_t)(__ccgo_up(p)) { if (*TFILE)(unsafe.Pointer(f)).Frend != 0 && Uint32FromInt32(c) < uint32(128) { v6 = f + 8 *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 v5 = *(*uintptr)(unsafe.Pointer(v6)) - _ = *(*uint8)(unsafe.Pointer(v5)) + _ = **(**uint8)(__ccgo_up(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -142789,12 +142789,12 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { goto _2 } p += 4 - if *(*Twchar_t)(unsafe.Pointer(p)) == int32('*') { + if **(**Twchar_t)(__ccgo_up(p)) == int32('*') { dest = uintptr(0) p += 4 } else { - if BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(p)))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(p + 1*4)) == int32('$') { - dest = _arg_n1(tls, ap, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(p))-int32('0'))) + if BoolInt32(Uint32FromInt32(**(**Twchar_t)(__ccgo_up(p)))-uint32('0') < uint32(10)) != 0 && **(**Twchar_t)(__ccgo_up(p + 1*4)) == int32('$') { + dest = _arg_n1(tls, ap, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(p))-int32('0'))) p = p + uintptr(2)*4 } else { dest = VaUintptr(&ap) @@ -142802,16 +142802,16 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } width = 0 for { - if !(BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(p)))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(Uint32FromInt32(**(**Twchar_t)(__ccgo_up(p)))-uint32('0') < uint32(10)) != 0) { break } - width = int32(10)*width + *(*Twchar_t)(unsafe.Pointer(p)) - int32('0') + width = int32(10)*width + **(**Twchar_t)(__ccgo_up(p)) - int32('0') goto _18 _18: ; p += 4 } - if *(*Twchar_t)(unsafe.Pointer(p)) == int32('m') { + if **(**Twchar_t)(__ccgo_up(p)) == int32('m') { wcs = uintptr(0) s = uintptr(0) alloc = BoolInt32(!!(dest != 0)) @@ -142822,16 +142822,16 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { size = SIZE_def v5 = p p += 4 - switch *(*Twchar_t)(unsafe.Pointer(v5)) { + switch **(**Twchar_t)(__ccgo_up(v5)) { case int32('h'): - if *(*Twchar_t)(unsafe.Pointer(p)) == int32('h') { + if **(**Twchar_t)(__ccgo_up(p)) == int32('h') { p += 4 size = -Int32FromInt32(2) } else { size = -int32(1) } case int32('l'): - if *(*Twchar_t)(unsafe.Pointer(p)) == int32('l') { + if **(**Twchar_t)(__ccgo_up(p)) == int32('l') { p += 4 size = Int32FromInt32(SIZE_ll) } else { @@ -142890,7 +142890,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { default: goto fmt_fail } - t = *(*Twchar_t)(unsafe.Pointer(p)) + t = **(**Twchar_t)(__ccgo_up(p)) /* Transform S,C -> ls,lc */ if t&int32(0x2f) == int32(3) { size = int32(SIZE_l) @@ -142899,11 +142899,11 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if t != int32('n') { if t != int32('[') && t|int32(32) != int32('c') { for { - if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { + if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(**(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) + v4 = uint32(**(**uint8)(__ccgo_up(v5))) } else { v4 = Xgetwc(tls, f) } @@ -142915,11 +142915,11 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { pos = pos + 1 } } else { - if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { + if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(**(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) + v4 = uint32(**(**uint8)(__ccgo_up(v5))) } else { v4 = Xgetwc(tls, f) } @@ -142932,7 +142932,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v6 = f + 8 *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 v5 = *(*uintptr)(unsafe.Pointer(v6)) - _ = *(*uint8)(unsafe.Pointer(v5)) + _ = **(**uint8)(__ccgo_up(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -142960,18 +142960,18 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } else { p += 4 v5 = p - if *(*Twchar_t)(unsafe.Pointer(v5)) == int32('^') { + if **(**Twchar_t)(__ccgo_up(v5)) == int32('^') { p += 4 invert = Int32FromInt32(1) } else { invert = 0 } set = p - if *(*Twchar_t)(unsafe.Pointer(p)) == int32(']') { + if **(**Twchar_t)(__ccgo_up(p)) == int32(']') { p += 4 } - for *(*Twchar_t)(unsafe.Pointer(p)) != int32(']') { - if !(*(*Twchar_t)(unsafe.Pointer(p)) != 0) { + for **(**Twchar_t)(__ccgo_up(p)) != int32(']') { + if !(**(**Twchar_t)(__ccgo_up(p)) != 0) { goto fmt_fail } p += 4 @@ -143015,11 +143015,11 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } } for width != 0 { - if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { + if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(**(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) + v4 = uint32(**(**uint8)(__ccgo_up(v5))) } else { v4 = Xgetwc(tls, f) } @@ -143034,7 +143034,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if wcs != 0 { v37 = i i = i + 1 - *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(v37)*4)) = c + **(**Twchar_t)(__ccgo_up(wcs + uintptr(v37)*4)) = c if alloc != 0 && i == k { k = k + (k + uint64(1)) tmp1 = Xrealloc(tls, wcs, k*uint64(4)) @@ -143074,7 +143074,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v6 = f + 8 *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 v5 = *(*uintptr)(unsafe.Pointer(v6)) - _ = *(*uint8)(unsafe.Pointer(v5)) + _ = **(**uint8)(__ccgo_up(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -143084,17 +143084,17 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } if alloc != 0 { if size == int32(SIZE_l) { - *(*uintptr)(unsafe.Pointer(dest)) = wcs + **(**uintptr)(__ccgo_up(dest)) = wcs } else { - *(*uintptr)(unsafe.Pointer(dest)) = s + **(**uintptr)(__ccgo_up(dest)) = s } } if t != int32('c') { if wcs != 0 { - *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) = 0 + **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) = 0 } if s != 0 { - *(*int8)(unsafe.Pointer(s + uintptr(i))) = 0 + **(**int8)(__ccgo_up(s + uintptr(i))) = 0 } } case int32('d'): @@ -143130,7 +143130,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { width = 0 } Xsnprintf(tls, bp+8, uint64(22), __ccgo_ts+1687, VaList(bp+40, int32(1)+BoolInt32(!(dest != 0)), __ccgo_ts+1705, width, uintptr(unsafe.Pointer(&_size_pfx))+uintptr(size+int32(2))*3, t)) - *(*Toff_t)(unsafe.Pointer(bp)) = 0 + **(**Toff_t)(__ccgo_up(bp)) = 0 if dest != 0 { v5 = dest } else { @@ -143139,11 +143139,11 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if Xfscanf(tls, f, bp+8, VaList(bp+40, v5, bp)) == -int32(1) { goto input_fail } else { - if !(*(*Toff_t)(unsafe.Pointer(bp)) != 0) { + if !(**(**Toff_t)(__ccgo_up(bp)) != 0) { goto match_fail } } - pos = pos + *(*Toff_t)(unsafe.Pointer(bp)) + pos = pos + **(**Toff_t)(__ccgo_up(bp)) default: goto fmt_fail } @@ -143269,8 +143269,8 @@ func _sn_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { k = v1 if k != 0 { Xmemcpy(tls, (*Tcookie3)(unsafe.Pointer(c)).Fs, (*TFILE)(unsafe.Pointer(f)).Fwbase, k) - *(*uintptr)(unsafe.Pointer(c)) += uintptr(k) - *(*Tsize_t)(unsafe.Pointer(c + 8)) -= k + **(**uintptr)(__ccgo_up(c)) += uintptr(k) + **(**Tsize_t)(__ccgo_up(c + 8)) -= k } if (*Tcookie3)(unsafe.Pointer(c)).Fn < l { v1 = (*Tcookie3)(unsafe.Pointer(c)).Fn @@ -143280,10 +143280,10 @@ func _sn_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { k = v1 if k != 0 { Xmemcpy(tls, (*Tcookie3)(unsafe.Pointer(c)).Fs, s, k) - *(*uintptr)(unsafe.Pointer(c)) += uintptr(k) - *(*Tsize_t)(unsafe.Pointer(c + 8)) -= k + **(**uintptr)(__ccgo_up(c)) += uintptr(k) + **(**Tsize_t)(__ccgo_up(c + 8)) -= k } - *(*int8)(unsafe.Pointer((*Tcookie3)(unsafe.Pointer(c)).Fs)) = 0 + **(**int8)(__ccgo_up((*Tcookie3)(unsafe.Pointer(c)).Fs)) = 0 v3 = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Fwbase = v3 (*TFILE)(unsafe.Pointer(f)).Fwpos = v3 @@ -143315,18 +143315,18 @@ func Xvsnprintf(tls *TLS, s uintptr, n Tsize_t, fmt uintptr, ap Tva_list) (r int } else { v2 = uint64(0) } - *(*Tcookie3)(unsafe.Pointer(bp + 8)) = Tcookie3{ + **(**Tcookie3)(__ccgo_up(bp + 8)) = Tcookie3{ Fs: v1, Fn: v2, } - *(*TFILE)(unsafe.Pointer(bp + 24)) = TFILE{ + **(**TFILE)(__ccgo_up(bp + 24)) = TFILE{ Fwrite: __ccgo_fp(_sn_write), Fbuf: bp, Flock: -int32(1), Flbf: -int32(1), Fcookie: bp + 8, } - *(*int8)(unsafe.Pointer((*(*Tcookie3)(unsafe.Pointer(bp + 8))).Fs)) = 0 + **(**int8)(__ccgo_up((**(**Tcookie3)(__ccgo_up(bp + 8))).Fs)) = 0 return Xvfprintf(tls, bp+24, fmt, ap) } @@ -143375,7 +143375,7 @@ func Xvsscanf(tls *TLS, s uintptr, fmt uintptr, ap Tva_list) (r int32) { bp := tls.Alloc(240) defer tls.Free(240) var _ /* f at bp+0 */ TFILE - *(*TFILE)(unsafe.Pointer(bp)) = TFILE{ + **(**TFILE)(__ccgo_up(bp)) = TFILE{ Fread: __ccgo_fp(_string_read), Fbuf: s, Flock: -int32(1), @@ -143425,14 +143425,14 @@ func _sw_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { (*Tcookie4)(unsafe.Pointer(c)).Fl = (*Tcookie4)(unsafe.Pointer(c)).Fl - 1 (*Tcookie4)(unsafe.Pointer(c)).Fws += 4 } - *(*Twchar_t)(unsafe.Pointer((*Tcookie4)(unsafe.Pointer(c)).Fws)) = 0 + **(**Twchar_t)(__ccgo_up((*Tcookie4)(unsafe.Pointer(c)).Fws)) = 0 if i < 0 { v4 = UintptrFromInt32(0) (*TFILE)(unsafe.Pointer(f)).Fwend = v4 v3 = v4 (*TFILE)(unsafe.Pointer(f)).Fwbase = v3 (*TFILE)(unsafe.Pointer(f)).Fwpos = v3 - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) return Uint64FromInt32(i) } (*TFILE)(unsafe.Pointer(f)).Fwend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr((*TFILE)(unsafe.Pointer(f)).Fbuf_size) @@ -143454,11 +143454,11 @@ func Xvswprintf(tls *TLS, s uintptr, n Tsize_t, fmt uintptr, ap Tva_list) (r1 in var _ /* c at bp+256 */ Tcookie4 var _ /* f at bp+272 */ TFILE _, _ = r, v1 - *(*Tcookie4)(unsafe.Pointer(bp + 256)) = Tcookie4{ + **(**Tcookie4)(__ccgo_up(bp + 256)) = Tcookie4{ Fws: s, Fl: n - uint64(1), } - *(*TFILE)(unsafe.Pointer(bp + 272)) = TFILE{ + **(**TFILE)(__ccgo_up(bp + 272)) = TFILE{ Fwrite: __ccgo_fp(_sw_write), Fbuf: bp, Fbuf_size: uint64(256), @@ -143486,8 +143486,8 @@ func _wstring_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { var v1, v2 uintptr var _ /* src at bp+0 */ uintptr _, _, _ = k, v1, v2 - *(*uintptr)(unsafe.Pointer(bp)) = (*TFILE)(unsafe.Pointer(f)).Fcookie - if !(*(*uintptr)(unsafe.Pointer(bp)) != 0) { + **(**uintptr)(__ccgo_up(bp)) = (*TFILE)(unsafe.Pointer(f)).Fcookie + if !(**(**uintptr)(__ccgo_up(bp)) != 0) { return uint64(0) } k = Xwcsrtombs(tls, (*TFILE)(unsafe.Pointer(f)).Fbuf, bp, (*TFILE)(unsafe.Pointer(f)).Fbuf_size, uintptr(0)) @@ -143499,14 +143499,14 @@ func _wstring_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { } (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(k) - (*TFILE)(unsafe.Pointer(f)).Fcookie = *(*uintptr)(unsafe.Pointer(bp)) + (*TFILE)(unsafe.Pointer(f)).Fcookie = **(**uintptr)(__ccgo_up(bp)) if !(len1 != 0) || !(k != 0) { return uint64(0) } v2 = f + 8 v1 = *(*uintptr)(unsafe.Pointer(v2)) *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(v2)) + 1 - *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v1)) + **(**uint8)(__ccgo_up(buf)) = **(**uint8)(__ccgo_up(v1)) return uint64(1) } @@ -143519,7 +143519,7 @@ func Xvswscanf(tls *TLS, s uintptr, fmt uintptr, ap Tva_list) (r int32) { defer tls.Free(496) var _ /* buf at bp+0 */ [256]uint8 var _ /* f at bp+256 */ TFILE - *(*TFILE)(unsafe.Pointer(bp + 256)) = TFILE{ + **(**TFILE)(__ccgo_up(bp + 256)) = TFILE{ Fread: __ccgo_fp(_wstring_read), Fbuf: bp, Fbuf_size: uint64(256), @@ -143631,7 +143631,7 @@ func Xatoi(tls *TLS, s uintptr) (r int32) { n = 0 neg = 0 for { - v1 = int32(*(*int8)(unsafe.Pointer(s))) + v1 = int32(**(**int8)(__ccgo_up(s))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _3 _3: @@ -143640,7 +143640,7 @@ func Xatoi(tls *TLS, s uintptr) (r int32) { } s = s + 1 } - switch int32(*(*int8)(unsafe.Pointer(s))) { + switch int32(**(**int8)(__ccgo_up(s))) { case int32('-'): neg = int32(1) fallthrough @@ -143648,10 +143648,10 @@ func Xatoi(tls *TLS, s uintptr) (r int32) { s = s + 1 } /* Compute n as a negative number to avoid overflow on INT_MIN */ - for BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { + for BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(s)))-uint32('0') < uint32(10)) != 0 { v4 = s s = s + 1 - n = int32(10)*n - (int32(*(*int8)(unsafe.Pointer(v4))) - int32('0')) + n = int32(10)*n - (int32(**(**int8)(__ccgo_up(v4))) - int32('0')) } if neg != 0 { v1 = n @@ -143673,7 +143673,7 @@ func Xatol(tls *TLS, s uintptr) (r int64) { n = 0 neg = 0 for { - v1 = int32(*(*int8)(unsafe.Pointer(s))) + v1 = int32(**(**int8)(__ccgo_up(s))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _3 _3: @@ -143682,7 +143682,7 @@ func Xatol(tls *TLS, s uintptr) (r int64) { } s = s + 1 } - switch int32(*(*int8)(unsafe.Pointer(s))) { + switch int32(**(**int8)(__ccgo_up(s))) { case int32('-'): neg = int32(1) fallthrough @@ -143690,10 +143690,10 @@ func Xatol(tls *TLS, s uintptr) (r int64) { s = s + 1 } /* Compute n as a negative number to avoid overflow on LONG_MIN */ - for BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { + for BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(s)))-uint32('0') < uint32(10)) != 0 { v4 = s s = s + 1 - n = int64(10)*n - int64(int32(*(*int8)(unsafe.Pointer(v4)))-Int32FromUint8('0')) + n = int64(10)*n - int64(int32(**(**int8)(__ccgo_up(v4)))-Int32FromUint8('0')) } if neg != 0 { v5 = n @@ -143715,7 +143715,7 @@ func Xatoll(tls *TLS, s uintptr) (r int64) { n = 0 neg = 0 for { - v1 = int32(*(*int8)(unsafe.Pointer(s))) + v1 = int32(**(**int8)(__ccgo_up(s))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _3 _3: @@ -143724,7 +143724,7 @@ func Xatoll(tls *TLS, s uintptr) (r int64) { } s = s + 1 } - switch int32(*(*int8)(unsafe.Pointer(s))) { + switch int32(**(**int8)(__ccgo_up(s))) { case int32('-'): neg = int32(1) fallthrough @@ -143732,10 +143732,10 @@ func Xatoll(tls *TLS, s uintptr) (r int64) { s = s + 1 } /* Compute n as a negative number to avoid overflow on LLONG_MIN */ - for BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { + for BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(s)))-uint32('0') < uint32(10)) != 0 { v4 = s s = s + 1 - n = int64(10)*n - int64(int32(*(*int8)(unsafe.Pointer(v4)))-Int32FromUint8('0')) + n = int64(10)*n - int64(int32(**(**int8)(__ccgo_up(v4)))-Int32FromUint8('0')) } if neg != 0 { v5 = n @@ -143797,24 +143797,24 @@ func Xecvt(tls *TLS, x float64, n int32, dp uintptr, sign uintptr) (r uintptr) { n = int32(15) } Xsprintf(tls, bp, __ccgo_ts+1708, VaList(bp+40, n-int32(1), x)) - v1 = BoolInt32(int32((*(*[32]int8)(unsafe.Pointer(bp)))[0]) == Int32FromUint8('-')) - *(*int32)(unsafe.Pointer(sign)) = v1 + v1 = BoolInt32(int32((**(**[32]int8)(__ccgo_up(bp)))[0]) == Int32FromUint8('-')) + **(**int32)(__ccgo_up(sign)) = v1 i = v1 j = 0 for { - if !(int32((*(*[32]int8)(unsafe.Pointer(bp)))[i]) != int32('e')) { + if !(int32((**(**[32]int8)(__ccgo_up(bp)))[i]) != int32('e')) { break } - _buf8[j] = (*(*[32]int8)(unsafe.Pointer(bp)))[i] + _buf8[j] = (**(**[32]int8)(__ccgo_up(bp)))[i] goto _2 _2: ; v1 = i i = i + 1 - j = j + BoolInt32(int32((*(*[32]int8)(unsafe.Pointer(bp)))[v1]) != int32('.')) + j = j + BoolInt32(int32((**(**[32]int8)(__ccgo_up(bp)))[v1]) != int32('.')) } _buf8[j] = 0 - *(*int32)(unsafe.Pointer(dp)) = Xatoi(tls, bp+uintptr(i)+uintptr(1)) + int32(1) + **(**int32)(__ccgo_up(dp)) = Xatoi(tls, bp+uintptr(i)+uintptr(1)) + int32(1) return uintptr(unsafe.Pointer(&_buf8)) } @@ -143834,15 +143834,15 @@ func Xfcvt(tls *TLS, x float64, n int32, dp uintptr, sign uintptr) (r uintptr) { n = int32(1400) } Xsprintf(tls, bp, __ccgo_ts+1713, VaList(bp+1512, n, x)) - i = BoolInt32(int32((*(*[1500]int8)(unsafe.Pointer(bp)))[0]) == int32('-')) - if int32((*(*[1500]int8)(unsafe.Pointer(bp)))[i]) == int32('0') { + i = BoolInt32(int32((**(**[1500]int8)(__ccgo_up(bp)))[0]) == int32('-')) + if int32((**(**[1500]int8)(__ccgo_up(bp)))[i]) == int32('0') { lz = Int32FromUint64(Xstrspn(tls, bp+uintptr(i)+uintptr(2), __ccgo_ts+1681)) } else { lz = -Int32FromUint64(Xstrcspn(tls, bp+uintptr(i), __ccgo_ts+575)) } if n <= lz { - *(*int32)(unsafe.Pointer(sign)) = i - *(*int32)(unsafe.Pointer(dp)) = int32(1) + **(**int32)(__ccgo_up(sign)) = i + **(**int32)(__ccgo_up(dp)) = int32(1) if Uint32FromInt32(n) > uint32(14) { n = int32(14) } @@ -143946,9 +143946,9 @@ func _pntz(tls *TLS, p uintptr) (r1 int32) { var r, v1 int32 var v2 bool _, _, _ = r, v1, v2 - r = _a_ctz_l(tls, *(*Tsize_t)(unsafe.Pointer(p))-uint64(1)) + r = _a_ctz_l(tls, **(**Tsize_t)(__ccgo_up(p))-uint64(1)) if v2 = r != 0; !v2 { - v1 = Int32FromUint64(Uint64FromInt32(8)*Uint64FromInt64(8) + Uint64FromInt32(_a_ctz_l(tls, *(*Tsize_t)(unsafe.Pointer(p + 1*8))))) + v1 = Int32FromUint64(Uint64FromInt32(8)*Uint64FromInt64(8) + Uint64FromInt32(_a_ctz_l(tls, **(**Tsize_t)(__ccgo_up(p + 1*8))))) r = v1 } if v2 || Uint64FromInt32(v1) != Uint64FromInt32(8)*Uint64FromInt64(8) { @@ -143968,7 +143968,7 @@ func _cycle(tls *TLS, width Tsize_t, ar uintptr, n int32) { if n < int32(2) { return } - *(*uintptr)(unsafe.Pointer(ar + uintptr(n)*8)) = bp + **(**uintptr)(__ccgo_up(ar + uintptr(n)*8)) = bp for width != 0 { if uint64(256) < width { v1 = uint64(256) @@ -143976,14 +143976,14 @@ func _cycle(tls *TLS, width Tsize_t, ar uintptr, n int32) { v1 = width } l = v1 - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(ar + uintptr(n)*8)), *(*uintptr)(unsafe.Pointer(ar)), l) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(ar + uintptr(n)*8)), **(**uintptr)(__ccgo_up(ar)), l) i = 0 for { if !(i < n) { break } - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(ar + uintptr(i)*8)), *(*uintptr)(unsafe.Pointer(ar + uintptr(i+int32(1))*8)), l) - *(*uintptr)(unsafe.Pointer(ar + uintptr(i)*8)) += uintptr(l) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(ar + uintptr(i)*8)), **(**uintptr)(__ccgo_up(ar + uintptr(i+int32(1))*8)), l) + **(**uintptr)(__ccgo_up(ar + uintptr(i)*8)) += uintptr(l) goto _2 _2: ; @@ -143999,23 +143999,23 @@ func _cycle(tls *TLS, width Tsize_t, ar uintptr, n int32) { func _shl(tls *TLS, p uintptr, n int32) { if Uint64FromInt32(n) >= Uint64FromInt32(8)*Uint64FromInt64(8) { n = Int32FromUint64(uint64(n) - Uint64FromInt32(8)*Uint64FromInt64(8)) - *(*Tsize_t)(unsafe.Pointer(p + 1*8)) = *(*Tsize_t)(unsafe.Pointer(p)) - *(*Tsize_t)(unsafe.Pointer(p)) = uint64(0) + **(**Tsize_t)(__ccgo_up(p + 1*8)) = **(**Tsize_t)(__ccgo_up(p)) + **(**Tsize_t)(__ccgo_up(p)) = uint64(0) } - *(*Tsize_t)(unsafe.Pointer(p + 1*8)) <<= Uint64FromInt32(n) - *(*Tsize_t)(unsafe.Pointer(p + 1*8)) |= *(*Tsize_t)(unsafe.Pointer(p)) >> (Uint64FromInt64(8)*Uint64FromInt32(8) - Uint64FromInt32(n)) - *(*Tsize_t)(unsafe.Pointer(p)) <<= Uint64FromInt32(n) + **(**Tsize_t)(__ccgo_up(p + 1*8)) <<= Uint64FromInt32(n) + **(**Tsize_t)(__ccgo_up(p + 1*8)) |= **(**Tsize_t)(__ccgo_up(p)) >> (Uint64FromInt64(8)*Uint64FromInt32(8) - Uint64FromInt32(n)) + **(**Tsize_t)(__ccgo_up(p)) <<= Uint64FromInt32(n) } func _shr(tls *TLS, p uintptr, n int32) { if Uint64FromInt32(n) >= Uint64FromInt32(8)*Uint64FromInt64(8) { n = Int32FromUint64(uint64(n) - Uint64FromInt32(8)*Uint64FromInt64(8)) - *(*Tsize_t)(unsafe.Pointer(p)) = *(*Tsize_t)(unsafe.Pointer(p + 1*8)) - *(*Tsize_t)(unsafe.Pointer(p + 1*8)) = uint64(0) + **(**Tsize_t)(__ccgo_up(p)) = **(**Tsize_t)(__ccgo_up(p + 1*8)) + **(**Tsize_t)(__ccgo_up(p + 1*8)) = uint64(0) } - *(*Tsize_t)(unsafe.Pointer(p)) >>= Uint64FromInt32(n) - *(*Tsize_t)(unsafe.Pointer(p)) |= *(*Tsize_t)(unsafe.Pointer(p + 1*8)) << (Uint64FromInt64(8)*Uint64FromInt32(8) - Uint64FromInt32(n)) - *(*Tsize_t)(unsafe.Pointer(p + 1*8)) >>= Uint64FromInt32(n) + **(**Tsize_t)(__ccgo_up(p)) >>= Uint64FromInt32(n) + **(**Tsize_t)(__ccgo_up(p)) |= **(**Tsize_t)(__ccgo_up(p + 1*8)) << (Uint64FromInt64(8)*Uint64FromInt32(8) - Uint64FromInt32(n)) + **(**Tsize_t)(__ccgo_up(p + 1*8)) >>= Uint64FromInt32(n) } func _sift(tls *TLS, head uintptr, width Tsize_t, __ccgo_fp_cmp Tcmpfun, arg uintptr, pshift int32, lp uintptr) { @@ -144026,23 +144026,23 @@ func _sift(tls *TLS, head uintptr, width Tsize_t, __ccgo_fp_cmp Tcmpfun, arg uin var _ /* ar at bp+0 */ [113]uintptr _, _, _, _ = i, lf, rt, v1 i = int32(1) - (*(*[113]uintptr)(unsafe.Pointer(bp)))[0] = head + (**(**[113]uintptr)(__ccgo_up(bp)))[0] = head for pshift > int32(1) { rt = head - uintptr(width) - lf = head - uintptr(width) - uintptr(*(*Tsize_t)(unsafe.Pointer(lp + uintptr(pshift-int32(2))*8))) - if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, (*(*[113]uintptr)(unsafe.Pointer(bp)))[0], lf, arg) >= 0 && (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, (*(*[113]uintptr)(unsafe.Pointer(bp)))[0], rt, arg) >= 0 { + lf = head - uintptr(width) - uintptr(**(**Tsize_t)(__ccgo_up(lp + uintptr(pshift-int32(2))*8))) + if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, (**(**[113]uintptr)(__ccgo_up(bp)))[0], lf, arg) >= 0 && (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, (**(**[113]uintptr)(__ccgo_up(bp)))[0], rt, arg) >= 0 { break } if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, lf, rt, arg) >= 0 { v1 = i i = i + 1 - (*(*[113]uintptr)(unsafe.Pointer(bp)))[v1] = lf + (**(**[113]uintptr)(__ccgo_up(bp)))[v1] = lf head = lf pshift = pshift - int32(1) } else { v1 = i i = i + 1 - (*(*[113]uintptr)(unsafe.Pointer(bp)))[v1] = rt + (**(**[113]uintptr)(__ccgo_up(bp)))[v1] = rt head = rt pshift = pshift - int32(2) } @@ -144059,24 +144059,24 @@ func _trinkle(tls *TLS, head uintptr, width Tsize_t, __ccgo_fp_cmp Tcmpfun, arg var _ /* p at bp+0 */ [2]Tsize_t _, _, _, _, _, _ = i, lf, rt, stepson, trail, v1 i = int32(1) - (*(*[2]Tsize_t)(unsafe.Pointer(bp)))[0] = *(*Tsize_t)(unsafe.Pointer(pp)) - (*(*[2]Tsize_t)(unsafe.Pointer(bp)))[int32(1)] = *(*Tsize_t)(unsafe.Pointer(pp + 1*8)) - (*(*[113]uintptr)(unsafe.Pointer(bp + 16)))[0] = head - for (*(*[2]Tsize_t)(unsafe.Pointer(bp)))[0] != uint64(1) || (*(*[2]Tsize_t)(unsafe.Pointer(bp)))[int32(1)] != uint64(0) { - stepson = head - uintptr(*(*Tsize_t)(unsafe.Pointer(lp + uintptr(pshift)*8))) - if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, stepson, (*(*[113]uintptr)(unsafe.Pointer(bp + 16)))[0], arg) <= 0 { + (**(**[2]Tsize_t)(__ccgo_up(bp)))[0] = **(**Tsize_t)(__ccgo_up(pp)) + (**(**[2]Tsize_t)(__ccgo_up(bp)))[int32(1)] = **(**Tsize_t)(__ccgo_up(pp + 1*8)) + (**(**[113]uintptr)(__ccgo_up(bp + 16)))[0] = head + for (**(**[2]Tsize_t)(__ccgo_up(bp)))[0] != uint64(1) || (**(**[2]Tsize_t)(__ccgo_up(bp)))[int32(1)] != uint64(0) { + stepson = head - uintptr(**(**Tsize_t)(__ccgo_up(lp + uintptr(pshift)*8))) + if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, stepson, (**(**[113]uintptr)(__ccgo_up(bp + 16)))[0], arg) <= 0 { break } if !(trusty != 0) && pshift > int32(1) { rt = head - uintptr(width) - lf = head - uintptr(width) - uintptr(*(*Tsize_t)(unsafe.Pointer(lp + uintptr(pshift-int32(2))*8))) + lf = head - uintptr(width) - uintptr(**(**Tsize_t)(__ccgo_up(lp + uintptr(pshift-int32(2))*8))) if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, rt, stepson, arg) >= 0 || (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, lf, stepson, arg) >= 0 { break } } v1 = i i = i + 1 - (*(*[113]uintptr)(unsafe.Pointer(bp + 16)))[v1] = stepson + (**(**[113]uintptr)(__ccgo_up(bp + 16)))[v1] = stepson head = stepson trail = _pntz(tls, bp) _shr(tls, bp, trail) @@ -144104,7 +144104,7 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm var _ /* p at bp+768 */ [2]Tsize_t _, _, _, _, _, _, _, _ = head, high, i, pshift, size, trail, v2, v3 size = width * nel - *(*[2]Tsize_t)(unsafe.Pointer(bp + 768)) = [2]Tsize_t{ + **(**[2]Tsize_t)(__ccgo_up(bp + 768)) = [2]Tsize_t{ 0: uint64(1), } pshift = int32(1) @@ -144115,12 +144115,12 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm high = head + uintptr(size) - uintptr(width) /* Precompute Leonardo numbers, scaled by element width */ v2 = width - (*(*[96]Tsize_t)(unsafe.Pointer(bp)))[int32(1)] = v2 - (*(*[96]Tsize_t)(unsafe.Pointer(bp)))[0] = v2 + (**(**[96]Tsize_t)(__ccgo_up(bp)))[int32(1)] = v2 + (**(**[96]Tsize_t)(__ccgo_up(bp)))[0] = v2 i = Uint64FromInt32(2) for { - v3 = (*(*[96]Tsize_t)(unsafe.Pointer(bp)))[i-uint64(2)] + (*(*[96]Tsize_t)(unsafe.Pointer(bp)))[i-uint64(1)] + width - (*(*[96]Tsize_t)(unsafe.Pointer(bp)))[i] = v3 + v3 = (**(**[96]Tsize_t)(__ccgo_up(bp)))[i-uint64(2)] + (**(**[96]Tsize_t)(__ccgo_up(bp)))[i-uint64(1)] + width + (**(**[96]Tsize_t)(__ccgo_up(bp)))[i] = v3 if !(v3 < size) { break } @@ -144130,12 +144130,12 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm i = i + 1 } for head < high { - if (*(*[2]Tsize_t)(unsafe.Pointer(bp + 768)))[0]&uint64(3) == uint64(3) { + if (**(**[2]Tsize_t)(__ccgo_up(bp + 768)))[0]&uint64(3) == uint64(3) { _sift(tls, head, width, __ccgo_fp_cmp, arg, pshift, bp) _shr(tls, bp+768, int32(2)) pshift = pshift + int32(2) } else { - if (*(*[96]Tsize_t)(unsafe.Pointer(bp)))[pshift-int32(1)] >= Uint64FromInt64(int64(high)-int64(head)) { + if (**(**[96]Tsize_t)(__ccgo_up(bp)))[pshift-int32(1)] >= Uint64FromInt64(int64(high)-int64(head)) { _trinkle(tls, head, width, __ccgo_fp_cmp, arg, bp+768, pshift, 0, bp) } else { _sift(tls, head, width, __ccgo_fp_cmp, arg, pshift, bp) @@ -144148,11 +144148,11 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm pshift = int32(1) } } - *(*Tsize_t)(unsafe.Pointer(bp + 768)) |= uint64(1) + **(**Tsize_t)(__ccgo_up(bp + 768)) |= uint64(1) head = head + uintptr(width) } _trinkle(tls, head, width, __ccgo_fp_cmp, arg, bp+768, pshift, 0, bp) - for pshift != int32(1) || (*(*[2]Tsize_t)(unsafe.Pointer(bp + 768)))[0] != uint64(1) || (*(*[2]Tsize_t)(unsafe.Pointer(bp + 768)))[int32(1)] != uint64(0) { + for pshift != int32(1) || (**(**[2]Tsize_t)(__ccgo_up(bp + 768)))[0] != uint64(1) || (**(**[2]Tsize_t)(__ccgo_up(bp + 768)))[int32(1)] != uint64(0) { if pshift <= int32(1) { trail = _pntz(tls, bp+768) _shr(tls, bp+768, trail) @@ -144160,11 +144160,11 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm } else { _shl(tls, bp+768, int32(2)) pshift = pshift - int32(2) - *(*Tsize_t)(unsafe.Pointer(bp + 768)) ^= uint64(7) + **(**Tsize_t)(__ccgo_up(bp + 768)) ^= uint64(7) _shr(tls, bp+768, int32(1)) - _trinkle(tls, head-uintptr((*(*[96]Tsize_t)(unsafe.Pointer(bp)))[pshift])-uintptr(width), width, __ccgo_fp_cmp, arg, bp+768, pshift+int32(1), int32(1), bp) + _trinkle(tls, head-uintptr((**(**[96]Tsize_t)(__ccgo_up(bp)))[pshift])-uintptr(width), width, __ccgo_fp_cmp, arg, bp+768, pshift+int32(1), int32(1), bp) _shl(tls, bp+768, int32(1)) - *(*Tsize_t)(unsafe.Pointer(bp + 768)) |= uint64(1) + **(**Tsize_t)(__ccgo_up(bp + 768)) |= uint64(1) _trinkle(tls, head-uintptr(width), width, __ccgo_fp_cmp, arg, bp+768, pshift, int32(1), bp) } head = head - uintptr(width) @@ -144214,7 +144214,7 @@ func _strtox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { } else { v1 = s } - *(*uintptr)(unsafe.Pointer(p)) = v1 + **(**uintptr)(__ccgo_up(p)) = v1 } return y } @@ -144259,7 +144259,7 @@ func _strtox1(tls *TLS, s uintptr, p uintptr, base int32, lim uint64) (r uint64) y = X__intscan(tls, bp, Uint32FromInt32(base), int32(1), lim) if p != 0 { cnt = Uint64FromInt64((*TFILE)(unsafe.Pointer(bp)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(bp)).Frpos) - int64((*TFILE)(unsafe.Pointer(bp)).Fbuf))) - *(*uintptr)(unsafe.Pointer(p)) = s + uintptr(cnt) + **(**uintptr)(__ccgo_up(p)) = s + uintptr(cnt) } return y } @@ -144370,20 +144370,20 @@ func _do_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { var v2 int32 _, _, _, _, _ = i, wcs, v2, v3, v4 wcs = (*TFILE)(unsafe.Pointer(f)).Fcookie - if !(*(*Twchar_t)(unsafe.Pointer(wcs)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(wcs)) != 0) { wcs = __ccgo_ts + 1739 } i = uint64(0) for { - if !(i < (*TFILE)(unsafe.Pointer(f)).Fbuf_size && *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) != 0) { + if !(i < (*TFILE)(unsafe.Pointer(f)).Fbuf_size && **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) != 0) { break } - if *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) < int32(128) { - v2 = *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) + if **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) < int32(128) { + v2 = **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) } else { v2 = int32('@') } - *(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(i))) = Uint8FromInt32(v2) + **(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(i))) = Uint8FromInt32(v2) goto _1 _1: ; @@ -144396,7 +144396,7 @@ func _do_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(buf)) = **(**uint8)(__ccgo_up(v3)) return uint64(1) } return uint64(0) @@ -144412,20 +144412,20 @@ func _wcstox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { var _ /* f at bp+64 */ TFILE _, _, _, _, _ = cnt, t, y, v1, v2 t = s - *(*TFILE)(unsafe.Pointer(bp + 64)) = TFILE{} - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fflags = uint32(0) + **(**TFILE)(__ccgo_up(bp + 64)) = TFILE{} + (**(**TFILE)(__ccgo_up(bp + 64))).Fflags = uint32(0) v2 = bp + UintptrFromInt32(4) - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fbuf = v2 + (**(**TFILE)(__ccgo_up(bp + 64))).Fbuf = v2 v1 = v2 - (*(*TFILE)(unsafe.Pointer(bp + 64))).Frend = v1 - (*(*TFILE)(unsafe.Pointer(bp + 64))).Frpos = v1 - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fbuf_size = Uint64FromInt64(64) - Uint64FromInt32(4) + (**(**TFILE)(__ccgo_up(bp + 64))).Frend = v1 + (**(**TFILE)(__ccgo_up(bp + 64))).Frpos = v1 + (**(**TFILE)(__ccgo_up(bp + 64))).Fbuf_size = Uint64FromInt64(64) - Uint64FromInt32(4) AtomicStorePInt32(bp+64+140, -int32(1)) - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fread = __ccgo_fp(_do_read) - for Xiswspace(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(t)))) != 0 { + (**(**TFILE)(__ccgo_up(bp + 64))).Fread = __ccgo_fp(_do_read) + for Xiswspace(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(t)))) != 0 { t += 4 } - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fcookie = t + (**(**TFILE)(__ccgo_up(bp + 64))).Fcookie = t X__shlim(tls, bp+64, int64(Int32FromInt32(0))) y = X__floatscan(tls, bp+64, prec, int32(1)) if p != 0 { @@ -144435,7 +144435,7 @@ func _wcstox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { } else { v1 = s } - *(*uintptr)(unsafe.Pointer(p)) = v1 + **(**uintptr)(__ccgo_up(p)) = v1 } return y } @@ -144474,20 +144474,20 @@ func _do_read1(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { var v2 int32 _, _, _, _, _ = i, wcs, v2, v3, v4 wcs = (*TFILE)(unsafe.Pointer(f)).Fcookie - if !(*(*Twchar_t)(unsafe.Pointer(wcs)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(wcs)) != 0) { wcs = __ccgo_ts + 1739 } i = uint64(0) for { - if !(i < (*TFILE)(unsafe.Pointer(f)).Fbuf_size && *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) != 0) { + if !(i < (*TFILE)(unsafe.Pointer(f)).Fbuf_size && **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) != 0) { break } - if *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) < int32(128) { - v2 = *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) + if **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) < int32(128) { + v2 = **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) } else { v2 = int32('@') } - *(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(i))) = Uint8FromInt32(v2) + **(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(i))) = Uint8FromInt32(v2) goto _1 _1: ; @@ -144500,7 +144500,7 @@ func _do_read1(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(buf)) = **(**uint8)(__ccgo_up(v3)) return uint64(1) } return uint64(0) @@ -144516,20 +144516,20 @@ func _wcstox1(tls *TLS, s uintptr, p uintptr, base int32, lim uint64) (r uint64) var _ /* f at bp+64 */ TFILE _, _, _, _, _ = cnt, t, y, v1, v2 t = s - *(*TFILE)(unsafe.Pointer(bp + 64)) = TFILE{} - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fflags = uint32(0) + **(**TFILE)(__ccgo_up(bp + 64)) = TFILE{} + (**(**TFILE)(__ccgo_up(bp + 64))).Fflags = uint32(0) v2 = bp + UintptrFromInt32(4) - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fbuf = v2 + (**(**TFILE)(__ccgo_up(bp + 64))).Fbuf = v2 v1 = v2 - (*(*TFILE)(unsafe.Pointer(bp + 64))).Frend = v1 - (*(*TFILE)(unsafe.Pointer(bp + 64))).Frpos = v1 - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fbuf_size = Uint64FromInt64(64) - Uint64FromInt32(4) + (**(**TFILE)(__ccgo_up(bp + 64))).Frend = v1 + (**(**TFILE)(__ccgo_up(bp + 64))).Frpos = v1 + (**(**TFILE)(__ccgo_up(bp + 64))).Fbuf_size = Uint64FromInt64(64) - Uint64FromInt32(4) AtomicStorePInt32(bp+64+140, -int32(1)) - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fread = __ccgo_fp(_do_read1) - for Xiswspace(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(t)))) != 0 { + (**(**TFILE)(__ccgo_up(bp + 64))).Fread = __ccgo_fp(_do_read1) + for Xiswspace(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(t)))) != 0 { t += 4 } - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fcookie = t + (**(**TFILE)(__ccgo_up(bp + 64))).Fcookie = t X__shlim(tls, bp+64, int64(Int32FromInt32(0))) y = X__intscan(tls, bp+64, Uint32FromInt32(base), int32(1), lim) if p != 0 { @@ -144539,7 +144539,7 @@ func _wcstox1(tls *TLS, s uintptr, p uintptr, base int32, lim uint64) (r uint64) } else { v1 = s } - *(*uintptr)(unsafe.Pointer(p)) = v1 + **(**uintptr)(__ccgo_up(p)) = v1 } return y } @@ -144658,8 +144658,8 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt if uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) == uint64(d)&(Uint64FromInt64(8)-Uint64FromInt32(1)) { for { if v3 = uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) != 0 && n != 0; v3 { - v2 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v2 + v2 = **(**uint8)(__ccgo_up(s)) + **(**uint8)(__ccgo_up(d)) = v2 } if !(v3 && Int32FromUint8(v2) != c) { break @@ -144678,10 +144678,10 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt wd = d ws = s for { - if !(n >= uint64(8) && !((*(*uint64)(unsafe.Pointer(ws))^k-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^(*(*uint64)(unsafe.Pointer(ws))^k) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { + if !(n >= uint64(8) && !((**(**uint64)(__ccgo_up(ws))^k-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^(**(**uint64)(__ccgo_up(ws))^k) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { break } - *(*uint64)(unsafe.Pointer(wd)) = *(*uint64)(unsafe.Pointer(ws)) + **(**uint64)(__ccgo_up(wd)) = **(**uint64)(__ccgo_up(ws)) goto _4 _4: ; @@ -144694,8 +144694,8 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt } for { if v3 = n != 0; v3 { - v2 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v2 + v2 = **(**uint8)(__ccgo_up(s)) + **(**uint8)(__ccgo_up(d)) = v2 } if !(v3 && Int32FromUint8(v2) != c) { break @@ -144738,7 +144738,7 @@ func Xmemchr(tls *TLS, src uintptr, c int32, n Tsize_t) (r uintptr) { s = src c = Int32FromUint8(Uint8FromInt32(c)) for { - if !(uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) != 0 && n != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != c) { + if !(uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) != 0 && n != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != c) { break } goto _1 @@ -144747,11 +144747,11 @@ func Xmemchr(tls *TLS, src uintptr, c int32, n Tsize_t) (r uintptr) { s = s + 1 n = n - 1 } - if n != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != c { + if n != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != c { k = Uint64FromInt32(-Int32FromInt32(1)) / Uint64FromInt32(UCHAR_MAX) * Uint64FromInt32(c) w = s for { - if !(n >= Uint64FromInt64(8) && !((*(*uint64)(unsafe.Pointer(w))^k-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^(*(*uint64)(unsafe.Pointer(w))^k) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { + if !(n >= Uint64FromInt64(8) && !((**(**uint64)(__ccgo_up(w))^k-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^(**(**uint64)(__ccgo_up(w))^k) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { break } goto _2 @@ -144763,7 +144763,7 @@ func Xmemchr(tls *TLS, src uintptr, c int32, n Tsize_t) (r uintptr) { s = w } for { - if !(n != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != c) { + if !(n != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != c) { break } goto _3 @@ -144791,7 +144791,7 @@ func Xmemcmp(tls *TLS, vl uintptr, vr uintptr, n Tsize_t) (r1 int32) { l = vl r = vr for { - if !(n != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))) { + if !(n != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(l))) == Int32FromUint8(**(**uint8)(__ccgo_up(r)))) { break } goto _1 @@ -144802,7 +144802,7 @@ func Xmemcmp(tls *TLS, vl uintptr, vr uintptr, n Tsize_t) (r1 int32) { r = r + 1 } if n != 0 { - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(l))) - Int32FromUint8(**(**uint8)(__ccgo_up(r))) } else { v2 = 0 } @@ -144830,7 +144830,7 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) goto _1 _1: ; @@ -144841,10 +144841,10 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { if !(n >= uint64(16)) { break } - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(0))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(4))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(4))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(8))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(8))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(12))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(12))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(0))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(0))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(4))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(4))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(8))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(8))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(12))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(12))) goto _4 _4: ; @@ -144853,13 +144853,13 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { n = n - uint64(16) } if n&uint64(8) != 0 { - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(0))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(4))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(4))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(0))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(0))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(4))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(4))) d = d + uintptr(8) s = s + uintptr(8) } if n&uint64(4) != 0 { - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(0))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(0))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(0))) d = d + uintptr(4) s = s + uintptr(4) } @@ -144868,50 +144868,50 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) } if n&uint64(1) != 0 { - *(*uint8)(unsafe.Pointer(d)) = *(*uint8)(unsafe.Pointer(s)) + **(**uint8)(__ccgo_up(d)) = **(**uint8)(__ccgo_up(s)) } return dest } if n >= uint64(32) { switch uint64(d) % Uint64FromInt32(4) { case uint64(1): - w = *(*uint32)(unsafe.Pointer(s)) + w = **(**uint32)(__ccgo_up(s)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) n = n - uint64(3) for { if !(n >= uint64(17)) { break } - x = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(1))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = w>>Int32FromInt32(24) | x<>Int32FromInt32(24) | w<>Int32FromInt32(24) | x<>Int32FromInt32(24) | w<>Int32FromInt32(24) | x<>Int32FromInt32(24) | w<>Int32FromInt32(24) | x<>Int32FromInt32(24) | w<= uint64(18)) { break } - x = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(2))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = w>>Int32FromInt32(16) | x<>Int32FromInt32(16) | w<>Int32FromInt32(16) | x<>Int32FromInt32(16) | w<>Int32FromInt32(16) | x<>Int32FromInt32(16) | w<>Int32FromInt32(16) | x<>Int32FromInt32(16) | w<= uint64(19)) { break } - x = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(3))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = w>>Int32FromInt32(8) | x<>Int32FromInt32(8) | w<>Int32FromInt32(8) | x<>Int32FromInt32(8) | w<>Int32FromInt32(8) | x<>Int32FromInt32(8) | w<>Int32FromInt32(8) | x<>Int32FromInt32(8) | w< Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(ip+k)))) > Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(jp+k)))) { jp = jp + k k = uint64(1) p = jp - ip @@ -145313,7 +145313,7 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin p = v2 k = v2 for jp+k < l { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(ip+k)))) == Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(jp+k)))) { if k == p { jp = jp + p k = uint64(1) @@ -145321,7 +145321,7 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin k = k + 1 } } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) < Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(ip+k)))) < Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(jp+k)))) { jp = jp + k k = uint64(1) p = jp - ip @@ -145360,8 +145360,8 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin return uintptr(0) } /* Check last byte first; advance by shift on mismatch */ - if (*(*[4]Tsize_t)(unsafe.Pointer(bp)))[uint64(*(*uint8)(unsafe.Pointer(h + uintptr(l-uint64(1)))))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(*(*uint8)(unsafe.Pointer(h + uintptr(l-uint64(1)))))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0 { - k = l - shift[*(*uint8)(unsafe.Pointer(h + uintptr(l-uint64(1))))] + if (**(**[4]Tsize_t)(__ccgo_up(bp)))[uint64(**(**uint8)(__ccgo_up(h + uintptr(l-uint64(1)))))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(**(**uint8)(__ccgo_up(h + uintptr(l-uint64(1)))))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0 { + k = l - shift[**(**uint8)(__ccgo_up(h + uintptr(l-uint64(1))))] if k != 0 { if k < mem { k = mem @@ -145383,7 +145383,7 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin } k = v8 for { - if !(k < l && Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(h + uintptr(k))))) { + if !(k < l && Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(k)))) == Int32FromUint8(**(**uint8)(__ccgo_up(h + uintptr(k))))) { break } goto _10 @@ -145399,7 +145399,7 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin /* Compare left half */ k = ms + uint64(1) for { - if !(k > mem && Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(k-uint64(1))))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(h + uintptr(k-uint64(1)))))) { + if !(k > mem && Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(k-uint64(1))))) == Int32FromUint8(**(**uint8)(__ccgo_up(h + uintptr(k-uint64(1)))))) { break } goto _12 @@ -145436,7 +145436,7 @@ func Xmemmem(tls *TLS, h0 uintptr, k Tsize_t, n0 uintptr, l Tsize_t) (r uintptr) return uintptr(0) } /* Use faster algorithms for short needles */ - h = Xmemchr(tls, h0, Int32FromUint8(*(*uint8)(unsafe.Pointer(n))), k) + h = Xmemchr(tls, h0, Int32FromUint8(**(**uint8)(__ccgo_up(n))), k) if !(h != 0) || l == uint64(1) { return h } @@ -145488,13 +145488,13 @@ func Xmemmove(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { d = d + 1 v3 = s s = s + 1 - *(*int8)(unsafe.Pointer(v2)) = *(*int8)(unsafe.Pointer(v3)) + **(**int8)(__ccgo_up(v2)) = **(**int8)(__ccgo_up(v3)) } for { if !(n >= Uint64FromInt64(8)) { break } - *(*TWT)(unsafe.Pointer(d)) = *(*TWT)(unsafe.Pointer(s)) + **(**TWT)(__ccgo_up(d)) = **(**TWT)(__ccgo_up(s)) goto _4 _4: ; @@ -145511,7 +145511,7 @@ func Xmemmove(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { d = d + 1 v3 = s s = s + 1 - *(*int8)(unsafe.Pointer(v2)) = *(*int8)(unsafe.Pointer(v3)) + **(**int8)(__ccgo_up(v2)) = **(**int8)(__ccgo_up(v3)) goto _5 _5: ; @@ -145525,16 +145525,16 @@ func Xmemmove(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { if !(v1 != 0) { return dest } - *(*int8)(unsafe.Pointer(d + uintptr(n))) = *(*int8)(unsafe.Pointer(s + uintptr(n))) + **(**int8)(__ccgo_up(d + uintptr(n))) = **(**int8)(__ccgo_up(s + uintptr(n))) } for n >= Uint64FromInt64(8) { n = n - Uint64FromInt64(8) - *(*TWT)(unsafe.Pointer(d + uintptr(n))) = *(*TWT)(unsafe.Pointer(s + uintptr(n))) + **(**TWT)(__ccgo_up(d + uintptr(n))) = **(**TWT)(__ccgo_up(s + uintptr(n))) } } for n != 0 { n = n - 1 - *(*int8)(unsafe.Pointer(d + uintptr(n))) = *(*int8)(unsafe.Pointer(s + uintptr(n))) + **(**int8)(__ccgo_up(d + uintptr(n))) = **(**int8)(__ccgo_up(s + uintptr(n))) } } return dest @@ -145564,7 +145564,7 @@ func X__memrchr(tls *TLS, m uintptr, c int32, n Tsize_t) (r uintptr) { if !(v1 != 0) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(n)))) == c { + if Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(n)))) == c { return s + uintptr(n) } } @@ -145596,20 +145596,20 @@ func Xmemset(tls *TLS, dest uintptr, c int32, n Tsize_t) (r uintptr) { if !(n != 0) { return dest } - *(*uint8)(unsafe.Pointer(s)) = Uint8FromInt32(c) - *(*uint8)(unsafe.Pointer(s + uintptr(n-uint64(1)))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s)) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + uintptr(n-uint64(1)))) = Uint8FromInt32(c) if n <= uint64(2) { return dest } - *(*uint8)(unsafe.Pointer(s + 1)) = Uint8FromInt32(c) - *(*uint8)(unsafe.Pointer(s + 2)) = Uint8FromInt32(c) - *(*uint8)(unsafe.Pointer(s + uintptr(n-uint64(2)))) = Uint8FromInt32(c) - *(*uint8)(unsafe.Pointer(s + uintptr(n-uint64(3)))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + 1)) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + 2)) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + uintptr(n-uint64(2)))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + uintptr(n-uint64(3)))) = Uint8FromInt32(c) if n <= uint64(6) { return dest } - *(*uint8)(unsafe.Pointer(s + 3)) = Uint8FromInt32(c) - *(*uint8)(unsafe.Pointer(s + uintptr(n-uint64(4)))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + 3)) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + uintptr(n-uint64(4)))) = Uint8FromInt32(c) if n <= uint64(8) { return dest } @@ -145627,26 +145627,26 @@ func Xmemset(tls *TLS, dest uintptr, c int32, n Tsize_t) (r uintptr) { * As in the initial byte-based head/tail fill, each * conditional below ensures that the subsequent offsets * are valid (e.g. !(n<=24) implies n>=28). */ - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(0))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(4))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(0))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(4))) = c32 if n <= uint64(8) { return dest } - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(4))) = c32 - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(8))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(12))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(8))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(4))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(8))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(12))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(8))) = c32 if n <= uint64(24) { return dest } - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(12))) = c32 - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(16))) = c32 - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(20))) = c32 - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(24))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(28))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(24))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(20))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(16))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(12))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(16))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(20))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(24))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(28))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(24))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(20))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(16))) = c32 /* Align to a multiple of 8 so we can fill 64 bits at a time, * and avoid writing the same bytes twice as much as is * practical without introducing additional branching. */ @@ -145661,10 +145661,10 @@ func Xmemset(tls *TLS, dest uintptr, c int32, n Tsize_t) (r uintptr) { if !(n >= uint64(32)) { break } - *(*uint64)(unsafe.Pointer(s + UintptrFromInt32(0))) = c64 - *(*uint64)(unsafe.Pointer(s + UintptrFromInt32(8))) = c64 - *(*uint64)(unsafe.Pointer(s + UintptrFromInt32(16))) = c64 - *(*uint64)(unsafe.Pointer(s + UintptrFromInt32(24))) = c64 + **(**uint64)(__ccgo_up(s + UintptrFromInt32(0))) = c64 + **(**uint64)(__ccgo_up(s + UintptrFromInt32(8))) = c64 + **(**uint64)(__ccgo_up(s + UintptrFromInt32(16))) = c64 + **(**uint64)(__ccgo_up(s + UintptrFromInt32(24))) = c64 goto _1 _1: ; @@ -145706,8 +145706,8 @@ func X__stpcpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { if !(uint64(s)%Uint64FromInt64(8) != 0) { break } - v2 = *(*int8)(unsafe.Pointer(s)) - *(*int8)(unsafe.Pointer(d)) = v2 + v2 = **(**int8)(__ccgo_up(s)) + **(**int8)(__ccgo_up(d)) = v2 if !(v2 != 0) { return d } @@ -145720,7 +145720,7 @@ func X__stpcpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { wd = d ws = s for { - if !!((*(*uint64)(unsafe.Pointer(ws))-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^*(*uint64)(unsafe.Pointer(ws)) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0) { + if !!((**(**uint64)(__ccgo_up(ws))-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^**(**uint64)(__ccgo_up(ws)) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0) { break } goto _3 @@ -145730,14 +145730,14 @@ func X__stpcpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { wd += 8 v5 = ws ws += 8 - *(*uint64)(unsafe.Pointer(v4)) = *(*uint64)(unsafe.Pointer(v5)) + **(**uint64)(__ccgo_up(v4)) = **(**uint64)(__ccgo_up(v5)) } d = wd s = ws } for { - v2 = *(*int8)(unsafe.Pointer(s)) - *(*int8)(unsafe.Pointer(d)) = v2 + v2 = **(**int8)(__ccgo_up(s)) + **(**int8)(__ccgo_up(d)) = v2 if !(v2 != 0) { break } @@ -145790,8 +145790,8 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { if uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) == uint64(d)&(Uint64FromInt64(8)-Uint64FromInt32(1)) { for { if v3 = uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) != 0 && n != 0; v3 { - v2 = *(*int8)(unsafe.Pointer(s)) - *(*int8)(unsafe.Pointer(d)) = v2 + v2 = **(**int8)(__ccgo_up(s)) + **(**int8)(__ccgo_up(d)) = v2 } if !(v3 && v2 != 0) { break @@ -145803,16 +145803,16 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { s = s + 1 d = d + 1 } - if !(n != 0) || !(*(*int8)(unsafe.Pointer(s)) != 0) { + if !(n != 0) || !(**(**int8)(__ccgo_up(s)) != 0) { goto tail } wd = d ws = s for { - if !(n >= uint64(8) && !((*(*uint64)(unsafe.Pointer(ws))-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^*(*uint64)(unsafe.Pointer(ws)) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { + if !(n >= uint64(8) && !((**(**uint64)(__ccgo_up(ws))-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^**(**uint64)(__ccgo_up(ws)) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { break } - *(*uint64)(unsafe.Pointer(wd)) = *(*uint64)(unsafe.Pointer(ws)) + **(**uint64)(__ccgo_up(wd)) = **(**uint64)(__ccgo_up(ws)) goto _4 _4: ; @@ -145825,8 +145825,8 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { } for { if v3 = n != 0; v3 { - v2 = *(*int8)(unsafe.Pointer(s)) - *(*int8)(unsafe.Pointer(d)) = v2 + v2 = **(**int8)(__ccgo_up(s)) + **(**int8)(__ccgo_up(d)) = v2 } if !(v3 && v2 != 0) { break @@ -145872,7 +145872,7 @@ func Xstrcasecmp(tls *TLS, _l uintptr, _r uintptr) (r1 int32) { l = _l r = _r for { - if !(*(*uint8)(unsafe.Pointer(l)) != 0 && *(*uint8)(unsafe.Pointer(r)) != 0 && (Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) || Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(l)))) == Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))))) { + if !(**(**uint8)(__ccgo_up(l)) != 0 && **(**uint8)(__ccgo_up(r)) != 0 && (Int32FromUint8(**(**uint8)(__ccgo_up(l))) == Int32FromUint8(**(**uint8)(__ccgo_up(r))) || Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(l)))) == Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(r)))))) { break } goto _1 @@ -145881,7 +145881,7 @@ func Xstrcasecmp(tls *TLS, _l uintptr, _r uintptr) (r1 int32) { l = l + 1 r = r + 1 } - return Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(l)))) - Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))) + return Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(l)))) - Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(r)))) } func X__strcasecmp_l(tls *TLS, l uintptr, r uintptr, loc Tlocale_t) (r1 int32) { @@ -145909,7 +145909,7 @@ func Xstrcasestr(tls *TLS, h uintptr, n uintptr) (r uintptr) { _ = l l = _strlen(tls, n) for { - if !(*(*int8)(unsafe.Pointer(h)) != 0) { + if !(**(**int8)(__ccgo_up(h)) != 0) { break } if !(Xstrncasecmp(tls, h, n, l) != 0) { @@ -145940,7 +145940,7 @@ func Xstrchr(tls *TLS, s uintptr, c int32) (r1 uintptr) { var r, v1 uintptr _, _ = r, v1 r = X__strchrnul(tls, s, c) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) == Int32FromUint8(Uint8FromInt32(c)) { + if Int32FromUint8(**(**uint8)(__ccgo_up(r))) == Int32FromUint8(Uint8FromInt32(c)) { v1 = r } else { v1 = uintptr(0) @@ -145975,7 +145975,7 @@ func X__strchrnul(tls *TLS, s uintptr, c int32) (r uintptr) { if !(uint64(s)%Uint64FromInt64(8) != 0) { break } - if !(*(*int8)(unsafe.Pointer(s)) != 0) || Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == c { + if !(**(**int8)(__ccgo_up(s)) != 0) || Int32FromUint8(**(**uint8)(__ccgo_up(s))) == c { return s } goto _1 @@ -145986,7 +145986,7 @@ func X__strchrnul(tls *TLS, s uintptr, c int32) (r uintptr) { k = Uint64FromInt32(-Int32FromInt32(1)) / Uint64FromInt32(UCHAR_MAX) * Uint64FromInt32(c) w = s for { - if !(!((*(*uint64)(unsafe.Pointer(w))-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^*(*uint64)(unsafe.Pointer(w)) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0) && !((*(*uint64)(unsafe.Pointer(w))^k-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^(*(*uint64)(unsafe.Pointer(w))^k) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { + if !(!((**(**uint64)(__ccgo_up(w))-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^**(**uint64)(__ccgo_up(w)) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0) && !((**(**uint64)(__ccgo_up(w))^k-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^(**(**uint64)(__ccgo_up(w))^k) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { break } goto _2 @@ -145996,7 +145996,7 @@ func X__strchrnul(tls *TLS, s uintptr, c int32) (r uintptr) { } s = w for { - if !(*(*int8)(unsafe.Pointer(s)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != c) { + if !(**(**int8)(__ccgo_up(s)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != c) { break } goto _3 @@ -146030,7 +146030,7 @@ func Xstrcmp(tls *TLS, l uintptr, r uintptr) (r1 int32) { defer func() { trc("-> %v", r1) }() } for { - if !(int32(*(*int8)(unsafe.Pointer(l))) == int32(*(*int8)(unsafe.Pointer(r))) && *(*int8)(unsafe.Pointer(l)) != 0) { + if !(int32(**(**int8)(__ccgo_up(l))) == int32(**(**int8)(__ccgo_up(r))) && **(**int8)(__ccgo_up(l)) != 0) { break } goto _1 @@ -146039,7 +146039,7 @@ func Xstrcmp(tls *TLS, l uintptr, r uintptr) (r1 int32) { l = l + 1 r = r + 1 } - return Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) + return Int32FromUint8(**(**uint8)(__ccgo_up(l))) - Int32FromUint8(**(**uint8)(__ccgo_up(r))) } func Xstrcpy(tls *TLS, dest uintptr, src uintptr) (r uintptr) { @@ -146063,14 +146063,14 @@ func Xstrcspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { var _ /* byteset at bp+0 */ [4]Tsize_t _, _, _ = a, v2, v3 a = s - if !(*(*int8)(unsafe.Pointer(c)) != 0) || !(*(*int8)(unsafe.Pointer(c + 1)) != 0) { - return Uint64FromInt64(int64(X__strchrnul(tls, s, int32(*(*int8)(unsafe.Pointer(c))))) - int64(a)) + if !(**(**int8)(__ccgo_up(c)) != 0) || !(**(**int8)(__ccgo_up(c + 1)) != 0) { + return Uint64FromInt64(int64(X__strchrnul(tls, s, int32(**(**int8)(__ccgo_up(c))))) - int64(a)) } Xmemset(tls, bp, 0, uint64(32)) for { - if v3 = *(*int8)(unsafe.Pointer(c)) != 0; v3 { - v2 = bp + uintptr(uint64(*(*uint8)(unsafe.Pointer(c)))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 - *(*Tsize_t)(unsafe.Pointer(v2)) |= Uint64FromInt32(1) << (uint64(*(*uint8)(unsafe.Pointer(c))) % (Uint64FromInt32(8) * Uint64FromInt64(8))) + if v3 = **(**int8)(__ccgo_up(c)) != 0; v3 { + v2 = bp + uintptr(uint64(**(**uint8)(__ccgo_up(c)))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 + *(*Tsize_t)(unsafe.Pointer(v2)) |= Uint64FromInt32(1) << (uint64(**(**uint8)(__ccgo_up(c))) % (Uint64FromInt32(8) * Uint64FromInt64(8))) } if !(v3 && *(*Tsize_t)(unsafe.Pointer(v2)) != 0) { break @@ -146081,7 +146081,7 @@ func Xstrcspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { c = c + 1 } for { - if !(*(*int8)(unsafe.Pointer(s)) != 0 && !((*(*[4]Tsize_t)(unsafe.Pointer(bp)))[uint64(*(*uint8)(unsafe.Pointer(s)))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(*(*uint8)(unsafe.Pointer(s)))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0)) { + if !(**(**int8)(__ccgo_up(s)) != 0 && !((**(**[4]Tsize_t)(__ccgo_up(bp)))[uint64(**(**uint8)(__ccgo_up(s)))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(**(**uint8)(__ccgo_up(s)))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0)) { break } goto _4 @@ -146121,7 +146121,7 @@ func Xstrerror_r(tls *TLS, err int32, buf uintptr, buflen Tsize_t) (r int32) { if l >= buflen { if buflen != 0 { Xmemcpy(tls, buf, msg, buflen-uint64(1)) - *(*int8)(unsafe.Pointer(buf + uintptr(buflen-uint64(1)))) = 0 + **(**int8)(__ccgo_up(buf + uintptr(buflen-uint64(1)))) = 0 } return int32(ERANGE) } @@ -146181,8 +146181,8 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { if uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) == uint64(d)&(Uint64FromInt64(8)-Uint64FromInt32(1)) { for { if v4 = uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) != 0 && n != 0; v4 { - v3 = *(*int8)(unsafe.Pointer(s)) - *(*int8)(unsafe.Pointer(d)) = v3 + v3 = **(**int8)(__ccgo_up(s)) + **(**int8)(__ccgo_up(d)) = v3 } if !(v4 && v3 != 0) { break @@ -146194,14 +146194,14 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { s = s + 1 d = d + 1 } - if n != 0 && *(*int8)(unsafe.Pointer(s)) != 0 { + if n != 0 && **(**int8)(__ccgo_up(s)) != 0 { wd = d ws = s for { - if !(n >= uint64(8) && !((*(*uint64)(unsafe.Pointer(ws))-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^*(*uint64)(unsafe.Pointer(ws)) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { + if !(n >= uint64(8) && !((**(**uint64)(__ccgo_up(ws))-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^**(**uint64)(__ccgo_up(ws)) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { break } - *(*Tsize_t)(unsafe.Pointer(wd)) = *(*uint64)(unsafe.Pointer(ws)) + **(**Tsize_t)(__ccgo_up(wd)) = **(**uint64)(__ccgo_up(ws)) goto _5 _5: ; @@ -146215,8 +146215,8 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { } for { if v4 = n != 0; v4 { - v3 = *(*int8)(unsafe.Pointer(s)) - *(*int8)(unsafe.Pointer(d)) = v3 + v3 = **(**int8)(__ccgo_up(s)) + **(**int8)(__ccgo_up(d)) = v3 } if !(v4 && v3 != 0) { break @@ -146228,7 +146228,7 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { s = s + 1 d = d + 1 } - *(*int8)(unsafe.Pointer(d)) = 0 + **(**int8)(__ccgo_up(d)) = 0 goto finish finish: ; @@ -146254,7 +146254,7 @@ func Xstrncasecmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { return 0 } for { - if !(*(*uint8)(unsafe.Pointer(l)) != 0 && *(*uint8)(unsafe.Pointer(r)) != 0 && n != 0 && (Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) || Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(l)))) == Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))))) { + if !(**(**uint8)(__ccgo_up(l)) != 0 && **(**uint8)(__ccgo_up(r)) != 0 && n != 0 && (Int32FromUint8(**(**uint8)(__ccgo_up(l))) == Int32FromUint8(**(**uint8)(__ccgo_up(r))) || Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(l)))) == Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(r)))))) { break } goto _2 @@ -146264,7 +146264,7 @@ func Xstrncasecmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { r = r + 1 n = n - 1 } - return Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(l)))) - Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))) + return Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(l)))) - Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(r)))) } func X__strncasecmp_l(tls *TLS, l uintptr, r uintptr, n Tsize_t, loc Tlocale_t) (r1 int32) { @@ -146292,17 +146292,17 @@ func Xstrncat(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { _, _, _ = a, v1, v2 a = d d = d + uintptr(_strlen(tls, d)) - for n != 0 && *(*int8)(unsafe.Pointer(s)) != 0 { + for n != 0 && **(**int8)(__ccgo_up(s)) != 0 { n = n - 1 v1 = d d = d + 1 v2 = s s = s + 1 - *(*int8)(unsafe.Pointer(v1)) = *(*int8)(unsafe.Pointer(v2)) + **(**int8)(__ccgo_up(v1)) = **(**int8)(__ccgo_up(v2)) } v1 = d d = d + 1 - *(*int8)(unsafe.Pointer(v1)) = 0 + **(**int8)(__ccgo_up(v1)) = 0 return a } @@ -146322,7 +146322,7 @@ func Xstrncmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { return 0 } for { - if !(*(*uint8)(unsafe.Pointer(l)) != 0 && *(*uint8)(unsafe.Pointer(r)) != 0 && n != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))) { + if !(**(**uint8)(__ccgo_up(l)) != 0 && **(**uint8)(__ccgo_up(r)) != 0 && n != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(l))) == Int32FromUint8(**(**uint8)(__ccgo_up(r)))) { break } goto _2 @@ -146332,7 +146332,7 @@ func Xstrncmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { r = r + 1 n = n - 1 } - return Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) + return Int32FromUint8(**(**uint8)(__ccgo_up(l))) - Int32FromUint8(**(**uint8)(__ccgo_up(r))) } func Xstrncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { @@ -146358,7 +146358,7 @@ func Xstrndup(tls *TLS, s uintptr, n Tsize_t) (r uintptr) { return UintptrFromInt32(0) } Xmemcpy(tls, d, s, l) - *(*int8)(unsafe.Pointer(d + uintptr(l))) = 0 + **(**int8)(__ccgo_up(d + uintptr(l))) = 0 return d } @@ -146387,7 +146387,7 @@ func Xstrpbrk(tls *TLS, s uintptr, b uintptr) (r uintptr) { var v1 uintptr _ = v1 s = s + uintptr(Xstrcspn(tls, s, b)) - if *(*int8)(unsafe.Pointer(s)) != 0 { + if **(**int8)(__ccgo_up(s)) != 0 { v1 = s } else { v1 = uintptr(0) @@ -146410,19 +146410,19 @@ func Xstrsep(tls *TLS, str uintptr, sep uintptr) (r uintptr) { } var end, s, v1 uintptr _, _, _ = end, s, v1 - s = *(*uintptr)(unsafe.Pointer(str)) + s = **(**uintptr)(__ccgo_up(str)) if !(s != 0) { return UintptrFromInt32(0) } end = s + uintptr(Xstrcspn(tls, s, sep)) - if *(*int8)(unsafe.Pointer(end)) != 0 { + if **(**int8)(__ccgo_up(end)) != 0 { v1 = end end = end + 1 - *(*int8)(unsafe.Pointer(v1)) = 0 + **(**int8)(__ccgo_up(v1)) = 0 } else { end = uintptr(0) } - *(*uintptr)(unsafe.Pointer(str)) = end + **(**uintptr)(__ccgo_up(str)) = end return s } @@ -146448,7 +146448,7 @@ func Xstrsignal(tls *TLS, signum int32) (r uintptr) { break } for { - if !(*(*int8)(unsafe.Pointer(s)) != 0) { + if !(**(**int8)(__ccgo_up(s)) != 0) { break } goto _3 @@ -146476,13 +146476,13 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { var _ /* byteset at bp+0 */ [4]Tsize_t _, _, _ = a, v3, v4 a = s - *(*[4]Tsize_t)(unsafe.Pointer(bp)) = [4]Tsize_t{} - if !(*(*int8)(unsafe.Pointer(c)) != 0) { + **(**[4]Tsize_t)(__ccgo_up(bp)) = [4]Tsize_t{} + if !(**(**int8)(__ccgo_up(c)) != 0) { return uint64(0) } - if !(*(*int8)(unsafe.Pointer(c + 1)) != 0) { + if !(**(**int8)(__ccgo_up(c + 1)) != 0) { for { - if !(int32(*(*int8)(unsafe.Pointer(s))) == int32(*(*int8)(unsafe.Pointer(c)))) { + if !(int32(**(**int8)(__ccgo_up(s))) == int32(**(**int8)(__ccgo_up(c)))) { break } goto _1 @@ -146493,9 +146493,9 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { return Uint64FromInt64(int64(s) - int64(a)) } for { - if v4 = *(*int8)(unsafe.Pointer(c)) != 0; v4 { - v3 = bp + uintptr(uint64(*(*uint8)(unsafe.Pointer(c)))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 - *(*Tsize_t)(unsafe.Pointer(v3)) |= Uint64FromInt32(1) << (uint64(*(*uint8)(unsafe.Pointer(c))) % (Uint64FromInt32(8) * Uint64FromInt64(8))) + if v4 = **(**int8)(__ccgo_up(c)) != 0; v4 { + v3 = bp + uintptr(uint64(**(**uint8)(__ccgo_up(c)))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 + *(*Tsize_t)(unsafe.Pointer(v3)) |= Uint64FromInt32(1) << (uint64(**(**uint8)(__ccgo_up(c))) % (Uint64FromInt32(8) * Uint64FromInt64(8))) } if !(v4 && *(*Tsize_t)(unsafe.Pointer(v3)) != 0) { break @@ -146506,7 +146506,7 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { c = c + 1 } for { - if !(*(*int8)(unsafe.Pointer(s)) != 0 && (*(*[4]Tsize_t)(unsafe.Pointer(bp)))[uint64(*(*uint8)(unsafe.Pointer(s)))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(*(*uint8)(unsafe.Pointer(s)))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0) { + if !(**(**int8)(__ccgo_up(s)) != 0 && (**(**[4]Tsize_t)(__ccgo_up(bp)))[uint64(**(**uint8)(__ccgo_up(s)))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(**(**uint8)(__ccgo_up(s)))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0) { break } goto _5 @@ -146521,11 +146521,11 @@ func _twobyte_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { var hw, nw Tuint16_t var v2 uintptr _, _, _ = hw, nw, v2 - nw = Uint16FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(n)))< Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(ip+k)))) > Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(jp+k)))) { jp = jp + k k = uint64(1) p = jp - ip @@ -146659,7 +146659,7 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { p = v2 k = v2 for jp+k < l { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(ip+k)))) == Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(jp+k)))) { if k == p { jp = jp + p k = uint64(1) @@ -146667,7 +146667,7 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { k = k + 1 } } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) < Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(ip+k)))) < Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(jp+k)))) { jp = jp + k k = uint64(1) p = jp - ip @@ -146718,8 +146718,8 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { } } /* Check last byte first; advance by shift on mismatch */ - if (*(*[4]Tsize_t)(unsafe.Pointer(bp)))[uint64(*(*uint8)(unsafe.Pointer(h + uintptr(l-uint64(1)))))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(*(*uint8)(unsafe.Pointer(h + uintptr(l-uint64(1)))))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0 { - k = l - shift[*(*uint8)(unsafe.Pointer(h + uintptr(l-uint64(1))))] + if (**(**[4]Tsize_t)(__ccgo_up(bp)))[uint64(**(**uint8)(__ccgo_up(h + uintptr(l-uint64(1)))))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(**(**uint8)(__ccgo_up(h + uintptr(l-uint64(1)))))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0 { + k = l - shift[**(**uint8)(__ccgo_up(h + uintptr(l-uint64(1))))] if k != 0 { if k < mem { k = mem @@ -146741,7 +146741,7 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { } k = v8 for { - if !(*(*uint8)(unsafe.Pointer(n + uintptr(k))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(h + uintptr(k))))) { + if !(**(**uint8)(__ccgo_up(n + uintptr(k))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(k)))) == Int32FromUint8(**(**uint8)(__ccgo_up(h + uintptr(k))))) { break } goto _10 @@ -146749,7 +146749,7 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { ; k = k + 1 } - if *(*uint8)(unsafe.Pointer(n + uintptr(k))) != 0 { + if **(**uint8)(__ccgo_up(n + uintptr(k))) != 0 { h = h + uintptr(k-ms) mem = uint64(0) goto _9 @@ -146757,7 +146757,7 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { /* Compare left half */ k = ms + uint64(1) for { - if !(k > mem && Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(k-uint64(1))))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(h + uintptr(k-uint64(1)))))) { + if !(k > mem && Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(k-uint64(1))))) == Int32FromUint8(**(**uint8)(__ccgo_up(h + uintptr(k-uint64(1)))))) { break } goto _12 @@ -146782,30 +146782,30 @@ func Xstrstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { defer func() { trc("-> %v", r) }() } /* Return immediately on empty needle */ - if !(*(*int8)(unsafe.Pointer(n)) != 0) { + if !(**(**int8)(__ccgo_up(n)) != 0) { return h } /* Use faster algorithms for short needles */ - h = Xstrchr(tls, h, int32(*(*int8)(unsafe.Pointer(n)))) - if !(h != 0) || !(*(*int8)(unsafe.Pointer(n + 1)) != 0) { + h = Xstrchr(tls, h, int32(**(**int8)(__ccgo_up(n)))) + if !(h != 0) || !(**(**int8)(__ccgo_up(n + 1)) != 0) { return h } - if !(*(*int8)(unsafe.Pointer(h + 1)) != 0) { + if !(**(**int8)(__ccgo_up(h + 1)) != 0) { return uintptr(0) } - if !(*(*int8)(unsafe.Pointer(n + 2)) != 0) { + if !(**(**int8)(__ccgo_up(n + 2)) != 0) { return _twobyte_strstr(tls, h, n) } - if !(*(*int8)(unsafe.Pointer(h + 2)) != 0) { + if !(**(**int8)(__ccgo_up(h + 2)) != 0) { return uintptr(0) } - if !(*(*int8)(unsafe.Pointer(n + 3)) != 0) { + if !(**(**int8)(__ccgo_up(n + 3)) != 0) { return _threebyte_strstr(tls, h, n) } - if !(*(*int8)(unsafe.Pointer(h + 3)) != 0) { + if !(**(**int8)(__ccgo_up(h + 3)) != 0) { return uintptr(0) } - if !(*(*int8)(unsafe.Pointer(n + 4)) != 0) { + if !(**(**int8)(__ccgo_up(n + 4)) != 0) { return _fourbyte_strstr(tls, h, n) } return _twoway_strstr(tls, h, n) @@ -146827,16 +146827,16 @@ func Xstrtok(tls *TLS, s uintptr, sep uintptr) (r uintptr) { return UintptrFromInt32(0) } s = s + uintptr(Xstrspn(tls, s, sep)) - if !(*(*int8)(unsafe.Pointer(s)) != 0) { + if !(**(**int8)(__ccgo_up(s)) != 0) { v1 = UintptrFromInt32(0) _p2 = v1 return v1 } _p2 = s + uintptr(Xstrcspn(tls, s, sep)) - if *(*int8)(unsafe.Pointer(_p2)) != 0 { + if **(**int8)(__ccgo_up(_p2)) != 0 { v1 = _p2 _p2 = _p2 + 1 - *(*int8)(unsafe.Pointer(v1)) = 0 + **(**int8)(__ccgo_up(v1)) = 0 } else { _p2 = uintptr(0) } @@ -146854,26 +146854,26 @@ func Xstrtok_r(tls *TLS, s uintptr, sep uintptr, p uintptr) (r uintptr) { var v2 bool _, _, _ = v1, v2, v3 if v2 = !(s != 0); v2 { - v1 = *(*uintptr)(unsafe.Pointer(p)) + v1 = **(**uintptr)(__ccgo_up(p)) s = v1 } if v2 && !(v1 != 0) { return UintptrFromInt32(0) } s = s + uintptr(Xstrspn(tls, s, sep)) - if !(*(*int8)(unsafe.Pointer(s)) != 0) { + if !(**(**int8)(__ccgo_up(s)) != 0) { v1 = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(p)) = v1 + **(**uintptr)(__ccgo_up(p)) = v1 return v1 } - *(*uintptr)(unsafe.Pointer(p)) = s + uintptr(Xstrcspn(tls, s, sep)) - if *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)))) != 0 { + **(**uintptr)(__ccgo_up(p)) = s + uintptr(Xstrcspn(tls, s, sep)) + if **(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)))) != 0 { v3 = p v1 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - *(*int8)(unsafe.Pointer(v1)) = 0 + **(**int8)(__ccgo_up(v1)) = 0 } else { - *(*uintptr)(unsafe.Pointer(p)) = uintptr(0) + **(**uintptr)(__ccgo_up(p)) = uintptr(0) } return s } @@ -146896,10 +146896,10 @@ func Xstrverscmp(tls *TLS, l0 uintptr, r0 uintptr) (r1 int32) { i = v2 dp = v2 for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(l + uintptr(i)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(r + uintptr(i))))) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(l + uintptr(i)))) == Int32FromUint8(**(**uint8)(__ccgo_up(r + uintptr(i))))) { break } - c = Int32FromUint8(*(*uint8)(unsafe.Pointer(l + uintptr(i)))) + c = Int32FromUint8(**(**uint8)(__ccgo_up(l + uintptr(i)))) if !(c != 0) { return 0 } @@ -146916,15 +146916,15 @@ func Xstrverscmp(tls *TLS, l0 uintptr, r0 uintptr) (r1 int32) { ; i = i + 1 } - if Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(l + uintptr(dp))))-int32('1')) < uint32(9) && Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(r + uintptr(dp))))-int32('1')) < uint32(9) { + if Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(l + uintptr(dp))))-int32('1')) < uint32(9) && Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(r + uintptr(dp))))-int32('1')) < uint32(9) { /* If we're looking at non-degenerate digit sequences starting * with nonzero digits, longest digit string is greater. */ j = i for { - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(l + uintptr(j))))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(l + uintptr(j))))-uint32('0') < uint32(10)) != 0) { break } - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(r + uintptr(j))))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(r + uintptr(j))))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return int32(1) } goto _3 @@ -146932,17 +146932,17 @@ func Xstrverscmp(tls *TLS, l0 uintptr, r0 uintptr) (r1 int32) { ; j = j + 1 } - if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(r + uintptr(j))))-uint32('0') < uint32(10)) != 0 { + if BoolInt32(uint32(**(**uint8)(__ccgo_up(r + uintptr(j))))-uint32('0') < uint32(10)) != 0 { return -int32(1) } } else { - if z != 0 && dp < i && (BoolInt32(uint32(*(*uint8)(unsafe.Pointer(l + uintptr(i))))-uint32('0') < uint32(10)) != 0 || BoolInt32(uint32(*(*uint8)(unsafe.Pointer(r + uintptr(i))))-uint32('0') < uint32(10)) != 0) { + if z != 0 && dp < i && (BoolInt32(uint32(**(**uint8)(__ccgo_up(l + uintptr(i))))-uint32('0') < uint32(10)) != 0 || BoolInt32(uint32(**(**uint8)(__ccgo_up(r + uintptr(i))))-uint32('0') < uint32(10)) != 0) { /* Otherwise, if common prefix of digit sequence is * all zeros, digits order less than non-digits. */ - return Int32FromUint8(Uint8FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(l + uintptr(i))))-Int32FromUint8('0'))) - Int32FromUint8(Uint8FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(r + uintptr(i))))-Int32FromUint8('0'))) + return Int32FromUint8(Uint8FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(l + uintptr(i))))-Int32FromUint8('0'))) - Int32FromUint8(Uint8FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(r + uintptr(i))))-Int32FromUint8('0'))) } } - return Int32FromUint8(*(*uint8)(unsafe.Pointer(l + uintptr(i)))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r + uintptr(i)))) + return Int32FromUint8(**(**uint8)(__ccgo_up(l + uintptr(i)))) - Int32FromUint8(**(**uint8)(__ccgo_up(r + uintptr(i)))) } func Xswab(tls *TLS, _src uintptr, _dest uintptr, n Tssize_t) { @@ -146957,8 +146957,8 @@ func Xswab(tls *TLS, _src uintptr, _dest uintptr, n Tssize_t) { if !(n > int64(1)) { break } - *(*int8)(unsafe.Pointer(dest)) = *(*int8)(unsafe.Pointer(src + 1)) - *(*int8)(unsafe.Pointer(dest + 1)) = *(*int8)(unsafe.Pointer(src)) + **(**int8)(__ccgo_up(dest)) = **(**int8)(__ccgo_up(src + 1)) + **(**int8)(__ccgo_up(dest + 1)) = **(**int8)(__ccgo_up(src)) dest = dest + uintptr(2) src = src + uintptr(2) goto _1 @@ -147020,7 +147020,7 @@ func Xwcschr(tls *TLS, s uintptr, c Twchar_t) (r uintptr) { return s + uintptr(Xwcslen(tls, s))*4 } for { - if !(*(*Twchar_t)(unsafe.Pointer(s)) != 0 && *(*Twchar_t)(unsafe.Pointer(s)) != c) { + if !(**(**Twchar_t)(__ccgo_up(s)) != 0 && **(**Twchar_t)(__ccgo_up(s)) != c) { break } goto _1 @@ -147028,7 +147028,7 @@ func Xwcschr(tls *TLS, s uintptr, c Twchar_t) (r uintptr) { ; s += 4 } - if *(*Twchar_t)(unsafe.Pointer(s)) != 0 { + if **(**Twchar_t)(__ccgo_up(s)) != 0 { v2 = s } else { v2 = uintptr(0) @@ -147044,7 +147044,7 @@ func Xwcscmp(tls *TLS, l uintptr, r uintptr) (r1 int32) { var v2 int32 _ = v2 for { - if !(*(*Twchar_t)(unsafe.Pointer(l)) == *(*Twchar_t)(unsafe.Pointer(r)) && *(*Twchar_t)(unsafe.Pointer(l)) != 0 && *(*Twchar_t)(unsafe.Pointer(r)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(l)) == **(**Twchar_t)(__ccgo_up(r)) && **(**Twchar_t)(__ccgo_up(l)) != 0 && **(**Twchar_t)(__ccgo_up(r)) != 0) { break } goto _1 @@ -147053,10 +147053,10 @@ func Xwcscmp(tls *TLS, l uintptr, r uintptr) (r1 int32) { l += 4 r += 4 } - if *(*Twchar_t)(unsafe.Pointer(l)) < *(*Twchar_t)(unsafe.Pointer(r)) { + if **(**Twchar_t)(__ccgo_up(l)) < **(**Twchar_t)(__ccgo_up(r)) { v2 = -int32(1) } else { - v2 = BoolInt32(*(*Twchar_t)(unsafe.Pointer(l)) > *(*Twchar_t)(unsafe.Pointer(r))) + v2 = BoolInt32(**(**Twchar_t)(__ccgo_up(l)) > **(**Twchar_t)(__ccgo_up(r))) } return v2 } @@ -147073,10 +147073,10 @@ func Xwcscpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { for { v2 = s s += 4 - v1 = *(*Twchar_t)(unsafe.Pointer(v2)) + v1 = **(**Twchar_t)(__ccgo_up(v2)) v3 = d d += 4 - *(*Twchar_t)(unsafe.Pointer(v3)) = v1 + **(**Twchar_t)(__ccgo_up(v3)) = v1 if !(v1 != 0) { break } @@ -147092,13 +147092,13 @@ func Xwcscspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { var a, v2, v3 uintptr var v1 uint64 _, _, _, _ = a, v1, v2, v3 - if !(*(*Twchar_t)(unsafe.Pointer(c)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(c)) != 0) { return Xwcslen(tls, s) } - if !(*(*Twchar_t)(unsafe.Pointer(c + 1*4)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(c + 1*4)) != 0) { v3 = s a = v3 - v2 = Xwcschr(tls, v3, *(*Twchar_t)(unsafe.Pointer(c))) + v2 = Xwcschr(tls, v3, **(**Twchar_t)(__ccgo_up(c))) s = v2 if v2 != 0 { v1 = Uint64FromInt64((int64(s) - int64(a)) / 4) @@ -147109,7 +147109,7 @@ func Xwcscspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { } a = s for { - if !(*(*Twchar_t)(unsafe.Pointer(s)) != 0 && !(Xwcschr(tls, c, *(*Twchar_t)(unsafe.Pointer(s))) != 0)) { + if !(**(**Twchar_t)(__ccgo_up(s)) != 0 && !(Xwcschr(tls, c, **(**Twchar_t)(__ccgo_up(s))) != 0)) { break } goto _4 @@ -147145,7 +147145,7 @@ func Xwcslen(tls *TLS, s uintptr) (r Tsize_t) { _ = a a = s for { - if !(*(*Twchar_t)(unsafe.Pointer(s)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(s)) != 0) { break } goto _1 @@ -147169,7 +147169,7 @@ func Xwcsncasecmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { return 0 } for { - if !(*(*Twchar_t)(unsafe.Pointer(l)) != 0 && *(*Twchar_t)(unsafe.Pointer(r)) != 0 && n != 0 && (*(*Twchar_t)(unsafe.Pointer(l)) == *(*Twchar_t)(unsafe.Pointer(r)) || Xtowlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(l)))) == Xtowlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(r)))))) { + if !(**(**Twchar_t)(__ccgo_up(l)) != 0 && **(**Twchar_t)(__ccgo_up(r)) != 0 && n != 0 && (**(**Twchar_t)(__ccgo_up(l)) == **(**Twchar_t)(__ccgo_up(r)) || Xtowlower(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(l)))) == Xtowlower(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(r)))))) { break } goto _2 @@ -147179,7 +147179,7 @@ func Xwcsncasecmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { r += 4 n = n - 1 } - return Int32FromUint32(Xtowlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(l)))) - Xtowlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(r))))) + return Int32FromUint32(Xtowlower(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(l)))) - Xtowlower(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(r))))) } func Xwcsncasecmp_l(tls *TLS, l uintptr, r uintptr, n Tsize_t, locale Tlocale_t) (r1 int32) { @@ -147199,17 +147199,17 @@ func Xwcsncat(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { _, _, _ = a, v1, v2 a = d d = d + uintptr(Xwcslen(tls, d))*4 - for n != 0 && *(*Twchar_t)(unsafe.Pointer(s)) != 0 { + for n != 0 && **(**Twchar_t)(__ccgo_up(s)) != 0 { n = n - 1 v1 = d d += 4 v2 = s s += 4 - *(*Twchar_t)(unsafe.Pointer(v1)) = *(*Twchar_t)(unsafe.Pointer(v2)) + **(**Twchar_t)(__ccgo_up(v1)) = **(**Twchar_t)(__ccgo_up(v2)) } v1 = d d += 4 - *(*Twchar_t)(unsafe.Pointer(v1)) = 0 + **(**Twchar_t)(__ccgo_up(v1)) = 0 return a } @@ -147221,7 +147221,7 @@ func Xwcsncmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { var v2, v3 int32 _, _ = v2, v3 for { - if !(n != 0 && *(*Twchar_t)(unsafe.Pointer(l)) == *(*Twchar_t)(unsafe.Pointer(r)) && *(*Twchar_t)(unsafe.Pointer(l)) != 0 && *(*Twchar_t)(unsafe.Pointer(r)) != 0) { + if !(n != 0 && **(**Twchar_t)(__ccgo_up(l)) == **(**Twchar_t)(__ccgo_up(r)) && **(**Twchar_t)(__ccgo_up(l)) != 0 && **(**Twchar_t)(__ccgo_up(r)) != 0) { break } goto _1 @@ -147232,10 +147232,10 @@ func Xwcsncmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { r += 4 } if n != 0 { - if *(*Twchar_t)(unsafe.Pointer(l)) < *(*Twchar_t)(unsafe.Pointer(r)) { + if **(**Twchar_t)(__ccgo_up(l)) < **(**Twchar_t)(__ccgo_up(r)) { v3 = -int32(1) } else { - v3 = BoolInt32(*(*Twchar_t)(unsafe.Pointer(l)) > *(*Twchar_t)(unsafe.Pointer(r))) + v3 = BoolInt32(**(**Twchar_t)(__ccgo_up(l)) > **(**Twchar_t)(__ccgo_up(r))) } v2 = v3 } else { @@ -147252,13 +147252,13 @@ func Xwcsncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { var a, v1, v2 uintptr _, _, _ = a, v1, v2 a = d - for n != 0 && *(*Twchar_t)(unsafe.Pointer(s)) != 0 { + for n != 0 && **(**Twchar_t)(__ccgo_up(s)) != 0 { n = n - 1 v1 = d d += 4 v2 = s s += 4 - *(*Twchar_t)(unsafe.Pointer(v1)) = *(*Twchar_t)(unsafe.Pointer(v2)) + **(**Twchar_t)(__ccgo_up(v1)) = **(**Twchar_t)(__ccgo_up(v2)) } Xwmemset(tls, d, 0, n) return a @@ -147286,7 +147286,7 @@ func Xwcspbrk(tls *TLS, s uintptr, b uintptr) (r uintptr) { var v1 uintptr _ = v1 s = s + uintptr(Xwcscspn(tls, s, b))*4 - if *(*Twchar_t)(unsafe.Pointer(s)) != 0 { + if **(**Twchar_t)(__ccgo_up(s)) != 0 { v1 = s } else { v1 = UintptrFromInt32(0) @@ -147303,7 +147303,7 @@ func Xwcsrchr(tls *TLS, s uintptr, c Twchar_t) (r uintptr) { _, _ = p, v2 p = s + uintptr(Xwcslen(tls, s))*4 for { - if !(p >= s && *(*Twchar_t)(unsafe.Pointer(p)) != c) { + if !(p >= s && **(**Twchar_t)(__ccgo_up(p)) != c) { break } goto _1 @@ -147328,7 +147328,7 @@ func Xwcsspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { _ = a a = s for { - if !(*(*Twchar_t)(unsafe.Pointer(s)) != 0 && Xwcschr(tls, c, *(*Twchar_t)(unsafe.Pointer(s))) != 0) { + if !(**(**Twchar_t)(__ccgo_up(s)) != 0 && Xwcschr(tls, c, **(**Twchar_t)(__ccgo_up(s))) != 0) { break } goto _1 @@ -147347,7 +147347,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { /* Computing length of needle */ l = uint64(0) for { - if !(*(*Twchar_t)(unsafe.Pointer(n + uintptr(l)*4)) != 0 && *(*Twchar_t)(unsafe.Pointer(h + uintptr(l)*4)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(n + uintptr(l)*4)) != 0 && **(**Twchar_t)(__ccgo_up(h + uintptr(l)*4)) != 0) { break } goto _1 @@ -147355,7 +147355,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { ; l = l + 1 } - if *(*Twchar_t)(unsafe.Pointer(n + uintptr(l)*4)) != 0 { + if **(**Twchar_t)(__ccgo_up(n + uintptr(l)*4)) != 0 { return uintptr(0) } /* hit the end of h */ /* Compute maximal suffix */ @@ -147365,7 +147365,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { p = v2 k = v2 for jp+k < l { - if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) == *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { + if **(**Twchar_t)(__ccgo_up(n + uintptr(ip+k)*4)) == **(**Twchar_t)(__ccgo_up(n + uintptr(jp+k)*4)) { if k == p { jp = jp + p k = uint64(1) @@ -147373,7 +147373,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { k = k + 1 } } else { - if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) > *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { + if **(**Twchar_t)(__ccgo_up(n + uintptr(ip+k)*4)) > **(**Twchar_t)(__ccgo_up(n + uintptr(jp+k)*4)) { jp = jp + k k = uint64(1) p = jp - ip @@ -147396,7 +147396,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { p = v2 k = v2 for jp+k < l { - if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) == *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { + if **(**Twchar_t)(__ccgo_up(n + uintptr(ip+k)*4)) == **(**Twchar_t)(__ccgo_up(n + uintptr(jp+k)*4)) { if k == p { jp = jp + p k = uint64(1) @@ -147404,7 +147404,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { k = k + 1 } } else { - if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) < *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { + if **(**Twchar_t)(__ccgo_up(n + uintptr(ip+k)*4)) < **(**Twchar_t)(__ccgo_up(n + uintptr(jp+k)*4)) { jp = jp + k k = uint64(1) p = jp - ip @@ -147462,7 +147462,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { } k = v8 for { - if !(*(*Twchar_t)(unsafe.Pointer(n + uintptr(k)*4)) != 0 && *(*Twchar_t)(unsafe.Pointer(n + uintptr(k)*4)) == *(*Twchar_t)(unsafe.Pointer(h + uintptr(k)*4))) { + if !(**(**Twchar_t)(__ccgo_up(n + uintptr(k)*4)) != 0 && **(**Twchar_t)(__ccgo_up(n + uintptr(k)*4)) == **(**Twchar_t)(__ccgo_up(h + uintptr(k)*4))) { break } goto _10 @@ -147470,7 +147470,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { ; k = k + 1 } - if *(*Twchar_t)(unsafe.Pointer(n + uintptr(k)*4)) != 0 { + if **(**Twchar_t)(__ccgo_up(n + uintptr(k)*4)) != 0 { h = h + uintptr(k-ms)*4 mem = uint64(0) goto _9 @@ -147478,7 +147478,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { /* Compare left half */ k = ms + uint64(1) for { - if !(k > mem && *(*Twchar_t)(unsafe.Pointer(n + uintptr(k-uint64(1))*4)) == *(*Twchar_t)(unsafe.Pointer(h + uintptr(k-uint64(1))*4))) { + if !(k > mem && **(**Twchar_t)(__ccgo_up(n + uintptr(k-uint64(1))*4)) == **(**Twchar_t)(__ccgo_up(h + uintptr(k-uint64(1))*4))) { break } goto _12 @@ -147503,18 +147503,18 @@ func Xwcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { defer func() { trc("-> %v", r) }() } /* Return immediately on empty needle or haystack */ - if !(*(*Twchar_t)(unsafe.Pointer(n)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(n)) != 0) { return h } - if !(*(*Twchar_t)(unsafe.Pointer(h)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(h)) != 0) { return uintptr(0) } /* Use faster algorithms for short needles */ - h = Xwcschr(tls, h, *(*Twchar_t)(unsafe.Pointer(n))) - if !(h != 0) || !(*(*Twchar_t)(unsafe.Pointer(n + 1*4)) != 0) { + h = Xwcschr(tls, h, **(**Twchar_t)(__ccgo_up(n))) + if !(h != 0) || !(**(**Twchar_t)(__ccgo_up(n + 1*4)) != 0) { return h } - if !(*(*Twchar_t)(unsafe.Pointer(h + 1*4)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(h + 1*4)) != 0) { return uintptr(0) } return _twoway_wcsstr(tls, h, n) @@ -147529,26 +147529,26 @@ func Xwcstok(tls *TLS, s uintptr, sep uintptr, p uintptr) (r uintptr) { var v2 bool _, _, _ = v1, v2, v3 if v2 = !(s != 0); v2 { - v1 = *(*uintptr)(unsafe.Pointer(p)) + v1 = **(**uintptr)(__ccgo_up(p)) s = v1 } if v2 && !(v1 != 0) { return UintptrFromInt32(0) } s = s + uintptr(Xwcsspn(tls, s, sep))*4 - if !(*(*Twchar_t)(unsafe.Pointer(s)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(s)) != 0) { v1 = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(p)) = v1 + **(**uintptr)(__ccgo_up(p)) = v1 return v1 } - *(*uintptr)(unsafe.Pointer(p)) = s + uintptr(Xwcscspn(tls, s, sep))*4 - if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)))) != 0 { + **(**uintptr)(__ccgo_up(p)) = s + uintptr(Xwcscspn(tls, s, sep))*4 + if **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(p)))) != 0 { v3 = p v1 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) += 4 - *(*Twchar_t)(unsafe.Pointer(v1)) = 0 + **(**Twchar_t)(__ccgo_up(v1)) = 0 } else { - *(*uintptr)(unsafe.Pointer(p)) = uintptr(0) + **(**uintptr)(__ccgo_up(p)) = uintptr(0) } return s } @@ -147569,7 +147569,7 @@ func Xwmemchr(tls *TLS, s uintptr, c Twchar_t, n Tsize_t) (r uintptr) { var v2 uintptr _ = v2 for { - if !(n != 0 && *(*Twchar_t)(unsafe.Pointer(s)) != c) { + if !(n != 0 && **(**Twchar_t)(__ccgo_up(s)) != c) { break } goto _1 @@ -147594,7 +147594,7 @@ func Xwmemcmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { var v2, v3 int32 _, _ = v2, v3 for { - if !(n != 0 && *(*Twchar_t)(unsafe.Pointer(l)) == *(*Twchar_t)(unsafe.Pointer(r))) { + if !(n != 0 && **(**Twchar_t)(__ccgo_up(l)) == **(**Twchar_t)(__ccgo_up(r))) { break } goto _1 @@ -147605,10 +147605,10 @@ func Xwmemcmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { r += 4 } if n != 0 { - if *(*Twchar_t)(unsafe.Pointer(l)) < *(*Twchar_t)(unsafe.Pointer(r)) { + if **(**Twchar_t)(__ccgo_up(l)) < **(**Twchar_t)(__ccgo_up(r)) { v3 = -int32(1) } else { - v3 = BoolInt32(*(*Twchar_t)(unsafe.Pointer(l)) > *(*Twchar_t)(unsafe.Pointer(r))) + v3 = BoolInt32(**(**Twchar_t)(__ccgo_up(l)) > **(**Twchar_t)(__ccgo_up(r))) } v2 = v3 } else { @@ -147636,7 +147636,7 @@ func Xwmemcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { d += 4 v3 = s s += 4 - *(*Twchar_t)(unsafe.Pointer(v2)) = *(*Twchar_t)(unsafe.Pointer(v3)) + **(**Twchar_t)(__ccgo_up(v2)) = **(**Twchar_t)(__ccgo_up(v3)) } return a } @@ -147660,7 +147660,7 @@ func Xwmemmove(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { if !(v1 != 0) { break } - *(*Twchar_t)(unsafe.Pointer(d + uintptr(n)*4)) = *(*Twchar_t)(unsafe.Pointer(s + uintptr(n)*4)) + **(**Twchar_t)(__ccgo_up(d + uintptr(n)*4)) = **(**Twchar_t)(__ccgo_up(s + uintptr(n)*4)) } } else { for { @@ -147673,7 +147673,7 @@ func Xwmemmove(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { d += 4 v4 = s s += 4 - *(*Twchar_t)(unsafe.Pointer(v3)) = *(*Twchar_t)(unsafe.Pointer(v4)) + **(**Twchar_t)(__ccgo_up(v3)) = **(**Twchar_t)(__ccgo_up(v4)) } } return d0 @@ -147696,7 +147696,7 @@ func Xwmemset(tls *TLS, d uintptr, c Twchar_t, n Tsize_t) (r uintptr) { } v2 = d d += 4 - *(*Twchar_t)(unsafe.Pointer(v2)) = c + **(**Twchar_t)(__ccgo_up(v2)) = c } return ret } @@ -147712,7 +147712,7 @@ func Xmkdtemp(tls *TLS, template uintptr) (r uintptr) { l = _strlen(tls, template) retries = int32(100) if l < uint64(6) || Xmemcmp(tls, template+uintptr(l)-uintptr(6), __ccgo_ts+1747, uint64(6)) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } for { @@ -147725,7 +147725,7 @@ func Xmkdtemp(tls *TLS, template uintptr) (r uintptr) { ; retries = retries - 1 v1 = retries - if !(v1 != 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EEXIST)) { + if !(v1 != 0 && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EEXIST)) { break } } @@ -147753,7 +147753,7 @@ func X__mkostemps(tls *TLS, template uintptr, len1 int32, flags int32) (r int32) _, _, _, _ = fd, l, retries, v1 l = _strlen(tls, template) if l < uint64(6) || Uint64FromInt32(len1) > l-uint64(6) || Xmemcmp(tls, template+uintptr(l)-uintptr(len1)-uintptr(6), __ccgo_ts+1747, uint64(6)) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } flags = flags - flags&(Int32FromInt32(03)|Int32FromInt32(O_PATH)) @@ -147770,7 +147770,7 @@ func X__mkostemps(tls *TLS, template uintptr, len1 int32, flags int32) (r int32) ; retries = retries - 1 v1 = retries - if !(v1 != 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EEXIST)) { + if !(v1 != 0 && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EEXIST)) { break } } @@ -147816,15 +147816,15 @@ func Xmktemp(tls *TLS, template uintptr) (r uintptr) { l = _strlen(tls, template) retries = int32(100) if l < uint64(6) || Xmemcmp(tls, template+uintptr(l)-uintptr(6), __ccgo_ts+1747, uint64(6)) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) - *(*int8)(unsafe.Pointer(template)) = 0 + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) + **(**int8)(__ccgo_up(template)) = 0 return template } for { ___randname(tls, template+uintptr(l)-uintptr(6)) if Xstat(tls, template, bp) != 0 { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(ENOENT) { - *(*int8)(unsafe.Pointer(template)) = 0 + if **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(ENOENT) { + **(**int8)(__ccgo_up(template)) = 0 } return template } @@ -147837,8 +147837,8 @@ func Xmktemp(tls *TLS, template uintptr) (r uintptr) { break } } - *(*int8)(unsafe.Pointer(template)) = 0 - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EEXIST) + **(**int8)(__ccgo_up(template)) = 0 + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EEXIST) return template } @@ -147862,13 +147862,13 @@ func Xcfmakeraw(tls *TLS, t uintptr) { if __ccgo_strace { trc("tls=%v t=%v, (%v:)", tls, t, origin(2)) } - *(*Ttcflag_t)(unsafe.Pointer(t)) &= Uint32FromInt32(^(Int32FromInt32(IGNBRK) | Int32FromInt32(BRKINT) | Int32FromInt32(PARMRK) | Int32FromInt32(ISTRIP) | Int32FromInt32(INLCR) | Int32FromInt32(IGNCR) | Int32FromInt32(ICRNL) | Int32FromInt32(IXON))) - *(*Ttcflag_t)(unsafe.Pointer(t + 4)) &= Uint32FromInt32(^Int32FromInt32(OPOST)) - *(*Ttcflag_t)(unsafe.Pointer(t + 12)) &= Uint32FromInt32(^(Int32FromInt32(ECHO) | Int32FromInt32(ECHONL) | Int32FromInt32(ICANON) | Int32FromInt32(ISIG) | Int32FromInt32(IEXTEN))) - *(*Ttcflag_t)(unsafe.Pointer(t + 8)) &= Uint32FromInt32(^(Int32FromInt32(CSIZE) | Int32FromInt32(PARENB))) - *(*Ttcflag_t)(unsafe.Pointer(t + 8)) |= uint32(CS8) - *(*Tcc_t)(unsafe.Pointer(t + 17 + 6)) = uint8(1) - *(*Tcc_t)(unsafe.Pointer(t + 17 + 5)) = uint8(0) + **(**Ttcflag_t)(__ccgo_up(t)) &= Uint32FromInt32(^(Int32FromInt32(IGNBRK) | Int32FromInt32(BRKINT) | Int32FromInt32(PARMRK) | Int32FromInt32(ISTRIP) | Int32FromInt32(INLCR) | Int32FromInt32(IGNCR) | Int32FromInt32(ICRNL) | Int32FromInt32(IXON))) + **(**Ttcflag_t)(__ccgo_up(t + 4)) &= Uint32FromInt32(^Int32FromInt32(OPOST)) + **(**Ttcflag_t)(__ccgo_up(t + 12)) &= Uint32FromInt32(^(Int32FromInt32(ECHO) | Int32FromInt32(ECHONL) | Int32FromInt32(ICANON) | Int32FromInt32(ISIG) | Int32FromInt32(IEXTEN))) + **(**Ttcflag_t)(__ccgo_up(t + 8)) &= Uint32FromInt32(^(Int32FromInt32(CSIZE) | Int32FromInt32(PARENB))) + **(**Ttcflag_t)(__ccgo_up(t + 8)) |= uint32(CS8) + **(**Tcc_t)(__ccgo_up(t + 17 + 6)) = uint8(1) + **(**Tcc_t)(__ccgo_up(t + 17 + 5)) = uint8(0) } func Xcfsetospeed(tls *TLS, tio uintptr, speed Tspeed_t) (r int32) { @@ -147877,11 +147877,11 @@ func Xcfsetospeed(tls *TLS, tio uintptr, speed Tspeed_t) (r int32) { defer func() { trc("-> %v", r) }() } if speed&Uint32FromInt32(^Int32FromInt32(CBAUD)) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } - *(*Ttcflag_t)(unsafe.Pointer(tio + 8)) &= Uint32FromInt32(^Int32FromInt32(CBAUD)) - *(*Ttcflag_t)(unsafe.Pointer(tio + 8)) |= speed + **(**Ttcflag_t)(__ccgo_up(tio + 8)) &= Uint32FromInt32(^Int32FromInt32(CBAUD)) + **(**Ttcflag_t)(__ccgo_up(tio + 8)) |= speed return 0 } @@ -147960,7 +147960,7 @@ func Xtcgetsid(tls *TLS, fd int32) (r Tpid_t) { if Xioctl(tls, fd, int32(TIOCGSID), VaList(bp+16, bp)) < 0 { return -int32(1) } - return *(*int32)(unsafe.Pointer(bp)) + return **(**int32)(__ccgo_up(bp)) } func Xtcgetwinsize(tls *TLS, fd int32, wsz uintptr) (r int32) { @@ -147990,7 +147990,7 @@ func Xtcsetattr(tls *TLS, fd int32, act int32, tio uintptr) (r int32) { bp := tls.Alloc(16) defer tls.Free(16) if act < 0 || act > int32(2) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } return Xioctl(tls, fd, int32(TCSETS)+act, VaList(bp+8, tio)) @@ -148021,8 +148021,8 @@ func X__map_file(tls *TLS, pathname uintptr, size uintptr) (r uintptr) { return uintptr(0) } if !(X__fstat(tls, fd, bp) != 0) { - map1 = X__mmap(tls, uintptr(0), Uint64FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_size), int32(PROT_READ), int32(MAP_SHARED), fd, 0) - *(*Tsize_t)(unsafe.Pointer(size)) = Uint64FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_size) + map1 = X__mmap(tls, uintptr(0), Uint64FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_size), int32(PROT_READ), int32(MAP_SHARED), fd, 0) + **(**Tsize_t)(__ccgo_up(size)) = Uint64FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_size) } X__syscall1(tls, int64(SYS_close), int64(fd)) if map1 == uintptr(-Int32FromInt32(1)) { @@ -148194,7 +148194,7 @@ func X__tm_to_secs(tls *TLS, tm uintptr) (r int64) { year = year + int64(adj) } t = X__year_to_secs(tls, year, bp) - t = t + int64(X__month_to_secs(tls, month, *(*int32)(unsafe.Pointer(bp)))) + t = t + int64(X__month_to_secs(tls, month, **(**int32)(__ccgo_up(bp)))) t = t + int64(86400)*int64((*Ttm)(unsafe.Pointer(tm)).Ftm_mday-Int32FromInt32(1)) t = t + int64(3600)*int64((*Ttm)(unsafe.Pointer(tm)).Ftm_hour) t = t + int64(60)*int64((*Ttm)(unsafe.Pointer(tm)).Ftm_min) @@ -148228,14 +148228,14 @@ func _getint2(tls *TLS, p uintptr) (r int32) { _ = x x = uint32(0) for { - if !(Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)))))-int32('0')) < uint32(10)) { + if !(Uint32FromInt32(int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)))))-int32('0')) < uint32(10)) { break } - x = Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)))))-int32('0')) + uint32(10)*x + x = Uint32FromInt32(int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)))))-int32('0')) + uint32(10)*x goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 } return Int32FromUint32(x) } @@ -148244,20 +148244,20 @@ func _getoff(tls *TLS, p uintptr) (r int32) { var neg, off, v1 int32 _, _, _ = neg, off, v1 neg = 0 - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('-') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) == int32('-') { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 neg = int32(1) } else { - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('+') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) == int32('+') { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 } } off = int32(3600) * _getint2(tls, p) - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32(':') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) == int32(':') { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 off = off + int32(60)*_getint2(tls, p) - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32(':') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) == int32(':') { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 off = off + _getint2(tls, p) } } @@ -148272,61 +148272,61 @@ func _getoff(tls *TLS, p uintptr) (r int32) { func _getrule(tls *TLS, p uintptr, rule uintptr) { var r, v1 int32 _, _ = r, v1 - v1 = int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) - *(*int32)(unsafe.Pointer(rule)) = v1 + v1 = int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) + **(**int32)(__ccgo_up(rule)) = v1 r = v1 if r != int32('M') { if r == int32('J') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 } else { - *(*int32)(unsafe.Pointer(rule)) = 0 + **(**int32)(__ccgo_up(rule)) = 0 } - *(*int32)(unsafe.Pointer(rule + 1*4)) = _getint2(tls, p) + **(**int32)(__ccgo_up(rule + 1*4)) = _getint2(tls, p) } else { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 - *(*int32)(unsafe.Pointer(rule + 1*4)) = _getint2(tls, p) - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 - *(*int32)(unsafe.Pointer(rule + 2*4)) = _getint2(tls, p) - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 - *(*int32)(unsafe.Pointer(rule + 3*4)) = _getint2(tls, p) - } - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('/') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 - *(*int32)(unsafe.Pointer(rule + 4*4)) = _getoff(tls, p) + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 + **(**int32)(__ccgo_up(rule + 1*4)) = _getint2(tls, p) + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 + **(**int32)(__ccgo_up(rule + 2*4)) = _getint2(tls, p) + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 + **(**int32)(__ccgo_up(rule + 3*4)) = _getint2(tls, p) + } + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) == int32('/') { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 + **(**int32)(__ccgo_up(rule + 4*4)) = _getoff(tls, p) } else { - *(*int32)(unsafe.Pointer(rule + 4*4)) = int32(7200) + **(**int32)(__ccgo_up(rule + 4*4)) = int32(7200) } } func _getname(tls *TLS, d uintptr, p uintptr) { var i, v3 int32 _, _ = i, v3 - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('<') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) == int32('<') { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 i = 0 for { - if !(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))) != 0 && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i)))) != int32('>')) { + if !(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)) + uintptr(i))) != 0 && int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)) + uintptr(i)))) != int32('>')) { break } if i < int32(TZNAME_MAX) { - *(*int8)(unsafe.Pointer(d + uintptr(i))) = *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))) + **(**int8)(__ccgo_up(d + uintptr(i))) = **(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)) + uintptr(i))) } goto _1 _1: ; i = i + 1 } - if *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))) != 0 { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + if **(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)) + uintptr(i))) != 0 { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 } } else { i = 0 for { - if !(Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))))|int32(32)-int32('a')) < uint32(26)) { + if !(Uint32FromInt32(int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)) + uintptr(i))))|int32(32)-int32('a')) < uint32(26)) { break } if i < int32(TZNAME_MAX) { - *(*int8)(unsafe.Pointer(d + uintptr(i))) = *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))) + **(**int8)(__ccgo_up(d + uintptr(i))) = **(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)) + uintptr(i))) } goto _2 _2: @@ -148334,17 +148334,17 @@ func _getname(tls *TLS, d uintptr, p uintptr) { i = i + 1 } } - *(*uintptr)(unsafe.Pointer(p)) += uintptr(i) + **(**uintptr)(__ccgo_up(p)) += uintptr(i) if i < int32(TZNAME_MAX) { v3 = i } else { v3 = int32(TZNAME_MAX) } - *(*int8)(unsafe.Pointer(d + uintptr(v3))) = 0 + **(**int8)(__ccgo_up(d + uintptr(v3))) = 0 } func _zi_read32(tls *TLS, z uintptr) (r Tuint32_t) { - return uint32(*(*uint8)(unsafe.Pointer(z)))< Uint64FromInt32(Int32FromInt32(PATH_MAX)+Int32FromInt32(1)) { - *(*uintptr)(unsafe.Pointer(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) + **(**uintptr)(__ccgo_up(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) i = Uint64FromInt32(3) } if i >= _old_tz_size { @@ -148427,13 +148427,13 @@ func _do_tzset(tls *TLS) { _old_tz = Xmalloc(tls, _old_tz_size) } if _old_tz != 0 { - Xmemcpy(tls, _old_tz, *(*uintptr)(unsafe.Pointer(bp + 288)), i+uint64(1)) + Xmemcpy(tls, _old_tz, **(**uintptr)(__ccgo_up(bp + 288)), i+uint64(1)) } posix_form = 0 - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) != int32(':') { - *(*uintptr)(unsafe.Pointer(bp + 296)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) != int32(':') { + **(**uintptr)(__ccgo_up(bp + 296)) = **(**uintptr)(__ccgo_up(bp + 288)) _getname(tls, bp+308, bp+296) - if *(*uintptr)(unsafe.Pointer(bp + 296)) != *(*uintptr)(unsafe.Pointer(bp + 288)) && (int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 296))))) == int32('+') || int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 296))))) == int32('-') || BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 296)))))-uint32('0') < uint32(10)) != 0 || !(Xstrcmp(tls, bp+308, __ccgo_ts+1772) != 0) || !(Xstrcmp(tls, bp+308, __ccgo_ts+1776) != 0)) { + if **(**uintptr)(__ccgo_up(bp + 296)) != **(**uintptr)(__ccgo_up(bp + 288)) && (int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 296))))) == int32('+') || int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 296))))) == int32('-') || BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 296)))))-uint32('0') < uint32(10)) != 0 || !(Xstrcmp(tls, bp+308, __ccgo_ts+1772) != 0) || !(Xstrcmp(tls, bp+308, __ccgo_ts+1776) != 0)) { posix_form = int32(1) } } @@ -148441,21 +148441,21 @@ func _do_tzset(tls *TLS) { * pathame beginning with "."; in secure mode, only the * standard path will be searched. */ if !(posix_form != 0) { - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32(':') { - *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32(':') { + **(**uintptr)(__ccgo_up(bp + 288)) = **(**uintptr)(__ccgo_up(bp + 288)) + 1 } - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32('/') || int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32('.') { - if !(X__libc.Fsecure != 0) || !(Xstrcmp(tls, *(*uintptr)(unsafe.Pointer(bp + 288)), __ccgo_ts+1757) != 0) { - map1 = X__map_file(tls, *(*uintptr)(unsafe.Pointer(bp + 288)), uintptr(unsafe.Pointer(&_map_size))) + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32('/') || int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32('.') { + if !(X__libc.Fsecure != 0) || !(Xstrcmp(tls, **(**uintptr)(__ccgo_up(bp + 288)), __ccgo_ts+1757) != 0) { + map1 = X__map_file(tls, **(**uintptr)(__ccgo_up(bp + 288)), uintptr(unsafe.Pointer(&_map_size))) } } else { - l = _strlen(tls, *(*uintptr)(unsafe.Pointer(bp + 288))) - if l <= uint64(NAME_MAX) && !(Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp + 288)), int32('.')) != 0) { - Xmemcpy(tls, pathname, *(*uintptr)(unsafe.Pointer(bp + 288)), l+uint64(1)) - *(*int8)(unsafe.Pointer(pathname + uintptr(l))) = 0 + l = _strlen(tls, **(**uintptr)(__ccgo_up(bp + 288))) + if l <= uint64(NAME_MAX) && !(Xstrchr(tls, **(**uintptr)(__ccgo_up(bp + 288)), int32('.')) != 0) { + Xmemcpy(tls, pathname, **(**uintptr)(__ccgo_up(bp + 288)), l+uint64(1)) + **(**int8)(__ccgo_up(pathname + uintptr(l))) = 0 try = uintptr(unsafe.Pointer(&_search)) for { - if !(!(map1 != 0) && *(*int8)(unsafe.Pointer(try)) != 0) { + if !(!(map1 != 0) && **(**int8)(__ccgo_up(try)) != 0) { break } l = _strlen(tls, try) @@ -148469,18 +148469,18 @@ func _do_tzset(tls *TLS) { } } if !(map1 != 0) { - *(*uintptr)(unsafe.Pointer(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) + **(**uintptr)(__ccgo_up(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) } } if map1 != 0 && (_map_size < uint64(44) || Xmemcmp(tls, map1, __ccgo_ts+1780, uint64(4)) != 0) { X__munmap(tls, map1, _map_size) map1 = uintptr(0) - *(*uintptr)(unsafe.Pointer(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) + **(**uintptr)(__ccgo_up(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) } _zi = map1 if map1 != 0 { scale = int32(2) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(map1 + 4))) != int32('1') { + if Int32FromUint8(**(**uint8)(__ccgo_up(map1 + 4))) != int32('1') { *(*[6]uint8)(unsafe.Pointer(bp)) = [6]uint8{ 0: uint8(1), 1: uint8(1), @@ -148499,18 +148499,18 @@ func _do_tzset(tls *TLS) { _types = _index + uintptr(_zi_read32(tls, _trans-uintptr(12))) _abbrevs = _types + uintptr(uint32(6)*_zi_read32(tls, _trans-uintptr(8))) _abbrevs_end = _abbrevs + uintptr(_zi_read32(tls, _trans-uintptr(4))) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(_zi + uintptr(_map_size-uint64(1))))) == int32('\n') { - *(*uintptr)(unsafe.Pointer(bp + 288)) = _zi + uintptr(_map_size) - uintptr(2) + if Int32FromUint8(**(**uint8)(__ccgo_up(_zi + uintptr(_map_size-uint64(1))))) == int32('\n') { + **(**uintptr)(__ccgo_up(bp + 288)) = _zi + uintptr(_map_size) - uintptr(2) for { - if !(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) != int32('\n')) { + if !(int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) != int32('\n')) { break } goto _4 _4: ; - *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) - 1 + **(**uintptr)(__ccgo_up(bp + 288)) = **(**uintptr)(__ccgo_up(bp + 288)) - 1 } - *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 + **(**uintptr)(__ccgo_up(bp + 288)) = **(**uintptr)(__ccgo_up(bp + 288)) + 1 } else { v5 = UintptrFromInt32(0) Xtzname[int32(1)] = v5 @@ -148525,12 +148525,12 @@ func _do_tzset(tls *TLS) { if !(p1 < _abbrevs) { break } - if !(*(*uint8)(unsafe.Pointer(p1 + 4)) != 0) && !(Xtzname[0] != 0) { - Xtzname[0] = _abbrevs + uintptr(*(*uint8)(unsafe.Pointer(p1 + 5))) + if !(**(**uint8)(__ccgo_up(p1 + 4)) != 0) && !(Xtzname[0] != 0) { + Xtzname[0] = _abbrevs + uintptr(**(**uint8)(__ccgo_up(p1 + 5))) Xtimezone = Int64FromUint32(-_zi_read32(tls, p1)) } - if *(*uint8)(unsafe.Pointer(p1 + 4)) != 0 && !(Xtzname[int32(1)] != 0) { - Xtzname[int32(1)] = _abbrevs + uintptr(*(*uint8)(unsafe.Pointer(p1 + 5))) + if **(**uint8)(__ccgo_up(p1 + 4)) != 0 && !(Xtzname[int32(1)] != 0) { + Xtzname[int32(1)] = _abbrevs + uintptr(**(**uint8)(__ccgo_up(p1 + 5))) _dst_off = Int32FromUint32(-_zi_read32(tls, p1)) Xdaylight = int32(1) } @@ -148552,8 +148552,8 @@ func _do_tzset(tls *TLS) { return } } - if !(*(*uintptr)(unsafe.Pointer(bp + 288)) != 0) { - *(*uintptr)(unsafe.Pointer(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) + if !(**(**uintptr)(__ccgo_up(bp + 288)) != 0) { + **(**uintptr)(__ccgo_up(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) } _getname(tls, uintptr(unsafe.Pointer(&_std_name)), bp+288) Xtzname[0] = uintptr(unsafe.Pointer(&_std_name)) @@ -148562,7 +148562,7 @@ func _do_tzset(tls *TLS) { Xtzname[int32(1)] = uintptr(unsafe.Pointer(&_dst_name)) if _dst_name[0] != 0 { Xdaylight = int32(1) - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32('+') || int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32('-') || Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288)))))-int32('0')) < uint32(10) { + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32('+') || int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32('-') || Uint32FromInt32(int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288)))))-int32('0')) < uint32(10) { _dst_off = _getoff(tls, bp+288) } else { _dst_off = int32(Xtimezone - int64(3600)) @@ -148571,12 +148571,12 @@ func _do_tzset(tls *TLS) { Xdaylight = 0 _dst_off = int32(Xtimezone) } - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32(',') { - *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32(',') { + **(**uintptr)(__ccgo_up(bp + 288)) = **(**uintptr)(__ccgo_up(bp + 288)) + 1 _getrule(tls, bp+288, uintptr(unsafe.Pointer(&_r0))) } - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32(',') { - *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32(',') { + **(**uintptr)(__ccgo_up(bp + 288)) = **(**uintptr)(__ccgo_up(bp + 288)) + 1 _getrule(tls, bp+288, uintptr(unsafe.Pointer(&_r12))) } } @@ -148597,7 +148597,7 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { n = Uint64FromInt64((int64(_index) - int64(_trans)) >> scale) if !(n != 0) { if alt != 0 { - *(*Tsize_t)(unsafe.Pointer(alt)) = uint64(0) + **(**Tsize_t)(__ccgo_up(alt)) = uint64(0) } return uint64(0) } @@ -148611,7 +148611,7 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { x = Uint64FromInt32(Int32FromUint64(x)) } if local != 0 { - off = Int32FromUint32(_zi_read32(tls, _types+uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(m-uint64(1)))))))) + off = Int32FromUint32(_zi_read32(tls, _types+uintptr(int32(6)*Int32FromUint8(**(**uint8)(__ccgo_up(_index + uintptr(m-uint64(1)))))))) } if t-int64(off) < int64(Int64FromUint64(x)) { n = n / uint64(2) @@ -148640,7 +148640,7 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { if !(i != 0) { break } - if !(*(*uint8)(unsafe.Pointer(_types + uintptr(i-uint64(6)+uint64(4)))) != 0) { + if !(**(**uint8)(__ccgo_up(_types + uintptr(i-uint64(6)+uint64(4)))) != 0) { j = i - uint64(6) } goto _1 @@ -148655,24 +148655,24 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { * and the index-zero (after transition) type as the alt. */ if t-int64(off) < int64(Int64FromUint64(x)) { if alt != 0 { - *(*Tsize_t)(unsafe.Pointer(alt)) = uint64(*(*uint8)(unsafe.Pointer(_index))) + **(**Tsize_t)(__ccgo_up(alt)) = uint64(**(**uint8)(__ccgo_up(_index))) } return j / uint64(6) } } /* Try to find a neighboring opposite-DST-status rule. */ if alt != 0 { - if a != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(_types + uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(a-uint64(1)))))+int32(4))))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(_types + uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(a))))+int32(4))))) { - *(*Tsize_t)(unsafe.Pointer(alt)) = uint64(*(*uint8)(unsafe.Pointer(_index + uintptr(a-uint64(1))))) + if a != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(_types + uintptr(int32(6)*Int32FromUint8(**(**uint8)(__ccgo_up(_index + uintptr(a-uint64(1)))))+int32(4))))) != Int32FromUint8(**(**uint8)(__ccgo_up(_types + uintptr(int32(6)*Int32FromUint8(**(**uint8)(__ccgo_up(_index + uintptr(a))))+int32(4))))) { + **(**Tsize_t)(__ccgo_up(alt)) = uint64(**(**uint8)(__ccgo_up(_index + uintptr(a-uint64(1))))) } else { - if a+uint64(1) < n && Int32FromUint8(*(*uint8)(unsafe.Pointer(_types + uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(a+uint64(1)))))+int32(4))))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(_types + uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(a))))+int32(4))))) { - *(*Tsize_t)(unsafe.Pointer(alt)) = uint64(*(*uint8)(unsafe.Pointer(_index + uintptr(a+uint64(1))))) + if a+uint64(1) < n && Int32FromUint8(**(**uint8)(__ccgo_up(_types + uintptr(int32(6)*Int32FromUint8(**(**uint8)(__ccgo_up(_index + uintptr(a+uint64(1)))))+int32(4))))) != Int32FromUint8(**(**uint8)(__ccgo_up(_types + uintptr(int32(6)*Int32FromUint8(**(**uint8)(__ccgo_up(_index + uintptr(a))))+int32(4))))) { + **(**Tsize_t)(__ccgo_up(alt)) = uint64(**(**uint8)(__ccgo_up(_index + uintptr(a+uint64(1))))) } else { - *(*Tsize_t)(unsafe.Pointer(alt)) = uint64(*(*uint8)(unsafe.Pointer(_index + uintptr(a)))) + **(**Tsize_t)(__ccgo_up(alt)) = uint64(**(**uint8)(__ccgo_up(_index + uintptr(a)))) } } } - return uint64(*(*uint8)(unsafe.Pointer(_index + uintptr(a)))) + return uint64(**(**uint8)(__ccgo_up(_index + uintptr(a)))) } func _days_in_month1(tls *TLS, m int32, is_leap int32) (r int32) { @@ -148694,28 +148694,28 @@ func _rule_to_secs(tls *TLS, rule uintptr, year int32) (r int64) { var _ /* is_leap at bp+0 */ int32 _, _, _, _, _, _, _ = d, days, m, n, t, wday, x t = X__year_to_secs(tls, int64(year), bp) - if *(*int32)(unsafe.Pointer(rule)) != int32('M') { - x = *(*int32)(unsafe.Pointer(rule + 1*4)) - if *(*int32)(unsafe.Pointer(rule)) == int32('J') && (x < int32(60) || !(*(*int32)(unsafe.Pointer(bp)) != 0)) { + if **(**int32)(__ccgo_up(rule)) != int32('M') { + x = **(**int32)(__ccgo_up(rule + 1*4)) + if **(**int32)(__ccgo_up(rule)) == int32('J') && (x < int32(60) || !(**(**int32)(__ccgo_up(bp)) != 0)) { x = x - 1 } t = t + int64(int32(86400)*x) } else { - m = *(*int32)(unsafe.Pointer(rule + 1*4)) - n = *(*int32)(unsafe.Pointer(rule + 2*4)) - d = *(*int32)(unsafe.Pointer(rule + 3*4)) - t = t + int64(X__month_to_secs(tls, m-int32(1), *(*int32)(unsafe.Pointer(bp)))) + m = **(**int32)(__ccgo_up(rule + 1*4)) + n = **(**int32)(__ccgo_up(rule + 2*4)) + d = **(**int32)(__ccgo_up(rule + 3*4)) + t = t + int64(X__month_to_secs(tls, m-int32(1), **(**int32)(__ccgo_up(bp)))) wday = int32((t+int64(Int32FromInt32(4)*Int32FromInt32(86400)))%int64(Int32FromInt32(7)*Int32FromInt32(86400))) / int32(86400) days = d - wday if days < 0 { days = days + int32(7) } - if n == int32(5) && days+int32(28) >= _days_in_month1(tls, m, *(*int32)(unsafe.Pointer(bp))) { + if n == int32(5) && days+int32(28) >= _days_in_month1(tls, m, **(**int32)(__ccgo_up(bp))) { n = int32(4) } t = t + int64(int32(86400)*(days+int32(7)*(n-int32(1)))) } - t = t + int64(*(*int32)(unsafe.Pointer(rule + 4*4))) + t = t + int64(**(**int32)(__ccgo_up(rule + 4*4))) return t } @@ -148741,11 +148741,11 @@ func X__secs_to_zone(tls *TLS, t int64, local int32, isdst uintptr, offset uintp if _zi != 0 { i = _scan_trans(tls, t, local, bp) if i != Uint64FromInt32(-Int32FromInt32(1)) { - *(*int32)(unsafe.Pointer(isdst)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(_types + uintptr(uint64(6)*i+uint64(4))))) - *(*int64)(unsafe.Pointer(offset)) = int64(Int32FromUint32(_zi_read32(tls, _types+uintptr(uint64(6)*i)))) - *(*uintptr)(unsafe.Pointer(zonename)) = _abbrevs + uintptr(*(*uint8)(unsafe.Pointer(_types + uintptr(uint64(6)*i+uint64(5))))) + **(**int32)(__ccgo_up(isdst)) = Int32FromUint8(**(**uint8)(__ccgo_up(_types + uintptr(uint64(6)*i+uint64(4))))) + **(**int64)(__ccgo_up(offset)) = int64(Int32FromUint32(_zi_read32(tls, _types+uintptr(uint64(6)*i)))) + **(**uintptr)(__ccgo_up(zonename)) = _abbrevs + uintptr(**(**uint8)(__ccgo_up(_types + uintptr(uint64(6)*i+uint64(5))))) if oppoff != 0 { - *(*int64)(unsafe.Pointer(oppoff)) = int64(Int32FromUint32(_zi_read32(tls, _types+uintptr(uint64(6)**(*Tsize_t)(unsafe.Pointer(bp)))))) + **(**int64)(__ccgo_up(oppoff)) = int64(Int32FromUint32(_zi_read32(tls, _types+uintptr(uint64(6)***(**Tsize_t)(__ccgo_up(bp)))))) } ___unlock(tls, uintptr(unsafe.Pointer(&_lock4))) return @@ -148783,23 +148783,23 @@ func X__secs_to_zone(tls *TLS, t int64, local int32, isdst uintptr, offset uintp goto std std: ; - *(*int32)(unsafe.Pointer(isdst)) = 0 - *(*int64)(unsafe.Pointer(offset)) = -Xtimezone + **(**int32)(__ccgo_up(isdst)) = 0 + **(**int64)(__ccgo_up(offset)) = -Xtimezone if oppoff != 0 { - *(*int64)(unsafe.Pointer(oppoff)) = int64(-_dst_off) + **(**int64)(__ccgo_up(oppoff)) = int64(-_dst_off) } - *(*uintptr)(unsafe.Pointer(zonename)) = Xtzname[0] + **(**uintptr)(__ccgo_up(zonename)) = Xtzname[0] ___unlock(tls, uintptr(unsafe.Pointer(&_lock4))) return goto dst dst: ; - *(*int32)(unsafe.Pointer(isdst)) = int32(1) - *(*int64)(unsafe.Pointer(offset)) = int64(-_dst_off) + **(**int32)(__ccgo_up(isdst)) = int32(1) + **(**int64)(__ccgo_up(offset)) = int64(-_dst_off) if oppoff != 0 { - *(*int64)(unsafe.Pointer(oppoff)) = -Xtimezone + **(**int64)(__ccgo_up(oppoff)) = -Xtimezone } - *(*uintptr)(unsafe.Pointer(zonename)) = Xtzname[int32(1)] + **(**uintptr)(__ccgo_up(zonename)) = Xtzname[int32(1)] ___unlock(tls, uintptr(unsafe.Pointer(&_lock4))) } @@ -148842,11 +148842,11 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { if !((y-Int32FromInt32(68))&Int32FromInt32(3) != 0) { leaps = leaps - 1 if is_leap != 0 { - *(*int32)(unsafe.Pointer(is_leap)) = int32(1) + **(**int32)(__ccgo_up(is_leap)) = int32(1) } } else { if is_leap != 0 { - *(*int32)(unsafe.Pointer(is_leap)) = 0 + **(**int32)(__ccgo_up(is_leap)) = 0 } } return int64(int32(31536000)*(y-int32(70)) + int32(86400)*leaps) @@ -148861,7 +148861,7 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { rem = rem + int32(400) } if !(rem != 0) { - *(*int32)(unsafe.Pointer(is_leap)) = int32(1) + **(**int32)(__ccgo_up(is_leap)) = int32(1) centuries = 0 leaps1 = 0 } else { @@ -148882,15 +148882,15 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { } } if !(rem != 0) { - *(*int32)(unsafe.Pointer(is_leap)) = 0 + **(**int32)(__ccgo_up(is_leap)) = 0 leaps1 = 0 } else { leaps1 = Int32FromUint32(Uint32FromInt32(rem) / uint32(4)) rem = Int32FromUint32(uint32(rem) % Uint32FromUint32(4)) - *(*int32)(unsafe.Pointer(is_leap)) = BoolInt32(!(rem != 0)) + **(**int32)(__ccgo_up(is_leap)) = BoolInt32(!(rem != 0)) } } - leaps1 = leaps1 + (int32(97)*cycles + int32(24)*centuries - *(*int32)(unsafe.Pointer(is_leap))) + leaps1 = leaps1 + (int32(97)*cycles + int32(24)*centuries - **(**int32)(__ccgo_up(is_leap))) return (year-int64(100))*int64(31536000) + int64(leaps1)*int64(86400) + int64(946684800) + int64(86400) } @@ -148953,10 +148953,10 @@ func Xclock(tls *TLS) (r Tclock_t) { if X__clock_gettime(tls, int32(CLOCK_PROCESS_CPUTIME_ID), bp) != 0 { return int64(-int32(1)) } - if (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec > Int64FromInt64(0x7fffffffffffffff)/Int64FromInt32(1000000) || (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_nsec/int64(1000) > int64(0x7fffffffffffffff)-int64(1000000)*(*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec { + if (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec > Int64FromInt64(0x7fffffffffffffff)/Int64FromInt32(1000000) || (**(**Ttimespec)(__ccgo_up(bp))).Ftv_nsec/int64(1000) > int64(0x7fffffffffffffff)-int64(1000000)*(**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec { return int64(-int32(1)) } - return (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec*int64(1000000) + (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_nsec/int64(1000) + return (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec*int64(1000000) + (**(**Ttimespec)(__ccgo_up(bp))).Ftv_nsec/int64(1000) } func Xclock_getcpuclockid(tls *TLS, pid Tpid_t, clk uintptr) (r int32) { @@ -148978,7 +148978,7 @@ func Xclock_getcpuclockid(tls *TLS, pid Tpid_t, clk uintptr) (r int32) { if ret != 0 { return -ret } - *(*Tclockid_t)(unsafe.Pointer(clk)) = id + **(**Tclockid_t)(__ccgo_up(clk)) = id return 0 } @@ -149108,8 +149108,8 @@ func Xftime(tls *TLS, tp uintptr) (r int32) { var _ /* ts at bp+0 */ Ttimespec _ = v1 Xclock_gettime(tls, CLOCK_REALTIME, bp) - (*Ttimeb)(unsafe.Pointer(tp)).Ftime = (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec - (*Ttimeb)(unsafe.Pointer(tp)).Fmillitm = Uint16FromInt64((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_nsec / int64(1000000)) + (*Ttimeb)(unsafe.Pointer(tp)).Ftime = (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec + (*Ttimeb)(unsafe.Pointer(tp)).Fmillitm = Uint16FromInt64((**(**Ttimespec)(__ccgo_up(bp))).Ftv_nsec / int64(1000000)) v1 = Int16FromInt32(0) (*Ttimeb)(unsafe.Pointer(tp)).Fdstflag = v1 (*Ttimeb)(unsafe.Pointer(tp)).Ftimezone = v1 @@ -149137,7 +149137,7 @@ func Xgetdate(tls *TLS, s uintptr) (r uintptr) { } f = Xfopen(tls, datemsk, __ccgo_ts+381) if !(f != 0) { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENOMEM) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENOMEM) { Xgetdate_err = int32(6) } else { Xgetdate_err = int32(2) @@ -149146,7 +149146,7 @@ func Xgetdate(tls *TLS, s uintptr) (r uintptr) { } for Xfgets(tls, bp, int32(100), f) != 0 { p = Xstrptime(tls, s, bp, uintptr(unsafe.Pointer(&_tmbuf))) - if p != 0 && !(*(*int8)(unsafe.Pointer(p)) != 0) { + if p != 0 && !(**(**int8)(__ccgo_up(p)) != 0) { ret = uintptr(unsafe.Pointer(&_tmbuf)) goto out } @@ -149162,7 +149162,7 @@ out: if f != 0 { Xfclose(tls, f) } - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 100)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 100)), uintptr(0)) return ret } @@ -149180,8 +149180,8 @@ func Xgettimeofday(tls *TLS, tv uintptr, tz uintptr) (r int32) { return 0 } Xclock_gettime(tls, CLOCK_REALTIME, bp) - (*Ttimeval)(unsafe.Pointer(tv)).Ftv_sec = (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec - (*Ttimeval)(unsafe.Pointer(tv)).Ftv_usec = int64(int32((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_nsec) / int32(1000)) + (*Ttimeval)(unsafe.Pointer(tv)).Ftv_sec = (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec + (*Ttimeval)(unsafe.Pointer(tv)).Ftv_usec = int64(int32((**(**Ttimespec)(__ccgo_up(bp))).Ftv_nsec) / int32(1000)) return 0 } @@ -149200,8 +149200,8 @@ func X__gmtime_r(tls *TLS, t uintptr, tm uintptr) (r uintptr) { trc("tls=%v t=%v tm=%v, (%v:)", tls, t, tm, origin(2)) defer func() { trc("-> %v", r) }() } - if X__secs_to_tm(tls, *(*Ttime_t)(unsafe.Pointer(t)), tm) < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + if X__secs_to_tm(tls, int64(**(**Ttime_t)(__ccgo_up(t))), tm) < 0 { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return uintptr(0) } (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst = 0 @@ -149244,13 +149244,13 @@ func X__localtime_r(tls *TLS, t uintptr, tm uintptr) (r uintptr) { } /* Reject time_t values whose year would overflow int because * __secs_to_zone cannot safely handle them. */ - if *(*Ttime_t)(unsafe.Pointer(t)) < int64(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff))*Int64FromInt64(31622400) || *(*Ttime_t)(unsafe.Pointer(t)) > Int64FromInt32(INT_MAX)*Int64FromInt64(31622400) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + if int64(**(**Ttime_t)(__ccgo_up(t))) < int64(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff))*Int64FromInt64(31622400) || int64(**(**Ttime_t)(__ccgo_up(t))) > Int64FromInt32(INT_MAX)*Int64FromInt64(31622400) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return uintptr(0) } - X__secs_to_zone(tls, *(*Ttime_t)(unsafe.Pointer(t)), 0, tm+32, tm+40, uintptr(0), tm+48) - if X__secs_to_tm(tls, *(*Ttime_t)(unsafe.Pointer(t))+(*Ttm)(unsafe.Pointer(tm)).F__tm_gmtoff, tm) < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + X__secs_to_zone(tls, int64(**(**Ttime_t)(__ccgo_up(t))), 0, tm+32, tm+40, uintptr(0), tm+48) + if X__secs_to_tm(tls, int64(**(**Ttime_t)(__ccgo_up(t)))+(*Ttm)(unsafe.Pointer(tm)).F__tm_gmtoff, tm) < 0 { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return uintptr(0) } return tm @@ -149286,23 +149286,23 @@ func Xmktime(tls *TLS, tm uintptr) (r Ttime_t) { _ = t t = X__tm_to_secs(tls, tm) X__secs_to_zone(tls, t, int32(1), bp+32, bp+40, bp+56, bp+48) - if (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst >= 0 && (*(*Ttm)(unsafe.Pointer(bp))).Ftm_isdst != (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst { - t = t - (*(*int64)(unsafe.Pointer(bp + 56)) - (*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff) + if (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst >= 0 && (**(**Ttm)(__ccgo_up(bp))).Ftm_isdst != (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst { + t = t - int64(**(**int64)(__ccgo_up(bp + 56))-(**(**Ttm)(__ccgo_up(bp))).F__tm_gmtoff) } - t = t - (*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff + t = t - int64((**(**Ttm)(__ccgo_up(bp))).F__tm_gmtoff) if t != t { goto error } X__secs_to_zone(tls, t, 0, bp+32, bp+40, bp+56, bp+48) - if X__secs_to_tm(tls, t+(*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff, bp) < 0 { + if X__secs_to_tm(tls, t+int64((**(**Ttm)(__ccgo_up(bp))).F__tm_gmtoff), bp) < 0 { goto error } - *(*Ttm)(unsafe.Pointer(tm)) = *(*Ttm)(unsafe.Pointer(bp)) + **(**Ttm)(__ccgo_up(tm)) = **(**Ttm)(__ccgo_up(bp)) return t goto error error: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return int64(-int32(1)) } @@ -149463,7 +149463,7 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc val = int64((*Ttm)(unsafe.Pointer(tm)).Ftm_min) goto number case int32('n'): - *(*Tsize_t)(unsafe.Pointer(l)) = uint64(1) + **(**Tsize_t)(__ccgo_up(l)) = uint64(1) return __ccgo_ts + 367 case int32('p'): if (*Ttm)(unsafe.Pointer(tm)).Ftm_hour >= int32(12) { @@ -149482,20 +149482,20 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc item = v1 fmt = X__nl_langinfo_l(tls, item, loc) d = s - *(*Tsize_t)(unsafe.Pointer(l)) = uint64(0) + **(**Tsize_t)(__ccgo_up(l)) = uint64(0) for { - if !(*(*int8)(unsafe.Pointer(fmt)) != 0) { + if !(**(**int8)(__ccgo_up(fmt)) != 0) { break } v4 = d d = d + 1 v5 = fmt fmt = fmt + 1 - *(*int8)(unsafe.Pointer(v4)) = int8(Xtolower(tls, int32(*(*int8)(unsafe.Pointer(v5))))) + **(**int8)(__ccgo_up(v4)) = int8(Xtolower(tls, int32(**(**int8)(__ccgo_up(v5))))) goto _3 _3: ; - *(*Tsize_t)(unsafe.Pointer(l)) = *(*Tsize_t)(unsafe.Pointer(l)) + 1 + **(**Tsize_t)(__ccgo_up(l)) = **(**Tsize_t)(__ccgo_up(l)) + 1 } return s case int32('r'): @@ -149512,7 +149512,7 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc val = int64((*Ttm)(unsafe.Pointer(tm)).Ftm_sec) goto number case int32('t'): - *(*Tsize_t)(unsafe.Pointer(l)) = uint64(1) + **(**Tsize_t)(__ccgo_up(l)) = uint64(1) return __ccgo_ts + 1417 case int32('T'): fmt = __ccgo_ts + 1861 @@ -149554,27 +149554,27 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc case int32('Y'): val = int64((*Ttm)(unsafe.Pointer(tm)).Ftm_year) + int64(1900) if val >= int64(10000) { - *(*Tsize_t)(unsafe.Pointer(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1870, VaList(bp+8, val))) + **(**Tsize_t)(__ccgo_up(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1870, VaList(bp+8, val))) return s } width = int32(4) goto number case int32('z'): if (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst < 0 { - *(*Tsize_t)(unsafe.Pointer(l)) = uint64(0) + **(**Tsize_t)(__ccgo_up(l)) = uint64(0) return __ccgo_ts } - *(*Tsize_t)(unsafe.Pointer(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1876, VaList(bp+8, (*Ttm)(unsafe.Pointer(tm)).F__tm_gmtoff/int64(3600)*int64(100)+(*Ttm)(unsafe.Pointer(tm)).F__tm_gmtoff%int64(3600)/int64(60)))) + **(**Tsize_t)(__ccgo_up(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1876, VaList(bp+8, (*Ttm)(unsafe.Pointer(tm)).F__tm_gmtoff/int64(3600)*int64(100)+(*Ttm)(unsafe.Pointer(tm)).F__tm_gmtoff%int64(3600)/int64(60)))) return s case int32('Z'): if (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst < 0 { - *(*Tsize_t)(unsafe.Pointer(l)) = uint64(0) + **(**Tsize_t)(__ccgo_up(l)) = uint64(0) return __ccgo_ts } fmt = X__tm_to_tzname(tls, tm) goto string case int32('%'): - *(*Tsize_t)(unsafe.Pointer(l)) = uint64(1) + **(**Tsize_t)(__ccgo_up(l)) = uint64(1) return __ccgo_ts + 414 default: return uintptr(0) @@ -149589,13 +149589,13 @@ number: } switch v1 { case int32('-'): - *(*Tsize_t)(unsafe.Pointer(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1883, VaList(bp+8, val))) + **(**Tsize_t)(__ccgo_up(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1883, VaList(bp+8, val))) case int32('_'): - *(*Tsize_t)(unsafe.Pointer(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1888, VaList(bp+8, width, val))) + **(**Tsize_t)(__ccgo_up(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1888, VaList(bp+8, width, val))) case int32('0'): fallthrough default: - *(*Tsize_t)(unsafe.Pointer(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1894, VaList(bp+8, width, val))) + **(**Tsize_t)(__ccgo_up(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1894, VaList(bp+8, width, val))) break } return s @@ -149606,7 +149606,7 @@ nl_strcat: goto string string: ; - *(*Tsize_t)(unsafe.Pointer(l)) = _strlen(tls, fmt) + **(**Tsize_t)(__ccgo_up(l)) = _strlen(tls, fmt) return fmt goto nl_strftime nl_strftime: @@ -149615,8 +149615,8 @@ nl_strftime: goto recu_strftime recu_strftime: ; - *(*Tsize_t)(unsafe.Pointer(l)) = X__strftime_l(tls, s, uint64(100), fmt, tm, loc) - if !(*(*Tsize_t)(unsafe.Pointer(l)) != 0) { + **(**Tsize_t)(__ccgo_up(l)) = X__strftime_l(tls, s, uint64(100), fmt, tm, loc) + if !(**(**Tsize_t)(__ccgo_up(l)) != 0) { return uintptr(0) } return s @@ -149643,46 +149643,46 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl if !(l < n) { break } - if !(*(*int8)(unsafe.Pointer(f)) != 0) { - *(*int8)(unsafe.Pointer(s + uintptr(l))) = 0 + if !(**(**int8)(__ccgo_up(f)) != 0) { + **(**int8)(__ccgo_up(s + uintptr(l))) = 0 return l } - if int32(*(*int8)(unsafe.Pointer(f))) != int32('%') { + if int32(**(**int8)(__ccgo_up(f))) != int32('%') { v2 = l l = l + 1 - *(*int8)(unsafe.Pointer(s + uintptr(v2))) = *(*int8)(unsafe.Pointer(f)) + **(**int8)(__ccgo_up(s + uintptr(v2))) = **(**int8)(__ccgo_up(f)) goto _1 } f = f + 1 pad = 0 - if int32(*(*int8)(unsafe.Pointer(f))) == int32('-') || int32(*(*int8)(unsafe.Pointer(f))) == int32('_') || int32(*(*int8)(unsafe.Pointer(f))) == int32('0') { + if int32(**(**int8)(__ccgo_up(f))) == int32('-') || int32(**(**int8)(__ccgo_up(f))) == int32('_') || int32(**(**int8)(__ccgo_up(f))) == int32('0') { v3 = f f = f + 1 - pad = int32(*(*int8)(unsafe.Pointer(v3))) + pad = int32(**(**int8)(__ccgo_up(v3))) } - v4 = BoolInt32(int32(*(*int8)(unsafe.Pointer(f))) == Int32FromUint8('+')) + v4 = BoolInt32(int32(**(**int8)(__ccgo_up(f))) == Int32FromUint8('+')) plus = v4 if v4 != 0 { f = f + 1 } - if BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(f)))-uint32('0') < uint32(10)) != 0 { + if BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(f)))-uint32('0') < uint32(10)) != 0 { width = Xstrtoul(tls, f, bp+112, int32(10)) } else { width = uint64(0) - *(*uintptr)(unsafe.Pointer(bp + 112)) = f + **(**uintptr)(__ccgo_up(bp + 112)) = f } - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 112))))) == int32('C') || int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 112))))) == int32('F') || int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 112))))) == int32('G') || int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 112))))) == int32('Y') { - if !(width != 0) && *(*uintptr)(unsafe.Pointer(bp + 112)) != f { + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 112))))) == int32('C') || int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 112))))) == int32('F') || int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 112))))) == int32('G') || int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 112))))) == int32('Y') { + if !(width != 0) && **(**uintptr)(__ccgo_up(bp + 112)) != f { width = uint64(1) } } else { width = uint64(0) } - f = *(*uintptr)(unsafe.Pointer(bp + 112)) - if int32(*(*int8)(unsafe.Pointer(f))) == int32('E') || int32(*(*int8)(unsafe.Pointer(f))) == int32('O') { + f = **(**uintptr)(__ccgo_up(bp + 112)) + if int32(**(**int8)(__ccgo_up(f))) == int32('E') || int32(**(**int8)(__ccgo_up(f))) == int32('O') { f = f + 1 } - t = X__strftime_fmt_1(tls, bp+8, bp, int32(*(*int8)(unsafe.Pointer(f))), tm, loc, pad) + t = X__strftime_fmt_1(tls, bp+8, bp, int32(**(**int8)(__ccgo_up(f))), tm, loc, pad) if !(t != 0) { break } @@ -149690,26 +149690,26 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl /* Trim off any sign and leading zeros, then * count remaining digits to determine behavior * for the + flag. */ - if int32(*(*int8)(unsafe.Pointer(t))) == int32('+') || int32(*(*int8)(unsafe.Pointer(t))) == int32('-') { + if int32(**(**int8)(__ccgo_up(t))) == int32('+') || int32(**(**int8)(__ccgo_up(t))) == int32('-') { t = t + 1 - *(*Tsize_t)(unsafe.Pointer(bp)) = *(*Tsize_t)(unsafe.Pointer(bp)) - 1 + **(**Tsize_t)(__ccgo_up(bp)) = **(**Tsize_t)(__ccgo_up(bp)) - 1 } for { - if !(int32(*(*int8)(unsafe.Pointer(t))) == int32('0') && Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(t + 1)))-int32('0')) < uint32(10)) { + if !(int32(**(**int8)(__ccgo_up(t))) == int32('0') && Uint32FromInt32(int32(**(**int8)(__ccgo_up(t + 1)))-int32('0')) < uint32(10)) { break } goto _5 _5: ; t = t + 1 - *(*Tsize_t)(unsafe.Pointer(bp)) = *(*Tsize_t)(unsafe.Pointer(bp)) - 1 + **(**Tsize_t)(__ccgo_up(bp)) = **(**Tsize_t)(__ccgo_up(bp)) - 1 } - if width < *(*Tsize_t)(unsafe.Pointer(bp)) { - width = *(*Tsize_t)(unsafe.Pointer(bp)) + if width < **(**Tsize_t)(__ccgo_up(bp)) { + width = **(**Tsize_t)(__ccgo_up(bp)) } d = uint64(0) for { - if !(Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(t + uintptr(d))))-int32('0')) < uint32(10)) { + if !(Uint32FromInt32(int32(**(**int8)(__ccgo_up(t + uintptr(d))))-int32('0')) < uint32(10)) { break } goto _6 @@ -149720,41 +149720,41 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl if (*Ttm)(unsafe.Pointer(tm)).Ftm_year < -int32(1900) { v2 = l l = l + 1 - *(*int8)(unsafe.Pointer(s + uintptr(v2))) = int8('-') + **(**int8)(__ccgo_up(s + uintptr(v2))) = int8('-') width = width - 1 } else { if v9 = plus != 0; v9 { - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 112))))) == int32('C') { + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 112))))) == int32('C') { v4 = int32(3) } else { v4 = int32(5) } } - if v9 && d+(width-*(*Tsize_t)(unsafe.Pointer(bp))) >= Uint64FromInt32(v4) { + if v9 && d+(width-**(**Tsize_t)(__ccgo_up(bp))) >= Uint64FromInt32(v4) { v2 = l l = l + 1 - *(*int8)(unsafe.Pointer(s + uintptr(v2))) = int8('+') + **(**int8)(__ccgo_up(s + uintptr(v2))) = int8('+') width = width - 1 } } for { - if !(width > *(*Tsize_t)(unsafe.Pointer(bp)) && l < n) { + if !(width > **(**Tsize_t)(__ccgo_up(bp)) && l < n) { break } v2 = l l = l + 1 - *(*int8)(unsafe.Pointer(s + uintptr(v2))) = int8('0') + **(**int8)(__ccgo_up(s + uintptr(v2))) = int8('0') goto _11 _11: ; width = width - 1 } } - if *(*Tsize_t)(unsafe.Pointer(bp)) > n-l { - *(*Tsize_t)(unsafe.Pointer(bp)) = n - l + if **(**Tsize_t)(__ccgo_up(bp)) > n-l { + **(**Tsize_t)(__ccgo_up(bp)) = n - l } - Xmemcpy(tls, s+uintptr(l), t, *(*Tsize_t)(unsafe.Pointer(bp))) - l = l + *(*Tsize_t)(unsafe.Pointer(bp)) + Xmemcpy(tls, s+uintptr(l), t, **(**Tsize_t)(__ccgo_up(bp))) + l = l + **(**Tsize_t)(__ccgo_up(bp)) goto _1 _1: ; @@ -149764,7 +149764,7 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl if l == n { l = n - uint64(1) } - *(*int8)(unsafe.Pointer(s + uintptr(l))) = 0 + **(**int8)(__ccgo_up(s + uintptr(l))) = 0 } return uint64(0) } @@ -149802,18 +149802,18 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { var _ /* relyear at bp+8 */ int32 _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = adj, dest, ex, i, len1, min, neg, range1, w, want_century, v1, v2, v5, v6, v8, v9 want_century = 0 - *(*int32)(unsafe.Pointer(bp + 4)) = 0 - *(*int32)(unsafe.Pointer(bp + 8)) = 0 - for *(*int8)(unsafe.Pointer(f)) != 0 { - if int32(*(*int8)(unsafe.Pointer(f))) != int32('%') { - v1 = int32(*(*int8)(unsafe.Pointer(f))) + **(**int32)(__ccgo_up(bp + 4)) = 0 + **(**int32)(__ccgo_up(bp + 8)) = 0 + for **(**int8)(__ccgo_up(f)) != 0 { + if int32(**(**int8)(__ccgo_up(f))) != int32('%') { + v1 = int32(**(**int8)(__ccgo_up(f))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _3 _3: if v2 != 0 { for { - if v8 = *(*int8)(unsafe.Pointer(s)) != 0; v8 { - v5 = int32(*(*int8)(unsafe.Pointer(s))) + if v8 = **(**int8)(__ccgo_up(s)) != 0; v8 { + v5 = int32(**(**int8)(__ccgo_up(s))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _7 _7: @@ -149827,7 +149827,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { s = s + 1 } } else { - if int32(*(*int8)(unsafe.Pointer(s))) != int32(*(*int8)(unsafe.Pointer(f))) { + if int32(**(**int8)(__ccgo_up(s))) != int32(**(**int8)(__ccgo_up(f))) { return uintptr(0) } else { s = s + 1 @@ -149837,19 +149837,19 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { continue } f = f + 1 - if int32(*(*int8)(unsafe.Pointer(f))) == int32('+') { + if int32(**(**int8)(__ccgo_up(f))) == int32('+') { f = f + 1 } - if BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(f)))-uint32('0') < uint32(10)) != 0 { + if BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(f)))-uint32('0') < uint32(10)) != 0 { w = Int32FromUint64(Xstrtoul(tls, f, bp+16, int32(10))) - f = *(*uintptr)(unsafe.Pointer(bp + 16)) + f = **(**uintptr)(__ccgo_up(bp + 16)) } else { w = -int32(1) } adj = 0 v9 = f f = f + 1 - switch int32(*(*int8)(unsafe.Pointer(v9))) { + switch int32(**(**int8)(__ccgo_up(v9))) { case int32('A'): goto _10 case int32('a'): @@ -150000,8 +150000,8 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { ; _44: ; - if v8 = *(*int8)(unsafe.Pointer(s)) != 0; v8 { - v1 = int32(*(*int8)(unsafe.Pointer(s))) + if v8 = **(**int8)(__ccgo_up(s)) != 0; v8 { + v1 = int32(**(**int8)(__ccgo_up(s))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _47 _47: @@ -150023,15 +150023,15 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { ex = Xnl_langinfo(tls, int32(AM_STR)) len1 = _strlen(tls, ex) if !(Xstrncasecmp(tls, s, ex, len1) != 0) { - *(*int32)(unsafe.Pointer(tm + 8)) %= int32(12) + **(**int32)(__ccgo_up(tm + 8)) %= int32(12) s = s + uintptr(len1) goto _41 } ex = Xnl_langinfo(tls, int32(PM_STR)) len1 = _strlen(tls, ex) if !(Xstrncasecmp(tls, s, ex, len1) != 0) { - *(*int32)(unsafe.Pointer(tm + 8)) %= int32(12) - *(*int32)(unsafe.Pointer(tm + 8)) += int32(12) + **(**int32)(__ccgo_up(tm + 8)) %= int32(12) + **(**int32)(__ccgo_up(tm + 8)) += int32(12) s = s + uintptr(len1) goto _41 } @@ -150111,7 +150111,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { ; v9 = s s = s + 1 - if int32(*(*int8)(unsafe.Pointer(v9))) != int32('%') { + if int32(**(**int8)(__ccgo_up(v9))) != int32('%') { return uintptr(0) } goto _41 @@ -150121,27 +150121,27 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { goto numeric_range numeric_range: ; - if !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + if !(BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } - *(*int32)(unsafe.Pointer(dest)) = 0 + **(**int32)(__ccgo_up(dest)) = 0 i = int32(1) for { - if !(i <= min+range1 && BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0) { + if !(i <= min+range1 && BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(s)))-uint32('0') < uint32(10)) != 0) { break } v9 = s s = s + 1 - *(*int32)(unsafe.Pointer(dest)) = *(*int32)(unsafe.Pointer(dest))*int32(10) + int32(*(*int8)(unsafe.Pointer(v9))) - int32('0') + **(**int32)(__ccgo_up(dest)) = **(**int32)(__ccgo_up(dest))*int32(10) + int32(**(**int8)(__ccgo_up(v9))) - int32('0') goto _50 _50: ; i = i * int32(10) } - if Uint32FromInt32(*(*int32)(unsafe.Pointer(dest))-min) >= Uint32FromInt32(range1) { + if Uint32FromInt32(**(**int32)(__ccgo_up(dest))-min) >= Uint32FromInt32(range1) { return uintptr(0) } - *(*int32)(unsafe.Pointer(dest)) -= adj + **(**int32)(__ccgo_up(dest)) -= adj switch int64(dest) - int64(tm) { case Int64FromUint64(uint64(UintptrFromInt32(0) + 28)): } @@ -150150,36 +150150,36 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { numeric_digits: ; neg = 0 - if int32(*(*int8)(unsafe.Pointer(s))) == int32('+') { + if int32(**(**int8)(__ccgo_up(s))) == int32('+') { s = s + 1 } else { - if int32(*(*int8)(unsafe.Pointer(s))) == int32('-') { + if int32(**(**int8)(__ccgo_up(s))) == int32('-') { neg = int32(1) s = s + 1 } } - if !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + if !(BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } v1 = Int32FromInt32(0) i = v1 - *(*int32)(unsafe.Pointer(dest)) = v1 + **(**int32)(__ccgo_up(dest)) = v1 for { - if !(i < w && BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0) { + if !(i < w && BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(s)))-uint32('0') < uint32(10)) != 0) { break } v9 = s s = s + 1 - *(*int32)(unsafe.Pointer(dest)) = *(*int32)(unsafe.Pointer(dest))*int32(10) + int32(*(*int8)(unsafe.Pointer(v9))) - int32('0') + **(**int32)(__ccgo_up(dest)) = **(**int32)(__ccgo_up(dest))*int32(10) + int32(**(**int8)(__ccgo_up(v9))) - int32('0') goto _52 _52: ; i = i + 1 } if neg != 0 { - *(*int32)(unsafe.Pointer(dest)) = -*(*int32)(unsafe.Pointer(dest)) + **(**int32)(__ccgo_up(dest)) = -**(**int32)(__ccgo_up(dest)) } - *(*int32)(unsafe.Pointer(dest)) -= adj + **(**int32)(__ccgo_up(dest)) -= adj goto update goto symbolic_range symbolic_range: @@ -150195,7 +150195,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { goto _55 } s = s + uintptr(len1) - *(*int32)(unsafe.Pointer(dest)) = i % range1 + **(**int32)(__ccgo_up(dest)) = i % range1 break goto _55 _55: @@ -150213,12 +150213,12 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { _41: } if want_century != 0 { - (*Ttm)(unsafe.Pointer(tm)).Ftm_year = *(*int32)(unsafe.Pointer(bp + 8)) + (*Ttm)(unsafe.Pointer(tm)).Ftm_year = **(**int32)(__ccgo_up(bp + 8)) if want_century&int32(2) != 0 { - *(*int32)(unsafe.Pointer(tm + 20)) += *(*int32)(unsafe.Pointer(bp + 4))*int32(100) - int32(1900) + **(**int32)(__ccgo_up(tm + 20)) += **(**int32)(__ccgo_up(bp + 4))*int32(100) - int32(1900) } else { if (*Ttm)(unsafe.Pointer(tm)).Ftm_year <= int32(68) { - *(*int32)(unsafe.Pointer(tm + 20)) += int32(100) + **(**int32)(__ccgo_up(tm + 20)) += int32(100) } } } @@ -150235,9 +150235,9 @@ func Xtime(tls *TLS, t uintptr) (r Ttime_t) { var _ /* ts at bp+0 */ Ttimespec X__clock_gettime(tls, CLOCK_REALTIME, bp) if t != 0 { - *(*Ttime_t)(unsafe.Pointer(t)) = (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec + **(**Ttime_t)(__ccgo_up(t)) = (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec } - return (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec + return (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec } func Xtimegm(tls *TLS, tm uintptr) (r Ttime_t) { @@ -150252,10 +150252,10 @@ func Xtimegm(tls *TLS, tm uintptr) (r Ttime_t) { _ = t t = X__tm_to_secs(tls, tm) if X__secs_to_tm(tls, t, bp) < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return int64(-int32(1)) } - *(*Ttm1)(unsafe.Pointer(tm)) = *(*Ttm1)(unsafe.Pointer(bp)) + **(**Ttm1)(__ccgo_up(tm)) = **(**Ttm1)(__ccgo_up(bp)) (*Ttm1)(unsafe.Pointer(tm)).Ftm_isdst = 0 (*Ttm1)(unsafe.Pointer(tm)).Ftm_gmtoff = 0 (*Ttm1)(unsafe.Pointer(tm)).Ftm_zone = uintptr(unsafe.Pointer(&X__utc)) @@ -150413,92 +150413,92 @@ func X__wcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl if !(l < n) { break } - if !(*(*Twchar_t)(unsafe.Pointer(f)) != 0) { - *(*Twchar_t)(unsafe.Pointer(s + uintptr(l)*4)) = 0 + if !(**(**Twchar_t)(__ccgo_up(f)) != 0) { + **(**Twchar_t)(__ccgo_up(s + uintptr(l)*4)) = 0 return l } - if *(*Twchar_t)(unsafe.Pointer(f)) != int32('%') { + if **(**Twchar_t)(__ccgo_up(f)) != int32('%') { v2 = l l = l + 1 - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = *(*Twchar_t)(unsafe.Pointer(f)) + **(**Twchar_t)(__ccgo_up(s + uintptr(v2)*4)) = **(**Twchar_t)(__ccgo_up(f)) goto _1 } f += 4 pad = 0 - if *(*Twchar_t)(unsafe.Pointer(f)) == int32('-') || *(*Twchar_t)(unsafe.Pointer(f)) == int32('_') || *(*Twchar_t)(unsafe.Pointer(f)) == int32('0') { + if **(**Twchar_t)(__ccgo_up(f)) == int32('-') || **(**Twchar_t)(__ccgo_up(f)) == int32('_') || **(**Twchar_t)(__ccgo_up(f)) == int32('0') { v3 = f f += 4 - pad = *(*Twchar_t)(unsafe.Pointer(v3)) + pad = **(**Twchar_t)(__ccgo_up(v3)) } - v4 = BoolInt32(*(*Twchar_t)(unsafe.Pointer(f)) == Int32FromUint8('+')) + v4 = BoolInt32(**(**Twchar_t)(__ccgo_up(f)) == Int32FromUint8('+')) plus = v4 if v4 != 0 { f += 4 } width = Xwcstoul(tls, f, bp+512, int32(10)) - if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 512)))) == int32('C') || *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 512)))) == int32('F') || *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 512)))) == int32('G') || *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 512)))) == int32('Y') { - if !(width != 0) && *(*uintptr)(unsafe.Pointer(bp + 512)) != f { + if **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 512)))) == int32('C') || **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 512)))) == int32('F') || **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 512)))) == int32('G') || **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 512)))) == int32('Y') { + if !(width != 0) && **(**uintptr)(__ccgo_up(bp + 512)) != f { width = uint64(1) } } else { width = uint64(0) } - f = *(*uintptr)(unsafe.Pointer(bp + 512)) - if *(*Twchar_t)(unsafe.Pointer(f)) == int32('E') || *(*Twchar_t)(unsafe.Pointer(f)) == int32('O') { + f = **(**uintptr)(__ccgo_up(bp + 512)) + if **(**Twchar_t)(__ccgo_up(f)) == int32('E') || **(**Twchar_t)(__ccgo_up(f)) == int32('O') { f += 4 } - t_mb = X__strftime_fmt_1(tls, bp+8, bp, *(*Twchar_t)(unsafe.Pointer(f)), tm, loc, pad) + t_mb = X__strftime_fmt_1(tls, bp+8, bp, **(**Twchar_t)(__ccgo_up(f)), tm, loc, pad) if !(t_mb != 0) { break } - *(*Tsize_t)(unsafe.Pointer(bp)) = Xmbstowcs(tls, bp+108, t_mb, Uint64FromInt64(400)/Uint64FromInt64(4)) - if *(*Tsize_t)(unsafe.Pointer(bp)) == Uint64FromInt32(-Int32FromInt32(1)) { + **(**Tsize_t)(__ccgo_up(bp)) = Xmbstowcs(tls, bp+108, t_mb, Uint64FromInt64(400)/Uint64FromInt64(4)) + if **(**Tsize_t)(__ccgo_up(bp)) == Uint64FromInt32(-Int32FromInt32(1)) { return uint64(0) } t = bp + 108 if width != 0 { for { - if !(*(*Twchar_t)(unsafe.Pointer(t)) == int32('+') || *(*Twchar_t)(unsafe.Pointer(t)) == int32('-') || *(*Twchar_t)(unsafe.Pointer(t)) == int32('0') && *(*Twchar_t)(unsafe.Pointer(t + 1*4)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(t)) == int32('+') || **(**Twchar_t)(__ccgo_up(t)) == int32('-') || **(**Twchar_t)(__ccgo_up(t)) == int32('0') && **(**Twchar_t)(__ccgo_up(t + 1*4)) != 0) { break } goto _5 _5: ; t += 4 - *(*Tsize_t)(unsafe.Pointer(bp)) = *(*Tsize_t)(unsafe.Pointer(bp)) - 1 + **(**Tsize_t)(__ccgo_up(bp)) = **(**Tsize_t)(__ccgo_up(bp)) - 1 } width = width - 1 if plus != 0 && (*Ttm)(unsafe.Pointer(tm)).Ftm_year >= Int32FromInt32(10000)-Int32FromInt32(1900) { v2 = l l = l + 1 - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = int32('+') + **(**Twchar_t)(__ccgo_up(s + uintptr(v2)*4)) = int32('+') } else { if (*Ttm)(unsafe.Pointer(tm)).Ftm_year < -int32(1900) { v2 = l l = l + 1 - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = int32('-') + **(**Twchar_t)(__ccgo_up(s + uintptr(v2)*4)) = int32('-') } else { width = width + 1 } } for { - if !(width > *(*Tsize_t)(unsafe.Pointer(bp)) && l < n) { + if !(width > **(**Tsize_t)(__ccgo_up(bp)) && l < n) { break } v2 = l l = l + 1 - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = int32('0') + **(**Twchar_t)(__ccgo_up(s + uintptr(v2)*4)) = int32('0') goto _8 _8: ; width = width - 1 } } - if *(*Tsize_t)(unsafe.Pointer(bp)) >= n-l { - *(*Tsize_t)(unsafe.Pointer(bp)) = n - l + if **(**Tsize_t)(__ccgo_up(bp)) >= n-l { + **(**Tsize_t)(__ccgo_up(bp)) = n - l } - Xwmemcpy(tls, s+uintptr(l)*4, t, *(*Tsize_t)(unsafe.Pointer(bp))) - l = l + *(*Tsize_t)(unsafe.Pointer(bp)) + Xwmemcpy(tls, s+uintptr(l)*4, t, **(**Tsize_t)(__ccgo_up(bp))) + l = l + **(**Tsize_t)(__ccgo_up(bp)) goto _1 _1: ; @@ -150508,7 +150508,7 @@ func X__wcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl if l == n { l = n - uint64(1) } - *(*Twchar_t)(unsafe.Pointer(s + uintptr(l)*4)) = 0 + **(**Twchar_t)(__ccgo_up(s + uintptr(l)*4)) = 0 } return uint64(0) } @@ -150561,14 +150561,14 @@ func Xalarm(tls *TLS, seconds uint32) (r uint32) { defer tls.Free(64) var _ /* it at bp+0 */ Titimerval var _ /* old at bp+32 */ Titimerval - *(*Titimerval)(unsafe.Pointer(bp)) = Titimerval{ + **(**Titimerval)(__ccgo_up(bp)) = Titimerval{ Fit_value: Ttimeval{ Ftv_sec: Int64FromUint32(seconds), }, } - *(*Titimerval)(unsafe.Pointer(bp + 32)) = Titimerval{} + **(**Titimerval)(__ccgo_up(bp + 32)) = Titimerval{} Xsetitimer(tls, ITIMER_REAL, bp, bp+32) - return Uint32FromInt64((*(*Titimerval)(unsafe.Pointer(bp + 32))).Fit_value.Ftv_sec + BoolInt64(!!((*(*Titimerval)(unsafe.Pointer(bp + 32))).Fit_value.Ftv_usec != 0))) + return Uint32FromInt64((**(**Titimerval)(__ccgo_up(bp + 32))).Fit_value.Ftv_sec + BoolInt64(!!((**(**Titimerval)(__ccgo_up(bp + 32))).Fit_value.Ftv_usec != 0))) } func Xchdir(tls *TLS, path uintptr) (r int32) { @@ -150709,7 +150709,7 @@ func _checker(tls *TLS, p uintptr) (r int32) { if X__syscall2(tls, int64(SYS_setregid), X__syscall0(tls, int64(SYS_getegid)), int64(-Int32FromInt32(1))) != 0 || X__syscall2(tls, int64(SYS_setreuid), X__syscall0(tls, int64(SYS_geteuid)), int64(-Int32FromInt32(1))) != 0 { X__syscall1(tls, int64(SYS_exit), int64(Int32FromInt32(1))) } - *(*int32)(unsafe.Pointer(bp)) = int32(X__syscall4(tls, int64(SYS_faccessat), int64((*Tctx1)(unsafe.Pointer(c)).Ffd), int64((*Tctx1)(unsafe.Pointer(c)).Ffilename), int64((*Tctx1)(unsafe.Pointer(c)).Famode), int64(Int32FromInt32(0)))) + **(**int32)(__ccgo_up(bp)) = int32(X__syscall4(tls, int64(SYS_faccessat), int64((*Tctx1)(unsafe.Pointer(c)).Ffd), int64((*Tctx1)(unsafe.Pointer(c)).Ffilename), int64((*Tctx1)(unsafe.Pointer(c)).Famode), int64(Int32FromInt32(0)))) X__syscall3(tls, int64(SYS_write), int64((*Tctx1)(unsafe.Pointer(c)).Fp), int64(bp), Int64FromUint64(Uint64FromInt64(4))) return 0 } @@ -150824,7 +150824,7 @@ func Xgetcwd(tls *TLS, buf uintptr, size Tsize_t) (r uintptr) { size = v1 } else { if !(size != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } } @@ -150832,8 +150832,8 @@ func Xgetcwd(tls *TLS, buf uintptr, size Tsize_t) (r uintptr) { if ret < 0 { return uintptr(0) } - if ret == 0 || int32(*(*int8)(unsafe.Pointer(buf))) != int32('/') { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOENT) + if ret == 0 || int32(**(**int8)(__ccgo_up(buf))) != int32('/') { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOENT) return uintptr(0) } if buf == tmp { @@ -150897,8 +150897,8 @@ func Xgethostname(tls *TLS, name uintptr, len1 Tsize_t) (r int32) { i = uint64(0) for { if v3 = i < len1; v3 { - v2 = *(*int8)(unsafe.Pointer(bp + 65 + uintptr(i))) - *(*int8)(unsafe.Pointer(name + uintptr(i))) = v2 + v2 = **(**int8)(__ccgo_up(bp + 65 + uintptr(i))) + **(**int8)(__ccgo_up(name + uintptr(i))) = v2 } if !(v3 && v2 != 0) { break @@ -150909,7 +150909,7 @@ func Xgethostname(tls *TLS, name uintptr, len1 Tsize_t) (r int32) { i = i + 1 } if i != 0 && i == len1 { - *(*int8)(unsafe.Pointer(name + uintptr(i-uint64(1)))) = 0 + **(**int8)(__ccgo_up(name + uintptr(i-uint64(1)))) = 0 } return 0 } @@ -151002,8 +151002,8 @@ func Xisatty(tls *TLS, fd int32) (r1 int32) { if r == uint64(0) { return int32(1) } - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(EBADF) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOTTY) + if **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(EBADF) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOTTY) } return 0 } @@ -151068,8 +151068,8 @@ func Xnice(tls *TLS, inc int32) (r int32) { prio = -int32(NZERO) } if Xsetpriority(tls, PRIO_PROCESS, uint32(0), prio) != 0 { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EACCES) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EPERM) + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EACCES) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EPERM) } return -int32(1) } else { @@ -151116,12 +151116,12 @@ func Xpipe2(tls *TLS, fd uintptr, flag int32) (r int32) { return ret } if flag&int32(O_CLOEXEC) != 0 { - X__syscall3(tls, int64(SYS_fcntl), int64(*(*int32)(unsafe.Pointer(fd))), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) - X__syscall3(tls, int64(SYS_fcntl), int64(*(*int32)(unsafe.Pointer(fd + 1*4))), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) + X__syscall3(tls, int64(SYS_fcntl), int64(**(**int32)(__ccgo_up(fd))), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) + X__syscall3(tls, int64(SYS_fcntl), int64(**(**int32)(__ccgo_up(fd + 1*4))), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) } if flag&int32(O_NONBLOCK) != 0 { - X__syscall3(tls, int64(SYS_fcntl), int64(*(*int32)(unsafe.Pointer(fd))), int64(Int32FromInt32(F_SETFL)), int64(Int32FromInt32(O_NONBLOCK))) - X__syscall3(tls, int64(SYS_fcntl), int64(*(*int32)(unsafe.Pointer(fd + 1*4))), int64(Int32FromInt32(F_SETFL)), int64(Int32FromInt32(O_NONBLOCK))) + X__syscall3(tls, int64(SYS_fcntl), int64(**(**int32)(__ccgo_up(fd))), int64(Int32FromInt32(F_SETFL)), int64(Int32FromInt32(O_NONBLOCK))) + X__syscall3(tls, int64(SYS_fcntl), int64(**(**int32)(__ccgo_up(fd + 1*4))), int64(Int32FromInt32(F_SETFL)), int64(Int32FromInt32(O_NONBLOCK))) } return 0 } @@ -151320,7 +151320,7 @@ func X__setxid(tls *TLS, nr int32, id int32, eid int32, sid int32) (r int32) { _ = v1 /* ret is initially nonzero so that failure of the first thread does not * trigger the safety kill above. */ - *(*Tctx2)(unsafe.Pointer(bp)) = Tctx2{ + **(**Tctx2)(__ccgo_up(bp)) = Tctx2{ Fid: id, Feid: eid, Fsid: sid, @@ -151328,10 +151328,10 @@ func X__setxid(tls *TLS, nr int32, id int32, eid int32, sid int32) (r int32) { Fret: int32(1), } ___synccall(tls, __ccgo_fp(_do_setxid), bp) - if (*(*Tctx2)(unsafe.Pointer(bp))).Fret > 0 { + if (**(**Tctx2)(__ccgo_up(bp))).Fret > 0 { v1 = -int32(EAGAIN) } else { - v1 = (*(*Tctx2)(unsafe.Pointer(bp))).Fret + v1 = (**(**Tctx2)(__ccgo_up(bp))).Fret } return int32(X__syscall_ret(tls, Uint64FromInt32(v1))) } @@ -151344,11 +151344,11 @@ func Xsleep(tls *TLS, seconds uint32) (r uint32) { bp := tls.Alloc(16) defer tls.Free(16) var _ /* tv at bp+0 */ Ttimespec - *(*Ttimespec)(unsafe.Pointer(bp)) = Ttimespec{ + **(**Ttimespec)(__ccgo_up(bp)) = Ttimespec{ Ftv_sec: Int64FromUint32(seconds), } if Xnanosleep(tls, bp, bp) != 0 { - return Uint32FromInt64((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec) + return Uint32FromInt64((**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec) } return uint32(0) } @@ -151387,7 +151387,7 @@ func Xtcgetpgrp(tls *TLS, fd int32) (r Tpid_t) { if Xioctl(tls, fd, int32(TIOCGPGRP), VaList(bp+16, bp)) < 0 { return -int32(1) } - return *(*int32)(unsafe.Pointer(bp)) + return **(**int32)(__ccgo_up(bp)) } func Xtcsetpgrp(tls *TLS, fd int32, pgrp Tpid_t) (r int32) { @@ -151398,7 +151398,7 @@ func Xtcsetpgrp(tls *TLS, fd int32, pgrp Tpid_t) (r int32) { bp := tls.Alloc(32) defer tls.Free(32) var _ /* pgrp_int at bp+0 */ int32 - *(*int32)(unsafe.Pointer(bp)) = pgrp + **(**int32)(__ccgo_up(bp)) = pgrp return Xioctl(tls, fd, int32(TIOCSPGRP), VaList(bp+16, bp)) } @@ -151429,7 +151429,7 @@ func Xttyname(tls *TLS, fd int32) (r uintptr) { v1 = Xttyname_r(tls, fd, uintptr(unsafe.Pointer(&_buf10)), uint64(32)) result = v1 if v1 != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = result + **(**int32)(__ccgo_up(X__errno_location(tls))) = result return UintptrFromInt32(0) } return uintptr(unsafe.Pointer(&_buf10)) @@ -151450,22 +151450,22 @@ func Xttyname_r(tls *TLS, fd int32, name uintptr, size Tsize_t) (r int32) { var _ /* st2 at bp+144 */ Tstat _ = l if !(Xisatty(tls, fd) != 0) { - return *(*int32)(unsafe.Pointer(X__errno_location(tls))) + return **(**int32)(__ccgo_up(X__errno_location(tls))) } X__procfdname(tls, bp+288, Uint32FromInt32(fd)) l = Xreadlink(tls, bp+288, name, size) if l < 0 { - return *(*int32)(unsafe.Pointer(X__errno_location(tls))) + return **(**int32)(__ccgo_up(X__errno_location(tls))) } else { if Uint64FromInt64(l) == size { return int32(ERANGE) } } - *(*int8)(unsafe.Pointer(name + uintptr(l))) = 0 + **(**int8)(__ccgo_up(name + uintptr(l))) = 0 if Xstat(tls, name, bp) != 0 || Xfstat(tls, fd, bp+144) != 0 { - return *(*int32)(unsafe.Pointer(X__errno_location(tls))) + return **(**int32)(__ccgo_up(X__errno_location(tls))) } - if (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev != (*(*Tstat)(unsafe.Pointer(bp + 144))).Fst_dev || (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino != (*(*Tstat)(unsafe.Pointer(bp + 144))).Fst_ino { + if (**(**Tstat)(__ccgo_up(bp))).Fst_dev != (**(**Tstat)(__ccgo_up(bp + 144))).Fst_dev || (**(**Tstat)(__ccgo_up(bp))).Fst_ino != (**(**Tstat)(__ccgo_up(bp + 144))).Fst_ino { return int32(ENODEV) } return 0 @@ -151480,7 +151480,7 @@ func Xualarm(tls *TLS, value uint32, interval uint32) (r uint32) { defer tls.Free(64) var _ /* it at bp+0 */ Titimerval var _ /* it_old at bp+32 */ Titimerval - *(*Titimerval)(unsafe.Pointer(bp)) = Titimerval{ + **(**Titimerval)(__ccgo_up(bp)) = Titimerval{ Fit_interval: Ttimeval{ Ftv_usec: Int64FromUint32(interval), }, @@ -151489,7 +151489,7 @@ func Xualarm(tls *TLS, value uint32, interval uint32) (r uint32) { }, } Xsetitimer(tls, ITIMER_REAL, bp, bp+32) - return Uint32FromInt64((*(*Titimerval)(unsafe.Pointer(bp + 32))).Fit_value.Ftv_sec*int64(1000000) + (*(*Titimerval)(unsafe.Pointer(bp + 32))).Fit_value.Ftv_usec) + return Uint32FromInt64((**(**Titimerval)(__ccgo_up(bp + 32))).Fit_value.Ftv_sec*int64(1000000) + (**(**Titimerval)(__ccgo_up(bp + 32))).Fit_value.Ftv_usec) } func Xunlink(tls *TLS, path uintptr) (r int32) { @@ -151516,7 +151516,7 @@ func Xusleep(tls *TLS, useconds uint32) (r int32) { bp := tls.Alloc(16) defer tls.Free(16) var _ /* tv at bp+0 */ Ttimespec - *(*Ttimespec)(unsafe.Pointer(bp)) = Ttimespec{ + **(**Ttimespec)(__ccgo_up(bp)) = Ttimespec{ Ftv_sec: Int64FromUint32(useconds / uint32(1000000)), Ftv_nsec: Int64FromUint32(useconds % uint32(1000000) * uint32(1000)), } @@ -151544,6 +151544,10 @@ func __ccgo_fp(f interface{}) uintptr { return (*iface)(unsafe.Pointer(&f))[1] } +func __ccgo_up(n uintptr) unsafe.Pointer { + return unsafe.Pointer(&n) +} + var X__abort_lock [1]int32 var X__at_quick_exit_lockptr = uintptr(unsafe.Pointer(&_lock)) diff --git a/vendor/modernc.org/libc/ccgo_linux_arm.go b/vendor/modernc.org/libc/ccgo_linux_arm.go index 3fcf03577f..3c24e75521 100644 --- a/vendor/modernc.org/libc/ccgo_linux_arm.go +++ b/vendor/modernc.org/libc/ccgo_linux_arm.go @@ -618,7 +618,7 @@ func ___frexp_exp(tls *TLS, x float64, expt uintptr) (r float64) { */ exp_x = Xexp(tls, x-_kln2) hx = uint32(*(*Tuint64_t)(unsafe.Pointer(&exp_x)) >> int32(32)) - *(*int32)(unsafe.Pointer(expt)) = Int32FromUint32(hx>>Int32FromInt32(20) - Uint32FromInt32(Int32FromInt32(0x3ff)+Int32FromInt32(1023)) + _k) + **(**int32)(__ccgo_up(expt)) = Int32FromUint32(hx>>Int32FromInt32(20) - Uint32FromInt32(Int32FromInt32(0x3ff)+Int32FromInt32(1023)) + _k) v1 = uint64(hx&Uint32FromInt32(0xfffff)|Uint32FromInt32((Int32FromInt32(0x3ff)+Int32FromInt32(1023))<>Int32FromInt32(23) - Uint32FromInt32(Int32FromInt32(0x7f)+Int32FromInt32(127)) + _k1) + **(**int32)(__ccgo_up(expt)) = Int32FromUint32(hx>>Int32FromInt32(23) - Uint32FromInt32(Int32FromInt32(0x7f)+Int32FromInt32(127)) + _k1) v1 = hx&uint32(0x7fffff) | Uint32FromInt32((Int32FromInt32(0x7f)+Int32FromInt32(127))< uint32(35) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uint32(0) } } @@ -3354,7 +3354,7 @@ func Xfpathconf(tls *TLS, fd int32, name int32) (r int32) { defer func() { trc("-> %v", r) }() } if Uint32FromInt32(name) >= Uint32FromInt64(42)/Uint32FromInt64(2) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } return int32(_values[name]) @@ -7648,7 +7648,7 @@ func Xsysconf(tls *TLS, name int32) (r int32) { var _ /* si at bp+144 */ Tsysinfo _, _, _, _, _, _, _ = cnt, i, mem, val, v1, v3, v5 if Uint32FromInt32(name) >= Uint32FromInt64(502)/Uint32FromInt64(2) || !(_values1[name] != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } else { if int32(_values1[name]) >= -int32(1) { @@ -7656,13 +7656,13 @@ func Xsysconf(tls *TLS, name int32) (r int32) { } else { if int32(_values1[name]) < -int32(256) { Xgetrlimit(tls, int32(_values1[name])&int32(16383), bp) - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur == ^Uint64FromUint64(0) { + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur == ^Uint64FromUint64(0) { return -int32(1) } - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur > uint64(0x7fffffff) { + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur > uint64(0x7fffffff) { v1 = uint64(0x7fffffff) } else { - v1 = (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur + v1 = (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur } return Int32FromUint64(v1) } @@ -7684,7 +7684,7 @@ func Xsysconf(tls *TLS, name int32) (r int32) { case (-Int32FromInt32(256) | Int32FromInt32(6)) & Int32FromInt32(255): fallthrough case (-Int32FromInt32(256) | Int32FromInt32(7)) & Int32FromInt32(255): - *(*[128]uint8)(unsafe.Pointer(bp + 16)) = [128]uint8{ + **(**[128]uint8)(__ccgo_up(bp + 16)) = [128]uint8{ 0: uint8(1), } X__syscall3(tls, int32(SYS_sched_getaffinity), int32(Int32FromInt32(0)), Int32FromUint32(Uint32FromInt64(128)), int32(bp+16)) @@ -7696,14 +7696,14 @@ func Xsysconf(tls *TLS, name int32) (r int32) { break } for { - if !((*(*[128]uint8)(unsafe.Pointer(bp + 16)))[i] != 0) { + if !((**(**[128]uint8)(__ccgo_up(bp + 16)))[i] != 0) { break } goto _4 _4: ; v5 = bp + 16 + uintptr(i) - *(*uint8)(unsafe.Pointer(v5)) = uint8(int32(*(*uint8)(unsafe.Pointer(v5))) & (Int32FromUint8((*(*[128]uint8)(unsafe.Pointer(bp + 16)))[i]) - Int32FromInt32(1))) + *(*uint8)(unsafe.Pointer(v5)) = uint8(int32(*(*uint8)(unsafe.Pointer(v5))) & (Int32FromUint8((**(**[128]uint8)(__ccgo_up(bp + 16)))[i]) - Int32FromInt32(1))) cnt = cnt + 1 } goto _2 @@ -7716,15 +7716,15 @@ func Xsysconf(tls *TLS, name int32) (r int32) { fallthrough case (-Int32FromInt32(256) | Int32FromInt32(9)) & Int32FromInt32(255): X__lsysinfo(tls, bp+144) - if !((*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fmem_unit != 0) { - (*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fmem_unit = uint32(1) + if !((**(**Tsysinfo)(__ccgo_up(bp + 144))).Fmem_unit != 0) { + (**(**Tsysinfo)(__ccgo_up(bp + 144))).Fmem_unit = uint32(1) } if name == int32(_SC_PHYS_PAGES) { - mem = uint64((*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Ftotalram) + mem = uint64((**(**Tsysinfo)(__ccgo_up(bp + 144))).Ftotalram) } else { - mem = uint64((*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Ffreeram + (*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fbufferram) + mem = uint64((**(**Tsysinfo)(__ccgo_up(bp + 144))).Ffreeram + (**(**Tsysinfo)(__ccgo_up(bp + 144))).Fbufferram) } - mem = mem * uint64((*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fmem_unit) + mem = mem * uint64((**(**Tsysinfo)(__ccgo_up(bp + 144))).Fmem_unit) mem = mem / uint64(X__libc.Fpage_size) if mem > uint64(0x7fffffff) { v1 = uint64(0x7fffffff) @@ -9124,7 +9124,7 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { for cond := true; cond; cond = dptr < end { v1 = sptr sptr = sptr + 1 - tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = uint32(**(**uint8)(__ccgo_up(v1))) tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) @@ -9136,7 +9136,7 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { c1 = tmp v1 = sptr sptr = sptr + 1 - tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = uint32(**(**uint8)(__ccgo_up(v1))) tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) @@ -9148,13 +9148,13 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { c2 = tmp v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(c1<>int32(4)) + **(**uint8)(__ccgo_up(v1)) = uint8(c1<>int32(4)) if dptr >= end { break } v1 = sptr sptr = sptr + 1 - tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = uint32(**(**uint8)(__ccgo_up(v1))) tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) @@ -9166,13 +9166,13 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { c3 = tmp v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(c2&uint32(0x0F)<>int32(2)) + **(**uint8)(__ccgo_up(v1)) = uint8(c2&uint32(0x0F)<>int32(2)) if dptr >= end { break } v1 = sptr sptr = sptr + 1 - tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = uint32(**(**uint8)(__ccgo_up(v1))) tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) @@ -9184,7 +9184,7 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { c4 = tmp v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(c3&uint32(0x03)<>int32(2)] + **(**uint8)(__ccgo_up(v1)) = _BF_itoa64[c1>>int32(2)] c1 = c1 & uint32(0x03) << int32(4) if sptr >= end { v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] + **(**uint8)(__ccgo_up(v1)) = _BF_itoa64[c1] break } v1 = sptr sptr = sptr + 1 - c2 = uint32(*(*uint8)(unsafe.Pointer(v1))) + c2 = uint32(**(**uint8)(__ccgo_up(v1))) c1 = c1 | c2>>int32(4) v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] + **(**uint8)(__ccgo_up(v1)) = _BF_itoa64[c1] c1 = c2 & uint32(0x0f) << int32(2) if sptr >= end { v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] + **(**uint8)(__ccgo_up(v1)) = _BF_itoa64[c1] break } v1 = sptr sptr = sptr + 1 - c2 = uint32(*(*uint8)(unsafe.Pointer(v1))) + c2 = uint32(**(**uint8)(__ccgo_up(v1))) c1 = c1 | c2>>int32(6) v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] + **(**uint8)(__ccgo_up(v1)) = _BF_itoa64[c1] v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c2&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _BF_itoa64[c2&uint32(0x3f)] } } @@ -9245,11 +9245,11 @@ func _BF_swap(tls *TLS, x uintptr, count int32) { v1 = int32(1) if *(*uint8)(unsafe.Pointer(&v1)) != 0 { for { - tmp = *(*TBF_word)(unsafe.Pointer(x)) + tmp = **(**TBF_word)(__ccgo_up(x)) tmp = tmp<>Int32FromInt32(16) v4 = x x += 4 - *(*TBF_word)(unsafe.Pointer(v4)) = tmp&uint32(0x00FF00FF)<>Int32FromInt32(8)&uint32(0x00FF00FF) + **(**TBF_word)(__ccgo_up(v4)) = tmp&uint32(0x00FF00FF)<>Int32FromInt32(8)&uint32(0x00FF00FF) goto _3 _3: ; @@ -9269,7 +9269,7 @@ func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, e _, _, _, _, _, _, _ = i, ptr, tmp1, tmp2, tmp3, tmp4, v2 ptr = start for cond := true; cond; cond = ptr < end { - L = L ^ *(*TBF_word)(unsafe.Pointer(ctx)) + L = L ^ **(**TBF_word)(__ccgo_up(ctx)) i = 0 for { if !(i < int32(16)) { @@ -9281,12 +9281,12 @@ func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, e tmp3 = L >> int32(16) tmp3 = tmp3 & uint32(0xFF) tmp4 = L >> int32(24) - tmp1 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 3*1024 + uintptr(tmp1)*4)) - tmp2 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 2*1024 + uintptr(tmp2)*4)) - tmp3 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 1*1024 + uintptr(tmp3)*4)) - tmp3 = tmp3 + *(*TBF_word)(unsafe.Pointer(ctx + 72 + uintptr(tmp4)*4)) + tmp1 = **(**TBF_word)(__ccgo_up(ctx + 72 + 3*1024 + uintptr(tmp1)*4)) + tmp2 = **(**TBF_word)(__ccgo_up(ctx + 72 + 2*1024 + uintptr(tmp2)*4)) + tmp3 = **(**TBF_word)(__ccgo_up(ctx + 72 + 1*1024 + uintptr(tmp3)*4)) + tmp3 = tmp3 + **(**TBF_word)(__ccgo_up(ctx + 72 + uintptr(tmp4)*4)) tmp3 = tmp3 ^ tmp2 - R = R ^ *(*TBF_word)(unsafe.Pointer(ctx + uintptr(i+int32(1))*4)) + R = R ^ **(**TBF_word)(__ccgo_up(ctx + uintptr(i+int32(1))*4)) tmp3 = tmp3 + tmp1 R = R ^ tmp3 tmp1 = R & uint32(0xFF) @@ -9295,12 +9295,12 @@ func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, e tmp3 = R >> int32(16) tmp3 = tmp3 & uint32(0xFF) tmp4 = R >> int32(24) - tmp1 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 3*1024 + uintptr(tmp1)*4)) - tmp2 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 2*1024 + uintptr(tmp2)*4)) - tmp3 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 1*1024 + uintptr(tmp3)*4)) - tmp3 = tmp3 + *(*TBF_word)(unsafe.Pointer(ctx + 72 + uintptr(tmp4)*4)) + tmp1 = **(**TBF_word)(__ccgo_up(ctx + 72 + 3*1024 + uintptr(tmp1)*4)) + tmp2 = **(**TBF_word)(__ccgo_up(ctx + 72 + 2*1024 + uintptr(tmp2)*4)) + tmp3 = **(**TBF_word)(__ccgo_up(ctx + 72 + 1*1024 + uintptr(tmp3)*4)) + tmp3 = tmp3 + **(**TBF_word)(__ccgo_up(ctx + 72 + uintptr(tmp4)*4)) tmp3 = tmp3 ^ tmp2 - L = L ^ *(*TBF_word)(unsafe.Pointer(ctx + uintptr(i+int32(1)+int32(1))*4)) + L = L ^ **(**TBF_word)(__ccgo_up(ctx + uintptr(i+int32(1)+int32(1))*4)) tmp3 = tmp3 + tmp1 L = L ^ tmp3 goto _1 @@ -9310,13 +9310,13 @@ func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, e } tmp4 = R R = L - L = tmp4 ^ *(*TBF_word)(unsafe.Pointer(ctx + uintptr(Int32FromInt32(BF_N)+Int32FromInt32(1))*4)) + L = tmp4 ^ **(**TBF_word)(__ccgo_up(ctx + uintptr(Int32FromInt32(BF_N)+Int32FromInt32(1))*4)) v2 = ptr ptr += 4 - *(*TBF_word)(unsafe.Pointer(v2)) = L + **(**TBF_word)(__ccgo_up(v2)) = L v2 = ptr ptr += 4 - *(*TBF_word)(unsafe.Pointer(v2)) = R + **(**TBF_word)(__ccgo_up(v2)) = R } return L } @@ -9376,17 +9376,17 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags break } v1 = Uint32FromInt32(0) - (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)] = v1 - (*(*[2]TBF_word)(unsafe.Pointer(bp)))[0] = v1 + (**(**[2]TBF_word)(__ccgo_up(bp)))[int32(1)] = v1 + (**(**[2]TBF_word)(__ccgo_up(bp)))[0] = v1 j = uint32(0) for { if !(j < uint32(4)) { break } - *(*TBF_word)(unsafe.Pointer(bp)) <<= uint32(8) - *(*TBF_word)(unsafe.Pointer(bp)) |= uint32(*(*uint8)(unsafe.Pointer(ptr))) /* correct */ - *(*TBF_word)(unsafe.Pointer(bp + 1*4)) <<= uint32(8) - *(*TBF_word)(unsafe.Pointer(bp + 1*4)) |= Uint32FromInt8(Int8FromUint8(*(*uint8)(unsafe.Pointer(ptr)))) /* bug */ + **(**TBF_word)(__ccgo_up(bp)) <<= uint32(8) + **(**TBF_word)(__ccgo_up(bp)) |= uint32(uint8(**(**uint8)(__ccgo_up(ptr)))) /* correct */ + **(**TBF_word)(__ccgo_up(bp + 1*4)) <<= uint32(8) + **(**TBF_word)(__ccgo_up(bp + 1*4)) |= Uint32FromInt8(Int8FromUint8(**(**uint8)(__ccgo_up(ptr)))) /* bug */ /* * Sign extension in the first char has no effect - nothing to overwrite yet, * and those extra 24 bits will be fully shifted out of the 32-bit word. For @@ -9394,9 +9394,9 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags * extension in tmp[1] occurs. Once this flag is set, it remains set. */ if j != 0 { - sign = sign | (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)]&uint32(0x80) + sign = sign | (**(**[2]TBF_word)(__ccgo_up(bp)))[int32(1)]&uint32(0x80) } - if !(*(*uint8)(unsafe.Pointer(ptr)) != 0) { + if !(**(**uint8)(__ccgo_up(ptr)) != 0) { ptr = key } else { ptr = ptr + 1 @@ -9406,9 +9406,9 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags ; j = j + 1 } - diff = diff | ((*(*[2]TBF_word)(unsafe.Pointer(bp)))[0] ^ (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)]) /* Non-zero on any differences */ - *(*TBF_word)(unsafe.Pointer(expanded + uintptr(i)*4)) = (*(*[2]TBF_word)(unsafe.Pointer(bp)))[bug] - *(*TBF_word)(unsafe.Pointer(initial + uintptr(i)*4)) = *(*TBF_word)(unsafe.Pointer(uintptr(unsafe.Pointer(&_BF_init_state)) + uintptr(i)*4)) ^ (*(*[2]TBF_word)(unsafe.Pointer(bp)))[bug] + diff = diff | ((**(**[2]TBF_word)(__ccgo_up(bp)))[0] ^ (**(**[2]TBF_word)(__ccgo_up(bp)))[int32(1)]) /* Non-zero on any differences */ + **(**TBF_word)(__ccgo_up(expanded + uintptr(i)*4)) = (**(**[2]TBF_word)(__ccgo_up(bp)))[bug] + **(**TBF_word)(__ccgo_up(initial + uintptr(i)*4)) = **(**TBF_word)(__ccgo_up(uintptr(unsafe.Pointer(&_BF_init_state)) + uintptr(i)*4)) ^ (**(**[2]TBF_word)(__ccgo_up(bp)))[bug] goto _2 _2: ; @@ -9439,7 +9439,7 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags * state that could be directly specified by a password to the buggy algorithm * (and to the fully correct one as well, but that's a side-effect). */ - *(*TBF_word)(unsafe.Pointer(initial)) ^= sign + **(**TBF_word)(__ccgo_up(initial)) ^= sign } var _flags_by_subtype = [26]uint8{ @@ -9466,28 +9466,28 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w } } _, _, _, _, _, _, _, _, _, _, _, _ = L, L1, R, count, done, i, ptr, tmp1, tmp2, tmp3, tmp4, v1 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(setting))) != int32('$') || Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 1))) != int32('2') || Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 2)))-int32('a')) > uint32(25) || !(_flags_by_subtype[Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 2)))-int32('a')] != 0) || Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 3))) != int32('$') || Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 4)))-int32('0')) > uint32(1) || Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 5)))-int32('0')) > uint32(9) || Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 6))) != int32('$') { + if Int32FromUint8(**(**uint8)(__ccgo_up(setting))) != int32('$') || Int32FromUint8(**(**uint8)(__ccgo_up(setting + 1))) != int32('2') || Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(setting + 2)))-int32('a')) > uint32(25) || !(_flags_by_subtype[Int32FromUint8(**(**uint8)(__ccgo_up(setting + 2)))-int32('a')] != 0) || Int32FromUint8(**(**uint8)(__ccgo_up(setting + 3))) != int32('$') || Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(setting + 4)))-int32('0')) > uint32(1) || Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(setting + 5)))-int32('0')) > uint32(9) || Int32FromUint8(**(**uint8)(__ccgo_up(setting + 6))) != int32('$') { return UintptrFromInt32(0) } - count = Uint32FromInt32(1) << ((Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 4)))-int32('0'))*int32(10) + (Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 5))) - int32('0'))) + count = Uint32FromInt32(1) << ((Int32FromUint8(**(**uint8)(__ccgo_up(setting + 4)))-int32('0'))*int32(10) + (Int32FromUint8(**(**uint8)(__ccgo_up(setting + 5))) - int32('0'))) if count < min || _BF_decode(tls, bp+4240, setting+7, int32(16)) != 0 { return UintptrFromInt32(0) } _BF_swap(tls, bp+4240, int32(4)) - _BF_set_key(tls, key, bp+4168, bp, _flags_by_subtype[Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 2)))-int32('a')]) + _BF_set_key(tls, key, bp+4168, bp, _flags_by_subtype[Int32FromUint8(**(**uint8)(__ccgo_up(setting + 2)))-int32('a')]) _memcpy(tls, bp+72, uintptr(unsafe.Pointer(&_BF_init_state))+72, uint32(4096)) L = uint32(0) R = uint32(0) ptr = bp for cond := true; cond; cond = int32(1) != 0 { - L = _BF_encrypt(tls, bp, L^*(*TBF_word)(unsafe.Pointer(bp + 4240)), R^*(*TBF_word)(unsafe.Pointer(bp + 4240 + 1*4)), ptr, ptr) - R = *(*TBF_word)(unsafe.Pointer(ptr + UintptrFromInt32(1)*4)) + L = _BF_encrypt(tls, bp, L^**(**TBF_word)(__ccgo_up(bp + 4240)), R^**(**TBF_word)(__ccgo_up(bp + 4240 + 1*4)), ptr, ptr) + R = **(**TBF_word)(__ccgo_up(ptr + UintptrFromInt32(1)*4)) ptr = ptr + uintptr(2)*4 if ptr >= bp+uintptr(Int32FromInt32(BF_N)+Int32FromInt32(2)+Int32FromInt32(4)*Int32FromInt32(0x100))*4 { break } - L = _BF_encrypt(tls, bp, L^*(*TBF_word)(unsafe.Pointer(bp + 4240 + 2*4)), R^*(*TBF_word)(unsafe.Pointer(bp + 4240 + 3*4)), ptr, ptr) - R = *(*TBF_word)(unsafe.Pointer(ptr + UintptrFromInt32(1)*4)) + L = _BF_encrypt(tls, bp, L^**(**TBF_word)(__ccgo_up(bp + 4240 + 2*4)), R^**(**TBF_word)(__ccgo_up(bp + 4240 + 3*4)), ptr, ptr) + R = **(**TBF_word)(__ccgo_up(ptr + UintptrFromInt32(1)*4)) ptr = ptr + uintptr(2)*4 } for { @@ -9496,8 +9496,8 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w if !(i < Int32FromInt32(BF_N)+Int32FromInt32(2)) { break } - *(*TBF_word)(unsafe.Pointer(bp + uintptr(i)*4)) ^= *(*TBF_word)(unsafe.Pointer(bp + 4168 + uintptr(i)*4)) - *(*TBF_word)(unsafe.Pointer(bp + uintptr(i+int32(1))*4)) ^= *(*TBF_word)(unsafe.Pointer(bp + 4168 + uintptr(i+int32(1))*4)) + **(**TBF_word)(__ccgo_up(bp + uintptr(i)*4)) ^= **(**TBF_word)(__ccgo_up(bp + 4168 + uintptr(i)*4)) + **(**TBF_word)(__ccgo_up(bp + uintptr(i+int32(1))*4)) ^= **(**TBF_word)(__ccgo_up(bp + 4168 + uintptr(i+int32(1))*4)) goto _3 _3: ; @@ -9510,26 +9510,26 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w break } done = int32(1) - tmp1 = *(*TBF_word)(unsafe.Pointer(bp + 4240)) - tmp2 = *(*TBF_word)(unsafe.Pointer(bp + 4240 + 1*4)) - tmp3 = *(*TBF_word)(unsafe.Pointer(bp + 4240 + 2*4)) - tmp4 = *(*TBF_word)(unsafe.Pointer(bp + 4240 + 3*4)) + tmp1 = **(**TBF_word)(__ccgo_up(bp + 4240)) + tmp2 = **(**TBF_word)(__ccgo_up(bp + 4240 + 1*4)) + tmp3 = **(**TBF_word)(__ccgo_up(bp + 4240 + 2*4)) + tmp4 = **(**TBF_word)(__ccgo_up(bp + 4240 + 3*4)) i = 0 for { if !(i < int32(BF_N)) { break } - *(*TBF_word)(unsafe.Pointer(bp + uintptr(i)*4)) ^= tmp1 - *(*TBF_word)(unsafe.Pointer(bp + uintptr(i+int32(1))*4)) ^= tmp2 - *(*TBF_word)(unsafe.Pointer(bp + uintptr(i+int32(2))*4)) ^= tmp3 - *(*TBF_word)(unsafe.Pointer(bp + uintptr(i+int32(3))*4)) ^= tmp4 + **(**TBF_word)(__ccgo_up(bp + uintptr(i)*4)) ^= tmp1 + **(**TBF_word)(__ccgo_up(bp + uintptr(i+int32(1))*4)) ^= tmp2 + **(**TBF_word)(__ccgo_up(bp + uintptr(i+int32(2))*4)) ^= tmp3 + **(**TBF_word)(__ccgo_up(bp + uintptr(i+int32(3))*4)) ^= tmp4 goto _4 _4: ; i = i + int32(4) } - *(*TBF_word)(unsafe.Pointer(bp + 16*4)) ^= tmp1 - *(*TBF_word)(unsafe.Pointer(bp + 17*4)) ^= tmp2 + **(**TBF_word)(__ccgo_up(bp + 16*4)) ^= tmp1 + **(**TBF_word)(__ccgo_up(bp + 17*4)) ^= tmp2 } goto _2 _2: @@ -9546,10 +9546,10 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w break } L1 = _BF_magic_w[i] - (*(*[2]TBF_word)(unsafe.Pointer(bp + 4264)))[int32(1)] = _BF_magic_w[i+int32(1)] + (**(**[2]TBF_word)(__ccgo_up(bp + 4264)))[int32(1)] = _BF_magic_w[i+int32(1)] count = uint32(64) for { - L1 = _BF_encrypt(tls, bp, L1, (*(*[2]TBF_word)(unsafe.Pointer(bp + 4264)))[int32(1)], bp+4264, bp+4264) + L1 = _BF_encrypt(tls, bp, L1, (**(**[2]TBF_word)(__ccgo_up(bp + 4264)))[int32(1)], bp+4264, bp+4264) goto _7 _7: ; @@ -9559,20 +9559,20 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w break } } - *(*TBF_word)(unsafe.Pointer(bp + 4240 + uintptr(i)*4)) = L1 - *(*TBF_word)(unsafe.Pointer(bp + 4240 + uintptr(i+int32(1))*4)) = (*(*[2]TBF_word)(unsafe.Pointer(bp + 4264)))[int32(1)] + **(**TBF_word)(__ccgo_up(bp + 4240 + uintptr(i)*4)) = L1 + **(**TBF_word)(__ccgo_up(bp + 4240 + uintptr(i+int32(1))*4)) = (**(**[2]TBF_word)(__ccgo_up(bp + 4264)))[int32(1)] goto _5 _5: ; i = i + int32(2) } _memcpy(tls, output, setting, Uint32FromInt32(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1))) - *(*uint8)(unsafe.Pointer(output + uintptr(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1)))) = _BF_itoa64[Int32FromUint8(_BF_atoi64[Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1)))))-int32(0x20)])&int32(0x30)] + **(**uint8)(__ccgo_up(output + uintptr(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1)))) = _BF_itoa64[Int32FromUint8(_BF_atoi64[Int32FromUint8(**(**uint8)(__ccgo_up(setting + uintptr(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1)))))-int32(0x20)])&int32(0x30)] /* This has to be bug-compatible with the original implementation, so * only encode 23 of the 24 bytes. :-) */ _BF_swap(tls, bp+4240, int32(6)) _BF_encode(tls, output+uintptr(Int32FromInt32(7)+Int32FromInt32(22)), bp+4240, int32(23)) - *(*uint8)(unsafe.Pointer(output + uintptr(Int32FromInt32(7)+Int32FromInt32(22)+Int32FromInt32(31)))) = uint8('\000') + **(**uint8)(__ccgo_up(output + uintptr(Int32FromInt32(7)+Int32FromInt32(22)+Int32FromInt32(31)))) = uint8('\000') return output } @@ -9631,19 +9631,19 @@ func X__crypt_blowfish(tls *TLS, key uintptr, setting uintptr, output uintptr) ( */ _memcpy(tls, bp, test_setting, uint32(30)) if retval != 0 { - flags = uint32(_flags_by_subtype[Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 2)))-int32('a')]) + flags = uint32(_flags_by_subtype[Int32FromUint8(**(**uint8)(__ccgo_up(setting + 2)))-int32('a')]) test_hash = uintptr(unsafe.Pointer(&_test_hashes)) + uintptr(flags&uint32(1))*34 - *(*uint8)(unsafe.Pointer(bp + 2)) = *(*uint8)(unsafe.Pointer(setting + 2)) + **(**uint8)(__ccgo_up(bp + 2)) = **(**uint8)(__ccgo_up(setting + 2)) } Xmemset(tls, bp+30, int32(0x55), uint32(63)) - *(*uint8)(unsafe.Pointer(bp + 30 + uintptr(Uint32FromInt64(63)-Uint32FromInt32(1)))) = uint8(0) + **(**uint8)(__ccgo_up(bp + 30 + uintptr(Uint32FromInt64(63)-Uint32FromInt32(1)))) = uint8(0) p = _BF_crypt(tls, test_key, bp, bp+30, uint32(1)) ok = BoolInt32(p == bp+30 && !(Xmemcmp(tls, p, bp, Uint32FromInt32(Int32FromInt32(7)+Int32FromInt32(22))) != 0) && !(Xmemcmp(tls, p+uintptr(Int32FromInt32(7)+Int32FromInt32(22)), test_hash, Uint32FromInt32(Int32FromInt32(31)+Int32FromInt32(1)+Int32FromInt32(1)+Int32FromInt32(1))) != 0)) k = __ccgo_ts + 58 - _BF_set_key(tls, k, bp+96, bp+168, uint8(2)) /* $2a$ */ - _BF_set_key(tls, k, bp+240, bp+312, uint8(4)) /* $2y$ */ - *(*TBF_word)(unsafe.Pointer(bp + 168)) ^= uint32(0x10000) /* undo the safety (for comparison) */ - ok = BoolInt32(ok != 0 && (*(*TBF_key)(unsafe.Pointer(bp + 168)))[0] == uint32(0xdb9c59bc) && (*(*TBF_key)(unsafe.Pointer(bp + 240)))[int32(17)] == uint32(0x33343500) && !(Xmemcmp(tls, bp+96, bp+240, uint32(72)) != 0) && !(Xmemcmp(tls, bp+168, bp+312, uint32(72)) != 0)) + _BF_set_key(tls, k, bp+96, bp+168, uint8(2)) /* $2a$ */ + _BF_set_key(tls, k, bp+240, bp+312, uint8(4)) /* $2y$ */ + **(**TBF_word)(__ccgo_up(bp + 168)) ^= uint32(0x10000) /* undo the safety (for comparison) */ + ok = BoolInt32(ok != 0 && (**(**TBF_key)(__ccgo_up(bp + 168)))[0] == uint32(0xdb9c59bc) && (**(**TBF_key)(__ccgo_up(bp + 240)))[int32(17)] == uint32(0x33343500) && !(Xmemcmp(tls, bp+96, bp+240, uint32(72)) != 0) && !(Xmemcmp(tls, bp+168, bp+312, uint32(72)) != 0)) if ok != 0 && retval != 0 { return retval } @@ -11493,8 +11493,8 @@ func X__des_setkey(tls *TLS, key uintptr, ekey uintptr) { var i, ibit, j, round, shifts uint32 var k0, k1, kl, kr, rawkey0, rawkey1, t0, t1, v1 Tuint32_t _, _, _, _, _, _, _, _, _, _, _, _, _, _ = i, ibit, j, k0, k1, kl, kr, rawkey0, rawkey1, round, shifts, t0, t1, v1 - rawkey0 = uint32(*(*uint8)(unsafe.Pointer(key + 3))) | uint32(*(*uint8)(unsafe.Pointer(key + 2)))<>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskl)) + uintptr(i+uint32(4))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4))) - k1 = k1 | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j)*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) + k0 = k0 | (**(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_key_perm_maskl)) + uintptr(i)*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_key_perm_maskl)) + uintptr(i+uint32(4))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4))) + k1 = k1 | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j)*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) ibit = ibit - uint32(4) - k1 = k1 | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j+uint32(1))*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(i+uint32(8))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4))) + k1 = k1 | (**(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j+uint32(1))*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(i+uint32(8))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4))) goto _2 _2: ; @@ -11539,19 +11539,19 @@ func X__des_setkey(tls *TLS, key uintptr, ekey uintptr) { if !(i < uint32(4)) { break } - kl = kl | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskl0)) + uintptr(i)*32 + uintptr(t0>>ibit&uint32(7))*4)) - kr = kr | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskr0)) + uintptr(i)*32 + uintptr(t1>>ibit&uint32(7))*4)) + kl = kl | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_comp_maskl0)) + uintptr(i)*32 + uintptr(t0>>ibit&uint32(7))*4)) + kr = kr | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_comp_maskr0)) + uintptr(i)*32 + uintptr(t1>>ibit&uint32(7))*4)) ibit = ibit - uint32(4) - kl = kl | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskl1)) + uintptr(i)*64 + uintptr(t0>>ibit&uint32(0xf))*4)) - kr = kr | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskr1)) + uintptr(i)*64 + uintptr(t1>>ibit&uint32(0xf))*4)) + kl = kl | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_comp_maskl1)) + uintptr(i)*64 + uintptr(t0>>ibit&uint32(0xf))*4)) + kr = kr | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_comp_maskr1)) + uintptr(i)*64 + uintptr(t1>>ibit&uint32(0xf))*4)) ibit = ibit - uint32(3) goto _5 _5: ; i = i + 1 } - *(*Tuint32_t)(unsafe.Pointer(ekey + uintptr(round)*4)) = kl - *(*Tuint32_t)(unsafe.Pointer(ekey + 64 + uintptr(round)*4)) = kr + **(**Tuint32_t)(__ccgo_up(ekey + uintptr(round)*4)) = kl + **(**Tuint32_t)(__ccgo_up(ekey + 64 + uintptr(round)*4)) = kr goto _3 _3: ; @@ -11585,8 +11585,8 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui if !(i < uint32(8)) { break } - l = l | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4))) - r = r | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4))) + l = l | (**(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4))) + r = r | (**(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4))) goto _2 _2: ; @@ -11624,15 +11624,15 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui f = (r48l ^ r48r) & saltbits v5 = kl kl += 4 - r48l = r48l ^ (f ^ *(*Tuint32_t)(unsafe.Pointer(v5))) + r48l = r48l ^ (f ^ **(**Tuint32_t)(__ccgo_up(v5))) v5 = kr kr += 4 - r48r = r48r ^ (f ^ *(*Tuint32_t)(unsafe.Pointer(v5))) + r48r = r48r ^ (f ^ **(**Tuint32_t)(__ccgo_up(v5))) /* * Do S-box lookups (which shrink it back to 32 bits) * and do the P-box permutation at the same time. */ - f = *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + uintptr(r48l>>int32(18))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 1*256 + uintptr(r48l>>Int32FromInt32(12)&uint32(0x3f))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 2*256 + uintptr(r48l>>Int32FromInt32(6)&uint32(0x3f))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 3*256 + uintptr(r48l&uint32(0x3f))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 4*256 + uintptr(r48r>>int32(18))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 5*256 + uintptr(r48r>>Int32FromInt32(12)&uint32(0x3f))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 6*256 + uintptr(r48r>>Int32FromInt32(6)&uint32(0x3f))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 7*256 + uintptr(r48r&uint32(0x3f))*4)) + f = **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + uintptr(r48l>>int32(18))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 1*256 + uintptr(r48l>>Int32FromInt32(12)&uint32(0x3f))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 2*256 + uintptr(r48l>>Int32FromInt32(6)&uint32(0x3f))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 3*256 + uintptr(r48l&uint32(0x3f))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 4*256 + uintptr(r48r>>int32(18))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 5*256 + uintptr(r48r>>Int32FromInt32(12)&uint32(0x3f))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 6*256 + uintptr(r48r>>Int32FromInt32(6)&uint32(0x3f))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 7*256 + uintptr(r48r&uint32(0x3f))*4)) /* * Now that we've permuted things, complete f(). */ @@ -11655,17 +11655,17 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui if !(i1 < uint32(4)) { break } - ro = ro | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4))) + ro = ro | (**(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4))) ibit1 = ibit1 - uint32(4) - lo = lo | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4))) + lo = lo | (**(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4))) goto _8 _8: ; i1 = i1 + 1 ibit1 = ibit1 - uint32(4) } - *(*Tuint32_t)(unsafe.Pointer(l_out)) = lo - *(*Tuint32_t)(unsafe.Pointer(r_out)) = ro + **(**Tuint32_t)(__ccgo_up(l_out)) = lo + **(**Tuint32_t)(__ccgo_up(r_out)) = ro } func _des_cipher(tls *TLS, in uintptr, out uintptr, count Tuint32_t, saltbits Tuint32_t, ekey uintptr) { @@ -11675,17 +11675,17 @@ func _des_cipher(tls *TLS, in uintptr, out uintptr, count Tuint32_t, saltbits Tu var _ /* l_out at bp+0 */ Tuint32_t var _ /* r_out at bp+4 */ Tuint32_t _, _ = rawl, rawr - rawl = uint32(*(*uint8)(unsafe.Pointer(in + 3))) | uint32(*(*uint8)(unsafe.Pointer(in + 2)))<> int32(24)) - *(*uint8)(unsafe.Pointer(out + 1)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp)) >> int32(16)) - *(*uint8)(unsafe.Pointer(out + 2)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp)) >> int32(8)) - *(*uint8)(unsafe.Pointer(out + 3)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp))) - *(*uint8)(unsafe.Pointer(out + 4)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp + 4)) >> int32(24)) - *(*uint8)(unsafe.Pointer(out + 5)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp + 4)) >> int32(16)) - *(*uint8)(unsafe.Pointer(out + 6)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp + 4)) >> int32(8)) - *(*uint8)(unsafe.Pointer(out + 7)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp + 4))) + **(**uint8)(__ccgo_up(out)) = uint8(**(**Tuint32_t)(__ccgo_up(bp)) >> int32(24)) + **(**uint8)(__ccgo_up(out + 1)) = uint8(**(**Tuint32_t)(__ccgo_up(bp)) >> int32(16)) + **(**uint8)(__ccgo_up(out + 2)) = uint8(**(**Tuint32_t)(__ccgo_up(bp)) >> int32(8)) + **(**uint8)(__ccgo_up(out + 3)) = uint8(**(**Tuint32_t)(__ccgo_up(bp))) + **(**uint8)(__ccgo_up(out + 4)) = uint8(**(**Tuint32_t)(__ccgo_up(bp + 4)) >> int32(24)) + **(**uint8)(__ccgo_up(out + 5)) = uint8(**(**Tuint32_t)(__ccgo_up(bp + 4)) >> int32(16)) + **(**uint8)(__ccgo_up(out + 6)) = uint8(**(**Tuint32_t)(__ccgo_up(bp + 4)) >> int32(8)) + **(**uint8)(__ccgo_up(out + 7)) = uint8(**(**Tuint32_t)(__ccgo_up(bp + 4))) } func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uintptr) (r uintptr) { @@ -11709,13 +11709,13 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin for q <= bp+128+uintptr(Uint32FromInt64(8)-Uint32FromInt32(1)) { v1 = q q = q + 1 - *(*uint8)(unsafe.Pointer(v1)) = Uint8FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(key))) << int32(1)) - if *(*uint8)(unsafe.Pointer(key)) != 0 { + **(**uint8)(__ccgo_up(v1)) = Uint8FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(key))) << int32(1)) + if **(**uint8)(__ccgo_up(key)) != 0 { key = key + 1 } } X__des_setkey(tls, bp+128, bp) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(setting))) == int32('_') { + if Int32FromUint8(**(**uint8)(__ccgo_up(setting))) == int32('_') { /* * "new"-style: * setting - underscore, 4 chars of count, 4 chars of salt @@ -11727,8 +11727,8 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin if !(i < uint32(5)) { break } - value = _ascii_to_bin(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(i))))) - if Int32FromUint8(_ascii64[value]) != Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(i)))) { + value = _ascii_to_bin(tls, Int32FromUint8(**(**uint8)(__ccgo_up(setting + uintptr(i))))) + if Int32FromUint8(_ascii64[value]) != Int32FromUint8(**(**uint8)(__ccgo_up(setting + uintptr(i)))) { return UintptrFromInt32(0) } count = count | value<<((i-uint32(1))*uint32(6)) @@ -11746,8 +11746,8 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin if !(i < uint32(9)) { break } - value1 = _ascii_to_bin(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(i))))) - if Int32FromUint8(_ascii64[value1]) != Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(i)))) { + value1 = _ascii_to_bin(tls, Int32FromUint8(**(**uint8)(__ccgo_up(setting + uintptr(i))))) + if Int32FromUint8(_ascii64[value1]) != Int32FromUint8(**(**uint8)(__ccgo_up(setting + uintptr(i)))) { return UintptrFromInt32(0) } salt = salt | value1<<((i-uint32(5))*uint32(6)) @@ -11756,7 +11756,7 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin ; i = i + 1 } - for *(*uint8)(unsafe.Pointer(key)) != 0 { + for **(**uint8)(__ccgo_up(key)) != 0 { /* * Encrypt the key with itself. */ @@ -11765,18 +11765,18 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin * And XOR with the next 8 characters of the key. */ q = bp + 128 - for q <= bp+128+uintptr(Uint32FromInt64(8)-Uint32FromInt32(1)) && *(*uint8)(unsafe.Pointer(key)) != 0 { + for q <= bp+128+uintptr(Uint32FromInt64(8)-Uint32FromInt32(1)) && **(**uint8)(__ccgo_up(key)) != 0 { v4 = q q = q + 1 v1 = v4 v5 = key key = key + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(int32(*(*uint8)(unsafe.Pointer(v1))) ^ Int32FromUint8(*(*uint8)(unsafe.Pointer(v5)))<> int32(8) + l = **(**Tuint32_t)(__ccgo_up(bp + 136)) >> int32(8) v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l&uint32(0x3f)] - l = *(*Tuint32_t)(unsafe.Pointer(bp + 136))<>Int32FromInt32(16)&uint32(0xffff) + **(**uint8)(__ccgo_up(v1)) = _ascii64[l&uint32(0x3f)] + l = **(**Tuint32_t)(__ccgo_up(bp + 136))<>Int32FromInt32(16)&uint32(0xffff) v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l&uint32(0x3f)] - l = *(*Tuint32_t)(unsafe.Pointer(bp + 140)) << int32(2) + **(**uint8)(__ccgo_up(v1)) = _ascii64[l&uint32(0x3f)] + l = **(**Tuint32_t)(__ccgo_up(bp + 140)) << int32(2) v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l&uint32(0x3f)] - *(*uint8)(unsafe.Pointer(p)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = _ascii64[l&uint32(0x3f)] + **(**uint8)(__ccgo_up(p)) = uint8(0) return output } @@ -11853,7 +11853,7 @@ func X__crypt_des(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uin test_key = __ccgo_ts + 72 test_setting = __ccgo_ts + 93 test_hash = __ccgo_ts + 103 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(setting))) != int32('_') { + if Int32FromUint8(**(**uint8)(__ccgo_up(setting))) != int32('_') { test_setting = __ccgo_ts + 124 test_hash = __ccgo_ts + 127 } @@ -11872,7 +11872,7 @@ func X__crypt_des(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uin if p != 0 && !(Xstrcmp(tls, p, test_hash) != 0) && retval != 0 { return retval } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(setting))) == int32('*') { + if Int32FromUint8(**(**uint8)(__ccgo_up(setting))) == int32('*') { v1 = __ccgo_ts + 141 } else { v1 = __ccgo_ts + 70 @@ -11974,80 +11974,80 @@ func _processblock(tls *TLS, s uintptr, buf uintptr) { if !(i < uint32(16)) { break } - (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] = uint32(*(*Tuint8_t)(unsafe.Pointer(buf + uintptr(uint32(4)*i)))) - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(i)*4)) |= uint32(*(*Tuint8_t)(unsafe.Pointer(buf + uintptr(uint32(4)*i+uint32(1))))) << int32(8) - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(i)*4)) |= uint32(*(*Tuint8_t)(unsafe.Pointer(buf + uintptr(uint32(4)*i+uint32(2))))) << int32(16) - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(i)*4)) |= uint32(*(*Tuint8_t)(unsafe.Pointer(buf + uintptr(uint32(4)*i+uint32(3))))) << int32(24) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[i] = uint32(**(**Tuint8_t)(__ccgo_up(buf + uintptr(uint32(4)*i)))) + **(**Tuint32_t)(__ccgo_up(bp + uintptr(i)*4)) |= uint32(**(**Tuint8_t)(__ccgo_up(buf + uintptr(uint32(4)*i+uint32(1))))) << int32(8) + **(**Tuint32_t)(__ccgo_up(bp + uintptr(i)*4)) |= uint32(**(**Tuint8_t)(__ccgo_up(buf + uintptr(uint32(4)*i+uint32(2))))) << int32(16) + **(**Tuint32_t)(__ccgo_up(bp + uintptr(i)*4)) |= uint32(**(**Tuint8_t)(__ccgo_up(buf + uintptr(uint32(4)*i+uint32(3))))) << int32(24) goto _1 _1: ; i = i + 1 } - a = *(*Tuint32_t)(unsafe.Pointer(s + 8)) - b = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) - c = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 2*4)) - d = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) + a = **(**Tuint32_t)(__ccgo_up(s + 8)) + b = **(**Tuint32_t)(__ccgo_up(s + 8 + 1*4)) + c = **(**Tuint32_t)(__ccgo_up(s + 8 + 2*4)) + d = **(**Tuint32_t)(__ccgo_up(s + 8 + 3*4)) i = uint32(0) for i < uint32(16) { - a = a + (d ^ b&(c^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) + a = a + (d ^ b&(c^d) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[i] + _tab[i]) a = _rol(tls, a, int32(7)) + b i = i + 1 - d = d + (c ^ a&(b^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) + d = d + (c ^ a&(b^c) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[i] + _tab[i]) d = _rol(tls, d, int32(12)) + a i = i + 1 - c = c + (b ^ d&(a^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) + c = c + (b ^ d&(a^b) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[i] + _tab[i]) c = _rol(tls, c, int32(17)) + d i = i + 1 - b = b + (a ^ c&(d^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) + b = b + (a ^ c&(d^a) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[i] + _tab[i]) b = _rol(tls, b, int32(22)) + c i = i + 1 } for i < uint32(32) { - a = a + (c ^ d&(c^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) + a = a + (c ^ d&(c^b) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) a = _rol(tls, a, int32(5)) + b i = i + 1 - d = d + (b ^ c&(b^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) + d = d + (b ^ c&(b^a) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) d = _rol(tls, d, int32(9)) + a i = i + 1 - c = c + (a ^ b&(a^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) + c = c + (a ^ b&(a^d) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) c = _rol(tls, c, int32(14)) + d i = i + 1 - b = b + (d ^ a&(d^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) + b = b + (d ^ a&(d^c) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) b = _rol(tls, b, int32(20)) + c i = i + 1 } for i < uint32(48) { - a = a + (b ^ c ^ d + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) + a = a + (b ^ c ^ d + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) a = _rol(tls, a, int32(4)) + b i = i + 1 - d = d + (a ^ b ^ c + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) + d = d + (a ^ b ^ c + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) d = _rol(tls, d, int32(11)) + a i = i + 1 - c = c + (d ^ a ^ b + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) + c = c + (d ^ a ^ b + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) c = _rol(tls, c, int32(16)) + d i = i + 1 - b = b + (c ^ d ^ a + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) + b = b + (c ^ d ^ a + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) b = _rol(tls, b, int32(23)) + c i = i + 1 } for i < uint32(64) { - a = a + (c ^ (b | ^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) + a = a + (c ^ (b | ^d) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) a = _rol(tls, a, int32(6)) + b i = i + 1 - d = d + (b ^ (a | ^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) + d = d + (b ^ (a | ^c) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) d = _rol(tls, d, int32(10)) + a i = i + 1 - c = c + (a ^ (d | ^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) + c = c + (a ^ (d | ^b) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) c = _rol(tls, c, int32(15)) + d i = i + 1 - b = b + (d ^ (c | ^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) + b = b + (d ^ (c | ^a) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) b = _rol(tls, b, int32(21)) + c i = i + 1 } - *(*Tuint32_t)(unsafe.Pointer(s + 8)) += a - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) += b - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 2*4)) += c - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) += d + **(**Tuint32_t)(__ccgo_up(s + 8)) += a + **(**Tuint32_t)(__ccgo_up(s + 8 + 1*4)) += b + **(**Tuint32_t)(__ccgo_up(s + 8 + 2*4)) += c + **(**Tuint32_t)(__ccgo_up(s + 8 + 3*4)) += d } func _pad(tls *TLS, s uintptr) { @@ -12056,31 +12056,31 @@ func _pad(tls *TLS, s uintptr) { r = uint32((*Tmd5)(unsafe.Pointer(s)).Flen1 % uint64(64)) v1 = r r = r + 1 - *(*Tuint8_t)(unsafe.Pointer(s + 24 + uintptr(v1))) = uint8(0x80) + **(**Tuint8_t)(__ccgo_up(s + 24 + uintptr(v1))) = uint8(0x80) if r > uint32(56) { Xmemset(tls, s+24+uintptr(r), 0, uint32(64)-r) r = uint32(0) _processblock(tls, s, s+24) } Xmemset(tls, s+24+uintptr(r), 0, uint32(56)-r) - *(*Tuint64_t)(unsafe.Pointer(s)) *= uint64(8) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 56)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 57)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(8)) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 58)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(16)) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 59)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(24)) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 60)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(32)) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 61)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(40)) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 62)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(48)) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 63)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(56)) + **(**Tuint64_t)(__ccgo_up(s)) *= uint64(8) + **(**Tuint8_t)(__ccgo_up(s + 24 + 56)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1) + **(**Tuint8_t)(__ccgo_up(s + 24 + 57)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(8)) + **(**Tuint8_t)(__ccgo_up(s + 24 + 58)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(16)) + **(**Tuint8_t)(__ccgo_up(s + 24 + 59)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(24)) + **(**Tuint8_t)(__ccgo_up(s + 24 + 60)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(32)) + **(**Tuint8_t)(__ccgo_up(s + 24 + 61)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(40)) + **(**Tuint8_t)(__ccgo_up(s + 24 + 62)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(48)) + **(**Tuint8_t)(__ccgo_up(s + 24 + 63)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(56)) _processblock(tls, s, s+24) } func _md5_init(tls *TLS, s uintptr) { (*Tmd5)(unsafe.Pointer(s)).Flen1 = uint64(0) - *(*Tuint32_t)(unsafe.Pointer(s + 8)) = uint32(0x67452301) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) = uint32(0xefcdab89) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 2*4)) = uint32(0x98badcfe) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) = uint32(0x10325476) + **(**Tuint32_t)(__ccgo_up(s + 8)) = uint32(0x67452301) + **(**Tuint32_t)(__ccgo_up(s + 8 + 1*4)) = uint32(0xefcdab89) + **(**Tuint32_t)(__ccgo_up(s + 8 + 2*4)) = uint32(0x98badcfe) + **(**Tuint32_t)(__ccgo_up(s + 8 + 3*4)) = uint32(0x10325476) } func _md5_sum(tls *TLS, s uintptr, md uintptr) { @@ -12092,10 +12092,10 @@ func _md5_sum(tls *TLS, s uintptr, md uintptr) { if !(i < int32(4)) { break } - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4))) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i+int32(1)))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4)) >> int32(8)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i+int32(2)))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4)) >> int32(16)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i+int32(3)))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4)) >> int32(24)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4))) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i+int32(1)))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4)) >> int32(8)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i+int32(2)))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4)) >> int32(16)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i+int32(3)))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4)) >> int32(24)) goto _1 _1: ; @@ -12109,7 +12109,7 @@ func _md5_update(tls *TLS, s uintptr, m uintptr, len1 uint32) { _, _ = p, r p = m r = uint32((*Tmd5)(unsafe.Pointer(s)).Flen1 % uint64(64)) - *(*Tuint64_t)(unsafe.Pointer(s)) += uint64(len1) + **(**Tuint64_t)(__ccgo_up(s)) += uint64(len1) if r != 0 { if len1 < uint32(64)-r { _memcpy(tls, s+24+uintptr(r), p, len1) @@ -12176,7 +12176,7 @@ func _to64(tls *TLS, s uintptr, u uint32, n int32) (r uintptr) { } v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = _b64[u%uint32(64)] + **(**uint8)(__ccgo_up(v2)) = _b64[u%uint32(64)] u = u / uint32(64) } return s @@ -12202,7 +12202,7 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt salt = setting + uintptr(3) i = uint32(0) for { - if !(i < uint32(SALT_MAX) && *(*uint8)(unsafe.Pointer(salt + uintptr(i))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(salt + uintptr(i)))) != int32('$')) { + if !(i < uint32(SALT_MAX) && **(**uint8)(__ccgo_up(salt + uintptr(i))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(salt + uintptr(i)))) != int32('$')) { break } goto _1 @@ -12233,7 +12233,7 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt i = i - uint32(16) } _md5_update(tls, bp, bp+88, i) - (*(*[16]uint8)(unsafe.Pointer(bp + 88)))[0] = uint8(0) + (**(**[16]uint8)(__ccgo_up(bp + 88)))[0] = uint8(0) i = klen for { if !(i != 0) { @@ -12284,20 +12284,20 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt p = output + uintptr(3) + uintptr(slen) v5 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v5)) = uint8('$') + **(**uint8)(__ccgo_up(v5)) = uint8('$') i = uint32(0) for { if !(i < uint32(5)) { break } - p = _to64(tls, p, Uint32FromInt32(Int32FromUint8((*(*[16]uint8)(unsafe.Pointer(bp + 88)))[*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_perm)) + uintptr(i)*3))])<>Int32FromInt32(10) + (*(*[64]Tuint32_t)(unsafe.Pointer(bp)))[i-int32(7)] + (_ror(tls, (*(*[64]Tuint32_t)(unsafe.Pointer(bp)))[i-int32(15)], int32(7)) ^ _ror(tls, (*(*[64]Tuint32_t)(unsafe.Pointer(bp)))[i-int32(15)], int32(18)) ^ (*(*[64]Tuint32_t)(unsafe.Pointer(bp)))[i-int32(15)]>>Int32FromInt32(3)) + (*(*[64]Tuint32_t)(unsafe.Pointer(bp)))[i-int32(16)] + (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i] = _ror(tls, (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(2)], int32(17)) ^ _ror(tls, (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(2)], int32(19)) ^ (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(2)]>>Int32FromInt32(10) + (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(7)] + (_ror(tls, (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(15)], int32(7)) ^ _ror(tls, (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(15)], int32(18)) ^ (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(15)]>>Int32FromInt32(3)) + (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(16)] goto _2 _2: ; i = i + 1 } - a = *(*Tuint32_t)(unsafe.Pointer(s + 8)) - b = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) - c = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 2*4)) - d = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) - e = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 4*4)) - f = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 5*4)) - g = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 6*4)) - h = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 7*4)) + a = **(**Tuint32_t)(__ccgo_up(s + 8)) + b = **(**Tuint32_t)(__ccgo_up(s + 8 + 1*4)) + c = **(**Tuint32_t)(__ccgo_up(s + 8 + 2*4)) + d = **(**Tuint32_t)(__ccgo_up(s + 8 + 3*4)) + e = **(**Tuint32_t)(__ccgo_up(s + 8 + 4*4)) + f = **(**Tuint32_t)(__ccgo_up(s + 8 + 5*4)) + g = **(**Tuint32_t)(__ccgo_up(s + 8 + 6*4)) + h = **(**Tuint32_t)(__ccgo_up(s + 8 + 7*4)) i = 0 for { if !(i < int32(64)) { break } - t1 = h + (_ror(tls, e, int32(6)) ^ _ror(tls, e, int32(11)) ^ _ror(tls, e, int32(25))) + (g ^ e&(f^g)) + _K[i] + (*(*[64]Tuint32_t)(unsafe.Pointer(bp)))[i] + t1 = h + (_ror(tls, e, int32(6)) ^ _ror(tls, e, int32(11)) ^ _ror(tls, e, int32(25))) + (g ^ e&(f^g)) + _K[i] + (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i] t2 = _ror(tls, a, int32(2)) ^ _ror(tls, a, int32(13)) ^ _ror(tls, a, int32(22)) + (a&b | c&(a|b)) h = g g = f @@ -12535,14 +12535,14 @@ func _processblock1(tls *TLS, s uintptr, buf uintptr) { ; i = i + 1 } - *(*Tuint32_t)(unsafe.Pointer(s + 8)) += a - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) += b - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 2*4)) += c - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) += d - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 4*4)) += e - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 5*4)) += f - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 6*4)) += g - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 7*4)) += h + **(**Tuint32_t)(__ccgo_up(s + 8)) += a + **(**Tuint32_t)(__ccgo_up(s + 8 + 1*4)) += b + **(**Tuint32_t)(__ccgo_up(s + 8 + 2*4)) += c + **(**Tuint32_t)(__ccgo_up(s + 8 + 3*4)) += d + **(**Tuint32_t)(__ccgo_up(s + 8 + 4*4)) += e + **(**Tuint32_t)(__ccgo_up(s + 8 + 5*4)) += f + **(**Tuint32_t)(__ccgo_up(s + 8 + 6*4)) += g + **(**Tuint32_t)(__ccgo_up(s + 8 + 7*4)) += h } func _pad1(tls *TLS, s uintptr) { @@ -12551,35 +12551,35 @@ func _pad1(tls *TLS, s uintptr) { r = uint32((*Tsha256)(unsafe.Pointer(s)).Flen1 % uint64(64)) v1 = r r = r + 1 - *(*Tuint8_t)(unsafe.Pointer(s + 40 + uintptr(v1))) = uint8(0x80) + **(**Tuint8_t)(__ccgo_up(s + 40 + uintptr(v1))) = uint8(0x80) if r > uint32(56) { Xmemset(tls, s+40+uintptr(r), 0, uint32(64)-r) r = uint32(0) _processblock1(tls, s, s+40) } Xmemset(tls, s+40+uintptr(r), 0, uint32(56)-r) - *(*Tuint64_t)(unsafe.Pointer(s)) *= uint64(8) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 56)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(56)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 57)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(48)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 58)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(40)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 59)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(32)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 60)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(24)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 61)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(16)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 62)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(8)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 63)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1) + **(**Tuint64_t)(__ccgo_up(s)) *= uint64(8) + **(**Tuint8_t)(__ccgo_up(s + 40 + 56)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(56)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 57)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(48)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 58)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(40)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 59)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(32)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 60)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(24)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 61)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(16)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 62)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(8)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 63)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1) _processblock1(tls, s, s+40) } func _sha256_init(tls *TLS, s uintptr) { (*Tsha256)(unsafe.Pointer(s)).Flen1 = uint64(0) - *(*Tuint32_t)(unsafe.Pointer(s + 8)) = uint32(0x6a09e667) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) = uint32(0xbb67ae85) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 2*4)) = uint32(0x3c6ef372) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) = uint32(0xa54ff53a) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 4*4)) = uint32(0x510e527f) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 5*4)) = uint32(0x9b05688c) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 6*4)) = uint32(0x1f83d9ab) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 7*4)) = uint32(0x5be0cd19) + **(**Tuint32_t)(__ccgo_up(s + 8)) = uint32(0x6a09e667) + **(**Tuint32_t)(__ccgo_up(s + 8 + 1*4)) = uint32(0xbb67ae85) + **(**Tuint32_t)(__ccgo_up(s + 8 + 2*4)) = uint32(0x3c6ef372) + **(**Tuint32_t)(__ccgo_up(s + 8 + 3*4)) = uint32(0xa54ff53a) + **(**Tuint32_t)(__ccgo_up(s + 8 + 4*4)) = uint32(0x510e527f) + **(**Tuint32_t)(__ccgo_up(s + 8 + 5*4)) = uint32(0x9b05688c) + **(**Tuint32_t)(__ccgo_up(s + 8 + 6*4)) = uint32(0x1f83d9ab) + **(**Tuint32_t)(__ccgo_up(s + 8 + 7*4)) = uint32(0x5be0cd19) } func _sha256_sum(tls *TLS, s uintptr, md uintptr) { @@ -12591,10 +12591,10 @@ func _sha256_sum(tls *TLS, s uintptr, md uintptr) { if !(i < int32(8)) { break } - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4)) >> int32(24)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i+int32(1)))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4)) >> int32(16)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i+int32(2)))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4)) >> int32(8)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i+int32(3)))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4))) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4)) >> int32(24)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i+int32(1)))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4)) >> int32(16)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i+int32(2)))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4)) >> int32(8)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i+int32(3)))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4))) goto _1 _1: ; @@ -12608,7 +12608,7 @@ func _sha256_update(tls *TLS, s uintptr, m uintptr, len1 uint32) { _, _ = p, r p = m r = uint32((*Tsha256)(unsafe.Pointer(s)).Flen1 % uint64(64)) - *(*Tuint64_t)(unsafe.Pointer(s)) += uint64(len1) + **(**Tuint64_t)(__ccgo_up(s)) += uint64(len1) if r != 0 { if len1 < uint32(64)-r { _memcpy(tls, s+40+uintptr(r), p, len1) @@ -12647,7 +12647,7 @@ func _to641(tls *TLS, s uintptr, u uint32, n int32) (r uintptr) { } v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = _b641[u%uint32(64)] + **(**uint8)(__ccgo_up(v2)) = _b641[u%uint32(64)] u = u / uint32(64) } return s @@ -12689,7 +12689,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui var _ /* rounds at bp+200 */ [20]uint8 var _ /* smd at bp+168 */ [32]uint8 _, _, _, _, _, _, _ = i, klen, p, r, salt, slen, u - *(*[20]uint8)(unsafe.Pointer(bp + 200)) = [20]uint8{} + **(**[20]uint8)(__ccgo_up(bp + 200)) = [20]uint8{} /* reject large keys */ klen = Xstrnlen(tls, key, Uint32FromInt32(Int32FromInt32(KEY_MAX1)+Int32FromInt32(1))) if klen > uint32(KEY_MAX1) { @@ -12715,14 +12715,14 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui * the host's value of ULONG_MAX. */ salt = salt + uintptr(Uint32FromInt64(8)-Uint32FromInt32(1)) - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(salt)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(salt)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } u = Xstrtoul(tls, salt, bp+220, int32(10)) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 220))))) != int32('$') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 220))))) != int32('$') { return uintptr(0) } - salt = *(*uintptr)(unsafe.Pointer(bp + 220)) + uintptr(1) + salt = **(**uintptr)(__ccgo_up(bp + 220)) + uintptr(1) if u < uint32(ROUNDS_MIN) { r = uint32(ROUNDS_MIN) } else { @@ -12737,11 +12737,11 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui } i = uint32(0) for { - if !(i < uint32(SALT_MAX1) && *(*uint8)(unsafe.Pointer(salt + uintptr(i))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(salt + uintptr(i)))) != int32('$')) { + if !(i < uint32(SALT_MAX1) && **(**uint8)(__ccgo_up(salt + uintptr(i))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(salt + uintptr(i)))) != int32('$')) { break } /* reject characters that interfere with /etc/shadow parsing */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(salt + uintptr(i)))) == int32('\n') || Int32FromUint8(*(*uint8)(unsafe.Pointer(salt + uintptr(i)))) == int32(':') { + if Int32FromUint8(**(**uint8)(__ccgo_up(salt + uintptr(i)))) == int32('\n') || Int32FromUint8(**(**uint8)(__ccgo_up(salt + uintptr(i)))) == int32(':') { return uintptr(0) } goto _1 @@ -12795,7 +12795,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui _sha256_init(tls, bp) i = uint32(0) for { - if !(i < Uint32FromInt32(int32(16)+Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp + 104)))[0]))) { + if !(i < Uint32FromInt32(int32(16)+Int32FromUint8((**(**[32]uint8)(__ccgo_up(bp + 104)))[0]))) { break } _sha256_update(tls, bp, salt, slen) @@ -12842,14 +12842,14 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui if !(i < uint32(10)) { break } - p = _to641(tls, p, Uint32FromInt32(Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp + 104)))[*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_perm1)) + uintptr(i)*3))])<>Int32FromInt32(6) + (*(*[80]Tuint64_t)(unsafe.Pointer(bp)))[i-int32(7)] + (_ror1(tls, (*(*[80]Tuint64_t)(unsafe.Pointer(bp)))[i-int32(15)], int32(1)) ^ _ror1(tls, (*(*[80]Tuint64_t)(unsafe.Pointer(bp)))[i-int32(15)], int32(8)) ^ (*(*[80]Tuint64_t)(unsafe.Pointer(bp)))[i-int32(15)]>>Int32FromInt32(7)) + (*(*[80]Tuint64_t)(unsafe.Pointer(bp)))[i-int32(16)] + (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i] = _ror1(tls, (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(2)], int32(19)) ^ _ror1(tls, (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(2)], int32(61)) ^ (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(2)]>>Int32FromInt32(6) + (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(7)] + (_ror1(tls, (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(15)], int32(1)) ^ _ror1(tls, (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(15)], int32(8)) ^ (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(15)]>>Int32FromInt32(7)) + (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(16)] goto _2 _2: ; i = i + 1 } - a = *(*Tuint64_t)(unsafe.Pointer(s + 8)) - b = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 1*8)) - c = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 2*8)) - d = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 3*8)) - e = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 4*8)) - f = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 5*8)) - g = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 6*8)) - h = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 7*8)) + a = **(**Tuint64_t)(__ccgo_up(s + 8)) + b = **(**Tuint64_t)(__ccgo_up(s + 8 + 1*8)) + c = **(**Tuint64_t)(__ccgo_up(s + 8 + 2*8)) + d = **(**Tuint64_t)(__ccgo_up(s + 8 + 3*8)) + e = **(**Tuint64_t)(__ccgo_up(s + 8 + 4*8)) + f = **(**Tuint64_t)(__ccgo_up(s + 8 + 5*8)) + g = **(**Tuint64_t)(__ccgo_up(s + 8 + 6*8)) + h = **(**Tuint64_t)(__ccgo_up(s + 8 + 7*8)) i = 0 for { if !(i < int32(80)) { break } - t1 = h + (_ror1(tls, e, int32(14)) ^ _ror1(tls, e, int32(18)) ^ _ror1(tls, e, int32(41))) + (g ^ e&(f^g)) + _K1[i] + (*(*[80]Tuint64_t)(unsafe.Pointer(bp)))[i] + t1 = h + (_ror1(tls, e, int32(14)) ^ _ror1(tls, e, int32(18)) ^ _ror1(tls, e, int32(41))) + (g ^ e&(f^g)) + _K1[i] + (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i] t2 = _ror1(tls, a, int32(28)) ^ _ror1(tls, a, int32(34)) ^ _ror1(tls, a, int32(39)) + (a&b | c&(a|b)) h = g g = f @@ -13090,14 +13090,14 @@ func _processblock2(tls *TLS, s uintptr, buf uintptr) { ; i = i + 1 } - *(*Tuint64_t)(unsafe.Pointer(s + 8)) += a - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 1*8)) += b - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 2*8)) += c - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 3*8)) += d - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 4*8)) += e - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 5*8)) += f - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 6*8)) += g - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 7*8)) += h + **(**Tuint64_t)(__ccgo_up(s + 8)) += a + **(**Tuint64_t)(__ccgo_up(s + 8 + 1*8)) += b + **(**Tuint64_t)(__ccgo_up(s + 8 + 2*8)) += c + **(**Tuint64_t)(__ccgo_up(s + 8 + 3*8)) += d + **(**Tuint64_t)(__ccgo_up(s + 8 + 4*8)) += e + **(**Tuint64_t)(__ccgo_up(s + 8 + 5*8)) += f + **(**Tuint64_t)(__ccgo_up(s + 8 + 6*8)) += g + **(**Tuint64_t)(__ccgo_up(s + 8 + 7*8)) += h } func _pad2(tls *TLS, s uintptr) { @@ -13106,35 +13106,35 @@ func _pad2(tls *TLS, s uintptr) { r = uint32((*Tsha512)(unsafe.Pointer(s)).Flen1 % uint64(128)) v1 = r r = r + 1 - *(*Tuint8_t)(unsafe.Pointer(s + 72 + uintptr(v1))) = uint8(0x80) + **(**Tuint8_t)(__ccgo_up(s + 72 + uintptr(v1))) = uint8(0x80) if r > uint32(112) { Xmemset(tls, s+72+uintptr(r), 0, uint32(128)-r) r = uint32(0) _processblock2(tls, s, s+72) } Xmemset(tls, s+72+uintptr(r), 0, uint32(120)-r) - *(*Tuint64_t)(unsafe.Pointer(s)) *= uint64(8) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 120)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(56)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 121)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(48)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 122)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(40)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 123)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(32)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 124)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(24)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 125)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(16)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 126)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(8)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 127)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1) + **(**Tuint64_t)(__ccgo_up(s)) *= uint64(8) + **(**Tuint8_t)(__ccgo_up(s + 72 + 120)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(56)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 121)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(48)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 122)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(40)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 123)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(32)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 124)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(24)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 125)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(16)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 126)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(8)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 127)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1) _processblock2(tls, s, s+72) } func _sha512_init(tls *TLS, s uintptr) { (*Tsha512)(unsafe.Pointer(s)).Flen1 = uint64(0) - *(*Tuint64_t)(unsafe.Pointer(s + 8)) = uint64(0x6a09e667f3bcc908) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 1*8)) = uint64(0xbb67ae8584caa73b) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 2*8)) = uint64(0x3c6ef372fe94f82b) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 3*8)) = uint64(0xa54ff53a5f1d36f1) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 4*8)) = uint64(0x510e527fade682d1) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 5*8)) = uint64(0x9b05688c2b3e6c1f) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 6*8)) = uint64(0x1f83d9abfb41bd6b) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 7*8)) = uint64(0x5be0cd19137e2179) + **(**Tuint64_t)(__ccgo_up(s + 8)) = uint64(0x6a09e667f3bcc908) + **(**Tuint64_t)(__ccgo_up(s + 8 + 1*8)) = uint64(0xbb67ae8584caa73b) + **(**Tuint64_t)(__ccgo_up(s + 8 + 2*8)) = uint64(0x3c6ef372fe94f82b) + **(**Tuint64_t)(__ccgo_up(s + 8 + 3*8)) = uint64(0xa54ff53a5f1d36f1) + **(**Tuint64_t)(__ccgo_up(s + 8 + 4*8)) = uint64(0x510e527fade682d1) + **(**Tuint64_t)(__ccgo_up(s + 8 + 5*8)) = uint64(0x9b05688c2b3e6c1f) + **(**Tuint64_t)(__ccgo_up(s + 8 + 6*8)) = uint64(0x1f83d9abfb41bd6b) + **(**Tuint64_t)(__ccgo_up(s + 8 + 7*8)) = uint64(0x5be0cd19137e2179) } func _sha512_sum(tls *TLS, s uintptr, md uintptr) { @@ -13146,14 +13146,14 @@ func _sha512_sum(tls *TLS, s uintptr, md uintptr) { if !(i < int32(8)) { break } - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(56)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(1)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(48)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(2)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(40)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(3)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(32)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(4)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(24)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(5)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(16)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(6)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(8)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(7)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8))) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(56)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(1)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(48)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(2)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(40)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(3)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(32)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(4)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(24)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(5)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(16)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(6)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(8)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(7)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8))) goto _1 _1: ; @@ -13167,7 +13167,7 @@ func _sha512_update(tls *TLS, s uintptr, m uintptr, len1 uint32) { _, _ = p, r p = m r = uint32((*Tsha512)(unsafe.Pointer(s)).Flen1 % uint64(128)) - *(*Tuint64_t)(unsafe.Pointer(s)) += uint64(len1) + **(**Tuint64_t)(__ccgo_up(s)) += uint64(len1) if r != 0 { if len1 < uint32(128)-r { _memcpy(tls, s+72+uintptr(r), p, len1) @@ -13206,7 +13206,7 @@ func _to642(tls *TLS, s uintptr, u uint32, n int32) (r uintptr) { } v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = _b642[u%uint32(64)] + **(**uint8)(__ccgo_up(v2)) = _b642[u%uint32(64)] u = u / uint32(64) } return s @@ -13248,11 +13248,11 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui var _ /* rounds at bp+392 */ [20]uint8 var _ /* smd at bp+328 */ [64]uint8 _, _, _, _, _, _, _ = i, klen, p, r, salt, slen, u - *(*[20]uint8)(unsafe.Pointer(bp + 392)) = [20]uint8{} + **(**[20]uint8)(__ccgo_up(bp + 392)) = [20]uint8{} /* reject large keys */ i = uint32(0) for { - if !(i <= uint32(KEY_MAX1) && *(*uint8)(unsafe.Pointer(key + uintptr(i))) != 0) { + if !(i <= uint32(KEY_MAX1) && **(**uint8)(__ccgo_up(key + uintptr(i))) != 0) { break } goto _1 @@ -13284,14 +13284,14 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui * the host's value of ULONG_MAX. */ salt = salt + uintptr(Uint32FromInt64(8)-Uint32FromInt32(1)) - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(salt)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(salt)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } u = Xstrtoul(tls, salt, bp+412, int32(10)) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 412))))) != int32('$') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 412))))) != int32('$') { return uintptr(0) } - salt = *(*uintptr)(unsafe.Pointer(bp + 412)) + uintptr(1) + salt = **(**uintptr)(__ccgo_up(bp + 412)) + uintptr(1) if u < uint32(ROUNDS_MIN) { r = uint32(ROUNDS_MIN) } else { @@ -13306,11 +13306,11 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui } i = uint32(0) for { - if !(i < uint32(SALT_MAX1) && *(*uint8)(unsafe.Pointer(salt + uintptr(i))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(salt + uintptr(i)))) != int32('$')) { + if !(i < uint32(SALT_MAX1) && **(**uint8)(__ccgo_up(salt + uintptr(i))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(salt + uintptr(i)))) != int32('$')) { break } /* reject characters that interfere with /etc/shadow parsing */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(salt + uintptr(i)))) == int32('\n') || Int32FromUint8(*(*uint8)(unsafe.Pointer(salt + uintptr(i)))) == int32(':') { + if Int32FromUint8(**(**uint8)(__ccgo_up(salt + uintptr(i)))) == int32('\n') || Int32FromUint8(**(**uint8)(__ccgo_up(salt + uintptr(i)))) == int32(':') { return uintptr(0) } goto _2 @@ -13364,7 +13364,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui _sha512_init(tls, bp) i = uint32(0) for { - if !(i < Uint32FromInt32(int32(16)+Int32FromUint8((*(*[64]uint8)(unsafe.Pointer(bp + 200)))[0]))) { + if !(i < Uint32FromInt32(int32(16)+Int32FromUint8((**(**[64]uint8)(__ccgo_up(bp + 200)))[0]))) { break } _sha512_update(tls, bp, salt, slen) @@ -13411,14 +13411,14 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui if !(i < uint32(21)) { break } - p = _to642(tls, p, Uint32FromInt32(Int32FromUint8((*(*[64]uint8)(unsafe.Pointer(bp + 200)))[*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_perm2)) + uintptr(i)*3))])<= 0) { break } v3 = bp + uintptr(i) - *(*uint8)(unsafe.Pointer(v3)) = uint8(uint32(*(*uint8)(unsafe.Pointer(v3))) | Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(key)))&Int32FromInt32(1))<= 0) { break } - *(*Tuint32_t)(unsafe.Pointer(bp + 128 + uintptr(i)*4)) |= Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))&Int32FromInt32(1)) << j + **(**Tuint32_t)(__ccgo_up(bp + 128 + uintptr(i)*4)) |= Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(p)))&Int32FromInt32(1)) << j goto _2 _2: ; @@ -13636,15 +13636,15 @@ func Xencrypt(tls *TLS, block uintptr, edflag int32) { if !(i < int32(16)) { break } - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(i)*4)) = *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&___encrypt_key)) + uintptr(int32(15)-i)*4)) - *(*Tuint32_t)(unsafe.Pointer(bp + 64 + uintptr(i)*4)) = *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&___encrypt_key)) + 64 + uintptr(int32(15)-i)*4)) + **(**Tuint32_t)(__ccgo_up(bp + uintptr(i)*4)) = **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&___encrypt_key)) + uintptr(int32(15)-i)*4)) + **(**Tuint32_t)(__ccgo_up(bp + 64 + uintptr(i)*4)) = **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&___encrypt_key)) + 64 + uintptr(int32(15)-i)*4)) goto _3 _3: ; i = i + 1 } } - X__do_des(tls, (*(*[2]Tuint32_t)(unsafe.Pointer(bp + 128)))[0], (*(*[2]Tuint32_t)(unsafe.Pointer(bp + 128)))[int32(1)], bp+128, bp+128+uintptr(1)*4, uint32(1), uint32(0), key) + X__do_des(tls, (**(**[2]Tuint32_t)(__ccgo_up(bp + 128)))[0], (**(**[2]Tuint32_t)(__ccgo_up(bp + 128)))[int32(1)], bp+128, bp+128+uintptr(1)*4, uint32(1), uint32(0), key) p = block i = 0 for { @@ -13658,7 +13658,7 @@ func Xencrypt(tls *TLS, block uintptr, edflag int32) { } v6 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v6)) = uint8((*(*[2]Tuint32_t)(unsafe.Pointer(bp + 128)))[i] >> j & uint32(1)) + **(**uint8)(__ccgo_up(v6)) = uint8((**(**[2]Tuint32_t)(__ccgo_up(bp + 128)))[i] >> j & uint32(1)) goto _5 _5: ; @@ -14140,7 +14140,7 @@ func X__ctype_get_mb_cur_max(tls *TLS) (r Tsize_t) { } var v1 int32 _ = v1 - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v1 = int32(4) } else { v1 = int32(1) @@ -17704,10 +17704,10 @@ func Xwctype(tls *TLS, s uintptr) (r Twctype_t) { i = int32(1) p = uintptr(unsafe.Pointer(&_names)) for { - if !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if !(**(**uint8)(__ccgo_up(p)) != 0) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) && !(Xstrcmp(tls, s, p) != 0) { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == Int32FromUint8(**(**uint8)(__ccgo_up(p))) && !(Xstrcmp(tls, s, p) != 0) { return Uint32FromInt32(i) } goto _1 @@ -22453,9 +22453,9 @@ func _casemap(tls *TLS, c uint32, dir int32) (r1 int32) { xn = Uint32FromInt32(rd & int32(0xff)) xb = Uint32FromInt32(rd) >> int32(8) for xn != 0 { - try = uint32(*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_exceptions)) + uintptr(xb+xn/uint32(2))*2))) + try = uint32(**(**uint8)(__ccgo_up(uintptr(unsafe.Pointer(&_exceptions)) + uintptr(xb+xn/uint32(2))*2))) if try == c { - r = _rules[*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_exceptions)) + uintptr(xb+xn/uint32(2))*2 + 1))] + r = _rules[**(**uint8)(__ccgo_up(uintptr(unsafe.Pointer(&_exceptions)) + uintptr(xb+xn/uint32(2))*2 + 1))] rt = Uint32FromInt32(r & int32(255)) rd = r >> int32(8) if rt < uint32(2) { @@ -22548,8 +22548,8 @@ func Xwcswidth(tls *TLS, wcs uintptr, n Tsize_t) (r int32) { for { v2 = n n = n - 1 - if v4 = v2 != 0 && *(*Twchar_t)(unsafe.Pointer(wcs)) != 0; v4 { - v3 = Xwcwidth(tls, *(*Twchar_t)(unsafe.Pointer(wcs))) + if v4 = v2 != 0 && **(**Twchar_t)(__ccgo_up(wcs)) != 0; v4 { + v3 = Xwcwidth(tls, **(**Twchar_t)(__ccgo_up(wcs))) k = v3 } if !(v4 && v3 >= 0) { @@ -24751,7 +24751,7 @@ func Xalphasort(tls *TLS, a uintptr, b uintptr) (r int32) { trc("tls=%v a=%v b=%v, (%v:)", tls, a, b, origin(2)) defer func() { trc("-> %v", r) }() } - return Xstrcoll(tls, *(*uintptr)(unsafe.Pointer(a))+19, *(*uintptr)(unsafe.Pointer(b))+19) + return Xstrcoll(tls, **(**uintptr)(__ccgo_up(a))+19, **(**uintptr)(__ccgo_up(b))+19) } type TDIR = struct { @@ -24939,11 +24939,11 @@ func Xfdopendir(tls *TLS, fd int32) (r uintptr) { return uintptr(0) } if Xfcntl(tls, fd, int32(F_GETFL), 0)&int32(O_PATH) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EBADF) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EBADF) return uintptr(0) } - if !((*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&Uint32FromInt32(S_IFMT) == Uint32FromInt32(S_IFDIR)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOTDIR) + if !((**(**Tstat)(__ccgo_up(bp))).Fst_mode&Uint32FromInt32(S_IFMT) == Uint32FromInt32(S_IFDIR)) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOTDIR) return uintptr(0) } v1 = Xcalloc(tls, uint32(1), uint32(2072)) @@ -25078,7 +25078,7 @@ func Xreaddir(tls *TLS, dir uintptr) (r uintptr) { len1 = int32(X__syscall3(tls, int32(SYS_getdents64), (*TDIR)(unsafe.Pointer(dir)).Ffd, int32(dir+24), Int32FromUint32(Uint32FromInt64(2048)))) if len1 <= 0 { if len1 < 0 && len1 != -int32(ENOENT) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = -len1 + **(**int32)(__ccgo_up(X__errno_location(tls))) = -len1 } return uintptr(0) } @@ -25086,7 +25086,7 @@ func Xreaddir(tls *TLS, dir uintptr) (r uintptr) { (*TDIR)(unsafe.Pointer(dir)).Fbuf_pos = 0 } de = dir + 24 + uintptr((*TDIR)(unsafe.Pointer(dir)).Fbuf_pos) - *(*int32)(unsafe.Pointer(dir + 12)) += Int32FromUint16((*Tdirent)(unsafe.Pointer(de)).Fd_reclen) + **(**int32)(__ccgo_up(dir + 12)) += Int32FromUint16((*Tdirent)(unsafe.Pointer(de)).Fd_reclen) (*TDIR)(unsafe.Pointer(dir)).Ftell = (*Tdirent)(unsafe.Pointer(de)).Fd_off return de } @@ -25099,24 +25099,24 @@ func Xreaddir_r(tls *TLS, dir uintptr, buf uintptr, result uintptr) (r int32) { var de uintptr var errno_save, ret, v1 int32 _, _, _, _ = de, errno_save, ret, v1 - errno_save = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + errno_save = **(**int32)(__ccgo_up(X__errno_location(tls))) ___lock(tls, dir+20) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = 0 + **(**int32)(__ccgo_up(X__errno_location(tls))) = 0 de = Xreaddir(tls, dir) - v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = **(**int32)(__ccgo_up(X__errno_location(tls))) ret = v1 if v1 != 0 { ___unlock(tls, dir+20) return ret } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = errno_save + **(**int32)(__ccgo_up(X__errno_location(tls))) = errno_save if de != 0 { _memcpy(tls, buf, de, uint32((*Tdirent)(unsafe.Pointer(de)).Fd_reclen)) } else { buf = UintptrFromInt32(0) } ___unlock(tls, dir+20) - *(*uintptr)(unsafe.Pointer(result)) = buf + **(**uintptr)(__ccgo_up(result)) = buf return 0 } @@ -25152,12 +25152,12 @@ func Xscandir(tls *TLS, path uintptr, res uintptr, __ccgo_fp_sel uintptr, __ccgo names = uintptr(0) cnt = uint32(0) len1 = uint32(0) - old_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + old_errno = **(**int32)(__ccgo_up(X__errno_location(tls))) if !(d != 0) { return -int32(1) } for { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = 0 + **(**int32)(__ccgo_up(X__errno_location(tls))) = 0 v1 = Xreaddir(tls, d) de = v1 if !(v1 != 0) { @@ -25177,16 +25177,16 @@ func Xscandir(tls *TLS, path uintptr, res uintptr, __ccgo_fp_sel uintptr, __ccgo } names = tmp } - *(*uintptr)(unsafe.Pointer(names + uintptr(cnt)*4)) = Xmalloc(tls, uint32((*Tdirent)(unsafe.Pointer(de)).Fd_reclen)) - if !(*(*uintptr)(unsafe.Pointer(names + uintptr(cnt)*4)) != 0) { + **(**uintptr)(__ccgo_up(names + uintptr(cnt)*4)) = Xmalloc(tls, uint32((*Tdirent)(unsafe.Pointer(de)).Fd_reclen)) + if !(**(**uintptr)(__ccgo_up(names + uintptr(cnt)*4)) != 0) { break } v2 = cnt cnt = cnt + 1 - _memcpy(tls, *(*uintptr)(unsafe.Pointer(names + uintptr(v2)*4)), de, uint32((*Tdirent)(unsafe.Pointer(de)).Fd_reclen)) + _memcpy(tls, **(**uintptr)(__ccgo_up(names + uintptr(v2)*4)), de, uint32((*Tdirent)(unsafe.Pointer(de)).Fd_reclen)) } Xclosedir(tls, d) - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != 0 { + if **(**int32)(__ccgo_up(X__errno_location(tls))) != 0 { if names != 0 { for { v2 = cnt @@ -25194,17 +25194,17 @@ func Xscandir(tls *TLS, path uintptr, res uintptr, __ccgo_fp_sel uintptr, __ccgo if !(v2 > uint32(0)) { break } - Xfree(tls, *(*uintptr)(unsafe.Pointer(names + uintptr(cnt)*4))) + Xfree(tls, **(**uintptr)(__ccgo_up(names + uintptr(cnt)*4))) } } Xfree(tls, names) return -int32(1) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = old_errno + **(**int32)(__ccgo_up(X__errno_location(tls))) = old_errno if __ccgo_fp_cmp != 0 { Xqsort(tls, names, cnt, uint32(4), __ccgo_fp_cmp) } - *(*uintptr)(unsafe.Pointer(res)) = names + **(**uintptr)(__ccgo_up(res)) = names return Int32FromUint32(cnt) } @@ -25235,7 +25235,7 @@ func Xversionsort(tls *TLS, a uintptr, b uintptr) (r int32) { trc("tls=%v a=%v b=%v, (%v:)", tls, a, b, origin(2)) defer func() { trc("-> %v", r) }() } - return Xstrverscmp(tls, *(*uintptr)(unsafe.Pointer(a))+19, *(*uintptr)(unsafe.Pointer(b))+19) + return Xstrverscmp(tls, **(**uintptr)(__ccgo_up(a))+19, **(**uintptr)(__ccgo_up(b))+19) } func X__reset_tls(tls *TLS) { @@ -25247,7 +25247,7 @@ func X__reset_tls(tls *TLS) { var self Tpthread_t _, _, _, _, _ = i, mem, n, p, self self = uintptr(___get_tp(tls)) - n = *(*Tuintptr_t)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(self)).Fdtv)) + n = **(**Tuintptr_t)(__ccgo_up((*t__pthread)(unsafe.Pointer(self)).Fdtv)) if n != 0 { p = X__libc.Ftls_head i = Uint32FromInt32(1) @@ -25255,7 +25255,7 @@ func X__reset_tls(tls *TLS) { if !(i <= n) { break } - mem = uintptr(*(*Tuintptr_t)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(self)).Fdtv + uintptr(i)*4)) - Uint32FromInt32(DTP_OFFSET)) + mem = uintptr(**(**Tuintptr_t)(__ccgo_up((*t__pthread)(unsafe.Pointer(self)).Fdtv + uintptr(i)*4)) - Uint32FromInt32(DTP_OFFSET)) _memcpy(tls, mem, (*Ttls_module)(unsafe.Pointer(p)).Fimage, (*Ttls_module)(unsafe.Pointer(p)).Flen1) Xmemset(tls, mem+uintptr((*Ttls_module)(unsafe.Pointer(p)).Flen1), 0, (*Ttls_module)(unsafe.Pointer(p)).Fsize-(*Ttls_module)(unsafe.Pointer(p)).Flen1) goto _1 @@ -25310,10 +25310,10 @@ func Xclearenv(tls *TLS) (r int32) { e = Xenviron Xenviron = uintptr(0) if e != 0 { - for *(*uintptr)(unsafe.Pointer(e)) != 0 { + for **(**uintptr)(__ccgo_up(e)) != 0 { v1 = e e += 4 - X__env_rm_add(tls, *(*uintptr)(unsafe.Pointer(v1)), uintptr(0)) + X__env_rm_add(tls, **(**uintptr)(__ccgo_up(v1)), uintptr(0)) } } return 0 @@ -25328,14 +25328,14 @@ func Xgetenv(tls *TLS, name uintptr) (r uintptr) { var l Tsize_t _, _ = e, l l = Uint32FromInt32(int32(X__strchrnul(tls, name, int32('='))) - int32(name)) - if l != 0 && !(*(*uint8)(unsafe.Pointer(name + uintptr(l))) != 0) && Xenviron != 0 { + if l != 0 && !(**(**uint8)(__ccgo_up(name + uintptr(l))) != 0) && Xenviron != 0 { e = Xenviron for { - if !(*(*uintptr)(unsafe.Pointer(e)) != 0) { + if !(**(**uintptr)(__ccgo_up(e)) != 0) { break } - if !(Xstrncmp(tls, name, *(*uintptr)(unsafe.Pointer(e)), l) != 0) && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(e)) + uintptr(l)))) == int32('=') { - return *(*uintptr)(unsafe.Pointer(e)) + uintptr(l) + uintptr(1) + if !(Xstrncmp(tls, name, **(**uintptr)(__ccgo_up(e)), l) != 0) && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(e)) + uintptr(l)))) == int32('=') { + return **(**uintptr)(__ccgo_up(e)) + uintptr(l) + uintptr(1) } goto _1 _1: @@ -25361,12 +25361,12 @@ func X__putenv(tls *TLS, s uintptr, l Tsize_t, r uintptr) (r1 int32) { if Xenviron != 0 { e = Xenviron for { - if !(*(*uintptr)(unsafe.Pointer(e)) != 0) { + if !(**(**uintptr)(__ccgo_up(e)) != 0) { break } - if !(Xstrncmp(tls, s, *(*uintptr)(unsafe.Pointer(e)), l+uint32(1)) != 0) { - tmp = *(*uintptr)(unsafe.Pointer(e)) - *(*uintptr)(unsafe.Pointer(e)) = s + if !(Xstrncmp(tls, s, **(**uintptr)(__ccgo_up(e)), l+uint32(1)) != 0) { + tmp = **(**uintptr)(__ccgo_up(e)) + **(**uintptr)(__ccgo_up(e)) = s X__env_rm_add(tls, tmp, r) return 0 } @@ -25392,8 +25392,8 @@ func X__putenv(tls *TLS, s uintptr, l Tsize_t, r uintptr) (r1 int32) { } Xfree(tls, _oldenv) } - *(*uintptr)(unsafe.Pointer(newenv + uintptr(i)*4)) = s - *(*uintptr)(unsafe.Pointer(newenv + uintptr(i+uint32(1))*4)) = uintptr(0) + **(**uintptr)(__ccgo_up(newenv + uintptr(i)*4)) = s + **(**uintptr)(__ccgo_up(newenv + uintptr(i+uint32(1))*4)) = uintptr(0) v2 = newenv _oldenv = v2 Xenviron = v2 @@ -25418,7 +25418,7 @@ func Xputenv(tls *TLS, s uintptr) (r int32) { var l Tsize_t _ = l l = Uint32FromInt32(int32(X__strchrnul(tls, s, int32('='))) - int32(s)) - if !(l != 0) || !(*(*uint8)(unsafe.Pointer(s + uintptr(l))) != 0) { + if !(l != 0) || !(**(**uint8)(__ccgo_up(s + uintptr(l))) != 0) { return Xunsetenv(tls, s) } return X__putenv(tls, s, l, uintptr(0)) @@ -25463,13 +25463,13 @@ func X__env_rm_add(tls *TLS, old uintptr, new1 uintptr) { if !(i < _env_alloced_n) { break } - if *(*uintptr)(unsafe.Pointer(_env_alloced + uintptr(i)*4)) == old { - *(*uintptr)(unsafe.Pointer(_env_alloced + uintptr(i)*4)) = new1 + if **(**uintptr)(__ccgo_up(_env_alloced + uintptr(i)*4)) == old { + **(**uintptr)(__ccgo_up(_env_alloced + uintptr(i)*4)) = new1 Xfree(tls, old) return } else { - if !(*(*uintptr)(unsafe.Pointer(_env_alloced + uintptr(i)*4)) != 0) && new1 != 0 { - *(*uintptr)(unsafe.Pointer(_env_alloced + uintptr(i)*4)) = new1 + if !(**(**uintptr)(__ccgo_up(_env_alloced + uintptr(i)*4)) != 0) && new1 != 0 { + **(**uintptr)(__ccgo_up(_env_alloced + uintptr(i)*4)) = new1 new1 = uintptr(0) } } @@ -25489,7 +25489,7 @@ func X__env_rm_add(tls *TLS, old uintptr, new1 uintptr) { _env_alloced = v2 v3 = _env_alloced_n _env_alloced_n = _env_alloced_n + 1 - *(*uintptr)(unsafe.Pointer(v2 + uintptr(v3)*4)) = new1 + **(**uintptr)(__ccgo_up(v2 + uintptr(v3)*4)) = new1 } var _env_alloced uintptr @@ -25509,8 +25509,8 @@ func Xsetenv(tls *TLS, var1 uintptr, value uintptr, overwrite int32) (r int32) { v1 = Uint32FromInt32(int32(X__strchrnul(tls, var1, int32('='))) - int32(var1)) l1 = v1 } - if v2 || !(v1 != 0) || *(*uint8)(unsafe.Pointer(var1 + uintptr(l1))) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if v2 || !(v1 != 0) || **(**uint8)(__ccgo_up(var1 + uintptr(l1))) != 0 { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } if !(overwrite != 0) && Xgetenv(tls, var1) != 0 { @@ -25522,7 +25522,7 @@ func Xsetenv(tls *TLS, var1 uintptr, value uintptr, overwrite int32) (r int32) { return -int32(1) } _memcpy(tls, s, var1, l1) - *(*uint8)(unsafe.Pointer(s + uintptr(l1))) = uint8('=') + **(**uint8)(__ccgo_up(s + uintptr(l1))) = uint8('=') _memcpy(tls, s+uintptr(l1)+uintptr(1), value, l2+uint32(1)) return X__putenv(tls, s, l1, s) } @@ -25539,24 +25539,24 @@ func Xunsetenv(tls *TLS, name uintptr) (r int32) { var l Tsize_t _, _, _, _ = e, eo, l, v2 l = Uint32FromInt32(int32(X__strchrnul(tls, name, int32('='))) - int32(name)) - if !(l != 0) || *(*uint8)(unsafe.Pointer(name + uintptr(l))) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if !(l != 0) || **(**uint8)(__ccgo_up(name + uintptr(l))) != 0 { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } if Xenviron != 0 { e = Xenviron eo = e for { - if !(*(*uintptr)(unsafe.Pointer(e)) != 0) { + if !(**(**uintptr)(__ccgo_up(e)) != 0) { break } - if !(Xstrncmp(tls, name, *(*uintptr)(unsafe.Pointer(e)), l) != 0) && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(e)) + uintptr(l)))) == int32('=') { - X__env_rm_add(tls, *(*uintptr)(unsafe.Pointer(e)), uintptr(0)) + if !(Xstrncmp(tls, name, **(**uintptr)(__ccgo_up(e)), l) != 0) && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(e)) + uintptr(l)))) == int32('=') { + X__env_rm_add(tls, **(**uintptr)(__ccgo_up(e)), uintptr(0)) } else { if eo != e { v2 = eo eo += 4 - *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(e)) + **(**uintptr)(__ccgo_up(v2)) = **(**uintptr)(__ccgo_up(e)) } else { eo += 4 } @@ -25567,7 +25567,7 @@ func Xunsetenv(tls *TLS, name uintptr) (r int32) { e += 4 } if eo != e { - *(*uintptr)(unsafe.Pointer(eo)) = uintptr(0) + **(**uintptr)(__ccgo_up(eo)) = uintptr(0) } } return 0 @@ -25877,7 +25877,7 @@ func X__strerror_l(tls *TLS, e int32, loc Tlocale_t) (r uintptr) { e = 0 } s = uintptr(unsafe.Pointer(&_errmsgstr)) + uintptr(_errmsgidx[e]) - return X__lctrans(tls, s, *(*uintptr)(unsafe.Pointer(loc + 5*4))) + return X__lctrans(tls, s, **(**uintptr)(__ccgo_up(loc + 5*4))) } func Xstrerror(tls *TLS, e int32) (r uintptr) { @@ -26014,10 +26014,10 @@ func Xfcntl(tls *TLS, fd int32, cmd int32, va uintptr) (r int32) { if ret != 0 { return X__syscall_ret(tls, Uint32FromInt32(ret)) } - if (*(*Tf_owner_ex)(unsafe.Pointer(bp))).Ftype1 == int32(F_OWNER_PGRP) { - v1 = -(*(*Tf_owner_ex)(unsafe.Pointer(bp))).Fpid + if (**(**Tf_owner_ex)(__ccgo_up(bp))).Ftype1 == int32(F_OWNER_PGRP) { + v1 = -(**(**Tf_owner_ex)(__ccgo_up(bp))).Fpid } else { - v1 = (*(*Tf_owner_ex)(unsafe.Pointer(bp))).Fpid + v1 = (**(**Tf_owner_ex)(__ccgo_up(bp))).Fpid } return v1 } @@ -26195,7 +26195,7 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { v3 = f + 4 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26206,7 +26206,7 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { v3 = f + 4 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26236,7 +26236,7 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { v3 = f + 4 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26255,7 +26255,7 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { v3 = f + 4 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26272,7 +26272,7 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { v3 = f + 4 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26325,7 +26325,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__shgetc(tls, f) } @@ -26337,7 +26337,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__shgetc(tls, f) } @@ -26355,14 +26355,14 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__shgetc(tls, f) } c = v2 } } - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0] = uint32(0) + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[0] = uint32(0) for { if !(Uint32FromInt32(c-int32('0')) < uint32(10) || c == int32('.')) { break @@ -26380,9 +26380,9 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, lnz = int32(dc) } if j != 0 { - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k]*uint32(10) + Uint32FromInt32(c) - uint32('0') + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] = (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k]*uint32(10) + Uint32FromInt32(c) - uint32('0') } else { - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] = Uint32FromInt32(c - int32('0')) + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] = Uint32FromInt32(c - int32('0')) } j = j + 1 v2 = j @@ -26395,7 +26395,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, dc = dc + 1 if c != int32('0') { lnz = (Int32FromInt32(KMAX) - Int32FromInt32(4)) * Int32FromInt32(9) - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(Int32FromInt32(KMAX)-Int32FromInt32(4))*4)) |= uint32(1) + **(**Tuint32_t)(__ccgo_up(bp + uintptr(Int32FromInt32(KMAX)-Int32FromInt32(4))*4)) |= uint32(1) } } } @@ -26406,7 +26406,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__shgetc(tls, f) } @@ -26437,24 +26437,24 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, } } if !(gotdig != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) X__shlim(tls, f, int64(Int32FromInt32(0))) return Float64FromInt32(0) } /* Handle zero specially to avoid nasty special cases later */ - if !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0] != 0) { + if !((**(**[128]Tuint32_t)(__ccgo_up(bp)))[0] != 0) { return float64(float64(sign) * float64(0)) } /* Optimize small integers (w/no exponent) and over/under-flow */ - if lrp == dc && dc < int64(10) && (bits > int32(30) || (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0]>>bits == uint32(0)) { - return float64(float64(sign) * float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0])) + if lrp == dc && dc < int64(10) && (bits > int32(30) || (**(**[128]Tuint32_t)(__ccgo_up(bp)))[0]>>bits == uint32(0)) { + return float64(float64(sign) * float64((**(**[128]Tuint32_t)(__ccgo_up(bp)))[0])) } if lrp > int64(-emin/int32(2)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return float64(float64(float64(sign)*Float64FromFloat64(1.79769313486231570815e+308)) * Float64FromFloat64(1.79769313486231570815e+308)) } if lrp < int64(emin-Int32FromInt32(2)*Int32FromInt32(LDBL_MANT_DIG)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return float64(float64(float64(sign)*Float64FromFloat64(2.22507385850720138309e-308)) * Float64FromFloat64(2.22507385850720138309e-308)) } /* Align incomplete final B1B digit */ @@ -26463,7 +26463,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if !(j < int32(9)) { break } - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(k)*4)) *= uint32(10) + **(**Tuint32_t)(__ccgo_up(bp + uintptr(k)*4)) *= uint32(10) goto _17 _17: ; @@ -26479,19 +26479,19 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, /* Optimize small to mid-size integers (even in exp. notation) */ if lnz < int32(9) && lnz <= rp && rp < int32(18) { if rp == int32(9) { - return float64(float64(sign) * float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0])) + return float64(float64(sign) * float64((**(**[128]Tuint32_t)(__ccgo_up(bp)))[0])) } if rp < int32(9) { - return float64(float64(sign)*float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0])) / float64(_p10s[int32(8)-rp]) + return float64(float64(sign)*float64((**(**[128]Tuint32_t)(__ccgo_up(bp)))[0])) / float64(_p10s[int32(8)-rp]) } bitlim = bits - int32(3)*(rp-Int32FromInt32(9)) - if bitlim > int32(30) || (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0]>>bitlim == uint32(0) { - return float64(float64(float64(sign)*float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0])) * float64(_p10s[rp-int32(10)])) + if bitlim > int32(30) || (**(**[128]Tuint32_t)(__ccgo_up(bp)))[0]>>bitlim == uint32(0) { + return float64(float64(float64(sign)*float64((**(**[128]Tuint32_t)(__ccgo_up(bp)))[0])) * float64(_p10s[rp-int32(10)])) } } /* Drop trailing zeros */ for { - if !!((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[z-int32(1)] != 0) { + if !!((**(**[128]Tuint32_t)(__ccgo_up(bp)))[z-int32(1)] != 0) { break } goto _18 @@ -26514,10 +26514,10 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if !(k != z) { break } - tmp = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] % Uint32FromInt32(p10) - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k]/Uint32FromInt32(p10) + carry + tmp = (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] % Uint32FromInt32(p10) + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] = (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k]/Uint32FromInt32(p10) + carry carry = Uint32FromInt32(int32(1000000000)/p10) * tmp - if k == a && !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] != 0) { + if k == a && !((**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] != 0) { a = (a + int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) rp = rp - int32(9) } @@ -26529,25 +26529,25 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if carry != 0 { v2 = z z = z + 1 - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v2] = carry + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[v2] = carry } rp = rp + (int32(9) - rpm9) } /* Upscale until desired number of bits are left of radix point */ - for rp < Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) || rp == Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) && (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[a] < _th[0] { + for rp < Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) || rp == Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) && (**(**[128]Tuint32_t)(__ccgo_up(bp)))[a] < _th[0] { carry1 = uint32(0) e2 = e2 - int32(29) k = (z - int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) for { - tmp1 = uint64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k])< uint64(1000000000) { carry1 = uint32(tmp1 / uint64(1000000000)) - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] = uint32(tmp1 % uint64(1000000000)) + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] = uint32(tmp1 % uint64(1000000000)) } else { carry1 = uint32(0) - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] = uint32(tmp1) + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] = uint32(tmp1) } - if k == (z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) && k != a && !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] != 0) { + if k == (z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) && k != a && !((**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] != 0) { z = k } if k == a { @@ -26563,9 +26563,9 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, a = (a - int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) if a == z { z = (z - int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr((z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)))*4)) |= (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[z] + **(**Tuint32_t)(__ccgo_up(bp + uintptr((z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)))*4)) |= (**(**[128]Tuint32_t)(__ccgo_up(bp)))[z] } - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[a] = carry1 + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[a] = carry1 } } /* Downscale until exactly number of bits are left of radix point */ @@ -26578,11 +26578,11 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, break } k = (a + i) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) - if k == z || (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] < _th[i] { + if k == z || (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] < _th[i] { i = int32(LD_B1B_DIG) break } - if (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))] > _th[i] { + if (**(**[128]Tuint32_t)(__ccgo_up(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))] > _th[i] { break } goto _24 @@ -26603,10 +26603,10 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if !(k != z) { break } - tmp2 = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] & Uint32FromInt32(int32(1)<>sh + carry2 + tmp2 = (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] & Uint32FromInt32(int32(1)<>sh + carry2 carry2 = Uint32FromInt32(Int32FromInt32(1000000000)>>sh) * tmp2 - if k == a && !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] != 0) { + if k == a && !((**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] != 0) { a = (a + int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) i = i - 1 rp = rp - int32(9) @@ -26618,10 +26618,10 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, } if carry2 != 0 { if (z+int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) != a { - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[z] = carry2 + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[z] = carry2 z = (z + int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) } else { - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr((z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)))*4)) |= uint32(1) + **(**Tuint32_t)(__ccgo_up(bp + uintptr((z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)))*4)) |= uint32(1) } } goto _23 @@ -26638,9 +26638,9 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if (a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1)) == z { v6 = (z + Int32FromInt32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) z = v6 - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v6-int32(1)] = uint32(0) + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[v6-int32(1)] = uint32(0) } - y = float64(Float64FromFloat64(1e+09)*y) + float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))]) + y = float64(Float64FromFloat64(1e+09)*y) + float64((**(**[128]Tuint32_t)(__ccgo_up(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))]) goto _26 _26: ; @@ -26664,7 +26664,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, } /* Process tail of decimal input so it can affect rounding */ if (a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1)) != z { - t = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))] + t = (**(**[128]Tuint32_t)(__ccgo_up(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))] if t < uint32(500000000) && (t != 0 || (a+i+int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) != z) { frac = frac + float64(float64(0.25)*float64(sign)) } else { @@ -26695,7 +26695,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, e2 = e2 + 1 } if e2+int32(LDBL_MANT_DIG) > emax || denormal != 0 && frac != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) } } return Xscalbnl(tls, y, e2) @@ -26738,7 +26738,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 v3 = f + 4 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26756,7 +26756,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 v3 = f + 4 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26768,7 +26768,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 v3 = f + 4 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26787,7 +26787,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 v3 = f + 4 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26834,7 +26834,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 v3 = f + 4 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26888,11 +26888,11 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 return float64(float64(sign) * float64(0)) } if e2 > int64(-emin) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return float64(float64(float64(sign)*Float64FromFloat64(1.79769313486231570815e+308)) * Float64FromFloat64(1.79769313486231570815e+308)) } if e2 < int64(emin-Int32FromInt32(2)*Int32FromInt32(LDBL_MANT_DIG)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return float64(float64(float64(sign)*Float64FromFloat64(2.22507385850720138309e-308)) * Float64FromFloat64(2.22507385850720138309e-308)) } for x < uint32(0x80000000) { @@ -26921,7 +26921,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 y = bias + float64(float64(sign)*float64(x)) + float64(float64(sign)*y) y = y - bias if !(y != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) } return Xscalbnl(tls, y, int32(e2)) } @@ -26954,7 +26954,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__shgetc(tls, f) } @@ -26974,7 +26974,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -26982,7 +26982,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { } i = uint32(0) for { - if !(i < uint32(8) && c|int32(32) == Int32FromUint8(*(*uint8)(unsafe.Pointer(__ccgo_ts + 247 + uintptr(i))))) { + if !(i < uint32(8) && c|int32(32) == Int32FromUint8(**(**uint8)(__ccgo_up(__ccgo_ts + 247 + uintptr(i))))) { break } if i < uint32(7) { @@ -26990,7 +26990,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27026,7 +27026,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { if !(i != 0) { i = uint32(0) for { - if !(i < uint32(3) && c|int32(32) == Int32FromUint8(*(*uint8)(unsafe.Pointer(__ccgo_ts + 256 + uintptr(i))))) { + if !(i < uint32(3) && c|int32(32) == Int32FromUint8(**(**uint8)(__ccgo_up(__ccgo_ts + 256 + uintptr(i))))) { break } if i < uint32(2) { @@ -27034,7 +27034,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27051,7 +27051,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27067,7 +27067,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27082,7 +27082,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if !(pok != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) X__shlim(tls, f, int64(Int32FromInt32(0))) return Float64FromInt32(0) } @@ -27108,7 +27108,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) X__shlim(tls, f, int64(Int32FromInt32(0))) return Float64FromInt32(0) } @@ -27117,7 +27117,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27408,7 +27408,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint val = uintptr(unsafe.Pointer(&_table6)) + uintptr(1) neg = 0 if base > uint32(36) || base == uint32(1) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uint64(0) } for { @@ -27416,7 +27416,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__shgetc(tls, f) } @@ -27436,7 +27436,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27447,7 +27447,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27457,12 +27457,12 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } c = v1 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) >= int32(16) { + if Int32FromUint8(**(**uint8)(__ccgo_up(val + uintptr(c)))) >= int32(16) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } @@ -27485,12 +27485,12 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint if base == uint32(0) { base = uint32(10) } - if uint32(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) >= base { + if uint32(**(**uint8)(__ccgo_up(val + uintptr(c)))) >= base { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } X__shlim(tls, f, int64(Int32FromInt32(0))) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uint64(0) } } @@ -27508,7 +27508,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27527,7 +27527,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27538,13 +27538,13 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint } } else { if !(base&(base-Uint32FromInt32(1)) != 0) { - bs = Int32FromUint8(*(*uint8)(unsafe.Pointer(__ccgo_ts + 260 + uintptr(uint32(0x17)*base>>int32(5)&uint32(7))))) + bs = Int32FromUint8(**(**uint8)(__ccgo_up(__ccgo_ts + 260 + uintptr(uint32(0x17)*base>>int32(5)&uint32(7))))) x = uint32(0) for { - if !(uint32(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) < base && x <= Uint32FromUint32(0xffffffff)/Uint32FromInt32(32)) { + if !(uint32(**(**uint8)(__ccgo_up(val + uintptr(c)))) < base && x <= Uint32FromUint32(0xffffffff)/Uint32FromInt32(32)) { break } - x = x<>bs) { + if !(uint32(**(**uint8)(__ccgo_up(val + uintptr(c)))) < base && y <= (Uint64FromUint64(2)*Uint64FromInt64(0x7fffffffffffffff)+Uint64FromInt32(1))>>bs) { break } - y = y<= lim { if !(lim&Uint64FromInt32(1) != 0) && !(neg != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return lim - uint64(1) } else { if y > lim { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return lim } } @@ -27671,8 +27671,8 @@ func X__procfdname(tls *TLS, buf uintptr, fd uint32) { _, _, _, _ = i, j, v2, v5 i = uint32(0) for { - v2 = *(*uint8)(unsafe.Pointer(__ccgo_ts + 269 + uintptr(i))) - *(*uint8)(unsafe.Pointer(buf + uintptr(i))) = v2 + v2 = **(**uint8)(__ccgo_up(__ccgo_ts + 269 + uintptr(i))) + **(**uint8)(__ccgo_up(buf + uintptr(i))) = v2 if !(v2 != 0) { break } @@ -27682,8 +27682,8 @@ func X__procfdname(tls *TLS, buf uintptr, fd uint32) { i = i + 1 } if !(fd != 0) { - *(*uint8)(unsafe.Pointer(buf + uintptr(i))) = uint8('0') - *(*uint8)(unsafe.Pointer(buf + uintptr(i+uint32(1)))) = uint8(0) + **(**uint8)(__ccgo_up(buf + uintptr(i))) = uint8('0') + **(**uint8)(__ccgo_up(buf + uintptr(i+uint32(1)))) = uint8(0) return } j = fd @@ -27697,14 +27697,14 @@ func X__procfdname(tls *TLS, buf uintptr, fd uint32) { j = j / uint32(10) i = i + 1 } - *(*uint8)(unsafe.Pointer(buf + uintptr(i))) = uint8(0) + **(**uint8)(__ccgo_up(buf + uintptr(i))) = uint8(0) for { if !(fd != 0) { break } i = i - 1 v5 = i - *(*uint8)(unsafe.Pointer(buf + uintptr(v5))) = uint8(uint32('0') + fd%uint32(10)) + **(**uint8)(__ccgo_up(buf + uintptr(v5))) = uint8(uint32('0') + fd%uint32(10)) goto _4 _4: ; @@ -27759,7 +27759,7 @@ func X__shgetc(tls *TLS, f uintptr) (r int32) { } (*TFILE)(unsafe.Pointer(f)).Fshcnt = int64(int32((*TFILE)(unsafe.Pointer(f)).Fbuf)-int32((*TFILE)(unsafe.Pointer(f)).Frpos)) + cnt if (*TFILE)(unsafe.Pointer(f)).Frpos <= (*TFILE)(unsafe.Pointer(f)).Fbuf { - *(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos + uintptr(-Int32FromInt32(1)))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos + uintptr(-Int32FromInt32(1)))) = Uint8FromInt32(c) } return c } @@ -27770,7 +27770,7 @@ func X__syscall_ret(tls *TLS, r uint32) (r1 int32) { defer func() { trc("-> %v", r1) }() } if r > -Uint32FromUint32(4096) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = Int32FromUint32(-r) + **(**int32)(__ccgo_up(X__errno_location(tls))) = Int32FromUint32(-r) return -int32(1) } return Int32FromUint32(r) @@ -27847,7 +27847,7 @@ func Xftok(tls *TLS, path uintptr, id int32) (r Tkey_t) { if Xstat(tls, path, bp) < 0 { return -int32(1) } - return Int32FromUint64((*(*Tstat)(unsafe.Pointer(bp))).Fst_ino&Uint64FromInt32(0xffff) | (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev&Uint64FromInt32(0xff)<= 0 && cmd&(Int32FromInt32(IPC_STAT)&Int32FromInt32(0x100)) != 0 { buf = orig - *(*Tmsqid_ds)(unsafe.Pointer(buf)) = *(*Tmsqid_ds)(unsafe.Pointer(bp)) + **(**Tmsqid_ds)(__ccgo_up(buf)) = **(**Tmsqid_ds)(__ccgo_up(bp)) (*Tmsqid_ds)(unsafe.Pointer(buf)).Fmsg_stime = Int64FromUint32((*Tmsqid_ds)(unsafe.Pointer(buf)).F__msg_stime_lo) | (0+Int64FromUint32((*Tmsqid_ds)(unsafe.Pointer(buf)).F__msg_stime_hi))<= 0 && cmd&(Int32FromInt32(IPC_STAT)&Int32FromInt32(0x100)) != 0 { *(*uintptr)(unsafe.Pointer(bp)) = orig - *(*Tsemid_ds)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) = *(*Tsemid_ds)(unsafe.Pointer(bp + 8)) + **(**Tsemid_ds)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp)))) = **(**Tsemid_ds)(__ccgo_up(bp + 8)) (*Tsemid_ds)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fsem_otime = Int64FromUint32((*Tsemid_ds)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).F__sem_otime_lo) | (0+Int64FromUint32((*Tsemid_ds)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).F__sem_otime_hi))<= 0 && cmd&(Int32FromInt32(IPC_STAT)&Int32FromInt32(0x100)) != 0 { buf = orig - *(*Tshmid_ds)(unsafe.Pointer(buf)) = *(*Tshmid_ds)(unsafe.Pointer(bp)) + **(**Tshmid_ds)(__ccgo_up(buf)) = **(**Tshmid_ds)(__ccgo_up(bp)) (*Tshmid_ds)(unsafe.Pointer(buf)).Fshm_atime = Int64FromUint32((*Tshmid_ds)(unsafe.Pointer(buf)).F__shm_atime_lo) | (0+Int64FromUint32((*Tshmid_ds)(unsafe.Pointer(buf)).F__shm_atime_hi))< int64(1000) || (*Ttimeval)(unsafe.Pointer(in)).Ftv_usec > int64(1000000000) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } - (*(*Ttimex)(unsafe.Pointer(bp))).Foffset = int32((*Ttimeval)(unsafe.Pointer(in)).Ftv_sec*int64(1000000) + (*Ttimeval)(unsafe.Pointer(in)).Ftv_usec) - (*(*Ttimex)(unsafe.Pointer(bp))).Fmodes = uint32(ADJ_OFFSET_SINGLESHOT) + (**(**Ttimex)(__ccgo_up(bp))).Foffset = int32((*Ttimeval)(unsafe.Pointer(in)).Ftv_sec*int64(1000000) + (*Ttimeval)(unsafe.Pointer(in)).Ftv_usec) + (**(**Ttimex)(__ccgo_up(bp))).Fmodes = uint32(ADJ_OFFSET_SINGLESHOT) } if Xadjtimex(tls, bp) < 0 { return -int32(1) } if out != 0 { - (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec = int64((*(*Ttimex)(unsafe.Pointer(bp))).Foffset / int32(1000000)) - v1 = int64((*(*Ttimex)(unsafe.Pointer(bp))).Foffset % Int32FromInt32(1000000)) + (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec = int64((**(**Ttimex)(__ccgo_up(bp))).Foffset / int32(1000000)) + v1 = int64((**(**Ttimex)(__ccgo_up(bp))).Foffset % Int32FromInt32(1000000)) (*Ttimeval)(unsafe.Pointer(out)).Ftv_usec = v1 if v1 < 0 { (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec = (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec - 1 - *(*Tsuseconds_t)(unsafe.Pointer(out + 8)) += int64(1000000) + **(**Tsuseconds_t)(__ccgo_up(out + 8)) += int64(1000000) } } return 0 @@ -29420,7 +29420,7 @@ func Xclock_adjtime(tls *TLS, clock_id Tclockid_t, utx uintptr) (r1 int32) { var _ /* ktx at bp+208 */ Tktimex _ = r r = -int32(ENOSYS) - *(*Tktimex64)(unsafe.Pointer(bp)) = Tktimex64{ + **(**Tktimex64)(__ccgo_up(bp)) = Tktimex64{ Fmodes: (*Ttimex)(unsafe.Pointer(utx)).Fmodes, Foffset: int64((*Ttimex)(unsafe.Pointer(utx)).Foffset), Ffreq: int64((*Ttimex)(unsafe.Pointer(utx)).Ffreq), @@ -29445,27 +29445,27 @@ func Xclock_adjtime(tls *TLS, clock_id Tclockid_t, utx uintptr) (r1 int32) { } r = int32(X__syscall2(tls, int32(SYS_clock_adjtime64), clock_id, int32(bp))) if r >= 0 { - (*Ttimex)(unsafe.Pointer(utx)).Fmodes = (*(*Tktimex64)(unsafe.Pointer(bp))).Fmodes - (*Ttimex)(unsafe.Pointer(utx)).Foffset = int32((*(*Tktimex64)(unsafe.Pointer(bp))).Foffset) - (*Ttimex)(unsafe.Pointer(utx)).Ffreq = int32((*(*Tktimex64)(unsafe.Pointer(bp))).Ffreq) - (*Ttimex)(unsafe.Pointer(utx)).Fmaxerror = int32((*(*Tktimex64)(unsafe.Pointer(bp))).Fmaxerror) - (*Ttimex)(unsafe.Pointer(utx)).Festerror = int32((*(*Tktimex64)(unsafe.Pointer(bp))).Festerror) - (*Ttimex)(unsafe.Pointer(utx)).Fstatus = (*(*Tktimex64)(unsafe.Pointer(bp))).Fstatus - (*Ttimex)(unsafe.Pointer(utx)).Fconstant = int32((*(*Tktimex64)(unsafe.Pointer(bp))).Fconstant) - (*Ttimex)(unsafe.Pointer(utx)).Fprecision = int32((*(*Tktimex64)(unsafe.Pointer(bp))).Fprecision) - (*Ttimex)(unsafe.Pointer(utx)).Ftolerance = int32((*(*Tktimex64)(unsafe.Pointer(bp))).Ftolerance) - (*Ttimex)(unsafe.Pointer(utx)).Ftime.Ftv_sec = (*(*Tktimex64)(unsafe.Pointer(bp))).Ftime_sec - (*Ttimex)(unsafe.Pointer(utx)).Ftime.Ftv_usec = (*(*Tktimex64)(unsafe.Pointer(bp))).Ftime_usec - (*Ttimex)(unsafe.Pointer(utx)).Ftick = int32((*(*Tktimex64)(unsafe.Pointer(bp))).Ftick) - (*Ttimex)(unsafe.Pointer(utx)).Fppsfreq = int32((*(*Tktimex64)(unsafe.Pointer(bp))).Fppsfreq) - (*Ttimex)(unsafe.Pointer(utx)).Fjitter = int32((*(*Tktimex64)(unsafe.Pointer(bp))).Fjitter) - (*Ttimex)(unsafe.Pointer(utx)).Fshift = (*(*Tktimex64)(unsafe.Pointer(bp))).Fshift - (*Ttimex)(unsafe.Pointer(utx)).Fstabil = int32((*(*Tktimex64)(unsafe.Pointer(bp))).Fstabil) - (*Ttimex)(unsafe.Pointer(utx)).Fjitcnt = int32((*(*Tktimex64)(unsafe.Pointer(bp))).Fjitcnt) - (*Ttimex)(unsafe.Pointer(utx)).Fcalcnt = int32((*(*Tktimex64)(unsafe.Pointer(bp))).Fcalcnt) - (*Ttimex)(unsafe.Pointer(utx)).Ferrcnt = int32((*(*Tktimex64)(unsafe.Pointer(bp))).Ferrcnt) - (*Ttimex)(unsafe.Pointer(utx)).Fstbcnt = int32((*(*Tktimex64)(unsafe.Pointer(bp))).Fstbcnt) - (*Ttimex)(unsafe.Pointer(utx)).Ftai = (*(*Tktimex64)(unsafe.Pointer(bp))).Ftai + (*Ttimex)(unsafe.Pointer(utx)).Fmodes = (**(**Tktimex64)(__ccgo_up(bp))).Fmodes + (*Ttimex)(unsafe.Pointer(utx)).Foffset = int32((**(**Tktimex64)(__ccgo_up(bp))).Foffset) + (*Ttimex)(unsafe.Pointer(utx)).Ffreq = int32((**(**Tktimex64)(__ccgo_up(bp))).Ffreq) + (*Ttimex)(unsafe.Pointer(utx)).Fmaxerror = int32((**(**Tktimex64)(__ccgo_up(bp))).Fmaxerror) + (*Ttimex)(unsafe.Pointer(utx)).Festerror = int32((**(**Tktimex64)(__ccgo_up(bp))).Festerror) + (*Ttimex)(unsafe.Pointer(utx)).Fstatus = (**(**Tktimex64)(__ccgo_up(bp))).Fstatus + (*Ttimex)(unsafe.Pointer(utx)).Fconstant = int32((**(**Tktimex64)(__ccgo_up(bp))).Fconstant) + (*Ttimex)(unsafe.Pointer(utx)).Fprecision = int32((**(**Tktimex64)(__ccgo_up(bp))).Fprecision) + (*Ttimex)(unsafe.Pointer(utx)).Ftolerance = int32((**(**Tktimex64)(__ccgo_up(bp))).Ftolerance) + (*Ttimex)(unsafe.Pointer(utx)).Ftime.Ftv_sec = (**(**Tktimex64)(__ccgo_up(bp))).Ftime_sec + (*Ttimex)(unsafe.Pointer(utx)).Ftime.Ftv_usec = (**(**Tktimex64)(__ccgo_up(bp))).Ftime_usec + (*Ttimex)(unsafe.Pointer(utx)).Ftick = int32((**(**Tktimex64)(__ccgo_up(bp))).Ftick) + (*Ttimex)(unsafe.Pointer(utx)).Fppsfreq = int32((**(**Tktimex64)(__ccgo_up(bp))).Fppsfreq) + (*Ttimex)(unsafe.Pointer(utx)).Fjitter = int32((**(**Tktimex64)(__ccgo_up(bp))).Fjitter) + (*Ttimex)(unsafe.Pointer(utx)).Fshift = (**(**Tktimex64)(__ccgo_up(bp))).Fshift + (*Ttimex)(unsafe.Pointer(utx)).Fstabil = int32((**(**Tktimex64)(__ccgo_up(bp))).Fstabil) + (*Ttimex)(unsafe.Pointer(utx)).Fjitcnt = int32((**(**Tktimex64)(__ccgo_up(bp))).Fjitcnt) + (*Ttimex)(unsafe.Pointer(utx)).Fcalcnt = int32((**(**Tktimex64)(__ccgo_up(bp))).Fcalcnt) + (*Ttimex)(unsafe.Pointer(utx)).Ferrcnt = int32((**(**Tktimex64)(__ccgo_up(bp))).Ferrcnt) + (*Ttimex)(unsafe.Pointer(utx)).Fstbcnt = int32((**(**Tktimex64)(__ccgo_up(bp))).Fstbcnt) + (*Ttimex)(unsafe.Pointer(utx)).Ftai = (**(**Tktimex64)(__ccgo_up(bp))).Ftai } if Bool(false) || r != -int32(ENOSYS) { return X__syscall_ret(tls, Uint32FromInt32(r)) @@ -29474,7 +29474,7 @@ func Xclock_adjtime(tls *TLS, clock_id Tclockid_t, utx uintptr) (r1 int32) { return X__syscall_ret(tls, Uint32FromInt32(-Int32FromInt32(EOPNOTSUPP))) } if uint32(8) > uint32(4) { - *(*Tktimex)(unsafe.Pointer(bp + 208)) = Tktimex{ + **(**Tktimex)(__ccgo_up(bp + 208)) = Tktimex{ Fmodes: (*Ttimex)(unsafe.Pointer(utx)).Fmodes, Foffset: (*Ttimex)(unsafe.Pointer(utx)).Foffset, Ffreq: (*Ttimex)(unsafe.Pointer(utx)).Ffreq, @@ -29503,27 +29503,27 @@ func Xclock_adjtime(tls *TLS, clock_id Tclockid_t, utx uintptr) (r1 int32) { r = int32(X__syscall2(tls, int32(SYS_clock_adjtime), clock_id, int32(bp+208))) } if r >= 0 { - (*Ttimex)(unsafe.Pointer(utx)).Fmodes = (*(*Tktimex)(unsafe.Pointer(bp + 208))).Fmodes - (*Ttimex)(unsafe.Pointer(utx)).Foffset = (*(*Tktimex)(unsafe.Pointer(bp + 208))).Foffset - (*Ttimex)(unsafe.Pointer(utx)).Ffreq = (*(*Tktimex)(unsafe.Pointer(bp + 208))).Ffreq - (*Ttimex)(unsafe.Pointer(utx)).Fmaxerror = (*(*Tktimex)(unsafe.Pointer(bp + 208))).Fmaxerror - (*Ttimex)(unsafe.Pointer(utx)).Festerror = (*(*Tktimex)(unsafe.Pointer(bp + 208))).Festerror - (*Ttimex)(unsafe.Pointer(utx)).Fstatus = (*(*Tktimex)(unsafe.Pointer(bp + 208))).Fstatus - (*Ttimex)(unsafe.Pointer(utx)).Fconstant = (*(*Tktimex)(unsafe.Pointer(bp + 208))).Fconstant - (*Ttimex)(unsafe.Pointer(utx)).Fprecision = (*(*Tktimex)(unsafe.Pointer(bp + 208))).Fprecision - (*Ttimex)(unsafe.Pointer(utx)).Ftolerance = (*(*Tktimex)(unsafe.Pointer(bp + 208))).Ftolerance - (*Ttimex)(unsafe.Pointer(utx)).Ftime.Ftv_sec = int64((*(*Tktimex)(unsafe.Pointer(bp + 208))).Ftime_sec) - (*Ttimex)(unsafe.Pointer(utx)).Ftime.Ftv_usec = int64((*(*Tktimex)(unsafe.Pointer(bp + 208))).Ftime_usec) - (*Ttimex)(unsafe.Pointer(utx)).Ftick = (*(*Tktimex)(unsafe.Pointer(bp + 208))).Ftick - (*Ttimex)(unsafe.Pointer(utx)).Fppsfreq = (*(*Tktimex)(unsafe.Pointer(bp + 208))).Fppsfreq - (*Ttimex)(unsafe.Pointer(utx)).Fjitter = (*(*Tktimex)(unsafe.Pointer(bp + 208))).Fjitter - (*Ttimex)(unsafe.Pointer(utx)).Fshift = (*(*Tktimex)(unsafe.Pointer(bp + 208))).Fshift - (*Ttimex)(unsafe.Pointer(utx)).Fstabil = (*(*Tktimex)(unsafe.Pointer(bp + 208))).Fstabil - (*Ttimex)(unsafe.Pointer(utx)).Fjitcnt = (*(*Tktimex)(unsafe.Pointer(bp + 208))).Fjitcnt - (*Ttimex)(unsafe.Pointer(utx)).Fcalcnt = (*(*Tktimex)(unsafe.Pointer(bp + 208))).Fcalcnt - (*Ttimex)(unsafe.Pointer(utx)).Ferrcnt = (*(*Tktimex)(unsafe.Pointer(bp + 208))).Ferrcnt - (*Ttimex)(unsafe.Pointer(utx)).Fstbcnt = (*(*Tktimex)(unsafe.Pointer(bp + 208))).Fstbcnt - (*Ttimex)(unsafe.Pointer(utx)).Ftai = (*(*Tktimex)(unsafe.Pointer(bp + 208))).Ftai + (*Ttimex)(unsafe.Pointer(utx)).Fmodes = (**(**Tktimex)(__ccgo_up(bp + 208))).Fmodes + (*Ttimex)(unsafe.Pointer(utx)).Foffset = (**(**Tktimex)(__ccgo_up(bp + 208))).Foffset + (*Ttimex)(unsafe.Pointer(utx)).Ffreq = (**(**Tktimex)(__ccgo_up(bp + 208))).Ffreq + (*Ttimex)(unsafe.Pointer(utx)).Fmaxerror = (**(**Tktimex)(__ccgo_up(bp + 208))).Fmaxerror + (*Ttimex)(unsafe.Pointer(utx)).Festerror = (**(**Tktimex)(__ccgo_up(bp + 208))).Festerror + (*Ttimex)(unsafe.Pointer(utx)).Fstatus = (**(**Tktimex)(__ccgo_up(bp + 208))).Fstatus + (*Ttimex)(unsafe.Pointer(utx)).Fconstant = (**(**Tktimex)(__ccgo_up(bp + 208))).Fconstant + (*Ttimex)(unsafe.Pointer(utx)).Fprecision = (**(**Tktimex)(__ccgo_up(bp + 208))).Fprecision + (*Ttimex)(unsafe.Pointer(utx)).Ftolerance = (**(**Tktimex)(__ccgo_up(bp + 208))).Ftolerance + (*Ttimex)(unsafe.Pointer(utx)).Ftime.Ftv_sec = int64((**(**Tktimex)(__ccgo_up(bp + 208))).Ftime_sec) + (*Ttimex)(unsafe.Pointer(utx)).Ftime.Ftv_usec = int64((**(**Tktimex)(__ccgo_up(bp + 208))).Ftime_usec) + (*Ttimex)(unsafe.Pointer(utx)).Ftick = (**(**Tktimex)(__ccgo_up(bp + 208))).Ftick + (*Ttimex)(unsafe.Pointer(utx)).Fppsfreq = (**(**Tktimex)(__ccgo_up(bp + 208))).Fppsfreq + (*Ttimex)(unsafe.Pointer(utx)).Fjitter = (**(**Tktimex)(__ccgo_up(bp + 208))).Fjitter + (*Ttimex)(unsafe.Pointer(utx)).Fshift = (**(**Tktimex)(__ccgo_up(bp + 208))).Fshift + (*Ttimex)(unsafe.Pointer(utx)).Fstabil = (**(**Tktimex)(__ccgo_up(bp + 208))).Fstabil + (*Ttimex)(unsafe.Pointer(utx)).Fjitcnt = (**(**Tktimex)(__ccgo_up(bp + 208))).Fjitcnt + (*Ttimex)(unsafe.Pointer(utx)).Fcalcnt = (**(**Tktimex)(__ccgo_up(bp + 208))).Fcalcnt + (*Ttimex)(unsafe.Pointer(utx)).Ferrcnt = (**(**Tktimex)(__ccgo_up(bp + 208))).Ferrcnt + (*Ttimex)(unsafe.Pointer(utx)).Fstbcnt = (**(**Tktimex)(__ccgo_up(bp + 208))).Fstbcnt + (*Ttimex)(unsafe.Pointer(utx)).Ftai = (**(**Tktimex)(__ccgo_up(bp + 208))).Ftai } return X__syscall_ret(tls, Uint32FromInt32(r)) } @@ -30587,12 +30587,12 @@ func Xprlimit(tls *TLS, pid Tpid_t, resource int32, new_limit uintptr, old_limit var _ /* tmp at bp+0 */ Trlimit _ = r if new_limit != 0 && Bool(^Uint64FromUint64(0) != ^Uint64FromUint64(0)) { - *(*Trlimit)(unsafe.Pointer(bp)) = *(*Trlimit)(unsafe.Pointer(new_limit)) - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur >= ^Uint64FromUint64(0) { - (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur = ^Uint64FromUint64(0) + **(**Trlimit)(__ccgo_up(bp)) = **(**Trlimit)(__ccgo_up(new_limit)) + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur >= ^Uint64FromUint64(0) { + (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur = ^Uint64FromUint64(0) } - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_max >= ^Uint64FromUint64(0) { - (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_max = ^Uint64FromUint64(0) + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_max >= ^Uint64FromUint64(0) { + (**(**Trlimit)(__ccgo_up(bp))).Frlim_max = ^Uint64FromUint64(0) } new_limit = bp } @@ -30811,7 +30811,7 @@ func Xptrace(tls *TLS, req int32, va uintptr) (r int32) { if ret < 0 || Uint32FromInt32(req)-uint32(1) >= uint32(3) { return ret } - return *(*int32)(unsafe.Pointer(bp)) + return **(**int32)(__ccgo_up(bp)) } func Xpwritev2(tls *TLS, fd int32, iov uintptr, count int32, ofs Toff_t, flags int32) (r Tssize_t) { @@ -31127,22 +31127,22 @@ func Xstatx(tls *TLS, dirfd int32, path uintptr, flags int32, mask uint32, stx u if ret != 0 { return ret } - (*Tstatx)(unsafe.Pointer(stx)).Fstx_dev_major = uint32((*(*Tstat)(unsafe.Pointer(bp))).Fst_dev>>Int32FromInt32(31)>>Int32FromInt32(1)&Uint64FromUint32(0xfffff000) | (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev>>Int32FromInt32(8)&Uint64FromInt32(0x00000fff)) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_dev_minor = uint32((*(*Tstat)(unsafe.Pointer(bp))).Fst_dev>>Int32FromInt32(12)&Uint64FromUint32(0xffffff00) | (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev&Uint64FromInt32(0x000000ff)) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_ino = (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino - (*Tstatx)(unsafe.Pointer(stx)).Fstx_mode = uint16((*(*Tstat)(unsafe.Pointer(bp))).Fst_mode) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_nlink = (*(*Tstat)(unsafe.Pointer(bp))).Fst_nlink - (*Tstatx)(unsafe.Pointer(stx)).Fstx_uid = (*(*Tstat)(unsafe.Pointer(bp))).Fst_uid - (*Tstatx)(unsafe.Pointer(stx)).Fstx_gid = (*(*Tstat)(unsafe.Pointer(bp))).Fst_gid - (*Tstatx)(unsafe.Pointer(stx)).Fstx_size = Uint64FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_size) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_blksize = Uint32FromInt32((*(*Tstat)(unsafe.Pointer(bp))).Fst_blksize) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_blocks = Uint64FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_blocks) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_atime.Ftv_sec = (*(*Tstat)(unsafe.Pointer(bp))).Fst_atim.Ftv_sec - (*Tstatx)(unsafe.Pointer(stx)).Fstx_atime.Ftv_nsec = Uint32FromInt32((*(*Tstat)(unsafe.Pointer(bp))).Fst_atim.Ftv_nsec) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_mtime.Ftv_sec = (*(*Tstat)(unsafe.Pointer(bp))).Fst_mtim.Ftv_sec - (*Tstatx)(unsafe.Pointer(stx)).Fstx_mtime.Ftv_nsec = Uint32FromInt32((*(*Tstat)(unsafe.Pointer(bp))).Fst_mtim.Ftv_nsec) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_ctime.Ftv_sec = (*(*Tstat)(unsafe.Pointer(bp))).Fst_ctim.Ftv_sec - (*Tstatx)(unsafe.Pointer(stx)).Fstx_ctime.Ftv_nsec = Uint32FromInt32((*(*Tstat)(unsafe.Pointer(bp))).Fst_ctim.Ftv_nsec) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_dev_major = uint32((**(**Tstat)(__ccgo_up(bp))).Fst_dev>>Int32FromInt32(31)>>Int32FromInt32(1)&Uint64FromUint32(0xfffff000) | (**(**Tstat)(__ccgo_up(bp))).Fst_dev>>Int32FromInt32(8)&Uint64FromInt32(0x00000fff)) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_dev_minor = uint32((**(**Tstat)(__ccgo_up(bp))).Fst_dev>>Int32FromInt32(12)&Uint64FromUint32(0xffffff00) | (**(**Tstat)(__ccgo_up(bp))).Fst_dev&Uint64FromInt32(0x000000ff)) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_ino = (**(**Tstat)(__ccgo_up(bp))).Fst_ino + (*Tstatx)(unsafe.Pointer(stx)).Fstx_mode = uint16((**(**Tstat)(__ccgo_up(bp))).Fst_mode) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_nlink = (**(**Tstat)(__ccgo_up(bp))).Fst_nlink + (*Tstatx)(unsafe.Pointer(stx)).Fstx_uid = (**(**Tstat)(__ccgo_up(bp))).Fst_uid + (*Tstatx)(unsafe.Pointer(stx)).Fstx_gid = (**(**Tstat)(__ccgo_up(bp))).Fst_gid + (*Tstatx)(unsafe.Pointer(stx)).Fstx_size = Uint64FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_size) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_blksize = Uint32FromInt32((**(**Tstat)(__ccgo_up(bp))).Fst_blksize) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_blocks = Uint64FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_blocks) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_atime.Ftv_sec = (**(**Tstat)(__ccgo_up(bp))).Fst_atim.Ftv_sec + (*Tstatx)(unsafe.Pointer(stx)).Fstx_atime.Ftv_nsec = Uint32FromInt32((**(**Tstat)(__ccgo_up(bp))).Fst_atim.Ftv_nsec) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_mtime.Ftv_sec = (**(**Tstat)(__ccgo_up(bp))).Fst_mtim.Ftv_sec + (*Tstatx)(unsafe.Pointer(stx)).Fstx_mtime.Ftv_nsec = Uint32FromInt32((**(**Tstat)(__ccgo_up(bp))).Fst_mtim.Ftv_nsec) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_ctime.Ftv_sec = (**(**Tstat)(__ccgo_up(bp))).Fst_ctim.Ftv_sec + (*Tstatx)(unsafe.Pointer(stx)).Fstx_ctime.Ftv_nsec = Uint32FromInt32((**(**Tstat)(__ccgo_up(bp))).Fst_ctim.Ftv_nsec) (*Tstatx)(unsafe.Pointer(stx)).Fstx_btime = Tstatx_timestamp{} (*Tstatx)(unsafe.Pointer(stx)).Fstx_mask = uint32(0x7ff) return 0 @@ -31156,8 +31156,8 @@ func Xstime(tls *TLS, t uintptr) (r int32) { bp := tls.Alloc(16) defer tls.Free(16) var _ /* tv at bp+0 */ Ttimeval - *(*Ttimeval)(unsafe.Pointer(bp)) = Ttimeval{ - Ftv_sec: *(*Ttime_t)(unsafe.Pointer(t)), + **(**Ttimeval)(__ccgo_up(bp)) = Ttimeval{ + Ftv_sec: **(**Ttime_t)(__ccgo_up(t)), } return Xsettimeofday(tls, bp, UintptrFromInt32(0)) } @@ -31275,10 +31275,10 @@ func Xtimerfd_settime(tls *TLS, fd int32, flags int32, new1 uintptr, old uintptr } r = int32(X__syscall4(tls, int32(SYS_timerfd_settime32), fd, flags, int32(bp+32), int32(bp+48))) if !(r != 0) && old != 0 { - (*Titimerspec)(unsafe.Pointer(old)).Fit_interval.Ftv_sec = int64((*(*[4]int32)(unsafe.Pointer(bp + 48)))[0]) - (*Titimerspec)(unsafe.Pointer(old)).Fit_interval.Ftv_nsec = (*(*[4]int32)(unsafe.Pointer(bp + 48)))[int32(1)] - (*Titimerspec)(unsafe.Pointer(old)).Fit_value.Ftv_sec = int64((*(*[4]int32)(unsafe.Pointer(bp + 48)))[int32(2)]) - (*Titimerspec)(unsafe.Pointer(old)).Fit_value.Ftv_nsec = (*(*[4]int32)(unsafe.Pointer(bp + 48)))[int32(3)] + (*Titimerspec)(unsafe.Pointer(old)).Fit_interval.Ftv_sec = int64((**(**[4]int32)(__ccgo_up(bp + 48)))[0]) + (*Titimerspec)(unsafe.Pointer(old)).Fit_interval.Ftv_nsec = (**(**[4]int32)(__ccgo_up(bp + 48)))[int32(1)] + (*Titimerspec)(unsafe.Pointer(old)).Fit_value.Ftv_sec = int64((**(**[4]int32)(__ccgo_up(bp + 48)))[int32(2)]) + (*Titimerspec)(unsafe.Pointer(old)).Fit_value.Ftv_nsec = (**(**[4]int32)(__ccgo_up(bp + 48)))[int32(3)] } return X__syscall_ret(tls, Uint32FromInt32(r)) return X__syscall_ret(tls, Uint32FromInt32(X__syscall4(tls, int32(SYS_timerfd_settime32), fd, flags, int32(new1), int32(old)))) @@ -31303,10 +31303,10 @@ func Xtimerfd_gettime(tls *TLS, fd int32, cur uintptr) (r1 int32) { } r = int32(X__syscall2(tls, int32(SYS_timerfd_gettime32), fd, int32(bp))) if !(r != 0) { - (*Titimerspec)(unsafe.Pointer(cur)).Fit_interval.Ftv_sec = int64((*(*[4]int32)(unsafe.Pointer(bp)))[0]) - (*Titimerspec)(unsafe.Pointer(cur)).Fit_interval.Ftv_nsec = (*(*[4]int32)(unsafe.Pointer(bp)))[int32(1)] - (*Titimerspec)(unsafe.Pointer(cur)).Fit_value.Ftv_sec = int64((*(*[4]int32)(unsafe.Pointer(bp)))[int32(2)]) - (*Titimerspec)(unsafe.Pointer(cur)).Fit_value.Ftv_nsec = (*(*[4]int32)(unsafe.Pointer(bp)))[int32(3)] + (*Titimerspec)(unsafe.Pointer(cur)).Fit_interval.Ftv_sec = int64((**(**[4]int32)(__ccgo_up(bp)))[0]) + (*Titimerspec)(unsafe.Pointer(cur)).Fit_interval.Ftv_nsec = (**(**[4]int32)(__ccgo_up(bp)))[int32(1)] + (*Titimerspec)(unsafe.Pointer(cur)).Fit_value.Ftv_sec = int64((**(**[4]int32)(__ccgo_up(bp)))[int32(2)]) + (*Titimerspec)(unsafe.Pointer(cur)).Fit_value.Ftv_nsec = (**(**[4]int32)(__ccgo_up(bp)))[int32(3)] } return X__syscall_ret(tls, Uint32FromInt32(r)) return X__syscall_ret(tls, Uint32FromInt32(X__syscall2(tls, int32(SYS_timerfd_gettime32), fd, int32(cur)))) @@ -31426,12 +31426,12 @@ func Xwait4(tls *TLS, pid Tpid_t, status uintptr, options int32, ru uintptr) (r1 if r > 0 && ru != 0 && Bool(uint32(8) > uint32(4)) { _memcpy(tls, bp, dest, Uint32FromInt32(4)*Uint32FromInt64(4)) (*Trusage)(unsafe.Pointer(ru)).Fru_utime = Ttimeval{ - Ftv_sec: int64((*(*[4]int32)(unsafe.Pointer(bp)))[0]), - Ftv_usec: int64((*(*[4]int32)(unsafe.Pointer(bp)))[int32(1)]), + Ftv_sec: int64((**(**[4]int32)(__ccgo_up(bp)))[0]), + Ftv_usec: int64((**(**[4]int32)(__ccgo_up(bp)))[int32(1)]), } (*Trusage)(unsafe.Pointer(ru)).Fru_stime = Ttimeval{ - Ftv_sec: int64((*(*[4]int32)(unsafe.Pointer(bp)))[int32(2)]), - Ftv_usec: int64((*(*[4]int32)(unsafe.Pointer(bp)))[int32(3)]), + Ftv_sec: int64((**(**[4]int32)(__ccgo_up(bp)))[int32(2)]), + Ftv_usec: int64((**(**[4]int32)(__ccgo_up(bp)))[int32(3)]), } } return X__syscall_ret(tls, Uint32FromInt32(r)) @@ -31554,7 +31554,7 @@ func X__lctrans_cur(tls *TLS, msg uintptr) (r uintptr) { trc("tls=%v msg=%v, (%v:)", tls, msg, origin(2)) defer func() { trc("-> %v", r) }() } - return X__lctrans_impl(tls, msg, *(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale + 5*4))) + return X__lctrans_impl(tls, msg, **(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale + 5*4))) } func _swapc(tls *TLS, x Tuint32_t, c int32) (r Tuint32_t) { @@ -31578,27 +31578,27 @@ func X__mo_lookup(tls *TLS, p uintptr, size Tsize_t, s uintptr) (r uintptr) { var sign, sw int32 _, _, _, _, _, _, _, _, _, _, _ = b, mo, n, o, ol, os, sign, sw, t, tl, ts mo = p - sw = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(mo)) - uint32(0x950412de)) + sw = Int32FromUint32(**(**Tuint32_t)(__ccgo_up(mo)) - uint32(0x950412de)) b = uint32(0) - n = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + 2*4)), sw) - o = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + 3*4)), sw) - t = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + 4*4)), sw) + n = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + 2*4)), sw) + o = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + 3*4)), sw) + t = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + 4*4)), sw) if n >= size/uint32(4) || o >= size-uint32(4)*n || t >= size-uint32(4)*n || (o|t)%uint32(4) != 0 { return uintptr(0) } o = o / uint32(4) t = t / uint32(4) for { - ol = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + uintptr(o+uint32(2)*(b+n/uint32(2)))*4)), sw) - os = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + uintptr(o+uint32(2)*(b+n/uint32(2))+uint32(1))*4)), sw) - if os >= size || ol >= size-os || *(*uint8)(unsafe.Pointer(p + uintptr(os+ol))) != 0 { + ol = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + uintptr(o+uint32(2)*(b+n/uint32(2)))*4)), sw) + os = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + uintptr(o+uint32(2)*(b+n/uint32(2))+uint32(1))*4)), sw) + if os >= size || ol >= size-os || **(**uint8)(__ccgo_up(p + uintptr(os+ol))) != 0 { return uintptr(0) } sign = Xstrcmp(tls, s, p+uintptr(os)) if !(sign != 0) { - tl = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + uintptr(t+uint32(2)*(b+n/uint32(2)))*4)), sw) - ts = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + uintptr(t+uint32(2)*(b+n/uint32(2))+uint32(1))*4)), sw) - if ts >= size || tl >= size-ts || *(*uint8)(unsafe.Pointer(p + uintptr(ts+tl))) != 0 { + tl = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + uintptr(t+uint32(2)*(b+n/uint32(2)))*4)), sw) + ts = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + uintptr(t+uint32(2)*(b+n/uint32(2))+uint32(1))*4)), sw) + if ts >= size || tl >= size-ts || **(**uint8)(__ccgo_up(p + uintptr(ts+tl))) != 0 { return uintptr(0) } return p + uintptr(ts) @@ -31628,7 +31628,7 @@ func Xbind_textdomain_codeset(tls *TLS, domainname uintptr, codeset uintptr) (r defer func() { trc("-> %v", r) }() } if codeset != 0 && Xstrcasecmp(tls, codeset, __ccgo_ts+322) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) } return UintptrFromInt32(0) } @@ -31656,7 +31656,7 @@ func Xcatclose(tls *TLS, catd Tnl_catd) (r int32) { var v1, v2 Tuint32_t _, _, _ = map1, v1, v2 map1 = catd - v1 = *(*Tuint32_t)(unsafe.Pointer(map1 + UintptrFromInt32(8))) + v1 = **(**Tuint32_t)(__ccgo_up(map1 + UintptrFromInt32(8))) v2 = v1>>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v4>>int32(8)&uint32(0xff00) | v4<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v4>>int32(8)&uint32(0xff00) | v4<>int32(24) | v7>>int32(8)&uint32(0xff00) | v7<>int32(24) | v10>>int32(8)&uint32(0xff00) | v10<>int32(24) | v13>>int32(8)&uint32(0xff00) | v13<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v4>>int32(8)&uint32(0xff00) | v4<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v5>>int32(8)&uint32(0xff00) | v5< uint32(NAME_MAX) || dirlen >= uint32(PATH_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } ___lock(tls, uintptr(unsafe.Pointer(&_lock1))) @@ -32135,7 +32135,7 @@ func Xdcngettext(tls *TLS, domainname uintptr, msgid1 uintptr, msgid2 uintptr, n _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = alt_modlen, catlen, catname, csp, dirlen, dirname, domlen, l, lm, loc, loclen, locname, locp, map1, modlen, modname, name, np, old, old_cats, old_errno, p2, plural, q, r, rem, rule, trans, v11, v12, v23, v3, v5, v6, v8 defer func() { Xrealloc(tls, name, 0) }() loc = (*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale - old_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + old_errno = **(**int32)(__ccgo_up(X__errno_location(tls))) /* match gnu gettext behaviour */ if !(msgid1 != 0) { goto notrans @@ -32166,14 +32166,14 @@ func Xdcngettext(tls *TLS, domainname uintptr, msgid1 uintptr, msgid2 uintptr, n if !(q != 0) { goto notrans } - lm = *(*uintptr)(unsafe.Pointer(loc + uintptr(category)*4)) + lm = **(**uintptr)(__ccgo_up(loc + uintptr(category)*4)) if !!(lm != 0) { goto _2 } goto notrans notrans: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = old_errno + **(**int32)(__ccgo_up(X__errno_location(tls))) = old_errno if n == uint32(1) { v3 = msgid1 } else { @@ -32246,21 +32246,21 @@ _2: } p2 = Xcalloc(tls, uint32(32), uint32(1)) if !(p2 != 0) { - X__munmap(tls, map1, *(*Tsize_t)(unsafe.Pointer(bp))) + X__munmap(tls, map1, **(**Tsize_t)(__ccgo_up(bp))) goto notrans } (*Tmsgcat)(unsafe.Pointer(p2)).Fcat = category (*Tmsgcat)(unsafe.Pointer(p2)).Fbinding = q (*Tmsgcat)(unsafe.Pointer(p2)).Flm = lm (*Tmsgcat)(unsafe.Pointer(p2)).Fmap1 = map1 - (*Tmsgcat)(unsafe.Pointer(p2)).Fmap_size = *(*Tsize_t)(unsafe.Pointer(bp)) + (*Tmsgcat)(unsafe.Pointer(p2)).Fmap_size = **(**Tsize_t)(__ccgo_up(bp)) rule = __ccgo_ts + 381 np = uint32(2) r = X__mo_lookup(tls, (*Tmsgcat)(unsafe.Pointer(p2)).Fmap1, (*Tmsgcat)(unsafe.Pointer(p2)).Fmap_size, __ccgo_ts) for r != 0 && Xstrncmp(tls, r, __ccgo_ts+387, uint32(13)) != 0 { - *(*uintptr)(unsafe.Pointer(bp + 4)) = Xstrchr(tls, r, int32('\n')) - if *(*uintptr)(unsafe.Pointer(bp + 4)) != 0 { - v3 = *(*uintptr)(unsafe.Pointer(bp + 4)) + uintptr(1) + **(**uintptr)(__ccgo_up(bp + 4)) = Xstrchr(tls, r, int32('\n')) + if **(**uintptr)(__ccgo_up(bp + 4)) != 0 { + v3 = **(**uintptr)(__ccgo_up(bp + 4)) + uintptr(1) } else { v3 = uintptr(0) } @@ -32269,7 +32269,7 @@ _2: if r != 0 { r = r + uintptr(13) for { - v11 = Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) + v11 = Int32FromUint8(**(**uint8)(__ccgo_up(r))) v12 = BoolInt32(v11 == int32(' ') || Uint32FromInt32(v11)-uint32('\t') < uint32(5)) goto _13 _13: @@ -32280,15 +32280,15 @@ _2: } if !(Xstrncmp(tls, r, __ccgo_ts+401, uint32(9)) != 0) { np = Xstrtoul(tls, r+uintptr(9), bp+4, int32(10)) - r = *(*uintptr)(unsafe.Pointer(bp + 4)) + r = **(**uintptr)(__ccgo_up(bp + 4)) } - for *(*uint8)(unsafe.Pointer(r)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) != int32(';') { + for **(**uint8)(__ccgo_up(r)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(r))) != int32(';') { r = r + 1 } - if *(*uint8)(unsafe.Pointer(r)) != 0 { + if **(**uint8)(__ccgo_up(r)) != 0 { r = r + 1 for { - v11 = Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) + v11 = Int32FromUint8(**(**uint8)(__ccgo_up(r))) v12 = BoolInt32(v11 == int32(' ') || Uint32FromInt32(v11)-uint32('\t') < uint32(5)) goto _16 _16: @@ -32353,7 +32353,7 @@ _2: trans = trans + uintptr(l+uint32(1)) } } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = old_errno + **(**int32)(__ccgo_up(X__errno_location(tls))) = old_errno return trans } @@ -32397,7 +32397,7 @@ func X__duplocale(tls *TLS, old Tlocale_t) (r Tlocale_t) { if old == uintptr(-Int32FromInt32(1)) { old = uintptr(unsafe.Pointer(&X__libc)) + 32 } - *(*t__locale_struct)(unsafe.Pointer(new1)) = *(*t__locale_struct)(unsafe.Pointer(old)) + **(**t__locale_struct)(__ccgo_up(new1)) = **(**t__locale_struct)(__ccgo_up(old)) return new1 } @@ -98571,13 +98571,13 @@ var _rev_jis = [6879]uint16{ func _fuzzycmp(tls *TLS, a uintptr, b uintptr) (r int32) { for { - if !(*(*uint8)(unsafe.Pointer(a)) != 0 && *(*uint8)(unsafe.Pointer(b)) != 0) { + if !(**(**uint8)(__ccgo_up(a)) != 0 && **(**uint8)(__ccgo_up(b)) != 0) { break } - for *(*uint8)(unsafe.Pointer(a)) != 0 && uint32(*(*uint8)(unsafe.Pointer(a)))|uint32(32)-uint32('a') > uint32(26) && Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(a)))-int32('0')) > uint32(10) { + for **(**uint8)(__ccgo_up(a)) != 0 && uint32(**(**uint8)(__ccgo_up(a)))|uint32(32)-uint32('a') > uint32(26) && Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(a)))-int32('0')) > uint32(10) { a = a + 1 } - if uint32(*(*uint8)(unsafe.Pointer(a)))|uint32(32) != uint32(*(*uint8)(unsafe.Pointer(b))) { + if uint32(**(**uint8)(__ccgo_up(a)))|uint32(32) != uint32(**(**uint8)(__ccgo_up(b))) { return int32(1) } goto _1 @@ -98586,23 +98586,23 @@ func _fuzzycmp(tls *TLS, a uintptr, b uintptr) (r int32) { a = a + 1 b = b + 1 } - return BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(a))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(b)))) + return BoolInt32(Int32FromUint8(**(**uint8)(__ccgo_up(a))) != Int32FromUint8(**(**uint8)(__ccgo_up(b)))) } func _find_charmap(tls *TLS, name uintptr) (r Tsize_t) { var s uintptr _ = s - if !(*(*uint8)(unsafe.Pointer(name)) != 0) { + if !(**(**uint8)(__ccgo_up(name)) != 0) { name = uintptr(unsafe.Pointer(&_charmaps)) } /* "utf8" */ s = uintptr(unsafe.Pointer(&_charmaps)) for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { break } if !(_fuzzycmp(tls, name, s) != 0) { for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { break } goto _2 @@ -98613,11 +98613,11 @@ func _find_charmap(tls *TLS, name uintptr) (r Tsize_t) { return Uint32FromInt32(int32(s+uintptr(1)) - t__predefined_ptrdiff_t(uintptr(unsafe.Pointer(&_charmaps)))) } s = s + uintptr(_strlen(tls, s)+uint32(1)) - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) > int32(0200) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { + if Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) > int32(0200) { s = s + uintptr(2) } else { - s = s + uintptr(uint32(2)+(uint32(64)-uint32(*(*uint8)(unsafe.Pointer(s + 1))))*uint32(5)) + s = s + uintptr(uint32(2)+(uint32(64)-uint32(**(**uint8)(__ccgo_up(s + 1))))*uint32(5)) } } goto _1 @@ -98660,7 +98660,7 @@ func Xiconv_open(tls *TLS, to uintptr, from uintptr) (r Ticonv_t) { f = v2 } if v3 || v2 == Uint32FromInt32(-Int32FromInt32(1)) || Int32FromUint8(_charmaps[t]) >= int32(0330) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(-Int32FromInt32(1)) } cd = _combine_to_from(tls, t, f) @@ -98685,26 +98685,26 @@ func Xiconv_open(tls *TLS, to uintptr, from uintptr) (r Ticonv_t) { func _get_16(tls *TLS, s uintptr, e int32) (r uint32) { e = e & int32(1) - return Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(e))))<> int32(8)) - *(*uint8)(unsafe.Pointer(s + uintptr(int32(1)-e))) = uint8(c) + **(**uint8)(__ccgo_up(s + uintptr(e))) = uint8(c >> int32(8)) + **(**uint8)(__ccgo_up(s + uintptr(int32(1)-e))) = uint8(c) } func _get_32(tls *TLS, s uintptr, e int32) (r uint32) { e = e & int32(3) - return (uint32(*(*uint8)(unsafe.Pointer(s + uintptr(e))))+0)<> int32(24)) - *(*uint8)(unsafe.Pointer(s + uintptr(e^int32(1)))) = uint8(c >> int32(16)) - *(*uint8)(unsafe.Pointer(s + uintptr(e^int32(2)))) = uint8(c >> int32(8)) - *(*uint8)(unsafe.Pointer(s + uintptr(e^int32(3)))) = uint8(c) + **(**uint8)(__ccgo_up(s + uintptr(e^0))) = uint8(c >> int32(24)) + **(**uint8)(__ccgo_up(s + uintptr(e^int32(1)))) = uint8(c >> int32(16)) + **(**uint8)(__ccgo_up(s + uintptr(e^int32(2)))) = uint8(c >> int32(8)) + **(**uint8)(__ccgo_up(s + uintptr(e^int32(3)))) = uint8(c) } /* Adapt as needed */ @@ -98712,11 +98712,11 @@ func _put_32(tls *TLS, s uintptr, c uint32, e int32) { func _legacy_map(tls *TLS, map1 uintptr, c uint32) (r uint32) { var x, v1 uint32 _, _ = x, v1 - if c < Uint32FromInt32(int32(4)*Int32FromUint8(*(*uint8)(unsafe.Pointer(map1 + uintptr(-Int32FromInt32(1)))))) { + if c < Uint32FromInt32(int32(4)*Int32FromUint8(**(**uint8)(__ccgo_up(map1 + uintptr(-Int32FromInt32(1)))))) { return c } - x = c - Uint32FromInt32(int32(4)*Int32FromUint8(*(*uint8)(unsafe.Pointer(map1 + uintptr(-Int32FromInt32(1)))))) - x = Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(map1 + uintptr(x*uint32(5)/uint32(4)))))>>(uint32(2)*x%uint32(8)) | Int32FromUint8(*(*uint8)(unsafe.Pointer(map1 + uintptr(x*uint32(5)/uint32(4)+uint32(1)))))<<(uint32(8)-uint32(2)*x%uint32(8))&int32(1023)) + x = c - Uint32FromInt32(int32(4)*Int32FromUint8(**(**uint8)(__ccgo_up(map1 + uintptr(-Int32FromInt32(1)))))) + x = Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(map1 + uintptr(x*uint32(5)/uint32(4)))))>>(uint32(2)*x%uint32(8)) | Int32FromUint8(**(**uint8)(__ccgo_up(map1 + uintptr(x*uint32(5)/uint32(4)+uint32(1)))))<<(uint32(8)-uint32(2)*x%uint32(8))&int32(1023)) if x < uint32(256) { v1 = x } else { @@ -98733,7 +98733,7 @@ func _uni_to_jis(tls *TLS, c uint32) (r uint32) { for { i = nel / uint32(2) j = uint32(_rev_jis[b+i]) - d = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(j/uint32(256))*188 + uintptr(j%uint32(256))*2))) + d = uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(j/uint32(256))*188 + uintptr(j%uint32(256))*2))) if d == c { return j + uint32(0x2121) } else { @@ -98786,20 +98786,20 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui from = _extract_from(tls, cd) map1 = uintptr(unsafe.Pointer(&_charmaps)) + uintptr(from) + uintptr(1) tomap = uintptr(unsafe.Pointer(&_charmaps)) + uintptr(to) + uintptr(1) - *(*Tmbstate_t)(unsafe.Pointer(bp + 16)) = Tmbstate_t{} - type1 = *(*uint8)(unsafe.Pointer(map1 + uintptr(-Int32FromInt32(1)))) - totype = *(*uint8)(unsafe.Pointer(tomap + uintptr(-Int32FromInt32(1)))) + **(**Tmbstate_t)(__ccgo_up(bp + 16)) = Tmbstate_t{} + type1 = **(**uint8)(__ccgo_up(map1 + uintptr(-Int32FromInt32(1)))) + totype = **(**uint8)(__ccgo_up(tomap + uintptr(-Int32FromInt32(1)))) ploc = uintptr(___get_tp(tls)) + 88 - loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) - if !(in != 0) || !(*(*uintptr)(unsafe.Pointer(in)) != 0) || !(*(*Tsize_t)(unsafe.Pointer(inb)) != 0) { + loc = **(**Tlocale_t)(__ccgo_up(ploc)) + if !(in != 0) || !(**(**uintptr)(__ccgo_up(in)) != 0) || !(**(**Tsize_t)(__ccgo_up(inb)) != 0) { return uint32(0) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = uintptr(unsafe.Pointer(&X__c_dot_utf8_locale)) + **(**Tlocale_t)(__ccgo_up(ploc)) = uintptr(unsafe.Pointer(&X__c_dot_utf8_locale)) for { - if !(*(*Tsize_t)(unsafe.Pointer(inb)) != 0) { + if !(**(**Tsize_t)(__ccgo_up(inb)) != 0) { break } - c = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in))))) + c = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in))))) l = uint32(1) switch Int32FromUint8(type1) { case int32(UTF_8): @@ -98851,14 +98851,14 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if c < uint32(128) { goto _23 } - l = Xmbrtowc(tls, bp+24, *(*uintptr)(unsafe.Pointer(in)), *(*Tsize_t)(unsafe.Pointer(inb)), bp+16) + l = Xmbrtowc(tls, bp+24, **(**uintptr)(__ccgo_up(in)), **(**Tsize_t)(__ccgo_up(inb)), bp+16) if l == Uint32FromInt32(-Int32FromInt32(1)) { goto ilseq } if l == Uint32FromInt32(-Int32FromInt32(2)) { goto starved } - c = *(*Twchar_t)(unsafe.Pointer(bp + 24)) + c = **(**Twchar_t)(__ccgo_up(bp + 24)) goto _23 _3: ; @@ -98869,10 +98869,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui _4: ; l = uint32(4) - if *(*Tsize_t)(unsafe.Pointer(inb)) < l { + if **(**Tsize_t)(__ccgo_up(inb)) < l { goto starved } - c = *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)))) + c = **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(in)))) if !(0 != 0) { goto _24 } @@ -98881,10 +98881,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui _5: ; l = uint32(4) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint32(4) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint32(4) { goto starved } - c = _get_32(tls, *(*uintptr)(unsafe.Pointer(in)), Int32FromUint8(type1)) + c = _get_32(tls, **(**uintptr)(__ccgo_up(in)), Int32FromUint8(type1)) _24: ; if c-uint32(0xd800) < uint32(0x800) || c >= uint32(0x110000) { @@ -98900,10 +98900,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui _7: ; l = uint32(2) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint32(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint32(2) { goto starved } - c = _get_16(tls, *(*uintptr)(unsafe.Pointer(in)), Int32FromUint8(type1)) + c = _get_16(tls, **(**uintptr)(__ccgo_up(in)), Int32FromUint8(type1)) if c-Uint32FromInt32(0xdc00) < uint32(0x400) { goto ilseq } @@ -98912,10 +98912,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto ilseq } l = uint32(4) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint32(4) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint32(4) { goto starved } - d = _get_16(tls, *(*uintptr)(unsafe.Pointer(in))+UintptrFromInt32(2), Int32FromUint8(type1)) + d = _get_16(tls, **(**uintptr)(__ccgo_up(in))+UintptrFromInt32(2), Int32FromUint8(type1)) if d-Uint32FromInt32(0xdc00) >= uint32(0x400) { goto ilseq } @@ -98928,10 +98928,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui ; l = uint32(0) if !((*Tstateful_cd)(unsafe.Pointer(scd)).Fstate != 0) { - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint32(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint32(2) { goto starved } - c = _get_16(tls, *(*uintptr)(unsafe.Pointer(in)), 0) + c = _get_16(tls, **(**uintptr)(__ccgo_up(in)), 0) if Int32FromUint8(type1) == int32(UCS2) { if c == uint32(0xfffe) { v26 = int32(UCS2LE) @@ -98958,10 +98958,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui ; l = uint32(0) if !((*Tstateful_cd)(unsafe.Pointer(scd)).Fstate != 0) { - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint32(4) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint32(4) { goto starved } - c = _get_32(tls, *(*uintptr)(unsafe.Pointer(in)), 0) + c = _get_32(tls, **(**uintptr)(__ccgo_up(in)), 0) if c == uint32(0xfffe0000) { v25 = int32(UTF_32LE) } else { @@ -98984,10 +98984,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _23 } l = uint32(2) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint32(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint32(2) { goto starved } - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(1)))) if c-uint32(129) <= Uint32FromInt32(Int32FromInt32(159)-Int32FromInt32(129)) { c = c - uint32(129) } else { @@ -99015,7 +99015,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if c >= uint32(84) { goto ilseq } - c = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(c)*188 + uintptr(d)*2))) + c = uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(c)*188 + uintptr(d)*2))) if !(c != 0) { goto ilseq } @@ -99026,10 +99026,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _23 } l = uint32(2) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint32(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint32(2) { goto starved } - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(1)))) if c == uint32(0x8e) { c = d if c-uint32(0xa1) > Uint32FromInt32(Int32FromInt32(0xdf)-Int32FromInt32(0xa1)) { @@ -99043,7 +99043,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if c >= uint32(84) || d >= uint32(94) { goto ilseq } - c = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(c)*188 + uintptr(d)*2))) + c = uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(c)*188 + uintptr(d)*2))) if !(c != 0) { goto ilseq } @@ -99055,11 +99055,11 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } if c == uint32('\033') { l = uint32(3) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint32(3) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint32(3) { goto starved } - c = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(2)))) + c = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(1)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(2)))) if c != uint32('(') && c != uint32('$') { goto ilseq } @@ -99094,16 +99094,16 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui fallthrough case uint32(3): l = uint32(2) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint32(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint32(2) { goto starved } - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(1)))) c = c - uint32(0x21) d = d - uint32(0x21) if c >= uint32(84) || d >= uint32(94) { goto ilseq } - c = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(c)*188 + uintptr(d)*2))) + c = uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(c)*188 + uintptr(d)*2))) if !(c != 0) { goto ilseq } @@ -99141,10 +99141,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto ilseq } l = uint32(2) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint32(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint32(2) { goto starved } - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(1)))) if d < uint32(0xa1) && Int32FromUint8(type1) == int32(GB2312) { goto ilseq } @@ -99153,16 +99153,16 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto ilseq } l = uint32(4) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint32(4) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint32(4) { goto starved } c = (uint32(10)*c + d - uint32('0')) * uint32(1260) - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(2)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(2)))) if d-uint32(0x81) > uint32(126) { goto ilseq } c = c + uint32(10)*(d-uint32(0x81)) - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(3)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(3)))) if d-uint32('0') > uint32(9) { goto ilseq } @@ -99184,7 +99184,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if !(j < int32(190)) { break } - if uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_gb18030)) + uintptr(i)*380 + uintptr(j)*2)))-d <= c-d { + if uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_gb18030)) + uintptr(i)*380 + uintptr(j)*2)))-d <= c-d { k = k + 1 } goto _31 @@ -99208,7 +99208,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if d > uint32(63) { d = d - 1 } - c = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_gb18030)) + uintptr(c)*380 + uintptr(d)*2))) + c = uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_gb18030)) + uintptr(c)*380 + uintptr(d)*2))) goto _23 _20: ; @@ -99216,10 +99216,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _23 } l = uint32(2) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint32(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint32(2) { goto starved } - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(1)))) if d-uint32(0x40) >= Uint32FromInt32(Int32FromInt32(0xff)-Int32FromInt32(0x40)) || d-uint32(0x7f) < Uint32FromInt32(Int32FromInt32(0xa1)-Int32FromInt32(0x7f)) { goto ilseq } @@ -99242,21 +99242,21 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui * range in the hkscs table then hard-coded * here. Ugly, yes. */ if c/uint32(256) == uint32(0xdc) { - *(*uintptr)(unsafe.Pointer(bp + 40)) = bp + 32 + **(**uintptr)(__ccgo_up(bp + 40)) = bp + 32 *(*uintptr)(unsafe.Pointer(bp)) = __ccgo_ts + 419 + uintptr(c%uint32(256)) *(*Tsize_t)(unsafe.Pointer(bp + 4)) = uint32(4) *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint32(8) tmpx = Xiconv(tls, _combine_to_from(tls, to, _find_charmap(tls, __ccgo_ts+436)), bp, bp+4, bp+40, bp+8) - tmplen = Uint32FromInt32(int32(*(*uintptr)(unsafe.Pointer(bp + 40))) - t__predefined_ptrdiff_t(bp+32)) - if tmplen > *(*Tsize_t)(unsafe.Pointer(outb)) { + tmplen = Uint32FromInt32(int32(**(**uintptr)(__ccgo_up(bp + 40))) - t__predefined_ptrdiff_t(bp+32)) + if tmplen > **(**Tsize_t)(__ccgo_up(outb)) { goto toobig } if tmpx != 0 { x = x + 1 } - _memcpy(tls, *(*uintptr)(unsafe.Pointer(out)), bp+32, tmplen) - *(*uintptr)(unsafe.Pointer(out)) += uintptr(tmplen) - *(*Tsize_t)(unsafe.Pointer(outb)) -= tmplen + _memcpy(tls, **(**uintptr)(__ccgo_up(out)), bp+32, tmplen) + **(**uintptr)(__ccgo_up(out)) += uintptr(tmplen) + **(**Tsize_t)(__ccgo_up(outb)) -= tmplen goto _1 } if !(c != 0) { @@ -99265,7 +99265,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _23 } c = c - uint32(0xa1) - c = Uint32FromInt32(Int32FromUint16(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_big5)) + uintptr(c)*314 + uintptr(d)*2))) | BoolInt32(c == uint32(0x27) && (d == uint32(0x3a) || d == uint32(0x3c) || d == uint32(0x42)))<= uint32(93) || d >= uint32(94) { @@ -99323,7 +99323,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if !(j1 < int32(94)) { break } - if uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ksc)) + uintptr(i1)*188 + uintptr(j1)*2)))-d <= c-d { + if uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_ksc)) + uintptr(i1)*188 + uintptr(j1)*2)))-d <= c-d { k = k + 1 } goto _34 @@ -99343,7 +99343,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } goto _23 } - c = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ksc)) + uintptr(c)*188 + uintptr(d)*2))) + c = uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_ksc)) + uintptr(c)*188 + uintptr(d)*2))) if !(c != 0) { goto ilseq } @@ -99396,26 +99396,26 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _51 _35: ; - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint32(4) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint32(4) { goto toobig } - *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(out)))) = c - *(*uintptr)(unsafe.Pointer(out)) += uintptr(4) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint32(4) + **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(out)))) = c + **(**uintptr)(__ccgo_up(out)) += uintptr(4) + **(**Tsize_t)(__ccgo_up(outb)) -= uint32(4) goto _51 _36: ; - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint32(4) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint32(4) { k = Uint32FromInt32(Xwctomb(tls, bp+44, c)) - if *(*Tsize_t)(unsafe.Pointer(outb)) < k { + if **(**Tsize_t)(__ccgo_up(outb)) < k { goto toobig } - _memcpy(tls, *(*uintptr)(unsafe.Pointer(out)), bp+44, k) + _memcpy(tls, **(**uintptr)(__ccgo_up(out)), bp+44, k) } else { - k = Uint32FromInt32(Xwctomb(tls, *(*uintptr)(unsafe.Pointer(out)), c)) + k = Uint32FromInt32(Xwctomb(tls, **(**uintptr)(__ccgo_up(out)), c)) } - *(*uintptr)(unsafe.Pointer(out)) += uintptr(k) - *(*Tsize_t)(unsafe.Pointer(outb)) -= k + **(**uintptr)(__ccgo_up(out)) += uintptr(k) + **(**Tsize_t)(__ccgo_up(outb)) -= k goto _51 _37: ; @@ -99431,7 +99431,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui ; _38: ; - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint32(1) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint32(1) { goto toobig } if !(c < uint32(256) && c == _legacy_map(tls, tomap, c)) { @@ -99440,14 +99440,14 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto revout revout: ; - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint32(1) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint32(1) { goto toobig } v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8(c) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint32(1) + **(**uint8)(__ccgo_up(v54)) = uint8(c) + **(**Tsize_t)(__ccgo_up(outb)) -= uint32(1) goto _51 _53: ; @@ -99489,7 +99489,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if !(c != 0) { goto subst } - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint32(2) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint32(2) { goto toobig } d = c % uint32(256) @@ -99502,7 +99502,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } else { v25 = int32(176) } - *(*uint8)(unsafe.Pointer(v54)) = uint8((c+uint32(1))/uint32(2) + Uint32FromInt32(v25)) + **(**uint8)(__ccgo_up(v54)) = uint8((c+uint32(1))/uint32(2) + Uint32FromInt32(v25)) v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 @@ -99511,8 +99511,8 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } else { v62 = d + uint32(126) } - *(*uint8)(unsafe.Pointer(v54)) = uint8(v62) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint32(2) + **(**uint8)(__ccgo_up(v54)) = uint8(v62) + **(**Tsize_t)(__ccgo_up(outb)) -= uint32(2) goto _51 _40: ; @@ -99527,18 +99527,18 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if !(c != 0) { goto subst } - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint32(2) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint32(2) { goto toobig } v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8(c/uint32(256) + uint32(0x80)) + **(**uint8)(__ccgo_up(v54)) = uint8(c/uint32(256) + uint32(0x80)) v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8(c%uint32(256) + uint32(0x80)) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint32(2) + **(**uint8)(__ccgo_up(v54)) = uint8(c%uint32(256) + uint32(0x80)) + **(**Tsize_t)(__ccgo_up(outb)) -= uint32(2) goto _51 _41: ; @@ -99546,102 +99546,102 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto revout } if c-uint32(0xff61) <= Uint32FromInt32(Int32FromInt32(0xdf)-Int32FromInt32(0xa1)) || c == uint32(0xa5) || c == uint32(0x203e) { - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint32(7) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint32(7) { goto toobig } v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('\033') + **(**uint8)(__ccgo_up(v54)) = uint8('\033') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('(') + **(**uint8)(__ccgo_up(v54)) = uint8('(') if c == uint32(0xa5) { v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('J') + **(**uint8)(__ccgo_up(v54)) = uint8('J') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('\\') + **(**uint8)(__ccgo_up(v54)) = uint8('\\') } else { if c == uint32(0x203e) { v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('J') + **(**uint8)(__ccgo_up(v54)) = uint8('J') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('~') + **(**uint8)(__ccgo_up(v54)) = uint8('~') } else { v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('I') + **(**uint8)(__ccgo_up(v54)) = uint8('I') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8(c - uint32(0xff61) + uint32(0x21)) + **(**uint8)(__ccgo_up(v54)) = uint8(c - uint32(0xff61) + uint32(0x21)) } } v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('\033') + **(**uint8)(__ccgo_up(v54)) = uint8('\033') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('(') + **(**uint8)(__ccgo_up(v54)) = uint8('(') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('B') - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint32(7) + **(**uint8)(__ccgo_up(v54)) = uint8('B') + **(**Tsize_t)(__ccgo_up(outb)) -= uint32(7) goto _51 } c = _uni_to_jis(tls, c) if !(c != 0) { goto subst } - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint32(8) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint32(8) { goto toobig } v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('\033') + **(**uint8)(__ccgo_up(v54)) = uint8('\033') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('$') + **(**uint8)(__ccgo_up(v54)) = uint8('$') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('B') + **(**uint8)(__ccgo_up(v54)) = uint8('B') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8(c / uint32(256)) + **(**uint8)(__ccgo_up(v54)) = uint8(c / uint32(256)) v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8(c % uint32(256)) + **(**uint8)(__ccgo_up(v54)) = uint8(c % uint32(256)) v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('\033') + **(**uint8)(__ccgo_up(v54)) = uint8('\033') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('(') + **(**uint8)(__ccgo_up(v54)) = uint8('(') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('B') - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint32(8) + **(**uint8)(__ccgo_up(v54)) = uint8('B') + **(**Tsize_t)(__ccgo_up(outb)) -= uint32(8) goto _51 _42: ; @@ -99660,22 +99660,22 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if c >= uint32(0x10000) { c = uint32(0xFFFD) } - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint32(2) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint32(2) { goto toobig } - _put_16(tls, *(*uintptr)(unsafe.Pointer(out)), c, Int32FromUint8(totype)) - *(*uintptr)(unsafe.Pointer(out)) += uintptr(2) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint32(2) + _put_16(tls, **(**uintptr)(__ccgo_up(out)), c, Int32FromUint8(totype)) + **(**uintptr)(__ccgo_up(out)) += uintptr(2) + **(**Tsize_t)(__ccgo_up(outb)) -= uint32(2) goto _51 } - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint32(4) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint32(4) { goto toobig } c = c - uint32(0x10000) - _put_16(tls, *(*uintptr)(unsafe.Pointer(out)), c>>int32(10)|uint32(0xd800), Int32FromUint8(totype)) - _put_16(tls, *(*uintptr)(unsafe.Pointer(out))+UintptrFromInt32(2), c&uint32(0x3ff)|uint32(0xdc00), Int32FromUint8(totype)) - *(*uintptr)(unsafe.Pointer(out)) += uintptr(4) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint32(4) + _put_16(tls, **(**uintptr)(__ccgo_up(out)), c>>int32(10)|uint32(0xd800), Int32FromUint8(totype)) + _put_16(tls, **(**uintptr)(__ccgo_up(out))+UintptrFromInt32(2), c&uint32(0x3ff)|uint32(0xdc00), Int32FromUint8(totype)) + **(**uintptr)(__ccgo_up(out)) += uintptr(4) + **(**Tsize_t)(__ccgo_up(outb)) -= uint32(4) goto _51 _48: ; @@ -99684,22 +99684,22 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui ; _49: ; - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint32(4) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint32(4) { goto toobig } - _put_32(tls, *(*uintptr)(unsafe.Pointer(out)), c, Int32FromUint8(totype)) - *(*uintptr)(unsafe.Pointer(out)) += uintptr(4) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint32(4) + _put_32(tls, **(**uintptr)(__ccgo_up(out)), c, Int32FromUint8(totype)) + **(**uintptr)(__ccgo_up(out)) += uintptr(4) + **(**Tsize_t)(__ccgo_up(outb)) -= uint32(4) goto _51 _51: ; goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(in)) += uintptr(l) - *(*Tsize_t)(unsafe.Pointer(inb)) -= l + **(**uintptr)(__ccgo_up(in)) += uintptr(l) + **(**Tsize_t)(__ccgo_up(inb)) -= l } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return x goto ilseq ilseq: @@ -99721,8 +99721,8 @@ starved: goto end end: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = err - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**int32)(__ccgo_up(X__errno_location(tls))) = err + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return x } @@ -99753,7 +99753,7 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { cat = item >> int32(16) idx = item & int32(65535) if item == int32(CODESET) { - if *(*uintptr)(unsafe.Pointer(loc)) != 0 { + if **(**uintptr)(__ccgo_up(loc)) != 0 { v1 = __ccgo_ts + 322 } else { v1 = __ccgo_ts + 441 @@ -99762,8 +99762,8 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { } /* _NL_LOCALE_NAME extension */ if idx == int32(65535) && cat < int32(LC_ALL) { - if *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*4)) != 0 { - v1 = *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*4)) + 8 + if **(**uintptr)(__ccgo_up(loc + uintptr(cat)*4)) != 0 { + v1 = **(**uintptr)(__ccgo_up(loc + uintptr(cat)*4)) + 8 } else { v1 = __ccgo_ts + 447 } @@ -99798,7 +99798,7 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { break } for { - if !(*(*uint8)(unsafe.Pointer(str)) != 0) { + if !(**(**uint8)(__ccgo_up(str)) != 0) { break } goto _4 @@ -99812,8 +99812,8 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { idx = idx - 1 str = str + 1 } - if cat != int32(LC_NUMERIC) && *(*uint8)(unsafe.Pointer(str)) != 0 { - str = X__lctrans(tls, str, *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*4))) + if cat != int32(LC_NUMERIC) && **(**uint8)(__ccgo_up(str)) != 0 { + str = X__lctrans(tls, str, **(**uintptr)(__ccgo_up(loc + uintptr(cat)*4))) } return str } @@ -99886,18 +99886,18 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = builtin, l, map1, n, new1, p, path, z, v1, v2, v3, v4, v5, v6, v7 new1 = uintptr(0) path = uintptr(0) - if !(*(*uint8)(unsafe.Pointer(val)) != 0) { + if !(**(**uint8)(__ccgo_up(val)) != 0) { v1 = Xgetenv(tls, __ccgo_ts+449) val = v1 - if v3 = v1 != 0 && *(*uint8)(unsafe.Pointer(val)) != 0; !v3 { + if v3 = v1 != 0 && **(**uint8)(__ccgo_up(val)) != 0; !v3 { v2 = Xgetenv(tls, uintptr(unsafe.Pointer(&_envvars))+uintptr(cat)*12) val = v2 } - if v5 = v3 || v2 != 0 && *(*uint8)(unsafe.Pointer(val)) != 0; !v5 { + if v5 = v3 || v2 != 0 && **(**uint8)(__ccgo_up(val)) != 0; !v5 { v4 = Xgetenv(tls, __ccgo_ts+336) val = v4 } - if v7 = v5 || v4 != 0 && *(*uint8)(unsafe.Pointer(val)) != 0; !v7 { + if v7 = v5 || v4 != 0 && **(**uint8)(__ccgo_up(val)) != 0; !v7 { v6 = __ccgo_ts + 456 val = v6 } @@ -99906,7 +99906,7 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { /* Limit name length and forbid leading dot or any slashes. */ n = uint32(0) for { - if !(n < uint32(LOCALE_NAME_MAX) && *(*uint8)(unsafe.Pointer(val + uintptr(n))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(val + uintptr(n)))) != int32('/')) { + if !(n < uint32(LOCALE_NAME_MAX) && **(**uint8)(__ccgo_up(val + uintptr(n))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(val + uintptr(n)))) != int32('/')) { break } goto _8 @@ -99914,12 +99914,12 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { ; n = n + 1 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(val))) == int32('.') || *(*uint8)(unsafe.Pointer(val + uintptr(n))) != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(val))) == int32('.') || **(**uint8)(__ccgo_up(val + uintptr(n))) != 0 { val = __ccgo_ts + 456 } - builtin = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(val))) == int32('C') && !(*(*uint8)(unsafe.Pointer(val + 1)) != 0) || !(Xstrcmp(tls, val, __ccgo_ts+456) != 0) || !(Xstrcmp(tls, val, __ccgo_ts+464) != 0)) + builtin = BoolInt32(Int32FromUint8(**(**uint8)(__ccgo_up(val))) == int32('C') && !(**(**uint8)(__ccgo_up(val + 1)) != 0) || !(Xstrcmp(tls, val, __ccgo_ts+456) != 0) || !(Xstrcmp(tls, val, __ccgo_ts+464) != 0)) if builtin != 0 { - if cat == LC_CTYPE && Int32FromUint8(*(*uint8)(unsafe.Pointer(val + 1))) == int32('.') { + if cat == LC_CTYPE && Int32FromUint8(**(**uint8)(__ccgo_up(val + 1))) == int32('.') { return uintptr(unsafe.Pointer(&X__c_dot_utf8)) } return uintptr(0) @@ -99943,7 +99943,7 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { /* FIXME: add a default path? */ if path != 0 { for { - if !(*(*uint8)(unsafe.Pointer(path)) != 0) { + if !(**(**uint8)(__ccgo_up(path)) != 0) { break } z = X__strchrnul(tls, path, int32(':')) @@ -99952,20 +99952,20 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { goto _10 } _memcpy(tls, bp, path, l) - (*(*[256]uint8)(unsafe.Pointer(bp)))[l] = uint8('/') + (**(**[256]uint8)(__ccgo_up(bp)))[l] = uint8('/') _memcpy(tls, bp+uintptr(l)+uintptr(1), val, n) - (*(*[256]uint8)(unsafe.Pointer(bp)))[l+uint32(1)+n] = uint8(0) + (**(**[256]uint8)(__ccgo_up(bp)))[l+uint32(1)+n] = uint8(0) map1 = X__map_file(tls, bp, bp+256) if map1 != 0 { new1 = Xmalloc(tls, uint32(36)) if !(new1 != 0) { - X__munmap(tls, map1, *(*Tsize_t)(unsafe.Pointer(bp + 256))) + X__munmap(tls, map1, **(**Tsize_t)(__ccgo_up(bp + 256))) break } (*t__locale_map)(unsafe.Pointer(new1)).Fmap1 = map1 - (*t__locale_map)(unsafe.Pointer(new1)).Fmap_size = *(*Tsize_t)(unsafe.Pointer(bp + 256)) + (*t__locale_map)(unsafe.Pointer(new1)).Fmap_size = **(**Tsize_t)(__ccgo_up(bp + 256)) _memcpy(tls, new1+8, val, n) - *(*uint8)(unsafe.Pointer(new1 + 8 + uintptr(n))) = uint8(0) + **(**uint8)(__ccgo_up(new1 + 8 + uintptr(n))) = uint8(0) (*t__locale_map)(unsafe.Pointer(new1)).Fnext = AtomicLoadPUintptr(uintptr(unsafe.Pointer(&_loc_head))) AtomicStorePUintptr(uintptr(unsafe.Pointer(&_loc_head)), new1) break @@ -99973,7 +99973,7 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { goto _10 _10: ; - path = z + BoolUintptr(!!(*(*uint8)(unsafe.Pointer(z)) != 0)) + path = z + BoolUintptr(!!(**(**uint8)(__ccgo_up(z)) != 0)) } } /* If no locale definition was found, make a locale map @@ -99988,7 +99988,7 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { (*t__locale_map)(unsafe.Pointer(new1)).Fmap1 = X__c_dot_utf8.Fmap1 (*t__locale_map)(unsafe.Pointer(new1)).Fmap_size = X__c_dot_utf8.Fmap_size _memcpy(tls, new1+8, val, n) - *(*uint8)(unsafe.Pointer(new1 + 8 + uintptr(n))) = uint8(0) + **(**uint8)(__ccgo_up(new1 + 8 + uintptr(n))) = uint8(0) (*t__locale_map)(unsafe.Pointer(new1)).Fnext = AtomicLoadPUintptr(uintptr(unsafe.Pointer(&_loc_head))) AtomicStorePUintptr(uintptr(unsafe.Pointer(&_loc_head)), new1) } @@ -100072,7 +100072,7 @@ func _do_newlocale(tls *TLS, mask int32, name uintptr, loc Tlocale_t) (r Tlocale break } if !(mask&(Int32FromInt32(1)<,< are accepted with or without = */ - if i < int32(6) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) == Int32FromUint8(_opch2[i]) { + if i < int32(6) && Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) == Int32FromUint8(_opch2[i]) { (*Tst)(unsafe.Pointer(st)).Fop = i return s + uintptr(2) } @@ -100378,12 +100378,12 @@ func _evalexpr(tls *TLS, st uintptr, s uintptr, d int32) (r uintptr) { return __ccgo_ts } s = _evalbinop(tls, st, s, 0, d) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('?') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32('?') { return s } a = (*Tst)(unsafe.Pointer(st)).Fr s = _evalexpr(tls, st, s+uintptr(1), d) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32(':') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32(':') { return __ccgo_ts } b = (*Tst)(unsafe.Pointer(st)).Fr @@ -100407,10 +100407,10 @@ func X__pleval(tls *TLS, s uintptr, n uint32) (r uint32) { var v1 uint32 var _ /* st at bp+0 */ Tst _ = v1 - (*(*Tst)(unsafe.Pointer(bp))).Fn = n + (**(**Tst)(__ccgo_up(bp))).Fn = n s = _evalexpr(tls, bp, s, int32(100)) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32(';') { - v1 = (*(*Tst)(unsafe.Pointer(bp))).Fr + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32(';') { + v1 = (**(**Tst)(__ccgo_up(bp))).Fr } else { v1 = Uint32FromInt32(-Int32FromInt32(1)) } @@ -100443,7 +100443,7 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { * on the format, so it can easily be changed if needed. */ if cat == int32(LC_ALL) { if name != 0 { - *(*[24]uint8)(unsafe.Pointer(bp + 24)) = [24]uint8{'C', '.', 'U', 'T', 'F', '-', '8'} + **(**[24]uint8)(__ccgo_up(bp + 24)) = [24]uint8{'C', '.', 'U', 'T', 'F', '-', '8'} p = name i = 0 for { @@ -100453,8 +100453,8 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { z = X__strchrnul(tls, p, int32(';')) if int32(z)-int32(p) <= int32(LOCALE_NAME_MAX) { _memcpy(tls, bp+24, p, Uint32FromInt32(int32(z)-int32(p))) - (*(*[24]uint8)(unsafe.Pointer(bp + 24)))[int32(z)-int32(p)] = uint8(0) - if *(*uint8)(unsafe.Pointer(z)) != 0 { + (**(**[24]uint8)(__ccgo_up(bp + 24)))[int32(z)-int32(p)] = uint8(0) + if **(**uint8)(__ccgo_up(z)) != 0 { p = z + uintptr(1) } } @@ -100463,13 +100463,13 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { ___unlock(tls, uintptr(unsafe.Pointer(&X__locale_lock))) return uintptr(0) } - *(*uintptr)(unsafe.Pointer(bp + uintptr(i)*4)) = lm + **(**uintptr)(__ccgo_up(bp + uintptr(i)*4)) = lm goto _1 _1: ; i = i + 1 } - X__libc.Fglobal_locale = *(*t__locale_struct)(unsafe.Pointer(bp)) + X__libc.Fglobal_locale = **(**t__locale_struct)(__ccgo_up(bp)) } s = uintptr(unsafe.Pointer(&_buf1)) same = 0 @@ -100478,8 +100478,8 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { if !(i < int32(LC_ALL)) { break } - lm1 = *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 32 + uintptr(i)*4)) - if lm1 == *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 32)) { + lm1 = **(**uintptr)(__ccgo_up(uintptr(unsafe.Pointer(&X__libc)) + 32 + uintptr(i)*4)) + if lm1 == **(**uintptr)(__ccgo_up(uintptr(unsafe.Pointer(&X__libc)) + 32)) { same = same + 1 } if lm1 != 0 { @@ -100490,7 +100490,7 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { part1 = v3 l = _strlen(tls, part1) _memcpy(tls, s, part1, l) - *(*uint8)(unsafe.Pointer(s + uintptr(l))) = uint8(';') + **(**uint8)(__ccgo_up(s + uintptr(l))) = uint8(';') s = s + uintptr(l+uint32(1)) goto _2 _2: @@ -100499,7 +100499,7 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { } s = s - 1 v3 = s - *(*uint8)(unsafe.Pointer(v3)) = uint8(0) + **(**uint8)(__ccgo_up(v3)) = uint8(0) ___unlock(tls, uintptr(unsafe.Pointer(&X__locale_lock))) if same == int32(LC_ALL) { v3 = part1 @@ -100514,9 +100514,9 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { ___unlock(tls, uintptr(unsafe.Pointer(&X__locale_lock))) return uintptr(0) } - *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 32 + uintptr(cat)*4)) = lm + **(**uintptr)(__ccgo_up(uintptr(unsafe.Pointer(&X__libc)) + 32 + uintptr(cat)*4)) = lm } else { - lm = *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 32 + uintptr(cat)*4)) + lm = **(**uintptr)(__ccgo_up(uintptr(unsafe.Pointer(&X__libc)) + 32 + uintptr(cat)*4)) } if lm != 0 { v3 = lm + 8 @@ -100563,10 +100563,10 @@ func _vstrfmon_l(tls *TLS, s uintptr, n Tsize_t, loc Tlocale_t, fmt uintptr, ap s0 = s _3: ; - if !(n != 0 && *(*uint8)(unsafe.Pointer(fmt)) != 0) { + if !(n != 0 && **(**uint8)(__ccgo_up(fmt)) != 0) { goto _1 } - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) != int32('%')) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(fmt))) != int32('%')) { goto _4 } goto literal @@ -100576,13 +100576,13 @@ literal: s = s + 1 v6 = fmt fmt = fmt + 1 - *(*uint8)(unsafe.Pointer(v5)) = *(*uint8)(unsafe.Pointer(v6)) + **(**uint8)(__ccgo_up(v5)) = **(**uint8)(__ccgo_up(v6)) n = n - 1 goto _2 _4: ; fmt = fmt + 1 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) == int32('%') { + if Int32FromUint8(**(**uint8)(__ccgo_up(fmt))) == int32('%') { goto literal } fill = int32(' ') @@ -100591,11 +100591,11 @@ _4: nosym = 0 left = 0 for { - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(fmt))) { case int32('='): fmt = fmt + 1 v5 = fmt - fill = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + fill = Int32FromUint8(**(**uint8)(__ccgo_up(v5))) goto _7 case int32('^'): nogrp = int32(1) @@ -100620,10 +100620,10 @@ _4: } fw = 0 for { - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(fmt)))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(fmt)))-uint32('0') < uint32(10)) != 0) { break } - fw = int32(10)*fw + (Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) - int32('0')) + fw = int32(10)*fw + (Int32FromUint8(**(**uint8)(__ccgo_up(fmt))) - int32('0')) goto _9 _9: ; @@ -100631,28 +100631,28 @@ _4: } lp = 0 rp = int32(2) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) == int32('#') { + if Int32FromUint8(**(**uint8)(__ccgo_up(fmt))) == int32('#') { lp = 0 fmt = fmt + 1 for { - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(fmt)))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(fmt)))-uint32('0') < uint32(10)) != 0) { break } - lp = int32(10)*lp + (Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) - int32('0')) + lp = int32(10)*lp + (Int32FromUint8(**(**uint8)(__ccgo_up(fmt))) - int32('0')) goto _10 _10: ; fmt = fmt + 1 } } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) == int32('.') { + if Int32FromUint8(**(**uint8)(__ccgo_up(fmt))) == int32('.') { rp = 0 fmt = fmt + 1 for { - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(fmt)))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(fmt)))-uint32('0') < uint32(10)) != 0) { break } - rp = int32(10)*rp + (Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) - int32('0')) + rp = int32(10)*rp + (Int32FromUint8(**(**uint8)(__ccgo_up(fmt))) - int32('0')) goto _11 _11: ; @@ -100661,7 +100661,7 @@ _4: } v5 = fmt fmt = fmt + 1 - intl = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) == int32('i')) + intl = BoolInt32(Int32FromUint8(**(**uint8)(__ccgo_up(v5))) == int32('i')) w = lp + int32(1) + rp if !(left != 0) && fw > w { w = fw @@ -100669,7 +100669,7 @@ _4: x = VaFloat64(&ap) l = Uint32FromInt32(Xsnprintf(tls, s, n, __ccgo_ts+485, VaList(bp+8, w, rp, x))) if l >= n { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(E2BIG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(E2BIG) return -int32(1) } s = s + uintptr(l) @@ -100834,7 +100834,7 @@ func Xtextdomain(tls *TLS, domainname uintptr) (r uintptr) { } domlen = _strlen(tls, domainname) if domlen > uint32(NAME_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } if !(_current_domain != 0) { @@ -100944,7 +100944,7 @@ func X__wcsxfrm_l(tls *TLS, dest uintptr, src uintptr, n Tsize_t, loc Tlocale_t) } else { if n != 0 { Xwmemcpy(tls, dest, src, n-uint32(1)) - *(*Twchar_t)(unsafe.Pointer(dest + uintptr(n-uint32(1))*4)) = uint32(0) + **(**Twchar_t)(__ccgo_up(dest + uintptr(n-uint32(1))*4)) = uint32(0) } } return l @@ -100975,7 +100975,7 @@ func Xreallocarray(tls *TLS, ptr uintptr, m Tsize_t, n Tsize_t) (r uintptr) { defer func() { trc("-> %v", r) }() } if n != 0 && m > Uint32FromInt32(-Int32FromInt32(1))/n { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return uintptr(0) } return Xrealloc(tls, ptr, m*n) @@ -101374,25 +101374,25 @@ func X__rem_pio2(tls *TLS, x float64, y uintptr) (r1 int32) { if ix <= uint32(0x4002d97c) { /* |x| ~<= 3pi/4 */ if !(sign != 0) { z = x - _pio2_1 /* one round good to 85 bits */ - *(*float64)(unsafe.Pointer(y)) = z - _pio2_1t - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) - _pio2_1t + **(**float64)(__ccgo_up(y)) = z - _pio2_1t + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) - _pio2_1t return int32(1) } else { z = x + _pio2_1 - *(*float64)(unsafe.Pointer(y)) = z + _pio2_1t - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) + _pio2_1t + **(**float64)(__ccgo_up(y)) = z + _pio2_1t + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) + _pio2_1t return -int32(1) } } else { if !(sign != 0) { z = x - float64(Float64FromInt32(2)*_pio2_1) - *(*float64)(unsafe.Pointer(y)) = z - Tdouble_t(Float64FromInt32(2)*_pio2_1t) - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) - Tdouble_t(Float64FromInt32(2)*_pio2_1t) + **(**float64)(__ccgo_up(y)) = z - Tdouble_t(Float64FromInt32(2)*_pio2_1t) + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) - Tdouble_t(Float64FromInt32(2)*_pio2_1t) return int32(2) } else { z = x + float64(Float64FromInt32(2)*_pio2_1) - *(*float64)(unsafe.Pointer(y)) = z + Tdouble_t(Float64FromInt32(2)*_pio2_1t) - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) + Tdouble_t(Float64FromInt32(2)*_pio2_1t) + **(**float64)(__ccgo_up(y)) = z + Tdouble_t(Float64FromInt32(2)*_pio2_1t) + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) + Tdouble_t(Float64FromInt32(2)*_pio2_1t) return -int32(2) } } @@ -101404,13 +101404,13 @@ func X__rem_pio2(tls *TLS, x float64, y uintptr) (r1 int32) { } if !(sign != 0) { z = x - float64(Float64FromInt32(3)*_pio2_1) - *(*float64)(unsafe.Pointer(y)) = z - Tdouble_t(Float64FromInt32(3)*_pio2_1t) - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) - Tdouble_t(Float64FromInt32(3)*_pio2_1t) + **(**float64)(__ccgo_up(y)) = z - Tdouble_t(Float64FromInt32(3)*_pio2_1t) + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) - Tdouble_t(Float64FromInt32(3)*_pio2_1t) return int32(3) } else { z = x + float64(Float64FromInt32(3)*_pio2_1) - *(*float64)(unsafe.Pointer(y)) = z + Tdouble_t(Float64FromInt32(3)*_pio2_1t) - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) + Tdouble_t(Float64FromInt32(3)*_pio2_1t) + **(**float64)(__ccgo_up(y)) = z + Tdouble_t(Float64FromInt32(3)*_pio2_1t) + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) + Tdouble_t(Float64FromInt32(3)*_pio2_1t) return -int32(3) } } else { @@ -101419,13 +101419,13 @@ func X__rem_pio2(tls *TLS, x float64, y uintptr) (r1 int32) { } if !(sign != 0) { z = x - float64(Float64FromInt32(4)*_pio2_1) - *(*float64)(unsafe.Pointer(y)) = z - Tdouble_t(Float64FromInt32(4)*_pio2_1t) - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) - Tdouble_t(Float64FromInt32(4)*_pio2_1t) + **(**float64)(__ccgo_up(y)) = z - Tdouble_t(Float64FromInt32(4)*_pio2_1t) + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) - Tdouble_t(Float64FromInt32(4)*_pio2_1t) return int32(4) } else { z = x + float64(Float64FromInt32(4)*_pio2_1) - *(*float64)(unsafe.Pointer(y)) = z + Tdouble_t(Float64FromInt32(4)*_pio2_1t) - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) + Tdouble_t(Float64FromInt32(4)*_pio2_1t) + **(**float64)(__ccgo_up(y)) = z + Tdouble_t(Float64FromInt32(4)*_pio2_1t) + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) + Tdouble_t(Float64FromInt32(4)*_pio2_1t) return -int32(4) } } @@ -101455,8 +101455,8 @@ medium: w = Tdouble_t(fn * _pio2_1t) } } - *(*float64)(unsafe.Pointer(y)) = r - w - *(*float64)(unsafe.Pointer(bp)) = *(*float64)(unsafe.Pointer(y)) + **(**float64)(__ccgo_up(y)) = r - w + *(*float64)(unsafe.Pointer(bp)) = **(**float64)(__ccgo_up(y)) ey = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(52) & uint64(0x7ff)) ex = Int32FromUint32(ix >> int32(20)) if ex-ey > int32(16) { /* 2nd round, good to 118 bits */ @@ -101464,18 +101464,18 @@ medium: w = Tdouble_t(fn * _pio2_2) r = t - w w = Tdouble_t(fn*_pio2_2t) - (t - r - w) - *(*float64)(unsafe.Pointer(y)) = r - w - *(*float64)(unsafe.Pointer(bp)) = *(*float64)(unsafe.Pointer(y)) + **(**float64)(__ccgo_up(y)) = r - w + *(*float64)(unsafe.Pointer(bp)) = **(**float64)(__ccgo_up(y)) ey = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(52) & uint64(0x7ff)) if ex-ey > int32(49) { /* 3rd round, good to 151 bits, covers all cases */ t = r w = Tdouble_t(fn * _pio2_3) r = t - w w = Tdouble_t(fn*_pio2_3t) - (t - r - w) - *(*float64)(unsafe.Pointer(y)) = r - w + **(**float64)(__ccgo_up(y)) = r - w } } - *(*float64)(unsafe.Pointer(y + 1*8)) = r - *(*float64)(unsafe.Pointer(y)) - w + **(**float64)(__ccgo_up(y + 1*8)) = r - **(**float64)(__ccgo_up(y)) - w return n _1: ; @@ -101484,8 +101484,8 @@ _1: */ if ix >= uint32(0x7ff00000) { /* x is inf or NaN */ v2 = x - x - *(*float64)(unsafe.Pointer(y + 1*8)) = v2 - *(*float64)(unsafe.Pointer(y)) = v2 + **(**float64)(__ccgo_up(y + 1*8)) = v2 + **(**float64)(__ccgo_up(y)) = v2 return 0 } /* set z = scalbn(|x|,-ilogb(x)+23) */ @@ -101498,26 +101498,26 @@ _1: if !(i < int32(2)) { break } - (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i] = float64(int32(z)) - z = Tdouble_t((z - (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i]) * float64(1.6777216e+07)) + (**(**[3]float64)(__ccgo_up(bp + 8)))[i] = float64(int32(z)) + z = Tdouble_t((z - (**(**[3]float64)(__ccgo_up(bp + 8)))[i]) * float64(1.6777216e+07)) goto _3 _3: ; i = i + 1 } - (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i] = z + (**(**[3]float64)(__ccgo_up(bp + 8)))[i] = z /* skip zero terms, first term is non-zero */ - for (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i] == float64(0) { + for (**(**[3]float64)(__ccgo_up(bp + 8)))[i] == float64(0) { i = i - 1 } n = X__rem_pio2_large(tls, bp+8, bp+32, Int32FromUint32(ix>>Int32FromInt32(20))-(Int32FromInt32(0x3ff)+Int32FromInt32(23)), i+int32(1), int32(1)) if sign != 0 { - *(*float64)(unsafe.Pointer(y)) = -(*(*[2]float64)(unsafe.Pointer(bp + 32)))[0] - *(*float64)(unsafe.Pointer(y + 1*8)) = -(*(*[2]float64)(unsafe.Pointer(bp + 32)))[int32(1)] + **(**float64)(__ccgo_up(y)) = -(**(**[2]float64)(__ccgo_up(bp + 32)))[0] + **(**float64)(__ccgo_up(y + 1*8)) = -(**(**[2]float64)(__ccgo_up(bp + 32)))[int32(1)] return -n } - *(*float64)(unsafe.Pointer(y)) = (*(*[2]float64)(unsafe.Pointer(bp + 32)))[0] - *(*float64)(unsafe.Pointer(y + 1*8)) = (*(*[2]float64)(unsafe.Pointer(bp + 32)))[int32(1)] + **(**float64)(__ccgo_up(y)) = (**(**[2]float64)(__ccgo_up(bp + 32)))[0] + **(**float64)(__ccgo_up(y + 1*8)) = (**(**[2]float64)(__ccgo_up(bp + 32)))[int32(1)] return n } @@ -101679,7 +101679,7 @@ func X__rem_pio2_large(tls *TLS, x uintptr, y uintptr, e0 int32, nx int32, prec if !(j <= jx) { break } - fw = fw + float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8))*f[jx+i-j]) + fw = fw + float64(**(**float64)(__ccgo_up(x + uintptr(j)*8))*f[jx+i-j]) goto _4 _4: ; @@ -101704,7 +101704,7 @@ recompute: break } fw = float64(int32(float64(Float64FromFloat64(5.960464477539063e-08) * z))) - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] = int32(z - float64(Float64FromFloat64(1.6777216e+07)*fw)) + (**(**[20]Tint32_t)(__ccgo_up(bp)))[i] = int32(z - float64(Float64FromFloat64(1.6777216e+07)*fw)) z = q[j-int32(1)] + fw goto _5 _5: @@ -101719,13 +101719,13 @@ recompute: z = z - float64(n) ih = 0 if q0 > 0 { /* need iq[jz-1] to determine n */ - i = (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz-int32(1)] >> (int32(24) - q0) + i = (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz-int32(1)] >> (int32(24) - q0) n = n + i - *(*Tint32_t)(unsafe.Pointer(bp + uintptr(jz-int32(1))*4)) -= i << (int32(24) - q0) - ih = (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz-int32(1)] >> (int32(23) - q0) + **(**Tint32_t)(__ccgo_up(bp + uintptr(jz-int32(1))*4)) -= i << (int32(24) - q0) + ih = (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz-int32(1)] >> (int32(23) - q0) } else { if q0 == 0 { - ih = (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz-int32(1)] >> int32(23) + ih = (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz-int32(1)] >> int32(23) } else { if z >= float64(0.5) { ih = int32(2) @@ -101740,14 +101740,14 @@ recompute: if !(i < jz) { break } /* compute 1-q */ - j = (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] + j = (**(**[20]Tint32_t)(__ccgo_up(bp)))[i] if carry == 0 { if j != 0 { carry = int32(1) - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] = int32(0x1000000) - j + (**(**[20]Tint32_t)(__ccgo_up(bp)))[i] = int32(0x1000000) - j } } else { - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] = int32(0xffffff) - j + (**(**[20]Tint32_t)(__ccgo_up(bp)))[i] = int32(0xffffff) - j } goto _6 _6: @@ -101757,9 +101757,9 @@ recompute: if q0 > 0 { /* rare case: chance is 1 in 12 */ switch q0 { case int32(1): - *(*Tint32_t)(unsafe.Pointer(bp + uintptr(jz-int32(1))*4)) &= int32(0x7fffff) + **(**Tint32_t)(__ccgo_up(bp + uintptr(jz-int32(1))*4)) &= int32(0x7fffff) case int32(2): - *(*Tint32_t)(unsafe.Pointer(bp + uintptr(jz-int32(1))*4)) &= int32(0x3fffff) + **(**Tint32_t)(__ccgo_up(bp + uintptr(jz-int32(1))*4)) &= int32(0x3fffff) break } } @@ -101778,7 +101778,7 @@ recompute: if !(i >= jk) { break } - j = j | (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] + j = j | (**(**[20]Tint32_t)(__ccgo_up(bp)))[i] goto _7 _7: ; @@ -101787,7 +101787,7 @@ recompute: if j == 0 { /* need recomputation */ k = int32(1) for { - if !((*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jk-k] == 0) { + if !((**(**[20]Tint32_t)(__ccgo_up(bp)))[jk-k] == 0) { break } goto _8 @@ -101807,7 +101807,7 @@ recompute: if !(j <= jx) { break } - fw = fw + float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8))*f[jx+i-j]) + fw = fw + float64(**(**float64)(__ccgo_up(x + uintptr(j)*8))*f[jx+i-j]) goto _10 _10: ; @@ -101827,7 +101827,7 @@ recompute: if z == float64(0) { jz = jz - int32(1) q0 = q0 - int32(24) - for (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] == 0 { + for (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz] == 0 { jz = jz - 1 q0 = q0 - int32(24) } @@ -101835,12 +101835,12 @@ recompute: z = Xscalbn(tls, z, -q0) if z >= float64(1.6777216e+07) { fw = float64(int32(float64(Float64FromFloat64(5.960464477539063e-08) * z))) - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(z - float64(Float64FromFloat64(1.6777216e+07)*fw)) + (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz] = int32(z - float64(Float64FromFloat64(1.6777216e+07)*fw)) jz = jz + int32(1) q0 = q0 + int32(24) - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(fw) + (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz] = int32(fw) } else { - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(z) + (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz] = int32(z) } } /* convert integer "bit" chunk to floating-point value */ @@ -101850,7 +101850,7 @@ recompute: if !(i >= 0) { break } - q[i] = float64(fw * float64((*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i])) + q[i] = float64(fw * float64((**(**[20]Tint32_t)(__ccgo_up(bp)))[i])) fw = fw * float64(5.960464477539063e-08) goto _11 _11: @@ -101875,7 +101875,7 @@ recompute: ; k = k + 1 } - (*(*[20]float64)(unsafe.Pointer(bp + 80)))[jz-i] = fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[jz-i] = fw goto _12 _12: ; @@ -101901,7 +101901,7 @@ _14: if !(i >= 0) { break } - fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[i] goto _19 _19: ; @@ -101912,7 +101912,7 @@ _14: } else { v2 = -fw } - *(*float64)(unsafe.Pointer(y)) = v2 + **(**float64)(__ccgo_up(y)) = v2 goto _18 _16: ; @@ -101924,7 +101924,7 @@ _15: if !(i >= 0) { break } - fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[i] goto _21 _21: ; @@ -101937,14 +101937,14 @@ _15: } else { v2 = -fw } - *(*float64)(unsafe.Pointer(y)) = v2 - fw = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[0] - fw + **(**float64)(__ccgo_up(y)) = v2 + fw = (**(**[20]float64)(__ccgo_up(bp + 80)))[0] - fw i = int32(1) for { if !(i <= jz) { break } - fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[i] goto _23 _23: ; @@ -101955,7 +101955,7 @@ _15: } else { v2 = -fw } - *(*float64)(unsafe.Pointer(y + 1*8)) = v2 + **(**float64)(__ccgo_up(y + 1*8)) = v2 goto _18 _17: ; /* painful */ @@ -101965,9 +101965,9 @@ _27: if !(i > 0) { goto _25 } - fw = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i-int32(1)] + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] - *(*float64)(unsafe.Pointer(bp + 80 + uintptr(i)*8)) += (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i-int32(1)] - fw - (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i-int32(1)] = fw + fw = (**(**[20]float64)(__ccgo_up(bp + 80)))[i-int32(1)] + (**(**[20]float64)(__ccgo_up(bp + 80)))[i] + **(**float64)(__ccgo_up(bp + 80 + uintptr(i)*8)) += (**(**[20]float64)(__ccgo_up(bp + 80)))[i-int32(1)] - fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[i-int32(1)] = fw goto _26 _26: ; @@ -101981,9 +101981,9 @@ _25: if !(i > int32(1)) { break } - fw = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i-int32(1)] + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] - *(*float64)(unsafe.Pointer(bp + 80 + uintptr(i)*8)) += (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i-int32(1)] - fw - (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i-int32(1)] = fw + fw = (**(**[20]float64)(__ccgo_up(bp + 80)))[i-int32(1)] + (**(**[20]float64)(__ccgo_up(bp + 80)))[i] + **(**float64)(__ccgo_up(bp + 80 + uintptr(i)*8)) += (**(**[20]float64)(__ccgo_up(bp + 80)))[i-int32(1)] - fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[i-int32(1)] = fw goto _28 _28: ; @@ -101995,20 +101995,20 @@ _25: if !(i >= int32(2)) { break } - fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[i] goto _29 _29: ; i = i - 1 } if ih == 0 { - *(*float64)(unsafe.Pointer(y)) = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[0] - *(*float64)(unsafe.Pointer(y + 1*8)) = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[int32(1)] - *(*float64)(unsafe.Pointer(y + 2*8)) = fw + **(**float64)(__ccgo_up(y)) = (**(**[20]float64)(__ccgo_up(bp + 80)))[0] + **(**float64)(__ccgo_up(y + 1*8)) = (**(**[20]float64)(__ccgo_up(bp + 80)))[int32(1)] + **(**float64)(__ccgo_up(y + 2*8)) = fw } else { - *(*float64)(unsafe.Pointer(y)) = -(*(*[20]float64)(unsafe.Pointer(bp + 80)))[0] - *(*float64)(unsafe.Pointer(y + 1*8)) = -(*(*[20]float64)(unsafe.Pointer(bp + 80)))[int32(1)] - *(*float64)(unsafe.Pointer(y + 2*8)) = -fw + **(**float64)(__ccgo_up(y)) = -(**(**[20]float64)(__ccgo_up(bp + 80)))[0] + **(**float64)(__ccgo_up(y + 1*8)) = -(**(**[20]float64)(__ccgo_up(bp + 80)))[int32(1)] + **(**float64)(__ccgo_up(y + 2*8)) = -fw } _18: ; @@ -102062,36 +102062,36 @@ func X__rem_pio2f(tls *TLS, x float32, y uintptr) (r int32) { /* Use a specialized rint() to get fn. */ fn = Tdouble_t(float64(x)*_invpio21) + _toint1 - _toint1 n = int32(fn) - *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) + **(**float64)(__ccgo_up(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) /* Matters with directed rounding. */ - if *(*float64)(unsafe.Pointer(y)) < -_pio41 { + if **(**float64)(__ccgo_up(y)) < -_pio41 { n = n - 1 fn = fn - 1 - *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) + **(**float64)(__ccgo_up(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) } else { - if *(*float64)(unsafe.Pointer(y)) > _pio41 { + if **(**float64)(__ccgo_up(y)) > _pio41 { n = n + 1 fn = fn + 1 - *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) + **(**float64)(__ccgo_up(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) } } return n } if ix >= uint32(0x7f800000) { /* x is inf or NaN */ - *(*float64)(unsafe.Pointer(y)) = float64(x - x) + **(**float64)(__ccgo_up(y)) = float64(x - x) return 0 } /* scale x into [2^23, 2^24-1] */ sign = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(bp)) >> int32(31)) e0 = Int32FromUint32(ix>>Int32FromInt32(23) - Uint32FromInt32(Int32FromInt32(0x7f)+Int32FromInt32(23))) /* e0 = ilogb(|x|)-23, positive */ *(*Tuint32_t)(unsafe.Pointer(bp)) = ix - Uint32FromInt32(e0<>int32(52)&uint64(0x7ff) < Uint64FromInt32(Int32FromInt32(0x3ff)+Int32FromInt32(4)) { if !(y != 0) { - return _p10[int32(*(*float64)(unsafe.Pointer(bp)))+int32(15)] + return _p10[int32(**(**float64)(__ccgo_up(bp)))+int32(15)] } y = Xexp2(tls, float64(float64(3.321928094887362)*y)) - return float64(y * _p10[int32(*(*float64)(unsafe.Pointer(bp)))+int32(15)]) + return float64(y * _p10[int32(**(**float64)(__ccgo_up(bp)))+int32(15)]) } return Xpow(tls, float64(10), x) } @@ -104766,14 +104766,14 @@ func Xexp10f(tls *TLS, x float32) (r float32) { Fi [0]Tuint32_t Ff float32 }{} - *(*float32)(unsafe.Pointer(bp + 4)) = *(*float32)(unsafe.Pointer(bp)) + *(*float32)(unsafe.Pointer(bp + 4)) = **(**float32)(__ccgo_up(bp)) /* fabsf(n) < 8 without raising invalid on nan */ if *(*Tuint32_t)(unsafe.Pointer(bp + 4))>>int32(23)&uint32(0xff) < Uint32FromInt32(Int32FromInt32(0x7f)+Int32FromInt32(3)) { if !(y != 0) { - return _p101[int32(*(*float32)(unsafe.Pointer(bp)))+int32(7)] + return _p101[int32(**(**float32)(__ccgo_up(bp)))+int32(7)] } y = Xexp2f(tls, float32(Float32FromFloat32(3.321928094887362)*y)) - return float32(y * _p101[int32(*(*float32)(unsafe.Pointer(bp)))+int32(7)]) + return float32(y * _p101[int32(**(**float32)(__ccgo_up(bp)))+int32(7)]) } return float32(Xexp2(tls, float64(float64(3.321928094887362)*float64(x)))) } @@ -104937,16 +104937,16 @@ _5: /* 2^(k/N) ~= scale * (1 + tail). */ idx = uint64(2) * (ki % Uint64FromInt32(Int32FromInt32(1)<>Int32FromInt32(32) + BoolUint64(t1 > *(*Tuint64_t)(unsafe.Pointer(lo))) + **(**Tuint64_t)(__ccgo_up(lo)) = t1 + t2<>Int32FromInt32(32) + BoolUint64(t1 > **(**Tuint64_t)(__ccgo_up(lo))) } func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { @@ -105863,11 +105863,11 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { if d == 0 { } else { if d < int32(64) { - *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = *(*Tuint64_t)(unsafe.Pointer(bp))<<(int32(64)-d) | *(*Tuint64_t)(unsafe.Pointer(bp + 8))>>d | BoolUint64(!!(*(*Tuint64_t)(unsafe.Pointer(bp + 8))<<(Int32FromInt32(64)-d) != 0)) - *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp)) >> d + **(**Tuint64_t)(__ccgo_up(bp + 8)) = **(**Tuint64_t)(__ccgo_up(bp))<<(int32(64)-d) | **(**Tuint64_t)(__ccgo_up(bp + 8))>>d | BoolUint64(!!(**(**Tuint64_t)(__ccgo_up(bp + 8))<<(Int32FromInt32(64)-d) != 0)) + **(**Tuint64_t)(__ccgo_up(bp)) = **(**Tuint64_t)(__ccgo_up(bp)) >> d } else { - *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = uint64(1) - *(*Tuint64_t)(unsafe.Pointer(bp)) = uint64(0) + **(**Tuint64_t)(__ccgo_up(bp + 8)) = uint64(1) + **(**Tuint64_t)(__ccgo_up(bp)) = uint64(0) } } } @@ -105890,24 +105890,24 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { nonzero = int32(1) if samesign != 0 { /* r += z */ - *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) + zlo - *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp)) + (zhi + BoolUint64(*(*Tuint64_t)(unsafe.Pointer(bp + 8)) < zlo)) + **(**Tuint64_t)(__ccgo_up(bp + 8)) = **(**Tuint64_t)(__ccgo_up(bp + 8)) + zlo + **(**Tuint64_t)(__ccgo_up(bp)) = **(**Tuint64_t)(__ccgo_up(bp)) + (zhi + BoolUint64(**(**Tuint64_t)(__ccgo_up(bp + 8)) < zlo)) } else { /* r -= z */ - t = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) - *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) - zlo - *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp)) - zhi - BoolUint64(t < *(*Tuint64_t)(unsafe.Pointer(bp + 8))) - if *(*Tuint64_t)(unsafe.Pointer(bp))>>int32(63) != 0 { - *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = -*(*Tuint64_t)(unsafe.Pointer(bp + 8)) - *(*Tuint64_t)(unsafe.Pointer(bp)) = -*(*Tuint64_t)(unsafe.Pointer(bp)) - BoolUint64(!!(*(*Tuint64_t)(unsafe.Pointer(bp + 8)) != 0)) + t = **(**Tuint64_t)(__ccgo_up(bp + 8)) + **(**Tuint64_t)(__ccgo_up(bp + 8)) = **(**Tuint64_t)(__ccgo_up(bp + 8)) - zlo + **(**Tuint64_t)(__ccgo_up(bp)) = **(**Tuint64_t)(__ccgo_up(bp)) - zhi - BoolUint64(t < **(**Tuint64_t)(__ccgo_up(bp + 8))) + if **(**Tuint64_t)(__ccgo_up(bp))>>int32(63) != 0 { + **(**Tuint64_t)(__ccgo_up(bp + 8)) = -**(**Tuint64_t)(__ccgo_up(bp + 8)) + **(**Tuint64_t)(__ccgo_up(bp)) = -**(**Tuint64_t)(__ccgo_up(bp)) - BoolUint64(!!(**(**Tuint64_t)(__ccgo_up(bp + 8)) != 0)) sign = BoolInt32(!(sign != 0)) } - nonzero = BoolInt32(!!(*(*Tuint64_t)(unsafe.Pointer(bp)) != 0)) + nonzero = BoolInt32(!!(**(**Tuint64_t)(__ccgo_up(bp)) != 0)) } /* set rhi to top 63bit of the result (last bit is sticky) */ if nonzero != 0 { e = e + int32(64) - v1 = *(*Tuint64_t)(unsafe.Pointer(bp)) + v1 = **(**Tuint64_t)(__ccgo_up(bp)) if v1>>Int32FromInt32(32) != 0 { v2 = _a_clz_32(tls, uint32(v1>>int32(32))) goto _3 @@ -105917,10 +105917,10 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { _3: d = v2 - int32(1) /* note: d > 0 */ - *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp))<>(int32(64)-d) | BoolUint64(!!(*(*Tuint64_t)(unsafe.Pointer(bp + 8))<>(int32(64)-d) | BoolUint64(!!(**(**Tuint64_t)(__ccgo_up(bp + 8))<>Int32FromInt32(32) != 0 { v2 = _a_clz_32(tls, uint32(v1>>int32(32))) goto _6 @@ -105930,9 +105930,9 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { _6: d = v2 - int32(1) if d < 0 { - *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp + 8))>>int32(1) | *(*Tuint64_t)(unsafe.Pointer(bp + 8))&uint64(1) + **(**Tuint64_t)(__ccgo_up(bp)) = **(**Tuint64_t)(__ccgo_up(bp + 8))>>int32(1) | **(**Tuint64_t)(__ccgo_up(bp + 8))&uint64(1) } else { - *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) << d + **(**Tuint64_t)(__ccgo_up(bp)) = **(**Tuint64_t)(__ccgo_up(bp + 8)) << d } } else { /* exact +-0 */ @@ -105941,7 +105941,7 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { } e = e - d /* convert to double */ - i = Int64FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp))) /* i is in [1<<62,(1<<63)-1] */ + i = Int64FromUint64(**(**Tuint64_t)(__ccgo_up(bp))) /* i is in [1<<62,(1<<63)-1] */ if sign != 0 { i = -i } @@ -105962,8 +105962,8 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { } /* one bit is lost when scaled, add another top bit to only round once at conversion if it is inexact */ - if *(*Tuint64_t)(unsafe.Pointer(bp))<>int32(1) | *(*Tuint64_t)(unsafe.Pointer(bp))&uint64(1) | Uint64FromUint64(1)<>int32(1) | **(**Tuint64_t)(__ccgo_up(bp))&uint64(1) | Uint64FromUint64(1)<>d | BoolUint64(!!(*(*Tuint64_t)(unsafe.Pointer(bp))<<(Int32FromInt32(64)-d) != 0))) << d) + i = Int64FromUint64((**(**Tuint64_t)(__ccgo_up(bp))>>d | BoolUint64(!!(**(**Tuint64_t)(__ccgo_up(bp))<<(Int32FromInt32(64)-d) != 0))) << d) if sign != 0 { i = -i } @@ -106571,9 +106571,9 @@ func Xfrexp(tls *TLS, x float64, e uintptr) (r float64) { if !(ee != 0) { if x != 0 { x = Xfrexp(tls, float64(x*float64(1.8446744073709552e+19)), e) - *(*int32)(unsafe.Pointer(e)) -= int32(64) + **(**int32)(__ccgo_up(e)) -= int32(64) } else { - *(*int32)(unsafe.Pointer(e)) = 0 + **(**int32)(__ccgo_up(e)) = 0 } return x } else { @@ -106581,7 +106581,7 @@ func Xfrexp(tls *TLS, x float64, e uintptr) (r float64) { return x } } - *(*int32)(unsafe.Pointer(e)) = ee - int32(0x3fe) + **(**int32)(__ccgo_up(e)) = ee - int32(0x3fe) *(*Tuint64_t)(unsafe.Pointer(bp)) &= uint64(0x800fffffffffffff) *(*Tuint64_t)(unsafe.Pointer(bp)) |= uint64(0x3fe0000000000000) return *(*float64)(unsafe.Pointer(bp)) @@ -106613,9 +106613,9 @@ func Xfrexpf(tls *TLS, x float32, e uintptr) (r float32) { if !(ee != 0) { if x != 0 { x = Xfrexpf(tls, float32(float64(x)*float64(1.8446744073709552e+19)), e) - *(*int32)(unsafe.Pointer(e)) -= int32(64) + **(**int32)(__ccgo_up(e)) -= int32(64) } else { - *(*int32)(unsafe.Pointer(e)) = 0 + **(**int32)(__ccgo_up(e)) = 0 } return x } else { @@ -106623,7 +106623,7 @@ func Xfrexpf(tls *TLS, x float32, e uintptr) (r float32) { return x } } - *(*int32)(unsafe.Pointer(e)) = ee - int32(0x7e) + **(**int32)(__ccgo_up(e)) = ee - int32(0x7e) v1 = bp *(*Tuint32_t)(unsafe.Pointer(v1)) = Tuint32_t(*(*Tuint32_t)(unsafe.Pointer(v1)) & Uint32FromUint32(0x807fffff)) v1 = bp @@ -106647,8 +106647,8 @@ func _sq(tls *TLS, hi uintptr, lo uintptr, x float64) { xc = Tdouble_t(x * (Float64FromFloat64(1.34217728e+08) + Float64FromInt32(1))) xh = x - xc + xc xl = x - xh - *(*Tdouble_t)(unsafe.Pointer(hi)) = Tdouble_t(x * x) - *(*Tdouble_t)(unsafe.Pointer(lo)) = Tdouble_t(xh*xh) - *(*Tdouble_t)(unsafe.Pointer(hi)) + Tdouble_t(Tdouble_t(Float64FromInt32(2)*xh)*xl) + Tdouble_t(xl*xl) + **(**Tdouble_t)(__ccgo_up(hi)) = Tdouble_t(x * x) + **(**Tdouble_t)(__ccgo_up(lo)) = Tdouble_t(xh*xh) - **(**Tdouble_t)(__ccgo_up(hi)) + Tdouble_t(Tdouble_t(Float64FromInt32(2)*xh)*xl) + Tdouble_t(xl*xl) } func Xhypot(tls *TLS, x float64, y float64) (r float64) { @@ -106704,25 +106704,25 @@ func Xhypot(tls *TLS, x float64, y float64) (r float64) { *(*Tuint64_t)(unsafe.Pointer(bp)) &= -Uint64FromUint64(1) >> Int32FromInt32(1) *(*Tuint64_t)(unsafe.Pointer(bp + 8)) &= -Uint64FromUint64(1) >> Int32FromInt32(1) if *(*Tuint64_t)(unsafe.Pointer(bp)) < *(*Tuint64_t)(unsafe.Pointer(bp + 8)) { - ut = *(*struct { + ut = **(**struct { F__ccgo_align [0]uint32 Fi [0]Tuint64_t Ff float64 - })(unsafe.Pointer(bp)) - *(*struct { + })(__ccgo_up(bp)) + **(**struct { F__ccgo_align [0]uint32 Fi [0]Tuint64_t Ff float64 - })(unsafe.Pointer(bp)) = *(*struct { + })(__ccgo_up(bp)) = **(**struct { F__ccgo_align [0]uint32 Fi [0]Tuint64_t Ff float64 - })(unsafe.Pointer(bp + 8)) - *(*struct { + })(__ccgo_up(bp + 8)) + **(**struct { F__ccgo_align [0]uint32 Fi [0]Tuint64_t Ff float64 - })(unsafe.Pointer(bp + 8)) = ut + })(__ccgo_up(bp + 8)) = ut } /* special cases */ ex = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(52)) @@ -106757,7 +106757,7 @@ func Xhypot(tls *TLS, x float64, y float64) (r float64) { } _sq(tls, bp+16, bp+24, x) _sq(tls, bp+32, bp+40, y) - return float64(z * Xsqrt(tls, *(*Tdouble_t)(unsafe.Pointer(bp + 40))+*(*Tdouble_t)(unsafe.Pointer(bp + 24))+*(*Tdouble_t)(unsafe.Pointer(bp + 32))+*(*Tdouble_t)(unsafe.Pointer(bp + 16)))) + return float64(z * Xsqrt(tls, **(**Tdouble_t)(__ccgo_up(bp + 40))+**(**Tdouble_t)(__ccgo_up(bp + 24))+**(**Tdouble_t)(__ccgo_up(bp + 32))+**(**Tdouble_t)(__ccgo_up(bp + 16)))) } func Xhypotf(tls *TLS, x float32, y float32) (r float32) { @@ -106800,21 +106800,21 @@ func Xhypotf(tls *TLS, x float32, y float32) (r float32) { *(*Tuint32_t)(unsafe.Pointer(bp)) &= -Uint32FromUint32(1) >> Int32FromInt32(1) *(*Tuint32_t)(unsafe.Pointer(bp + 4)) &= -Uint32FromUint32(1) >> Int32FromInt32(1) if *(*Tuint32_t)(unsafe.Pointer(bp)) < *(*Tuint32_t)(unsafe.Pointer(bp + 4)) { - ut = *(*struct { + ut = **(**struct { Fi [0]Tuint32_t Ff float32 - })(unsafe.Pointer(bp)) - *(*struct { + })(__ccgo_up(bp)) + **(**struct { Fi [0]Tuint32_t Ff float32 - })(unsafe.Pointer(bp)) = *(*struct { + })(__ccgo_up(bp)) = **(**struct { Fi [0]Tuint32_t Ff float32 - })(unsafe.Pointer(bp + 4)) - *(*struct { + })(__ccgo_up(bp + 4)) + **(**struct { Fi [0]Tuint32_t Ff float32 - })(unsafe.Pointer(bp + 4)) = ut + })(__ccgo_up(bp + 4)) = ut } x = *(*float32)(unsafe.Pointer(bp)) y = *(*float32)(unsafe.Pointer(bp + 4)) @@ -107245,8 +107245,8 @@ func _pzero(tls *TLS, x float64) (r1 float64) { } } z = float64(1) / float64(x*x) - r = *(*float64)(unsafe.Pointer(p)) + float64(z*(*(*float64)(unsafe.Pointer(p + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 4*8))+float64(z**(*float64)(unsafe.Pointer(p + 5*8))))))))))) - s = float64(1) + float64(z*(*(*float64)(unsafe.Pointer(q))+float64(z*(*(*float64)(unsafe.Pointer(q + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 3*8))+float64(z**(*float64)(unsafe.Pointer(q + 4*8))))))))))) + r = **(**float64)(__ccgo_up(p)) + float64(z*(**(**float64)(__ccgo_up(p + 1*8))+float64(z*(**(**float64)(__ccgo_up(p + 2*8))+float64(z*(**(**float64)(__ccgo_up(p + 3*8))+float64(z*(**(**float64)(__ccgo_up(p + 4*8))+float64(z***(**float64)(__ccgo_up(p + 5*8))))))))))) + s = float64(1) + float64(z*(**(**float64)(__ccgo_up(q))+float64(z*(**(**float64)(__ccgo_up(q + 1*8))+float64(z*(**(**float64)(__ccgo_up(q + 2*8))+float64(z*(**(**float64)(__ccgo_up(q + 3*8))+float64(z***(**float64)(__ccgo_up(q + 4*8))))))))))) return float64(1) + r/s } @@ -107353,8 +107353,8 @@ func _qzero(tls *TLS, x float64) (r1 float64) { } } z = float64(1) / float64(x*x) - r = *(*float64)(unsafe.Pointer(p)) + float64(z*(*(*float64)(unsafe.Pointer(p + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 4*8))+float64(z**(*float64)(unsafe.Pointer(p + 5*8))))))))))) - s = float64(1) + float64(z*(*(*float64)(unsafe.Pointer(q))+float64(z*(*(*float64)(unsafe.Pointer(q + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 4*8))+float64(z**(*float64)(unsafe.Pointer(q + 5*8))))))))))))) + r = **(**float64)(__ccgo_up(p)) + float64(z*(**(**float64)(__ccgo_up(p + 1*8))+float64(z*(**(**float64)(__ccgo_up(p + 2*8))+float64(z*(**(**float64)(__ccgo_up(p + 3*8))+float64(z*(**(**float64)(__ccgo_up(p + 4*8))+float64(z***(**float64)(__ccgo_up(p + 5*8))))))))))) + s = float64(1) + float64(z*(**(**float64)(__ccgo_up(q))+float64(z*(**(**float64)(__ccgo_up(q + 1*8))+float64(z*(**(**float64)(__ccgo_up(q + 2*8))+float64(z*(**(**float64)(__ccgo_up(q + 3*8))+float64(z*(**(**float64)(__ccgo_up(q + 4*8))+float64(z***(**float64)(__ccgo_up(q + 5*8))))))))))))) return (-Float64FromFloat64(0.125) + r/s) / x } @@ -107578,8 +107578,8 @@ func _pzerof(tls *TLS, x float32) (r1 float32) { } } z = Float32FromFloat32(1) / float32(x*x) - r = *(*float32)(unsafe.Pointer(p)) + float32(z*(*(*float32)(unsafe.Pointer(p + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 3*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 4*4))+float32(z**(*float32)(unsafe.Pointer(p + 5*4))))))))))) - s = Float32FromFloat32(1) + float32(z*(*(*float32)(unsafe.Pointer(q))+float32(z*(*(*float32)(unsafe.Pointer(q + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 3*4))+float32(z**(*float32)(unsafe.Pointer(q + 4*4))))))))))) + r = **(**float32)(__ccgo_up(p)) + float32(z*(**(**float32)(__ccgo_up(p + 1*4))+float32(z*(**(**float32)(__ccgo_up(p + 2*4))+float32(z*(**(**float32)(__ccgo_up(p + 3*4))+float32(z*(**(**float32)(__ccgo_up(p + 4*4))+float32(z***(**float32)(__ccgo_up(p + 5*4))))))))))) + s = Float32FromFloat32(1) + float32(z*(**(**float32)(__ccgo_up(q))+float32(z*(**(**float32)(__ccgo_up(q + 1*4))+float32(z*(**(**float32)(__ccgo_up(q + 2*4))+float32(z*(**(**float32)(__ccgo_up(q + 3*4))+float32(z***(**float32)(__ccgo_up(q + 4*4))))))))))) return Float32FromFloat32(1) + r/s } @@ -107686,8 +107686,8 @@ func _qzerof(tls *TLS, x float32) (r1 float32) { } } z = Float32FromFloat32(1) / float32(x*x) - r = *(*float32)(unsafe.Pointer(p)) + float32(z*(*(*float32)(unsafe.Pointer(p + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 3*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 4*4))+float32(z**(*float32)(unsafe.Pointer(p + 5*4))))))))))) - s = Float32FromFloat32(1) + float32(z*(*(*float32)(unsafe.Pointer(q))+float32(z*(*(*float32)(unsafe.Pointer(q + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 3*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 4*4))+float32(z**(*float32)(unsafe.Pointer(q + 5*4))))))))))))) + r = **(**float32)(__ccgo_up(p)) + float32(z*(**(**float32)(__ccgo_up(p + 1*4))+float32(z*(**(**float32)(__ccgo_up(p + 2*4))+float32(z*(**(**float32)(__ccgo_up(p + 3*4))+float32(z*(**(**float32)(__ccgo_up(p + 4*4))+float32(z***(**float32)(__ccgo_up(p + 5*4))))))))))) + s = Float32FromFloat32(1) + float32(z*(**(**float32)(__ccgo_up(q))+float32(z*(**(**float32)(__ccgo_up(q + 1*4))+float32(z*(**(**float32)(__ccgo_up(q + 2*4))+float32(z*(**(**float32)(__ccgo_up(q + 3*4))+float32(z*(**(**float32)(__ccgo_up(q + 4*4))+float32(z***(**float32)(__ccgo_up(q + 5*4))))))))))))) return (-Float32FromFloat32(0.125) + r/s) / x } @@ -107924,8 +107924,8 @@ func _pone(tls *TLS, x float64) (r1 float64) { } } z = float64(1) / float64(x*x) - r = *(*float64)(unsafe.Pointer(p)) + float64(z*(*(*float64)(unsafe.Pointer(p + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 4*8))+float64(z**(*float64)(unsafe.Pointer(p + 5*8))))))))))) - s = float64(1) + float64(z*(*(*float64)(unsafe.Pointer(q))+float64(z*(*(*float64)(unsafe.Pointer(q + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 3*8))+float64(z**(*float64)(unsafe.Pointer(q + 4*8))))))))))) + r = **(**float64)(__ccgo_up(p)) + float64(z*(**(**float64)(__ccgo_up(p + 1*8))+float64(z*(**(**float64)(__ccgo_up(p + 2*8))+float64(z*(**(**float64)(__ccgo_up(p + 3*8))+float64(z*(**(**float64)(__ccgo_up(p + 4*8))+float64(z***(**float64)(__ccgo_up(p + 5*8))))))))))) + s = float64(1) + float64(z*(**(**float64)(__ccgo_up(q))+float64(z*(**(**float64)(__ccgo_up(q + 1*8))+float64(z*(**(**float64)(__ccgo_up(q + 2*8))+float64(z*(**(**float64)(__ccgo_up(q + 3*8))+float64(z***(**float64)(__ccgo_up(q + 4*8))))))))))) return float64(1) + r/s } @@ -108031,8 +108031,8 @@ func _qone(tls *TLS, x float64) (r1 float64) { } } z = float64(1) / float64(x*x) - r = *(*float64)(unsafe.Pointer(p)) + float64(z*(*(*float64)(unsafe.Pointer(p + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 4*8))+float64(z**(*float64)(unsafe.Pointer(p + 5*8))))))))))) - s = float64(1) + float64(z*(*(*float64)(unsafe.Pointer(q))+float64(z*(*(*float64)(unsafe.Pointer(q + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 4*8))+float64(z**(*float64)(unsafe.Pointer(q + 5*8))))))))))))) + r = **(**float64)(__ccgo_up(p)) + float64(z*(**(**float64)(__ccgo_up(p + 1*8))+float64(z*(**(**float64)(__ccgo_up(p + 2*8))+float64(z*(**(**float64)(__ccgo_up(p + 3*8))+float64(z*(**(**float64)(__ccgo_up(p + 4*8))+float64(z***(**float64)(__ccgo_up(p + 5*8))))))))))) + s = float64(1) + float64(z*(**(**float64)(__ccgo_up(q))+float64(z*(**(**float64)(__ccgo_up(q + 1*8))+float64(z*(**(**float64)(__ccgo_up(q + 2*8))+float64(z*(**(**float64)(__ccgo_up(q + 3*8))+float64(z*(**(**float64)(__ccgo_up(q + 4*8))+float64(z***(**float64)(__ccgo_up(q + 5*8))))))))))))) return (float64(0.375) + r/s) / x } @@ -108255,8 +108255,8 @@ func _ponef(tls *TLS, x float32) (r1 float32) { } } z = Float32FromFloat32(1) / float32(x*x) - r = *(*float32)(unsafe.Pointer(p)) + float32(z*(*(*float32)(unsafe.Pointer(p + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 3*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 4*4))+float32(z**(*float32)(unsafe.Pointer(p + 5*4))))))))))) - s = Float32FromFloat32(1) + float32(z*(*(*float32)(unsafe.Pointer(q))+float32(z*(*(*float32)(unsafe.Pointer(q + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 3*4))+float32(z**(*float32)(unsafe.Pointer(q + 4*4))))))))))) + r = **(**float32)(__ccgo_up(p)) + float32(z*(**(**float32)(__ccgo_up(p + 1*4))+float32(z*(**(**float32)(__ccgo_up(p + 2*4))+float32(z*(**(**float32)(__ccgo_up(p + 3*4))+float32(z*(**(**float32)(__ccgo_up(p + 4*4))+float32(z***(**float32)(__ccgo_up(p + 5*4))))))))))) + s = Float32FromFloat32(1) + float32(z*(**(**float32)(__ccgo_up(q))+float32(z*(**(**float32)(__ccgo_up(q + 1*4))+float32(z*(**(**float32)(__ccgo_up(q + 2*4))+float32(z*(**(**float32)(__ccgo_up(q + 3*4))+float32(z***(**float32)(__ccgo_up(q + 4*4))))))))))) return Float32FromFloat32(1) + r/s } @@ -108362,8 +108362,8 @@ func _qonef(tls *TLS, x float32) (r1 float32) { } } z = Float32FromFloat32(1) / float32(x*x) - r = *(*float32)(unsafe.Pointer(p)) + float32(z*(*(*float32)(unsafe.Pointer(p + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 3*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 4*4))+float32(z**(*float32)(unsafe.Pointer(p + 5*4))))))))))) - s = Float32FromFloat32(1) + float32(z*(*(*float32)(unsafe.Pointer(q))+float32(z*(*(*float32)(unsafe.Pointer(q + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 3*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 4*4))+float32(z**(*float32)(unsafe.Pointer(q + 5*4))))))))))))) + r = **(**float32)(__ccgo_up(p)) + float32(z*(**(**float32)(__ccgo_up(p + 1*4))+float32(z*(**(**float32)(__ccgo_up(p + 2*4))+float32(z*(**(**float32)(__ccgo_up(p + 3*4))+float32(z*(**(**float32)(__ccgo_up(p + 4*4))+float32(z***(**float32)(__ccgo_up(p + 5*4))))))))))) + s = Float32FromFloat32(1) + float32(z*(**(**float32)(__ccgo_up(q))+float32(z*(**(**float32)(__ccgo_up(q + 1*4))+float32(z*(**(**float32)(__ccgo_up(q + 2*4))+float32(z*(**(**float32)(__ccgo_up(q + 3*4))+float32(z*(**(**float32)(__ccgo_up(q + 4*4))+float32(z***(**float32)(__ccgo_up(q + 5*4))))))))))))) return (Float32FromFloat32(0.375) + r/s) / x } @@ -109047,7 +109047,7 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { }{} *(*float64)(unsafe.Pointer(bp)) = x /* purge off +-inf, NaN, +-0, tiny and negative arguments */ - *(*int32)(unsafe.Pointer(signgamp)) = int32(1) + **(**int32)(__ccgo_up(signgamp)) = int32(1) sign = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(63)) ix = uint32(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(32) & uint64(0x7fffffff)) if ix >= uint32(0x7ff00000) { @@ -109056,7 +109056,7 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { if ix < Uint32FromInt32((Int32FromInt32(0x3ff)-Int32FromInt32(70))< float64(0) { - *(*int32)(unsafe.Pointer(signgamp)) = -int32(1) + **(**int32)(__ccgo_up(signgamp)) = -int32(1) } else { t = -t } @@ -109304,7 +109304,7 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { }{} *(*float32)(unsafe.Pointer(bp)) = x /* purge off +-inf, NaN, +-0, tiny and negative arguments */ - *(*int32)(unsafe.Pointer(signgamp)) = int32(1) + **(**int32)(__ccgo_up(signgamp)) = int32(1) sign = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(bp)) >> int32(31)) ix = *(*Tuint32_t)(unsafe.Pointer(bp)) & uint32(0x7fffffff) if ix >= uint32(0x7f800000) { @@ -109312,7 +109312,7 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { } if ix < uint32(0x35000000) { /* |x| < 2**-21, return -log(|x|) */ if sign != 0 { - *(*int32)(unsafe.Pointer(signgamp)) = -int32(1) + **(**int32)(__ccgo_up(signgamp)) = -int32(1) x = -x } return -Xlogf(tls, x) @@ -109324,7 +109324,7 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { return Float32FromFloat32(1) / (x - x) } if t > Float32FromFloat32(0) { - *(*int32)(unsafe.Pointer(signgamp)) = -int32(1) + **(**int32)(__ccgo_up(signgamp)) = -int32(1) } else { t = -t } @@ -109572,15 +109572,15 @@ func Xlog(tls *TLS, x1 float64) (r1 float64) { r = x1 - float64(1) r2 = Tdouble_t(r * r) r3 = Tdouble_t(r * r2) - y1 = Tdouble_t(r3 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 1*8)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 2*8))) + float64(r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 3*8))) + float64(r3*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 4*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 5*8)))+float64(r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 6*8)))+float64(r3*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 7*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 8*8)))+float64(r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 9*8)))+float64(r3**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 10*8))))))))) + y1 = Tdouble_t(r3 * (**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 1*8)) + float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 2*8))) + float64(r2***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 3*8))) + float64(r3*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 4*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 5*8)))+float64(r2***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 6*8)))+float64(r3*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 7*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 8*8)))+float64(r2***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 9*8)))+float64(r3***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 10*8))))))))) /* Worst-case error is around 0.507 ULP. */ w = Tdouble_t(r * float64(1.34217728e+08)) rhi = r + w - w rlo = r - rhi - w = Tdouble_t(Tdouble_t(rhi*rhi) * *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56))) /* B[0] == -0.5. */ + w = Tdouble_t(Tdouble_t(rhi*rhi) * **(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56))) /* B[0] == -0.5. */ hi = r + w lo = r - hi + w - lo = lo + Tdouble_t(float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56))*rlo)*(rhi+r)) + lo = lo + Tdouble_t(float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56))*rlo)*(rhi+r)) y1 = y1 + lo y1 = y1 + hi y = y1 @@ -109613,29 +109613,29 @@ func Xlog(tls *TLS, x1 float64) (r1 float64) { i = Int32FromUint64(tmp >> (Int32FromInt32(52) - Int32FromInt32(LOG_TABLE_BITS)) % Uint64FromInt32(Int32FromInt32(1)<> int32(52)) /* arithmetic shift */ iz = ix - tmp&(Uint64FromUint64(0xfff)< 0x1p-4: 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma). */ - y1 = lo + Tdouble_t(r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16))) + Tdouble_t(Tdouble_t(r*r2)*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 1*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 2*8)))+float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 3*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 4*8))))))) + hi + y1 = lo + Tdouble_t(r2***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 16))) + Tdouble_t(Tdouble_t(r*r2)*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 1*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 2*8)))+float64(r2*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 3*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 4*8))))))) + hi y = y1 v1 = y goto _11 @@ -110102,10 +110102,10 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { r2 = Tdouble_t(r * r) /* rounding error: 0x1p-62. */ r4 = Tdouble_t(r2 * r2) /* Worst-case error is less than 0.54 ULP (0.55 ULP without fma). */ - p = Tdouble_t(r2 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 1*8))))) + p = Tdouble_t(r2 * (**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64)) + float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 1*8))))) y1 = hi + p lo = lo + (hi - y1 + p) - lo = lo + Tdouble_t(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 2*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 3*8)))+float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 4*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 5*8)))))+float64(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 6*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 7*8)))+float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 8*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 9*8))))))))) + lo = lo + Tdouble_t(r4*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 2*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 3*8)))+float64(r2*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 4*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 5*8)))))+float64(r4*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 6*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 7*8)))+float64(r2*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 8*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 9*8))))))))) y1 = y1 + lo y = y1 v1 = y @@ -110137,28 +110137,28 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { i = Int32FromUint64(tmp >> (Int32FromInt32(52) - Int32FromInt32(LOG2_TABLE_BITS)) % Uint64FromInt32(Int32FromInt32(1)<> int32(52)) /* arithmetic shift */ iz = ix - tmp&(Uint64FromUint64(0xfff)< 0x1p-4: 0.547 ULP (0.550 ULP without fma). ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma). */ - p = *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 1*8))) + float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 2*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 3*8))))) + float64(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 4*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 5*8))))) + p = **(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 16)) + float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 1*8))) + float64(r2*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 2*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 3*8))))) + float64(r4*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 4*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 5*8))))) y1 = lo + Tdouble_t(r2*p) + hi y = y1 v1 = y @@ -110254,25 +110254,25 @@ func Xlog2f(tls *TLS, x1 float32) (r1 float32) { top = tmp & uint32(0xff800000) iz = ix - top k = Int32FromUint32(tmp) >> int32(23) /* arithmetic shift */ - invc = (*(*struct { + invc = (**(**struct { F__ccgo_align [0]uint32 Finvc float64 Flogc float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + uintptr(i)*16))).Finvc - logc = (*(*struct { + })(__ccgo_up(uintptr(unsafe.Pointer(&X__log2f_data)) + uintptr(i)*16))).Finvc + logc = (**(**struct { F__ccgo_align [0]uint32 Finvc float64 Flogc float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + uintptr(i)*16))).Flogc + })(__ccgo_up(uintptr(unsafe.Pointer(&X__log2f_data)) + uintptr(i)*16))).Flogc z = float64(*(*float32)(unsafe.Pointer(&iz))) /* log2(x) = log1p(z/c-1)/ln2 + log2(c) + k */ r = Tdouble_t(z*invc) - Float64FromInt32(1) y0 = logc + float64(k) /* Pipelined polynomial evaluation to approximate log1p(r)/ln2. */ r2 = Tdouble_t(r * r) - y1 = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 1*8))*r) + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 2*8)) - y1 = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256))*r2) + y1 - p = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 3*8))*r) + y0 + y1 = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 1*8))*r) + **(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 2*8)) + y1 = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2f_data)) + 256))*r2) + y1 + p = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 3*8))*r) + y0 y1 = Tdouble_t(y1*r2) + p y = float32(y1) v1 = y @@ -110456,24 +110456,24 @@ func Xlogf(tls *TLS, x1 float32) (r1 float32) { i = Int32FromUint32(tmp >> (Int32FromInt32(23) - Int32FromInt32(LOGF_TABLE_BITS)) % Uint32FromInt32(Int32FromInt32(1)<> int32(23) /* arithmetic shift */ iz = ix - tmp&uint32(0xff800000) - invc = (*(*struct { + invc = (**(**struct { F__ccgo_align [0]uint32 Finvc float64 Flogc float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + uintptr(i)*16))).Finvc - logc = (*(*struct { + })(__ccgo_up(uintptr(unsafe.Pointer(&X__logf_data)) + uintptr(i)*16))).Finvc + logc = (**(**struct { F__ccgo_align [0]uint32 Finvc float64 Flogc float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + uintptr(i)*16))).Flogc + })(__ccgo_up(uintptr(unsafe.Pointer(&X__logf_data)) + uintptr(i)*16))).Flogc z = float64(*(*float32)(unsafe.Pointer(&iz))) /* log(x) = log1p(z/c-1) + log(c) + k*Ln2 */ r = Tdouble_t(z*invc) - Float64FromInt32(1) y0 = logc + Tdouble_t(float64(k)*X__logf_data.Fln2) /* Pipelined polynomial evaluation to approximate log1p(r). */ r2 = Tdouble_t(r * r) - y1 = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + 264 + 1*8))*r) + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + 264 + 2*8)) - y1 = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + 264))*r2) + y1 + y1 = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__logf_data)) + 264 + 1*8))*r) + **(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__logf_data)) + 264 + 2*8)) + y1 = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__logf_data)) + 264))*r2) + y1 y1 = Tdouble_t(y1*r2) + (y0 + r) y = float32(y1) v1 = y @@ -110636,7 +110636,7 @@ func Xmodf(tls *TLS, x float64, iptr uintptr) (r float64) { e = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp))>>Int32FromInt32(52)&Uint64FromInt32(0x7ff)) - int32(0x3ff) /* no fractional part */ if e >= int32(52) { - *(*float64)(unsafe.Pointer(iptr)) = x + **(**float64)(__ccgo_up(iptr)) = x if e == int32(0x400) && *(*Tuint64_t)(unsafe.Pointer(bp))<> Int32FromInt32(12) >> e if *(*Tuint64_t)(unsafe.Pointer(bp))&mask == uint64(0) { - *(*float64)(unsafe.Pointer(iptr)) = x + **(**float64)(__ccgo_up(iptr)) = x *(*Tuint64_t)(unsafe.Pointer(bp)) &= Uint64FromUint64(1) << Int32FromInt32(63) return *(*float64)(unsafe.Pointer(bp)) } *(*Tuint64_t)(unsafe.Pointer(bp)) &= ^mask - *(*float64)(unsafe.Pointer(iptr)) = *(*float64)(unsafe.Pointer(bp)) + **(**float64)(__ccgo_up(iptr)) = *(*float64)(unsafe.Pointer(bp)) return x - *(*float64)(unsafe.Pointer(bp)) } @@ -110685,7 +110685,7 @@ func Xmodff(tls *TLS, x float32, iptr uintptr) (r float32) { e = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(bp))>>Int32FromInt32(23)&Uint32FromInt32(0xff)) - int32(0x7f) /* no fractional part */ if e >= int32(23) { - *(*float32)(unsafe.Pointer(iptr)) = x + **(**float32)(__ccgo_up(iptr)) = x if e == int32(0x80) && *(*Tuint32_t)(unsafe.Pointer(bp))<> e) if *(*Tuint32_t)(unsafe.Pointer(bp))&mask == uint32(0) { - *(*float32)(unsafe.Pointer(iptr)) = x + **(**float32)(__ccgo_up(iptr)) = x *(*Tuint32_t)(unsafe.Pointer(bp)) &= uint32(0x80000000) return *(*float32)(unsafe.Pointer(bp)) } *(*Tuint32_t)(unsafe.Pointer(bp)) &= ^mask - *(*float32)(unsafe.Pointer(iptr)) = *(*float32)(unsafe.Pointer(bp)) + **(**float32)(__ccgo_up(iptr)) = *(*float32)(unsafe.Pointer(bp)) return x - *(*float32)(unsafe.Pointer(bp)) } @@ -110720,7 +110720,7 @@ func Xmodfl(tls *TLS, x float64, iptr uintptr) (r1 float64) { var _ /* d at bp+0 */ float64 _ = r r = Xmodf(tls, x, bp) - *(*float64)(unsafe.Pointer(iptr)) = *(*float64)(unsafe.Pointer(bp)) + **(**float64)(__ccgo_up(iptr)) = float64(**(**float64)(__ccgo_up(bp))) return r } @@ -111130,27 +111130,27 @@ func _log_inline(tls *TLS, ix Tuint64_t, tail uintptr) (r1 Tdouble_t) { z = *(*float64)(unsafe.Pointer(&iz)) kd = float64(k) /* log(x) = k*Ln2 + log(c) + log1p(z/c-1). */ - invc = (*(*struct { + invc = (**(**struct { F__ccgo_align [0]uint32 Finvc float64 Fpad float64 Flogc float64 Flogctail float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Finvc - logc = (*(*struct { + })(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Finvc + logc = (**(**struct { F__ccgo_align [0]uint32 Finvc float64 Fpad float64 Flogc float64 Flogctail float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Flogc - logctail = (*(*struct { + })(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Flogc + logctail = (**(**struct { F__ccgo_align [0]uint32 Finvc float64 Fpad float64 Flogc float64 Flogctail float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Flogctail + })(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Flogctail v1 = (iz + Uint64FromUint64(1)<> (Int32FromInt32(23) - Int32FromInt32(POWF_SCALE_BITS)) /* arithmetic shift */ - invc = (*(*struct { + invc = (**(**struct { F__ccgo_align [0]uint32 Finvc float64 Flogc float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + uintptr(i)*16))).Finvc - logc = (*(*struct { + })(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + uintptr(i)*16))).Finvc + logc = (**(**struct { F__ccgo_align [0]uint32 Finvc float64 Flogc float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + uintptr(i)*16))).Flogc + })(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + uintptr(i)*16))).Flogc z = float64(*(*float32)(unsafe.Pointer(&iz))) /* log2(x) = log1p(z/c-1)/ln2 + log2(c) + k */ r = Tdouble_t(z*invc) - Float64FromInt32(1) y0 = logc + float64(k) /* Pipelined polynomial evaluation to approximate log1p(r)/ln2. */ r2 = Tdouble_t(r * r) - y = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256))*r) + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 1*8)) - p = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 2*8))*r) + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 3*8)) + y = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256))*r) + **(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 1*8)) + p = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 2*8))*r) + **(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 3*8)) r4 = Tdouble_t(r2 * r2) - q = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 4*8))*r) + y0 + q = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 4*8))*r) + y0 q = Tdouble_t(p*r2) + q y = Tdouble_t(y*r4) + q return y @@ -111580,13 +111580,13 @@ _2: kd = kd - X__exp2f_data.Fshift_scaled /* k/N */ r = xd - kd /* exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1) */ - t = *(*Tuint64_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + uintptr(ki%Uint64FromInt32(Int32FromInt32(1)<> int32(63)) sy = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp + 16)) >> int32(63)) uxi = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) - *(*int32)(unsafe.Pointer(quo)) = 0 + **(**int32)(__ccgo_up(quo)) = 0 if v3 = *(*Tuint64_t)(unsafe.Pointer(bp + 16))<> int32(31)) sy = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(bp + 8)) >> int32(31)) uxi = *(*Tuint32_t)(unsafe.Pointer(bp + 4)) - *(*int32)(unsafe.Pointer(quo)) = 0 + **(**int32)(__ccgo_up(quo)) = 0 if v3 = *(*Tuint32_t)(unsafe.Pointer(bp + 8))<= uint32(0x7ff00000) { v1 = x3 - x3 - *(*float64)(unsafe.Pointer(cos)) = v1 - *(*float64)(unsafe.Pointer(sin)) = v1 + **(**float64)(__ccgo_up(cos)) = v1 + **(**float64)(__ccgo_up(sin)) = v1 return } /* argument reduction needed */ n = Uint32FromInt32(X__rem_pio2(tls, x3, bp)) - s = X__sin(tls, (*(*[2]float64)(unsafe.Pointer(bp)))[0], (*(*[2]float64)(unsafe.Pointer(bp)))[int32(1)], int32(1)) - c = X__cos(tls, (*(*[2]float64)(unsafe.Pointer(bp)))[0], (*(*[2]float64)(unsafe.Pointer(bp)))[int32(1)]) + s = X__sin(tls, (**(**[2]float64)(__ccgo_up(bp)))[0], (**(**[2]float64)(__ccgo_up(bp)))[int32(1)], int32(1)) + c = X__cos(tls, (**(**[2]float64)(__ccgo_up(bp)))[0], (**(**[2]float64)(__ccgo_up(bp)))[int32(1)]) switch n & Uint32FromInt32(3) { case uint32(0): - *(*float64)(unsafe.Pointer(sin)) = s - *(*float64)(unsafe.Pointer(cos)) = c + **(**float64)(__ccgo_up(sin)) = s + **(**float64)(__ccgo_up(cos)) = c case uint32(1): - *(*float64)(unsafe.Pointer(sin)) = c - *(*float64)(unsafe.Pointer(cos)) = -s + **(**float64)(__ccgo_up(sin)) = c + **(**float64)(__ccgo_up(cos)) = -s case uint32(2): - *(*float64)(unsafe.Pointer(sin)) = -s - *(*float64)(unsafe.Pointer(cos)) = -c + **(**float64)(__ccgo_up(sin)) = -s + **(**float64)(__ccgo_up(cos)) = -c case uint32(3): fallthrough default: - *(*float64)(unsafe.Pointer(sin)) = -c - *(*float64)(unsafe.Pointer(cos)) = s + **(**float64)(__ccgo_up(sin)) = -c + **(**float64)(__ccgo_up(cos)) = s break } } @@ -112841,23 +112841,23 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { y2 = float64(v1) } } - *(*float32)(unsafe.Pointer(sin)) = x3 - *(*float32)(unsafe.Pointer(cos)) = Float32FromFloat32(1) + **(**float32)(__ccgo_up(sin)) = x3 + **(**float32)(__ccgo_up(cos)) = Float32FromFloat32(1) return } - *(*float32)(unsafe.Pointer(sin)) = X__sindf(tls, float64(x3)) - *(*float32)(unsafe.Pointer(cos)) = X__cosdf(tls, float64(x3)) + **(**float32)(__ccgo_up(sin)) = X__sindf(tls, float64(x3)) + **(**float32)(__ccgo_up(cos)) = X__cosdf(tls, float64(x3)) return } /* |x| ~<= 5*pi/4 */ if ix <= uint32(0x407b53d1) { if ix <= uint32(0x4016cbe3) { /* |x| ~<= 3pi/4 */ if sign != 0 { - *(*float32)(unsafe.Pointer(sin)) = -X__cosdf(tls, float64(x3)+_s1pio2) - *(*float32)(unsafe.Pointer(cos)) = X__sindf(tls, float64(x3)+_s1pio2) + **(**float32)(__ccgo_up(sin)) = -X__cosdf(tls, float64(x3)+_s1pio2) + **(**float32)(__ccgo_up(cos)) = X__sindf(tls, float64(x3)+_s1pio2) } else { - *(*float32)(unsafe.Pointer(sin)) = X__cosdf(tls, _s1pio2-float64(x3)) - *(*float32)(unsafe.Pointer(cos)) = X__sindf(tls, _s1pio2-float64(x3)) + **(**float32)(__ccgo_up(sin)) = X__cosdf(tls, _s1pio2-float64(x3)) + **(**float32)(__ccgo_up(cos)) = X__sindf(tls, _s1pio2-float64(x3)) } return } @@ -112867,24 +112867,24 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { } else { v4 = float64(x3) - _s2pio2 } - *(*float32)(unsafe.Pointer(sin)) = -X__sindf(tls, v4) + **(**float32)(__ccgo_up(sin)) = -X__sindf(tls, v4) if sign != 0 { v4 = float64(x3) + _s2pio2 } else { v4 = float64(x3) - _s2pio2 } - *(*float32)(unsafe.Pointer(cos)) = -X__cosdf(tls, v4) + **(**float32)(__ccgo_up(cos)) = -X__cosdf(tls, v4) return } /* |x| ~<= 9*pi/4 */ if ix <= uint32(0x40e231d5) { if ix <= uint32(0x40afeddf) { /* |x| ~<= 7*pi/4 */ if sign != 0 { - *(*float32)(unsafe.Pointer(sin)) = X__cosdf(tls, float64(x3)+_s3pio2) - *(*float32)(unsafe.Pointer(cos)) = -X__sindf(tls, float64(x3)+_s3pio2) + **(**float32)(__ccgo_up(sin)) = X__cosdf(tls, float64(x3)+_s3pio2) + **(**float32)(__ccgo_up(cos)) = -X__sindf(tls, float64(x3)+_s3pio2) } else { - *(*float32)(unsafe.Pointer(sin)) = -X__cosdf(tls, float64(x3)-_s3pio2) - *(*float32)(unsafe.Pointer(cos)) = X__sindf(tls, float64(x3)-_s3pio2) + **(**float32)(__ccgo_up(sin)) = -X__cosdf(tls, float64(x3)-_s3pio2) + **(**float32)(__ccgo_up(cos)) = X__sindf(tls, float64(x3)-_s3pio2) } return } @@ -112893,41 +112893,41 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { } else { v4 = float64(x3) - _s4pio2 } - *(*float32)(unsafe.Pointer(sin)) = X__sindf(tls, v4) + **(**float32)(__ccgo_up(sin)) = X__sindf(tls, v4) if sign != 0 { v4 = float64(x3) + _s4pio2 } else { v4 = float64(x3) - _s4pio2 } - *(*float32)(unsafe.Pointer(cos)) = X__cosdf(tls, v4) + **(**float32)(__ccgo_up(cos)) = X__cosdf(tls, v4) return } /* sin(Inf or NaN) is NaN */ if ix >= uint32(0x7f800000) { v1 = x3 - x3 - *(*float32)(unsafe.Pointer(cos)) = v1 - *(*float32)(unsafe.Pointer(sin)) = v1 + **(**float32)(__ccgo_up(cos)) = v1 + **(**float32)(__ccgo_up(sin)) = v1 return } /* general argument reduction needed */ n = Uint32FromInt32(X__rem_pio2f(tls, x3, bp)) - s = X__sindf(tls, *(*float64)(unsafe.Pointer(bp))) - c = X__cosdf(tls, *(*float64)(unsafe.Pointer(bp))) + s = X__sindf(tls, **(**float64)(__ccgo_up(bp))) + c = X__cosdf(tls, **(**float64)(__ccgo_up(bp))) switch n & Uint32FromInt32(3) { case uint32(0): - *(*float32)(unsafe.Pointer(sin)) = s - *(*float32)(unsafe.Pointer(cos)) = c + **(**float32)(__ccgo_up(sin)) = s + **(**float32)(__ccgo_up(cos)) = c case uint32(1): - *(*float32)(unsafe.Pointer(sin)) = c - *(*float32)(unsafe.Pointer(cos)) = -s + **(**float32)(__ccgo_up(sin)) = c + **(**float32)(__ccgo_up(cos)) = -s case uint32(2): - *(*float32)(unsafe.Pointer(sin)) = -s - *(*float32)(unsafe.Pointer(cos)) = -c + **(**float32)(__ccgo_up(sin)) = -s + **(**float32)(__ccgo_up(cos)) = -c case uint32(3): fallthrough default: - *(*float32)(unsafe.Pointer(sin)) = -c - *(*float32)(unsafe.Pointer(cos)) = s + **(**float32)(__ccgo_up(sin)) = -c + **(**float32)(__ccgo_up(cos)) = s break } } @@ -112943,8 +112943,8 @@ func Xsincosl(tls *TLS, x float64, sin uintptr, cos uintptr) { var _ /* cosd at bp+8 */ float64 var _ /* sind at bp+0 */ float64 Xsincos(tls, x, bp, bp+8) - *(*float64)(unsafe.Pointer(sin)) = *(*float64)(unsafe.Pointer(bp)) - *(*float64)(unsafe.Pointer(cos)) = *(*float64)(unsafe.Pointer(bp + 8)) + **(**float64)(__ccgo_up(sin)) = float64(**(**float64)(__ccgo_up(bp))) + **(**float64)(__ccgo_up(cos)) = float64(**(**float64)(__ccgo_up(bp + 8))) } const M_PI_27 = 1.5707963267948966 @@ -113043,13 +113043,13 @@ func Xsinf(tls *TLS, x3 float32) (r float32) { n = X__rem_pio2f(tls, x3, bp) switch n & Int32FromInt32(3) { case 0: - return X__sindf(tls, *(*float64)(unsafe.Pointer(bp))) + return X__sindf(tls, **(**float64)(__ccgo_up(bp))) case int32(1): - return X__cosdf(tls, *(*float64)(unsafe.Pointer(bp))) + return X__cosdf(tls, **(**float64)(__ccgo_up(bp))) case int32(2): - return X__sindf(tls, -*(*float64)(unsafe.Pointer(bp))) + return X__sindf(tls, -**(**float64)(__ccgo_up(bp))) default: - return -X__cosdf(tls, *(*float64)(unsafe.Pointer(bp))) + return -X__cosdf(tls, **(**float64)(__ccgo_up(bp))) } return r } @@ -113498,7 +113498,7 @@ func Xtan(tls *TLS, x3 float64) (r float64) { } /* argument reduction */ n = Uint32FromInt32(X__rem_pio2(tls, x3, bp)) - return X__tan(tls, (*(*[2]float64)(unsafe.Pointer(bp)))[0], (*(*[2]float64)(unsafe.Pointer(bp)))[int32(1)], Int32FromUint32(n&uint32(1))) + return X__tan(tls, (**(**[2]float64)(__ccgo_up(bp)))[0], (**(**[2]float64)(__ccgo_up(bp)))[int32(1)], Int32FromUint32(n&uint32(1))) } const M_PI_29 = 1.5707963267948966 @@ -113599,7 +113599,7 @@ func Xtanf(tls *TLS, x3 float32) (r float32) { } /* argument reduction */ n = Uint32FromInt32(X__rem_pio2f(tls, x3, bp)) - return X__tandf(tls, *(*float64)(unsafe.Pointer(bp)), Int32FromUint32(n&uint32(1))) + return X__tandf(tls, **(**float64)(__ccgo_up(bp)), Int32FromUint32(n&uint32(1))) } const M_PI_210 = 0 @@ -114148,10 +114148,10 @@ func Xa64l(tls *TLS, s uintptr) (r int32) { x = uint32(0) e = 0 for { - if !(e < int32(36) && *(*uint8)(unsafe.Pointer(s)) != 0) { + if !(e < int32(36) && **(**uint8)(__ccgo_up(s)) != 0) { break } - d = Xstrchr(tls, uintptr(unsafe.Pointer(&_digits)), Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))) + d = Xstrchr(tls, uintptr(unsafe.Pointer(&_digits)), Int32FromUint8(**(**uint8)(__ccgo_up(s)))) if !(d != 0) { break } @@ -114179,14 +114179,14 @@ func Xl64a(tls *TLS, x0 int32) (r uintptr) { if !(x != 0) { break } - *(*uint8)(unsafe.Pointer(p)) = _digits[x&uint32(63)] + **(**uint8)(__ccgo_up(p)) = _digits[x&uint32(63)] goto _1 _1: ; p = p + 1 x = x >> uint32(6) } - *(*uint8)(unsafe.Pointer(p)) = uint8(0) + **(**uint8)(__ccgo_up(p)) = uint8(0) return uintptr(unsafe.Pointer(&_s)) } @@ -114199,22 +114199,22 @@ func Xbasename(tls *TLS, s uintptr) (r uintptr) { } var i Tsize_t _ = i - if !(s != 0) || !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(s != 0) || !(**(**uint8)(__ccgo_up(s)) != 0) { return __ccgo_ts + 483 } i = _strlen(tls, s) - uint32(1) for { - if !(i != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(i)))) == int32('/')) { + if !(i != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(i)))) == int32('/')) { break } - *(*uint8)(unsafe.Pointer(s + uintptr(i))) = uint8(0) + **(**uint8)(__ccgo_up(s + uintptr(i))) = uint8(0) goto _1 _1: ; i = i - 1 } for { - if !(i != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(i-uint32(1))))) != int32('/')) { + if !(i != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(i-uint32(1))))) != int32('/')) { break } goto _2 @@ -114240,12 +114240,12 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { } var i Tsize_t _ = i - if !(s != 0) || !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(s != 0) || !(**(**uint8)(__ccgo_up(s)) != 0) { return __ccgo_ts + 483 } i = _strlen(tls, s) - uint32(1) for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(i)))) == int32('/')) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(i)))) == int32('/')) { break } if !(i != 0) { @@ -114257,7 +114257,7 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { i = i - 1 } for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(i)))) != int32('/')) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(i)))) != int32('/')) { break } if !(i != 0) { @@ -114269,7 +114269,7 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { i = i - 1 } for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(i)))) == int32('/')) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(i)))) == int32('/')) { break } if !(i != 0) { @@ -114280,7 +114280,7 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { ; i = i - 1 } - *(*uint8)(unsafe.Pointer(s + uintptr(i+uint32(1)))) = uint8(0) + **(**uint8)(__ccgo_up(s + uintptr(i+uint32(1)))) = uint8(0) return s } @@ -114471,10 +114471,10 @@ func __strcolcmp(tls *TLS, lstr uintptr, bstr uintptr) (r int32) { var i Tsize_t _ = i i = uint32(0) - for *(*uint8)(unsafe.Pointer(lstr + uintptr(i))) != 0 && *(*uint8)(unsafe.Pointer(bstr + uintptr(i))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(bstr + uintptr(i)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(lstr + uintptr(i)))) { + for **(**uint8)(__ccgo_up(lstr + uintptr(i))) != 0 && **(**uint8)(__ccgo_up(bstr + uintptr(i))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(bstr + uintptr(i)))) == Int32FromUint8(**(**uint8)(__ccgo_up(lstr + uintptr(i)))) { i = i + 1 } - if *(*uint8)(unsafe.Pointer(lstr + uintptr(i))) != 0 || *(*uint8)(unsafe.Pointer(bstr + uintptr(i))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(bstr + uintptr(i)))) != int32(':') { + if **(**uint8)(__ccgo_up(lstr + uintptr(i))) != 0 || **(**uint8)(__ccgo_up(bstr + uintptr(i))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(bstr + uintptr(i)))) != int32(':') { return int32(1) } return 0 @@ -114572,7 +114572,7 @@ func Xfmtmsg(tls *TLS, classification int32, label uintptr, severity int32, text } } if classification&int32(MM_PRINT) != 0 { - for cmsg != 0 && *(*uint8)(unsafe.Pointer(cmsg)) != 0 { + for cmsg != 0 && **(**uint8)(__ccgo_up(cmsg)) != 0 { i = 0 for { if !(msgs[i] != 0) { @@ -114648,7 +114648,7 @@ func Xfmtmsg(tls *TLS, classification int32, label uintptr, severity int32, text if ret&(Int32FromInt32(MM_NOCON)|Int32FromInt32(MM_NOMSG)) == Int32FromInt32(MM_NOCON)|Int32FromInt32(MM_NOMSG) { ret = -int32(1) } - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) return ret } @@ -114664,7 +114664,7 @@ func Xget_current_dir_name(tls *TLS) (r uintptr) { var _ /* b at bp+152 */ Tstat _ = res res = Xgetenv(tls, __ccgo_ts+607) - if res != 0 && *(*uint8)(unsafe.Pointer(res)) != 0 && !(Xstat(tls, res, bp) != 0) && !(Xstat(tls, __ccgo_ts+483, bp+152) != 0) && (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev == (*(*Tstat)(unsafe.Pointer(bp + 152))).Fst_dev && (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino == (*(*Tstat)(unsafe.Pointer(bp + 152))).Fst_ino { + if res != 0 && **(**uint8)(__ccgo_up(res)) != 0 && !(Xstat(tls, res, bp) != 0) && !(Xstat(tls, __ccgo_ts+483, bp+152) != 0) && (**(**Tstat)(__ccgo_up(bp))).Fst_dev == (**(**Tstat)(__ccgo_up(bp + 152))).Fst_dev && (**(**Tstat)(__ccgo_up(bp))).Fst_ino == (**(**Tstat)(__ccgo_up(bp + 152))).Fst_ino { return Xstrdup(tls, res) } return Xgetcwd(tls, uintptr(0), uint32(0)) @@ -114682,18 +114682,18 @@ func X__getauxval(tls *TLS, item uint32) (r uint32) { return uint32(X__libc.Fsecure) } for { - if !(*(*Tsize_t)(unsafe.Pointer(auxv)) != 0) { + if !(**(**Tsize_t)(__ccgo_up(auxv)) != 0) { break } - if *(*Tsize_t)(unsafe.Pointer(auxv)) == item { - return *(*Tsize_t)(unsafe.Pointer(auxv + 1*4)) + if uint32(**(**Tsize_t)(__ccgo_up(auxv))) == item { + return uint32(**(**Tsize_t)(__ccgo_up(auxv + 1*4))) } goto _1 _1: ; auxv = auxv + uintptr(2)*4 } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOENT) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOENT) return uint32(0) } @@ -114724,7 +114724,7 @@ func Xgetdomainname(tls *TLS, name uintptr, len1 Tsize_t) (r int32) { var _ /* temp at bp+0 */ Tutsname Xuname(tls, bp) if !(len1 != 0) || _strlen(tls, bp+325) >= len1 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } Xstrcpy(tls, name, bp+325) @@ -114745,14 +114745,14 @@ func Xgetentropy(tls *TLS, buffer uintptr, len1 Tsize_t) (r int32) { ret = 0 pos = buffer if len1 > uint32(256) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EIO) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EIO) return -int32(1) } _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp) for len1 != 0 { ret = Xgetrandom(tls, pos, len1, uint32(0)) if ret < 0 { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EINTR) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EINTR) { continue } else { break @@ -114762,7 +114762,7 @@ func Xgetentropy(tls *TLS, buffer uintptr, len1 Tsize_t) (r int32) { len1 = len1 - Uint32FromInt32(ret) ret = 0 } - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) return ret } @@ -114816,46 +114816,46 @@ func Xgetopt(tls *TLS, argc int32, argv uintptr, optstring uintptr) (r int32) { X__optpos = 0 Xoptind = int32(1) } - if Xoptind >= argc || !(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4)) != 0) { + if Xoptind >= argc || !(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*4)) != 0) { return -int32(1) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4))))) != int32('-') { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) == int32('-') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*4))))) != int32('-') { + if Int32FromUint8(**(**uint8)(__ccgo_up(optstring))) == int32('-') { v1 = Xoptind Xoptind = Xoptind + 1 - Xoptarg = *(*uintptr)(unsafe.Pointer(argv + uintptr(v1)*4)) + Xoptarg = **(**uintptr)(__ccgo_up(argv + uintptr(v1)*4)) return int32(1) } return -int32(1) } - if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4)) + 1)) != 0) { + if !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*4)) + 1)) != 0) { return -int32(1) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4)) + 1))) == int32('-') && !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4)) + 2)) != 0) { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*4)) + 1))) == int32('-') && !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*4)) + 2)) != 0) { Xoptind = Xoptind + 1 return -Int32FromInt32(1) } if !(X__optpos != 0) { X__optpos = X__optpos + 1 } - v1 = Xmbtowc(tls, bp, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4))+uintptr(X__optpos), uint32(MB_LEN_MAX)) + v1 = Xmbtowc(tls, bp, **(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*4))+uintptr(X__optpos), uint32(MB_LEN_MAX)) k = v1 if v1 < 0 { k = int32(1) - *(*Twchar_t)(unsafe.Pointer(bp)) = uint32(0xfffd) /* replacement char */ + **(**Twchar_t)(__ccgo_up(bp)) = uint32(0xfffd) /* replacement char */ } - optchar = *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4)) + uintptr(X__optpos) + optchar = **(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*4)) + uintptr(X__optpos) X__optpos = X__optpos + k - if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4)) + uintptr(X__optpos))) != 0) { + if !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*4)) + uintptr(X__optpos))) != 0) { Xoptind = Xoptind + 1 X__optpos = 0 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) == int32('-') || Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) == int32('+') { + if Int32FromUint8(**(**uint8)(__ccgo_up(optstring))) == int32('-') || Int32FromUint8(**(**uint8)(__ccgo_up(optstring))) == int32('+') { optstring = optstring + 1 } i = 0 - *(*Twchar_t)(unsafe.Pointer(bp + 4)) = uint32(0) - for cond := true; cond; cond = l != 0 && *(*Twchar_t)(unsafe.Pointer(bp + 4)) != *(*Twchar_t)(unsafe.Pointer(bp)) { + **(**Twchar_t)(__ccgo_up(bp + 4)) = uint32(0) + for cond := true; cond; cond = l != 0 && **(**Twchar_t)(__ccgo_up(bp + 4)) != **(**Twchar_t)(__ccgo_up(bp)) { l = Xmbtowc(tls, bp+4, optstring+uintptr(i), uint32(MB_LEN_MAX)) if l > 0 { i = i + l @@ -114863,36 +114863,36 @@ func Xgetopt(tls *TLS, argc int32, argv uintptr, optstring uintptr) (r int32) { i = i + 1 } } - if *(*Twchar_t)(unsafe.Pointer(bp + 4)) != *(*Twchar_t)(unsafe.Pointer(bp)) || *(*Twchar_t)(unsafe.Pointer(bp)) == uint32(':') { - Xoptopt = Int32FromUint32(*(*Twchar_t)(unsafe.Pointer(bp))) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) != int32(':') && Xopterr != 0 { - X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), __ccgo_ts+611, optchar, Uint32FromInt32(k)) + if **(**Twchar_t)(__ccgo_up(bp + 4)) != **(**Twchar_t)(__ccgo_up(bp)) || **(**Twchar_t)(__ccgo_up(bp)) == uint32(':') { + Xoptopt = Int32FromUint32(**(**Twchar_t)(__ccgo_up(bp))) + if Int32FromUint8(**(**uint8)(__ccgo_up(optstring))) != int32(':') && Xopterr != 0 { + X__getopt_msg(tls, **(**uintptr)(__ccgo_up(argv)), __ccgo_ts+611, optchar, Uint32FromInt32(k)) } return int32('?') } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring + uintptr(i)))) == int32(':') { + if Int32FromUint8(**(**uint8)(__ccgo_up(optstring + uintptr(i)))) == int32(':') { Xoptarg = uintptr(0) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring + uintptr(i+int32(1))))) != int32(':') || X__optpos != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(optstring + uintptr(i+int32(1))))) != int32(':') || X__optpos != 0 { v1 = Xoptind Xoptind = Xoptind + 1 - Xoptarg = *(*uintptr)(unsafe.Pointer(argv + uintptr(v1)*4)) + Xoptarg = **(**uintptr)(__ccgo_up(argv + uintptr(v1)*4)) if X__optpos != 0 { Xoptarg = Xoptarg + uintptr(X__optpos) } X__optpos = 0 } if Xoptind > argc { - Xoptopt = Int32FromUint32(*(*Twchar_t)(unsafe.Pointer(bp))) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) == int32(':') { + Xoptopt = Int32FromUint32(**(**Twchar_t)(__ccgo_up(bp))) + if Int32FromUint8(**(**uint8)(__ccgo_up(optstring))) == int32(':') { return int32(':') } if Xopterr != 0 { - X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), __ccgo_ts+635, optchar, Uint32FromInt32(k)) + X__getopt_msg(tls, **(**uintptr)(__ccgo_up(argv)), __ccgo_ts+635, optchar, Uint32FromInt32(k)) } return int32('?') } } - return Int32FromUint32(*(*Twchar_t)(unsafe.Pointer(bp))) + return Int32FromUint32(**(**Twchar_t)(__ccgo_up(bp))) } func X__posix_getopt(tls *TLS, argc int32, argv uintptr, optstring uintptr) (r int32) { @@ -114919,19 +114919,19 @@ func _permute(tls *TLS, argv uintptr, dest int32, src int32) { var i int32 _, _, _ = av, i, tmp av = argv - tmp = *(*uintptr)(unsafe.Pointer(av + uintptr(src)*4)) + tmp = **(**uintptr)(__ccgo_up(av + uintptr(src)*4)) i = src for { if !(i > dest) { break } - *(*uintptr)(unsafe.Pointer(av + uintptr(i)*4)) = *(*uintptr)(unsafe.Pointer(av + uintptr(i-int32(1))*4)) + **(**uintptr)(__ccgo_up(av + uintptr(i)*4)) = **(**uintptr)(__ccgo_up(av + uintptr(i-int32(1))*4)) goto _1 _1: ; i = i - 1 } - *(*uintptr)(unsafe.Pointer(av + uintptr(dest)*4)) = tmp + **(**uintptr)(__ccgo_up(av + uintptr(dest)*4)) = tmp } func ___getopt_long(tls *TLS, argc int32, argv uintptr, optstring uintptr, longopts uintptr, idx uintptr, longonly int32) (r int32) { @@ -114942,17 +114942,17 @@ func ___getopt_long(tls *TLS, argc int32, argv uintptr, optstring uintptr, longo X__optpos = 0 Xoptind = int32(1) } - if Xoptind >= argc || !(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4)) != 0) { + if Xoptind >= argc || !(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*4)) != 0) { return -int32(1) } skipped = Xoptind - if Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) != int32('+') && Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) != int32('-') { + if Int32FromUint8(**(**uint8)(__ccgo_up(optstring))) != int32('+') && Int32FromUint8(**(**uint8)(__ccgo_up(optstring))) != int32('-') { i = Xoptind for { - if i >= argc || !(*(*uintptr)(unsafe.Pointer(argv + uintptr(i)*4)) != 0) { + if i >= argc || !(**(**uintptr)(__ccgo_up(argv + uintptr(i)*4)) != 0) { return -int32(1) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(i)*4))))) == int32('-') && *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(i)*4)) + 1)) != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(i)*4))))) == int32('-') && **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(i)*4)) + 1)) != 0 { break } goto _1 @@ -114987,31 +114987,31 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, var cnt, colon, i, j, l, match, v2 int32 _, _, _, _, _, _, _, _, _, _, _, _ = arg, cnt, colon, i, j, l, match, name, opt, start, v2, v5 Xoptarg = uintptr(0) - if longopts != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4))))) == int32('-') && (longonly != 0 && *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4)) + 1)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4)) + 1))) != int32('-') || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4)) + 1))) == int32('-') && *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4)) + 2)) != 0) { - colon = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring + BoolUintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) == int32('+') || Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) == int32('-'))))) == int32(':')) - start = *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4)) + uintptr(1) + if longopts != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*4))))) == int32('-') && (longonly != 0 && **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*4)) + 1)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*4)) + 1))) != int32('-') || Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*4)) + 1))) == int32('-') && **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*4)) + 2)) != 0) { + colon = BoolInt32(Int32FromUint8(**(**uint8)(__ccgo_up(optstring + BoolUintptr(Int32FromUint8(**(**uint8)(__ccgo_up(optstring))) == int32('+') || Int32FromUint8(**(**uint8)(__ccgo_up(optstring))) == int32('-'))))) == int32(':')) + start = **(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*4)) + uintptr(1) v2 = Int32FromInt32(0) i = v2 cnt = v2 for { - if !((*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*16))).Fname != 0) { + if !((**(**Toption)(__ccgo_up(longopts + uintptr(i)*16))).Fname != 0) { break } - name = (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*16))).Fname + name = (**(**Toption)(__ccgo_up(longopts + uintptr(i)*16))).Fname opt = start - if Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) == int32('-') { + if Int32FromUint8(**(**uint8)(__ccgo_up(opt))) == int32('-') { opt = opt + 1 } - for *(*uint8)(unsafe.Pointer(opt)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) != int32('=') && Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) { + for **(**uint8)(__ccgo_up(opt)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(opt))) != int32('=') && Int32FromUint8(**(**uint8)(__ccgo_up(opt))) == Int32FromUint8(**(**uint8)(__ccgo_up(name))) { name = name + 1 opt = opt + 1 } - if *(*uint8)(unsafe.Pointer(opt)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) != int32('=') { + if **(**uint8)(__ccgo_up(opt)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(opt))) != int32('=') { goto _1 } arg = opt match = i - if !(*(*uint8)(unsafe.Pointer(name)) != 0) { + if !(**(**uint8)(__ccgo_up(name)) != 0) { cnt = int32(1) break } @@ -115025,12 +115025,12 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, l = int32(arg) - int32(start) i = 0 for { - if !(*(*uint8)(unsafe.Pointer(optstring + uintptr(i))) != 0) { + if !(**(**uint8)(__ccgo_up(optstring + uintptr(i))) != 0) { break } j = 0 for { - if !(j < l && Int32FromUint8(*(*uint8)(unsafe.Pointer(start + uintptr(j)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring + uintptr(i+j))))) { + if !(j < l && Int32FromUint8(**(**uint8)(__ccgo_up(start + uintptr(j)))) == Int32FromUint8(**(**uint8)(__ccgo_up(optstring + uintptr(i+j))))) { break } goto _4 @@ -115052,44 +115052,44 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, i = match opt = arg Xoptind = Xoptind + 1 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) == int32('=') { - if !((*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*16))).Fhas_arg != 0) { - Xoptopt = (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*16))).Fval + if Int32FromUint8(**(**uint8)(__ccgo_up(opt))) == int32('=') { + if !((**(**Toption)(__ccgo_up(longopts + uintptr(i)*16))).Fhas_arg != 0) { + Xoptopt = (**(**Toption)(__ccgo_up(longopts + uintptr(i)*16))).Fval if colon != 0 || !(Xopterr != 0) { return int32('?') } - X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), __ccgo_ts+667, (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*16))).Fname, _strlen(tls, (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*16))).Fname)) + X__getopt_msg(tls, **(**uintptr)(__ccgo_up(argv)), __ccgo_ts+667, (**(**Toption)(__ccgo_up(longopts + uintptr(i)*16))).Fname, _strlen(tls, (**(**Toption)(__ccgo_up(longopts + uintptr(i)*16))).Fname)) return int32('?') } Xoptarg = opt + uintptr(1) } else { - if (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*16))).Fhas_arg == int32(required_argument) { - v5 = *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4)) + if (**(**Toption)(__ccgo_up(longopts + uintptr(i)*16))).Fhas_arg == int32(required_argument) { + v5 = **(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*4)) Xoptarg = v5 if !(v5 != 0) { - Xoptopt = (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*16))).Fval + Xoptopt = (**(**Toption)(__ccgo_up(longopts + uintptr(i)*16))).Fval if colon != 0 { return int32(':') } if !(Xopterr != 0) { return int32('?') } - X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), __ccgo_ts+635, (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*16))).Fname, _strlen(tls, (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*16))).Fname)) + X__getopt_msg(tls, **(**uintptr)(__ccgo_up(argv)), __ccgo_ts+635, (**(**Toption)(__ccgo_up(longopts + uintptr(i)*16))).Fname, _strlen(tls, (**(**Toption)(__ccgo_up(longopts + uintptr(i)*16))).Fname)) return int32('?') } Xoptind = Xoptind + 1 } } if idx != 0 { - *(*int32)(unsafe.Pointer(idx)) = i + **(**int32)(__ccgo_up(idx)) = i } - if (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*16))).Fflag != 0 { - *(*int32)(unsafe.Pointer((*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*16))).Fflag)) = (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*16))).Fval + if (**(**Toption)(__ccgo_up(longopts + uintptr(i)*16))).Fflag != 0 { + **(**int32)(__ccgo_up((**(**Toption)(__ccgo_up(longopts + uintptr(i)*16))).Fflag)) = (**(**Toption)(__ccgo_up(longopts + uintptr(i)*16))).Fval return 0 } - return (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*16))).Fval + return (**(**Toption)(__ccgo_up(longopts + uintptr(i)*16))).Fval } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4)) + 1))) == int32('-') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*4)) + 1))) == int32('-') { Xoptopt = 0 if !(colon != 0) && Xopterr != 0 { if cnt != 0 { @@ -115097,7 +115097,7 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, } else { v5 = __ccgo_ts + 611 } - X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), v5, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4))+uintptr(2), _strlen(tls, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4))+uintptr(2))) + X__getopt_msg(tls, **(**uintptr)(__ccgo_up(argv)), v5, **(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*4))+uintptr(2), _strlen(tls, **(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*4))+uintptr(2))) } Xoptind = Xoptind + 1 return int32('?') @@ -115172,22 +115172,22 @@ func Xgetrlimit(tls *TLS, resource int32, rlim uintptr) (r int32) { (*Trlimit)(unsafe.Pointer(rlim)).Frlim_max = ^Uint64FromUint64(0) } } - if !(ret != 0) || *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(ENOSYS) { + if !(ret != 0) || **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(ENOSYS) { return ret } if X__syscall_ret(tls, Uint32FromInt32(X__syscall2(tls, int32(SYS_ugetrlimit), resource, int32(bp)))) < 0 { return -int32(1) } - if (*(*[2]uint32)(unsafe.Pointer(bp)))[0] == -Uint32FromUint32(1) { + if (**(**[2]uint32)(__ccgo_up(bp)))[0] == -Uint32FromUint32(1) { v1 = ^Uint64FromUint64(0) } else { - v1 = uint64((*(*[2]uint32)(unsafe.Pointer(bp)))[0]) + v1 = uint64((**(**[2]uint32)(__ccgo_up(bp)))[0]) } (*Trlimit)(unsafe.Pointer(rlim)).Frlim_cur = v1 - if (*(*[2]uint32)(unsafe.Pointer(bp)))[int32(1)] == -Uint32FromUint32(1) { + if (**(**[2]uint32)(__ccgo_up(bp)))[int32(1)] == -Uint32FromUint32(1) { v1 = ^Uint64FromUint64(0) } else { - v1 = uint64((*(*[2]uint32)(unsafe.Pointer(bp)))[int32(1)]) + v1 = uint64((**(**[2]uint32)(__ccgo_up(bp)))[int32(1)]) } (*Trlimit)(unsafe.Pointer(rlim)).Frlim_max = v1 if (*Trlimit)(unsafe.Pointer(rlim)).Frlim_cur >= ^Uint64FromUint64(0) { @@ -115215,12 +115215,12 @@ func Xgetrusage(tls *TLS, who int32, ru uintptr) (r1 int32) { if !(r != 0) && Bool(uint32(8) > uint32(4)) { _memcpy(tls, bp, dest, Uint32FromInt32(4)*Uint32FromInt64(4)) (*Trusage)(unsafe.Pointer(ru)).Fru_utime = Ttimeval{ - Ftv_sec: int64((*(*[4]int32)(unsafe.Pointer(bp)))[0]), - Ftv_usec: int64((*(*[4]int32)(unsafe.Pointer(bp)))[int32(1)]), + Ftv_sec: int64((**(**[4]int32)(__ccgo_up(bp)))[0]), + Ftv_usec: int64((**(**[4]int32)(__ccgo_up(bp)))[int32(1)]), } (*Trusage)(unsafe.Pointer(ru)).Fru_stime = Ttimeval{ - Ftv_sec: int64((*(*[4]int32)(unsafe.Pointer(bp)))[int32(2)]), - Ftv_usec: int64((*(*[4]int32)(unsafe.Pointer(bp)))[int32(3)]), + Ftv_sec: int64((**(**[4]int32)(__ccgo_up(bp)))[int32(2)]), + Ftv_usec: int64((**(**[4]int32)(__ccgo_up(bp)))[int32(3)]), } } return X__syscall_ret(tls, Uint32FromInt32(r)) @@ -115235,30 +115235,30 @@ func Xgetsubopt(tls *TLS, opt uintptr, keys uintptr, val uintptr) (r int32) { var l Tsize_t var s, v1, v2 uintptr _, _, _, _, _ = i, l, s, v1, v2 - s = *(*uintptr)(unsafe.Pointer(opt)) - *(*uintptr)(unsafe.Pointer(val)) = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(opt)) = Xstrchr(tls, s, int32(',')) - if *(*uintptr)(unsafe.Pointer(opt)) != 0 { + s = **(**uintptr)(__ccgo_up(opt)) + **(**uintptr)(__ccgo_up(val)) = UintptrFromInt32(0) + **(**uintptr)(__ccgo_up(opt)) = Xstrchr(tls, s, int32(',')) + if **(**uintptr)(__ccgo_up(opt)) != 0 { v2 = opt v1 = *(*uintptr)(unsafe.Pointer(v2)) *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(v2)) + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) } else { - *(*uintptr)(unsafe.Pointer(opt)) = s + uintptr(_strlen(tls, s)) + **(**uintptr)(__ccgo_up(opt)) = s + uintptr(_strlen(tls, s)) } i = 0 for { - if !(*(*uintptr)(unsafe.Pointer(keys + uintptr(i)*4)) != 0) { + if !(**(**uintptr)(__ccgo_up(keys + uintptr(i)*4)) != 0) { break } - l = _strlen(tls, *(*uintptr)(unsafe.Pointer(keys + uintptr(i)*4))) - if Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(keys + uintptr(i)*4)), s, l) != 0 { + l = _strlen(tls, **(**uintptr)(__ccgo_up(keys + uintptr(i)*4))) + if Xstrncmp(tls, **(**uintptr)(__ccgo_up(keys + uintptr(i)*4)), s, l) != 0 { goto _3 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(l)))) == int32('=') { - *(*uintptr)(unsafe.Pointer(val)) = s + uintptr(l) + uintptr(1) + if Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(l)))) == int32('=') { + **(**uintptr)(__ccgo_up(val)) = s + uintptr(l) + uintptr(1) } else { - if *(*uint8)(unsafe.Pointer(s + uintptr(l))) != 0 { + if **(**uint8)(__ccgo_up(s + uintptr(l))) != 0 { goto _3 } } @@ -115550,7 +115550,7 @@ func _convert_ioctl_struct(tls *TLS, map1 uintptr, old uintptr, new1 uintptr, di if !(i < Int32FromUint8((*Tioctl_compat_map)(unsafe.Pointer(map1)).Fnoffs)) { break } - ts_offset = Int32FromUint8(*(*uint8)(unsafe.Pointer(map1 + 12 + uintptr(i)))) + ts_offset = Int32FromUint8(**(**uint8)(__ccgo_up(map1 + 12 + uintptr(i)))) len1 = ts_offset - old_offset if dir == int32(W) { _memcpy(tls, old+uintptr(old_offset), new1+uintptr(new_offset), Uint32FromInt32(len1)) @@ -115568,11 +115568,11 @@ func _convert_ioctl_struct(tls *TLS, map1 uintptr, old uintptr, new1 uintptr, di new_offset = new_offset + (align-int32(1))&-new_offset if dir == int32(W) { _memcpy(tls, bp, new1+uintptr(new_offset), uint32(8)) - *(*int32)(unsafe.Pointer(bp + 8)) = int32(*(*int64)(unsafe.Pointer(bp))) + **(**int32)(__ccgo_up(bp + 8)) = int32(**(**int64)(__ccgo_up(bp))) _memcpy(tls, old+uintptr(old_offset), bp+8, uint32(4)) } else { _memcpy(tls, bp+8, old+uintptr(old_offset), uint32(4)) - *(*int64)(unsafe.Pointer(bp)) = int64(*(*int32)(unsafe.Pointer(bp + 8))) + **(**int64)(__ccgo_up(bp)) = int64(**(**int32)(__ccgo_up(bp + 8))) _memcpy(tls, new1+uintptr(new_offset), bp, uint32(8)) } new_offset = Int32FromUint32(uint32(new_offset) + Uint32FromInt64(8)) @@ -115651,31 +115651,31 @@ func Xlockf(tls *TLS, fd int32, op int32, size Toff_t) (r int32) { bp := tls.Alloc(48) defer tls.Free(48) var _ /* l at bp+0 */ Tflock - *(*Tflock)(unsafe.Pointer(bp)) = Tflock{ + **(**Tflock)(__ccgo_up(bp)) = Tflock{ Fl_type: int16(F_WRLCK), Fl_whence: int16(1), Fl_len: size, } switch op { case int32(F_TEST): - (*(*Tflock)(unsafe.Pointer(bp))).Fl_type = F_RDLCK + (**(**Tflock)(__ccgo_up(bp))).Fl_type = F_RDLCK if Xfcntl(tls, fd, int32(F_GETLK), VaList(bp+40, bp)) < 0 { return -int32(1) } - if int32((*(*Tflock)(unsafe.Pointer(bp))).Fl_type) == int32(F_UNLCK) || (*(*Tflock)(unsafe.Pointer(bp))).Fl_pid == Xgetpid(tls) { + if int32((**(**Tflock)(__ccgo_up(bp))).Fl_type) == int32(F_UNLCK) || (**(**Tflock)(__ccgo_up(bp))).Fl_pid == Xgetpid(tls) { return 0 } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EACCES) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EACCES) return -int32(1) case F_ULOCK: - (*(*Tflock)(unsafe.Pointer(bp))).Fl_type = int16(F_UNLCK) + (**(**Tflock)(__ccgo_up(bp))).Fl_type = int16(F_UNLCK) fallthrough case int32(F_TLOCK): return Xfcntl(tls, fd, int32(F_SETLK), VaList(bp+40, bp)) case int32(F_LOCK): return Xfcntl(tls, fd, int32(F_SETLKW), VaList(bp+40, bp)) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } @@ -115778,23 +115778,23 @@ func _unescape_ent(tls *TLS, beg uintptr) (r uintptr) { _, _, _, _, _, _, _ = cval, dest, i, src, val, v1, v2 dest = beg src = beg - for *(*uint8)(unsafe.Pointer(src)) != 0 { + for **(**uint8)(__ccgo_up(src)) != 0 { cval = uint8(0) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) != int32('\\') { + if Int32FromUint8(**(**uint8)(__ccgo_up(src))) != int32('\\') { v1 = dest dest = dest + 1 v2 = src src = src + 1 - *(*uint8)(unsafe.Pointer(v1)) = *(*uint8)(unsafe.Pointer(v2)) + **(**uint8)(__ccgo_up(v1)) = **(**uint8)(__ccgo_up(v2)) continue } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 1))) == int32('\\') { + if Int32FromUint8(**(**uint8)(__ccgo_up(src + 1))) == int32('\\') { src = src + 1 v1 = dest dest = dest + 1 v2 = src src = src + 1 - *(*uint8)(unsafe.Pointer(v1)) = *(*uint8)(unsafe.Pointer(v2)) + **(**uint8)(__ccgo_up(v1)) = **(**uint8)(__ccgo_up(v2)) continue } val = src + uintptr(1) @@ -115803,11 +115803,11 @@ func _unescape_ent(tls *TLS, beg uintptr) (r uintptr) { if !(i < int32(3)) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(val))) >= int32('0') && Int32FromUint8(*(*uint8)(unsafe.Pointer(val))) <= int32('7') { + if Int32FromUint8(**(**uint8)(__ccgo_up(val))) >= int32('0') && Int32FromUint8(**(**uint8)(__ccgo_up(val))) <= int32('7') { cval = Uint8FromInt32(int32(cval) << Int32FromInt32(3)) v1 = val val = val + 1 - cval = Uint8FromInt32(int32(cval) + (Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) - Int32FromUint8('0'))) + cval = Uint8FromInt32(int32(cval) + (Int32FromUint8(**(**uint8)(__ccgo_up(v1))) - Int32FromUint8('0'))) } else { break } @@ -115819,17 +115819,17 @@ func _unescape_ent(tls *TLS, beg uintptr) (r uintptr) { if cval != 0 { v1 = dest dest = dest + 1 - *(*uint8)(unsafe.Pointer(v1)) = cval + **(**uint8)(__ccgo_up(v1)) = cval src = val } else { v1 = dest dest = dest + 1 v2 = src src = src + 1 - *(*uint8)(unsafe.Pointer(v1)) = *(*uint8)(unsafe.Pointer(v2)) + **(**uint8)(__ccgo_up(v1)) = **(**uint8)(__ccgo_up(v2)) } } - *(*uint8)(unsafe.Pointer(dest)) = uint8(0) + **(**uint8)(__ccgo_up(dest)) = uint8(0) return beg } @@ -115847,7 +115847,7 @@ func Xgetmntent_r(tls *TLS, f uintptr, mnt uintptr, linebuf uintptr, buflen int3 use_internal = BoolInt32(linebuf == uintptr(unsafe.Pointer(&_internal_buf))) (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_freq = 0 (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_passno = 0 - for cond := true; cond; cond = Int32FromUint8(*(*uint8)(unsafe.Pointer(linebuf + uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[0])))) == int32('#') || Uint32FromInt32((*(*[8]int32)(unsafe.Pointer(bp)))[int32(1)]) == len1 { + for cond := true; cond; cond = Int32FromUint8(**(**uint8)(__ccgo_up(linebuf + uintptr((**(**[8]int32)(__ccgo_up(bp)))[0])))) == int32('#') || Uint32FromInt32((**(**[8]int32)(__ccgo_up(bp)))[int32(1)]) == len1 { if use_internal != 0 { Xgetline(tls, uintptr(unsafe.Pointer(&_internal_buf)), uintptr(unsafe.Pointer(&_internal_bufsize)), f) linebuf = _internal_buf @@ -115859,7 +115859,7 @@ func Xgetmntent_r(tls *TLS, f uintptr, mnt uintptr, linebuf uintptr, buflen int3 } if !(Xstrchr(tls, linebuf, int32('\n')) != 0) { Xfscanf(tls, f, __ccgo_ts+728, 0) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return uintptr(0) } len1 = _strlen(tls, linebuf) @@ -115871,7 +115871,7 @@ func Xgetmntent_r(tls *TLS, f uintptr, mnt uintptr, linebuf uintptr, buflen int3 if !(i < Uint32FromInt64(32)/Uint32FromInt64(4)) { break } - (*(*[8]int32)(unsafe.Pointer(bp)))[i] = Int32FromUint32(len1) + (**(**[8]int32)(__ccgo_up(bp)))[i] = Int32FromUint32(len1) goto _1 _1: ; @@ -115879,14 +115879,14 @@ func Xgetmntent_r(tls *TLS, f uintptr, mnt uintptr, linebuf uintptr, buflen int3 } Xsscanf(tls, linebuf, __ccgo_ts+740, VaList(bp+40, bp, bp+uintptr(1)*4, bp+uintptr(2)*4, bp+uintptr(3)*4, bp+uintptr(4)*4, bp+uintptr(5)*4, bp+uintptr(6)*4, bp+uintptr(7)*4, mnt+16, mnt+20)) } - *(*uint8)(unsafe.Pointer(linebuf + uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(1)]))) = uint8(0) - *(*uint8)(unsafe.Pointer(linebuf + uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(3)]))) = uint8(0) - *(*uint8)(unsafe.Pointer(linebuf + uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(5)]))) = uint8(0) - *(*uint8)(unsafe.Pointer(linebuf + uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(7)]))) = uint8(0) - (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_fsname = _unescape_ent(tls, linebuf+uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[0])) - (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_dir = _unescape_ent(tls, linebuf+uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(2)])) - (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_type = _unescape_ent(tls, linebuf+uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(4)])) - (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_opts = _unescape_ent(tls, linebuf+uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(6)])) + **(**uint8)(__ccgo_up(linebuf + uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(1)]))) = uint8(0) + **(**uint8)(__ccgo_up(linebuf + uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(3)]))) = uint8(0) + **(**uint8)(__ccgo_up(linebuf + uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(5)]))) = uint8(0) + **(**uint8)(__ccgo_up(linebuf + uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(7)]))) = uint8(0) + (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_fsname = _unescape_ent(tls, linebuf+uintptr((**(**[8]int32)(__ccgo_up(bp)))[0])) + (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_dir = _unescape_ent(tls, linebuf+uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(2)])) + (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_type = _unescape_ent(tls, linebuf+uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(4)])) + (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_opts = _unescape_ent(tls, linebuf+uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(6)])) return mnt } @@ -115945,39 +115945,39 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag var _ /* st at bp+0 */ Tstat _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, de, dfd, err, j, k, l, r, type1, v1, v10, v2, v3, v8 l = _strlen(tls, path) - if l != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(path + uintptr(l-uint32(1))))) == int32('/') { + if l != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(path + uintptr(l-uint32(1))))) == int32('/') { v1 = l - uint32(1) } else { v1 = l } j = v1 v2 = Uint64FromInt32(0) - (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino = v2 - (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev = v2 + (**(**Tstat)(__ccgo_up(bp))).Fst_ino = v2 + (**(**Tstat)(__ccgo_up(bp))).Fst_dev = v2 if flags&int32(FTW_PHYS) != 0 { v3 = Xlstat(tls, path, bp) } else { v3 = BoolInt32(Xstat(tls, path, bp) < 0) } if v3 != 0 { - if !(flags&Int32FromInt32(FTW_PHYS) != 0) && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENOENT) && !(Xlstat(tls, path, bp) != 0) { + if !(flags&Int32FromInt32(FTW_PHYS) != 0) && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENOENT) && !(Xlstat(tls, path, bp) != 0) { type1 = int32(FTW_SLN) } else { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(EACCES) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(EACCES) { return -int32(1) } else { type1 = int32(FTW_NS) } } } else { - if (*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFDIR) { + if (**(**Tstat)(__ccgo_up(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFDIR) { if flags&int32(FTW_DEPTH) != 0 { type1 = int32(FTW_DP) } else { type1 = int32(FTW_D) } } else { - if (*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { + if (**(**Tstat)(__ccgo_up(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { if flags&int32(FTW_PHYS) != 0 { type1 = int32(FTW_SL) } else { @@ -115988,26 +115988,26 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag } } } - if flags&int32(FTW_MOUNT) != 0 && h != 0 && type1 != int32(FTW_NS) && (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev != (*Thistory)(unsafe.Pointer(h)).Fdev { + if flags&int32(FTW_MOUNT) != 0 && h != 0 && type1 != int32(FTW_NS) && (**(**Tstat)(__ccgo_up(bp))).Fst_dev != (*Thistory)(unsafe.Pointer(h)).Fdev { return 0 } - (*(*Thistory)(unsafe.Pointer(bp + 152))).Fchain = h - (*(*Thistory)(unsafe.Pointer(bp + 152))).Fdev = (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev - (*(*Thistory)(unsafe.Pointer(bp + 152))).Fino = (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino + (**(**Thistory)(__ccgo_up(bp + 152))).Fchain = h + (**(**Thistory)(__ccgo_up(bp + 152))).Fdev = (**(**Tstat)(__ccgo_up(bp))).Fst_dev + (**(**Thistory)(__ccgo_up(bp + 152))).Fino = (**(**Tstat)(__ccgo_up(bp))).Fst_ino if h != 0 { v3 = (*Thistory)(unsafe.Pointer(h)).Flevel + int32(1) } else { v3 = 0 } - (*(*Thistory)(unsafe.Pointer(bp + 152))).Flevel = v3 - (*(*Thistory)(unsafe.Pointer(bp + 152))).Fbase = Int32FromUint32(j + uint32(1)) - (*(*TFTW)(unsafe.Pointer(bp + 184))).Flevel = (*(*Thistory)(unsafe.Pointer(bp + 152))).Flevel + (**(**Thistory)(__ccgo_up(bp + 152))).Flevel = v3 + (**(**Thistory)(__ccgo_up(bp + 152))).Fbase = Int32FromUint32(j + uint32(1)) + (**(**TFTW)(__ccgo_up(bp + 184))).Flevel = (**(**Thistory)(__ccgo_up(bp + 152))).Flevel if h != 0 { - (*(*TFTW)(unsafe.Pointer(bp + 184))).Fbase = (*Thistory)(unsafe.Pointer(h)).Fbase + (**(**TFTW)(__ccgo_up(bp + 184))).Fbase = (*Thistory)(unsafe.Pointer(h)).Fbase } else { k = j for { - if !(k != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(path + uintptr(k)))) == int32('/')) { + if !(k != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(path + uintptr(k)))) == int32('/')) { break } goto _5 @@ -116016,7 +116016,7 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag k = k - 1 } for { - if !(k != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(path + uintptr(k-uint32(1))))) != int32('/')) { + if !(k != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(path + uintptr(k-uint32(1))))) != int32('/')) { break } goto _6 @@ -116024,11 +116024,11 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag ; k = k - 1 } - (*(*TFTW)(unsafe.Pointer(bp + 184))).Fbase = Int32FromUint32(k) + (**(**TFTW)(__ccgo_up(bp + 184))).Fbase = Int32FromUint32(k) } if type1 == int32(FTW_D) || type1 == int32(FTW_DP) { dfd = Xopen(tls, path, O_RDONLY, 0) - err = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + err = **(**int32)(__ccgo_up(X__errno_location(tls))) if dfd < 0 && err == int32(EACCES) { type1 = int32(FTW_DNR) } @@ -116047,7 +116047,7 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag if !(h != 0) { break } - if (*Thistory)(unsafe.Pointer(h)).Fdev == (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev && (*Thistory)(unsafe.Pointer(h)).Fino == (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino { + if (*Thistory)(unsafe.Pointer(h)).Fdev == (**(**Tstat)(__ccgo_up(bp))).Fst_dev && (*Thistory)(unsafe.Pointer(h)).Fino == (**(**Tstat)(__ccgo_up(bp))).Fst_ino { return 0 } goto _9 @@ -116057,7 +116057,7 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag } if (type1 == int32(FTW_D) || type1 == int32(FTW_DP)) && fd_limit != 0 { if dfd < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = err + **(**int32)(__ccgo_up(X__errno_location(tls))) = err return -int32(1) } d = Xfdopendir(tls, dfd) @@ -116068,15 +116068,15 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag if !(v10 != 0) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(de + 19))) == int32('.') && (!(*(*uint8)(unsafe.Pointer(de + 19 + 1)) != 0) || Int32FromUint8(*(*uint8)(unsafe.Pointer(de + 19 + 1))) == int32('.') && !(*(*uint8)(unsafe.Pointer(de + 19 + 2)) != 0)) { + if Int32FromUint8(**(**uint8)(__ccgo_up(de + 19))) == int32('.') && (!(**(**uint8)(__ccgo_up(de + 19 + 1)) != 0) || Int32FromUint8(**(**uint8)(__ccgo_up(de + 19 + 1))) == int32('.') && !(**(**uint8)(__ccgo_up(de + 19 + 2)) != 0)) { continue } if _strlen(tls, de+19) >= uint32(PATH_MAX)-l { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENAMETOOLONG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENAMETOOLONG) Xclosedir(tls, d) return -int32(1) } - *(*uint8)(unsafe.Pointer(path + uintptr(j))) = uint8('/') + **(**uint8)(__ccgo_up(path + uintptr(j))) = uint8('/') Xstrcpy(tls, path+uintptr(j)+uintptr(1), de+19) v3 = _do_nftw(tls, path, __ccgo_fp_fn, fd_limit-int32(1), flags, bp+152) r = v3 @@ -116091,7 +116091,7 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag return -int32(1) } } - *(*uint8)(unsafe.Pointer(path + uintptr(l))) = uint8(0) + **(**uint8)(__ccgo_up(path + uintptr(l))) = uint8(0) if v8 = flags&int32(FTW_DEPTH) != 0; v8 { v3 = (*(*func(*TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_fn})))(tls, path, bp, type1, bp+184) r = v3 @@ -116121,13 +116121,13 @@ func Xnftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flags i } l = _strlen(tls, path) if l > uint32(PATH_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENAMETOOLONG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENAMETOOLONG) return -int32(1) } _memcpy(tls, bp+4, path, l+uint32(1)) _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp) r = _do_nftw(tls, bp+4, __ccgo_fp_fn, fd_limit, flags, UintptrFromInt32(0)) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) return r } @@ -116145,7 +116145,7 @@ func Xopenpty(tls *TLS, pm uintptr, ps uintptr, name uintptr, tio uintptr, ws ui var _ /* cs at bp+4 */ int32 var _ /* n at bp+0 */ int32 _, _, _ = m, s, v1 - *(*int32)(unsafe.Pointer(bp)) = 0 + **(**int32)(__ccgo_up(bp)) = 0 m = Xopen(tls, __ccgo_ts+814, Int32FromInt32(O_RDWR)|Int32FromInt32(O_NOCTTY), 0) if m < 0 { return -int32(1) @@ -116157,7 +116157,7 @@ func Xopenpty(tls *TLS, pm uintptr, ps uintptr, name uintptr, tio uintptr, ws ui if !(name != 0) { name = bp + 8 } - Xsnprintf(tls, name, uint32(20), __ccgo_ts+824, VaList(bp+40, *(*int32)(unsafe.Pointer(bp)))) + Xsnprintf(tls, name, uint32(20), __ccgo_ts+824, VaList(bp+40, **(**int32)(__ccgo_up(bp)))) v1 = Xopen(tls, name, Int32FromInt32(O_RDWR)|Int32FromInt32(O_NOCTTY), 0) s = v1 if v1 < 0 { @@ -116169,15 +116169,15 @@ func Xopenpty(tls *TLS, pm uintptr, ps uintptr, name uintptr, tio uintptr, ws ui if ws != 0 { Xioctl(tls, s, int32(TIOCSWINSZ), VaList(bp+40, ws)) } - *(*int32)(unsafe.Pointer(pm)) = m - *(*int32)(unsafe.Pointer(ps)) = s - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 4)), uintptr(0)) + **(**int32)(__ccgo_up(pm)) = m + **(**int32)(__ccgo_up(ps)) = s + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 4)), uintptr(0)) return 0 goto fail fail: ; Xclose(tls, m) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 4)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 4)), uintptr(0)) return -int32(1) } @@ -116190,7 +116190,7 @@ func Xptsname(tls *TLS, fd int32) (r uintptr) { _ = err err = X__ptsname_r(tls, fd, uintptr(unsafe.Pointer(&_buf2)), uint32(22)) if err != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = err + **(**int32)(__ccgo_up(X__errno_location(tls))) = err return uintptr(0) } return uintptr(unsafe.Pointer(&_buf2)) @@ -116206,8 +116206,8 @@ func Xposix_openpt(tls *TLS, flags int32) (r1 int32) { var r int32 _ = r r = Xopen(tls, __ccgo_ts+814, flags, 0) - if r < 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENOSPC) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EAGAIN) + if r < 0 && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENOSPC) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EAGAIN) } return r } @@ -116228,7 +116228,7 @@ func Xunlockpt(tls *TLS, fd int32) (r int32) { bp := tls.Alloc(32) defer tls.Free(32) var _ /* unlock at bp+0 */ int32 - *(*int32)(unsafe.Pointer(bp)) = 0 + **(**int32)(__ccgo_up(bp)) = 0 return Xioctl(tls, fd, int32(TIOCSPTLCK), VaList(bp+16, bp)) } @@ -116250,7 +116250,7 @@ func X__ptsname_r(tls *TLS, fd int32, buf uintptr, len1 Tsize_t) (r int32) { if v1 != 0 { return -err } - if Uint32FromInt32(Xsnprintf(tls, buf, len1, __ccgo_ts+824, VaList(bp+16, *(*int32)(unsafe.Pointer(bp))))) >= len1 { + if Uint32FromInt32(Xsnprintf(tls, buf, len1, __ccgo_ts+824, VaList(bp+16, **(**int32)(__ccgo_up(bp))))) >= len1 { return int32(ERANGE) } return 0 @@ -116268,7 +116268,7 @@ func _slash_len(tls *TLS, s uintptr) (r Tsize_t) { var s0 uintptr _ = s0 s0 = s - for Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('/') { + for Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('/') { s = s + 1 } return Uint32FromInt32(int32(s) - int32(s0)) @@ -116292,12 +116292,12 @@ func Xrealpath(tls *TLS, filename uintptr, resolved uintptr) (r uintptr) { nup = uint32(0) check_dir = 0 if !(filename != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } l = Xstrnlen(tls, filename, uint32(4097)) if !(l != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOENT) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOENT) return uintptr(0) } if l >= uint32(PATH_MAX) { @@ -116317,19 +116317,19 @@ _3: ; /* If stack starts with /, the whole component is / or // * and the output state must be reset. */ - if Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p]) == int32('/') { + if Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[p]) == int32('/') { check_dir = 0 nup = uint32(0) q = uint32(0) v4 = q q = q + 1 - (*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[v4] = uint8('/') + (**(**[4096]uint8)(__ccgo_up(bp + 4097)))[v4] = uint8('/') p = p + 1 /* Initial // is special. */ - if Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p]) == int32('/') && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p+uint32(1)]) != int32('/') { + if Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[p]) == int32('/') && Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[p+uint32(1)]) != int32('/') { v4 = q q = q + 1 - (*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[v4] = uint8('/') + (**(**[4096]uint8)(__ccgo_up(bp + 4097)))[v4] = uint8('/') } goto _2 } @@ -116341,30 +116341,30 @@ _3: goto _1 } /* Skip any . component but preserve check_dir status. */ - if l == uint32(1) && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p]) == int32('.') { + if l == uint32(1) && Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[p]) == int32('.') { p = p + l goto _2 } /* Copy next component onto output at least temporarily, to * call readlink, but wait to advance output position until * determining it's not a link. */ - if q != 0 && Int32FromUint8((*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[q-uint32(1)]) != int32('/') { + if q != 0 && Int32FromUint8((**(**[4096]uint8)(__ccgo_up(bp + 4097)))[q-uint32(1)]) != int32('/') { if !(p != 0) { goto toolong } p = p - 1 v4 = p - (*(*[4097]uint8)(unsafe.Pointer(bp)))[v4] = uint8('/') + (**(**[4097]uint8)(__ccgo_up(bp)))[v4] = uint8('/') l = l + 1 } if q+l >= uint32(PATH_MAX) { goto toolong } _memcpy(tls, bp+4097+uintptr(q), bp+uintptr(p), l) - (*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[q+l] = uint8(0) + (**(**[4096]uint8)(__ccgo_up(bp + 4097)))[q+l] = uint8(0) p = p + l up = 0 - if l0 == uint32(2) && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p-uint32(2)]) == int32('.') && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p-uint32(1)]) == int32('.') { + if l0 == uint32(2) && Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[p-uint32(2)]) == int32('.') && Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[p-uint32(1)]) == int32('.') { up = int32(1) /* Any non-.. path components we could cancel start * after nup repetitions of the 3-byte string "../"; @@ -116386,13 +116386,13 @@ _3: goto toolong } if !(k != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOENT) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOENT) return uintptr(0) } if !(k < 0) { goto _8 } - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(EINVAL) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(EINVAL) { return uintptr(0) } goto skip_readlink @@ -116400,10 +116400,10 @@ skip_readlink: ; check_dir = 0 if up != 0 { - for q != 0 && Int32FromUint8((*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[q-uint32(1)]) != int32('/') { + for q != 0 && Int32FromUint8((**(**[4096]uint8)(__ccgo_up(bp + 4097)))[q-uint32(1)]) != int32('/') { q = q - 1 } - if q > uint32(1) && (q > uint32(2) || Int32FromUint8((*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[0]) != int32('/')) { + if q > uint32(1) && (q > uint32(2) || Int32FromUint8((**(**[4096]uint8)(__ccgo_up(bp + 4097)))[0]) != int32('/')) { q = q - 1 } goto _2 @@ -116411,20 +116411,20 @@ skip_readlink: if l0 != 0 { q = q + l } - check_dir = Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p]) + check_dir = Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[p]) goto _2 _8: ; cnt = cnt + 1 v4 = cnt if v4 == uint32(SYMLOOP_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ELOOP) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ELOOP) return uintptr(0) } /* If link contents end in /, strip any slashes already on * stack to avoid /->// or //->/// or spurious toolong. */ - if Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[k-int32(1)]) == int32('/') { - for Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p]) == int32('/') { + if Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[k-int32(1)]) == int32('/') { + for Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[p]) == int32('/') { p = p + 1 } } @@ -116441,8 +116441,8 @@ _2: goto _1 _1: ; - (*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[q] = uint8(0) - if Int32FromUint8((*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[0]) != int32('/') { + (**(**[4096]uint8)(__ccgo_up(bp + 4097)))[q] = uint8(0) + if Int32FromUint8((**(**[4096]uint8)(__ccgo_up(bp + 4097)))[0]) != int32('/') { if !(Xgetcwd(tls, bp, uint32(4097)) != 0) { return uintptr(0) } @@ -116455,7 +116455,7 @@ _1: if !(v4 != 0) { break } - for l > uint32(1) && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[l-uint32(1)]) != int32('/') { + for l > uint32(1) && Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[l-uint32(1)]) != int32('/') { l = l - 1 } if l > uint32(1) { @@ -116466,10 +116466,10 @@ _1: p = p + 1 } } - if q-p != 0 && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[l-uint32(1)]) != int32('/') { + if q-p != 0 && Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[l-uint32(1)]) != int32('/') { v4 = l l = l + 1 - (*(*[4097]uint8)(unsafe.Pointer(bp)))[v4] = uint8('/') + (**(**[4097]uint8)(__ccgo_up(bp)))[v4] = uint8('/') } if l+(q-p)+uint32(1) >= uint32(PATH_MAX) { goto toolong @@ -116486,7 +116486,7 @@ _1: goto toolong toolong: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENAMETOOLONG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENAMETOOLONG) return uintptr(0) } @@ -116535,12 +116535,12 @@ func Xsetrlimit(tls *TLS, resource int32, rlim uintptr) (r int32) { var _ /* tmp at bp+0 */ Trlimit _, _, _ = ret, v1, v2 if ^Uint64FromUint64(0) != ^Uint64FromUint64(0) { - *(*Trlimit)(unsafe.Pointer(bp)) = *(*Trlimit)(unsafe.Pointer(rlim)) - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur >= ^Uint64FromUint64(0) { - (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur = ^Uint64FromUint64(0) + **(**Trlimit)(__ccgo_up(bp)) = **(**Trlimit)(__ccgo_up(rlim)) + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur >= ^Uint64FromUint64(0) { + (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur = ^Uint64FromUint64(0) } - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_max >= ^Uint64FromUint64(0) { - (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_max = ^Uint64FromUint64(0) + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_max >= ^Uint64FromUint64(0) { + (**(**Trlimit)(__ccgo_up(bp))).Frlim_max = ^Uint64FromUint64(0) } rlim = bp } @@ -116558,7 +116558,7 @@ func Xsetrlimit(tls *TLS, resource int32, rlim uintptr) (r int32) { } else { v2 = uint64(-Uint32FromUint32(1)) } - *(*Tctx)(unsafe.Pointer(bp + 16)) = Tctx{ + **(**Tctx)(__ccgo_up(bp + 16)) = Tctx{ Flim: [2]uint32{ 0: uint32(v1), 1: uint32(v2), @@ -116567,9 +116567,9 @@ func Xsetrlimit(tls *TLS, resource int32, rlim uintptr) (r int32) { Ferr: -int32(1), } ___synccall(tls, __ccgo_fp(_do_setrlimit), bp+16) - if (*(*Tctx)(unsafe.Pointer(bp + 16))).Ferr != 0 { - if (*(*Tctx)(unsafe.Pointer(bp + 16))).Ferr > 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = (*(*Tctx)(unsafe.Pointer(bp + 16))).Ferr + if (**(**Tctx)(__ccgo_up(bp + 16))).Ferr != 0 { + if (**(**Tctx)(__ccgo_up(bp + 16))).Ferr > 0 { + **(**int32)(__ccgo_up(X__errno_location(tls))) = (**(**Tctx)(__ccgo_up(bp + 16))).Ferr } return -int32(1) } @@ -116946,7 +116946,7 @@ func Xcloselog(tls *TLS) { Xclose(tls, _log_fd) _log_fd = -int32(1) ___unlock(tls, uintptr(unsafe.Pointer(&_lock2))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) } func ___openlog(tls *TLS) { @@ -116980,7 +116980,7 @@ func Xopenlog(tls *TLS, ident uintptr, opt int32, facility int32) { ___openlog(tls) } ___unlock(tls, uintptr(unsafe.Pointer(&_lock2))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) } func _is_lost_conn(tls *TLS, e int32) (r int32) { @@ -116997,14 +116997,14 @@ func __vsyslog(tls *TLS, priority int32, message uintptr, ap Tva_list) { var _ /* timebuf at bp+0 */ [16]uint8 var _ /* tm at bp+24 */ Ttm _, _, _, _, _, _ = errno_save, fd, l, l2, pid, v1 - errno_save = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + errno_save = **(**int32)(__ccgo_up(X__errno_location(tls))) if _log_fd < 0 { ___openlog(tls) } if !(priority&Int32FromInt32(LOG_FACMASK) != 0) { priority = priority | _log_facility } - *(*Ttime_t)(unsafe.Pointer(bp + 16)) = Xtime(tls, UintptrFromInt32(0)) + **(**Ttime_t)(__ccgo_up(bp + 16)) = Xtime(tls, UintptrFromInt32(0)) Xgmtime_r(tls, bp+16, bp+24) Xstrftime_l(tls, bp, uint32(16), __ccgo_ts+836, bp+24, uintptr(unsafe.Pointer(&X__c_locale))) if _log_opt&int32(LOG_PID) != 0 { @@ -117014,7 +117014,7 @@ func __vsyslog(tls *TLS, priority int32, message uintptr, ap Tva_list) { } pid = v1 l = Xsnprintf(tls, bp+68, uint32(1024), __ccgo_ts+845, VaList(bp+1104, priority, bp, bp+1092, uintptr(unsafe.Pointer(&_log_ident)), __ccgo_ts+867+BoolUintptr(!(pid != 0)), pid, __ccgo_ts+869+BoolUintptr(!(pid != 0)))) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = errno_save + **(**int32)(__ccgo_up(X__errno_location(tls))) = errno_save l2 = Xvsnprintf(tls, bp+68+uintptr(l), uint32(1024)-Uint32FromInt32(l), message, ap) if l2 >= 0 { if Uint32FromInt32(l2) >= uint32(1024)-Uint32FromInt32(l) { @@ -117022,20 +117022,20 @@ func __vsyslog(tls *TLS, priority int32, message uintptr, ap Tva_list) { } else { l = l + l2 } - if Int32FromUint8((*(*[1024]uint8)(unsafe.Pointer(bp + 68)))[l-int32(1)]) != int32('\n') { + if Int32FromUint8((**(**[1024]uint8)(__ccgo_up(bp + 68)))[l-int32(1)]) != int32('\n') { v1 = l l = l + 1 - (*(*[1024]uint8)(unsafe.Pointer(bp + 68)))[v1] = uint8('\n') + (**(**[1024]uint8)(__ccgo_up(bp + 68)))[v1] = uint8('\n') } - if Xsend(tls, _log_fd, bp+68, Uint32FromInt32(l), 0) < 0 && (!(_is_lost_conn(tls, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) != 0) || Xconnect(tls, _log_fd, uintptr(unsafe.Pointer(&_log_addr)), uint32(12)) < 0 || Xsend(tls, _log_fd, bp+68, Uint32FromInt32(l), 0) < 0) && _log_opt&int32(LOG_CONS) != 0 { + if Xsend(tls, _log_fd, bp+68, Uint32FromInt32(l), 0) < 0 && (!(_is_lost_conn(tls, **(**int32)(__ccgo_up(X__errno_location(tls)))) != 0) || Xconnect(tls, _log_fd, uintptr(unsafe.Pointer(&_log_addr)), uint32(12)) < 0 || Xsend(tls, _log_fd, bp+68, Uint32FromInt32(l), 0) < 0) && _log_opt&int32(LOG_CONS) != 0 { fd = Xopen(tls, __ccgo_ts+564, Int32FromInt32(O_WRONLY)|Int32FromInt32(O_NOCTTY)|Int32FromInt32(O_CLOEXEC), 0) if fd >= 0 { - Xdprintf(tls, fd, __ccgo_ts+871, VaList(bp+1104, l-*(*int32)(unsafe.Pointer(bp + 1092)), bp+68+uintptr(*(*int32)(unsafe.Pointer(bp + 1092))))) + Xdprintf(tls, fd, __ccgo_ts+871, VaList(bp+1104, l-**(**int32)(__ccgo_up(bp + 1092)), bp+68+uintptr(**(**int32)(__ccgo_up(bp + 1092))))) Xclose(tls, fd) } } if _log_opt&int32(LOG_PERROR) != 0 { - Xdprintf(tls, int32(2), __ccgo_ts+871, VaList(bp+1104, l-*(*int32)(unsafe.Pointer(bp + 1092)), bp+68+uintptr(*(*int32)(unsafe.Pointer(bp + 1092))))) + Xdprintf(tls, int32(2), __ccgo_ts+871, VaList(bp+1104, l-**(**int32)(__ccgo_up(bp + 1092)), bp+68+uintptr(**(**int32)(__ccgo_up(bp + 1092))))) } } } @@ -117051,7 +117051,7 @@ func ___vsyslog(tls *TLS, priority int32, message uintptr, ap Tva_list) { ___lock(tls, uintptr(unsafe.Pointer(&_lock2))) __vsyslog(tls, priority, message, ap) ___unlock(tls, uintptr(unsafe.Pointer(&_lock2))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) } func Xsyslog(tls *TLS, priority int32, message uintptr, va uintptr) { @@ -117136,11 +117136,11 @@ func X__mmap(tls *TLS, start uintptr, len1 Tsize_t, prot int32, flags int32, fd var ret int32 _ = ret if Uint64FromInt64(off)&(-Uint64FromUint64(0x2000)<<(Uint32FromInt32(8)*Uint32FromInt64(4)-Uint32FromInt32(1))|(Uint64FromUint64(4096)-Uint64FromInt32(1))) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(-Int32FromInt32(1)) } if len1 >= Uint32FromInt32(Int32FromInt32(INT32_MAX)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return uintptr(-Int32FromInt32(1)) } if flags&int32(MAP_FIXED) != 0 { @@ -117195,7 +117195,7 @@ func X__mremap(tls *TLS, old_addr uintptr, old_len Tsize_t, new_len Tsize_t, fla _, _ = ap, new_addr new_addr = uintptr(0) if new_len >= Uint32FromInt32(Int32FromInt32(INT32_MAX)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return uintptr(-Int32FromInt32(1)) } if flags&int32(MREMAP_FIXED) != 0 { @@ -117277,17 +117277,17 @@ func X__shm_mapname(tls *TLS, name uintptr, buf uintptr) (r uintptr) { } var p, v1 uintptr _, _ = p, v1 - for Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) == int32('/') { + for Int32FromUint8(**(**uint8)(__ccgo_up(name))) == int32('/') { name = name + 1 } v1 = X__strchrnul(tls, name, int32('/')) p = v1 - if *(*uint8)(unsafe.Pointer(v1)) != 0 || p == name || int32(p)-int32(name) <= int32(2) && Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) == int32('.') && Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) == int32('.') { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if **(**uint8)(__ccgo_up(v1)) != 0 || p == name || int32(p)-int32(name) <= int32(2) && Int32FromUint8(**(**uint8)(__ccgo_up(name))) == int32('.') && Int32FromUint8(**(**uint8)(__ccgo_up(p + uintptr(-Int32FromInt32(1))))) == int32('.') { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } if int32(p)-int32(name) > int32(NAME_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENAMETOOLONG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENAMETOOLONG) return uintptr(0) } _memcpy(tls, buf, __ccgo_ts+876, uint32(9)) @@ -117314,7 +117314,7 @@ func Xshm_open(tls *TLS, name uintptr, flag int32, mode Tmode_t) (r int32) { } _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp) fd = Xopen(tls, name, flag|int32(O_NOFOLLOW)|int32(O_CLOEXEC)|int32(O_NONBLOCK), VaList(bp+280, mode)) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) return fd } @@ -117352,7 +117352,7 @@ func Xbtowc(tls *TLS, c int32) (r Twint_t) { if Uint32FromInt32(b) < uint32(128) { v1 = Uint32FromInt32(b) } else { - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v3 = int32(4) } else { v3 = int32(1) @@ -117384,22 +117384,22 @@ func Xc16rtomb(tls *TLS, s uintptr, c16 Tchar16_t, ps uintptr) (r Tsize_t) { } x = ps if !(s != 0) { - if *(*uint32)(unsafe.Pointer(x)) != 0 { + if **(**uint32)(__ccgo_up(x)) != 0 { goto ilseq } return uint32(1) } - if !(*(*uint32)(unsafe.Pointer(x)) != 0) && uint32(c16)-uint32(0xd800) < uint32(0x400) { - *(*uint32)(unsafe.Pointer(x)) = Uint32FromInt32((Int32FromUint16(c16) - int32(0xd7c0)) << int32(10)) + if !(**(**uint32)(__ccgo_up(x)) != 0) && uint32(c16)-uint32(0xd800) < uint32(0x400) { + **(**uint32)(__ccgo_up(x)) = Uint32FromInt32((Int32FromUint16(c16) - int32(0xd7c0)) << int32(10)) return uint32(0) } - if *(*uint32)(unsafe.Pointer(x)) != 0 { + if **(**uint32)(__ccgo_up(x)) != 0 { if uint32(c16)-uint32(0xdc00) >= uint32(0x400) { goto ilseq } else { - wc = *(*uint32)(unsafe.Pointer(x)) + uint32(c16) - uint32(0xdc00) + wc = **(**uint32)(__ccgo_up(x)) + uint32(c16) - uint32(0xdc00) } - *(*uint32)(unsafe.Pointer(x)) = uint32(0) + **(**uint32)(__ccgo_up(x)) = uint32(0) } else { wc = uint32(c16) } @@ -117407,8 +117407,8 @@ func Xc16rtomb(tls *TLS, s uintptr, c16 Tchar16_t, ps uintptr) (r Tsize_t) { goto ilseq ilseq: ; - *(*uint32)(unsafe.Pointer(x)) = uint32(0) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EILSEQ) + **(**uint32)(__ccgo_up(x)) = uint32(0) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EILSEQ) return Uint32FromInt32(-Int32FromInt32(1)) } @@ -117467,21 +117467,21 @@ func Xmbrtoc16(tls *TLS, pc16 uintptr, s uintptr, n Tsize_t, ps uintptr) (r Tsiz } /* mbrtowc states for partial UTF-8 characters have the high bit set; * we use nonzero states without high bit for pending surrogates. */ - if Int32FromUint32(*(*uint32)(unsafe.Pointer(pending))) > 0 { + if Int32FromUint32(**(**uint32)(__ccgo_up(pending))) > 0 { if pc16 != 0 { - *(*Tchar16_t)(unsafe.Pointer(pc16)) = uint16(*(*uint32)(unsafe.Pointer(pending))) + **(**Tchar16_t)(__ccgo_up(pc16)) = uint16(**(**uint32)(__ccgo_up(pending))) } - *(*uint32)(unsafe.Pointer(pending)) = uint32(0) + **(**uint32)(__ccgo_up(pending)) = uint32(0) return Uint32FromInt32(-Int32FromInt32(3)) } ret = Xmbrtowc(tls, bp, s, n, ps) if ret <= uint32(4) { - if *(*Twchar_t)(unsafe.Pointer(bp)) >= uint32(0x10000) { - *(*uint32)(unsafe.Pointer(pending)) = *(*Twchar_t)(unsafe.Pointer(bp))&uint32(0x3ff) + uint32(0xdc00) - *(*Twchar_t)(unsafe.Pointer(bp)) = uint32(0xd7c0) + *(*Twchar_t)(unsafe.Pointer(bp))>>Int32FromInt32(10) + if **(**Twchar_t)(__ccgo_up(bp)) >= uint32(0x10000) { + **(**uint32)(__ccgo_up(pending)) = **(**Twchar_t)(__ccgo_up(bp))&uint32(0x3ff) + uint32(0xdc00) + **(**Twchar_t)(__ccgo_up(bp)) = uint32(0xd7c0) + **(**Twchar_t)(__ccgo_up(bp))>>Int32FromInt32(10) } if pc16 != 0 { - *(*Tchar16_t)(unsafe.Pointer(pc16)) = uint16(*(*Twchar_t)(unsafe.Pointer(bp))) + **(**Tchar16_t)(__ccgo_up(pc16)) = uint16(**(**Twchar_t)(__ccgo_up(bp))) } } return ret @@ -117507,7 +117507,7 @@ func Xmbrtoc32(tls *TLS, pc32 uintptr, s uintptr, n Tsize_t, ps uintptr) (r Tsiz } ret = Xmbrtowc(tls, bp, s, n, ps) if ret <= uint32(4) && pc32 != 0 { - *(*Tchar32_t)(unsafe.Pointer(pc32)) = *(*Twchar_t)(unsafe.Pointer(bp)) + **(**Tchar32_t)(__ccgo_up(pc32)) = **(**Twchar_t)(__ccgo_up(bp)) } return ret } @@ -117533,7 +117533,7 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize if !(st != 0) { st = uintptr(unsafe.Pointer(&_internal_state3)) } - c = *(*uint32)(unsafe.Pointer(st)) + c = **(**uint32)(__ccgo_up(st)) if !(s != 0) { if c != 0 { goto ilseq @@ -117548,30 +117548,30 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize return Uint32FromInt32(-Int32FromInt32(2)) } if !(c != 0) { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) < int32(0x80) { - v1 = uint32(*(*uint8)(unsafe.Pointer(s))) - *(*Twchar_t)(unsafe.Pointer(wc)) = v1 + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) < int32(0x80) { + v1 = uint32(**(**uint8)(__ccgo_up(s))) + **(**Twchar_t)(__ccgo_up(wc)) = v1 return BoolUint32(!!(v1 != 0)) } - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v2 = int32(4) } else { v2 = int32(1) } if v2 == int32(1) { - *(*Twchar_t)(unsafe.Pointer(wc)) = Uint32FromInt32(Int32FromInt32(0xdfff) & int32(Int8FromUint8(*(*uint8)(unsafe.Pointer(s))))) + **(**Twchar_t)(__ccgo_up(wc)) = Uint32FromInt32(Int32FromInt32(0xdfff) & int32(Int8FromUint8(**(**uint8)(__ccgo_up(s))))) return Uint32FromInt32(1) } - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { goto ilseq } v3 = s s = s + 1 - c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v3)))-uint32(0xc2)] + c = X__fsmu8[uint32(**(**uint8)(__ccgo_up(v3)))-uint32(0xc2)] n = n - 1 } if n != 0 { - if (Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { + if (Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { goto ilseq } goto loop @@ -117579,27 +117579,27 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize ; v3 = s s = s + 1 - c = c<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { goto ilseq } goto loop } } - *(*uint32)(unsafe.Pointer(st)) = c + **(**uint32)(__ccgo_up(st)) = c return Uint32FromInt32(-Int32FromInt32(2)) goto ilseq ilseq: ; - *(*uint32)(unsafe.Pointer(st)) = uint32(0) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EILSEQ) + **(**uint32)(__ccgo_up(st)) = uint32(0) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EILSEQ) return Uint32FromInt32(-Int32FromInt32(1)) } @@ -117610,7 +117610,7 @@ func Xmbsinit(tls *TLS, st uintptr) (r int32) { trc("tls=%v st=%v, (%v:)", tls, st, origin(2)) defer func() { trc("-> %v", r) }() } - return BoolInt32(!(st != 0) || !(*(*uint32)(unsafe.Pointer(st)) != 0)) + return BoolInt32(!(st != 0) || !(**(**uint32)(__ccgo_up(st)) != 0)) } func Xmbsnrtowcs(tls *TLS, wcs uintptr, src uintptr, n Tsize_t, wn Tsize_t, st uintptr) (r Tsize_t) { @@ -117628,7 +117628,7 @@ func Xmbsnrtowcs(tls *TLS, wcs uintptr, src uintptr, n Tsize_t, wn Tsize_t, st u var _ /* wbuf at bp+0 */ [256]Twchar_t _, _, _, _, _, _, _, _ = cnt, l, n2, tmp_s, ws, v1, v2, v3 cnt = uint32(0) - *(*uintptr)(unsafe.Pointer(bp + 1024)) = *(*uintptr)(unsafe.Pointer(src)) + **(**uintptr)(__ccgo_up(bp + 1024)) = **(**uintptr)(__ccgo_up(src)) if !(wcs != 0) { ws = bp wn = Uint32FromInt64(1024) / Uint32FromInt64(4) @@ -117639,7 +117639,7 @@ func Xmbsnrtowcs(tls *TLS, wcs uintptr, src uintptr, n Tsize_t, wn Tsize_t, st u * that mbsrtowcs never reads more than n input bytes. thus * we can use mbsrtowcs as long as it's practical.. */ for { - if v2 = *(*uintptr)(unsafe.Pointer(bp + 1024)) != 0 && wn != 0; v2 { + if v2 = **(**uintptr)(__ccgo_up(bp + 1024)) != 0 && wn != 0; v2 { v1 = n / Uint32FromInt32(4) n2 = v1 } @@ -117649,7 +117649,7 @@ func Xmbsnrtowcs(tls *TLS, wcs uintptr, src uintptr, n Tsize_t, wn Tsize_t, st u if n2 >= wn { n2 = wn } - tmp_s = *(*uintptr)(unsafe.Pointer(bp + 1024)) + tmp_s = **(**uintptr)(__ccgo_up(bp + 1024)) l = Xmbsrtowcs(tls, ws, bp+1024, n2, st) if !(l+Uint32FromInt32(1) != 0) { cnt = l @@ -117660,31 +117660,31 @@ func Xmbsnrtowcs(tls *TLS, wcs uintptr, src uintptr, n Tsize_t, wn Tsize_t, st u ws = ws + uintptr(l)*4 wn = wn - l } - if *(*uintptr)(unsafe.Pointer(bp + 1024)) != 0 { - v3 = n - Uint32FromInt32(int32(*(*uintptr)(unsafe.Pointer(bp + 1024)))-int32(tmp_s)) + if **(**uintptr)(__ccgo_up(bp + 1024)) != 0 { + v3 = n - Uint32FromInt32(int32(**(**uintptr)(__ccgo_up(bp + 1024)))-int32(tmp_s)) } else { v3 = uint32(0) } n = v3 cnt = cnt + l } - if *(*uintptr)(unsafe.Pointer(bp + 1024)) != 0 { + if **(**uintptr)(__ccgo_up(bp + 1024)) != 0 { for wn != 0 && n != 0 { - l = Xmbrtowc(tls, ws, *(*uintptr)(unsafe.Pointer(bp + 1024)), n, st) + l = Xmbrtowc(tls, ws, **(**uintptr)(__ccgo_up(bp + 1024)), n, st) if l+uint32(2) <= uint32(2) { if !(l+Uint32FromInt32(1) != 0) { cnt = l break } if !(l != 0) { - *(*uintptr)(unsafe.Pointer(bp + 1024)) = uintptr(0) + **(**uintptr)(__ccgo_up(bp + 1024)) = uintptr(0) break } /* have to roll back partial character */ - *(*uint32)(unsafe.Pointer(st)) = uint32(0) + **(**uint32)(__ccgo_up(st)) = uint32(0) break } - *(*uintptr)(unsafe.Pointer(bp + 1024)) = *(*uintptr)(unsafe.Pointer(bp + 1024)) + uintptr(l) + **(**uintptr)(__ccgo_up(bp + 1024)) = **(**uintptr)(__ccgo_up(bp + 1024)) + uintptr(l) n = n - l /* safe - this loop runs fewer than sizeof(wbuf)/8 times */ ws += 4 @@ -117693,7 +117693,7 @@ func Xmbsnrtowcs(tls *TLS, wcs uintptr, src uintptr, n Tsize_t, wn Tsize_t, st u } } if wcs != 0 { - *(*uintptr)(unsafe.Pointer(src)) = *(*uintptr)(unsafe.Pointer(bp + 1024)) + **(**uintptr)(__ccgo_up(src)) = **(**uintptr)(__ccgo_up(bp + 1024)) } return cnt } @@ -117709,22 +117709,22 @@ func Xmbsrtowcs(tls *TLS, ws uintptr, src uintptr, wn Tsize_t, st uintptr) (r Ts var v2 bool var v3 int32 _, _, _, _, _, _, _, _ = c, s, wn0, v1, v2, v3, v5, v6 - s = *(*uintptr)(unsafe.Pointer(src)) + s = **(**uintptr)(__ccgo_up(src)) wn0 = wn c = uint32(0) if v2 = st != 0; v2 { - v1 = *(*uint32)(unsafe.Pointer(st)) + v1 = **(**uint32)(__ccgo_up(st)) c = v1 } if v2 && v1 != 0 { if ws != 0 { - *(*uint32)(unsafe.Pointer(st)) = uint32(0) + **(**uint32)(__ccgo_up(st)) = uint32(0) goto resume } else { goto resume0 } } - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v3 = int32(4) } else { v3 = int32(1) @@ -117735,24 +117735,24 @@ func Xmbsrtowcs(tls *TLS, ws uintptr, src uintptr, wn Tsize_t, st uintptr) (r Ts } for { if !(wn != 0) { - *(*uintptr)(unsafe.Pointer(src)) = s + **(**uintptr)(__ccgo_up(src)) = s return wn0 } - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { break } v5 = s s = s + 1 - c = uint32(*(*uint8)(unsafe.Pointer(v5))) + c = uint32(**(**uint8)(__ccgo_up(v5))) v5 = ws ws += 4 - *(*Twchar_t)(unsafe.Pointer(v5)) = Uint32FromInt32(Int32FromInt32(0xdfff) & int32(Int8FromUint32(c))) + **(**Twchar_t)(__ccgo_up(v5)) = Uint32FromInt32(Int32FromInt32(0xdfff) & int32(Int8FromUint32(c))) wn = wn - 1 goto _4 _4: } - *(*Twchar_t)(unsafe.Pointer(ws)) = uint32(0) - *(*uintptr)(unsafe.Pointer(src)) = uintptr(0) + **(**Twchar_t)(__ccgo_up(ws)) = uint32(0) + **(**uintptr)(__ccgo_up(src)) = uintptr(0) return wn0 - wn } if !!(ws != 0) { @@ -117760,39 +117760,39 @@ func Xmbsrtowcs(tls *TLS, ws uintptr, src uintptr, wn Tsize_t, st uintptr) (r Ts } _11: ; - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) && uint32(s)%uint32(4) == uint32(0) { - for !((*(*uint32)(unsafe.Pointer(s))|(*(*uint32)(unsafe.Pointer(s))-Uint32FromInt32(0x01010101)))&Uint32FromUint32(0x80808080) != 0) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(1) < uint32(0x7f) && uint32(s)%uint32(4) == uint32(0) { + for !((**(**uint32)(__ccgo_up(s))|(**(**uint32)(__ccgo_up(s))-Uint32FromInt32(0x01010101)))&Uint32FromUint32(0x80808080) != 0) { s = s + uintptr(4) wn = wn - uint32(4) } } - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(1) < uint32(0x7f) { s = s + 1 wn = wn - 1 goto _10 } - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { goto _9 } v5 = s s = s + 1 - c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v5)))-uint32(0xc2)] + c = X__fsmu8[uint32(**(**uint8)(__ccgo_up(v5)))-uint32(0xc2)] goto resume0 resume0: ; - if (Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { + if (Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { s = s - 1 goto _9 } s = s + 1 if c&(Uint32FromUint32(1)<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { s = s - uintptr(2) goto _9 } s = s + 1 if c&(Uint32FromUint32(1)<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { s = s - uintptr(3) goto _9 } @@ -117814,80 +117814,80 @@ _7: _15: ; if !(wn != 0) { - *(*uintptr)(unsafe.Pointer(src)) = s + **(**uintptr)(__ccgo_up(src)) = s return wn0 } - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) && uint32(s)%uint32(4) == uint32(0) { - for wn >= uint32(5) && !((*(*uint32)(unsafe.Pointer(s))|(*(*uint32)(unsafe.Pointer(s))-Uint32FromInt32(0x01010101)))&Uint32FromUint32(0x80808080) != 0) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(1) < uint32(0x7f) && uint32(s)%uint32(4) == uint32(0) { + for wn >= uint32(5) && !((**(**uint32)(__ccgo_up(s))|(**(**uint32)(__ccgo_up(s))-Uint32FromInt32(0x01010101)))&Uint32FromUint32(0x80808080) != 0) { v5 = ws ws += 4 v6 = s s = s + 1 - *(*Twchar_t)(unsafe.Pointer(v5)) = uint32(*(*uint8)(unsafe.Pointer(v6))) + **(**Twchar_t)(__ccgo_up(v5)) = uint32(**(**uint8)(__ccgo_up(v6))) v5 = ws ws += 4 v6 = s s = s + 1 - *(*Twchar_t)(unsafe.Pointer(v5)) = uint32(*(*uint8)(unsafe.Pointer(v6))) + **(**Twchar_t)(__ccgo_up(v5)) = uint32(**(**uint8)(__ccgo_up(v6))) v5 = ws ws += 4 v6 = s s = s + 1 - *(*Twchar_t)(unsafe.Pointer(v5)) = uint32(*(*uint8)(unsafe.Pointer(v6))) + **(**Twchar_t)(__ccgo_up(v5)) = uint32(**(**uint8)(__ccgo_up(v6))) v5 = ws ws += 4 v6 = s s = s + 1 - *(*Twchar_t)(unsafe.Pointer(v5)) = uint32(*(*uint8)(unsafe.Pointer(v6))) + **(**Twchar_t)(__ccgo_up(v5)) = uint32(**(**uint8)(__ccgo_up(v6))) wn = wn - uint32(4) } } - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(1) < uint32(0x7f) { v5 = ws ws += 4 v6 = s s = s + 1 - *(*Twchar_t)(unsafe.Pointer(v5)) = uint32(*(*uint8)(unsafe.Pointer(v6))) + **(**Twchar_t)(__ccgo_up(v5)) = uint32(**(**uint8)(__ccgo_up(v6))) wn = wn - 1 goto _14 } - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { goto _13 } v5 = s s = s + 1 - c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v5)))-uint32(0xc2)] + c = X__fsmu8[uint32(**(**uint8)(__ccgo_up(v5)))-uint32(0xc2)] goto resume resume: ; - if (Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { + if (Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { s = s - 1 goto _13 } v5 = s s = s + 1 - c = c<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { s = s - uintptr(2) goto _13 } v5 = s s = s + 1 - c = c<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { s = s - uintptr(3) goto _13 } v5 = s s = s + 1 - c = c< Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { goto ilseq } v3 = s s = s + 1 - c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v3)))-uint32(0xc2)] + c = X__fsmu8[uint32(**(**uint8)(__ccgo_up(v3)))-uint32(0xc2)] /* Avoid excessive checks against n: If shifting the state n-1 * times does not clear the high bit, then the value of n is * insufficient to read a character */ if n < uint32(4) && c<<(uint32(6)*n-uint32(6))&(Uint32FromUint32(1)<>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { + if (Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { goto ilseq } v3 = s s = s + 1 - c = c<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { goto ilseq } v3 = s s = s + 1 - c = c<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { goto ilseq } v3 = s s = s + 1 - *(*Twchar_t)(unsafe.Pointer(wc)) = c<>Int32FromInt32(6)) - *(*uint8)(unsafe.Pointer(s)) = uint8(uint32(0x80) | wc&uint32(0x3f)) + **(**uint8)(__ccgo_up(v2)) = uint8(uint32(0xc0) | wc>>Int32FromInt32(6)) + **(**uint8)(__ccgo_up(s)) = uint8(uint32(0x80) | wc&uint32(0x3f)) return uint32(2) } else { if wc < uint32(0xd800) || wc-uint32(0xe000) < uint32(0x2000) { v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8(uint32(0xe0) | wc>>Int32FromInt32(12)) + **(**uint8)(__ccgo_up(v2)) = uint8(uint32(0xe0) | wc>>Int32FromInt32(12)) v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8(uint32(0x80) | wc>>Int32FromInt32(6)&uint32(0x3f)) - *(*uint8)(unsafe.Pointer(s)) = uint8(uint32(0x80) | wc&uint32(0x3f)) + **(**uint8)(__ccgo_up(v2)) = uint8(uint32(0x80) | wc>>Int32FromInt32(6)&uint32(0x3f)) + **(**uint8)(__ccgo_up(s)) = uint8(uint32(0x80) | wc&uint32(0x3f)) return uint32(3) } else { if wc-uint32(0x10000) < uint32(0x100000) { v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8(uint32(0xf0) | wc>>Int32FromInt32(18)) + **(**uint8)(__ccgo_up(v2)) = uint8(uint32(0xf0) | wc>>Int32FromInt32(18)) v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8(uint32(0x80) | wc>>Int32FromInt32(12)&uint32(0x3f)) + **(**uint8)(__ccgo_up(v2)) = uint8(uint32(0x80) | wc>>Int32FromInt32(12)&uint32(0x3f)) v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8(uint32(0x80) | wc>>Int32FromInt32(6)&uint32(0x3f)) - *(*uint8)(unsafe.Pointer(s)) = uint8(uint32(0x80) | wc&uint32(0x3f)) + **(**uint8)(__ccgo_up(v2)) = uint8(uint32(0x80) | wc>>Int32FromInt32(6)&uint32(0x3f)) + **(**uint8)(__ccgo_up(s)) = uint8(uint32(0x80) | wc&uint32(0x3f)) return uint32(4) } } } } } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EILSEQ) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EILSEQ) return Uint32FromInt32(-Int32FromInt32(1)) } @@ -118084,7 +118084,7 @@ func Xwcsnrtombs(tls *TLS, dst uintptr, wcs uintptr, wn Tsize_t, n Tsize_t, st u var ws, v1 uintptr var _ /* tmp at bp+0 */ [4]uint8 _, _, _, _ = cnt, l, ws, v1 - ws = *(*uintptr)(unsafe.Pointer(wcs)) + ws = **(**uintptr)(__ccgo_up(wcs)) cnt = uint32(0) if !(dst != 0) { n = uint32(0) @@ -118095,7 +118095,7 @@ func Xwcsnrtombs(tls *TLS, dst uintptr, wcs uintptr, wn Tsize_t, n Tsize_t, st u } else { v1 = dst } - l = Xwcrtomb(tls, v1, *(*Twchar_t)(unsafe.Pointer(ws)), uintptr(0)) + l = Xwcrtomb(tls, v1, **(**Twchar_t)(__ccgo_up(ws)), uintptr(0)) if l == Uint32FromInt32(-Int32FromInt32(1)) { cnt = Uint32FromInt32(-Int32FromInt32(1)) break @@ -118110,7 +118110,7 @@ func Xwcsnrtombs(tls *TLS, dst uintptr, wcs uintptr, wn Tsize_t, n Tsize_t, st u dst = dst + uintptr(l) n = n - l } - if !(*(*Twchar_t)(unsafe.Pointer(ws)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(ws)) != 0) { ws = uintptr(0) break } @@ -118119,7 +118119,7 @@ func Xwcsnrtombs(tls *TLS, dst uintptr, wcs uintptr, wn Tsize_t, n Tsize_t, st u cnt = cnt + l } if dst != 0 { - *(*uintptr)(unsafe.Pointer(wcs)) = ws + **(**uintptr)(__ccgo_up(wcs)) = ws } return cnt } @@ -118138,13 +118138,13 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize N = n if !(s != 0) { n = uint32(0) - ws2 = *(*uintptr)(unsafe.Pointer(ws)) + ws2 = **(**uintptr)(__ccgo_up(ws)) for { - if !(*(*Twchar_t)(unsafe.Pointer(ws2)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(ws2)) != 0) { break } - if *(*Twchar_t)(unsafe.Pointer(ws2)) >= uint32(0x80) { - l = Xwcrtomb(tls, bp, *(*Twchar_t)(unsafe.Pointer(ws2)), uintptr(0)) + if **(**Twchar_t)(__ccgo_up(ws2)) >= uint32(0x80) { + l = Xwcrtomb(tls, bp, **(**Twchar_t)(__ccgo_up(ws2)), uintptr(0)) if !(l+Uint32FromInt32(1) != 0) { return Uint32FromInt32(-Int32FromInt32(1)) } @@ -118160,13 +118160,13 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize return n } for n >= uint32(4) { - if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))-uint32(1) >= uint32(0x7f) { - if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))) != 0) { - *(*uint8)(unsafe.Pointer(s)) = uint8(0) - *(*uintptr)(unsafe.Pointer(ws)) = uintptr(0) + if **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws))))-uint32(1) >= uint32(0x7f) { + if !(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))) != 0) { + **(**uint8)(__ccgo_up(s)) = uint8(0) + **(**uintptr)(__ccgo_up(ws)) = uintptr(0) return N - n } - l = Xwcrtomb(tls, s, *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))), uintptr(0)) + l = Xwcrtomb(tls, s, **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))), uintptr(0)) if !(l+Uint32FromInt32(1) != 0) { return Uint32FromInt32(-Int32FromInt32(1)) } @@ -118175,35 +118175,35 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize } else { v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) + **(**uint8)(__ccgo_up(v2)) = uint8(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws))))) n = n - 1 } - *(*uintptr)(unsafe.Pointer(ws)) += 4 + **(**uintptr)(__ccgo_up(ws)) += 4 } for n != 0 { - if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))-uint32(1) >= uint32(0x7f) { - if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))) != 0) { - *(*uint8)(unsafe.Pointer(s)) = uint8(0) - *(*uintptr)(unsafe.Pointer(ws)) = uintptr(0) + if **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws))))-uint32(1) >= uint32(0x7f) { + if !(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))) != 0) { + **(**uint8)(__ccgo_up(s)) = uint8(0) + **(**uintptr)(__ccgo_up(ws)) = uintptr(0) return N - n } - l = Xwcrtomb(tls, bp, *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))), uintptr(0)) + l = Xwcrtomb(tls, bp, **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))), uintptr(0)) if !(l+Uint32FromInt32(1) != 0) { return Uint32FromInt32(-Int32FromInt32(1)) } if l > n { return N - n } - Xwcrtomb(tls, s, *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))), uintptr(0)) + Xwcrtomb(tls, s, **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))), uintptr(0)) s = s + uintptr(l) n = n - l } else { v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) + **(**uint8)(__ccgo_up(v2)) = uint8(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws))))) n = n - 1 } - *(*uintptr)(unsafe.Pointer(ws)) += 4 + **(**uintptr)(__ccgo_up(ws)) += 4 } return N } @@ -118229,7 +118229,7 @@ func Xwctob(tls *TLS, c Twint_t) (r int32) { if c < uint32(128) { return Int32FromUint32(c) } - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v1 = int32(4) } else { v1 = int32(1) @@ -118325,11 +118325,11 @@ func Xaccept4(tls *TLS, fd int32, addr uintptr, len1 uintptr, flg int32) (r1 int goto _9 _9: ret = X__syscall_ret(tls, Uint32FromInt32(v8)) - if ret >= 0 || *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(ENOSYS) && *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(EINVAL) { + if ret >= 0 || **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(ENOSYS) && **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(EINVAL) { return ret } if flg & ^(Int32FromInt32(SOCK_CLOEXEC)|Int32FromInt32(SOCK_NONBLOCK)) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } ret = Xaccept(tls, fd, addr, len1) @@ -119299,13 +119299,13 @@ func _getoffs(tls *TLS, offs uintptr, base uintptr, s uintptr) (r int32) { _, _ = i, v2 i = 0 for { - for Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))&int32(0xc0) != 0 { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))&int32(0xc0) != int32(0xc0) { + for Int32FromUint8(**(**uint8)(__ccgo_up(s)))&int32(0xc0) != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(s)))&int32(0xc0) != int32(0xc0) { return 0 } - s = base + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))&Int32FromInt32(0x3f)<= int32(0x4000) { @@ -119313,8 +119313,8 @@ func _getoffs(tls *TLS, offs uintptr, base uintptr, s uintptr) (r int32) { } v2 = i i = i + 1 - *(*int16)(unsafe.Pointer(offs + uintptr(v2)*2)) = int16(int32(s) - int32(base)) - s = s + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))+int32(1)) + **(**int16)(__ccgo_up(offs + uintptr(v2)*2)) = int16(int32(s) - int32(base)) + s = s + uintptr(Int32FromUint8(**(**uint8)(__ccgo_up(s)))+int32(1)) goto _1 _1: } @@ -119332,7 +119332,7 @@ func _getlens(tls *TLS, lens uintptr, s uintptr, l int32) (r int32) { k = 0 for { for { - if !(j < l && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(j)))) != int32('.')) { + if !(j < l && Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(j)))) != int32('.')) { break } goto _2 @@ -119345,7 +119345,7 @@ func _getlens(tls *TLS, lens uintptr, s uintptr, l int32) (r int32) { } v3 = i i = i + 1 - *(*uint8)(unsafe.Pointer(lens + uintptr(v3))) = Uint8FromInt32(j - k) + **(**uint8)(__ccgo_up(lens + uintptr(v3))) = Uint8FromInt32(j - k) if j == l { return i } @@ -119375,15 +119375,15 @@ func _match(tls *TLS, offset uintptr, base uintptr, dn uintptr, end uintptr, len for { nlen = nlen - 1 v2 = nlen - l = Int32FromUint8(*(*uint8)(unsafe.Pointer(lens + uintptr(v2)))) + l = Int32FromUint8(**(**uint8)(__ccgo_up(lens + uintptr(v2)))) noff = noff - 1 v2 = noff - o = int32((*(*[128]int16)(unsafe.Pointer(bp)))[v2]) + o = int32((**(**[128]int16)(__ccgo_up(bp)))[v2]) end = end - uintptr(l) - if l != Int32FromUint8(*(*uint8)(unsafe.Pointer(base + uintptr(o)))) || Xmemcmp(tls, base+uintptr(o)+uintptr(1), end, Uint32FromInt32(l)) != 0 { + if l != Int32FromUint8(**(**uint8)(__ccgo_up(base + uintptr(o)))) || Xmemcmp(tls, base+uintptr(o)+uintptr(1), end, Uint32FromInt32(l)) != 0 { return m } - *(*int32)(unsafe.Pointer(offset)) = o + **(**int32)(__ccgo_up(offset)) = o m = m + l if nlen != 0 { m = m + 1 @@ -119414,14 +119414,14 @@ func Xdn_comp(tls *TLS, src uintptr, dst uintptr, space int32, dnptrs uintptr, l m = 0 bestlen = 0 l = Xstrnlen(tls, src, uint32(255)) - if l != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(src + uintptr(l-uint32(1))))) == int32('.') { + if l != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(src + uintptr(l-uint32(1))))) == int32('.') { l = l - 1 } if l > uint32(253) || space <= 0 { return -int32(1) } if !(l != 0) { - *(*uint8)(unsafe.Pointer(dst)) = uint8(0) + **(**uint8)(__ccgo_up(dst)) = uint8(0) return int32(1) } end = src + uintptr(l) @@ -119430,16 +119430,16 @@ func Xdn_comp(tls *TLS, src uintptr, dst uintptr, space int32, dnptrs uintptr, l return -int32(1) } p = dnptrs - if p != 0 && *(*uintptr)(unsafe.Pointer(p)) != 0 { + if p != 0 && **(**uintptr)(__ccgo_up(p)) != 0 { p += 4 for { - if !(*(*uintptr)(unsafe.Pointer(p)) != 0) { + if !(**(**uintptr)(__ccgo_up(p)) != 0) { break } - m = _match(tls, bp, *(*uintptr)(unsafe.Pointer(dnptrs)), *(*uintptr)(unsafe.Pointer(p)), end, bp+4, n) + m = _match(tls, bp, **(**uintptr)(__ccgo_up(dnptrs)), **(**uintptr)(__ccgo_up(p)), end, bp+4, n) if m > bestlen { bestlen = m - bestoff = *(*int32)(unsafe.Pointer(bp)) + bestoff = **(**int32)(__ccgo_up(bp)) if Uint32FromInt32(m) == l { break } @@ -119462,37 +119462,37 @@ func Xdn_comp(tls *TLS, src uintptr, dst uintptr, space int32, dnptrs uintptr, l if !(Uint32FromInt32(i) < l-Uint32FromInt32(bestlen)) { break } - *(*uint8)(unsafe.Pointer(dst + uintptr(i))) = (*(*[127]uint8)(unsafe.Pointer(bp + 4)))[j] + **(**uint8)(__ccgo_up(dst + uintptr(i))) = (**(**[127]uint8)(__ccgo_up(bp + 4)))[j] goto _2 _2: ; v3 = j j = j + 1 - i = i + (Int32FromUint8((*(*[127]uint8)(unsafe.Pointer(bp + 4)))[v3]) + int32(1)) + i = i + (Int32FromUint8((**(**[127]uint8)(__ccgo_up(bp + 4)))[v3]) + int32(1)) } /* add tail */ if bestlen != 0 { v3 = i i = i + 1 - *(*uint8)(unsafe.Pointer(dst + uintptr(v3))) = Uint8FromInt32(int32(0xc0) | bestoff>>int32(8)) + **(**uint8)(__ccgo_up(dst + uintptr(v3))) = Uint8FromInt32(int32(0xc0) | bestoff>>int32(8)) v3 = i i = i + 1 - *(*uint8)(unsafe.Pointer(dst + uintptr(v3))) = Uint8FromInt32(bestoff) + **(**uint8)(__ccgo_up(dst + uintptr(v3))) = Uint8FromInt32(bestoff) } else { v3 = i i = i + 1 - *(*uint8)(unsafe.Pointer(dst + uintptr(v3))) = uint8(0) + **(**uint8)(__ccgo_up(dst + uintptr(v3))) = uint8(0) } /* save dst pointer */ - if i > int32(2) && lastdnptr != 0 && dnptrs != 0 && *(*uintptr)(unsafe.Pointer(dnptrs)) != 0 { - for *(*uintptr)(unsafe.Pointer(p)) != 0 { + if i > int32(2) && lastdnptr != 0 && dnptrs != 0 && **(**uintptr)(__ccgo_up(dnptrs)) != 0 { + for **(**uintptr)(__ccgo_up(p)) != 0 { p += 4 } if p+uintptr(1)*4 < lastdnptr { v8 = p p += 4 - *(*uintptr)(unsafe.Pointer(v8)) = dst - *(*uintptr)(unsafe.Pointer(p)) = uintptr(0) + **(**uintptr)(__ccgo_up(v8)) = dst + **(**uintptr)(__ccgo_up(p)) = uintptr(0) } } return i @@ -119525,11 +119525,11 @@ func X__dn_expand(tls *TLS, base uintptr, end uintptr, src uintptr, dest uintptr break } /* loop invariants: p= int32(end)-int32(p) || j >= int32(dend)-int32(dest) { return -int32(1) } @@ -119560,10 +119560,10 @@ func X__dn_expand(tls *TLS, base uintptr, end uintptr, src uintptr, dest uintptr dest = dest + 1 v4 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v3)) = *(*uint8)(unsafe.Pointer(v4)) + **(**uint8)(__ccgo_up(v3)) = uint8(**(**uint8)(__ccgo_up(v4))) } } else { - *(*uint8)(unsafe.Pointer(dest)) = uint8(0) + **(**uint8)(__ccgo_up(dest)) = uint8(0) if len1 < 0 { len1 = int32(p+uintptr(1)) - int32(src) } @@ -119595,20 +119595,20 @@ func Xdn_skipname(tls *TLS, s uintptr, end uintptr) (r int32) { _ = p p = s for p < end { - if !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if !(**(**uint8)(__ccgo_up(p)) != 0) { return int32(p) - int32(s) + int32(1) } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) >= int32(192) { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) >= int32(192) { if p+uintptr(1) < end { return int32(p) - int32(s) + int32(2) } else { break } } else { - if int32(end)-int32(p) < Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))+int32(1) { + if int32(end)-int32(p) < Int32FromUint8(**(**uint8)(__ccgo_up(p)))+int32(1) { break } else { - p = p + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))+int32(1)) + p = p + uintptr(Int32FromUint8(**(**uint8)(__ccgo_up(p)))+int32(1)) } } } @@ -119724,25 +119724,25 @@ func X__dns_parse(tls *TLS, r uintptr, rlen int32, __ccgo_fp_callback uintptr, c if rlen < int32(12) { return -int32(1) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 3)))&int32(15) != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(r + 3)))&int32(15) != 0 { return 0 } p = r + uintptr(12) - qdcount = Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 4)))*int32(256) + Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 5))) - ancount = Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 6)))*int32(256) + Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 7))) + qdcount = Int32FromUint8(**(**uint8)(__ccgo_up(r + 4)))*int32(256) + Int32FromUint8(**(**uint8)(__ccgo_up(r + 5))) + ancount = Int32FromUint8(**(**uint8)(__ccgo_up(r + 6)))*int32(256) + Int32FromUint8(**(**uint8)(__ccgo_up(r + 7))) for { v1 = qdcount qdcount = qdcount - 1 if !(v1 != 0) { break } - for int32(p)-int32(r) < rlen && uint32(*(*uint8)(unsafe.Pointer(p)))-uint32(1) < uint32(127) { + for int32(p)-int32(r) < rlen && uint32(**(**uint8)(__ccgo_up(p)))-uint32(1) < uint32(127) { p = p + 1 } if p > r+uintptr(rlen)-uintptr(6) { return -int32(1) } - p = p + uintptr(int32(5)+BoolInt32(!!(*(*uint8)(unsafe.Pointer(p)) != 0))) + p = p + uintptr(int32(5)+BoolInt32(!!(**(**uint8)(__ccgo_up(p)) != 0))) } for { v1 = ancount @@ -119750,18 +119750,18 @@ func X__dns_parse(tls *TLS, r uintptr, rlen int32, __ccgo_fp_callback uintptr, c if !(v1 != 0) { break } - for int32(p)-int32(r) < rlen && uint32(*(*uint8)(unsafe.Pointer(p)))-uint32(1) < uint32(127) { + for int32(p)-int32(r) < rlen && uint32(**(**uint8)(__ccgo_up(p)))-uint32(1) < uint32(127) { p = p + 1 } if p > r+uintptr(rlen)-uintptr(12) { return -int32(1) } - p = p + uintptr(int32(1)+BoolInt32(!!(*(*uint8)(unsafe.Pointer(p)) != 0))) - len1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 8)))*int32(256) + Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 9))) + p = p + uintptr(int32(1)+BoolInt32(!!(**(**uint8)(__ccgo_up(p)) != 0))) + len1 = Int32FromUint8(**(**uint8)(__ccgo_up(p + 8)))*int32(256) + Int32FromUint8(**(**uint8)(__ccgo_up(p + 9))) if len1+int32(10) > int32(r+uintptr(rlen))-int32(p) { return -int32(1) } - if (*(*func(*TLS, uintptr, int32, uintptr, int32, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_callback})))(tls, ctx, Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))), p+uintptr(10), len1, r, rlen) < 0 { + if (*(*func(*TLS, uintptr, int32, uintptr, int32, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_callback})))(tls, ctx, Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))), p+uintptr(10), len1, r, rlen) < 0 { return -int32(1) } p = p + uintptr(int32(10)+len1) @@ -120103,27 +120103,27 @@ func Xether_aton_r(tls *TLS, x uintptr, p_a uintptr) (r uintptr) { break } if ii != 0 { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(x))) != int32(':') { + if Int32FromUint8(**(**uint8)(__ccgo_up(x))) != int32(':') { return uintptr(0) } else { x = x + 1 } } n = Xstrtoul(tls, x, bp+8, int32(16)) - x = *(*uintptr)(unsafe.Pointer(bp + 8)) + x = **(**uintptr)(__ccgo_up(bp + 8)) if n > uint32(0xFF) { return uintptr(0) } /* bad byte */ - *(*Tuint8_t)(unsafe.Pointer(bp + uintptr(ii))) = uint8(n) + **(**Tuint8_t)(__ccgo_up(bp + uintptr(ii))) = uint8(n) goto _1 _1: ; ii = ii + 1 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(x))) != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(x))) != 0 { return uintptr(0) } /* bad format */ - *(*Tether_addr)(unsafe.Pointer(p_a)) = *(*Tether_addr)(unsafe.Pointer(bp)) + **(**Tether_addr)(__ccgo_up(p_a)) = **(**Tether_addr)(__ccgo_up(bp)) return p_a } @@ -120158,7 +120158,7 @@ func Xether_ntoa_r(tls *TLS, p_a uintptr, x uintptr) (r uintptr) { } else { v2 = __ccgo_ts + 891 } - x = x + uintptr(Xsprintf(tls, x, v2, VaList(bp+8, Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(p_a + uintptr(ii))))))) + x = x + uintptr(Xsprintf(tls, x, v2, VaList(bp+8, Int32FromUint8(**(**Tuint8_t)(__ccgo_up(p_a + uintptr(ii))))))) goto _1 _1: ; @@ -120243,11 +120243,11 @@ func Xgai_strerror(tls *TLS, ecode int32) (r uintptr) { s = uintptr(unsafe.Pointer(&_msgs)) ecode = ecode + 1 for { - if !(ecode != 0 && *(*uint8)(unsafe.Pointer(s)) != 0) { + if !(ecode != 0 && **(**uint8)(__ccgo_up(s)) != 0) { break } for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { break } goto _2 @@ -120261,7 +120261,7 @@ func Xgai_strerror(tls *TLS, ecode int32) (r uintptr) { ecode = ecode + 1 s = s + 1 } - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { s = s + 1 } return X__lctrans_cur(tls, s) @@ -120337,15 +120337,15 @@ func Xgetaddrinfo(tls *TLS, host uintptr, serv uintptr, hint uintptr, res uintpt if s >= 0 { _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp+1608) r = Xconnect(tls, s, ta[i], tl[i]) - saved_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 1608)), uintptr(0)) + saved_errno = **(**int32)(__ccgo_up(X__errno_location(tls))) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 1608)), uintptr(0)) Xclose(tls, s) if !(r != 0) { goto _1 } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = saved_errno + **(**int32)(__ccgo_up(X__errno_location(tls))) = saved_errno } - switch *(*int32)(unsafe.Pointer(X__errno_location(tls))) { + switch **(**int32)(__ccgo_up(X__errno_location(tls))) { case int32(EADDRNOTAVAIL): fallthrough case int32(EAFNOSUPPORT): @@ -120403,32 +120403,32 @@ func Xgetaddrinfo(tls *TLS, host uintptr, serv uintptr, hint uintptr, res uintpt if !(j < nservs) { break } - (*(*Taibuf)(unsafe.Pointer(out + uintptr(k)*68))).Fslot = int16(k) - if (*(*[48]Taddress)(unsafe.Pointer(bp + 8)))[i].Ffamily == int32(PF_INET) { + (**(**Taibuf)(__ccgo_up(out + uintptr(k)*68))).Fslot = int16(k) + if (**(**[48]Taddress)(__ccgo_up(bp + 8)))[i].Ffamily == int32(PF_INET) { v5 = uint32(16) } else { v5 = uint32(28) } - (*(*Taibuf)(unsafe.Pointer(out + uintptr(k)*68))).Fai = Taddrinfo{ - Fai_family: (*(*[48]Taddress)(unsafe.Pointer(bp + 8)))[i].Ffamily, - Fai_socktype: Int32FromUint8((*(*[2]Tservice)(unsafe.Pointer(bp)))[j].Fsocktype), - Fai_protocol: Int32FromUint8((*(*[2]Tservice)(unsafe.Pointer(bp)))[j].Fproto), + (**(**Taibuf)(__ccgo_up(out + uintptr(k)*68))).Fai = Taddrinfo{ + Fai_family: (**(**[48]Taddress)(__ccgo_up(bp + 8)))[i].Ffamily, + Fai_socktype: Int32FromUint8((**(**[2]Tservice)(__ccgo_up(bp)))[j].Fsocktype), + Fai_protocol: Int32FromUint8((**(**[2]Tservice)(__ccgo_up(bp)))[j].Fproto), Fai_addrlen: v5, Fai_addr: out + uintptr(k)*68 + 32, Fai_canonname: outcanon, } if k != 0 { - (*(*Taibuf)(unsafe.Pointer(out + uintptr(k-int32(1))*68))).Fai.Fai_next = out + uintptr(k)*68 + (**(**Taibuf)(__ccgo_up(out + uintptr(k-int32(1))*68))).Fai.Fai_next = out + uintptr(k)*68 } - switch (*(*[48]Taddress)(unsafe.Pointer(bp + 8)))[i].Ffamily { + switch (**(**[48]Taddress)(__ccgo_up(bp + 8)))[i].Ffamily { case int32(PF_INET): *(*Tsa_family_t)(unsafe.Pointer(out + uintptr(k)*68 + 32)) = uint16(PF_INET) - *(*Tin_port_t)(unsafe.Pointer(out + uintptr(k)*68 + 32 + 2)) = Xhtons(tls, (*(*[2]Tservice)(unsafe.Pointer(bp)))[j].Fport) + *(*Tin_port_t)(unsafe.Pointer(out + uintptr(k)*68 + 32 + 2)) = Xhtons(tls, (**(**[2]Tservice)(__ccgo_up(bp)))[j].Fport) _memcpy(tls, out+uintptr(k)*68+32+4, bp+8+uintptr(i)*28+8, uint32(4)) case int32(PF_INET6): *(*Tsa_family_t)(unsafe.Pointer(out + uintptr(k)*68 + 32)) = uint16(PF_INET6) - *(*Tin_port_t)(unsafe.Pointer(out + uintptr(k)*68 + 32 + 2)) = Xhtons(tls, (*(*[2]Tservice)(unsafe.Pointer(bp)))[j].Fport) - *(*Tuint32_t)(unsafe.Pointer(out + uintptr(k)*68 + 32 + 24)) = (*(*[48]Taddress)(unsafe.Pointer(bp + 8)))[i].Fscopeid + *(*Tin_port_t)(unsafe.Pointer(out + uintptr(k)*68 + 32 + 2)) = Xhtons(tls, (**(**[2]Tservice)(__ccgo_up(bp)))[j].Fport) + *(*Tuint32_t)(unsafe.Pointer(out + uintptr(k)*68 + 32 + 24)) = (**(**[48]Taddress)(__ccgo_up(bp + 8)))[i].Fscopeid _memcpy(tls, out+uintptr(k)*68+32+8, bp+8+uintptr(i)*28+8, uint32(16)) break } @@ -120443,8 +120443,8 @@ func Xgetaddrinfo(tls *TLS, host uintptr, serv uintptr, hint uintptr, res uintpt ; i = i + 1 } - (*(*Taibuf)(unsafe.Pointer(out))).Fref = int16(nais) - *(*uintptr)(unsafe.Pointer(res)) = out + (**(**Taibuf)(__ccgo_up(out))).Fref = int16(nais) + **(**uintptr)(__ccgo_up(res)) = out return 0 } @@ -120575,12 +120575,12 @@ func Xgethostbyaddr(tls *TLS, a uintptr, l Tsocklen_t, af int32) (r uintptr) { size = size + (size + uint32(1)) _h = Xmalloc(tls, size) if !(_h != 0) { - *(*int32)(unsafe.Pointer(X__h_errno_location(tls))) = int32(NO_RECOVERY) + **(**int32)(__ccgo_up(X__h_errno_location(tls))) = int32(NO_RECOVERY) return uintptr(0) } err = Xgethostbyaddr_r(tls, a, l, af, _h, _h+UintptrFromInt32(1)*20, size-uint32(20), bp, X__h_errno_location(tls)) } - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } var _h uintptr @@ -120617,7 +120617,7 @@ func Xgethostbyaddr_r(tls *TLS, a uintptr, l Tsocklen_t, af int32, h uintptr, bu v1 = uint32(16) } sl = v1 - *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) + **(**uintptr)(__ccgo_up(res)) = uintptr(0) /* Load address argument into sockaddr structure */ if af == int32(PF_INET6) && l == uint32(16) { _memcpy(tls, bp+8, a, uint32(16)) @@ -120625,7 +120625,7 @@ func Xgethostbyaddr_r(tls *TLS, a uintptr, l Tsocklen_t, af int32, h uintptr, bu if af == int32(PF_INET) && l == uint32(4) { _memcpy(tls, bp+4, a, uint32(4)) } else { - *(*int32)(unsafe.Pointer(err)) = int32(NO_RECOVERY) + **(**int32)(__ccgo_up(err)) = int32(NO_RECOVERY) return int32(EINVAL) } } @@ -120643,33 +120643,33 @@ func Xgethostbyaddr_r(tls *TLS, a uintptr, l Tsocklen_t, af int32, h uintptr, bu buf = buf + uintptr(Uint32FromInt32(2)*Uint32FromInt64(4)) (*Thostent)(unsafe.Pointer(h)).Fh_aliases = buf buf = buf + uintptr(Uint32FromInt32(2)*Uint32FromInt64(4)) - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list)) = buf - _memcpy(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list)), a, l) + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_addr_list)) = buf + _memcpy(tls, **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_addr_list)), a, l) buf = buf + uintptr(l) - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + 1*4)) = uintptr(0) - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) = buf - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*4)) = uintptr(0) + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + 1*4)) = uintptr(0) + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) = buf + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*4)) = uintptr(0) switch Xgetnameinfo(tls, bp, sl, buf, buflen, uintptr(0), uint32(0), 0) { case -int32(3): - *(*int32)(unsafe.Pointer(err)) = int32(TRY_AGAIN) + **(**int32)(__ccgo_up(err)) = int32(TRY_AGAIN) return int32(EAGAIN) case -int32(12): return int32(ERANGE) default: fallthrough case -int32(4): - *(*int32)(unsafe.Pointer(err)) = int32(NO_RECOVERY) + **(**int32)(__ccgo_up(err)) = int32(NO_RECOVERY) return int32(EBADMSG) case -int32(11): - *(*int32)(unsafe.Pointer(err)) = int32(NO_RECOVERY) - return *(*int32)(unsafe.Pointer(X__errno_location(tls))) + **(**int32)(__ccgo_up(err)) = int32(NO_RECOVERY) + return **(**int32)(__ccgo_up(X__errno_location(tls))) case 0: break } (*Thostent)(unsafe.Pointer(h)).Fh_addrtype = af (*Thostent)(unsafe.Pointer(h)).Fh_length = Int32FromUint32(l) - (*Thostent)(unsafe.Pointer(h)).Fh_name = *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) - *(*uintptr)(unsafe.Pointer(res)) = h + (*Thostent)(unsafe.Pointer(h)).Fh_name = **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) + **(**uintptr)(__ccgo_up(res)) = h return 0 } @@ -120698,12 +120698,12 @@ func Xgethostbyname2(tls *TLS, name uintptr, af int32) (r uintptr) { size = size + (size + uint32(1)) _h1 = Xmalloc(tls, size) if !(_h1 != 0) { - *(*int32)(unsafe.Pointer(X__h_errno_location(tls))) = int32(NO_RECOVERY) + **(**int32)(__ccgo_up(X__h_errno_location(tls))) = int32(NO_RECOVERY) return uintptr(0) } err = Xgethostbyname2_r(tls, name, af, _h1, _h1+UintptrFromInt32(1)*20, size-uint32(20), bp, X__h_errno_location(tls)) } - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } var _h1 uintptr @@ -120721,27 +120721,27 @@ func Xgethostbyname2_r(tls *TLS, name uintptr, af int32, h uintptr, buf uintptr, var _ /* addrs at bp+0 */ [48]Taddress var _ /* canon at bp+1344 */ [256]uint8 _, _, _, _, _, _ = align, cnt, i, need, v1, v3 - *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) + **(**uintptr)(__ccgo_up(res)) = uintptr(0) cnt = X__lookup_name(tls, bp, bp+1344, name, af, int32(AI_CANONNAME)) if cnt < 0 { switch cnt { case -int32(2): - *(*int32)(unsafe.Pointer(err)) = int32(HOST_NOT_FOUND) + **(**int32)(__ccgo_up(err)) = int32(HOST_NOT_FOUND) return 0 case -int32(5): - *(*int32)(unsafe.Pointer(err)) = int32(NO_DATA) + **(**int32)(__ccgo_up(err)) = int32(NO_DATA) return 0 case -int32(3): - *(*int32)(unsafe.Pointer(err)) = int32(TRY_AGAIN) + **(**int32)(__ccgo_up(err)) = int32(TRY_AGAIN) return int32(EAGAIN) default: fallthrough case -int32(4): - *(*int32)(unsafe.Pointer(err)) = int32(NO_RECOVERY) + **(**int32)(__ccgo_up(err)) = int32(NO_RECOVERY) return int32(EBADMSG) case -int32(11): - *(*int32)(unsafe.Pointer(err)) = int32(NO_RECOVERY) - return *(*int32)(unsafe.Pointer(X__errno_location(tls))) + **(**int32)(__ccgo_up(err)) = int32(NO_RECOVERY) + return **(**int32)(__ccgo_up(X__errno_location(tls))) } } (*Thostent)(unsafe.Pointer(h)).Fh_addrtype = af @@ -120771,29 +120771,29 @@ func Xgethostbyname2_r(tls *TLS, name uintptr, af int32, h uintptr, buf uintptr, if !(i < cnt) { break } - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*4)) = buf + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*4)) = buf buf = buf + uintptr((*Thostent)(unsafe.Pointer(h)).Fh_length) - _memcpy(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*4)), bp+uintptr(i)*28+8, Uint32FromInt32((*Thostent)(unsafe.Pointer(h)).Fh_length)) + _memcpy(tls, **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*4)), bp+uintptr(i)*28+8, Uint32FromInt32((*Thostent)(unsafe.Pointer(h)).Fh_length)) goto _2 _2: ; i = i + 1 } - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*4)) = uintptr(0) + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*4)) = uintptr(0) v3 = buf - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) = v3 + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) = v3 (*Thostent)(unsafe.Pointer(h)).Fh_name = v3 Xstrcpy(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name, bp+1344) buf = buf + uintptr(_strlen(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name)+uint32(1)) if Xstrcmp(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name, name) != 0 { - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*4)) = buf - Xstrcpy(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*4)), name) - buf = buf + uintptr(_strlen(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*4)))+uint32(1)) + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*4)) = buf + Xstrcpy(tls, **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*4)), name) + buf = buf + uintptr(_strlen(tls, **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*4)))+uint32(1)) } else { - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*4)) = uintptr(0) + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*4)) = uintptr(0) } - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 2*4)) = uintptr(0) - *(*uintptr)(unsafe.Pointer(res)) = h + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 2*4)) = uintptr(0) + **(**uintptr)(__ccgo_up(res)) = h return 0 } @@ -121021,7 +121021,7 @@ func _copy_addr(tls *TLS, r uintptr, af int32, sa uintptr, addr uintptr, addrlen case int32(PF_INET6): dst = sa + 8 len1 = int32(16) - if Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(addr))) == int32(0xfe) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(addr + 1)))&int32(0xc0) == int32(0x80) || Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(addr))) == int32(0xff) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(addr + 1)))&int32(0xf) == int32(0x2) { + if Int32FromUint8(**(**Tuint8_t)(__ccgo_up(addr))) == int32(0xfe) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(addr + 1)))&int32(0xc0) == int32(0x80) || Int32FromUint8(**(**Tuint8_t)(__ccgo_up(addr))) == int32(0xff) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(addr + 1)))&int32(0xf) == int32(0x2) { (*(*Tsockaddr_in6)(unsafe.Pointer(sa))).Fsin6_scope_id = Uint32FromInt32(ifindex) } default: @@ -121032,7 +121032,7 @@ func _copy_addr(tls *TLS, r uintptr, af int32, sa uintptr, addr uintptr, addrlen } (*Tsockany)(unsafe.Pointer(sa)).Fsa.Fsa_family = Uint16FromInt32(af) _memcpy(tls, dst, addr, Uint32FromInt32(len1)) - *(*uintptr)(unsafe.Pointer(r)) = sa + **(**uintptr)(__ccgo_up(r)) = sa } func _gen_netmask(tls *TLS, r uintptr, af int32, sa uintptr, prefixlen int32) { @@ -121041,7 +121041,7 @@ func _gen_netmask(tls *TLS, r uintptr, af int32, sa uintptr, prefixlen int32) { var i, v1 int32 var _ /* addr at bp+0 */ [16]Tuint8_t _, _ = i, v1 - *(*[16]Tuint8_t)(unsafe.Pointer(bp)) = [16]Tuint8_t{} + **(**[16]Tuint8_t)(__ccgo_up(bp)) = [16]Tuint8_t{} if Uint32FromInt32(prefixlen) > Uint32FromInt32(8)*Uint32FromInt64(16) { prefixlen = Int32FromUint32(Uint32FromInt32(8) * Uint32FromInt64(16)) } @@ -121050,7 +121050,7 @@ func _gen_netmask(tls *TLS, r uintptr, af int32, sa uintptr, prefixlen int32) { if Uint32FromInt32(i) < uint32(16) { v1 = i i = i + 1 - (*(*[16]Tuint8_t)(unsafe.Pointer(bp)))[v1] = Uint8FromInt32(int32(0xff) << (int32(8) - prefixlen%int32(8))) + (**(**[16]Tuint8_t)(__ccgo_up(bp)))[v1] = Uint8FromInt32(int32(0xff) << (int32(8) - prefixlen%int32(8))) } _copy_addr(tls, r, af, sa, bp, uint32(16), 0) } @@ -121064,7 +121064,7 @@ func _copy_lladdr(tls *TLS, r uintptr, sa uintptr, addr uintptr, addrlen Tsize_t (*(*Tsockaddr_ll_hack)(unsafe.Pointer(sa))).Fsll_hatype = hatype (*(*Tsockaddr_ll_hack)(unsafe.Pointer(sa))).Fsll_halen = uint8(addrlen) _memcpy(tls, sa+12, addr, addrlen) - *(*uintptr)(unsafe.Pointer(r)) = sa + **(**uintptr)(__ccgo_up(r)) = sa } func _netlink_msg_to_ifaddr(tls *TLS, pctx uintptr, h uintptr) (r int32) { @@ -121093,7 +121093,7 @@ func _netlink_msg_to_ifaddr(tls *TLS, pctx uintptr, h uintptr) (r int32) { rta = rta + uintptr((Int32FromUint16((*Trtattr)(unsafe.Pointer(rta)).Frta_len)+Int32FromInt32(3)) & ^Int32FromInt32(3)) } } else { - ifs0 = *(*uintptr)(unsafe.Pointer(ctx + 8 + uintptr((*Tifaddrmsg)(unsafe.Pointer(ifa)).Fifa_index%uint32(IFADDRS_HASH_SIZE))*4)) + ifs0 = **(**uintptr)(__ccgo_up(ctx + 8 + uintptr((*Tifaddrmsg)(unsafe.Pointer(ifa)).Fifa_index%uint32(IFADDRS_HASH_SIZE))*4)) for { if !(ifs0 != 0) { break @@ -121144,8 +121144,8 @@ func _netlink_msg_to_ifaddr(tls *TLS, pctx uintptr, h uintptr) (r int32) { } if (*Tifaddrs_storage)(unsafe.Pointer(ifs)).Fifa.Fifa_name != 0 { bucket = (*Tifaddrs_storage)(unsafe.Pointer(ifs)).Findex % uint32(IFADDRS_HASH_SIZE) - (*Tifaddrs_storage)(unsafe.Pointer(ifs)).Fhash_next = *(*uintptr)(unsafe.Pointer(ctx + 8 + uintptr(bucket)*4)) - *(*uintptr)(unsafe.Pointer(ctx + 8 + uintptr(bucket)*4)) = ifs + (*Tifaddrs_storage)(unsafe.Pointer(ifs)).Fhash_next = **(**uintptr)(__ccgo_up(ctx + 8 + uintptr(bucket)*4)) + **(**uintptr)(__ccgo_up(ctx + 8 + uintptr(bucket)*4)) = ifs } } else { (*Tifaddrs_storage)(unsafe.Pointer(ifs)).Fifa.Fifa_name = (*Tifaddrs_storage)(unsafe.Pointer(ifs0)).Fifa.Fifa_name @@ -121220,7 +121220,7 @@ func Xgetifaddrs(tls *TLS, ifap uintptr) (r1 int32) { Xmemset(tls, ctx, 0, uint32(264)) r = X__rtnetlink_enumerate(tls, PF_UNSPEC, PF_UNSPEC, __ccgo_fp(_netlink_msg_to_ifaddr), ctx) if r == 0 { - *(*uintptr)(unsafe.Pointer(ifap)) = (*Tifaddrs_ctx)(unsafe.Pointer(ctx)).Ffirst + **(**uintptr)(__ccgo_up(ifap)) = (*Tifaddrs_ctx)(unsafe.Pointer(ctx)).Ffirst } else { Xfreeifaddrs(tls, (*Tifaddrs_ctx)(unsafe.Pointer(ctx)).Ffirst) } @@ -121235,11 +121235,11 @@ func _itoa(tls *TLS, p uintptr, x uint32) (r uintptr) { p = p + uintptr(Uint32FromInt32(3)*Uint32FromInt64(4)) p = p - 1 v1 = p - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) for cond := true; cond; cond = x != 0 { p = p - 1 v1 = p - *(*uint8)(unsafe.Pointer(v1)) = uint8(uint32('0') + x%uint32(10)) + **(**uint8)(__ccgo_up(v1)) = uint8(uint32('0') + x%uint32(10)) x = x / uint32(10) } return p @@ -121248,7 +121248,7 @@ func _itoa(tls *TLS, p uintptr, x uint32) (r uintptr) { func _mkptr4(tls *TLS, s uintptr, ip uintptr) { bp := tls.Alloc(48) defer tls.Free(48) - Xsprintf(tls, s, __ccgo_ts+897, VaList(bp+8, Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + 3))), Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + 2))), Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + 1))), Int32FromUint8(*(*uint8)(unsafe.Pointer(ip))))) + Xsprintf(tls, s, __ccgo_ts+897, VaList(bp+8, Int32FromUint8(**(**uint8)(__ccgo_up(ip + 3))), Int32FromUint8(**(**uint8)(__ccgo_up(ip + 2))), Int32FromUint8(**(**uint8)(__ccgo_up(ip + 1))), Int32FromUint8(**(**uint8)(__ccgo_up(ip))))) } func _mkptr6(tls *TLS, s uintptr, ip uintptr) { @@ -121262,16 +121262,16 @@ func _mkptr6(tls *TLS, s uintptr, ip uintptr) { } v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = _xdigits[Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + uintptr(i))))&int32(15)] + **(**uint8)(__ccgo_up(v2)) = _xdigits[Int32FromUint8(**(**uint8)(__ccgo_up(ip + uintptr(i))))&int32(15)] v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8('.') + **(**uint8)(__ccgo_up(v2)) = uint8('.') v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = _xdigits[Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + uintptr(i))))>>int32(4)] + **(**uint8)(__ccgo_up(v2)) = _xdigits[Int32FromUint8(**(**uint8)(__ccgo_up(ip + uintptr(i))))>>int32(4)] v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8('.') + **(**uint8)(__ccgo_up(v2)) = uint8('.') goto _1 _1: ; @@ -121309,13 +121309,13 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int if v1 != 0 { v2 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8('\n') - *(*uint8)(unsafe.Pointer(p)) = Uint8FromInt32(0) + **(**uint8)(__ccgo_up(v2)) = uint8('\n') + **(**uint8)(__ccgo_up(p)) = Uint8FromInt32(0) } p = bp for { - if v7 = *(*uint8)(unsafe.Pointer(p)) != 0; v7 { - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + if v7 = **(**uint8)(__ccgo_up(p)) != 0; v7 { + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v5 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _6 _6: @@ -121328,26 +121328,26 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int ; p = p + 1 } - if !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if !(**(**uint8)(__ccgo_up(p)) != 0) { continue } v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) if X__lookup_ipliteral(tls, bp+1560, bp, PF_UNSPEC) <= 0 { continue } - if (*(*Taddress)(unsafe.Pointer(bp + 1560))).Ffamily == int32(PF_INET) { + if (**(**Taddress)(__ccgo_up(bp + 1560))).Ffamily == int32(PF_INET) { _memcpy(tls, bp+1560+8+uintptr(12), bp+1560+8, uint32(4)) _memcpy(tls, bp+1560+8, __ccgo_ts+942, uint32(12)) - (*(*Taddress)(unsafe.Pointer(bp + 1560))).Fscopeid = uint32(0) + (**(**Taddress)(__ccgo_up(bp + 1560))).Fscopeid = uint32(0) } - if Xmemcmp(tls, a, bp+1560+8, uint32(16)) != 0 || (*(*Taddress)(unsafe.Pointer(bp + 1560))).Fscopeid != scopeid { + if Xmemcmp(tls, a, bp+1560+8, uint32(16)) != 0 || (**(**Taddress)(__ccgo_up(bp + 1560))).Fscopeid != scopeid { continue } for { - if v7 = *(*uint8)(unsafe.Pointer(p)) != 0; v7 { - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + if v7 = **(**uint8)(__ccgo_up(p)) != 0; v7 { + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v5 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _12 _12: @@ -121362,8 +121362,8 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int } z = p for { - if v7 = *(*uint8)(unsafe.Pointer(z)) != 0; v7 { - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(z))) + if v7 = **(**uint8)(__ccgo_up(z)) != 0; v7 { + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(z))) v5 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _17 _17: @@ -121376,7 +121376,7 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int ; z = z + 1 } - *(*uint8)(unsafe.Pointer(z)) = uint8(0) + **(**uint8)(__ccgo_up(z)) = uint8(0) if int32(z)-int32(p) < int32(256) { _memcpy(tls, buf, p, Uint32FromInt32(int32(z)-int32(p)+int32(1))) break @@ -121407,13 +121407,13 @@ func _reverse_services(tls *TLS, buf uintptr, port int32, dgram int32) { if v1 != 0 { v2 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8('\n') - *(*uint8)(unsafe.Pointer(p)) = Uint8FromInt32(0) + **(**uint8)(__ccgo_up(v2)) = uint8('\n') + **(**uint8)(__ccgo_up(p)) = Uint8FromInt32(0) } p = bp for { - if v7 = *(*uint8)(unsafe.Pointer(p)) != 0; v7 { - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + if v7 = **(**uint8)(__ccgo_up(p)) != 0; v7 { + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v5 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _6 _6: @@ -121426,20 +121426,20 @@ func _reverse_services(tls *TLS, buf uintptr, port int32, dgram int32) { ; p = p + 1 } - if !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if !(**(**uint8)(__ccgo_up(p)) != 0) { continue } v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) svport = Xstrtoul(tls, p, bp+128, int32(10)) - if svport != Uint32FromInt32(port) || *(*uintptr)(unsafe.Pointer(bp + 128)) == p { + if svport != Uint32FromInt32(port) || **(**uintptr)(__ccgo_up(bp + 128)) == p { continue } - if dgram != 0 && Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(bp + 128)), __ccgo_ts+969, uint32(4)) != 0 { + if dgram != 0 && Xstrncmp(tls, **(**uintptr)(__ccgo_up(bp + 128)), __ccgo_ts+969, uint32(4)) != 0 { continue } - if !(dgram != 0) && Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(bp + 128)), __ccgo_ts+974, uint32(4)) != 0 { + if !(dgram != 0) && Xstrncmp(tls, **(**uintptr)(__ccgo_up(bp + 128)), __ccgo_ts+974, uint32(4)) != 0 { continue } if int32(p)-t__predefined_ptrdiff_t(bp) > int32(32) { @@ -121456,7 +121456,7 @@ func _dns_parse_callback(tls *TLS, c uintptr, rr int32, data uintptr, len1 int32 return 0 } if X__dn_expand(tls, packet, packet+uintptr(plen), data, c, int32(256)) <= 0 { - *(*uint8)(unsafe.Pointer(c)) = uint8(0) + **(**uint8)(__ccgo_up(c)) = uint8(0) } return 0 } @@ -121502,15 +121502,15 @@ func Xgetnameinfo(tls *TLS, sa uintptr, sl Tsocklen_t, node uintptr, nodelen Tso return -int32(6) } if node != 0 && nodelen != 0 { - (*(*[256]uint8)(unsafe.Pointer(bp + 78)))[0] = uint8(0) + (**(**[256]uint8)(__ccgo_up(bp + 78)))[0] = uint8(0) if !(flags&Int32FromInt32(NI_NUMERICHOST) != 0) { _reverse_hosts(tls, bp+78, a, scopeid, af) } - if !(*(*uint8)(unsafe.Pointer(bp + 78)) != 0) && !(flags&Int32FromInt32(NI_NUMERICHOST) != 0) { + if !(**(**uint8)(__ccgo_up(bp + 78)) != 0) && !(flags&Int32FromInt32(NI_NUMERICHOST) != 0) { qlen = X__res_mkquery(tls, 0, bp, int32(1), int32(RR_PTR), uintptr(0), 0, uintptr(0), bp+347, int32(96)) - (*(*[96]uint8)(unsafe.Pointer(bp + 347)))[int32(3)] = uint8(0) /* don't need AD flag */ + (**(**[96]uint8)(__ccgo_up(bp + 347)))[int32(3)] = uint8(0) /* don't need AD flag */ rlen = X__res_send(tls, bp+347, qlen, bp+443, int32(512)) - (*(*[256]uint8)(unsafe.Pointer(bp + 78)))[0] = uint8(0) + (**(**[256]uint8)(__ccgo_up(bp + 78)))[0] = uint8(0) if rlen > 0 { if Uint32FromInt32(rlen) > uint32(512) { rlen = int32(512) @@ -121518,14 +121518,14 @@ func Xgetnameinfo(tls *TLS, sa uintptr, sl Tsocklen_t, node uintptr, nodelen Tso X__dns_parse(tls, bp+443, rlen, __ccgo_fp(_dns_parse_callback), bp+78) } } - if !(*(*uint8)(unsafe.Pointer(bp + 78)) != 0) { + if !(**(**uint8)(__ccgo_up(bp + 78)) != 0) { if flags&int32(NI_NAMEREQD) != 0 { return -int32(2) } Xinet_ntop(tls, af, a, bp+78, uint32(256)) if scopeid != 0 { p = uintptr(0) - if !(flags&Int32FromInt32(NI_NUMERICSCOPE) != 0) && (Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a))) == int32(0xfe) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 1)))&int32(0xc0) == int32(0x80) || Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a))) == int32(0xff) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 1)))&int32(0xf) == int32(0x2)) { + if !(flags&Int32FromInt32(NI_NUMERICSCOPE) != 0) && (Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a))) == int32(0xfe) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 1)))&int32(0xc0) == int32(0x80) || Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a))) == int32(0xff) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 1)))&int32(0xf) == int32(0x2)) { p = Xif_indextoname(tls, scopeid, bp+955+uintptr(1)) } if !(p != 0) { @@ -121533,7 +121533,7 @@ func Xgetnameinfo(tls *TLS, sa uintptr, sl Tsocklen_t, node uintptr, nodelen Tso } p = p - 1 v1 = p - *(*uint8)(unsafe.Pointer(v1)) = uint8('%') + **(**uint8)(__ccgo_up(v1)) = uint8('%') Xstrcat(tls, bp+78, p) } } @@ -121545,11 +121545,11 @@ func Xgetnameinfo(tls *TLS, sa uintptr, sl Tsocklen_t, node uintptr, nodelen Tso if serv != 0 && servlen != 0 { p1 = bp + 78 port = Int32FromUint16(Xntohs(tls, (*Tsockaddr_in)(unsafe.Pointer(sa)).Fsin_port)) - (*(*[256]uint8)(unsafe.Pointer(bp + 78)))[0] = uint8(0) + (**(**[256]uint8)(__ccgo_up(bp + 78)))[0] = uint8(0) if !(flags&Int32FromInt32(NI_NUMERICSERV) != 0) { _reverse_services(tls, bp+78, port, flags&int32(NI_DGRAM)) } - if !(*(*uint8)(unsafe.Pointer(p1)) != 0) { + if !(**(**uint8)(__ccgo_up(p1)) != 0) { p1 = _itoa(tls, bp+334, Uint32FromInt32(port)) } if _strlen(tls, p1) >= servlen { @@ -121623,11 +121623,11 @@ func Xgetservbyname_r(tls *TLS, name uintptr, prots uintptr, se uintptr, buf uin var _ /* end at bp+8 */ uintptr var _ /* servs at bp+0 */ [2]Tservice _, _, _, _ = align, cnt, proto, v1 - *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) + **(**uintptr)(__ccgo_up(res)) = uintptr(0) /* Don't treat numeric port number strings as service records. */ - *(*uintptr)(unsafe.Pointer(bp + 8)) = __ccgo_ts + **(**uintptr)(__ccgo_up(bp + 8)) = __ccgo_ts Xstrtoul(tls, name, bp+8, int32(10)) - if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) != 0) { + if !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) != 0) { return int32(ENOENT) } /* Align buffer */ @@ -121662,16 +121662,16 @@ func Xgetservbyname_r(tls *TLS, name uintptr, prots uintptr, se uintptr, buf uin } (*Tservent)(unsafe.Pointer(se)).Fs_name = name (*Tservent)(unsafe.Pointer(se)).Fs_aliases = buf - *(*uintptr)(unsafe.Pointer((*Tservent)(unsafe.Pointer(se)).Fs_aliases)) = (*Tservent)(unsafe.Pointer(se)).Fs_name - *(*uintptr)(unsafe.Pointer((*Tservent)(unsafe.Pointer(se)).Fs_aliases + 1*4)) = uintptr(0) - (*Tservent)(unsafe.Pointer(se)).Fs_port = Int32FromUint16(Xhtons(tls, (*(*[2]Tservice)(unsafe.Pointer(bp)))[0].Fport)) - if Int32FromUint8((*(*[2]Tservice)(unsafe.Pointer(bp)))[0].Fproto) == int32(IPPROTO_TCP) { + **(**uintptr)(__ccgo_up((*Tservent)(unsafe.Pointer(se)).Fs_aliases)) = (*Tservent)(unsafe.Pointer(se)).Fs_name + **(**uintptr)(__ccgo_up((*Tservent)(unsafe.Pointer(se)).Fs_aliases + 1*4)) = uintptr(0) + (*Tservent)(unsafe.Pointer(se)).Fs_port = Int32FromUint16(Xhtons(tls, (**(**[2]Tservice)(__ccgo_up(bp)))[0].Fport)) + if Int32FromUint8((**(**[2]Tservice)(__ccgo_up(bp)))[0].Fproto) == int32(IPPROTO_TCP) { v1 = __ccgo_ts + 979 } else { v1 = __ccgo_ts + 983 } (*Tservent)(unsafe.Pointer(se)).Fs_proto = v1 - *(*uintptr)(unsafe.Pointer(res)) = se + **(**uintptr)(__ccgo_up(res)) = se return 0 } @@ -121749,7 +121749,7 @@ _9: if false { break } - if *(*Tsocklen_t)(unsafe.Pointer(optlen)) < uint32(16) { + if **(**Tsocklen_t)(__ccgo_up(optlen)) < uint32(16) { return X__syscall_ret(tls, Uint32FromInt32(-Int32FromInt32(EINVAL))) } if optname == int32(SO_RCVTIMEO) { @@ -121786,9 +121786,9 @@ _9: break } tv = optval - (*Ttimeval)(unsafe.Pointer(tv)).Ftv_sec = int64((*(*[2]int32)(unsafe.Pointer(bp + 8)))[0]) - (*Ttimeval)(unsafe.Pointer(tv)).Ftv_usec = int64((*(*[2]int32)(unsafe.Pointer(bp + 8)))[int32(1)]) - *(*Tsocklen_t)(unsafe.Pointer(optlen)) = uint32(16) + (*Ttimeval)(unsafe.Pointer(tv)).Ftv_sec = int64((**(**[2]int32)(__ccgo_up(bp + 8)))[0]) + (*Ttimeval)(unsafe.Pointer(tv)).Ftv_usec = int64((**(**[2]int32)(__ccgo_up(bp + 8)))[int32(1)]) + **(**Tsocklen_t)(__ccgo_up(optlen)) = uint32(16) case int32(SO_TIMESTAMP): fallthrough case int32(SO_TIMESTAMPNS): @@ -121858,7 +121858,7 @@ func Xherror(tls *TLS, msg uintptr) { } else { v2 = __ccgo_ts } - Xfprintf(tls, uintptr(unsafe.Pointer(&X__stderr_FILE)), __ccgo_ts+987, VaList(bp+8, v1, v2, Xhstrerror(tls, *(*int32)(unsafe.Pointer(X__h_errno_location(tls)))))) + Xfprintf(tls, uintptr(unsafe.Pointer(&X__stderr_FILE)), __ccgo_ts+987, VaList(bp+8, v1, v2, Xhstrerror(tls, **(**int32)(__ccgo_up(X__h_errno_location(tls)))))) } var _msgs1 = [84]uint8{'H', 'o', 's', 't', ' ', 'n', 'o', 't', ' ', 'f', 'o', 'u', 'n', 'd', 0, 'T', 'r', 'y', ' ', 'a', 'g', 'a', 'i', 'n', 0, 'N', 'o', 'n', '-', 'r', 'e', 'c', 'o', 'v', 'e', 'r', 'a', 'b', 'l', 'e', ' ', 'e', 'r', 'r', 'o', 'r', 0, 'A', 'd', 'd', 'r', 'e', 's', 's', ' ', 'n', 'o', 't', ' ', 'a', 'v', 'a', 'i', 'l', 'a', 'b', 'l', 'e', 0, 0, 'U', 'n', 'k', 'n', 'o', 'w', 'n', ' ', 'e', 'r', 'r', 'o', 'r'} @@ -121873,11 +121873,11 @@ func Xhstrerror(tls *TLS, ecode int32) (r uintptr) { s = uintptr(unsafe.Pointer(&_msgs1)) ecode = ecode - 1 for { - if !(ecode != 0 && *(*uint8)(unsafe.Pointer(s)) != 0) { + if !(ecode != 0 && **(**uint8)(__ccgo_up(s)) != 0) { break } for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { break } goto _2 @@ -121891,7 +121891,7 @@ func Xhstrerror(tls *TLS, ecode int32) (r uintptr) { ecode = ecode - 1 s = s + 1 } - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { s = s + 1 } return X__lctrans_cur(tls, s) @@ -121979,8 +121979,8 @@ func Xif_indextoname(tls *TLS, index uint32, name uintptr) (r1 uintptr) { r = Xioctl(tls, fd, int32(SIOCGIFNAME), VaList(bp+40, bp)) X__syscall1(tls, int32(SYS_close), fd) if r < 0 { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENODEV) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENXIO) + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENODEV) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENXIO) } return uintptr(0) } @@ -122033,7 +122033,7 @@ func _netlink_msg_to_nameindex(tls *TLS, pctx uintptr, h uintptr) (r int32) { } /* suppress duplicates */ bucket = index % int32(IFADDRS_HASH_SIZE) - i = *(*uint32)(unsafe.Pointer(ctx + 16 + uintptr(bucket)*4)) + i = **(**uint32)(__ccgo_up(ctx + 16 + uintptr(bucket)*4)) for i != 0 { map1 = (*Tifnameindexctx)(unsafe.Pointer(ctx)).Flist + uintptr(i-uint32(1))*28 if (*Tifnamemap)(unsafe.Pointer(map1)).Findex == Uint32FromInt32(index) && Int32FromUint8((*Tifnamemap)(unsafe.Pointer(map1)).Fnamelen) == namelen && Xmemcmp(tls, map1+9, rta+UintptrFromInt64(4), Uint32FromInt32(namelen)) == 0 { @@ -122062,10 +122062,10 @@ func _netlink_msg_to_nameindex(tls *TLS, pctx uintptr, h uintptr) (r int32) { (*Tifnamemap)(unsafe.Pointer(map1)).Findex = Uint32FromInt32(index) (*Tifnamemap)(unsafe.Pointer(map1)).Fnamelen = Uint8FromInt32(namelen) _memcpy(tls, map1+9, rta+UintptrFromInt64(4), Uint32FromInt32(namelen)) - *(*uint32)(unsafe.Pointer(ctx + 8)) += Uint32FromInt32(namelen + int32(1)) + **(**uint32)(__ccgo_up(ctx + 8)) += Uint32FromInt32(namelen + int32(1)) (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum = (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum + 1 - (*Tifnamemap)(unsafe.Pointer(map1)).Fhash_next = *(*uint32)(unsafe.Pointer(ctx + 16 + uintptr(bucket)*4)) - *(*uint32)(unsafe.Pointer(ctx + 16 + uintptr(bucket)*4)) = (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum + (*Tifnamemap)(unsafe.Pointer(map1)).Fhash_next = **(**uint32)(__ccgo_up(ctx + 16 + uintptr(bucket)*4)) + **(**uint32)(__ccgo_up(ctx + 16 + uintptr(bucket)*4)) = (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum return 0 goto _1 _1: @@ -122112,7 +122112,7 @@ func Xif_nameindex(tls *TLS) (r uintptr) { p = p + uintptr((*Tifnamemap)(unsafe.Pointer(s)).Fnamelen) v2 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8(0) + **(**uint8)(__ccgo_up(v2)) = uint8(0) goto _1 _1: ; @@ -122125,9 +122125,9 @@ func Xif_nameindex(tls *TLS) (r uintptr) { goto err err: ; - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 272)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 272)), uintptr(0)) Xfree(tls, (*Tifnameindexctx)(unsafe.Pointer(ctx)).Flist) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOBUFS) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOBUFS) return ifs } @@ -122168,7 +122168,7 @@ func Xinet_addr(tls *TLS, p uintptr) (r Tin_addr_t) { if !(X__inet_aton(tls, p, bp) != 0) { return Uint32FromInt32(-Int32FromInt32(1)) } - return (*(*Tin_addr)(unsafe.Pointer(bp))).Fs_addr + return (**(**Tin_addr)(__ccgo_up(bp))).Fs_addr } func X__inet_aton(tls *TLS, s0 uintptr, dest uintptr) (r int32) { @@ -122185,20 +122185,20 @@ func X__inet_aton(tls *TLS, s0 uintptr, dest uintptr) (r int32) { _, _, _ = d, i, s s = s0 d = dest - *(*[4]uint32)(unsafe.Pointer(bp)) = [4]uint32{} + **(**[4]uint32)(__ccgo_up(bp)) = [4]uint32{} i = 0 for { if !(i < int32(4)) { break } - (*(*[4]uint32)(unsafe.Pointer(bp)))[i] = Xstrtoul(tls, s, bp+16, 0) - if *(*uintptr)(unsafe.Pointer(bp + 16)) == s || *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16))))) != int32('.') || !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + (**(**[4]uint32)(__ccgo_up(bp)))[i] = Xstrtoul(tls, s, bp+16, 0) + if **(**uintptr)(__ccgo_up(bp + 16)) == s || **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 16)))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 16))))) != int32('.') || !(BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return 0 } - if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))) != 0) { + if !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 16)))) != 0) { break } - s = *(*uintptr)(unsafe.Pointer(bp + 16)) + uintptr(1) + s = **(**uintptr)(__ccgo_up(bp + 16)) + uintptr(1) goto _1 _1: ; @@ -122209,26 +122209,26 @@ func X__inet_aton(tls *TLS, s0 uintptr, dest uintptr) (r int32) { } switch i { case 0: - (*(*[4]uint32)(unsafe.Pointer(bp)))[int32(1)] = (*(*[4]uint32)(unsafe.Pointer(bp)))[0] & uint32(0xffffff) - *(*uint32)(unsafe.Pointer(bp)) >>= uint32(24) + (**(**[4]uint32)(__ccgo_up(bp)))[int32(1)] = (**(**[4]uint32)(__ccgo_up(bp)))[0] & uint32(0xffffff) + **(**uint32)(__ccgo_up(bp)) >>= uint32(24) fallthrough case int32(1): - (*(*[4]uint32)(unsafe.Pointer(bp)))[int32(2)] = (*(*[4]uint32)(unsafe.Pointer(bp)))[int32(1)] & uint32(0xffff) - *(*uint32)(unsafe.Pointer(bp + 1*4)) >>= uint32(16) + (**(**[4]uint32)(__ccgo_up(bp)))[int32(2)] = (**(**[4]uint32)(__ccgo_up(bp)))[int32(1)] & uint32(0xffff) + **(**uint32)(__ccgo_up(bp + 1*4)) >>= uint32(16) fallthrough case int32(2): - (*(*[4]uint32)(unsafe.Pointer(bp)))[int32(3)] = (*(*[4]uint32)(unsafe.Pointer(bp)))[int32(2)] & uint32(0xff) - *(*uint32)(unsafe.Pointer(bp + 2*4)) >>= uint32(8) + (**(**[4]uint32)(__ccgo_up(bp)))[int32(3)] = (**(**[4]uint32)(__ccgo_up(bp)))[int32(2)] & uint32(0xff) + **(**uint32)(__ccgo_up(bp + 2*4)) >>= uint32(8) } i = 0 for { if !(i < int32(4)) { break } - if (*(*[4]uint32)(unsafe.Pointer(bp)))[i] > uint32(255) { + if (**(**[4]uint32)(__ccgo_up(bp)))[i] > uint32(255) { return 0 } - *(*uint8)(unsafe.Pointer(d + uintptr(i))) = uint8((*(*[4]uint32)(unsafe.Pointer(bp)))[i]) + **(**uint8)(__ccgo_up(d + uintptr(i))) = uint8((**(**[4]uint32)(__ccgo_up(bp)))[i]) goto _2 _2: ; @@ -122317,7 +122317,7 @@ func Xinet_ntoa(tls *TLS, _in Tin_addr) (r uintptr) { var a uintptr _ = a a = bp - Xsnprintf(tls, uintptr(unsafe.Pointer(&_buf4)), uint32(16), __ccgo_ts+995, VaList(bp+16, Int32FromUint8(*(*uint8)(unsafe.Pointer(a))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 1))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 2))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 3))))) + Xsnprintf(tls, uintptr(unsafe.Pointer(&_buf4)), uint32(16), __ccgo_ts+995, VaList(bp+16, Int32FromUint8(**(**uint8)(__ccgo_up(a))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 1))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 2))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 3))))) return uintptr(unsafe.Pointer(&_buf4)) } @@ -122338,14 +122338,14 @@ func Xinet_ntop(tls *TLS, af int32, a0 uintptr, s uintptr, l Tsocklen_t) (r uint a = a0 switch af { case int32(PF_INET): - if Uint32FromInt32(Xsnprintf(tls, s, l, __ccgo_ts+995, VaList(bp+112, Int32FromUint8(*(*uint8)(unsafe.Pointer(a))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 1))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 2))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 3)))))) < l { + if Uint32FromInt32(Xsnprintf(tls, s, l, __ccgo_ts+995, VaList(bp+112, Int32FromUint8(**(**uint8)(__ccgo_up(a))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 1))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 2))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 3)))))) < l { return s } case int32(PF_INET6): if Xmemcmp(tls, a, __ccgo_ts+942, uint32(12)) != 0 { - Xsnprintf(tls, bp, uint32(100), __ccgo_ts+1007, VaList(bp+112, int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 1))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 2)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 3))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 4)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 5))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 6)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 7))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 8)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 9))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 10)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 11))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 12)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 13))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 14)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 15))))) + Xsnprintf(tls, bp, uint32(100), __ccgo_ts+1007, VaList(bp+112, int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 1))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 2)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 3))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 4)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 5))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 6)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 7))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 8)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 9))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 10)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 11))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 12)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 13))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 14)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 15))))) } else { - Xsnprintf(tls, bp, uint32(100), __ccgo_ts+1031, VaList(bp+112, int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 1))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 2)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 3))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 4)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 5))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 6)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 7))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 8)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 9))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 10)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 11))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 12))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 13))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 14))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 15))))) + Xsnprintf(tls, bp, uint32(100), __ccgo_ts+1031, VaList(bp+112, int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 1))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 2)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 3))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 4)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 5))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 6)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 7))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 8)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 9))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 10)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 11))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 12))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 13))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 14))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 15))))) } /* Replace longest /(^0|:)[:0]{2,}/ with "::" */ v2 = Int32FromInt32(0) @@ -122353,10 +122353,10 @@ func Xinet_ntop(tls *TLS, af int32, a0 uintptr, s uintptr, l Tsocklen_t) (r uint i = v2 max = Int32FromInt32(2) for { - if !((*(*[100]uint8)(unsafe.Pointer(bp)))[i] != 0) { + if !((**(**[100]uint8)(__ccgo_up(bp)))[i] != 0) { break } - if i != 0 && Int32FromUint8((*(*[100]uint8)(unsafe.Pointer(bp)))[i]) != int32(':') { + if i != 0 && Int32FromUint8((**(**[100]uint8)(__ccgo_up(bp)))[i]) != int32(':') { goto _1 } j = Int32FromUint32(Xstrspn(tls, bp+uintptr(i), __ccgo_ts+1061)) @@ -122371,8 +122371,8 @@ func Xinet_ntop(tls *TLS, af int32, a0 uintptr, s uintptr, l Tsocklen_t) (r uint } if max > int32(3) { v3 = Uint8FromUint8(':') - (*(*[100]uint8)(unsafe.Pointer(bp)))[best+int32(1)] = v3 - (*(*[100]uint8)(unsafe.Pointer(bp)))[best] = v3 + (**(**[100]uint8)(__ccgo_up(bp)))[best+int32(1)] = v3 + (**(**[100]uint8)(__ccgo_up(bp)))[best] = v3 Xmemmove(tls, bp+uintptr(best)+uintptr(2), bp+uintptr(best)+uintptr(max), Uint32FromInt32(i-best-max+int32(1))) } if _strlen(tls, bp) < l { @@ -122380,10 +122380,10 @@ func Xinet_ntop(tls *TLS, af int32, a0 uintptr, s uintptr, l Tsocklen_t) (r uint return s } default: - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EAFNOSUPPORT) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EAFNOSUPPORT) return uintptr(0) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOSPC) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOSPC) return uintptr(0) } @@ -122423,23 +122423,23 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { j = v3 v = v3 for { - if !(j < int32(3) && BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s + uintptr(j))))-uint32('0') < uint32(10)) != 0) { + if !(j < int32(3) && BoolInt32(uint32(**(**uint8)(__ccgo_up(s + uintptr(j))))-uint32('0') < uint32(10)) != 0) { break } - v = int32(10)*v + Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(j)))) - int32('0') + v = int32(10)*v + Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(j)))) - int32('0') goto _2 _2: ; j = j + 1 } - if j == 0 || j > int32(1) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('0') || v > int32(255) { + if j == 0 || j > int32(1) && Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('0') || v > int32(255) { return 0 } - *(*uint8)(unsafe.Pointer(a + uintptr(i))) = Uint8FromInt32(v) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(j)))) == 0 && i == int32(3) { + **(**uint8)(__ccgo_up(a + uintptr(i))) = Uint8FromInt32(v) + if Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(j)))) == 0 && i == int32(3) { return int32(1) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(j)))) != int32('.') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(j)))) != int32('.') { return 0 } s = s + uintptr(j+int32(1)) @@ -122451,25 +122451,25 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { return 0 } else { if af != int32(PF_INET6) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EAFNOSUPPORT) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EAFNOSUPPORT) return -int32(1) } } - if v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32(':'); v5 { + if v5 = Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32(':'); v5 { s = s + 1 v4 = s } - if v5 && Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) != int32(':') { + if v5 && Int32FromUint8(**(**uint8)(__ccgo_up(v4))) != int32(':') { return 0 } i = 0 for { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32(':') && brk < 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32(':') && brk < 0 { brk = i - (*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[i&int32(7)] = uint16(0) + (**(**[8]Tuint16_t)(__ccgo_up(bp)))[i&int32(7)] = uint16(0) s = s + 1 v4 = s - if !(*(*uint8)(unsafe.Pointer(v4)) != 0) { + if !(**(**uint8)(__ccgo_up(v4)) != 0) { break } if i == int32(7) { @@ -122482,7 +122482,7 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { v = v3 for { if v5 = j < int32(4); v5 { - v9 = _hexval(tls, uint32(*(*uint8)(unsafe.Pointer(s + uintptr(j))))) + v9 = _hexval(tls, uint32(**(**uint8)(__ccgo_up(s + uintptr(j))))) d = v9 } if !(v5 && v9 >= 0) { @@ -122497,20 +122497,20 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { if j == 0 { return 0 } - (*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[i&int32(7)] = Uint16FromInt32(v) - if !(*(*uint8)(unsafe.Pointer(s + uintptr(j))) != 0) && (brk >= 0 || i == int32(7)) { + (**(**[8]Tuint16_t)(__ccgo_up(bp)))[i&int32(7)] = Uint16FromInt32(v) + if !(**(**uint8)(__ccgo_up(s + uintptr(j))) != 0) && (brk >= 0 || i == int32(7)) { break } if i == int32(7) { return 0 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(j)))) != int32(':') { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(j)))) != int32('.') || i < int32(6) && brk < 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(j)))) != int32(':') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(j)))) != int32('.') || i < int32(6) && brk < 0 { return 0 } need_v4 = int32(1) i = i + 1 - (*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[i&int32(7)] = uint16(0) + (**(**[8]Tuint16_t)(__ccgo_up(bp)))[i&int32(7)] = uint16(0) break } s = s + uintptr(j+int32(1)) @@ -122526,7 +122526,7 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { if !(j < int32(7)-i) { break } - (*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[brk+j] = uint16(0) + (**(**[8]Tuint16_t)(__ccgo_up(bp)))[brk+j] = uint16(0) goto _12 _12: ; @@ -122540,10 +122540,10 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { } v4 = a a = a + 1 - *(*uint8)(unsafe.Pointer(v4)) = Uint8FromInt32(Int32FromUint16((*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[j]) >> int32(8)) + **(**uint8)(__ccgo_up(v4)) = Uint8FromInt32(Int32FromUint16((**(**[8]Tuint16_t)(__ccgo_up(bp)))[j]) >> int32(8)) v4 = a a = a + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8((*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[j]) + **(**uint8)(__ccgo_up(v4)) = uint8((**(**[8]Tuint16_t)(__ccgo_up(bp)))[j]) goto _13 _13: ; @@ -122605,15 +122605,15 @@ func X__lookup_ipliteral(tls *TLS, buf uintptr, name uintptr, family int32) (r i return -int32(5) } _memcpy(tls, buf+8, bp, uint32(4)) - (*(*Taddress)(unsafe.Pointer(buf))).Ffamily = int32(PF_INET) - (*(*Taddress)(unsafe.Pointer(buf))).Fscopeid = uint32(0) + (**(**Taddress)(__ccgo_up(buf))).Ffamily = int32(PF_INET) + (**(**Taddress)(__ccgo_up(buf))).Fscopeid = uint32(0) return int32(1) } p = Xstrchr(tls, name, int32('%')) scopeid = uint64(0) if p != 0 && int32(p)-int32(name) < int32(64) { _memcpy(tls, bp+20, name, Uint32FromInt32(int32(p)-int32(name))) - (*(*[64]uint8)(unsafe.Pointer(bp + 20)))[int32(p)-int32(name)] = uint8(0) + (**(**[64]uint8)(__ccgo_up(bp + 20)))[int32(p)-int32(name)] = uint8(0) name = bp + 20 } if Xinet_pton(tls, int32(PF_INET6), name, bp+4) <= 0 { @@ -122623,17 +122623,17 @@ func X__lookup_ipliteral(tls *TLS, buf uintptr, name uintptr, family int32) (r i return -int32(5) } _memcpy(tls, buf+8, bp+4, uint32(16)) - (*(*Taddress)(unsafe.Pointer(buf))).Ffamily = int32(PF_INET6) + (**(**Taddress)(__ccgo_up(buf))).Ffamily = int32(PF_INET6) if p != 0 { p = p + 1 v1 = p - if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(v1)))-uint32('0') < uint32(10)) != 0 { + if BoolInt32(uint32(**(**uint8)(__ccgo_up(v1)))-uint32('0') < uint32(10)) != 0 { scopeid = Xstrtoull(tls, p, bp+84, int32(10)) } else { - *(*uintptr)(unsafe.Pointer(bp + 84)) = p - uintptr(1) + **(**uintptr)(__ccgo_up(bp + 84)) = p - uintptr(1) } - if *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 84)))) != 0 { - if !(Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(bp + 4))) == int32(0xfe) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(bp + 4 + 1)))&int32(0xc0) == int32(0x80)) && !(Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(bp + 4))) == int32(0xff) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(bp + 4 + 1)))&int32(0xf) == int32(0x2)) { + if **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 84)))) != 0 { + if !(Int32FromUint8(**(**Tuint8_t)(__ccgo_up(bp + 4))) == int32(0xfe) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(bp + 4 + 1)))&int32(0xc0) == int32(0x80)) && !(Int32FromUint8(**(**Tuint8_t)(__ccgo_up(bp + 4))) == int32(0xff) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(bp + 4 + 1)))&int32(0xf) == int32(0x2)) { return -int32(2) } scopeid = uint64(Xif_nametoindex(tls, p)) @@ -122645,7 +122645,7 @@ func X__lookup_ipliteral(tls *TLS, buf uintptr, name uintptr, family int32) (r i return -int32(2) } } - (*(*Taddress)(unsafe.Pointer(buf))).Fscopeid = uint32(scopeid) + (**(**Taddress)(__ccgo_up(buf))).Fscopeid = uint32(scopeid) return int32(1) } @@ -122669,7 +122669,7 @@ func _is_valid_hostname(tls *TLS, host uintptr) (r int32) { } s = host for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) >= int32(0x80) || Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('.') || Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('-') || Xisalnum(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))) != 0) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(s))) >= int32(0x80) || Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('.') || Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('-') || Xisalnum(tls, Int32FromUint8(**(**uint8)(__ccgo_up(s)))) != 0) { break } goto _1 @@ -122677,7 +122677,7 @@ func _is_valid_hostname(tls *TLS, host uintptr) (r int32) { ; s = s + 1 } - return BoolInt32(!(*(*uint8)(unsafe.Pointer(s)) != 0)) + return BoolInt32(!(**(**uint8)(__ccgo_up(s)) != 0)) } func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags int32) (r int32) { @@ -122691,14 +122691,14 @@ func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags in if family != int32(PF_INET6) { v1 = cnt cnt = cnt + 1 - *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ + **(**Taddress)(__ccgo_up(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET), } } if family != int32(PF_INET) { v1 = cnt cnt = cnt + 1 - *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ + **(**Taddress)(__ccgo_up(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET6), } } @@ -122706,7 +122706,7 @@ func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags in if family != int32(PF_INET6) { v1 = cnt cnt = cnt + 1 - *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ + **(**Taddress)(__ccgo_up(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET), Faddr: [16]Tuint8_t{ 0: uint8(127), @@ -122717,7 +122717,7 @@ func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags in if family != int32(PF_INET) { v1 = cnt cnt = cnt + 1 - *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ + **(**Taddress)(__ccgo_up(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET6), Faddr: [16]Tuint8_t{ 15: uint8(1), @@ -122749,7 +122749,7 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family have_canon = 0 f = X__fopen_rb_ca(tls, __ccgo_ts+931, bp+1544, bp+512, uint32(1032)) if !(f != 0) { - switch *(*int32)(unsafe.Pointer(X__errno_location(tls))) { + switch **(**int32)(__ccgo_up(X__errno_location(tls))) { case int32(ENOENT): fallthrough case int32(ENOTDIR): @@ -122766,21 +122766,21 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family if v1 != 0 { v2 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8('\n') - *(*uint8)(unsafe.Pointer(p)) = Uint8FromInt32(0) + **(**uint8)(__ccgo_up(v2)) = uint8('\n') + **(**uint8)(__ccgo_up(p)) = Uint8FromInt32(0) } p = bp + uintptr(1) for { v1 = Xstrstr(tls, p, name) p = v1 if v12 = v1 != 0; v12 { - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) + v5 = Int32FromUint8(**(**uint8)(__ccgo_up(p + uintptr(-Int32FromInt32(1))))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _7 _7: ; if v11 = !(v6 != 0); !v11 { - v8 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(l)))) + v8 = Int32FromUint8(**(**uint8)(__ccgo_up(p + uintptr(l)))) v9 = BoolInt32(v8 == int32(' ') || Uint32FromInt32(v8)-uint32('\t') < uint32(5)) goto _10 _10: @@ -122800,8 +122800,8 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family /* Isolate IP address to parse */ p = bp for { - if v11 = *(*uint8)(unsafe.Pointer(p)) != 0; v11 { - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + if v11 = **(**uint8)(__ccgo_up(p)) != 0; v11 { + v5 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _16 _16: @@ -122816,7 +122816,7 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family } v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) switch _name_from_numeric(tls, buf+uintptr(cnt)*28, bp, family) { case int32(1): cnt = cnt + 1 @@ -122831,8 +122831,8 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family } /* Extract first name as canonical name */ for { - if v11 = *(*uint8)(unsafe.Pointer(p)) != 0; v11 { - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + if v11 = **(**uint8)(__ccgo_up(p)) != 0; v11 { + v5 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _22 _22: @@ -122847,8 +122847,8 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family } z = p for { - if v11 = *(*uint8)(unsafe.Pointer(z)) != 0; v11 { - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(z))) + if v11 = **(**uint8)(__ccgo_up(z)) != 0; v11 { + v5 = Int32FromUint8(**(**uint8)(__ccgo_up(z))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _27 _27: @@ -122861,7 +122861,7 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family ; z = z + 1 } - *(*uint8)(unsafe.Pointer(z)) = uint8(0) + **(**uint8)(__ccgo_up(z)) = uint8(0) if _is_valid_hostname(tls, p) != 0 { have_canon = int32(1) _memcpy(tls, canon, p, Uint32FromInt32(int32(z)-int32(p)+int32(1))) @@ -122916,8 +122916,8 @@ func _dns_parse_callback1(tls *TLS, c uintptr, rr int32, data uintptr, len1 int3 family = int32(PF_INET6) break } - (*(*Taddress)(unsafe.Pointer((*Tdpc_ctx)(unsafe.Pointer(ctx)).Faddrs + uintptr((*Tdpc_ctx)(unsafe.Pointer(ctx)).Fcnt)*28))).Ffamily = family - (*(*Taddress)(unsafe.Pointer((*Tdpc_ctx)(unsafe.Pointer(ctx)).Faddrs + uintptr((*Tdpc_ctx)(unsafe.Pointer(ctx)).Fcnt)*28))).Fscopeid = uint32(0) + (**(**Taddress)(__ccgo_up((*Tdpc_ctx)(unsafe.Pointer(ctx)).Faddrs + uintptr((*Tdpc_ctx)(unsafe.Pointer(ctx)).Fcnt)*28))).Ffamily = family + (**(**Taddress)(__ccgo_up((*Tdpc_ctx)(unsafe.Pointer(ctx)).Faddrs + uintptr((*Tdpc_ctx)(unsafe.Pointer(ctx)).Fcnt)*28))).Fscopeid = uint32(0) v2 = ctx + 8 v1 = *(*int32)(unsafe.Pointer(v2)) *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) + 1 @@ -122938,16 +122938,16 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i var _ /* qlens at bp+10176 */ [2]int32 var _ /* qp at bp+10160 */ [2]uintptr _, _, _ = i, nq, qtypes - *(*[2]uintptr)(unsafe.Pointer(bp + 10160)) = [2]uintptr{ + **(**[2]uintptr)(__ccgo_up(bp + 10160)) = [2]uintptr{ 0: bp, 1: bp + 1*280, } - *(*[2]uintptr)(unsafe.Pointer(bp + 10168)) = [2]uintptr{ + **(**[2]uintptr)(__ccgo_up(bp + 10168)) = [2]uintptr{ 0: bp + 560, 1: bp + 560 + 1*4800, } nq = 0 - *(*Tdpc_ctx)(unsafe.Pointer(bp + 10192)) = Tdpc_ctx{ + **(**Tdpc_ctx)(__ccgo_up(bp + 10192)) = Tdpc_ctx{ Faddrs: buf, Fcanon: canon, } @@ -122957,15 +122957,15 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i break } if family != _afrr[i].Faf { - (*(*[2]int32)(unsafe.Pointer(bp + 10176)))[nq] = X__res_mkquery(tls, 0, name, int32(1), _afrr[i].Frr, uintptr(0), 0, uintptr(0), bp+uintptr(nq)*280, int32(280)) - if (*(*[2]int32)(unsafe.Pointer(bp + 10176)))[nq] == -int32(1) { + (**(**[2]int32)(__ccgo_up(bp + 10176)))[nq] = X__res_mkquery(tls, 0, name, int32(1), _afrr[i].Frr, uintptr(0), 0, uintptr(0), bp+uintptr(nq)*280, int32(280)) + if (**(**[2]int32)(__ccgo_up(bp + 10176)))[nq] == -int32(1) { return 0 } qtypes[nq] = _afrr[i].Frr - *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280 + 3)) = uint8(0) /* don't need AD flag */ + **(**uint8)(__ccgo_up(bp + uintptr(nq)*280 + 3)) = uint8(0) /* don't need AD flag */ /* Ensure query IDs are distinct. */ - if nq != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) { - *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280)) = *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280)) + 1 + if nq != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(bp + uintptr(nq)*280))) == Int32FromUint8(**(**uint8)(__ccgo_up(bp))) { + **(**uint8)(__ccgo_up(bp + uintptr(nq)*280)) = **(**uint8)(__ccgo_up(bp + uintptr(nq)*280)) + 1 } nq = nq + 1 } @@ -122982,13 +122982,13 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if !(i < nq) { break } - if (*(*[2]int32)(unsafe.Pointer(bp + 10184)))[i] < int32(4) || Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + 560 + uintptr(i)*4800 + 3)))&int32(15) == int32(2) { + if (**(**[2]int32)(__ccgo_up(bp + 10184)))[i] < int32(4) || Int32FromUint8(**(**uint8)(__ccgo_up(bp + 560 + uintptr(i)*4800 + 3)))&int32(15) == int32(2) { return -int32(3) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + 560 + uintptr(i)*4800 + 3)))&int32(15) == int32(3) { + if Int32FromUint8(**(**uint8)(__ccgo_up(bp + 560 + uintptr(i)*4800 + 3)))&int32(15) == int32(3) { return 0 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + 560 + uintptr(i)*4800 + 3)))&int32(15) != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(bp + 560 + uintptr(i)*4800 + 3)))&int32(15) != 0 { return -int32(4) } goto _2 @@ -123001,18 +123001,18 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if !(i >= 0) { break } - (*(*Tdpc_ctx)(unsafe.Pointer(bp + 10192))).Frrtype = qtypes[i] - if Uint32FromInt32((*(*[2]int32)(unsafe.Pointer(bp + 10184)))[i]) > uint32(4800) { - (*(*[2]int32)(unsafe.Pointer(bp + 10184)))[i] = int32(4800) + (**(**Tdpc_ctx)(__ccgo_up(bp + 10192))).Frrtype = qtypes[i] + if Uint32FromInt32((**(**[2]int32)(__ccgo_up(bp + 10184)))[i]) > uint32(4800) { + (**(**[2]int32)(__ccgo_up(bp + 10184)))[i] = int32(4800) } - X__dns_parse(tls, bp+560+uintptr(i)*4800, (*(*[2]int32)(unsafe.Pointer(bp + 10184)))[i], __ccgo_fp(_dns_parse_callback1), bp+10192) + X__dns_parse(tls, bp+560+uintptr(i)*4800, (**(**[2]int32)(__ccgo_up(bp + 10184)))[i], __ccgo_fp(_dns_parse_callback1), bp+10192) goto _3 _3: ; i = i - 1 } - if (*(*Tdpc_ctx)(unsafe.Pointer(bp + 10192))).Fcnt != 0 { - return (*(*Tdpc_ctx)(unsafe.Pointer(bp + 10192))).Fcnt + if (**(**Tdpc_ctx)(__ccgo_up(bp + 10192))).Fcnt != 0 { + return (**(**Tdpc_ctx)(__ccgo_up(bp + 10192))).Fcnt } return -int32(5) } @@ -123050,10 +123050,10 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f l = v2 dots = v2 for { - if !(*(*uint8)(unsafe.Pointer(name + uintptr(l))) != 0) { + if !(**(**uint8)(__ccgo_up(name + uintptr(l))) != 0) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(name + uintptr(l)))) == int32('.') { + if Int32FromUint8(**(**uint8)(__ccgo_up(name + uintptr(l)))) == int32('.') { dots = dots + 1 } goto _1 @@ -123061,14 +123061,14 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f ; l = l + 1 } - if dots >= (*(*Tresolvconf)(unsafe.Pointer(bp + 256))).Fndots || Int32FromUint8(*(*uint8)(unsafe.Pointer(name + uintptr(l-uint32(1))))) == int32('.') { - *(*uint8)(unsafe.Pointer(bp)) = uint8(0) + if dots >= (**(**Tresolvconf)(__ccgo_up(bp + 256))).Fndots || Int32FromUint8(**(**uint8)(__ccgo_up(name + uintptr(l-uint32(1))))) == int32('.') { + **(**uint8)(__ccgo_up(bp)) = uint8(0) } /* Strip final dot for canon, fail if multiple trailing dots. */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(name + uintptr(l-uint32(1))))) == int32('.') { + if Int32FromUint8(**(**uint8)(__ccgo_up(name + uintptr(l-uint32(1))))) == int32('.') { l = l - 1 } - if !(l != 0) || Int32FromUint8(*(*uint8)(unsafe.Pointer(name + uintptr(l-uint32(1))))) == int32('.') { + if !(l != 0) || Int32FromUint8(**(**uint8)(__ccgo_up(name + uintptr(l-uint32(1))))) == int32('.') { return -int32(2) } /* This can never happen; the caller already checked length. */ @@ -123080,14 +123080,14 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f * name is not a CNAME record) and serves as a buffer for passing * the full requested name to name_from_dns. */ _memcpy(tls, canon, name, l) - *(*uint8)(unsafe.Pointer(canon + uintptr(l))) = uint8('.') + **(**uint8)(__ccgo_up(canon + uintptr(l))) = uint8('.') p = bp for { - if !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if !(**(**uint8)(__ccgo_up(p)) != 0) { break } for { - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v5 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _7 _7: @@ -123101,8 +123101,8 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f } z = p for { - if v12 = *(*uint8)(unsafe.Pointer(z)) != 0; v12 { - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(z))) + if v12 = **(**uint8)(__ccgo_up(z)) != 0; v12 { + v5 = Int32FromUint8(**(**uint8)(__ccgo_up(z))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _11 _11: @@ -123120,7 +123120,7 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f } if Uint32FromInt32(int32(z)-int32(p)) < uint32(256)-l-uint32(1) { _memcpy(tls, canon+uintptr(l)+uintptr(1), p, Uint32FromInt32(int32(z)-int32(p))) - *(*uint8)(unsafe.Pointer(canon + uintptr(Uint32FromInt32(int32(z)-int32(p)+int32(1))+l))) = uint8(0) + **(**uint8)(__ccgo_up(canon + uintptr(Uint32FromInt32(int32(z)-int32(p)+int32(1))+l))) = uint8(0) cnt = _name_from_dns(tls, buf, canon, canon, family, bp+256) if cnt != 0 { return cnt @@ -123131,7 +123131,7 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f ; p = z } - *(*uint8)(unsafe.Pointer(canon + uintptr(l))) = uint8(0) + **(**uint8)(__ccgo_up(canon + uintptr(l))) = uint8(0) return _name_from_dns(tls, buf, canon, name, family, bp+256) } @@ -123192,7 +123192,7 @@ func _policyof(tls *TLS, a uintptr) (r uintptr) { if Xmemcmp(tls, a, uintptr(unsafe.Pointer(&_defpolicy))+uintptr(i)*20, uint32(_defpolicy[i].Flen1)) != 0 { goto _1 } - if Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + uintptr(_defpolicy[i].Flen1))))&Int32FromUint8(_defpolicy[i].Fmask) != Int32FromUint8(*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_defpolicy)) + uintptr(i)*20 + uintptr(_defpolicy[i].Flen1)))) { + if Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + uintptr(_defpolicy[i].Flen1))))&Int32FromUint8(_defpolicy[i].Fmask) != Int32FromUint8(**(**uint8)(__ccgo_up(uintptr(unsafe.Pointer(&_defpolicy)) + uintptr(i)*20 + uintptr(_defpolicy[i].Flen1)))) { goto _1 } return uintptr(unsafe.Pointer(&_defpolicy)) + uintptr(i)*20 @@ -123209,16 +123209,16 @@ func _labelof(tls *TLS, a uintptr) (r int32) { } func _scopeof(tls *TLS, a uintptr) (r int32) { - if Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a))) == int32(0xff) { - return Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 1))) & int32(15) + if Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a))) == int32(0xff) { + return Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 1))) & int32(15) } - if Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a))) == int32(0xfe) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 1)))&int32(0xc0) == int32(0x80) { + if Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a))) == int32(0xfe) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 1)))&int32(0xc0) == int32(0x80) { return int32(2) } - if *(*Tuint32_t)(unsafe.Pointer(a)) == uint32(0) && *(*Tuint32_t)(unsafe.Pointer(a + 1*4)) == uint32(0) && *(*Tuint32_t)(unsafe.Pointer(a + 2*4)) == uint32(0) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 12))) == 0 && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 13))) == 0 && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 14))) == 0 && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 15))) == int32(1) { + if **(**Tuint32_t)(__ccgo_up(a)) == uint32(0) && **(**Tuint32_t)(__ccgo_up(a + 1*4)) == uint32(0) && **(**Tuint32_t)(__ccgo_up(a + 2*4)) == uint32(0) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 12))) == 0 && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 13))) == 0 && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 14))) == 0 && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 15))) == int32(1) { return int32(2) } - if Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a))) == int32(0xfe) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 1)))&int32(0xc0) == int32(0xc0) { + if Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a))) == int32(0xfe) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 1)))&int32(0xc0) == int32(0xc0) { return int32(5) } return int32(14) @@ -123229,7 +123229,7 @@ func _prefixmatch(tls *TLS, s uintptr, d uintptr) (r int32) { _ = i i = uint32(0) for { - if !(i < uint32(128) && !((Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(s + uintptr(i/uint32(8)))))^Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(d + uintptr(i/uint32(8))))))&(Int32FromInt32(128)>>(i%Uint32FromInt32(8))) != 0)) { + if !(i < uint32(128) && !((Int32FromUint8(**(**Tuint8_t)(__ccgo_up(s + uintptr(i/uint32(8)))))^Int32FromUint8(**(**Tuint8_t)(__ccgo_up(d + uintptr(i/uint32(8))))))&(Int32FromInt32(128)>>(i%Uint32FromInt32(8))) != 0)) { break } goto _1 @@ -123267,7 +123267,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i var _ /* salen at bp+92 */ Tsocklen_t _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cnt, da, dalen, dlabel, dpolicy, dprec, dscope, family1, fd, i, j, key, l, prefixlen, sa, v1 cnt = 0 - *(*uint8)(unsafe.Pointer(canon)) = uint8(0) + **(**uint8)(__ccgo_up(canon)) = uint8(0) if name != 0 { /* reject empty name and check len so it fits into temp bufs */ l = Xstrnlen(tls, name, uint32(255)) @@ -123311,7 +123311,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i /* If any v6 results exist, remove v4 results. */ i = 0 for { - if !(i < cnt && (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily != int32(PF_INET6)) { + if !(i < cnt && (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Ffamily != int32(PF_INET6)) { break } goto _2 @@ -123325,10 +123325,10 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if !(i < cnt) { break } - if (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily == int32(PF_INET6) { + if (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Ffamily == int32(PF_INET6) { v1 = j j = j + 1 - *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = *(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28)) + **(**Taddress)(__ccgo_up(buf + uintptr(v1)*28)) = **(**Taddress)(__ccgo_up(buf + uintptr(i)*28)) } goto _3 _3: @@ -123346,12 +123346,12 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if !(i < cnt) { break } - if (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily != int32(PF_INET) { + if (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Ffamily != int32(PF_INET) { goto _6 } _memcpy(tls, buf+uintptr(i)*28+8+uintptr(12), buf+uintptr(i)*28+8, uint32(4)) _memcpy(tls, buf+uintptr(i)*28+8, __ccgo_ts+942, uint32(12)) - (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily = int32(PF_INET6) + (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Ffamily = int32(PF_INET6) goto _6 _6: ; @@ -123368,7 +123368,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if !(i < cnt) { break } - if (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily != int32(PF_INET) { + if (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Ffamily != int32(PF_INET) { break } goto _7 @@ -123390,16 +123390,16 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if !(i < cnt) { break } - family1 = (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily + family1 = (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Ffamily key = 0 - *(*Tsockaddr_in6)(unsafe.Pointer(bp + 4)) = Tsockaddr_in6{} - *(*Tsockaddr_in6)(unsafe.Pointer(bp + 32)) = Tsockaddr_in6{ + **(**Tsockaddr_in6)(__ccgo_up(bp + 4)) = Tsockaddr_in6{} + **(**Tsockaddr_in6)(__ccgo_up(bp + 32)) = Tsockaddr_in6{ Fsin6_family: uint16(PF_INET6), Fsin6_port: uint16(65535), - Fsin6_scope_id: (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Fscopeid, + Fsin6_scope_id: (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Fscopeid, } - *(*Tsockaddr_in)(unsafe.Pointer(bp + 60)) = Tsockaddr_in{} - *(*Tsockaddr_in)(unsafe.Pointer(bp + 76)) = Tsockaddr_in{ + **(**Tsockaddr_in)(__ccgo_up(bp + 60)) = Tsockaddr_in{} + **(**Tsockaddr_in)(__ccgo_up(bp + 76)) = Tsockaddr_in{ Fsin_family: uint16(PF_INET), Fsin_port: uint16(65535), } @@ -123408,7 +123408,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i da = bp + 32 dalen = uint32(28) sa = bp + 4 - *(*Tsocklen_t)(unsafe.Pointer(bp + 92)) = uint32(28) + **(**Tsocklen_t)(__ccgo_up(bp + 92)) = uint32(28) } else { _memcpy(tls, bp+4+8, __ccgo_ts+942, uint32(12)) _memcpy(tls, bp+32+8+uintptr(12), buf+uintptr(i)*28+8, uint32(4)) @@ -123418,7 +123418,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i da = bp + 76 dalen = uint32(16) sa = bp + 60 - *(*Tsocklen_t)(unsafe.Pointer(bp + 92)) = uint32(16) + **(**Tsocklen_t)(__ccgo_up(bp + 92)) = uint32(16) } dpolicy = _policyof(tls, bp+32+8) dscope = _scopeof(tls, bp+32+8) @@ -123448,14 +123448,14 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i key = key | (int32(15)-dscope)< uint32(65535) { return -int32(8) } if proto != int32(IPPROTO_UDP) { - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fport = uint16(port) - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_STREAM) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fport = uint16(port) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_STREAM) v1 = cnt cnt = cnt + 1 - (*(*Tservice)(unsafe.Pointer(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_TCP) + (**(**Tservice)(__ccgo_up(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_TCP) } if proto != int32(IPPROTO_TCP) { - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fport = uint16(port) - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_DGRAM) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fport = uint16(port) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_DGRAM) v1 = cnt cnt = cnt + 1 - (*(*Tservice)(unsafe.Pointer(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_UDP) + (**(**Tservice)(__ccgo_up(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_UDP) } return cnt } @@ -123541,7 +123541,7 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i l = _strlen(tls, name) f = X__fopen_rb_ca(tls, __ccgo_ts+955, bp+1168, bp+132, uint32(1032)) if !(f != 0) { - switch *(*int32)(unsafe.Pointer(X__errno_location(tls))) { + switch **(**int32)(__ccgo_up(X__errno_location(tls))) { case int32(ENOENT): fallthrough case int32(ENOTDIR): @@ -123558,8 +123558,8 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i if v3 != 0 { v4 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8('\n') - *(*uint8)(unsafe.Pointer(p)) = Uint8FromInt32(0) + **(**uint8)(__ccgo_up(v4)) = uint8('\n') + **(**uint8)(__ccgo_up(p)) = Uint8FromInt32(0) } /* Find service name */ p = bp @@ -123570,7 +123570,7 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i break } if v10 = p > bp; v10 { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(p + uintptr(-Int32FromInt32(1))))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _9 _9: @@ -123578,8 +123578,8 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i if v10 && !(v2 != 0) { goto _5 } - if v10 = *(*uint8)(unsafe.Pointer(p + uintptr(l))) != 0; v10 { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(l)))) + if v10 = **(**uint8)(__ccgo_up(p + uintptr(l))) != 0; v10 { + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(p + uintptr(l)))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _13 _13: @@ -123599,8 +123599,8 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i /* Skip past canonical name at beginning of line */ p = bp for { - if v10 = *(*uint8)(unsafe.Pointer(p)) != 0; v10 { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + if v10 = **(**uint8)(__ccgo_up(p)) != 0; v10 { + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _18 _18: @@ -123614,28 +123614,28 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i p = p + 1 } port = Xstrtoul(tls, p, bp+128, int32(10)) - if port > uint32(65535) || *(*uintptr)(unsafe.Pointer(bp + 128)) == p { + if port > uint32(65535) || **(**uintptr)(__ccgo_up(bp + 128)) == p { continue } - if !(Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(bp + 128)), __ccgo_ts+969, uint32(4)) != 0) { + if !(Xstrncmp(tls, **(**uintptr)(__ccgo_up(bp + 128)), __ccgo_ts+969, uint32(4)) != 0) { if proto == int32(IPPROTO_TCP) { continue } - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fport = uint16(port) - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_DGRAM) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fport = uint16(port) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_DGRAM) v1 = cnt cnt = cnt + 1 - (*(*Tservice)(unsafe.Pointer(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_UDP) + (**(**Tservice)(__ccgo_up(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_UDP) } - if !(Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(bp + 128)), __ccgo_ts+974, uint32(4)) != 0) { + if !(Xstrncmp(tls, **(**uintptr)(__ccgo_up(bp + 128)), __ccgo_ts+974, uint32(4)) != 0) { if proto == int32(IPPROTO_UDP) { continue } - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fport = uint16(port) - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_STREAM) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fport = uint16(port) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_STREAM) v1 = cnt cnt = cnt + 1 - (*(*Tservice)(unsafe.Pointer(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_TCP) + (**(**Tservice)(__ccgo_up(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_TCP) } } X__fclose_ca(tls, f) @@ -123665,58 +123665,58 @@ func ___netlink_enumerate(tls *TLS, fd int32, seq uint32, type1 int32, af int32, (*(*struct { Fnlh Tnlmsghdr Fg Trtgenmsg - })(unsafe.Pointer(&*(*struct { + })(unsafe.Pointer(&**(**struct { Freq [0]struct { Fnlh Tnlmsghdr Fg Trtgenmsg } Freply [0]Tnlmsghdr Fbuf [8192]Tuint8_t - })(unsafe.Pointer(bp))))).Fnlh.Fnlmsg_len = uint32(20) + })(__ccgo_up(bp))))).Fnlh.Fnlmsg_len = uint32(20) (*(*struct { Fnlh Tnlmsghdr Fg Trtgenmsg - })(unsafe.Pointer(&*(*struct { + })(unsafe.Pointer(&**(**struct { Freq [0]struct { Fnlh Tnlmsghdr Fg Trtgenmsg } Freply [0]Tnlmsghdr Fbuf [8192]Tuint8_t - })(unsafe.Pointer(bp))))).Fnlh.Fnlmsg_type = Uint16FromInt32(type1) + })(__ccgo_up(bp))))).Fnlh.Fnlmsg_type = Uint16FromInt32(type1) (*(*struct { Fnlh Tnlmsghdr Fg Trtgenmsg - })(unsafe.Pointer(&*(*struct { + })(unsafe.Pointer(&**(**struct { Freq [0]struct { Fnlh Tnlmsghdr Fg Trtgenmsg } Freply [0]Tnlmsghdr Fbuf [8192]Tuint8_t - })(unsafe.Pointer(bp))))).Fnlh.Fnlmsg_flags = Uint16FromInt32(Int32FromInt32(NLM_F_ROOT) | Int32FromInt32(NLM_F_MATCH) | Int32FromInt32(NLM_F_REQUEST)) + })(__ccgo_up(bp))))).Fnlh.Fnlmsg_flags = Uint16FromInt32(Int32FromInt32(NLM_F_ROOT) | Int32FromInt32(NLM_F_MATCH) | Int32FromInt32(NLM_F_REQUEST)) (*(*struct { Fnlh Tnlmsghdr Fg Trtgenmsg - })(unsafe.Pointer(&*(*struct { + })(unsafe.Pointer(&**(**struct { Freq [0]struct { Fnlh Tnlmsghdr Fg Trtgenmsg } Freply [0]Tnlmsghdr Fbuf [8192]Tuint8_t - })(unsafe.Pointer(bp))))).Fnlh.Fnlmsg_seq = seq + })(__ccgo_up(bp))))).Fnlh.Fnlmsg_seq = seq (*(*struct { Fnlh Tnlmsghdr Fg Trtgenmsg - })(unsafe.Pointer(&*(*struct { + })(unsafe.Pointer(&**(**struct { Freq [0]struct { Fnlh Tnlmsghdr Fg Trtgenmsg } Freply [0]Tnlmsghdr Fbuf [8192]Tuint8_t - })(unsafe.Pointer(bp))))).Fg.Frtgen_family = Uint8FromInt32(af) + })(__ccgo_up(bp))))).Fg.Frtgen_family = Uint8FromInt32(af) r = Xsend(tls, fd, bp, uint32(20), 0) if r < 0 { return r @@ -123792,7 +123792,7 @@ func Xns_get16(tls *TLS, cp uintptr) (r uint32) { trc("tls=%v cp=%v, (%v:)", tls, cp, origin(2)) defer func() { trc("-> %v", r) }() } - return Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(cp)))< %v", r) }() } - return uint32(uint32(*(*uint8)(unsafe.Pointer(cp)))<> int32(8)) + **(**uint8)(__ccgo_up(v1)) = uint8(s >> int32(8)) v1 = cp cp = cp + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(s) + **(**uint8)(__ccgo_up(v1)) = uint8(s) } func Xns_put32(tls *TLS, l uint32, cp uintptr) { @@ -123825,16 +123825,16 @@ func Xns_put32(tls *TLS, l uint32, cp uintptr) { _ = v1 v1 = cp cp = cp + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(l >> int32(24)) + **(**uint8)(__ccgo_up(v1)) = uint8(l >> int32(24)) v1 = cp cp = cp + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(l >> int32(16)) + **(**uint8)(__ccgo_up(v1)) = uint8(l >> int32(16)) v1 = cp cp = cp + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(l >> int32(8)) + **(**uint8)(__ccgo_up(v1)) = uint8(l >> int32(8)) v1 = cp cp = cp + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(l) + **(**uint8)(__ccgo_up(v1)) = uint8(l) } func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int32) { @@ -123859,7 +123859,7 @@ func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int3 break } msg = msg + uintptr(2) - *(*Tuint16_t)(unsafe.Pointer(handle + 12 + uintptr(i)*2)) = uint16(Xns_get16(tls, msg-uintptr(2))) + **(**Tuint16_t)(__ccgo_up(handle + 12 + uintptr(i)*2)) = uint16(Xns_get16(tls, msg-uintptr(2))) goto _1 _1: ; @@ -123870,15 +123870,15 @@ func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int3 if !(i < int32(_ns_s_max)) { break } - if *(*Tuint16_t)(unsafe.Pointer(handle + 12 + uintptr(i)*2)) != 0 { - *(*uintptr)(unsafe.Pointer(handle + 20 + uintptr(i)*4)) = msg - r = Xns_skiprr(tls, msg, (*Tns_msg)(unsafe.Pointer(handle)).F_eom, i, Int32FromUint16(*(*Tuint16_t)(unsafe.Pointer(handle + 12 + uintptr(i)*2)))) + if **(**Tuint16_t)(__ccgo_up(handle + 12 + uintptr(i)*2)) != 0 { + **(**uintptr)(__ccgo_up(handle + 20 + uintptr(i)*4)) = msg + r = Xns_skiprr(tls, msg, (*Tns_msg)(unsafe.Pointer(handle)).F_eom, i, Int32FromUint16(**(**Tuint16_t)(__ccgo_up(handle + 12 + uintptr(i)*2)))) if r < 0 { return -int32(1) } msg = msg + uintptr(r) } else { - *(*uintptr)(unsafe.Pointer(handle + 20 + uintptr(i)*4)) = UintptrFromInt32(0) + **(**uintptr)(__ccgo_up(handle + 20 + uintptr(i)*4)) = UintptrFromInt32(0) } goto _2 _2: @@ -123895,7 +123895,7 @@ func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int3 goto bad bad: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EMSGSIZE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EMSGSIZE) return -int32(1) } @@ -123939,7 +123939,7 @@ func Xns_skiprr(tls *TLS, ptr uintptr, eom uintptr, section Tns_sect, count int3 goto bad bad: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EMSGSIZE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EMSGSIZE) return -int32(1) } @@ -123957,31 +123957,31 @@ func Xns_parserr(tls *TLS, handle uintptr, section Tns_sect, rrnum int32, rr uin if section != (*Tns_msg)(unsafe.Pointer(handle)).F_sect { (*Tns_msg)(unsafe.Pointer(handle)).F_sect = section (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum = 0 - (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr = *(*uintptr)(unsafe.Pointer(handle + 20 + uintptr(section)*4)) + (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr = **(**uintptr)(__ccgo_up(handle + 20 + uintptr(section)*4)) } if rrnum == -int32(1) { rrnum = (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum } - if rrnum < 0 || rrnum >= Int32FromUint16(*(*Tuint16_t)(unsafe.Pointer(handle + 12 + uintptr(section)*2))) { + if rrnum < 0 || rrnum >= Int32FromUint16(**(**Tuint16_t)(__ccgo_up(handle + 12 + uintptr(section)*2))) { goto bad } if rrnum < (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum { (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum = 0 - (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr = *(*uintptr)(unsafe.Pointer(handle + 20 + uintptr(section)*4)) + (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr = **(**uintptr)(__ccgo_up(handle + 20 + uintptr(section)*4)) } if rrnum > (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum { r = Xns_skiprr(tls, (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr, (*Tns_msg)(unsafe.Pointer(handle)).F_eom, section, rrnum-(*Tns_msg)(unsafe.Pointer(handle)).F_rrnum) if r < 0 { return -int32(1) } - *(*uintptr)(unsafe.Pointer(handle + 44)) += uintptr(r) + **(**uintptr)(__ccgo_up(handle + 44)) += uintptr(r) (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum = rrnum } r = Xns_name_uncompress(tls, (*Tns_msg)(unsafe.Pointer(handle)).F_msg, (*Tns_msg)(unsafe.Pointer(handle)).F_eom, (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr, rr, uint32(NS_MAXDNAME)) if r < 0 { return -int32(1) } - *(*uintptr)(unsafe.Pointer(handle + 44)) += uintptr(r) + **(**uintptr)(__ccgo_up(handle + 44)) += uintptr(r) if Int32FromInt32(2)*Int32FromInt32(NS_INT16SZ) > int32((*Tns_msg)(unsafe.Pointer(handle)).F_eom)-int32((*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr) { goto size } @@ -124005,14 +124005,14 @@ func Xns_parserr(tls *TLS, handle uintptr, section Tns_sect, rrnum int32, rr uin goto size } (*Tns_rr)(unsafe.Pointer(rr)).Frdata = (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr - *(*uintptr)(unsafe.Pointer(handle + 44)) += uintptr((*Tns_rr)(unsafe.Pointer(rr)).Frdlength) + **(**uintptr)(__ccgo_up(handle + 44)) += uintptr((*Tns_rr)(unsafe.Pointer(rr)).Frdlength) } else { (*Tns_rr)(unsafe.Pointer(rr)).Fttl = uint32(0) (*Tns_rr)(unsafe.Pointer(rr)).Frdlength = uint16(0) (*Tns_rr)(unsafe.Pointer(rr)).Frdata = UintptrFromInt32(0) } (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum = (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum + 1 - if (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum > Int32FromUint16(*(*Tuint16_t)(unsafe.Pointer(handle + 12 + uintptr(section)*2))) { + if (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum > Int32FromUint16(**(**Tuint16_t)(__ccgo_up(handle + 12 + uintptr(section)*2))) { (*Tns_msg)(unsafe.Pointer(handle)).F_sect = section + int32(1) if (*Tns_msg)(unsafe.Pointer(handle)).F_sect == int32(_ns_s_max) { (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum = -int32(1) @@ -124025,12 +124025,12 @@ func Xns_parserr(tls *TLS, handle uintptr, section Tns_sect, rrnum int32, rr uin goto bad bad: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENODEV) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENODEV) return -int32(1) goto size size: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EMSGSIZE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EMSGSIZE) return -int32(1) } @@ -124043,7 +124043,7 @@ func Xns_name_uncompress(tls *TLS, msg uintptr, eom uintptr, src uintptr, dst ui _ = r r = Xdn_expand(tls, msg, eom, src, dst, Int32FromUint32(dstsiz)) if r < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EMSGSIZE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EMSGSIZE) } return r } @@ -124259,7 +124259,7 @@ func Xrecvmmsg(tls *TLS, fd int32, msgvec uintptr, vlen uint32, flags uint32, ti if !(Uint32FromInt32(i) < vlen) { break } - *(*Tsocklen_t)(unsafe.Add(unsafe.Pointer(csize), i*4)) = (*(*Tmmsghdr)(unsafe.Pointer(msgvec + uintptr(i)*32))).Fmsg_hdr.Fmsg_controllen + *(*Tsocklen_t)(unsafe.Add(unsafe.Pointer(csize), i*4)) = (**(**Tmmsghdr)(__ccgo_up(msgvec + uintptr(i)*32))).Fmsg_hdr.Fmsg_controllen goto _5 _5: ; @@ -124345,9 +124345,9 @@ func X__convert_scm_timestamps(tls *TLS, msg uintptr, csize Tsocklen_t) { common: ; _memcpy(tls, bp, cmsg+UintptrFromInt32(1)*12, uint32(4)) - (*(*[2]int64)(unsafe.Pointer(bp + 8)))[0] = int64(*(*int32)(unsafe.Pointer(bp))) + (**(**[2]int64)(__ccgo_up(bp + 8)))[0] = int64(**(**int32)(__ccgo_up(bp))) _memcpy(tls, bp, cmsg+UintptrFromInt32(1)*12+uintptr(4), uint32(4)) - (*(*[2]int64)(unsafe.Pointer(bp + 8)))[int32(1)] = int64(*(*int32)(unsafe.Pointer(bp))) + (**(**[2]int64)(__ccgo_up(bp + 8)))[int32(1)] = int64(**(**int32)(__ccgo_up(bp))) goto _5 _5: } @@ -124366,10 +124366,10 @@ func X__convert_scm_timestamps(tls *TLS, msg uintptr, csize Tsocklen_t) { return } if (Uint32FromInt64(16)+Uint32FromInt64(4)-Uint32FromInt32(1)) & ^(Uint32FromInt64(4)-Uint32FromInt32(1)) + (Uint32FromInt64(12)+Uint32FromInt64(4)-Uint32FromInt32(1)) & ^(Uint32FromInt64(4)-Uint32FromInt32(1)) > csize-(*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_controllen { - *(*int32)(unsafe.Pointer(msg + 24)) |= int32(MSG_CTRUNC) + **(**int32)(__ccgo_up(msg + 24)) |= int32(MSG_CTRUNC) return } - *(*Tsocklen_t)(unsafe.Pointer(msg + 20)) += (Uint32FromInt64(16)+Uint32FromInt64(4)-Uint32FromInt32(1)) & ^(Uint32FromInt64(4)-Uint32FromInt32(1)) + (Uint32FromInt64(12)+Uint32FromInt64(4)-Uint32FromInt32(1)) & ^(Uint32FromInt64(4)-Uint32FromInt32(1)) + **(**Tsocklen_t)(__ccgo_up(msg + 20)) += (Uint32FromInt64(16)+Uint32FromInt64(4)-Uint32FromInt32(1)) & ^(Uint32FromInt64(4)-Uint32FromInt32(1)) + (Uint32FromInt64(12)+Uint32FromInt64(4)-Uint32FromInt32(1)) & ^(Uint32FromInt64(4)-Uint32FromInt32(1)) if (*Tcmsghdr)(unsafe.Pointer(last)).Fcmsg_len < uint32(12) || uint32((*Tcmsghdr)(unsafe.Pointer(last)).Fcmsg_len+Uint32FromInt64(4)-Uint32FromInt32(1))&Uint32FromInt32(^Int32FromUint32(Uint32FromInt64(4)-Uint32FromInt32(1)))+uint32(12) >= Uint32FromInt32(int32((*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_control+uintptr((*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_controllen))-int32(last)) { v2 = uintptr(0) } else { @@ -124441,10 +124441,10 @@ func X__res_mkquery(tls *TLS, op int32, dname uintptr, class int32, type1 int32, var _ /* ts at bp+280 */ Ttimespec _, _, _, _, _ = i, id, j, l, n l = Xstrnlen(tls, dname, uint32(255)) - if l != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(dname + uintptr(l-uint32(1))))) == int32('.') { + if l != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(dname + uintptr(l-uint32(1))))) == int32('.') { l = l - 1 } - if l != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(dname + uintptr(l-uint32(1))))) == int32('.') { + if l != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(dname + uintptr(l-uint32(1))))) == int32('.') { return -int32(1) } n = Int32FromUint32(uint32(17) + l + BoolUint32(!!(l != 0))) @@ -124453,18 +124453,18 @@ func X__res_mkquery(tls *TLS, op int32, dname uintptr, class int32, type1 int32, } /* Construct query template - ID will be filled later */ Xmemset(tls, bp, 0, Uint32FromInt32(n)) - (*(*[280]uint8)(unsafe.Pointer(bp)))[int32(2)] = Uint8FromInt32(op*int32(8) + int32(1)) - (*(*[280]uint8)(unsafe.Pointer(bp)))[int32(3)] = uint8(32) /* AD */ - (*(*[280]uint8)(unsafe.Pointer(bp)))[int32(5)] = uint8(1) + (**(**[280]uint8)(__ccgo_up(bp)))[int32(2)] = Uint8FromInt32(op*int32(8) + int32(1)) + (**(**[280]uint8)(__ccgo_up(bp)))[int32(3)] = uint8(32) /* AD */ + (**(**[280]uint8)(__ccgo_up(bp)))[int32(5)] = uint8(1) _memcpy(tls, bp+uintptr(13), dname, l) i = int32(13) for { - if !((*(*[280]uint8)(unsafe.Pointer(bp)))[i] != 0) { + if !((**(**[280]uint8)(__ccgo_up(bp)))[i] != 0) { break } j = i for { - if !((*(*[280]uint8)(unsafe.Pointer(bp)))[j] != 0 && Int32FromUint8((*(*[280]uint8)(unsafe.Pointer(bp)))[j]) != int32('.')) { + if !((**(**[280]uint8)(__ccgo_up(bp)))[j] != 0 && Int32FromUint8((**(**[280]uint8)(__ccgo_up(bp)))[j]) != int32('.')) { break } goto _2 @@ -124475,19 +124475,19 @@ func X__res_mkquery(tls *TLS, op int32, dname uintptr, class int32, type1 int32, if Uint32FromInt32(j-i)-uint32(1) > uint32(62) { return -int32(1) } - (*(*[280]uint8)(unsafe.Pointer(bp)))[i-int32(1)] = Uint8FromInt32(j - i) + (**(**[280]uint8)(__ccgo_up(bp)))[i-int32(1)] = Uint8FromInt32(j - i) goto _1 _1: ; i = j + int32(1) } - (*(*[280]uint8)(unsafe.Pointer(bp)))[i+int32(1)] = Uint8FromInt32(type1) - (*(*[280]uint8)(unsafe.Pointer(bp)))[i+int32(3)] = Uint8FromInt32(class) + (**(**[280]uint8)(__ccgo_up(bp)))[i+int32(1)] = Uint8FromInt32(type1) + (**(**[280]uint8)(__ccgo_up(bp)))[i+int32(3)] = Uint8FromInt32(class) /* Make a reasonably unpredictable id */ Xclock_gettime(tls, CLOCK_REALTIME, bp+280) - id = Int32FromUint32((Uint32FromInt32((*(*Ttimespec)(unsafe.Pointer(bp + 280))).Ftv_nsec) + Uint32FromInt32((*(*Ttimespec)(unsafe.Pointer(bp + 280))).Ftv_nsec)/uint32(65536)) & uint32(0xffff)) - (*(*[280]uint8)(unsafe.Pointer(bp)))[0] = Uint8FromInt32(id / int32(256)) - (*(*[280]uint8)(unsafe.Pointer(bp)))[int32(1)] = Uint8FromInt32(id) + id = Int32FromUint32((Uint32FromInt32((**(**Ttimespec)(__ccgo_up(bp + 280))).Ftv_nsec) + Uint32FromInt32((**(**Ttimespec)(__ccgo_up(bp + 280))).Ftv_nsec)/uint32(65536)) & uint32(0xffff)) + (**(**[280]uint8)(__ccgo_up(bp)))[0] = Uint8FromInt32(id / int32(256)) + (**(**[280]uint8)(__ccgo_up(bp)))[int32(1)] = Uint8FromInt32(id) _memcpy(tls, buf, bp, Uint32FromInt32(n)) return n } @@ -124604,11 +124604,11 @@ func _cleanup(tls *TLS, p uintptr) { pfd = p i = 0 for { - if !((*(*Tpollfd)(unsafe.Pointer(pfd + uintptr(i)*8))).Ffd >= -int32(1)) { + if !((**(**Tpollfd)(__ccgo_up(pfd + uintptr(i)*8))).Ffd >= -int32(1)) { break } - if (*(*Tpollfd)(unsafe.Pointer(pfd + uintptr(i)*8))).Ffd >= 0 { - X__syscall1(tls, int32(SYS_close), (*(*Tpollfd)(unsafe.Pointer(pfd + uintptr(i)*8))).Ffd) + if (**(**Tpollfd)(__ccgo_up(pfd + uintptr(i)*8))).Ffd >= 0 { + X__syscall1(tls, int32(SYS_close), int32((**(**Tpollfd)(__ccgo_up(pfd + uintptr(i)*8))).Ffd)) } goto _1 _1: @@ -124621,10 +124621,10 @@ func _mtime(tls *TLS) (r uint32) { bp := tls.Alloc(16) defer tls.Free(16) var _ /* ts at bp+0 */ Ttimespec - if Xclock_gettime(tls, int32(CLOCK_MONOTONIC), bp) < 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENOSYS) { + if Xclock_gettime(tls, int32(CLOCK_MONOTONIC), bp) < 0 && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENOSYS) { Xclock_gettime(tls, CLOCK_REALTIME, bp) } - return Uint32FromInt64((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec)*uint32(1000) + Uint32FromInt32((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_nsec/int32(1000000)) + return Uint32FromInt64((**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec)*uint32(1000) + Uint32FromInt32((**(**Ttimespec)(__ccgo_up(bp))).Ftv_nsec/int32(1000000)) } func _start_tcp(tls *TLS, pfd uintptr, family int32, sa uintptr, sl Tsocklen_t, q uintptr, ql int32) (r1 int32) { @@ -124647,7 +124647,7 @@ func _start_tcp(tls *TLS, pfd uintptr, family int32, sa uintptr, sl Tsocklen_t, Fiov_len: Uint32FromInt32(ql), }, } - *(*Tmsghdr)(unsafe.Pointer(bp + 24)) = Tmsghdr{ + **(**Tmsghdr)(__ccgo_up(bp + 24)) = Tmsghdr{ Fmsg_name: sa, Fmsg_namelen: sl, Fmsg_iov: bp, @@ -124665,12 +124665,12 @@ func _start_tcp(tls *TLS, pfd uintptr, family int32, sa uintptr, sl Tsocklen_t, if r >= 0 { return r } - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EINPROGRESS) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EINPROGRESS) { return 0 } } r = Xconnect(tls, fd, sa, sl) - if !(r != 0) || *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EINPROGRESS) { + if !(r != 0) || **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EINPROGRESS) { return 0 } Xclose(tls, fd) @@ -124689,7 +124689,7 @@ func _step_mh(tls *TLS, mh uintptr, n Tsize_t) { return } (*Tiovec)(unsafe.Pointer((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov)).Fiov_base = (*Tiovec)(unsafe.Pointer((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov)).Fiov_base + uintptr(n) - *(*Tsize_t)(unsafe.Pointer((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov + 4)) -= n + **(**Tsize_t)(__ccgo_up((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov + 4)) -= n } /* Internal contract for __res_msend[_rc]: asize must be >=512, nqueries @@ -124741,11 +124741,11 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a F__ccgo_pad2 [12]byte }{} *(*uint16)(unsafe.Pointer(bp + 48)) = uint16(0) - *(*[3]struct { + **(**[3]struct { Fsin6 [0]Tsockaddr_in6 Fsin Tsockaddr_in F__ccgo_pad2 [12]byte - })(unsafe.Pointer(bp + 76)) = [3]struct { + })(__ccgo_up(bp + 76)) = [3]struct { Fsin6 [0]Tsockaddr_in6 Fsin Tsockaddr_in F__ccgo_pad2 [12]byte @@ -124772,16 +124772,16 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a iplit = conf + uintptr(nns)*28 if (*Taddress)(unsafe.Pointer(iplit)).Ffamily == int32(PF_INET) { _memcpy(tls, bp+76+uintptr(nns)*28+4, iplit+8, uint32(4)) - (*(*[3]struct { + (**(**[3]struct { Fsin6 [0]Tsockaddr_in6 Fsin Tsockaddr_in F__ccgo_pad2 [12]byte - })(unsafe.Pointer(bp + 76)))[nns].Fsin.Fsin_port = Xhtons(tls, uint16(53)) - (*(*[3]struct { + })(__ccgo_up(bp + 76)))[nns].Fsin.Fsin_port = Xhtons(tls, uint16(53)) + (**(**[3]struct { Fsin6 [0]Tsockaddr_in6 Fsin Tsockaddr_in F__ccgo_pad2 [12]byte - })(unsafe.Pointer(bp + 76)))[nns].Fsin.Fsin_family = uint16(PF_INET) + })(__ccgo_up(bp + 76)))[nns].Fsin.Fsin_family = uint16(PF_INET) } else { sl = uint32(28) _memcpy(tls, bp+76+uintptr(nns)*28+8, iplit+8, uint32(16)) @@ -124799,10 +124799,10 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a /* Get local address and open/bind a socket */ fd = Xsocket(tls, family, Int32FromInt32(SOCK_DGRAM)|Int32FromInt32(SOCK_CLOEXEC)|Int32FromInt32(SOCK_NONBLOCK), 0) /* Handle case where system lacks IPv6 support */ - if fd < 0 && family == int32(PF_INET6) && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EAFNOSUPPORT) { + if fd < 0 && family == int32(PF_INET6) && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EAFNOSUPPORT) { i = 0 for { - if !(i < nns && (*(*Taddress)(unsafe.Pointer(conf + uintptr(nns)*28))).Ffamily == int32(PF_INET6)) { + if !(i < nns && (**(**Taddress)(__ccgo_up(conf + uintptr(nns)*28))).Ffamily == int32(PF_INET6)) { break } goto _7 @@ -124811,7 +124811,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a i = i + 1 } if i == nns { - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 160)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 160)), uintptr(0)) return -int32(1) } fd = Xsocket(tls, int32(PF_INET), Int32FromInt32(SOCK_DGRAM)|Int32FromInt32(SOCK_CLOEXEC)|Int32FromInt32(SOCK_NONBLOCK), 0) @@ -124827,11 +124827,11 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a if !(i < nns) { break } - if Int32FromUint16((*(*[3]struct { + if Int32FromUint16((**(**[3]struct { Fsin6 [0]Tsockaddr_in6 Fsin Tsockaddr_in F__ccgo_pad2 [12]byte - })(unsafe.Pointer(bp + 76)))[i].Fsin.Fsin_family) != int32(PF_INET) { + })(__ccgo_up(bp + 76)))[i].Fsin.Fsin_family) != int32(PF_INET) { goto _8 } _memcpy(tls, bp+76+uintptr(i)*28+8+uintptr(12), bp+76+uintptr(i)*28+4, uint32(4)) @@ -124845,16 +124845,16 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a i = i + 1 } } - (*(*struct { + (**(**struct { Fsin6 [0]Tsockaddr_in6 Fsin Tsockaddr_in F__ccgo_pad2 [12]byte - })(unsafe.Pointer(bp + 48))).Fsin.Fsin_family = Uint16FromInt32(family) + })(__ccgo_up(bp + 48))).Fsin.Fsin_family = Uint16FromInt32(family) if fd < 0 || Xbind(tls, fd, bp+48, sl) < 0 { if fd >= 0 { Xclose(tls, fd) } - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 160)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 160)), uintptr(0)) return -int32(1) } /* Past this point, there are no errors. Each individual query will @@ -124875,7 +124875,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), nqueries*8))).Fevents = int16(POLLIN) (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), (nqueries+int32(1))*8))).Ffd = -int32(2) __pthread_cleanup_push(tls, bp+164, __ccgo_fp(_cleanup), pfd) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 160)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 160)), uintptr(0)) Xmemset(tls, alens, 0, uint32(4)*Uint32FromInt32(nqueries)) retry_interval = timeout / attempts next = 0 @@ -124891,7 +124891,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a * have an accepted answer. */ i = 0 for { - if !(i < nqueries && *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) > 0) { + if !(i < nqueries && **(**int32)(__ccgo_up(alens + uintptr(i)*4)) > 0) { break } goto _12 @@ -124909,13 +124909,13 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a if !(i < nqueries) { break } - if !(*(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) != 0) { + if !(**(**int32)(__ccgo_up(alens + uintptr(i)*4)) != 0) { j = 0 for { if !(j < nns) { break } - Xsendto(tls, fd, *(*uintptr)(unsafe.Pointer(queries + uintptr(i)*4)), Uint32FromInt32(*(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))), int32(MSG_NOSIGNAL), bp+76+uintptr(j)*28, sl) + Xsendto(tls, fd, **(**uintptr)(__ccgo_up(queries + uintptr(i)*4)), Uint32FromInt32(**(**int32)(__ccgo_up(qlens + uintptr(i)*4))), int32(MSG_NOSIGNAL), bp+76+uintptr(j)*28, sl) goto _14 _14: ; @@ -124937,11 +124937,11 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a for next < nqueries { *(*[1]Tiovec)(unsafe.Pointer(bp + 8)) = [1]Tiovec{ 0: { - Fiov_base: *(*uintptr)(unsafe.Pointer(answers + uintptr(next)*4)), + Fiov_base: **(**uintptr)(__ccgo_up(answers + uintptr(next)*4)), Fiov_len: Uint32FromInt32(asize), }, } - *(*Tmsghdr)(unsafe.Pointer(bp + 176)) = Tmsghdr{ + **(**Tmsghdr)(__ccgo_up(bp + 176)) = Tmsghdr{ Fmsg_name: bp + 48, Fmsg_namelen: sl, Fmsg_iov: bp + 8, @@ -124972,7 +124972,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a /* Find which query this answer goes with, if any */ i = next for { - if !(i < nqueries && (Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(answers + uintptr(next)*4))))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(queries + uintptr(i)*4))))) || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(answers + uintptr(next)*4)) + 1))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(queries + uintptr(i)*4)) + 1))))) { + if !(i < nqueries && (Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(answers + uintptr(next)*4))))) != Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(queries + uintptr(i)*4))))) || Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(answers + uintptr(next)*4)) + 1))) != Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(queries + uintptr(i)*4)) + 1))))) { break } goto _16 @@ -124983,13 +124983,13 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a if i == nqueries { continue } - if *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) != 0 { + if **(**int32)(__ccgo_up(alens + uintptr(i)*4)) != 0 { continue } /* Only accept positive or negative responses; * retry immediately on server failure, and ignore * all other codes such as refusal. */ - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(answers + uintptr(next)*4)) + 3))) & Int32FromInt32(15) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(answers + uintptr(next)*4)) + 3))) & Int32FromInt32(15) { case 0: fallthrough case int32(3): @@ -124999,7 +124999,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a servfail_retry = servfail_retry - 1 } if v18 && v6 != 0 { - Xsendto(tls, fd, *(*uintptr)(unsafe.Pointer(queries + uintptr(i)*4)), Uint32FromInt32(*(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))), int32(MSG_NOSIGNAL), bp+76+uintptr(j)*28, sl) + Xsendto(tls, fd, **(**uintptr)(__ccgo_up(queries + uintptr(i)*4)), Uint32FromInt32(**(**int32)(__ccgo_up(qlens + uintptr(i)*4))), int32(MSG_NOSIGNAL), bp+76+uintptr(j)*28, sl) } fallthrough default: @@ -125007,10 +125007,10 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a } /* Store answer in the right slot, or update next * available temp slot if it's already in place. */ - *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) = rlen + **(**int32)(__ccgo_up(alens + uintptr(i)*4)) = rlen if i == next { for { - if !(next < nqueries && *(*int32)(unsafe.Pointer(alens + uintptr(next)*4)) != 0) { + if !(next < nqueries && **(**int32)(__ccgo_up(alens + uintptr(next)*4)) != 0) { break } goto _19 @@ -125019,18 +125019,18 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a next = next + 1 } } else { - _memcpy(tls, *(*uintptr)(unsafe.Pointer(answers + uintptr(i)*4)), *(*uintptr)(unsafe.Pointer(answers + uintptr(next)*4)), Uint32FromInt32(rlen)) + _memcpy(tls, **(**uintptr)(__ccgo_up(answers + uintptr(i)*4)), **(**uintptr)(__ccgo_up(answers + uintptr(next)*4)), Uint32FromInt32(rlen)) } /* Ignore further UDP if all slots full or TCP-mode */ if next == nqueries { (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), nqueries*8))).Fevents = 0 } /* If answer is truncated (TC bit), fallback to TCP */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(answers + uintptr(i)*4)) + 2)))&int32(2) != 0 || (*(*Tmsghdr)(unsafe.Pointer(bp + 176))).Fmsg_flags&int32(MSG_TRUNC) != 0 { - *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) = -int32(1) + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(answers + uintptr(i)*4)) + 2)))&int32(2) != 0 || (**(**Tmsghdr)(__ccgo_up(bp + 176))).Fmsg_flags&int32(MSG_TRUNC) != 0 { + **(**int32)(__ccgo_up(alens + uintptr(i)*4)) = -int32(1) _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), uintptr(0)) - r = _start_tcp(tls, pfd+uintptr(i)*8, family, bp+76+uintptr(j)*28, sl, *(*uintptr)(unsafe.Pointer(queries + uintptr(i)*4)), *(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 160)), uintptr(0)) + r = _start_tcp(tls, pfd+uintptr(i)*8, family, bp+76+uintptr(j)*28, sl, **(**uintptr)(__ccgo_up(queries + uintptr(i)*4)), **(**int32)(__ccgo_up(qlens + uintptr(i)*4))) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 160)), uintptr(0)) if r >= 0 { *(*int32)(unsafe.Add(unsafe.Pointer(qpos), i*4)) = r *(*int32)(unsafe.Add(unsafe.Pointer(apos), i*4)) = 0 @@ -125045,8 +125045,8 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a } if int32((*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), i*8))).Frevents)&int32(POLLOUT) != 0 { *(*[2]Tuint8_t)(unsafe.Pointer(bp + 28)) = [2]Tuint8_t{ - 0: Uint8FromInt32(*(*int32)(unsafe.Pointer(qlens + uintptr(i)*4)) >> int32(8)), - 1: Uint8FromInt32(*(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))), + 0: Uint8FromInt32(**(**int32)(__ccgo_up(qlens + uintptr(i)*4)) >> int32(8)), + 1: Uint8FromInt32(**(**int32)(__ccgo_up(qlens + uintptr(i)*4))), } *(*[2]Tiovec)(unsafe.Pointer(bp + 12)) = [2]Tiovec{ 0: { @@ -125054,11 +125054,11 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a Fiov_len: uint32(2), }, 1: { - Fiov_base: *(*uintptr)(unsafe.Pointer(queries + uintptr(i)*4)), - Fiov_len: Uint32FromInt32(*(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))), + Fiov_base: **(**uintptr)(__ccgo_up(queries + uintptr(i)*4)), + Fiov_len: Uint32FromInt32(**(**int32)(__ccgo_up(qlens + uintptr(i)*4))), }, } - *(*Tmsghdr)(unsafe.Pointer(bp + 204)) = Tmsghdr{ + **(**Tmsghdr)(__ccgo_up(bp + 204)) = Tmsghdr{ Fmsg_iov: bp + 12, Fmsg_iovlen: int32(2), } @@ -125067,8 +125067,8 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a if r < 0 { goto out } - *(*int32)(unsafe.Pointer(qpos + uintptr(i)*4)) += r - if *(*int32)(unsafe.Add(unsafe.Pointer(qpos), i*4)) == *(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))+int32(2) { + **(**int32)(__ccgo_up(qpos + uintptr(i)*4)) += r + if *(*int32)(unsafe.Add(unsafe.Pointer(qpos), i*4)) == **(**int32)(__ccgo_up(qlens + uintptr(i)*4))+int32(2) { (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), i*8))).Fevents = int16(POLLIN) } } @@ -125089,11 +125089,11 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a Fiov_len: uint32(2), }, 1: { - Fiov_base: *(*uintptr)(unsafe.Pointer(answers + uintptr(i)*4)), + Fiov_base: **(**uintptr)(__ccgo_up(answers + uintptr(i)*4)), Fiov_len: Uint32FromInt32(asize), }, } - *(*Tmsghdr)(unsafe.Pointer(bp + 232)) = Tmsghdr{ + **(**Tmsghdr)(__ccgo_up(bp + 232)) = Tmsghdr{ Fmsg_iov: bp + 32, Fmsg_iovlen: int32(2), } @@ -125102,25 +125102,25 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a if r <= 0 { goto out } - *(*int32)(unsafe.Pointer(apos + uintptr(i)*4)) += r + **(**int32)(__ccgo_up(apos + uintptr(i)*4)) += r if *(*int32)(unsafe.Add(unsafe.Pointer(apos), i*4)) < int32(2) { goto _21 } - alen = Int32FromUint8(*(*uint8)(unsafe.Pointer(alen_buf + uintptr(i)*2)))*int32(256) + Int32FromUint8(*(*uint8)(unsafe.Pointer(alen_buf + uintptr(i)*2 + 1))) + alen = Int32FromUint8(**(**uint8)(__ccgo_up(alen_buf + uintptr(i)*2)))*int32(256) + Int32FromUint8(**(**uint8)(__ccgo_up(alen_buf + uintptr(i)*2 + 1))) if alen < int32(13) { goto out } if *(*int32)(unsafe.Add(unsafe.Pointer(apos), i*4)) < alen+int32(2) && *(*int32)(unsafe.Add(unsafe.Pointer(apos), i*4)) < asize+int32(2) { goto _21 } - rcode = Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(answers + uintptr(i)*4)) + 3))) & int32(15) + rcode = Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(answers + uintptr(i)*4)) + 3))) & int32(15) if rcode != 0 && rcode != int32(3) { goto out } /* Storing the length here commits the accepted answer. * Immediately close TCP socket so as not to consume * resources we no longer need. */ - *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) = alen + **(**int32)(__ccgo_up(alens + uintptr(i)*4)) = alen X__syscall1(tls, int32(SYS_close), (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), i*8))).Ffd) (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), i*8))).Ffd = -int32(1) } @@ -125144,8 +125144,8 @@ out: if !(i < nqueries) { break } - if *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) < 0 { - *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) = 0 + if **(**int32)(__ccgo_up(alens + uintptr(i)*4)) < 0 { + **(**int32)(__ccgo_up(alens + uintptr(i)*4)) = 0 } goto _22 _22: @@ -125183,23 +125183,23 @@ func X__res_send(tls *TLS, _msg uintptr, _msglen int32, _answer uintptr, _anslen var r, v1 int32 var _ /* buf at bp+16 */ [512]uint8 _, _ = r, v1 - if *(*int32)(unsafe.Pointer(bp + 12)) < int32(512) { - r = X__res_send(tls, *(*uintptr)(unsafe.Pointer(bp)), *(*int32)(unsafe.Pointer(bp + 4)), bp+16, int32(512)) + if **(**int32)(__ccgo_up(bp + 12)) < int32(512) { + r = X__res_send(tls, **(**uintptr)(__ccgo_up(bp)), **(**int32)(__ccgo_up(bp + 4)), bp+16, int32(512)) if r >= 0 { - if r < *(*int32)(unsafe.Pointer(bp + 12)) { + if r < **(**int32)(__ccgo_up(bp + 12)) { v1 = r } else { - v1 = *(*int32)(unsafe.Pointer(bp + 12)) + v1 = **(**int32)(__ccgo_up(bp + 12)) } - _memcpy(tls, *(*uintptr)(unsafe.Pointer(bp + 8)), bp+16, Uint32FromInt32(v1)) + _memcpy(tls, **(**uintptr)(__ccgo_up(bp + 8)), bp+16, Uint32FromInt32(v1)) } return r } - r = X__res_msend(tls, int32(1), bp, bp+4, bp+8, bp+12, *(*int32)(unsafe.Pointer(bp + 12))) - if r < 0 || !(*(*int32)(unsafe.Pointer(bp + 12)) != 0) { + r = X__res_msend(tls, int32(1), bp, bp+4, bp+8, bp+12, **(**int32)(__ccgo_up(bp + 12))) + if r < 0 || !(**(**int32)(__ccgo_up(bp + 12)) != 0) { v1 = -int32(1) } else { - v1 = *(*int32)(unsafe.Pointer(bp + 12)) + v1 = **(**int32)(__ccgo_up(bp + 12)) } return v1 } @@ -125246,11 +125246,11 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ (*Tresolvconf)(unsafe.Pointer(conf)).Ftimeout = uint32(5) (*Tresolvconf)(unsafe.Pointer(conf)).Fattempts = uint32(2) if search != 0 { - *(*uint8)(unsafe.Pointer(search)) = uint8(0) + **(**uint8)(__ccgo_up(search)) = uint8(0) } f = X__fopen_rb_ca(tls, __ccgo_ts+1064, bp+512, bp+256, uint32(256)) if !(f != 0) { - switch *(*int32)(unsafe.Pointer(X__errno_location(tls))) { + switch **(**int32)(__ccgo_up(X__errno_location(tls))) { case int32(ENOENT): fallthrough case int32(ENOTDIR): @@ -125269,17 +125269,17 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ continue } if v4 = !(Xstrncmp(tls, bp, __ccgo_ts+1081, uint32(7)) != 0); v4 { - v1 = Int32FromUint8((*(*[256]uint8)(unsafe.Pointer(bp)))[int32(7)]) + v1 = Int32FromUint8((**(**[256]uint8)(__ccgo_up(bp)))[int32(7)]) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _3 _3: } if v4 && v2 != 0 { p = Xstrstr(tls, bp, __ccgo_ts+1089) - if p != 0 && BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p + 6)))-uint32('0') < uint32(10)) != 0 { + if p != 0 && BoolInt32(uint32(**(**uint8)(__ccgo_up(p + 6)))-uint32('0') < uint32(10)) != 0 { p = p + uintptr(6) x = Xstrtoul(tls, p, bp+656, int32(10)) - if *(*uintptr)(unsafe.Pointer(bp + 656)) != p { + if **(**uintptr)(__ccgo_up(bp + 656)) != p { if x > uint32(15) { v5 = uint32(15) } else { @@ -125289,10 +125289,10 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ } } p = Xstrstr(tls, bp, __ccgo_ts+1096) - if p != 0 && BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p + 9)))-uint32('0') < uint32(10)) != 0 { + if p != 0 && BoolInt32(uint32(**(**uint8)(__ccgo_up(p + 9)))-uint32('0') < uint32(10)) != 0 { p = p + uintptr(9) x1 = Xstrtoul(tls, p, bp+656, int32(10)) - if *(*uintptr)(unsafe.Pointer(bp + 656)) != p { + if **(**uintptr)(__ccgo_up(bp + 656)) != p { if x1 > uint32(10) { v5 = uint32(10) } else { @@ -125302,10 +125302,10 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ } } p = Xstrstr(tls, bp, __ccgo_ts+1106) - if p != 0 && (BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p + 8)))-uint32('0') < uint32(10)) != 0 || Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 8))) == int32('.')) { + if p != 0 && (BoolInt32(uint32(**(**uint8)(__ccgo_up(p + 8)))-uint32('0') < uint32(10)) != 0 || Int32FromUint8(**(**uint8)(__ccgo_up(p + 8))) == int32('.')) { p = p + uintptr(8) x2 = Xstrtoul(tls, p, bp+656, int32(10)) - if *(*uintptr)(unsafe.Pointer(bp + 656)) != p { + if **(**uintptr)(__ccgo_up(bp + 656)) != p { if x2 > uint32(60) { v5 = uint32(60) } else { @@ -125317,7 +125317,7 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ continue } if v4 = !(Xstrncmp(tls, bp, __ccgo_ts+1115, uint32(10)) != 0); v4 { - v1 = Int32FromUint8((*(*[256]uint8)(unsafe.Pointer(bp)))[int32(10)]) + v1 = Int32FromUint8((**(**[256]uint8)(__ccgo_up(bp)))[int32(10)]) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _10 _10: @@ -125328,7 +125328,7 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ } p = bp + uintptr(11) for { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _15 _15: @@ -125340,10 +125340,10 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ ; p = p + 1 } - *(*uintptr)(unsafe.Pointer(bp + 656)) = p + **(**uintptr)(__ccgo_up(bp + 656)) = p for { - if v4 = *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 656)))) != 0; v4 { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 656))))) + if v4 = **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 656)))) != 0; v4 { + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 656))))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _19 _19: @@ -125354,9 +125354,9 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ goto _16 _16: ; - *(*uintptr)(unsafe.Pointer(bp + 656)) = *(*uintptr)(unsafe.Pointer(bp + 656)) + 1 + **(**uintptr)(__ccgo_up(bp + 656)) = **(**uintptr)(__ccgo_up(bp + 656)) + 1 } - *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 656)))) = uint8(0) + **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 656)))) = uint8(0) if X__lookup_ipliteral(tls, conf+uintptr(nns)*28, p, PF_UNSPEC) > 0 { nns = nns + 1 } @@ -125366,7 +125366,7 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ continue } if v4 = Xstrncmp(tls, bp, __ccgo_ts+1126, uint32(6)) != 0 && Xstrncmp(tls, bp, __ccgo_ts+1133, uint32(6)) != 0; !v4 { - v1 = Int32FromUint8((*(*[256]uint8)(unsafe.Pointer(bp)))[int32(6)]) + v1 = Int32FromUint8((**(**[256]uint8)(__ccgo_up(bp)))[int32(6)]) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _23 _23: @@ -125376,7 +125376,7 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ } p = bp + uintptr(7) for { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _28 _28: @@ -125677,7 +125677,7 @@ func Xsockatmark(tls *TLS, s int32) (r int32) { if Xioctl(tls, s, int32(SIOCATMARK), VaList(bp+16, bp)) < 0 { return -int32(1) } - return *(*int32)(unsafe.Pointer(bp)) + return **(**int32)(__ccgo_up(bp)) } func Xsocket(tls *TLS, domain int32, type1 int32, protocol int32) (r1 int32) { @@ -125773,7 +125773,7 @@ func Xsocketpair(tls *TLS, domain int32, type1 int32, protocol int32, fd uintptr goto _9 _9: r1 = X__syscall_ret(tls, Uint32FromInt32(v8)) - if r1 < 0 && (*(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EINVAL) || *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EPROTONOSUPPORT)) && type1&(Int32FromInt32(SOCK_CLOEXEC)|Int32FromInt32(SOCK_NONBLOCK)) != 0 { + if r1 < 0 && (**(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EINVAL) || **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EPROTONOSUPPORT)) && type1&(Int32FromInt32(SOCK_CLOEXEC)|Int32FromInt32(SOCK_NONBLOCK)) != 0 { v10 = int32(SYS_socketpair) _ = int32(__SC_socketpair) v11 = domain @@ -125799,12 +125799,12 @@ _9: return r1 } if type1&int32(SOCK_CLOEXEC) != 0 { - X__syscall3(tls, int32(SYS_fcntl64), *(*int32)(unsafe.Pointer(fd)), int32(Int32FromInt32(F_SETFD)), int32(Int32FromInt32(FD_CLOEXEC))) - X__syscall3(tls, int32(SYS_fcntl64), *(*int32)(unsafe.Pointer(fd + 1*4)), int32(Int32FromInt32(F_SETFD)), int32(Int32FromInt32(FD_CLOEXEC))) + X__syscall3(tls, int32(SYS_fcntl64), int32(**(**int32)(__ccgo_up(fd))), int32(Int32FromInt32(F_SETFD)), int32(Int32FromInt32(FD_CLOEXEC))) + X__syscall3(tls, int32(SYS_fcntl64), int32(**(**int32)(__ccgo_up(fd + 1*4))), int32(Int32FromInt32(F_SETFD)), int32(Int32FromInt32(FD_CLOEXEC))) } if type1&int32(SOCK_NONBLOCK) != 0 { - X__syscall3(tls, int32(SYS_fcntl64), *(*int32)(unsafe.Pointer(fd)), int32(Int32FromInt32(F_SETFL)), int32(Int32FromInt32(O_NONBLOCK))) - X__syscall3(tls, int32(SYS_fcntl64), *(*int32)(unsafe.Pointer(fd + 1*4)), int32(Int32FromInt32(F_SETFL)), int32(Int32FromInt32(O_NONBLOCK))) + X__syscall3(tls, int32(SYS_fcntl64), int32(**(**int32)(__ccgo_up(fd))), int32(Int32FromInt32(F_SETFL)), int32(Int32FromInt32(O_NONBLOCK))) + X__syscall3(tls, int32(SYS_fcntl64), int32(**(**int32)(__ccgo_up(fd + 1*4))), int32(Int32FromInt32(F_SETFL)), int32(Int32FromInt32(O_NONBLOCK))) } } return r1 @@ -125841,10 +125841,10 @@ func Xfgetgrent(tls *TLS, f uintptr) (r uintptr) { var _ /* nmem at bp+8 */ Tsize_t var _ /* res at bp+0 */ uintptr var _ /* size at bp+4 */ Tsize_t - *(*Tsize_t)(unsafe.Pointer(bp + 4)) = uint32(0) - *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint32(0) + **(**Tsize_t)(__ccgo_up(bp + 4)) = uint32(0) + **(**Tsize_t)(__ccgo_up(bp + 8)) = uint32(0) X__getgrent_a(tls, f, uintptr(unsafe.Pointer(&_gr)), uintptr(unsafe.Pointer(&_line1)), bp+4, uintptr(unsafe.Pointer(&_mem)), bp+8, bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } var _line1 uintptr @@ -125862,9 +125862,9 @@ func Xfgetpwent(tls *TLS, f uintptr) (r uintptr) { defer tls.Free(16) var _ /* res at bp+4 */ uintptr var _ /* size at bp+0 */ Tsize_t - *(*Tsize_t)(unsafe.Pointer(bp)) = uint32(0) + **(**Tsize_t)(__ccgo_up(bp)) = uint32(0) X__getpwent_a(tls, f, uintptr(unsafe.Pointer(&_pw)), uintptr(unsafe.Pointer(&_line2)), bp, bp+4) - return *(*uintptr)(unsafe.Pointer(bp + 4)) + return **(**uintptr)(__ccgo_up(bp + 4)) } var _line2 uintptr @@ -125910,11 +125910,11 @@ func _itoa1(tls *TLS, p uintptr, x Tuint32_t) (r uintptr) { p = p + uintptr(11) p = p - 1 v1 = p - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) for cond := true; cond; cond = x != 0 { p = p - 1 v1 = p - *(*uint8)(unsafe.Pointer(v1)) = uint8(uint32('0') + x%uint32(10)) + **(**uint8)(__ccgo_up(v1)) = uint8(uint32('0') + x%uint32(10)) x = x / uint32(10) } return p @@ -125939,36 +125939,36 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz var _ /* swap at bp+40 */ int32 _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, grlist_len, i, key, len1, ptr, req, rv, tmp, tmp1, v1, v10, v5, v6 rv = 0 - *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) + **(**uintptr)(__ccgo_up(res)) = uintptr(0) _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp) f = Xfopen(tls, __ccgo_ts+1150, __ccgo_ts+315) if !(f != 0) { - rv = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + rv = **(**int32)(__ccgo_up(X__errno_location(tls))) goto done } for { v1 = X__getgrent_a(tls, f, gr, buf, size, mem, nmem, res) rv = v1 - if !(!(v1 != 0) && *(*uintptr)(unsafe.Pointer(res)) != 0) { + if !(!(v1 != 0) && **(**uintptr)(__ccgo_up(res)) != 0) { break } - if name != 0 && !(Xstrcmp(tls, name, (*Tgroup)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(res)))).Fgr_name) != 0) || !(name != 0) && (*Tgroup)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(res)))).Fgr_gid == gid { + if name != 0 && !(Xstrcmp(tls, name, (*Tgroup)(unsafe.Pointer(**(**uintptr)(__ccgo_up(res)))).Fgr_name) != 0) || !(name != 0) && (*Tgroup)(unsafe.Pointer(**(**uintptr)(__ccgo_up(res)))).Fgr_gid == gid { break } } Xfclose(tls, f) - if !(*(*uintptr)(unsafe.Pointer(res)) != 0) && (rv == 0 || rv == int32(ENOENT) || rv == int32(ENOTDIR)) { + if !(**(**uintptr)(__ccgo_up(res)) != 0) && (rv == 0 || rv == int32(ENOENT) || rv == int32(ENOTDIR)) { if name != 0 { v1 = int32(GETGRBYNAME) } else { v1 = int32(GETGRBYGID) } req = v1 - *(*[6]Tint32_t)(unsafe.Pointer(bp + 4)) = [6]Tint32_t{} + **(**[6]Tint32_t)(__ccgo_up(bp + 4)) = [6]Tint32_t{} len1 = uint32(0) grlist_len = uint32(0) - *(*[11]uint8)(unsafe.Pointer(bp + 28)) = [11]uint8{} - *(*int32)(unsafe.Pointer(bp + 40)) = 0 + **(**[11]uint8)(__ccgo_up(bp + 28)) = [11]uint8{} + **(**int32)(__ccgo_up(bp + 40)) = 0 if name != 0 { key = name } else { @@ -125980,116 +125980,116 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz } f = X__nscd_query(tls, req, key, bp+4, uint32(24), bp+40) if !(f != 0) { - rv = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + rv = **(**int32)(__ccgo_up(X__errno_location(tls))) goto done } - if !((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRFOUND)] != 0) { + if !((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRFOUND)] != 0) { rv = 0 goto cleanup_f } - if !((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRNAMELEN)] != 0) || !((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRPASSWDLEN)] != 0) { + if !((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRNAMELEN)] != 0) || !((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRPASSWDLEN)] != 0) { rv = int32(EIO) goto cleanup_f } - if Uint32FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRNAMELEN)]) > uint32(0xffffffff)-Uint32FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRPASSWDLEN)]) { + if Uint32FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRNAMELEN)]) > uint32(0xffffffff)-Uint32FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRPASSWDLEN)]) { rv = int32(ENOMEM) goto cleanup_f } - len1 = Uint32FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRNAMELEN)] + (*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRPASSWDLEN)]) + len1 = Uint32FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRNAMELEN)] + (**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRPASSWDLEN)]) i = 0 for { - if !(i < (*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)]) { + if !(i < (**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)]) { break } if Xfread(tls, bp+44, uint32(4), uint32(1), f) < uint32(1) { if Xferror(tls, f) != 0 { - v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = **(**int32)(__ccgo_up(X__errno_location(tls))) } else { v1 = int32(EIO) } rv = v1 goto cleanup_f } - if *(*int32)(unsafe.Pointer(bp + 40)) != 0 { - v5 = *(*Tuint32_t)(unsafe.Pointer(bp + 44)) + if **(**int32)(__ccgo_up(bp + 40)) != 0 { + v5 = **(**Tuint32_t)(__ccgo_up(bp + 44)) v6 = v5>>int32(24) | v5>>int32(8)&uint32(0xff00) | v5< uint32(0xffffffff)-grlist_len || *(*Tuint32_t)(unsafe.Pointer(bp + 44)) > uint32(0xffffffff)-len1 { + if **(**Tuint32_t)(__ccgo_up(bp + 44)) > uint32(0xffffffff)-grlist_len || **(**Tuint32_t)(__ccgo_up(bp + 44)) > uint32(0xffffffff)-len1 { rv = int32(ENOMEM) goto cleanup_f } - len1 = len1 + *(*Tuint32_t)(unsafe.Pointer(bp + 44)) - grlist_len = grlist_len + *(*Tuint32_t)(unsafe.Pointer(bp + 44)) + len1 = len1 + **(**Tuint32_t)(__ccgo_up(bp + 44)) + grlist_len = grlist_len + **(**Tuint32_t)(__ccgo_up(bp + 44)) goto _3 _3: ; i = i + 1 } - if len1 > *(*Tsize_t)(unsafe.Pointer(size)) || !(*(*uintptr)(unsafe.Pointer(buf)) != 0) { - tmp = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(buf)), len1) + if len1 > **(**Tsize_t)(__ccgo_up(size)) || !(**(**uintptr)(__ccgo_up(buf)) != 0) { + tmp = Xrealloc(tls, **(**uintptr)(__ccgo_up(buf)), len1) if !(tmp != 0) { - rv = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + rv = **(**int32)(__ccgo_up(X__errno_location(tls))) goto cleanup_f } - *(*uintptr)(unsafe.Pointer(buf)) = tmp - *(*Tsize_t)(unsafe.Pointer(size)) = len1 + **(**uintptr)(__ccgo_up(buf)) = tmp + **(**Tsize_t)(__ccgo_up(size)) = len1 } - if !(Xfread(tls, *(*uintptr)(unsafe.Pointer(buf)), len1, uint32(1), f) != 0) { + if !(Xfread(tls, **(**uintptr)(__ccgo_up(buf)), len1, uint32(1), f) != 0) { if Xferror(tls, f) != 0 { - v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = **(**int32)(__ccgo_up(X__errno_location(tls))) } else { v1 = int32(EIO) } rv = v1 goto cleanup_f } - if Uint32FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)]+int32(1)) > *(*Tsize_t)(unsafe.Pointer(nmem)) { - if Uint32FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)]+int32(1)) > Uint32FromUint32(0xffffffff)/Uint32FromInt64(4) { + if Uint32FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)]+int32(1)) > **(**Tsize_t)(__ccgo_up(nmem)) { + if Uint32FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)]+int32(1)) > Uint32FromUint32(0xffffffff)/Uint32FromInt64(4) { rv = int32(ENOMEM) goto cleanup_f } - tmp1 = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(mem)), Uint32FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)]+Int32FromInt32(1))*uint32(4)) + tmp1 = Xrealloc(tls, **(**uintptr)(__ccgo_up(mem)), Uint32FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)]+Int32FromInt32(1))*uint32(4)) if !(tmp1 != 0) { - rv = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + rv = **(**int32)(__ccgo_up(X__errno_location(tls))) goto cleanup_f } - *(*uintptr)(unsafe.Pointer(mem)) = tmp1 - *(*Tsize_t)(unsafe.Pointer(nmem)) = Uint32FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)] + int32(1)) + **(**uintptr)(__ccgo_up(mem)) = tmp1 + **(**Tsize_t)(__ccgo_up(nmem)) = Uint32FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)] + int32(1)) } - if (*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)] != 0 { - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)))) = *(*uintptr)(unsafe.Pointer(buf)) + uintptr((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRNAMELEN)]) + uintptr((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRPASSWDLEN)]) - ptr = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)))) + if (**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)] != 0 { + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)))) = **(**uintptr)(__ccgo_up(buf)) + uintptr((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRNAMELEN)]) + uintptr((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRPASSWDLEN)]) + ptr = **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)))) i = Int32FromInt32(0) for { - if !(ptr != *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem))))+uintptr(grlist_len)) { + if !(ptr != **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem))))+uintptr(grlist_len)) { break } - if !(*(*uint8)(unsafe.Pointer(ptr)) != 0) { + if !(**(**uint8)(__ccgo_up(ptr)) != 0) { i = i + 1 v10 = i - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v10)*4)) = ptr + uintptr(1) + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)) + uintptr(v10)*4)) = ptr + uintptr(1) } goto _9 _9: ; ptr = ptr + 1 } - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(i)*4)) = uintptr(0) - if i != (*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)] { + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)) + uintptr(i)*4)) = uintptr(0) + if i != (**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)] { rv = int32(EIO) goto cleanup_f } } else { - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)))) = uintptr(0) + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)))) = uintptr(0) } - (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = *(*uintptr)(unsafe.Pointer(buf)) - (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = (*Tgroup)(unsafe.Pointer(gr)).Fgr_name + uintptr((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRNAMELEN)]) - (*Tgroup)(unsafe.Pointer(gr)).Fgr_gid = Uint32FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRGID)]) - (*Tgroup)(unsafe.Pointer(gr)).Fgr_mem = *(*uintptr)(unsafe.Pointer(mem)) - if *(*uint8)(unsafe.Pointer((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd + uintptr(-Int32FromInt32(1)))) != 0 || *(*uint8)(unsafe.Pointer((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd + uintptr((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRPASSWDLEN)]-int32(1)))) != 0 { + (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = **(**uintptr)(__ccgo_up(buf)) + (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = (*Tgroup)(unsafe.Pointer(gr)).Fgr_name + uintptr((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRNAMELEN)]) + (*Tgroup)(unsafe.Pointer(gr)).Fgr_gid = Uint32FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRGID)]) + (*Tgroup)(unsafe.Pointer(gr)).Fgr_mem = **(**uintptr)(__ccgo_up(mem)) + if **(**uint8)(__ccgo_up((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd + uintptr(-Int32FromInt32(1)))) != 0 || **(**uint8)(__ccgo_up((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd + uintptr((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRPASSWDLEN)]-int32(1)))) != 0 { rv = int32(EIO) goto cleanup_f } @@ -126097,7 +126097,7 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz rv = int32(EIO) goto cleanup_f } - *(*uintptr)(unsafe.Pointer(res)) = gr + **(**uintptr)(__ccgo_up(res)) = gr goto cleanup_f cleanup_f: ; @@ -126107,9 +126107,9 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz goto done done: ; - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) if rv != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = rv + **(**int32)(__ccgo_up(X__errno_location(tls))) = rv } return rv } @@ -126125,42 +126125,42 @@ func _getgr_r(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, size var _ /* mem at bp+8 */ uintptr var _ /* nmem at bp+12 */ Tsize_t _, _ = i, rv - *(*uintptr)(unsafe.Pointer(bp)) = uintptr(0) - *(*Tsize_t)(unsafe.Pointer(bp + 4)) = uint32(0) - *(*uintptr)(unsafe.Pointer(bp + 8)) = uintptr(0) - *(*Tsize_t)(unsafe.Pointer(bp + 12)) = uint32(0) + **(**uintptr)(__ccgo_up(bp)) = uintptr(0) + **(**Tsize_t)(__ccgo_up(bp + 4)) = uint32(0) + **(**uintptr)(__ccgo_up(bp + 8)) = uintptr(0) + **(**Tsize_t)(__ccgo_up(bp + 12)) = uint32(0) rv = 0 _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp+16) rv = X__getgr_a(tls, name, gid, gr, bp, bp+4, bp+8, bp+12, res) - if *(*uintptr)(unsafe.Pointer(res)) != 0 && size < *(*Tsize_t)(unsafe.Pointer(bp + 4))+(*(*Tsize_t)(unsafe.Pointer(bp + 12))+uint32(1))*uint32(4)+uint32(32) { - *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) + if **(**uintptr)(__ccgo_up(res)) != 0 && size < **(**Tsize_t)(__ccgo_up(bp + 4))+(**(**Tsize_t)(__ccgo_up(bp + 12))+uint32(1))*uint32(4)+uint32(32) { + **(**uintptr)(__ccgo_up(res)) = uintptr(0) rv = int32(ERANGE) } - if *(*uintptr)(unsafe.Pointer(res)) != 0 { + if **(**uintptr)(__ccgo_up(res)) != 0 { buf = buf + uintptr((uint32(16)-uint32(buf))%uint32(16)) (*Tgroup)(unsafe.Pointer(gr)).Fgr_mem = buf - buf = buf + uintptr((*(*Tsize_t)(unsafe.Pointer(bp + 12))+uint32(1))*uint32(4)) - _memcpy(tls, buf, *(*uintptr)(unsafe.Pointer(bp)), *(*Tsize_t)(unsafe.Pointer(bp + 4))) - (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = uintptr(int32((*Tgroup)(unsafe.Pointer(gr)).Fgr_name)-int32(*(*uintptr)(unsafe.Pointer(bp)))) + buf - (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = uintptr(int32((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd)-int32(*(*uintptr)(unsafe.Pointer(bp)))) + buf + buf = buf + uintptr((**(**Tsize_t)(__ccgo_up(bp + 12))+uint32(1))*uint32(4)) + _memcpy(tls, buf, **(**uintptr)(__ccgo_up(bp)), **(**Tsize_t)(__ccgo_up(bp + 4))) + (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = uintptr(int32((*Tgroup)(unsafe.Pointer(gr)).Fgr_name)-int32(**(**uintptr)(__ccgo_up(bp)))) + buf + (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = uintptr(int32((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd)-int32(**(**uintptr)(__ccgo_up(bp)))) + buf i = uint32(0) for { - if !(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*4)) != 0) { + if !(**(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + uintptr(i)*4)) != 0) { break } - *(*uintptr)(unsafe.Pointer((*Tgroup)(unsafe.Pointer(gr)).Fgr_mem + uintptr(i)*4)) = uintptr(int32(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*4)))-int32(*(*uintptr)(unsafe.Pointer(bp)))) + buf + **(**uintptr)(__ccgo_up((*Tgroup)(unsafe.Pointer(gr)).Fgr_mem + uintptr(i)*4)) = uintptr(int32(**(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + uintptr(i)*4)))-int32(**(**uintptr)(__ccgo_up(bp)))) + buf goto _1 _1: ; i = i + 1 } - *(*uintptr)(unsafe.Pointer((*Tgroup)(unsafe.Pointer(gr)).Fgr_mem + uintptr(i)*4)) = uintptr(0) + **(**uintptr)(__ccgo_up((*Tgroup)(unsafe.Pointer(gr)).Fgr_mem + uintptr(i)*4)) = uintptr(0) } - Xfree(tls, *(*uintptr)(unsafe.Pointer(bp + 8))) - Xfree(tls, *(*uintptr)(unsafe.Pointer(bp))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 16)), uintptr(0)) + Xfree(tls, **(**uintptr)(__ccgo_up(bp + 8))) + Xfree(tls, **(**uintptr)(__ccgo_up(bp))) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 16)), uintptr(0)) if rv != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = rv + **(**int32)(__ccgo_up(X__errno_location(tls))) = rv } return rv } @@ -126206,8 +126206,8 @@ func Xgetgrent(tls *TLS) (r uintptr) { var _ /* nmem at bp+8 */ Tsize_t var _ /* res at bp+0 */ uintptr var _ /* size at bp+4 */ Tsize_t - *(*Tsize_t)(unsafe.Pointer(bp + 4)) = uint32(0) - *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint32(0) + **(**Tsize_t)(__ccgo_up(bp + 4)) = uint32(0) + **(**Tsize_t)(__ccgo_up(bp + 8)) = uint32(0) if !(_f1 != 0) { _f1 = Xfopen(tls, __ccgo_ts+1150, __ccgo_ts+315) } @@ -126215,7 +126215,7 @@ func Xgetgrent(tls *TLS) (r uintptr) { return uintptr(0) } X__getgrent_a(tls, _f1, uintptr(unsafe.Pointer(&_gr1)), uintptr(unsafe.Pointer(&_line3)), bp+4, uintptr(unsafe.Pointer(&_mem1)), bp+8, bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func Xgetgrgid(tls *TLS, gid Tgid_t) (r uintptr) { @@ -126228,10 +126228,10 @@ func Xgetgrgid(tls *TLS, gid Tgid_t) (r uintptr) { var _ /* nmem at bp+8 */ Tsize_t var _ /* res at bp+0 */ uintptr var _ /* size at bp+4 */ Tsize_t - *(*Tsize_t)(unsafe.Pointer(bp + 4)) = uint32(0) - *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint32(0) + **(**Tsize_t)(__ccgo_up(bp + 4)) = uint32(0) + **(**Tsize_t)(__ccgo_up(bp + 8)) = uint32(0) X__getgr_a(tls, uintptr(0), gid, uintptr(unsafe.Pointer(&_gr1)), uintptr(unsafe.Pointer(&_line3)), bp+4, uintptr(unsafe.Pointer(&_mem1)), bp+8, bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func Xgetgrnam(tls *TLS, name uintptr) (r uintptr) { @@ -126244,10 +126244,10 @@ func Xgetgrnam(tls *TLS, name uintptr) (r uintptr) { var _ /* nmem at bp+8 */ Tsize_t var _ /* res at bp+0 */ uintptr var _ /* size at bp+4 */ Tsize_t - *(*Tsize_t)(unsafe.Pointer(bp + 4)) = uint32(0) - *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint32(0) + **(**Tsize_t)(__ccgo_up(bp + 4)) = uint32(0) + **(**Tsize_t)(__ccgo_up(bp + 8)) = uint32(0) X__getgr_a(tls, name, uint32(0), uintptr(unsafe.Pointer(&_gr1)), uintptr(unsafe.Pointer(&_line3)), bp+4, uintptr(unsafe.Pointer(&_mem1)), bp+8, bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func Xendgrent(tls *TLS) { @@ -126262,14 +126262,14 @@ func _atou(tls *TLS, s uintptr) (r uint32) { _ = x x = uint32(0) for { - if !(Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-int32('0')) < uint32(10)) { + if !(Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-int32('0')) < uint32(10)) { break } - x = uint32(10)*x + Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-Int32FromUint8('0')) + x = uint32(10)*x + Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-Int32FromUint8('0')) goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s)) = *(*uintptr)(unsafe.Pointer(s)) + 1 + **(**uintptr)(__ccgo_up(s)) = **(**uintptr)(__ccgo_up(s)) + 1 } return x } @@ -126295,107 +126295,107 @@ func X__getgrent_a(tls *TLS, f uintptr, gr uintptr, line uintptr, size uintptr, l = v2 if v2 < 0 { if Xferror(tls, f) != 0 { - v3 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v3 = **(**int32)(__ccgo_up(X__errno_location(tls))) } else { v3 = 0 } rv = v3 - Xfree(tls, *(*uintptr)(unsafe.Pointer(line))) - *(*uintptr)(unsafe.Pointer(line)) = uintptr(0) + Xfree(tls, **(**uintptr)(__ccgo_up(line))) + **(**uintptr)(__ccgo_up(line)) = uintptr(0) gr = uintptr(0) goto end } - *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(line)) + uintptr(l-int32(1)))) = uint8(0) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(line)) - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(line)) + uintptr(l-int32(1)))) = uint8(0) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(line)) + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = v4 - v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v4 + v4 = Xstrchr(tls, **(**uintptr)(__ccgo_up(bp)), int32(':')) + **(**uintptr)(__ccgo_up(bp)) = v4 if !(v4 != 0) { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) - (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = *(*uintptr)(unsafe.Pointer(bp)) - v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v4 + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) + (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = **(**uintptr)(__ccgo_up(bp)) + v4 = Xstrchr(tls, **(**uintptr)(__ccgo_up(bp)), int32(':')) + **(**uintptr)(__ccgo_up(bp)) = v4 if !(v4 != 0) { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) (*Tgroup)(unsafe.Pointer(gr)).Fgr_gid = _atou(tls, bp) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32(':') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) != int32(':') { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) - mems = *(*uintptr)(unsafe.Pointer(bp)) + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) + mems = **(**uintptr)(__ccgo_up(bp)) break goto _1 _1: } - *(*Tsize_t)(unsafe.Pointer(nmem)) = BoolUint32(!!(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) != 0)) + **(**Tsize_t)(__ccgo_up(nmem)) = BoolUint32(!!(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))) != 0)) for { - if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) != 0) { + if !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))) != 0) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32(',') { - *(*Tsize_t)(unsafe.Pointer(nmem)) = *(*Tsize_t)(unsafe.Pointer(nmem)) + 1 + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) == int32(',') { + **(**Tsize_t)(__ccgo_up(nmem)) = **(**Tsize_t)(__ccgo_up(nmem)) + 1 } goto _10 _10: ; - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - } - Xfree(tls, *(*uintptr)(unsafe.Pointer(mem))) - *(*uintptr)(unsafe.Pointer(mem)) = Xcalloc(tls, uint32(4), *(*Tsize_t)(unsafe.Pointer(nmem))+uint32(1)) - if !(*(*uintptr)(unsafe.Pointer(mem)) != 0) { - rv = *(*int32)(unsafe.Pointer(X__errno_location(tls))) - Xfree(tls, *(*uintptr)(unsafe.Pointer(line))) - *(*uintptr)(unsafe.Pointer(line)) = uintptr(0) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + } + Xfree(tls, **(**uintptr)(__ccgo_up(mem))) + **(**uintptr)(__ccgo_up(mem)) = Xcalloc(tls, uint32(4), **(**Tsize_t)(__ccgo_up(nmem))+uint32(1)) + if !(**(**uintptr)(__ccgo_up(mem)) != 0) { + rv = **(**int32)(__ccgo_up(X__errno_location(tls))) + Xfree(tls, **(**uintptr)(__ccgo_up(line))) + **(**uintptr)(__ccgo_up(line)) = uintptr(0) gr = uintptr(0) goto end } - if *(*uint8)(unsafe.Pointer(mems)) != 0 { - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)))) = mems - *(*uintptr)(unsafe.Pointer(bp)) = mems + if **(**uint8)(__ccgo_up(mems)) != 0 { + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)))) = mems + **(**uintptr)(__ccgo_up(bp)) = mems i = Uint32FromInt32(0) for { - if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) != 0) { + if !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))) != 0) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32(',') { - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) == int32(',') { + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) i = i + 1 v13 = i - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v13)*4)) = *(*uintptr)(unsafe.Pointer(bp)) + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)) + uintptr(v13)*4)) = **(**uintptr)(__ccgo_up(bp)) } goto _11 _11: ; - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 } i = i + 1 v13 = i - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v13)*4)) = uintptr(0) + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)) + uintptr(v13)*4)) = uintptr(0) } else { - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)))) = uintptr(0) + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)))) = uintptr(0) } - (*Tgroup)(unsafe.Pointer(gr)).Fgr_mem = *(*uintptr)(unsafe.Pointer(mem)) + (*Tgroup)(unsafe.Pointer(gr)).Fgr_mem = **(**uintptr)(__ccgo_up(mem)) goto end end: ; - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 4)), uintptr(0)) - *(*uintptr)(unsafe.Pointer(res)) = gr + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 4)), uintptr(0)) + **(**uintptr)(__ccgo_up(res)) = gr if rv != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = rv + **(**int32)(__ccgo_up(X__errno_location(tls))) = rv } return rv } @@ -126423,44 +126423,44 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u _, _, _, _, _, _, _, _, _, _, _, _, _ = f, i, n, nbytes, nlim, nscdbuf, ret, rv, v1, v3, v4, v6, v9 ret = -int32(1) n = int32(1) - *(*int32)(unsafe.Pointer(bp + 20)) = 0 + **(**int32)(__ccgo_up(bp + 20)) = 0 nscdbuf = uintptr(0) - *(*uintptr)(unsafe.Pointer(bp + 36)) = uintptr(0) - *(*uintptr)(unsafe.Pointer(bp + 40)) = uintptr(0) - *(*Tsize_t)(unsafe.Pointer(bp + 44)) = uint32(0) - nlim = *(*int32)(unsafe.Pointer(ngroups)) + **(**uintptr)(__ccgo_up(bp + 36)) = uintptr(0) + **(**uintptr)(__ccgo_up(bp + 40)) = uintptr(0) + **(**Tsize_t)(__ccgo_up(bp + 44)) = uint32(0) + nlim = **(**int32)(__ccgo_up(ngroups)) if nlim >= int32(1) { v1 = groups groups += 4 - *(*Tgid_t)(unsafe.Pointer(v1)) = gid + **(**Tgid_t)(__ccgo_up(v1)) = gid } f = X__nscd_query(tls, int32(GETINITGR), user, bp+24, uint32(12), bp+20) if !(f != 0) { goto cleanup } - if (*(*[3]Tint32_t)(unsafe.Pointer(bp + 24)))[int32(INITGRFOUND)] != 0 { - nscdbuf = Xcalloc(tls, Uint32FromInt32((*(*[3]Tint32_t)(unsafe.Pointer(bp + 24)))[int32(INITGRNGRPS)]), uint32(4)) + if (**(**[3]Tint32_t)(__ccgo_up(bp + 24)))[int32(INITGRFOUND)] != 0 { + nscdbuf = Xcalloc(tls, Uint32FromInt32((**(**[3]Tint32_t)(__ccgo_up(bp + 24)))[int32(INITGRNGRPS)]), uint32(4)) if !(nscdbuf != 0) { goto cleanup } - nbytes = uint32(4) * Uint32FromInt32((*(*[3]Tint32_t)(unsafe.Pointer(bp + 24)))[int32(INITGRNGRPS)]) + nbytes = uint32(4) * Uint32FromInt32((**(**[3]Tint32_t)(__ccgo_up(bp + 24)))[int32(INITGRNGRPS)]) if nbytes != 0 && !(Xfread(tls, nscdbuf, nbytes, uint32(1), f) != 0) { if !(Xferror(tls, f) != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EIO) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EIO) } goto cleanup } - if *(*int32)(unsafe.Pointer(bp + 20)) != 0 { + if **(**int32)(__ccgo_up(bp + 20)) != 0 { i = 0 for { - if !(i < (*(*[3]Tint32_t)(unsafe.Pointer(bp + 24)))[int32(INITGRNGRPS)]) { + if !(i < (**(**[3]Tint32_t)(__ccgo_up(bp + 24)))[int32(INITGRNGRPS)]) { break } - v3 = *(*Tuint32_t)(unsafe.Pointer(nscdbuf + uintptr(i)*4)) + v3 = **(**Tuint32_t)(__ccgo_up(nscdbuf + uintptr(i)*4)) v4 = v3>>int32(24) | v3>>int32(8)&uint32(0xff00) | v3<= Uint32FromUint32(0xffffffff)/Uint32FromInt32(8) { + if Uint32FromInt32((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWNAMELEN)]|(**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWPASSWDLEN)]|(**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWGECOSLEN)]|(**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWDIRLEN)]|(**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWSHELLLEN)]) >= Uint32FromUint32(0xffffffff)/Uint32FromInt32(8) { rv = int32(ENOMEM) goto cleanup_f } - len1 = Uint32FromInt32((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWNAMELEN)] + (*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWPASSWDLEN)] + (*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWGECOSLEN)] + (*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWDIRLEN)] + (*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWSHELLLEN)]) - if len1 > *(*Tsize_t)(unsafe.Pointer(size)) || !(*(*uintptr)(unsafe.Pointer(buf)) != 0) { - tmp = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(buf)), len1) + len1 = Uint32FromInt32((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWNAMELEN)] + (**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWPASSWDLEN)] + (**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWGECOSLEN)] + (**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWDIRLEN)] + (**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWSHELLLEN)]) + if len1 > **(**Tsize_t)(__ccgo_up(size)) || !(**(**uintptr)(__ccgo_up(buf)) != 0) { + tmp = Xrealloc(tls, **(**uintptr)(__ccgo_up(buf)), len1) if !(tmp != 0) { - rv = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + rv = **(**int32)(__ccgo_up(X__errno_location(tls))) goto cleanup_f } - *(*uintptr)(unsafe.Pointer(buf)) = tmp - *(*Tsize_t)(unsafe.Pointer(size)) = len1 + **(**uintptr)(__ccgo_up(buf)) = tmp + **(**Tsize_t)(__ccgo_up(size)) = len1 } - if !(Xfread(tls, *(*uintptr)(unsafe.Pointer(buf)), len1, uint32(1), f) != 0) { + if !(Xfread(tls, **(**uintptr)(__ccgo_up(buf)), len1, uint32(1), f) != 0) { if Xferror(tls, f) != 0 { - v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = **(**int32)(__ccgo_up(X__errno_location(tls))) } else { v1 = int32(EIO) } rv = v1 goto cleanup_f } - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = *(*uintptr)(unsafe.Pointer(buf)) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name + uintptr((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWNAMELEN)]) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd + uintptr((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWPASSWDLEN)]) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos + uintptr((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWGECOSLEN)]) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir + uintptr((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWDIRLEN)]) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_uid = Uint32FromInt32((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWUID)]) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gid = Uint32FromInt32((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWGID)]) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = **(**uintptr)(__ccgo_up(buf)) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name + uintptr((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWNAMELEN)]) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd + uintptr((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWPASSWDLEN)]) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos + uintptr((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWGECOSLEN)]) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir + uintptr((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWDIRLEN)]) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_uid = Uint32FromInt32((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWUID)]) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gid = Uint32FromInt32((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWGID)]) /* Don't assume that nscd made sure to null terminate strings. * It's supposed to, but malicious nscd should be ignored * rather than causing a crash. */ - if *(*uint8)(unsafe.Pointer((*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd + uintptr(-Int32FromInt32(1)))) != 0 || *(*uint8)(unsafe.Pointer((*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos + uintptr(-Int32FromInt32(1)))) != 0 || *(*uint8)(unsafe.Pointer((*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir + uintptr(-Int32FromInt32(1)))) != 0 || *(*uint8)(unsafe.Pointer((*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell + uintptr((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWSHELLLEN)]-int32(1)))) != 0 { + if **(**uint8)(__ccgo_up((*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd + uintptr(-Int32FromInt32(1)))) != 0 || **(**uint8)(__ccgo_up((*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos + uintptr(-Int32FromInt32(1)))) != 0 || **(**uint8)(__ccgo_up((*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir + uintptr(-Int32FromInt32(1)))) != 0 || **(**uint8)(__ccgo_up((*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell + uintptr((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWSHELLLEN)]-int32(1)))) != 0 { rv = int32(EIO) goto cleanup_f } @@ -126696,7 +126696,7 @@ func X__getpw_a(tls *TLS, name uintptr, uid Tuid_t, pw uintptr, buf uintptr, siz rv = int32(EIO) goto cleanup_f } - *(*uintptr)(unsafe.Pointer(res)) = pw + **(**uintptr)(__ccgo_up(res)) = pw goto cleanup_f cleanup_f: ; @@ -126706,9 +126706,9 @@ func X__getpw_a(tls *TLS, name uintptr, uid Tuid_t, pw uintptr, buf uintptr, siz goto done done: ; - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 4)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 4)), uintptr(0)) if rv != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = rv + **(**int32)(__ccgo_up(X__errno_location(tls))) = rv } return rv } @@ -126721,27 +126721,27 @@ func _getpw_r(tls *TLS, name uintptr, uid Tuid_t, pw uintptr, buf uintptr, size var _ /* len at bp+4 */ Tsize_t var _ /* line at bp+0 */ uintptr _ = rv - *(*uintptr)(unsafe.Pointer(bp)) = uintptr(0) - *(*Tsize_t)(unsafe.Pointer(bp + 4)) = uint32(0) + **(**uintptr)(__ccgo_up(bp)) = uintptr(0) + **(**Tsize_t)(__ccgo_up(bp + 4)) = uint32(0) rv = 0 _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp+8) rv = X__getpw_a(tls, name, uid, pw, bp, bp+4, res) - if *(*uintptr)(unsafe.Pointer(res)) != 0 && size < *(*Tsize_t)(unsafe.Pointer(bp + 4)) { - *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) + if **(**uintptr)(__ccgo_up(res)) != 0 && size < **(**Tsize_t)(__ccgo_up(bp + 4)) { + **(**uintptr)(__ccgo_up(res)) = uintptr(0) rv = int32(ERANGE) } - if *(*uintptr)(unsafe.Pointer(res)) != 0 { - _memcpy(tls, buf, *(*uintptr)(unsafe.Pointer(bp)), *(*Tsize_t)(unsafe.Pointer(bp + 4))) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = uintptr(int32((*Tpasswd)(unsafe.Pointer(pw)).Fpw_name)-int32(*(*uintptr)(unsafe.Pointer(bp)))) + buf - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = uintptr(int32((*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd)-int32(*(*uintptr)(unsafe.Pointer(bp)))) + buf - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = uintptr(int32((*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos)-int32(*(*uintptr)(unsafe.Pointer(bp)))) + buf - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = uintptr(int32((*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir)-int32(*(*uintptr)(unsafe.Pointer(bp)))) + buf - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = uintptr(int32((*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell)-int32(*(*uintptr)(unsafe.Pointer(bp)))) + buf + if **(**uintptr)(__ccgo_up(res)) != 0 { + _memcpy(tls, buf, **(**uintptr)(__ccgo_up(bp)), **(**Tsize_t)(__ccgo_up(bp + 4))) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = uintptr(int32((*Tpasswd)(unsafe.Pointer(pw)).Fpw_name)-int32(**(**uintptr)(__ccgo_up(bp)))) + buf + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = uintptr(int32((*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd)-int32(**(**uintptr)(__ccgo_up(bp)))) + buf + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = uintptr(int32((*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos)-int32(**(**uintptr)(__ccgo_up(bp)))) + buf + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = uintptr(int32((*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir)-int32(**(**uintptr)(__ccgo_up(bp)))) + buf + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = uintptr(int32((*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell)-int32(**(**uintptr)(__ccgo_up(bp)))) + buf } - Xfree(tls, *(*uintptr)(unsafe.Pointer(bp))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 8)), uintptr(0)) + Xfree(tls, **(**uintptr)(__ccgo_up(bp))) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 8)), uintptr(0)) if rv != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = rv + **(**int32)(__ccgo_up(X__errno_location(tls))) = rv } return rv } @@ -126792,7 +126792,7 @@ func Xgetpwent(tls *TLS) (r uintptr) { return uintptr(0) } X__getpwent_a(tls, _f2, uintptr(unsafe.Pointer(&_pw1)), uintptr(unsafe.Pointer(&_line4)), uintptr(unsafe.Pointer(&_size)), bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func Xgetpwuid(tls *TLS, uid Tuid_t) (r uintptr) { @@ -126804,7 +126804,7 @@ func Xgetpwuid(tls *TLS, uid Tuid_t) (r uintptr) { defer tls.Free(16) var _ /* res at bp+0 */ uintptr X__getpw_a(tls, uintptr(0), uid, uintptr(unsafe.Pointer(&_pw1)), uintptr(unsafe.Pointer(&_line4)), uintptr(unsafe.Pointer(&_size)), bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func Xgetpwnam(tls *TLS, name uintptr) (r uintptr) { @@ -126816,7 +126816,7 @@ func Xgetpwnam(tls *TLS, name uintptr) (r uintptr) { defer tls.Free(16) var _ /* res at bp+0 */ uintptr X__getpw_a(tls, name, uint32(0), uintptr(unsafe.Pointer(&_pw1)), uintptr(unsafe.Pointer(&_line4)), uintptr(unsafe.Pointer(&_size)), bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func Xendpwent(tls *TLS) { @@ -126831,14 +126831,14 @@ func _atou1(tls *TLS, s uintptr) (r uint32) { _ = x x = uint32(0) for { - if !(Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-int32('0')) < uint32(10)) { + if !(Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-int32('0')) < uint32(10)) { break } - x = uint32(10)*x + Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-Int32FromUint8('0')) + x = uint32(10)*x + Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-Int32FromUint8('0')) goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s)) = *(*uintptr)(unsafe.Pointer(s)) + 1 + **(**uintptr)(__ccgo_up(s)) = **(**uintptr)(__ccgo_up(s)) + 1 } return x } @@ -126863,79 +126863,79 @@ func X__getpwent_a(tls *TLS, f uintptr, pw uintptr, line uintptr, size uintptr, l = v2 if v2 < 0 { if Xferror(tls, f) != 0 { - v3 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v3 = **(**int32)(__ccgo_up(X__errno_location(tls))) } else { v3 = 0 } rv = v3 - Xfree(tls, *(*uintptr)(unsafe.Pointer(line))) - *(*uintptr)(unsafe.Pointer(line)) = uintptr(0) + Xfree(tls, **(**uintptr)(__ccgo_up(line))) + **(**uintptr)(__ccgo_up(line)) = uintptr(0) pw = uintptr(0) break } - *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(line)) + uintptr(l-int32(1)))) = uint8(0) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(line)) - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(line)) + uintptr(l-int32(1)))) = uint8(0) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(line)) + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = v4 - v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v4 + v4 = Xstrchr(tls, **(**uintptr)(__ccgo_up(bp)), int32(':')) + **(**uintptr)(__ccgo_up(bp)) = v4 if !(v4 != 0) { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = *(*uintptr)(unsafe.Pointer(bp)) - v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v4 + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = **(**uintptr)(__ccgo_up(bp)) + v4 = Xstrchr(tls, **(**uintptr)(__ccgo_up(bp)), int32(':')) + **(**uintptr)(__ccgo_up(bp)) = v4 if !(v4 != 0) { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) (*Tpasswd)(unsafe.Pointer(pw)).Fpw_uid = _atou1(tls, bp) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32(':') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) != int32(':') { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gid = _atou1(tls, bp) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32(':') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) != int32(':') { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = *(*uintptr)(unsafe.Pointer(bp)) - v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v4 + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = **(**uintptr)(__ccgo_up(bp)) + v4 = Xstrchr(tls, **(**uintptr)(__ccgo_up(bp)), int32(':')) + **(**uintptr)(__ccgo_up(bp)) = v4 if !(v4 != 0) { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = *(*uintptr)(unsafe.Pointer(bp)) - v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v4 + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = **(**uintptr)(__ccgo_up(bp)) + v4 = Xstrchr(tls, **(**uintptr)(__ccgo_up(bp)), int32(':')) + **(**uintptr)(__ccgo_up(bp)) = v4 if !(v4 != 0) { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = *(*uintptr)(unsafe.Pointer(bp)) + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = **(**uintptr)(__ccgo_up(bp)) break goto _1 _1: } - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 4)), uintptr(0)) - *(*uintptr)(unsafe.Pointer(res)) = pw + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 4)), uintptr(0)) + **(**uintptr)(__ccgo_up(res)) = pw if rv != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = rv + **(**int32)(__ccgo_up(X__errno_location(tls))) = rv } return rv } @@ -126999,7 +126999,7 @@ func X__nscd_query(tls *TLS, req Tint32_t, key uintptr, buf uintptr, len1 Tsize_ var _ /* req_buf at bp+16 */ [3]Tint32_t _, _, _, _, _, _, _ = errno_save, f, fd, i, v1, v3, v4 f = uintptr(0) - *(*[3]Tint32_t)(unsafe.Pointer(bp + 16)) = [3]Tint32_t{ + **(**[3]Tint32_t)(__ccgo_up(bp + 16)) = [3]Tint32_t{ 0: int32(NSCDVERSION), 1: req, 2: Int32FromUint32(Xstrnlen(tls, key, uint32(LOGIN_NAME_MAX)) + uint32(1)), @@ -127014,23 +127014,23 @@ func X__nscd_query(tls *TLS, req Tint32_t, key uintptr, buf uintptr, len1 Tsize_ Fiov_len: _strlen(tls, key) + uint32(1), }, } - *(*Tmsghdr)(unsafe.Pointer(bp + 28)) = Tmsghdr{ + **(**Tmsghdr)(__ccgo_up(bp + 28)) = Tmsghdr{ Fmsg_iov: bp, Fmsg_iovlen: int32(2), } - errno_save = *(*int32)(unsafe.Pointer(X__errno_location(tls))) - *(*int32)(unsafe.Pointer(swap)) = 0 + errno_save = **(**int32)(__ccgo_up(X__errno_location(tls))) + **(**int32)(__ccgo_up(swap)) = 0 goto retry retry: ; Xmemset(tls, buf, 0, len1) - *(*Tint32_t)(unsafe.Pointer(buf)) = int32(NSCDVERSION) + **(**Tint32_t)(__ccgo_up(buf)) = int32(NSCDVERSION) fd = Xsocket(tls, int32(PF_LOCAL), Int32FromInt32(SOCK_STREAM)|Int32FromInt32(SOCK_CLOEXEC), 0) if fd < 0 { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EAFNOSUPPORT) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EAFNOSUPPORT) { f = Xfopen(tls, __ccgo_ts+1173, __ccgo_ts+1183) if f != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = errno_save + **(**int32)(__ccgo_up(X__errno_location(tls))) = errno_save } return f } @@ -127042,7 +127042,7 @@ retry: Xclose(tls, fd) return uintptr(0) } - if (*(*[3]Tint32_t)(unsafe.Pointer(bp + 16)))[int32(2)] > int32(LOGIN_NAME_MAX) { + if (**(**[3]Tint32_t)(__ccgo_up(bp + 16)))[int32(2)] > int32(LOGIN_NAME_MAX) { return f } if Xconnect(tls, fd, uintptr(unsafe.Pointer(&_addr)), uint32(24)) < 0 { @@ -127050,8 +127050,8 @@ retry: * result and the caller is responsible for calling * fclose on the (unconnected) socket. The value of * errno must be left unchanged in this case. */ - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EACCES) || *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ECONNREFUSED) || *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENOENT) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = errno_save + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EACCES) || **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ECONNREFUSED) || **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENOENT) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = errno_save return f } goto error @@ -127068,41 +127068,41 @@ retry: if Xferror(tls, f) != 0 { goto error } - if !(*(*int32)(unsafe.Pointer(swap)) != 0) { + if !(**(**int32)(__ccgo_up(swap)) != 0) { Xfclose(tls, f) i = uint32(0) for { if !(i < Uint32FromInt64(12)/Uint32FromInt64(4)) { break } - v3 = Uint32FromInt32((*(*[3]Tint32_t)(unsafe.Pointer(bp + 16)))[i]) + v3 = Uint32FromInt32((**(**[3]Tint32_t)(__ccgo_up(bp + 16)))[i]) v4 = v3>>int32(24) | v3>>int32(8)&uint32(0xff00) | v3<>int32(24) | v3>>int32(8)&uint32(0xff00) | v3<> int32(16)) - *(*uint16)(unsafe.Pointer(xi + 2*2)) = uint16(x >> int32(32)) + x = uint64(uint32(**(**uint16)(__ccgo_up(xi)))|(uint32(**(**uint16)(__ccgo_up(xi + 1*2)))+0)<> int32(16)) + **(**uint16)(__ccgo_up(xi + 2*2)) = uint16(x >> int32(32)) return x & uint64(0xffffffffffff) } @@ -127414,8 +127414,8 @@ func Xrand_r(tls *TLS, seed uintptr) (r int32) { } var v1 uint32 _ = v1 - v1 = *(*uint32)(unsafe.Pointer(seed))*Uint32FromInt32(1103515245) + Uint32FromInt32(12345) - *(*uint32)(unsafe.Pointer(seed)) = v1 + v1 = **(**uint32)(__ccgo_up(seed))*Uint32FromInt32(1103515245) + Uint32FromInt32(12345) + **(**uint32)(__ccgo_up(seed)) = v1 return Int32FromUint32(_temper(tls, v1) / uint32(2)) } @@ -127474,15 +127474,15 @@ func _lcg64(tls *TLS, x Tuint64_t) (r Tuint64_t) { } func _savestate(tls *TLS) (r uintptr) { - *(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(-Int32FromInt32(1))*4)) = Uint32FromInt32(_n<> int32(16)) - _i = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(-Int32FromInt32(1))*4)) >> Int32FromInt32(8) & uint32(0xff)) - _j = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(-Int32FromInt32(1))*4)) & uint32(0xff)) + _n = Int32FromUint32(**(**Tuint32_t)(__ccgo_up(_x1 + uintptr(-Int32FromInt32(1))*4)) >> int32(16)) + _i = Int32FromUint32(**(**Tuint32_t)(__ccgo_up(_x1 + uintptr(-Int32FromInt32(1))*4)) >> Int32FromInt32(8) & uint32(0xff)) + _j = Int32FromUint32(**(**Tuint32_t)(__ccgo_up(_x1 + uintptr(-Int32FromInt32(1))*4)) & uint32(0xff)) } func ___srandom(tls *TLS, seed uint32) { @@ -127491,7 +127491,7 @@ func ___srandom(tls *TLS, seed uint32) { _, _, _ = k, s, v1 s = uint64(seed) if _n == 0 { - *(*Tuint32_t)(unsafe.Pointer(_x1)) = uint32(s) + **(**Tuint32_t)(__ccgo_up(_x1)) = uint32(s) return } if _n == int32(31) || _n == int32(7) { @@ -127507,14 +127507,14 @@ func ___srandom(tls *TLS, seed uint32) { break } s = _lcg64(tls, s) - *(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(k)*4)) = uint32(s >> int32(32)) + **(**Tuint32_t)(__ccgo_up(_x1 + uintptr(k)*4)) = uint32(s >> int32(32)) goto _2 _2: ; k = k + 1 } /* make sure x contains at least one odd number */ - *(*Tuint32_t)(unsafe.Pointer(_x1)) |= uint32(1) + **(**Tuint32_t)(__ccgo_up(_x1)) |= uint32(1) } func Xsrandom(tls *TLS, seed uint32) { @@ -127586,13 +127586,13 @@ func Xrandom(tls *TLS) (r int32) { _, _, _ = k, v1, v2 ___lock(tls, uintptr(unsafe.Pointer(&_lock3))) if _n == 0 { - v1 = _lcg31(tls, *(*Tuint32_t)(unsafe.Pointer(_x1))) - *(*Tuint32_t)(unsafe.Pointer(_x1)) = v1 + v1 = _lcg31(tls, **(**Tuint32_t)(__ccgo_up(_x1))) + **(**Tuint32_t)(__ccgo_up(_x1)) = v1 k = Int32FromUint32(v1) goto end } - *(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(_i)*4)) += *(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(_j)*4)) - k = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(_i)*4)) >> int32(1)) + **(**Tuint32_t)(__ccgo_up(_x1 + uintptr(_i)*4)) += **(**Tuint32_t)(__ccgo_up(_x1 + uintptr(_j)*4)) + k = Int32FromUint32(**(**Tuint32_t)(__ccgo_up(_x1 + uintptr(_i)*4)) >> int32(1)) _i = _i + 1 v2 = _i if v2 == _n { @@ -127798,8 +127798,8 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { defer func() { Xrealloc(tls, b, 0) }() path = Xgetenv(tls, __ccgo_ts+1276) seen_eacces = 0 - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOENT) - if !(*(*uint8)(unsafe.Pointer(file)) != 0) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOENT) + if !(**(**uint8)(__ccgo_up(file)) != 0) { return -int32(1) } if Xstrchr(tls, file, int32('/')) != 0 { @@ -127810,7 +127810,7 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { } k = Xstrnlen(tls, file, Uint32FromInt32(Int32FromInt32(NAME_MAX)+Int32FromInt32(1))) if k > uint32(NAME_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENAMETOOLONG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENAMETOOLONG) return -int32(1) } l = Xstrnlen(tls, path, Uint32FromInt32(Int32FromInt32(PATH_MAX)-Int32FromInt32(1))) + uint32(1) @@ -127822,7 +127822,7 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { if Uint32FromInt32(int32(z)-int32(p)) >= l { v3 = z z = z + 1 - if !(*(*uint8)(unsafe.Pointer(v3)) != 0) { + if !(**(**uint8)(__ccgo_up(v3)) != 0) { break } goto _1 @@ -127831,7 +127831,7 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { *(*uint8)(unsafe.Add(unsafe.Pointer(b), int32(z)-int32(p))) = uint8('/') _memcpy(tls, b+uintptr(int32(z)-int32(p))+BoolUintptr(z > p), file, k+uint32(1)) Xexecve(tls, b, argv, envp) - switch *(*int32)(unsafe.Pointer(X__errno_location(tls))) { + switch **(**int32)(__ccgo_up(X__errno_location(tls))) { case int32(EACCES): seen_eacces = int32(1) fallthrough @@ -127843,7 +127843,7 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { } v3 = z z = z + 1 - if !(*(*uint8)(unsafe.Pointer(v3)) != 0) { + if !(**(**uint8)(__ccgo_up(v3)) != 0) { break } goto _1 @@ -127852,7 +127852,7 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { p = z } if seen_eacces != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EACCES) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EACCES) } return -int32(1) } @@ -127889,8 +127889,8 @@ func Xfexecve(tls *TLS, fd int32, argv uintptr, envp uintptr) (r1 int32) { } X__procfdname(tls, bp, Uint32FromInt32(fd)) Xexecve(tls, bp, argv, envp) - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENOENT) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EBADF) + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENOENT) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EBADF) } return -int32(1) } @@ -128127,7 +128127,7 @@ func Xposix_spawnattr_getflags(tls *TLS, attr uintptr, flags uintptr) (r int32) trc("tls=%v attr=%v flags=%v, (%v:)", tls, attr, flags, origin(2)) defer func() { trc("-> %v", r) }() } - *(*int16)(unsafe.Pointer(flags)) = int16((*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__flags) + **(**int16)(__ccgo_up(flags)) = int16((*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__flags) return 0 } @@ -128136,7 +128136,7 @@ func Xposix_spawnattr_getpgroup(tls *TLS, attr uintptr, pgrp uintptr) (r int32) trc("tls=%v attr=%v pgrp=%v, (%v:)", tls, attr, pgrp, origin(2)) defer func() { trc("-> %v", r) }() } - *(*Tpid_t)(unsafe.Pointer(pgrp)) = (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__pgrp + **(**Tpid_t)(__ccgo_up(pgrp)) = (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__pgrp return 0 } @@ -128145,7 +128145,7 @@ func Xposix_spawnattr_getsigdefault(tls *TLS, attr uintptr, def uintptr) (r int3 trc("tls=%v attr=%v def=%v, (%v:)", tls, attr, def, origin(2)) defer func() { trc("-> %v", r) }() } - *(*Tsigset_t)(unsafe.Pointer(def)) = (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__def + **(**Tsigset_t)(__ccgo_up(def)) = (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__def return 0 } @@ -128154,7 +128154,7 @@ func Xposix_spawnattr_getsigmask(tls *TLS, attr uintptr, mask uintptr) (r int32) trc("tls=%v attr=%v mask=%v, (%v:)", tls, attr, mask, origin(2)) defer func() { trc("-> %v", r) }() } - *(*Tsigset_t)(unsafe.Pointer(mask)) = (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__mask + **(**Tsigset_t)(__ccgo_up(mask)) = (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__mask return 0 } @@ -128163,7 +128163,7 @@ func Xposix_spawnattr_init(tls *TLS, attr uintptr) (r int32) { trc("tls=%v attr=%v, (%v:)", tls, attr, origin(2)) defer func() { trc("-> %v", r) }() } - *(*Tposix_spawnattr_t)(unsafe.Pointer(attr)) = Tposix_spawnattr_t{} + **(**Tposix_spawnattr_t)(__ccgo_up(attr)) = Tposix_spawnattr_t{} return 0 } @@ -128228,7 +128228,7 @@ func Xposix_spawnattr_setsigdefault(tls *TLS, attr uintptr, def uintptr) (r int3 trc("tls=%v attr=%v def=%v, (%v:)", tls, attr, def, origin(2)) defer func() { trc("-> %v", r) }() } - (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__def = *(*Tsigset_t)(unsafe.Pointer(def)) + (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__def = **(**Tsigset_t)(__ccgo_up(def)) return 0 } @@ -128237,7 +128237,7 @@ func Xposix_spawnattr_setsigmask(tls *TLS, attr uintptr, mask uintptr) (r int32) trc("tls=%v attr=%v mask=%v, (%v:)", tls, attr, mask, origin(2)) defer func() { trc("-> %v", r) }() } - (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__mask = *(*Tsigset_t)(unsafe.Pointer(mask)) + (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__mask = **(**Tsigset_t)(__ccgo_up(mask)) return 0 } @@ -128295,20 +128295,20 @@ func _str_next(tls *TLS, str uintptr, n Tsize_t, step uintptr) (r int32) { var _ /* wc at bp+0 */ Twchar_t _ = k if !(n != 0) { - *(*Tsize_t)(unsafe.Pointer(step)) = uint32(0) + **(**Tsize_t)(__ccgo_up(step)) = uint32(0) return 0 } - if uint32(*(*uint8)(unsafe.Pointer(str))) >= uint32(128) { + if uint32(**(**uint8)(__ccgo_up(str))) >= uint32(128) { k = Xmbtowc(tls, bp, str, n) if k < 0 { - *(*Tsize_t)(unsafe.Pointer(step)) = uint32(1) + **(**Tsize_t)(__ccgo_up(step)) = uint32(1) return -int32(1) } - *(*Tsize_t)(unsafe.Pointer(step)) = Uint32FromInt32(k) - return Int32FromUint32(*(*Twchar_t)(unsafe.Pointer(bp))) + **(**Tsize_t)(__ccgo_up(step)) = Uint32FromInt32(k) + return Int32FromUint32(**(**Twchar_t)(__ccgo_up(bp))) } - *(*Tsize_t)(unsafe.Pointer(step)) = uint32(1) - return Int32FromUint8(*(*uint8)(unsafe.Pointer(str))) + **(**Tsize_t)(__ccgo_up(step)) = uint32(1) + return Int32FromUint8(**(**uint8)(__ccgo_up(str))) } func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r int32) { @@ -128319,43 +128319,43 @@ func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r i var _ /* wc at bp+0 */ Twchar_t _, _, _, _ = esc, k, k1, z esc = 0 - if !(m != 0) || !(*(*uint8)(unsafe.Pointer(pat)) != 0) { - *(*Tsize_t)(unsafe.Pointer(step)) = uint32(0) + if !(m != 0) || !(**(**uint8)(__ccgo_up(pat)) != 0) { + **(**Tsize_t)(__ccgo_up(step)) = uint32(0) return END } - *(*Tsize_t)(unsafe.Pointer(step)) = uint32(1) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) == int32('\\') && *(*uint8)(unsafe.Pointer(pat + 1)) != 0 && !(flags&Int32FromInt32(FNM_NOESCAPE) != 0) { - *(*Tsize_t)(unsafe.Pointer(step)) = uint32(2) + **(**Tsize_t)(__ccgo_up(step)) = uint32(1) + if Int32FromUint8(**(**uint8)(__ccgo_up(pat))) == int32('\\') && **(**uint8)(__ccgo_up(pat + 1)) != 0 && !(flags&Int32FromInt32(FNM_NOESCAPE) != 0) { + **(**Tsize_t)(__ccgo_up(step)) = uint32(2) pat = pat + 1 esc = int32(1) goto escaped } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) == int32('[') { + if Int32FromUint8(**(**uint8)(__ccgo_up(pat))) == int32('[') { k = uint32(1) if k < m { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) == int32('^') || Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) == int32('!') { + if Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k)))) == int32('^') || Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k)))) == int32('!') { k = k + 1 } } if k < m { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) == int32(']') { + if Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k)))) == int32(']') { k = k + 1 } } for { - if !(k < m && *(*uint8)(unsafe.Pointer(pat + uintptr(k))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) != int32(']')) { + if !(k < m && **(**uint8)(__ccgo_up(pat + uintptr(k))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k)))) != int32(']')) { break } - if k+uint32(1) < m && *(*uint8)(unsafe.Pointer(pat + uintptr(k+uint32(1)))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) == int32('[') && (Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k+uint32(1))))) == int32(':') || Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k+uint32(1))))) == int32('.') || Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k+uint32(1))))) == int32('=')) { - z = Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k+uint32(1))))) + if k+uint32(1) < m && **(**uint8)(__ccgo_up(pat + uintptr(k+uint32(1)))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k)))) == int32('[') && (Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k+uint32(1))))) == int32(':') || Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k+uint32(1))))) == int32('.') || Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k+uint32(1))))) == int32('=')) { + z = Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k+uint32(1))))) k = k + uint32(2) - if k < m && *(*uint8)(unsafe.Pointer(pat + uintptr(k))) != 0 { + if k < m && **(**uint8)(__ccgo_up(pat + uintptr(k))) != 0 { k = k + 1 } - for k < m && *(*uint8)(unsafe.Pointer(pat + uintptr(k))) != 0 && (Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k-uint32(1))))) != z || Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) != int32(']')) { + for k < m && **(**uint8)(__ccgo_up(pat + uintptr(k))) != 0 && (Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k-uint32(1))))) != z || Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k)))) != int32(']')) { k = k + 1 } - if k == m || !(*(*uint8)(unsafe.Pointer(pat + uintptr(k))) != 0) { + if k == m || !(**(**uint8)(__ccgo_up(pat + uintptr(k))) != 0) { break } } @@ -128364,32 +128364,32 @@ func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r i ; k = k + 1 } - if k == m || !(*(*uint8)(unsafe.Pointer(pat + uintptr(k))) != 0) { - *(*Tsize_t)(unsafe.Pointer(step)) = uint32(1) + if k == m || !(**(**uint8)(__ccgo_up(pat + uintptr(k))) != 0) { + **(**Tsize_t)(__ccgo_up(step)) = uint32(1) return int32('[') } - *(*Tsize_t)(unsafe.Pointer(step)) = k + uint32(1) + **(**Tsize_t)(__ccgo_up(step)) = k + uint32(1) return -int32(3) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) == int32('*') { + if Int32FromUint8(**(**uint8)(__ccgo_up(pat))) == int32('*') { return -int32(5) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) == int32('?') { + if Int32FromUint8(**(**uint8)(__ccgo_up(pat))) == int32('?') { return -int32(4) } goto escaped escaped: ; - if uint32(*(*uint8)(unsafe.Pointer(pat))) >= uint32(128) { + if uint32(**(**uint8)(__ccgo_up(pat))) >= uint32(128) { k1 = Xmbtowc(tls, bp, pat, m) if k1 < 0 { - *(*Tsize_t)(unsafe.Pointer(step)) = uint32(0) + **(**Tsize_t)(__ccgo_up(step)) = uint32(0) return -int32(2) } - *(*Tsize_t)(unsafe.Pointer(step)) = Uint32FromInt32(k1 + esc) - return Int32FromUint32(*(*Twchar_t)(unsafe.Pointer(bp))) + **(**Tsize_t)(__ccgo_up(step)) = Uint32FromInt32(k1 + esc) + return Int32FromUint32(**(**Twchar_t)(__ccgo_up(bp))) } - return Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) + return Int32FromUint8(**(**uint8)(__ccgo_up(pat))) } func _casefold(tls *TLS, k int32) (r int32) { @@ -128416,59 +128416,59 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { _, _, _, _, _ = inv, l, l1, p0, z inv = 0 p = p + 1 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('^') || Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('!') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('^') || Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('!') { inv = int32(1) p = p + 1 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32(']') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32(']') { if k == int32(']') { return BoolInt32(!(inv != 0)) } p = p + 1 } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('-') { if k == int32('-') { return BoolInt32(!(inv != 0)) } p = p + 1 } } - *(*Twchar_t)(unsafe.Pointer(bp)) = uint32(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) + **(**Twchar_t)(__ccgo_up(bp)) = uint32(**(**uint8)(__ccgo_up(p + uintptr(-Int32FromInt32(1))))) for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32(']')) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(p))) != int32(']')) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') && Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) != int32(']') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('-') && Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) != int32(']') { l = Xmbtowc(tls, bp+4, p+uintptr(1), uint32(4)) if l < 0 { return 0 } - if *(*Twchar_t)(unsafe.Pointer(bp)) <= *(*Twchar_t)(unsafe.Pointer(bp + 4)) { - if Uint32FromInt32(k)-*(*Twchar_t)(unsafe.Pointer(bp)) <= *(*Twchar_t)(unsafe.Pointer(bp + 4))-*(*Twchar_t)(unsafe.Pointer(bp)) || Uint32FromInt32(kfold)-*(*Twchar_t)(unsafe.Pointer(bp)) <= *(*Twchar_t)(unsafe.Pointer(bp + 4))-*(*Twchar_t)(unsafe.Pointer(bp)) { + if **(**Twchar_t)(__ccgo_up(bp)) <= **(**Twchar_t)(__ccgo_up(bp + 4)) { + if Uint32FromInt32(k)-**(**Twchar_t)(__ccgo_up(bp)) <= **(**Twchar_t)(__ccgo_up(bp + 4))-**(**Twchar_t)(__ccgo_up(bp)) || Uint32FromInt32(kfold)-**(**Twchar_t)(__ccgo_up(bp)) <= **(**Twchar_t)(__ccgo_up(bp + 4))-**(**Twchar_t)(__ccgo_up(bp)) { return BoolInt32(!(inv != 0)) } } p = p + uintptr(l-int32(1)) goto _1 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('[') && (Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32(':') || Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('.') || Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('=')) { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('[') && (Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) == int32(':') || Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) == int32('.') || Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) == int32('=')) { p0 = p + uintptr(2) - z = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) + z = Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) p = p + uintptr(3) - for Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) != z || Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32(']') { + for Int32FromUint8(**(**uint8)(__ccgo_up(p + uintptr(-Int32FromInt32(1))))) != z || Int32FromUint8(**(**uint8)(__ccgo_up(p))) != int32(']') { p = p + 1 } if z == int32(':') && int32(p-uintptr(1))-int32(p0) < int32(16) { _memcpy(tls, bp+8, p0, Uint32FromInt32(int32(p-uintptr(1))-int32(p0))) - (*(*[16]uint8)(unsafe.Pointer(bp + 8)))[int32(p-uintptr(1))-int32(p0)] = uint8(0) + (**(**[16]uint8)(__ccgo_up(bp + 8)))[int32(p-uintptr(1))-int32(p0)] = uint8(0) if Xiswctype(tls, Uint32FromInt32(k), Xwctype(tls, bp+8)) != 0 || Xiswctype(tls, Uint32FromInt32(kfold), Xwctype(tls, bp+8)) != 0 { return BoolInt32(!(inv != 0)) } } goto _1 } - if uint32(*(*uint8)(unsafe.Pointer(p))) < uint32(128) { - *(*Twchar_t)(unsafe.Pointer(bp)) = uint32(*(*uint8)(unsafe.Pointer(p))) + if uint32(**(**uint8)(__ccgo_up(p))) < uint32(128) { + **(**Twchar_t)(__ccgo_up(bp)) = uint32(uint8(**(**uint8)(__ccgo_up(p)))) } else { l1 = Xmbtowc(tls, bp, p, uint32(4)) if l1 < 0 { @@ -128476,7 +128476,7 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { } p = p + uintptr(l1-int32(1)) } - if *(*Twchar_t)(unsafe.Pointer(bp)) == Uint32FromInt32(k) || *(*Twchar_t)(unsafe.Pointer(bp)) == Uint32FromInt32(kfold) { + if **(**Twchar_t)(__ccgo_up(bp)) == Uint32FromInt32(k) || **(**Twchar_t)(__ccgo_up(bp)) == Uint32FromInt32(kfold) { return BoolInt32(!(inv != 0)) } goto _1 @@ -128499,7 +128499,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, endpat, endstr, k, kfold, p, ptail, s, stail, tailcnt, v2, v6, v9 tailcnt = uint32(0) if flags&int32(FNM_PERIOD) != 0 { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(str))) == int32('.') && Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) != int32('.') { + if Int32FromUint8(**(**uint8)(__ccgo_up(str))) == int32('.') && Int32FromUint8(**(**uint8)(__ccgo_up(pat))) != int32('.') { return int32(FNM_NOMATCH) } } @@ -128522,8 +128522,8 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, } return v2 } - str = str + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 4))) - n = n - *(*Tsize_t)(unsafe.Pointer(bp + 4)) + str = str + uintptr(**(**Tsize_t)(__ccgo_up(bp + 4))) + n = n - **(**Tsize_t)(__ccgo_up(bp + 4)) if flags&int32(FNM_CASEFOLD) != 0 { v2 = _casefold(tls, k) } else { @@ -128539,8 +128539,8 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, return int32(FNM_NOMATCH) } } - pat = pat + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) - m = m - *(*Tsize_t)(unsafe.Pointer(bp)) + pat = pat + uintptr(**(**Tsize_t)(__ccgo_up(bp))) + m = m - **(**Tsize_t)(__ccgo_up(bp)) goto _1 } break @@ -128571,7 +128571,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, goto _5 _5: ; - p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(**(**Tsize_t)(__ccgo_up(bp))) } /* Past this point we need not check for UNMATCHABLE in pat, * because all of pat has already been parsed once. */ @@ -128589,8 +128589,8 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, if !(s > str && tailcnt != 0) { break } - if v9 = uint32(*(*uint8)(unsafe.Pointer(s + uintptr(-Int32FromInt32(1))))) < uint32(128); !v9 { - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if v9 = uint32(**(**uint8)(__ccgo_up(s + uintptr(-Int32FromInt32(1))))) < uint32(128); !v9 { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v2 = int32(4) } else { v2 = int32(1) @@ -128602,7 +128602,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, for { s = s - 1 v6 = s - if !(uint32(*(*uint8)(unsafe.Pointer(v6)))-uint32(0x80) < uint32(0x40) && s > str) { + if !(uint32(uint8(**(**uint8)(__ccgo_up(v6))))-uint32(0x80) < uint32(0x40) && s > str) { break } } @@ -128620,7 +128620,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, p = ptail for { c = _pat_next(tls, p, Uint32FromInt32(int32(endpat)-int32(p)), bp, flags) - p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(**(**Tsize_t)(__ccgo_up(bp))) v2 = _str_next(tls, s, Uint32FromInt32(int32(endstr)-int32(s)), bp+4) k = v2 if v2 <= 0 { @@ -128629,7 +128629,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, } break } - s = s + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 4))) + s = s + uintptr(**(**Tsize_t)(__ccgo_up(bp + 4))) if flags&int32(FNM_CASEFOLD) != 0 { v2 = _casefold(tls, k) } else { @@ -128637,7 +128637,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, } kfold = v2 if c == -int32(3) { - if !(_match_bracket(tls, p-uintptr(*(*Tsize_t)(unsafe.Pointer(bp))), k, kfold) != 0) { + if !(_match_bracket(tls, p-uintptr(**(**Tsize_t)(__ccgo_up(bp))), k, kfold) != 0) { return int32(FNM_NOMATCH) } } else { @@ -128657,7 +128657,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, s = str for { c = _pat_next(tls, p, Uint32FromInt32(int32(endpat)-int32(p)), bp, flags) - p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(**(**Tsize_t)(__ccgo_up(bp))) /* Encountering * completes/commits a component */ if c == -int32(5) { pat = p @@ -128675,7 +128675,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, } kfold = v2 if c == -int32(3) { - if !(_match_bracket(tls, p-uintptr(*(*Tsize_t)(unsafe.Pointer(bp))), k, kfold) != 0) { + if !(_match_bracket(tls, p-uintptr(**(**Tsize_t)(__ccgo_up(bp))), k, kfold) != 0) { break } } else { @@ -128683,7 +128683,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, break } } - s = s + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 4))) + s = s + uintptr(**(**Tsize_t)(__ccgo_up(bp + 4))) goto _14 _14: } @@ -128694,7 +128694,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, * char, or past all invalid bytes otherwise. */ k = _str_next(tls, str, Uint32FromInt32(int32(endstr)-int32(str)), bp+4) if k > 0 { - str = str + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 4))) + str = str + uintptr(**(**Tsize_t)(__ccgo_up(bp + 4))) } else { str = str + 1 for { @@ -128726,7 +128726,7 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { for { s = str for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('/')) { + if !(**(**uint8)(__ccgo_up(s)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32('/')) { break } goto _2 @@ -128744,9 +128744,9 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { goto _3 _3: ; - p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(**(**Tsize_t)(__ccgo_up(bp))) } - if c != Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) && (!(*(*uint8)(unsafe.Pointer(s)) != 0) || !(flags&Int32FromInt32(FNM_LEADING_DIR) != 0)) { + if c != Int32FromUint8(**(**uint8)(__ccgo_up(s))) && (!(**(**uint8)(__ccgo_up(s)) != 0) || !(flags&Int32FromInt32(FNM_LEADING_DIR) != 0)) { return int32(FNM_NOMATCH) } if _fnmatch_internal(tls, pat, Uint32FromInt32(int32(p)-int32(pat)), str, Uint32FromInt32(int32(s)-int32(str)), flags) != 0 { @@ -128756,7 +128756,7 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { return 0 } str = s + uintptr(1) - pat = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + pat = p + uintptr(**(**Tsize_t)(__ccgo_up(bp))) goto _1 _1: } @@ -128764,10 +128764,10 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { if flags&int32(FNM_LEADING_DIR) != 0 { s = str for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('/') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32('/') { goto _5 } if !(_fnmatch_internal(tls, pat, Uint32FromInt32(-Int32FromInt32(1)), str, Uint32FromInt32(int32(s)-int32(str)), flags) != 0) { @@ -128817,14 +128817,14 @@ func _append(tls *TLS, tail uintptr, name uintptr, len1 Tsize_t, mark int32) (r if !(new1 != 0) { return -int32(1) } - (*Tmatch)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tail)))).Fnext = new1 + (*Tmatch)(unsafe.Pointer(**(**uintptr)(__ccgo_up(tail)))).Fnext = new1 (*Tmatch)(unsafe.Pointer(new1)).Fnext = UintptrFromInt32(0) _memcpy(tls, new1+4, name, len1+uint32(1)) - if mark != 0 && len1 != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(name + uintptr(len1-uint32(1))))) != int32('/') { + if mark != 0 && len1 != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(name + uintptr(len1-uint32(1))))) != int32('/') { *(*uint8)(unsafe.Pointer(new1 + 4 + uintptr(len1))) = uint8('/') *(*uint8)(unsafe.Pointer(new1 + 4 + uintptr(len1+uint32(1)))) = uint8(0) } - *(*uintptr)(unsafe.Pointer(tail)) = new1 + **(**uintptr)(__ccgo_up(tail)) = new1 return 0 } @@ -128844,15 +128844,15 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag } /* Special-case the remaining pattern being all slashes, in * which case we can use caller-passed type if it's a dir. */ - if *(*uint8)(unsafe.Pointer(pat)) != 0 && type1 != int32(DT_DIR) { + if **(**uint8)(__ccgo_up(pat)) != 0 && type1 != int32(DT_DIR) { type1 = 0 } - for pos+uint32(1) < uint32(PATH_MAX) && Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) == int32('/') { + for pos+uint32(1) < uint32(PATH_MAX) && Int32FromUint8(**(**uint8)(__ccgo_up(pat))) == int32('/') { v1 = pos pos = pos + 1 v2 = pat pat = pat + 1 - *(*uint8)(unsafe.Pointer(buf + uintptr(v1))) = *(*uint8)(unsafe.Pointer(v2)) + **(**uint8)(__ccgo_up(buf + uintptr(v1))) = **(**uint8)(__ccgo_up(v2)) } /* Consume maximal [escaped-]literal prefix of pattern, copying * and un-escaping it to the running buffer as we go. */ @@ -128861,10 +128861,10 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag in_bracket = 0 overflow = 0 for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(i)))) != int32('*') && Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(i)))) != int32('?') && (!(in_bracket != 0) || Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(i)))) != int32(']'))) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(i)))) != int32('*') && Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(i)))) != int32('?') && (!(in_bracket != 0) || Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(i)))) != int32(']'))) { break } - if !(*(*uint8)(unsafe.Pointer(pat + uintptr(i))) != 0) { + if !(**(**uint8)(__ccgo_up(pat + uintptr(i))) != 0) { if overflow != 0 { return 0 } @@ -128875,25 +128875,25 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag i = v4 break } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(i)))) == int32('[') { + if Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(i)))) == int32('[') { in_bracket = int32(1) } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(i)))) == int32('\\') && !(flags&Int32FromInt32(GLOB_NOESCAPE) != 0) { + if Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(i)))) == int32('\\') && !(flags&Int32FromInt32(GLOB_NOESCAPE) != 0) { /* Backslashes inside a bracket are (at least by * our interpretation) non-special, so if next * char is ']' we have a complete expression. */ - if in_bracket != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(i+int32(1))))) == int32(']') { + if in_bracket != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(i+int32(1))))) == int32(']') { break } /* Unpaired final backslash never matches. */ - if !(*(*uint8)(unsafe.Pointer(pat + uintptr(i+int32(1)))) != 0) { + if !(**(**uint8)(__ccgo_up(pat + uintptr(i+int32(1)))) != 0) { return 0 } i = i + 1 } } } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(i)))) == int32('/') { + if Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(i)))) == int32('/') { if overflow != 0 { return 0 } @@ -128911,7 +128911,7 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag if pos+Uint32FromInt32(j+Int32FromInt32(1)) < uint32(PATH_MAX) { v4 = j j = j + 1 - *(*uint8)(unsafe.Pointer(buf + uintptr(pos+Uint32FromInt32(v4)))) = *(*uint8)(unsafe.Pointer(pat + uintptr(i))) + **(**uint8)(__ccgo_up(buf + uintptr(pos+Uint32FromInt32(v4)))) = **(**uint8)(__ccgo_up(pat + uintptr(i))) } else { if in_bracket != 0 { overflow = int32(1) @@ -128927,17 +128927,17 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag ; i = i + 1 } - *(*uint8)(unsafe.Pointer(buf + uintptr(pos))) = uint8(0) - if !(*(*uint8)(unsafe.Pointer(pat)) != 0) { + **(**uint8)(__ccgo_up(buf + uintptr(pos))) = uint8(0) + if !(**(**uint8)(__ccgo_up(pat)) != 0) { if flags&int32(GLOB_MARK) != 0 && (!(type1 != 0) || type1 == int32(DT_LNK)) && !(Xstat(tls, buf, bp) != 0) { - if (*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFDIR) { + if (**(**Tstat)(__ccgo_up(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFDIR) { type1 = int32(DT_DIR) } else { type1 = int32(DT_REG) } } if !(type1 != 0) && Xlstat(tls, buf, bp) != 0 { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(ENOENT) && ((*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(ENOENT) && ((*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, **(**int32)(__ccgo_up(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0) { return int32(GLOB_ABORTED) } return 0 @@ -128954,7 +128954,7 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag if p2 != 0 && !(flags&Int32FromInt32(GLOB_NOESCAPE) != 0) { p = p2 for { - if !(p > pat && Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) == int32('\\')) { + if !(p > pat && Int32FromUint8(**(**uint8)(__ccgo_up(p + uintptr(-Int32FromInt32(1))))) == int32('\\')) { break } goto _6 @@ -128974,14 +128974,14 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag } dir = Xopendir(tls, v2) if !(dir != 0) { - if (*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0 { + if (*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, **(**int32)(__ccgo_up(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0 { return int32(GLOB_ABORTED) } return 0 } - old_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + old_errno = **(**int32)(__ccgo_up(X__errno_location(tls))) for { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = 0 + **(**int32)(__ccgo_up(X__errno_location(tls))) = 0 v2 = Xreaddir(tls, dir) de = v2 if !(v2 != 0) { @@ -128996,7 +128996,7 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag continue } if p2 != 0 { - *(*uint8)(unsafe.Pointer(p2)) = uint8(0) + **(**uint8)(__ccgo_up(p2)) = uint8(0) } if flags&int32(GLOB_NOESCAPE) != 0 { v9 = int32(FNM_NOESCAPE) @@ -129014,12 +129014,12 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag } /* With GLOB_PERIOD, don't allow matching . or .. unless * fnmatch would match them with FNM_PERIOD rules in effect. */ - if p2 != 0 && flags&int32(GLOB_PERIOD) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(de + 19))) == int32('.') && (!(*(*uint8)(unsafe.Pointer(de + 19 + 1)) != 0) || Int32FromUint8(*(*uint8)(unsafe.Pointer(de + 19 + 1))) == int32('.') && !(*(*uint8)(unsafe.Pointer(de + 19 + 2)) != 0)) && Xfnmatch(tls, pat, de+19, fnm_flags|int32(FNM_PERIOD)) != 0 { + if p2 != 0 && flags&int32(GLOB_PERIOD) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(de + 19))) == int32('.') && (!(**(**uint8)(__ccgo_up(de + 19 + 1)) != 0) || Int32FromUint8(**(**uint8)(__ccgo_up(de + 19 + 1))) == int32('.') && !(**(**uint8)(__ccgo_up(de + 19 + 2)) != 0)) && Xfnmatch(tls, pat, de+19, fnm_flags|int32(FNM_PERIOD)) != 0 { continue } _memcpy(tls, buf+uintptr(pos), de+19, l+uint32(1)) if p2 != 0 { - *(*uint8)(unsafe.Pointer(p2)) = saved_sep + **(**uint8)(__ccgo_up(p2)) = saved_sep } if p2 != 0 { v2 = p2 @@ -129032,15 +129032,15 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag return r } } - readerr = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + readerr = **(**int32)(__ccgo_up(X__errno_location(tls))) if p2 != 0 { - *(*uint8)(unsafe.Pointer(p2)) = saved_sep + **(**uint8)(__ccgo_up(p2)) = saved_sep } Xclosedir(tls, dir) - if readerr != 0 && ((*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0) { + if readerr != 0 && ((*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, **(**int32)(__ccgo_up(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0) { return int32(GLOB_ABORTED) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = old_errno + **(**int32)(__ccgo_up(X__errno_location(tls))) = old_errno return 0 } @@ -129066,7 +129066,7 @@ func _freelist(tls *TLS, head uintptr) { } func _sort(tls *TLS, a uintptr, b uintptr) (r int32) { - return Xstrcmp(tls, *(*uintptr)(unsafe.Pointer(a)), *(*uintptr)(unsafe.Pointer(b))) + return Xstrcmp(tls, **(**uintptr)(__ccgo_up(a)), **(**uintptr)(__ccgo_up(b))) } func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { @@ -129079,25 +129079,25 @@ func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { var _ /* pw at bp+0 */ Tpasswd var _ /* res at bp+28 */ uintptr _, _, _, _, _, _, _, _, _ = delim, home, i, name_end, p, v1, v10, v2, v4 - p = *(*uintptr)(unsafe.Pointer(pat)) + uintptr(1) + p = **(**uintptr)(__ccgo_up(pat)) + uintptr(1) i = uint32(0) name_end = X__strchrnul(tls, p, int32('/')) - v1 = *(*uint8)(unsafe.Pointer(name_end)) + v1 = **(**uint8)(__ccgo_up(name_end)) delim = v1 if v1 != 0 { v2 = name_end name_end = name_end + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8(0) + **(**uint8)(__ccgo_up(v2)) = uint8(0) } - *(*uintptr)(unsafe.Pointer(pat)) = name_end - if *(*uint8)(unsafe.Pointer(p)) != 0 { + **(**uintptr)(__ccgo_up(pat)) = name_end + if **(**uint8)(__ccgo_up(p)) != 0 { v2 = UintptrFromInt32(0) } else { v2 = Xgetenv(tls, __ccgo_ts+1310) } home = v2 if !(home != 0) { - if *(*uint8)(unsafe.Pointer(p)) != 0 { + if **(**uint8)(__ccgo_up(p)) != 0 { v4 = Xgetpwnam_r(tls, p, bp, buf, uint32(PATH_MAX), bp+28) } else { v4 = Xgetpwuid_r(tls, Xgetuid(tls), bp, buf, uint32(PATH_MAX), bp+28) @@ -129116,7 +129116,7 @@ func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { return int32(GLOB_NOSPACE) _7: ; - if !!(*(*uintptr)(unsafe.Pointer(bp + 28)) != 0) { + if !!(**(**uintptr)(__ccgo_up(bp + 28)) != 0) { goto _9 } _6: @@ -129126,26 +129126,26 @@ func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { ; _8: ; - home = (*(*Tpasswd)(unsafe.Pointer(bp))).Fpw_dir + home = (**(**Tpasswd)(__ccgo_up(bp))).Fpw_dir } - for i < Uint32FromInt32(Int32FromInt32(PATH_MAX)-Int32FromInt32(2)) && *(*uint8)(unsafe.Pointer(home)) != 0 { + for i < Uint32FromInt32(Int32FromInt32(PATH_MAX)-Int32FromInt32(2)) && **(**uint8)(__ccgo_up(home)) != 0 { v10 = i i = i + 1 v2 = home home = home + 1 - *(*uint8)(unsafe.Pointer(buf + uintptr(v10))) = *(*uint8)(unsafe.Pointer(v2)) + **(**uint8)(__ccgo_up(buf + uintptr(v10))) = **(**uint8)(__ccgo_up(v2)) } - if *(*uint8)(unsafe.Pointer(home)) != 0 { + if **(**uint8)(__ccgo_up(home)) != 0 { return int32(GLOB_NOMATCH) } v1 = delim - *(*uint8)(unsafe.Pointer(buf + uintptr(i))) = v1 + **(**uint8)(__ccgo_up(buf + uintptr(i))) = v1 if v1 != 0 { i = i + 1 v10 = i - *(*uint8)(unsafe.Pointer(buf + uintptr(v10))) = uint8(0) + **(**uint8)(__ccgo_up(buf + uintptr(v10))) = uint8(0) } - *(*Tsize_t)(unsafe.Pointer(pos)) = i + **(**Tsize_t)(__ccgo_up(pos)) = i return 0 } @@ -129168,10 +129168,10 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint var _ /* s at bp+4108 */ uintptr var _ /* tail at bp+4 */ uintptr _, _, _, _, _, _, _ = cnt, error1, i, offs, p, pathv, v1 - *(*Tmatch)(unsafe.Pointer(bp)) = struct { + **(**Tmatch)(__ccgo_up(bp)) = struct { Fnext uintptr }{} - *(*uintptr)(unsafe.Pointer(bp + 4)) = bp + **(**uintptr)(__ccgo_up(bp + 4)) = bp if flags&int32(GLOB_DOOFFS) != 0 { v1 = (*Tglob_t)(unsafe.Pointer(g)).Fgl_offs } else { @@ -129187,19 +129187,19 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathc = uint32(0) (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv = UintptrFromInt32(0) } - if *(*uint8)(unsafe.Pointer(pat)) != 0 { + if **(**uint8)(__ccgo_up(pat)) != 0 { p = Xstrdup(tls, pat) if !(p != 0) { return int32(GLOB_NOSPACE) } - (*(*[4096]uint8)(unsafe.Pointer(bp + 8)))[0] = uint8(0) - *(*Tsize_t)(unsafe.Pointer(bp + 4104)) = uint32(0) - *(*uintptr)(unsafe.Pointer(bp + 4108)) = p - if flags&(Int32FromInt32(GLOB_TILDE)|Int32FromInt32(GLOB_TILDE_CHECK)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('~') { + (**(**[4096]uint8)(__ccgo_up(bp + 8)))[0] = uint8(0) + **(**Tsize_t)(__ccgo_up(bp + 4104)) = uint32(0) + **(**uintptr)(__ccgo_up(bp + 4108)) = p + if flags&(Int32FromInt32(GLOB_TILDE)|Int32FromInt32(GLOB_TILDE_CHECK)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('~') { error1 = _expand_tilde(tls, bp+4108, bp+8, bp+4104) } if !(error1 != 0) { - error1 = _do_glob(tls, bp+8, *(*Tsize_t)(unsafe.Pointer(bp + 4104)), 0, *(*uintptr)(unsafe.Pointer(bp + 4108)), flags, __ccgo_fp_errfunc, bp+4) + error1 = _do_glob(tls, bp+8, **(**Tsize_t)(__ccgo_up(bp + 4104)), 0, **(**uintptr)(__ccgo_up(bp + 4108)), flags, __ccgo_fp_errfunc, bp+4) } Xfree(tls, p) } @@ -129208,20 +129208,20 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint return error1 } cnt = uint32(0) - *(*uintptr)(unsafe.Pointer(bp + 4)) = (*(*Tmatch)(unsafe.Pointer(bp))).Fnext + **(**uintptr)(__ccgo_up(bp + 4)) = (**(**Tmatch)(__ccgo_up(bp))).Fnext for { - if !(*(*uintptr)(unsafe.Pointer(bp + 4)) != 0) { + if !(**(**uintptr)(__ccgo_up(bp + 4)) != 0) { break } goto _2 _2: ; - *(*uintptr)(unsafe.Pointer(bp + 4)) = (*Tmatch)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)))).Fnext + **(**uintptr)(__ccgo_up(bp + 4)) = (*Tmatch)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp + 4)))).Fnext cnt = cnt + 1 } if !(cnt != 0) { if flags&int32(GLOB_NOCHECK) != 0 { - *(*uintptr)(unsafe.Pointer(bp + 4)) = bp + **(**uintptr)(__ccgo_up(bp + 4)) = bp if _append(tls, bp+4, pat, _strlen(tls, pat), 0) != 0 { return int32(GLOB_NOSPACE) } @@ -129251,7 +129251,7 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint if !(i < offs) { break } - *(*uintptr)(unsafe.Pointer((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(i)*4)) = UintptrFromInt32(0) + **(**uintptr)(__ccgo_up((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(i)*4)) = UintptrFromInt32(0) goto _3 _3: ; @@ -129259,20 +129259,20 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint } } i = uint32(0) - *(*uintptr)(unsafe.Pointer(bp + 4)) = (*(*Tmatch)(unsafe.Pointer(bp))).Fnext + **(**uintptr)(__ccgo_up(bp + 4)) = (**(**Tmatch)(__ccgo_up(bp))).Fnext for { if !(i < cnt) { break } - *(*uintptr)(unsafe.Pointer((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(offs+i)*4)) = *(*uintptr)(unsafe.Pointer(bp + 4)) + 4 + **(**uintptr)(__ccgo_up((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(offs+i)*4)) = **(**uintptr)(__ccgo_up(bp + 4)) + 4 goto _4 _4: ; - *(*uintptr)(unsafe.Pointer(bp + 4)) = (*Tmatch)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)))).Fnext + **(**uintptr)(__ccgo_up(bp + 4)) = (*Tmatch)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp + 4)))).Fnext i = i + 1 } - *(*uintptr)(unsafe.Pointer((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(offs+i)*4)) = UintptrFromInt32(0) - *(*Tsize_t)(unsafe.Pointer(g)) += cnt + **(**uintptr)(__ccgo_up((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(offs+i)*4)) = UintptrFromInt32(0) + **(**Tsize_t)(__ccgo_up(g)) += cnt if !(flags&Int32FromInt32(GLOB_NOSORT) != 0) { Xqsort(tls, (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv+uintptr(offs)*4, cnt, uint32(4), __ccgo_fp(_sort)) } @@ -129290,7 +129290,7 @@ func Xglobfree(tls *TLS, g uintptr) { if !(i < (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathc) { break } - Xfree(tls, *(*uintptr)(unsafe.Pointer((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr((*Tglob_t)(unsafe.Pointer(g)).Fgl_offs+i)*4))-uintptr(uint32(UintptrFromInt32(0)+4))) + Xfree(tls, **(**uintptr)(__ccgo_up((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr((*Tglob_t)(unsafe.Pointer(g)).Fgl_offs+i)*4))-uintptr(uint32(UintptrFromInt32(0)+4))) goto _1 _1: ; @@ -129689,7 +129689,7 @@ func _tre_stack_push(tls *TLS, s uintptr, value Ttre_stack_item) (r Treg_errcode var new_size int32 _, _ = new_buffer, new_size if (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr < (*Ttre_stack_t)(unsafe.Pointer(s)).Fsize { - *(*Ttre_stack_item)(unsafe.Pointer((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr((*Ttre_stack_t)(unsafe.Pointer(s)).Fptr)*4)) = value + **(**Ttre_stack_item)(__ccgo_up((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr((*Ttre_stack_t)(unsafe.Pointer(s)).Fptr)*4)) = value (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr = (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr + 1 } else { if (*Ttre_stack_t)(unsafe.Pointer(s)).Fsize >= (*Ttre_stack_t)(unsafe.Pointer(s)).Fmax_size { @@ -129716,7 +129716,7 @@ func _tre_stack_push_int(tls *TLS, s uintptr, value int32) (r Treg_errcode_t) { defer tls.Free(16) var _ /* item at bp+0 */ Ttre_stack_item *(*int32)(unsafe.Pointer(bp)) = value - return _tre_stack_push(tls, s, *(*Ttre_stack_item)(unsafe.Pointer(bp))) + return _tre_stack_push(tls, s, **(**Ttre_stack_item)(__ccgo_up(bp))) } func _tre_stack_push_voidptr(tls *TLS, s uintptr, value uintptr) (r Treg_errcode_t) { @@ -129724,7 +129724,7 @@ func _tre_stack_push_voidptr(tls *TLS, s uintptr, value uintptr) (r Treg_errcode defer tls.Free(16) var _ /* item at bp+0 */ Ttre_stack_item *(*uintptr)(unsafe.Pointer(bp)) = value - return _tre_stack_push(tls, s, *(*Ttre_stack_item)(unsafe.Pointer(bp))) + return _tre_stack_push(tls, s, **(**Ttre_stack_item)(__ccgo_up(bp))) } func _tre_stack_pop_int(tls *TLS, s uintptr) (r int32) { @@ -129834,7 +129834,7 @@ func _tre_expand_macro(tls *TLS, s uintptr) (r uintptr) { _ = i i = 0 for { - if !(_tre_macros[i].Fc != 0 && Int32FromUint8(_tre_macros[i].Fc) != Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))) { + if !(_tre_macros[i].Fc != 0 && Int32FromUint8(_tre_macros[i].Fc) != Int32FromUint8(**(**uint8)(__ccgo_up(s)))) { break } goto _1 @@ -129851,7 +129851,7 @@ func _tre_compare_lit(tls *TLS, a uintptr, b uintptr) (r int32) { la = a lb = b /* assumes the range of valid code_min is < INT_MAX */ - return (*Ttre_literal_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(la)))).Fcode_min - (*Ttre_literal_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(lb)))).Fcode_min + return (*Ttre_literal_t)(unsafe.Pointer(**(**uintptr)(__ccgo_up(la)))).Fcode_min - (*Ttre_literal_t)(unsafe.Pointer(**(**uintptr)(__ccgo_up(lb)))).Fcode_min } type Tliterals = struct { @@ -129869,7 +129869,7 @@ func _tre_new_lit(tls *TLS, p uintptr) (r uintptr) { if (*Tliterals)(unsafe.Pointer(p)).Fcap1 >= Int32FromInt32(1)< max { @@ -130061,7 +130061,7 @@ func _parse_bracket_terms(tls *TLS, ctx uintptr, s uintptr, ls uintptr, neg uint v6 = neg + 4 v2 = *(*int32)(unsafe.Pointer(v6)) *(*int32)(unsafe.Pointer(v6)) = *(*int32)(unsafe.Pointer(v6)) + 1 - *(*Ttre_ctype_t)(unsafe.Pointer(neg + 8 + uintptr(v2)*4)) = class + **(**Ttre_ctype_t)(__ccgo_up(neg + 8 + uintptr(v2)*4)) = class } else { lit = _tre_new_lit(tls, ls) if !(lit != 0) { @@ -130101,23 +130101,23 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { _, _, _, _, _, _, _, _, _, _, _ = err, i, lit, max, min, n, nc, negmax, negmin, node, v1 node = uintptr(0) nc = uintptr(0) - (*(*Tliterals)(unsafe.Pointer(bp))).Fmem = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem - (*(*Tliterals)(unsafe.Pointer(bp))).Flen1 = 0 - (*(*Tliterals)(unsafe.Pointer(bp))).Fcap1 = int32(32) - (*(*Tliterals)(unsafe.Pointer(bp))).Fa = Xmalloc(tls, Uint32FromInt32((*(*Tliterals)(unsafe.Pointer(bp))).Fcap1)*uint32(4)) - if !((*(*Tliterals)(unsafe.Pointer(bp))).Fa != 0) { + (**(**Tliterals)(__ccgo_up(bp))).Fmem = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem + (**(**Tliterals)(__ccgo_up(bp))).Flen1 = 0 + (**(**Tliterals)(__ccgo_up(bp))).Fcap1 = int32(32) + (**(**Tliterals)(__ccgo_up(bp))).Fa = Xmalloc(tls, Uint32FromInt32((**(**Tliterals)(__ccgo_up(bp))).Fcap1)*uint32(4)) + if !((**(**Tliterals)(__ccgo_up(bp))).Fa != 0) { return int32(REG_ESPACE) } - (*(*Tneg)(unsafe.Pointer(bp + 16))).Flen1 = 0 - (*(*Tneg)(unsafe.Pointer(bp + 16))).Fnegate = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('^')) - if (*(*Tneg)(unsafe.Pointer(bp + 16))).Fnegate != 0 { + (**(**Tneg)(__ccgo_up(bp + 16))).Flen1 = 0 + (**(**Tneg)(__ccgo_up(bp + 16))).Fnegate = BoolInt32(Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('^')) + if (**(**Tneg)(__ccgo_up(bp + 16))).Fnegate != 0 { s = s + 1 } err = _parse_bracket_terms(tls, ctx, s, bp, bp+16) if err != REG_OK { goto parse_bracket_done } - if (*(*Tneg)(unsafe.Pointer(bp + 16))).Fnegate != 0 { + if (**(**Tneg)(__ccgo_up(bp + 16))).Fnegate != 0 { /* * With REG_NEWLINE, POSIX requires that newlines are not matched by * any form of a non-matching list. @@ -130133,7 +130133,7 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition = -int32(1) } /* Sort the array if we need to negate it. */ - Xqsort(tls, (*(*Tliterals)(unsafe.Pointer(bp))).Fa, Uint32FromInt32((*(*Tliterals)(unsafe.Pointer(bp))).Flen1), uint32(4), __ccgo_fp(_tre_compare_lit)) + Xqsort(tls, (**(**Tliterals)(__ccgo_up(bp))).Fa, Uint32FromInt32((**(**Tliterals)(__ccgo_up(bp))).Flen1), uint32(4), __ccgo_fp(_tre_compare_lit)) /* extra lit for the last negated range */ lit = _tre_new_lit(tls, bp) if !(lit != 0) { @@ -130144,14 +130144,14 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max = int32(Int32FromInt32(TRE_CHAR_MAX) + Int32FromInt32(1)) (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition = -int32(1) /* negated classes */ - if (*(*Tneg)(unsafe.Pointer(bp + 16))).Flen1 != 0 { - nc = X__tre_mem_alloc_impl(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, 0, UintptrFromInt32(0), 0, Uint32FromInt32((*(*Tneg)(unsafe.Pointer(bp + 16))).Flen1+Int32FromInt32(1))*uint32(4)) + if (**(**Tneg)(__ccgo_up(bp + 16))).Flen1 != 0 { + nc = X__tre_mem_alloc_impl(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, 0, UintptrFromInt32(0), 0, Uint32FromInt32((**(**Tneg)(__ccgo_up(bp + 16))).Flen1+Int32FromInt32(1))*uint32(4)) if !(nc != 0) { err = int32(REG_ESPACE) goto parse_bracket_done } - _memcpy(tls, nc, bp+16+8, Uint32FromInt32((*(*Tneg)(unsafe.Pointer(bp + 16))).Flen1)*uint32(4)) - *(*Ttre_ctype_t)(unsafe.Pointer(nc + uintptr((*(*Tneg)(unsafe.Pointer(bp + 16))).Flen1)*4)) = uint32(0) + _memcpy(tls, nc, bp+16+8, Uint32FromInt32((**(**Tneg)(__ccgo_up(bp + 16))).Flen1)*uint32(4)) + **(**Ttre_ctype_t)(__ccgo_up(nc + uintptr((**(**Tneg)(__ccgo_up(bp + 16))).Flen1)*4)) = uint32(0) } } /* Build a union of the items in the array, negated if necessary. */ @@ -130160,13 +130160,13 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { negmax = v1 i = 0 for { - if !(i < (*(*Tliterals)(unsafe.Pointer(bp))).Flen1) { + if !(i < (**(**Tliterals)(__ccgo_up(bp))).Flen1) { break } - lit = *(*uintptr)(unsafe.Pointer((*(*Tliterals)(unsafe.Pointer(bp))).Fa + uintptr(i)*4)) + lit = **(**uintptr)(__ccgo_up((**(**Tliterals)(__ccgo_up(bp))).Fa + uintptr(i)*4)) min = (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min max = (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max - if (*(*Tneg)(unsafe.Pointer(bp + 16))).Fnegate != 0 { + if (**(**Tneg)(__ccgo_up(bp + 16))).Fnegate != 0 { if min <= negmin { /* Overlap. */ if max+int32(1) >= negmin { @@ -130198,22 +130198,22 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { goto parse_bracket_done parse_bracket_done: ; - Xfree(tls, (*(*Tliterals)(unsafe.Pointer(bp))).Fa) + Xfree(tls, (**(**Tliterals)(__ccgo_up(bp))).Fa) (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition + 1 (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = node return err } func _parse_dup_count(tls *TLS, s uintptr, n uintptr) (r uintptr) { - *(*int32)(unsafe.Pointer(n)) = -int32(1) - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + **(**int32)(__ccgo_up(n)) = -int32(1) + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return s } - *(*int32)(unsafe.Pointer(n)) = 0 + **(**int32)(__ccgo_up(n)) = 0 for { - *(*int32)(unsafe.Pointer(n)) = int32(10)**(*int32)(unsafe.Pointer(n)) + (Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) - int32('0')) + **(**int32)(__ccgo_up(n)) = int32(10)***(**int32)(__ccgo_up(n)) + (Int32FromUint8(**(**uint8)(__ccgo_up(s))) - int32('0')) s = s + 1 - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) || *(*int32)(unsafe.Pointer(n)) > int32(RE_DUP_MAX) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) || **(**int32)(__ccgo_up(n)) > int32(RE_DUP_MAX) { break } goto _1 @@ -130231,26 +130231,26 @@ func _parse_dup(tls *TLS, s uintptr, ere int32, pmin uintptr, pmax uintptr) (r u var _ /* min at bp+0 */ int32 _, _, _, _, _ = v1, v2, v3, v4, v5 s = _parse_dup_count(tls, s, bp) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32(',') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32(',') { s = _parse_dup_count(tls, s+uintptr(1), bp+4) } else { - *(*int32)(unsafe.Pointer(bp + 4)) = *(*int32)(unsafe.Pointer(bp)) + **(**int32)(__ccgo_up(bp + 4)) = **(**int32)(__ccgo_up(bp)) } - if v3 = *(*int32)(unsafe.Pointer(bp + 4)) < *(*int32)(unsafe.Pointer(bp)) && *(*int32)(unsafe.Pointer(bp + 4)) >= 0 || *(*int32)(unsafe.Pointer(bp + 4)) > int32(RE_DUP_MAX) || *(*int32)(unsafe.Pointer(bp)) > int32(RE_DUP_MAX) || *(*int32)(unsafe.Pointer(bp)) < 0; !v3 { + if v3 = **(**int32)(__ccgo_up(bp + 4)) < **(**int32)(__ccgo_up(bp)) && **(**int32)(__ccgo_up(bp + 4)) >= 0 || **(**int32)(__ccgo_up(bp + 4)) > int32(RE_DUP_MAX) || **(**int32)(__ccgo_up(bp)) > int32(RE_DUP_MAX) || **(**int32)(__ccgo_up(bp)) < 0; !v3 { if v2 = !(ere != 0); v2 { v1 = s s = s + 1 } } - if v5 = v3 || v2 && Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) != int32('\\'); !v5 { + if v5 = v3 || v2 && Int32FromUint8(**(**uint8)(__ccgo_up(v1))) != int32('\\'); !v5 { v4 = s s = s + 1 } - if v5 || Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) != int32('}') { + if v5 || Int32FromUint8(**(**uint8)(__ccgo_up(v4))) != int32('}') { return uintptr(0) } - *(*int32)(unsafe.Pointer(pmin)) = *(*int32)(unsafe.Pointer(bp)) - *(*int32)(unsafe.Pointer(pmax)) = *(*int32)(unsafe.Pointer(bp + 4)) + **(**int32)(__ccgo_up(pmin)) = **(**int32)(__ccgo_up(bp)) + **(**int32)(__ccgo_up(pmax)) = **(**int32)(__ccgo_up(bp + 4)) return s } @@ -130313,7 +130313,7 @@ func _parse_atom(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { var _ /* wc at bp+0 */ Twchar_t _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, ere, err, i, len1, node, p, tmp1, tmp11, tmp2, tmp21, v, val, v14, v16 ere = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fcflags & int32(REG_EXTENDED) - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(s))) { case int32('['): goto _1 case int32('\\'): @@ -130355,7 +130355,7 @@ _2: /* extensions: \b, \B, \<, \>, \xHH \x{HHHH} */ s = s + 1 v14 = s - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(v14))) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(v14))) { case 0: return int32(REG_EESCAPE) case int32('b'): @@ -130370,7 +130370,7 @@ _2: s = s + 1 v = 0 len1 = int32(2) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('{') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('{') { len1 = int32(8) s = s + 1 } @@ -130379,7 +130379,7 @@ _2: if !(i < len1 && v < int32(0x110000)) { break } - c = _hexval1(tls, uint32(*(*uint8)(unsafe.Pointer(s + uintptr(i))))) + c = _hexval1(tls, uint32(**(**uint8)(__ccgo_up(s + uintptr(i))))) if c < 0 { break } @@ -130391,7 +130391,7 @@ _2: } s = s + uintptr(i) if len1 == int32(8) { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('}') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32('}') { return int32(REG_EBRACE) } s = s + 1 @@ -130422,9 +130422,9 @@ _2: /* fallthrough */ fallthrough default: - if !(ere != 0) && uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('1') < uint32(9) { + if !(ere != 0) && uint32(**(**uint8)(__ccgo_up(s)))-uint32('1') < uint32(9) { /* back reference */ - val = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) - int32('0') + val = Int32FromUint8(**(**uint8)(__ccgo_up(s))) - int32('0') v14 = ctx + 24 v16 = *(*int32)(unsafe.Pointer(v14)) *(*int32)(unsafe.Pointer(v14)) = *(*int32)(unsafe.Pointer(v14)) + 1 @@ -130479,7 +130479,7 @@ _4: _5: ; /* '$' is special everywhere in EREs, and at the end of a BRE subexpression. */ - if !(ere != 0) && *(*uint8)(unsafe.Pointer(s + 1)) != 0 && (Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) != int32('\\') || Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 2))) != int32(')') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 2))) != int32('|')) { + if !(ere != 0) && **(**uint8)(__ccgo_up(s + 1)) != 0 && (Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) != int32('\\') || Int32FromUint8(**(**uint8)(__ccgo_up(s + 2))) != int32(')') && Int32FromUint8(**(**uint8)(__ccgo_up(s + 2))) != int32('|')) { goto parse_literal } node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(2), int32(ASSERT_AT_EOL), -int32(1)) @@ -130515,17 +130515,17 @@ parse_literal: if len1 < 0 { return int32(REG_BADPAT) } - if (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fcflags&int32(REG_ICASE) != 0 && (Xiswupper(tls, *(*Twchar_t)(unsafe.Pointer(bp))) != 0 || Xiswlower(tls, *(*Twchar_t)(unsafe.Pointer(bp))) != 0) { + if (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fcflags&int32(REG_ICASE) != 0 && (Xiswupper(tls, **(**Twchar_t)(__ccgo_up(bp))) != 0 || Xiswlower(tls, **(**Twchar_t)(__ccgo_up(bp))) != 0) { /* multiple opposite case characters are not supported */ - tmp11 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint32(Xtowupper(tls, *(*Twchar_t)(unsafe.Pointer(bp)))), Int32FromUint32(Xtowupper(tls, *(*Twchar_t)(unsafe.Pointer(bp)))), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) - tmp21 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint32(Xtowlower(tls, *(*Twchar_t)(unsafe.Pointer(bp)))), Int32FromUint32(Xtowlower(tls, *(*Twchar_t)(unsafe.Pointer(bp)))), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) + tmp11 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint32(Xtowupper(tls, **(**Twchar_t)(__ccgo_up(bp)))), Int32FromUint32(Xtowupper(tls, **(**Twchar_t)(__ccgo_up(bp)))), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) + tmp21 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint32(Xtowlower(tls, **(**Twchar_t)(__ccgo_up(bp)))), Int32FromUint32(Xtowlower(tls, **(**Twchar_t)(__ccgo_up(bp)))), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) if tmp11 != 0 && tmp21 != 0 { node = _tre_ast_new_union(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, tmp11, tmp21) } else { node = uintptr(0) } } else { - node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint32(*(*Twchar_t)(unsafe.Pointer(bp))), Int32FromUint32(*(*Twchar_t)(unsafe.Pointer(bp))), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) + node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint32(**(**Twchar_t)(__ccgo_up(bp))), Int32FromUint32(**(**Twchar_t)(__ccgo_up(bp))), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) } (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition + 1 s = s + uintptr(len1) @@ -130567,7 +130567,7 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { return err } for { - if !(ere != 0) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('\\') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) == int32('(') || ere != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('(') { + if !(ere != 0) && Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('\\') && Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) == int32('(') || ere != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('(') { v1 = _tre_stack_push_voidptr(tls, stack, nunion) err = v1 if v1 != REG_OK { @@ -130596,7 +130596,7 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart = s goto _3 } - if !(ere != 0) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('\\') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) == int32(')') || ere != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32(')') && depth != 0 { + if !(ere != 0) && Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('\\') && Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) == int32(')') || ere != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32(')') && depth != 0 { (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(1), -int32(1), -int32(1)) if !((*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn != 0) { return int32(REG_ESPACE) @@ -130612,52 +130612,52 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { parse_iter: ; for { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('\\') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('*') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32('\\') && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32('*') { if !(ere != 0) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('+') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('?') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('{') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32('+') && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32('?') && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32('{') { break } } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('\\') && ere != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('\\') && ere != 0 { break } /* extension: treat \+, \? as repetitions in BRE */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('\\') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) != int32('+') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) != int32('?') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) != int32('{') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('\\') && Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) != int32('+') && Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) != int32('?') && Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) != int32('{') { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('\\') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('\\') { s = s + 1 } /* handle ^* at the start of a BRE. */ - if !(ere != 0) && s == (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart+uintptr(1) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(-Int32FromInt32(1))))) == int32('^') { + if !(ere != 0) && s == (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart+uintptr(1) && Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(-Int32FromInt32(1))))) == int32('^') { break } /* extension: multiple consecutive *+?{,} is unspecified, but (a+)+ has to be supported so accepting a++ makes sense, note however that the RE_DUP_MAX limit can be circumvented: (a{255}){255} uses a lot of memory.. */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('{') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('{') { s = _parse_dup(tls, s+uintptr(1), ere, bp, bp+4) if !(s != 0) { return int32(REG_BADBR) } } else { - *(*int32)(unsafe.Pointer(bp)) = 0 - *(*int32)(unsafe.Pointer(bp + 4)) = -int32(1) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('+') { - *(*int32)(unsafe.Pointer(bp)) = int32(1) + **(**int32)(__ccgo_up(bp)) = 0 + **(**int32)(__ccgo_up(bp + 4)) = -int32(1) + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('+') { + **(**int32)(__ccgo_up(bp)) = int32(1) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('?') { - *(*int32)(unsafe.Pointer(bp + 4)) = int32(1) + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('?') { + **(**int32)(__ccgo_up(bp + 4)) = int32(1) } s = s + 1 } - if *(*int32)(unsafe.Pointer(bp + 4)) == 0 { + if **(**int32)(__ccgo_up(bp + 4)) == 0 { (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(1), -int32(1), -int32(1)) } else { - (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = _tre_ast_new_iter(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn, *(*int32)(unsafe.Pointer(bp)), *(*int32)(unsafe.Pointer(bp + 4)), 0) + (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = _tre_ast_new_iter(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn, **(**int32)(__ccgo_up(bp)), **(**int32)(__ccgo_up(bp + 4)), 0) } if !((*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn != 0) { return int32(REG_ESPACE) @@ -130666,13 +130666,13 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { _9: } nbranch = _tre_ast_new_catenation(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, nbranch, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn) - if ere != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('|') || ere != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32(')') && depth != 0 || !(ere != 0) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('\\') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) == int32(')') || !(ere != 0) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('\\') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) == int32('|') || !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if ere != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('|') || ere != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32(')') && depth != 0 || !(ere != 0) && Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('\\') && Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) == int32(')') || !(ere != 0) && Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('\\') && Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) == int32('|') || !(**(**uint8)(__ccgo_up(s)) != 0) { /* extension: empty branch is unspecified (), (|a), (a|) here they are not rejected but match on empty string */ - c = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) + c = Int32FromUint8(**(**uint8)(__ccgo_up(s))) nunion = _tre_ast_new_union(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, nunion, nbranch) nbranch = uintptr(0) - if c == int32('\\') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) == int32('|') { + if c == int32('\\') && Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) == int32('|') { s = s + uintptr(2) (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart = s } else { @@ -130818,22 +130818,22 @@ func _tre_purge_regset(tls *TLS, regset uintptr, tnfa uintptr, tag int32) { _, _, _ = i, id, start i = 0 for { - if !(*(*int32)(unsafe.Pointer(regset + uintptr(i)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(regset + uintptr(i)*4)) >= 0) { break } - id = *(*int32)(unsafe.Pointer(regset + uintptr(i)*4)) / int32(2) - start = BoolInt32(!(*(*int32)(unsafe.Pointer(regset + uintptr(i)*4))%Int32FromInt32(2) != 0)) + id = **(**int32)(__ccgo_up(regset + uintptr(i)*4)) / int32(2) + start = BoolInt32(!(**(**int32)(__ccgo_up(regset + uintptr(i)*4))%Int32FromInt32(2) != 0)) if start != 0 { - (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id)*12))).Fso_tag = tag + (**(**Ttre_submatch_data_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id)*12))).Fso_tag = tag } else { - (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id)*12))).Feo_tag = tag + (**(**Ttre_submatch_data_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id)*12))).Feo_tag = tag } goto _1 _1: ; i = i + 1 } - *(*int32)(unsafe.Pointer(regset)) = -int32(1) + **(**int32)(__ccgo_up(regset)) = -int32(1) } // C documentation @@ -130862,20 +130862,20 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u direction = int32(_TRE_TAG_MINIMIZE) if !(first_pass != 0) { (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fend_tag = 0 - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags)) = -int32(1) + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags)) = -int32(1) } regset = Xmalloc(tls, uint32(4)*(((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches+uint32(1))*uint32(2))) if regset == UintptrFromInt32(0) { return int32(REG_ESPACE) } - *(*int32)(unsafe.Pointer(regset)) = -int32(1) + **(**int32)(__ccgo_up(regset)) = -int32(1) orig_regset = regset parents = Xmalloc(tls, uint32(4)*((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches+uint32(1))) if parents == UintptrFromInt32(0) { Xfree(tls, regset) return int32(REG_ESPACE) } - *(*int32)(unsafe.Pointer(parents)) = -int32(1) + **(**int32)(__ccgo_up(parents)) = -int32(1) saved_states = Xmalloc(tls, uint32(8)*((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches+uint32(1))) if saved_states == UintptrFromInt32(0) { Xfree(tls, regset) @@ -130887,7 +130887,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u if !(i <= (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches) { break } - (*(*Ttre_tag_states_t)(unsafe.Pointer(saved_states + uintptr(i)*8))).Ftag = -int32(1) + (**(**Ttre_tag_states_t)(__ccgo_up(saved_states + uintptr(i)*8))).Ftag = -int32(1) goto _1 _1: ; @@ -130926,7 +130926,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u /* Add end of this submatch to regset. */ i1 = 0 for { - if !(*(*int32)(unsafe.Pointer(regset + uintptr(i1)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(regset + uintptr(i1)*4)) >= 0) { break } goto _11 @@ -130934,12 +130934,12 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i1 = i1 + 1 } - *(*int32)(unsafe.Pointer(regset + uintptr(i1)*4)) = id*int32(2) + int32(1) - *(*int32)(unsafe.Pointer(regset + uintptr(i1+int32(1))*4)) = -int32(1) + **(**int32)(__ccgo_up(regset + uintptr(i1)*4)) = id*int32(2) + int32(1) + **(**int32)(__ccgo_up(regset + uintptr(i1+int32(1))*4)) = -int32(1) /* Pop this submatch from the parents stack. */ i1 = 0 for { - if !(*(*int32)(unsafe.Pointer(parents + uintptr(i1)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(parents + uintptr(i1)*4)) >= 0) { break } goto _12 @@ -130947,7 +130947,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i1 = i1 + 1 } - *(*int32)(unsafe.Pointer(parents + uintptr(i1-int32(1))*4)) = -int32(1) + **(**int32)(__ccgo_up(parents + uintptr(i1-int32(1))*4)) = -int32(1) goto _10 _3: ; @@ -130957,7 +130957,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u /* Add start of this submatch to regset. */ i2 = 0 for { - if !(*(*int32)(unsafe.Pointer(regset + uintptr(i2)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(regset + uintptr(i2)*4)) >= 0) { break } goto _13 @@ -130965,12 +130965,12 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i2 = i2 + 1 } - *(*int32)(unsafe.Pointer(regset + uintptr(i2)*4)) = id1 * int32(2) - *(*int32)(unsafe.Pointer(regset + uintptr(i2+int32(1))*4)) = -int32(1) + **(**int32)(__ccgo_up(regset + uintptr(i2)*4)) = id1 * int32(2) + **(**int32)(__ccgo_up(regset + uintptr(i2+int32(1))*4)) = -int32(1) if !(first_pass != 0) { i2 = 0 for { - if !(*(*int32)(unsafe.Pointer(parents + uintptr(i2)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(parents + uintptr(i2)*4)) >= 0) { break } goto _14 @@ -130978,26 +130978,26 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i2 = i2 + 1 } - (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id1)*12))).Fparents = UintptrFromInt32(0) + (**(**Ttre_submatch_data_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id1)*12))).Fparents = UintptrFromInt32(0) if i2 > 0 { p = Xmalloc(tls, uint32(4)*Uint32FromInt32(i2+Int32FromInt32(1))) if p == UintptrFromInt32(0) { status = int32(REG_ESPACE) goto _10 } - (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id1)*12))).Fparents = p + (**(**Ttre_submatch_data_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id1)*12))).Fparents = p i2 = 0 for { - if !(*(*int32)(unsafe.Pointer(parents + uintptr(i2)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(parents + uintptr(i2)*4)) >= 0) { break } - *(*int32)(unsafe.Pointer(p + uintptr(i2)*4)) = *(*int32)(unsafe.Pointer(parents + uintptr(i2)*4)) + **(**int32)(__ccgo_up(p + uintptr(i2)*4)) = **(**int32)(__ccgo_up(parents + uintptr(i2)*4)) goto _15 _15: ; i2 = i2 + 1 } - *(*int32)(unsafe.Pointer(p + uintptr(i2)*4)) = -int32(1) + **(**int32)(__ccgo_up(p + uintptr(i2)*4)) = -int32(1) } } /* Add end of this submatch to regset after processing this @@ -131015,16 +131015,16 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u case int32(_LITERAL): lit = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj if !((*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min < Int32FromInt32(0)) || (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min == -int32(4) { - if *(*int32)(unsafe.Pointer(regset)) >= 0 { + if **(**int32)(__ccgo_up(regset)) >= 0 { /* Regset is not empty, so add a tag before the literal or backref. */ if !(first_pass != 0) { status = _tre_add_tag_left(tls, mem, node, tag) - *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = direction + **(**Ttre_tag_direction_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = direction if minimal_tag >= 0 { i3 = 0 for { - if !(*(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3)*4)) >= 0) { break } goto _16 @@ -131032,9 +131032,9 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i3 = i3 + 1 } - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3)*4)) = tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3+int32(1))*4)) = minimal_tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3+int32(2))*4)) = -int32(1) + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3)*4)) = tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3+int32(1))*4)) = minimal_tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) num_minimals = num_minimals + 1 } @@ -131042,7 +131042,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u } else { (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fnum_tags = int32(1) } - *(*int32)(unsafe.Pointer(regset)) = -int32(1) + **(**int32)(__ccgo_up(regset)) = -int32(1) tag = next_tag num_tags = num_tags + 1 next_tag = next_tag + 1 @@ -131102,7 +131102,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u case int32(_ITERATION): iter = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj if first_pass != 0 { - status = _tre_stack_push_int(tls, stack, BoolInt32(*(*int32)(unsafe.Pointer(regset)) >= 0 || int32(uint32(*(*uint8)(unsafe.Pointer(iter + 12))&0x1>>0)) != 0)) + status = _tre_stack_push_int(tls, stack, BoolInt32(**(**int32)(__ccgo_up(regset)) >= 0 || int32(uint32(*(*uint8)(unsafe.Pointer(iter + 12))&0x1>>0)) != 0)) if status != REG_OK { break } @@ -131133,18 +131133,18 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u break } /* Regset is not empty, so add a tag here. */ - if *(*int32)(unsafe.Pointer(regset)) >= 0 || int32(uint32(*(*uint8)(unsafe.Pointer(iter + 12))&0x1>>0)) != 0 { + if **(**int32)(__ccgo_up(regset)) >= 0 || int32(uint32(*(*uint8)(unsafe.Pointer(iter + 12))&0x1>>0)) != 0 { if !(first_pass != 0) { status = _tre_add_tag_left(tls, mem, node, tag) if int32(uint32(*(*uint8)(unsafe.Pointer(iter + 12))&0x1>>0)) != 0 { - *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = int32(_TRE_TAG_MAXIMIZE) + **(**Ttre_tag_direction_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = int32(_TRE_TAG_MAXIMIZE) } else { - *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = direction + **(**Ttre_tag_direction_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = direction } if minimal_tag >= 0 { i4 = 0 for { - if !(*(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4)*4)) >= 0) { break } goto _17 @@ -131152,15 +131152,15 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i4 = i4 + 1 } - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4)*4)) = tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4+int32(1))*4)) = minimal_tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4+int32(2))*4)) = -int32(1) + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4)*4)) = tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4+int32(1))*4)) = minimal_tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) num_minimals = num_minimals + 1 } _tre_purge_regset(tls, regset, tnfa, tag) } - *(*int32)(unsafe.Pointer(regset)) = -int32(1) + **(**int32)(__ccgo_up(regset)) = -int32(1) tag = next_tag num_tags = num_tags + 1 next_tag = next_tag + 1 @@ -131170,7 +131170,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u uni = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj left1 = (*Ttre_union_t)(unsafe.Pointer(uni)).Fleft right1 = (*Ttre_union_t)(unsafe.Pointer(uni)).Fright - if *(*int32)(unsafe.Pointer(regset)) >= 0 { + if **(**int32)(__ccgo_up(regset)) >= 0 { left_tag = next_tag right_tag = next_tag + int32(1) } else { @@ -131190,7 +131190,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u if status != REG_OK { break } - status = _tre_stack_push_int(tls, stack, BoolInt32(*(*int32)(unsafe.Pointer(regset)) >= 0)) + status = _tre_stack_push_int(tls, stack, BoolInt32(**(**int32)(__ccgo_up(regset)) >= 0)) if status != REG_OK { break } @@ -131234,14 +131234,14 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u break } /* Regset is not empty, so add a tag here. */ - if *(*int32)(unsafe.Pointer(regset)) >= 0 { + if **(**int32)(__ccgo_up(regset)) >= 0 { if !(first_pass != 0) { status = _tre_add_tag_left(tls, mem, node, tag) - *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = direction + **(**Ttre_tag_direction_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = direction if minimal_tag >= 0 { i5 = 0 for { - if !(*(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5)*4)) >= 0) { break } goto _18 @@ -131249,15 +131249,15 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i5 = i5 + 1 } - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5)*4)) = tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5+int32(1))*4)) = minimal_tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5+int32(2))*4)) = -int32(1) + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5)*4)) = tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5+int32(1))*4)) = minimal_tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) num_minimals = num_minimals + 1 } _tre_purge_regset(tls, regset, tnfa, tag) } - *(*int32)(unsafe.Pointer(regset)) = -int32(1) + **(**int32)(__ccgo_up(regset)) = -int32(1) tag = next_tag num_tags = num_tags + 1 next_tag = next_tag + 1 @@ -131274,7 +131274,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u /* Push this submatch on the parents stack. */ i6 = 0 for { - if !(*(*int32)(unsafe.Pointer(parents + uintptr(i6)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(parents + uintptr(i6)*4)) >= 0) { break } goto _19 @@ -131282,8 +131282,8 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i6 = i6 + 1 } - *(*int32)(unsafe.Pointer(parents + uintptr(i6)*4)) = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fsubmatch_id - *(*int32)(unsafe.Pointer(parents + uintptr(i6+int32(1))*4)) = -int32(1) + **(**int32)(__ccgo_up(parents + uintptr(i6)*4)) = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fsubmatch_id + **(**int32)(__ccgo_up(parents + uintptr(i6+int32(1))*4)) = -int32(1) } goto _10 /* end case: ADDTAGS_RECURSE */ _4: @@ -131331,7 +131331,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u will be restored at ADDTAGS_AFTER_UNION_RIGHT below. */ _21: ; - if !(*(*int32)(unsafe.Pointer(regset)) >= 0) { + if !(**(**int32)(__ccgo_up(regset)) >= 0) { goto _20 } regset += 4 @@ -131368,11 +131368,11 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u if (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fnum_submatches > 0 { if !(first_pass != 0) { status = _tre_add_tag_right(tls, mem, left2, tag_left) - *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag_left)*4)) = int32(_TRE_TAG_MAXIMIZE) + **(**Ttre_tag_direction_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag_left)*4)) = int32(_TRE_TAG_MAXIMIZE) if status == REG_OK { status = _tre_add_tag_right(tls, mem, right2, tag_right) } - *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag_right)*4)) = int32(_TRE_TAG_MAXIMIZE) + **(**Ttre_tag_direction_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag_right)*4)) = int32(_TRE_TAG_MAXIMIZE) } num_tags = num_tags + int32(2) } @@ -131390,7 +131390,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u if !(first_pass != 0) && minimal_tag >= 0 { i7 = 0 for { - if !(*(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7)*4)) >= 0) { break } goto _23 @@ -131398,9 +131398,9 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i7 = i7 + 1 } - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7)*4)) = tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7+int32(1))*4)) = minimal_tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7+int32(2))*4)) = -int32(1) + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7)*4)) = tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7+int32(1))*4)) = minimal_tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) num_minimals = num_minimals + 1 } @@ -131457,7 +131457,7 @@ func _tre_copy_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, flags i /* XXX - e.g. [ab] has only one position but two nodes, so we are creating holes in the state space here. Not fatal, just wastes memory. */ - pos = pos + *(*int32)(unsafe.Pointer(pos_add)) + pos = pos + **(**int32)(__ccgo_up(pos_add)) num_copied = num_copied + 1 } else { if (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min == -int32(3) && flags&int32(COPY_REMOVE_TAGS) != 0 { @@ -131469,30 +131469,30 @@ func _tre_copy_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, flags i } else { if (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min == -int32(3) && flags&int32(COPY_MAXIMIZE_FIRST_TAG) != 0 && first_tag != 0 { /* Maximize the first tag. */ - *(*Ttre_tag_direction_t)(unsafe.Pointer(tag_directions + uintptr(max)*4)) = int32(_TRE_TAG_MAXIMIZE) + **(**Ttre_tag_direction_t)(__ccgo_up(tag_directions + uintptr(max)*4)) = int32(_TRE_TAG_MAXIMIZE) first_tag = 0 } } } - *(*uintptr)(unsafe.Pointer(result)) = _tre_ast_new_literal(tls, mem, min, max, pos) - if *(*uintptr)(unsafe.Pointer(result)) == UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(result)) = _tre_ast_new_literal(tls, mem, min, max, pos) + if **(**uintptr)(__ccgo_up(result)) == UintptrFromInt32(0) { status = int32(REG_ESPACE) } else { - p = (*Ttre_ast_node_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(result)))).Fobj + p = (*Ttre_ast_node_t)(unsafe.Pointer(**(**uintptr)(__ccgo_up(result)))).Fobj (*Ttre_literal_t)(unsafe.Pointer(p)).Fclass = (*Ttre_literal_t)(unsafe.Pointer(lit)).Fclass (*Ttre_literal_t)(unsafe.Pointer(p)).Fneg_classes = (*Ttre_literal_t)(unsafe.Pointer(lit)).Fneg_classes } - if pos > *(*int32)(unsafe.Pointer(max_pos)) { - *(*int32)(unsafe.Pointer(max_pos)) = pos + if pos > **(**int32)(__ccgo_up(max_pos)) { + **(**int32)(__ccgo_up(max_pos)) = pos } case int32(_UNION): uni = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj - *(*uintptr)(unsafe.Pointer(result)) = _tre_ast_new_union(tls, mem, (*Ttre_union_t)(unsafe.Pointer(uni)).Fleft, (*Ttre_union_t)(unsafe.Pointer(uni)).Fright) - if *(*uintptr)(unsafe.Pointer(result)) == UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(result)) = _tre_ast_new_union(tls, mem, (*Ttre_union_t)(unsafe.Pointer(uni)).Fleft, (*Ttre_union_t)(unsafe.Pointer(uni)).Fright) + if **(**uintptr)(__ccgo_up(result)) == UintptrFromInt32(0) { status = int32(REG_ESPACE) break } - tmp = (*Ttre_ast_node_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(result)))).Fobj + tmp = (*Ttre_ast_node_t)(unsafe.Pointer(**(**uintptr)(__ccgo_up(result)))).Fobj result = tmp status = _tre_stack_push_voidptr(tls, stack, (*Ttre_union_t)(unsafe.Pointer(uni)).Fright) if status != REG_OK { @@ -131520,12 +131520,12 @@ func _tre_copy_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, flags i } case int32(_CATENATION): cat = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj - *(*uintptr)(unsafe.Pointer(result)) = _tre_ast_new_catenation(tls, mem, (*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft, (*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright) - if *(*uintptr)(unsafe.Pointer(result)) == UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(result)) = _tre_ast_new_catenation(tls, mem, (*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft, (*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright) + if **(**uintptr)(__ccgo_up(result)) == UintptrFromInt32(0) { status = int32(REG_ESPACE) break } - tmp1 = (*Ttre_ast_node_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(result)))).Fobj + tmp1 = (*Ttre_ast_node_t)(unsafe.Pointer(**(**uintptr)(__ccgo_up(result)))).Fobj (*Ttre_catenation_t)(unsafe.Pointer(tmp1)).Fleft = UintptrFromInt32(0) (*Ttre_catenation_t)(unsafe.Pointer(tmp1)).Fright = UintptrFromInt32(0) result = tmp1 @@ -131563,12 +131563,12 @@ func _tre_copy_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, flags i if status != REG_OK { break } - *(*uintptr)(unsafe.Pointer(result)) = _tre_ast_new_iter(tls, mem, (*Ttre_iteration_t)(unsafe.Pointer(iter)).Farg, (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmin, (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmax, int32(uint32(*(*uint8)(unsafe.Pointer(iter + 12))&0x1>>0))) - if *(*uintptr)(unsafe.Pointer(result)) == UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(result)) = _tre_ast_new_iter(tls, mem, (*Ttre_iteration_t)(unsafe.Pointer(iter)).Farg, (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmin, (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmax, int32(uint32(*(*uint8)(unsafe.Pointer(iter + 12))&0x1>>0))) + if **(**uintptr)(__ccgo_up(result)) == UintptrFromInt32(0) { status = int32(REG_ESPACE) break } - iter = (*Ttre_ast_node_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(result)))).Fobj + iter = (*Ttre_ast_node_t)(unsafe.Pointer(**(**uintptr)(__ccgo_up(result)))).Fobj result = iter default: break @@ -131576,7 +131576,7 @@ func _tre_copy_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, flags i break } } - *(*int32)(unsafe.Pointer(pos_add)) += num_copied + **(**int32)(__ccgo_up(pos_add)) += num_copied return status } @@ -131604,9 +131604,9 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _status, _status1, bottom, cat, flags, iter, iter1, iter_depth, j, lit, node, pos_add_last, pos_add_save, pos_add_total, seq1, status, symbol, tmp, uni, v2 status = REG_OK bottom = _tre_stack_num_objects(tls, stack) - *(*int32)(unsafe.Pointer(bp)) = 0 + **(**int32)(__ccgo_up(bp)) = 0 pos_add_total = 0 - *(*int32)(unsafe.Pointer(bp + 4)) = 0 + **(**int32)(__ccgo_up(bp + 4)) = 0 iter_depth = 0 _status = _tre_stack_push_voidptr(tls, stack, ast) if _status != REG_OK { @@ -131628,9 +131628,9 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit case int32(_LITERAL): lit = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj if !((*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min < Int32FromInt32(0)) || (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min == -int32(4) { - *(*int32)(unsafe.Pointer(lit + 8)) += *(*int32)(unsafe.Pointer(bp)) - if (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition > *(*int32)(unsafe.Pointer(bp + 4)) { - *(*int32)(unsafe.Pointer(bp + 4)) = (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition + **(**int32)(__ccgo_up(lit + 8)) += **(**int32)(__ccgo_up(bp)) + if (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition > **(**int32)(__ccgo_up(bp + 4)) { + **(**int32)(__ccgo_up(bp + 4)) = (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition } } case int32(_UNION): @@ -131671,7 +131671,7 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit } case int32(_ITERATION): iter = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj - status = _tre_stack_push_int(tls, stack, *(*int32)(unsafe.Pointer(bp))) + status = _tre_stack_push_int(tls, stack, **(**int32)(__ccgo_up(bp))) if status != REG_OK { break } @@ -131695,7 +131695,7 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit then don't increase the `pos' fields of the nodes now, it will get done when expanding. */ if (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmin > int32(1) || (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmax > int32(1) { - *(*int32)(unsafe.Pointer(bp)) = 0 + **(**int32)(__ccgo_up(bp)) = 0 } iter_depth = iter_depth + 1 default: @@ -131703,12 +131703,12 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit } case int32(_EXPAND_AFTER_ITER): iter1 = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj - *(*int32)(unsafe.Pointer(bp)) = _tre_stack_pop_int(tls, stack) - pos_add_last = *(*int32)(unsafe.Pointer(bp)) + **(**int32)(__ccgo_up(bp)) = _tre_stack_pop_int(tls, stack) + pos_add_last = **(**int32)(__ccgo_up(bp)) if (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Fmin > int32(1) || (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Fmax > int32(1) { seq1 = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(bp + 8)) = UintptrFromInt32(0) - pos_add_save = *(*int32)(unsafe.Pointer(bp)) + **(**uintptr)(__ccgo_up(bp + 8)) = UintptrFromInt32(0) + pos_add_save = **(**int32)(__ccgo_up(bp)) /* Create a catenated sequence of copies of the node. */ j = 0 for { @@ -131722,15 +131722,15 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit } /* Remove tags from all but the last copy. */ flags = v2 - pos_add_save = *(*int32)(unsafe.Pointer(bp)) + pos_add_save = **(**int32)(__ccgo_up(bp)) status = _tre_copy_ast(tls, mem, stack, (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Farg, flags, bp, tag_directions, bp+12, bp+4) if status != REG_OK { return status } if seq1 != UintptrFromInt32(0) { - seq1 = _tre_ast_new_catenation(tls, mem, seq1, *(*uintptr)(unsafe.Pointer(bp + 12))) + seq1 = _tre_ast_new_catenation(tls, mem, seq1, **(**uintptr)(__ccgo_up(bp + 12))) } else { - seq1 = *(*uintptr)(unsafe.Pointer(bp + 12)) + seq1 = **(**uintptr)(__ccgo_up(bp + 12)) } if seq1 == UintptrFromInt32(0) { return int32(REG_ESPACE) @@ -131742,13 +131742,13 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit } if (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Fmax == -int32(1) { /* No upper limit. */ - pos_add_save = *(*int32)(unsafe.Pointer(bp)) + pos_add_save = **(**int32)(__ccgo_up(bp)) status = _tre_copy_ast(tls, mem, stack, (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Farg, 0, bp, UintptrFromInt32(0), bp+8, bp+4) if status != REG_OK { return status } - *(*uintptr)(unsafe.Pointer(bp + 8)) = _tre_ast_new_iter(tls, mem, *(*uintptr)(unsafe.Pointer(bp + 8)), 0, -int32(1), 0) - if *(*uintptr)(unsafe.Pointer(bp + 8)) == UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(bp + 8)) = _tre_ast_new_iter(tls, mem, **(**uintptr)(__ccgo_up(bp + 8)), 0, -int32(1), 0) + if **(**uintptr)(__ccgo_up(bp + 8)) == UintptrFromInt32(0) { return int32(REG_ESPACE) } } else { @@ -131757,25 +131757,25 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit if !(j < (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Fmax) { break } - pos_add_save = *(*int32)(unsafe.Pointer(bp)) + pos_add_save = **(**int32)(__ccgo_up(bp)) status = _tre_copy_ast(tls, mem, stack, (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Farg, 0, bp, UintptrFromInt32(0), bp+16, bp+4) if status != REG_OK { return status } - if *(*uintptr)(unsafe.Pointer(bp + 8)) != UintptrFromInt32(0) { - *(*uintptr)(unsafe.Pointer(bp + 8)) = _tre_ast_new_catenation(tls, mem, *(*uintptr)(unsafe.Pointer(bp + 16)), *(*uintptr)(unsafe.Pointer(bp + 8))) + if **(**uintptr)(__ccgo_up(bp + 8)) != UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(bp + 8)) = _tre_ast_new_catenation(tls, mem, **(**uintptr)(__ccgo_up(bp + 16)), **(**uintptr)(__ccgo_up(bp + 8))) } else { - *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 16)) + **(**uintptr)(__ccgo_up(bp + 8)) = **(**uintptr)(__ccgo_up(bp + 16)) } - if *(*uintptr)(unsafe.Pointer(bp + 8)) == UintptrFromInt32(0) { + if **(**uintptr)(__ccgo_up(bp + 8)) == UintptrFromInt32(0) { return int32(REG_ESPACE) } tmp = _tre_ast_new_literal(tls, mem, -int32(1), -int32(1), -int32(1)) if tmp == UintptrFromInt32(0) { return int32(REG_ESPACE) } - *(*uintptr)(unsafe.Pointer(bp + 8)) = _tre_ast_new_union(tls, mem, tmp, *(*uintptr)(unsafe.Pointer(bp + 8))) - if *(*uintptr)(unsafe.Pointer(bp + 8)) == UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(bp + 8)) = _tre_ast_new_union(tls, mem, tmp, **(**uintptr)(__ccgo_up(bp + 8))) + if **(**uintptr)(__ccgo_up(bp + 8)) == UintptrFromInt32(0) { return int32(REG_ESPACE) } goto _3 @@ -131784,12 +131784,12 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit j = j + 1 } } - *(*int32)(unsafe.Pointer(bp)) = pos_add_save + **(**int32)(__ccgo_up(bp)) = pos_add_save if seq1 == UintptrFromInt32(0) { - seq1 = *(*uintptr)(unsafe.Pointer(bp + 8)) + seq1 = **(**uintptr)(__ccgo_up(bp + 8)) } else { - if *(*uintptr)(unsafe.Pointer(bp + 8)) != UintptrFromInt32(0) { - seq1 = _tre_ast_new_catenation(tls, mem, seq1, *(*uintptr)(unsafe.Pointer(bp + 8))) + if **(**uintptr)(__ccgo_up(bp + 8)) != UintptrFromInt32(0) { + seq1 = _tre_ast_new_catenation(tls, mem, seq1, **(**uintptr)(__ccgo_up(bp + 8))) } } if seq1 == UintptrFromInt32(0) { @@ -131799,21 +131799,21 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit (*Ttre_ast_node_t)(unsafe.Pointer(node)).Ftype1 = (*Ttre_ast_node_t)(unsafe.Pointer(seq1)).Ftype1 } iter_depth = iter_depth - 1 - pos_add_total = pos_add_total + (*(*int32)(unsafe.Pointer(bp)) - pos_add_last) + pos_add_total = pos_add_total + (**(**int32)(__ccgo_up(bp)) - pos_add_last) if iter_depth == 0 { - *(*int32)(unsafe.Pointer(bp)) = pos_add_total + **(**int32)(__ccgo_up(bp)) = pos_add_total } default: break } } - *(*int32)(unsafe.Pointer(position)) += pos_add_total + **(**int32)(__ccgo_up(position)) += pos_add_total /* `max_pos' should never be larger than `*position' if the above code works, but just an extra safeguard let's make sure `*position' is set large enough so enough memory will be allocated for the transition table. */ - if *(*int32)(unsafe.Pointer(bp + 4)) > *(*int32)(unsafe.Pointer(position)) { - *(*int32)(unsafe.Pointer(position)) = *(*int32)(unsafe.Pointer(bp + 4)) + if **(**int32)(__ccgo_up(bp + 4)) > **(**int32)(__ccgo_up(position)) { + **(**int32)(__ccgo_up(position)) = **(**int32)(__ccgo_up(bp + 4)) } return status } @@ -131825,9 +131825,9 @@ func _tre_set_empty(tls *TLS, mem Ttre_mem_t) (r uintptr) { if new_set == UintptrFromInt32(0) { return UintptrFromInt32(0) } - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fposition = -int32(1) - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fcode_min = -int32(1) - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fcode_max = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fposition = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fcode_min = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fcode_max = -int32(1) return new_set } @@ -131838,15 +131838,15 @@ func _tre_set_one(tls *TLS, mem Ttre_mem_t, position int32, code_min int32, code if new_set == UintptrFromInt32(0) { return UintptrFromInt32(0) } - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fposition = position - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fcode_min = code_min - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fcode_max = code_max - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fclass = class - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fneg_classes = neg_classes - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fbackref = backref - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + 1*32))).Fposition = -int32(1) - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + 1*32))).Fcode_min = -int32(1) - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + 1*32))).Fcode_max = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fposition = position + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fcode_min = code_min + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fcode_max = code_max + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fclass = class + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fneg_classes = neg_classes + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fbackref = backref + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + 1*32))).Fposition = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + 1*32))).Fcode_min = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + 1*32))).Fcode_max = -int32(1) return new_set } @@ -131856,7 +131856,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u _, _, _, _, _, _, _ = i, j, new_set, new_tags, num_tags, s1, s2 num_tags = 0 for { - if !(tags != UintptrFromInt32(0) && *(*int32)(unsafe.Pointer(tags + uintptr(num_tags)*4)) >= 0) { + if !(tags != UintptrFromInt32(0) && **(**int32)(__ccgo_up(tags + uintptr(num_tags)*4)) >= 0) { break } goto _1 @@ -131866,7 +131866,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u } s1 = 0 for { - if !((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*32))).Fposition >= 0) { + if !((**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*32))).Fposition >= 0) { break } goto _2 @@ -131876,7 +131876,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u } s2 = 0 for { - if !((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*32))).Fposition >= 0) { + if !((**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*32))).Fposition >= 0) { break } goto _3 @@ -131890,22 +131890,22 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u } s1 = 0 for { - if !((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*32))).Fposition >= 0) { + if !((**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*32))).Fposition >= 0) { break } - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*32))).Fposition = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*32))).Fposition - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*32))).Fcode_min = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*32))).Fcode_min - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*32))).Fcode_max = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*32))).Fcode_max - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*32))).Fassertions = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*32))).Fassertions | assertions - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*32))).Fclass = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*32))).Fclass - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*32))).Fneg_classes = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*32))).Fneg_classes - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*32))).Fbackref = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*32))).Fbackref - if (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*32))).Ftags == UintptrFromInt32(0) && tags == UintptrFromInt32(0) { - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*32))).Ftags = UintptrFromInt32(0) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*32))).Fposition = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*32))).Fposition + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*32))).Fcode_min = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*32))).Fcode_min + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*32))).Fcode_max = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*32))).Fcode_max + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*32))).Fassertions = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*32))).Fassertions | assertions + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*32))).Fclass = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*32))).Fclass + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*32))).Fneg_classes = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*32))).Fneg_classes + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*32))).Fbackref = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*32))).Fbackref + if (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*32))).Ftags == UintptrFromInt32(0) && tags == UintptrFromInt32(0) { + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*32))).Ftags = UintptrFromInt32(0) } else { i = 0 for { - if !((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*32))).Ftags != UintptrFromInt32(0) && *(*int32)(unsafe.Pointer((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*32))).Ftags + uintptr(i)*4)) >= 0) { + if !((**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*32))).Ftags != UintptrFromInt32(0) && **(**int32)(__ccgo_up((**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*32))).Ftags + uintptr(i)*4)) >= 0) { break } goto _5 @@ -131922,7 +131922,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u if !(j < i) { break } - *(*int32)(unsafe.Pointer(new_tags + uintptr(j)*4)) = *(*int32)(unsafe.Pointer((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*32))).Ftags + uintptr(j)*4)) + **(**int32)(__ccgo_up(new_tags + uintptr(j)*4)) = **(**int32)(__ccgo_up((**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*32))).Ftags + uintptr(j)*4)) goto _6 _6: ; @@ -131933,14 +131933,14 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u if !(i < num_tags) { break } - *(*int32)(unsafe.Pointer(new_tags + uintptr(j+i)*4)) = *(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) + **(**int32)(__ccgo_up(new_tags + uintptr(j+i)*4)) = **(**int32)(__ccgo_up(tags + uintptr(i)*4)) goto _7 _7: ; i = i + 1 } - *(*int32)(unsafe.Pointer(new_tags + uintptr(j+i)*4)) = -int32(1) - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*32))).Ftags = new_tags + **(**int32)(__ccgo_up(new_tags + uintptr(j+i)*4)) = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*32))).Ftags = new_tags } goto _4 _4: @@ -131949,23 +131949,23 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u } s2 = 0 for { - if !((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*32))).Fposition >= 0) { + if !((**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*32))).Fposition >= 0) { break } - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*32))).Fposition = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*32))).Fposition - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*32))).Fcode_min = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*32))).Fcode_min - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*32))).Fcode_max = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*32))).Fcode_max + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*32))).Fposition = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*32))).Fposition + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*32))).Fcode_min = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*32))).Fcode_min + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*32))).Fcode_max = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*32))).Fcode_max /* XXX - why not | assertions here as well? */ - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*32))).Fassertions = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*32))).Fassertions - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*32))).Fclass = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*32))).Fclass - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*32))).Fneg_classes = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*32))).Fneg_classes - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*32))).Fbackref = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*32))).Fbackref - if (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*32))).Ftags == UintptrFromInt32(0) { - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*32))).Ftags = UintptrFromInt32(0) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*32))).Fassertions = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*32))).Fassertions + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*32))).Fclass = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*32))).Fclass + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*32))).Fneg_classes = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*32))).Fneg_classes + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*32))).Fbackref = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*32))).Fbackref + if (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*32))).Ftags == UintptrFromInt32(0) { + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*32))).Ftags = UintptrFromInt32(0) } else { i = 0 for { - if !(*(*int32)(unsafe.Pointer((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*32))).Ftags + uintptr(i)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*32))).Ftags + uintptr(i)*4)) >= 0) { break } goto _9 @@ -131982,21 +131982,21 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u if !(j < i) { break } - *(*int32)(unsafe.Pointer(new_tags + uintptr(j)*4)) = *(*int32)(unsafe.Pointer((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*32))).Ftags + uintptr(j)*4)) + **(**int32)(__ccgo_up(new_tags + uintptr(j)*4)) = **(**int32)(__ccgo_up((**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*32))).Ftags + uintptr(j)*4)) goto _10 _10: ; j = j + 1 } - *(*int32)(unsafe.Pointer(new_tags + uintptr(j)*4)) = -int32(1) - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*32))).Ftags = new_tags + **(**int32)(__ccgo_up(new_tags + uintptr(j)*4)) = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*32))).Ftags = new_tags } goto _8 _8: ; s2 = s2 + 1 } - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*32))).Fposition = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*32))).Fposition = -int32(1) return new_set } @@ -132014,7 +132014,7 @@ func _tre_match_empty(tls *TLS, stack uintptr, node uintptr, tags uintptr, asser bottom = _tre_stack_num_objects(tls, stack) status = REG_OK if num_tags_seen != 0 { - *(*int32)(unsafe.Pointer(num_tags_seen)) = 0 + **(**int32)(__ccgo_up(num_tags_seen)) = 0 } status = _tre_stack_push_voidptr(tls, stack, node) /* Walk through the tree recursively. */ @@ -132030,10 +132030,10 @@ func _tre_match_empty(tls *TLS, stack uintptr, node uintptr, tags uintptr, asser /* Add the tag to `tags'. */ i = 0 for { - if !(*(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(tags + uintptr(i)*4)) >= 0) { break } - if *(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) == (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max { + if int32(**(**int32)(__ccgo_up(tags + uintptr(i)*4))) == (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max { break } goto _1 @@ -132041,13 +132041,13 @@ func _tre_match_empty(tls *TLS, stack uintptr, node uintptr, tags uintptr, asser ; i = i + 1 } - if *(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) < 0 { - *(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) = (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max - *(*int32)(unsafe.Pointer(tags + uintptr(i+int32(1))*4)) = -int32(1) + if **(**int32)(__ccgo_up(tags + uintptr(i)*4)) < 0 { + **(**int32)(__ccgo_up(tags + uintptr(i)*4)) = (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max + **(**int32)(__ccgo_up(tags + uintptr(i+int32(1))*4)) = -int32(1) } } if num_tags_seen != 0 { - *(*int32)(unsafe.Pointer(num_tags_seen)) = *(*int32)(unsafe.Pointer(num_tags_seen)) + 1 + **(**int32)(__ccgo_up(num_tags_seen)) = **(**int32)(__ccgo_up(num_tags_seen)) + 1 } } case -int32(2): @@ -132291,12 +132291,12 @@ func _tre_compute_nfl(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr) (r return status } /* Allocate arrays for the tags and parameters. */ - tags = Xmalloc(tls, uint32(4)*Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))+Int32FromInt32(1))) + tags = Xmalloc(tls, uint32(4)*Uint32FromInt32(**(**int32)(__ccgo_up(bp))+Int32FromInt32(1))) if !(tags != 0) { return int32(REG_ESPACE) } - *(*int32)(unsafe.Pointer(tags)) = -int32(1) - *(*int32)(unsafe.Pointer(bp + 4)) = 0 + **(**int32)(__ccgo_up(tags)) = -int32(1) + **(**int32)(__ccgo_up(bp + 4)) = 0 /* Second pass with tre_mach_empty() to get the list of tags and parameters. */ status = _tre_match_empty(tls, stack, (*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft, tags, bp+4, UintptrFromInt32(0)) @@ -132304,7 +132304,7 @@ func _tre_compute_nfl(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr) (r Xfree(tls, tags) return status } - (*Ttre_ast_node_t)(unsafe.Pointer(node)).Ffirstpos = _tre_set_union(tls, mem, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright)).Ffirstpos, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft)).Ffirstpos, tags, *(*int32)(unsafe.Pointer(bp + 4))) + (*Ttre_ast_node_t)(unsafe.Pointer(node)).Ffirstpos = _tre_set_union(tls, mem, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright)).Ffirstpos, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft)).Ffirstpos, tags, **(**int32)(__ccgo_up(bp + 4))) Xfree(tls, tags) if !((*Ttre_ast_node_t)(unsafe.Pointer(node)).Ffirstpos != 0) { return int32(REG_ESPACE) @@ -132322,12 +132322,12 @@ func _tre_compute_nfl(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr) (r return status } /* Allocate arrays for the tags and parameters. */ - tags = Xmalloc(tls, uint32(4)*Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))+Int32FromInt32(1))) + tags = Xmalloc(tls, uint32(4)*Uint32FromInt32(**(**int32)(__ccgo_up(bp))+Int32FromInt32(1))) if !(tags != 0) { return int32(REG_ESPACE) } - *(*int32)(unsafe.Pointer(tags)) = -int32(1) - *(*int32)(unsafe.Pointer(bp + 4)) = 0 + **(**int32)(__ccgo_up(tags)) = -int32(1) + **(**int32)(__ccgo_up(bp + 4)) = 0 /* Second pass with tre_mach_empty() to get the list of tags and parameters. */ status = _tre_match_empty(tls, stack, (*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright, tags, bp+4, UintptrFromInt32(0)) @@ -132335,7 +132335,7 @@ func _tre_compute_nfl(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr) (r Xfree(tls, tags) return status } - (*Ttre_ast_node_t)(unsafe.Pointer(node)).Flastpos = _tre_set_union(tls, mem, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft)).Flastpos, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright)).Flastpos, tags, *(*int32)(unsafe.Pointer(bp + 4))) + (*Ttre_ast_node_t)(unsafe.Pointer(node)).Flastpos = _tre_set_union(tls, mem, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft)).Flastpos, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright)).Flastpos, tags, **(**int32)(__ccgo_up(bp + 4))) Xfree(tls, tags) if !((*Ttre_ast_node_t)(unsafe.Pointer(node)).Flastpos != 0) { return int32(REG_ESPACE) @@ -132371,7 +132371,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun prev_p2_pos = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fposition /* Set `trans' to point to the next unused transition from position `p1->position'. */ - trans = transitions + uintptr(*(*int32)(unsafe.Pointer(offs + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)))*32 + trans = transitions + uintptr(**(**int32)(__ccgo_up(offs + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)))*32 for (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fstate != UintptrFromInt32(0) { trans += 32 } @@ -132382,7 +132382,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun the transition from `p1' to `p2'. */ (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fcode_min = Uint32FromInt32((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fcode_min) (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fcode_max = Uint32FromInt32((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fcode_max) - (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fstate = transitions + uintptr(*(*int32)(unsafe.Pointer(offs + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fposition)*4)))*32 + (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fstate = transitions + uintptr(**(**int32)(__ccgo_up(offs + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fposition)*4)))*32 (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fstate_id = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fposition if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fclass != 0 { v1 = int32(ASSERT_CHAR_CLASS) @@ -132397,14 +132397,14 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fassertions = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fassertions | (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fassertions | v1 | v2 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fbackref >= 0 { *(*int32)(unsafe.Pointer(trans + 24)) = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fbackref - *(*int32)(unsafe.Pointer(trans + 20)) |= int32(ASSERT_BACKREF) + **(**int32)(__ccgo_up(trans + 20)) |= int32(ASSERT_BACKREF) } else { *(*Ttre_ctype_t)(unsafe.Pointer(trans + 24)) = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fclass } if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes != UintptrFromInt32(0) { i = 0 for { - if !(*(*Ttre_ctype_t)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes + uintptr(i)*4)) != Uint32FromInt32(0)) { + if !(**(**Ttre_ctype_t)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes + uintptr(i)*4)) != Uint32FromInt32(0)) { break } goto _3 @@ -132418,29 +132418,29 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun } i = 0 for { - if !(*(*Ttre_ctype_t)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes + uintptr(i)*4)) != Uint32FromInt32(0)) { + if !(**(**Ttre_ctype_t)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes + uintptr(i)*4)) != Uint32FromInt32(0)) { break } - *(*Ttre_ctype_t)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes + uintptr(i)*4)) = *(*Ttre_ctype_t)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes + uintptr(i)*4)) + **(**Ttre_ctype_t)(__ccgo_up((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes + uintptr(i)*4)) = **(**Ttre_ctype_t)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes + uintptr(i)*4)) goto _4 _4: ; i = i + 1 } - *(*Ttre_ctype_t)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes + uintptr(i)*4)) = Uint32FromInt32(0) + **(**Ttre_ctype_t)(__ccgo_up((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes + uintptr(i)*4)) = Uint32FromInt32(0) } else { (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes = UintptrFromInt32(0) } /* Find out how many tags this transition has. */ i = 0 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags != UintptrFromInt32(0) { - for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) >= 0 { + for **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) >= 0 { i = i + 1 } } j = 0 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags != UintptrFromInt32(0) { - for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) >= 0 { + for **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) >= 0 { j = j + 1 } } @@ -132457,15 +132457,15 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun } i = 0 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags != UintptrFromInt32(0) { - for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) >= 0 { - *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(i)*4)) = *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) + for **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) >= 0 { + **(**int32)(__ccgo_up((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(i)*4)) = **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) i = i + 1 } } l = i j = 0 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags != UintptrFromInt32(0) { - for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) >= 0 { + for **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) >= 0 { /* Don't add duplicates. */ dup = 0 k = 0 @@ -132473,7 +132473,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun if !(k < i) { break } - if *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(k)*4)) == *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) { + if **(**int32)(__ccgo_up((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(k)*4)) == **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) { dup = int32(1) break } @@ -132485,12 +132485,12 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun if !(dup != 0) { v1 = l l = l + 1 - *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(v1)*4)) = *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) + **(**int32)(__ccgo_up((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(v1)*4)) = **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) } j = j + 1 } } - *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(l)*4)) = -int32(1) + **(**int32)(__ccgo_up((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(l)*4)) = -int32(1) } p2 += 32 } @@ -132502,7 +132502,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun for (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition >= 0 { p2 = orig_p2 for (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fposition >= 0 { - *(*int32)(unsafe.Pointer(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)) = *(*int32)(unsafe.Pointer(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)) + 1 + **(**int32)(__ccgo_up(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)) = **(**int32)(__ccgo_up(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)) + 1 p2 += 32 } p1 += 32 @@ -132593,11 +132593,11 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { } /* Parse the regexp. */ Xmemset(tls, bp, 0, uint32(36)) - (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fmem = mem - (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fstack = stack - (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fstart = regex - (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fcflags = cflags - (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fmax_backref = -int32(1) + (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fmem = mem + (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fstack = stack + (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fstart = regex + (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fcflags = cflags + (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fmax_backref = -int32(1) errcode = _tre_parse(tls, bp) if errcode != REG_OK { errcode = errcode @@ -132605,10 +132605,10 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { goto error_exit } } - (*Tregex_t)(unsafe.Pointer(preg)).Fre_nsub = Uint32FromInt32((*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fsubmatch_id - int32(1)) - tree = (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fn + (*Tregex_t)(unsafe.Pointer(preg)).Fre_nsub = Uint32FromInt32((**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fsubmatch_id - int32(1)) + tree = (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fn /* Referring to nonexistent subexpressions is illegal. */ - if (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fmax_backref > Int32FromUint32((*Tregex_t)(unsafe.Pointer(preg)).Fre_nsub) { + if (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fmax_backref > Int32FromUint32((*Tregex_t)(unsafe.Pointer(preg)).Fre_nsub) { errcode = int32(REG_ESUBREG) if int32(1) != 0 { goto error_exit @@ -132622,9 +132622,9 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { goto error_exit } } - (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fhave_backrefs = BoolInt32((*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fmax_backref >= 0) + (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fhave_backrefs = BoolInt32((**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fmax_backref >= 0) (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fhave_approx = 0 - (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches = Uint32FromInt32((*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fsubmatch_id) + (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches = Uint32FromInt32((**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fsubmatch_id) /* Set up tags for submatch addressing. If REG_NOSUB is set and the regexp does not have back references, this can be skipped. */ if (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fhave_backrefs != 0 || !(cflags&Int32FromInt32(REG_NOSUB) != 0) { @@ -132654,7 +132654,7 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { goto error_exit } } - submatch_data = Xcalloc(tls, Uint32FromInt32((*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fsubmatch_id), uint32(12)) + submatch_data = Xcalloc(tls, Uint32FromInt32((**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fsubmatch_id), uint32(12)) if submatch_data == UintptrFromInt32(0) { errcode = int32(REG_ESPACE) if int32(1) != 0 { @@ -132707,14 +132707,14 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { goto error_exit } } - counts = Xmalloc(tls, uint32(4)*Uint32FromInt32((*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fposition)) + counts = Xmalloc(tls, uint32(4)*Uint32FromInt32((**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fposition)) if counts == UintptrFromInt32(0) { errcode = int32(REG_ESPACE) if int32(1) != 0 { goto error_exit } } - offs = Xmalloc(tls, uint32(4)*Uint32FromInt32((*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fposition)) + offs = Xmalloc(tls, uint32(4)*Uint32FromInt32((**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fposition)) if offs == UintptrFromInt32(0) { errcode = int32(REG_ESPACE) if int32(1) != 0 { @@ -132723,10 +132723,10 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { } i = 0 for { - if !(i < (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fposition) { + if !(i < (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fposition) { break } - *(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) = 0 + **(**int32)(__ccgo_up(counts + uintptr(i)*4)) = 0 goto _3 _3: ; @@ -132736,12 +132736,12 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { add = 0 i = 0 for { - if !(i < (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fposition) { + if !(i < (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fposition) { break } - *(*int32)(unsafe.Pointer(offs + uintptr(i)*4)) = add - add = add + (*(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) + int32(1)) - *(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) = 0 + **(**int32)(__ccgo_up(offs + uintptr(i)*4)) = add + add = add + (**(**int32)(__ccgo_up(counts + uintptr(i)*4)) + int32(1)) + **(**int32)(__ccgo_up(counts + uintptr(i)*4)) = 0 goto _4 _4: ; @@ -132784,15 +132784,15 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { if !((*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fposition >= 0) { break } - (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*32))).Fstate = transitions + uintptr(*(*int32)(unsafe.Pointer(offs + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fposition)*4)))*32 - (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*32))).Fstate_id = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fposition - (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*32))).Ftags = UintptrFromInt32(0) + (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*32))).Fstate = transitions + uintptr(**(**int32)(__ccgo_up(offs + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fposition)*4)))*32 + (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*32))).Fstate_id = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fposition + (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*32))).Ftags = UintptrFromInt32(0) /* Copy the arrays p->tags, and p->params, they are allocated from a tre_mem object. */ if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Ftags != 0 { j = 0 for { - if !(*(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Ftags + uintptr(j)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Ftags + uintptr(j)*4)) >= 0) { break } goto _6 @@ -132800,26 +132800,26 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { ; j = j + 1 } - (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*32))).Ftags = Xmalloc(tls, uint32(4)*Uint32FromInt32(j+Int32FromInt32(1))) - if !((*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*32))).Ftags != 0) { + (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*32))).Ftags = Xmalloc(tls, uint32(4)*Uint32FromInt32(j+Int32FromInt32(1))) + if !((**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*32))).Ftags != 0) { errcode = int32(REG_ESPACE) if int32(1) != 0 { goto error_exit } } - _memcpy(tls, (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*32))).Ftags, (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Ftags, uint32(4)*Uint32FromInt32(j+Int32FromInt32(1))) + _memcpy(tls, (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*32))).Ftags, (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Ftags, uint32(4)*Uint32FromInt32(j+Int32FromInt32(1))) } - (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*32))).Fassertions = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fassertions + (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*32))).Fassertions = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fassertions i = i + 1 goto _5 _5: ; p += 32 } - (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*32))).Fstate = UintptrFromInt32(0) + (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*32))).Fstate = UintptrFromInt32(0) (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_transitions = Uint32FromInt32(add) - (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ffinal = transitions + uintptr(*(*int32)(unsafe.Pointer(offs + uintptr((*(*Ttre_pos_and_tags_t)(unsafe.Pointer((*Ttre_ast_node_t)(unsafe.Pointer(tree)).Flastpos))).Fposition)*4)))*32 - (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_states = (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fposition + (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ffinal = transitions + uintptr(**(**int32)(__ccgo_up(offs + uintptr((**(**Ttre_pos_and_tags_t)(__ccgo_up((*Ttre_ast_node_t)(unsafe.Pointer(tree)).Flastpos))).Fposition)*4)))*32 + (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_states = (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fposition (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags = cflags X__tre_mem_destroy(tls, mem) _tre_stack_destroy(tls, stack) @@ -132862,12 +132862,12 @@ func Xregfree(tls *TLS, preg uintptr) { if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_transitions) { break } - if (*(*Ttre_tnfa_transition_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*32))).Fstate != 0 { - if (*(*Ttre_tnfa_transition_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*32))).Ftags != 0 { - Xfree(tls, (*(*Ttre_tnfa_transition_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*32))).Ftags) + if (**(**Ttre_tnfa_transition_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*32))).Fstate != 0 { + if (**(**Ttre_tnfa_transition_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*32))).Ftags != 0 { + Xfree(tls, (**(**Ttre_tnfa_transition_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*32))).Ftags) } - if (*(*Ttre_tnfa_transition_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*32))).Fneg_classes != 0 { - Xfree(tls, (*(*Ttre_tnfa_transition_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*32))).Fneg_classes) + if (**(**Ttre_tnfa_transition_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*32))).Fneg_classes != 0 { + Xfree(tls, (**(**Ttre_tnfa_transition_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*32))).Fneg_classes) } } goto _1 @@ -132900,8 +132900,8 @@ func Xregfree(tls *TLS, preg uintptr) { if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches) { break } - if (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(i)*12))).Fparents != 0 { - Xfree(tls, (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(i)*12))).Fparents) + if (**(**Ttre_submatch_data_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(i)*12))).Fparents != 0 { + Xfree(tls, (**(**Ttre_submatch_data_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(i)*12))).Fparents) } goto _3 _3: @@ -132941,7 +132941,7 @@ func Xregerror(tls *TLS, e int32, preg uintptr, buf uintptr, size Tsize_t) (r Ts _ = s s = uintptr(unsafe.Pointer(&_messages)) for { - if !(e != 0 && *(*uint8)(unsafe.Pointer(s)) != 0) { + if !(e != 0 && **(**uint8)(__ccgo_up(s)) != 0) { break } goto _1 @@ -132950,7 +132950,7 @@ func Xregerror(tls *TLS, e int32, preg uintptr, buf uintptr, size Tsize_t) (r Ts e = e - 1 s = s + uintptr(_strlen(tls, s)+uint32(1)) } - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { s = s + 1 } s = X__lctrans_cur(tls, s) @@ -132976,18 +132976,18 @@ func _tre_tag_order(tls *TLS, num_tags int32, tag_directions uintptr, t1 uintptr if !(i < num_tags) { break } - if *(*Ttre_tag_direction_t)(unsafe.Pointer(tag_directions + uintptr(i)*4)) == int32(_TRE_TAG_MINIMIZE) { - if *(*Tregoff_t)(unsafe.Pointer(t1 + uintptr(i)*4)) < *(*Tregoff_t)(unsafe.Pointer(t2 + uintptr(i)*4)) { + if **(**Ttre_tag_direction_t)(__ccgo_up(tag_directions + uintptr(i)*4)) == int32(_TRE_TAG_MINIMIZE) { + if **(**Tregoff_t)(__ccgo_up(t1 + uintptr(i)*4)) < **(**Tregoff_t)(__ccgo_up(t2 + uintptr(i)*4)) { return int32(1) } - if *(*Tregoff_t)(unsafe.Pointer(t1 + uintptr(i)*4)) > *(*Tregoff_t)(unsafe.Pointer(t2 + uintptr(i)*4)) { + if **(**Tregoff_t)(__ccgo_up(t1 + uintptr(i)*4)) > **(**Tregoff_t)(__ccgo_up(t2 + uintptr(i)*4)) { return 0 } } else { - if *(*Tregoff_t)(unsafe.Pointer(t1 + uintptr(i)*4)) > *(*Tregoff_t)(unsafe.Pointer(t2 + uintptr(i)*4)) { + if **(**Tregoff_t)(__ccgo_up(t1 + uintptr(i)*4)) > **(**Tregoff_t)(__ccgo_up(t2 + uintptr(i)*4)) { return int32(1) } - if *(*Tregoff_t)(unsafe.Pointer(t1 + uintptr(i)*4)) < *(*Tregoff_t)(unsafe.Pointer(t2 + uintptr(i)*4)) { + if **(**Tregoff_t)(__ccgo_up(t1 + uintptr(i)*4)) < **(**Tregoff_t)(__ccgo_up(t2 + uintptr(i)*4)) { return 0 } } @@ -133001,8 +133001,8 @@ func _tre_tag_order(tls *TLS, num_tags int32, tag_directions uintptr, t1 uintptr } func _tre_neg_char_classes_match(tls *TLS, classes uintptr, wc Ttre_cint_t, icase int32) (r int32) { - for *(*Ttre_ctype_t)(unsafe.Pointer(classes)) != Uint32FromInt32(0) { - if !(icase != 0) && Xiswctype(tls, wc, *(*Ttre_ctype_t)(unsafe.Pointer(classes))) != 0 || icase != 0 && (Xiswctype(tls, Xtowupper(tls, wc), *(*Ttre_ctype_t)(unsafe.Pointer(classes))) != 0 || Xiswctype(tls, Xtowlower(tls, wc), *(*Ttre_ctype_t)(unsafe.Pointer(classes))) != 0) { + for **(**Ttre_ctype_t)(__ccgo_up(classes)) != Uint32FromInt32(0) { + if !(icase != 0) && Xiswctype(tls, wc, **(**Ttre_ctype_t)(__ccgo_up(classes))) != 0 || icase != 0 && (Xiswctype(tls, Xtowupper(tls, wc), **(**Ttre_ctype_t)(__ccgo_up(classes))) != 0 || Xiswctype(tls, Xtowlower(tls, wc), **(**Ttre_ctype_t)(__ccgo_up(classes))) != 0) { return int32(1) } else { classes += 4 @@ -133055,7 +133055,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = buf, end, i, match_eo, new_match, num_tags, pbytes, pos, pos_add_next, prev_c, rbytes, reach, reach_i, reach_next, reach_next_i, reach_pos, reg_newline, reg_notbol, reg_noteol, ret, skip, start, str_byte, tag_i, tbytes, tmp_buf, tmp_iptr, tmp_tags, total_bytes, trans_i, xbytes, v1, v18, v7 /* State variables required by GET_NEXT_WCHAR. */ prev_c = uint32(0) - *(*Ttre_char_t)(unsafe.Pointer(bp)) = uint32(0) + **(**Ttre_char_t)(__ccgo_up(bp)) = uint32(0) str_byte = string1 pos = -int32(1) pos_add_next = int32(1) @@ -133135,9 +133135,9 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_states) { break } - (*(*Ttre_tnfa_reach_t)(unsafe.Pointer(reach + uintptr(i)*8))).Ftags = tmp_buf + (**(**Ttre_tnfa_reach_t)(__ccgo_up(reach + uintptr(i)*8))).Ftags = tmp_buf tmp_buf = tmp_buf + uintptr(xbytes) - (*(*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next + uintptr(i)*8))).Ftags = tmp_buf + (**(**Ttre_tnfa_reach_t)(__ccgo_up(reach_next + uintptr(i)*8))).Ftags = tmp_buf tmp_buf = tmp_buf + uintptr(xbytes) goto _5 _5: @@ -133149,13 +133149,13 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_states) { break } - (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr(i)*8))).Fpos = -int32(1) + (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr(i)*8))).Fpos = -int32(1) goto _6 _6: ; i = i + 1 } - prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + prev_c = **(**Ttre_char_t)(__ccgo_up(bp)) pos = pos + pos_add_next v7 = Xmbtowc(tls, bp, str_byte, uint32(MB_LEN_MAX)) pos_add_next = v7 @@ -133175,8 +133175,8 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if match_eo < 0 { trans_i = (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Finitial for (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate != UintptrFromInt32(0) { - if (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*8))).Fpos < pos { - if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != uint32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != uint32('\000') || reg_noteol != 0) && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != uint32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0 || !(*(*Ttre_char_t)(unsafe.Pointer(bp)) == uint32('_') || Xiswalnum(tls, *(*Ttre_char_t)(unsafe.Pointer(bp))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0) || (*(*Ttre_char_t)(unsafe.Pointer(bp)) == uint32('_') || Xiswalnum(tls, *(*Ttre_char_t)(unsafe.Pointer(bp))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && *(*Ttre_char_t)(unsafe.Pointer(bp)) != uint32('\000') && BoolInt32(prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0) == BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == uint32('_') || Xiswalnum(tls, *(*Ttre_char_t)(unsafe.Pointer(bp))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || *(*Ttre_char_t)(unsafe.Pointer(bp)) == uint32('\000') || BoolInt32(prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0) != BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == uint32('_') || Xiswalnum(tls, *(*Ttre_char_t)(unsafe.Pointer(bp))) != 0))) { + if (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*8))).Fpos < pos { + if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != uint32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (**(**Ttre_char_t)(__ccgo_up(bp)) != uint32('\000') || reg_noteol != 0) && (**(**Ttre_char_t)(__ccgo_up(bp)) != uint32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0 || !(**(**Ttre_char_t)(__ccgo_up(bp)) == uint32('_') || Xiswalnum(tls, **(**Ttre_char_t)(__ccgo_up(bp))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0) || (**(**Ttre_char_t)(__ccgo_up(bp)) == uint32('_') || Xiswalnum(tls, **(**Ttre_char_t)(__ccgo_up(bp))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && **(**Ttre_char_t)(__ccgo_up(bp)) != uint32('\000') && BoolInt32(prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0) == BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == uint32('_') || Xiswalnum(tls, **(**Ttre_char_t)(__ccgo_up(bp))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || **(**Ttre_char_t)(__ccgo_up(bp)) == uint32('\000') || BoolInt32(prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0) != BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == uint32('_') || Xiswalnum(tls, **(**Ttre_char_t)(__ccgo_up(bp))) != 0))) { trans_i += 32 continue } @@ -133186,7 +133186,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < num_tags) { break } - *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(i)*4)) = -int32(1) + **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(i)*4)) = -int32(1) goto _8 _8: ; @@ -133194,9 +133194,9 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags } tag_i = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags if tag_i != 0 { - for *(*int32)(unsafe.Pointer(tag_i)) >= 0 { - if *(*int32)(unsafe.Pointer(tag_i)) < num_tags { - *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(*(*int32)(unsafe.Pointer(tag_i)))*4)) = pos + for **(**int32)(__ccgo_up(tag_i)) >= 0 { + if **(**int32)(__ccgo_up(tag_i)) < num_tags { + **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(**(**int32)(__ccgo_up(tag_i)))*4)) = pos } tag_i += 4 } @@ -133209,15 +133209,15 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < num_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(i)*4)) = *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(i)*4)) + **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(i)*4)) = **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(i)*4)) goto _9 _9: ; i = i + 1 } } - (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*8))).Fpos = pos - (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*8))).Ftags = reach_next_i + 4 + (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*8))).Fpos = pos + (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*8))).Ftags = reach_next_i + 4 reach_next_i += 8 } trans_i += 32 @@ -133230,10 +133230,10 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags } } /* Check for end of string. */ - if !(*(*Ttre_char_t)(unsafe.Pointer(bp)) != 0) { + if !(**(**Ttre_char_t)(__ccgo_up(bp)) != 0) { break } - prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + prev_c = **(**Ttre_char_t)(__ccgo_up(bp)) pos = pos + pos_add_next v7 = Xmbtowc(tls, bp, str_byte, uint32(MB_LEN_MAX)) pos_add_next = v7 @@ -133263,16 +133263,16 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags skip = 0 i = 0 for { - if !(*(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i)*4)) >= 0) { break } - end = *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i)*4)) - start = *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i+int32(1))*4)) + end = **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i)*4)) + start = **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i+int32(1))*4)) if end >= num_tags { skip = int32(1) break } else { - if *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Ftags + uintptr(start)*4)) == *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(start)*4)) && *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Ftags + uintptr(end)*4)) < *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(end)*4)) { + if **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Ftags + uintptr(start)*4)) == **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(start)*4)) && **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Ftags + uintptr(end)*4)) < **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(end)*4)) { skip = int32(1) break } @@ -133316,7 +133316,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags } /* Does this transition match the input symbol? */ if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fcode_min <= prev_c && (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fcode_max >= prev_c { - if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != uint32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != uint32('\000') || reg_noteol != 0) && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != uint32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0 || !(*(*Ttre_char_t)(unsafe.Pointer(bp)) == uint32('_') || Xiswalnum(tls, *(*Ttre_char_t)(unsafe.Pointer(bp))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0) || (*(*Ttre_char_t)(unsafe.Pointer(bp)) == uint32('_') || Xiswalnum(tls, *(*Ttre_char_t)(unsafe.Pointer(bp))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && *(*Ttre_char_t)(unsafe.Pointer(bp)) != uint32('\000') && BoolInt32(prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0) == BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == uint32('_') || Xiswalnum(tls, *(*Ttre_char_t)(unsafe.Pointer(bp))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || *(*Ttre_char_t)(unsafe.Pointer(bp)) == uint32('\000') || BoolInt32(prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0) != BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == uint32('_') || Xiswalnum(tls, *(*Ttre_char_t)(unsafe.Pointer(bp))) != 0)) || ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && !((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&Int32FromInt32(REG_ICASE) != 0) && !(Xiswctype(tls, prev_c, *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 24))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE) != 0 && !(Xiswctype(tls, Xtowlower(tls, prev_c), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 24))) != 0) && !(Xiswctype(tls, Xtowupper(tls, prev_c), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 24))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS_NEG) != 0 && _tre_neg_char_classes_match(tls, (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fneg_classes, prev_c, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE)) != 0)) { + if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != uint32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (**(**Ttre_char_t)(__ccgo_up(bp)) != uint32('\000') || reg_noteol != 0) && (**(**Ttre_char_t)(__ccgo_up(bp)) != uint32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0 || !(**(**Ttre_char_t)(__ccgo_up(bp)) == uint32('_') || Xiswalnum(tls, **(**Ttre_char_t)(__ccgo_up(bp))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0) || (**(**Ttre_char_t)(__ccgo_up(bp)) == uint32('_') || Xiswalnum(tls, **(**Ttre_char_t)(__ccgo_up(bp))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && **(**Ttre_char_t)(__ccgo_up(bp)) != uint32('\000') && BoolInt32(prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0) == BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == uint32('_') || Xiswalnum(tls, **(**Ttre_char_t)(__ccgo_up(bp))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || **(**Ttre_char_t)(__ccgo_up(bp)) == uint32('\000') || BoolInt32(prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0) != BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == uint32('_') || Xiswalnum(tls, **(**Ttre_char_t)(__ccgo_up(bp))) != 0)) || ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && !((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&Int32FromInt32(REG_ICASE) != 0) && !(Xiswctype(tls, prev_c, *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 24))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE) != 0 && !(Xiswctype(tls, Xtowlower(tls, prev_c), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 24))) != 0) && !(Xiswctype(tls, Xtowupper(tls, prev_c), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 24))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS_NEG) != 0 && _tre_neg_char_classes_match(tls, (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fneg_classes, prev_c, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE)) != 0)) { goto _14 } /* Compute the tags after this transition. */ @@ -133325,7 +133325,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < num_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(tmp_tags + uintptr(i)*4)) = *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Ftags + uintptr(i)*4)) + **(**Tregoff_t)(__ccgo_up(tmp_tags + uintptr(i)*4)) = **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Ftags + uintptr(i)*4)) goto _15 _15: ; @@ -133333,22 +133333,22 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags } tag_i = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags if tag_i != UintptrFromInt32(0) { - for *(*int32)(unsafe.Pointer(tag_i)) >= 0 { - if *(*int32)(unsafe.Pointer(tag_i)) < num_tags { - *(*Tregoff_t)(unsafe.Pointer(tmp_tags + uintptr(*(*int32)(unsafe.Pointer(tag_i)))*4)) = pos + for **(**int32)(__ccgo_up(tag_i)) >= 0 { + if **(**int32)(__ccgo_up(tag_i)) < num_tags { + **(**Tregoff_t)(__ccgo_up(tmp_tags + uintptr(**(**int32)(__ccgo_up(tag_i)))*4)) = pos } tag_i += 4 } } - if (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*8))).Fpos < pos { + if (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*8))).Fpos < pos { /* Found an unvisited node. */ (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Fstate = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate tmp_iptr = (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags = tmp_tags tmp_tags = tmp_iptr - (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*8))).Fpos = pos - (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*8))).Ftags = reach_next_i + 4 - if (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Fstate == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ffinal && (match_eo == -int32(1) || num_tags > 0 && *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags)) <= *(*Tregoff_t)(unsafe.Pointer(match_tags))) { + (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*8))).Fpos = pos + (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*8))).Ftags = reach_next_i + 4 + if (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Fstate == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ffinal && (match_eo == -int32(1) || num_tags > 0 && **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags)) <= **(**Tregoff_t)(__ccgo_up(match_tags))) { match_eo = pos new_match = int32(1) i = 0 @@ -133356,7 +133356,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < num_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(i)*4)) = *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(i)*4)) + **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(i)*4)) = **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(i)*4)) goto _16 _16: ; @@ -133368,10 +133368,10 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags /* Another path has also reached this state. We choose the winner by examining the tag values for both paths. */ - if _tre_tag_order(tls, num_tags, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions, tmp_tags, *(*uintptr)(unsafe.Pointer((*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*8))).Ftags))) != 0 { + if _tre_tag_order(tls, num_tags, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions, tmp_tags, **(**uintptr)(__ccgo_up((**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*8))).Ftags))) != 0 { /* The new path wins. */ - tmp_iptr = *(*uintptr)(unsafe.Pointer((*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*8))).Ftags)) - *(*uintptr)(unsafe.Pointer((*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*8))).Ftags)) = tmp_tags + tmp_iptr = **(**uintptr)(__ccgo_up((**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*8))).Ftags)) + **(**uintptr)(__ccgo_up((**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*8))).Ftags)) = tmp_tags if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ffinal { match_eo = pos new_match = int32(1) @@ -133380,7 +133380,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < num_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(i)*4)) = *(*Tregoff_t)(unsafe.Pointer(tmp_tags + uintptr(i)*4)) + **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(i)*4)) = **(**Tregoff_t)(__ccgo_up(tmp_tags + uintptr(i)*4)) goto _17 _17: ; @@ -133403,7 +133403,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags } (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Fstate = UintptrFromInt32(0) } - *(*Tregoff_t)(unsafe.Pointer(match_end_ofs)) = match_eo + **(**Tregoff_t)(__ccgo_up(match_end_ofs)) = match_eo if match_eo >= 0 { v18 = REG_OK } else { @@ -133474,7 +133474,7 @@ func _tre_tnfa_run_backtrack(tls *TLS, tnfa uintptr, string1 uintptr, match_tags _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bt, bt_len, empty_br_match, eo, i, i1, i2, i3, i4, match_eo, mem, next_c_start, next_state, next_tags, pmatch, pos, pos_add_next, pos_start, prev_c, reg_newline, reg_notbol, reg_noteol, result, ret, s, s1, so, stack, state, states_seen, str_byte, str_byte_start, tags, tmp, tmp1, trans_i, v20, v3, v6 /* State variables required by GET_NEXT_WCHAR. */ prev_c = uint32(0) - *(*Ttre_char_t)(unsafe.Pointer(bp)) = uint32(0) + **(**Ttre_char_t)(__ccgo_up(bp)) = uint32(0) str_byte = string1 pos = 0 pos_add_next = int32(1) @@ -133528,9 +133528,9 @@ retry: if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(i)*4)) = -int32(1) + **(**Tregoff_t)(__ccgo_up(tags + uintptr(i)*4)) = -int32(1) if match_tags != 0 { - *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(i)*4)) = -int32(1) + **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(i)*4)) = -int32(1) } goto _1 _1: @@ -133542,7 +133542,7 @@ retry: if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_states) { break } - *(*int32)(unsafe.Pointer(states_seen + uintptr(i)*4)) = 0 + **(**int32)(__ccgo_up(states_seen + uintptr(i)*4)) = 0 goto _2 _2: ; @@ -133550,7 +133550,7 @@ retry: } state = UintptrFromInt32(0) pos = pos_start - prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + prev_c = **(**Ttre_char_t)(__ccgo_up(bp)) pos = pos + pos_add_next v3 = Xmbtowc(tls, bp, str_byte, uint32(MB_LEN_MAX)) pos_add_next = v3 @@ -133564,7 +133564,7 @@ retry: } str_byte = str_byte + uintptr(pos_add_next) pos_start = pos - next_c_start = Int32FromUint32(*(*Ttre_char_t)(unsafe.Pointer(bp))) + next_c_start = Int32FromUint32(**(**Ttre_char_t)(__ccgo_up(bp))) str_byte_start = str_byte /* Handle initial states. */ next_tags = UintptrFromInt32(0) @@ -133573,7 +133573,7 @@ retry: if !((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate != 0) { break } - if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != uint32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != uint32('\000') || reg_noteol != 0) && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != uint32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0 || !(*(*Ttre_char_t)(unsafe.Pointer(bp)) == uint32('_') || Xiswalnum(tls, *(*Ttre_char_t)(unsafe.Pointer(bp))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0) || (*(*Ttre_char_t)(unsafe.Pointer(bp)) == uint32('_') || Xiswalnum(tls, *(*Ttre_char_t)(unsafe.Pointer(bp))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && *(*Ttre_char_t)(unsafe.Pointer(bp)) != uint32('\000') && BoolInt32(prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0) == BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == uint32('_') || Xiswalnum(tls, *(*Ttre_char_t)(unsafe.Pointer(bp))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || *(*Ttre_char_t)(unsafe.Pointer(bp)) == uint32('\000') || BoolInt32(prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0) != BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == uint32('_') || Xiswalnum(tls, *(*Ttre_char_t)(unsafe.Pointer(bp))) != 0))) { + if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != uint32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (**(**Ttre_char_t)(__ccgo_up(bp)) != uint32('\000') || reg_noteol != 0) && (**(**Ttre_char_t)(__ccgo_up(bp)) != uint32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0 || !(**(**Ttre_char_t)(__ccgo_up(bp)) == uint32('_') || Xiswalnum(tls, **(**Ttre_char_t)(__ccgo_up(bp))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0) || (**(**Ttre_char_t)(__ccgo_up(bp)) == uint32('_') || Xiswalnum(tls, **(**Ttre_char_t)(__ccgo_up(bp))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && **(**Ttre_char_t)(__ccgo_up(bp)) != uint32('\000') && BoolInt32(prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0) == BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == uint32('_') || Xiswalnum(tls, **(**Ttre_char_t)(__ccgo_up(bp))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || **(**Ttre_char_t)(__ccgo_up(bp)) == uint32('\000') || BoolInt32(prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0) != BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == uint32('_') || Xiswalnum(tls, **(**Ttre_char_t)(__ccgo_up(bp))) != 0))) { goto _4 } if state == UintptrFromInt32(0) { @@ -133622,13 +133622,13 @@ retry: (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstr_byte = str_byte (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate_id = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id - (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fnext_c = Int32FromUint32(*(*Ttre_char_t)(unsafe.Pointer(bp))) + (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fnext_c = Int32FromUint32(**(**Ttre_char_t)(__ccgo_up(bp))) i1 = 0 for { if !(i1 < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_tags) { break } - *(*Tregoff_t)(unsafe.Pointer((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(i1)*4)) = *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(i1)*4)) + **(**Tregoff_t)(__ccgo_up((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(i1)*4)) = **(**Tregoff_t)(__ccgo_up(tags + uintptr(i1)*4)) goto _5 _5: ; @@ -133636,10 +133636,10 @@ retry: } tmp = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags if tmp != 0 { - for *(*int32)(unsafe.Pointer(tmp)) >= 0 { + for **(**int32)(__ccgo_up(tmp)) >= 0 { v6 = tmp tmp += 4 - *(*Tregoff_t)(unsafe.Pointer((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(*(*int32)(unsafe.Pointer(v6)))*4)) = pos + **(**Tregoff_t)(__ccgo_up((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(**(**int32)(__ccgo_up(v6)))*4)) = pos } } } @@ -133650,10 +133650,10 @@ retry: } if next_tags != 0 { for { - if !(*(*int32)(unsafe.Pointer(next_tags)) >= 0) { + if !(**(**int32)(__ccgo_up(next_tags)) >= 0) { break } - *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(*(*int32)(unsafe.Pointer(next_tags)))*4)) = pos + **(**Tregoff_t)(__ccgo_up(tags + uintptr(**(**int32)(__ccgo_up(next_tags)))*4)) = pos goto _7 _7: ; @@ -133678,7 +133678,7 @@ _9: if !(i2 < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(i2)*4)) = *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(i2)*4)) + **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(i2)*4)) = **(**Tregoff_t)(__ccgo_up(tags + uintptr(i2)*4)) goto _10 _10: ; @@ -133698,8 +133698,8 @@ _9: /* Get the substring we need to match against. Remember to turn off REG_NOSUB temporarily. */ _tre_fill_pmatch(tls, Uint32FromInt32(bt+int32(1)), pmatch, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags & ^Int32FromInt32(REG_NOSUB), tnfa, tags, pos) - so = (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(bt)*8))).Frm_so - eo = (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(bt)*8))).Frm_eo + so = (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(bt)*8))).Frm_so + eo = (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(bt)*8))).Frm_eo bt_len = eo - so result = Xstrncmp(tls, string1+uintptr(so), str_byte-uintptr(1), Uint32FromInt32(bt_len)) if result == 0 { @@ -133707,15 +133707,15 @@ _9: if bt_len == 0 { empty_br_match = int32(1) } - if empty_br_match != 0 && *(*int32)(unsafe.Pointer(states_seen + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*4)) != 0 { + if empty_br_match != 0 && **(**int32)(__ccgo_up(states_seen + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*4)) != 0 { goto backtrack } - *(*int32)(unsafe.Pointer(states_seen + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*4)) = empty_br_match + **(**int32)(__ccgo_up(states_seen + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*4)) = empty_br_match /* Advance in input string and resync `prev_c', `next_c' and pos. */ str_byte = str_byte + uintptr(bt_len-int32(1)) pos = pos + (bt_len - int32(1)) - prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + prev_c = **(**Ttre_char_t)(__ccgo_up(bp)) pos = pos + pos_add_next v3 = Xmbtowc(tls, bp, str_byte, uint32(MB_LEN_MAX)) pos_add_next = v3 @@ -133733,11 +133733,11 @@ _9: } } else { /* Check for end of string. */ - if *(*Ttre_char_t)(unsafe.Pointer(bp)) == uint32('\000') { + if **(**Ttre_char_t)(__ccgo_up(bp)) == uint32('\000') { goto backtrack } /* Read the next character. */ - prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + prev_c = **(**Ttre_char_t)(__ccgo_up(bp)) pos = pos + pos_add_next v3 = Xmbtowc(tls, bp, str_byte, uint32(MB_LEN_MAX)) pos_add_next = v3 @@ -133758,7 +133758,7 @@ _9: break } if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fcode_min <= prev_c && (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fcode_max >= prev_c { - if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != uint32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != uint32('\000') || reg_noteol != 0) && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != uint32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0 || !(*(*Ttre_char_t)(unsafe.Pointer(bp)) == uint32('_') || Xiswalnum(tls, *(*Ttre_char_t)(unsafe.Pointer(bp))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0) || (*(*Ttre_char_t)(unsafe.Pointer(bp)) == uint32('_') || Xiswalnum(tls, *(*Ttre_char_t)(unsafe.Pointer(bp))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && *(*Ttre_char_t)(unsafe.Pointer(bp)) != uint32('\000') && BoolInt32(prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0) == BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == uint32('_') || Xiswalnum(tls, *(*Ttre_char_t)(unsafe.Pointer(bp))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || *(*Ttre_char_t)(unsafe.Pointer(bp)) == uint32('\000') || BoolInt32(prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0) != BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == uint32('_') || Xiswalnum(tls, *(*Ttre_char_t)(unsafe.Pointer(bp))) != 0)) || ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && !((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&Int32FromInt32(REG_ICASE) != 0) && !(Xiswctype(tls, prev_c, *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 24))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE) != 0 && !(Xiswctype(tls, Xtowlower(tls, prev_c), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 24))) != 0) && !(Xiswctype(tls, Xtowupper(tls, prev_c), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 24))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS_NEG) != 0 && _tre_neg_char_classes_match(tls, (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fneg_classes, prev_c, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE)) != 0)) { + if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != uint32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (**(**Ttre_char_t)(__ccgo_up(bp)) != uint32('\000') || reg_noteol != 0) && (**(**Ttre_char_t)(__ccgo_up(bp)) != uint32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0 || !(**(**Ttre_char_t)(__ccgo_up(bp)) == uint32('_') || Xiswalnum(tls, **(**Ttre_char_t)(__ccgo_up(bp))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0) || (**(**Ttre_char_t)(__ccgo_up(bp)) == uint32('_') || Xiswalnum(tls, **(**Ttre_char_t)(__ccgo_up(bp))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && **(**Ttre_char_t)(__ccgo_up(bp)) != uint32('\000') && BoolInt32(prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0) == BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == uint32('_') || Xiswalnum(tls, **(**Ttre_char_t)(__ccgo_up(bp))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || **(**Ttre_char_t)(__ccgo_up(bp)) == uint32('\000') || BoolInt32(prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0) != BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == uint32('_') || Xiswalnum(tls, **(**Ttre_char_t)(__ccgo_up(bp))) != 0)) || ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && !((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&Int32FromInt32(REG_ICASE) != 0) && !(Xiswctype(tls, prev_c, *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 24))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE) != 0 && !(Xiswctype(tls, Xtowlower(tls, prev_c), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 24))) != 0) && !(Xiswctype(tls, Xtowupper(tls, prev_c), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 24))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS_NEG) != 0 && _tre_neg_char_classes_match(tls, (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fneg_classes, prev_c, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE)) != 0)) { goto _13 } if next_state == UintptrFromInt32(0) { @@ -133810,13 +133810,13 @@ _9: (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstr_byte = str_byte (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate_id = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id - (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fnext_c = Int32FromUint32(*(*Ttre_char_t)(unsafe.Pointer(bp))) + (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fnext_c = Int32FromUint32(**(**Ttre_char_t)(__ccgo_up(bp))) i3 = 0 for { if !(i3 < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_tags) { break } - *(*Tregoff_t)(unsafe.Pointer((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(i3)*4)) = *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(i3)*4)) + **(**Tregoff_t)(__ccgo_up((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(i3)*4)) = **(**Tregoff_t)(__ccgo_up(tags + uintptr(i3)*4)) goto _14 _14: ; @@ -133824,10 +133824,10 @@ _9: } tmp1 = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags for { - if !(tmp1 != 0 && *(*int32)(unsafe.Pointer(tmp1)) >= 0) { + if !(tmp1 != 0 && **(**int32)(__ccgo_up(tmp1)) >= 0) { break } - *(*Tregoff_t)(unsafe.Pointer((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(*(*int32)(unsafe.Pointer(tmp1)))*4)) = pos + **(**Tregoff_t)(__ccgo_up((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(**(**int32)(__ccgo_up(tmp1)))*4)) = pos goto _15 _15: ; @@ -133847,10 +133847,10 @@ _9: state = next_state /* Update the tag values. */ if next_tags != 0 { - for *(*int32)(unsafe.Pointer(next_tags)) >= 0 { + for **(**int32)(__ccgo_up(next_tags)) >= 0 { v6 = next_tags next_tags += 4 - *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(*(*int32)(unsafe.Pointer(v6)))*4)) = pos + **(**Tregoff_t)(__ccgo_up(tags + uintptr(**(**int32)(__ccgo_up(v6)))*4)) = pos } } goto _17 @@ -133862,18 +133862,18 @@ backtrack: /* A matching transition was not found. Try to backtrack. */ if (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fprev != 0 { if (*Ttre_tnfa_transition_t)(unsafe.Pointer((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate)).Fassertions&int32(ASSERT_BACKREF) != 0 { - *(*int32)(unsafe.Pointer(states_seen + uintptr((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate_id)*4)) = 0 + **(**int32)(__ccgo_up(states_seen + uintptr((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate_id)*4)) = 0 } pos = (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fpos str_byte = (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstr_byte state = (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate - *(*Ttre_char_t)(unsafe.Pointer(bp)) = Uint32FromInt32((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fnext_c) + **(**Ttre_char_t)(__ccgo_up(bp)) = Uint32FromInt32((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fnext_c) i4 = 0 for { if !(i4 < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(i4)*4)) = *(*Tregoff_t)(unsafe.Pointer((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(i4)*4)) + **(**Tregoff_t)(__ccgo_up(tags + uintptr(i4)*4)) = **(**Tregoff_t)(__ccgo_up((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(i4)*4)) goto _19 _19: ; @@ -133884,10 +133884,10 @@ backtrack: if match_eo < 0 { /* Try starting from a later position in the input string. */ /* Check for end of string. */ - if *(*Ttre_char_t)(unsafe.Pointer(bp)) == uint32('\000') { + if **(**Ttre_char_t)(__ccgo_up(bp)) == uint32('\000') { goto _8 } - *(*Ttre_char_t)(unsafe.Pointer(bp)) = Uint32FromInt32(next_c_start) + **(**Ttre_char_t)(__ccgo_up(bp)) = Uint32FromInt32(next_c_start) str_byte = str_byte_start goto retry } else { @@ -133905,7 +133905,7 @@ _8: v20 = int32(REG_NOMATCH) } ret = v20 - *(*Tregoff_t)(unsafe.Pointer(match_end_ofs)) = match_eo + **(**Tregoff_t)(__ccgo_up(match_end_ofs)) = match_eo goto error_exit error_exit: ; @@ -133940,22 +133940,22 @@ func _tre_fill_pmatch(tls *TLS, nmatch Tsize_t, pmatch uintptr, cflags int32, tn /* Construct submatch offsets from the tags. */ submatch_data = (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data for i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches && i < nmatch { - if (*(*Ttre_submatch_data_t)(unsafe.Pointer(submatch_data + uintptr(i)*12))).Fso_tag == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fend_tag { - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_so = match_eo + if (**(**Ttre_submatch_data_t)(__ccgo_up(submatch_data + uintptr(i)*12))).Fso_tag == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fend_tag { + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*8))).Frm_so = match_eo } else { - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_so = *(*Tregoff_t)(unsafe.Pointer(tags + uintptr((*(*Ttre_submatch_data_t)(unsafe.Pointer(submatch_data + uintptr(i)*12))).Fso_tag)*4)) + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*8))).Frm_so = **(**Tregoff_t)(__ccgo_up(tags + uintptr((**(**Ttre_submatch_data_t)(__ccgo_up(submatch_data + uintptr(i)*12))).Fso_tag)*4)) } - if (*(*Ttre_submatch_data_t)(unsafe.Pointer(submatch_data + uintptr(i)*12))).Feo_tag == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fend_tag { - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_eo = match_eo + if (**(**Ttre_submatch_data_t)(__ccgo_up(submatch_data + uintptr(i)*12))).Feo_tag == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fend_tag { + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*8))).Frm_eo = match_eo } else { - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_eo = *(*Tregoff_t)(unsafe.Pointer(tags + uintptr((*(*Ttre_submatch_data_t)(unsafe.Pointer(submatch_data + uintptr(i)*12))).Feo_tag)*4)) + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*8))).Frm_eo = **(**Tregoff_t)(__ccgo_up(tags + uintptr((**(**Ttre_submatch_data_t)(__ccgo_up(submatch_data + uintptr(i)*12))).Feo_tag)*4)) } /* If either of the endpoints were not used, this submatch was not part of the match. */ - if (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_so == -int32(1) || (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_eo == -int32(1) { + if (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*8))).Frm_so == -int32(1) || (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*8))).Frm_eo == -int32(1) { v1 = -Int32FromInt32(1) - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_eo = v1 - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_so = v1 + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*8))).Frm_eo = v1 + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*8))).Frm_so = v1 } i = i + 1 } @@ -133963,19 +133963,19 @@ func _tre_fill_pmatch(tls *TLS, nmatch Tsize_t, pmatch uintptr, cflags int32, tn submatches. */ i = uint32(0) for i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches && i < nmatch { - if (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_eo == -int32(1) { + if (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*8))).Frm_eo == -int32(1) { } - parents = (*(*Ttre_submatch_data_t)(unsafe.Pointer(submatch_data + uintptr(i)*12))).Fparents + parents = (**(**Ttre_submatch_data_t)(__ccgo_up(submatch_data + uintptr(i)*12))).Fparents if parents != UintptrFromInt32(0) { j = uint32(0) for { - if !(*(*int32)(unsafe.Pointer(parents + uintptr(j)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(parents + uintptr(j)*4)) >= 0) { break } - if (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_so < (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(*(*int32)(unsafe.Pointer(parents + uintptr(j)*4)))*8))).Frm_so || (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_eo > (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(*(*int32)(unsafe.Pointer(parents + uintptr(j)*4)))*8))).Frm_eo { + if (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*8))).Frm_so < (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(**(**int32)(__ccgo_up(parents + uintptr(j)*4)))*8))).Frm_so || (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*8))).Frm_eo > (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(**(**int32)(__ccgo_up(parents + uintptr(j)*4)))*8))).Frm_eo { v1 = -Int32FromInt32(1) - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_eo = v1 - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_so = v1 + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*8))).Frm_eo = v1 + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*8))).Frm_so = v1 } goto _2 _2: @@ -133987,8 +133987,8 @@ func _tre_fill_pmatch(tls *TLS, nmatch Tsize_t, pmatch uintptr, cflags int32, tn } } for i < nmatch { - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_so = -int32(1) - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_eo = -int32(1) + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*8))).Frm_so = -int32(1) + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*8))).Frm_eo = -int32(1) i = i + 1 } } @@ -134029,7 +134029,7 @@ func Xregexec(tls *TLS, preg uintptr, string1 uintptr, nmatch Tsize_t, pmatch ui } if status == REG_OK { /* A match was found, so fill the submatch registers. */ - _tre_fill_pmatch(tls, nmatch, pmatch, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags, tnfa, tags, *(*Tregoff_t)(unsafe.Pointer(bp))) + _tre_fill_pmatch(tls, nmatch, pmatch, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags, tnfa, tags, **(**Tregoff_t)(__ccgo_up(bp))) } if tags != 0 { Xfree(tls, tags) @@ -134147,8 +134147,8 @@ func X__tre_mem_alloc_impl(tls *TLS, mem Ttre_mem_t, provided int32, provided_bl size = size + v1 /* Allocate from current block. */ ptr = (*Ttre_mem_struct)(unsafe.Pointer(mem)).Fptr - *(*uintptr)(unsafe.Pointer(mem + 8)) += uintptr(size) - *(*Tsize_t)(unsafe.Pointer(mem + 12)) -= size + **(**uintptr)(__ccgo_up(mem + 8)) += uintptr(size) + **(**Tsize_t)(__ccgo_up(mem + 12)) -= size /* Set to zero if needed. */ if zero != 0 { Xmemset(tls, ptr, 0, size) @@ -134213,10 +134213,10 @@ func _keyhash(tls *TLS, k uintptr) (r Tsize_t) { _, _, _ = h, p, v1 p = k h = uint32(0) - for *(*uint8)(unsafe.Pointer(p)) != 0 { + for **(**uint8)(__ccgo_up(p)) != 0 { v1 = p p = p + 1 - h = uint32(31)*h + uint32(*(*uint8)(unsafe.Pointer(v1))) + h = uint32(31)*h + uint32(**(**uint8)(__ccgo_up(v1))) } return h } @@ -134269,7 +134269,7 @@ func _resize(tls *TLS, nel Tsize_t, htab uintptr) (r int32) { j = j + 1 i = i + v4 } - *(*TENTRY)(unsafe.Pointer(newe)) = *(*TENTRY)(unsafe.Pointer(e)) + **(**TENTRY)(__ccgo_up(newe)) = **(**TENTRY)(__ccgo_up(e)) } goto _2 _2: @@ -134325,7 +134325,7 @@ func Xhsearch(tls *TLS, item TENTRY, action TACTION) (r uintptr) { defer tls.Free(16) var _ /* e at bp+0 */ uintptr ___hsearch_r(tls, item, action, bp, uintptr(unsafe.Pointer(&_htab))) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func ___hcreate_r(tls *TLS, nel Tsize_t, htab uintptr) (r1 int32) { @@ -134358,14 +134358,14 @@ func ___hsearch_r(tls *TLS, item TENTRY, action TACTION, retval uintptr, htab ui hash = _keyhash(tls, item.Fkey) e = _lookup(tls, item.Fkey, hash, htab) if (*TENTRY)(unsafe.Pointer(e)).Fkey != 0 { - *(*uintptr)(unsafe.Pointer(retval)) = e + **(**uintptr)(__ccgo_up(retval)) = e return int32(1) } if action == int32(_FIND) { - *(*uintptr)(unsafe.Pointer(retval)) = uintptr(0) + **(**uintptr)(__ccgo_up(retval)) = uintptr(0) return 0 } - *(*TENTRY)(unsafe.Pointer(e)) = item + **(**TENTRY)(__ccgo_up(e)) = item v2 = (*Thsearch_data)(unsafe.Pointer(htab)).F__tab + 8 *(*Tsize_t)(unsafe.Pointer(v2)) = *(*Tsize_t)(unsafe.Pointer(v2)) + 1 v1 = *(*Tsize_t)(unsafe.Pointer(v2)) @@ -134373,12 +134373,12 @@ func ___hsearch_r(tls *TLS, item TENTRY, action TACTION, retval uintptr, htab ui if !(_resize(tls, uint32(2)*(*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused, htab) != 0) { (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused = (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused - 1 (*TENTRY)(unsafe.Pointer(e)).Fkey = uintptr(0) - *(*uintptr)(unsafe.Pointer(retval)) = uintptr(0) + **(**uintptr)(__ccgo_up(retval)) = uintptr(0) return 0 } e = _lookup(tls, item.Fkey, hash, htab) } - *(*uintptr)(unsafe.Pointer(retval)) = e + **(**uintptr)(__ccgo_up(retval)) = e return int32(1) } @@ -134438,7 +134438,7 @@ func Xlsearch(tls *TLS, key uintptr, base uintptr, nelp uintptr, width Tsize_t, defer func() {}() v1 = width p = base - n = *(*Tsize_t)(unsafe.Pointer(nelp)) + n = **(**Tsize_t)(__ccgo_up(nelp)) i = uint32(0) for { if !(i < n) { @@ -134452,7 +134452,7 @@ func Xlsearch(tls *TLS, key uintptr, base uintptr, nelp uintptr, width Tsize_t, ; i = i + 1 } - *(*Tsize_t)(unsafe.Pointer(nelp)) = n + uint32(1) + **(**Tsize_t)(__ccgo_up(nelp)) = n + uint32(1) return _memcpy(tls, p+uintptr(n)*uintptr(v1), key, width) } @@ -134470,7 +134470,7 @@ func Xlfind(tls *TLS, key uintptr, base uintptr, nelp uintptr, width Tsize_t, __ defer func() {}() v1 = width p = base - n = *(*Tsize_t)(unsafe.Pointer(nelp)) + n = **(**Tsize_t)(__ccgo_up(nelp)) i = uint32(0) for { if !(i < n) { @@ -134509,7 +134509,7 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui if !(rootp != 0) { return uintptr(0) } - n = *(*uintptr)(unsafe.Pointer(rootp)) + n = **(**uintptr)(__ccgo_up(rootp)) i = 0 /* *a[0] is an arbitrary non-null pointer that is returned when the root node is deleted. */ @@ -134530,34 +134530,34 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui v1 = i i = i + 1 a[v1] = n + 4 + BoolUintptr(c > 0)*4 - n = *(*uintptr)(unsafe.Pointer(n + 4 + BoolUintptr(c > 0)*4)) + n = **(**uintptr)(__ccgo_up(n + 4 + BoolUintptr(c > 0)*4)) goto _3 _3: } - parent = *(*uintptr)(unsafe.Pointer(a[i-int32(2)])) - if *(*uintptr)(unsafe.Pointer(n + 4)) != 0 { + parent = **(**uintptr)(__ccgo_up(a[i-int32(2)])) + if **(**uintptr)(__ccgo_up(n + 4)) != 0 { /* free the preceding node instead of the deleted one. */ deleted = n v1 = i i = i + 1 a[v1] = n + 4 - n = *(*uintptr)(unsafe.Pointer(n + 4)) - for *(*uintptr)(unsafe.Pointer(n + 4 + 1*4)) != 0 { + n = **(**uintptr)(__ccgo_up(n + 4)) + for **(**uintptr)(__ccgo_up(n + 4 + 1*4)) != 0 { v1 = i i = i + 1 a[v1] = n + 4 + 1*4 - n = *(*uintptr)(unsafe.Pointer(n + 4 + 1*4)) + n = **(**uintptr)(__ccgo_up(n + 4 + 1*4)) } (*Tnode1)(unsafe.Pointer(deleted)).Fkey = (*Tnode1)(unsafe.Pointer(n)).Fkey - child = *(*uintptr)(unsafe.Pointer(n + 4)) + child = **(**uintptr)(__ccgo_up(n + 4)) } else { - child = *(*uintptr)(unsafe.Pointer(n + 4 + 1*4)) + child = **(**uintptr)(__ccgo_up(n + 4 + 1*4)) } /* freed node has at most one child, move it up and rebalance. */ Xfree(tls, n) i = i - 1 v1 = i - *(*uintptr)(unsafe.Pointer(a[v1])) = child + **(**uintptr)(__ccgo_up(a[v1])) = child for { i = i - 1 v1 = i @@ -134580,8 +134580,8 @@ func Xtdestroy(tls *TLS, root uintptr, __ccgo_fp_freekey uintptr) { if r == uintptr(0) { return } - Xtdestroy(tls, *(*uintptr)(unsafe.Pointer(r + 4)), __ccgo_fp_freekey) - Xtdestroy(tls, *(*uintptr)(unsafe.Pointer(r + 4 + 1*4)), __ccgo_fp_freekey) + Xtdestroy(tls, **(**uintptr)(__ccgo_up(r + 4)), __ccgo_fp_freekey) + Xtdestroy(tls, **(**uintptr)(__ccgo_up(r + 4 + 1*4)), __ccgo_fp_freekey) if __ccgo_fp_freekey != 0 { (*(*func(*TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_freekey})))(tls, (*Tnode1)(unsafe.Pointer(r)).Fkey) } @@ -134601,7 +134601,7 @@ func Xtfind(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r uint if !(rootp != 0) { return uintptr(0) } - n = *(*uintptr)(unsafe.Pointer(rootp)) + n = **(**uintptr)(__ccgo_up(rootp)) for { if !(n != 0) { break @@ -134610,7 +134610,7 @@ func Xtfind(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r uint if !(c != 0) { break } - n = *(*uintptr)(unsafe.Pointer(n + 4 + BoolUintptr(c > 0)*4)) + n = **(**uintptr)(__ccgo_up(n + 4 + BoolUintptr(c > 0)*4)) goto _1 _1: } @@ -134632,11 +134632,11 @@ func _rot(tls *TLS, p uintptr, x uintptr, dir int32) (r int32) { var hx, hz int32 var y, z uintptr _, _, _, _ = hx, hz, y, z - y = *(*uintptr)(unsafe.Pointer(x + 4 + uintptr(dir)*4)) - z = *(*uintptr)(unsafe.Pointer(y + 4 + BoolUintptr(!(dir != 0))*4)) + y = **(**uintptr)(__ccgo_up(x + 4 + uintptr(dir)*4)) + z = **(**uintptr)(__ccgo_up(y + 4 + BoolUintptr(!(dir != 0))*4)) hx = (*Tnode1)(unsafe.Pointer(x)).Fh hz = _height(tls, z) - if hz > _height(tls, *(*uintptr)(unsafe.Pointer(y + 4 + uintptr(dir)*4))) { + if hz > _height(tls, **(**uintptr)(__ccgo_up(y + 4 + uintptr(dir)*4))) { /* * x * / \ dir z @@ -134644,10 +134644,10 @@ func _rot(tls *TLS, p uintptr, x uintptr, dir int32) (r int32) { * z D /| | * / \ A B C D * B C */ - *(*uintptr)(unsafe.Pointer(x + 4 + uintptr(dir)*4)) = *(*uintptr)(unsafe.Pointer(z + 4 + BoolUintptr(!(dir != 0))*4)) - *(*uintptr)(unsafe.Pointer(y + 4 + BoolUintptr(!(dir != 0))*4)) = *(*uintptr)(unsafe.Pointer(z + 4 + uintptr(dir)*4)) - *(*uintptr)(unsafe.Pointer(z + 4 + BoolUintptr(!(dir != 0))*4)) = x - *(*uintptr)(unsafe.Pointer(z + 4 + uintptr(dir)*4)) = y + **(**uintptr)(__ccgo_up(x + 4 + uintptr(dir)*4)) = **(**uintptr)(__ccgo_up(z + 4 + BoolUintptr(!(dir != 0))*4)) + **(**uintptr)(__ccgo_up(y + 4 + BoolUintptr(!(dir != 0))*4)) = **(**uintptr)(__ccgo_up(z + 4 + uintptr(dir)*4)) + **(**uintptr)(__ccgo_up(z + 4 + BoolUintptr(!(dir != 0))*4)) = x + **(**uintptr)(__ccgo_up(z + 4 + uintptr(dir)*4)) = y (*Tnode1)(unsafe.Pointer(x)).Fh = hz (*Tnode1)(unsafe.Pointer(y)).Fh = hz (*Tnode1)(unsafe.Pointer(z)).Fh = hz + int32(1) @@ -134657,13 +134657,13 @@ func _rot(tls *TLS, p uintptr, x uintptr, dir int32) (r int32) { * / \ / * A y --> x D * / \ / * z D A z */ - *(*uintptr)(unsafe.Pointer(x + 4 + uintptr(dir)*4)) = z - *(*uintptr)(unsafe.Pointer(y + 4 + BoolUintptr(!(dir != 0))*4)) = x + **(**uintptr)(__ccgo_up(x + 4 + uintptr(dir)*4)) = z + **(**uintptr)(__ccgo_up(y + 4 + BoolUintptr(!(dir != 0))*4)) = x (*Tnode1)(unsafe.Pointer(x)).Fh = hz + int32(1) (*Tnode1)(unsafe.Pointer(y)).Fh = hz + int32(2) z = y } - *(*uintptr)(unsafe.Pointer(p)) = z + **(**uintptr)(__ccgo_up(p)) = z return (*Tnode1)(unsafe.Pointer(z)).Fh - hx } @@ -134678,9 +134678,9 @@ func X__tsearch_balance(tls *TLS, p uintptr) (r int32) { var h0, h1, old, v1 int32 var n uintptr _, _, _, _, _ = h0, h1, n, old, v1 - n = *(*uintptr)(unsafe.Pointer(p)) - h0 = _height(tls, *(*uintptr)(unsafe.Pointer(n + 4))) - h1 = _height(tls, *(*uintptr)(unsafe.Pointer(n + 4 + 1*4))) + n = **(**uintptr)(__ccgo_up(p)) + h0 = _height(tls, **(**uintptr)(__ccgo_up(n + 4))) + h1 = _height(tls, **(**uintptr)(__ccgo_up(n + 4 + 1*4))) if Uint32FromInt32(h0-h1)+uint32(1) < uint32(3) { old = (*Tnode1)(unsafe.Pointer(n)).Fh if h0 < h1 { @@ -134709,7 +134709,7 @@ func Xtsearch(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r1 u if !(rootp != 0) { return uintptr(0) } - n = *(*uintptr)(unsafe.Pointer(rootp)) + n = **(**uintptr)(__ccgo_up(rootp)) i = 0 v1 = i i = i + 1 @@ -134725,7 +134725,7 @@ func Xtsearch(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r1 u v1 = i i = i + 1 a[v1] = n + 4 + BoolUintptr(c > 0)*4 - n = *(*uintptr)(unsafe.Pointer(n + 4 + BoolUintptr(c > 0)*4)) + n = **(**uintptr)(__ccgo_up(n + 4 + BoolUintptr(c > 0)*4)) goto _2 _2: } @@ -134735,13 +134735,13 @@ func Xtsearch(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r1 u } (*Tnode1)(unsafe.Pointer(r)).Fkey = key v4 = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(r + 4 + 1*4)) = v4 - *(*uintptr)(unsafe.Pointer(r + 4)) = v4 + **(**uintptr)(__ccgo_up(r + 4 + 1*4)) = v4 + **(**uintptr)(__ccgo_up(r + 4)) = v4 (*Tnode1)(unsafe.Pointer(r)).Fh = int32(1) /* insert new node, rebalance ancestors. */ i = i - 1 v1 = i - *(*uintptr)(unsafe.Pointer(a[v1])) = r + **(**uintptr)(__ccgo_up(a[v1])) = r for { if v7 = i != 0; v7 { i = i - 1 @@ -134762,9 +134762,9 @@ func _walk(tls *TLS, r uintptr, __ccgo_fp_action uintptr, d int32) { (*(*func(*TLS, uintptr, TVISIT, int32))(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_action})))(tls, r, int32(_leaf), d) } else { (*(*func(*TLS, uintptr, TVISIT, int32))(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_action})))(tls, r, int32(_preorder), d) - _walk(tls, *(*uintptr)(unsafe.Pointer(r + 4)), __ccgo_fp_action, d+int32(1)) + _walk(tls, **(**uintptr)(__ccgo_up(r + 4)), __ccgo_fp_action, d+int32(1)) (*(*func(*TLS, uintptr, TVISIT, int32))(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_action})))(tls, r, int32(_postorder), d) - _walk(tls, *(*uintptr)(unsafe.Pointer(r + 4 + 1*4)), __ccgo_fp_action, d+int32(1)) + _walk(tls, **(**uintptr)(__ccgo_up(r + 4 + 1*4)), __ccgo_fp_action, d+int32(1)) (*(*func(*TLS, uintptr, TVISIT, int32))(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_action})))(tls, r, int32(_endorder), d) } } @@ -134859,7 +134859,7 @@ func Xpselect(tls *TLS, n int32, rfds uintptr, wfds uintptr, efds uintptr, ts ui var v4 uint64 var _ /* data at bp+24 */ [2]Tsyscall_arg_t _, _, _, _, _, _, _ = ns, r, s, v1, v2, v3, v4 - *(*[2]Tsyscall_arg_t)(unsafe.Pointer(bp + 24)) = [2]Tsyscall_arg_t{ + **(**[2]Tsyscall_arg_t)(__ccgo_up(bp + 24)) = [2]Tsyscall_arg_t{ 0: Int32FromUint32(uint32(mask)), 1: int32(Int32FromInt32(_NSIG) / Int32FromInt32(8)), } @@ -135029,10 +135029,10 @@ func Xgetitimer(tls *TLS, which int32, old uintptr) (r1 int32) { if uint32(8) > uint32(4) { r = int32(X__syscall2(tls, int32(SYS_getitimer), which, int32(bp))) if !(r != 0) { - (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_sec = int64((*(*[4]int32)(unsafe.Pointer(bp)))[0]) - (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_usec = int64((*(*[4]int32)(unsafe.Pointer(bp)))[int32(1)]) - (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_sec = int64((*(*[4]int32)(unsafe.Pointer(bp)))[int32(2)]) - (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_usec = int64((*(*[4]int32)(unsafe.Pointer(bp)))[int32(3)]) + (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_sec = int64((**(**[4]int32)(__ccgo_up(bp)))[0]) + (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_usec = int64((**(**[4]int32)(__ccgo_up(bp)))[int32(1)]) + (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_sec = int64((**(**[4]int32)(__ccgo_up(bp)))[int32(2)]) + (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_usec = int64((**(**[4]int32)(__ccgo_up(bp)))[int32(3)]) } return X__syscall_ret(tls, Uint32FromInt32(r)) } @@ -135053,7 +135053,7 @@ func Xkillpg(tls *TLS, pgid Tpid_t, sig int32) (r int32) { defer func() { trc("-> %v", r) }() } if pgid < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } return Xkill(tls, -pgid, sig) @@ -135089,7 +135089,7 @@ func Xpsignal(tls *TLS, sig int32, msg uintptr) { * not permitted to do so. */ old_locale = (*TFILE)(unsafe.Pointer(f)).Flocale old_mode = (*TFILE)(unsafe.Pointer(f)).Fmode - old_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + old_errno = **(**int32)(__ccgo_up(X__errno_location(tls))) if msg != 0 { v2 = msg } else { @@ -135101,7 +135101,7 @@ func Xpsignal(tls *TLS, sig int32, msg uintptr) { v3 = __ccgo_ts } if Xfprintf(tls, f, __ccgo_ts+987, VaList(bp+8, v2, v3, s)) >= 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = old_errno + **(**int32)(__ccgo_up(X__errno_location(tls))) = old_errno } (*TFILE)(unsafe.Pointer(f)).Fmode = old_mode (*TFILE)(unsafe.Pointer(f)).Flocale = old_locale @@ -135167,10 +135167,10 @@ func Xsetitimer(tls *TLS, which int32, new1 uintptr, old uintptr) (r1 int32) { } r = int32(X__syscall3(tls, int32(SYS_setitimer), which, int32(bp), int32(bp+16))) if !(r != 0) && old != 0 { - (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_sec = int64((*(*[4]int32)(unsafe.Pointer(bp + 16)))[0]) - (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_usec = int64((*(*[4]int32)(unsafe.Pointer(bp + 16)))[int32(1)]) - (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_sec = int64((*(*[4]int32)(unsafe.Pointer(bp + 16)))[int32(2)]) - (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_usec = int64((*(*[4]int32)(unsafe.Pointer(bp + 16)))[int32(3)]) + (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_sec = int64((**(**[4]int32)(__ccgo_up(bp + 16)))[0]) + (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_usec = int64((**(**[4]int32)(__ccgo_up(bp + 16)))[int32(1)]) + (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_sec = int64((**(**[4]int32)(__ccgo_up(bp + 16)))[int32(2)]) + (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_usec = int64((**(**[4]int32)(__ccgo_up(bp + 16)))[int32(3)]) } return X__syscall_ret(tls, Uint32FromInt32(r)) } @@ -135237,10 +135237,10 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old1 uintptr) (r1 int32) Fv Tuint64_t }{} *(*uint64)(unsafe.Pointer(bp + 8)) = Uint64FromInt32(v2) - if *(*Tuint32_t)(unsafe.Pointer(bp + 8)) != 0 { + if **(**Tuint32_t)(__ccgo_up(bp + 8)) != 0 { v6 = v5 _a_barrier(tls) - for cond := true; cond; cond = !(_a_sc(tls, v6, old|Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(bp + 8)))) != 0) { + for cond := true; cond; cond = !(_a_sc(tls, v6, old|Int32FromUint32(**(**Tuint32_t)(__ccgo_up(bp + 8)))) != 0) { old = _a_ll(tls, v6) } _a_barrier(tls) @@ -135248,10 +135248,10 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old1 uintptr) (r1 int32) goto _7 _7: } - if *(*Tuint32_t)(unsafe.Pointer(bp + 8 + 1*4)) != 0 { + if **(**Tuint32_t)(__ccgo_up(bp + 8 + 1*4)) != 0 { v8 = v5 + uintptr(1)*4 _a_barrier(tls) - for cond := true; cond; cond = !(_a_sc(tls, v8, old|Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(bp + 8 + 1*4)))) != 0) { + for cond := true; cond; cond = !(_a_sc(tls, v8, old|Int32FromUint32(**(**Tuint32_t)(__ccgo_up(bp + 8 + 1*4)))) != 0) { old = _a_ll(tls, v8) } _a_barrier(tls) @@ -135281,15 +135281,15 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old1 uintptr) (r1 int32) _a_barrier(tls) } } - (*(*Tk_sigaction)(unsafe.Pointer(bp + 16))).Fhandler = *(*uintptr)(unsafe.Pointer(sa)) - (*(*Tk_sigaction)(unsafe.Pointer(bp + 16))).Fflags = Uint32FromInt32((*Tsigaction)(unsafe.Pointer(sa)).Fsa_flags) - (*(*Tk_sigaction)(unsafe.Pointer(bp + 16))).Fflags |= uint32(SA_RESTORER) + (**(**Tk_sigaction)(__ccgo_up(bp + 16))).Fhandler = *(*uintptr)(unsafe.Pointer(sa)) + (**(**Tk_sigaction)(__ccgo_up(bp + 16))).Fflags = Uint32FromInt32((*Tsigaction)(unsafe.Pointer(sa)).Fsa_flags) + (**(**Tk_sigaction)(__ccgo_up(bp + 16))).Fflags |= uint32(SA_RESTORER) if (*Tsigaction)(unsafe.Pointer(sa)).Fsa_flags&int32(SA_SIGINFO) != 0 { v1 = __ccgo_fp(X__restore_rt) } else { v1 = __ccgo_fp(X__restore) } - (*(*Tk_sigaction)(unsafe.Pointer(bp + 16))).Frestorer = v1 + (**(**Tk_sigaction)(__ccgo_up(bp + 16))).Frestorer = v1 _memcpy(tls, bp+16+12, sa+4, Uint32FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))) } if sa != 0 { @@ -135304,8 +135304,8 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old1 uintptr) (r1 int32) } r = int32(X__syscall4(tls, int32(SYS_rt_sigaction), sig, int32(v1), int32(v3), int32(Int32FromInt32(_NSIG)/Int32FromInt32(8)))) if old1 != 0 && !(r != 0) { - *(*uintptr)(unsafe.Pointer(old1)) = (*(*Tk_sigaction)(unsafe.Pointer(bp + 36))).Fhandler - (*Tsigaction)(unsafe.Pointer(old1)).Fsa_flags = Int32FromUint32((*(*Tk_sigaction)(unsafe.Pointer(bp + 36))).Fflags) + *(*uintptr)(unsafe.Pointer(old1)) = (**(**Tk_sigaction)(__ccgo_up(bp + 36))).Fhandler + (*Tsigaction)(unsafe.Pointer(old1)).Fsa_flags = Int32FromUint32((**(**Tk_sigaction)(__ccgo_up(bp + 36))).Fflags) _memcpy(tls, old1+4, bp+36+12, Uint32FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))) } return X__syscall_ret(tls, Uint32FromInt32(r)) @@ -135322,7 +135322,7 @@ func X__sigaction(tls *TLS, sig int32, sa uintptr, old uintptr) (r1 int32) { var _ /* set at bp+0 */ [2]uint32 _ = r if Uint32FromInt32(sig)-uint32(32) < uint32(3) || Uint32FromInt32(sig)-uint32(1) >= Uint32FromInt32(Int32FromInt32(_NSIG)-Int32FromInt32(1)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } /* Doing anything with the disposition of SIGABRT requires a lock, @@ -135357,10 +135357,10 @@ func Xsigaddset(tls *TLS, set uintptr, sig int32) (r int32) { _ = s s = Uint32FromInt32(sig - int32(1)) if s >= Uint32FromInt32(Int32FromInt32(_NSIG)-Int32FromInt32(1)) || Uint32FromInt32(sig)-uint32(32) < uint32(3) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } - *(*uint32)(unsafe.Pointer(set + uintptr(s/uint32(8)/uint32(4))*4)) |= uint32(1) << (s & (Uint32FromInt32(8)*Uint32FromInt64(4) - Uint32FromInt32(1))) + **(**uint32)(__ccgo_up(set + uintptr(s/uint32(8)/uint32(4))*4)) |= uint32(1) << (s & (Uint32FromInt32(8)*Uint32FromInt64(4) - Uint32FromInt32(1))) return 0 } @@ -135371,11 +135371,11 @@ func Xsigaltstack(tls *TLS, ss uintptr, old uintptr) (r int32) { } if ss != 0 { if !((*Tstack_t)(unsafe.Pointer(ss)).Fss_flags&Int32FromInt32(SS_DISABLE) != 0) && (*Tstack_t)(unsafe.Pointer(ss)).Fss_size < uint32(MINSIGSTKSZ) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return -int32(1) } if (*Tstack_t)(unsafe.Pointer(ss)).Fss_flags&int32(SS_ONSTACK) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } } @@ -135400,7 +135400,7 @@ func Xsigandset(tls *TLS, dest uintptr, left uintptr, right uintptr) (r1 int32) if !(i < uint32(Uint32FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))/Uint32FromInt64(4))) { break } - *(*uint32)(unsafe.Pointer(d + uintptr(i)*4)) = *(*uint32)(unsafe.Pointer(l + uintptr(i)*4)) & *(*uint32)(unsafe.Pointer(r + uintptr(i)*4)) + **(**uint32)(__ccgo_up(d + uintptr(i)*4)) = **(**uint32)(__ccgo_up(l + uintptr(i)*4)) & **(**uint32)(__ccgo_up(r + uintptr(i)*4)) goto _1 _1: ; @@ -135418,10 +135418,10 @@ func Xsigdelset(tls *TLS, set uintptr, sig int32) (r int32) { _ = s s = Uint32FromInt32(sig - int32(1)) if s >= Uint32FromInt32(Int32FromInt32(_NSIG)-Int32FromInt32(1)) || Uint32FromInt32(sig)-uint32(32) < uint32(3) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } - *(*uint32)(unsafe.Pointer(set + uintptr(s/uint32(8)/uint32(4))*4)) &= ^(Uint32FromUint32(1) << (s & (Uint32FromInt32(8)*Uint32FromInt64(4) - Uint32FromInt32(1)))) + **(**uint32)(__ccgo_up(set + uintptr(s/uint32(8)/uint32(4))*4)) &= ^(Uint32FromUint32(1) << (s & (Uint32FromInt32(8)*Uint32FromInt64(4) - Uint32FromInt32(1)))) return 0 } @@ -135430,13 +135430,13 @@ func Xsigemptyset(tls *TLS, set uintptr) (r int32) { trc("tls=%v set=%v, (%v:)", tls, set, origin(2)) defer func() { trc("-> %v", r) }() } - *(*uint32)(unsafe.Pointer(set)) = uint32(0) + **(**uint32)(__ccgo_up(set)) = uint32(0) if Bool(uint32(4) == uint32(4)) || Bool(int32(_NSIG) > int32(65)) { - *(*uint32)(unsafe.Pointer(set + 1*4)) = uint32(0) + **(**uint32)(__ccgo_up(set + 1*4)) = uint32(0) } if Bool(uint32(4) == uint32(4)) && Bool(int32(_NSIG) > int32(65)) { - *(*uint32)(unsafe.Pointer(set + 2*4)) = uint32(0) - *(*uint32)(unsafe.Pointer(set + 3*4)) = uint32(0) + **(**uint32)(__ccgo_up(set + 2*4)) = uint32(0) + **(**uint32)(__ccgo_up(set + 3*4)) = uint32(0) } return 0 } @@ -135455,11 +135455,11 @@ func Xsigfillset(tls *TLS, set uintptr) (r int32) { trc("tls=%v set=%v, (%v:)", tls, set, origin(2)) defer func() { trc("-> %v", r) }() } - *(*uint32)(unsafe.Pointer(set)) = uint32(0x7fffffff) - *(*uint32)(unsafe.Pointer(set + 1*4)) = uint32(0xfffffffc) + **(**uint32)(__ccgo_up(set)) = uint32(0x7fffffff) + **(**uint32)(__ccgo_up(set + 1*4)) = uint32(0xfffffffc) if int32(_NSIG) > int32(65) { - *(*uint32)(unsafe.Pointer(set + 2*4)) = uint32(0xffffffff) - *(*uint32)(unsafe.Pointer(set + 3*4)) = uint32(0xffffffff) + **(**uint32)(__ccgo_up(set + 2*4)) = uint32(0xffffffff) + **(**uint32)(__ccgo_up(set + 3*4)) = uint32(0xffffffff) } return 0 } @@ -135476,7 +135476,7 @@ func Xsigisemptyset(tls *TLS, set uintptr) (r int32) { if !(i < Uint32FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))/Uint32FromInt64(4)) { break } - if *(*uint32)(unsafe.Pointer(set + uintptr(i)*4)) != 0 { + if **(**uint32)(__ccgo_up(set + uintptr(i)*4)) != 0 { return 0 } goto _1 @@ -135498,7 +135498,7 @@ func Xsigismember(tls *TLS, set uintptr, sig int32) (r int32) { if s >= Uint32FromInt32(Int32FromInt32(_NSIG)-Int32FromInt32(1)) { return 0 } - return BoolInt32(!!(*(*uint32)(unsafe.Pointer(set + uintptr(s/uint32(8)/uint32(4))*4))&(Uint32FromUint32(1)<<(s&(Uint32FromInt32(8)*Uint32FromInt64(4)-Uint32FromInt32(1)))) != 0)) + return BoolInt32(!!(**(**uint32)(__ccgo_up(set + uintptr(s/uint32(8)/uint32(4))*4))&(Uint32FromUint32(1)<<(s&(Uint32FromInt32(8)*Uint32FromInt64(4)-Uint32FromInt32(1)))) != 0)) } func Xsigorset(tls *TLS, dest uintptr, left uintptr, right uintptr) (r1 int32) { @@ -135517,7 +135517,7 @@ func Xsigorset(tls *TLS, dest uintptr, left uintptr, right uintptr) (r1 int32) { if !(i < uint32(Uint32FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))/Uint32FromInt64(4))) { break } - *(*uint32)(unsafe.Pointer(d + uintptr(i)*4)) = *(*uint32)(unsafe.Pointer(l + uintptr(i)*4)) | *(*uint32)(unsafe.Pointer(r + uintptr(i)*4)) + **(**uint32)(__ccgo_up(d + uintptr(i)*4)) = **(**uint32)(__ccgo_up(l + uintptr(i)*4)) | **(**uint32)(__ccgo_up(r + uintptr(i)*4)) goto _1 _1: ; @@ -135545,7 +135545,7 @@ func Xsigprocmask(tls *TLS, how int32, set uintptr, old uintptr) (r1 int32) { if !(r != 0) { return r } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = r + **(**int32)(__ccgo_up(X__errno_location(tls))) = r return -int32(1) } @@ -135561,8 +135561,8 @@ func Xsigqueue(tls *TLS, pid Tpid_t, sig int32, value Tsigval) (r1 int32) { var _ /* si at bp+0 */ Tsiginfo_t _ = r Xmemset(tls, bp, 0, uint32(128)) - (*(*Tsiginfo_t)(unsafe.Pointer(bp))).Fsi_signo = sig - (*(*Tsiginfo_t)(unsafe.Pointer(bp))).Fsi_code = -int32(1) + (**(**Tsiginfo_t)(__ccgo_up(bp))).Fsi_signo = sig + (**(**Tsiginfo_t)(__ccgo_up(bp))).Fsi_code = -int32(1) *(*Tsigval)(unsafe.Pointer(bp + 12 + 8)) = value *(*Tuid_t)(unsafe.Pointer(bp + 12 + 4)) = Xgetuid(tls) X__block_app_sigs(tls, bp+128) @@ -135711,7 +135711,7 @@ func Xsigwait(tls *TLS, mask uintptr, sig uintptr) (r int32) { if Xsigtimedwait(tls, mask, bp, uintptr(0)) < 0 { return -int32(1) } - *(*int32)(unsafe.Pointer(sig)) = (*(*Tsiginfo_t)(unsafe.Pointer(bp))).Fsi_signo + **(**int32)(__ccgo_up(sig)) = (**(**Tsiginfo_t)(__ccgo_up(bp))).Fsi_signo return 0 } @@ -135728,7 +135728,7 @@ func X__xmknod(tls *TLS, ver int32, path uintptr, mode Tmode_t, dev uintptr) (r trc("tls=%v ver=%v path=%v mode=%v dev=%v, (%v:)", tls, ver, path, mode, dev, origin(2)) defer func() { trc("-> %v", r) }() } - return Xmknod(tls, path, mode, *(*Tdev_t)(unsafe.Pointer(dev))) + return Xmknod(tls, path, mode, **(**Tdev_t)(__ccgo_up(dev))) } func X__xmknodat(tls *TLS, ver int32, fd int32, path uintptr, mode Tmode_t, dev uintptr) (r int32) { @@ -135736,7 +135736,7 @@ func X__xmknodat(tls *TLS, ver int32, fd int32, path uintptr, mode Tmode_t, dev trc("tls=%v ver=%v fd=%v path=%v mode=%v dev=%v, (%v:)", tls, ver, fd, path, mode, dev, origin(2)) defer func() { trc("-> %v", r) }() } - return Xmknodat(tls, fd, path, mode, *(*Tdev_t)(unsafe.Pointer(dev))) + return Xmknodat(tls, fd, path, mode, **(**Tdev_t)(__ccgo_up(dev))) } func Xchmod(tls *TLS, path uintptr, mode Tmode_t) (r int32) { @@ -135789,7 +135789,7 @@ func Xfchmodat(tls *TLS, fd int32, path uintptr, mode Tmode_t, flag int32) (r in if Xfstatat(tls, fd, path, bp, flag) != 0 { return -int32(1) } - if (*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { + if (**(**Tstat)(__ccgo_up(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { return X__syscall_ret(tls, Uint32FromInt32(-Int32FromInt32(EOPNOTSUPP))) } v1 = int32(X__syscall3(tls, int32(SYS_openat), fd, int32(path), int32(Int32FromInt32(O_RDONLY)|Int32FromInt32(O_PATH)|Int32FromInt32(O_NOFOLLOW)|Int32FromInt32(O_NOCTTY)|Int32FromInt32(O_CLOEXEC)))) @@ -135803,7 +135803,7 @@ func Xfchmodat(tls *TLS, fd int32, path uintptr, mode Tmode_t, flag int32) (r in X__procfdname(tls, bp+152, Uint32FromInt32(fd2)) ret = Xstat(tls, bp+152, bp) if !(ret != 0) { - if (*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { + if (**(**Tstat)(__ccgo_up(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { ret = X__syscall_ret(tls, Uint32FromInt32(-Int32FromInt32(EOPNOTSUPP))) } else { ret = X__syscall_ret(tls, Uint32FromInt32(X__syscall3(tls, int32(SYS_fchmodat), int32(-Int32FromInt32(100)), int32(bp+152), Int32FromUint32(mode)))) @@ -135888,49 +135888,49 @@ func _fstatat_statx(tls *TLS, fd int32, path uintptr, st uintptr, flag int32) (r if ret != 0 { return ret } - *(*Tstat)(unsafe.Pointer(st)) = Tstat{ - Fst_dev: uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_dev_major)&Uint64FromUint64(0xfffff000)<= 0 && !(*(*uint8)(unsafe.Pointer(path)) != 0) { + if flag == int32(AT_EMPTY_PATH) && fd >= 0 && !(**(**uint8)(__ccgo_up(path)) != 0) { ret = int32(X__syscall2(tls, int32(SYS_fstat64), fd, int32(bp))) if ret == -int32(EBADF) && X__syscall2(tls, int32(SYS_fcntl64), fd, int32(Int32FromInt32(F_GETFD))) >= 0 { ret = int32(X__syscall4(tls, int32(SYS_fstatat64), fd, int32(path), int32(bp), flag)) @@ -135978,10 +135978,10 @@ func _fstatat_kstat(tls *TLS, fd int32, path uintptr, st uintptr, flag int32) (r } } } else { - if (fd == -int32(100) || Int32FromUint8(*(*uint8)(unsafe.Pointer(path))) == int32('/')) && flag == int32(AT_SYMLINK_NOFOLLOW) { + if (fd == -int32(100) || Int32FromUint8(**(**uint8)(__ccgo_up(path))) == int32('/')) && flag == int32(AT_SYMLINK_NOFOLLOW) { ret = int32(X__syscall2(tls, int32(SYS_lstat64), int32(path), int32(bp))) } else { - if (fd == -int32(100) || Int32FromUint8(*(*uint8)(unsafe.Pointer(path))) == int32('/')) && !(flag != 0) { + if (fd == -int32(100) || Int32FromUint8(**(**uint8)(__ccgo_up(path))) == int32('/')) && !(flag != 0) { ret = int32(X__syscall2(tls, int32(SYS_stat64), int32(path), int32(bp))) } else { ret = int32(X__syscall4(tls, int32(SYS_fstatat64), fd, int32(path), int32(bp), flag)) @@ -135991,49 +135991,49 @@ func _fstatat_kstat(tls *TLS, fd int32, path uintptr, st uintptr, flag int32) (r if ret != 0 { return ret } - *(*Tstat)(unsafe.Pointer(st)) = Tstat{ - Fst_dev: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_dev, - Fst_mode: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_mode, - Fst_nlink: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_nlink, - Fst_uid: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_uid, - Fst_gid: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_gid, - Fst_rdev: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_rdev, - Fst_size: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_size, - Fst_blksize: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_blksize, - Fst_blocks: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_blocks, + **(**Tstat)(__ccgo_up(st)) = Tstat{ + Fst_dev: (**(**Tkstat)(__ccgo_up(bp))).Fst_dev, + Fst_mode: (**(**Tkstat)(__ccgo_up(bp))).Fst_mode, + Fst_nlink: (**(**Tkstat)(__ccgo_up(bp))).Fst_nlink, + Fst_uid: (**(**Tkstat)(__ccgo_up(bp))).Fst_uid, + Fst_gid: (**(**Tkstat)(__ccgo_up(bp))).Fst_gid, + Fst_rdev: (**(**Tkstat)(__ccgo_up(bp))).Fst_rdev, + Fst_size: (**(**Tkstat)(__ccgo_up(bp))).Fst_size, + Fst_blksize: (**(**Tkstat)(__ccgo_up(bp))).Fst_blksize, + Fst_blocks: (**(**Tkstat)(__ccgo_up(bp))).Fst_blocks, F__st_atim32: struct { Ftv_sec int32 Ftv_nsec int32 }{ - Ftv_sec: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_atime_sec, - Ftv_nsec: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_atime_nsec, + Ftv_sec: (**(**Tkstat)(__ccgo_up(bp))).Fst_atime_sec, + Ftv_nsec: (**(**Tkstat)(__ccgo_up(bp))).Fst_atime_nsec, }, F__st_mtim32: struct { Ftv_sec int32 Ftv_nsec int32 }{ - Ftv_sec: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_mtime_sec, - Ftv_nsec: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_mtime_nsec, + Ftv_sec: (**(**Tkstat)(__ccgo_up(bp))).Fst_mtime_sec, + Ftv_nsec: (**(**Tkstat)(__ccgo_up(bp))).Fst_mtime_nsec, }, F__st_ctim32: struct { Ftv_sec int32 Ftv_nsec int32 }{ - Ftv_sec: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_ctime_sec, - Ftv_nsec: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_ctime_nsec, + Ftv_sec: (**(**Tkstat)(__ccgo_up(bp))).Fst_ctime_sec, + Ftv_nsec: (**(**Tkstat)(__ccgo_up(bp))).Fst_ctime_nsec, }, - Fst_ino: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_ino, + Fst_ino: (**(**Tkstat)(__ccgo_up(bp))).Fst_ino, Fst_atim: Ttimespec{ - Ftv_sec: int64((*(*Tkstat)(unsafe.Pointer(bp))).Fst_atime_sec), - Ftv_nsec: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_atime_nsec, + Ftv_sec: int64((**(**Tkstat)(__ccgo_up(bp))).Fst_atime_sec), + Ftv_nsec: (**(**Tkstat)(__ccgo_up(bp))).Fst_atime_nsec, }, Fst_mtim: Ttimespec{ - Ftv_sec: int64((*(*Tkstat)(unsafe.Pointer(bp))).Fst_mtime_sec), - Ftv_nsec: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_mtime_nsec, + Ftv_sec: int64((**(**Tkstat)(__ccgo_up(bp))).Fst_mtime_sec), + Ftv_nsec: (**(**Tkstat)(__ccgo_up(bp))).Fst_mtime_nsec, }, Fst_ctim: Ttimespec{ - Ftv_sec: int64((*(*Tkstat)(unsafe.Pointer(bp))).Fst_ctime_sec), - Ftv_nsec: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_ctime_nsec, + Ftv_sec: int64((**(**Tkstat)(__ccgo_up(bp))).Fst_ctime_sec), + Ftv_nsec: (**(**Tkstat)(__ccgo_up(bp))).Fst_ctime_nsec, }, } return 0 @@ -136089,11 +136089,11 @@ func X__futimesat(tls *TLS, dirfd int32, pathname uintptr, times uintptr) (r int if !(i < int32(2)) { break } - if Uint64FromInt64((*(*Ttimeval)(unsafe.Pointer(times + uintptr(i)*16))).Ftv_usec) >= uint64(1000000) { + if Uint64FromInt64((**(**Ttimeval)(__ccgo_up(times + uintptr(i)*16))).Ftv_usec) >= uint64(1000000) { return X__syscall_ret(tls, Uint32FromInt32(-Int32FromInt32(EINVAL))) } - (*(*[2]Ttimespec)(unsafe.Pointer(bp)))[i].Ftv_sec = (*(*Ttimeval)(unsafe.Pointer(times + uintptr(i)*16))).Ftv_sec - (*(*[2]Ttimespec)(unsafe.Pointer(bp)))[i].Ftv_nsec = int32((*(*Ttimeval)(unsafe.Pointer(times + uintptr(i)*16))).Ftv_usec * int64(1000)) + (**(**[2]Ttimespec)(__ccgo_up(bp)))[i].Ftv_sec = (**(**Ttimeval)(__ccgo_up(times + uintptr(i)*16))).Ftv_sec + (**(**[2]Ttimespec)(__ccgo_up(bp)))[i].Ftv_nsec = int32((**(**Ttimeval)(__ccgo_up(times + uintptr(i)*16))).Ftv_usec * int64(1000)) goto _1 _1: ; @@ -136189,7 +136189,7 @@ func Xstat(tls *TLS, path uintptr, buf uintptr) (r int32) { } func ___statfs(tls *TLS, path uintptr, buf uintptr) (r int32) { - *(*Tstatfs)(unsafe.Pointer(buf)) = Tstatfs{} + **(**Tstatfs)(__ccgo_up(buf)) = Tstatfs{} return X__syscall_ret(tls, Uint32FromInt32(X__syscall3(tls, int32(SYS_statfs64), int32(path), Int32FromUint32(Uint32FromInt64(88)), int32(buf)))) } @@ -136198,14 +136198,14 @@ func Xfstatfs(tls *TLS, fd int32, buf uintptr) (r int32) { trc("tls=%v fd=%v buf=%v, (%v:)", tls, fd, buf, origin(2)) defer func() { trc("-> %v", r) }() } - *(*Tstatfs)(unsafe.Pointer(buf)) = Tstatfs{} + **(**Tstatfs)(__ccgo_up(buf)) = Tstatfs{} return X__syscall_ret(tls, Uint32FromInt32(X__syscall3(tls, int32(SYS_fstatfs64), fd, Int32FromUint32(Uint32FromInt64(88)), int32(buf)))) } func _fixup(tls *TLS, out uintptr, in uintptr) { var v1 uint32 _ = v1 - *(*Tstatvfs)(unsafe.Pointer(out)) = Tstatvfs{} + **(**Tstatvfs)(__ccgo_up(out)) = Tstatvfs{} (*Tstatvfs)(unsafe.Pointer(out)).Ff_bsize = (*Tstatfs)(unsafe.Pointer(in)).Ff_bsize if (*Tstatfs)(unsafe.Pointer(in)).Ff_frsize != 0 { v1 = (*Tstatfs)(unsafe.Pointer(in)).Ff_frsize @@ -136219,7 +136219,7 @@ func _fixup(tls *TLS, out uintptr, in uintptr) { (*Tstatvfs)(unsafe.Pointer(out)).Ff_files = (*Tstatfs)(unsafe.Pointer(in)).Ff_files (*Tstatvfs)(unsafe.Pointer(out)).Ff_ffree = (*Tstatfs)(unsafe.Pointer(in)).Ff_ffree (*Tstatvfs)(unsafe.Pointer(out)).Ff_favail = (*Tstatfs)(unsafe.Pointer(in)).Ff_ffree - (*Tstatvfs)(unsafe.Pointer(out)).Ff_fsid = Uint32FromInt32(*(*int32)(unsafe.Pointer(in + 48))) + (*Tstatvfs)(unsafe.Pointer(out)).Ff_fsid = Uint32FromInt32(**(**int32)(__ccgo_up(in + 48))) (*Tstatvfs)(unsafe.Pointer(out)).Ff_flag = (*Tstatfs)(unsafe.Pointer(in)).Ff_flags (*Tstatvfs)(unsafe.Pointer(out)).Ff_namemax = (*Tstatfs)(unsafe.Pointer(in)).Ff_namelen (*Tstatvfs)(unsafe.Pointer(out)).Ff_type = (*Tstatfs)(unsafe.Pointer(in)).Ff_type @@ -136275,7 +136275,7 @@ func Xutimensat(tls *TLS, fd int32, path uintptr, times uintptr, flags int32) (r var tv, v1 uintptr var _ /* tmp at bp+48 */ [4]int32 _, _, _, _, _, _, _, _ = i, ns0, ns1, r, s0, s1, tv, v1 - if times != 0 && (*(*Ttimespec)(unsafe.Pointer(times))).Ftv_nsec == int32(UTIME_NOW) && (*(*Ttimespec)(unsafe.Pointer(times + 1*16))).Ftv_nsec == int32(UTIME_NOW) { + if times != 0 && (**(**Ttimespec)(__ccgo_up(times))).Ftv_nsec == int32(UTIME_NOW) && (**(**Ttimespec)(__ccgo_up(times + 1*16))).Ftv_nsec == int32(UTIME_NOW) { times = uintptr(0) } r = -int32(ENOSYS) @@ -136284,13 +136284,13 @@ func Xutimensat(tls *TLS, fd int32, path uintptr, times uintptr, flags int32) (r ns0 = 0 ns1 = 0 if times != 0 { - ns0 = (*(*Ttimespec)(unsafe.Pointer(times))).Ftv_nsec - ns1 = (*(*Ttimespec)(unsafe.Pointer(times + 1*16))).Ftv_nsec + ns0 = (**(**Ttimespec)(__ccgo_up(times))).Ftv_nsec + ns1 = (**(**Ttimespec)(__ccgo_up(times + 1*16))).Ftv_nsec if !(ns0 == int32(UTIME_NOW) || ns0 == int32(UTIME_OMIT)) { - s0 = (*(*Ttimespec)(unsafe.Pointer(times))).Ftv_sec + s0 = (**(**Ttimespec)(__ccgo_up(times))).Ftv_sec } if !(ns1 == int32(UTIME_NOW) || ns1 == int32(UTIME_OMIT)) { - s1 = (*(*Ttimespec)(unsafe.Pointer(times + 1*16))).Ftv_sec + s1 = (**(**Ttimespec)(__ccgo_up(times + 1*16))).Ftv_sec } } if Bool(false) || !!((Uint64FromInt64(s0)+Uint64FromUint64(0x80000000))>>Int32FromInt32(32) != 0) || !!((Uint64FromInt64(s1)+Uint64FromUint64(0x80000000))>>Int32FromInt32(32) != 0) { @@ -136336,14 +136336,14 @@ func Xutimensat(tls *TLS, fd int32, path uintptr, times uintptr, flags int32) (r if !(i < int32(2)) { break } - if Uint64FromInt32((*(*Ttimespec)(unsafe.Pointer(times + uintptr(i)*16))).Ftv_nsec) >= uint64(1000000000) { - if (*(*Ttimespec)(unsafe.Pointer(times + uintptr(i)*16))).Ftv_nsec == int32(UTIME_NOW) || (*(*Ttimespec)(unsafe.Pointer(times + uintptr(i)*16))).Ftv_nsec == int32(UTIME_OMIT) { + if Uint64FromInt32((**(**Ttimespec)(__ccgo_up(times + uintptr(i)*16))).Ftv_nsec) >= uint64(1000000000) { + if (**(**Ttimespec)(__ccgo_up(times + uintptr(i)*16))).Ftv_nsec == int32(UTIME_NOW) || (**(**Ttimespec)(__ccgo_up(times + uintptr(i)*16))).Ftv_nsec == int32(UTIME_OMIT) { return X__syscall_ret(tls, Uint32FromInt32(-Int32FromInt32(ENOSYS))) } return X__syscall_ret(tls, Uint32FromInt32(-Int32FromInt32(EINVAL))) } - (*(*[4]int32)(unsafe.Pointer(bp + 48)))[int32(2)*i+0] = int32((*(*Ttimespec)(unsafe.Pointer(times + uintptr(i)*16))).Ftv_sec) - (*(*[4]int32)(unsafe.Pointer(bp + 48)))[int32(2)*i+int32(1)] = (*(*Ttimespec)(unsafe.Pointer(times + uintptr(i)*16))).Ftv_nsec / int32(1000) + (**(**[4]int32)(__ccgo_up(bp + 48)))[int32(2)*i+0] = int32((**(**Ttimespec)(__ccgo_up(times + uintptr(i)*16))).Ftv_sec) + (**(**[4]int32)(__ccgo_up(bp + 48)))[int32(2)*i+int32(1)] = (**(**Ttimespec)(__ccgo_up(times + uintptr(i)*16))).Ftv_nsec / int32(1000) goto _3 _3: ; @@ -136378,8 +136378,8 @@ func X__fdopen(tls *TLS, fd int32, mode uintptr) (r uintptr) { var _ /* wsz at bp+0 */ Twinsize _, _, _, _ = f, flags, v1, v2 /* Check for valid initial mode character */ - if !(Xstrchr(tls, __ccgo_ts+1402, Int32FromUint8(*(*uint8)(unsafe.Pointer(mode)))) != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if !(Xstrchr(tls, __ccgo_ts+1402, Int32FromUint8(**(**uint8)(__ccgo_up(mode)))) != 0) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } /* Allocate FILE+buffer or fail */ @@ -136392,7 +136392,7 @@ func X__fdopen(tls *TLS, fd int32, mode uintptr) (r uintptr) { Xmemset(tls, f, 0, uint32(144)) /* Impose mode restrictions */ if !(Xstrchr(tls, mode, int32('+')) != 0) { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('r') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) == int32('r') { v2 = int32(F_NOWR) } else { v2 = int32(F_NORD) @@ -136404,12 +136404,12 @@ func X__fdopen(tls *TLS, fd int32, mode uintptr) (r uintptr) { X__syscall3(tls, int32(SYS_fcntl64), fd, int32(Int32FromInt32(F_SETFD)), int32(Int32FromInt32(FD_CLOEXEC))) } /* Set append mode on fd if opened for append */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('a') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) == int32('a') { flags = int32(X__syscall2(tls, int32(SYS_fcntl64), fd, int32(Int32FromInt32(F_GETFL)))) if !(flags&Int32FromInt32(O_APPEND) != 0) { X__syscall3(tls, int32(SYS_fcntl64), fd, int32(Int32FromInt32(F_SETFL)), int32(flags|Int32FromInt32(O_APPEND))) } - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_APP) + **(**uint32)(__ccgo_up(f)) |= uint32(F_APP) } (*TFILE)(unsafe.Pointer(f)).Ffd = fd (*TFILE)(unsafe.Pointer(f)).Fbuf = f + uintptr(144) + uintptr(UNGET) @@ -136449,7 +136449,7 @@ func X__fmodeflags(tls *TLS, mode uintptr) (r int32) { if Xstrchr(tls, mode, int32('+')) != 0 { flags = int32(O_RDWR) } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('r') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) == int32('r') { flags = O_RDONLY } else { flags = int32(O_WRONLY) @@ -136461,13 +136461,13 @@ func X__fmodeflags(tls *TLS, mode uintptr) (r int32) { if Xstrchr(tls, mode, int32('e')) != 0 { flags = flags | int32(O_CLOEXEC) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) != int32('r') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) != int32('r') { flags = flags | int32(O_CREAT) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('w') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) == int32('w') { flags = flags | int32(O_TRUNC) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('a') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) == int32('a') { flags = flags | int32(O_APPEND) } return flags @@ -136505,22 +136505,22 @@ func X__overflow(tls *TLS, f uintptr, _c int32) (r int32) { var v2, v3 uintptr var _ /* c at bp+0 */ uint8 _, _, _ = v1, v2, v3 - *(*uint8)(unsafe.Pointer(bp)) = Uint8FromInt32(_c) + **(**uint8)(__ccgo_up(bp)) = Uint8FromInt32(_c) if !((*TFILE)(unsafe.Pointer(f)).Fwend != 0) && X__towrite(tls, f) != 0 { return -int32(1) } - if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwend && Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) != (*TFILE)(unsafe.Pointer(f)).Flbf { - v1 = *(*uint8)(unsafe.Pointer(bp)) + if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwend && Int32FromUint8(**(**uint8)(__ccgo_up(bp))) != (*TFILE)(unsafe.Pointer(f)).Flbf { + v1 = **(**uint8)(__ccgo_up(bp)) v3 = f + 20 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - *(*uint8)(unsafe.Pointer(v2)) = v1 + **(**uint8)(__ccgo_up(v2)) = v1 return Int32FromUint8(v1) } if (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fwrite})))(tls, f, bp, uint32(1)) != uint32(1) { return -int32(1) } - return Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) + return Int32FromUint8(**(**uint8)(__ccgo_up(bp))) } func _dummy9(tls *TLS, fd int32) (r int32) { @@ -136558,7 +136558,7 @@ func X__stdio_exit(tls *TLS) { } var f uintptr _ = f - f = *(*uintptr)(unsafe.Pointer(X__ofl_lock(tls))) + f = **(**uintptr)(__ccgo_up(X__ofl_lock(tls))) for { if !(f != 0) { break @@ -136593,7 +136593,7 @@ func X__stdio_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { var v3, v4 uintptr var _ /* iov at bp+0 */ [2]Tiovec _, _, _, _ = cnt, v1, v3, v4 - *(*[2]Tiovec)(unsafe.Pointer(bp)) = [2]Tiovec{ + **(**[2]Tiovec)(__ccgo_up(bp)) = [2]Tiovec{ 0: { Fiov_base: buf, Fiov_len: len1 - BoolUint32(!!((*TFILE)(unsafe.Pointer(f)).Fbuf_size != 0)), @@ -136603,10 +136603,10 @@ func X__stdio_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { Fiov_len: (*TFILE)(unsafe.Pointer(f)).Fbuf_size, }, } - if (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len != 0 { + if (**(**[2]Tiovec)(__ccgo_up(bp)))[0].Fiov_len != 0 { v1 = X__syscall_ret(tls, Uint32FromInt32(X__syscall3(tls, int32(SYS_readv), (*TFILE)(unsafe.Pointer(f)).Ffd, int32(bp), int32(Int32FromInt32(2))))) } else { - v1 = X__syscall_ret(tls, Uint32FromInt32(X__syscall3(tls, int32(SYS_read), (*TFILE)(unsafe.Pointer(f)).Ffd, int32((*(*[2]Tiovec)(unsafe.Pointer(bp)))[int32(1)].Fiov_base), Int32FromUint32((*(*[2]Tiovec)(unsafe.Pointer(bp)))[int32(1)].Fiov_len)))) + v1 = X__syscall_ret(tls, Uint32FromInt32(X__syscall3(tls, int32(SYS_read), (*TFILE)(unsafe.Pointer(f)).Ffd, int32((**(**[2]Tiovec)(__ccgo_up(bp)))[int32(1)].Fiov_base), Int32FromUint32((**(**[2]Tiovec)(__ccgo_up(bp)))[int32(1)].Fiov_len)))) } cnt = v1 if cnt <= 0 { @@ -136615,20 +136615,20 @@ func X__stdio_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { } else { v1 = int32(F_EOF) } - *(*uint32)(unsafe.Pointer(f)) |= Uint32FromInt32(v1) + **(**uint32)(__ccgo_up(f)) |= Uint32FromInt32(v1) return uint32(0) } - if Uint32FromInt32(cnt) <= (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len { + if Uint32FromInt32(cnt) <= (**(**[2]Tiovec)(__ccgo_up(bp)))[0].Fiov_len { return Uint32FromInt32(cnt) } - cnt = Int32FromUint32(uint32(cnt) - (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len) + cnt = Int32FromUint32(uint32(cnt) - (**(**[2]Tiovec)(__ccgo_up(bp)))[0].Fiov_len) (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(cnt) if (*TFILE)(unsafe.Pointer(f)).Fbuf_size != 0 { v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(buf + uintptr(len1-uint32(1)))) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(buf + uintptr(len1-uint32(1)))) = **(**uint8)(__ccgo_up(v3)) } return len1 } @@ -136655,7 +136655,7 @@ func X__stdio_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) var v5 uint32 var _ /* iovs at bp+0 */ [2]Tiovec _, _, _, _, _, _, _ = cnt, iov, iovcnt, rem, v2, v3, v5 - *(*[2]Tiovec)(unsafe.Pointer(bp)) = [2]Tiovec{ + **(**[2]Tiovec)(__ccgo_up(bp)) = [2]Tiovec{ 0: { Fiov_base: (*TFILE)(unsafe.Pointer(f)).Fwbase, Fiov_len: Uint32FromInt32(int32((*TFILE)(unsafe.Pointer(f)).Fwpos) - int32((*TFILE)(unsafe.Pointer(f)).Fwbase)), @@ -136666,7 +136666,7 @@ func X__stdio_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) }, } iov = bp - rem = (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len + (*(*Tiovec)(unsafe.Pointer(iov + 1*8))).Fiov_len + rem = (**(**Tiovec)(__ccgo_up(iov))).Fiov_len + (**(**Tiovec)(__ccgo_up(iov + 1*8))).Fiov_len iovcnt = int32(2) for { cnt = X__syscall_ret(tls, Uint32FromInt32(X__syscall3(tls, int32(SYS_writev), (*TFILE)(unsafe.Pointer(f)).Ffd, int32(iov), iovcnt))) @@ -136683,22 +136683,22 @@ func X__stdio_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) v2 = v3 (*TFILE)(unsafe.Pointer(f)).Fwbase = v2 (*TFILE)(unsafe.Pointer(f)).Fwpos = v2 - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) if iovcnt == int32(2) { v5 = uint32(0) } else { - v5 = len1 - (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len + v5 = len1 - (**(**Tiovec)(__ccgo_up(iov))).Fiov_len } return v5 } rem = rem - Uint32FromInt32(cnt) - if Uint32FromInt32(cnt) > (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len { - cnt = Int32FromUint32(uint32(cnt) - (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len) + if Uint32FromInt32(cnt) > (**(**Tiovec)(__ccgo_up(iov))).Fiov_len { + cnt = Int32FromUint32(uint32(cnt) - (**(**Tiovec)(__ccgo_up(iov))).Fiov_len) iov += 8 iovcnt = iovcnt - 1 } - (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_base = (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_base + uintptr(cnt) - (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len -= Uint32FromInt32(cnt) + (**(**Tiovec)(__ccgo_up(iov))).Fiov_base = (**(**Tiovec)(__ccgo_up(iov))).Fiov_base + uintptr(cnt) + (**(**Tiovec)(__ccgo_up(iov))).Fiov_len -= Uint32FromInt32(cnt) goto _1 _1: } @@ -136728,7 +136728,7 @@ func X__toread(tls *TLS, f uintptr) (r int32) { var v1, v2 uintptr var v4 int32 _, _, _ = v1, v2, v4 - *(*int32)(unsafe.Pointer(f + 72)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) + **(**int32)(__ccgo_up(f + 72)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwbase { (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fwrite})))(tls, f, uintptr(0), uint32(0)) } @@ -136738,7 +136738,7 @@ func X__toread(tls *TLS, f uintptr) (r int32) { (*TFILE)(unsafe.Pointer(f)).Fwbase = v1 (*TFILE)(unsafe.Pointer(f)).Fwpos = v1 if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_NORD) != 0 { - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) return -int32(1) } v1 = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr((*TFILE)(unsafe.Pointer(f)).Fbuf_size) @@ -136766,9 +136766,9 @@ func X__towrite(tls *TLS, f uintptr) (r int32) { } var v1 uintptr _ = v1 - *(*int32)(unsafe.Pointer(f + 72)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) + **(**int32)(__ccgo_up(f + 72)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_NOWR) != 0 { - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) return -int32(1) } /* Clear read buffer (easier than summoning nasal demons) */ @@ -136802,7 +136802,7 @@ func X__uflow(tls *TLS, f uintptr) (r int32) { defer tls.Free(16) var _ /* c at bp+0 */ uint8 if !(X__toread(tls, f) != 0) && (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fread})))(tls, f, bp, uint32(1)) == uint32(1) { - return Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) + return Int32FromUint8(**(**uint8)(__ccgo_up(bp))) } return -int32(1) } @@ -136833,7 +136833,7 @@ func Xclearerr(tls *TLS, f uintptr) { v1 = 0 } __need_unlock = v1 - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^(Int32FromInt32(F_EOF) | Int32FromInt32(F_ERR))) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^(Int32FromInt32(F_EOF) | Int32FromInt32(F_ERR))) if __need_unlock != 0 { ___unlockfile(tls, f) } @@ -136994,7 +136994,7 @@ func X__freadptr(tls *TLS, f uintptr, sizep uintptr) (r uintptr) { if (*TFILE)(unsafe.Pointer(f)).Frpos == (*TFILE)(unsafe.Pointer(f)).Frend { return uintptr(0) } - *(*Tsize_t)(unsafe.Pointer(sizep)) = Uint32FromInt32(int32((*TFILE)(unsafe.Pointer(f)).Frend) - int32((*TFILE)(unsafe.Pointer(f)).Frpos)) + **(**Tsize_t)(__ccgo_up(sizep)) = Uint32FromInt32(int32((*TFILE)(unsafe.Pointer(f)).Frend) - int32((*TFILE)(unsafe.Pointer(f)).Frpos)) return (*TFILE)(unsafe.Pointer(f)).Frpos } @@ -137002,14 +137002,14 @@ func X__freadptrinc(tls *TLS, f uintptr, inc Tsize_t) { if __ccgo_strace { trc("tls=%v f=%v inc=%v, (%v:)", tls, f, inc, origin(2)) } - *(*uintptr)(unsafe.Pointer(f + 4)) += uintptr(inc) + **(**uintptr)(__ccgo_up(f + 4)) += uintptr(inc) } func X__fseterr(tls *TLS, f uintptr) { if __ccgo_strace { trc("tls=%v f=%v, (%v:)", tls, f, origin(2)) } - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) } func _dummy10(tls *TLS, f uintptr) { @@ -137052,8 +137052,8 @@ func Xfclose(tls *TLS, f uintptr) (r1 int32) { if (*TFILE)(unsafe.Pointer(f)).Fnext != 0 { (*TFILE)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Fnext)).Fprev = (*TFILE)(unsafe.Pointer(f)).Fprev } - if *(*uintptr)(unsafe.Pointer(head)) == f { - *(*uintptr)(unsafe.Pointer(head)) = (*TFILE)(unsafe.Pointer(f)).Fnext + if **(**uintptr)(__ccgo_up(head)) == f { + **(**uintptr)(__ccgo_up(head)) = (*TFILE)(unsafe.Pointer(f)).Fnext } X__ofl_unlock(tls) Xfree(tls, (*TFILE)(unsafe.Pointer(f)).Fgetln_buf) @@ -137154,7 +137154,7 @@ func Xfflush(tls *TLS, f uintptr) (r1 int32) { if AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stderr_used))) != 0 { r = r | Xfflush(tls, AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stderr_used)))) } - f = *(*uintptr)(unsafe.Pointer(X__ofl_lock(tls))) + f = **(**uintptr)(__ccgo_up(X__ofl_lock(tls))) for { if !(f != 0) { break @@ -137242,7 +137242,7 @@ _3: v5 = f + 4 v1 = *(*uintptr)(unsafe.Pointer(v5)) *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v1))) } else { v2 = X__uflow(tls, f) } @@ -137286,7 +137286,7 @@ func Xfgetc(tls *TLS, f1 uintptr) (r int32) { v6 = v1 + 4 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(v5))) } else { v4 = X__uflow(tls, v1) } @@ -137322,7 +137322,7 @@ func Xfgetln(tls *TLS, f uintptr, plen uintptr) (r uintptr) { v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__uflow(tls, f) } @@ -137335,14 +137335,14 @@ func Xfgetln(tls *TLS, f uintptr, plen uintptr) (r uintptr) { ret = (*TFILE)(unsafe.Pointer(f)).Frpos z = z + 1 v3 = z - *(*Tsize_t)(unsafe.Pointer(plen)) = Uint32FromInt32(int32(v3) - int32(ret)) + **(**Tsize_t)(__ccgo_up(plen)) = Uint32FromInt32(int32(v3) - int32(ret)) (*TFILE)(unsafe.Pointer(f)).Frpos = z } else { *(*[1]Tsize_t)(unsafe.Pointer(bp)) = [1]Tsize_t{} v8 = Xgetline(tls, f+96, bp, f) l = v8 if v8 > 0 { - *(*Tsize_t)(unsafe.Pointer(plen)) = Uint32FromInt32(l) + **(**Tsize_t)(__ccgo_up(plen)) = Uint32FromInt32(l) ret = (*TFILE)(unsafe.Pointer(f)).Fgetln_buf } } @@ -137363,7 +137363,7 @@ func Xfgetpos(tls *TLS, f uintptr, pos uintptr) (r int32) { if off < 0 { return -int32(1) } - *(*int64)(unsafe.Pointer(pos)) = off + **(**int64)(__ccgo_up(pos)) = off return 0 } @@ -137386,14 +137386,14 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { } __need_unlock = v1 if n <= int32(1) { - *(*int32)(unsafe.Pointer(f + 72)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) + **(**int32)(__ccgo_up(f + 72)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) if __need_unlock != 0 { ___unlockfile(tls, f) } if n < int32(1) { return uintptr(0) } - *(*uint8)(unsafe.Pointer(s)) = uint8(0) + **(**uint8)(__ccgo_up(s)) = uint8(0) return s } n = n - 1 @@ -137413,7 +137413,7 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { } k = v3 _memcpy(tls, p, (*TFILE)(unsafe.Pointer(f)).Frpos, k) - *(*uintptr)(unsafe.Pointer(f + 4)) += uintptr(k) + **(**uintptr)(__ccgo_up(f + 4)) += uintptr(k) p = p + uintptr(k) n = Int32FromUint32(uint32(n) - k) if z != 0 || !(n != 0) { @@ -137424,7 +137424,7 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { v7 = f + 4 v6 = *(*uintptr)(unsafe.Pointer(v7)) *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v6))) } else { v2 = X__uflow(tls, f) } @@ -137440,13 +137440,13 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { v8 = Uint8FromInt32(c) v6 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v6)) = v8 + **(**uint8)(__ccgo_up(v6)) = v8 if Int32FromUint8(v8) == int32('\n') { break } } if s != 0 { - *(*uint8)(unsafe.Pointer(p)) = uint8(0) + **(**uint8)(__ccgo_up(p)) = uint8(0) } if __need_unlock != 0 { ___unlockfile(tls, f) @@ -137476,43 +137476,43 @@ func ___fgetwc_unlocked_internal(tls *TLS, f uintptr) (r Twint_t) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { l = Uint32FromInt32(Xmbtowc(tls, bp, (*TFILE)(unsafe.Pointer(f)).Frpos, Uint32FromInt32(int32((*TFILE)(unsafe.Pointer(f)).Frend)-int32((*TFILE)(unsafe.Pointer(f)).Frpos)))) if l+uint32(1) >= uint32(1) { - *(*uintptr)(unsafe.Pointer(f + 4)) += uintptr(l + BoolUint32(!(l != 0))) /* l==0 means 1 byte, null */ - return *(*Twchar_t)(unsafe.Pointer(bp)) + **(**uintptr)(__ccgo_up(f + 4)) += uintptr(l + BoolUint32(!(l != 0))) /* l==0 means 1 byte, null */ + return **(**Twchar_t)(__ccgo_up(bp)) } } /* Convert character byte-by-byte */ - *(*Tmbstate_t)(unsafe.Pointer(bp + 8)) = Tmbstate_t{} + **(**Tmbstate_t)(__ccgo_up(bp + 8)) = Tmbstate_t{} first = int32(1) for cond := true; cond; cond = l == Uint32FromInt32(-Int32FromInt32(2)) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__uflow(tls, f) } v1 = v2 c = v1 - *(*uint8)(unsafe.Pointer(bp + 16)) = Uint8FromInt32(v1) + **(**uint8)(__ccgo_up(bp + 16)) = Uint8FromInt32(v1) if c < 0 { if !(first != 0) { - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EILSEQ) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EILSEQ) } return uint32(0xffffffff) } l = Xmbrtowc(tls, bp, bp+16, uint32(1), bp+8) if l == Uint32FromInt32(-Int32FromInt32(1)) { if !(first != 0) { - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) - Xungetc(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + 16))), f) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) + Xungetc(tls, Int32FromUint8(**(**uint8)(__ccgo_up(bp + 16))), f) } return uint32(0xffffffff) } first = 0 } - return *(*Twchar_t)(unsafe.Pointer(bp)) + return **(**Twchar_t)(__ccgo_up(bp)) } func X__fgetwc_unlocked(tls *TLS, f uintptr) (r Twint_t) { @@ -137525,13 +137525,13 @@ func X__fgetwc_unlocked(tls *TLS, f uintptr) (r Twint_t) { var wc Twchar_t _, _, _ = loc, ploc, wc ploc = uintptr(___get_tp(tls)) + 88 - loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) + loc = **(**Tlocale_t)(__ccgo_up(ploc)) if (*TFILE)(unsafe.Pointer(f)).Fmode <= 0 { Xfwide(tls, f, int32(1)) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale + **(**Tlocale_t)(__ccgo_up(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale wc = ___fgetwc_unlocked_internal(tls, f) - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return wc } @@ -137603,7 +137603,7 @@ func Xfgetws(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { } v4 = p p += 4 - *(*Twchar_t)(unsafe.Pointer(v4)) = c + **(**Twchar_t)(__ccgo_up(v4)) = c if c == uint32('\n') { break } @@ -137612,7 +137612,7 @@ func Xfgetws(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { ; n = n - 1 } - *(*Twchar_t)(unsafe.Pointer(p)) = uint32(0) + **(**Twchar_t)(__ccgo_up(p)) = uint32(0) if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_ERR) != 0 { p = s } @@ -137653,7 +137653,7 @@ func Xfileno(tls *TLS, f uintptr) (r int32) { ___unlockfile(tls, f) } if fd < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EBADF) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EBADF) return -int32(1) } return fd @@ -137708,7 +137708,7 @@ func _mseek(tls *TLS, f uintptr, off Toff_t, whence int32) (r Toff_t) { goto fail fail: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) _1: ; @@ -137716,7 +137716,7 @@ _1: 1: (*Tcookie)(unsafe.Pointer(c)).Fpos, 2: (*Tcookie)(unsafe.Pointer(c)).Flen1, } - base = Int32FromUint32(*(*Tsize_t)(unsafe.Pointer(bp + uintptr(whence)*4))) + base = Int32FromUint32(**(**Tsize_t)(__ccgo_up(bp + uintptr(whence)*4))) if off < int64(-base) || off > int64(Int32FromUint32((*Tcookie)(unsafe.Pointer(c)).Fsize)-base) { goto fail } @@ -137736,10 +137736,10 @@ func _mread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { } if len1 > rem { len1 = rem - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_EOF) + **(**uint32)(__ccgo_up(f)) |= uint32(F_EOF) } _memcpy(tls, buf, (*Tcookie)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie)(unsafe.Pointer(c)).Fpos), len1) - *(*Tsize_t)(unsafe.Pointer(c)) += len1 + **(**Tsize_t)(__ccgo_up(c)) += len1 rem = rem - len1 if rem > (*TFILE)(unsafe.Pointer(f)).Fbuf_size { rem = (*TFILE)(unsafe.Pointer(f)).Fbuf_size @@ -137747,7 +137747,7 @@ func _mread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(rem) _memcpy(tls, (*TFILE)(unsafe.Pointer(f)).Frpos, (*Tcookie)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie)(unsafe.Pointer(c)).Fpos), rem) - *(*Tsize_t)(unsafe.Pointer(c)) += rem + **(**Tsize_t)(__ccgo_up(c)) += rem return len1 } @@ -137771,14 +137771,14 @@ func _mwrite(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { len1 = rem } _memcpy(tls, (*Tcookie)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie)(unsafe.Pointer(c)).Fpos), buf, len1) - *(*Tsize_t)(unsafe.Pointer(c)) += len1 + **(**Tsize_t)(__ccgo_up(c)) += len1 if (*Tcookie)(unsafe.Pointer(c)).Fpos > (*Tcookie)(unsafe.Pointer(c)).Flen1 { (*Tcookie)(unsafe.Pointer(c)).Flen1 = (*Tcookie)(unsafe.Pointer(c)).Fpos if (*Tcookie)(unsafe.Pointer(c)).Flen1 < (*Tcookie)(unsafe.Pointer(c)).Fsize { - *(*uint8)(unsafe.Pointer((*Tcookie)(unsafe.Pointer(c)).Fbuf + uintptr((*Tcookie)(unsafe.Pointer(c)).Flen1))) = uint8(0) + **(**uint8)(__ccgo_up((*Tcookie)(unsafe.Pointer(c)).Fbuf + uintptr((*Tcookie)(unsafe.Pointer(c)).Flen1))) = uint8(0) } else { if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_NORD) != 0 && (*Tcookie)(unsafe.Pointer(c)).Fsize != 0 { - *(*uint8)(unsafe.Pointer((*Tcookie)(unsafe.Pointer(c)).Fbuf + uintptr((*Tcookie)(unsafe.Pointer(c)).Fsize-uint32(1)))) = uint8(0) + **(**uint8)(__ccgo_up((*Tcookie)(unsafe.Pointer(c)).Fbuf + uintptr((*Tcookie)(unsafe.Pointer(c)).Fsize-uint32(1)))) = uint8(0) } } } @@ -137800,12 +137800,12 @@ func Xfmemopen(tls *TLS, buf uintptr, size Tsize_t, mode uintptr) (r uintptr) { var v3 Tsize_t _, _, _, _, _ = f, plus, v1, v2, v3 plus = BoolInt32(!!(Xstrchr(tls, mode, int32('+')) != 0)) - if !(Xstrchr(tls, __ccgo_ts+1402, Int32FromUint8(*(*uint8)(unsafe.Pointer(mode)))) != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if !(Xstrchr(tls, __ccgo_ts+1402, Int32FromUint8(**(**uint8)(__ccgo_up(mode)))) != 0) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } if !(buf != 0) && size > Uint32FromInt32(Int32FromInt32(INT32_MAX)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return uintptr(0) } if buf != 0 { @@ -137829,25 +137829,25 @@ func Xfmemopen(tls *TLS, buf uintptr, size Tsize_t, mode uintptr) (r uintptr) { } (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fbuf = buf (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fsize = size - (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fmode = Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) + (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fmode = Int32FromUint8(**(**uint8)(__ccgo_up(mode))) if !(plus != 0) { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('r') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) == int32('r') { v2 = int32(F_NOWR) } else { v2 = int32(F_NORD) } (*Tmem_FILE)(unsafe.Pointer(f)).Ff.Fflags = Uint32FromInt32(v2) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('r') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) == int32('r') { (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Flen1 = size } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('a') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) == int32('a') { v3 = Xstrnlen(tls, buf, size) (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fpos = v3 (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Flen1 = v3 } else { if plus != 0 { - *(*uint8)(unsafe.Pointer((*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fbuf)) = uint8(0) + **(**uint8)(__ccgo_up((*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fbuf)) = uint8(0) } } } @@ -137870,8 +137870,8 @@ func Xfopen(tls *TLS, filename uintptr, mode uintptr) (r uintptr) { var fd, flags int32 _, _, _ = f, fd, flags /* Check for valid initial mode character */ - if !(Xstrchr(tls, __ccgo_ts+1402, Int32FromUint8(*(*uint8)(unsafe.Pointer(mode)))) != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if !(Xstrchr(tls, __ccgo_ts+1402, Int32FromUint8(**(**uint8)(__ccgo_up(mode)))) != 0) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } /* Compute the flags to pass to open() */ @@ -137940,7 +137940,7 @@ func _cookieread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { v3 = f + 4 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - *(*uint8)(unsafe.Pointer(buf + uintptr(v1))) = *(*uint8)(unsafe.Pointer(v2)) + **(**uint8)(__ccgo_up(buf + uintptr(v1))) = **(**uint8)(__ccgo_up(v2)) return readlen goto bail bail: @@ -137950,7 +137950,7 @@ bail: } else { v4 = int32(F_ERR) } - *(*uint32)(unsafe.Pointer(f)) |= Uint32FromInt32(v4) + **(**uint32)(__ccgo_up(f)) |= Uint32FromInt32(v4) v2 = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = v2 (*TFILE)(unsafe.Pointer(f)).Frpos = v2 @@ -137980,7 +137980,7 @@ func _cookiewrite(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { v1 = v2 (*TFILE)(unsafe.Pointer(f)).Fwbase = v1 (*TFILE)(unsafe.Pointer(f)).Fwpos = v1 - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) return uint32(0) } return Uint32FromInt32(ret) @@ -137995,18 +137995,18 @@ func _cookieseek(tls *TLS, f uintptr, _off Toff_t, whence int32) (r Toff_t) { _, _ = fc, res fc = (*TFILE)(unsafe.Pointer(f)).Fcookie if Uint32FromInt32(whence) > uint32(2) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) } if !((*Tfcookie)(unsafe.Pointer(fc)).Fiofuncs.Fseek != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOPNOTSUPP) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOPNOTSUPP) return int64(-int32(1)) } res = (*(*func(*TLS, uintptr, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{(*Tfcookie)(unsafe.Pointer(fc)).Fiofuncs.Fseek})))(tls, (*Tfcookie)(unsafe.Pointer(fc)).Fcookie, bp, whence) if res < 0 { return int64(res) } - return *(*Toff_t)(unsafe.Pointer(bp)) + return **(**Toff_t)(__ccgo_up(bp)) } func _cookieclose(tls *TLS, f uintptr) (r int32) { @@ -138028,8 +138028,8 @@ func Xfopencookie(tls *TLS, cookie uintptr, mode uintptr, iofuncs Tcookie_io_fun var v2 int32 _, _, _ = f, v1, v2 /* Check for valid initial mode character */ - if !(Xstrchr(tls, __ccgo_ts+1402, Int32FromUint8(*(*uint8)(unsafe.Pointer(mode)))) != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if !(Xstrchr(tls, __ccgo_ts+1402, Int32FromUint8(**(**uint8)(__ccgo_up(mode)))) != 0) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } /* Allocate FILE+fcookie+buffer or fail */ @@ -138042,7 +138042,7 @@ func Xfopencookie(tls *TLS, cookie uintptr, mode uintptr, iofuncs Tcookie_io_fun Xmemset(tls, f, 0, uint32(144)) /* Impose mode restrictions */ if !(Xstrchr(tls, mode, int32('+')) != 0) { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('r') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) == int32('r') { v2 = int32(F_NOWR) } else { v2 = int32(F_NORD) @@ -138102,7 +138102,7 @@ _3: v6 = f + 20 v1 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - *(*uint8)(unsafe.Pointer(v1)) = v5 + **(**uint8)(__ccgo_up(v1)) = v5 v2 = Int32FromUint8(v5) } else { v2 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) @@ -138150,7 +138150,7 @@ func Xfputc(tls *TLS, c1 int32, f1 uintptr) (r int32) { v8 = v2 + 20 v7 = *(*uintptr)(unsafe.Pointer(v8)) *(*uintptr)(unsafe.Pointer(v8)) = *(*uintptr)(unsafe.Pointer(v8)) + 1 - *(*uint8)(unsafe.Pointer(v7)) = v6 + **(**uint8)(__ccgo_up(v7)) = v6 v5 = Int32FromUint8(v6) } else { v5 = X__overflow(tls, v2, Int32FromUint8(Uint8FromInt32(v1))) @@ -138197,18 +138197,18 @@ func X__fputwc_unlocked(tls *TLS, c Twchar_t, f uintptr) (r Twint_t) { var _ /* mbc at bp+0 */ [4]uint8 _, _, _, _, _, _, _ = l, loc, ploc, v1, v2, v3, v4 ploc = uintptr(___get_tp(tls)) + 88 - loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) + loc = **(**Tlocale_t)(__ccgo_up(ploc)) if (*TFILE)(unsafe.Pointer(f)).Fmode <= 0 { Xfwide(tls, f, int32(1)) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale + **(**Tlocale_t)(__ccgo_up(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale if BoolInt32(c < uint32(128)) != 0 { if Int32FromUint8(uint8(c)) != (*TFILE)(unsafe.Pointer(f)).Flbf && (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwend { v2 = uint8(c) v4 = f + 20 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(v3)) = v2 + **(**uint8)(__ccgo_up(v3)) = v2 v1 = Int32FromUint8(v2) } else { v1 = X__overflow(tls, f, Int32FromUint8(uint8(c))) @@ -138220,7 +138220,7 @@ func X__fputwc_unlocked(tls *TLS, c Twchar_t, f uintptr) (r Twint_t) { if l < 0 { c = uint32(0xffffffff) } else { - *(*uintptr)(unsafe.Pointer(f + 20)) += uintptr(l) + **(**uintptr)(__ccgo_up(f + 20)) += uintptr(l) } } else { l = Xwctomb(tls, bp, c) @@ -138230,9 +138230,9 @@ func X__fputwc_unlocked(tls *TLS, c Twchar_t, f uintptr) (r Twint_t) { } } if c == uint32(0xffffffff) { - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return c } @@ -138289,7 +138289,7 @@ func Xfputws(tls *TLS, _ws uintptr, f uintptr) (r int32) { _, _, _, _, _, _, _ = __need_unlock, l, loc, ploc, v1, v2, v3 l = uint32(0) ploc = uintptr(___get_tp(tls)) + 88 - loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) + loc = **(**Tlocale_t)(__ccgo_up(ploc)) if AtomicLoadPInt32(f+76) >= 0 { v1 = ___lockfile(tls, f) } else { @@ -138297,9 +138297,9 @@ func Xfputws(tls *TLS, _ws uintptr, f uintptr) (r int32) { } __need_unlock = v1 Xfwide(tls, f, int32(1)) - *(*Tlocale_t)(unsafe.Pointer(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale + **(**Tlocale_t)(__ccgo_up(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale for { - if v3 = *(*uintptr)(unsafe.Pointer(bp)) != 0; v3 { + if v3 = **(**uintptr)(__ccgo_up(bp)) != 0; v3 { v2 = Xwcsrtombs(tls, bp+4, bp, uint32(1024), uintptr(0)) l = v2 } @@ -138310,14 +138310,14 @@ func Xfputws(tls *TLS, _ws uintptr, f uintptr) (r int32) { if __need_unlock != 0 { ___unlockfile(tls, f) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return -int32(1) } } if __need_unlock != 0 { ___unlockfile(tls, f) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return Int32FromUint32(l) /* 0 or -1 */ } @@ -138351,7 +138351,7 @@ func Xfread(tls *TLS, destv uintptr, size Tsize_t, nmemb Tsize_t, f uintptr) (r v1 = 0 } __need_unlock = v1 - *(*int32)(unsafe.Pointer(f + 72)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) + **(**int32)(__ccgo_up(f + 72)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { /* First exhaust the buffer. */ if Uint32FromInt32(int32((*TFILE)(unsafe.Pointer(f)).Frend)-int32((*TFILE)(unsafe.Pointer(f)).Frpos)) < l { @@ -138361,7 +138361,7 @@ func Xfread(tls *TLS, destv uintptr, size Tsize_t, nmemb Tsize_t, f uintptr) (r } k = v2 _memcpy(tls, dest, (*TFILE)(unsafe.Pointer(f)).Frpos, k) - *(*uintptr)(unsafe.Pointer(f + 4)) += uintptr(k) + **(**uintptr)(__ccgo_up(f + 4)) += uintptr(k) dest = dest + uintptr(k) l = l - k } @@ -138501,7 +138501,7 @@ func X__fseeko_unlocked(tls *TLS, f uintptr, off Toff_t, whence int32) (r int32) _, _ = v1, v2 /* Fail immediately for invalid whence argument. */ if whence != int32(1) && whence != 0 && whence != int32(2) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } /* Adjust relative offset for unread data in buffer, if any. */ @@ -138529,7 +138529,7 @@ func X__fseeko_unlocked(tls *TLS, f uintptr, off Toff_t, whence int32) (r int32) v1 = UintptrFromInt32(0) (*TFILE)(unsafe.Pointer(f)).Frend = v1 (*TFILE)(unsafe.Pointer(f)).Frpos = v1 - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) return 0 } @@ -138574,7 +138574,7 @@ func Xfsetpos(tls *TLS, f uintptr, pos uintptr) (r int32) { trc("tls=%v f=%v pos=%v, (%v:)", tls, f, pos, origin(2)) defer func() { trc("-> %v", r) }() } - return X__fseeko(tls, f, *(*int64)(unsafe.Pointer(pos)), 0) + return X__fseeko(tls, f, **(**int64)(__ccgo_up(pos)), 0) } /* Support signed or unsigned plain-char */ @@ -138644,7 +138644,7 @@ func Xftell(tls *TLS, f uintptr) (r int32) { _ = pos pos = X__ftello(tls, f) if pos > int64(0x7fffffff) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return -int32(1) } return int32(pos) @@ -138780,7 +138780,7 @@ func Xfwide(tls *TLS, f uintptr, mode int32) (r int32) { __need_unlock = v1 if mode != 0 { if !((*TFILE)(unsafe.Pointer(f)).Flocale != 0) { - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v3 = int32(4) } else { v3 = int32(1) @@ -138840,7 +138840,7 @@ func X__fwritex(tls *TLS, s uintptr, l Tsize_t, f uintptr) (r Tsize_t) { /* Match /^(.*\n|)/ */ i = l for { - if !(i != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(i-uint32(1))))) != int32('\n')) { + if !(i != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(i-uint32(1))))) != int32('\n')) { break } goto _1 @@ -138858,7 +138858,7 @@ func X__fwritex(tls *TLS, s uintptr, l Tsize_t, f uintptr) (r Tsize_t) { } } _memcpy(tls, (*TFILE)(unsafe.Pointer(f)).Fwpos, s, l) - *(*uintptr)(unsafe.Pointer(f + 20)) += uintptr(l) + **(**uintptr)(__ccgo_up(f + 20)) += uintptr(l) return l + i } @@ -138943,7 +138943,7 @@ _3: v5 = f + 4 v1 = *(*uintptr)(unsafe.Pointer(v5)) *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v1))) } else { v2 = X__uflow(tls, f) } @@ -138987,7 +138987,7 @@ func Xgetc(tls *TLS, f1 uintptr) (r int32) { v6 = v1 + 4 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(v5))) } else { v4 = X__uflow(tls, v1) } @@ -139020,7 +139020,7 @@ func Xgetc_unlocked(tls *TLS, f uintptr) (r int32) { v3 = f + 4 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__uflow(tls, f) } @@ -139063,7 +139063,7 @@ _3: v5 = f + 4 v1 = *(*uintptr)(unsafe.Pointer(v5)) *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v1))) } else { v2 = X__uflow(tls, f) } @@ -139107,7 +139107,7 @@ func Xgetchar(tls *TLS) (r int32) { v6 = v1 + 4 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(v5))) } else { v4 = X__uflow(tls, v1) } @@ -139132,7 +139132,7 @@ func Xgetchar_unlocked(tls *TLS) (r int32) { v3 = uintptr(unsafe.Pointer(&X__stdin_FILE)) + 4 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__uflow(tls, uintptr(unsafe.Pointer(&X__stdin_FILE))) } @@ -139157,16 +139157,16 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize } __need_unlock = v1 if !(n != 0) || !(s != 0) { - *(*int32)(unsafe.Pointer(f + 72)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**int32)(__ccgo_up(f + 72)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) if __need_unlock != 0 { ___unlockfile(tls, f) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } - if !(*(*uintptr)(unsafe.Pointer(s)) != 0) { - *(*Tsize_t)(unsafe.Pointer(n)) = uint32(0) + if !(**(**uintptr)(__ccgo_up(s)) != 0) { + **(**Tsize_t)(__ccgo_up(n)) = uint32(0) } for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { @@ -139181,36 +139181,36 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize z = uintptr(0) k = uint32(0) } - if i+k >= *(*Tsize_t)(unsafe.Pointer(n)) { + if i+k >= **(**Tsize_t)(__ccgo_up(n)) { m = i + k + uint32(2) if !(z != 0) && m < Uint32FromUint32(0xffffffff)/Uint32FromInt32(4) { m = m + m/uint32(2) } - tmp = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(s)), m) + tmp = Xrealloc(tls, **(**uintptr)(__ccgo_up(s)), m) if !(tmp != 0) { m = i + k + uint32(2) - tmp = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(s)), m) + tmp = Xrealloc(tls, **(**uintptr)(__ccgo_up(s)), m) if !(tmp != 0) { /* Copy as much as fits and ensure no * pushback remains in the FILE buf. */ - k = *(*Tsize_t)(unsafe.Pointer(n)) - i - _memcpy(tls, *(*uintptr)(unsafe.Pointer(s))+uintptr(i), (*TFILE)(unsafe.Pointer(f)).Frpos, k) - *(*uintptr)(unsafe.Pointer(f + 4)) += uintptr(k) - *(*int32)(unsafe.Pointer(f + 72)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + k = **(**Tsize_t)(__ccgo_up(n)) - i + _memcpy(tls, **(**uintptr)(__ccgo_up(s))+uintptr(i), (*TFILE)(unsafe.Pointer(f)).Frpos, k) + **(**uintptr)(__ccgo_up(f + 4)) += uintptr(k) + **(**int32)(__ccgo_up(f + 72)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) if __need_unlock != 0 { ___unlockfile(tls, f) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return -int32(1) } } - *(*uintptr)(unsafe.Pointer(s)) = tmp - *(*Tsize_t)(unsafe.Pointer(n)) = m + **(**uintptr)(__ccgo_up(s)) = tmp + **(**Tsize_t)(__ccgo_up(n)) = m } if k != 0 { - _memcpy(tls, *(*uintptr)(unsafe.Pointer(s))+uintptr(i), (*TFILE)(unsafe.Pointer(f)).Frpos, k) - *(*uintptr)(unsafe.Pointer(f + 4)) += uintptr(k) + _memcpy(tls, **(**uintptr)(__ccgo_up(s))+uintptr(i), (*TFILE)(unsafe.Pointer(f)).Frpos, k) + **(**uintptr)(__ccgo_up(f + 4)) += uintptr(k) i = i + k } if z != 0 { @@ -139220,7 +139220,7 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize v7 = f + 4 v6 = *(*uintptr)(unsafe.Pointer(v7)) *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v6))) } else { v3 = X__uflow(tls, f) } @@ -139237,16 +139237,16 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize } /* If the byte read by getc won't fit without growing the * output buffer, push it back for next iteration. */ - if i+uint32(1) >= *(*Tsize_t)(unsafe.Pointer(n)) { + if i+uint32(1) >= **(**Tsize_t)(__ccgo_up(n)) { v7 = f + 4 *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) - 1 v6 = *(*uintptr)(unsafe.Pointer(v7)) - *(*uint8)(unsafe.Pointer(v6)) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(v6)) = Uint8FromInt32(c) } else { v10 = Uint8FromInt32(c) v11 = i i = i + 1 - *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)) + uintptr(v11))) = v10 + **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)) + uintptr(v11))) = v10 if Int32FromUint8(v10) == delim { break } @@ -139254,7 +139254,7 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize goto _2 _2: } - *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)) + uintptr(i))) = uint8(0) + **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)) + uintptr(i))) = uint8(0) if __need_unlock != 0 { ___unlockfile(tls, f) } @@ -139298,7 +139298,7 @@ func Xgets(tls *TLS, s uintptr) (r uintptr) { v5 = uintptr(unsafe.Pointer(&X__stdin_FILE)) + 4 v4 = *(*uintptr)(unsafe.Pointer(v5)) *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v4))) } else { v3 = X__uflow(tls, uintptr(unsafe.Pointer(&X__stdin_FILE))) } @@ -139309,9 +139309,9 @@ func Xgets(tls *TLS, s uintptr) (r uintptr) { } v6 = i i = i + 1 - *(*uint8)(unsafe.Pointer(s + uintptr(v6))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + uintptr(v6))) = Uint8FromInt32(c) } - *(*uint8)(unsafe.Pointer(s + uintptr(i))) = uint8(0) + **(**uint8)(__ccgo_up(s + uintptr(i))) = uint8(0) if c != int32('\n') && (!((*TFILE)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stdin_FILE)))).Fflags&Uint32FromInt32(F_EOF) != 0) || !(i != 0)) { s = uintptr(0) } @@ -139332,7 +139332,7 @@ func Xgetw(tls *TLS, f uintptr) (r int32) { var _ /* x at bp+0 */ int32 _ = v1 if Xfread(tls, bp, uint32(4), uint32(1), f) != 0 { - v1 = *(*int32)(unsafe.Pointer(bp)) + v1 = **(**int32)(__ccgo_up(bp)) } else { v1 = -int32(1) } @@ -139390,11 +139390,11 @@ func X__ofl_add(tls *TLS, f uintptr) (r uintptr) { var head uintptr _ = head head = X__ofl_lock(tls) - (*TFILE)(unsafe.Pointer(f)).Fnext = *(*uintptr)(unsafe.Pointer(head)) - if *(*uintptr)(unsafe.Pointer(head)) != 0 { - (*TFILE)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(head)))).Fprev = f + (*TFILE)(unsafe.Pointer(f)).Fnext = **(**uintptr)(__ccgo_up(head)) + if **(**uintptr)(__ccgo_up(head)) != 0 { + (*TFILE)(unsafe.Pointer(**(**uintptr)(__ccgo_up(head)))).Fprev = f } - *(*uintptr)(unsafe.Pointer(head)) = f + **(**uintptr)(__ccgo_up(head)) = f X__ofl_unlock(tls) return f } @@ -139429,7 +139429,7 @@ func _ms_seek(tls *TLS, f uintptr, off Toff_t, whence int32) (r Toff_t) { goto fail fail: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) _1: ; @@ -139437,7 +139437,7 @@ _1: 1: (*Tcookie1)(unsafe.Pointer(c)).Fpos, 2: (*Tcookie1)(unsafe.Pointer(c)).Flen1, } - base = Int32FromUint32(*(*Tsize_t)(unsafe.Pointer(bp + uintptr(whence)*4))) + base = Int32FromUint32(**(**Tsize_t)(__ccgo_up(bp + uintptr(whence)*4))) if off < int64(-base) || off > int64(int32(0x7fffffff)-base) { goto fail } @@ -139466,16 +139466,16 @@ func _ms_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { } v1 = newbuf (*Tcookie1)(unsafe.Pointer(c)).Fbuf = v1 - *(*uintptr)(unsafe.Pointer((*Tcookie1)(unsafe.Pointer(c)).Fbufp)) = v1 + **(**uintptr)(__ccgo_up((*Tcookie1)(unsafe.Pointer(c)).Fbufp)) = v1 Xmemset(tls, (*Tcookie1)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie1)(unsafe.Pointer(c)).Fspace), 0, len2-(*Tcookie1)(unsafe.Pointer(c)).Fspace) (*Tcookie1)(unsafe.Pointer(c)).Fspace = len2 } _memcpy(tls, (*Tcookie1)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie1)(unsafe.Pointer(c)).Fpos), buf, len1) - *(*Tsize_t)(unsafe.Pointer(c + 8)) += len1 + **(**Tsize_t)(__ccgo_up(c + 8)) += len1 if (*Tcookie1)(unsafe.Pointer(c)).Fpos >= (*Tcookie1)(unsafe.Pointer(c)).Flen1 { (*Tcookie1)(unsafe.Pointer(c)).Flen1 = (*Tcookie1)(unsafe.Pointer(c)).Fpos } - *(*Tsize_t)(unsafe.Pointer((*Tcookie1)(unsafe.Pointer(c)).Fsizep)) = (*Tcookie1)(unsafe.Pointer(c)).Fpos + **(**Tsize_t)(__ccgo_up((*Tcookie1)(unsafe.Pointer(c)).Fsizep)) = (*Tcookie1)(unsafe.Pointer(c)).Fpos return len1 } @@ -139508,16 +139508,16 @@ func Xopen_memstream(tls *TLS, bufp uintptr, sizep uintptr) (r uintptr) { (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fbufp = bufp (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fsizep = sizep v5 = Uint32FromInt32(0) - *(*Tsize_t)(unsafe.Pointer(sizep)) = v5 + **(**Tsize_t)(__ccgo_up(sizep)) = v5 v4 = v5 (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fspace = v4 v3 = v4 (*Tms_FILE)(unsafe.Pointer(f)).Fc.Flen1 = v3 (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fpos = v3 v1 = buf - *(*uintptr)(unsafe.Pointer(bufp)) = v1 + **(**uintptr)(__ccgo_up(bufp)) = v1 (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fbuf = v1 - *(*uint8)(unsafe.Pointer(buf)) = uint8(0) + **(**uint8)(__ccgo_up(buf)) = uint8(0) (*Tms_FILE)(unsafe.Pointer(f)).Ff.Fflags = uint32(F_NORD) (*Tms_FILE)(unsafe.Pointer(f)).Ff.Ffd = -int32(1) (*Tms_FILE)(unsafe.Pointer(f)).Ff.Fbuf = f + 168 @@ -139565,7 +139565,7 @@ func _wms_seek(tls *TLS, f uintptr, off Toff_t, whence int32) (r Toff_t) { goto fail fail: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) _1: ; @@ -139573,7 +139573,7 @@ _1: 1: (*Tcookie2)(unsafe.Pointer(c)).Fpos, 2: (*Tcookie2)(unsafe.Pointer(c)).Flen1, } - base = Int32FromUint32(*(*Tsize_t)(unsafe.Pointer(bp + uintptr(whence)*4))) + base = Int32FromUint32(**(**Tsize_t)(__ccgo_up(bp + uintptr(whence)*4))) if off < int64(-base) || off > int64(Int32FromInt32(0x7fffffff)/Int32FromInt32(4)-base) { goto fail } @@ -139609,7 +139609,7 @@ func _wms_write(tls *TLS, f uintptr, _buf uintptr, len1 Tsize_t) (r Tsize_t) { } v1 = newbuf (*Tcookie2)(unsafe.Pointer(c)).Fbuf = v1 - *(*uintptr)(unsafe.Pointer((*Tcookie2)(unsafe.Pointer(c)).Fbufp)) = v1 + **(**uintptr)(__ccgo_up((*Tcookie2)(unsafe.Pointer(c)).Fbufp)) = v1 Xmemset(tls, (*Tcookie2)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie2)(unsafe.Pointer(c)).Fspace)*4, 0, uint32(4)*(len2-(*Tcookie2)(unsafe.Pointer(c)).Fspace)) (*Tcookie2)(unsafe.Pointer(c)).Fspace = len2 } @@ -139617,11 +139617,11 @@ func _wms_write(tls *TLS, f uintptr, _buf uintptr, len1 Tsize_t) (r Tsize_t) { if len2 == Uint32FromInt32(-Int32FromInt32(1)) { return uint32(0) } - *(*Tsize_t)(unsafe.Pointer(c + 8)) += len2 + **(**Tsize_t)(__ccgo_up(c + 8)) += len2 if (*Tcookie2)(unsafe.Pointer(c)).Fpos >= (*Tcookie2)(unsafe.Pointer(c)).Flen1 { (*Tcookie2)(unsafe.Pointer(c)).Flen1 = (*Tcookie2)(unsafe.Pointer(c)).Fpos } - *(*Tsize_t)(unsafe.Pointer((*Tcookie2)(unsafe.Pointer(c)).Fsizep)) = (*Tcookie2)(unsafe.Pointer(c)).Fpos + **(**Tsize_t)(__ccgo_up((*Tcookie2)(unsafe.Pointer(c)).Fsizep)) = (*Tcookie2)(unsafe.Pointer(c)).Fpos return len1 } @@ -139654,16 +139654,16 @@ func Xopen_wmemstream(tls *TLS, bufp uintptr, sizep uintptr) (r uintptr) { (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fbufp = bufp (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fsizep = sizep v5 = Uint32FromInt32(0) - *(*Tsize_t)(unsafe.Pointer(sizep)) = v5 + **(**Tsize_t)(__ccgo_up(sizep)) = v5 v4 = v5 (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fspace = v4 v3 = v4 (*Twms_FILE)(unsafe.Pointer(f)).Fc.Flen1 = v3 (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fpos = v3 v1 = buf - *(*uintptr)(unsafe.Pointer(bufp)) = v1 + **(**uintptr)(__ccgo_up(bufp)) = v1 (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fbuf = v1 - *(*Twchar_t)(unsafe.Pointer(buf)) = uint32(0) + **(**Twchar_t)(__ccgo_up(buf)) = uint32(0) (*Twms_FILE)(unsafe.Pointer(f)).Ff.Fflags = uint32(F_NORD) (*Twms_FILE)(unsafe.Pointer(f)).Ff.Ffd = -int32(1) (*Twms_FILE)(unsafe.Pointer(f)).Ff.Fbuf = f + 176 @@ -139702,7 +139702,7 @@ func Xpclose(tls *TLS, f uintptr) (r1 int32) { if r < 0 { return X__syscall_ret(tls, Uint32FromInt32(r)) } - return *(*int32)(unsafe.Pointer(bp)) + return **(**int32)(__ccgo_up(bp)) } func Xperror(tls *TLS, msg uintptr) { @@ -139713,7 +139713,7 @@ func Xperror(tls *TLS, msg uintptr) { var errstr, f, old_locale uintptr _, _, _, _, _, _ = __need_unlock, errstr, f, old_locale, old_mode, v1 f = uintptr(unsafe.Pointer(&X__stderr_FILE)) - errstr = Xstrerror(tls, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) + errstr = Xstrerror(tls, **(**int32)(__ccgo_up(X__errno_location(tls)))) if AtomicLoadPInt32(f+76) >= 0 { v1 = ___lockfile(tls, f) } else { @@ -139724,7 +139724,7 @@ func Xperror(tls *TLS, msg uintptr) { * permitted to change them. */ old_locale = (*TFILE)(unsafe.Pointer(f)).Flocale old_mode = (*TFILE)(unsafe.Pointer(f)).Fmode - if msg != 0 && *(*uint8)(unsafe.Pointer(msg)) != 0 { + if msg != 0 && **(**uint8)(__ccgo_up(msg)) != 0 { Xfwrite(tls, msg, _strlen(tls, msg), uint32(1), f) Xfputc(tls, int32(':'), f) Xfputc(tls, int32(' '), f) @@ -139774,7 +139774,7 @@ _3: v6 = f + 20 v1 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - *(*uint8)(unsafe.Pointer(v1)) = v5 + **(**uint8)(__ccgo_up(v1)) = v5 v2 = Int32FromUint8(v5) } else { v2 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) @@ -139822,7 +139822,7 @@ func Xputc(tls *TLS, c1 int32, f1 uintptr) (r int32) { v8 = v2 + 20 v7 = *(*uintptr)(unsafe.Pointer(v8)) *(*uintptr)(unsafe.Pointer(v8)) = *(*uintptr)(unsafe.Pointer(v8)) + 1 - *(*uint8)(unsafe.Pointer(v7)) = v6 + **(**uint8)(__ccgo_up(v7)) = v6 v5 = Int32FromUint8(v6) } else { v5 = X__overflow(tls, v2, Int32FromUint8(Uint8FromInt32(v1))) @@ -139858,7 +139858,7 @@ func Xputc_unlocked(tls *TLS, c int32, f uintptr) (r int32) { v4 = f + 20 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(v3)) = v2 + **(**uint8)(__ccgo_up(v3)) = v2 v1 = Int32FromUint8(v2) } else { v1 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) @@ -139904,7 +139904,7 @@ _3: v6 = f + 20 v1 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - *(*uint8)(unsafe.Pointer(v1)) = v5 + **(**uint8)(__ccgo_up(v1)) = v5 v2 = Int32FromUint8(v5) } else { v2 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) @@ -139952,7 +139952,7 @@ func Xputchar(tls *TLS, c1 int32) (r int32) { v8 = v2 + 20 v7 = *(*uintptr)(unsafe.Pointer(v8)) *(*uintptr)(unsafe.Pointer(v8)) = *(*uintptr)(unsafe.Pointer(v8)) + 1 - *(*uint8)(unsafe.Pointer(v7)) = v6 + **(**uint8)(__ccgo_up(v7)) = v6 v5 = Int32FromUint8(v6) } else { v5 = X__overflow(tls, v2, Int32FromUint8(Uint8FromInt32(v1))) @@ -139980,7 +139980,7 @@ func Xputchar_unlocked(tls *TLS, c int32) (r int32) { v4 = uintptr(unsafe.Pointer(&X__stdout_FILE)) + 20 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(v3)) = v2 + **(**uint8)(__ccgo_up(v3)) = v2 v1 = Int32FromUint8(v2) } else { v1 = X__overflow(tls, uintptr(unsafe.Pointer(&X__stdout_FILE)), Int32FromUint8(Uint8FromInt32(c))) @@ -140010,7 +140010,7 @@ func Xputs(tls *TLS, s uintptr) (r1 int32) { v5 = uintptr(unsafe.Pointer(&X__stdout_FILE)) + 20 v4 = *(*uintptr)(unsafe.Pointer(v5)) *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = v3 + **(**uint8)(__ccgo_up(v4)) = v3 v2 = Int32FromUint8(v3) } else { v2 = X__overflow(tls, uintptr(unsafe.Pointer(&X__stdout_FILE)), Int32FromUint8(Uint8FromInt32(Int32FromUint8('\n')))) @@ -140093,7 +140093,7 @@ func Xrewind(tls *TLS, f uintptr) { } __need_unlock = v1 X__fseeko_unlocked(tls, f, 0, 0) - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_ERR)) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^Int32FromInt32(F_ERR)) if __need_unlock != 0 { ___unlockfile(tls, f) } @@ -140183,7 +140183,7 @@ func Xsetvbuf(tls *TLS, f uintptr, buf uintptr, type1 int32, size Tsize_t) (r in return -int32(1) } } - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_SVB) + **(**uint32)(__ccgo_up(f)) |= uint32(F_SVB) return 0 } @@ -140323,14 +140323,14 @@ func Xtempnam(tls *TLS, dir uintptr, pfx uintptr) (r1 uintptr) { pl = _strlen(tls, pfx) l = dl + uint32(1) + pl + uint32(1) + uint32(6) if l >= uint32(PATH_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENAMETOOLONG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENAMETOOLONG) return uintptr(0) } _memcpy(tls, bp+1, dir, dl) - (*(*[4096]uint8)(unsafe.Pointer(bp + 1)))[dl] = uint8('/') + (**(**[4096]uint8)(__ccgo_up(bp + 1)))[dl] = uint8('/') _memcpy(tls, bp+1+uintptr(dl)+uintptr(1), pfx, pl) - (*(*[4096]uint8)(unsafe.Pointer(bp + 1)))[dl+uint32(1)+pl] = uint8('_') - (*(*[4096]uint8)(unsafe.Pointer(bp + 1)))[l] = uint8(0) + (**(**[4096]uint8)(__ccgo_up(bp + 1)))[dl+uint32(1)+pl] = uint8('_') + (**(**[4096]uint8)(__ccgo_up(bp + 1)))[l] = uint8(0) try = 0 for { if !(try < int32(MAXTRIES)) { @@ -140361,7 +140361,7 @@ func Xtmpfile(tls *TLS) (r uintptr) { var fd, try int32 var _ /* s at bp+0 */ [20]uint8 _, _, _ = f, fd, try - *(*[20]uint8)(unsafe.Pointer(bp)) = [20]uint8{'/', 't', 'm', 'p', '/', 't', 'm', 'p', 'f', 'i', 'l', 'e', '_', 'X', 'X', 'X', 'X', 'X', 'X'} + **(**[20]uint8)(__ccgo_up(bp)) = [20]uint8{'/', 't', 'm', 'p', '/', 't', 'm', 'p', 'f', 'i', 'l', 'e', '_', 'X', 'X', 'X', 'X', 'X', 'X'} try = 0 for { if !(try < int32(MAXTRIES)) { @@ -140396,7 +140396,7 @@ func Xtmpnam(tls *TLS, buf uintptr) (r1 uintptr) { var v2 uintptr var _ /* s at bp+1 */ [19]uint8 _, _, _ = r, try, v2 - *(*[19]uint8)(unsafe.Pointer(bp + 1)) = [19]uint8{'/', 't', 'm', 'p', '/', 't', 'm', 'p', 'n', 'a', 'm', '_', 'X', 'X', 'X', 'X', 'X', 'X'} + **(**[19]uint8)(__ccgo_up(bp + 1)) = [19]uint8{'/', 't', 'm', 'p', '/', 't', 'm', 'p', 'n', 'a', 'm', '_', 'X', 'X', 'X', 'X', 'X', 'X'} try = 0 for { if !(try < int32(MAXTRIES)) { @@ -140452,8 +140452,8 @@ func Xungetc(tls *TLS, c int32, f uintptr) (r int32) { v3 = f + 4 *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) - 1 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(c) - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) + **(**uint8)(__ccgo_up(v2)) = Uint8FromInt32(c) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) if __need_unlock != 0 { ___unlockfile(tls, f) } @@ -140474,7 +140474,7 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { var _ /* mbc at bp+0 */ [4]uint8 _, _, _, _, _, _, _, _ = __need_unlock, l, loc, ploc, v1, v3, v4, v5 ploc = uintptr(___get_tp(tls)) + 88 - loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) + loc = **(**Tlocale_t)(__ccgo_up(ploc)) if AtomicLoadPInt32(f+76) >= 0 { v1 = ___lockfile(tls, f) } else { @@ -140484,7 +140484,7 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { if (*TFILE)(unsafe.Pointer(f)).Fmode <= 0 { Xfwide(tls, f, int32(1)) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale + **(**Tlocale_t)(__ccgo_up(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale if !((*TFILE)(unsafe.Pointer(f)).Frpos != 0) { X__toread(tls, f) } @@ -140496,24 +140496,24 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { if __need_unlock != 0 { ___unlockfile(tls, f) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return uint32(0xffffffff) } if BoolInt32(c < uint32(128)) != 0 { v5 = f + 4 *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) - 1 v4 = *(*uintptr)(unsafe.Pointer(v5)) - *(*uint8)(unsafe.Pointer(v4)) = uint8(c) + **(**uint8)(__ccgo_up(v4)) = uint8(c) } else { v4 = f + 4 *(*uintptr)(unsafe.Pointer(v4)) -= uintptr(l) _memcpy(tls, *(*uintptr)(unsafe.Pointer(v4)), bp, Uint32FromInt32(l)) } - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) if __need_unlock != 0 { ___unlockfile(tls, f) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return c } @@ -140532,12 +140532,12 @@ func Xvasprintf(tls *TLS, s uintptr, fmt uintptr, ap Tva_list) (r int32) { _ = ap2 if v2 = l < 0; !v2 { v1 = Xmalloc(tls, Uint32FromInt32(l)+uint32(1)) - *(*uintptr)(unsafe.Pointer(s)) = v1 + **(**uintptr)(__ccgo_up(s)) = v1 } if v2 || !(v1 != 0) { return -int32(1) } - return Xvsnprintf(tls, *(*uintptr)(unsafe.Pointer(s)), Uint32FromInt32(l)+uint32(1), fmt, ap) + return Xvsnprintf(tls, **(**uintptr)(__ccgo_up(s)), Uint32FromInt32(l)+uint32(1), fmt, ap) } func Xvdprintf(tls *TLS, fd int32, fmt uintptr, ap Tva_list) (r int32) { @@ -140548,7 +140548,7 @@ func Xvdprintf(tls *TLS, fd int32, fmt uintptr, ap Tva_list) (r int32) { bp := tls.Alloc(144) defer tls.Free(144) var _ /* f at bp+0 */ TFILE - *(*TFILE)(unsafe.Pointer(bp)) = TFILE{ + **(**TFILE)(__ccgo_up(bp)) = TFILE{ Fwrite: __ccgo_fp(X__stdio_write), Fbuf: fmt, Ffd: fd, @@ -140716,41 +140716,41 @@ type Targ = struct { func _pop_arg(tls *TLS, arg uintptr, type1 int32, ap uintptr) { switch type1 { case int32(_PTR): - *(*uintptr)(unsafe.Pointer(arg)) = VaUintptr(&*(*Tva_list)(unsafe.Pointer(ap))) + *(*uintptr)(unsafe.Pointer(arg)) = VaUintptr(&**(**Tva_list)(__ccgo_up(ap))) case int32(_INT): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_UINT): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint32(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint32(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_LONG): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_ULONG): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint32(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint32(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_ULLONG): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&**(**Tva_list)(__ccgo_up(ap))) case int32(_SHORT): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt16(int16(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt16(int16(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_USHORT): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint16FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint16FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_CHAR): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt8(int8(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt8(int8(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_UCHAR): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint8FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint8FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_LLONG): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_SIZET): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint32(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint32(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_IMAX): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_UMAX): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&**(**Tva_list)(__ccgo_up(ap))) case int32(_PDIFF): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_UIPTR): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(uint32(VaUintptr(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(uint32(VaUintptr(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_DBL): - *(*float64)(unsafe.Pointer(arg)) = float64(VaFloat64(&*(*Tva_list)(unsafe.Pointer(ap)))) + *(*float64)(unsafe.Pointer(arg)) = float64(VaFloat64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_LDBL): - *(*float64)(unsafe.Pointer(arg)) = VaFloat64(&*(*Tva_list)(unsafe.Pointer(ap))) + *(*float64)(unsafe.Pointer(arg)) = VaFloat64(&**(**Tva_list)(__ccgo_up(ap))) } } @@ -140800,7 +140800,7 @@ func _fmt_x(tls *TLS, x Tuintmax_t, s uintptr, lower int32) (r uintptr) { } s = s - 1 v2 = s - *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(Int32FromUint8(_xdigits1[x&uint64(15)]) | lower) + **(**uint8)(__ccgo_up(v2)) = Uint8FromInt32(Int32FromUint8(_xdigits1[x&uint64(15)]) | lower) goto _1 _1: ; @@ -140818,7 +140818,7 @@ func _fmt_o(tls *TLS, x Tuintmax_t, s uintptr) (r uintptr) { } s = s - 1 v2 = s - *(*uint8)(unsafe.Pointer(v2)) = uint8(uint64('0') + x&uint64(7)) + **(**uint8)(__ccgo_up(v2)) = uint8(uint64('0') + x&uint64(7)) goto _1 _1: ; @@ -140837,7 +140837,7 @@ func _fmt_u(tls *TLS, x Tuintmax_t, s uintptr) (r uintptr) { } s = s - 1 v2 = s - *(*uint8)(unsafe.Pointer(v2)) = uint8(uint64('0') + x%uint64(10)) + **(**uint8)(__ccgo_up(v2)) = uint8(uint64('0') + x%uint64(10)) goto _1 _1: ; @@ -140850,7 +140850,7 @@ func _fmt_u(tls *TLS, x Tuintmax_t, s uintptr) (r uintptr) { } s = s - 1 v2 = s - *(*uint8)(unsafe.Pointer(v2)) = uint8(uint32('0') + y%uint32(10)) + **(**uint8)(__ccgo_up(v2)) = uint8(uint32('0') + y%uint32(10)) goto _3 _3: ; @@ -140885,7 +140885,7 @@ func _fmt_fp(tls *TLS, f uintptr, y float64, w int32, p int32, fl int32, t int32 var _ /* e2 at bp+512 */ int32 var _ /* ebuf0 at bp+538 */ [12]uint8 _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, b, carry, carry1, d, e, ebuf, estr, i, j, l, need, pl, prefix, r, re, rm, round, round1, s, s1, s2, s3, s4, sh, sh1, small, x, x1, x2, z, v1, v5, v6, v7, v8, v9 - *(*int32)(unsafe.Pointer(bp + 512)) = 0 + **(**int32)(__ccgo_up(bp + 512)) = 0 prefix = __ccgo_ts + 1419 ebuf = bp + 538 + uintptr(Uint32FromInt32(3)*Uint32FromInt64(4)) pl = int32(1) @@ -140939,7 +140939,7 @@ _4: } y = float64(Xfrexpl(tls, y, bp+512) * Float64FromInt32(2)) if y != 0 { - *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) - 1 + **(**int32)(__ccgo_up(bp + 512)) = **(**int32)(__ccgo_up(bp + 512)) - 1 } if t|int32(32) == int32('a') { round = Float64FromFloat64(8) @@ -140962,7 +140962,7 @@ _4: } round = round * Float64FromInt32(16) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(prefix))) == int32('-') { + if Int32FromUint8(**(**uint8)(__ccgo_up(prefix))) == int32('-') { y = -y y = y - round y = y + round @@ -140972,39 +140972,39 @@ _4: y = y - round } } - if *(*int32)(unsafe.Pointer(bp + 512)) < 0 { - v7 = -*(*int32)(unsafe.Pointer(bp + 512)) + if **(**int32)(__ccgo_up(bp + 512)) < 0 { + v7 = -**(**int32)(__ccgo_up(bp + 512)) } else { - v7 = *(*int32)(unsafe.Pointer(bp + 512)) + v7 = **(**int32)(__ccgo_up(bp + 512)) } estr = _fmt_u(tls, Uint64FromInt32(v7), ebuf) if estr == ebuf { estr = estr - 1 v5 = estr - *(*uint8)(unsafe.Pointer(v5)) = uint8('0') + **(**uint8)(__ccgo_up(v5)) = uint8('0') } estr = estr - 1 v5 = estr - if *(*int32)(unsafe.Pointer(bp + 512)) < 0 { + if **(**int32)(__ccgo_up(bp + 512)) < 0 { v7 = int32('-') } else { v7 = int32('+') } - *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(v7) + **(**uint8)(__ccgo_up(v5)) = Uint8FromInt32(v7) estr = estr - 1 v5 = estr - *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(t + (Int32FromUint8('p') - Int32FromUint8('a'))) + **(**uint8)(__ccgo_up(v5)) = Uint8FromInt32(t + (Int32FromUint8('p') - Int32FromUint8('a'))) s = bp + 516 for cond := true; cond; cond = y != 0 { x = int32(y) v5 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(Int32FromUint8(_xdigits1[x]) | t&int32(32)) + **(**uint8)(__ccgo_up(v5)) = Uint8FromInt32(Int32FromUint8(_xdigits1[x]) | t&int32(32)) y = float64(Float64FromInt32(16) * (y - float64(x))) if int32(s)-t__predefined_ptrdiff_t(bp+516) == int32(1) && (y != 0 || p > 0 || Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0) { v5 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v5)) = uint8('.') + **(**uint8)(__ccgo_up(v5)) = uint8('.') } } if p > Int32FromInt32(INT_MAX)-Int32FromInt32(2)-(int32(ebuf)-int32(estr))-pl { @@ -141034,9 +141034,9 @@ _4: } if y != 0 { y = y * Float64FromFloat64(2.68435456e+08) - *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) - int32(28) + **(**int32)(__ccgo_up(bp + 512)) = **(**int32)(__ccgo_up(bp + 512)) - int32(28) } - if *(*int32)(unsafe.Pointer(bp + 512)) < 0 { + if **(**int32)(__ccgo_up(bp + 512)) < 0 { v6 = bp + 8 z = v6 v5 = v6 @@ -141050,17 +141050,17 @@ _4: a = v5 } for cond := true; cond; cond = y != 0 { - *(*Tuint32_t)(unsafe.Pointer(z)) = uint32(y) + **(**Tuint32_t)(__ccgo_up(z)) = uint32(y) v5 = z z += 4 - y = float64(Float64FromInt32(1000000000) * (y - float64(*(*Tuint32_t)(unsafe.Pointer(v5))))) + y = float64(Float64FromInt32(1000000000) * (y - float64(**(**Tuint32_t)(__ccgo_up(v5))))) } - for *(*int32)(unsafe.Pointer(bp + 512)) > 0 { + for **(**int32)(__ccgo_up(bp + 512)) > 0 { carry = uint32(0) - if int32(29) < *(*int32)(unsafe.Pointer(bp + 512)) { + if int32(29) < **(**int32)(__ccgo_up(bp + 512)) { v7 = int32(29) } else { - v7 = *(*int32)(unsafe.Pointer(bp + 512)) + v7 = **(**int32)(__ccgo_up(bp + 512)) } sh = v7 d = z - uintptr(1)*4 @@ -141068,8 +141068,8 @@ _4: if !(d >= a) { break } - x1 = uint64(*(*Tuint32_t)(unsafe.Pointer(d)))< a && !(*(*Tuint32_t)(unsafe.Pointer(z + uintptr(-Int32FromInt32(1))*4)) != 0) { + for z > a && !(**(**Tuint32_t)(__ccgo_up(z + uintptr(-Int32FromInt32(1))*4)) != 0) { z -= 4 } - *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) - sh + **(**int32)(__ccgo_up(bp + 512)) = **(**int32)(__ccgo_up(bp + 512)) - sh } - for *(*int32)(unsafe.Pointer(bp + 512)) < 0 { + for **(**int32)(__ccgo_up(bp + 512)) < 0 { carry1 = uint32(0) - if int32(9) < -*(*int32)(unsafe.Pointer(bp + 512)) { + if int32(9) < -**(**int32)(__ccgo_up(bp + 512)) { v7 = int32(9) } else { - v7 = -*(*int32)(unsafe.Pointer(bp + 512)) + v7 = -**(**int32)(__ccgo_up(bp + 512)) } sh1 = v7 need = Int32FromUint32(uint32(1) + (Uint32FromInt32(p)+Uint32FromInt32(LDBL_MANT_DIG)/Uint32FromUint32(3)+uint32(8))/uint32(9)) @@ -141100,21 +141100,21 @@ _4: if !(d < z) { break } - rm = *(*Tuint32_t)(unsafe.Pointer(d)) & Uint32FromInt32(int32(1)<>sh1 + carry1 + rm = **(**Tuint32_t)(__ccgo_up(d)) & Uint32FromInt32(int32(1)<>sh1 + carry1 carry1 = Uint32FromInt32(Int32FromInt32(1000000000)>>sh1) * rm goto _26 _26: ; d += 4 } - if !(*(*Tuint32_t)(unsafe.Pointer(a)) != 0) { + if !(**(**Tuint32_t)(__ccgo_up(a)) != 0) { a += 4 } if carry1 != 0 { v5 = z z += 4 - *(*Tuint32_t)(unsafe.Pointer(v5)) = carry1 + **(**Tuint32_t)(__ccgo_up(v5)) = carry1 } /* Avoid (slow!) computation past requested precision */ if t|int32(32) == int32('f') { @@ -141126,13 +141126,13 @@ _4: if (int32(z)-int32(b))/4 > need { z = b + uintptr(need)*4 } - *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) + sh1 + **(**int32)(__ccgo_up(bp + 512)) = **(**int32)(__ccgo_up(bp + 512)) + sh1 } if a < z { i = int32(10) e = Int32FromInt32(9) * ((int32(r) - int32(a)) / 4) for { - if !(*(*Tuint32_t)(unsafe.Pointer(a)) >= Uint32FromInt32(i)) { + if !(**(**Tuint32_t)(__ccgo_up(a)) >= Uint32FromInt32(i)) { break } goto _29 @@ -141163,11 +141163,11 @@ _4: i = i * int32(10) j = j + 1 } - x2 = *(*Tuint32_t)(unsafe.Pointer(d)) % Uint32FromInt32(i) + x2 = **(**Tuint32_t)(__ccgo_up(d)) % Uint32FromInt32(i) /* Are there any significant digits past j? */ if x2 != 0 || d+uintptr(1)*4 != z { round1 = Float64FromInt32(2) / Float64FromFloat64(2.22044604925031308085e-16) - if *(*Tuint32_t)(unsafe.Pointer(d))/Uint32FromInt32(i)&uint32(1) != 0 || i == int32(1000000000) && d > a && *(*Tuint32_t)(unsafe.Pointer(d + uintptr(-Int32FromInt32(1))*4))&uint32(1) != 0 { + if **(**Tuint32_t)(__ccgo_up(d))/Uint32FromInt32(i)&uint32(1) != 0 || i == int32(1000000000) && d > a && **(**Tuint32_t)(__ccgo_up(d + uintptr(-Int32FromInt32(1))*4))&uint32(1) != 0 { round1 = round1 + Float64FromInt32(2) } if x2 < Uint32FromInt32(i/int32(2)) { @@ -141179,29 +141179,29 @@ _4: small = Float64FromFloat64(1.5) } } - if pl != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(prefix))) == int32('-') { + if pl != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(prefix))) == int32('-') { round1 = round1 * float64(-Int32FromInt32(1)) small = small * float64(-Int32FromInt32(1)) } - *(*Tuint32_t)(unsafe.Pointer(d)) -= x2 + **(**Tuint32_t)(__ccgo_up(d)) -= x2 /* Decide whether to round by probing round+small */ if round1+small != round1 { - *(*Tuint32_t)(unsafe.Pointer(d)) = *(*Tuint32_t)(unsafe.Pointer(d)) + Uint32FromInt32(i) - for *(*Tuint32_t)(unsafe.Pointer(d)) > uint32(999999999) { + **(**Tuint32_t)(__ccgo_up(d)) = **(**Tuint32_t)(__ccgo_up(d)) + Uint32FromInt32(i) + for **(**Tuint32_t)(__ccgo_up(d)) > uint32(999999999) { v5 = d d -= 4 - *(*Tuint32_t)(unsafe.Pointer(v5)) = uint32(0) + **(**Tuint32_t)(__ccgo_up(v5)) = uint32(0) if d < a { a -= 4 v5 = a - *(*Tuint32_t)(unsafe.Pointer(v5)) = uint32(0) + **(**Tuint32_t)(__ccgo_up(v5)) = uint32(0) } - *(*Tuint32_t)(unsafe.Pointer(d)) = *(*Tuint32_t)(unsafe.Pointer(d)) + 1 + **(**Tuint32_t)(__ccgo_up(d)) = **(**Tuint32_t)(__ccgo_up(d)) + 1 } i = int32(10) e = Int32FromInt32(9) * ((int32(r) - int32(a)) / 4) for { - if !(*(*Tuint32_t)(unsafe.Pointer(a)) >= Uint32FromInt32(i)) { + if !(**(**Tuint32_t)(__ccgo_up(a)) >= Uint32FromInt32(i)) { break } goto _33 @@ -141217,7 +141217,7 @@ _4: } } for { - if !(z > a && !(*(*Tuint32_t)(unsafe.Pointer(z + uintptr(-Int32FromInt32(1))*4)) != 0)) { + if !(z > a && !(**(**Tuint32_t)(__ccgo_up(z + uintptr(-Int32FromInt32(1))*4)) != 0)) { break } goto _34 @@ -141238,11 +141238,11 @@ _4: } if !(Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0) { /* Count trailing zeros in last place */ - if z > a && *(*Tuint32_t)(unsafe.Pointer(z + uintptr(-Int32FromInt32(1))*4)) != 0 { + if z > a && **(**Tuint32_t)(__ccgo_up(z + uintptr(-Int32FromInt32(1))*4)) != 0 { i = int32(10) j = Int32FromInt32(0) for { - if !(*(*Tuint32_t)(unsafe.Pointer(z + uintptr(-Int32FromInt32(1))*4))%Uint32FromInt32(i) == uint32(0)) { + if !(**(**Tuint32_t)(__ccgo_up(z + uintptr(-Int32FromInt32(1))*4))%Uint32FromInt32(i) == uint32(0)) { break } goto _35 @@ -141312,7 +141312,7 @@ _4: for int32(ebuf)-int32(estr) < int32(2) { estr = estr - 1 v5 = estr - *(*uint8)(unsafe.Pointer(v5)) = uint8('0') + **(**uint8)(__ccgo_up(v5)) = uint8('0') } estr = estr - 1 v5 = estr @@ -141321,10 +141321,10 @@ _4: } else { v7 = int32('+') } - *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(v7) + **(**uint8)(__ccgo_up(v5)) = Uint8FromInt32(v7) estr = estr - 1 v5 = estr - *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(t) + **(**uint8)(__ccgo_up(v5)) = Uint8FromInt32(t) if int32(ebuf)-int32(estr) > int32(INT_MAX)-l { return -int32(1) } @@ -141345,18 +141345,18 @@ _4: if !(d <= r) { break } - s2 = _fmt_u(tls, uint64(*(*Tuint32_t)(unsafe.Pointer(d))), bp+516+uintptr(9)) + s2 = _fmt_u(tls, uint64(**(**Tuint32_t)(__ccgo_up(d))), bp+516+uintptr(9)) if d != a { for s2 > bp+516 { s2 = s2 - 1 v5 = s2 - *(*uint8)(unsafe.Pointer(v5)) = uint8('0') + **(**uint8)(__ccgo_up(v5)) = uint8('0') } } else { if s2 == bp+516+uintptr(9) { s2 = s2 - 1 v5 = s2 - *(*uint8)(unsafe.Pointer(v5)) = uint8('0') + **(**uint8)(__ccgo_up(v5)) = uint8('0') } } _out(tls, f, s2, Uint32FromInt32(int32(bp+516+uintptr(9))-int32(s2))) @@ -141372,11 +141372,11 @@ _4: if !(d < z && p > 0) { break } - s3 = _fmt_u(tls, uint64(*(*Tuint32_t)(unsafe.Pointer(d))), bp+516+uintptr(9)) + s3 = _fmt_u(tls, uint64(**(**Tuint32_t)(__ccgo_up(d))), bp+516+uintptr(9)) for s3 > bp+516 { s3 = s3 - 1 v5 = s3 - *(*uint8)(unsafe.Pointer(v5)) = uint8('0') + **(**uint8)(__ccgo_up(v5)) = uint8('0') } if int32(9) < p { v7 = int32(9) @@ -141400,17 +141400,17 @@ _4: if !(d < z && p >= 0) { break } - s4 = _fmt_u(tls, uint64(*(*Tuint32_t)(unsafe.Pointer(d))), bp+516+uintptr(9)) + s4 = _fmt_u(tls, uint64(**(**Tuint32_t)(__ccgo_up(d))), bp+516+uintptr(9)) if s4 == bp+516+uintptr(9) { s4 = s4 - 1 v5 = s4 - *(*uint8)(unsafe.Pointer(v5)) = uint8('0') + **(**uint8)(__ccgo_up(v5)) = uint8('0') } if d != a { for s4 > bp+516 { s4 = s4 - 1 v5 = s4 - *(*uint8)(unsafe.Pointer(v5)) = uint8('0') + **(**uint8)(__ccgo_up(v5)) = uint8('0') } } else { v5 = s4 @@ -141449,18 +141449,18 @@ func _getint(tls *TLS, s uintptr) (r int32) { _ = i i = 0 for { - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-uint32('0') < uint32(10)) != 0) { break } - if Uint32FromInt32(i) > Uint32FromInt32(INT_MAX)/Uint32FromUint32(10) || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-int32('0') > int32(INT_MAX)-int32(10)*i { + if Uint32FromInt32(i) > Uint32FromInt32(INT_MAX)/Uint32FromUint32(10) || Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-int32('0') > int32(INT_MAX)-int32(10)*i { i = -int32(1) } else { - i = int32(10)*i + (Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s))))) - int32('0')) + i = int32(10)*i + (Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(s))))) - int32('0')) } goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s)) = *(*uintptr)(unsafe.Pointer(s)) + 1 + **(**uintptr)(__ccgo_up(s)) = **(**uintptr)(__ccgo_up(s)) + 1 } return i } @@ -141479,7 +141479,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, var _ /* s at bp+0 */ uintptr var _ /* wc at bp+40 */ [2]Twchar_t _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argpos, cnt, fl, i, l, l10n, p, pl, prefix, ps, st, t, w, ws, xp, z, v31, v45, v5, v6, v8 - *(*uintptr)(unsafe.Pointer(bp)) = fmt + **(**uintptr)(__ccgo_up(bp)) = fmt l10n = uint32(0) cnt = 0 l = 0 @@ -141492,30 +141492,30 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } /* Update output count, end loop when fmt is exhausted */ cnt = cnt + l - if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) != 0) { + if !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))) != 0) { break } /* Handle literal text and %% format specifiers */ - a = *(*uintptr)(unsafe.Pointer(bp)) + a = **(**uintptr)(__ccgo_up(bp)) for { - if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32('%')) { + if !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) != int32('%')) { break } goto _2 _2: ; - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 } - z = *(*uintptr)(unsafe.Pointer(bp)) + z = **(**uintptr)(__ccgo_up(bp)) for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('%') && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1))) == int32('%')) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) == int32('%') && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1))) == int32('%')) { break } goto _3 _3: ; z = z + 1 - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(2) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + uintptr(2) } if int32(z)-int32(a) > int32(INT_MAX)-cnt { goto overflow @@ -141527,46 +141527,46 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if l != 0 { goto _1 } - if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2))) == int32('$') { + if BoolInt32(uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 2))) == int32('$') { l10n = uint32(1) - argpos = Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1))) - int32('0') - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(3) + argpos = Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1))) - int32('0') + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + uintptr(3) } else { argpos = -int32(1) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 } /* Read modifier flags */ fl = uint32(0) for { - if !(uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-uint32(' ') < uint32(32) && (Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('0')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('\'')-Int32FromUint8(' ')))&(uint32(1)<<(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-int32(' '))) != 0) { + if !(uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))))-uint32(' ') < uint32(32) && (Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('0')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('\'')-Int32FromUint8(' ')))&(uint32(1)<<(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))))-int32(' '))) != 0) { break } - fl = fl | uint32(1)<<(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-int32(' ')) + fl = fl | uint32(1)<<(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))))-int32(' ')) goto _4 _4: ; - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 } /* Read field width */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('*') { - if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2))) == int32('$') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) == int32('*') { + if BoolInt32(uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 2))) == int32('$') { l10n = uint32(1) if !(f != 0) { - *(*int32)(unsafe.Pointer(nl_type + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))-int32('0'))*4)) = int32(_INT) + **(**int32)(__ccgo_up(nl_type + uintptr(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1)))-int32('0'))*4)) = int32(_INT) w = Int32FromInt32(0) } else { - w = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))-int32('0'))*8))) + w = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1)))-int32('0'))*8))) } - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(3) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + uintptr(3) } else { if !(l10n != 0) { if f != 0 { - v5 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) + v5 = VaInt32(&**(**Tva_list)(__ccgo_up(ap))) } else { v5 = 0 } w = v5 - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 } else { goto inval } @@ -141583,32 +141583,32 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } } /* Read precision */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('.') && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1))) == int32('*') { - if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 3))) == int32('$') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) == int32('.') && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1))) == int32('*') { + if BoolInt32(uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 2)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 3))) == int32('$') { if !(f != 0) { - *(*int32)(unsafe.Pointer(nl_type + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2)))-int32('0'))*4)) = int32(_INT) + **(**int32)(__ccgo_up(nl_type + uintptr(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 2)))-int32('0'))*4)) = int32(_INT) p = Int32FromInt32(0) } else { - p = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2)))-int32('0'))*8))) + p = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 2)))-int32('0'))*8))) } - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(4) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + uintptr(4) } else { if !(l10n != 0) { if f != 0 { - v5 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) + v5 = VaInt32(&**(**Tva_list)(__ccgo_up(ap))) } else { v5 = 0 } p = v5 - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(2) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + uintptr(2) } else { goto inval } } xp = BoolInt32(p >= 0) } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('.') { - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) == int32('.') { + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 p = _getint(tls, bp) xp = int32(1) } else { @@ -141619,13 +141619,13 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, /* Format specifier state machine */ st = uint32(0) for cond := true; cond; cond = st-uint32(1) < uint32(_STOP) { - if uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-uint32('A') > Uint32FromInt32(Int32FromUint8('z')-Int32FromUint8('A')) { + if uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))))-uint32('A') > Uint32FromInt32(Int32FromUint8('z')-Int32FromUint8('A')) { goto inval } ps = st - v8 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - st = uint32(*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_states)) + uintptr(st)*58 + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(v8)))-int32('A'))))) + v8 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + st = uint32(**(**uint8)(__ccgo_up(uintptr(unsafe.Pointer(&_states)) + uintptr(st)*58 + uintptr(Int32FromUint8(**(**uint8)(__ccgo_up(v8)))-int32('A'))))) } if !(st != 0) { goto inval @@ -141638,9 +141638,9 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } else { if argpos >= 0 { if !(f != 0) { - *(*int32)(unsafe.Pointer(nl_type + uintptr(argpos)*4)) = Int32FromUint32(st) + **(**int32)(__ccgo_up(nl_type + uintptr(argpos)*4)) = Int32FromUint32(st) } else { - *(*Targ)(unsafe.Pointer(bp + 8)) = *(*Targ)(unsafe.Pointer(nl_arg + uintptr(argpos)*8)) + **(**Targ)(__ccgo_up(bp + 8)) = **(**Targ)(__ccgo_up(nl_arg + uintptr(argpos)*8)) } } else { if f != 0 { @@ -141660,7 +141660,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, z = bp + 16 + uintptr(24) prefix = __ccgo_ts + 1450 pl = 0 - t = Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + uintptr(-Int32FromInt32(1))))) + t = Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + uintptr(-Int32FromInt32(1))))) /* Transform ls,lc -> S,C */ if ps != 0 && t&int32(15) == int32(3) { t = t & ^Int32FromInt32(32) @@ -141718,19 +141718,19 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, ; switch ps { case uint32(_BARE): - *(*int32)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))))) = cnt + **(**int32)(__ccgo_up(*(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))))) = cnt case uint32(_LPRE): - *(*int32)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))))) = cnt + **(**int32)(__ccgo_up(*(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))))) = cnt case uint32(_LLPRE): - *(*int64)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))))) = int64(cnt) + **(**int64)(__ccgo_up(*(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))))) = int64(cnt) case uint32(_HPRE): - *(*uint16)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))))) = Uint16FromInt32(cnt) + **(**uint16)(__ccgo_up(*(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))))) = Uint16FromInt32(cnt) case uint32(_HHPRE): - *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))))) = Uint8FromInt32(cnt) + **(**uint8)(__ccgo_up(*(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))))) = Uint8FromInt32(cnt) case uint32(_ZTPRE): - *(*Tsize_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))))) = Uint32FromInt32(cnt) + **(**Tsize_t)(__ccgo_up(*(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))))) = Uint32FromInt32(cnt) case uint32(_JPRE): - *(*Tuintmax_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))))) = Uint64FromInt32(cnt) + **(**Tuintmax_t)(__ccgo_up(*(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))))) = Uint64FromInt32(cnt) break } goto _1 @@ -141816,7 +141816,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, p = v5 v8 = z - uintptr(v5) a = v8 - *(*uint8)(unsafe.Pointer(v8)) = uint8(*(*Tuintmax_t)(unsafe.Pointer(bp + 8))) + **(**uint8)(__ccgo_up(v8)) = uint8(*(*Tuintmax_t)(unsafe.Pointer(bp + 8))) fl = fl & ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) goto _30 _19: @@ -141824,14 +141824,14 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if !(int32(1) != 0) { goto _37 } - a = Xstrerror(tls, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) + a = Xstrerror(tls, **(**int32)(__ccgo_up(X__errno_location(tls)))) goto _38 _37: ; _18: ; - if *(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))) != 0 { - v8 = *(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))) + if *(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))) != 0 { + v8 = *(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))) } else { v8 = __ccgo_ts + 1460 } @@ -141844,7 +141844,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, v5 = p } z = a + uintptr(Xstrnlen(tls, a, Uint32FromInt32(v5))) - if p < 0 && *(*uint8)(unsafe.Pointer(z)) != 0 { + if p < 0 && **(**uint8)(__ccgo_up(z)) != 0 { goto overflow } p = int32(z) - int32(a) @@ -141855,21 +141855,21 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if !(*(*Tuintmax_t)(unsafe.Pointer(bp + 8)) != 0) { goto narrow_c } - (*(*[2]Twchar_t)(unsafe.Pointer(bp + 40)))[0] = uint32(*(*Tuintmax_t)(unsafe.Pointer(bp + 8))) - (*(*[2]Twchar_t)(unsafe.Pointer(bp + 40)))[int32(1)] = uint32(0) - *(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))) = bp + 40 + (**(**[2]Twchar_t)(__ccgo_up(bp + 40)))[0] = uint32(*(*Tuintmax_t)(unsafe.Pointer(bp + 8))) + (**(**[2]Twchar_t)(__ccgo_up(bp + 40)))[int32(1)] = uint32(0) + *(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))) = bp + 40 p = -int32(1) _21: ; - ws = *(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))) + ws = *(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))) v5 = Int32FromInt32(0) l = v5 i = Uint32FromInt32(v5) for { - if v45 = i < Uint32FromInt32(p) && *(*Twchar_t)(unsafe.Pointer(ws)) != 0; v45 { + if v45 = i < Uint32FromInt32(p) && **(**Twchar_t)(__ccgo_up(ws)) != 0; v45 { v8 = ws ws += 4 - v6 = Xwctomb(tls, bp+48, *(*Twchar_t)(unsafe.Pointer(v8))) + v6 = Xwctomb(tls, bp+48, **(**Twchar_t)(__ccgo_up(v8))) l = v6 } if !(v45 && v6 >= 0 && Uint32FromInt32(l) <= Uint32FromInt32(p)-i) { @@ -141888,13 +141888,13 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } p = Int32FromUint32(i) _pad3(tls, f, uint8(' '), w, p, Int32FromUint32(fl)) - ws = *(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))) + ws = *(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))) i = uint32(0) for { - if v45 = i < 0+Uint32FromInt32(p) && *(*Twchar_t)(unsafe.Pointer(ws)) != 0; v45 { + if v45 = i < 0+Uint32FromInt32(p) && **(**Twchar_t)(__ccgo_up(ws)) != 0; v45 { v8 = ws ws += 4 - v5 = Xwctomb(tls, bp+48, *(*Twchar_t)(unsafe.Pointer(v8))) + v5 = Xwctomb(tls, bp+48, **(**Twchar_t)(__ccgo_up(v8))) l = v5 } if !(v45 && i+Uint32FromInt32(v5) <= Uint32FromInt32(p)) { @@ -141970,17 +141970,17 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } i = uint32(1) for { - if !(i <= uint32(NL_ARGMAX) && *(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)) != 0) { + if !(i <= uint32(NL_ARGMAX) && **(**int32)(__ccgo_up(nl_type + uintptr(i)*4)) != 0) { break } - _pop_arg(tls, nl_arg+uintptr(i)*8, *(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)), ap) + _pop_arg(tls, nl_arg+uintptr(i)*8, **(**int32)(__ccgo_up(nl_type + uintptr(i)*4)), ap) goto _51 _51: ; i = i + 1 } for { - if !(i <= uint32(NL_ARGMAX) && !(*(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)) != 0)) { + if !(i <= uint32(NL_ARGMAX) && !(**(**int32)(__ccgo_up(nl_type + uintptr(i)*4)) != 0)) { break } goto _52 @@ -141995,12 +141995,12 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto inval inval: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) goto overflow overflow: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return -int32(1) } @@ -142018,12 +142018,12 @@ func Xvfprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { var _ /* nl_arg at bp+48 */ [10]Targ var _ /* nl_type at bp+4 */ [10]int32 _, _, _, _, _, _, _ = __need_unlock, olderr, ret, saved_buf, v1, v2, v3 - *(*[10]int32)(unsafe.Pointer(bp + 4)) = [10]int32{} + **(**[10]int32)(__ccgo_up(bp + 4)) = [10]int32{} saved_buf = uintptr(0) /* the copy allows passing va_list* even if va_list is an array */ - *(*Tva_list)(unsafe.Pointer(bp)) = ap + **(**Tva_list)(__ccgo_up(bp)) = ap if _printf_core(tls, uintptr(0), fmt, bp, bp+48, bp+4) < 0 { - _ = *(*Tva_list)(unsafe.Pointer(bp)) + _ = **(**Tva_list)(__ccgo_up(bp)) return -int32(1) } if AtomicLoadPInt32(f+76) >= 0 { @@ -142033,7 +142033,7 @@ func Xvfprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } __need_unlock = v1 olderr = Int32FromUint32((*TFILE)(unsafe.Pointer(f)).Fflags & uint32(F_ERR)) - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_ERR)) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^Int32FromInt32(F_ERR)) if !((*TFILE)(unsafe.Pointer(f)).Fbuf_size != 0) { saved_buf = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Fbuf = bp + 128 @@ -142065,11 +142065,11 @@ func Xvfprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_ERR) != 0 { ret = -int32(1) } - *(*uint32)(unsafe.Pointer(f)) |= Uint32FromInt32(olderr) + **(**uint32)(__ccgo_up(f)) |= Uint32FromInt32(olderr) if __need_unlock != 0 { ___unlockfile(tls, f) } - _ = *(*Tva_list)(unsafe.Pointer(bp)) + _ = **(**Tva_list)(__ccgo_up(bp)) return ret } @@ -142086,15 +142086,15 @@ func _store_int(tls *TLS, dest uintptr, size int32, i uint64) { } switch size { case -int32(2): - *(*uint8)(unsafe.Pointer(dest)) = uint8(i) + **(**uint8)(__ccgo_up(dest)) = uint8(i) case -int32(1): - *(*int16)(unsafe.Pointer(dest)) = Int16FromUint64(i) + **(**int16)(__ccgo_up(dest)) = Int16FromUint64(i) case SIZE_def: - *(*int32)(unsafe.Pointer(dest)) = Int32FromUint64(i) + **(**int32)(__ccgo_up(dest)) = Int32FromUint64(i) case int32(SIZE_l): - *(*int32)(unsafe.Pointer(dest)) = Int32FromUint64(i) + **(**int32)(__ccgo_up(dest)) = Int32FromUint64(i) case int32(SIZE_ll): - *(*int64)(unsafe.Pointer(dest)) = Int64FromUint64(i) + **(**int64)(__ccgo_up(dest)) = Int64FromUint64(i) break } } @@ -142157,17 +142157,17 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } p = fmt for { - if !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if !(**(**uint8)(__ccgo_up(p)) != 0) { break } alloc = 0 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v3 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _5 _5: if v3 != 0 { for { - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) v6 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _8 _8: @@ -142182,7 +142182,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v11 = f + 4 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v1 = X__shgetc(tls, f) } @@ -142200,16 +142200,16 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { pos = pos + ((*TFILE)(unsafe.Pointer(f)).Fshcnt + int64(int32((*TFILE)(unsafe.Pointer(f)).Frpos)-int32((*TFILE)(unsafe.Pointer(f)).Fbuf))) goto _2 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32('%') || Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('%') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) != int32('%') || Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) == int32('%') { X__shlim(tls, f, int64(Int32FromInt32(0))) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('%') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('%') { p = p + 1 for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v11 = f + 4 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v3 = X__shgetc(tls, f) } @@ -142228,13 +142228,13 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v11 = f + 4 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v1 = X__shgetc(tls, f) } c = v1 } - if c != Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) { + if c != Int32FromUint8(**(**uint8)(__ccgo_up(p))) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } @@ -142247,12 +142247,12 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { goto _2 } p = p + 1 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('*') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('*') { dest = uintptr(0) p = p + 1 } else { - if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('$') { - dest = _arg_n(tls, ap, Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))-int32('0'))) + if BoolInt32(uint32(**(**uint8)(__ccgo_up(p)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) == int32('$') { + dest = _arg_n(tls, ap, Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(p)))-int32('0'))) p = p + uintptr(2) } else { dest = VaUintptr(&ap) @@ -142260,16 +142260,16 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } width = 0 for { - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p)))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(p)))-uint32('0') < uint32(10)) != 0) { break } - width = int32(10)*width + Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - int32('0') + width = int32(10)*width + Int32FromUint8(**(**uint8)(__ccgo_up(p))) - int32('0') goto _25 _25: ; p = p + 1 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('m') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('m') { wcs = uintptr(0) s = uintptr(0) alloc = BoolInt32(!!(dest != 0)) @@ -142280,16 +142280,16 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { size = SIZE_def v10 = p p = p + 1 - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(v10))) { case int32('h'): - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('h') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('h') { p = p + 1 size = -Int32FromInt32(2) } else { size = -int32(1) } case int32('l'): - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('l') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('l') { p = p + 1 size = Int32FromInt32(SIZE_ll) } else { @@ -142348,7 +142348,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { default: goto fmt_fail } - t = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + t = Int32FromUint8(**(**uint8)(__ccgo_up(p))) /* C or S */ if t&int32(0x2f) == int32(3) { t = t | int32(32) @@ -142372,7 +142372,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v11 = f + 4 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v1 = X__shgetc(tls, f) } @@ -142394,7 +142394,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v11 = f + 4 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v1 = X__shgetc(tls, f) } @@ -142451,58 +142451,58 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { ; if t == int32('c') || t == int32('s') { Xmemset(tls, bp+16, -int32(1), uint32(257)) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[0] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[0] = uint8(0) if t == int32('s') { - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\t')] = uint8(0) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\n')] = uint8(0) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\v')] = uint8(0) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\f')] = uint8(0) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\r')] = uint8(0) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8(' ')] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\t')] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\n')] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\v')] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\f')] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\r')] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8(' ')] = uint8(0) } } else { p = p + 1 v10 = p - if Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) == int32('^') { + if Int32FromUint8(**(**uint8)(__ccgo_up(v10))) == int32('^') { p = p + 1 invert = Int32FromInt32(1) } else { invert = 0 } Xmemset(tls, bp+16, invert, uint32(257)) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[0] = uint8(0) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') { + (**(**[257]uint8)(__ccgo_up(bp + 16)))[0] = uint8(0) + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('-') { p = p + 1 - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('-')] = Uint8FromInt32(Int32FromInt32(1) - invert) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('-')] = Uint8FromInt32(Int32FromInt32(1) - invert) } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32(']') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32(']') { p = p + 1 - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8(']')] = Uint8FromInt32(Int32FromInt32(1) - invert) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8(']')] = Uint8FromInt32(Int32FromInt32(1) - invert) } } for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32(']')) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(p))) != int32(']')) { break } - if !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if !(**(**uint8)(__ccgo_up(p)) != 0) { goto fmt_fail } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') && *(*uint8)(unsafe.Pointer(p + 1)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) != int32(']') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('-') && **(**uint8)(__ccgo_up(p + 1)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) != int32(']') { v10 = p p = p + 1 - c = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10 + uintptr(-Int32FromInt32(1))))) + c = Int32FromUint8(**(**uint8)(__ccgo_up(v10 + uintptr(-Int32FromInt32(1))))) for { - if !(c < Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))) { + if !(c < Int32FromUint8(**(**uint8)(__ccgo_up(p)))) { break } - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[int32(1)+c] = Uint8FromInt32(int32(1) - invert) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[int32(1)+c] = Uint8FromInt32(int32(1) - invert) goto _57 _57: ; c = c + 1 } } - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[int32(1)+Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))] = Uint8FromInt32(int32(1) - invert) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[int32(1)+Int32FromUint8(**(**uint8)(__ccgo_up(p)))] = Uint8FromInt32(int32(1) - invert) goto _56 _56: ; @@ -142527,19 +142527,19 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } else { wcs = dest } - *(*Tmbstate_t)(unsafe.Pointer(bp + 8)) = Tmbstate_t{} + **(**Tmbstate_t)(__ccgo_up(bp + 8)) = Tmbstate_t{} for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v11 = f + 4 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v3 = X__shgetc(tls, f) } v1 = v3 c = v1 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { + if !((**(**[257]uint8)(__ccgo_up(bp + 16)))[v1+int32(1)] != 0) { break } *(*uint8)(unsafe.Pointer(bp)) = Uint8FromInt32(c) @@ -142552,7 +142552,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if wcs != 0 { v64 = i i = i + 1 - *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(v64)*4)) = *(*Twchar_t)(unsafe.Pointer(bp + 276)) + **(**Twchar_t)(__ccgo_up(wcs + uintptr(v64)*4)) = **(**Twchar_t)(__ccgo_up(bp + 276)) } if alloc != 0 && i == k { k = k + (k + uint32(1)) @@ -142577,18 +142577,18 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v11 = f + 4 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v3 = X__shgetc(tls, f) } v1 = v3 c = v1 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { + if !((**(**[257]uint8)(__ccgo_up(bp + 16)))[v1+int32(1)] != 0) { break } v64 = i i = i + 1 - *(*uint8)(unsafe.Pointer(s + uintptr(v64))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + uintptr(v64))) = Uint8FromInt32(c) if i == k { k = k + (k + uint32(1)) tmp1 = Xrealloc(tls, s, k) @@ -142607,18 +142607,18 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v17 = f + 4 v11 = *(*uintptr)(unsafe.Pointer(v17)) *(*uintptr)(unsafe.Pointer(v17)) = *(*uintptr)(unsafe.Pointer(v17)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v11))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v11))) } else { v3 = X__shgetc(tls, f) } v1 = v3 c = v1 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { + if !((**(**[257]uint8)(__ccgo_up(bp + 16)))[v1+int32(1)] != 0) { break } v64 = i i = i + 1 - *(*uint8)(unsafe.Pointer(s + uintptr(v64))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + uintptr(v64))) = Uint8FromInt32(c) } } else { for { @@ -142626,13 +142626,13 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v11 = f + 4 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v3 = X__shgetc(tls, f) } v1 = v3 c = v1 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { + if !((**(**[257]uint8)(__ccgo_up(bp + 16)))[v1+int32(1)] != 0) { break } } @@ -142650,17 +142650,17 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } if alloc != 0 { if size == int32(SIZE_l) { - *(*uintptr)(unsafe.Pointer(dest)) = wcs + **(**uintptr)(__ccgo_up(dest)) = wcs } else { - *(*uintptr)(unsafe.Pointer(dest)) = s + **(**uintptr)(__ccgo_up(dest)) = s } } if t != int32('c') { if wcs != 0 { - *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) = uint32(0) + **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) = uint32(0) } if s != 0 { - *(*uint8)(unsafe.Pointer(s + uintptr(i))) = uint8(0) + **(**uint8)(__ccgo_up(s + uintptr(i))) = uint8(0) } } goto _54 @@ -142693,7 +142693,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { goto match_fail } if t == int32('p') && dest != 0 { - *(*uintptr)(unsafe.Pointer(dest)) = uintptr(uint32(x)) + **(**uintptr)(__ccgo_up(dest)) = uintptr(uint32(x)) } else { _store_int(tls, dest, size, x) } @@ -142721,11 +142721,11 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if dest != 0 { switch size { case SIZE_def: - *(*float32)(unsafe.Pointer(dest)) = float32(y) + **(**float32)(__ccgo_up(dest)) = float32(y) case int32(SIZE_l): - *(*float64)(unsafe.Pointer(dest)) = y + **(**float64)(__ccgo_up(dest)) = y case int32(SIZE_L): - *(*float64)(unsafe.Pointer(dest)) = y + **(**float64)(__ccgo_up(dest)) = y break } } @@ -142891,41 +142891,41 @@ var _states1 = [8][58]uint8{ func _pop_arg1(tls *TLS, arg uintptr, type1 int32, ap uintptr) { switch type1 { case int32(_PTR): - *(*uintptr)(unsafe.Pointer(arg)) = VaUintptr(&*(*Tva_list)(unsafe.Pointer(ap))) + *(*uintptr)(unsafe.Pointer(arg)) = VaUintptr(&**(**Tva_list)(__ccgo_up(ap))) case int32(_INT): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_UINT): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint32(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint32(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_LONG): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_ULONG): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint32(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint32(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_ULLONG): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&**(**Tva_list)(__ccgo_up(ap))) case int32(_SHORT): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt16(int16(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt16(int16(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_USHORT): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint16FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint16FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_CHAR): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt8(int8(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt8(int8(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_UCHAR): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint8FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint8FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_LLONG): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_SIZET): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint32(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint32(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_IMAX): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_UMAX): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&**(**Tva_list)(__ccgo_up(ap))) case int32(_PDIFF): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_UIPTR): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(uint32(VaUintptr(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(uint32(VaUintptr(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_DBL): - *(*float64)(unsafe.Pointer(arg)) = float64(VaFloat64(&*(*Tva_list)(unsafe.Pointer(ap)))) + *(*float64)(unsafe.Pointer(arg)) = float64(VaFloat64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_LDBL): - *(*float64)(unsafe.Pointer(arg)) = VaFloat64(&*(*Tva_list)(unsafe.Pointer(ap))) + *(*float64)(unsafe.Pointer(arg)) = VaFloat64(&**(**Tva_list)(__ccgo_up(ap))) } } @@ -142941,7 +142941,7 @@ func _out1(tls *TLS, f uintptr, s uintptr, l Tsize_t) { } v2 = s s += 4 - Xfputwc(tls, *(*Twchar_t)(unsafe.Pointer(v2)), f) + Xfputwc(tls, **(**Twchar_t)(__ccgo_up(v2)), f) } } @@ -142959,18 +142959,18 @@ func _getint1(tls *TLS, s uintptr) (r int32) { _ = i i = 0 for { - if !(BoolInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s))))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(s))))-uint32('0') < uint32(10)) != 0) { break } - if Uint32FromInt32(i) > Uint32FromInt32(INT_MAX)/Uint32FromUint32(10) || *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s))))-uint32('0') > Uint32FromInt32(int32(INT_MAX)-int32(10)*i) { + if Uint32FromInt32(i) > Uint32FromInt32(INT_MAX)/Uint32FromUint32(10) || **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(s))))-uint32('0') > Uint32FromInt32(int32(INT_MAX)-int32(10)*i) { i = -int32(1) } else { - i = Int32FromUint32(Uint32FromInt32(int32(10)*i) + (*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))) - uint32('0'))) + i = Int32FromUint32(Uint32FromInt32(int32(10)*i) + (**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))) - uint32('0'))) } goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s)) += 4 + **(**uintptr)(__ccgo_up(s)) += 4 } return i } @@ -143001,7 +143001,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, var _ /* s at bp+4 */ uintptr var _ /* wc at bp+32 */ Twchar_t _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argpos, bs, cnt, fl, i, l, l10n, p, ps, st, t, w, xp, z, v15, v5, v6, v7, v8, v9 - *(*uintptr)(unsafe.Pointer(bp + 4)) = fmt + **(**uintptr)(__ccgo_up(bp + 4)) = fmt l10n = uint32(0) cnt = 0 l = 0 @@ -143014,30 +143014,30 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } /* Update output count, end loop when fmt is exhausted */ cnt = cnt + l - if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)))) != 0) { + if !(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4)))) != 0) { break } /* Handle literal text and %% format specifiers */ - a = *(*uintptr)(unsafe.Pointer(bp + 4)) + a = **(**uintptr)(__ccgo_up(bp + 4)) for { - if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)))) != 0 && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)))) != uint32('%')) { + if !(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4)))) != 0 && **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4)))) != uint32('%')) { break } goto _2 _2: ; - *(*uintptr)(unsafe.Pointer(bp + 4)) += 4 + **(**uintptr)(__ccgo_up(bp + 4)) += 4 } - z = *(*uintptr)(unsafe.Pointer(bp + 4)) + z = **(**uintptr)(__ccgo_up(bp + 4)) for { - if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)))) == uint32('%') && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)) + 1*4)) == uint32('%')) { + if !(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4)))) == uint32('%') && **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4)) + 1*4)) == uint32('%')) { break } goto _3 _3: ; z += 4 - *(*uintptr)(unsafe.Pointer(bp + 4)) = *(*uintptr)(unsafe.Pointer(bp + 4)) + uintptr(2)*4 + **(**uintptr)(__ccgo_up(bp + 4)) = **(**uintptr)(__ccgo_up(bp + 4)) + uintptr(2)*4 } if (int32(z)-int32(a))/4 > int32(INT_MAX)-cnt { goto overflow @@ -143049,42 +143049,42 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if l != 0 { goto _1 } - if BoolInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)) + 1*4))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)) + 2*4)) == uint32('$') { + if BoolInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4)) + 1*4))-uint32('0') < uint32(10)) != 0 && **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4)) + 2*4)) == uint32('$') { l10n = uint32(1) - argpos = Int32FromUint32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)) + 1*4)) - uint32('0')) - *(*uintptr)(unsafe.Pointer(bp + 4)) = *(*uintptr)(unsafe.Pointer(bp + 4)) + uintptr(3)*4 + argpos = Int32FromUint32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4)) + 1*4)) - uint32('0')) + **(**uintptr)(__ccgo_up(bp + 4)) = **(**uintptr)(__ccgo_up(bp + 4)) + uintptr(3)*4 } else { argpos = -int32(1) - *(*uintptr)(unsafe.Pointer(bp + 4)) += 4 + **(**uintptr)(__ccgo_up(bp + 4)) += 4 } /* Read modifier flags */ fl = uint32(0) for { - if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4))))-uint32(' ') < uint32(32) && (Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('0')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('\'')-Int32FromUint8(' ')))&(uint32(1)<<(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4))))-uint32(' '))) != 0) { + if !(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4))))-uint32(' ') < uint32(32) && (Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('0')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('\'')-Int32FromUint8(' ')))&(uint32(1)<<(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4))))-uint32(' '))) != 0) { break } - fl = fl | uint32(1)<<(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4))))-uint32(' ')) + fl = fl | uint32(1)<<(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4))))-uint32(' ')) goto _4 _4: ; - *(*uintptr)(unsafe.Pointer(bp + 4)) += 4 + **(**uintptr)(__ccgo_up(bp + 4)) += 4 } /* Read field width */ - if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)))) == uint32('*') { - if BoolInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)) + 1*4))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)) + 2*4)) == uint32('$') { + if **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4)))) == uint32('*') { + if BoolInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4)) + 1*4))-uint32('0') < uint32(10)) != 0 && **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4)) + 2*4)) == uint32('$') { l10n = uint32(1) - *(*int32)(unsafe.Pointer(nl_type + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)) + 1*4))-uint32('0'))*4)) = int32(_INT) - w = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)) + 1*4))-uint32('0'))*8))) - *(*uintptr)(unsafe.Pointer(bp + 4)) = *(*uintptr)(unsafe.Pointer(bp + 4)) + uintptr(3)*4 + **(**int32)(__ccgo_up(nl_type + uintptr(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4)) + 1*4))-uint32('0'))*4)) = int32(_INT) + w = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4)) + 1*4))-uint32('0'))*8))) + **(**uintptr)(__ccgo_up(bp + 4)) = **(**uintptr)(__ccgo_up(bp + 4)) + uintptr(3)*4 } else { if !(l10n != 0) { if f != 0 { - v5 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) + v5 = VaInt32(&**(**Tva_list)(__ccgo_up(ap))) } else { v5 = 0 } w = v5 - *(*uintptr)(unsafe.Pointer(bp + 4)) += 4 + **(**uintptr)(__ccgo_up(bp + 4)) += 4 } else { goto inval } @@ -143101,28 +143101,28 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } } /* Read precision */ - if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)))) == uint32('.') && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)) + 1*4)) == uint32('*') { - if BoolInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)) + 2*4))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)) + 3*4)) == uint32('$') { - *(*int32)(unsafe.Pointer(nl_type + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)) + 2*4))-uint32('0'))*4)) = int32(_INT) - p = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)) + 2*4))-uint32('0'))*8))) - *(*uintptr)(unsafe.Pointer(bp + 4)) = *(*uintptr)(unsafe.Pointer(bp + 4)) + uintptr(4)*4 + if **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4)))) == uint32('.') && **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4)) + 1*4)) == uint32('*') { + if BoolInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4)) + 2*4))-uint32('0') < uint32(10)) != 0 && **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4)) + 3*4)) == uint32('$') { + **(**int32)(__ccgo_up(nl_type + uintptr(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4)) + 2*4))-uint32('0'))*4)) = int32(_INT) + p = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4)) + 2*4))-uint32('0'))*8))) + **(**uintptr)(__ccgo_up(bp + 4)) = **(**uintptr)(__ccgo_up(bp + 4)) + uintptr(4)*4 } else { if !(l10n != 0) { if f != 0 { - v5 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) + v5 = VaInt32(&**(**Tva_list)(__ccgo_up(ap))) } else { v5 = 0 } p = v5 - *(*uintptr)(unsafe.Pointer(bp + 4)) = *(*uintptr)(unsafe.Pointer(bp + 4)) + uintptr(2)*4 + **(**uintptr)(__ccgo_up(bp + 4)) = **(**uintptr)(__ccgo_up(bp + 4)) + uintptr(2)*4 } else { goto inval } } xp = BoolInt32(p >= 0) } else { - if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)))) == uint32('.') { - *(*uintptr)(unsafe.Pointer(bp + 4)) += 4 + if **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4)))) == uint32('.') { + **(**uintptr)(__ccgo_up(bp + 4)) += 4 p = _getint1(tls, bp+4) xp = int32(1) } else { @@ -143133,13 +143133,13 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, /* Format specifier state machine */ st = uint32(0) for cond := true; cond; cond = st-uint32(1) < uint32(_STOP) { - if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4))))-uint32('A') > Uint32FromInt32(Int32FromUint8('z')-Int32FromUint8('A')) { + if **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4))))-uint32('A') > Uint32FromInt32(Int32FromUint8('z')-Int32FromUint8('A')) { goto inval } ps = st - v8 = *(*uintptr)(unsafe.Pointer(bp + 4)) - *(*uintptr)(unsafe.Pointer(bp + 4)) += 4 - st = uint32(*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_states1)) + uintptr(st)*58 + uintptr(*(*Twchar_t)(unsafe.Pointer(v8))-uint32('A'))))) + v8 = **(**uintptr)(__ccgo_up(bp + 4)) + **(**uintptr)(__ccgo_up(bp + 4)) += 4 + st = uint32(**(**uint8)(__ccgo_up(uintptr(unsafe.Pointer(&_states1)) + uintptr(st)*58 + uintptr(**(**Twchar_t)(__ccgo_up(v8))-uint32('A'))))) } if !(st != 0) { goto inval @@ -143151,8 +143151,8 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } } else { if argpos >= 0 { - *(*int32)(unsafe.Pointer(nl_type + uintptr(argpos)*4)) = Int32FromUint32(st) - *(*Targ)(unsafe.Pointer(bp + 8)) = *(*Targ)(unsafe.Pointer(nl_arg + uintptr(argpos)*8)) + **(**int32)(__ccgo_up(nl_type + uintptr(argpos)*4)) = Int32FromUint32(st) + **(**Targ)(__ccgo_up(bp + 8)) = **(**Targ)(__ccgo_up(nl_arg + uintptr(argpos)*8)) } else { if f != 0 { _pop_arg1(tls, bp+8, Int32FromUint32(st), ap) @@ -143168,7 +143168,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_ERR) != 0 { return -int32(1) } - t = Int32FromUint32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)) + uintptr(-Int32FromInt32(1))*4))) + t = Int32FromUint32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 4)) + uintptr(-Int32FromInt32(1))*4))) if ps != 0 && t&int32(15) == int32(3) { t = t & ^Int32FromInt32(32) } @@ -143176,19 +143176,19 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, case int32('n'): switch ps { case uint32(_BARE): - *(*int32)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))))) = cnt + **(**int32)(__ccgo_up(*(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))))) = cnt case uint32(_LPRE): - *(*int32)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))))) = cnt + **(**int32)(__ccgo_up(*(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))))) = cnt case uint32(_LLPRE): - *(*int64)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))))) = int64(cnt) + **(**int64)(__ccgo_up(*(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))))) = int64(cnt) case uint32(_HPRE): - *(*uint16)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))))) = Uint16FromInt32(cnt) + **(**uint16)(__ccgo_up(*(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))))) = Uint16FromInt32(cnt) case uint32(_HHPRE): - *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))))) = Uint8FromInt32(cnt) + **(**uint8)(__ccgo_up(*(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))))) = Uint8FromInt32(cnt) case uint32(_ZTPRE): - *(*Tsize_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))))) = Uint32FromInt32(cnt) + **(**Tsize_t)(__ccgo_up(*(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))))) = Uint32FromInt32(cnt) case uint32(_JPRE): - *(*Tuintmax_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))))) = Uint64FromInt32(cnt) + **(**Tuintmax_t)(__ccgo_up(*(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))))) = Uint64FromInt32(cnt) break } goto _1 @@ -143210,14 +143210,14 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, l = w goto _1 case int32('S'): - a = *(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))) + a = *(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))) if p < 0 { v5 = int32(INT_MAX) } else { v5 = p } z = a + uintptr(Xwcsnlen(tls, a, Uint32FromInt32(v5)))*4 - if p < 0 && *(*Twchar_t)(unsafe.Pointer(z)) != 0 { + if p < 0 && **(**Twchar_t)(__ccgo_up(z)) != 0 { goto overflow } p = (int32(z) - int32(a)) / 4 @@ -143230,13 +143230,13 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, l = w goto _1 case int32('m'): - *(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))) = Xstrerror(tls, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) + *(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))) = Xstrerror(tls, **(**int32)(__ccgo_up(X__errno_location(tls)))) fallthrough case int32('s'): - if !(*(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))) != 0) { - *(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))) = __ccgo_ts + 1460 + if !(*(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))) != 0) { + *(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))) = __ccgo_ts + 1460 } - bs = *(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))) + bs = *(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))) v5 = Int32FromInt32(0) l = v5 i = v5 @@ -143262,7 +143262,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if i < 0 { return -int32(1) } - if p < 0 && *(*uint8)(unsafe.Pointer(bs)) != 0 { + if p < 0 && **(**uint8)(__ccgo_up(bs)) != 0 { goto overflow } p = l @@ -143270,7 +143270,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, w = p } _pad4(tls, f, w-p, Int32FromUint32(fl)) - bs = *(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))) + bs = *(*uintptr)(unsafe.Pointer(&**(**Targ)(__ccgo_up(bp + 8)))) for { v5 = l l = l - 1 @@ -143323,17 +143323,17 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } i = int32(1) for { - if !(i <= int32(NL_ARGMAX) && *(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)) != 0) { + if !(i <= int32(NL_ARGMAX) && **(**int32)(__ccgo_up(nl_type + uintptr(i)*4)) != 0) { break } - _pop_arg1(tls, nl_arg+uintptr(i)*8, *(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)), ap) + _pop_arg1(tls, nl_arg+uintptr(i)*8, **(**int32)(__ccgo_up(nl_type + uintptr(i)*4)), ap) goto _17 _17: ; i = i + 1 } for { - if !(i <= int32(NL_ARGMAX) && !(*(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)) != 0)) { + if !(i <= int32(NL_ARGMAX) && !(**(**int32)(__ccgo_up(nl_type + uintptr(i)*4)) != 0)) { break } goto _18 @@ -143348,12 +143348,12 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto inval inval: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) goto overflow overflow: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return -int32(1) } @@ -143369,11 +143369,11 @@ func Xvfwprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { var _ /* nl_arg at bp+48 */ [10]Targ var _ /* nl_type at bp+4 */ [10]int32 _, _, _, _ = __need_unlock, olderr, ret, v1 - *(*[10]int32)(unsafe.Pointer(bp + 4)) = [10]int32{} + **(**[10]int32)(__ccgo_up(bp + 4)) = [10]int32{} /* the copy allows passing va_list* even if va_list is an array */ - *(*Tva_list)(unsafe.Pointer(bp)) = ap + **(**Tva_list)(__ccgo_up(bp)) = ap if _wprintf_core(tls, uintptr(0), fmt, bp, bp+48, bp+4) < 0 { - _ = *(*Tva_list)(unsafe.Pointer(bp)) + _ = **(**Tva_list)(__ccgo_up(bp)) return -int32(1) } if AtomicLoadPInt32(f+76) >= 0 { @@ -143384,16 +143384,16 @@ func Xvfwprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { __need_unlock = v1 Xfwide(tls, f, int32(1)) olderr = Int32FromUint32((*TFILE)(unsafe.Pointer(f)).Fflags & uint32(F_ERR)) - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_ERR)) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^Int32FromInt32(F_ERR)) ret = _wprintf_core(tls, f, fmt, bp, bp+48, bp+4) if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_ERR) != 0 { ret = -int32(1) } - *(*uint32)(unsafe.Pointer(f)) |= Uint32FromInt32(olderr) + **(**uint32)(__ccgo_up(f)) |= Uint32FromInt32(olderr) if __need_unlock != 0 { ___unlockfile(tls, f) } - _ = *(*Tva_list)(unsafe.Pointer(bp)) + _ = **(**Tva_list)(__ccgo_up(bp)) return ret } @@ -143403,15 +143403,15 @@ func _store_int1(tls *TLS, dest uintptr, size int32, i uint64) { } switch size { case -int32(2): - *(*uint8)(unsafe.Pointer(dest)) = uint8(i) + **(**uint8)(__ccgo_up(dest)) = uint8(i) case -int32(1): - *(*int16)(unsafe.Pointer(dest)) = Int16FromUint64(i) + **(**int16)(__ccgo_up(dest)) = Int16FromUint64(i) case SIZE_def: - *(*int32)(unsafe.Pointer(dest)) = Int32FromUint64(i) + **(**int32)(__ccgo_up(dest)) = Int32FromUint64(i) case int32(SIZE_l): - *(*int32)(unsafe.Pointer(dest)) = Int32FromUint64(i) + **(**int32)(__ccgo_up(dest)) = Int32FromUint64(i) case int32(SIZE_ll): - *(*int64)(unsafe.Pointer(dest)) = Int64FromUint64(i) + **(**int64)(__ccgo_up(dest)) = Int64FromUint64(i) break } } @@ -143443,13 +143443,13 @@ func _in_set(tls *TLS, set uintptr, c int32) (r int32) { var p, v3 uintptr _, _, _ = j, p, v3 p = set - if *(*Twchar_t)(unsafe.Pointer(p)) == uint32('-') { + if **(**Twchar_t)(__ccgo_up(p)) == uint32('-') { if c == int32('-') { return int32(1) } p += 4 } else { - if *(*Twchar_t)(unsafe.Pointer(p)) == uint32(']') { + if **(**Twchar_t)(__ccgo_up(p)) == uint32(']') { if c == int32(']') { return int32(1) } @@ -143457,15 +143457,15 @@ func _in_set(tls *TLS, set uintptr, c int32) (r int32) { } } for { - if !(*(*Twchar_t)(unsafe.Pointer(p)) != 0 && *(*Twchar_t)(unsafe.Pointer(p)) != uint32(']')) { + if !(**(**Twchar_t)(__ccgo_up(p)) != 0 && **(**Twchar_t)(__ccgo_up(p)) != uint32(']')) { break } - if *(*Twchar_t)(unsafe.Pointer(p)) == uint32('-') && *(*Twchar_t)(unsafe.Pointer(p + 1*4)) != 0 && *(*Twchar_t)(unsafe.Pointer(p + 1*4)) != uint32(']') { + if **(**Twchar_t)(__ccgo_up(p)) == uint32('-') && **(**Twchar_t)(__ccgo_up(p + 1*4)) != 0 && **(**Twchar_t)(__ccgo_up(p + 1*4)) != uint32(']') { v3 = p p += 4 - j = Int32FromUint32(*(*Twchar_t)(unsafe.Pointer(v3 + uintptr(-Int32FromInt32(1))*4))) + j = Int32FromUint32(**(**Twchar_t)(__ccgo_up(v3 + uintptr(-Int32FromInt32(1))*4))) for { - if !(Uint32FromInt32(j) < *(*Twchar_t)(unsafe.Pointer(p))) { + if !(Uint32FromInt32(j) < **(**Twchar_t)(__ccgo_up(p))) { break } if c == j { @@ -143477,7 +143477,7 @@ func _in_set(tls *TLS, set uintptr, c int32) (r int32) { j = j + 1 } } - if Uint32FromInt32(c) == *(*Twchar_t)(unsafe.Pointer(p)) { + if Uint32FromInt32(c) == **(**Twchar_t)(__ccgo_up(p)) { return int32(1) } goto _1 @@ -143515,20 +143515,20 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { Xfwide(tls, f, int32(1)) p = fmt for { - if !(*(*Twchar_t)(unsafe.Pointer(p)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(p)) != 0) { break } alloc = 0 - if Xiswspace(tls, *(*Twchar_t)(unsafe.Pointer(p))) != 0 { - for Xiswspace(tls, *(*Twchar_t)(unsafe.Pointer(p + 1*4))) != 0 { + if Xiswspace(tls, **(**Twchar_t)(__ccgo_up(p))) != 0 { + for Xiswspace(tls, **(**Twchar_t)(__ccgo_up(p + 1*4))) != 0 { p += 4 } for { - if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { + if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(**(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 4 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) + v4 = uint32(**(**uint8)(__ccgo_up(v5))) } else { v4 = Xgetwc(tls, f) } @@ -143543,21 +143543,21 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v6 = f + 4 *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 v5 = *(*uintptr)(unsafe.Pointer(v6)) - _ = *(*uint8)(unsafe.Pointer(v5)) + _ = **(**uint8)(__ccgo_up(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } goto _2 } - if *(*Twchar_t)(unsafe.Pointer(p)) != uint32('%') || *(*Twchar_t)(unsafe.Pointer(p + 1*4)) == uint32('%') { - if *(*Twchar_t)(unsafe.Pointer(p)) == uint32('%') { + if **(**Twchar_t)(__ccgo_up(p)) != uint32('%') || **(**Twchar_t)(__ccgo_up(p + 1*4)) == uint32('%') { + if **(**Twchar_t)(__ccgo_up(p)) == uint32('%') { p += 4 for { - if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { + if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(**(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 4 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) + v4 = uint32(**(**uint8)(__ccgo_up(v5))) } else { v4 = Xgetwc(tls, f) } @@ -143569,22 +143569,22 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { pos = pos + 1 } } else { - if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { + if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(**(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 4 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) + v4 = uint32(**(**uint8)(__ccgo_up(v5))) } else { v4 = Xgetwc(tls, f) } c = Int32FromUint32(v4) } - if Uint32FromInt32(c) != *(*Twchar_t)(unsafe.Pointer(p)) { + if Uint32FromInt32(c) != **(**Twchar_t)(__ccgo_up(p)) { if (*TFILE)(unsafe.Pointer(f)).Frend != 0 && Uint32FromInt32(c) < uint32(128) { v6 = f + 4 *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 v5 = *(*uintptr)(unsafe.Pointer(v6)) - _ = *(*uint8)(unsafe.Pointer(v5)) + _ = **(**uint8)(__ccgo_up(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -143597,12 +143597,12 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { goto _2 } p += 4 - if *(*Twchar_t)(unsafe.Pointer(p)) == uint32('*') { + if **(**Twchar_t)(__ccgo_up(p)) == uint32('*') { dest = uintptr(0) p += 4 } else { - if BoolInt32(*(*Twchar_t)(unsafe.Pointer(p))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(p + 1*4)) == uint32('$') { - dest = _arg_n1(tls, ap, *(*Twchar_t)(unsafe.Pointer(p))-uint32('0')) + if BoolInt32(**(**Twchar_t)(__ccgo_up(p))-uint32('0') < uint32(10)) != 0 && **(**Twchar_t)(__ccgo_up(p + 1*4)) == uint32('$') { + dest = _arg_n1(tls, ap, **(**Twchar_t)(__ccgo_up(p))-uint32('0')) p = p + uintptr(2)*4 } else { dest = VaUintptr(&ap) @@ -143610,16 +143610,16 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } width = 0 for { - if !(BoolInt32(*(*Twchar_t)(unsafe.Pointer(p))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(**(**Twchar_t)(__ccgo_up(p))-uint32('0') < uint32(10)) != 0) { break } - width = Int32FromUint32(Uint32FromInt32(int32(10)*width) + *(*Twchar_t)(unsafe.Pointer(p)) - uint32('0')) + width = Int32FromUint32(Uint32FromInt32(int32(10)*width) + **(**Twchar_t)(__ccgo_up(p)) - uint32('0')) goto _18 _18: ; p += 4 } - if *(*Twchar_t)(unsafe.Pointer(p)) == uint32('m') { + if **(**Twchar_t)(__ccgo_up(p)) == uint32('m') { wcs = uintptr(0) s = uintptr(0) alloc = BoolInt32(!!(dest != 0)) @@ -143630,16 +143630,16 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { size = SIZE_def v5 = p p += 4 - switch *(*Twchar_t)(unsafe.Pointer(v5)) { + switch **(**Twchar_t)(__ccgo_up(v5)) { case uint32('h'): - if *(*Twchar_t)(unsafe.Pointer(p)) == uint32('h') { + if **(**Twchar_t)(__ccgo_up(p)) == uint32('h') { p += 4 size = -Int32FromInt32(2) } else { size = -int32(1) } case uint32('l'): - if *(*Twchar_t)(unsafe.Pointer(p)) == uint32('l') { + if **(**Twchar_t)(__ccgo_up(p)) == uint32('l') { p += 4 size = Int32FromInt32(SIZE_ll) } else { @@ -143698,7 +143698,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { default: goto fmt_fail } - t = Int32FromUint32(*(*Twchar_t)(unsafe.Pointer(p))) + t = Int32FromUint32(**(**Twchar_t)(__ccgo_up(p))) /* Transform S,C -> ls,lc */ if t&int32(0x2f) == int32(3) { size = int32(SIZE_l) @@ -143707,11 +143707,11 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if t != int32('n') { if t != int32('[') && t|int32(32) != int32('c') { for { - if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { + if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(**(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 4 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) + v4 = uint32(**(**uint8)(__ccgo_up(v5))) } else { v4 = Xgetwc(tls, f) } @@ -143723,11 +143723,11 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { pos = pos + 1 } } else { - if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { + if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(**(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 4 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) + v4 = uint32(**(**uint8)(__ccgo_up(v5))) } else { v4 = Xgetwc(tls, f) } @@ -143740,7 +143740,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v6 = f + 4 *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 v5 = *(*uintptr)(unsafe.Pointer(v6)) - _ = *(*uint8)(unsafe.Pointer(v5)) + _ = **(**uint8)(__ccgo_up(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -143768,18 +143768,18 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } else { p += 4 v5 = p - if *(*Twchar_t)(unsafe.Pointer(v5)) == uint32('^') { + if **(**Twchar_t)(__ccgo_up(v5)) == uint32('^') { p += 4 invert = Int32FromInt32(1) } else { invert = 0 } set = p - if *(*Twchar_t)(unsafe.Pointer(p)) == uint32(']') { + if **(**Twchar_t)(__ccgo_up(p)) == uint32(']') { p += 4 } - for *(*Twchar_t)(unsafe.Pointer(p)) != uint32(']') { - if !(*(*Twchar_t)(unsafe.Pointer(p)) != 0) { + for **(**Twchar_t)(__ccgo_up(p)) != uint32(']') { + if !(**(**Twchar_t)(__ccgo_up(p)) != 0) { goto fmt_fail } p += 4 @@ -143823,11 +143823,11 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } } for width != 0 { - if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { + if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(**(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 4 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) + v4 = uint32(**(**uint8)(__ccgo_up(v5))) } else { v4 = Xgetwc(tls, f) } @@ -143842,7 +143842,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if wcs != 0 { v37 = i i = i + 1 - *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(v37)*4)) = Uint32FromInt32(c) + **(**Twchar_t)(__ccgo_up(wcs + uintptr(v37)*4)) = Uint32FromInt32(c) if alloc != 0 && i == k { k = k + (k + uint32(1)) tmp1 = Xrealloc(tls, wcs, k*uint32(4)) @@ -143882,7 +143882,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v6 = f + 4 *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 v5 = *(*uintptr)(unsafe.Pointer(v6)) - _ = *(*uint8)(unsafe.Pointer(v5)) + _ = **(**uint8)(__ccgo_up(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -143892,17 +143892,17 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } if alloc != 0 { if size == int32(SIZE_l) { - *(*uintptr)(unsafe.Pointer(dest)) = wcs + **(**uintptr)(__ccgo_up(dest)) = wcs } else { - *(*uintptr)(unsafe.Pointer(dest)) = s + **(**uintptr)(__ccgo_up(dest)) = s } } if t != int32('c') { if wcs != 0 { - *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) = uint32(0) + **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) = uint32(0) } if s != 0 { - *(*uint8)(unsafe.Pointer(s + uintptr(i))) = uint8(0) + **(**uint8)(__ccgo_up(s + uintptr(i))) = uint8(0) } } case int32('d'): @@ -143938,7 +143938,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { width = 0 } Xsnprintf(tls, bp+8, uint32(22), __ccgo_ts+1503, VaList(bp+40, int32(1)+BoolInt32(!(dest != 0)), __ccgo_ts+1521, width, uintptr(unsafe.Pointer(&_size_pfx))+uintptr(size+int32(2))*3, t)) - *(*Toff_t)(unsafe.Pointer(bp)) = 0 + **(**Toff_t)(__ccgo_up(bp)) = 0 if dest != 0 { v5 = dest } else { @@ -143947,11 +143947,11 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if Xfscanf(tls, f, bp+8, VaList(bp+40, v5, bp)) == -int32(1) { goto input_fail } else { - if !(*(*Toff_t)(unsafe.Pointer(bp)) != 0) { + if !(**(**Toff_t)(__ccgo_up(bp)) != 0) { goto match_fail } } - pos = pos + *(*Toff_t)(unsafe.Pointer(bp)) + pos = pos + **(**Toff_t)(__ccgo_up(bp)) default: goto fmt_fail } @@ -144077,8 +144077,8 @@ func _sn_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { k = v1 if k != 0 { _memcpy(tls, (*Tcookie3)(unsafe.Pointer(c)).Fs, (*TFILE)(unsafe.Pointer(f)).Fwbase, k) - *(*uintptr)(unsafe.Pointer(c)) += uintptr(k) - *(*Tsize_t)(unsafe.Pointer(c + 4)) -= k + **(**uintptr)(__ccgo_up(c)) += uintptr(k) + **(**Tsize_t)(__ccgo_up(c + 4)) -= k } if (*Tcookie3)(unsafe.Pointer(c)).Fn < l { v1 = (*Tcookie3)(unsafe.Pointer(c)).Fn @@ -144088,10 +144088,10 @@ func _sn_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { k = v1 if k != 0 { _memcpy(tls, (*Tcookie3)(unsafe.Pointer(c)).Fs, s, k) - *(*uintptr)(unsafe.Pointer(c)) += uintptr(k) - *(*Tsize_t)(unsafe.Pointer(c + 4)) -= k + **(**uintptr)(__ccgo_up(c)) += uintptr(k) + **(**Tsize_t)(__ccgo_up(c + 4)) -= k } - *(*uint8)(unsafe.Pointer((*Tcookie3)(unsafe.Pointer(c)).Fs)) = uint8(0) + **(**uint8)(__ccgo_up((*Tcookie3)(unsafe.Pointer(c)).Fs)) = uint8(0) v3 = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Fwbase = v3 (*TFILE)(unsafe.Pointer(f)).Fwpos = v3 @@ -144123,18 +144123,18 @@ func Xvsnprintf(tls *TLS, s uintptr, n Tsize_t, fmt uintptr, ap Tva_list) (r int } else { v2 = uint32(0) } - *(*Tcookie3)(unsafe.Pointer(bp + 8)) = Tcookie3{ + **(**Tcookie3)(__ccgo_up(bp + 8)) = Tcookie3{ Fs: v1, Fn: v2, } - *(*TFILE)(unsafe.Pointer(bp + 16)) = TFILE{ + **(**TFILE)(__ccgo_up(bp + 16)) = TFILE{ Fwrite: __ccgo_fp(_sn_write), Fbuf: bp, Flock: -int32(1), Flbf: -int32(1), Fcookie: bp + 8, } - *(*uint8)(unsafe.Pointer((*(*Tcookie3)(unsafe.Pointer(bp + 8))).Fs)) = uint8(0) + **(**uint8)(__ccgo_up((**(**Tcookie3)(__ccgo_up(bp + 8))).Fs)) = uint8(0) return Xvfprintf(tls, bp+16, fmt, ap) } @@ -144183,7 +144183,7 @@ func Xvsscanf(tls *TLS, s uintptr, fmt uintptr, ap Tva_list) (r int32) { bp := tls.Alloc(144) defer tls.Free(144) var _ /* f at bp+0 */ TFILE - *(*TFILE)(unsafe.Pointer(bp)) = TFILE{ + **(**TFILE)(__ccgo_up(bp)) = TFILE{ Fread: __ccgo_fp(_string_read), Fbuf: s, Flock: -int32(1), @@ -144233,14 +144233,14 @@ func _sw_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { (*Tcookie4)(unsafe.Pointer(c)).Fl = (*Tcookie4)(unsafe.Pointer(c)).Fl - 1 (*Tcookie4)(unsafe.Pointer(c)).Fws += 4 } - *(*Twchar_t)(unsafe.Pointer((*Tcookie4)(unsafe.Pointer(c)).Fws)) = uint32(0) + **(**Twchar_t)(__ccgo_up((*Tcookie4)(unsafe.Pointer(c)).Fws)) = uint32(0) if i < 0 { v4 = UintptrFromInt32(0) (*TFILE)(unsafe.Pointer(f)).Fwend = v4 v3 = v4 (*TFILE)(unsafe.Pointer(f)).Fwbase = v3 (*TFILE)(unsafe.Pointer(f)).Fwpos = v3 - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) return Uint32FromInt32(i) } (*TFILE)(unsafe.Pointer(f)).Fwend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr((*TFILE)(unsafe.Pointer(f)).Fbuf_size) @@ -144262,11 +144262,11 @@ func Xvswprintf(tls *TLS, s uintptr, n Tsize_t, fmt uintptr, ap Tva_list) (r1 in var _ /* c at bp+256 */ Tcookie4 var _ /* f at bp+264 */ TFILE _, _ = r, v1 - *(*Tcookie4)(unsafe.Pointer(bp + 256)) = Tcookie4{ + **(**Tcookie4)(__ccgo_up(bp + 256)) = Tcookie4{ Fws: s, Fl: n - uint32(1), } - *(*TFILE)(unsafe.Pointer(bp + 264)) = TFILE{ + **(**TFILE)(__ccgo_up(bp + 264)) = TFILE{ Fwrite: __ccgo_fp(_sw_write), Fbuf: bp, Fbuf_size: uint32(256), @@ -144294,8 +144294,8 @@ func _wstring_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { var v1, v2 uintptr var _ /* src at bp+0 */ uintptr _, _, _ = k, v1, v2 - *(*uintptr)(unsafe.Pointer(bp)) = (*TFILE)(unsafe.Pointer(f)).Fcookie - if !(*(*uintptr)(unsafe.Pointer(bp)) != 0) { + **(**uintptr)(__ccgo_up(bp)) = (*TFILE)(unsafe.Pointer(f)).Fcookie + if !(**(**uintptr)(__ccgo_up(bp)) != 0) { return uint32(0) } k = Xwcsrtombs(tls, (*TFILE)(unsafe.Pointer(f)).Fbuf, bp, (*TFILE)(unsafe.Pointer(f)).Fbuf_size, uintptr(0)) @@ -144307,14 +144307,14 @@ func _wstring_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { } (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(k) - (*TFILE)(unsafe.Pointer(f)).Fcookie = *(*uintptr)(unsafe.Pointer(bp)) + (*TFILE)(unsafe.Pointer(f)).Fcookie = **(**uintptr)(__ccgo_up(bp)) if !(len1 != 0) || !(k != 0) { return uint32(0) } v2 = f + 4 v1 = *(*uintptr)(unsafe.Pointer(v2)) *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(v2)) + 1 - *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v1)) + **(**uint8)(__ccgo_up(buf)) = **(**uint8)(__ccgo_up(v1)) return uint32(1) } @@ -144327,7 +144327,7 @@ func Xvswscanf(tls *TLS, s uintptr, fmt uintptr, ap Tva_list) (r int32) { defer tls.Free(400) var _ /* buf at bp+0 */ [256]uint8 var _ /* f at bp+256 */ TFILE - *(*TFILE)(unsafe.Pointer(bp + 256)) = TFILE{ + **(**TFILE)(__ccgo_up(bp + 256)) = TFILE{ Fread: __ccgo_fp(_wstring_read), Fbuf: bp, Fbuf_size: uint32(256), @@ -144439,7 +144439,7 @@ func Xatoi(tls *TLS, s uintptr) (r int32) { n = 0 neg = 0 for { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(s))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _3 _3: @@ -144448,7 +144448,7 @@ func Xatoi(tls *TLS, s uintptr) (r int32) { } s = s + 1 } - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(s))) { case int32('-'): neg = int32(1) fallthrough @@ -144456,10 +144456,10 @@ func Xatoi(tls *TLS, s uintptr) (r int32) { s = s + 1 } /* Compute n as a negative number to avoid overflow on INT_MIN */ - for BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { + for BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-uint32('0') < uint32(10)) != 0 { v4 = s s = s + 1 - n = int32(10)*n - (Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) - int32('0')) + n = int32(10)*n - (Int32FromUint8(**(**uint8)(__ccgo_up(v4))) - int32('0')) } if neg != 0 { v1 = n @@ -144480,7 +144480,7 @@ func Xatol(tls *TLS, s uintptr) (r int32) { n = 0 neg = 0 for { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(s))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _3 _3: @@ -144489,7 +144489,7 @@ func Xatol(tls *TLS, s uintptr) (r int32) { } s = s + 1 } - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(s))) { case int32('-'): neg = int32(1) fallthrough @@ -144497,10 +144497,10 @@ func Xatol(tls *TLS, s uintptr) (r int32) { s = s + 1 } /* Compute n as a negative number to avoid overflow on LONG_MIN */ - for BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { + for BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-uint32('0') < uint32(10)) != 0 { v4 = s s = s + 1 - n = int32(10)*n - int32(Int32FromUint8(*(*uint8)(unsafe.Pointer(v4)))-Int32FromUint8('0')) + n = int32(10)*n - int32(Int32FromUint8(**(**uint8)(__ccgo_up(v4)))-Int32FromUint8('0')) } if neg != 0 { v1 = n @@ -144522,7 +144522,7 @@ func Xatoll(tls *TLS, s uintptr) (r int64) { n = 0 neg = 0 for { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(s))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _3 _3: @@ -144531,7 +144531,7 @@ func Xatoll(tls *TLS, s uintptr) (r int64) { } s = s + 1 } - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(s))) { case int32('-'): neg = int32(1) fallthrough @@ -144539,10 +144539,10 @@ func Xatoll(tls *TLS, s uintptr) (r int64) { s = s + 1 } /* Compute n as a negative number to avoid overflow on LLONG_MIN */ - for BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { + for BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-uint32('0') < uint32(10)) != 0 { v4 = s s = s + 1 - n = int64(10)*n - int64(Int32FromUint8(*(*uint8)(unsafe.Pointer(v4)))-Int32FromUint8('0')) + n = int64(10)*n - int64(Int32FromUint8(**(**uint8)(__ccgo_up(v4)))-Int32FromUint8('0')) } if neg != 0 { v5 = n @@ -144604,24 +144604,24 @@ func Xecvt(tls *TLS, x float64, n int32, dp uintptr, sign uintptr) (r uintptr) { n = int32(15) } Xsprintf(tls, bp, __ccgo_ts+1524, VaList(bp+40, n-int32(1), x)) - v1 = BoolInt32(Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp)))[0]) == Int32FromUint8('-')) - *(*int32)(unsafe.Pointer(sign)) = v1 + v1 = BoolInt32(Int32FromUint8((**(**[32]uint8)(__ccgo_up(bp)))[0]) == Int32FromUint8('-')) + **(**int32)(__ccgo_up(sign)) = v1 i = v1 j = 0 for { - if !(Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp)))[i]) != int32('e')) { + if !(Int32FromUint8((**(**[32]uint8)(__ccgo_up(bp)))[i]) != int32('e')) { break } - _buf8[j] = (*(*[32]uint8)(unsafe.Pointer(bp)))[i] + _buf8[j] = (**(**[32]uint8)(__ccgo_up(bp)))[i] goto _2 _2: ; v1 = i i = i + 1 - j = j + BoolInt32(Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp)))[v1]) != int32('.')) + j = j + BoolInt32(Int32FromUint8((**(**[32]uint8)(__ccgo_up(bp)))[v1]) != int32('.')) } _buf8[j] = uint8(0) - *(*int32)(unsafe.Pointer(dp)) = Xatoi(tls, bp+uintptr(i)+uintptr(1)) + int32(1) + **(**int32)(__ccgo_up(dp)) = Xatoi(tls, bp+uintptr(i)+uintptr(1)) + int32(1) return uintptr(unsafe.Pointer(&_buf8)) } @@ -144641,15 +144641,15 @@ func Xfcvt(tls *TLS, x float64, n int32, dp uintptr, sign uintptr) (r uintptr) { n = int32(1400) } Xsprintf(tls, bp, __ccgo_ts+1529, VaList(bp+1512, n, x)) - i = BoolInt32(Int32FromUint8((*(*[1500]uint8)(unsafe.Pointer(bp)))[0]) == int32('-')) - if Int32FromUint8((*(*[1500]uint8)(unsafe.Pointer(bp)))[i]) == int32('0') { + i = BoolInt32(Int32FromUint8((**(**[1500]uint8)(__ccgo_up(bp)))[0]) == int32('-')) + if Int32FromUint8((**(**[1500]uint8)(__ccgo_up(bp)))[i]) == int32('0') { lz = Int32FromUint32(Xstrspn(tls, bp+uintptr(i)+uintptr(2), __ccgo_ts+1497)) } else { lz = -Int32FromUint32(Xstrcspn(tls, bp+uintptr(i), __ccgo_ts+483)) } if n <= lz { - *(*int32)(unsafe.Pointer(sign)) = i - *(*int32)(unsafe.Pointer(dp)) = int32(1) + **(**int32)(__ccgo_up(sign)) = i + **(**int32)(__ccgo_up(dp)) = int32(1) if Uint32FromInt32(n) > uint32(14) { n = int32(14) } @@ -144755,7 +144755,7 @@ func _pntz(tls *TLS, p uintptr) (r1 int32) { var v11, v4 Tuint32_t var v14 bool _, _, _, _, _, _, _, _, _, _, _ = r, v1, v11, v12, v14, v2, v4, v5, v7, v8, v9 - v1 = uint32(*(*Tsize_t)(unsafe.Pointer(p)) - Uint32FromInt32(1)) + v1 = uint32(**(**Tsize_t)(__ccgo_up(p)) - Uint32FromInt32(1)) v4 = v1 v5 = int32(31) - _a_clz_32(tls, v4&-v4) goto _6 @@ -144765,7 +144765,7 @@ _6: _3: r = v2 if v14 = r != 0; !v14 { - v8 = *(*Tsize_t)(unsafe.Pointer(p + 1*4)) + v8 = uint32(**(**Tsize_t)(__ccgo_up(p + 1*4))) v11 = v8 v12 = int32(31) - _a_clz_32(tls, v11&-v11) goto _13 @@ -144793,7 +144793,7 @@ func _cycle(tls *TLS, width Tsize_t, ar uintptr, n int32) { if n < int32(2) { return } - *(*uintptr)(unsafe.Pointer(ar + uintptr(n)*4)) = bp + **(**uintptr)(__ccgo_up(ar + uintptr(n)*4)) = bp for width != 0 { if uint32(256) < width { v1 = uint32(256) @@ -144801,14 +144801,14 @@ func _cycle(tls *TLS, width Tsize_t, ar uintptr, n int32) { v1 = width } l = v1 - _memcpy(tls, *(*uintptr)(unsafe.Pointer(ar + uintptr(n)*4)), *(*uintptr)(unsafe.Pointer(ar)), l) + _memcpy(tls, **(**uintptr)(__ccgo_up(ar + uintptr(n)*4)), **(**uintptr)(__ccgo_up(ar)), l) i = 0 for { if !(i < n) { break } - _memcpy(tls, *(*uintptr)(unsafe.Pointer(ar + uintptr(i)*4)), *(*uintptr)(unsafe.Pointer(ar + uintptr(i+int32(1))*4)), l) - *(*uintptr)(unsafe.Pointer(ar + uintptr(i)*4)) += uintptr(l) + _memcpy(tls, **(**uintptr)(__ccgo_up(ar + uintptr(i)*4)), **(**uintptr)(__ccgo_up(ar + uintptr(i+int32(1))*4)), l) + **(**uintptr)(__ccgo_up(ar + uintptr(i)*4)) += uintptr(l) goto _2 _2: ; @@ -144824,23 +144824,23 @@ func _cycle(tls *TLS, width Tsize_t, ar uintptr, n int32) { func _shl(tls *TLS, p uintptr, n int32) { if Uint32FromInt32(n) >= Uint32FromInt32(8)*Uint32FromInt64(4) { n = Int32FromUint32(uint32(n) - Uint32FromInt32(8)*Uint32FromInt64(4)) - *(*Tsize_t)(unsafe.Pointer(p + 1*4)) = *(*Tsize_t)(unsafe.Pointer(p)) - *(*Tsize_t)(unsafe.Pointer(p)) = uint32(0) + **(**Tsize_t)(__ccgo_up(p + 1*4)) = **(**Tsize_t)(__ccgo_up(p)) + **(**Tsize_t)(__ccgo_up(p)) = uint32(0) } - *(*Tsize_t)(unsafe.Pointer(p + 1*4)) <<= Uint32FromInt32(n) - *(*Tsize_t)(unsafe.Pointer(p + 1*4)) |= *(*Tsize_t)(unsafe.Pointer(p)) >> (Uint32FromInt64(4)*Uint32FromInt32(8) - Uint32FromInt32(n)) - *(*Tsize_t)(unsafe.Pointer(p)) <<= Uint32FromInt32(n) + **(**Tsize_t)(__ccgo_up(p + 1*4)) <<= Uint32FromInt32(n) + **(**Tsize_t)(__ccgo_up(p + 1*4)) |= **(**Tsize_t)(__ccgo_up(p)) >> (Uint32FromInt64(4)*Uint32FromInt32(8) - Uint32FromInt32(n)) + **(**Tsize_t)(__ccgo_up(p)) <<= Uint32FromInt32(n) } func _shr(tls *TLS, p uintptr, n int32) { if Uint32FromInt32(n) >= Uint32FromInt32(8)*Uint32FromInt64(4) { n = Int32FromUint32(uint32(n) - Uint32FromInt32(8)*Uint32FromInt64(4)) - *(*Tsize_t)(unsafe.Pointer(p)) = *(*Tsize_t)(unsafe.Pointer(p + 1*4)) - *(*Tsize_t)(unsafe.Pointer(p + 1*4)) = uint32(0) + **(**Tsize_t)(__ccgo_up(p)) = **(**Tsize_t)(__ccgo_up(p + 1*4)) + **(**Tsize_t)(__ccgo_up(p + 1*4)) = uint32(0) } - *(*Tsize_t)(unsafe.Pointer(p)) >>= Uint32FromInt32(n) - *(*Tsize_t)(unsafe.Pointer(p)) |= *(*Tsize_t)(unsafe.Pointer(p + 1*4)) << (Uint32FromInt64(4)*Uint32FromInt32(8) - Uint32FromInt32(n)) - *(*Tsize_t)(unsafe.Pointer(p + 1*4)) >>= Uint32FromInt32(n) + **(**Tsize_t)(__ccgo_up(p)) >>= Uint32FromInt32(n) + **(**Tsize_t)(__ccgo_up(p)) |= **(**Tsize_t)(__ccgo_up(p + 1*4)) << (Uint32FromInt64(4)*Uint32FromInt32(8) - Uint32FromInt32(n)) + **(**Tsize_t)(__ccgo_up(p + 1*4)) >>= Uint32FromInt32(n) } func _sift(tls *TLS, head uintptr, width Tsize_t, __ccgo_fp_cmp Tcmpfun, arg uintptr, pshift int32, lp uintptr) { @@ -144851,23 +144851,23 @@ func _sift(tls *TLS, head uintptr, width Tsize_t, __ccgo_fp_cmp Tcmpfun, arg uin var _ /* ar at bp+0 */ [57]uintptr _, _, _, _ = i, lf, rt, v1 i = int32(1) - (*(*[57]uintptr)(unsafe.Pointer(bp)))[0] = head + (**(**[57]uintptr)(__ccgo_up(bp)))[0] = head for pshift > int32(1) { rt = head - uintptr(width) - lf = head - uintptr(width) - uintptr(*(*Tsize_t)(unsafe.Pointer(lp + uintptr(pshift-int32(2))*4))) - if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, (*(*[57]uintptr)(unsafe.Pointer(bp)))[0], lf, arg) >= 0 && (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, (*(*[57]uintptr)(unsafe.Pointer(bp)))[0], rt, arg) >= 0 { + lf = head - uintptr(width) - uintptr(**(**Tsize_t)(__ccgo_up(lp + uintptr(pshift-int32(2))*4))) + if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, (**(**[57]uintptr)(__ccgo_up(bp)))[0], lf, arg) >= 0 && (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, (**(**[57]uintptr)(__ccgo_up(bp)))[0], rt, arg) >= 0 { break } if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, lf, rt, arg) >= 0 { v1 = i i = i + 1 - (*(*[57]uintptr)(unsafe.Pointer(bp)))[v1] = lf + (**(**[57]uintptr)(__ccgo_up(bp)))[v1] = lf head = lf pshift = pshift - int32(1) } else { v1 = i i = i + 1 - (*(*[57]uintptr)(unsafe.Pointer(bp)))[v1] = rt + (**(**[57]uintptr)(__ccgo_up(bp)))[v1] = rt head = rt pshift = pshift - int32(2) } @@ -144884,24 +144884,24 @@ func _trinkle(tls *TLS, head uintptr, width Tsize_t, __ccgo_fp_cmp Tcmpfun, arg var _ /* p at bp+0 */ [2]Tsize_t _, _, _, _, _, _ = i, lf, rt, stepson, trail, v1 i = int32(1) - (*(*[2]Tsize_t)(unsafe.Pointer(bp)))[0] = *(*Tsize_t)(unsafe.Pointer(pp)) - (*(*[2]Tsize_t)(unsafe.Pointer(bp)))[int32(1)] = *(*Tsize_t)(unsafe.Pointer(pp + 1*4)) - (*(*[57]uintptr)(unsafe.Pointer(bp + 8)))[0] = head - for (*(*[2]Tsize_t)(unsafe.Pointer(bp)))[0] != uint32(1) || (*(*[2]Tsize_t)(unsafe.Pointer(bp)))[int32(1)] != uint32(0) { - stepson = head - uintptr(*(*Tsize_t)(unsafe.Pointer(lp + uintptr(pshift)*4))) - if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, stepson, (*(*[57]uintptr)(unsafe.Pointer(bp + 8)))[0], arg) <= 0 { + (**(**[2]Tsize_t)(__ccgo_up(bp)))[0] = **(**Tsize_t)(__ccgo_up(pp)) + (**(**[2]Tsize_t)(__ccgo_up(bp)))[int32(1)] = **(**Tsize_t)(__ccgo_up(pp + 1*4)) + (**(**[57]uintptr)(__ccgo_up(bp + 8)))[0] = head + for (**(**[2]Tsize_t)(__ccgo_up(bp)))[0] != uint32(1) || (**(**[2]Tsize_t)(__ccgo_up(bp)))[int32(1)] != uint32(0) { + stepson = head - uintptr(**(**Tsize_t)(__ccgo_up(lp + uintptr(pshift)*4))) + if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, stepson, (**(**[57]uintptr)(__ccgo_up(bp + 8)))[0], arg) <= 0 { break } if !(trusty != 0) && pshift > int32(1) { rt = head - uintptr(width) - lf = head - uintptr(width) - uintptr(*(*Tsize_t)(unsafe.Pointer(lp + uintptr(pshift-int32(2))*4))) + lf = head - uintptr(width) - uintptr(**(**Tsize_t)(__ccgo_up(lp + uintptr(pshift-int32(2))*4))) if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, rt, stepson, arg) >= 0 || (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, lf, stepson, arg) >= 0 { break } } v1 = i i = i + 1 - (*(*[57]uintptr)(unsafe.Pointer(bp + 8)))[v1] = stepson + (**(**[57]uintptr)(__ccgo_up(bp + 8)))[v1] = stepson head = stepson trail = _pntz(tls, bp) _shr(tls, bp, trail) @@ -144929,7 +144929,7 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm var _ /* p at bp+192 */ [2]Tsize_t _, _, _, _, _, _, _, _ = head, high, i, pshift, size, trail, v2, v3 size = width * nel - *(*[2]Tsize_t)(unsafe.Pointer(bp + 192)) = [2]Tsize_t{ + **(**[2]Tsize_t)(__ccgo_up(bp + 192)) = [2]Tsize_t{ 0: uint32(1), } pshift = int32(1) @@ -144940,12 +144940,12 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm high = head + uintptr(size) - uintptr(width) /* Precompute Leonardo numbers, scaled by element width */ v2 = width - (*(*[48]Tsize_t)(unsafe.Pointer(bp)))[int32(1)] = v2 - (*(*[48]Tsize_t)(unsafe.Pointer(bp)))[0] = v2 + (**(**[48]Tsize_t)(__ccgo_up(bp)))[int32(1)] = v2 + (**(**[48]Tsize_t)(__ccgo_up(bp)))[0] = v2 i = Uint32FromInt32(2) for { - v3 = (*(*[48]Tsize_t)(unsafe.Pointer(bp)))[i-uint32(2)] + (*(*[48]Tsize_t)(unsafe.Pointer(bp)))[i-uint32(1)] + width - (*(*[48]Tsize_t)(unsafe.Pointer(bp)))[i] = v3 + v3 = (**(**[48]Tsize_t)(__ccgo_up(bp)))[i-uint32(2)] + (**(**[48]Tsize_t)(__ccgo_up(bp)))[i-uint32(1)] + width + (**(**[48]Tsize_t)(__ccgo_up(bp)))[i] = v3 if !(v3 < size) { break } @@ -144955,12 +144955,12 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm i = i + 1 } for head < high { - if (*(*[2]Tsize_t)(unsafe.Pointer(bp + 192)))[0]&uint32(3) == uint32(3) { + if (**(**[2]Tsize_t)(__ccgo_up(bp + 192)))[0]&uint32(3) == uint32(3) { _sift(tls, head, width, __ccgo_fp_cmp, arg, pshift, bp) _shr(tls, bp+192, int32(2)) pshift = pshift + int32(2) } else { - if (*(*[48]Tsize_t)(unsafe.Pointer(bp)))[pshift-int32(1)] >= Uint32FromInt32(int32(high)-int32(head)) { + if (**(**[48]Tsize_t)(__ccgo_up(bp)))[pshift-int32(1)] >= Uint32FromInt32(int32(high)-int32(head)) { _trinkle(tls, head, width, __ccgo_fp_cmp, arg, bp+192, pshift, 0, bp) } else { _sift(tls, head, width, __ccgo_fp_cmp, arg, pshift, bp) @@ -144973,11 +144973,11 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm pshift = int32(1) } } - *(*Tsize_t)(unsafe.Pointer(bp + 192)) |= uint32(1) + **(**Tsize_t)(__ccgo_up(bp + 192)) |= uint32(1) head = head + uintptr(width) } _trinkle(tls, head, width, __ccgo_fp_cmp, arg, bp+192, pshift, 0, bp) - for pshift != int32(1) || (*(*[2]Tsize_t)(unsafe.Pointer(bp + 192)))[0] != uint32(1) || (*(*[2]Tsize_t)(unsafe.Pointer(bp + 192)))[int32(1)] != uint32(0) { + for pshift != int32(1) || (**(**[2]Tsize_t)(__ccgo_up(bp + 192)))[0] != uint32(1) || (**(**[2]Tsize_t)(__ccgo_up(bp + 192)))[int32(1)] != uint32(0) { if pshift <= int32(1) { trail = _pntz(tls, bp+192) _shr(tls, bp+192, trail) @@ -144985,11 +144985,11 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm } else { _shl(tls, bp+192, int32(2)) pshift = pshift - int32(2) - *(*Tsize_t)(unsafe.Pointer(bp + 192)) ^= uint32(7) + **(**Tsize_t)(__ccgo_up(bp + 192)) ^= uint32(7) _shr(tls, bp+192, int32(1)) - _trinkle(tls, head-uintptr((*(*[48]Tsize_t)(unsafe.Pointer(bp)))[pshift])-uintptr(width), width, __ccgo_fp_cmp, arg, bp+192, pshift+int32(1), int32(1), bp) + _trinkle(tls, head-uintptr((**(**[48]Tsize_t)(__ccgo_up(bp)))[pshift])-uintptr(width), width, __ccgo_fp_cmp, arg, bp+192, pshift+int32(1), int32(1), bp) _shl(tls, bp+192, int32(1)) - *(*Tsize_t)(unsafe.Pointer(bp + 192)) |= uint32(1) + **(**Tsize_t)(__ccgo_up(bp + 192)) |= uint32(1) _trinkle(tls, head-uintptr(width), width, __ccgo_fp_cmp, arg, bp+192, pshift, int32(1), bp) } head = head - uintptr(width) @@ -145039,7 +145039,7 @@ func _strtox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { } else { v1 = s } - *(*uintptr)(unsafe.Pointer(p)) = v1 + **(**uintptr)(__ccgo_up(p)) = v1 } return y } @@ -145084,7 +145084,7 @@ func _strtox1(tls *TLS, s uintptr, p uintptr, base int32, lim uint64) (r uint64) y = X__intscan(tls, bp, Uint32FromInt32(base), int32(1), lim) if p != 0 { cnt = Uint32FromInt64((*TFILE)(unsafe.Pointer(bp)).Fshcnt + int64(int32((*TFILE)(unsafe.Pointer(bp)).Frpos)-int32((*TFILE)(unsafe.Pointer(bp)).Fbuf))) - *(*uintptr)(unsafe.Pointer(p)) = s + uintptr(cnt) + **(**uintptr)(__ccgo_up(p)) = s + uintptr(cnt) } return y } @@ -145195,20 +145195,20 @@ func _do_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { var v2 uint32 _, _, _, _, _ = i, wcs, v2, v3, v4 wcs = (*TFILE)(unsafe.Pointer(f)).Fcookie - if !(*(*Twchar_t)(unsafe.Pointer(wcs)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(wcs)) != 0) { wcs = __ccgo_ts + 1555 } i = uint32(0) for { - if !(i < (*TFILE)(unsafe.Pointer(f)).Fbuf_size && *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) != 0) { + if !(i < (*TFILE)(unsafe.Pointer(f)).Fbuf_size && **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) != 0) { break } - if *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) < uint32(128) { - v2 = *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) + if **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) < uint32(128) { + v2 = **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) } else { v2 = uint32('@') } - *(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(i))) = uint8(v2) + **(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(i))) = uint8(v2) goto _1 _1: ; @@ -145221,7 +145221,7 @@ func _do_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(buf)) = **(**uint8)(__ccgo_up(v3)) return uint32(1) } return uint32(0) @@ -145237,20 +145237,20 @@ func _wcstox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { var _ /* f at bp+64 */ TFILE _, _, _, _, _ = cnt, t, y, v1, v2 t = s - *(*TFILE)(unsafe.Pointer(bp + 64)) = TFILE{} - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fflags = uint32(0) + **(**TFILE)(__ccgo_up(bp + 64)) = TFILE{} + (**(**TFILE)(__ccgo_up(bp + 64))).Fflags = uint32(0) v2 = bp + UintptrFromInt32(4) - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fbuf = v2 + (**(**TFILE)(__ccgo_up(bp + 64))).Fbuf = v2 v1 = v2 - (*(*TFILE)(unsafe.Pointer(bp + 64))).Frend = v1 - (*(*TFILE)(unsafe.Pointer(bp + 64))).Frpos = v1 - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fbuf_size = Uint32FromInt64(64) - Uint32FromInt32(4) + (**(**TFILE)(__ccgo_up(bp + 64))).Frend = v1 + (**(**TFILE)(__ccgo_up(bp + 64))).Frpos = v1 + (**(**TFILE)(__ccgo_up(bp + 64))).Fbuf_size = Uint32FromInt64(64) - Uint32FromInt32(4) AtomicStorePInt32(bp+64+76, -int32(1)) - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fread = __ccgo_fp(_do_read) - for Xiswspace(tls, *(*Twchar_t)(unsafe.Pointer(t))) != 0 { + (**(**TFILE)(__ccgo_up(bp + 64))).Fread = __ccgo_fp(_do_read) + for Xiswspace(tls, **(**Twchar_t)(__ccgo_up(t))) != 0 { t += 4 } - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fcookie = t + (**(**TFILE)(__ccgo_up(bp + 64))).Fcookie = t X__shlim(tls, bp+64, int64(Int32FromInt32(0))) y = X__floatscan(tls, bp+64, prec, int32(1)) if p != 0 { @@ -145260,7 +145260,7 @@ func _wcstox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { } else { v1 = s } - *(*uintptr)(unsafe.Pointer(p)) = v1 + **(**uintptr)(__ccgo_up(p)) = v1 } return y } @@ -145299,20 +145299,20 @@ func _do_read1(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { var v2 uint32 _, _, _, _, _ = i, wcs, v2, v3, v4 wcs = (*TFILE)(unsafe.Pointer(f)).Fcookie - if !(*(*Twchar_t)(unsafe.Pointer(wcs)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(wcs)) != 0) { wcs = __ccgo_ts + 1555 } i = uint32(0) for { - if !(i < (*TFILE)(unsafe.Pointer(f)).Fbuf_size && *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) != 0) { + if !(i < (*TFILE)(unsafe.Pointer(f)).Fbuf_size && **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) != 0) { break } - if *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) < uint32(128) { - v2 = *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) + if **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) < uint32(128) { + v2 = **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) } else { v2 = uint32('@') } - *(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(i))) = uint8(v2) + **(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(i))) = uint8(v2) goto _1 _1: ; @@ -145325,7 +145325,7 @@ func _do_read1(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(buf)) = **(**uint8)(__ccgo_up(v3)) return uint32(1) } return uint32(0) @@ -145341,20 +145341,20 @@ func _wcstox1(tls *TLS, s uintptr, p uintptr, base int32, lim uint64) (r uint64) var _ /* f at bp+64 */ TFILE _, _, _, _, _ = cnt, t, y, v1, v2 t = s - *(*TFILE)(unsafe.Pointer(bp + 64)) = TFILE{} - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fflags = uint32(0) + **(**TFILE)(__ccgo_up(bp + 64)) = TFILE{} + (**(**TFILE)(__ccgo_up(bp + 64))).Fflags = uint32(0) v2 = bp + UintptrFromInt32(4) - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fbuf = v2 + (**(**TFILE)(__ccgo_up(bp + 64))).Fbuf = v2 v1 = v2 - (*(*TFILE)(unsafe.Pointer(bp + 64))).Frend = v1 - (*(*TFILE)(unsafe.Pointer(bp + 64))).Frpos = v1 - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fbuf_size = Uint32FromInt64(64) - Uint32FromInt32(4) + (**(**TFILE)(__ccgo_up(bp + 64))).Frend = v1 + (**(**TFILE)(__ccgo_up(bp + 64))).Frpos = v1 + (**(**TFILE)(__ccgo_up(bp + 64))).Fbuf_size = Uint32FromInt64(64) - Uint32FromInt32(4) AtomicStorePInt32(bp+64+76, -int32(1)) - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fread = __ccgo_fp(_do_read1) - for Xiswspace(tls, *(*Twchar_t)(unsafe.Pointer(t))) != 0 { + (**(**TFILE)(__ccgo_up(bp + 64))).Fread = __ccgo_fp(_do_read1) + for Xiswspace(tls, **(**Twchar_t)(__ccgo_up(t))) != 0 { t += 4 } - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fcookie = t + (**(**TFILE)(__ccgo_up(bp + 64))).Fcookie = t X__shlim(tls, bp+64, int64(Int32FromInt32(0))) y = X__intscan(tls, bp+64, Uint32FromInt32(base), int32(1), lim) if p != 0 { @@ -145364,7 +145364,7 @@ func _wcstox1(tls *TLS, s uintptr, p uintptr, base int32, lim uint64) (r uint64) } else { v1 = s } - *(*uintptr)(unsafe.Pointer(p)) = v1 + **(**uintptr)(__ccgo_up(p)) = v1 } return y } @@ -145483,8 +145483,8 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt if uint32(s)&(Uint32FromInt64(4)-Uint32FromInt32(1)) == uint32(d)&(Uint32FromInt64(4)-Uint32FromInt32(1)) { for { if v3 = uint32(s)&(Uint32FromInt64(4)-Uint32FromInt32(1)) != 0 && n != 0; v3 { - v2 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v2 + v2 = **(**uint8)(__ccgo_up(s)) + **(**uint8)(__ccgo_up(d)) = v2 } if !(v3 && Int32FromUint8(v2) != c) { break @@ -145503,10 +145503,10 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt wd = d ws = s for { - if !(n >= uint32(4) && !((*(*uint32)(unsafe.Pointer(ws))^k-Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)) & ^(*(*uint32)(unsafe.Pointer(ws))^k) & (Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)*Uint32FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { + if !(n >= uint32(4) && !((**(**uint32)(__ccgo_up(ws))^k-Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)) & ^(**(**uint32)(__ccgo_up(ws))^k) & (Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)*Uint32FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { break } - *(*uint32)(unsafe.Pointer(wd)) = *(*uint32)(unsafe.Pointer(ws)) + **(**uint32)(__ccgo_up(wd)) = **(**uint32)(__ccgo_up(ws)) goto _4 _4: ; @@ -145519,8 +145519,8 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt } for { if v3 = n != 0; v3 { - v2 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v2 + v2 = **(**uint8)(__ccgo_up(s)) + **(**uint8)(__ccgo_up(d)) = v2 } if !(v3 && Int32FromUint8(v2) != c) { break @@ -145563,7 +145563,7 @@ func Xmemchr(tls *TLS, src uintptr, c int32, n Tsize_t) (r uintptr) { s = src c = Int32FromUint8(Uint8FromInt32(c)) for { - if !(uint32(s)&(Uint32FromInt64(4)-Uint32FromInt32(1)) != 0 && n != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != c) { + if !(uint32(s)&(Uint32FromInt64(4)-Uint32FromInt32(1)) != 0 && n != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != c) { break } goto _1 @@ -145572,11 +145572,11 @@ func Xmemchr(tls *TLS, src uintptr, c int32, n Tsize_t) (r uintptr) { s = s + 1 n = n - 1 } - if n != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != c { + if n != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != c { k = Uint32FromInt32(-Int32FromInt32(1)) / Uint32FromInt32(UCHAR_MAX) * Uint32FromInt32(c) w = s for { - if !(n >= Uint32FromInt64(4) && !((*(*uint32)(unsafe.Pointer(w))^k-Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)) & ^(*(*uint32)(unsafe.Pointer(w))^k) & (Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)*Uint32FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { + if !(n >= Uint32FromInt64(4) && !((**(**uint32)(__ccgo_up(w))^k-Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)) & ^(**(**uint32)(__ccgo_up(w))^k) & (Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)*Uint32FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { break } goto _2 @@ -145588,7 +145588,7 @@ func Xmemchr(tls *TLS, src uintptr, c int32, n Tsize_t) (r uintptr) { s = w } for { - if !(n != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != c) { + if !(n != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != c) { break } goto _3 @@ -145616,7 +145616,7 @@ func Xmemcmp(tls *TLS, vl uintptr, vr uintptr, n Tsize_t) (r1 int32) { l = vl r = vr for { - if !(n != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))) { + if !(n != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(l))) == Int32FromUint8(**(**uint8)(__ccgo_up(r)))) { break } goto _1 @@ -145627,7 +145627,7 @@ func Xmemcmp(tls *TLS, vl uintptr, vr uintptr, n Tsize_t) (r1 int32) { r = r + 1 } if n != 0 { - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(l))) - Int32FromUint8(**(**uint8)(__ccgo_up(r))) } else { v2 = 0 } @@ -145638,8 +145638,8 @@ func _twobyte_memmem(tls *TLS, h uintptr, k Tsize_t, n uintptr) (r uintptr) { var hw, nw Tuint16_t var v2 uintptr _, _, _ = hw, nw, v2 - nw = Uint16FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(n)))< Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(ip+k)))) > Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(jp+k)))) { jp = jp + k k = uint32(1) p = jp - ip @@ -145787,7 +145787,7 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin p = v2 k = v2 for jp+k < l { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(ip+k)))) == Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(jp+k)))) { if k == p { jp = jp + p k = uint32(1) @@ -145795,7 +145795,7 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin k = k + 1 } } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) < Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(ip+k)))) < Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(jp+k)))) { jp = jp + k k = uint32(1) p = jp - ip @@ -145834,8 +145834,8 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin return uintptr(0) } /* Check last byte first; advance by shift on mismatch */ - if (*(*[8]Tsize_t)(unsafe.Pointer(bp)))[uint32(*(*uint8)(unsafe.Pointer(h + uintptr(l-uint32(1)))))/(Uint32FromInt32(8)*Uint32FromInt64(4))]&(Uint32FromInt32(1)<<(uint32(*(*uint8)(unsafe.Pointer(h + uintptr(l-uint32(1)))))%(Uint32FromInt32(8)*Uint32FromInt64(4)))) != 0 { - k = l - shift[*(*uint8)(unsafe.Pointer(h + uintptr(l-uint32(1))))] + if (**(**[8]Tsize_t)(__ccgo_up(bp)))[uint32(**(**uint8)(__ccgo_up(h + uintptr(l-uint32(1)))))/(Uint32FromInt32(8)*Uint32FromInt64(4))]&(Uint32FromInt32(1)<<(uint32(**(**uint8)(__ccgo_up(h + uintptr(l-uint32(1)))))%(Uint32FromInt32(8)*Uint32FromInt64(4)))) != 0 { + k = l - shift[**(**uint8)(__ccgo_up(h + uintptr(l-uint32(1))))] if k != 0 { if k < mem { k = mem @@ -145857,7 +145857,7 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin } k = v8 for { - if !(k < l && Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(h + uintptr(k))))) { + if !(k < l && Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(k)))) == Int32FromUint8(**(**uint8)(__ccgo_up(h + uintptr(k))))) { break } goto _10 @@ -145873,7 +145873,7 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin /* Compare left half */ k = ms + uint32(1) for { - if !(k > mem && Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(k-uint32(1))))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(h + uintptr(k-uint32(1)))))) { + if !(k > mem && Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(k-uint32(1))))) == Int32FromUint8(**(**uint8)(__ccgo_up(h + uintptr(k-uint32(1)))))) { break } goto _12 @@ -145910,7 +145910,7 @@ func Xmemmem(tls *TLS, h0 uintptr, k Tsize_t, n0 uintptr, l Tsize_t) (r uintptr) return uintptr(0) } /* Use faster algorithms for short needles */ - h = Xmemchr(tls, h0, Int32FromUint8(*(*uint8)(unsafe.Pointer(n))), k) + h = Xmemchr(tls, h0, Int32FromUint8(**(**uint8)(__ccgo_up(n))), k) if !(h != 0) || l == uint32(1) { return h } @@ -145962,13 +145962,13 @@ func Xmemmove(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) } for { if !(n >= Uint32FromInt64(4)) { break } - *(*TWT)(unsafe.Pointer(d)) = *(*TWT)(unsafe.Pointer(s)) + **(**TWT)(__ccgo_up(d)) = **(**TWT)(__ccgo_up(s)) goto _4 _4: ; @@ -145985,7 +145985,7 @@ func Xmemmove(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) goto _5 _5: ; @@ -145999,16 +145999,16 @@ func Xmemmove(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { if !(v1 != 0) { return dest } - *(*uint8)(unsafe.Pointer(d + uintptr(n))) = *(*uint8)(unsafe.Pointer(s + uintptr(n))) + **(**uint8)(__ccgo_up(d + uintptr(n))) = **(**uint8)(__ccgo_up(s + uintptr(n))) } for n >= Uint32FromInt64(4) { n = n - Uint32FromInt64(4) - *(*TWT)(unsafe.Pointer(d + uintptr(n))) = *(*TWT)(unsafe.Pointer(s + uintptr(n))) + **(**TWT)(__ccgo_up(d + uintptr(n))) = **(**TWT)(__ccgo_up(s + uintptr(n))) } } for n != 0 { n = n - 1 - *(*uint8)(unsafe.Pointer(d + uintptr(n))) = *(*uint8)(unsafe.Pointer(s + uintptr(n))) + **(**uint8)(__ccgo_up(d + uintptr(n))) = **(**uint8)(__ccgo_up(s + uintptr(n))) } } return dest @@ -146038,7 +146038,7 @@ func X__memrchr(tls *TLS, m uintptr, c int32, n Tsize_t) (r uintptr) { if !(v1 != 0) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(n)))) == c { + if Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(n)))) == c { return s + uintptr(n) } } @@ -146070,20 +146070,20 @@ func Xmemset(tls *TLS, dest uintptr, c int32, n Tsize_t) (r uintptr) { if !(n != 0) { return dest } - *(*uint8)(unsafe.Pointer(s)) = Uint8FromInt32(c) - *(*uint8)(unsafe.Pointer(s + uintptr(n-uint32(1)))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s)) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + uintptr(n-uint32(1)))) = Uint8FromInt32(c) if n <= uint32(2) { return dest } - *(*uint8)(unsafe.Pointer(s + 1)) = Uint8FromInt32(c) - *(*uint8)(unsafe.Pointer(s + 2)) = Uint8FromInt32(c) - *(*uint8)(unsafe.Pointer(s + uintptr(n-uint32(2)))) = Uint8FromInt32(c) - *(*uint8)(unsafe.Pointer(s + uintptr(n-uint32(3)))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + 1)) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + 2)) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + uintptr(n-uint32(2)))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + uintptr(n-uint32(3)))) = Uint8FromInt32(c) if n <= uint32(6) { return dest } - *(*uint8)(unsafe.Pointer(s + 3)) = Uint8FromInt32(c) - *(*uint8)(unsafe.Pointer(s + uintptr(n-uint32(4)))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + 3)) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + uintptr(n-uint32(4)))) = Uint8FromInt32(c) if n <= uint32(8) { return dest } @@ -146101,26 +146101,26 @@ func Xmemset(tls *TLS, dest uintptr, c int32, n Tsize_t) (r uintptr) { * As in the initial byte-based head/tail fill, each * conditional below ensures that the subsequent offsets * are valid (e.g. !(n<=24) implies n>=28). */ - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(0))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(4))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(0))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(4))) = c32 if n <= uint32(8) { return dest } - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(4))) = c32 - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(8))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(12))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(8))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(4))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(8))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(12))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(8))) = c32 if n <= uint32(24) { return dest } - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(12))) = c32 - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(16))) = c32 - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(20))) = c32 - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(24))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(28))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(24))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(20))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(16))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(12))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(16))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(20))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(24))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(28))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(24))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(20))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(16))) = c32 /* Align to a multiple of 8 so we can fill 64 bits at a time, * and avoid writing the same bytes twice as much as is * practical without introducing additional branching. */ @@ -146135,10 +146135,10 @@ func Xmemset(tls *TLS, dest uintptr, c int32, n Tsize_t) (r uintptr) { if !(n >= uint32(32)) { break } - *(*uint64)(unsafe.Pointer(s + UintptrFromInt32(0))) = c64 - *(*uint64)(unsafe.Pointer(s + UintptrFromInt32(8))) = c64 - *(*uint64)(unsafe.Pointer(s + UintptrFromInt32(16))) = c64 - *(*uint64)(unsafe.Pointer(s + UintptrFromInt32(24))) = c64 + **(**uint64)(__ccgo_up(s + UintptrFromInt32(0))) = c64 + **(**uint64)(__ccgo_up(s + UintptrFromInt32(8))) = c64 + **(**uint64)(__ccgo_up(s + UintptrFromInt32(16))) = c64 + **(**uint64)(__ccgo_up(s + UintptrFromInt32(24))) = c64 goto _1 _1: ; @@ -146180,8 +146180,8 @@ func X__stpcpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { if !(uint32(s)%Uint32FromInt64(4) != 0) { break } - v2 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v2 + v2 = **(**uint8)(__ccgo_up(s)) + **(**uint8)(__ccgo_up(d)) = v2 if !(v2 != 0) { return d } @@ -146194,7 +146194,7 @@ func X__stpcpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { wd = d ws = s for { - if !!((*(*uint32)(unsafe.Pointer(ws))-Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)) & ^*(*uint32)(unsafe.Pointer(ws)) & (Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)*Uint32FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0) { + if !!((**(**uint32)(__ccgo_up(ws))-Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)) & ^**(**uint32)(__ccgo_up(ws)) & (Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)*Uint32FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0) { break } goto _3 @@ -146204,14 +146204,14 @@ func X__stpcpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { wd += 4 v5 = ws ws += 4 - *(*uint32)(unsafe.Pointer(v4)) = *(*uint32)(unsafe.Pointer(v5)) + **(**uint32)(__ccgo_up(v4)) = **(**uint32)(__ccgo_up(v5)) } d = wd s = ws } for { - v2 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v2 + v2 = **(**uint8)(__ccgo_up(s)) + **(**uint8)(__ccgo_up(d)) = v2 if !(v2 != 0) { break } @@ -146264,8 +146264,8 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { if uint32(s)&(Uint32FromInt64(4)-Uint32FromInt32(1)) == uint32(d)&(Uint32FromInt64(4)-Uint32FromInt32(1)) { for { if v3 = uint32(s)&(Uint32FromInt64(4)-Uint32FromInt32(1)) != 0 && n != 0; v3 { - v2 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v2 + v2 = **(**uint8)(__ccgo_up(s)) + **(**uint8)(__ccgo_up(d)) = v2 } if !(v3 && v2 != 0) { break @@ -146277,16 +146277,16 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { s = s + 1 d = d + 1 } - if !(n != 0) || !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(n != 0) || !(**(**uint8)(__ccgo_up(s)) != 0) { goto tail } wd = d ws = s for { - if !(n >= uint32(4) && !((*(*uint32)(unsafe.Pointer(ws))-Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)) & ^*(*uint32)(unsafe.Pointer(ws)) & (Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)*Uint32FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { + if !(n >= uint32(4) && !((**(**uint32)(__ccgo_up(ws))-Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)) & ^**(**uint32)(__ccgo_up(ws)) & (Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)*Uint32FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { break } - *(*uint32)(unsafe.Pointer(wd)) = *(*uint32)(unsafe.Pointer(ws)) + **(**uint32)(__ccgo_up(wd)) = **(**uint32)(__ccgo_up(ws)) goto _4 _4: ; @@ -146299,8 +146299,8 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { } for { if v3 = n != 0; v3 { - v2 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v2 + v2 = **(**uint8)(__ccgo_up(s)) + **(**uint8)(__ccgo_up(d)) = v2 } if !(v3 && v2 != 0) { break @@ -146346,7 +146346,7 @@ func Xstrcasecmp(tls *TLS, _l uintptr, _r uintptr) (r1 int32) { l = _l r = _r for { - if !(*(*uint8)(unsafe.Pointer(l)) != 0 && *(*uint8)(unsafe.Pointer(r)) != 0 && (Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) || Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(l)))) == Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))))) { + if !(**(**uint8)(__ccgo_up(l)) != 0 && **(**uint8)(__ccgo_up(r)) != 0 && (Int32FromUint8(**(**uint8)(__ccgo_up(l))) == Int32FromUint8(**(**uint8)(__ccgo_up(r))) || Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(l)))) == Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(r)))))) { break } goto _1 @@ -146355,7 +146355,7 @@ func Xstrcasecmp(tls *TLS, _l uintptr, _r uintptr) (r1 int32) { l = l + 1 r = r + 1 } - return Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(l)))) - Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))) + return Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(l)))) - Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(r)))) } func X__strcasecmp_l(tls *TLS, l uintptr, r uintptr, loc Tlocale_t) (r1 int32) { @@ -146383,7 +146383,7 @@ func Xstrcasestr(tls *TLS, h uintptr, n uintptr) (r uintptr) { _ = l l = _strlen(tls, n) for { - if !(*(*uint8)(unsafe.Pointer(h)) != 0) { + if !(**(**uint8)(__ccgo_up(h)) != 0) { break } if !(Xstrncasecmp(tls, h, n, l) != 0) { @@ -146414,7 +146414,7 @@ func Xstrchr(tls *TLS, s uintptr, c int32) (r1 uintptr) { var r, v1 uintptr _, _ = r, v1 r = X__strchrnul(tls, s, c) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) == Int32FromUint8(Uint8FromInt32(c)) { + if Int32FromUint8(**(**uint8)(__ccgo_up(r))) == Int32FromUint8(Uint8FromInt32(c)) { v1 = r } else { v1 = uintptr(0) @@ -146449,7 +146449,7 @@ func X__strchrnul(tls *TLS, s uintptr, c int32) (r uintptr) { if !(uint32(s)%Uint32FromInt64(4) != 0) { break } - if !(*(*uint8)(unsafe.Pointer(s)) != 0) || Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == c { + if !(**(**uint8)(__ccgo_up(s)) != 0) || Int32FromUint8(**(**uint8)(__ccgo_up(s))) == c { return s } goto _1 @@ -146460,7 +146460,7 @@ func X__strchrnul(tls *TLS, s uintptr, c int32) (r uintptr) { k = Uint32FromInt32(-Int32FromInt32(1)) / Uint32FromInt32(UCHAR_MAX) * Uint32FromInt32(c) w = s for { - if !(!((*(*uint32)(unsafe.Pointer(w))-Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)) & ^*(*uint32)(unsafe.Pointer(w)) & (Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)*Uint32FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0) && !((*(*uint32)(unsafe.Pointer(w))^k-Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)) & ^(*(*uint32)(unsafe.Pointer(w))^k) & (Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)*Uint32FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { + if !(!((**(**uint32)(__ccgo_up(w))-Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)) & ^**(**uint32)(__ccgo_up(w)) & (Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)*Uint32FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0) && !((**(**uint32)(__ccgo_up(w))^k-Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)) & ^(**(**uint32)(__ccgo_up(w))^k) & (Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)*Uint32FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { break } goto _2 @@ -146470,7 +146470,7 @@ func X__strchrnul(tls *TLS, s uintptr, c int32) (r uintptr) { } s = w for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != c) { + if !(**(**uint8)(__ccgo_up(s)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != c) { break } goto _3 @@ -146504,7 +146504,7 @@ func Xstrcmp(tls *TLS, l uintptr, r uintptr) (r1 int32) { defer func() { trc("-> %v", r1) }() } for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) && *(*uint8)(unsafe.Pointer(l)) != 0) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(l))) == Int32FromUint8(**(**uint8)(__ccgo_up(r))) && **(**uint8)(__ccgo_up(l)) != 0) { break } goto _1 @@ -146513,7 +146513,7 @@ func Xstrcmp(tls *TLS, l uintptr, r uintptr) (r1 int32) { l = l + 1 r = r + 1 } - return Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) + return Int32FromUint8(**(**uint8)(__ccgo_up(l))) - Int32FromUint8(**(**uint8)(__ccgo_up(r))) } func Xstrcpy(tls *TLS, dest uintptr, src uintptr) (r uintptr) { @@ -146537,14 +146537,14 @@ func Xstrcspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { var _ /* byteset at bp+0 */ [8]Tsize_t _, _, _ = a, v2, v3 a = s - if !(*(*uint8)(unsafe.Pointer(c)) != 0) || !(*(*uint8)(unsafe.Pointer(c + 1)) != 0) { - return Uint32FromInt32(int32(X__strchrnul(tls, s, Int32FromUint8(*(*uint8)(unsafe.Pointer(c))))) - int32(a)) + if !(**(**uint8)(__ccgo_up(c)) != 0) || !(**(**uint8)(__ccgo_up(c + 1)) != 0) { + return Uint32FromInt32(int32(X__strchrnul(tls, s, Int32FromUint8(**(**uint8)(__ccgo_up(c))))) - int32(a)) } Xmemset(tls, bp, 0, uint32(32)) for { - if v3 = *(*uint8)(unsafe.Pointer(c)) != 0; v3 { - v2 = bp + uintptr(uint32(*(*uint8)(unsafe.Pointer(c)))/(Uint32FromInt32(8)*Uint32FromInt64(4)))*4 - *(*Tsize_t)(unsafe.Pointer(v2)) |= Uint32FromInt32(1) << (uint32(*(*uint8)(unsafe.Pointer(c))) % (Uint32FromInt32(8) * Uint32FromInt64(4))) + if v3 = **(**uint8)(__ccgo_up(c)) != 0; v3 { + v2 = bp + uintptr(uint32(**(**uint8)(__ccgo_up(c)))/(Uint32FromInt32(8)*Uint32FromInt64(4)))*4 + *(*Tsize_t)(unsafe.Pointer(v2)) |= Uint32FromInt32(1) << (uint32(**(**uint8)(__ccgo_up(c))) % (Uint32FromInt32(8) * Uint32FromInt64(4))) } if !(v3 && *(*Tsize_t)(unsafe.Pointer(v2)) != 0) { break @@ -146555,7 +146555,7 @@ func Xstrcspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { c = c + 1 } for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0 && !((*(*[8]Tsize_t)(unsafe.Pointer(bp)))[uint32(*(*uint8)(unsafe.Pointer(s)))/(Uint32FromInt32(8)*Uint32FromInt64(4))]&(Uint32FromInt32(1)<<(uint32(*(*uint8)(unsafe.Pointer(s)))%(Uint32FromInt32(8)*Uint32FromInt64(4)))) != 0)) { + if !(**(**uint8)(__ccgo_up(s)) != 0 && !((**(**[8]Tsize_t)(__ccgo_up(bp)))[uint32(**(**uint8)(__ccgo_up(s)))/(Uint32FromInt32(8)*Uint32FromInt64(4))]&(Uint32FromInt32(1)<<(uint32(**(**uint8)(__ccgo_up(s)))%(Uint32FromInt32(8)*Uint32FromInt64(4)))) != 0)) { break } goto _4 @@ -146595,7 +146595,7 @@ func Xstrerror_r(tls *TLS, err int32, buf uintptr, buflen Tsize_t) (r int32) { if l >= buflen { if buflen != 0 { _memcpy(tls, buf, msg, buflen-uint32(1)) - *(*uint8)(unsafe.Pointer(buf + uintptr(buflen-uint32(1)))) = uint8(0) + **(**uint8)(__ccgo_up(buf + uintptr(buflen-uint32(1)))) = uint8(0) } return int32(ERANGE) } @@ -146655,8 +146655,8 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { if uint32(s)&(Uint32FromInt64(4)-Uint32FromInt32(1)) == uint32(d)&(Uint32FromInt64(4)-Uint32FromInt32(1)) { for { if v4 = uint32(s)&(Uint32FromInt64(4)-Uint32FromInt32(1)) != 0 && n != 0; v4 { - v3 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v3 + v3 = **(**uint8)(__ccgo_up(s)) + **(**uint8)(__ccgo_up(d)) = v3 } if !(v4 && v3 != 0) { break @@ -146668,14 +146668,14 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { s = s + 1 d = d + 1 } - if n != 0 && *(*uint8)(unsafe.Pointer(s)) != 0 { + if n != 0 && **(**uint8)(__ccgo_up(s)) != 0 { wd = d ws = s for { - if !(n >= uint32(4) && !((*(*uint32)(unsafe.Pointer(ws))-Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)) & ^*(*uint32)(unsafe.Pointer(ws)) & (Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)*Uint32FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { + if !(n >= uint32(4) && !((**(**uint32)(__ccgo_up(ws))-Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)) & ^**(**uint32)(__ccgo_up(ws)) & (Uint32FromInt32(-Int32FromInt32(1))/Uint32FromInt32(UCHAR_MAX)*Uint32FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { break } - *(*Tsize_t)(unsafe.Pointer(wd)) = *(*uint32)(unsafe.Pointer(ws)) + **(**Tsize_t)(__ccgo_up(wd)) = **(**uint32)(__ccgo_up(ws)) goto _5 _5: ; @@ -146689,8 +146689,8 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { } for { if v4 = n != 0; v4 { - v3 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v3 + v3 = **(**uint8)(__ccgo_up(s)) + **(**uint8)(__ccgo_up(d)) = v3 } if !(v4 && v3 != 0) { break @@ -146702,7 +146702,7 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { s = s + 1 d = d + 1 } - *(*uint8)(unsafe.Pointer(d)) = uint8(0) + **(**uint8)(__ccgo_up(d)) = uint8(0) goto finish finish: ; @@ -146728,7 +146728,7 @@ func Xstrncasecmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { return 0 } for { - if !(*(*uint8)(unsafe.Pointer(l)) != 0 && *(*uint8)(unsafe.Pointer(r)) != 0 && n != 0 && (Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) || Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(l)))) == Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))))) { + if !(**(**uint8)(__ccgo_up(l)) != 0 && **(**uint8)(__ccgo_up(r)) != 0 && n != 0 && (Int32FromUint8(**(**uint8)(__ccgo_up(l))) == Int32FromUint8(**(**uint8)(__ccgo_up(r))) || Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(l)))) == Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(r)))))) { break } goto _2 @@ -146738,7 +146738,7 @@ func Xstrncasecmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { r = r + 1 n = n - 1 } - return Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(l)))) - Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))) + return Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(l)))) - Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(r)))) } func X__strncasecmp_l(tls *TLS, l uintptr, r uintptr, n Tsize_t, loc Tlocale_t) (r1 int32) { @@ -146766,17 +146766,17 @@ func Xstrncat(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { _, _, _ = a, v1, v2 a = d d = d + uintptr(_strlen(tls, d)) - for n != 0 && *(*uint8)(unsafe.Pointer(s)) != 0 { + for n != 0 && **(**uint8)(__ccgo_up(s)) != 0 { n = n - 1 v1 = d d = d + 1 v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v1)) = *(*uint8)(unsafe.Pointer(v2)) + **(**uint8)(__ccgo_up(v1)) = **(**uint8)(__ccgo_up(v2)) } v1 = d d = d + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) return a } @@ -146796,7 +146796,7 @@ func Xstrncmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { return 0 } for { - if !(*(*uint8)(unsafe.Pointer(l)) != 0 && *(*uint8)(unsafe.Pointer(r)) != 0 && n != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))) { + if !(**(**uint8)(__ccgo_up(l)) != 0 && **(**uint8)(__ccgo_up(r)) != 0 && n != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(l))) == Int32FromUint8(**(**uint8)(__ccgo_up(r)))) { break } goto _2 @@ -146806,7 +146806,7 @@ func Xstrncmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { r = r + 1 n = n - 1 } - return Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) + return Int32FromUint8(**(**uint8)(__ccgo_up(l))) - Int32FromUint8(**(**uint8)(__ccgo_up(r))) } func Xstrncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { @@ -146832,7 +146832,7 @@ func Xstrndup(tls *TLS, s uintptr, n Tsize_t) (r uintptr) { return UintptrFromInt32(0) } _memcpy(tls, d, s, l) - *(*uint8)(unsafe.Pointer(d + uintptr(l))) = uint8(0) + **(**uint8)(__ccgo_up(d + uintptr(l))) = uint8(0) return d } @@ -146861,7 +146861,7 @@ func Xstrpbrk(tls *TLS, s uintptr, b uintptr) (r uintptr) { var v1 uintptr _ = v1 s = s + uintptr(Xstrcspn(tls, s, b)) - if *(*uint8)(unsafe.Pointer(s)) != 0 { + if **(**uint8)(__ccgo_up(s)) != 0 { v1 = s } else { v1 = uintptr(0) @@ -146884,19 +146884,19 @@ func Xstrsep(tls *TLS, str uintptr, sep uintptr) (r uintptr) { } var end, s, v1 uintptr _, _, _ = end, s, v1 - s = *(*uintptr)(unsafe.Pointer(str)) + s = **(**uintptr)(__ccgo_up(str)) if !(s != 0) { return UintptrFromInt32(0) } end = s + uintptr(Xstrcspn(tls, s, sep)) - if *(*uint8)(unsafe.Pointer(end)) != 0 { + if **(**uint8)(__ccgo_up(end)) != 0 { v1 = end end = end + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) } else { end = uintptr(0) } - *(*uintptr)(unsafe.Pointer(str)) = end + **(**uintptr)(__ccgo_up(str)) = end return s } @@ -146922,7 +146922,7 @@ func Xstrsignal(tls *TLS, signum int32) (r uintptr) { break } for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { break } goto _3 @@ -146950,13 +146950,13 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { var _ /* byteset at bp+0 */ [8]Tsize_t _, _, _ = a, v3, v4 a = s - *(*[8]Tsize_t)(unsafe.Pointer(bp)) = [8]Tsize_t{} - if !(*(*uint8)(unsafe.Pointer(c)) != 0) { + **(**[8]Tsize_t)(__ccgo_up(bp)) = [8]Tsize_t{} + if !(**(**uint8)(__ccgo_up(c)) != 0) { return uint32(0) } - if !(*(*uint8)(unsafe.Pointer(c + 1)) != 0) { + if !(**(**uint8)(__ccgo_up(c + 1)) != 0) { for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(c)))) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(s))) == Int32FromUint8(**(**uint8)(__ccgo_up(c)))) { break } goto _1 @@ -146967,9 +146967,9 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { return Uint32FromInt32(int32(s) - int32(a)) } for { - if v4 = *(*uint8)(unsafe.Pointer(c)) != 0; v4 { - v3 = bp + uintptr(uint32(*(*uint8)(unsafe.Pointer(c)))/(Uint32FromInt32(8)*Uint32FromInt64(4)))*4 - *(*Tsize_t)(unsafe.Pointer(v3)) |= Uint32FromInt32(1) << (uint32(*(*uint8)(unsafe.Pointer(c))) % (Uint32FromInt32(8) * Uint32FromInt64(4))) + if v4 = **(**uint8)(__ccgo_up(c)) != 0; v4 { + v3 = bp + uintptr(uint32(**(**uint8)(__ccgo_up(c)))/(Uint32FromInt32(8)*Uint32FromInt64(4)))*4 + *(*Tsize_t)(unsafe.Pointer(v3)) |= Uint32FromInt32(1) << (uint32(**(**uint8)(__ccgo_up(c))) % (Uint32FromInt32(8) * Uint32FromInt64(4))) } if !(v4 && *(*Tsize_t)(unsafe.Pointer(v3)) != 0) { break @@ -146980,7 +146980,7 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { c = c + 1 } for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0 && (*(*[8]Tsize_t)(unsafe.Pointer(bp)))[uint32(*(*uint8)(unsafe.Pointer(s)))/(Uint32FromInt32(8)*Uint32FromInt64(4))]&(Uint32FromInt32(1)<<(uint32(*(*uint8)(unsafe.Pointer(s)))%(Uint32FromInt32(8)*Uint32FromInt64(4)))) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0 && (**(**[8]Tsize_t)(__ccgo_up(bp)))[uint32(**(**uint8)(__ccgo_up(s)))/(Uint32FromInt32(8)*Uint32FromInt64(4))]&(Uint32FromInt32(1)<<(uint32(**(**uint8)(__ccgo_up(s)))%(Uint32FromInt32(8)*Uint32FromInt64(4)))) != 0) { break } goto _5 @@ -146995,11 +146995,11 @@ func _twobyte_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { var hw, nw Tuint16_t var v2 uintptr _, _, _ = hw, nw, v2 - nw = Uint16FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(n)))< Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(ip+k)))) > Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(jp+k)))) { jp = jp + k k = uint32(1) p = jp - ip @@ -147133,7 +147133,7 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { p = v2 k = v2 for jp+k < l { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(ip+k)))) == Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(jp+k)))) { if k == p { jp = jp + p k = uint32(1) @@ -147141,7 +147141,7 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { k = k + 1 } } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) < Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(ip+k)))) < Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(jp+k)))) { jp = jp + k k = uint32(1) p = jp - ip @@ -147192,8 +147192,8 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { } } /* Check last byte first; advance by shift on mismatch */ - if (*(*[8]Tsize_t)(unsafe.Pointer(bp)))[uint32(*(*uint8)(unsafe.Pointer(h + uintptr(l-uint32(1)))))/(Uint32FromInt32(8)*Uint32FromInt64(4))]&(Uint32FromInt32(1)<<(uint32(*(*uint8)(unsafe.Pointer(h + uintptr(l-uint32(1)))))%(Uint32FromInt32(8)*Uint32FromInt64(4)))) != 0 { - k = l - shift[*(*uint8)(unsafe.Pointer(h + uintptr(l-uint32(1))))] + if (**(**[8]Tsize_t)(__ccgo_up(bp)))[uint32(**(**uint8)(__ccgo_up(h + uintptr(l-uint32(1)))))/(Uint32FromInt32(8)*Uint32FromInt64(4))]&(Uint32FromInt32(1)<<(uint32(**(**uint8)(__ccgo_up(h + uintptr(l-uint32(1)))))%(Uint32FromInt32(8)*Uint32FromInt64(4)))) != 0 { + k = l - shift[**(**uint8)(__ccgo_up(h + uintptr(l-uint32(1))))] if k != 0 { if k < mem { k = mem @@ -147215,7 +147215,7 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { } k = v8 for { - if !(*(*uint8)(unsafe.Pointer(n + uintptr(k))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(h + uintptr(k))))) { + if !(**(**uint8)(__ccgo_up(n + uintptr(k))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(k)))) == Int32FromUint8(**(**uint8)(__ccgo_up(h + uintptr(k))))) { break } goto _10 @@ -147223,7 +147223,7 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { ; k = k + 1 } - if *(*uint8)(unsafe.Pointer(n + uintptr(k))) != 0 { + if **(**uint8)(__ccgo_up(n + uintptr(k))) != 0 { h = h + uintptr(k-ms) mem = uint32(0) goto _9 @@ -147231,7 +147231,7 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { /* Compare left half */ k = ms + uint32(1) for { - if !(k > mem && Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(k-uint32(1))))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(h + uintptr(k-uint32(1)))))) { + if !(k > mem && Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(k-uint32(1))))) == Int32FromUint8(**(**uint8)(__ccgo_up(h + uintptr(k-uint32(1)))))) { break } goto _12 @@ -147256,30 +147256,30 @@ func Xstrstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { defer func() { trc("-> %v", r) }() } /* Return immediately on empty needle */ - if !(*(*uint8)(unsafe.Pointer(n)) != 0) { + if !(**(**uint8)(__ccgo_up(n)) != 0) { return h } /* Use faster algorithms for short needles */ - h = Xstrchr(tls, h, Int32FromUint8(*(*uint8)(unsafe.Pointer(n)))) - if !(h != 0) || !(*(*uint8)(unsafe.Pointer(n + 1)) != 0) { + h = Xstrchr(tls, h, Int32FromUint8(**(**uint8)(__ccgo_up(n)))) + if !(h != 0) || !(**(**uint8)(__ccgo_up(n + 1)) != 0) { return h } - if !(*(*uint8)(unsafe.Pointer(h + 1)) != 0) { + if !(**(**uint8)(__ccgo_up(h + 1)) != 0) { return uintptr(0) } - if !(*(*uint8)(unsafe.Pointer(n + 2)) != 0) { + if !(**(**uint8)(__ccgo_up(n + 2)) != 0) { return _twobyte_strstr(tls, h, n) } - if !(*(*uint8)(unsafe.Pointer(h + 2)) != 0) { + if !(**(**uint8)(__ccgo_up(h + 2)) != 0) { return uintptr(0) } - if !(*(*uint8)(unsafe.Pointer(n + 3)) != 0) { + if !(**(**uint8)(__ccgo_up(n + 3)) != 0) { return _threebyte_strstr(tls, h, n) } - if !(*(*uint8)(unsafe.Pointer(h + 3)) != 0) { + if !(**(**uint8)(__ccgo_up(h + 3)) != 0) { return uintptr(0) } - if !(*(*uint8)(unsafe.Pointer(n + 4)) != 0) { + if !(**(**uint8)(__ccgo_up(n + 4)) != 0) { return _fourbyte_strstr(tls, h, n) } return _twoway_strstr(tls, h, n) @@ -147301,16 +147301,16 @@ func Xstrtok(tls *TLS, s uintptr, sep uintptr) (r uintptr) { return UintptrFromInt32(0) } s = s + uintptr(Xstrspn(tls, s, sep)) - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { v1 = UintptrFromInt32(0) _p2 = v1 return v1 } _p2 = s + uintptr(Xstrcspn(tls, s, sep)) - if *(*uint8)(unsafe.Pointer(_p2)) != 0 { + if **(**uint8)(__ccgo_up(_p2)) != 0 { v1 = _p2 _p2 = _p2 + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) } else { _p2 = uintptr(0) } @@ -147328,26 +147328,26 @@ func Xstrtok_r(tls *TLS, s uintptr, sep uintptr, p uintptr) (r uintptr) { var v2 bool _, _, _ = v1, v2, v3 if v2 = !(s != 0); v2 { - v1 = *(*uintptr)(unsafe.Pointer(p)) + v1 = **(**uintptr)(__ccgo_up(p)) s = v1 } if v2 && !(v1 != 0) { return UintptrFromInt32(0) } s = s + uintptr(Xstrspn(tls, s, sep)) - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { v1 = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(p)) = v1 + **(**uintptr)(__ccgo_up(p)) = v1 return v1 } - *(*uintptr)(unsafe.Pointer(p)) = s + uintptr(Xstrcspn(tls, s, sep)) - if *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)))) != 0 { + **(**uintptr)(__ccgo_up(p)) = s + uintptr(Xstrcspn(tls, s, sep)) + if **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)))) != 0 { v3 = p v1 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) } else { - *(*uintptr)(unsafe.Pointer(p)) = uintptr(0) + **(**uintptr)(__ccgo_up(p)) = uintptr(0) } return s } @@ -147370,10 +147370,10 @@ func Xstrverscmp(tls *TLS, l0 uintptr, r0 uintptr) (r1 int32) { i = v2 dp = v2 for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(l + uintptr(i)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(r + uintptr(i))))) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(l + uintptr(i)))) == Int32FromUint8(**(**uint8)(__ccgo_up(r + uintptr(i))))) { break } - c = Int32FromUint8(*(*uint8)(unsafe.Pointer(l + uintptr(i)))) + c = Int32FromUint8(**(**uint8)(__ccgo_up(l + uintptr(i)))) if !(c != 0) { return 0 } @@ -147390,15 +147390,15 @@ func Xstrverscmp(tls *TLS, l0 uintptr, r0 uintptr) (r1 int32) { ; i = i + 1 } - if Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(l + uintptr(dp))))-int32('1')) < uint32(9) && Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(r + uintptr(dp))))-int32('1')) < uint32(9) { + if Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(l + uintptr(dp))))-int32('1')) < uint32(9) && Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(r + uintptr(dp))))-int32('1')) < uint32(9) { /* If we're looking at non-degenerate digit sequences starting * with nonzero digits, longest digit string is greater. */ j = i for { - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(l + uintptr(j))))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(l + uintptr(j))))-uint32('0') < uint32(10)) != 0) { break } - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(r + uintptr(j))))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(r + uintptr(j))))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return int32(1) } goto _3 @@ -147406,17 +147406,17 @@ func Xstrverscmp(tls *TLS, l0 uintptr, r0 uintptr) (r1 int32) { ; j = j + 1 } - if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(r + uintptr(j))))-uint32('0') < uint32(10)) != 0 { + if BoolInt32(uint32(**(**uint8)(__ccgo_up(r + uintptr(j))))-uint32('0') < uint32(10)) != 0 { return -int32(1) } } else { - if z != 0 && dp < i && (BoolInt32(uint32(*(*uint8)(unsafe.Pointer(l + uintptr(i))))-uint32('0') < uint32(10)) != 0 || BoolInt32(uint32(*(*uint8)(unsafe.Pointer(r + uintptr(i))))-uint32('0') < uint32(10)) != 0) { + if z != 0 && dp < i && (BoolInt32(uint32(**(**uint8)(__ccgo_up(l + uintptr(i))))-uint32('0') < uint32(10)) != 0 || BoolInt32(uint32(**(**uint8)(__ccgo_up(r + uintptr(i))))-uint32('0') < uint32(10)) != 0) { /* Otherwise, if common prefix of digit sequence is * all zeros, digits order less than non-digits. */ - return Int32FromUint8(Uint8FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(l + uintptr(i))))-Int32FromUint8('0'))) - Int32FromUint8(Uint8FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(r + uintptr(i))))-Int32FromUint8('0'))) + return Int32FromUint8(Uint8FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(l + uintptr(i))))-Int32FromUint8('0'))) - Int32FromUint8(Uint8FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(r + uintptr(i))))-Int32FromUint8('0'))) } } - return Int32FromUint8(*(*uint8)(unsafe.Pointer(l + uintptr(i)))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r + uintptr(i)))) + return Int32FromUint8(**(**uint8)(__ccgo_up(l + uintptr(i)))) - Int32FromUint8(**(**uint8)(__ccgo_up(r + uintptr(i)))) } func Xswab(tls *TLS, _src uintptr, _dest uintptr, n Tssize_t) { @@ -147431,8 +147431,8 @@ func Xswab(tls *TLS, _src uintptr, _dest uintptr, n Tssize_t) { if !(n > int32(1)) { break } - *(*uint8)(unsafe.Pointer(dest)) = *(*uint8)(unsafe.Pointer(src + 1)) - *(*uint8)(unsafe.Pointer(dest + 1)) = *(*uint8)(unsafe.Pointer(src)) + **(**uint8)(__ccgo_up(dest)) = **(**uint8)(__ccgo_up(src + 1)) + **(**uint8)(__ccgo_up(dest + 1)) = **(**uint8)(__ccgo_up(src)) dest = dest + uintptr(2) src = src + uintptr(2) goto _1 @@ -147494,7 +147494,7 @@ func Xwcschr(tls *TLS, s uintptr, c Twchar_t) (r uintptr) { return s + uintptr(Xwcslen(tls, s))*4 } for { - if !(*(*Twchar_t)(unsafe.Pointer(s)) != 0 && *(*Twchar_t)(unsafe.Pointer(s)) != c) { + if !(**(**Twchar_t)(__ccgo_up(s)) != 0 && **(**Twchar_t)(__ccgo_up(s)) != c) { break } goto _1 @@ -147502,7 +147502,7 @@ func Xwcschr(tls *TLS, s uintptr, c Twchar_t) (r uintptr) { ; s += 4 } - if *(*Twchar_t)(unsafe.Pointer(s)) != 0 { + if **(**Twchar_t)(__ccgo_up(s)) != 0 { v2 = s } else { v2 = uintptr(0) @@ -147518,7 +147518,7 @@ func Xwcscmp(tls *TLS, l uintptr, r uintptr) (r1 int32) { var v2 int32 _ = v2 for { - if !(*(*Twchar_t)(unsafe.Pointer(l)) == *(*Twchar_t)(unsafe.Pointer(r)) && *(*Twchar_t)(unsafe.Pointer(l)) != 0 && *(*Twchar_t)(unsafe.Pointer(r)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(l)) == **(**Twchar_t)(__ccgo_up(r)) && **(**Twchar_t)(__ccgo_up(l)) != 0 && **(**Twchar_t)(__ccgo_up(r)) != 0) { break } goto _1 @@ -147527,10 +147527,10 @@ func Xwcscmp(tls *TLS, l uintptr, r uintptr) (r1 int32) { l += 4 r += 4 } - if *(*Twchar_t)(unsafe.Pointer(l)) < *(*Twchar_t)(unsafe.Pointer(r)) { + if **(**Twchar_t)(__ccgo_up(l)) < **(**Twchar_t)(__ccgo_up(r)) { v2 = -int32(1) } else { - v2 = BoolInt32(*(*Twchar_t)(unsafe.Pointer(l)) > *(*Twchar_t)(unsafe.Pointer(r))) + v2 = BoolInt32(**(**Twchar_t)(__ccgo_up(l)) > **(**Twchar_t)(__ccgo_up(r))) } return v2 } @@ -147547,10 +147547,10 @@ func Xwcscpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { for { v2 = s s += 4 - v1 = *(*Twchar_t)(unsafe.Pointer(v2)) + v1 = **(**Twchar_t)(__ccgo_up(v2)) v3 = d d += 4 - *(*Twchar_t)(unsafe.Pointer(v3)) = v1 + **(**Twchar_t)(__ccgo_up(v3)) = v1 if !(v1 != 0) { break } @@ -147566,13 +147566,13 @@ func Xwcscspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { var a, v2, v3 uintptr var v1 uint32 _, _, _, _ = a, v1, v2, v3 - if !(*(*Twchar_t)(unsafe.Pointer(c)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(c)) != 0) { return Xwcslen(tls, s) } - if !(*(*Twchar_t)(unsafe.Pointer(c + 1*4)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(c + 1*4)) != 0) { v3 = s a = v3 - v2 = Xwcschr(tls, v3, *(*Twchar_t)(unsafe.Pointer(c))) + v2 = Xwcschr(tls, v3, **(**Twchar_t)(__ccgo_up(c))) s = v2 if v2 != 0 { v1 = Uint32FromInt32((int32(s) - int32(a)) / 4) @@ -147583,7 +147583,7 @@ func Xwcscspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { } a = s for { - if !(*(*Twchar_t)(unsafe.Pointer(s)) != 0 && !(Xwcschr(tls, c, *(*Twchar_t)(unsafe.Pointer(s))) != 0)) { + if !(**(**Twchar_t)(__ccgo_up(s)) != 0 && !(Xwcschr(tls, c, **(**Twchar_t)(__ccgo_up(s))) != 0)) { break } goto _4 @@ -147619,7 +147619,7 @@ func Xwcslen(tls *TLS, s uintptr) (r Tsize_t) { _ = a a = s for { - if !(*(*Twchar_t)(unsafe.Pointer(s)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(s)) != 0) { break } goto _1 @@ -147643,7 +147643,7 @@ func Xwcsncasecmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { return 0 } for { - if !(*(*Twchar_t)(unsafe.Pointer(l)) != 0 && *(*Twchar_t)(unsafe.Pointer(r)) != 0 && n != 0 && (*(*Twchar_t)(unsafe.Pointer(l)) == *(*Twchar_t)(unsafe.Pointer(r)) || Xtowlower(tls, *(*Twchar_t)(unsafe.Pointer(l))) == Xtowlower(tls, *(*Twchar_t)(unsafe.Pointer(r))))) { + if !(**(**Twchar_t)(__ccgo_up(l)) != 0 && **(**Twchar_t)(__ccgo_up(r)) != 0 && n != 0 && (**(**Twchar_t)(__ccgo_up(l)) == **(**Twchar_t)(__ccgo_up(r)) || Xtowlower(tls, **(**Twchar_t)(__ccgo_up(l))) == Xtowlower(tls, **(**Twchar_t)(__ccgo_up(r))))) { break } goto _2 @@ -147653,7 +147653,7 @@ func Xwcsncasecmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { r += 4 n = n - 1 } - return Int32FromUint32(Xtowlower(tls, *(*Twchar_t)(unsafe.Pointer(l))) - Xtowlower(tls, *(*Twchar_t)(unsafe.Pointer(r)))) + return Int32FromUint32(Xtowlower(tls, **(**Twchar_t)(__ccgo_up(l))) - Xtowlower(tls, **(**Twchar_t)(__ccgo_up(r)))) } func Xwcsncasecmp_l(tls *TLS, l uintptr, r uintptr, n Tsize_t, locale Tlocale_t) (r1 int32) { @@ -147673,17 +147673,17 @@ func Xwcsncat(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { _, _, _ = a, v1, v2 a = d d = d + uintptr(Xwcslen(tls, d))*4 - for n != 0 && *(*Twchar_t)(unsafe.Pointer(s)) != 0 { + for n != 0 && **(**Twchar_t)(__ccgo_up(s)) != 0 { n = n - 1 v1 = d d += 4 v2 = s s += 4 - *(*Twchar_t)(unsafe.Pointer(v1)) = *(*Twchar_t)(unsafe.Pointer(v2)) + **(**Twchar_t)(__ccgo_up(v1)) = **(**Twchar_t)(__ccgo_up(v2)) } v1 = d d += 4 - *(*Twchar_t)(unsafe.Pointer(v1)) = uint32(0) + **(**Twchar_t)(__ccgo_up(v1)) = uint32(0) return a } @@ -147695,7 +147695,7 @@ func Xwcsncmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { var v2, v3 int32 _, _ = v2, v3 for { - if !(n != 0 && *(*Twchar_t)(unsafe.Pointer(l)) == *(*Twchar_t)(unsafe.Pointer(r)) && *(*Twchar_t)(unsafe.Pointer(l)) != 0 && *(*Twchar_t)(unsafe.Pointer(r)) != 0) { + if !(n != 0 && **(**Twchar_t)(__ccgo_up(l)) == **(**Twchar_t)(__ccgo_up(r)) && **(**Twchar_t)(__ccgo_up(l)) != 0 && **(**Twchar_t)(__ccgo_up(r)) != 0) { break } goto _1 @@ -147706,10 +147706,10 @@ func Xwcsncmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { r += 4 } if n != 0 { - if *(*Twchar_t)(unsafe.Pointer(l)) < *(*Twchar_t)(unsafe.Pointer(r)) { + if **(**Twchar_t)(__ccgo_up(l)) < **(**Twchar_t)(__ccgo_up(r)) { v3 = -int32(1) } else { - v3 = BoolInt32(*(*Twchar_t)(unsafe.Pointer(l)) > *(*Twchar_t)(unsafe.Pointer(r))) + v3 = BoolInt32(**(**Twchar_t)(__ccgo_up(l)) > **(**Twchar_t)(__ccgo_up(r))) } v2 = v3 } else { @@ -147726,13 +147726,13 @@ func Xwcsncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { var a, v1, v2 uintptr _, _, _ = a, v1, v2 a = d - for n != 0 && *(*Twchar_t)(unsafe.Pointer(s)) != 0 { + for n != 0 && **(**Twchar_t)(__ccgo_up(s)) != 0 { n = n - 1 v1 = d d += 4 v2 = s s += 4 - *(*Twchar_t)(unsafe.Pointer(v1)) = *(*Twchar_t)(unsafe.Pointer(v2)) + **(**Twchar_t)(__ccgo_up(v1)) = **(**Twchar_t)(__ccgo_up(v2)) } Xwmemset(tls, d, uint32(0), n) return a @@ -147760,7 +147760,7 @@ func Xwcspbrk(tls *TLS, s uintptr, b uintptr) (r uintptr) { var v1 uintptr _ = v1 s = s + uintptr(Xwcscspn(tls, s, b))*4 - if *(*Twchar_t)(unsafe.Pointer(s)) != 0 { + if **(**Twchar_t)(__ccgo_up(s)) != 0 { v1 = s } else { v1 = UintptrFromInt32(0) @@ -147777,7 +147777,7 @@ func Xwcsrchr(tls *TLS, s uintptr, c Twchar_t) (r uintptr) { _, _ = p, v2 p = s + uintptr(Xwcslen(tls, s))*4 for { - if !(p >= s && *(*Twchar_t)(unsafe.Pointer(p)) != c) { + if !(p >= s && **(**Twchar_t)(__ccgo_up(p)) != c) { break } goto _1 @@ -147802,7 +147802,7 @@ func Xwcsspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { _ = a a = s for { - if !(*(*Twchar_t)(unsafe.Pointer(s)) != 0 && Xwcschr(tls, c, *(*Twchar_t)(unsafe.Pointer(s))) != 0) { + if !(**(**Twchar_t)(__ccgo_up(s)) != 0 && Xwcschr(tls, c, **(**Twchar_t)(__ccgo_up(s))) != 0) { break } goto _1 @@ -147821,7 +147821,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { /* Computing length of needle */ l = uint32(0) for { - if !(*(*Twchar_t)(unsafe.Pointer(n + uintptr(l)*4)) != 0 && *(*Twchar_t)(unsafe.Pointer(h + uintptr(l)*4)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(n + uintptr(l)*4)) != 0 && **(**Twchar_t)(__ccgo_up(h + uintptr(l)*4)) != 0) { break } goto _1 @@ -147829,7 +147829,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { ; l = l + 1 } - if *(*Twchar_t)(unsafe.Pointer(n + uintptr(l)*4)) != 0 { + if **(**Twchar_t)(__ccgo_up(n + uintptr(l)*4)) != 0 { return uintptr(0) } /* hit the end of h */ /* Compute maximal suffix */ @@ -147839,7 +147839,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { p = v2 k = v2 for jp+k < l { - if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) == *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { + if **(**Twchar_t)(__ccgo_up(n + uintptr(ip+k)*4)) == **(**Twchar_t)(__ccgo_up(n + uintptr(jp+k)*4)) { if k == p { jp = jp + p k = uint32(1) @@ -147847,7 +147847,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { k = k + 1 } } else { - if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) > *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { + if **(**Twchar_t)(__ccgo_up(n + uintptr(ip+k)*4)) > **(**Twchar_t)(__ccgo_up(n + uintptr(jp+k)*4)) { jp = jp + k k = uint32(1) p = jp - ip @@ -147870,7 +147870,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { p = v2 k = v2 for jp+k < l { - if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) == *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { + if **(**Twchar_t)(__ccgo_up(n + uintptr(ip+k)*4)) == **(**Twchar_t)(__ccgo_up(n + uintptr(jp+k)*4)) { if k == p { jp = jp + p k = uint32(1) @@ -147878,7 +147878,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { k = k + 1 } } else { - if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) < *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { + if **(**Twchar_t)(__ccgo_up(n + uintptr(ip+k)*4)) < **(**Twchar_t)(__ccgo_up(n + uintptr(jp+k)*4)) { jp = jp + k k = uint32(1) p = jp - ip @@ -147936,7 +147936,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { } k = v8 for { - if !(*(*Twchar_t)(unsafe.Pointer(n + uintptr(k)*4)) != 0 && *(*Twchar_t)(unsafe.Pointer(n + uintptr(k)*4)) == *(*Twchar_t)(unsafe.Pointer(h + uintptr(k)*4))) { + if !(**(**Twchar_t)(__ccgo_up(n + uintptr(k)*4)) != 0 && **(**Twchar_t)(__ccgo_up(n + uintptr(k)*4)) == **(**Twchar_t)(__ccgo_up(h + uintptr(k)*4))) { break } goto _10 @@ -147944,7 +147944,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { ; k = k + 1 } - if *(*Twchar_t)(unsafe.Pointer(n + uintptr(k)*4)) != 0 { + if **(**Twchar_t)(__ccgo_up(n + uintptr(k)*4)) != 0 { h = h + uintptr(k-ms)*4 mem = uint32(0) goto _9 @@ -147952,7 +147952,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { /* Compare left half */ k = ms + uint32(1) for { - if !(k > mem && *(*Twchar_t)(unsafe.Pointer(n + uintptr(k-uint32(1))*4)) == *(*Twchar_t)(unsafe.Pointer(h + uintptr(k-uint32(1))*4))) { + if !(k > mem && **(**Twchar_t)(__ccgo_up(n + uintptr(k-uint32(1))*4)) == **(**Twchar_t)(__ccgo_up(h + uintptr(k-uint32(1))*4))) { break } goto _12 @@ -147977,18 +147977,18 @@ func Xwcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { defer func() { trc("-> %v", r) }() } /* Return immediately on empty needle or haystack */ - if !(*(*Twchar_t)(unsafe.Pointer(n)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(n)) != 0) { return h } - if !(*(*Twchar_t)(unsafe.Pointer(h)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(h)) != 0) { return uintptr(0) } /* Use faster algorithms for short needles */ - h = Xwcschr(tls, h, *(*Twchar_t)(unsafe.Pointer(n))) - if !(h != 0) || !(*(*Twchar_t)(unsafe.Pointer(n + 1*4)) != 0) { + h = Xwcschr(tls, h, **(**Twchar_t)(__ccgo_up(n))) + if !(h != 0) || !(**(**Twchar_t)(__ccgo_up(n + 1*4)) != 0) { return h } - if !(*(*Twchar_t)(unsafe.Pointer(h + 1*4)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(h + 1*4)) != 0) { return uintptr(0) } return _twoway_wcsstr(tls, h, n) @@ -148003,26 +148003,26 @@ func Xwcstok(tls *TLS, s uintptr, sep uintptr, p uintptr) (r uintptr) { var v2 bool _, _, _ = v1, v2, v3 if v2 = !(s != 0); v2 { - v1 = *(*uintptr)(unsafe.Pointer(p)) + v1 = **(**uintptr)(__ccgo_up(p)) s = v1 } if v2 && !(v1 != 0) { return UintptrFromInt32(0) } s = s + uintptr(Xwcsspn(tls, s, sep))*4 - if !(*(*Twchar_t)(unsafe.Pointer(s)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(s)) != 0) { v1 = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(p)) = v1 + **(**uintptr)(__ccgo_up(p)) = v1 return v1 } - *(*uintptr)(unsafe.Pointer(p)) = s + uintptr(Xwcscspn(tls, s, sep))*4 - if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)))) != 0 { + **(**uintptr)(__ccgo_up(p)) = s + uintptr(Xwcscspn(tls, s, sep))*4 + if **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(p)))) != 0 { v3 = p v1 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) += 4 - *(*Twchar_t)(unsafe.Pointer(v1)) = uint32(0) + **(**Twchar_t)(__ccgo_up(v1)) = uint32(0) } else { - *(*uintptr)(unsafe.Pointer(p)) = uintptr(0) + **(**uintptr)(__ccgo_up(p)) = uintptr(0) } return s } @@ -148043,7 +148043,7 @@ func Xwmemchr(tls *TLS, s uintptr, c Twchar_t, n Tsize_t) (r uintptr) { var v2 uintptr _ = v2 for { - if !(n != 0 && *(*Twchar_t)(unsafe.Pointer(s)) != c) { + if !(n != 0 && **(**Twchar_t)(__ccgo_up(s)) != c) { break } goto _1 @@ -148068,7 +148068,7 @@ func Xwmemcmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { var v2, v3 int32 _, _ = v2, v3 for { - if !(n != 0 && *(*Twchar_t)(unsafe.Pointer(l)) == *(*Twchar_t)(unsafe.Pointer(r))) { + if !(n != 0 && **(**Twchar_t)(__ccgo_up(l)) == **(**Twchar_t)(__ccgo_up(r))) { break } goto _1 @@ -148079,10 +148079,10 @@ func Xwmemcmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { r += 4 } if n != 0 { - if *(*Twchar_t)(unsafe.Pointer(l)) < *(*Twchar_t)(unsafe.Pointer(r)) { + if **(**Twchar_t)(__ccgo_up(l)) < **(**Twchar_t)(__ccgo_up(r)) { v3 = -int32(1) } else { - v3 = BoolInt32(*(*Twchar_t)(unsafe.Pointer(l)) > *(*Twchar_t)(unsafe.Pointer(r))) + v3 = BoolInt32(**(**Twchar_t)(__ccgo_up(l)) > **(**Twchar_t)(__ccgo_up(r))) } v2 = v3 } else { @@ -148110,7 +148110,7 @@ func Xwmemcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { d += 4 v3 = s s += 4 - *(*Twchar_t)(unsafe.Pointer(v2)) = *(*Twchar_t)(unsafe.Pointer(v3)) + **(**Twchar_t)(__ccgo_up(v2)) = **(**Twchar_t)(__ccgo_up(v3)) } return a } @@ -148134,7 +148134,7 @@ func Xwmemmove(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { if !(v1 != 0) { break } - *(*Twchar_t)(unsafe.Pointer(d + uintptr(n)*4)) = *(*Twchar_t)(unsafe.Pointer(s + uintptr(n)*4)) + **(**Twchar_t)(__ccgo_up(d + uintptr(n)*4)) = **(**Twchar_t)(__ccgo_up(s + uintptr(n)*4)) } } else { for { @@ -148147,7 +148147,7 @@ func Xwmemmove(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { d += 4 v4 = s s += 4 - *(*Twchar_t)(unsafe.Pointer(v3)) = *(*Twchar_t)(unsafe.Pointer(v4)) + **(**Twchar_t)(__ccgo_up(v3)) = **(**Twchar_t)(__ccgo_up(v4)) } } return d0 @@ -148170,7 +148170,7 @@ func Xwmemset(tls *TLS, d uintptr, c Twchar_t, n Tsize_t) (r uintptr) { } v2 = d d += 4 - *(*Twchar_t)(unsafe.Pointer(v2)) = c + **(**Twchar_t)(__ccgo_up(v2)) = c } return ret } @@ -148186,7 +148186,7 @@ func Xmkdtemp(tls *TLS, template uintptr) (r uintptr) { l = _strlen(tls, template) retries = int32(100) if l < uint32(6) || Xmemcmp(tls, template+uintptr(l)-uintptr(6), __ccgo_ts+1563, uint32(6)) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } for { @@ -148199,7 +148199,7 @@ func Xmkdtemp(tls *TLS, template uintptr) (r uintptr) { ; retries = retries - 1 v1 = retries - if !(v1 != 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EEXIST)) { + if !(v1 != 0 && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EEXIST)) { break } } @@ -148227,7 +148227,7 @@ func X__mkostemps(tls *TLS, template uintptr, len1 int32, flags int32) (r int32) _, _, _, _ = fd, l, retries, v1 l = _strlen(tls, template) if l < uint32(6) || Uint32FromInt32(len1) > l-uint32(6) || Xmemcmp(tls, template+uintptr(l)-uintptr(len1)-uintptr(6), __ccgo_ts+1563, uint32(6)) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } flags = flags - flags&(Int32FromInt32(03)|Int32FromInt32(O_PATH)) @@ -148244,7 +148244,7 @@ func X__mkostemps(tls *TLS, template uintptr, len1 int32, flags int32) (r int32) ; retries = retries - 1 v1 = retries - if !(v1 != 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EEXIST)) { + if !(v1 != 0 && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EEXIST)) { break } } @@ -148290,15 +148290,15 @@ func Xmktemp(tls *TLS, template uintptr) (r uintptr) { l = _strlen(tls, template) retries = int32(100) if l < uint32(6) || Xmemcmp(tls, template+uintptr(l)-uintptr(6), __ccgo_ts+1563, uint32(6)) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) - *(*uint8)(unsafe.Pointer(template)) = uint8(0) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) + **(**uint8)(__ccgo_up(template)) = uint8(0) return template } for { ___randname(tls, template+uintptr(l)-uintptr(6)) if Xstat(tls, template, bp) != 0 { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(ENOENT) { - *(*uint8)(unsafe.Pointer(template)) = uint8(0) + if **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(ENOENT) { + **(**uint8)(__ccgo_up(template)) = uint8(0) } return template } @@ -148311,8 +148311,8 @@ func Xmktemp(tls *TLS, template uintptr) (r uintptr) { break } } - *(*uint8)(unsafe.Pointer(template)) = uint8(0) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EEXIST) + **(**uint8)(__ccgo_up(template)) = uint8(0) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EEXIST) return template } @@ -148336,13 +148336,13 @@ func Xcfmakeraw(tls *TLS, t uintptr) { if __ccgo_strace { trc("tls=%v t=%v, (%v:)", tls, t, origin(2)) } - *(*Ttcflag_t)(unsafe.Pointer(t)) &= Uint32FromInt32(^(Int32FromInt32(IGNBRK) | Int32FromInt32(BRKINT) | Int32FromInt32(PARMRK) | Int32FromInt32(ISTRIP) | Int32FromInt32(INLCR) | Int32FromInt32(IGNCR) | Int32FromInt32(ICRNL) | Int32FromInt32(IXON))) - *(*Ttcflag_t)(unsafe.Pointer(t + 4)) &= Uint32FromInt32(^Int32FromInt32(OPOST)) - *(*Ttcflag_t)(unsafe.Pointer(t + 12)) &= Uint32FromInt32(^(Int32FromInt32(ECHO) | Int32FromInt32(ECHONL) | Int32FromInt32(ICANON) | Int32FromInt32(ISIG) | Int32FromInt32(IEXTEN))) - *(*Ttcflag_t)(unsafe.Pointer(t + 8)) &= Uint32FromInt32(^(Int32FromInt32(CSIZE) | Int32FromInt32(PARENB))) - *(*Ttcflag_t)(unsafe.Pointer(t + 8)) |= uint32(CS8) - *(*Tcc_t)(unsafe.Pointer(t + 17 + 6)) = uint8(1) - *(*Tcc_t)(unsafe.Pointer(t + 17 + 5)) = uint8(0) + **(**Ttcflag_t)(__ccgo_up(t)) &= Uint32FromInt32(^(Int32FromInt32(IGNBRK) | Int32FromInt32(BRKINT) | Int32FromInt32(PARMRK) | Int32FromInt32(ISTRIP) | Int32FromInt32(INLCR) | Int32FromInt32(IGNCR) | Int32FromInt32(ICRNL) | Int32FromInt32(IXON))) + **(**Ttcflag_t)(__ccgo_up(t + 4)) &= Uint32FromInt32(^Int32FromInt32(OPOST)) + **(**Ttcflag_t)(__ccgo_up(t + 12)) &= Uint32FromInt32(^(Int32FromInt32(ECHO) | Int32FromInt32(ECHONL) | Int32FromInt32(ICANON) | Int32FromInt32(ISIG) | Int32FromInt32(IEXTEN))) + **(**Ttcflag_t)(__ccgo_up(t + 8)) &= Uint32FromInt32(^(Int32FromInt32(CSIZE) | Int32FromInt32(PARENB))) + **(**Ttcflag_t)(__ccgo_up(t + 8)) |= uint32(CS8) + **(**Tcc_t)(__ccgo_up(t + 17 + 6)) = uint8(1) + **(**Tcc_t)(__ccgo_up(t + 17 + 5)) = uint8(0) } func Xcfsetospeed(tls *TLS, tio uintptr, speed Tspeed_t) (r int32) { @@ -148351,11 +148351,11 @@ func Xcfsetospeed(tls *TLS, tio uintptr, speed Tspeed_t) (r int32) { defer func() { trc("-> %v", r) }() } if speed&Uint32FromInt32(^Int32FromInt32(CBAUD)) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } - *(*Ttcflag_t)(unsafe.Pointer(tio + 8)) &= Uint32FromInt32(^Int32FromInt32(CBAUD)) - *(*Ttcflag_t)(unsafe.Pointer(tio + 8)) |= speed + **(**Ttcflag_t)(__ccgo_up(tio + 8)) &= Uint32FromInt32(^Int32FromInt32(CBAUD)) + **(**Ttcflag_t)(__ccgo_up(tio + 8)) |= speed return 0 } @@ -148434,7 +148434,7 @@ func Xtcgetsid(tls *TLS, fd int32) (r Tpid_t) { if Xioctl(tls, fd, int32(TIOCGSID), VaList(bp+16, bp)) < 0 { return -int32(1) } - return *(*int32)(unsafe.Pointer(bp)) + return **(**int32)(__ccgo_up(bp)) } func Xtcgetwinsize(tls *TLS, fd int32, wsz uintptr) (r int32) { @@ -148464,7 +148464,7 @@ func Xtcsetattr(tls *TLS, fd int32, act int32, tio uintptr) (r int32) { bp := tls.Alloc(16) defer tls.Free(16) if act < 0 || act > int32(2) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } return Xioctl(tls, fd, int32(TCSETS)+act, VaList(bp+8, tio)) @@ -148495,8 +148495,8 @@ func X__map_file(tls *TLS, pathname uintptr, size uintptr) (r uintptr) { return uintptr(0) } if !(X__fstat(tls, fd, bp) != 0) { - map1 = X__mmap(tls, uintptr(0), Uint32FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_size), int32(PROT_READ), int32(MAP_SHARED), fd, 0) - *(*Tsize_t)(unsafe.Pointer(size)) = Uint32FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_size) + map1 = X__mmap(tls, uintptr(0), Uint32FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_size), int32(PROT_READ), int32(MAP_SHARED), fd, 0) + **(**Tsize_t)(__ccgo_up(size)) = Uint32FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_size) } X__syscall1(tls, int32(SYS_close), fd) if map1 == uintptr(-Int32FromInt32(1)) { @@ -148668,7 +148668,7 @@ func X__tm_to_secs(tls *TLS, tm uintptr) (r int64) { year = year + int64(adj) } t = X__year_to_secs(tls, year, bp) - t = t + int64(X__month_to_secs(tls, month, *(*int32)(unsafe.Pointer(bp)))) + t = t + int64(X__month_to_secs(tls, month, **(**int32)(__ccgo_up(bp)))) t = t + int64(86400)*int64((*Ttm)(unsafe.Pointer(tm)).Ftm_mday-Int32FromInt32(1)) t = t + int64(3600)*int64((*Ttm)(unsafe.Pointer(tm)).Ftm_hour) t = t + int64(60)*int64((*Ttm)(unsafe.Pointer(tm)).Ftm_min) @@ -148702,14 +148702,14 @@ func _getint2(tls *TLS, p uintptr) (r int32) { _ = x x = uint32(0) for { - if !(Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)))))-int32('0')) < uint32(10)) { + if !(Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)))))-int32('0')) < uint32(10)) { break } - x = Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)))))-int32('0')) + uint32(10)*x + x = Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)))))-int32('0')) + uint32(10)*x goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 } return Int32FromUint32(x) } @@ -148718,20 +148718,20 @@ func _getoff(tls *TLS, p uintptr) (r int32) { var neg, off, v1 int32 _, _, _ = neg, off, v1 neg = 0 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('-') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) == int32('-') { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 neg = int32(1) } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('+') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) == int32('+') { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 } } off = int32(3600) * _getint2(tls, p) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32(':') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) == int32(':') { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 off = off + int32(60)*_getint2(tls, p) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32(':') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) == int32(':') { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 off = off + _getint2(tls, p) } } @@ -148746,61 +148746,61 @@ func _getoff(tls *TLS, p uintptr) (r int32) { func _getrule(tls *TLS, p uintptr, rule uintptr) { var r, v1 int32 _, _ = r, v1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) - *(*int32)(unsafe.Pointer(rule)) = v1 + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) + **(**int32)(__ccgo_up(rule)) = v1 r = v1 if r != int32('M') { if r == int32('J') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 } else { - *(*int32)(unsafe.Pointer(rule)) = 0 + **(**int32)(__ccgo_up(rule)) = 0 } - *(*int32)(unsafe.Pointer(rule + 1*4)) = _getint2(tls, p) + **(**int32)(__ccgo_up(rule + 1*4)) = _getint2(tls, p) } else { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 - *(*int32)(unsafe.Pointer(rule + 1*4)) = _getint2(tls, p) - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 - *(*int32)(unsafe.Pointer(rule + 2*4)) = _getint2(tls, p) - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 - *(*int32)(unsafe.Pointer(rule + 3*4)) = _getint2(tls, p) - } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('/') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 - *(*int32)(unsafe.Pointer(rule + 4*4)) = _getoff(tls, p) + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 + **(**int32)(__ccgo_up(rule + 1*4)) = _getint2(tls, p) + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 + **(**int32)(__ccgo_up(rule + 2*4)) = _getint2(tls, p) + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 + **(**int32)(__ccgo_up(rule + 3*4)) = _getint2(tls, p) + } + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) == int32('/') { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 + **(**int32)(__ccgo_up(rule + 4*4)) = _getoff(tls, p) } else { - *(*int32)(unsafe.Pointer(rule + 4*4)) = int32(7200) + **(**int32)(__ccgo_up(rule + 4*4)) = int32(7200) } } func _getname(tls *TLS, d uintptr, p uintptr) { var i, v3 int32 _, _ = i, v3 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('<') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) == int32('<') { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 i = 0 for { - if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i)))) != int32('>')) { + if !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)) + uintptr(i))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)) + uintptr(i)))) != int32('>')) { break } if i < int32(TZNAME_MAX) { - *(*uint8)(unsafe.Pointer(d + uintptr(i))) = *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))) + **(**uint8)(__ccgo_up(d + uintptr(i))) = **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)) + uintptr(i))) } goto _1 _1: ; i = i + 1 } - if *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))) != 0 { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + if **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)) + uintptr(i))) != 0 { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 } } else { i = 0 for { - if !(Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))))|int32(32)-int32('a')) < uint32(26)) { + if !(Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)) + uintptr(i))))|int32(32)-int32('a')) < uint32(26)) { break } if i < int32(TZNAME_MAX) { - *(*uint8)(unsafe.Pointer(d + uintptr(i))) = *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))) + **(**uint8)(__ccgo_up(d + uintptr(i))) = **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)) + uintptr(i))) } goto _2 _2: @@ -148808,17 +148808,17 @@ func _getname(tls *TLS, d uintptr, p uintptr) { i = i + 1 } } - *(*uintptr)(unsafe.Pointer(p)) += uintptr(i) + **(**uintptr)(__ccgo_up(p)) += uintptr(i) if i < int32(TZNAME_MAX) { v3 = i } else { v3 = int32(TZNAME_MAX) } - *(*uint8)(unsafe.Pointer(d + uintptr(v3))) = uint8(0) + **(**uint8)(__ccgo_up(d + uintptr(v3))) = uint8(0) } func _zi_read32(tls *TLS, z uintptr) (r Tuint32_t) { - return uint32(*(*uint8)(unsafe.Pointer(z)))< Uint32FromInt32(Int32FromInt32(PATH_MAX)+Int32FromInt32(1)) { - *(*uintptr)(unsafe.Pointer(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) + **(**uintptr)(__ccgo_up(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) i = Uint32FromInt32(3) } if i >= _old_tz_size { @@ -148900,13 +148900,13 @@ func _do_tzset(tls *TLS) { _old_tz = Xmalloc(tls, _old_tz_size) } if _old_tz != 0 { - _memcpy(tls, _old_tz, *(*uintptr)(unsafe.Pointer(bp + 288)), i+uint32(1)) + _memcpy(tls, _old_tz, **(**uintptr)(__ccgo_up(bp + 288)), i+uint32(1)) } posix_form = 0 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) != int32(':') { - *(*uintptr)(unsafe.Pointer(bp + 292)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) != int32(':') { + **(**uintptr)(__ccgo_up(bp + 292)) = **(**uintptr)(__ccgo_up(bp + 288)) _getname(tls, bp+301, bp+292) - if *(*uintptr)(unsafe.Pointer(bp + 292)) != *(*uintptr)(unsafe.Pointer(bp + 288)) && (Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 292))))) == int32('+') || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 292))))) == int32('-') || BoolInt32(uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 292)))))-uint32('0') < uint32(10)) != 0 || !(Xstrcmp(tls, bp+301, __ccgo_ts+1588) != 0) || !(Xstrcmp(tls, bp+301, __ccgo_ts+1592) != 0)) { + if **(**uintptr)(__ccgo_up(bp + 292)) != **(**uintptr)(__ccgo_up(bp + 288)) && (Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 292))))) == int32('+') || Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 292))))) == int32('-') || BoolInt32(uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 292)))))-uint32('0') < uint32(10)) != 0 || !(Xstrcmp(tls, bp+301, __ccgo_ts+1588) != 0) || !(Xstrcmp(tls, bp+301, __ccgo_ts+1592) != 0)) { posix_form = int32(1) } } @@ -148914,21 +148914,21 @@ func _do_tzset(tls *TLS) { * pathame beginning with "."; in secure mode, only the * standard path will be searched. */ if !(posix_form != 0) { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32(':') { - *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32(':') { + **(**uintptr)(__ccgo_up(bp + 288)) = **(**uintptr)(__ccgo_up(bp + 288)) + 1 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32('/') || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32('.') { - if !(X__libc.Fsecure != 0) || !(Xstrcmp(tls, *(*uintptr)(unsafe.Pointer(bp + 288)), __ccgo_ts+1573) != 0) { - map1 = X__map_file(tls, *(*uintptr)(unsafe.Pointer(bp + 288)), uintptr(unsafe.Pointer(&_map_size))) + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32('/') || Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32('.') { + if !(X__libc.Fsecure != 0) || !(Xstrcmp(tls, **(**uintptr)(__ccgo_up(bp + 288)), __ccgo_ts+1573) != 0) { + map1 = X__map_file(tls, **(**uintptr)(__ccgo_up(bp + 288)), uintptr(unsafe.Pointer(&_map_size))) } } else { - l = _strlen(tls, *(*uintptr)(unsafe.Pointer(bp + 288))) - if l <= uint32(NAME_MAX) && !(Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp + 288)), int32('.')) != 0) { - _memcpy(tls, pathname, *(*uintptr)(unsafe.Pointer(bp + 288)), l+uint32(1)) - *(*uint8)(unsafe.Pointer(pathname + uintptr(l))) = uint8(0) + l = _strlen(tls, **(**uintptr)(__ccgo_up(bp + 288))) + if l <= uint32(NAME_MAX) && !(Xstrchr(tls, **(**uintptr)(__ccgo_up(bp + 288)), int32('.')) != 0) { + _memcpy(tls, pathname, **(**uintptr)(__ccgo_up(bp + 288)), l+uint32(1)) + **(**uint8)(__ccgo_up(pathname + uintptr(l))) = uint8(0) try = uintptr(unsafe.Pointer(&_search)) for { - if !(!(map1 != 0) && *(*uint8)(unsafe.Pointer(try)) != 0) { + if !(!(map1 != 0) && **(**uint8)(__ccgo_up(try)) != 0) { break } l = _strlen(tls, try) @@ -148942,18 +148942,18 @@ func _do_tzset(tls *TLS) { } } if !(map1 != 0) { - *(*uintptr)(unsafe.Pointer(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) + **(**uintptr)(__ccgo_up(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) } } if map1 != 0 && (_map_size < uint32(44) || Xmemcmp(tls, map1, __ccgo_ts+1596, uint32(4)) != 0) { X__munmap(tls, map1, _map_size) map1 = uintptr(0) - *(*uintptr)(unsafe.Pointer(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) + **(**uintptr)(__ccgo_up(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) } _zi = map1 if map1 != 0 { scale = int32(2) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(map1 + 4))) != int32('1') { + if Int32FromUint8(**(**uint8)(__ccgo_up(map1 + 4))) != int32('1') { *(*[6]uint8)(unsafe.Pointer(bp)) = [6]uint8{ 0: uint8(1), 1: uint8(1), @@ -148972,18 +148972,18 @@ func _do_tzset(tls *TLS) { _types = _index + uintptr(_zi_read32(tls, _trans-uintptr(12))) _abbrevs = _types + uintptr(uint32(6)*_zi_read32(tls, _trans-uintptr(8))) _abbrevs_end = _abbrevs + uintptr(_zi_read32(tls, _trans-uintptr(4))) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(_zi + uintptr(_map_size-uint32(1))))) == int32('\n') { - *(*uintptr)(unsafe.Pointer(bp + 288)) = _zi + uintptr(_map_size) - uintptr(2) + if Int32FromUint8(**(**uint8)(__ccgo_up(_zi + uintptr(_map_size-uint32(1))))) == int32('\n') { + **(**uintptr)(__ccgo_up(bp + 288)) = _zi + uintptr(_map_size) - uintptr(2) for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) != int32('\n')) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) != int32('\n')) { break } goto _4 _4: ; - *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) - 1 + **(**uintptr)(__ccgo_up(bp + 288)) = **(**uintptr)(__ccgo_up(bp + 288)) - 1 } - *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 + **(**uintptr)(__ccgo_up(bp + 288)) = **(**uintptr)(__ccgo_up(bp + 288)) + 1 } else { v5 = UintptrFromInt32(0) Xtzname[int32(1)] = v5 @@ -148998,12 +148998,12 @@ func _do_tzset(tls *TLS) { if !(p1 < _abbrevs) { break } - if !(*(*uint8)(unsafe.Pointer(p1 + 4)) != 0) && !(Xtzname[0] != 0) { - Xtzname[0] = _abbrevs + uintptr(*(*uint8)(unsafe.Pointer(p1 + 5))) + if !(**(**uint8)(__ccgo_up(p1 + 4)) != 0) && !(Xtzname[0] != 0) { + Xtzname[0] = _abbrevs + uintptr(**(**uint8)(__ccgo_up(p1 + 5))) Xtimezone = Int32FromUint32(-_zi_read32(tls, p1)) } - if *(*uint8)(unsafe.Pointer(p1 + 4)) != 0 && !(Xtzname[int32(1)] != 0) { - Xtzname[int32(1)] = _abbrevs + uintptr(*(*uint8)(unsafe.Pointer(p1 + 5))) + if **(**uint8)(__ccgo_up(p1 + 4)) != 0 && !(Xtzname[int32(1)] != 0) { + Xtzname[int32(1)] = _abbrevs + uintptr(**(**uint8)(__ccgo_up(p1 + 5))) _dst_off = Int32FromUint32(-_zi_read32(tls, p1)) Xdaylight = int32(1) } @@ -149025,8 +149025,8 @@ func _do_tzset(tls *TLS) { return } } - if !(*(*uintptr)(unsafe.Pointer(bp + 288)) != 0) { - *(*uintptr)(unsafe.Pointer(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) + if !(**(**uintptr)(__ccgo_up(bp + 288)) != 0) { + **(**uintptr)(__ccgo_up(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) } _getname(tls, uintptr(unsafe.Pointer(&_std_name)), bp+288) Xtzname[0] = uintptr(unsafe.Pointer(&_std_name)) @@ -149035,7 +149035,7 @@ func _do_tzset(tls *TLS) { Xtzname[int32(1)] = uintptr(unsafe.Pointer(&_dst_name)) if _dst_name[0] != 0 { Xdaylight = int32(1) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32('+') || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32('-') || Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288)))))-int32('0')) < uint32(10) { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32('+') || Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32('-') || Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288)))))-int32('0')) < uint32(10) { _dst_off = _getoff(tls, bp+288) } else { _dst_off = Xtimezone - int32(3600) @@ -149044,12 +149044,12 @@ func _do_tzset(tls *TLS) { Xdaylight = 0 _dst_off = Xtimezone } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32(',') { - *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32(',') { + **(**uintptr)(__ccgo_up(bp + 288)) = **(**uintptr)(__ccgo_up(bp + 288)) + 1 _getrule(tls, bp+288, uintptr(unsafe.Pointer(&_r0))) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32(',') { - *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32(',') { + **(**uintptr)(__ccgo_up(bp + 288)) = **(**uintptr)(__ccgo_up(bp + 288)) + 1 _getrule(tls, bp+288, uintptr(unsafe.Pointer(&_r12))) } } @@ -149070,7 +149070,7 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { n = Uint32FromInt32((int32(_index) - int32(_trans)) >> scale) if !(n != 0) { if alt != 0 { - *(*Tsize_t)(unsafe.Pointer(alt)) = uint32(0) + **(**Tsize_t)(__ccgo_up(alt)) = uint32(0) } return uint32(0) } @@ -149084,7 +149084,7 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { x = Uint64FromInt32(Int32FromUint64(x)) } if local != 0 { - off = Int32FromUint32(_zi_read32(tls, _types+uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(m-uint32(1)))))))) + off = Int32FromUint32(_zi_read32(tls, _types+uintptr(int32(6)*Int32FromUint8(**(**uint8)(__ccgo_up(_index + uintptr(m-uint32(1)))))))) } if t-int64(off) < Int64FromUint64(x) { n = n / uint32(2) @@ -149113,7 +149113,7 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { if !(i != 0) { break } - if !(*(*uint8)(unsafe.Pointer(_types + uintptr(i-uint32(6)+uint32(4)))) != 0) { + if !(**(**uint8)(__ccgo_up(_types + uintptr(i-uint32(6)+uint32(4)))) != 0) { j = i - uint32(6) } goto _1 @@ -149128,24 +149128,24 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { * and the index-zero (after transition) type as the alt. */ if t-int64(off) < Int64FromUint64(x) { if alt != 0 { - *(*Tsize_t)(unsafe.Pointer(alt)) = uint32(*(*uint8)(unsafe.Pointer(_index))) + **(**Tsize_t)(__ccgo_up(alt)) = uint32(**(**uint8)(__ccgo_up(_index))) } return j / uint32(6) } } /* Try to find a neighboring opposite-DST-status rule. */ if alt != 0 { - if a != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(_types + uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(a-uint32(1)))))+int32(4))))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(_types + uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(a))))+int32(4))))) { - *(*Tsize_t)(unsafe.Pointer(alt)) = uint32(*(*uint8)(unsafe.Pointer(_index + uintptr(a-uint32(1))))) + if a != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(_types + uintptr(int32(6)*Int32FromUint8(**(**uint8)(__ccgo_up(_index + uintptr(a-uint32(1)))))+int32(4))))) != Int32FromUint8(**(**uint8)(__ccgo_up(_types + uintptr(int32(6)*Int32FromUint8(**(**uint8)(__ccgo_up(_index + uintptr(a))))+int32(4))))) { + **(**Tsize_t)(__ccgo_up(alt)) = uint32(**(**uint8)(__ccgo_up(_index + uintptr(a-uint32(1))))) } else { - if a+uint32(1) < n && Int32FromUint8(*(*uint8)(unsafe.Pointer(_types + uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(a+uint32(1)))))+int32(4))))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(_types + uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(a))))+int32(4))))) { - *(*Tsize_t)(unsafe.Pointer(alt)) = uint32(*(*uint8)(unsafe.Pointer(_index + uintptr(a+uint32(1))))) + if a+uint32(1) < n && Int32FromUint8(**(**uint8)(__ccgo_up(_types + uintptr(int32(6)*Int32FromUint8(**(**uint8)(__ccgo_up(_index + uintptr(a+uint32(1)))))+int32(4))))) != Int32FromUint8(**(**uint8)(__ccgo_up(_types + uintptr(int32(6)*Int32FromUint8(**(**uint8)(__ccgo_up(_index + uintptr(a))))+int32(4))))) { + **(**Tsize_t)(__ccgo_up(alt)) = uint32(**(**uint8)(__ccgo_up(_index + uintptr(a+uint32(1))))) } else { - *(*Tsize_t)(unsafe.Pointer(alt)) = uint32(*(*uint8)(unsafe.Pointer(_index + uintptr(a)))) + **(**Tsize_t)(__ccgo_up(alt)) = uint32(**(**uint8)(__ccgo_up(_index + uintptr(a)))) } } } - return uint32(*(*uint8)(unsafe.Pointer(_index + uintptr(a)))) + return uint32(**(**uint8)(__ccgo_up(_index + uintptr(a)))) } func _days_in_month1(tls *TLS, m int32, is_leap int32) (r int32) { @@ -149167,28 +149167,28 @@ func _rule_to_secs(tls *TLS, rule uintptr, year int32) (r int64) { var _ /* is_leap at bp+0 */ int32 _, _, _, _, _, _, _ = d, days, m, n, t, wday, x t = X__year_to_secs(tls, int64(year), bp) - if *(*int32)(unsafe.Pointer(rule)) != int32('M') { - x = *(*int32)(unsafe.Pointer(rule + 1*4)) - if *(*int32)(unsafe.Pointer(rule)) == int32('J') && (x < int32(60) || !(*(*int32)(unsafe.Pointer(bp)) != 0)) { + if **(**int32)(__ccgo_up(rule)) != int32('M') { + x = **(**int32)(__ccgo_up(rule + 1*4)) + if **(**int32)(__ccgo_up(rule)) == int32('J') && (x < int32(60) || !(**(**int32)(__ccgo_up(bp)) != 0)) { x = x - 1 } t = t + int64(int32(86400)*x) } else { - m = *(*int32)(unsafe.Pointer(rule + 1*4)) - n = *(*int32)(unsafe.Pointer(rule + 2*4)) - d = *(*int32)(unsafe.Pointer(rule + 3*4)) - t = t + int64(X__month_to_secs(tls, m-int32(1), *(*int32)(unsafe.Pointer(bp)))) + m = **(**int32)(__ccgo_up(rule + 1*4)) + n = **(**int32)(__ccgo_up(rule + 2*4)) + d = **(**int32)(__ccgo_up(rule + 3*4)) + t = t + int64(X__month_to_secs(tls, m-int32(1), **(**int32)(__ccgo_up(bp)))) wday = int32((t+int64(Int32FromInt32(4)*Int32FromInt32(86400)))%int64(Int32FromInt32(7)*Int32FromInt32(86400))) / int32(86400) days = d - wday if days < 0 { days = days + int32(7) } - if n == int32(5) && days+int32(28) >= _days_in_month1(tls, m, *(*int32)(unsafe.Pointer(bp))) { + if n == int32(5) && days+int32(28) >= _days_in_month1(tls, m, **(**int32)(__ccgo_up(bp))) { n = int32(4) } t = t + int64(int32(86400)*(days+int32(7)*(n-int32(1)))) } - t = t + int64(*(*int32)(unsafe.Pointer(rule + 4*4))) + t = t + int64(**(**int32)(__ccgo_up(rule + 4*4))) return t } @@ -149214,11 +149214,11 @@ func X__secs_to_zone(tls *TLS, t int64, local int32, isdst uintptr, offset uintp if _zi != 0 { i = _scan_trans(tls, t, local, bp) if i != Uint32FromInt32(-Int32FromInt32(1)) { - *(*int32)(unsafe.Pointer(isdst)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(_types + uintptr(uint32(6)*i+uint32(4))))) - *(*int32)(unsafe.Pointer(offset)) = int32(Int32FromUint32(_zi_read32(tls, _types+uintptr(uint32(6)*i)))) - *(*uintptr)(unsafe.Pointer(zonename)) = _abbrevs + uintptr(*(*uint8)(unsafe.Pointer(_types + uintptr(uint32(6)*i+uint32(5))))) + **(**int32)(__ccgo_up(isdst)) = Int32FromUint8(**(**uint8)(__ccgo_up(_types + uintptr(uint32(6)*i+uint32(4))))) + **(**int32)(__ccgo_up(offset)) = int32(Int32FromUint32(_zi_read32(tls, _types+uintptr(uint32(6)*i)))) + **(**uintptr)(__ccgo_up(zonename)) = _abbrevs + uintptr(**(**uint8)(__ccgo_up(_types + uintptr(uint32(6)*i+uint32(5))))) if oppoff != 0 { - *(*int32)(unsafe.Pointer(oppoff)) = int32(Int32FromUint32(_zi_read32(tls, _types+uintptr(uint32(6)**(*Tsize_t)(unsafe.Pointer(bp)))))) + **(**int32)(__ccgo_up(oppoff)) = int32(Int32FromUint32(_zi_read32(tls, _types+uintptr(uint32(6)***(**Tsize_t)(__ccgo_up(bp)))))) } ___unlock(tls, uintptr(unsafe.Pointer(&_lock4))) return @@ -149256,23 +149256,23 @@ func X__secs_to_zone(tls *TLS, t int64, local int32, isdst uintptr, offset uintp goto std std: ; - *(*int32)(unsafe.Pointer(isdst)) = 0 - *(*int32)(unsafe.Pointer(offset)) = -Xtimezone + **(**int32)(__ccgo_up(isdst)) = 0 + **(**int32)(__ccgo_up(offset)) = -Xtimezone if oppoff != 0 { - *(*int32)(unsafe.Pointer(oppoff)) = -_dst_off + **(**int32)(__ccgo_up(oppoff)) = -_dst_off } - *(*uintptr)(unsafe.Pointer(zonename)) = Xtzname[0] + **(**uintptr)(__ccgo_up(zonename)) = Xtzname[0] ___unlock(tls, uintptr(unsafe.Pointer(&_lock4))) return goto dst dst: ; - *(*int32)(unsafe.Pointer(isdst)) = int32(1) - *(*int32)(unsafe.Pointer(offset)) = -_dst_off + **(**int32)(__ccgo_up(isdst)) = int32(1) + **(**int32)(__ccgo_up(offset)) = -_dst_off if oppoff != 0 { - *(*int32)(unsafe.Pointer(oppoff)) = -Xtimezone + **(**int32)(__ccgo_up(oppoff)) = -Xtimezone } - *(*uintptr)(unsafe.Pointer(zonename)) = Xtzname[int32(1)] + **(**uintptr)(__ccgo_up(zonename)) = Xtzname[int32(1)] ___unlock(tls, uintptr(unsafe.Pointer(&_lock4))) } @@ -149315,11 +149315,11 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { if !((y-Int32FromInt32(68))&Int32FromInt32(3) != 0) { leaps = leaps - 1 if is_leap != 0 { - *(*int32)(unsafe.Pointer(is_leap)) = int32(1) + **(**int32)(__ccgo_up(is_leap)) = int32(1) } } else { if is_leap != 0 { - *(*int32)(unsafe.Pointer(is_leap)) = 0 + **(**int32)(__ccgo_up(is_leap)) = 0 } } return int64(int32(31536000)*(y-int32(70)) + int32(86400)*leaps) @@ -149334,7 +149334,7 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { rem = rem + int32(400) } if !(rem != 0) { - *(*int32)(unsafe.Pointer(is_leap)) = int32(1) + **(**int32)(__ccgo_up(is_leap)) = int32(1) centuries = 0 leaps1 = 0 } else { @@ -149355,15 +149355,15 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { } } if !(rem != 0) { - *(*int32)(unsafe.Pointer(is_leap)) = 0 + **(**int32)(__ccgo_up(is_leap)) = 0 leaps1 = 0 } else { leaps1 = Int32FromUint32(Uint32FromInt32(rem) / uint32(4)) rem = Int32FromUint32(uint32(rem) % Uint32FromUint32(4)) - *(*int32)(unsafe.Pointer(is_leap)) = BoolInt32(!(rem != 0)) + **(**int32)(__ccgo_up(is_leap)) = BoolInt32(!(rem != 0)) } } - leaps1 = leaps1 + (int32(97)*cycles + int32(24)*centuries - *(*int32)(unsafe.Pointer(is_leap))) + leaps1 = leaps1 + (int32(97)*cycles + int32(24)*centuries - **(**int32)(__ccgo_up(is_leap))) return (year-int64(100))*int64(31536000) + int64(leaps1)*int64(86400) + int64(946684800) + int64(86400) } @@ -149425,10 +149425,10 @@ func Xclock(tls *TLS) (r Tclock_t) { if X__clock_gettime(tls, int32(CLOCK_PROCESS_CPUTIME_ID), bp) != 0 { return -int32(1) } - if (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec > int64(Int32FromInt32(0x7fffffff)/Int32FromInt32(1000000)) || int64((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_nsec/int32(1000)) > int64(0x7fffffff)-int64(1000000)*(*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec { + if (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec > int64(Int32FromInt32(0x7fffffff)/Int32FromInt32(1000000)) || int64((**(**Ttimespec)(__ccgo_up(bp))).Ftv_nsec/int32(1000)) > int64(0x7fffffff)-int64(1000000)*(**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec { return -int32(1) } - return int32((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec*int64(1000000) + int64((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_nsec/int32(1000))) + return int32((**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec*int64(1000000) + int64((**(**Ttimespec)(__ccgo_up(bp))).Ftv_nsec/int32(1000))) } func Xclock_getcpuclockid(tls *TLS, pid Tpid_t, clk uintptr) (r int32) { @@ -149450,7 +149450,7 @@ func Xclock_getcpuclockid(tls *TLS, pid Tpid_t, clk uintptr) (r int32) { if ret != 0 { return -ret } - *(*Tclockid_t)(unsafe.Pointer(clk)) = id + **(**Tclockid_t)(__ccgo_up(clk)) = id return 0 } @@ -149468,8 +149468,8 @@ func Xclock_getres(tls *TLS, clk Tclockid_t, ts uintptr) (r1 int32) { if int32(SYS_clock_getres_time32) != int32(SYS_clock_getres_time64) { r = int32(X__syscall2(tls, int32(SYS_clock_getres_time32), clk, int32(bp))) if !(r != 0) && ts != 0 { - (*Ttimespec)(unsafe.Pointer(ts)).Ftv_sec = int64((*(*[2]int32)(unsafe.Pointer(bp)))[0]) - (*Ttimespec)(unsafe.Pointer(ts)).Ftv_nsec = (*(*[2]int32)(unsafe.Pointer(bp)))[int32(1)] + (*Ttimespec)(unsafe.Pointer(ts)).Ftv_sec = int64((**(**[2]int32)(__ccgo_up(bp)))[0]) + (*Ttimespec)(unsafe.Pointer(ts)).Ftv_nsec = (**(**[2]int32)(__ccgo_up(bp)))[int32(1)] } return X__syscall_ret(tls, Uint32FromInt32(r)) } @@ -149498,11 +149498,11 @@ func X__clock_gettime(tls *TLS, clk Tclockid_t, ts uintptr) (r1 int32) { r = int32(X__syscall2(tls, int32(SYS_clock_gettime32), clk, int32(bp))) if r == -int32(ENOSYS) && clk == CLOCK_REALTIME { r = int32(X__syscall2(tls, int32(SYS_gettimeofday_time32), int32(bp), int32(Int32FromInt32(0)))) - *(*int32)(unsafe.Pointer(bp + 1*4)) *= int32(1000) + **(**int32)(__ccgo_up(bp + 1*4)) *= int32(1000) } if !(r != 0) { - (*Ttimespec)(unsafe.Pointer(ts)).Ftv_sec = int64((*(*[2]int32)(unsafe.Pointer(bp)))[0]) - (*Ttimespec)(unsafe.Pointer(ts)).Ftv_nsec = (*(*[2]int32)(unsafe.Pointer(bp)))[int32(1)] + (*Ttimespec)(unsafe.Pointer(ts)).Ftv_sec = int64((**(**[2]int32)(__ccgo_up(bp)))[0]) + (*Ttimespec)(unsafe.Pointer(ts)).Ftv_nsec = (**(**[2]int32)(__ccgo_up(bp)))[int32(1)] return r } return X__syscall_ret(tls, Uint32FromInt32(r)) @@ -149556,7 +149556,7 @@ func X__clock_nanosleep(tls *TLS, clk Tclockid_t, flags int32, req uintptr, rem } else { v2 = uint64(0x7fffffff) + (0+Uint64FromInt64(s))>>int32(63) } - *(*[2]int32)(unsafe.Pointer(bp + 16)) = [2]int32{ + **(**[2]int32)(__ccgo_up(bp + 16)) = [2]int32{ 0: int32(Int32FromUint64(v2)), 1: ns, } @@ -149566,8 +149566,8 @@ func X__clock_nanosleep(tls *TLS, clk Tclockid_t, flags int32, req uintptr, rem r = int32(___syscall_cp(tls, int32(SYS_clock_nanosleep_time32), clk, flags, int32(bp+16), int32(bp+16), 0, 0)) } if r == -int32(EINTR) && rem != 0 && !(flags&Int32FromInt32(TIMER_ABSTIME) != 0) { - (*Ttimespec)(unsafe.Pointer(rem)).Ftv_sec = int64((*(*[2]int32)(unsafe.Pointer(bp + 16)))[0]) + extra - (*Ttimespec)(unsafe.Pointer(rem)).Ftv_nsec = (*(*[2]int32)(unsafe.Pointer(bp + 16)))[int32(1)] + (*Ttimespec)(unsafe.Pointer(rem)).Ftv_sec = int64((**(**[2]int32)(__ccgo_up(bp + 16)))[0]) + extra + (*Ttimespec)(unsafe.Pointer(rem)).Ftv_nsec = (**(**[2]int32)(__ccgo_up(bp + 16)))[int32(1)] } return -r } @@ -149674,8 +149674,8 @@ func Xftime(tls *TLS, tp uintptr) (r int32) { var _ /* ts at bp+0 */ Ttimespec _ = v1 Xclock_gettime(tls, CLOCK_REALTIME, bp) - (*Ttimeb)(unsafe.Pointer(tp)).Ftime = (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec - (*Ttimeb)(unsafe.Pointer(tp)).Fmillitm = Uint16FromInt32((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_nsec / int32(1000000)) + (*Ttimeb)(unsafe.Pointer(tp)).Ftime = (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec + (*Ttimeb)(unsafe.Pointer(tp)).Fmillitm = Uint16FromInt32((**(**Ttimespec)(__ccgo_up(bp))).Ftv_nsec / int32(1000000)) v1 = Int16FromInt32(0) (*Ttimeb)(unsafe.Pointer(tp)).Fdstflag = v1 (*Ttimeb)(unsafe.Pointer(tp)).Ftimezone = v1 @@ -149703,7 +149703,7 @@ func Xgetdate(tls *TLS, s uintptr) (r uintptr) { } f = Xfopen(tls, datemsk, __ccgo_ts+315) if !(f != 0) { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENOMEM) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENOMEM) { Xgetdate_err = int32(6) } else { Xgetdate_err = int32(2) @@ -149712,7 +149712,7 @@ func Xgetdate(tls *TLS, s uintptr) (r uintptr) { } for Xfgets(tls, bp, int32(100), f) != 0 { p = Xstrptime(tls, s, bp, uintptr(unsafe.Pointer(&_tmbuf))) - if p != 0 && !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if p != 0 && !(**(**uint8)(__ccgo_up(p)) != 0) { ret = uintptr(unsafe.Pointer(&_tmbuf)) goto out } @@ -149728,7 +149728,7 @@ out: if f != 0 { Xfclose(tls, f) } - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 100)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 100)), uintptr(0)) return ret } @@ -149746,8 +149746,8 @@ func Xgettimeofday(tls *TLS, tv uintptr, tz uintptr) (r int32) { return 0 } Xclock_gettime(tls, CLOCK_REALTIME, bp) - (*Ttimeval)(unsafe.Pointer(tv)).Ftv_sec = (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec - (*Ttimeval)(unsafe.Pointer(tv)).Ftv_usec = int64((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_nsec / int32(1000)) + (*Ttimeval)(unsafe.Pointer(tv)).Ftv_sec = (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec + (*Ttimeval)(unsafe.Pointer(tv)).Ftv_usec = int64(int32((**(**Ttimespec)(__ccgo_up(bp))).Ftv_nsec) / int32(1000)) return 0 } @@ -149766,8 +149766,8 @@ func X__gmtime_r(tls *TLS, t uintptr, tm uintptr) (r uintptr) { trc("tls=%v t=%v tm=%v, (%v:)", tls, t, tm, origin(2)) defer func() { trc("-> %v", r) }() } - if X__secs_to_tm(tls, *(*Ttime_t)(unsafe.Pointer(t)), tm) < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + if X__secs_to_tm(tls, **(**Ttime_t)(__ccgo_up(t)), tm) < 0 { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return uintptr(0) } (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst = 0 @@ -149810,13 +149810,13 @@ func X__localtime_r(tls *TLS, t uintptr, tm uintptr) (r uintptr) { } /* Reject time_t values whose year would overflow int because * __secs_to_zone cannot safely handle them. */ - if *(*Ttime_t)(unsafe.Pointer(t)) < int64(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff))*Int64FromInt64(31622400) || *(*Ttime_t)(unsafe.Pointer(t)) > Int64FromInt32(INT_MAX)*Int64FromInt64(31622400) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + if **(**Ttime_t)(__ccgo_up(t)) < int64(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff))*Int64FromInt64(31622400) || **(**Ttime_t)(__ccgo_up(t)) > Int64FromInt32(INT_MAX)*Int64FromInt64(31622400) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return uintptr(0) } - X__secs_to_zone(tls, *(*Ttime_t)(unsafe.Pointer(t)), 0, tm+32, tm+36, uintptr(0), tm+40) - if X__secs_to_tm(tls, *(*Ttime_t)(unsafe.Pointer(t))+int64((*Ttm)(unsafe.Pointer(tm)).F__tm_gmtoff), tm) < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + X__secs_to_zone(tls, **(**Ttime_t)(__ccgo_up(t)), 0, tm+32, tm+36, uintptr(0), tm+40) + if X__secs_to_tm(tls, **(**Ttime_t)(__ccgo_up(t))+int64((*Ttm)(unsafe.Pointer(tm)).F__tm_gmtoff), tm) < 0 { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return uintptr(0) } return tm @@ -149852,23 +149852,23 @@ func Xmktime(tls *TLS, tm uintptr) (r Ttime_t) { _ = t t = X__tm_to_secs(tls, tm) X__secs_to_zone(tls, t, int32(1), bp+32, bp+36, bp+44, bp+40) - if (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst >= 0 && (*(*Ttm)(unsafe.Pointer(bp))).Ftm_isdst != (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst { - t = t - int64(*(*int32)(unsafe.Pointer(bp + 44))-(*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff) + if (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst >= 0 && (**(**Ttm)(__ccgo_up(bp))).Ftm_isdst != (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst { + t = t - int64(**(**int32)(__ccgo_up(bp + 44))-(**(**Ttm)(__ccgo_up(bp))).F__tm_gmtoff) } - t = t - int64((*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff) + t = t - int64((**(**Ttm)(__ccgo_up(bp))).F__tm_gmtoff) if t != t { goto error } X__secs_to_zone(tls, t, 0, bp+32, bp+36, bp+44, bp+40) - if X__secs_to_tm(tls, t+int64((*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff), bp) < 0 { + if X__secs_to_tm(tls, t+int64((**(**Ttm)(__ccgo_up(bp))).F__tm_gmtoff), bp) < 0 { goto error } - *(*Ttm)(unsafe.Pointer(tm)) = *(*Ttm)(unsafe.Pointer(bp)) + **(**Ttm)(__ccgo_up(tm)) = **(**Ttm)(__ccgo_up(bp)) return t goto error error: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return int64(-int32(1)) } @@ -150029,7 +150029,7 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc val = int64((*Ttm)(unsafe.Pointer(tm)).Ftm_min) goto number case int32('n'): - *(*Tsize_t)(unsafe.Pointer(l)) = uint32(1) + **(**Tsize_t)(__ccgo_up(l)) = uint32(1) return __ccgo_ts + 301 case int32('p'): if (*Ttm)(unsafe.Pointer(tm)).Ftm_hour >= int32(12) { @@ -150048,20 +150048,20 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc item = v1 fmt = X__nl_langinfo_l(tls, item, loc) d = s - *(*Tsize_t)(unsafe.Pointer(l)) = uint32(0) + **(**Tsize_t)(__ccgo_up(l)) = uint32(0) for { - if !(*(*uint8)(unsafe.Pointer(fmt)) != 0) { + if !(**(**uint8)(__ccgo_up(fmt)) != 0) { break } v4 = d d = d + 1 v5 = fmt fmt = fmt + 1 - *(*uint8)(unsafe.Pointer(v4)) = Uint8FromInt32(Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))))) + **(**uint8)(__ccgo_up(v4)) = Uint8FromInt32(Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(v5))))) goto _3 _3: ; - *(*Tsize_t)(unsafe.Pointer(l)) = *(*Tsize_t)(unsafe.Pointer(l)) + 1 + **(**Tsize_t)(__ccgo_up(l)) = **(**Tsize_t)(__ccgo_up(l)) + 1 } return s case int32('r'): @@ -150078,7 +150078,7 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc val = int64((*Ttm)(unsafe.Pointer(tm)).Ftm_sec) goto number case int32('t'): - *(*Tsize_t)(unsafe.Pointer(l)) = uint32(1) + **(**Tsize_t)(__ccgo_up(l)) = uint32(1) return __ccgo_ts + 1315 case int32('T'): fmt = __ccgo_ts + 1665 @@ -150120,27 +150120,27 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc case int32('Y'): val = int64((*Ttm)(unsafe.Pointer(tm)).Ftm_year) + int64(1900) if val >= int64(10000) { - *(*Tsize_t)(unsafe.Pointer(l)) = Uint32FromInt32(Xsnprintf(tls, s, uint32(100), __ccgo_ts+1674, VaList(bp+8, val))) + **(**Tsize_t)(__ccgo_up(l)) = Uint32FromInt32(Xsnprintf(tls, s, uint32(100), __ccgo_ts+1674, VaList(bp+8, val))) return s } width = int32(4) goto number case int32('z'): if (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst < 0 { - *(*Tsize_t)(unsafe.Pointer(l)) = uint32(0) + **(**Tsize_t)(__ccgo_up(l)) = uint32(0) return __ccgo_ts } - *(*Tsize_t)(unsafe.Pointer(l)) = Uint32FromInt32(Xsnprintf(tls, s, uint32(100), __ccgo_ts+1680, VaList(bp+8, (*Ttm)(unsafe.Pointer(tm)).F__tm_gmtoff/int32(3600)*int32(100)+(*Ttm)(unsafe.Pointer(tm)).F__tm_gmtoff%int32(3600)/int32(60)))) + **(**Tsize_t)(__ccgo_up(l)) = Uint32FromInt32(Xsnprintf(tls, s, uint32(100), __ccgo_ts+1680, VaList(bp+8, (*Ttm)(unsafe.Pointer(tm)).F__tm_gmtoff/int32(3600)*int32(100)+(*Ttm)(unsafe.Pointer(tm)).F__tm_gmtoff%int32(3600)/int32(60)))) return s case int32('Z'): if (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst < 0 { - *(*Tsize_t)(unsafe.Pointer(l)) = uint32(0) + **(**Tsize_t)(__ccgo_up(l)) = uint32(0) return __ccgo_ts } fmt = X__tm_to_tzname(tls, tm) goto string case int32('%'): - *(*Tsize_t)(unsafe.Pointer(l)) = uint32(1) + **(**Tsize_t)(__ccgo_up(l)) = uint32(1) return __ccgo_ts + 348 default: return uintptr(0) @@ -150155,13 +150155,13 @@ number: } switch v1 { case int32('-'): - *(*Tsize_t)(unsafe.Pointer(l)) = Uint32FromInt32(Xsnprintf(tls, s, uint32(100), __ccgo_ts+1687, VaList(bp+8, val))) + **(**Tsize_t)(__ccgo_up(l)) = Uint32FromInt32(Xsnprintf(tls, s, uint32(100), __ccgo_ts+1687, VaList(bp+8, val))) case int32('_'): - *(*Tsize_t)(unsafe.Pointer(l)) = Uint32FromInt32(Xsnprintf(tls, s, uint32(100), __ccgo_ts+1692, VaList(bp+8, width, val))) + **(**Tsize_t)(__ccgo_up(l)) = Uint32FromInt32(Xsnprintf(tls, s, uint32(100), __ccgo_ts+1692, VaList(bp+8, width, val))) case int32('0'): fallthrough default: - *(*Tsize_t)(unsafe.Pointer(l)) = Uint32FromInt32(Xsnprintf(tls, s, uint32(100), __ccgo_ts+1698, VaList(bp+8, width, val))) + **(**Tsize_t)(__ccgo_up(l)) = Uint32FromInt32(Xsnprintf(tls, s, uint32(100), __ccgo_ts+1698, VaList(bp+8, width, val))) break } return s @@ -150172,7 +150172,7 @@ nl_strcat: goto string string: ; - *(*Tsize_t)(unsafe.Pointer(l)) = _strlen(tls, fmt) + **(**Tsize_t)(__ccgo_up(l)) = _strlen(tls, fmt) return fmt goto nl_strftime nl_strftime: @@ -150181,8 +150181,8 @@ nl_strftime: goto recu_strftime recu_strftime: ; - *(*Tsize_t)(unsafe.Pointer(l)) = X__strftime_l(tls, s, uint32(100), fmt, tm, loc) - if !(*(*Tsize_t)(unsafe.Pointer(l)) != 0) { + **(**Tsize_t)(__ccgo_up(l)) = X__strftime_l(tls, s, uint32(100), fmt, tm, loc) + if !(**(**Tsize_t)(__ccgo_up(l)) != 0) { return uintptr(0) } return s @@ -150209,46 +150209,46 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl if !(l < n) { break } - if !(*(*uint8)(unsafe.Pointer(f)) != 0) { - *(*uint8)(unsafe.Pointer(s + uintptr(l))) = uint8(0) + if !(**(**uint8)(__ccgo_up(f)) != 0) { + **(**uint8)(__ccgo_up(s + uintptr(l))) = uint8(0) return l } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) != int32('%') { + if Int32FromUint8(**(**uint8)(__ccgo_up(f))) != int32('%') { v2 = l l = l + 1 - *(*uint8)(unsafe.Pointer(s + uintptr(v2))) = *(*uint8)(unsafe.Pointer(f)) + **(**uint8)(__ccgo_up(s + uintptr(v2))) = **(**uint8)(__ccgo_up(f)) goto _1 } f = f + 1 pad = 0 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('-') || Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('_') || Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('0') { + if Int32FromUint8(**(**uint8)(__ccgo_up(f))) == int32('-') || Int32FromUint8(**(**uint8)(__ccgo_up(f))) == int32('_') || Int32FromUint8(**(**uint8)(__ccgo_up(f))) == int32('0') { v3 = f f = f + 1 - pad = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + pad = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } - v4 = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == Int32FromUint8('+')) + v4 = BoolInt32(Int32FromUint8(**(**uint8)(__ccgo_up(f))) == Int32FromUint8('+')) plus = v4 if v4 != 0 { f = f + 1 } - if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(f)))-uint32('0') < uint32(10)) != 0 { + if BoolInt32(uint32(**(**uint8)(__ccgo_up(f)))-uint32('0') < uint32(10)) != 0 { width = Xstrtoul(tls, f, bp+104, int32(10)) } else { width = uint32(0) - *(*uintptr)(unsafe.Pointer(bp + 104)) = f + **(**uintptr)(__ccgo_up(bp + 104)) = f } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 104))))) == int32('C') || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 104))))) == int32('F') || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 104))))) == int32('G') || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 104))))) == int32('Y') { - if !(width != 0) && *(*uintptr)(unsafe.Pointer(bp + 104)) != f { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 104))))) == int32('C') || Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 104))))) == int32('F') || Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 104))))) == int32('G') || Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 104))))) == int32('Y') { + if !(width != 0) && **(**uintptr)(__ccgo_up(bp + 104)) != f { width = uint32(1) } } else { width = uint32(0) } - f = *(*uintptr)(unsafe.Pointer(bp + 104)) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('E') || Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('O') { + f = **(**uintptr)(__ccgo_up(bp + 104)) + if Int32FromUint8(**(**uint8)(__ccgo_up(f))) == int32('E') || Int32FromUint8(**(**uint8)(__ccgo_up(f))) == int32('O') { f = f + 1 } - t = X__strftime_fmt_1(tls, bp+4, bp, Int32FromUint8(*(*uint8)(unsafe.Pointer(f))), tm, loc, pad) + t = X__strftime_fmt_1(tls, bp+4, bp, Int32FromUint8(**(**uint8)(__ccgo_up(f))), tm, loc, pad) if !(t != 0) { break } @@ -150256,26 +150256,26 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl /* Trim off any sign and leading zeros, then * count remaining digits to determine behavior * for the + flag. */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(t))) == int32('+') || Int32FromUint8(*(*uint8)(unsafe.Pointer(t))) == int32('-') { + if Int32FromUint8(**(**uint8)(__ccgo_up(t))) == int32('+') || Int32FromUint8(**(**uint8)(__ccgo_up(t))) == int32('-') { t = t + 1 - *(*Tsize_t)(unsafe.Pointer(bp)) = *(*Tsize_t)(unsafe.Pointer(bp)) - 1 + **(**Tsize_t)(__ccgo_up(bp)) = **(**Tsize_t)(__ccgo_up(bp)) - 1 } for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(t))) == int32('0') && Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(t + 1)))-int32('0')) < uint32(10)) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(t))) == int32('0') && Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(t + 1)))-int32('0')) < uint32(10)) { break } goto _5 _5: ; t = t + 1 - *(*Tsize_t)(unsafe.Pointer(bp)) = *(*Tsize_t)(unsafe.Pointer(bp)) - 1 + **(**Tsize_t)(__ccgo_up(bp)) = **(**Tsize_t)(__ccgo_up(bp)) - 1 } - if width < *(*Tsize_t)(unsafe.Pointer(bp)) { - width = *(*Tsize_t)(unsafe.Pointer(bp)) + if width < uint32(**(**Tsize_t)(__ccgo_up(bp))) { + width = uint32(**(**Tsize_t)(__ccgo_up(bp))) } d = uint32(0) for { - if !(Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(t + uintptr(d))))-int32('0')) < uint32(10)) { + if !(Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(t + uintptr(d))))-int32('0')) < uint32(10)) { break } goto _6 @@ -150286,41 +150286,41 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl if (*Ttm)(unsafe.Pointer(tm)).Ftm_year < -int32(1900) { v2 = l l = l + 1 - *(*uint8)(unsafe.Pointer(s + uintptr(v2))) = uint8('-') + **(**uint8)(__ccgo_up(s + uintptr(v2))) = uint8('-') width = width - 1 } else { if v9 = plus != 0; v9 { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 104))))) == int32('C') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 104))))) == int32('C') { v4 = int32(3) } else { v4 = int32(5) } } - if v9 && d+(width-*(*Tsize_t)(unsafe.Pointer(bp))) >= Uint32FromInt32(v4) { + if v9 && d+(width-uint32(**(**Tsize_t)(__ccgo_up(bp)))) >= Uint32FromInt32(v4) { v2 = l l = l + 1 - *(*uint8)(unsafe.Pointer(s + uintptr(v2))) = uint8('+') + **(**uint8)(__ccgo_up(s + uintptr(v2))) = uint8('+') width = width - 1 } } for { - if !(width > *(*Tsize_t)(unsafe.Pointer(bp)) && l < n) { + if !(width > uint32(**(**Tsize_t)(__ccgo_up(bp))) && l < n) { break } v2 = l l = l + 1 - *(*uint8)(unsafe.Pointer(s + uintptr(v2))) = uint8('0') + **(**uint8)(__ccgo_up(s + uintptr(v2))) = uint8('0') goto _11 _11: ; width = width - 1 } } - if *(*Tsize_t)(unsafe.Pointer(bp)) > n-l { - *(*Tsize_t)(unsafe.Pointer(bp)) = n - l + if **(**Tsize_t)(__ccgo_up(bp)) > n-l { + **(**Tsize_t)(__ccgo_up(bp)) = n - l } - _memcpy(tls, s+uintptr(l), t, *(*Tsize_t)(unsafe.Pointer(bp))) - l = l + *(*Tsize_t)(unsafe.Pointer(bp)) + _memcpy(tls, s+uintptr(l), t, **(**Tsize_t)(__ccgo_up(bp))) + l = l + **(**Tsize_t)(__ccgo_up(bp)) goto _1 _1: ; @@ -150330,7 +150330,7 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl if l == n { l = n - uint32(1) } - *(*uint8)(unsafe.Pointer(s + uintptr(l))) = uint8(0) + **(**uint8)(__ccgo_up(s + uintptr(l))) = uint8(0) } return uint32(0) } @@ -150368,18 +150368,18 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { var _ /* relyear at bp+8 */ int32 _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = adj, dest, ex, i, len1, min, neg, range1, w, want_century, v1, v2, v5, v6, v8, v9 want_century = 0 - *(*int32)(unsafe.Pointer(bp + 4)) = 0 - *(*int32)(unsafe.Pointer(bp + 8)) = 0 - for *(*uint8)(unsafe.Pointer(f)) != 0 { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) != int32('%') { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) + **(**int32)(__ccgo_up(bp + 4)) = 0 + **(**int32)(__ccgo_up(bp + 8)) = 0 + for **(**uint8)(__ccgo_up(f)) != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(f))) != int32('%') { + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(f))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _3 _3: if v2 != 0 { for { - if v8 = *(*uint8)(unsafe.Pointer(s)) != 0; v8 { - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) + if v8 = **(**uint8)(__ccgo_up(s)) != 0; v8 { + v5 = Int32FromUint8(**(**uint8)(__ccgo_up(s))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _7 _7: @@ -150393,7 +150393,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { s = s + 1 } } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) != Int32FromUint8(**(**uint8)(__ccgo_up(f))) { return uintptr(0) } else { s = s + 1 @@ -150403,19 +150403,19 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { continue } f = f + 1 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('+') { + if Int32FromUint8(**(**uint8)(__ccgo_up(f))) == int32('+') { f = f + 1 } - if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(f)))-uint32('0') < uint32(10)) != 0 { + if BoolInt32(uint32(**(**uint8)(__ccgo_up(f)))-uint32('0') < uint32(10)) != 0 { w = Int32FromUint32(Xstrtoul(tls, f, bp+12, int32(10))) - f = *(*uintptr)(unsafe.Pointer(bp + 12)) + f = **(**uintptr)(__ccgo_up(bp + 12)) } else { w = -int32(1) } adj = 0 v9 = f f = f + 1 - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(v9))) { case int32('A'): goto _10 case int32('a'): @@ -150566,8 +150566,8 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { ; _44: ; - if v8 = *(*uint8)(unsafe.Pointer(s)) != 0; v8 { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) + if v8 = **(**uint8)(__ccgo_up(s)) != 0; v8 { + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(s))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _47 _47: @@ -150589,15 +150589,15 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { ex = Xnl_langinfo(tls, int32(AM_STR)) len1 = _strlen(tls, ex) if !(Xstrncasecmp(tls, s, ex, len1) != 0) { - *(*int32)(unsafe.Pointer(tm + 8)) %= int32(12) + **(**int32)(__ccgo_up(tm + 8)) %= int32(12) s = s + uintptr(len1) goto _41 } ex = Xnl_langinfo(tls, int32(PM_STR)) len1 = _strlen(tls, ex) if !(Xstrncasecmp(tls, s, ex, len1) != 0) { - *(*int32)(unsafe.Pointer(tm + 8)) %= int32(12) - *(*int32)(unsafe.Pointer(tm + 8)) += int32(12) + **(**int32)(__ccgo_up(tm + 8)) %= int32(12) + **(**int32)(__ccgo_up(tm + 8)) += int32(12) s = s + uintptr(len1) goto _41 } @@ -150677,7 +150677,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { ; v9 = s s = s + 1 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) != int32('%') { + if Int32FromUint8(**(**uint8)(__ccgo_up(v9))) != int32('%') { return uintptr(0) } goto _41 @@ -150687,27 +150687,27 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { goto numeric_range numeric_range: ; - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } - *(*int32)(unsafe.Pointer(dest)) = 0 + **(**int32)(__ccgo_up(dest)) = 0 i = int32(1) for { - if !(i <= min+range1 && BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0) { + if !(i <= min+range1 && BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-uint32('0') < uint32(10)) != 0) { break } v9 = s s = s + 1 - *(*int32)(unsafe.Pointer(dest)) = *(*int32)(unsafe.Pointer(dest))*int32(10) + Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) - int32('0') + **(**int32)(__ccgo_up(dest)) = **(**int32)(__ccgo_up(dest))*int32(10) + Int32FromUint8(**(**uint8)(__ccgo_up(v9))) - int32('0') goto _50 _50: ; i = i * int32(10) } - if Uint32FromInt32(*(*int32)(unsafe.Pointer(dest))-min) >= Uint32FromInt32(range1) { + if Uint32FromInt32(**(**int32)(__ccgo_up(dest))-min) >= Uint32FromInt32(range1) { return uintptr(0) } - *(*int32)(unsafe.Pointer(dest)) -= adj + **(**int32)(__ccgo_up(dest)) -= adj switch int32(dest) - int32(tm) { case Int32FromUint32(uint32(UintptrFromInt32(0) + 28)): } @@ -150716,36 +150716,36 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { numeric_digits: ; neg = 0 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('+') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('+') { s = s + 1 } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('-') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('-') { neg = int32(1) s = s + 1 } } - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } v1 = Int32FromInt32(0) i = v1 - *(*int32)(unsafe.Pointer(dest)) = v1 + **(**int32)(__ccgo_up(dest)) = v1 for { - if !(i < w && BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0) { + if !(i < w && BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-uint32('0') < uint32(10)) != 0) { break } v9 = s s = s + 1 - *(*int32)(unsafe.Pointer(dest)) = *(*int32)(unsafe.Pointer(dest))*int32(10) + Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) - int32('0') + **(**int32)(__ccgo_up(dest)) = **(**int32)(__ccgo_up(dest))*int32(10) + Int32FromUint8(**(**uint8)(__ccgo_up(v9))) - int32('0') goto _52 _52: ; i = i + 1 } if neg != 0 { - *(*int32)(unsafe.Pointer(dest)) = -*(*int32)(unsafe.Pointer(dest)) + **(**int32)(__ccgo_up(dest)) = -**(**int32)(__ccgo_up(dest)) } - *(*int32)(unsafe.Pointer(dest)) -= adj + **(**int32)(__ccgo_up(dest)) -= adj goto update goto symbolic_range symbolic_range: @@ -150761,7 +150761,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { goto _55 } s = s + uintptr(len1) - *(*int32)(unsafe.Pointer(dest)) = i % range1 + **(**int32)(__ccgo_up(dest)) = i % range1 break goto _55 _55: @@ -150779,12 +150779,12 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { _41: } if want_century != 0 { - (*Ttm)(unsafe.Pointer(tm)).Ftm_year = *(*int32)(unsafe.Pointer(bp + 8)) + (*Ttm)(unsafe.Pointer(tm)).Ftm_year = **(**int32)(__ccgo_up(bp + 8)) if want_century&int32(2) != 0 { - *(*int32)(unsafe.Pointer(tm + 20)) += *(*int32)(unsafe.Pointer(bp + 4))*int32(100) - int32(1900) + **(**int32)(__ccgo_up(tm + 20)) += **(**int32)(__ccgo_up(bp + 4))*int32(100) - int32(1900) } else { if (*Ttm)(unsafe.Pointer(tm)).Ftm_year <= int32(68) { - *(*int32)(unsafe.Pointer(tm + 20)) += int32(100) + **(**int32)(__ccgo_up(tm + 20)) += int32(100) } } } @@ -150801,9 +150801,9 @@ func Xtime(tls *TLS, t uintptr) (r Ttime_t) { var _ /* ts at bp+0 */ Ttimespec X__clock_gettime(tls, CLOCK_REALTIME, bp) if t != 0 { - *(*Ttime_t)(unsafe.Pointer(t)) = (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec + **(**Ttime_t)(__ccgo_up(t)) = (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec } - return (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec + return (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec } func Xtimegm(tls *TLS, tm uintptr) (r Ttime_t) { @@ -150818,10 +150818,10 @@ func Xtimegm(tls *TLS, tm uintptr) (r Ttime_t) { _ = t t = X__tm_to_secs(tls, tm) if X__secs_to_tm(tls, t, bp) < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return int64(-int32(1)) } - *(*Ttm1)(unsafe.Pointer(tm)) = *(*Ttm1)(unsafe.Pointer(bp)) + **(**Ttm1)(__ccgo_up(tm)) = **(**Ttm1)(__ccgo_up(bp)) (*Ttm1)(unsafe.Pointer(tm)).Ftm_isdst = 0 (*Ttm1)(unsafe.Pointer(tm)).Ftm_gmtoff = 0 (*Ttm1)(unsafe.Pointer(tm)).Ftm_zone = uintptr(unsafe.Pointer(&X__utc)) @@ -150884,10 +150884,10 @@ func Xtimer_gettime(tls *TLS, t Ttimer_t, val uintptr) (r1 int32) { } r = int32(X__syscall2(tls, int32(SYS_timer_gettime32), int32(t), int32(bp))) if !(r != 0) { - (*Titimerspec)(unsafe.Pointer(val)).Fit_interval.Ftv_sec = int64((*(*[4]int32)(unsafe.Pointer(bp)))[0]) - (*Titimerspec)(unsafe.Pointer(val)).Fit_interval.Ftv_nsec = (*(*[4]int32)(unsafe.Pointer(bp)))[int32(1)] - (*Titimerspec)(unsafe.Pointer(val)).Fit_value.Ftv_sec = int64((*(*[4]int32)(unsafe.Pointer(bp)))[int32(2)]) - (*Titimerspec)(unsafe.Pointer(val)).Fit_value.Ftv_nsec = (*(*[4]int32)(unsafe.Pointer(bp)))[int32(3)] + (*Titimerspec)(unsafe.Pointer(val)).Fit_interval.Ftv_sec = int64((**(**[4]int32)(__ccgo_up(bp)))[0]) + (*Titimerspec)(unsafe.Pointer(val)).Fit_interval.Ftv_nsec = (**(**[4]int32)(__ccgo_up(bp)))[int32(1)] + (*Titimerspec)(unsafe.Pointer(val)).Fit_value.Ftv_sec = int64((**(**[4]int32)(__ccgo_up(bp)))[int32(2)]) + (*Titimerspec)(unsafe.Pointer(val)).Fit_value.Ftv_nsec = (**(**[4]int32)(__ccgo_up(bp)))[int32(3)] } return X__syscall_ret(tls, Uint32FromInt32(r)) return X__syscall_ret(tls, Uint32FromInt32(X__syscall2(tls, int32(SYS_timer_gettime32), int32(t), int32(val)))) @@ -150937,10 +150937,10 @@ func Xtimer_settime(tls *TLS, t Ttimer_t, flags int32, val uintptr, old uintptr) } r = int32(X__syscall4(tls, int32(SYS_timer_settime32), int32(t), flags, int32(bp+32), int32(bp+48))) if !(r != 0) && old != 0 { - (*Titimerspec)(unsafe.Pointer(old)).Fit_interval.Ftv_sec = int64((*(*[4]int32)(unsafe.Pointer(bp + 48)))[0]) - (*Titimerspec)(unsafe.Pointer(old)).Fit_interval.Ftv_nsec = (*(*[4]int32)(unsafe.Pointer(bp + 48)))[int32(1)] - (*Titimerspec)(unsafe.Pointer(old)).Fit_value.Ftv_sec = int64((*(*[4]int32)(unsafe.Pointer(bp + 48)))[int32(2)]) - (*Titimerspec)(unsafe.Pointer(old)).Fit_value.Ftv_nsec = (*(*[4]int32)(unsafe.Pointer(bp + 48)))[int32(3)] + (*Titimerspec)(unsafe.Pointer(old)).Fit_interval.Ftv_sec = int64((**(**[4]int32)(__ccgo_up(bp + 48)))[0]) + (*Titimerspec)(unsafe.Pointer(old)).Fit_interval.Ftv_nsec = (**(**[4]int32)(__ccgo_up(bp + 48)))[int32(1)] + (*Titimerspec)(unsafe.Pointer(old)).Fit_value.Ftv_sec = int64((**(**[4]int32)(__ccgo_up(bp + 48)))[int32(2)]) + (*Titimerspec)(unsafe.Pointer(old)).Fit_value.Ftv_nsec = (**(**[4]int32)(__ccgo_up(bp + 48)))[int32(3)] } return X__syscall_ret(tls, Uint32FromInt32(r)) return X__syscall_ret(tls, Uint32FromInt32(X__syscall4(tls, int32(SYS_timer_settime32), int32(t), flags, int32(val), int32(old)))) @@ -151036,92 +151036,92 @@ func X__wcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl if !(l < n) { break } - if !(*(*Twchar_t)(unsafe.Pointer(f)) != 0) { - *(*Twchar_t)(unsafe.Pointer(s + uintptr(l)*4)) = uint32(0) + if !(**(**Twchar_t)(__ccgo_up(f)) != 0) { + **(**Twchar_t)(__ccgo_up(s + uintptr(l)*4)) = uint32(0) return l } - if *(*Twchar_t)(unsafe.Pointer(f)) != uint32('%') { + if **(**Twchar_t)(__ccgo_up(f)) != uint32('%') { v2 = l l = l + 1 - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = *(*Twchar_t)(unsafe.Pointer(f)) + **(**Twchar_t)(__ccgo_up(s + uintptr(v2)*4)) = **(**Twchar_t)(__ccgo_up(f)) goto _1 } f += 4 pad = 0 - if *(*Twchar_t)(unsafe.Pointer(f)) == uint32('-') || *(*Twchar_t)(unsafe.Pointer(f)) == uint32('_') || *(*Twchar_t)(unsafe.Pointer(f)) == uint32('0') { + if **(**Twchar_t)(__ccgo_up(f)) == uint32('-') || **(**Twchar_t)(__ccgo_up(f)) == uint32('_') || **(**Twchar_t)(__ccgo_up(f)) == uint32('0') { v3 = f f += 4 - pad = Int32FromUint32(*(*Twchar_t)(unsafe.Pointer(v3))) + pad = Int32FromUint32(**(**Twchar_t)(__ccgo_up(v3))) } - v4 = BoolInt32(*(*Twchar_t)(unsafe.Pointer(f)) == Uint32FromUint8('+')) + v4 = BoolInt32(**(**Twchar_t)(__ccgo_up(f)) == Uint32FromUint8('+')) plus = v4 if v4 != 0 { f += 4 } width = Xwcstoul(tls, f, bp+504, int32(10)) - if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 504)))) == uint32('C') || *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 504)))) == uint32('F') || *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 504)))) == uint32('G') || *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 504)))) == uint32('Y') { - if !(width != 0) && *(*uintptr)(unsafe.Pointer(bp + 504)) != f { + if **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 504)))) == uint32('C') || **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 504)))) == uint32('F') || **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 504)))) == uint32('G') || **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 504)))) == uint32('Y') { + if !(width != 0) && **(**uintptr)(__ccgo_up(bp + 504)) != f { width = uint32(1) } } else { width = uint32(0) } - f = *(*uintptr)(unsafe.Pointer(bp + 504)) - if *(*Twchar_t)(unsafe.Pointer(f)) == uint32('E') || *(*Twchar_t)(unsafe.Pointer(f)) == uint32('O') { + f = **(**uintptr)(__ccgo_up(bp + 504)) + if **(**Twchar_t)(__ccgo_up(f)) == uint32('E') || **(**Twchar_t)(__ccgo_up(f)) == uint32('O') { f += 4 } - t_mb = X__strftime_fmt_1(tls, bp+4, bp, Int32FromUint32(*(*Twchar_t)(unsafe.Pointer(f))), tm, loc, pad) + t_mb = X__strftime_fmt_1(tls, bp+4, bp, Int32FromUint32(**(**Twchar_t)(__ccgo_up(f))), tm, loc, pad) if !(t_mb != 0) { break } - *(*Tsize_t)(unsafe.Pointer(bp)) = Xmbstowcs(tls, bp+104, t_mb, Uint32FromInt64(400)/Uint32FromInt64(4)) - if *(*Tsize_t)(unsafe.Pointer(bp)) == Uint32FromInt32(-Int32FromInt32(1)) { + **(**Tsize_t)(__ccgo_up(bp)) = Xmbstowcs(tls, bp+104, t_mb, Uint32FromInt64(400)/Uint32FromInt64(4)) + if **(**Tsize_t)(__ccgo_up(bp)) == Uint32FromInt32(-Int32FromInt32(1)) { return uint32(0) } t = bp + 104 if width != 0 { for { - if !(*(*Twchar_t)(unsafe.Pointer(t)) == uint32('+') || *(*Twchar_t)(unsafe.Pointer(t)) == uint32('-') || *(*Twchar_t)(unsafe.Pointer(t)) == uint32('0') && *(*Twchar_t)(unsafe.Pointer(t + 1*4)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(t)) == uint32('+') || **(**Twchar_t)(__ccgo_up(t)) == uint32('-') || **(**Twchar_t)(__ccgo_up(t)) == uint32('0') && **(**Twchar_t)(__ccgo_up(t + 1*4)) != 0) { break } goto _5 _5: ; t += 4 - *(*Tsize_t)(unsafe.Pointer(bp)) = *(*Tsize_t)(unsafe.Pointer(bp)) - 1 + **(**Tsize_t)(__ccgo_up(bp)) = **(**Tsize_t)(__ccgo_up(bp)) - 1 } width = width - 1 if plus != 0 && (*Ttm)(unsafe.Pointer(tm)).Ftm_year >= Int32FromInt32(10000)-Int32FromInt32(1900) { v2 = l l = l + 1 - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = uint32('+') + **(**Twchar_t)(__ccgo_up(s + uintptr(v2)*4)) = uint32('+') } else { if (*Ttm)(unsafe.Pointer(tm)).Ftm_year < -int32(1900) { v2 = l l = l + 1 - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = uint32('-') + **(**Twchar_t)(__ccgo_up(s + uintptr(v2)*4)) = uint32('-') } else { width = width + 1 } } for { - if !(width > *(*Tsize_t)(unsafe.Pointer(bp)) && l < n) { + if !(width > uint32(**(**Tsize_t)(__ccgo_up(bp))) && l < n) { break } v2 = l l = l + 1 - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = uint32('0') + **(**Twchar_t)(__ccgo_up(s + uintptr(v2)*4)) = uint32('0') goto _8 _8: ; width = width - 1 } } - if *(*Tsize_t)(unsafe.Pointer(bp)) >= n-l { - *(*Tsize_t)(unsafe.Pointer(bp)) = n - l + if **(**Tsize_t)(__ccgo_up(bp)) >= n-l { + **(**Tsize_t)(__ccgo_up(bp)) = n - l } - Xwmemcpy(tls, s+uintptr(l)*4, t, *(*Tsize_t)(unsafe.Pointer(bp))) - l = l + *(*Tsize_t)(unsafe.Pointer(bp)) + Xwmemcpy(tls, s+uintptr(l)*4, t, **(**Tsize_t)(__ccgo_up(bp))) + l = l + **(**Tsize_t)(__ccgo_up(bp)) goto _1 _1: ; @@ -151131,7 +151131,7 @@ func X__wcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl if l == n { l = n - uint32(1) } - *(*Twchar_t)(unsafe.Pointer(s + uintptr(l)*4)) = uint32(0) + **(**Twchar_t)(__ccgo_up(s + uintptr(l)*4)) = uint32(0) } return uint32(0) } @@ -151184,14 +151184,14 @@ func Xalarm(tls *TLS, seconds uint32) (r uint32) { defer tls.Free(64) var _ /* it at bp+0 */ Titimerval var _ /* old at bp+32 */ Titimerval - *(*Titimerval)(unsafe.Pointer(bp)) = Titimerval{ + **(**Titimerval)(__ccgo_up(bp)) = Titimerval{ Fit_value: Ttimeval{ Ftv_sec: Int64FromUint32(seconds), }, } - *(*Titimerval)(unsafe.Pointer(bp + 32)) = Titimerval{} + **(**Titimerval)(__ccgo_up(bp + 32)) = Titimerval{} Xsetitimer(tls, ITIMER_REAL, bp, bp+32) - return Uint32FromInt64((*(*Titimerval)(unsafe.Pointer(bp + 32))).Fit_value.Ftv_sec + BoolInt64(!!((*(*Titimerval)(unsafe.Pointer(bp + 32))).Fit_value.Ftv_usec != 0))) + return Uint32FromInt64((**(**Titimerval)(__ccgo_up(bp + 32))).Fit_value.Ftv_sec + BoolInt64(!!((**(**Titimerval)(__ccgo_up(bp + 32))).Fit_value.Ftv_usec != 0))) } func Xchdir(tls *TLS, path uintptr) (r int32) { @@ -151332,7 +151332,7 @@ func _checker(tls *TLS, p uintptr) (r int32) { if X__syscall2(tls, int32(SYS_setregid32), X__syscall0(tls, int32(SYS_getegid32)), int32(-Int32FromInt32(1))) != 0 || X__syscall2(tls, int32(SYS_setreuid32), X__syscall0(tls, int32(SYS_geteuid32)), int32(-Int32FromInt32(1))) != 0 { X__syscall1(tls, int32(SYS_exit), int32(Int32FromInt32(1))) } - *(*int32)(unsafe.Pointer(bp)) = int32(X__syscall4(tls, int32(SYS_faccessat), (*Tctx1)(unsafe.Pointer(c)).Ffd, int32((*Tctx1)(unsafe.Pointer(c)).Ffilename), (*Tctx1)(unsafe.Pointer(c)).Famode, int32(Int32FromInt32(0)))) + **(**int32)(__ccgo_up(bp)) = int32(X__syscall4(tls, int32(SYS_faccessat), (*Tctx1)(unsafe.Pointer(c)).Ffd, int32((*Tctx1)(unsafe.Pointer(c)).Ffilename), (*Tctx1)(unsafe.Pointer(c)).Famode, int32(Int32FromInt32(0)))) X__syscall3(tls, int32(SYS_write), (*Tctx1)(unsafe.Pointer(c)).Fp, int32(bp), Int32FromUint32(Uint32FromInt64(4))) return 0 } @@ -151446,7 +151446,7 @@ func Xgetcwd(tls *TLS, buf uintptr, size Tsize_t) (r uintptr) { size = v1 } else { if !(size != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } } @@ -151454,8 +151454,8 @@ func Xgetcwd(tls *TLS, buf uintptr, size Tsize_t) (r uintptr) { if ret < 0 { return uintptr(0) } - if ret == 0 || Int32FromUint8(*(*uint8)(unsafe.Pointer(buf))) != int32('/') { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOENT) + if ret == 0 || Int32FromUint8(**(**uint8)(__ccgo_up(buf))) != int32('/') { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOENT) return uintptr(0) } if buf == tmp { @@ -151519,8 +151519,8 @@ func Xgethostname(tls *TLS, name uintptr, len1 Tsize_t) (r int32) { i = uint32(0) for { if v3 = i < len1; v3 { - v2 = *(*uint8)(unsafe.Pointer(bp + 65 + uintptr(i))) - *(*uint8)(unsafe.Pointer(name + uintptr(i))) = v2 + v2 = **(**uint8)(__ccgo_up(bp + 65 + uintptr(i))) + **(**uint8)(__ccgo_up(name + uintptr(i))) = v2 } if !(v3 && v2 != 0) { break @@ -151531,7 +151531,7 @@ func Xgethostname(tls *TLS, name uintptr, len1 Tsize_t) (r int32) { i = i + 1 } if i != 0 && i == len1 { - *(*uint8)(unsafe.Pointer(name + uintptr(i-uint32(1)))) = uint8(0) + **(**uint8)(__ccgo_up(name + uintptr(i-uint32(1)))) = uint8(0) } return 0 } @@ -151624,8 +151624,8 @@ func Xisatty(tls *TLS, fd int32) (r1 int32) { if r == uint32(0) { return int32(1) } - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(EBADF) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOTTY) + if **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(EBADF) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOTTY) } return 0 } @@ -151667,7 +151667,7 @@ func X__lseek(tls *TLS, fd int32, offset Toff_t, whence int32) (r Toff_t) { if X__syscall_ret(tls, Uint32FromInt32(X__syscall5(tls, int32(SYS__llseek), fd, int32(offset>>Int32FromInt32(32)), int32(offset), int32(bp), whence))) != 0 { v1 = int64(-int32(1)) } else { - v1 = *(*Toff_t)(unsafe.Pointer(bp)) + v1 = **(**Toff_t)(__ccgo_up(bp)) } return v1 } @@ -151700,8 +151700,8 @@ func Xnice(tls *TLS, inc int32) (r int32) { prio = -int32(NZERO) } if Xsetpriority(tls, PRIO_PROCESS, uint32(0), prio) != 0 { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EACCES) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EPERM) + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EACCES) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EPERM) } return -int32(1) } else { @@ -151748,12 +151748,12 @@ func Xpipe2(tls *TLS, fd uintptr, flag int32) (r int32) { return ret } if flag&int32(O_CLOEXEC) != 0 { - X__syscall3(tls, int32(SYS_fcntl64), *(*int32)(unsafe.Pointer(fd)), int32(Int32FromInt32(F_SETFD)), int32(Int32FromInt32(FD_CLOEXEC))) - X__syscall3(tls, int32(SYS_fcntl64), *(*int32)(unsafe.Pointer(fd + 1*4)), int32(Int32FromInt32(F_SETFD)), int32(Int32FromInt32(FD_CLOEXEC))) + X__syscall3(tls, int32(SYS_fcntl64), int32(**(**int32)(__ccgo_up(fd))), int32(Int32FromInt32(F_SETFD)), int32(Int32FromInt32(FD_CLOEXEC))) + X__syscall3(tls, int32(SYS_fcntl64), int32(**(**int32)(__ccgo_up(fd + 1*4))), int32(Int32FromInt32(F_SETFD)), int32(Int32FromInt32(FD_CLOEXEC))) } if flag&int32(O_NONBLOCK) != 0 { - X__syscall3(tls, int32(SYS_fcntl64), *(*int32)(unsafe.Pointer(fd)), int32(Int32FromInt32(F_SETFL)), int32(Int32FromInt32(O_NONBLOCK))) - X__syscall3(tls, int32(SYS_fcntl64), *(*int32)(unsafe.Pointer(fd + 1*4)), int32(Int32FromInt32(F_SETFL)), int32(Int32FromInt32(O_NONBLOCK))) + X__syscall3(tls, int32(SYS_fcntl64), int32(**(**int32)(__ccgo_up(fd))), int32(Int32FromInt32(F_SETFL)), int32(Int32FromInt32(O_NONBLOCK))) + X__syscall3(tls, int32(SYS_fcntl64), int32(**(**int32)(__ccgo_up(fd + 1*4))), int32(Int32FromInt32(F_SETFL)), int32(Int32FromInt32(O_NONBLOCK))) } return 0 } @@ -151952,7 +151952,7 @@ func X__setxid(tls *TLS, nr int32, id int32, eid int32, sid int32) (r int32) { _ = v1 /* ret is initially nonzero so that failure of the first thread does not * trigger the safety kill above. */ - *(*Tctx2)(unsafe.Pointer(bp)) = Tctx2{ + **(**Tctx2)(__ccgo_up(bp)) = Tctx2{ Fid: id, Feid: eid, Fsid: sid, @@ -151960,10 +151960,10 @@ func X__setxid(tls *TLS, nr int32, id int32, eid int32, sid int32) (r int32) { Fret: int32(1), } ___synccall(tls, __ccgo_fp(_do_setxid), bp) - if (*(*Tctx2)(unsafe.Pointer(bp))).Fret > 0 { + if (**(**Tctx2)(__ccgo_up(bp))).Fret > 0 { v1 = -int32(EAGAIN) } else { - v1 = (*(*Tctx2)(unsafe.Pointer(bp))).Fret + v1 = (**(**Tctx2)(__ccgo_up(bp))).Fret } return X__syscall_ret(tls, Uint32FromInt32(v1)) } @@ -151976,11 +151976,11 @@ func Xsleep(tls *TLS, seconds uint32) (r uint32) { bp := tls.Alloc(16) defer tls.Free(16) var _ /* tv at bp+0 */ Ttimespec - *(*Ttimespec)(unsafe.Pointer(bp)) = Ttimespec{ + **(**Ttimespec)(__ccgo_up(bp)) = Ttimespec{ Ftv_sec: Int64FromUint32(seconds), } if Xnanosleep(tls, bp, bp) != 0 { - return Uint32FromInt64((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec) + return Uint32FromInt64((**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec) } return uint32(0) } @@ -152019,7 +152019,7 @@ func Xtcgetpgrp(tls *TLS, fd int32) (r Tpid_t) { if Xioctl(tls, fd, int32(TIOCGPGRP), VaList(bp+16, bp)) < 0 { return -int32(1) } - return *(*int32)(unsafe.Pointer(bp)) + return **(**int32)(__ccgo_up(bp)) } func Xtcsetpgrp(tls *TLS, fd int32, pgrp Tpid_t) (r int32) { @@ -152030,7 +152030,7 @@ func Xtcsetpgrp(tls *TLS, fd int32, pgrp Tpid_t) (r int32) { bp := tls.Alloc(32) defer tls.Free(32) var _ /* pgrp_int at bp+0 */ int32 - *(*int32)(unsafe.Pointer(bp)) = pgrp + **(**int32)(__ccgo_up(bp)) = pgrp return Xioctl(tls, fd, int32(TIOCSPGRP), VaList(bp+16, bp)) } @@ -152061,7 +152061,7 @@ func Xttyname(tls *TLS, fd int32) (r uintptr) { v1 = Xttyname_r(tls, fd, uintptr(unsafe.Pointer(&_buf10)), uint32(32)) result = v1 if v1 != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = result + **(**int32)(__ccgo_up(X__errno_location(tls))) = result return UintptrFromInt32(0) } return uintptr(unsafe.Pointer(&_buf10)) @@ -152082,22 +152082,22 @@ func Xttyname_r(tls *TLS, fd int32, name uintptr, size Tsize_t) (r int32) { var _ /* st2 at bp+152 */ Tstat _ = l if !(Xisatty(tls, fd) != 0) { - return *(*int32)(unsafe.Pointer(X__errno_location(tls))) + return **(**int32)(__ccgo_up(X__errno_location(tls))) } X__procfdname(tls, bp+304, Uint32FromInt32(fd)) l = Xreadlink(tls, bp+304, name, size) if l < 0 { - return *(*int32)(unsafe.Pointer(X__errno_location(tls))) + return **(**int32)(__ccgo_up(X__errno_location(tls))) } else { if Uint32FromInt32(l) == size { return int32(ERANGE) } } - *(*uint8)(unsafe.Pointer(name + uintptr(l))) = uint8(0) + **(**uint8)(__ccgo_up(name + uintptr(l))) = uint8(0) if Xstat(tls, name, bp) != 0 || Xfstat(tls, fd, bp+152) != 0 { - return *(*int32)(unsafe.Pointer(X__errno_location(tls))) + return **(**int32)(__ccgo_up(X__errno_location(tls))) } - if (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev != (*(*Tstat)(unsafe.Pointer(bp + 152))).Fst_dev || (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino != (*(*Tstat)(unsafe.Pointer(bp + 152))).Fst_ino { + if (**(**Tstat)(__ccgo_up(bp))).Fst_dev != (**(**Tstat)(__ccgo_up(bp + 152))).Fst_dev || (**(**Tstat)(__ccgo_up(bp))).Fst_ino != (**(**Tstat)(__ccgo_up(bp + 152))).Fst_ino { return int32(ENODEV) } return 0 @@ -152112,7 +152112,7 @@ func Xualarm(tls *TLS, value uint32, interval uint32) (r uint32) { defer tls.Free(64) var _ /* it at bp+0 */ Titimerval var _ /* it_old at bp+32 */ Titimerval - *(*Titimerval)(unsafe.Pointer(bp)) = Titimerval{ + **(**Titimerval)(__ccgo_up(bp)) = Titimerval{ Fit_interval: Ttimeval{ Ftv_usec: Int64FromUint32(interval), }, @@ -152121,7 +152121,7 @@ func Xualarm(tls *TLS, value uint32, interval uint32) (r uint32) { }, } Xsetitimer(tls, ITIMER_REAL, bp, bp+32) - return Uint32FromInt64((*(*Titimerval)(unsafe.Pointer(bp + 32))).Fit_value.Ftv_sec*int64(1000000) + (*(*Titimerval)(unsafe.Pointer(bp + 32))).Fit_value.Ftv_usec) + return Uint32FromInt64((**(**Titimerval)(__ccgo_up(bp + 32))).Fit_value.Ftv_sec*int64(1000000) + (**(**Titimerval)(__ccgo_up(bp + 32))).Fit_value.Ftv_usec) } func Xunlink(tls *TLS, path uintptr) (r int32) { @@ -152148,7 +152148,7 @@ func Xusleep(tls *TLS, useconds uint32) (r int32) { bp := tls.Alloc(16) defer tls.Free(16) var _ /* tv at bp+0 */ Ttimespec - *(*Ttimespec)(unsafe.Pointer(bp)) = Ttimespec{ + **(**Ttimespec)(__ccgo_up(bp)) = Ttimespec{ Ftv_sec: Int64FromUint32(useconds / uint32(1000000)), Ftv_nsec: Int32FromUint32(useconds % uint32(1000000) * uint32(1000)), } @@ -152276,8 +152276,8 @@ func X__adjtime32(tls *TLS, in32 uintptr, out32 uintptr) (r1 int32) { /* We can't range-check the result because success was already * committed by the above call. */ if out32 != 0 { - (*Ttimeval32)(unsafe.Pointer(out32)).Ftv_sec = int32((*(*Ttimeval)(unsafe.Pointer(bp + 16))).Ftv_sec) - (*Ttimeval32)(unsafe.Pointer(out32)).Ftv_usec = int32((*(*Ttimeval)(unsafe.Pointer(bp + 16))).Ftv_usec) + (*Ttimeval32)(unsafe.Pointer(out32)).Ftv_sec = int32((**(**Ttimeval)(__ccgo_up(bp + 16))).Ftv_sec) + (*Ttimeval32)(unsafe.Pointer(out32)).Ftv_usec = int32((**(**Ttimeval)(__ccgo_up(bp + 16))).Ftv_usec) } return r } @@ -152324,7 +152324,7 @@ func X__clock_adjtime32(tls *TLS, clock_id Tclockid_t, tx32 uintptr) (r1 int32) var r int32 var _ /* utx at bp+0 */ Ttimex _ = r - *(*Ttimex)(unsafe.Pointer(bp)) = Ttimex{ + **(**Ttimex)(__ccgo_up(bp)) = Ttimex{ Fmodes: (*Ttimex32)(unsafe.Pointer(tx32)).Fmodes, Foffset: (*Ttimex32)(unsafe.Pointer(tx32)).Foffset, Ffreq: (*Ttimex32)(unsafe.Pointer(tx32)).Ffreq, @@ -152353,27 +152353,27 @@ func X__clock_adjtime32(tls *TLS, clock_id Tclockid_t, tx32 uintptr) (r1 int32) if r < 0 { return r } - (*Ttimex32)(unsafe.Pointer(tx32)).Fmodes = (*(*Ttimex)(unsafe.Pointer(bp))).Fmodes - (*Ttimex32)(unsafe.Pointer(tx32)).Foffset = (*(*Ttimex)(unsafe.Pointer(bp))).Foffset - (*Ttimex32)(unsafe.Pointer(tx32)).Ffreq = (*(*Ttimex)(unsafe.Pointer(bp))).Ffreq - (*Ttimex32)(unsafe.Pointer(tx32)).Fmaxerror = (*(*Ttimex)(unsafe.Pointer(bp))).Fmaxerror - (*Ttimex32)(unsafe.Pointer(tx32)).Festerror = (*(*Ttimex)(unsafe.Pointer(bp))).Festerror - (*Ttimex32)(unsafe.Pointer(tx32)).Fstatus = (*(*Ttimex)(unsafe.Pointer(bp))).Fstatus - (*Ttimex32)(unsafe.Pointer(tx32)).Fconstant = (*(*Ttimex)(unsafe.Pointer(bp))).Fconstant - (*Ttimex32)(unsafe.Pointer(tx32)).Fprecision = (*(*Ttimex)(unsafe.Pointer(bp))).Fprecision - (*Ttimex32)(unsafe.Pointer(tx32)).Ftolerance = (*(*Ttimex)(unsafe.Pointer(bp))).Ftolerance - (*Ttimex32)(unsafe.Pointer(tx32)).Ftime.Ftv_sec = int32((*(*Ttimex)(unsafe.Pointer(bp))).Ftime.Ftv_sec) - (*Ttimex32)(unsafe.Pointer(tx32)).Ftime.Ftv_usec = int32((*(*Ttimex)(unsafe.Pointer(bp))).Ftime.Ftv_usec) - (*Ttimex32)(unsafe.Pointer(tx32)).Ftick = (*(*Ttimex)(unsafe.Pointer(bp))).Ftick - (*Ttimex32)(unsafe.Pointer(tx32)).Fppsfreq = (*(*Ttimex)(unsafe.Pointer(bp))).Fppsfreq - (*Ttimex32)(unsafe.Pointer(tx32)).Fjitter = (*(*Ttimex)(unsafe.Pointer(bp))).Fjitter - (*Ttimex32)(unsafe.Pointer(tx32)).Fshift = (*(*Ttimex)(unsafe.Pointer(bp))).Fshift - (*Ttimex32)(unsafe.Pointer(tx32)).Fstabil = (*(*Ttimex)(unsafe.Pointer(bp))).Fstabil - (*Ttimex32)(unsafe.Pointer(tx32)).Fjitcnt = (*(*Ttimex)(unsafe.Pointer(bp))).Fjitcnt - (*Ttimex32)(unsafe.Pointer(tx32)).Fcalcnt = (*(*Ttimex)(unsafe.Pointer(bp))).Fcalcnt - (*Ttimex32)(unsafe.Pointer(tx32)).Ferrcnt = (*(*Ttimex)(unsafe.Pointer(bp))).Ferrcnt - (*Ttimex32)(unsafe.Pointer(tx32)).Fstbcnt = (*(*Ttimex)(unsafe.Pointer(bp))).Fstbcnt - (*Ttimex32)(unsafe.Pointer(tx32)).Ftai = (*(*Ttimex)(unsafe.Pointer(bp))).Ftai + (*Ttimex32)(unsafe.Pointer(tx32)).Fmodes = (**(**Ttimex)(__ccgo_up(bp))).Fmodes + (*Ttimex32)(unsafe.Pointer(tx32)).Foffset = (**(**Ttimex)(__ccgo_up(bp))).Foffset + (*Ttimex32)(unsafe.Pointer(tx32)).Ffreq = (**(**Ttimex)(__ccgo_up(bp))).Ffreq + (*Ttimex32)(unsafe.Pointer(tx32)).Fmaxerror = (**(**Ttimex)(__ccgo_up(bp))).Fmaxerror + (*Ttimex32)(unsafe.Pointer(tx32)).Festerror = (**(**Ttimex)(__ccgo_up(bp))).Festerror + (*Ttimex32)(unsafe.Pointer(tx32)).Fstatus = (**(**Ttimex)(__ccgo_up(bp))).Fstatus + (*Ttimex32)(unsafe.Pointer(tx32)).Fconstant = (**(**Ttimex)(__ccgo_up(bp))).Fconstant + (*Ttimex32)(unsafe.Pointer(tx32)).Fprecision = (**(**Ttimex)(__ccgo_up(bp))).Fprecision + (*Ttimex32)(unsafe.Pointer(tx32)).Ftolerance = (**(**Ttimex)(__ccgo_up(bp))).Ftolerance + (*Ttimex32)(unsafe.Pointer(tx32)).Ftime.Ftv_sec = int32((**(**Ttimex)(__ccgo_up(bp))).Ftime.Ftv_sec) + (*Ttimex32)(unsafe.Pointer(tx32)).Ftime.Ftv_usec = int32((**(**Ttimex)(__ccgo_up(bp))).Ftime.Ftv_usec) + (*Ttimex32)(unsafe.Pointer(tx32)).Ftick = (**(**Ttimex)(__ccgo_up(bp))).Ftick + (*Ttimex32)(unsafe.Pointer(tx32)).Fppsfreq = (**(**Ttimex)(__ccgo_up(bp))).Fppsfreq + (*Ttimex32)(unsafe.Pointer(tx32)).Fjitter = (**(**Ttimex)(__ccgo_up(bp))).Fjitter + (*Ttimex32)(unsafe.Pointer(tx32)).Fshift = (**(**Ttimex)(__ccgo_up(bp))).Fshift + (*Ttimex32)(unsafe.Pointer(tx32)).Fstabil = (**(**Ttimex)(__ccgo_up(bp))).Fstabil + (*Ttimex32)(unsafe.Pointer(tx32)).Fjitcnt = (**(**Ttimex)(__ccgo_up(bp))).Fjitcnt + (*Ttimex32)(unsafe.Pointer(tx32)).Fcalcnt = (**(**Ttimex)(__ccgo_up(bp))).Fcalcnt + (*Ttimex32)(unsafe.Pointer(tx32)).Ferrcnt = (**(**Ttimex)(__ccgo_up(bp))).Ferrcnt + (*Ttimex32)(unsafe.Pointer(tx32)).Fstbcnt = (**(**Ttimex)(__ccgo_up(bp))).Fstbcnt + (*Ttimex32)(unsafe.Pointer(tx32)).Ftai = (**(**Ttimex)(__ccgo_up(bp))).Ftai return r } @@ -152389,8 +152389,8 @@ func X__clock_getres_time32(tls *TLS, clk Tclockid_t, ts32 uintptr) (r1 int32) { _ = r r = Xclock_getres(tls, clk, bp) if !(r != 0) && ts32 != 0 { - (*Ttimespec32)(unsafe.Pointer(ts32)).Ftv_sec = int32((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec) - (*Ttimespec32)(unsafe.Pointer(ts32)).Ftv_nsec = (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_nsec + (*Ttimespec32)(unsafe.Pointer(ts32)).Ftv_sec = int32((**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec) + (*Ttimespec32)(unsafe.Pointer(ts32)).Ftv_nsec = (**(**Ttimespec)(__ccgo_up(bp))).Ftv_nsec } return r } @@ -152409,12 +152409,12 @@ func X__clock_gettime32(tls *TLS, clk Tclockid_t, ts32 uintptr) (r1 int32) { if r != 0 { return r } - if (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec < int64(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff)) || (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec > int64(Int32FromInt32(INT32_MAX)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + if (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec < int64(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff)) || (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec > int64(Int32FromInt32(INT32_MAX)) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return -int32(1) } - (*Ttimespec32)(unsafe.Pointer(ts32)).Ftv_sec = int32((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec) - (*Ttimespec32)(unsafe.Pointer(ts32)).Ftv_nsec = (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_nsec + (*Ttimespec32)(unsafe.Pointer(ts32)).Ftv_sec = int32((**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec) + (*Ttimespec32)(unsafe.Pointer(ts32)).Ftv_nsec = (**(**Ttimespec)(__ccgo_up(bp))).Ftv_nsec return 0 } @@ -152434,8 +152434,8 @@ func X__clock_nanosleep_time32(tls *TLS, clk Tclockid_t, flags int32, req32 uint } ret = Xclock_nanosleep(tls, clk, flags, bp, bp+16) if ret == int32(EINTR) && rem32 != 0 && !(flags&Int32FromInt32(TIMER_ABSTIME) != 0) { - (*Ttimespec32)(unsafe.Pointer(rem32)).Ftv_sec = int32((*(*Ttimespec)(unsafe.Pointer(bp + 16))).Ftv_sec) - (*Ttimespec32)(unsafe.Pointer(rem32)).Ftv_nsec = (*(*Ttimespec)(unsafe.Pointer(bp + 16))).Ftv_nsec + (*Ttimespec32)(unsafe.Pointer(rem32)).Ftv_sec = int32((**(**Ttimespec)(__ccgo_up(bp + 16))).Ftv_sec) + (*Ttimespec32)(unsafe.Pointer(rem32)).Ftv_nsec = (**(**Ttimespec)(__ccgo_up(bp + 16))).Ftv_nsec } return ret } @@ -152461,7 +152461,7 @@ func X__ctime32(tls *TLS, t uintptr) (r uintptr) { } bp := tls.Alloc(16) defer tls.Free(16) - *(*Ttime_t)(unsafe.Pointer(bp)) = int64(*(*Ttime32_t)(unsafe.Pointer(t))) + *(*Ttime_t)(unsafe.Pointer(bp)) = int64(**(**Ttime32_t)(__ccgo_up(t))) return Xctime(tls, bp) } @@ -152472,7 +152472,7 @@ func X__ctime32_r(tls *TLS, t uintptr, buf uintptr) (r uintptr) { } bp := tls.Alloc(16) defer tls.Free(16) - *(*Ttime_t)(unsafe.Pointer(bp)) = int64(*(*Ttime32_t)(unsafe.Pointer(t))) + *(*Ttime_t)(unsafe.Pointer(bp)) = int64(**(**Ttime32_t)(__ccgo_up(t))) return Xctime_r(tls, bp, buf) } @@ -152536,14 +152536,14 @@ func X__ftime32(tls *TLS, tp uintptr) (r int32) { if Xftime(tls, bp) < 0 { return -int32(1) } - if (*(*Ttimeb)(unsafe.Pointer(bp))).Ftime < int64(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff)) || (*(*Ttimeb)(unsafe.Pointer(bp))).Ftime > int64(Int32FromInt32(INT32_MAX)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + if (**(**Ttimeb)(__ccgo_up(bp))).Ftime < int64(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff)) || (**(**Ttimeb)(__ccgo_up(bp))).Ftime > int64(Int32FromInt32(INT32_MAX)) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return -int32(1) } - (*Ttimeb32)(unsafe.Pointer(tp)).Ftime = int32((*(*Ttimeb)(unsafe.Pointer(bp))).Ftime) - (*Ttimeb32)(unsafe.Pointer(tp)).Fmillitm = (*(*Ttimeb)(unsafe.Pointer(bp))).Fmillitm - (*Ttimeb32)(unsafe.Pointer(tp)).Ftimezone = (*(*Ttimeb)(unsafe.Pointer(bp))).Ftimezone - (*Ttimeb32)(unsafe.Pointer(tp)).Fdstflag = (*(*Ttimeb)(unsafe.Pointer(bp))).Fdstflag + (*Ttimeb32)(unsafe.Pointer(tp)).Ftime = int32((**(**Ttimeb)(__ccgo_up(bp))).Ftime) + (*Ttimeb32)(unsafe.Pointer(tp)).Fmillitm = (**(**Ttimeb)(__ccgo_up(bp))).Fmillitm + (*Ttimeb32)(unsafe.Pointer(tp)).Ftimezone = (**(**Ttimeb)(__ccgo_up(bp))).Ftimezone + (*Ttimeb32)(unsafe.Pointer(tp)).Fdstflag = (**(**Ttimeb)(__ccgo_up(bp))).Fdstflag return 0 } @@ -152561,12 +152561,12 @@ func X__futimens_time32(tls *TLS, fd int32, times32 uintptr) (r int32) { } else { *(*[2]Ttimespec)(unsafe.Pointer(bp)) = [2]Ttimespec{ 0: { - Ftv_sec: int64((*(*Ttimespec32)(unsafe.Pointer(times32))).Ftv_sec), - Ftv_nsec: (*(*Ttimespec32)(unsafe.Pointer(times32))).Ftv_nsec, + Ftv_sec: int64((**(**Ttimespec32)(__ccgo_up(times32))).Ftv_sec), + Ftv_nsec: (**(**Ttimespec32)(__ccgo_up(times32))).Ftv_nsec, }, 1: { - Ftv_sec: int64((*(*Ttimespec32)(unsafe.Pointer(times32 + 1*8))).Ftv_sec), - Ftv_nsec: (*(*Ttimespec32)(unsafe.Pointer(times32 + 1*8))).Ftv_nsec, + Ftv_sec: int64((**(**Ttimespec32)(__ccgo_up(times32 + 1*8))).Ftv_sec), + Ftv_nsec: (**(**Ttimespec32)(__ccgo_up(times32 + 1*8))).Ftv_nsec, }, } v1 = bp @@ -152588,12 +152588,12 @@ func X__futimes_time32(tls *TLS, fd int32, times32 uintptr) (r int32) { } else { *(*[2]Ttimeval)(unsafe.Pointer(bp)) = [2]Ttimeval{ 0: { - Ftv_sec: int64((*(*Ttimeval32)(unsafe.Pointer(times32))).Ftv_sec), - Ftv_usec: int64((*(*Ttimeval32)(unsafe.Pointer(times32))).Ftv_usec), + Ftv_sec: int64((**(**Ttimeval32)(__ccgo_up(times32))).Ftv_sec), + Ftv_usec: int64((**(**Ttimeval32)(__ccgo_up(times32))).Ftv_usec), }, 1: { - Ftv_sec: int64((*(*Ttimeval32)(unsafe.Pointer(times32 + 1*8))).Ftv_sec), - Ftv_usec: int64((*(*Ttimeval32)(unsafe.Pointer(times32 + 1*8))).Ftv_usec), + Ftv_sec: int64((**(**Ttimeval32)(__ccgo_up(times32 + 1*8))).Ftv_sec), + Ftv_usec: int64((**(**Ttimeval32)(__ccgo_up(times32 + 1*8))).Ftv_usec), }, } v1 = bp @@ -152615,12 +152615,12 @@ func X__futimesat_time32(tls *TLS, dirfd int32, pathname uintptr, times32 uintpt } else { *(*[2]Ttimeval)(unsafe.Pointer(bp)) = [2]Ttimeval{ 0: { - Ftv_sec: int64((*(*Ttimeval32)(unsafe.Pointer(times32))).Ftv_sec), - Ftv_usec: int64((*(*Ttimeval32)(unsafe.Pointer(times32))).Ftv_usec), + Ftv_sec: int64((**(**Ttimeval32)(__ccgo_up(times32))).Ftv_sec), + Ftv_usec: int64((**(**Ttimeval32)(__ccgo_up(times32))).Ftv_usec), }, 1: { - Ftv_sec: int64((*(*Ttimeval32)(unsafe.Pointer(times32 + 1*8))).Ftv_sec), - Ftv_usec: int64((*(*Ttimeval32)(unsafe.Pointer(times32 + 1*8))).Ftv_usec), + Ftv_sec: int64((**(**Ttimeval32)(__ccgo_up(times32 + 1*8))).Ftv_sec), + Ftv_usec: int64((**(**Ttimeval32)(__ccgo_up(times32 + 1*8))).Ftv_usec), }, } v1 = bp @@ -152642,10 +152642,10 @@ func X__getitimer_time32(tls *TLS, which int32, old32 uintptr) (r1 int32) { if r != 0 { return r } - (*Titimerval32)(unsafe.Pointer(old32)).Fit_interval.Ftv_sec = int32((*(*Titimerval)(unsafe.Pointer(bp))).Fit_interval.Ftv_sec) - (*Titimerval32)(unsafe.Pointer(old32)).Fit_interval.Ftv_usec = int32((*(*Titimerval)(unsafe.Pointer(bp))).Fit_interval.Ftv_usec) - (*Titimerval32)(unsafe.Pointer(old32)).Fit_value.Ftv_sec = int32((*(*Titimerval)(unsafe.Pointer(bp))).Fit_value.Ftv_sec) - (*Titimerval32)(unsafe.Pointer(old32)).Fit_value.Ftv_usec = int32((*(*Titimerval)(unsafe.Pointer(bp))).Fit_value.Ftv_usec) + (*Titimerval32)(unsafe.Pointer(old32)).Fit_interval.Ftv_sec = int32((**(**Titimerval)(__ccgo_up(bp))).Fit_interval.Ftv_sec) + (*Titimerval32)(unsafe.Pointer(old32)).Fit_interval.Ftv_usec = int32((**(**Titimerval)(__ccgo_up(bp))).Fit_interval.Ftv_usec) + (*Titimerval32)(unsafe.Pointer(old32)).Fit_value.Ftv_sec = int32((**(**Titimerval)(__ccgo_up(bp))).Fit_value.Ftv_sec) + (*Titimerval32)(unsafe.Pointer(old32)).Fit_value.Ftv_usec = int32((**(**Titimerval)(__ccgo_up(bp))).Fit_value.Ftv_usec) return 0 } @@ -152680,10 +152680,10 @@ func X__getrusage_time32(tls *TLS, who int32, usage uintptr) (r1 int32) { _ = r r = Xgetrusage(tls, who, bp) if !(r != 0) { - (*Tcompat_rusage)(unsafe.Pointer(usage)).Fru_utime.Ftv_sec = int32((*(*Trusage)(unsafe.Pointer(bp))).Fru_utime.Ftv_sec) - (*Tcompat_rusage)(unsafe.Pointer(usage)).Fru_utime.Ftv_usec = int32((*(*Trusage)(unsafe.Pointer(bp))).Fru_utime.Ftv_usec) - (*Tcompat_rusage)(unsafe.Pointer(usage)).Fru_stime.Ftv_sec = int32((*(*Trusage)(unsafe.Pointer(bp))).Fru_stime.Ftv_sec) - (*Tcompat_rusage)(unsafe.Pointer(usage)).Fru_stime.Ftv_usec = int32((*(*Trusage)(unsafe.Pointer(bp))).Fru_stime.Ftv_usec) + (*Tcompat_rusage)(unsafe.Pointer(usage)).Fru_utime.Ftv_sec = int32((**(**Trusage)(__ccgo_up(bp))).Fru_utime.Ftv_sec) + (*Tcompat_rusage)(unsafe.Pointer(usage)).Fru_utime.Ftv_usec = int32((**(**Trusage)(__ccgo_up(bp))).Fru_utime.Ftv_usec) + (*Tcompat_rusage)(unsafe.Pointer(usage)).Fru_stime.Ftv_sec = int32((**(**Trusage)(__ccgo_up(bp))).Fru_stime.Ftv_sec) + (*Tcompat_rusage)(unsafe.Pointer(usage)).Fru_stime.Ftv_usec = int32((**(**Trusage)(__ccgo_up(bp))).Fru_stime.Ftv_usec) _memcpy(tls, usage+16, bp+32, Uint32FromInt64(72)-uint32(UintptrFromInt32(0)+16)) } return r @@ -152706,12 +152706,12 @@ func X__gettimeofday_time32(tls *TLS, tv32 uintptr, tz uintptr) (r1 int32) { if r != 0 { return r } - if (*(*Ttimeval)(unsafe.Pointer(bp))).Ftv_sec < int64(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff)) || (*(*Ttimeval)(unsafe.Pointer(bp))).Ftv_sec > int64(Int32FromInt32(INT32_MAX)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + if (**(**Ttimeval)(__ccgo_up(bp))).Ftv_sec < int64(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff)) || (**(**Ttimeval)(__ccgo_up(bp))).Ftv_sec > int64(Int32FromInt32(INT32_MAX)) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return -int32(1) } - (*Ttimeval32)(unsafe.Pointer(tv32)).Ftv_sec = int32((*(*Ttimeval)(unsafe.Pointer(bp))).Ftv_sec) - (*Ttimeval32)(unsafe.Pointer(tv32)).Ftv_usec = int32((*(*Ttimeval)(unsafe.Pointer(bp))).Ftv_usec) + (*Ttimeval32)(unsafe.Pointer(tv32)).Ftv_sec = int32((**(**Ttimeval)(__ccgo_up(bp))).Ftv_sec) + (*Ttimeval32)(unsafe.Pointer(tv32)).Ftv_usec = int32((**(**Ttimeval)(__ccgo_up(bp))).Ftv_usec) return 0 } @@ -152722,7 +152722,7 @@ func X__gmtime32(tls *TLS, t uintptr) (r uintptr) { } bp := tls.Alloc(16) defer tls.Free(16) - *(*Ttime_t)(unsafe.Pointer(bp)) = int64(*(*Ttime32_t)(unsafe.Pointer(t))) + *(*Ttime_t)(unsafe.Pointer(bp)) = int64(**(**Ttime32_t)(__ccgo_up(t))) return Xgmtime(tls, bp) } @@ -152733,7 +152733,7 @@ func X__gmtime32_r(tls *TLS, t uintptr, tm uintptr) (r uintptr) { } bp := tls.Alloc(16) defer tls.Free(16) - *(*Ttime_t)(unsafe.Pointer(bp)) = int64(*(*Ttime32_t)(unsafe.Pointer(t))) + *(*Ttime_t)(unsafe.Pointer(bp)) = int64(**(**Ttime32_t)(__ccgo_up(t))) return Xgmtime_r(tls, bp, tm) } @@ -152744,7 +152744,7 @@ func X__localtime32(tls *TLS, t uintptr) (r uintptr) { } bp := tls.Alloc(16) defer tls.Free(16) - *(*Ttime_t)(unsafe.Pointer(bp)) = int64(*(*Ttime32_t)(unsafe.Pointer(t))) + *(*Ttime_t)(unsafe.Pointer(bp)) = int64(**(**Ttime32_t)(__ccgo_up(t))) return Xlocaltime(tls, bp) } @@ -152755,7 +152755,7 @@ func X__localtime32_r(tls *TLS, t uintptr, tm uintptr) (r uintptr) { } bp := tls.Alloc(16) defer tls.Free(16) - *(*Ttime_t)(unsafe.Pointer(bp)) = int64(*(*Ttime32_t)(unsafe.Pointer(t))) + *(*Ttime_t)(unsafe.Pointer(bp)) = int64(**(**Ttime32_t)(__ccgo_up(t))) return Xlocaltime_r(tls, bp, tm) } @@ -152790,12 +152790,12 @@ func X__lutimes_time32(tls *TLS, path uintptr, times32 uintptr) (r int32) { } else { *(*[2]Ttimeval)(unsafe.Pointer(bp)) = [2]Ttimeval{ 0: { - Ftv_sec: int64((*(*Ttimeval32)(unsafe.Pointer(times32))).Ftv_sec), - Ftv_usec: int64((*(*Ttimeval32)(unsafe.Pointer(times32))).Ftv_usec), + Ftv_sec: int64((**(**Ttimeval32)(__ccgo_up(times32))).Ftv_sec), + Ftv_usec: int64((**(**Ttimeval32)(__ccgo_up(times32))).Ftv_usec), }, 1: { - Ftv_sec: int64((*(*Ttimeval32)(unsafe.Pointer(times32 + 1*8))).Ftv_sec), - Ftv_usec: int64((*(*Ttimeval32)(unsafe.Pointer(times32 + 1*8))).Ftv_usec), + Ftv_sec: int64((**(**Ttimeval32)(__ccgo_up(times32 + 1*8))).Ftv_sec), + Ftv_usec: int64((**(**Ttimeval32)(__ccgo_up(times32 + 1*8))).Ftv_usec), }, } v1 = bp @@ -152813,13 +152813,13 @@ func X__mktime32(tls *TLS, tm uintptr) (r Ttime32_t) { var t Ttime_t var _ /* tmp at bp+0 */ Ttm _ = t - *(*Ttm)(unsafe.Pointer(bp)) = *(*Ttm)(unsafe.Pointer(tm)) + **(**Ttm)(__ccgo_up(bp)) = **(**Ttm)(__ccgo_up(tm)) t = Xmktime(tls, bp) if t < int64(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff)) || t > int64(Int32FromInt32(INT32_MAX)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return -int32(1) } - *(*Ttm)(unsafe.Pointer(tm)) = *(*Ttm)(unsafe.Pointer(bp)) + **(**Ttm)(__ccgo_up(tm)) = **(**Ttm)(__ccgo_up(bp)) return int32(t) } @@ -152838,9 +152838,9 @@ func X__nanosleep_time32(tls *TLS, req32 uintptr, rem32 uintptr) (r int32) { Ftv_nsec: (*Ttimespec32)(unsafe.Pointer(req32)).Ftv_nsec, } ret = Xnanosleep(tls, bp, bp+16) - if ret < 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EINTR) && rem32 != 0 { - (*Ttimespec32)(unsafe.Pointer(rem32)).Ftv_sec = int32((*(*Ttimespec)(unsafe.Pointer(bp + 16))).Ftv_sec) - (*Ttimespec32)(unsafe.Pointer(rem32)).Ftv_nsec = (*(*Ttimespec)(unsafe.Pointer(bp + 16))).Ftv_nsec + if ret < 0 && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EINTR) && rem32 != 0 { + (*Ttimespec32)(unsafe.Pointer(rem32)).Ftv_sec = int32((**(**Ttimespec)(__ccgo_up(bp + 16))).Ftv_sec) + (*Ttimespec32)(unsafe.Pointer(rem32)).Ftv_nsec = (**(**Ttimespec)(__ccgo_up(bp + 16))).Ftv_nsec } return ret } @@ -152979,10 +152979,10 @@ func X__setitimer_time32(tls *TLS, which int32, new32 uintptr, old32 uintptr) (r * Since these are relative times, values large enough to overflow * don't make sense anyway. */ if old32 != 0 { - (*Titimerval32)(unsafe.Pointer(old32)).Fit_interval.Ftv_sec = int32((*(*Titimerval)(unsafe.Pointer(bp + 32))).Fit_interval.Ftv_sec) - (*Titimerval32)(unsafe.Pointer(old32)).Fit_interval.Ftv_usec = int32((*(*Titimerval)(unsafe.Pointer(bp + 32))).Fit_interval.Ftv_usec) - (*Titimerval32)(unsafe.Pointer(old32)).Fit_value.Ftv_sec = int32((*(*Titimerval)(unsafe.Pointer(bp + 32))).Fit_value.Ftv_sec) - (*Titimerval32)(unsafe.Pointer(old32)).Fit_value.Ftv_usec = int32((*(*Titimerval)(unsafe.Pointer(bp + 32))).Fit_value.Ftv_usec) + (*Titimerval32)(unsafe.Pointer(old32)).Fit_interval.Ftv_sec = int32((**(**Titimerval)(__ccgo_up(bp + 32))).Fit_interval.Ftv_sec) + (*Titimerval32)(unsafe.Pointer(old32)).Fit_interval.Ftv_usec = int32((**(**Titimerval)(__ccgo_up(bp + 32))).Fit_interval.Ftv_usec) + (*Titimerval32)(unsafe.Pointer(old32)).Fit_value.Ftv_sec = int32((**(**Titimerval)(__ccgo_up(bp + 32))).Fit_value.Ftv_sec) + (*Titimerval32)(unsafe.Pointer(old32)).Fit_value.Ftv_usec = int32((**(**Titimerval)(__ccgo_up(bp + 32))).Fit_value.Ftv_usec) } return 0 } @@ -153053,7 +153053,7 @@ func X__stime32(tls *TLS, t uintptr) (r int32) { } bp := tls.Alloc(16) defer tls.Free(16) - *(*Ttime_t)(unsafe.Pointer(bp)) = int64(*(*Ttime32_t)(unsafe.Pointer(t))) + *(*Ttime_t)(unsafe.Pointer(bp)) = int64(**(**Ttime32_t)(__ccgo_up(t))) return Xstime(tls, bp) } @@ -153066,11 +153066,11 @@ func X__time32(tls *TLS, p uintptr) (r Ttime32_t) { _ = t t = Xtime(tls, uintptr(0)) if t < int64(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff)) || t > int64(Int32FromInt32(INT32_MAX)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return -int32(1) } if p != 0 { - *(*Ttime32_t)(unsafe.Pointer(p)) = int32(t) + **(**Ttime32_t)(__ccgo_up(p)) = int32(t) } return int32(t) } @@ -153084,7 +153084,7 @@ func X__time32gm(tls *TLS, tm uintptr) (r Ttime32_t) { _ = t t = Xtimegm(tls, tm) if t < int64(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff)) || t > int64(Int32FromInt32(INT32_MAX)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return -int32(1) } return int32(t) @@ -153105,10 +153105,10 @@ func X__timer_gettime32(tls *TLS, t Ttimer_t, val32 uintptr) (r1 int32) { return r } /* No range checking for consistency with settime */ - (*Titimerspec32)(unsafe.Pointer(val32)).Fit_interval.Ftv_sec = int32((*(*Titimerspec)(unsafe.Pointer(bp))).Fit_interval.Ftv_sec) - (*Titimerspec32)(unsafe.Pointer(val32)).Fit_interval.Ftv_nsec = (*(*Titimerspec)(unsafe.Pointer(bp))).Fit_interval.Ftv_nsec - (*Titimerspec32)(unsafe.Pointer(val32)).Fit_value.Ftv_sec = int32((*(*Titimerspec)(unsafe.Pointer(bp))).Fit_value.Ftv_sec) - (*Titimerspec32)(unsafe.Pointer(val32)).Fit_value.Ftv_nsec = (*(*Titimerspec)(unsafe.Pointer(bp))).Fit_value.Ftv_nsec + (*Titimerspec32)(unsafe.Pointer(val32)).Fit_interval.Ftv_sec = int32((**(**Titimerspec)(__ccgo_up(bp))).Fit_interval.Ftv_sec) + (*Titimerspec32)(unsafe.Pointer(val32)).Fit_interval.Ftv_nsec = (**(**Titimerspec)(__ccgo_up(bp))).Fit_interval.Ftv_nsec + (*Titimerspec32)(unsafe.Pointer(val32)).Fit_value.Ftv_sec = int32((**(**Titimerspec)(__ccgo_up(bp))).Fit_value.Ftv_sec) + (*Titimerspec32)(unsafe.Pointer(val32)).Fit_value.Ftv_nsec = (**(**Titimerspec)(__ccgo_up(bp))).Fit_value.Ftv_nsec return 0 } @@ -153147,10 +153147,10 @@ func X__timer_settime32(tls *TLS, t Ttimer_t, flags int32, val32 uintptr, old32 * Since these are relative times, values large enough to overflow * don't make sense anyway. */ if old32 != 0 { - (*Titimerspec32)(unsafe.Pointer(old32)).Fit_interval.Ftv_sec = int32((*(*Titimerspec)(unsafe.Pointer(bp + 32))).Fit_interval.Ftv_sec) - (*Titimerspec32)(unsafe.Pointer(old32)).Fit_interval.Ftv_nsec = (*(*Titimerspec)(unsafe.Pointer(bp + 32))).Fit_interval.Ftv_nsec - (*Titimerspec32)(unsafe.Pointer(old32)).Fit_value.Ftv_sec = int32((*(*Titimerspec)(unsafe.Pointer(bp + 32))).Fit_value.Ftv_sec) - (*Titimerspec32)(unsafe.Pointer(old32)).Fit_value.Ftv_nsec = (*(*Titimerspec)(unsafe.Pointer(bp + 32))).Fit_value.Ftv_nsec + (*Titimerspec32)(unsafe.Pointer(old32)).Fit_interval.Ftv_sec = int32((**(**Titimerspec)(__ccgo_up(bp + 32))).Fit_interval.Ftv_sec) + (*Titimerspec32)(unsafe.Pointer(old32)).Fit_interval.Ftv_nsec = (**(**Titimerspec)(__ccgo_up(bp + 32))).Fit_interval.Ftv_nsec + (*Titimerspec32)(unsafe.Pointer(old32)).Fit_value.Ftv_sec = int32((**(**Titimerspec)(__ccgo_up(bp + 32))).Fit_value.Ftv_sec) + (*Titimerspec32)(unsafe.Pointer(old32)).Fit_value.Ftv_nsec = (**(**Titimerspec)(__ccgo_up(bp + 32))).Fit_value.Ftv_nsec } return 0 } @@ -153170,10 +153170,10 @@ func X__timerfd_gettime32(tls *TLS, t int32, val32 uintptr) (r1 int32) { return r } /* No range checking for consistency with settime */ - (*Titimerspec32)(unsafe.Pointer(val32)).Fit_interval.Ftv_sec = int32((*(*Titimerspec)(unsafe.Pointer(bp))).Fit_interval.Ftv_sec) - (*Titimerspec32)(unsafe.Pointer(val32)).Fit_interval.Ftv_nsec = (*(*Titimerspec)(unsafe.Pointer(bp))).Fit_interval.Ftv_nsec - (*Titimerspec32)(unsafe.Pointer(val32)).Fit_value.Ftv_sec = int32((*(*Titimerspec)(unsafe.Pointer(bp))).Fit_value.Ftv_sec) - (*Titimerspec32)(unsafe.Pointer(val32)).Fit_value.Ftv_nsec = (*(*Titimerspec)(unsafe.Pointer(bp))).Fit_value.Ftv_nsec + (*Titimerspec32)(unsafe.Pointer(val32)).Fit_interval.Ftv_sec = int32((**(**Titimerspec)(__ccgo_up(bp))).Fit_interval.Ftv_sec) + (*Titimerspec32)(unsafe.Pointer(val32)).Fit_interval.Ftv_nsec = (**(**Titimerspec)(__ccgo_up(bp))).Fit_interval.Ftv_nsec + (*Titimerspec32)(unsafe.Pointer(val32)).Fit_value.Ftv_sec = int32((**(**Titimerspec)(__ccgo_up(bp))).Fit_value.Ftv_sec) + (*Titimerspec32)(unsafe.Pointer(val32)).Fit_value.Ftv_nsec = (**(**Titimerspec)(__ccgo_up(bp))).Fit_value.Ftv_nsec return 0 } @@ -153212,10 +153212,10 @@ func X__timerfd_settime32(tls *TLS, t int32, flags int32, val32 uintptr, old32 u * Since these are relative times, values large enough to overflow * don't make sense anyway. */ if old32 != 0 { - (*Titimerspec32)(unsafe.Pointer(old32)).Fit_interval.Ftv_sec = int32((*(*Titimerspec)(unsafe.Pointer(bp + 32))).Fit_interval.Ftv_sec) - (*Titimerspec32)(unsafe.Pointer(old32)).Fit_interval.Ftv_nsec = (*(*Titimerspec)(unsafe.Pointer(bp + 32))).Fit_interval.Ftv_nsec - (*Titimerspec32)(unsafe.Pointer(old32)).Fit_value.Ftv_sec = int32((*(*Titimerspec)(unsafe.Pointer(bp + 32))).Fit_value.Ftv_sec) - (*Titimerspec32)(unsafe.Pointer(old32)).Fit_value.Ftv_nsec = (*(*Titimerspec)(unsafe.Pointer(bp + 32))).Fit_value.Ftv_nsec + (*Titimerspec32)(unsafe.Pointer(old32)).Fit_interval.Ftv_sec = int32((**(**Titimerspec)(__ccgo_up(bp + 32))).Fit_interval.Ftv_sec) + (*Titimerspec32)(unsafe.Pointer(old32)).Fit_interval.Ftv_nsec = (**(**Titimerspec)(__ccgo_up(bp + 32))).Fit_interval.Ftv_nsec + (*Titimerspec32)(unsafe.Pointer(old32)).Fit_value.Ftv_sec = int32((**(**Titimerspec)(__ccgo_up(bp + 32))).Fit_value.Ftv_sec) + (*Titimerspec32)(unsafe.Pointer(old32)).Fit_value.Ftv_nsec = (**(**Titimerspec)(__ccgo_up(bp + 32))).Fit_value.Ftv_nsec } return 0 } @@ -153234,12 +153234,12 @@ func X__timespec_get_time32(tls *TLS, ts32 uintptr, base int32) (r1 int32) { if !(r != 0) { return r } - if (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec < int64(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff)) || (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec > int64(Int32FromInt32(INT32_MAX)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + if (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec < int64(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff)) || (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec > int64(Int32FromInt32(INT32_MAX)) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return 0 } - (*Ttimespec32)(unsafe.Pointer(ts32)).Ftv_sec = int32((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec) - (*Ttimespec32)(unsafe.Pointer(ts32)).Ftv_nsec = (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_nsec + (*Ttimespec32)(unsafe.Pointer(ts32)).Ftv_sec = int32((**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec) + (*Ttimespec32)(unsafe.Pointer(ts32)).Ftv_nsec = (**(**Ttimespec)(__ccgo_up(bp))).Ftv_nsec return r } @@ -153283,12 +153283,12 @@ func X__utimensat_time32(tls *TLS, fd int32, path uintptr, times32 uintptr, flag } else { *(*[2]Ttimespec)(unsafe.Pointer(bp)) = [2]Ttimespec{ 0: { - Ftv_sec: int64((*(*Ttimespec32)(unsafe.Pointer(times32))).Ftv_sec), - Ftv_nsec: (*(*Ttimespec32)(unsafe.Pointer(times32))).Ftv_nsec, + Ftv_sec: int64((**(**Ttimespec32)(__ccgo_up(times32))).Ftv_sec), + Ftv_nsec: (**(**Ttimespec32)(__ccgo_up(times32))).Ftv_nsec, }, 1: { - Ftv_sec: int64((*(*Ttimespec32)(unsafe.Pointer(times32 + 1*8))).Ftv_sec), - Ftv_nsec: (*(*Ttimespec32)(unsafe.Pointer(times32 + 1*8))).Ftv_nsec, + Ftv_sec: int64((**(**Ttimespec32)(__ccgo_up(times32 + 1*8))).Ftv_sec), + Ftv_nsec: (**(**Ttimespec32)(__ccgo_up(times32 + 1*8))).Ftv_nsec, }, } v1 = bp @@ -153310,12 +153310,12 @@ func X__utimes_time32(tls *TLS, path uintptr, times32 uintptr) (r int32) { } else { *(*[2]Ttimeval)(unsafe.Pointer(bp)) = [2]Ttimeval{ 0: { - Ftv_sec: int64((*(*Ttimeval32)(unsafe.Pointer(times32))).Ftv_sec), - Ftv_usec: int64((*(*Ttimeval32)(unsafe.Pointer(times32))).Ftv_usec), + Ftv_sec: int64((**(**Ttimeval32)(__ccgo_up(times32))).Ftv_sec), + Ftv_usec: int64((**(**Ttimeval32)(__ccgo_up(times32))).Ftv_usec), }, 1: { - Ftv_sec: int64((*(*Ttimeval32)(unsafe.Pointer(times32 + 1*8))).Ftv_sec), - Ftv_usec: int64((*(*Ttimeval32)(unsafe.Pointer(times32 + 1*8))).Ftv_usec), + Ftv_sec: int64((**(**Ttimeval32)(__ccgo_up(times32 + 1*8))).Ftv_sec), + Ftv_usec: int64((**(**Ttimeval32)(__ccgo_up(times32 + 1*8))).Ftv_usec), }, } v1 = bp @@ -153341,10 +153341,10 @@ func X__wait3_time32(tls *TLS, status uintptr, options int32, usage uintptr) (r1 } r = Xwait3(tls, status, options, v1) if !(r != 0) && usage != 0 { - (*Tcompat_rusage)(unsafe.Pointer(usage)).Fru_utime.Ftv_sec = int32((*(*Trusage)(unsafe.Pointer(bp))).Fru_utime.Ftv_sec) - (*Tcompat_rusage)(unsafe.Pointer(usage)).Fru_utime.Ftv_usec = int32((*(*Trusage)(unsafe.Pointer(bp))).Fru_utime.Ftv_usec) - (*Tcompat_rusage)(unsafe.Pointer(usage)).Fru_stime.Ftv_sec = int32((*(*Trusage)(unsafe.Pointer(bp))).Fru_stime.Ftv_sec) - (*Tcompat_rusage)(unsafe.Pointer(usage)).Fru_stime.Ftv_usec = int32((*(*Trusage)(unsafe.Pointer(bp))).Fru_stime.Ftv_usec) + (*Tcompat_rusage)(unsafe.Pointer(usage)).Fru_utime.Ftv_sec = int32((**(**Trusage)(__ccgo_up(bp))).Fru_utime.Ftv_sec) + (*Tcompat_rusage)(unsafe.Pointer(usage)).Fru_utime.Ftv_usec = int32((**(**Trusage)(__ccgo_up(bp))).Fru_utime.Ftv_usec) + (*Tcompat_rusage)(unsafe.Pointer(usage)).Fru_stime.Ftv_sec = int32((**(**Trusage)(__ccgo_up(bp))).Fru_stime.Ftv_sec) + (*Tcompat_rusage)(unsafe.Pointer(usage)).Fru_stime.Ftv_usec = int32((**(**Trusage)(__ccgo_up(bp))).Fru_stime.Ftv_usec) _memcpy(tls, usage+16, bp+32, Uint32FromInt64(72)-uint32(UintptrFromInt32(0)+16)) } return r @@ -153368,10 +153368,10 @@ func X__wait4_time32(tls *TLS, pid Tpid_t, status uintptr, options int32, usage } r = Xwait4(tls, pid, status, options, v1) if !(r != 0) && usage != 0 { - (*Tcompat_rusage)(unsafe.Pointer(usage)).Fru_utime.Ftv_sec = int32((*(*Trusage)(unsafe.Pointer(bp))).Fru_utime.Ftv_sec) - (*Tcompat_rusage)(unsafe.Pointer(usage)).Fru_utime.Ftv_usec = int32((*(*Trusage)(unsafe.Pointer(bp))).Fru_utime.Ftv_usec) - (*Tcompat_rusage)(unsafe.Pointer(usage)).Fru_stime.Ftv_sec = int32((*(*Trusage)(unsafe.Pointer(bp))).Fru_stime.Ftv_sec) - (*Tcompat_rusage)(unsafe.Pointer(usage)).Fru_stime.Ftv_usec = int32((*(*Trusage)(unsafe.Pointer(bp))).Fru_stime.Ftv_usec) + (*Tcompat_rusage)(unsafe.Pointer(usage)).Fru_utime.Ftv_sec = int32((**(**Trusage)(__ccgo_up(bp))).Fru_utime.Ftv_sec) + (*Tcompat_rusage)(unsafe.Pointer(usage)).Fru_utime.Ftv_usec = int32((**(**Trusage)(__ccgo_up(bp))).Fru_utime.Ftv_usec) + (*Tcompat_rusage)(unsafe.Pointer(usage)).Fru_stime.Ftv_sec = int32((**(**Trusage)(__ccgo_up(bp))).Fru_stime.Ftv_sec) + (*Tcompat_rusage)(unsafe.Pointer(usage)).Fru_stime.Ftv_usec = int32((**(**Trusage)(__ccgo_up(bp))).Fru_stime.Ftv_usec) _memcpy(tls, usage+16, bp+32, Uint32FromInt64(72)-uint32(UintptrFromInt32(0)+16)) } return r @@ -153382,6 +153382,10 @@ func __ccgo_fp(f interface{}) uintptr { return (*iface)(unsafe.Pointer(&f))[1] } +func __ccgo_up(n uintptr) unsafe.Pointer { + return unsafe.Pointer(&n) +} + var X__abort_lock [1]int32 var X__at_quick_exit_lockptr = uintptr(unsafe.Pointer(&_lock)) diff --git a/vendor/modernc.org/libc/ccgo_linux_arm64.go b/vendor/modernc.org/libc/ccgo_linux_arm64.go index d52c284411..79d248046b 100644 --- a/vendor/modernc.org/libc/ccgo_linux_arm64.go +++ b/vendor/modernc.org/libc/ccgo_linux_arm64.go @@ -562,7 +562,7 @@ func ___frexp_exp(tls *TLS, x float64, expt uintptr) (r float64) { */ exp_x = Xexp(tls, x-_kln2) hx = uint32(*(*Tuint64_t)(unsafe.Pointer(&exp_x)) >> int32(32)) - *(*int32)(unsafe.Pointer(expt)) = Int32FromUint32(hx>>Int32FromInt32(20) - Uint32FromInt32(Int32FromInt32(0x3ff)+Int32FromInt32(1023)) + _k) + **(**int32)(__ccgo_up(expt)) = Int32FromUint32(hx>>Int32FromInt32(20) - Uint32FromInt32(Int32FromInt32(0x3ff)+Int32FromInt32(1023)) + _k) v1 = uint64(hx&Uint32FromInt32(0xfffff)|Uint32FromInt32((Int32FromInt32(0x3ff)+Int32FromInt32(1023))<>Int32FromInt32(23) - Uint32FromInt32(Int32FromInt32(0x7f)+Int32FromInt32(127)) + _k1) + **(**int32)(__ccgo_up(expt)) = Int32FromUint32(hx>>Int32FromInt32(23) - Uint32FromInt32(Int32FromInt32(0x7f)+Int32FromInt32(127)) + _k1) v1 = hx&uint32(0x7fffff) | Uint32FromInt32((Int32FromInt32(0x7f)+Int32FromInt32(127))< uint32(35) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uint64(0) } } @@ -3293,7 +3293,7 @@ func Xfpathconf(tls *TLS, fd int32, name int32) (r int64) { defer func() { trc("-> %v", r) }() } if Uint64FromInt32(name) >= Uint64FromInt64(42)/Uint64FromInt64(2) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) } return int64(_values[name]) @@ -7379,7 +7379,7 @@ func Xsysconf(tls *TLS, name int32) (r int64) { var _ /* si at bp+144 */ Tsysinfo _, _, _, _, _, _, _ = cnt, i, mem, val, v1, v3, v5 if Uint64FromInt32(name) >= Uint64FromInt64(502)/Uint64FromInt64(2) || !(_values1[name] != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) } else { if int32(_values1[name]) >= -int32(1) { @@ -7387,13 +7387,13 @@ func Xsysconf(tls *TLS, name int32) (r int64) { } else { if int32(_values1[name]) < -int32(256) { Xgetrlimit(tls, int32(_values1[name])&int32(16383), bp) - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur == ^Uint64FromUint64(0) { + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur == ^Uint64FromUint64(0) { return int64(-int32(1)) } - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur > uint64(0x7fffffffffffffff) { + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur > uint64(0x7fffffffffffffff) { v1 = uint64(0x7fffffffffffffff) } else { - v1 = (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur + v1 = (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur } return Int64FromUint64(v1) } @@ -7415,7 +7415,7 @@ func Xsysconf(tls *TLS, name int32) (r int64) { case (-Int32FromInt32(256) | Int32FromInt32(6)) & Int32FromInt32(255): fallthrough case (-Int32FromInt32(256) | Int32FromInt32(7)) & Int32FromInt32(255): - *(*[128]uint8)(unsafe.Pointer(bp + 16)) = [128]uint8{ + **(**[128]uint8)(__ccgo_up(bp + 16)) = [128]uint8{ 0: uint8(1), } X__syscall3(tls, int64(SYS_sched_getaffinity), int64(Int32FromInt32(0)), Int64FromUint64(Uint64FromInt64(128)), int64(bp+16)) @@ -7427,14 +7427,14 @@ func Xsysconf(tls *TLS, name int32) (r int64) { break } for { - if !((*(*[128]uint8)(unsafe.Pointer(bp + 16)))[i] != 0) { + if !((**(**[128]uint8)(__ccgo_up(bp + 16)))[i] != 0) { break } goto _4 _4: ; v5 = bp + 16 + uintptr(i) - *(*uint8)(unsafe.Pointer(v5)) = uint8(int32(*(*uint8)(unsafe.Pointer(v5))) & (Int32FromUint8((*(*[128]uint8)(unsafe.Pointer(bp + 16)))[i]) - Int32FromInt32(1))) + *(*uint8)(unsafe.Pointer(v5)) = uint8(int32(*(*uint8)(unsafe.Pointer(v5))) & (Int32FromUint8((**(**[128]uint8)(__ccgo_up(bp + 16)))[i]) - Int32FromInt32(1))) cnt = cnt + 1 } goto _2 @@ -7447,15 +7447,15 @@ func Xsysconf(tls *TLS, name int32) (r int64) { fallthrough case (-Int32FromInt32(256) | Int32FromInt32(9)) & Int32FromInt32(255): X__lsysinfo(tls, bp+144) - if !((*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fmem_unit != 0) { - (*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fmem_unit = uint32(1) + if !((**(**Tsysinfo)(__ccgo_up(bp + 144))).Fmem_unit != 0) { + (**(**Tsysinfo)(__ccgo_up(bp + 144))).Fmem_unit = uint32(1) } if name == int32(_SC_PHYS_PAGES) { - mem = (*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Ftotalram + mem = uint64((**(**Tsysinfo)(__ccgo_up(bp + 144))).Ftotalram) } else { - mem = (*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Ffreeram + (*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fbufferram + mem = uint64((**(**Tsysinfo)(__ccgo_up(bp + 144))).Ffreeram + (**(**Tsysinfo)(__ccgo_up(bp + 144))).Fbufferram) } - mem = mem * uint64((*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fmem_unit) + mem = mem * uint64((**(**Tsysinfo)(__ccgo_up(bp + 144))).Fmem_unit) mem = mem / X__libc.Fpage_size if mem > uint64(0x7fffffffffffffff) { v1 = uint64(0x7fffffffffffffff) @@ -8855,7 +8855,7 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { for cond := true; cond; cond = dptr < end { v1 = sptr sptr = sptr + 1 - tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = uint32(**(**uint8)(__ccgo_up(v1))) tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) @@ -8867,7 +8867,7 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { c1 = tmp v1 = sptr sptr = sptr + 1 - tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = uint32(**(**uint8)(__ccgo_up(v1))) tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) @@ -8879,13 +8879,13 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { c2 = tmp v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(c1<>int32(4)) + **(**uint8)(__ccgo_up(v1)) = uint8(c1<>int32(4)) if dptr >= end { break } v1 = sptr sptr = sptr + 1 - tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = uint32(**(**uint8)(__ccgo_up(v1))) tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) @@ -8897,13 +8897,13 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { c3 = tmp v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(c2&uint32(0x0F)<>int32(2)) + **(**uint8)(__ccgo_up(v1)) = uint8(c2&uint32(0x0F)<>int32(2)) if dptr >= end { break } v1 = sptr sptr = sptr + 1 - tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = uint32(**(**uint8)(__ccgo_up(v1))) tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) @@ -8915,7 +8915,7 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { c4 = tmp v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(c3&uint32(0x03)<>int32(2)] + **(**uint8)(__ccgo_up(v1)) = _BF_itoa64[c1>>int32(2)] c1 = c1 & uint32(0x03) << int32(4) if sptr >= end { v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] + **(**uint8)(__ccgo_up(v1)) = _BF_itoa64[c1] break } v1 = sptr sptr = sptr + 1 - c2 = uint32(*(*uint8)(unsafe.Pointer(v1))) + c2 = uint32(**(**uint8)(__ccgo_up(v1))) c1 = c1 | c2>>int32(4) v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] + **(**uint8)(__ccgo_up(v1)) = _BF_itoa64[c1] c1 = c2 & uint32(0x0f) << int32(2) if sptr >= end { v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] + **(**uint8)(__ccgo_up(v1)) = _BF_itoa64[c1] break } v1 = sptr sptr = sptr + 1 - c2 = uint32(*(*uint8)(unsafe.Pointer(v1))) + c2 = uint32(**(**uint8)(__ccgo_up(v1))) c1 = c1 | c2>>int32(6) v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] + **(**uint8)(__ccgo_up(v1)) = _BF_itoa64[c1] v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c2&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _BF_itoa64[c2&uint32(0x3f)] } } @@ -8976,11 +8976,11 @@ func _BF_swap(tls *TLS, x uintptr, count int32) { v1 = int32(1) if *(*uint8)(unsafe.Pointer(&v1)) != 0 { for { - tmp = *(*TBF_word)(unsafe.Pointer(x)) + tmp = **(**TBF_word)(__ccgo_up(x)) tmp = tmp<>Int32FromInt32(16) v4 = x x += 4 - *(*TBF_word)(unsafe.Pointer(v4)) = tmp&uint32(0x00FF00FF)<>Int32FromInt32(8)&uint32(0x00FF00FF) + **(**TBF_word)(__ccgo_up(v4)) = tmp&uint32(0x00FF00FF)<>Int32FromInt32(8)&uint32(0x00FF00FF) goto _3 _3: ; @@ -9000,7 +9000,7 @@ func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, e _, _, _, _, _, _, _ = i, ptr, tmp1, tmp2, tmp3, tmp4, v2 ptr = start for cond := true; cond; cond = ptr < end { - L = L ^ *(*TBF_word)(unsafe.Pointer(ctx)) + L = L ^ **(**TBF_word)(__ccgo_up(ctx)) i = 0 for { if !(i < int32(16)) { @@ -9012,12 +9012,12 @@ func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, e tmp3 = L >> int32(16) tmp3 = tmp3 & uint32(0xFF) tmp4 = L >> int32(24) - tmp1 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 3*1024 + uintptr(tmp1)*4)) - tmp2 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 2*1024 + uintptr(tmp2)*4)) - tmp3 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 1*1024 + uintptr(tmp3)*4)) - tmp3 = tmp3 + *(*TBF_word)(unsafe.Pointer(ctx + 72 + uintptr(tmp4)*4)) + tmp1 = **(**TBF_word)(__ccgo_up(ctx + 72 + 3*1024 + uintptr(tmp1)*4)) + tmp2 = **(**TBF_word)(__ccgo_up(ctx + 72 + 2*1024 + uintptr(tmp2)*4)) + tmp3 = **(**TBF_word)(__ccgo_up(ctx + 72 + 1*1024 + uintptr(tmp3)*4)) + tmp3 = tmp3 + **(**TBF_word)(__ccgo_up(ctx + 72 + uintptr(tmp4)*4)) tmp3 = tmp3 ^ tmp2 - R = R ^ *(*TBF_word)(unsafe.Pointer(ctx + uintptr(i+int32(1))*4)) + R = R ^ **(**TBF_word)(__ccgo_up(ctx + uintptr(i+int32(1))*4)) tmp3 = tmp3 + tmp1 R = R ^ tmp3 tmp1 = R & uint32(0xFF) @@ -9026,12 +9026,12 @@ func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, e tmp3 = R >> int32(16) tmp3 = tmp3 & uint32(0xFF) tmp4 = R >> int32(24) - tmp1 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 3*1024 + uintptr(tmp1)*4)) - tmp2 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 2*1024 + uintptr(tmp2)*4)) - tmp3 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 1*1024 + uintptr(tmp3)*4)) - tmp3 = tmp3 + *(*TBF_word)(unsafe.Pointer(ctx + 72 + uintptr(tmp4)*4)) + tmp1 = **(**TBF_word)(__ccgo_up(ctx + 72 + 3*1024 + uintptr(tmp1)*4)) + tmp2 = **(**TBF_word)(__ccgo_up(ctx + 72 + 2*1024 + uintptr(tmp2)*4)) + tmp3 = **(**TBF_word)(__ccgo_up(ctx + 72 + 1*1024 + uintptr(tmp3)*4)) + tmp3 = tmp3 + **(**TBF_word)(__ccgo_up(ctx + 72 + uintptr(tmp4)*4)) tmp3 = tmp3 ^ tmp2 - L = L ^ *(*TBF_word)(unsafe.Pointer(ctx + uintptr(i+int32(1)+int32(1))*4)) + L = L ^ **(**TBF_word)(__ccgo_up(ctx + uintptr(i+int32(1)+int32(1))*4)) tmp3 = tmp3 + tmp1 L = L ^ tmp3 goto _1 @@ -9041,13 +9041,13 @@ func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, e } tmp4 = R R = L - L = tmp4 ^ *(*TBF_word)(unsafe.Pointer(ctx + uintptr(Int32FromInt32(BF_N)+Int32FromInt32(1))*4)) + L = tmp4 ^ **(**TBF_word)(__ccgo_up(ctx + uintptr(Int32FromInt32(BF_N)+Int32FromInt32(1))*4)) v2 = ptr ptr += 4 - *(*TBF_word)(unsafe.Pointer(v2)) = L + **(**TBF_word)(__ccgo_up(v2)) = L v2 = ptr ptr += 4 - *(*TBF_word)(unsafe.Pointer(v2)) = R + **(**TBF_word)(__ccgo_up(v2)) = R } return L } @@ -9107,17 +9107,17 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags break } v1 = Uint32FromInt32(0) - (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)] = v1 - (*(*[2]TBF_word)(unsafe.Pointer(bp)))[0] = v1 + (**(**[2]TBF_word)(__ccgo_up(bp)))[int32(1)] = v1 + (**(**[2]TBF_word)(__ccgo_up(bp)))[0] = v1 j = uint32(0) for { if !(j < uint32(4)) { break } - *(*TBF_word)(unsafe.Pointer(bp)) <<= uint32(8) - *(*TBF_word)(unsafe.Pointer(bp)) |= uint32(*(*uint8)(unsafe.Pointer(ptr))) /* correct */ - *(*TBF_word)(unsafe.Pointer(bp + 1*4)) <<= uint32(8) - *(*TBF_word)(unsafe.Pointer(bp + 1*4)) |= Uint32FromInt8(Int8FromUint8(*(*uint8)(unsafe.Pointer(ptr)))) /* bug */ + **(**TBF_word)(__ccgo_up(bp)) <<= uint32(8) + **(**TBF_word)(__ccgo_up(bp)) |= uint32(uint8(**(**uint8)(__ccgo_up(ptr)))) /* correct */ + **(**TBF_word)(__ccgo_up(bp + 1*4)) <<= uint32(8) + **(**TBF_word)(__ccgo_up(bp + 1*4)) |= Uint32FromInt8(Int8FromUint8(**(**uint8)(__ccgo_up(ptr)))) /* bug */ /* * Sign extension in the first char has no effect - nothing to overwrite yet, * and those extra 24 bits will be fully shifted out of the 32-bit word. For @@ -9125,9 +9125,9 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags * extension in tmp[1] occurs. Once this flag is set, it remains set. */ if j != 0 { - sign = sign | (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)]&uint32(0x80) + sign = sign | (**(**[2]TBF_word)(__ccgo_up(bp)))[int32(1)]&uint32(0x80) } - if !(*(*uint8)(unsafe.Pointer(ptr)) != 0) { + if !(**(**uint8)(__ccgo_up(ptr)) != 0) { ptr = key } else { ptr = ptr + 1 @@ -9137,9 +9137,9 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags ; j = j + 1 } - diff = diff | ((*(*[2]TBF_word)(unsafe.Pointer(bp)))[0] ^ (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)]) /* Non-zero on any differences */ - *(*TBF_word)(unsafe.Pointer(expanded + uintptr(i)*4)) = (*(*[2]TBF_word)(unsafe.Pointer(bp)))[bug] - *(*TBF_word)(unsafe.Pointer(initial + uintptr(i)*4)) = *(*TBF_word)(unsafe.Pointer(uintptr(unsafe.Pointer(&_BF_init_state)) + uintptr(i)*4)) ^ (*(*[2]TBF_word)(unsafe.Pointer(bp)))[bug] + diff = diff | ((**(**[2]TBF_word)(__ccgo_up(bp)))[0] ^ (**(**[2]TBF_word)(__ccgo_up(bp)))[int32(1)]) /* Non-zero on any differences */ + **(**TBF_word)(__ccgo_up(expanded + uintptr(i)*4)) = (**(**[2]TBF_word)(__ccgo_up(bp)))[bug] + **(**TBF_word)(__ccgo_up(initial + uintptr(i)*4)) = **(**TBF_word)(__ccgo_up(uintptr(unsafe.Pointer(&_BF_init_state)) + uintptr(i)*4)) ^ (**(**[2]TBF_word)(__ccgo_up(bp)))[bug] goto _2 _2: ; @@ -9170,7 +9170,7 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags * state that could be directly specified by a password to the buggy algorithm * (and to the fully correct one as well, but that's a side-effect). */ - *(*TBF_word)(unsafe.Pointer(initial)) ^= sign + **(**TBF_word)(__ccgo_up(initial)) ^= sign } var _flags_by_subtype = [26]uint8{ @@ -9197,28 +9197,28 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w } } _, _, _, _, _, _, _, _, _, _, _, _ = L, L1, R, count, done, i, ptr, tmp1, tmp2, tmp3, tmp4, v1 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(setting))) != int32('$') || Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 1))) != int32('2') || Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 2)))-int32('a')) > uint32(25) || !(_flags_by_subtype[Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 2)))-int32('a')] != 0) || Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 3))) != int32('$') || Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 4)))-int32('0')) > uint32(1) || Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 5)))-int32('0')) > uint32(9) || Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 6))) != int32('$') { + if Int32FromUint8(**(**uint8)(__ccgo_up(setting))) != int32('$') || Int32FromUint8(**(**uint8)(__ccgo_up(setting + 1))) != int32('2') || Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(setting + 2)))-int32('a')) > uint32(25) || !(_flags_by_subtype[Int32FromUint8(**(**uint8)(__ccgo_up(setting + 2)))-int32('a')] != 0) || Int32FromUint8(**(**uint8)(__ccgo_up(setting + 3))) != int32('$') || Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(setting + 4)))-int32('0')) > uint32(1) || Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(setting + 5)))-int32('0')) > uint32(9) || Int32FromUint8(**(**uint8)(__ccgo_up(setting + 6))) != int32('$') { return UintptrFromInt32(0) } - count = Uint32FromInt32(1) << ((Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 4)))-int32('0'))*int32(10) + (Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 5))) - int32('0'))) + count = Uint32FromInt32(1) << ((Int32FromUint8(**(**uint8)(__ccgo_up(setting + 4)))-int32('0'))*int32(10) + (Int32FromUint8(**(**uint8)(__ccgo_up(setting + 5))) - int32('0'))) if count < min || _BF_decode(tls, bp+4240, setting+7, int32(16)) != 0 { return UintptrFromInt32(0) } _BF_swap(tls, bp+4240, int32(4)) - _BF_set_key(tls, key, bp+4168, bp, _flags_by_subtype[Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 2)))-int32('a')]) + _BF_set_key(tls, key, bp+4168, bp, _flags_by_subtype[Int32FromUint8(**(**uint8)(__ccgo_up(setting + 2)))-int32('a')]) Xmemcpy(tls, bp+72, uintptr(unsafe.Pointer(&_BF_init_state))+72, uint64(4096)) L = uint32(0) R = uint32(0) ptr = bp for cond := true; cond; cond = int32(1) != 0 { - L = _BF_encrypt(tls, bp, L^*(*TBF_word)(unsafe.Pointer(bp + 4240)), R^*(*TBF_word)(unsafe.Pointer(bp + 4240 + 1*4)), ptr, ptr) - R = *(*TBF_word)(unsafe.Pointer(ptr + UintptrFromInt32(1)*4)) + L = _BF_encrypt(tls, bp, L^**(**TBF_word)(__ccgo_up(bp + 4240)), R^**(**TBF_word)(__ccgo_up(bp + 4240 + 1*4)), ptr, ptr) + R = **(**TBF_word)(__ccgo_up(ptr + UintptrFromInt32(1)*4)) ptr = ptr + uintptr(2)*4 if ptr >= bp+uintptr(Int32FromInt32(BF_N)+Int32FromInt32(2)+Int32FromInt32(4)*Int32FromInt32(0x100))*4 { break } - L = _BF_encrypt(tls, bp, L^*(*TBF_word)(unsafe.Pointer(bp + 4240 + 2*4)), R^*(*TBF_word)(unsafe.Pointer(bp + 4240 + 3*4)), ptr, ptr) - R = *(*TBF_word)(unsafe.Pointer(ptr + UintptrFromInt32(1)*4)) + L = _BF_encrypt(tls, bp, L^**(**TBF_word)(__ccgo_up(bp + 4240 + 2*4)), R^**(**TBF_word)(__ccgo_up(bp + 4240 + 3*4)), ptr, ptr) + R = **(**TBF_word)(__ccgo_up(ptr + UintptrFromInt32(1)*4)) ptr = ptr + uintptr(2)*4 } for { @@ -9227,8 +9227,8 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w if !(i < Int32FromInt32(BF_N)+Int32FromInt32(2)) { break } - *(*TBF_word)(unsafe.Pointer(bp + uintptr(i)*4)) ^= *(*TBF_word)(unsafe.Pointer(bp + 4168 + uintptr(i)*4)) - *(*TBF_word)(unsafe.Pointer(bp + uintptr(i+int32(1))*4)) ^= *(*TBF_word)(unsafe.Pointer(bp + 4168 + uintptr(i+int32(1))*4)) + **(**TBF_word)(__ccgo_up(bp + uintptr(i)*4)) ^= **(**TBF_word)(__ccgo_up(bp + 4168 + uintptr(i)*4)) + **(**TBF_word)(__ccgo_up(bp + uintptr(i+int32(1))*4)) ^= **(**TBF_word)(__ccgo_up(bp + 4168 + uintptr(i+int32(1))*4)) goto _3 _3: ; @@ -9241,26 +9241,26 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w break } done = int32(1) - tmp1 = *(*TBF_word)(unsafe.Pointer(bp + 4240)) - tmp2 = *(*TBF_word)(unsafe.Pointer(bp + 4240 + 1*4)) - tmp3 = *(*TBF_word)(unsafe.Pointer(bp + 4240 + 2*4)) - tmp4 = *(*TBF_word)(unsafe.Pointer(bp + 4240 + 3*4)) + tmp1 = **(**TBF_word)(__ccgo_up(bp + 4240)) + tmp2 = **(**TBF_word)(__ccgo_up(bp + 4240 + 1*4)) + tmp3 = **(**TBF_word)(__ccgo_up(bp + 4240 + 2*4)) + tmp4 = **(**TBF_word)(__ccgo_up(bp + 4240 + 3*4)) i = 0 for { if !(i < int32(BF_N)) { break } - *(*TBF_word)(unsafe.Pointer(bp + uintptr(i)*4)) ^= tmp1 - *(*TBF_word)(unsafe.Pointer(bp + uintptr(i+int32(1))*4)) ^= tmp2 - *(*TBF_word)(unsafe.Pointer(bp + uintptr(i+int32(2))*4)) ^= tmp3 - *(*TBF_word)(unsafe.Pointer(bp + uintptr(i+int32(3))*4)) ^= tmp4 + **(**TBF_word)(__ccgo_up(bp + uintptr(i)*4)) ^= tmp1 + **(**TBF_word)(__ccgo_up(bp + uintptr(i+int32(1))*4)) ^= tmp2 + **(**TBF_word)(__ccgo_up(bp + uintptr(i+int32(2))*4)) ^= tmp3 + **(**TBF_word)(__ccgo_up(bp + uintptr(i+int32(3))*4)) ^= tmp4 goto _4 _4: ; i = i + int32(4) } - *(*TBF_word)(unsafe.Pointer(bp + 16*4)) ^= tmp1 - *(*TBF_word)(unsafe.Pointer(bp + 17*4)) ^= tmp2 + **(**TBF_word)(__ccgo_up(bp + 16*4)) ^= tmp1 + **(**TBF_word)(__ccgo_up(bp + 17*4)) ^= tmp2 } goto _2 _2: @@ -9277,10 +9277,10 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w break } L1 = _BF_magic_w[i] - (*(*[2]TBF_word)(unsafe.Pointer(bp + 4264)))[int32(1)] = _BF_magic_w[i+int32(1)] + (**(**[2]TBF_word)(__ccgo_up(bp + 4264)))[int32(1)] = _BF_magic_w[i+int32(1)] count = uint32(64) for { - L1 = _BF_encrypt(tls, bp, L1, (*(*[2]TBF_word)(unsafe.Pointer(bp + 4264)))[int32(1)], bp+4264, bp+4264) + L1 = _BF_encrypt(tls, bp, L1, (**(**[2]TBF_word)(__ccgo_up(bp + 4264)))[int32(1)], bp+4264, bp+4264) goto _7 _7: ; @@ -9290,20 +9290,20 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w break } } - *(*TBF_word)(unsafe.Pointer(bp + 4240 + uintptr(i)*4)) = L1 - *(*TBF_word)(unsafe.Pointer(bp + 4240 + uintptr(i+int32(1))*4)) = (*(*[2]TBF_word)(unsafe.Pointer(bp + 4264)))[int32(1)] + **(**TBF_word)(__ccgo_up(bp + 4240 + uintptr(i)*4)) = L1 + **(**TBF_word)(__ccgo_up(bp + 4240 + uintptr(i+int32(1))*4)) = (**(**[2]TBF_word)(__ccgo_up(bp + 4264)))[int32(1)] goto _5 _5: ; i = i + int32(2) } Xmemcpy(tls, output, setting, Uint64FromInt32(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1))) - *(*uint8)(unsafe.Pointer(output + uintptr(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1)))) = _BF_itoa64[Int32FromUint8(_BF_atoi64[Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1)))))-int32(0x20)])&int32(0x30)] + **(**uint8)(__ccgo_up(output + uintptr(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1)))) = _BF_itoa64[Int32FromUint8(_BF_atoi64[Int32FromUint8(**(**uint8)(__ccgo_up(setting + uintptr(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1)))))-int32(0x20)])&int32(0x30)] /* This has to be bug-compatible with the original implementation, so * only encode 23 of the 24 bytes. :-) */ _BF_swap(tls, bp+4240, int32(6)) _BF_encode(tls, output+uintptr(Int32FromInt32(7)+Int32FromInt32(22)), bp+4240, int32(23)) - *(*uint8)(unsafe.Pointer(output + uintptr(Int32FromInt32(7)+Int32FromInt32(22)+Int32FromInt32(31)))) = uint8('\000') + **(**uint8)(__ccgo_up(output + uintptr(Int32FromInt32(7)+Int32FromInt32(22)+Int32FromInt32(31)))) = uint8('\000') return output } @@ -9362,19 +9362,19 @@ func X__crypt_blowfish(tls *TLS, key uintptr, setting uintptr, output uintptr) ( */ Xmemcpy(tls, bp, test_setting, uint64(30)) if retval != 0 { - flags = uint32(_flags_by_subtype[Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 2)))-int32('a')]) + flags = uint32(_flags_by_subtype[Int32FromUint8(**(**uint8)(__ccgo_up(setting + 2)))-int32('a')]) test_hash = uintptr(unsafe.Pointer(&_test_hashes)) + uintptr(flags&uint32(1))*34 - *(*uint8)(unsafe.Pointer(bp + 2)) = *(*uint8)(unsafe.Pointer(setting + 2)) + **(**uint8)(__ccgo_up(bp + 2)) = **(**uint8)(__ccgo_up(setting + 2)) } Xmemset(tls, bp+30, int32(0x55), uint64(63)) - *(*uint8)(unsafe.Pointer(bp + 30 + uintptr(Uint64FromInt64(63)-Uint64FromInt32(1)))) = uint8(0) + **(**uint8)(__ccgo_up(bp + 30 + uintptr(Uint64FromInt64(63)-Uint64FromInt32(1)))) = uint8(0) p = _BF_crypt(tls, test_key, bp, bp+30, uint32(1)) ok = BoolInt32(p == bp+30 && !(Xmemcmp(tls, p, bp, Uint64FromInt32(Int32FromInt32(7)+Int32FromInt32(22))) != 0) && !(Xmemcmp(tls, p+uintptr(Int32FromInt32(7)+Int32FromInt32(22)), test_hash, Uint64FromInt32(Int32FromInt32(31)+Int32FromInt32(1)+Int32FromInt32(1)+Int32FromInt32(1))) != 0)) k = __ccgo_ts + 58 - _BF_set_key(tls, k, bp+96, bp+168, uint8(2)) /* $2a$ */ - _BF_set_key(tls, k, bp+240, bp+312, uint8(4)) /* $2y$ */ - *(*TBF_word)(unsafe.Pointer(bp + 168)) ^= uint32(0x10000) /* undo the safety (for comparison) */ - ok = BoolInt32(ok != 0 && (*(*TBF_key)(unsafe.Pointer(bp + 168)))[0] == uint32(0xdb9c59bc) && (*(*TBF_key)(unsafe.Pointer(bp + 240)))[int32(17)] == uint32(0x33343500) && !(Xmemcmp(tls, bp+96, bp+240, uint64(72)) != 0) && !(Xmemcmp(tls, bp+168, bp+312, uint64(72)) != 0)) + _BF_set_key(tls, k, bp+96, bp+168, uint8(2)) /* $2a$ */ + _BF_set_key(tls, k, bp+240, bp+312, uint8(4)) /* $2y$ */ + **(**TBF_word)(__ccgo_up(bp + 168)) ^= uint32(0x10000) /* undo the safety (for comparison) */ + ok = BoolInt32(ok != 0 && (**(**TBF_key)(__ccgo_up(bp + 168)))[0] == uint32(0xdb9c59bc) && (**(**TBF_key)(__ccgo_up(bp + 240)))[int32(17)] == uint32(0x33343500) && !(Xmemcmp(tls, bp+96, bp+240, uint64(72)) != 0) && !(Xmemcmp(tls, bp+168, bp+312, uint64(72)) != 0)) if ok != 0 && retval != 0 { return retval } @@ -11224,8 +11224,8 @@ func X__des_setkey(tls *TLS, key uintptr, ekey uintptr) { var i, ibit, j, round, shifts uint32 var k0, k1, kl, kr, rawkey0, rawkey1, t0, t1, v1 Tuint32_t _, _, _, _, _, _, _, _, _, _, _, _, _, _ = i, ibit, j, k0, k1, kl, kr, rawkey0, rawkey1, round, shifts, t0, t1, v1 - rawkey0 = uint32(*(*uint8)(unsafe.Pointer(key + 3))) | uint32(*(*uint8)(unsafe.Pointer(key + 2)))<>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskl)) + uintptr(i+uint32(4))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4))) - k1 = k1 | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j)*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) + k0 = k0 | (**(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_key_perm_maskl)) + uintptr(i)*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_key_perm_maskl)) + uintptr(i+uint32(4))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4))) + k1 = k1 | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j)*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) ibit = ibit - uint32(4) - k1 = k1 | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j+uint32(1))*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(i+uint32(8))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4))) + k1 = k1 | (**(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j+uint32(1))*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(i+uint32(8))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4))) goto _2 _2: ; @@ -11270,19 +11270,19 @@ func X__des_setkey(tls *TLS, key uintptr, ekey uintptr) { if !(i < uint32(4)) { break } - kl = kl | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskl0)) + uintptr(i)*32 + uintptr(t0>>ibit&uint32(7))*4)) - kr = kr | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskr0)) + uintptr(i)*32 + uintptr(t1>>ibit&uint32(7))*4)) + kl = kl | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_comp_maskl0)) + uintptr(i)*32 + uintptr(t0>>ibit&uint32(7))*4)) + kr = kr | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_comp_maskr0)) + uintptr(i)*32 + uintptr(t1>>ibit&uint32(7))*4)) ibit = ibit - uint32(4) - kl = kl | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskl1)) + uintptr(i)*64 + uintptr(t0>>ibit&uint32(0xf))*4)) - kr = kr | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskr1)) + uintptr(i)*64 + uintptr(t1>>ibit&uint32(0xf))*4)) + kl = kl | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_comp_maskl1)) + uintptr(i)*64 + uintptr(t0>>ibit&uint32(0xf))*4)) + kr = kr | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_comp_maskr1)) + uintptr(i)*64 + uintptr(t1>>ibit&uint32(0xf))*4)) ibit = ibit - uint32(3) goto _5 _5: ; i = i + 1 } - *(*Tuint32_t)(unsafe.Pointer(ekey + uintptr(round)*4)) = kl - *(*Tuint32_t)(unsafe.Pointer(ekey + 64 + uintptr(round)*4)) = kr + **(**Tuint32_t)(__ccgo_up(ekey + uintptr(round)*4)) = kl + **(**Tuint32_t)(__ccgo_up(ekey + 64 + uintptr(round)*4)) = kr goto _3 _3: ; @@ -11316,8 +11316,8 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui if !(i < uint32(8)) { break } - l = l | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4))) - r = r | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4))) + l = l | (**(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4))) + r = r | (**(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4))) goto _2 _2: ; @@ -11355,15 +11355,15 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui f = (r48l ^ r48r) & saltbits v5 = kl kl += 4 - r48l = r48l ^ (f ^ *(*Tuint32_t)(unsafe.Pointer(v5))) + r48l = r48l ^ (f ^ **(**Tuint32_t)(__ccgo_up(v5))) v5 = kr kr += 4 - r48r = r48r ^ (f ^ *(*Tuint32_t)(unsafe.Pointer(v5))) + r48r = r48r ^ (f ^ **(**Tuint32_t)(__ccgo_up(v5))) /* * Do S-box lookups (which shrink it back to 32 bits) * and do the P-box permutation at the same time. */ - f = *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + uintptr(r48l>>int32(18))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 1*256 + uintptr(r48l>>Int32FromInt32(12)&uint32(0x3f))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 2*256 + uintptr(r48l>>Int32FromInt32(6)&uint32(0x3f))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 3*256 + uintptr(r48l&uint32(0x3f))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 4*256 + uintptr(r48r>>int32(18))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 5*256 + uintptr(r48r>>Int32FromInt32(12)&uint32(0x3f))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 6*256 + uintptr(r48r>>Int32FromInt32(6)&uint32(0x3f))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 7*256 + uintptr(r48r&uint32(0x3f))*4)) + f = **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + uintptr(r48l>>int32(18))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 1*256 + uintptr(r48l>>Int32FromInt32(12)&uint32(0x3f))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 2*256 + uintptr(r48l>>Int32FromInt32(6)&uint32(0x3f))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 3*256 + uintptr(r48l&uint32(0x3f))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 4*256 + uintptr(r48r>>int32(18))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 5*256 + uintptr(r48r>>Int32FromInt32(12)&uint32(0x3f))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 6*256 + uintptr(r48r>>Int32FromInt32(6)&uint32(0x3f))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 7*256 + uintptr(r48r&uint32(0x3f))*4)) /* * Now that we've permuted things, complete f(). */ @@ -11386,17 +11386,17 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui if !(i1 < uint32(4)) { break } - ro = ro | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4))) + ro = ro | (**(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4))) ibit1 = ibit1 - uint32(4) - lo = lo | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4))) + lo = lo | (**(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4))) goto _8 _8: ; i1 = i1 + 1 ibit1 = ibit1 - uint32(4) } - *(*Tuint32_t)(unsafe.Pointer(l_out)) = lo - *(*Tuint32_t)(unsafe.Pointer(r_out)) = ro + **(**Tuint32_t)(__ccgo_up(l_out)) = lo + **(**Tuint32_t)(__ccgo_up(r_out)) = ro } func _des_cipher(tls *TLS, in uintptr, out uintptr, count Tuint32_t, saltbits Tuint32_t, ekey uintptr) { @@ -11406,17 +11406,17 @@ func _des_cipher(tls *TLS, in uintptr, out uintptr, count Tuint32_t, saltbits Tu var _ /* l_out at bp+0 */ Tuint32_t var _ /* r_out at bp+4 */ Tuint32_t _, _ = rawl, rawr - rawl = uint32(*(*uint8)(unsafe.Pointer(in + 3))) | uint32(*(*uint8)(unsafe.Pointer(in + 2)))<> int32(24)) - *(*uint8)(unsafe.Pointer(out + 1)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp)) >> int32(16)) - *(*uint8)(unsafe.Pointer(out + 2)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp)) >> int32(8)) - *(*uint8)(unsafe.Pointer(out + 3)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp))) - *(*uint8)(unsafe.Pointer(out + 4)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp + 4)) >> int32(24)) - *(*uint8)(unsafe.Pointer(out + 5)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp + 4)) >> int32(16)) - *(*uint8)(unsafe.Pointer(out + 6)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp + 4)) >> int32(8)) - *(*uint8)(unsafe.Pointer(out + 7)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp + 4))) + **(**uint8)(__ccgo_up(out)) = uint8(**(**Tuint32_t)(__ccgo_up(bp)) >> int32(24)) + **(**uint8)(__ccgo_up(out + 1)) = uint8(**(**Tuint32_t)(__ccgo_up(bp)) >> int32(16)) + **(**uint8)(__ccgo_up(out + 2)) = uint8(**(**Tuint32_t)(__ccgo_up(bp)) >> int32(8)) + **(**uint8)(__ccgo_up(out + 3)) = uint8(**(**Tuint32_t)(__ccgo_up(bp))) + **(**uint8)(__ccgo_up(out + 4)) = uint8(**(**Tuint32_t)(__ccgo_up(bp + 4)) >> int32(24)) + **(**uint8)(__ccgo_up(out + 5)) = uint8(**(**Tuint32_t)(__ccgo_up(bp + 4)) >> int32(16)) + **(**uint8)(__ccgo_up(out + 6)) = uint8(**(**Tuint32_t)(__ccgo_up(bp + 4)) >> int32(8)) + **(**uint8)(__ccgo_up(out + 7)) = uint8(**(**Tuint32_t)(__ccgo_up(bp + 4))) } func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uintptr) (r uintptr) { @@ -11440,13 +11440,13 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin for q <= bp+128+uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) { v1 = q q = q + 1 - *(*uint8)(unsafe.Pointer(v1)) = Uint8FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(key))) << int32(1)) - if *(*uint8)(unsafe.Pointer(key)) != 0 { + **(**uint8)(__ccgo_up(v1)) = Uint8FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(key))) << int32(1)) + if **(**uint8)(__ccgo_up(key)) != 0 { key = key + 1 } } X__des_setkey(tls, bp+128, bp) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(setting))) == int32('_') { + if Int32FromUint8(**(**uint8)(__ccgo_up(setting))) == int32('_') { /* * "new"-style: * setting - underscore, 4 chars of count, 4 chars of salt @@ -11458,8 +11458,8 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin if !(i < uint32(5)) { break } - value = _ascii_to_bin(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(i))))) - if Int32FromUint8(_ascii64[value]) != Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(i)))) { + value = _ascii_to_bin(tls, Int32FromUint8(**(**uint8)(__ccgo_up(setting + uintptr(i))))) + if Int32FromUint8(_ascii64[value]) != Int32FromUint8(**(**uint8)(__ccgo_up(setting + uintptr(i)))) { return UintptrFromInt32(0) } count = count | value<<((i-uint32(1))*uint32(6)) @@ -11477,8 +11477,8 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin if !(i < uint32(9)) { break } - value1 = _ascii_to_bin(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(i))))) - if Int32FromUint8(_ascii64[value1]) != Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(i)))) { + value1 = _ascii_to_bin(tls, Int32FromUint8(**(**uint8)(__ccgo_up(setting + uintptr(i))))) + if Int32FromUint8(_ascii64[value1]) != Int32FromUint8(**(**uint8)(__ccgo_up(setting + uintptr(i)))) { return UintptrFromInt32(0) } salt = salt | value1<<((i-uint32(5))*uint32(6)) @@ -11487,7 +11487,7 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin ; i = i + 1 } - for *(*uint8)(unsafe.Pointer(key)) != 0 { + for **(**uint8)(__ccgo_up(key)) != 0 { /* * Encrypt the key with itself. */ @@ -11496,18 +11496,18 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin * And XOR with the next 8 characters of the key. */ q = bp + 128 - for q <= bp+128+uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) && *(*uint8)(unsafe.Pointer(key)) != 0 { + for q <= bp+128+uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) && **(**uint8)(__ccgo_up(key)) != 0 { v4 = q q = q + 1 v1 = v4 v5 = key key = key + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(int32(*(*uint8)(unsafe.Pointer(v1))) ^ Int32FromUint8(*(*uint8)(unsafe.Pointer(v5)))<> int32(8) + l = **(**Tuint32_t)(__ccgo_up(bp + 136)) >> int32(8) v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l&uint32(0x3f)] - l = *(*Tuint32_t)(unsafe.Pointer(bp + 136))<>Int32FromInt32(16)&uint32(0xffff) + **(**uint8)(__ccgo_up(v1)) = _ascii64[l&uint32(0x3f)] + l = **(**Tuint32_t)(__ccgo_up(bp + 136))<>Int32FromInt32(16)&uint32(0xffff) v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l&uint32(0x3f)] - l = *(*Tuint32_t)(unsafe.Pointer(bp + 140)) << int32(2) + **(**uint8)(__ccgo_up(v1)) = _ascii64[l&uint32(0x3f)] + l = **(**Tuint32_t)(__ccgo_up(bp + 140)) << int32(2) v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l&uint32(0x3f)] - *(*uint8)(unsafe.Pointer(p)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = _ascii64[l&uint32(0x3f)] + **(**uint8)(__ccgo_up(p)) = uint8(0) return output } @@ -11584,7 +11584,7 @@ func X__crypt_des(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uin test_key = __ccgo_ts + 72 test_setting = __ccgo_ts + 93 test_hash = __ccgo_ts + 103 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(setting))) != int32('_') { + if Int32FromUint8(**(**uint8)(__ccgo_up(setting))) != int32('_') { test_setting = __ccgo_ts + 124 test_hash = __ccgo_ts + 127 } @@ -11603,7 +11603,7 @@ func X__crypt_des(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uin if p != 0 && !(Xstrcmp(tls, p, test_hash) != 0) && retval != 0 { return retval } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(setting))) == int32('*') { + if Int32FromUint8(**(**uint8)(__ccgo_up(setting))) == int32('*') { v1 = __ccgo_ts + 141 } else { v1 = __ccgo_ts + 70 @@ -11704,80 +11704,80 @@ func _processblock(tls *TLS, s uintptr, buf uintptr) { if !(i < uint32(16)) { break } - (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] = uint32(*(*Tuint8_t)(unsafe.Pointer(buf + uintptr(uint32(4)*i)))) - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(i)*4)) |= uint32(*(*Tuint8_t)(unsafe.Pointer(buf + uintptr(uint32(4)*i+uint32(1))))) << int32(8) - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(i)*4)) |= uint32(*(*Tuint8_t)(unsafe.Pointer(buf + uintptr(uint32(4)*i+uint32(2))))) << int32(16) - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(i)*4)) |= uint32(*(*Tuint8_t)(unsafe.Pointer(buf + uintptr(uint32(4)*i+uint32(3))))) << int32(24) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[i] = uint32(**(**Tuint8_t)(__ccgo_up(buf + uintptr(uint32(4)*i)))) + **(**Tuint32_t)(__ccgo_up(bp + uintptr(i)*4)) |= uint32(**(**Tuint8_t)(__ccgo_up(buf + uintptr(uint32(4)*i+uint32(1))))) << int32(8) + **(**Tuint32_t)(__ccgo_up(bp + uintptr(i)*4)) |= uint32(**(**Tuint8_t)(__ccgo_up(buf + uintptr(uint32(4)*i+uint32(2))))) << int32(16) + **(**Tuint32_t)(__ccgo_up(bp + uintptr(i)*4)) |= uint32(**(**Tuint8_t)(__ccgo_up(buf + uintptr(uint32(4)*i+uint32(3))))) << int32(24) goto _1 _1: ; i = i + 1 } - a = *(*Tuint32_t)(unsafe.Pointer(s + 8)) - b = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) - c = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 2*4)) - d = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) + a = **(**Tuint32_t)(__ccgo_up(s + 8)) + b = **(**Tuint32_t)(__ccgo_up(s + 8 + 1*4)) + c = **(**Tuint32_t)(__ccgo_up(s + 8 + 2*4)) + d = **(**Tuint32_t)(__ccgo_up(s + 8 + 3*4)) i = uint32(0) for i < uint32(16) { - a = a + (d ^ b&(c^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) + a = a + (d ^ b&(c^d) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[i] + _tab[i]) a = _rol(tls, a, int32(7)) + b i = i + 1 - d = d + (c ^ a&(b^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) + d = d + (c ^ a&(b^c) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[i] + _tab[i]) d = _rol(tls, d, int32(12)) + a i = i + 1 - c = c + (b ^ d&(a^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) + c = c + (b ^ d&(a^b) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[i] + _tab[i]) c = _rol(tls, c, int32(17)) + d i = i + 1 - b = b + (a ^ c&(d^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) + b = b + (a ^ c&(d^a) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[i] + _tab[i]) b = _rol(tls, b, int32(22)) + c i = i + 1 } for i < uint32(32) { - a = a + (c ^ d&(c^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) + a = a + (c ^ d&(c^b) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) a = _rol(tls, a, int32(5)) + b i = i + 1 - d = d + (b ^ c&(b^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) + d = d + (b ^ c&(b^a) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) d = _rol(tls, d, int32(9)) + a i = i + 1 - c = c + (a ^ b&(a^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) + c = c + (a ^ b&(a^d) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) c = _rol(tls, c, int32(14)) + d i = i + 1 - b = b + (d ^ a&(d^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) + b = b + (d ^ a&(d^c) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) b = _rol(tls, b, int32(20)) + c i = i + 1 } for i < uint32(48) { - a = a + (b ^ c ^ d + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) + a = a + (b ^ c ^ d + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) a = _rol(tls, a, int32(4)) + b i = i + 1 - d = d + (a ^ b ^ c + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) + d = d + (a ^ b ^ c + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) d = _rol(tls, d, int32(11)) + a i = i + 1 - c = c + (d ^ a ^ b + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) + c = c + (d ^ a ^ b + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) c = _rol(tls, c, int32(16)) + d i = i + 1 - b = b + (c ^ d ^ a + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) + b = b + (c ^ d ^ a + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) b = _rol(tls, b, int32(23)) + c i = i + 1 } for i < uint32(64) { - a = a + (c ^ (b | ^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) + a = a + (c ^ (b | ^d) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) a = _rol(tls, a, int32(6)) + b i = i + 1 - d = d + (b ^ (a | ^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) + d = d + (b ^ (a | ^c) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) d = _rol(tls, d, int32(10)) + a i = i + 1 - c = c + (a ^ (d | ^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) + c = c + (a ^ (d | ^b) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) c = _rol(tls, c, int32(15)) + d i = i + 1 - b = b + (d ^ (c | ^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) + b = b + (d ^ (c | ^a) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) b = _rol(tls, b, int32(21)) + c i = i + 1 } - *(*Tuint32_t)(unsafe.Pointer(s + 8)) += a - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) += b - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 2*4)) += c - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) += d + **(**Tuint32_t)(__ccgo_up(s + 8)) += a + **(**Tuint32_t)(__ccgo_up(s + 8 + 1*4)) += b + **(**Tuint32_t)(__ccgo_up(s + 8 + 2*4)) += c + **(**Tuint32_t)(__ccgo_up(s + 8 + 3*4)) += d } func _pad(tls *TLS, s uintptr) { @@ -11786,31 +11786,31 @@ func _pad(tls *TLS, s uintptr) { r = uint32((*Tmd5)(unsafe.Pointer(s)).Flen1 % uint64(64)) v1 = r r = r + 1 - *(*Tuint8_t)(unsafe.Pointer(s + 24 + uintptr(v1))) = uint8(0x80) + **(**Tuint8_t)(__ccgo_up(s + 24 + uintptr(v1))) = uint8(0x80) if r > uint32(56) { Xmemset(tls, s+24+uintptr(r), 0, uint64(uint32(64)-r)) r = uint32(0) _processblock(tls, s, s+24) } Xmemset(tls, s+24+uintptr(r), 0, uint64(uint32(56)-r)) - *(*Tuint64_t)(unsafe.Pointer(s)) *= uint64(8) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 56)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 57)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(8)) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 58)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(16)) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 59)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(24)) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 60)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(32)) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 61)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(40)) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 62)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(48)) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 63)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(56)) + **(**Tuint64_t)(__ccgo_up(s)) *= uint64(8) + **(**Tuint8_t)(__ccgo_up(s + 24 + 56)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1) + **(**Tuint8_t)(__ccgo_up(s + 24 + 57)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(8)) + **(**Tuint8_t)(__ccgo_up(s + 24 + 58)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(16)) + **(**Tuint8_t)(__ccgo_up(s + 24 + 59)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(24)) + **(**Tuint8_t)(__ccgo_up(s + 24 + 60)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(32)) + **(**Tuint8_t)(__ccgo_up(s + 24 + 61)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(40)) + **(**Tuint8_t)(__ccgo_up(s + 24 + 62)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(48)) + **(**Tuint8_t)(__ccgo_up(s + 24 + 63)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(56)) _processblock(tls, s, s+24) } func _md5_init(tls *TLS, s uintptr) { (*Tmd5)(unsafe.Pointer(s)).Flen1 = uint64(0) - *(*Tuint32_t)(unsafe.Pointer(s + 8)) = uint32(0x67452301) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) = uint32(0xefcdab89) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 2*4)) = uint32(0x98badcfe) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) = uint32(0x10325476) + **(**Tuint32_t)(__ccgo_up(s + 8)) = uint32(0x67452301) + **(**Tuint32_t)(__ccgo_up(s + 8 + 1*4)) = uint32(0xefcdab89) + **(**Tuint32_t)(__ccgo_up(s + 8 + 2*4)) = uint32(0x98badcfe) + **(**Tuint32_t)(__ccgo_up(s + 8 + 3*4)) = uint32(0x10325476) } func _md5_sum(tls *TLS, s uintptr, md uintptr) { @@ -11822,10 +11822,10 @@ func _md5_sum(tls *TLS, s uintptr, md uintptr) { if !(i < int32(4)) { break } - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4))) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i+int32(1)))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4)) >> int32(8)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i+int32(2)))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4)) >> int32(16)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i+int32(3)))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4)) >> int32(24)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4))) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i+int32(1)))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4)) >> int32(8)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i+int32(2)))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4)) >> int32(16)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i+int32(3)))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4)) >> int32(24)) goto _1 _1: ; @@ -11839,7 +11839,7 @@ func _md5_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { _, _ = p, r p = m r = uint32((*Tmd5)(unsafe.Pointer(s)).Flen1 % uint64(64)) - *(*Tuint64_t)(unsafe.Pointer(s)) += len1 + **(**Tuint64_t)(__ccgo_up(s)) += len1 if r != 0 { if len1 < uint64(uint32(64)-r) { Xmemcpy(tls, s+24+uintptr(r), p, len1) @@ -11906,7 +11906,7 @@ func _to64(tls *TLS, s uintptr, u uint32, n int32) (r uintptr) { } v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = _b64[u%uint32(64)] + **(**uint8)(__ccgo_up(v2)) = _b64[u%uint32(64)] u = u / uint32(64) } return s @@ -11932,7 +11932,7 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt salt = setting + uintptr(3) i = uint32(0) for { - if !(i < uint32(SALT_MAX) && *(*uint8)(unsafe.Pointer(salt + uintptr(i))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(salt + uintptr(i)))) != int32('$')) { + if !(i < uint32(SALT_MAX) && **(**uint8)(__ccgo_up(salt + uintptr(i))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(salt + uintptr(i)))) != int32('$')) { break } goto _1 @@ -11963,7 +11963,7 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt i = uint32(uint64(i) - Uint64FromInt64(16)) } _md5_update(tls, bp, bp+88, uint64(i)) - (*(*[16]uint8)(unsafe.Pointer(bp + 88)))[0] = uint8(0) + (**(**[16]uint8)(__ccgo_up(bp + 88)))[0] = uint8(0) i = klen for { if !(i != 0) { @@ -12014,20 +12014,20 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt p = output + uintptr(3) + uintptr(slen) v5 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v5)) = uint8('$') + **(**uint8)(__ccgo_up(v5)) = uint8('$') i = uint32(0) for { if !(i < uint32(5)) { break } - p = _to64(tls, p, Uint32FromInt32(Int32FromUint8((*(*[16]uint8)(unsafe.Pointer(bp + 88)))[*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_perm)) + uintptr(i)*3))])<>Int32FromInt32(10) + (*(*[64]Tuint32_t)(unsafe.Pointer(bp)))[i-int32(7)] + (_ror(tls, (*(*[64]Tuint32_t)(unsafe.Pointer(bp)))[i-int32(15)], int32(7)) ^ _ror(tls, (*(*[64]Tuint32_t)(unsafe.Pointer(bp)))[i-int32(15)], int32(18)) ^ (*(*[64]Tuint32_t)(unsafe.Pointer(bp)))[i-int32(15)]>>Int32FromInt32(3)) + (*(*[64]Tuint32_t)(unsafe.Pointer(bp)))[i-int32(16)] + (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i] = _ror(tls, (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(2)], int32(17)) ^ _ror(tls, (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(2)], int32(19)) ^ (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(2)]>>Int32FromInt32(10) + (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(7)] + (_ror(tls, (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(15)], int32(7)) ^ _ror(tls, (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(15)], int32(18)) ^ (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(15)]>>Int32FromInt32(3)) + (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(16)] goto _2 _2: ; i = i + 1 } - a = *(*Tuint32_t)(unsafe.Pointer(s + 8)) - b = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) - c = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 2*4)) - d = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) - e = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 4*4)) - f = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 5*4)) - g = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 6*4)) - h = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 7*4)) + a = **(**Tuint32_t)(__ccgo_up(s + 8)) + b = **(**Tuint32_t)(__ccgo_up(s + 8 + 1*4)) + c = **(**Tuint32_t)(__ccgo_up(s + 8 + 2*4)) + d = **(**Tuint32_t)(__ccgo_up(s + 8 + 3*4)) + e = **(**Tuint32_t)(__ccgo_up(s + 8 + 4*4)) + f = **(**Tuint32_t)(__ccgo_up(s + 8 + 5*4)) + g = **(**Tuint32_t)(__ccgo_up(s + 8 + 6*4)) + h = **(**Tuint32_t)(__ccgo_up(s + 8 + 7*4)) i = 0 for { if !(i < int32(64)) { break } - t1 = h + (_ror(tls, e, int32(6)) ^ _ror(tls, e, int32(11)) ^ _ror(tls, e, int32(25))) + (g ^ e&(f^g)) + _K[i] + (*(*[64]Tuint32_t)(unsafe.Pointer(bp)))[i] + t1 = h + (_ror(tls, e, int32(6)) ^ _ror(tls, e, int32(11)) ^ _ror(tls, e, int32(25))) + (g ^ e&(f^g)) + _K[i] + (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i] t2 = _ror(tls, a, int32(2)) ^ _ror(tls, a, int32(13)) ^ _ror(tls, a, int32(22)) + (a&b | c&(a|b)) h = g g = f @@ -12264,14 +12264,14 @@ func _processblock1(tls *TLS, s uintptr, buf uintptr) { ; i = i + 1 } - *(*Tuint32_t)(unsafe.Pointer(s + 8)) += a - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) += b - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 2*4)) += c - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) += d - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 4*4)) += e - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 5*4)) += f - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 6*4)) += g - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 7*4)) += h + **(**Tuint32_t)(__ccgo_up(s + 8)) += a + **(**Tuint32_t)(__ccgo_up(s + 8 + 1*4)) += b + **(**Tuint32_t)(__ccgo_up(s + 8 + 2*4)) += c + **(**Tuint32_t)(__ccgo_up(s + 8 + 3*4)) += d + **(**Tuint32_t)(__ccgo_up(s + 8 + 4*4)) += e + **(**Tuint32_t)(__ccgo_up(s + 8 + 5*4)) += f + **(**Tuint32_t)(__ccgo_up(s + 8 + 6*4)) += g + **(**Tuint32_t)(__ccgo_up(s + 8 + 7*4)) += h } func _pad1(tls *TLS, s uintptr) { @@ -12280,35 +12280,35 @@ func _pad1(tls *TLS, s uintptr) { r = uint32((*Tsha256)(unsafe.Pointer(s)).Flen1 % uint64(64)) v1 = r r = r + 1 - *(*Tuint8_t)(unsafe.Pointer(s + 40 + uintptr(v1))) = uint8(0x80) + **(**Tuint8_t)(__ccgo_up(s + 40 + uintptr(v1))) = uint8(0x80) if r > uint32(56) { Xmemset(tls, s+40+uintptr(r), 0, uint64(uint32(64)-r)) r = uint32(0) _processblock1(tls, s, s+40) } Xmemset(tls, s+40+uintptr(r), 0, uint64(uint32(56)-r)) - *(*Tuint64_t)(unsafe.Pointer(s)) *= uint64(8) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 56)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(56)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 57)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(48)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 58)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(40)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 59)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(32)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 60)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(24)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 61)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(16)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 62)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(8)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 63)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1) + **(**Tuint64_t)(__ccgo_up(s)) *= uint64(8) + **(**Tuint8_t)(__ccgo_up(s + 40 + 56)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(56)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 57)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(48)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 58)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(40)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 59)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(32)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 60)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(24)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 61)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(16)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 62)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(8)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 63)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1) _processblock1(tls, s, s+40) } func _sha256_init(tls *TLS, s uintptr) { (*Tsha256)(unsafe.Pointer(s)).Flen1 = uint64(0) - *(*Tuint32_t)(unsafe.Pointer(s + 8)) = uint32(0x6a09e667) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) = uint32(0xbb67ae85) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 2*4)) = uint32(0x3c6ef372) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) = uint32(0xa54ff53a) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 4*4)) = uint32(0x510e527f) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 5*4)) = uint32(0x9b05688c) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 6*4)) = uint32(0x1f83d9ab) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 7*4)) = uint32(0x5be0cd19) + **(**Tuint32_t)(__ccgo_up(s + 8)) = uint32(0x6a09e667) + **(**Tuint32_t)(__ccgo_up(s + 8 + 1*4)) = uint32(0xbb67ae85) + **(**Tuint32_t)(__ccgo_up(s + 8 + 2*4)) = uint32(0x3c6ef372) + **(**Tuint32_t)(__ccgo_up(s + 8 + 3*4)) = uint32(0xa54ff53a) + **(**Tuint32_t)(__ccgo_up(s + 8 + 4*4)) = uint32(0x510e527f) + **(**Tuint32_t)(__ccgo_up(s + 8 + 5*4)) = uint32(0x9b05688c) + **(**Tuint32_t)(__ccgo_up(s + 8 + 6*4)) = uint32(0x1f83d9ab) + **(**Tuint32_t)(__ccgo_up(s + 8 + 7*4)) = uint32(0x5be0cd19) } func _sha256_sum(tls *TLS, s uintptr, md uintptr) { @@ -12320,10 +12320,10 @@ func _sha256_sum(tls *TLS, s uintptr, md uintptr) { if !(i < int32(8)) { break } - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4)) >> int32(24)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i+int32(1)))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4)) >> int32(16)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i+int32(2)))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4)) >> int32(8)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i+int32(3)))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4))) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4)) >> int32(24)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i+int32(1)))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4)) >> int32(16)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i+int32(2)))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4)) >> int32(8)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i+int32(3)))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4))) goto _1 _1: ; @@ -12337,7 +12337,7 @@ func _sha256_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { _, _ = p, r p = m r = uint32((*Tsha256)(unsafe.Pointer(s)).Flen1 % uint64(64)) - *(*Tuint64_t)(unsafe.Pointer(s)) += len1 + **(**Tuint64_t)(__ccgo_up(s)) += len1 if r != 0 { if len1 < uint64(uint32(64)-r) { Xmemcpy(tls, s+40+uintptr(r), p, len1) @@ -12376,7 +12376,7 @@ func _to641(tls *TLS, s uintptr, u uint32, n int32) (r uintptr) { } v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = _b641[u%uint32(64)] + **(**uint8)(__ccgo_up(v2)) = _b641[u%uint32(64)] u = u / uint32(64) } return s @@ -12419,7 +12419,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui var _ /* rounds at bp+200 */ [20]uint8 var _ /* smd at bp+168 */ [32]uint8 _, _, _, _, _, _, _ = i, klen, p, r, salt, slen, u - *(*[20]uint8)(unsafe.Pointer(bp + 200)) = [20]uint8{} + **(**[20]uint8)(__ccgo_up(bp + 200)) = [20]uint8{} /* reject large keys */ klen = uint32(Xstrnlen(tls, key, Uint64FromInt32(Int32FromInt32(KEY_MAX1)+Int32FromInt32(1)))) if klen > uint32(KEY_MAX1) { @@ -12445,14 +12445,14 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui * the host's value of ULONG_MAX. */ salt = salt + uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(salt)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(salt)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } u = Xstrtoul(tls, salt, bp+224, int32(10)) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 224))))) != int32('$') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 224))))) != int32('$') { return uintptr(0) } - salt = *(*uintptr)(unsafe.Pointer(bp + 224)) + uintptr(1) + salt = **(**uintptr)(__ccgo_up(bp + 224)) + uintptr(1) if u < uint64(ROUNDS_MIN) { r = uint32(ROUNDS_MIN) } else { @@ -12467,11 +12467,11 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui } i = uint32(0) for { - if !(i < uint32(SALT_MAX1) && *(*uint8)(unsafe.Pointer(salt + uintptr(i))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(salt + uintptr(i)))) != int32('$')) { + if !(i < uint32(SALT_MAX1) && **(**uint8)(__ccgo_up(salt + uintptr(i))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(salt + uintptr(i)))) != int32('$')) { break } /* reject characters that interfere with /etc/shadow parsing */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(salt + uintptr(i)))) == int32('\n') || Int32FromUint8(*(*uint8)(unsafe.Pointer(salt + uintptr(i)))) == int32(':') { + if Int32FromUint8(**(**uint8)(__ccgo_up(salt + uintptr(i)))) == int32('\n') || Int32FromUint8(**(**uint8)(__ccgo_up(salt + uintptr(i)))) == int32(':') { return uintptr(0) } goto _1 @@ -12525,7 +12525,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui _sha256_init(tls, bp) i = uint32(0) for { - if !(i < Uint32FromInt32(int32(16)+Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp + 104)))[0]))) { + if !(i < Uint32FromInt32(int32(16)+Int32FromUint8((**(**[32]uint8)(__ccgo_up(bp + 104)))[0]))) { break } _sha256_update(tls, bp, salt, uint64(slen)) @@ -12572,14 +12572,14 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui if !(i < uint32(10)) { break } - p = _to641(tls, p, Uint32FromInt32(Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp + 104)))[*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_perm1)) + uintptr(i)*3))])<>Int32FromInt32(6) + (*(*[80]Tuint64_t)(unsafe.Pointer(bp)))[i-int32(7)] + (_ror1(tls, (*(*[80]Tuint64_t)(unsafe.Pointer(bp)))[i-int32(15)], int32(1)) ^ _ror1(tls, (*(*[80]Tuint64_t)(unsafe.Pointer(bp)))[i-int32(15)], int32(8)) ^ (*(*[80]Tuint64_t)(unsafe.Pointer(bp)))[i-int32(15)]>>Int32FromInt32(7)) + (*(*[80]Tuint64_t)(unsafe.Pointer(bp)))[i-int32(16)] + (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i] = _ror1(tls, (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(2)], int32(19)) ^ _ror1(tls, (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(2)], int32(61)) ^ (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(2)]>>Int32FromInt32(6) + (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(7)] + (_ror1(tls, (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(15)], int32(1)) ^ _ror1(tls, (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(15)], int32(8)) ^ (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(15)]>>Int32FromInt32(7)) + (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(16)] goto _2 _2: ; i = i + 1 } - a = *(*Tuint64_t)(unsafe.Pointer(s + 8)) - b = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 1*8)) - c = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 2*8)) - d = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 3*8)) - e = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 4*8)) - f = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 5*8)) - g = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 6*8)) - h = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 7*8)) + a = **(**Tuint64_t)(__ccgo_up(s + 8)) + b = **(**Tuint64_t)(__ccgo_up(s + 8 + 1*8)) + c = **(**Tuint64_t)(__ccgo_up(s + 8 + 2*8)) + d = **(**Tuint64_t)(__ccgo_up(s + 8 + 3*8)) + e = **(**Tuint64_t)(__ccgo_up(s + 8 + 4*8)) + f = **(**Tuint64_t)(__ccgo_up(s + 8 + 5*8)) + g = **(**Tuint64_t)(__ccgo_up(s + 8 + 6*8)) + h = **(**Tuint64_t)(__ccgo_up(s + 8 + 7*8)) i = 0 for { if !(i < int32(80)) { break } - t1 = h + (_ror1(tls, e, int32(14)) ^ _ror1(tls, e, int32(18)) ^ _ror1(tls, e, int32(41))) + (g ^ e&(f^g)) + _K1[i] + (*(*[80]Tuint64_t)(unsafe.Pointer(bp)))[i] + t1 = h + (_ror1(tls, e, int32(14)) ^ _ror1(tls, e, int32(18)) ^ _ror1(tls, e, int32(41))) + (g ^ e&(f^g)) + _K1[i] + (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i] t2 = _ror1(tls, a, int32(28)) ^ _ror1(tls, a, int32(34)) ^ _ror1(tls, a, int32(39)) + (a&b | c&(a|b)) h = g g = f @@ -12819,14 +12819,14 @@ func _processblock2(tls *TLS, s uintptr, buf uintptr) { ; i = i + 1 } - *(*Tuint64_t)(unsafe.Pointer(s + 8)) += a - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 1*8)) += b - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 2*8)) += c - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 3*8)) += d - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 4*8)) += e - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 5*8)) += f - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 6*8)) += g - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 7*8)) += h + **(**Tuint64_t)(__ccgo_up(s + 8)) += a + **(**Tuint64_t)(__ccgo_up(s + 8 + 1*8)) += b + **(**Tuint64_t)(__ccgo_up(s + 8 + 2*8)) += c + **(**Tuint64_t)(__ccgo_up(s + 8 + 3*8)) += d + **(**Tuint64_t)(__ccgo_up(s + 8 + 4*8)) += e + **(**Tuint64_t)(__ccgo_up(s + 8 + 5*8)) += f + **(**Tuint64_t)(__ccgo_up(s + 8 + 6*8)) += g + **(**Tuint64_t)(__ccgo_up(s + 8 + 7*8)) += h } func _pad2(tls *TLS, s uintptr) { @@ -12835,35 +12835,35 @@ func _pad2(tls *TLS, s uintptr) { r = uint32((*Tsha512)(unsafe.Pointer(s)).Flen1 % uint64(128)) v1 = r r = r + 1 - *(*Tuint8_t)(unsafe.Pointer(s + 72 + uintptr(v1))) = uint8(0x80) + **(**Tuint8_t)(__ccgo_up(s + 72 + uintptr(v1))) = uint8(0x80) if r > uint32(112) { Xmemset(tls, s+72+uintptr(r), 0, uint64(uint32(128)-r)) r = uint32(0) _processblock2(tls, s, s+72) } Xmemset(tls, s+72+uintptr(r), 0, uint64(uint32(120)-r)) - *(*Tuint64_t)(unsafe.Pointer(s)) *= uint64(8) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 120)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(56)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 121)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(48)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 122)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(40)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 123)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(32)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 124)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(24)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 125)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(16)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 126)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(8)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 127)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1) + **(**Tuint64_t)(__ccgo_up(s)) *= uint64(8) + **(**Tuint8_t)(__ccgo_up(s + 72 + 120)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(56)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 121)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(48)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 122)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(40)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 123)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(32)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 124)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(24)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 125)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(16)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 126)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(8)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 127)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1) _processblock2(tls, s, s+72) } func _sha512_init(tls *TLS, s uintptr) { (*Tsha512)(unsafe.Pointer(s)).Flen1 = uint64(0) - *(*Tuint64_t)(unsafe.Pointer(s + 8)) = uint64(0x6a09e667f3bcc908) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 1*8)) = uint64(0xbb67ae8584caa73b) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 2*8)) = uint64(0x3c6ef372fe94f82b) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 3*8)) = uint64(0xa54ff53a5f1d36f1) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 4*8)) = uint64(0x510e527fade682d1) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 5*8)) = uint64(0x9b05688c2b3e6c1f) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 6*8)) = uint64(0x1f83d9abfb41bd6b) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 7*8)) = uint64(0x5be0cd19137e2179) + **(**Tuint64_t)(__ccgo_up(s + 8)) = uint64(0x6a09e667f3bcc908) + **(**Tuint64_t)(__ccgo_up(s + 8 + 1*8)) = uint64(0xbb67ae8584caa73b) + **(**Tuint64_t)(__ccgo_up(s + 8 + 2*8)) = uint64(0x3c6ef372fe94f82b) + **(**Tuint64_t)(__ccgo_up(s + 8 + 3*8)) = uint64(0xa54ff53a5f1d36f1) + **(**Tuint64_t)(__ccgo_up(s + 8 + 4*8)) = uint64(0x510e527fade682d1) + **(**Tuint64_t)(__ccgo_up(s + 8 + 5*8)) = uint64(0x9b05688c2b3e6c1f) + **(**Tuint64_t)(__ccgo_up(s + 8 + 6*8)) = uint64(0x1f83d9abfb41bd6b) + **(**Tuint64_t)(__ccgo_up(s + 8 + 7*8)) = uint64(0x5be0cd19137e2179) } func _sha512_sum(tls *TLS, s uintptr, md uintptr) { @@ -12875,14 +12875,14 @@ func _sha512_sum(tls *TLS, s uintptr, md uintptr) { if !(i < int32(8)) { break } - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(56)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(1)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(48)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(2)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(40)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(3)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(32)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(4)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(24)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(5)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(16)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(6)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(8)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(7)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8))) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(56)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(1)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(48)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(2)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(40)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(3)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(32)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(4)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(24)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(5)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(16)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(6)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(8)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(7)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8))) goto _1 _1: ; @@ -12896,7 +12896,7 @@ func _sha512_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { _, _ = p, r p = m r = uint32((*Tsha512)(unsafe.Pointer(s)).Flen1 % uint64(128)) - *(*Tuint64_t)(unsafe.Pointer(s)) += len1 + **(**Tuint64_t)(__ccgo_up(s)) += len1 if r != 0 { if len1 < uint64(uint32(128)-r) { Xmemcpy(tls, s+72+uintptr(r), p, len1) @@ -12935,7 +12935,7 @@ func _to642(tls *TLS, s uintptr, u uint32, n int32) (r uintptr) { } v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = _b642[u%uint32(64)] + **(**uint8)(__ccgo_up(v2)) = _b642[u%uint32(64)] u = u / uint32(64) } return s @@ -12978,11 +12978,11 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui var _ /* rounds at bp+392 */ [20]uint8 var _ /* smd at bp+328 */ [64]uint8 _, _, _, _, _, _, _ = i, klen, p, r, salt, slen, u - *(*[20]uint8)(unsafe.Pointer(bp + 392)) = [20]uint8{} + **(**[20]uint8)(__ccgo_up(bp + 392)) = [20]uint8{} /* reject large keys */ i = uint32(0) for { - if !(i <= uint32(KEY_MAX1) && *(*uint8)(unsafe.Pointer(key + uintptr(i))) != 0) { + if !(i <= uint32(KEY_MAX1) && **(**uint8)(__ccgo_up(key + uintptr(i))) != 0) { break } goto _1 @@ -13014,14 +13014,14 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui * the host's value of ULONG_MAX. */ salt = salt + uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(salt)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(salt)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } u = Xstrtoul(tls, salt, bp+416, int32(10)) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 416))))) != int32('$') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 416))))) != int32('$') { return uintptr(0) } - salt = *(*uintptr)(unsafe.Pointer(bp + 416)) + uintptr(1) + salt = **(**uintptr)(__ccgo_up(bp + 416)) + uintptr(1) if u < uint64(ROUNDS_MIN) { r = uint32(ROUNDS_MIN) } else { @@ -13036,11 +13036,11 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui } i = uint32(0) for { - if !(i < uint32(SALT_MAX1) && *(*uint8)(unsafe.Pointer(salt + uintptr(i))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(salt + uintptr(i)))) != int32('$')) { + if !(i < uint32(SALT_MAX1) && **(**uint8)(__ccgo_up(salt + uintptr(i))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(salt + uintptr(i)))) != int32('$')) { break } /* reject characters that interfere with /etc/shadow parsing */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(salt + uintptr(i)))) == int32('\n') || Int32FromUint8(*(*uint8)(unsafe.Pointer(salt + uintptr(i)))) == int32(':') { + if Int32FromUint8(**(**uint8)(__ccgo_up(salt + uintptr(i)))) == int32('\n') || Int32FromUint8(**(**uint8)(__ccgo_up(salt + uintptr(i)))) == int32(':') { return uintptr(0) } goto _2 @@ -13094,7 +13094,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui _sha512_init(tls, bp) i = uint32(0) for { - if !(i < Uint32FromInt32(int32(16)+Int32FromUint8((*(*[64]uint8)(unsafe.Pointer(bp + 200)))[0]))) { + if !(i < Uint32FromInt32(int32(16)+Int32FromUint8((**(**[64]uint8)(__ccgo_up(bp + 200)))[0]))) { break } _sha512_update(tls, bp, salt, uint64(slen)) @@ -13141,14 +13141,14 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui if !(i < uint32(21)) { break } - p = _to642(tls, p, Uint32FromInt32(Int32FromUint8((*(*[64]uint8)(unsafe.Pointer(bp + 200)))[*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_perm2)) + uintptr(i)*3))])<= 0) { break } v3 = bp + uintptr(i) - *(*uint8)(unsafe.Pointer(v3)) = uint8(uint32(*(*uint8)(unsafe.Pointer(v3))) | Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(key)))&Int32FromInt32(1))<= 0) { break } - *(*Tuint32_t)(unsafe.Pointer(bp + 128 + uintptr(i)*4)) |= Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))&Int32FromInt32(1)) << j + **(**Tuint32_t)(__ccgo_up(bp + 128 + uintptr(i)*4)) |= Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(p)))&Int32FromInt32(1)) << j goto _2 _2: ; @@ -13366,15 +13366,15 @@ func Xencrypt(tls *TLS, block uintptr, edflag int32) { if !(i < int32(16)) { break } - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(i)*4)) = *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&___encrypt_key)) + uintptr(int32(15)-i)*4)) - *(*Tuint32_t)(unsafe.Pointer(bp + 64 + uintptr(i)*4)) = *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&___encrypt_key)) + 64 + uintptr(int32(15)-i)*4)) + **(**Tuint32_t)(__ccgo_up(bp + uintptr(i)*4)) = **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&___encrypt_key)) + uintptr(int32(15)-i)*4)) + **(**Tuint32_t)(__ccgo_up(bp + 64 + uintptr(i)*4)) = **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&___encrypt_key)) + 64 + uintptr(int32(15)-i)*4)) goto _3 _3: ; i = i + 1 } } - X__do_des(tls, (*(*[2]Tuint32_t)(unsafe.Pointer(bp + 128)))[0], (*(*[2]Tuint32_t)(unsafe.Pointer(bp + 128)))[int32(1)], bp+128, bp+128+uintptr(1)*4, uint32(1), uint32(0), key) + X__do_des(tls, (**(**[2]Tuint32_t)(__ccgo_up(bp + 128)))[0], (**(**[2]Tuint32_t)(__ccgo_up(bp + 128)))[int32(1)], bp+128, bp+128+uintptr(1)*4, uint32(1), uint32(0), key) p = block i = 0 for { @@ -13388,7 +13388,7 @@ func Xencrypt(tls *TLS, block uintptr, edflag int32) { } v6 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v6)) = uint8((*(*[2]Tuint32_t)(unsafe.Pointer(bp + 128)))[i] >> j & uint32(1)) + **(**uint8)(__ccgo_up(v6)) = uint8((**(**[2]Tuint32_t)(__ccgo_up(bp + 128)))[i] >> j & uint32(1)) goto _5 _5: ; @@ -13867,7 +13867,7 @@ func X__ctype_get_mb_cur_max(tls *TLS) (r Tsize_t) { } var v1 int32 _ = v1 - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v1 = int32(4) } else { v1 = int32(1) @@ -17431,10 +17431,10 @@ func Xwctype(tls *TLS, s uintptr) (r Twctype_t) { i = int32(1) p = uintptr(unsafe.Pointer(&_names)) for { - if !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if !(**(**uint8)(__ccgo_up(p)) != 0) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) && !(Xstrcmp(tls, s, p) != 0) { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == Int32FromUint8(**(**uint8)(__ccgo_up(p))) && !(Xstrcmp(tls, s, p) != 0) { return Uint64FromInt32(i) } goto _1 @@ -22180,9 +22180,9 @@ func _casemap(tls *TLS, c uint32, dir int32) (r1 int32) { xn = Uint32FromInt32(rd & int32(0xff)) xb = Uint32FromInt32(rd) >> int32(8) for xn != 0 { - try = uint32(*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_exceptions)) + uintptr(xb+xn/uint32(2))*2))) + try = uint32(**(**uint8)(__ccgo_up(uintptr(unsafe.Pointer(&_exceptions)) + uintptr(xb+xn/uint32(2))*2))) if try == c { - r = _rules[*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_exceptions)) + uintptr(xb+xn/uint32(2))*2 + 1))] + r = _rules[**(**uint8)(__ccgo_up(uintptr(unsafe.Pointer(&_exceptions)) + uintptr(xb+xn/uint32(2))*2 + 1))] rt = Uint32FromInt32(r & int32(255)) rd = r >> int32(8) if rt < uint32(2) { @@ -22275,8 +22275,8 @@ func Xwcswidth(tls *TLS, wcs uintptr, n Tsize_t) (r int32) { for { v2 = n n = n - 1 - if v4 = v2 != 0 && *(*Twchar_t)(unsafe.Pointer(wcs)) != 0; v4 { - v3 = Xwcwidth(tls, *(*Twchar_t)(unsafe.Pointer(wcs))) + if v4 = v2 != 0 && **(**Twchar_t)(__ccgo_up(wcs)) != 0; v4 { + v3 = Xwcwidth(tls, **(**Twchar_t)(__ccgo_up(wcs))) k = v3 } if !(v4 && v3 >= 0) { @@ -24476,7 +24476,7 @@ func Xalphasort(tls *TLS, a uintptr, b uintptr) (r int32) { trc("tls=%v a=%v b=%v, (%v:)", tls, a, b, origin(2)) defer func() { trc("-> %v", r) }() } - return Xstrcoll(tls, *(*uintptr)(unsafe.Pointer(a))+19, *(*uintptr)(unsafe.Pointer(b))+19) + return Xstrcoll(tls, **(**uintptr)(__ccgo_up(a))+19, **(**uintptr)(__ccgo_up(b))+19) } type TDIR = struct { @@ -24645,11 +24645,11 @@ func Xfdopendir(tls *TLS, fd int32) (r uintptr) { return uintptr(0) } if Xfcntl(tls, fd, int32(F_GETFL), 0)&int32(O_PATH) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EBADF) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EBADF) return uintptr(0) } - if !((*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&Uint32FromInt32(S_IFMT) == Uint32FromInt32(S_IFDIR)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOTDIR) + if !((**(**Tstat)(__ccgo_up(bp))).Fst_mode&Uint32FromInt32(S_IFMT) == Uint32FromInt32(S_IFDIR)) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOTDIR) return uintptr(0) } v1 = Xcalloc(tls, uint64(1), uint64(2072)) @@ -24784,7 +24784,7 @@ func Xreaddir(tls *TLS, dir uintptr) (r uintptr) { len1 = int32(X__syscall3(tls, int64(SYS_getdents64), int64((*TDIR)(unsafe.Pointer(dir)).Ffd), int64(dir+24), Int64FromUint64(Uint64FromInt64(2048)))) if len1 <= 0 { if len1 < 0 && len1 != -int32(ENOENT) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = -len1 + **(**int32)(__ccgo_up(X__errno_location(tls))) = -len1 } return uintptr(0) } @@ -24792,7 +24792,7 @@ func Xreaddir(tls *TLS, dir uintptr) (r uintptr) { (*TDIR)(unsafe.Pointer(dir)).Fbuf_pos = 0 } de = dir + 24 + uintptr((*TDIR)(unsafe.Pointer(dir)).Fbuf_pos) - *(*int32)(unsafe.Pointer(dir + 12)) += Int32FromUint16((*Tdirent)(unsafe.Pointer(de)).Fd_reclen) + **(**int32)(__ccgo_up(dir + 12)) += Int32FromUint16((*Tdirent)(unsafe.Pointer(de)).Fd_reclen) (*TDIR)(unsafe.Pointer(dir)).Ftell = (*Tdirent)(unsafe.Pointer(de)).Fd_off return de } @@ -24805,24 +24805,24 @@ func Xreaddir_r(tls *TLS, dir uintptr, buf uintptr, result uintptr) (r int32) { var de uintptr var errno_save, ret, v1 int32 _, _, _, _ = de, errno_save, ret, v1 - errno_save = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + errno_save = **(**int32)(__ccgo_up(X__errno_location(tls))) ___lock(tls, dir+20) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = 0 + **(**int32)(__ccgo_up(X__errno_location(tls))) = 0 de = Xreaddir(tls, dir) - v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = **(**int32)(__ccgo_up(X__errno_location(tls))) ret = v1 if v1 != 0 { ___unlock(tls, dir+20) return ret } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = errno_save + **(**int32)(__ccgo_up(X__errno_location(tls))) = errno_save if de != 0 { Xmemcpy(tls, buf, de, uint64((*Tdirent)(unsafe.Pointer(de)).Fd_reclen)) } else { buf = UintptrFromInt32(0) } ___unlock(tls, dir+20) - *(*uintptr)(unsafe.Pointer(result)) = buf + **(**uintptr)(__ccgo_up(result)) = buf return 0 } @@ -24858,12 +24858,12 @@ func Xscandir(tls *TLS, path uintptr, res uintptr, __ccgo_fp_sel uintptr, __ccgo names = uintptr(0) cnt = uint64(0) len1 = uint64(0) - old_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + old_errno = **(**int32)(__ccgo_up(X__errno_location(tls))) if !(d != 0) { return -int32(1) } for { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = 0 + **(**int32)(__ccgo_up(X__errno_location(tls))) = 0 v1 = Xreaddir(tls, d) de = v1 if !(v1 != 0) { @@ -24883,16 +24883,16 @@ func Xscandir(tls *TLS, path uintptr, res uintptr, __ccgo_fp_sel uintptr, __ccgo } names = tmp } - *(*uintptr)(unsafe.Pointer(names + uintptr(cnt)*8)) = Xmalloc(tls, uint64((*Tdirent)(unsafe.Pointer(de)).Fd_reclen)) - if !(*(*uintptr)(unsafe.Pointer(names + uintptr(cnt)*8)) != 0) { + **(**uintptr)(__ccgo_up(names + uintptr(cnt)*8)) = Xmalloc(tls, uint64((*Tdirent)(unsafe.Pointer(de)).Fd_reclen)) + if !(**(**uintptr)(__ccgo_up(names + uintptr(cnt)*8)) != 0) { break } v2 = cnt cnt = cnt + 1 - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(names + uintptr(v2)*8)), de, uint64((*Tdirent)(unsafe.Pointer(de)).Fd_reclen)) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(names + uintptr(v2)*8)), de, uint64((*Tdirent)(unsafe.Pointer(de)).Fd_reclen)) } Xclosedir(tls, d) - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != 0 { + if **(**int32)(__ccgo_up(X__errno_location(tls))) != 0 { if names != 0 { for { v2 = cnt @@ -24900,17 +24900,17 @@ func Xscandir(tls *TLS, path uintptr, res uintptr, __ccgo_fp_sel uintptr, __ccgo if !(v2 > uint64(0)) { break } - Xfree(tls, *(*uintptr)(unsafe.Pointer(names + uintptr(cnt)*8))) + Xfree(tls, **(**uintptr)(__ccgo_up(names + uintptr(cnt)*8))) } } Xfree(tls, names) return -int32(1) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = old_errno + **(**int32)(__ccgo_up(X__errno_location(tls))) = old_errno if __ccgo_fp_cmp != 0 { Xqsort(tls, names, cnt, uint64(8), __ccgo_fp_cmp) } - *(*uintptr)(unsafe.Pointer(res)) = names + **(**uintptr)(__ccgo_up(res)) = names return Int32FromUint64(cnt) } @@ -24941,7 +24941,7 @@ func Xversionsort(tls *TLS, a uintptr, b uintptr) (r int32) { trc("tls=%v a=%v b=%v, (%v:)", tls, a, b, origin(2)) defer func() { trc("-> %v", r) }() } - return Xstrverscmp(tls, *(*uintptr)(unsafe.Pointer(a))+19, *(*uintptr)(unsafe.Pointer(b))+19) + return Xstrverscmp(tls, **(**uintptr)(__ccgo_up(a))+19, **(**uintptr)(__ccgo_up(b))+19) } func X__reset_tls(tls *TLS) { @@ -24953,7 +24953,7 @@ func X__reset_tls(tls *TLS) { var self Tpthread_t _, _, _, _, _ = i, mem, n, p, self self = uintptr(___get_tp(tls)) - n = *(*Tuintptr_t)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(self)).Fdtv)) + n = **(**Tuintptr_t)(__ccgo_up((*t__pthread)(unsafe.Pointer(self)).Fdtv)) if n != 0 { p = X__libc.Ftls_head i = Uint64FromInt32(1) @@ -24961,7 +24961,7 @@ func X__reset_tls(tls *TLS) { if !(i <= n) { break } - mem = uintptr(*(*Tuintptr_t)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(self)).Fdtv + uintptr(i)*8)) - Uint64FromInt32(DTP_OFFSET)) + mem = uintptr(**(**Tuintptr_t)(__ccgo_up((*t__pthread)(unsafe.Pointer(self)).Fdtv + uintptr(i)*8)) - Uint64FromInt32(DTP_OFFSET)) Xmemcpy(tls, mem, (*Ttls_module)(unsafe.Pointer(p)).Fimage, (*Ttls_module)(unsafe.Pointer(p)).Flen1) Xmemset(tls, mem+uintptr((*Ttls_module)(unsafe.Pointer(p)).Flen1), 0, (*Ttls_module)(unsafe.Pointer(p)).Fsize-(*Ttls_module)(unsafe.Pointer(p)).Flen1) goto _1 @@ -24987,7 +24987,7 @@ func X__init_ssp(tls *TLS, entropy uintptr) { * The NULL byte is on the second byte so that off-by-ones can * still be detected. Endianness is taken care of * automatically. */ - *(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stack_chk_guard)) + 1)) = uint8(0) + **(**uint8)(__ccgo_up(uintptr(unsafe.Pointer(&X__stack_chk_guard)) + 1)) = uint8(0) (*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Fcanary = X__stack_chk_guard } @@ -24995,7 +24995,7 @@ func X__stack_chk_fail(tls *TLS) { if __ccgo_strace { trc("tls=%v, (%v:)", tls, origin(2)) } - *(*uint8)(unsafe.Pointer(UintptrFromInt32(0))) = uint8(0) + **(**uint8)(__ccgo_up(UintptrFromInt32(0))) = uint8(0) } func X__stack_chk_fail_local(tls *TLS) { @@ -25022,10 +25022,10 @@ func Xclearenv(tls *TLS) (r int32) { e = Xenviron Xenviron = uintptr(0) if e != 0 { - for *(*uintptr)(unsafe.Pointer(e)) != 0 { + for **(**uintptr)(__ccgo_up(e)) != 0 { v1 = e e += 8 - X__env_rm_add(tls, *(*uintptr)(unsafe.Pointer(v1)), uintptr(0)) + X__env_rm_add(tls, **(**uintptr)(__ccgo_up(v1)), uintptr(0)) } } return 0 @@ -25040,14 +25040,14 @@ func Xgetenv(tls *TLS, name uintptr) (r uintptr) { var l Tsize_t _, _ = e, l l = Uint64FromInt64(int64(X__strchrnul(tls, name, int32('='))) - int64(name)) - if l != 0 && !(*(*uint8)(unsafe.Pointer(name + uintptr(l))) != 0) && Xenviron != 0 { + if l != 0 && !(**(**uint8)(__ccgo_up(name + uintptr(l))) != 0) && Xenviron != 0 { e = Xenviron for { - if !(*(*uintptr)(unsafe.Pointer(e)) != 0) { + if !(**(**uintptr)(__ccgo_up(e)) != 0) { break } - if !(Xstrncmp(tls, name, *(*uintptr)(unsafe.Pointer(e)), l) != 0) && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(e)) + uintptr(l)))) == int32('=') { - return *(*uintptr)(unsafe.Pointer(e)) + uintptr(l) + uintptr(1) + if !(Xstrncmp(tls, name, **(**uintptr)(__ccgo_up(e)), l) != 0) && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(e)) + uintptr(l)))) == int32('=') { + return **(**uintptr)(__ccgo_up(e)) + uintptr(l) + uintptr(1) } goto _1 _1: @@ -25073,12 +25073,12 @@ func X__putenv(tls *TLS, s uintptr, l Tsize_t, r uintptr) (r1 int32) { if Xenviron != 0 { e = Xenviron for { - if !(*(*uintptr)(unsafe.Pointer(e)) != 0) { + if !(**(**uintptr)(__ccgo_up(e)) != 0) { break } - if !(Xstrncmp(tls, s, *(*uintptr)(unsafe.Pointer(e)), l+uint64(1)) != 0) { - tmp = *(*uintptr)(unsafe.Pointer(e)) - *(*uintptr)(unsafe.Pointer(e)) = s + if !(Xstrncmp(tls, s, **(**uintptr)(__ccgo_up(e)), l+uint64(1)) != 0) { + tmp = **(**uintptr)(__ccgo_up(e)) + **(**uintptr)(__ccgo_up(e)) = s X__env_rm_add(tls, tmp, r) return 0 } @@ -25104,8 +25104,8 @@ func X__putenv(tls *TLS, s uintptr, l Tsize_t, r uintptr) (r1 int32) { } Xfree(tls, _oldenv) } - *(*uintptr)(unsafe.Pointer(newenv + uintptr(i)*8)) = s - *(*uintptr)(unsafe.Pointer(newenv + uintptr(i+uint64(1))*8)) = uintptr(0) + **(**uintptr)(__ccgo_up(newenv + uintptr(i)*8)) = s + **(**uintptr)(__ccgo_up(newenv + uintptr(i+uint64(1))*8)) = uintptr(0) v2 = newenv _oldenv = v2 Xenviron = v2 @@ -25130,7 +25130,7 @@ func Xputenv(tls *TLS, s uintptr) (r int32) { var l Tsize_t _ = l l = Uint64FromInt64(int64(X__strchrnul(tls, s, int32('='))) - int64(s)) - if !(l != 0) || !(*(*uint8)(unsafe.Pointer(s + uintptr(l))) != 0) { + if !(l != 0) || !(**(**uint8)(__ccgo_up(s + uintptr(l))) != 0) { return Xunsetenv(tls, s) } return X__putenv(tls, s, l, uintptr(0)) @@ -25175,13 +25175,13 @@ func X__env_rm_add(tls *TLS, old uintptr, new1 uintptr) { if !(i < _env_alloced_n) { break } - if *(*uintptr)(unsafe.Pointer(_env_alloced + uintptr(i)*8)) == old { - *(*uintptr)(unsafe.Pointer(_env_alloced + uintptr(i)*8)) = new1 + if **(**uintptr)(__ccgo_up(_env_alloced + uintptr(i)*8)) == old { + **(**uintptr)(__ccgo_up(_env_alloced + uintptr(i)*8)) = new1 Xfree(tls, old) return } else { - if !(*(*uintptr)(unsafe.Pointer(_env_alloced + uintptr(i)*8)) != 0) && new1 != 0 { - *(*uintptr)(unsafe.Pointer(_env_alloced + uintptr(i)*8)) = new1 + if !(**(**uintptr)(__ccgo_up(_env_alloced + uintptr(i)*8)) != 0) && new1 != 0 { + **(**uintptr)(__ccgo_up(_env_alloced + uintptr(i)*8)) = new1 new1 = uintptr(0) } } @@ -25201,7 +25201,7 @@ func X__env_rm_add(tls *TLS, old uintptr, new1 uintptr) { _env_alloced = v2 v3 = _env_alloced_n _env_alloced_n = _env_alloced_n + 1 - *(*uintptr)(unsafe.Pointer(v2 + uintptr(v3)*8)) = new1 + **(**uintptr)(__ccgo_up(v2 + uintptr(v3)*8)) = new1 } var _env_alloced uintptr @@ -25221,8 +25221,8 @@ func Xsetenv(tls *TLS, var1 uintptr, value uintptr, overwrite int32) (r int32) { v1 = Uint64FromInt64(int64(X__strchrnul(tls, var1, int32('='))) - int64(var1)) l1 = v1 } - if v2 || !(v1 != 0) || *(*uint8)(unsafe.Pointer(var1 + uintptr(l1))) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if v2 || !(v1 != 0) || **(**uint8)(__ccgo_up(var1 + uintptr(l1))) != 0 { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } if !(overwrite != 0) && Xgetenv(tls, var1) != 0 { @@ -25234,7 +25234,7 @@ func Xsetenv(tls *TLS, var1 uintptr, value uintptr, overwrite int32) (r int32) { return -int32(1) } Xmemcpy(tls, s, var1, l1) - *(*uint8)(unsafe.Pointer(s + uintptr(l1))) = uint8('=') + **(**uint8)(__ccgo_up(s + uintptr(l1))) = uint8('=') Xmemcpy(tls, s+uintptr(l1)+uintptr(1), value, l2+uint64(1)) return X__putenv(tls, s, l1, s) } @@ -25251,24 +25251,24 @@ func Xunsetenv(tls *TLS, name uintptr) (r int32) { var l Tsize_t _, _, _, _ = e, eo, l, v2 l = Uint64FromInt64(int64(X__strchrnul(tls, name, int32('='))) - int64(name)) - if !(l != 0) || *(*uint8)(unsafe.Pointer(name + uintptr(l))) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if !(l != 0) || **(**uint8)(__ccgo_up(name + uintptr(l))) != 0 { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } if Xenviron != 0 { e = Xenviron eo = e for { - if !(*(*uintptr)(unsafe.Pointer(e)) != 0) { + if !(**(**uintptr)(__ccgo_up(e)) != 0) { break } - if !(Xstrncmp(tls, name, *(*uintptr)(unsafe.Pointer(e)), l) != 0) && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(e)) + uintptr(l)))) == int32('=') { - X__env_rm_add(tls, *(*uintptr)(unsafe.Pointer(e)), uintptr(0)) + if !(Xstrncmp(tls, name, **(**uintptr)(__ccgo_up(e)), l) != 0) && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(e)) + uintptr(l)))) == int32('=') { + X__env_rm_add(tls, **(**uintptr)(__ccgo_up(e)), uintptr(0)) } else { if eo != e { v2 = eo eo += 8 - *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(e)) + **(**uintptr)(__ccgo_up(v2)) = **(**uintptr)(__ccgo_up(e)) } else { eo += 8 } @@ -25279,7 +25279,7 @@ func Xunsetenv(tls *TLS, name uintptr) (r int32) { e += 8 } if eo != e { - *(*uintptr)(unsafe.Pointer(eo)) = uintptr(0) + **(**uintptr)(__ccgo_up(eo)) = uintptr(0) } } return 0 @@ -25589,7 +25589,7 @@ func X__strerror_l(tls *TLS, e int32, loc Tlocale_t) (r uintptr) { e = 0 } s = uintptr(unsafe.Pointer(&_errmsgstr)) + uintptr(_errmsgidx[e]) - return X__lctrans(tls, s, *(*uintptr)(unsafe.Pointer(loc + 5*8))) + return X__lctrans(tls, s, **(**uintptr)(__ccgo_up(loc + 5*8))) } func Xstrerror(tls *TLS, e int32) (r uintptr) { @@ -25726,10 +25726,10 @@ func Xfcntl(tls *TLS, fd int32, cmd int32, va uintptr) (r int32) { if ret != 0 { return int32(X__syscall_ret(tls, Uint64FromInt32(ret))) } - if (*(*Tf_owner_ex)(unsafe.Pointer(bp))).Ftype1 == int32(F_OWNER_PGRP) { - v1 = -(*(*Tf_owner_ex)(unsafe.Pointer(bp))).Fpid + if (**(**Tf_owner_ex)(__ccgo_up(bp))).Ftype1 == int32(F_OWNER_PGRP) { + v1 = -(**(**Tf_owner_ex)(__ccgo_up(bp))).Fpid } else { - v1 = (*(*Tf_owner_ex)(unsafe.Pointer(bp))).Fpid + v1 = (**(**Tf_owner_ex)(__ccgo_up(bp))).Fpid } return v1 } @@ -25977,7 +25977,7 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -25988,7 +25988,7 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26018,7 +26018,7 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26037,7 +26037,7 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26054,7 +26054,7 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26107,7 +26107,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__shgetc(tls, f) } @@ -26119,7 +26119,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__shgetc(tls, f) } @@ -26137,14 +26137,14 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__shgetc(tls, f) } c = v2 } } - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0] = uint32(0) + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[0] = uint32(0) for { if !(Uint32FromInt32(c-int32('0')) < uint32(10) || c == int32('.')) { break @@ -26162,9 +26162,9 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, lnz = int32(dc) } if j != 0 { - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k]*uint32(10) + Uint32FromInt32(c) - uint32('0') + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] = (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k]*uint32(10) + Uint32FromInt32(c) - uint32('0') } else { - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] = Uint32FromInt32(c - int32('0')) + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] = Uint32FromInt32(c - int32('0')) } j = j + 1 v2 = j @@ -26177,7 +26177,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, dc = dc + 1 if c != int32('0') { lnz = (Int32FromInt32(KMAX) - Int32FromInt32(4)) * Int32FromInt32(9) - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(Int32FromInt32(KMAX)-Int32FromInt32(4))*4)) |= uint32(1) + **(**Tuint32_t)(__ccgo_up(bp + uintptr(Int32FromInt32(KMAX)-Int32FromInt32(4))*4)) |= uint32(1) } } } @@ -26188,7 +26188,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__shgetc(tls, f) } @@ -26219,24 +26219,24 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, } } if !(gotdig != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) X__shlim(tls, f, int64(Int32FromInt32(0))) return Float64FromInt32(0) } /* Handle zero specially to avoid nasty special cases later */ - if !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0] != 0) { + if !((**(**[128]Tuint32_t)(__ccgo_up(bp)))[0] != 0) { return float64(float64(sign) * float64(0)) } /* Optimize small integers (w/no exponent) and over/under-flow */ - if lrp == dc && dc < int64(10) && (bits > int32(30) || (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0]>>bits == uint32(0)) { - return float64(float64(sign) * float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0])) + if lrp == dc && dc < int64(10) && (bits > int32(30) || (**(**[128]Tuint32_t)(__ccgo_up(bp)))[0]>>bits == uint32(0)) { + return float64(float64(sign) * float64((**(**[128]Tuint32_t)(__ccgo_up(bp)))[0])) } if lrp > int64(-emin/int32(2)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return float64(float64(float64(sign)*Float64FromFloat64(1.79769313486231570815e+308)) * Float64FromFloat64(1.79769313486231570815e+308)) } if lrp < int64(emin-Int32FromInt32(2)*Int32FromInt32(LDBL_MANT_DIG)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return float64(float64(float64(sign)*Float64FromFloat64(2.22507385850720138309e-308)) * Float64FromFloat64(2.22507385850720138309e-308)) } /* Align incomplete final B1B digit */ @@ -26245,7 +26245,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if !(j < int32(9)) { break } - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(k)*4)) *= uint32(10) + **(**Tuint32_t)(__ccgo_up(bp + uintptr(k)*4)) *= uint32(10) goto _17 _17: ; @@ -26261,19 +26261,19 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, /* Optimize small to mid-size integers (even in exp. notation) */ if lnz < int32(9) && lnz <= rp && rp < int32(18) { if rp == int32(9) { - return float64(float64(sign) * float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0])) + return float64(float64(sign) * float64((**(**[128]Tuint32_t)(__ccgo_up(bp)))[0])) } if rp < int32(9) { - return float64(float64(sign)*float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0])) / float64(_p10s[int32(8)-rp]) + return float64(float64(sign)*float64((**(**[128]Tuint32_t)(__ccgo_up(bp)))[0])) / float64(_p10s[int32(8)-rp]) } bitlim = bits - int32(3)*(rp-Int32FromInt32(9)) - if bitlim > int32(30) || (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0]>>bitlim == uint32(0) { - return float64(float64(float64(sign)*float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0])) * float64(_p10s[rp-int32(10)])) + if bitlim > int32(30) || (**(**[128]Tuint32_t)(__ccgo_up(bp)))[0]>>bitlim == uint32(0) { + return float64(float64(float64(sign)*float64((**(**[128]Tuint32_t)(__ccgo_up(bp)))[0])) * float64(_p10s[rp-int32(10)])) } } /* Drop trailing zeros */ for { - if !!((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[z-int32(1)] != 0) { + if !!((**(**[128]Tuint32_t)(__ccgo_up(bp)))[z-int32(1)] != 0) { break } goto _18 @@ -26296,10 +26296,10 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if !(k != z) { break } - tmp = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] % Uint32FromInt32(p10) - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k]/Uint32FromInt32(p10) + carry + tmp = (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] % Uint32FromInt32(p10) + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] = (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k]/Uint32FromInt32(p10) + carry carry = Uint32FromInt32(int32(1000000000)/p10) * tmp - if k == a && !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] != 0) { + if k == a && !((**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] != 0) { a = (a + int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) rp = rp - int32(9) } @@ -26311,25 +26311,25 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if carry != 0 { v2 = z z = z + 1 - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v2] = carry + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[v2] = carry } rp = rp + (int32(9) - rpm9) } /* Upscale until desired number of bits are left of radix point */ - for rp < Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) || rp == Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) && (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[a] < _th[0] { + for rp < Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) || rp == Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) && (**(**[128]Tuint32_t)(__ccgo_up(bp)))[a] < _th[0] { carry1 = uint32(0) e2 = e2 - int32(29) k = (z - int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) for { - tmp1 = uint64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k])< uint64(1000000000) { carry1 = uint32(tmp1 / uint64(1000000000)) - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] = uint32(tmp1 % uint64(1000000000)) + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] = uint32(tmp1 % uint64(1000000000)) } else { carry1 = uint32(0) - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] = uint32(tmp1) + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] = uint32(tmp1) } - if k == (z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) && k != a && !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] != 0) { + if k == (z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) && k != a && !((**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] != 0) { z = k } if k == a { @@ -26345,9 +26345,9 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, a = (a - int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) if a == z { z = (z - int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr((z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)))*4)) |= (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[z] + **(**Tuint32_t)(__ccgo_up(bp + uintptr((z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)))*4)) |= (**(**[128]Tuint32_t)(__ccgo_up(bp)))[z] } - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[a] = carry1 + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[a] = carry1 } } /* Downscale until exactly number of bits are left of radix point */ @@ -26360,11 +26360,11 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, break } k = (a + i) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) - if k == z || (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] < _th[i] { + if k == z || (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] < _th[i] { i = int32(LD_B1B_DIG) break } - if (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))] > _th[i] { + if (**(**[128]Tuint32_t)(__ccgo_up(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))] > _th[i] { break } goto _24 @@ -26385,10 +26385,10 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if !(k != z) { break } - tmp2 = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] & Uint32FromInt32(int32(1)<>sh + carry2 + tmp2 = (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] & Uint32FromInt32(int32(1)<>sh + carry2 carry2 = Uint32FromInt32(Int32FromInt32(1000000000)>>sh) * tmp2 - if k == a && !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] != 0) { + if k == a && !((**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] != 0) { a = (a + int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) i = i - 1 rp = rp - int32(9) @@ -26400,10 +26400,10 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, } if carry2 != 0 { if (z+int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) != a { - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[z] = carry2 + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[z] = carry2 z = (z + int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) } else { - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr((z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)))*4)) |= uint32(1) + **(**Tuint32_t)(__ccgo_up(bp + uintptr((z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)))*4)) |= uint32(1) } } goto _23 @@ -26420,9 +26420,9 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if (a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1)) == z { v6 = (z + Int32FromInt32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) z = v6 - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v6-int32(1)] = uint32(0) + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[v6-int32(1)] = uint32(0) } - y = float64(Float64FromFloat64(1e+09)*y) + float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))]) + y = float64(Float64FromFloat64(1e+09)*y) + float64((**(**[128]Tuint32_t)(__ccgo_up(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))]) goto _26 _26: ; @@ -26446,7 +26446,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, } /* Process tail of decimal input so it can affect rounding */ if (a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1)) != z { - t = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))] + t = (**(**[128]Tuint32_t)(__ccgo_up(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))] if t < uint32(500000000) && (t != 0 || (a+i+int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) != z) { frac = frac + float64(float64(0.25)*float64(sign)) } else { @@ -26477,7 +26477,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, e2 = e2 + 1 } if e2+int32(LDBL_MANT_DIG) > emax || denormal != 0 && frac != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) } } return Xscalbnl(tls, y, e2) @@ -26520,7 +26520,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26538,7 +26538,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26550,7 +26550,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26569,7 +26569,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26616,7 +26616,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26670,11 +26670,11 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 return float64(float64(sign) * float64(0)) } if e2 > int64(-emin) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return float64(float64(float64(sign)*Float64FromFloat64(1.79769313486231570815e+308)) * Float64FromFloat64(1.79769313486231570815e+308)) } if e2 < int64(emin-Int32FromInt32(2)*Int32FromInt32(LDBL_MANT_DIG)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return float64(float64(float64(sign)*Float64FromFloat64(2.22507385850720138309e-308)) * Float64FromFloat64(2.22507385850720138309e-308)) } for x < uint32(0x80000000) { @@ -26703,7 +26703,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 y = bias + float64(float64(sign)*float64(x)) + float64(float64(sign)*y) y = y - bias if !(y != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) } return Xscalbnl(tls, y, int32(e2)) } @@ -26736,7 +26736,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__shgetc(tls, f) } @@ -26756,7 +26756,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -26764,7 +26764,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { } i = uint64(0) for { - if !(i < uint64(8) && c|int32(32) == Int32FromUint8(*(*uint8)(unsafe.Pointer(__ccgo_ts + 247 + uintptr(i))))) { + if !(i < uint64(8) && c|int32(32) == Int32FromUint8(**(**uint8)(__ccgo_up(__ccgo_ts + 247 + uintptr(i))))) { break } if i < uint64(7) { @@ -26772,7 +26772,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -26808,7 +26808,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { if !(i != 0) { i = uint64(0) for { - if !(i < uint64(3) && c|int32(32) == Int32FromUint8(*(*uint8)(unsafe.Pointer(__ccgo_ts + 256 + uintptr(i))))) { + if !(i < uint64(3) && c|int32(32) == Int32FromUint8(**(**uint8)(__ccgo_up(__ccgo_ts + 256 + uintptr(i))))) { break } if i < uint64(2) { @@ -26816,7 +26816,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -26833,7 +26833,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -26849,7 +26849,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -26864,7 +26864,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if !(pok != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) X__shlim(tls, f, int64(Int32FromInt32(0))) return Float64FromInt32(0) } @@ -26890,7 +26890,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) X__shlim(tls, f, int64(Int32FromInt32(0))) return Float64FromInt32(0) } @@ -26899,7 +26899,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27190,7 +27190,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint val = uintptr(unsafe.Pointer(&_table6)) + uintptr(1) neg = 0 if base > uint32(36) || base == uint32(1) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uint64(0) } for { @@ -27198,7 +27198,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__shgetc(tls, f) } @@ -27218,7 +27218,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27229,7 +27229,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27239,12 +27239,12 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } c = v1 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) >= int32(16) { + if Int32FromUint8(**(**uint8)(__ccgo_up(val + uintptr(c)))) >= int32(16) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } @@ -27267,12 +27267,12 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint if base == uint32(0) { base = uint32(10) } - if uint32(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) >= base { + if uint32(**(**uint8)(__ccgo_up(val + uintptr(c)))) >= base { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } X__shlim(tls, f, int64(Int32FromInt32(0))) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uint64(0) } } @@ -27290,7 +27290,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27309,7 +27309,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27320,13 +27320,13 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint } } else { if !(base&(base-Uint32FromInt32(1)) != 0) { - bs = Int32FromUint8(*(*uint8)(unsafe.Pointer(__ccgo_ts + 260 + uintptr(uint32(0x17)*base>>int32(5)&uint32(7))))) + bs = Int32FromUint8(**(**uint8)(__ccgo_up(__ccgo_ts + 260 + uintptr(uint32(0x17)*base>>int32(5)&uint32(7))))) x = uint32(0) for { - if !(uint32(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) < base && x <= Uint32FromUint32(0xffffffff)/Uint32FromInt32(32)) { + if !(uint32(**(**uint8)(__ccgo_up(val + uintptr(c)))) < base && x <= Uint32FromUint32(0xffffffff)/Uint32FromInt32(32)) { break } - x = x<>bs) { + if !(uint32(**(**uint8)(__ccgo_up(val + uintptr(c)))) < base && y <= (Uint64FromUint64(2)*Uint64FromInt64(0x7fffffffffffffff)+Uint64FromInt32(1))>>bs) { break } - y = y<= lim { if !(lim&Uint64FromInt32(1) != 0) && !(neg != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return lim - uint64(1) } else { if y > lim { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return lim } } @@ -27453,8 +27453,8 @@ func X__procfdname(tls *TLS, buf uintptr, fd uint32) { _, _, _, _ = i, j, v2, v5 i = uint32(0) for { - v2 = *(*uint8)(unsafe.Pointer(__ccgo_ts + 269 + uintptr(i))) - *(*uint8)(unsafe.Pointer(buf + uintptr(i))) = v2 + v2 = **(**uint8)(__ccgo_up(__ccgo_ts + 269 + uintptr(i))) + **(**uint8)(__ccgo_up(buf + uintptr(i))) = v2 if !(v2 != 0) { break } @@ -27464,8 +27464,8 @@ func X__procfdname(tls *TLS, buf uintptr, fd uint32) { i = i + 1 } if !(fd != 0) { - *(*uint8)(unsafe.Pointer(buf + uintptr(i))) = uint8('0') - *(*uint8)(unsafe.Pointer(buf + uintptr(i+uint32(1)))) = uint8(0) + **(**uint8)(__ccgo_up(buf + uintptr(i))) = uint8('0') + **(**uint8)(__ccgo_up(buf + uintptr(i+uint32(1)))) = uint8(0) return } j = fd @@ -27479,14 +27479,14 @@ func X__procfdname(tls *TLS, buf uintptr, fd uint32) { j = j / uint32(10) i = i + 1 } - *(*uint8)(unsafe.Pointer(buf + uintptr(i))) = uint8(0) + **(**uint8)(__ccgo_up(buf + uintptr(i))) = uint8(0) for { if !(fd != 0) { break } i = i - 1 v5 = i - *(*uint8)(unsafe.Pointer(buf + uintptr(v5))) = uint8(uint32('0') + fd%uint32(10)) + **(**uint8)(__ccgo_up(buf + uintptr(v5))) = uint8(uint32('0') + fd%uint32(10)) goto _4 _4: ; @@ -27541,7 +27541,7 @@ func X__shgetc(tls *TLS, f uintptr) (r int32) { } (*TFILE)(unsafe.Pointer(f)).Fshcnt = int64((*TFILE)(unsafe.Pointer(f)).Fbuf) - int64((*TFILE)(unsafe.Pointer(f)).Frpos) + cnt if (*TFILE)(unsafe.Pointer(f)).Frpos <= (*TFILE)(unsafe.Pointer(f)).Fbuf { - *(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos + uintptr(-Int32FromInt32(1)))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos + uintptr(-Int32FromInt32(1)))) = Uint8FromInt32(c) } return c } @@ -27552,7 +27552,7 @@ func X__syscall_ret(tls *TLS, r uint64) (r1 int64) { defer func() { trc("-> %v", r1) }() } if r > -Uint64FromUint64(4096) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = Int32FromUint64(-r) + **(**int32)(__ccgo_up(X__errno_location(tls))) = Int32FromUint64(-r) return int64(-int32(1)) } return Int64FromUint64(r) @@ -27627,7 +27627,7 @@ func Xftok(tls *TLS, path uintptr, id int32) (r Tkey_t) { if Xstat(tls, path, bp) < 0 { return -int32(1) } - return Int32FromUint64((*(*Tstat)(unsafe.Pointer(bp))).Fst_ino&Uint64FromInt32(0xffff) | (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev&Uint64FromInt32(0xff)< int64(1000) || (*Ttimeval)(unsafe.Pointer(in)).Ftv_usec > int64(1000000000) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } - (*(*Ttimex)(unsafe.Pointer(bp))).Foffset = (*Ttimeval)(unsafe.Pointer(in)).Ftv_sec*int64(1000000) + (*Ttimeval)(unsafe.Pointer(in)).Ftv_usec - (*(*Ttimex)(unsafe.Pointer(bp))).Fmodes = uint32(ADJ_OFFSET_SINGLESHOT) + (**(**Ttimex)(__ccgo_up(bp))).Foffset = (*Ttimeval)(unsafe.Pointer(in)).Ftv_sec*int64(1000000) + (*Ttimeval)(unsafe.Pointer(in)).Ftv_usec + (**(**Ttimex)(__ccgo_up(bp))).Fmodes = uint32(ADJ_OFFSET_SINGLESHOT) } if Xadjtimex(tls, bp) < 0 { return -int32(1) } if out != 0 { - (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec = (*(*Ttimex)(unsafe.Pointer(bp))).Foffset / int64(1000000) - v1 = (*(*Ttimex)(unsafe.Pointer(bp))).Foffset % Int64FromInt32(1000000) + (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec = (**(**Ttimex)(__ccgo_up(bp))).Foffset / int64(1000000) + v1 = (**(**Ttimex)(__ccgo_up(bp))).Foffset % Int64FromInt32(1000000) (*Ttimeval)(unsafe.Pointer(out)).Ftv_usec = v1 if v1 < 0 { (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec = (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec - 1 - *(*Tsuseconds_t)(unsafe.Pointer(out + 8)) += int64(1000000) + **(**Tsuseconds_t)(__ccgo_up(out + 8)) += int64(1000000) } } return 0 @@ -29070,7 +29070,7 @@ func Xclock_adjtime(tls *TLS, clock_id Tclockid_t, utx uintptr) (r1 int32) { _ = r r = -int32(ENOSYS) if uint64(8) > uint64(8) { - *(*Tktimex)(unsafe.Pointer(bp)) = Tktimex{ + **(**Tktimex)(__ccgo_up(bp)) = Tktimex{ Fmodes: (*Ttimex)(unsafe.Pointer(utx)).Fmodes, Foffset: (*Ttimex)(unsafe.Pointer(utx)).Foffset, Ffreq: (*Ttimex)(unsafe.Pointer(utx)).Ffreq, @@ -29099,27 +29099,27 @@ func Xclock_adjtime(tls *TLS, clock_id Tclockid_t, utx uintptr) (r1 int32) { r = int32(X__syscall2(tls, int64(SYS_clock_adjtime), int64(clock_id), int64(bp))) } if r >= 0 { - (*Ttimex)(unsafe.Pointer(utx)).Fmodes = (*(*Tktimex)(unsafe.Pointer(bp))).Fmodes - (*Ttimex)(unsafe.Pointer(utx)).Foffset = (*(*Tktimex)(unsafe.Pointer(bp))).Foffset - (*Ttimex)(unsafe.Pointer(utx)).Ffreq = (*(*Tktimex)(unsafe.Pointer(bp))).Ffreq - (*Ttimex)(unsafe.Pointer(utx)).Fmaxerror = (*(*Tktimex)(unsafe.Pointer(bp))).Fmaxerror - (*Ttimex)(unsafe.Pointer(utx)).Festerror = (*(*Tktimex)(unsafe.Pointer(bp))).Festerror - (*Ttimex)(unsafe.Pointer(utx)).Fstatus = (*(*Tktimex)(unsafe.Pointer(bp))).Fstatus - (*Ttimex)(unsafe.Pointer(utx)).Fconstant = (*(*Tktimex)(unsafe.Pointer(bp))).Fconstant - (*Ttimex)(unsafe.Pointer(utx)).Fprecision = (*(*Tktimex)(unsafe.Pointer(bp))).Fprecision - (*Ttimex)(unsafe.Pointer(utx)).Ftolerance = (*(*Tktimex)(unsafe.Pointer(bp))).Ftolerance - (*Ttimex)(unsafe.Pointer(utx)).Ftime.Ftv_sec = (*(*Tktimex)(unsafe.Pointer(bp))).Ftime_sec - (*Ttimex)(unsafe.Pointer(utx)).Ftime.Ftv_usec = (*(*Tktimex)(unsafe.Pointer(bp))).Ftime_usec - (*Ttimex)(unsafe.Pointer(utx)).Ftick = (*(*Tktimex)(unsafe.Pointer(bp))).Ftick - (*Ttimex)(unsafe.Pointer(utx)).Fppsfreq = (*(*Tktimex)(unsafe.Pointer(bp))).Fppsfreq - (*Ttimex)(unsafe.Pointer(utx)).Fjitter = (*(*Tktimex)(unsafe.Pointer(bp))).Fjitter - (*Ttimex)(unsafe.Pointer(utx)).Fshift = (*(*Tktimex)(unsafe.Pointer(bp))).Fshift - (*Ttimex)(unsafe.Pointer(utx)).Fstabil = (*(*Tktimex)(unsafe.Pointer(bp))).Fstabil - (*Ttimex)(unsafe.Pointer(utx)).Fjitcnt = (*(*Tktimex)(unsafe.Pointer(bp))).Fjitcnt - (*Ttimex)(unsafe.Pointer(utx)).Fcalcnt = (*(*Tktimex)(unsafe.Pointer(bp))).Fcalcnt - (*Ttimex)(unsafe.Pointer(utx)).Ferrcnt = (*(*Tktimex)(unsafe.Pointer(bp))).Ferrcnt - (*Ttimex)(unsafe.Pointer(utx)).Fstbcnt = (*(*Tktimex)(unsafe.Pointer(bp))).Fstbcnt - (*Ttimex)(unsafe.Pointer(utx)).Ftai = (*(*Tktimex)(unsafe.Pointer(bp))).Ftai + (*Ttimex)(unsafe.Pointer(utx)).Fmodes = (**(**Tktimex)(__ccgo_up(bp))).Fmodes + (*Ttimex)(unsafe.Pointer(utx)).Foffset = (**(**Tktimex)(__ccgo_up(bp))).Foffset + (*Ttimex)(unsafe.Pointer(utx)).Ffreq = (**(**Tktimex)(__ccgo_up(bp))).Ffreq + (*Ttimex)(unsafe.Pointer(utx)).Fmaxerror = (**(**Tktimex)(__ccgo_up(bp))).Fmaxerror + (*Ttimex)(unsafe.Pointer(utx)).Festerror = (**(**Tktimex)(__ccgo_up(bp))).Festerror + (*Ttimex)(unsafe.Pointer(utx)).Fstatus = (**(**Tktimex)(__ccgo_up(bp))).Fstatus + (*Ttimex)(unsafe.Pointer(utx)).Fconstant = (**(**Tktimex)(__ccgo_up(bp))).Fconstant + (*Ttimex)(unsafe.Pointer(utx)).Fprecision = (**(**Tktimex)(__ccgo_up(bp))).Fprecision + (*Ttimex)(unsafe.Pointer(utx)).Ftolerance = (**(**Tktimex)(__ccgo_up(bp))).Ftolerance + (*Ttimex)(unsafe.Pointer(utx)).Ftime.Ftv_sec = (**(**Tktimex)(__ccgo_up(bp))).Ftime_sec + (*Ttimex)(unsafe.Pointer(utx)).Ftime.Ftv_usec = (**(**Tktimex)(__ccgo_up(bp))).Ftime_usec + (*Ttimex)(unsafe.Pointer(utx)).Ftick = (**(**Tktimex)(__ccgo_up(bp))).Ftick + (*Ttimex)(unsafe.Pointer(utx)).Fppsfreq = (**(**Tktimex)(__ccgo_up(bp))).Fppsfreq + (*Ttimex)(unsafe.Pointer(utx)).Fjitter = (**(**Tktimex)(__ccgo_up(bp))).Fjitter + (*Ttimex)(unsafe.Pointer(utx)).Fshift = (**(**Tktimex)(__ccgo_up(bp))).Fshift + (*Ttimex)(unsafe.Pointer(utx)).Fstabil = (**(**Tktimex)(__ccgo_up(bp))).Fstabil + (*Ttimex)(unsafe.Pointer(utx)).Fjitcnt = (**(**Tktimex)(__ccgo_up(bp))).Fjitcnt + (*Ttimex)(unsafe.Pointer(utx)).Fcalcnt = (**(**Tktimex)(__ccgo_up(bp))).Fcalcnt + (*Ttimex)(unsafe.Pointer(utx)).Ferrcnt = (**(**Tktimex)(__ccgo_up(bp))).Ferrcnt + (*Ttimex)(unsafe.Pointer(utx)).Fstbcnt = (**(**Tktimex)(__ccgo_up(bp))).Fstbcnt + (*Ttimex)(unsafe.Pointer(utx)).Ftai = (**(**Tktimex)(__ccgo_up(bp))).Ftai } return int32(X__syscall_ret(tls, Uint64FromInt32(r))) } @@ -30161,12 +30161,12 @@ func Xprlimit(tls *TLS, pid Tpid_t, resource int32, new_limit uintptr, old_limit var _ /* tmp at bp+0 */ Trlimit _ = r if new_limit != 0 && Bool(^Uint64FromUint64(0) != ^Uint64FromUint64(0)) { - *(*Trlimit)(unsafe.Pointer(bp)) = *(*Trlimit)(unsafe.Pointer(new_limit)) - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur >= ^Uint64FromUint64(0) { - (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur = ^Uint64FromUint64(0) + **(**Trlimit)(__ccgo_up(bp)) = **(**Trlimit)(__ccgo_up(new_limit)) + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur >= ^Uint64FromUint64(0) { + (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur = ^Uint64FromUint64(0) } - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_max >= ^Uint64FromUint64(0) { - (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_max = ^Uint64FromUint64(0) + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_max >= ^Uint64FromUint64(0) { + (**(**Trlimit)(__ccgo_up(bp))).Frlim_max = ^Uint64FromUint64(0) } new_limit = bp } @@ -30351,7 +30351,7 @@ func Xptrace(tls *TLS, req int32, va uintptr) (r int64) { if ret < 0 || Uint32FromInt32(req)-uint32(1) >= uint32(3) { return ret } - return *(*int64)(unsafe.Pointer(bp)) + return **(**int64)(__ccgo_up(bp)) } func Xpwritev2(tls *TLS, fd int32, iov uintptr, count int32, ofs Toff_t, flags int32) (r Tssize_t) { @@ -30651,22 +30651,22 @@ func Xstatx(tls *TLS, dirfd int32, path uintptr, flags int32, mask uint32, stx u if ret != 0 { return ret } - (*Tstatx)(unsafe.Pointer(stx)).Fstx_dev_major = uint32((*(*Tstat)(unsafe.Pointer(bp))).Fst_dev>>Int32FromInt32(31)>>Int32FromInt32(1)&Uint64FromUint32(0xfffff000) | (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev>>Int32FromInt32(8)&Uint64FromInt32(0x00000fff)) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_dev_minor = uint32((*(*Tstat)(unsafe.Pointer(bp))).Fst_dev>>Int32FromInt32(12)&Uint64FromUint32(0xffffff00) | (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev&Uint64FromInt32(0x000000ff)) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_ino = (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino - (*Tstatx)(unsafe.Pointer(stx)).Fstx_mode = uint16((*(*Tstat)(unsafe.Pointer(bp))).Fst_mode) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_nlink = (*(*Tstat)(unsafe.Pointer(bp))).Fst_nlink - (*Tstatx)(unsafe.Pointer(stx)).Fstx_uid = (*(*Tstat)(unsafe.Pointer(bp))).Fst_uid - (*Tstatx)(unsafe.Pointer(stx)).Fstx_gid = (*(*Tstat)(unsafe.Pointer(bp))).Fst_gid - (*Tstatx)(unsafe.Pointer(stx)).Fstx_size = Uint64FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_size) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_blksize = Uint32FromInt32((*(*Tstat)(unsafe.Pointer(bp))).Fst_blksize) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_blocks = Uint64FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_blocks) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_atime.Ftv_sec = (*(*Tstat)(unsafe.Pointer(bp))).Fst_atim.Ftv_sec - (*Tstatx)(unsafe.Pointer(stx)).Fstx_atime.Ftv_nsec = Uint32FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_atim.Ftv_nsec) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_mtime.Ftv_sec = (*(*Tstat)(unsafe.Pointer(bp))).Fst_mtim.Ftv_sec - (*Tstatx)(unsafe.Pointer(stx)).Fstx_mtime.Ftv_nsec = Uint32FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_mtim.Ftv_nsec) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_ctime.Ftv_sec = (*(*Tstat)(unsafe.Pointer(bp))).Fst_ctim.Ftv_sec - (*Tstatx)(unsafe.Pointer(stx)).Fstx_ctime.Ftv_nsec = Uint32FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_ctim.Ftv_nsec) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_dev_major = uint32((**(**Tstat)(__ccgo_up(bp))).Fst_dev>>Int32FromInt32(31)>>Int32FromInt32(1)&Uint64FromUint32(0xfffff000) | (**(**Tstat)(__ccgo_up(bp))).Fst_dev>>Int32FromInt32(8)&Uint64FromInt32(0x00000fff)) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_dev_minor = uint32((**(**Tstat)(__ccgo_up(bp))).Fst_dev>>Int32FromInt32(12)&Uint64FromUint32(0xffffff00) | (**(**Tstat)(__ccgo_up(bp))).Fst_dev&Uint64FromInt32(0x000000ff)) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_ino = (**(**Tstat)(__ccgo_up(bp))).Fst_ino + (*Tstatx)(unsafe.Pointer(stx)).Fstx_mode = uint16((**(**Tstat)(__ccgo_up(bp))).Fst_mode) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_nlink = (**(**Tstat)(__ccgo_up(bp))).Fst_nlink + (*Tstatx)(unsafe.Pointer(stx)).Fstx_uid = (**(**Tstat)(__ccgo_up(bp))).Fst_uid + (*Tstatx)(unsafe.Pointer(stx)).Fstx_gid = (**(**Tstat)(__ccgo_up(bp))).Fst_gid + (*Tstatx)(unsafe.Pointer(stx)).Fstx_size = Uint64FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_size) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_blksize = Uint32FromInt32((**(**Tstat)(__ccgo_up(bp))).Fst_blksize) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_blocks = Uint64FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_blocks) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_atime.Ftv_sec = (**(**Tstat)(__ccgo_up(bp))).Fst_atim.Ftv_sec + (*Tstatx)(unsafe.Pointer(stx)).Fstx_atime.Ftv_nsec = Uint32FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_atim.Ftv_nsec) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_mtime.Ftv_sec = (**(**Tstat)(__ccgo_up(bp))).Fst_mtim.Ftv_sec + (*Tstatx)(unsafe.Pointer(stx)).Fstx_mtime.Ftv_nsec = Uint32FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_mtim.Ftv_nsec) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_ctime.Ftv_sec = (**(**Tstat)(__ccgo_up(bp))).Fst_ctim.Ftv_sec + (*Tstatx)(unsafe.Pointer(stx)).Fstx_ctime.Ftv_nsec = Uint32FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_ctim.Ftv_nsec) (*Tstatx)(unsafe.Pointer(stx)).Fstx_btime = Tstatx_timestamp{} (*Tstatx)(unsafe.Pointer(stx)).Fstx_mask = uint32(0x7ff) return 0 @@ -30680,8 +30680,8 @@ func Xstime(tls *TLS, t uintptr) (r int32) { bp := tls.Alloc(16) defer tls.Free(16) var _ /* tv at bp+0 */ Ttimeval - *(*Ttimeval)(unsafe.Pointer(bp)) = Ttimeval{ - Ftv_sec: *(*Ttime_t)(unsafe.Pointer(t)), + **(**Ttimeval)(__ccgo_up(bp)) = Ttimeval{ + Ftv_sec: **(**Ttime_t)(__ccgo_up(t)), } return Xsettimeofday(tls, bp, UintptrFromInt32(0)) } @@ -30925,12 +30925,12 @@ func Xwait4(tls *TLS, pid Tpid_t, status uintptr, options int32, ru uintptr) (r1 if r > 0 && ru != 0 && Bool(uint64(8) > uint64(8)) { Xmemcpy(tls, bp, dest, Uint64FromInt32(4)*Uint64FromInt64(8)) (*Trusage)(unsafe.Pointer(ru)).Fru_utime = Ttimeval{ - Ftv_sec: (*(*[4]int64)(unsafe.Pointer(bp)))[0], - Ftv_usec: (*(*[4]int64)(unsafe.Pointer(bp)))[int32(1)], + Ftv_sec: (**(**[4]int64)(__ccgo_up(bp)))[0], + Ftv_usec: (**(**[4]int64)(__ccgo_up(bp)))[int32(1)], } (*Trusage)(unsafe.Pointer(ru)).Fru_stime = Ttimeval{ - Ftv_sec: (*(*[4]int64)(unsafe.Pointer(bp)))[int32(2)], - Ftv_usec: (*(*[4]int64)(unsafe.Pointer(bp)))[int32(3)], + Ftv_sec: (**(**[4]int64)(__ccgo_up(bp)))[int32(2)], + Ftv_usec: (**(**[4]int64)(__ccgo_up(bp)))[int32(3)], } } return int32(X__syscall_ret(tls, Uint64FromInt32(r))) @@ -31053,7 +31053,7 @@ func X__lctrans_cur(tls *TLS, msg uintptr) (r uintptr) { trc("tls=%v msg=%v, (%v:)", tls, msg, origin(2)) defer func() { trc("-> %v", r) }() } - return X__lctrans_impl(tls, msg, *(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale + 5*8))) + return X__lctrans_impl(tls, msg, **(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale + 5*8))) } func _swapc(tls *TLS, x Tuint32_t, c int32) (r Tuint32_t) { @@ -31077,27 +31077,27 @@ func X__mo_lookup(tls *TLS, p uintptr, size Tsize_t, s uintptr) (r uintptr) { var sign, sw int32 _, _, _, _, _, _, _, _, _, _, _ = b, mo, n, o, ol, os, sign, sw, t, tl, ts mo = p - sw = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(mo)) - uint32(0x950412de)) + sw = Int32FromUint32(**(**Tuint32_t)(__ccgo_up(mo)) - uint32(0x950412de)) b = uint32(0) - n = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + 2*4)), sw) - o = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + 3*4)), sw) - t = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + 4*4)), sw) + n = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + 2*4)), sw) + o = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + 3*4)), sw) + t = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + 4*4)), sw) if uint64(n) >= size/uint64(4) || uint64(o) >= size-uint64(uint32(4)*n) || uint64(t) >= size-uint64(uint32(4)*n) || (o|t)%uint32(4) != 0 { return uintptr(0) } o = o / uint32(4) t = t / uint32(4) for { - ol = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + uintptr(o+uint32(2)*(b+n/uint32(2)))*4)), sw) - os = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + uintptr(o+uint32(2)*(b+n/uint32(2))+uint32(1))*4)), sw) - if uint64(os) >= size || uint64(ol) >= size-uint64(os) || *(*uint8)(unsafe.Pointer(p + uintptr(os+ol))) != 0 { + ol = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + uintptr(o+uint32(2)*(b+n/uint32(2)))*4)), sw) + os = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + uintptr(o+uint32(2)*(b+n/uint32(2))+uint32(1))*4)), sw) + if uint64(os) >= size || uint64(ol) >= size-uint64(os) || **(**uint8)(__ccgo_up(p + uintptr(os+ol))) != 0 { return uintptr(0) } sign = Xstrcmp(tls, s, p+uintptr(os)) if !(sign != 0) { - tl = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + uintptr(t+uint32(2)*(b+n/uint32(2)))*4)), sw) - ts = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + uintptr(t+uint32(2)*(b+n/uint32(2))+uint32(1))*4)), sw) - if uint64(ts) >= size || uint64(tl) >= size-uint64(ts) || *(*uint8)(unsafe.Pointer(p + uintptr(ts+tl))) != 0 { + tl = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + uintptr(t+uint32(2)*(b+n/uint32(2)))*4)), sw) + ts = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + uintptr(t+uint32(2)*(b+n/uint32(2))+uint32(1))*4)), sw) + if uint64(ts) >= size || uint64(tl) >= size-uint64(ts) || **(**uint8)(__ccgo_up(p + uintptr(ts+tl))) != 0 { return uintptr(0) } return p + uintptr(ts) @@ -31127,7 +31127,7 @@ func Xbind_textdomain_codeset(tls *TLS, domainname uintptr, codeset uintptr) (r defer func() { trc("-> %v", r) }() } if codeset != 0 && Xstrcasecmp(tls, codeset, __ccgo_ts+322) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) } return UintptrFromInt32(0) } @@ -31155,7 +31155,7 @@ func Xcatclose(tls *TLS, catd Tnl_catd) (r int32) { var v1, v2 Tuint32_t _, _, _ = map1, v1, v2 map1 = catd - v1 = *(*Tuint32_t)(unsafe.Pointer(map1 + UintptrFromInt32(8))) + v1 = **(**Tuint32_t)(__ccgo_up(map1 + UintptrFromInt32(8))) v2 = v1>>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v4>>int32(8)&uint32(0xff00) | v4<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v4>>int32(8)&uint32(0xff00) | v4<>int32(24) | v7>>int32(8)&uint32(0xff00) | v7<>int32(24) | v10>>int32(8)&uint32(0xff00) | v10<>int32(24) | v13>>int32(8)&uint32(0xff00) | v13<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v4>>int32(8)&uint32(0xff00) | v4<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v5>>int32(8)&uint32(0xff00) | v5< uint64(NAME_MAX) || dirlen >= uint64(PATH_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } ___lock(tls, uintptr(unsafe.Pointer(&_lock1))) @@ -31655,7 +31655,7 @@ func Xdcngettext(tls *TLS, domainname uintptr, msgid1 uintptr, msgid2 uintptr, n _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = alt_modlen, catlen, catname, csp, dirlen, dirname, domlen, l, lm, loc, loclen, locname, locp, map1, modlen, modname, name, np, old, old_cats, old_errno, p3, plural, q, r, r1, rem, rule, trans, v, v11, v12, v26, v3, v5, v6, v8, v9 defer func() { Xrealloc(tls, name, 0) }() loc = (*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale - old_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + old_errno = **(**int32)(__ccgo_up(X__errno_location(tls))) /* match gnu gettext behaviour */ if !(msgid1 != 0) { goto notrans @@ -31686,14 +31686,14 @@ func Xdcngettext(tls *TLS, domainname uintptr, msgid1 uintptr, msgid2 uintptr, n if !(q != 0) { goto notrans } - lm = *(*uintptr)(unsafe.Pointer(loc + uintptr(category)*8)) + lm = **(**uintptr)(__ccgo_up(loc + uintptr(category)*8)) if !!(lm != 0) { goto _2 } goto notrans notrans: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = old_errno + **(**int32)(__ccgo_up(X__errno_location(tls))) = old_errno if n == uint64(1) { v3 = msgid1 } else { @@ -31766,21 +31766,21 @@ _2: } p3 = Xcalloc(tls, uint64(64), uint64(1)) if !(p3 != 0) { - X__munmap(tls, map1, *(*Tsize_t)(unsafe.Pointer(bp))) + X__munmap(tls, map1, **(**Tsize_t)(__ccgo_up(bp))) goto notrans } (*Tmsgcat)(unsafe.Pointer(p3)).Fcat = category (*Tmsgcat)(unsafe.Pointer(p3)).Fbinding = q (*Tmsgcat)(unsafe.Pointer(p3)).Flm = lm (*Tmsgcat)(unsafe.Pointer(p3)).Fmap1 = map1 - (*Tmsgcat)(unsafe.Pointer(p3)).Fmap_size = *(*Tsize_t)(unsafe.Pointer(bp)) + (*Tmsgcat)(unsafe.Pointer(p3)).Fmap_size = **(**Tsize_t)(__ccgo_up(bp)) rule = __ccgo_ts + 445 np = uint64(2) r1 = X__mo_lookup(tls, (*Tmsgcat)(unsafe.Pointer(p3)).Fmap1, (*Tmsgcat)(unsafe.Pointer(p3)).Fmap_size, __ccgo_ts) for r1 != 0 && Xstrncmp(tls, r1, __ccgo_ts+451, uint64(13)) != 0 { - *(*uintptr)(unsafe.Pointer(bp + 8)) = Xstrchr(tls, r1, int32('\n')) - if *(*uintptr)(unsafe.Pointer(bp + 8)) != 0 { - v3 = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(1) + **(**uintptr)(__ccgo_up(bp + 8)) = Xstrchr(tls, r1, int32('\n')) + if **(**uintptr)(__ccgo_up(bp + 8)) != 0 { + v3 = **(**uintptr)(__ccgo_up(bp + 8)) + uintptr(1) } else { v3 = uintptr(0) } @@ -31789,7 +31789,7 @@ _2: if r1 != 0 { r1 = r1 + uintptr(13) for { - v11 = Int32FromUint8(*(*uint8)(unsafe.Pointer(r1))) + v11 = Int32FromUint8(**(**uint8)(__ccgo_up(r1))) v12 = BoolInt32(v11 == int32(' ') || Uint32FromInt32(v11)-uint32('\t') < uint32(5)) goto _13 _13: @@ -31800,15 +31800,15 @@ _2: } if !(Xstrncmp(tls, r1, __ccgo_ts+465, uint64(9)) != 0) { np = Xstrtoul(tls, r1+uintptr(9), bp+8, int32(10)) - r1 = *(*uintptr)(unsafe.Pointer(bp + 8)) + r1 = **(**uintptr)(__ccgo_up(bp + 8)) } - for *(*uint8)(unsafe.Pointer(r1)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(r1))) != int32(';') { + for **(**uint8)(__ccgo_up(r1)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(r1))) != int32(';') { r1 = r1 + 1 } - if *(*uint8)(unsafe.Pointer(r1)) != 0 { + if **(**uint8)(__ccgo_up(r1)) != 0 { r1 = r1 + 1 for { - v11 = Int32FromUint8(*(*uint8)(unsafe.Pointer(r1))) + v11 = Int32FromUint8(**(**uint8)(__ccgo_up(r1))) v12 = BoolInt32(v11 == int32(' ') || Uint32FromInt32(v11)-uint32('\t') < uint32(5)) goto _16 _16: @@ -31890,7 +31890,7 @@ _2: trans = trans + uintptr(l+uint64(1)) } } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = old_errno + **(**int32)(__ccgo_up(X__errno_location(tls))) = old_errno return trans } @@ -31934,7 +31934,7 @@ func X__duplocale(tls *TLS, old Tlocale_t) (r Tlocale_t) { if old == uintptr(-Int32FromInt32(1)) { old = uintptr(unsafe.Pointer(&X__libc)) + 56 } - *(*t__locale_struct)(unsafe.Pointer(new1)) = *(*t__locale_struct)(unsafe.Pointer(old)) + **(**t__locale_struct)(__ccgo_up(new1)) = **(**t__locale_struct)(__ccgo_up(old)) return new1 } @@ -98108,13 +98108,13 @@ var _rev_jis = [6879]uint16{ func _fuzzycmp(tls *TLS, a uintptr, b uintptr) (r int32) { for { - if !(*(*uint8)(unsafe.Pointer(a)) != 0 && *(*uint8)(unsafe.Pointer(b)) != 0) { + if !(**(**uint8)(__ccgo_up(a)) != 0 && **(**uint8)(__ccgo_up(b)) != 0) { break } - for *(*uint8)(unsafe.Pointer(a)) != 0 && uint32(*(*uint8)(unsafe.Pointer(a)))|uint32(32)-uint32('a') > uint32(26) && Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(a)))-int32('0')) > uint32(10) { + for **(**uint8)(__ccgo_up(a)) != 0 && uint32(**(**uint8)(__ccgo_up(a)))|uint32(32)-uint32('a') > uint32(26) && Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(a)))-int32('0')) > uint32(10) { a = a + 1 } - if uint32(*(*uint8)(unsafe.Pointer(a)))|uint32(32) != uint32(*(*uint8)(unsafe.Pointer(b))) { + if uint32(**(**uint8)(__ccgo_up(a)))|uint32(32) != uint32(**(**uint8)(__ccgo_up(b))) { return int32(1) } goto _1 @@ -98123,23 +98123,23 @@ func _fuzzycmp(tls *TLS, a uintptr, b uintptr) (r int32) { a = a + 1 b = b + 1 } - return BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(a))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(b)))) + return BoolInt32(Int32FromUint8(**(**uint8)(__ccgo_up(a))) != Int32FromUint8(**(**uint8)(__ccgo_up(b)))) } func _find_charmap(tls *TLS, name uintptr) (r Tsize_t) { var s uintptr _ = s - if !(*(*uint8)(unsafe.Pointer(name)) != 0) { + if !(**(**uint8)(__ccgo_up(name)) != 0) { name = uintptr(unsafe.Pointer(&_charmaps)) } /* "utf8" */ s = uintptr(unsafe.Pointer(&_charmaps)) for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { break } if !(_fuzzycmp(tls, name, s) != 0) { for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { break } goto _2 @@ -98150,11 +98150,11 @@ func _find_charmap(tls *TLS, name uintptr) (r Tsize_t) { return Uint64FromInt64(int64(s+uintptr(1)) - t__predefined_ptrdiff_t(uintptr(unsafe.Pointer(&_charmaps)))) } s = s + uintptr(_strlen(tls, s)+uint64(1)) - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) > int32(0200) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { + if Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) > int32(0200) { s = s + uintptr(2) } else { - s = s + uintptr(uint32(2)+(uint32(64)-uint32(*(*uint8)(unsafe.Pointer(s + 1))))*uint32(5)) + s = s + uintptr(uint32(2)+(uint32(64)-uint32(**(**uint8)(__ccgo_up(s + 1))))*uint32(5)) } } goto _1 @@ -98197,7 +98197,7 @@ func Xiconv_open(tls *TLS, to uintptr, from uintptr) (r Ticonv_t) { f = v2 } if v3 || v2 == Uint64FromInt32(-Int32FromInt32(1)) || Int32FromUint8(_charmaps[t]) >= int32(0330) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(-Int32FromInt32(1)) } cd = _combine_to_from(tls, t, f) @@ -98222,26 +98222,26 @@ func Xiconv_open(tls *TLS, to uintptr, from uintptr) (r Ticonv_t) { func _get_16(tls *TLS, s uintptr, e int32) (r uint32) { e = e & int32(1) - return Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(e))))<> int32(8)) - *(*uint8)(unsafe.Pointer(s + uintptr(int32(1)-e))) = uint8(c) + **(**uint8)(__ccgo_up(s + uintptr(e))) = uint8(c >> int32(8)) + **(**uint8)(__ccgo_up(s + uintptr(int32(1)-e))) = uint8(c) } func _get_32(tls *TLS, s uintptr, e int32) (r uint32) { e = e & int32(3) - return (uint32(*(*uint8)(unsafe.Pointer(s + uintptr(e))))+0)<> int32(24)) - *(*uint8)(unsafe.Pointer(s + uintptr(e^int32(1)))) = uint8(c >> int32(16)) - *(*uint8)(unsafe.Pointer(s + uintptr(e^int32(2)))) = uint8(c >> int32(8)) - *(*uint8)(unsafe.Pointer(s + uintptr(e^int32(3)))) = uint8(c) + **(**uint8)(__ccgo_up(s + uintptr(e^0))) = uint8(c >> int32(24)) + **(**uint8)(__ccgo_up(s + uintptr(e^int32(1)))) = uint8(c >> int32(16)) + **(**uint8)(__ccgo_up(s + uintptr(e^int32(2)))) = uint8(c >> int32(8)) + **(**uint8)(__ccgo_up(s + uintptr(e^int32(3)))) = uint8(c) } /* Adapt as needed */ @@ -98249,11 +98249,11 @@ func _put_32(tls *TLS, s uintptr, c uint32, e int32) { func _legacy_map(tls *TLS, map1 uintptr, c uint32) (r uint32) { var x, v1 uint32 _, _ = x, v1 - if c < Uint32FromInt32(int32(4)*Int32FromUint8(*(*uint8)(unsafe.Pointer(map1 + uintptr(-Int32FromInt32(1)))))) { + if c < Uint32FromInt32(int32(4)*Int32FromUint8(**(**uint8)(__ccgo_up(map1 + uintptr(-Int32FromInt32(1)))))) { return c } - x = c - Uint32FromInt32(int32(4)*Int32FromUint8(*(*uint8)(unsafe.Pointer(map1 + uintptr(-Int32FromInt32(1)))))) - x = Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(map1 + uintptr(x*uint32(5)/uint32(4)))))>>(uint32(2)*x%uint32(8)) | Int32FromUint8(*(*uint8)(unsafe.Pointer(map1 + uintptr(x*uint32(5)/uint32(4)+uint32(1)))))<<(uint32(8)-uint32(2)*x%uint32(8))&int32(1023)) + x = c - Uint32FromInt32(int32(4)*Int32FromUint8(**(**uint8)(__ccgo_up(map1 + uintptr(-Int32FromInt32(1)))))) + x = Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(map1 + uintptr(x*uint32(5)/uint32(4)))))>>(uint32(2)*x%uint32(8)) | Int32FromUint8(**(**uint8)(__ccgo_up(map1 + uintptr(x*uint32(5)/uint32(4)+uint32(1)))))<<(uint32(8)-uint32(2)*x%uint32(8))&int32(1023)) if x < uint32(256) { v1 = x } else { @@ -98270,7 +98270,7 @@ func _uni_to_jis(tls *TLS, c uint32) (r uint32) { for { i = nel / uint32(2) j = uint32(_rev_jis[b+i]) - d = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(j/uint32(256))*188 + uintptr(j%uint32(256))*2))) + d = uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(j/uint32(256))*188 + uintptr(j%uint32(256))*2))) if d == c { return j + uint32(0x2121) } else { @@ -98323,20 +98323,20 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui from = uint32(_extract_from(tls, cd)) map1 = uintptr(unsafe.Pointer(&_charmaps)) + uintptr(from) + uintptr(1) tomap = uintptr(unsafe.Pointer(&_charmaps)) + uintptr(to) + uintptr(1) - *(*Tmbstate_t)(unsafe.Pointer(bp + 24)) = Tmbstate_t{} - type1 = *(*uint8)(unsafe.Pointer(map1 + uintptr(-Int32FromInt32(1)))) - totype = *(*uint8)(unsafe.Pointer(tomap + uintptr(-Int32FromInt32(1)))) + **(**Tmbstate_t)(__ccgo_up(bp + 24)) = Tmbstate_t{} + type1 = **(**uint8)(__ccgo_up(map1 + uintptr(-Int32FromInt32(1)))) + totype = **(**uint8)(__ccgo_up(tomap + uintptr(-Int32FromInt32(1)))) ploc = uintptr(___get_tp(tls)) + 152 - loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) - if !(in != 0) || !(*(*uintptr)(unsafe.Pointer(in)) != 0) || !(*(*Tsize_t)(unsafe.Pointer(inb)) != 0) { + loc = **(**Tlocale_t)(__ccgo_up(ploc)) + if !(in != 0) || !(**(**uintptr)(__ccgo_up(in)) != 0) || !(**(**Tsize_t)(__ccgo_up(inb)) != 0) { return uint64(0) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = uintptr(unsafe.Pointer(&X__c_dot_utf8_locale)) + **(**Tlocale_t)(__ccgo_up(ploc)) = uintptr(unsafe.Pointer(&X__c_dot_utf8_locale)) for { - if !(*(*Tsize_t)(unsafe.Pointer(inb)) != 0) { + if !(**(**Tsize_t)(__ccgo_up(inb)) != 0) { break } - c = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in))))) + c = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in))))) l = uint64(1) switch Int32FromUint8(type1) { case int32(UTF_8): @@ -98388,14 +98388,14 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if c < uint32(128) { goto _23 } - l = Xmbrtowc(tls, bp+32, *(*uintptr)(unsafe.Pointer(in)), *(*Tsize_t)(unsafe.Pointer(inb)), bp+24) + l = Xmbrtowc(tls, bp+32, **(**uintptr)(__ccgo_up(in)), **(**Tsize_t)(__ccgo_up(inb)), bp+24) if l == Uint64FromInt32(-Int32FromInt32(1)) { goto ilseq } if l == Uint64FromInt32(-Int32FromInt32(2)) { goto starved } - c = *(*Twchar_t)(unsafe.Pointer(bp + 32)) + c = **(**Twchar_t)(__ccgo_up(bp + 32)) goto _23 _3: ; @@ -98406,10 +98406,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui _4: ; l = uint64(4) - if *(*Tsize_t)(unsafe.Pointer(inb)) < l { + if **(**Tsize_t)(__ccgo_up(inb)) < l { goto starved } - c = *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)))) + c = **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(in)))) if !(0 != 0) { goto _24 } @@ -98418,10 +98418,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui _5: ; l = uint64(4) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(4) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(4) { goto starved } - c = _get_32(tls, *(*uintptr)(unsafe.Pointer(in)), Int32FromUint8(type1)) + c = _get_32(tls, **(**uintptr)(__ccgo_up(in)), Int32FromUint8(type1)) _24: ; if c-uint32(0xd800) < uint32(0x800) || c >= uint32(0x110000) { @@ -98437,10 +98437,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui _7: ; l = uint64(2) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(2) { goto starved } - c = _get_16(tls, *(*uintptr)(unsafe.Pointer(in)), Int32FromUint8(type1)) + c = _get_16(tls, **(**uintptr)(__ccgo_up(in)), Int32FromUint8(type1)) if c-Uint32FromInt32(0xdc00) < uint32(0x400) { goto ilseq } @@ -98449,10 +98449,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto ilseq } l = uint64(4) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(4) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(4) { goto starved } - d = _get_16(tls, *(*uintptr)(unsafe.Pointer(in))+UintptrFromInt32(2), Int32FromUint8(type1)) + d = _get_16(tls, **(**uintptr)(__ccgo_up(in))+UintptrFromInt32(2), Int32FromUint8(type1)) if d-Uint32FromInt32(0xdc00) >= uint32(0x400) { goto ilseq } @@ -98465,10 +98465,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui ; l = uint64(0) if !((*Tstateful_cd)(unsafe.Pointer(scd)).Fstate != 0) { - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(2) { goto starved } - c = _get_16(tls, *(*uintptr)(unsafe.Pointer(in)), 0) + c = _get_16(tls, **(**uintptr)(__ccgo_up(in)), 0) if Int32FromUint8(type1) == int32(UCS2) { if c == uint32(0xfffe) { v26 = int32(UCS2LE) @@ -98495,10 +98495,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui ; l = uint64(0) if !((*Tstateful_cd)(unsafe.Pointer(scd)).Fstate != 0) { - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(4) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(4) { goto starved } - c = _get_32(tls, *(*uintptr)(unsafe.Pointer(in)), 0) + c = _get_32(tls, **(**uintptr)(__ccgo_up(in)), 0) if c == uint32(0xfffe0000) { v25 = int32(UTF_32LE) } else { @@ -98521,10 +98521,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _23 } l = uint64(2) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(2) { goto starved } - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(1)))) if c-uint32(129) <= Uint32FromInt32(Int32FromInt32(159)-Int32FromInt32(129)) { c = c - uint32(129) } else { @@ -98552,7 +98552,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if c >= uint32(84) { goto ilseq } - c = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(c)*188 + uintptr(d)*2))) + c = uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(c)*188 + uintptr(d)*2))) if !(c != 0) { goto ilseq } @@ -98563,10 +98563,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _23 } l = uint64(2) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(2) { goto starved } - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(1)))) if c == uint32(0x8e) { c = d if c-uint32(0xa1) > Uint32FromInt32(Int32FromInt32(0xdf)-Int32FromInt32(0xa1)) { @@ -98580,7 +98580,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if c >= uint32(84) || d >= uint32(94) { goto ilseq } - c = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(c)*188 + uintptr(d)*2))) + c = uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(c)*188 + uintptr(d)*2))) if !(c != 0) { goto ilseq } @@ -98592,11 +98592,11 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } if c == uint32('\033') { l = uint64(3) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(3) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(3) { goto starved } - c = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(2)))) + c = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(1)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(2)))) if c != uint32('(') && c != uint32('$') { goto ilseq } @@ -98631,16 +98631,16 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui fallthrough case uint32(3): l = uint64(2) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(2) { goto starved } - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(1)))) c = c - uint32(0x21) d = d - uint32(0x21) if c >= uint32(84) || d >= uint32(94) { goto ilseq } - c = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(c)*188 + uintptr(d)*2))) + c = uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(c)*188 + uintptr(d)*2))) if !(c != 0) { goto ilseq } @@ -98678,10 +98678,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto ilseq } l = uint64(2) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(2) { goto starved } - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(1)))) if d < uint32(0xa1) && Int32FromUint8(type1) == int32(GB2312) { goto ilseq } @@ -98690,16 +98690,16 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto ilseq } l = uint64(4) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(4) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(4) { goto starved } c = (uint32(10)*c + d - uint32('0')) * uint32(1260) - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(2)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(2)))) if d-uint32(0x81) > uint32(126) { goto ilseq } c = c + uint32(10)*(d-uint32(0x81)) - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(3)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(3)))) if d-uint32('0') > uint32(9) { goto ilseq } @@ -98721,7 +98721,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if !(j < int32(190)) { break } - if uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_gb18030)) + uintptr(i)*380 + uintptr(j)*2)))-d <= c-d { + if uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_gb18030)) + uintptr(i)*380 + uintptr(j)*2)))-d <= c-d { k = k + 1 } goto _31 @@ -98745,7 +98745,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if d > uint32(63) { d = d - 1 } - c = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_gb18030)) + uintptr(c)*380 + uintptr(d)*2))) + c = uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_gb18030)) + uintptr(c)*380 + uintptr(d)*2))) goto _23 _20: ; @@ -98753,10 +98753,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _23 } l = uint64(2) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(2) { goto starved } - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(1)))) if d-uint32(0x40) >= Uint32FromInt32(Int32FromInt32(0xff)-Int32FromInt32(0x40)) || d-uint32(0x7f) < Uint32FromInt32(Int32FromInt32(0xa1)-Int32FromInt32(0x7f)) { goto ilseq } @@ -98779,21 +98779,21 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui * range in the hkscs table then hard-coded * here. Ugly, yes. */ if c/uint32(256) == uint32(0xdc) { - *(*uintptr)(unsafe.Pointer(bp + 48)) = bp + 40 + **(**uintptr)(__ccgo_up(bp + 48)) = bp + 40 *(*uintptr)(unsafe.Pointer(bp)) = __ccgo_ts + 494 + uintptr(c%uint32(256)) *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint64(4) *(*Tsize_t)(unsafe.Pointer(bp + 16)) = uint64(8) tmpx = Xiconv(tls, _combine_to_from(tls, uint64(to), _find_charmap(tls, __ccgo_ts+511)), bp, bp+8, bp+48, bp+16) - tmplen = Uint64FromInt64(int64(*(*uintptr)(unsafe.Pointer(bp + 48))) - t__predefined_ptrdiff_t(bp+40)) - if tmplen > *(*Tsize_t)(unsafe.Pointer(outb)) { + tmplen = Uint64FromInt64(int64(**(**uintptr)(__ccgo_up(bp + 48))) - t__predefined_ptrdiff_t(bp+40)) + if tmplen > **(**Tsize_t)(__ccgo_up(outb)) { goto toobig } if tmpx != 0 { x = x + 1 } - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(out)), bp+40, tmplen) - *(*uintptr)(unsafe.Pointer(out)) += uintptr(tmplen) - *(*Tsize_t)(unsafe.Pointer(outb)) -= tmplen + Xmemcpy(tls, **(**uintptr)(__ccgo_up(out)), bp+40, tmplen) + **(**uintptr)(__ccgo_up(out)) += uintptr(tmplen) + **(**Tsize_t)(__ccgo_up(outb)) -= tmplen goto _1 } if !(c != 0) { @@ -98802,7 +98802,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _23 } c = c - uint32(0xa1) - c = Uint32FromInt32(Int32FromUint16(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_big5)) + uintptr(c)*314 + uintptr(d)*2))) | BoolInt32(c == uint32(0x27) && (d == uint32(0x3a) || d == uint32(0x3c) || d == uint32(0x42)))<= uint32(93) || d >= uint32(94) { @@ -98860,7 +98860,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if !(j1 < int32(94)) { break } - if uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ksc)) + uintptr(i1)*188 + uintptr(j1)*2)))-d <= c-d { + if uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_ksc)) + uintptr(i1)*188 + uintptr(j1)*2)))-d <= c-d { k = k + 1 } goto _34 @@ -98880,7 +98880,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } goto _23 } - c = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ksc)) + uintptr(c)*188 + uintptr(d)*2))) + c = uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_ksc)) + uintptr(c)*188 + uintptr(d)*2))) if !(c != 0) { goto ilseq } @@ -98933,26 +98933,26 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _51 _35: ; - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(4) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(4) { goto toobig } - *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(out)))) = c - *(*uintptr)(unsafe.Pointer(out)) += uintptr(4) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(4) + **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(out)))) = c + **(**uintptr)(__ccgo_up(out)) += uintptr(4) + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(4) goto _51 _36: ; - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(4) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(4) { k = Uint64FromInt32(Xwctomb(tls, bp+56, c)) - if *(*Tsize_t)(unsafe.Pointer(outb)) < k { + if **(**Tsize_t)(__ccgo_up(outb)) < k { goto toobig } - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(out)), bp+56, k) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(out)), bp+56, k) } else { - k = Uint64FromInt32(Xwctomb(tls, *(*uintptr)(unsafe.Pointer(out)), c)) + k = Uint64FromInt32(Xwctomb(tls, **(**uintptr)(__ccgo_up(out)), c)) } - *(*uintptr)(unsafe.Pointer(out)) += uintptr(k) - *(*Tsize_t)(unsafe.Pointer(outb)) -= k + **(**uintptr)(__ccgo_up(out)) += uintptr(k) + **(**Tsize_t)(__ccgo_up(outb)) -= k goto _51 _37: ; @@ -98968,7 +98968,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui ; _38: ; - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(1) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(1) { goto toobig } if !(c < uint32(256) && c == _legacy_map(tls, tomap, c)) { @@ -98977,14 +98977,14 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto revout revout: ; - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(1) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(1) { goto toobig } v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8(c) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(1) + **(**uint8)(__ccgo_up(v54)) = uint8(c) + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(1) goto _51 _53: ; @@ -99026,7 +99026,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if !(c != 0) { goto subst } - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(2) { goto toobig } d = c % uint32(256) @@ -99039,7 +99039,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } else { v25 = int32(176) } - *(*uint8)(unsafe.Pointer(v54)) = uint8((c+uint32(1))/uint32(2) + Uint32FromInt32(v25)) + **(**uint8)(__ccgo_up(v54)) = uint8((c+uint32(1))/uint32(2) + Uint32FromInt32(v25)) v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 @@ -99048,8 +99048,8 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } else { v62 = d + uint32(126) } - *(*uint8)(unsafe.Pointer(v54)) = uint8(v62) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(2) + **(**uint8)(__ccgo_up(v54)) = uint8(v62) + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(2) goto _51 _40: ; @@ -99064,18 +99064,18 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if !(c != 0) { goto subst } - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(2) { goto toobig } v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8(c/uint32(256) + uint32(0x80)) + **(**uint8)(__ccgo_up(v54)) = uint8(c/uint32(256) + uint32(0x80)) v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8(c%uint32(256) + uint32(0x80)) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(2) + **(**uint8)(__ccgo_up(v54)) = uint8(c%uint32(256) + uint32(0x80)) + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(2) goto _51 _41: ; @@ -99083,102 +99083,102 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto revout } if c-uint32(0xff61) <= Uint32FromInt32(Int32FromInt32(0xdf)-Int32FromInt32(0xa1)) || c == uint32(0xa5) || c == uint32(0x203e) { - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(7) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(7) { goto toobig } v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('\033') + **(**uint8)(__ccgo_up(v54)) = uint8('\033') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('(') + **(**uint8)(__ccgo_up(v54)) = uint8('(') if c == uint32(0xa5) { v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('J') + **(**uint8)(__ccgo_up(v54)) = uint8('J') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('\\') + **(**uint8)(__ccgo_up(v54)) = uint8('\\') } else { if c == uint32(0x203e) { v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('J') + **(**uint8)(__ccgo_up(v54)) = uint8('J') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('~') + **(**uint8)(__ccgo_up(v54)) = uint8('~') } else { v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('I') + **(**uint8)(__ccgo_up(v54)) = uint8('I') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8(c - uint32(0xff61) + uint32(0x21)) + **(**uint8)(__ccgo_up(v54)) = uint8(c - uint32(0xff61) + uint32(0x21)) } } v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('\033') + **(**uint8)(__ccgo_up(v54)) = uint8('\033') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('(') + **(**uint8)(__ccgo_up(v54)) = uint8('(') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('B') - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(7) + **(**uint8)(__ccgo_up(v54)) = uint8('B') + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(7) goto _51 } c = _uni_to_jis(tls, c) if !(c != 0) { goto subst } - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(8) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(8) { goto toobig } v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('\033') + **(**uint8)(__ccgo_up(v54)) = uint8('\033') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('$') + **(**uint8)(__ccgo_up(v54)) = uint8('$') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('B') + **(**uint8)(__ccgo_up(v54)) = uint8('B') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8(c / uint32(256)) + **(**uint8)(__ccgo_up(v54)) = uint8(c / uint32(256)) v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8(c % uint32(256)) + **(**uint8)(__ccgo_up(v54)) = uint8(c % uint32(256)) v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('\033') + **(**uint8)(__ccgo_up(v54)) = uint8('\033') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('(') + **(**uint8)(__ccgo_up(v54)) = uint8('(') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('B') - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(8) + **(**uint8)(__ccgo_up(v54)) = uint8('B') + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(8) goto _51 _42: ; @@ -99197,22 +99197,22 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if c >= uint32(0x10000) { c = uint32(0xFFFD) } - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(2) { goto toobig } - _put_16(tls, *(*uintptr)(unsafe.Pointer(out)), c, Int32FromUint8(totype)) - *(*uintptr)(unsafe.Pointer(out)) += uintptr(2) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(2) + _put_16(tls, **(**uintptr)(__ccgo_up(out)), c, Int32FromUint8(totype)) + **(**uintptr)(__ccgo_up(out)) += uintptr(2) + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(2) goto _51 } - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(4) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(4) { goto toobig } c = c - uint32(0x10000) - _put_16(tls, *(*uintptr)(unsafe.Pointer(out)), c>>int32(10)|uint32(0xd800), Int32FromUint8(totype)) - _put_16(tls, *(*uintptr)(unsafe.Pointer(out))+UintptrFromInt32(2), c&uint32(0x3ff)|uint32(0xdc00), Int32FromUint8(totype)) - *(*uintptr)(unsafe.Pointer(out)) += uintptr(4) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(4) + _put_16(tls, **(**uintptr)(__ccgo_up(out)), c>>int32(10)|uint32(0xd800), Int32FromUint8(totype)) + _put_16(tls, **(**uintptr)(__ccgo_up(out))+UintptrFromInt32(2), c&uint32(0x3ff)|uint32(0xdc00), Int32FromUint8(totype)) + **(**uintptr)(__ccgo_up(out)) += uintptr(4) + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(4) goto _51 _48: ; @@ -99221,22 +99221,22 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui ; _49: ; - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(4) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(4) { goto toobig } - _put_32(tls, *(*uintptr)(unsafe.Pointer(out)), c, Int32FromUint8(totype)) - *(*uintptr)(unsafe.Pointer(out)) += uintptr(4) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(4) + _put_32(tls, **(**uintptr)(__ccgo_up(out)), c, Int32FromUint8(totype)) + **(**uintptr)(__ccgo_up(out)) += uintptr(4) + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(4) goto _51 _51: ; goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(in)) += uintptr(l) - *(*Tsize_t)(unsafe.Pointer(inb)) -= l + **(**uintptr)(__ccgo_up(in)) += uintptr(l) + **(**Tsize_t)(__ccgo_up(inb)) -= l } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return x goto ilseq ilseq: @@ -99258,8 +99258,8 @@ starved: goto end end: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = err - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**int32)(__ccgo_up(X__errno_location(tls))) = err + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return x } @@ -99290,7 +99290,7 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { cat = item >> int32(16) idx = item & int32(65535) if item == int32(CODESET) { - if *(*uintptr)(unsafe.Pointer(loc)) != 0 { + if **(**uintptr)(__ccgo_up(loc)) != 0 { v1 = __ccgo_ts + 322 } else { v1 = __ccgo_ts + 516 @@ -99299,8 +99299,8 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { } /* _NL_LOCALE_NAME extension */ if idx == int32(65535) && cat < int32(LC_ALL) { - if *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*8)) != 0 { - v1 = *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*8)) + 16 + if **(**uintptr)(__ccgo_up(loc + uintptr(cat)*8)) != 0 { + v1 = **(**uintptr)(__ccgo_up(loc + uintptr(cat)*8)) + 16 } else { v1 = __ccgo_ts + 522 } @@ -99335,7 +99335,7 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { break } for { - if !(*(*uint8)(unsafe.Pointer(str)) != 0) { + if !(**(**uint8)(__ccgo_up(str)) != 0) { break } goto _4 @@ -99349,8 +99349,8 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { idx = idx - 1 str = str + 1 } - if cat != int32(LC_NUMERIC) && *(*uint8)(unsafe.Pointer(str)) != 0 { - str = X__lctrans(tls, str, *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*8))) + if cat != int32(LC_NUMERIC) && **(**uint8)(__ccgo_up(str)) != 0 { + str = X__lctrans(tls, str, **(**uintptr)(__ccgo_up(loc + uintptr(cat)*8))) } return str } @@ -99423,18 +99423,18 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = builtin, l, map1, n, new1, p, path, z, v1, v2, v3, v4, v5, v6, v7 new1 = uintptr(0) path = uintptr(0) - if !(*(*uint8)(unsafe.Pointer(val)) != 0) { + if !(**(**uint8)(__ccgo_up(val)) != 0) { v1 = Xgetenv(tls, __ccgo_ts+524) val = v1 - if v3 = v1 != 0 && *(*uint8)(unsafe.Pointer(val)) != 0; !v3 { + if v3 = v1 != 0 && **(**uint8)(__ccgo_up(val)) != 0; !v3 { v2 = Xgetenv(tls, uintptr(unsafe.Pointer(&_envvars))+uintptr(cat)*12) val = v2 } - if v5 = v3 || v2 != 0 && *(*uint8)(unsafe.Pointer(val)) != 0; !v5 { + if v5 = v3 || v2 != 0 && **(**uint8)(__ccgo_up(val)) != 0; !v5 { v4 = Xgetenv(tls, __ccgo_ts+336) val = v4 } - if v7 = v5 || v4 != 0 && *(*uint8)(unsafe.Pointer(val)) != 0; !v7 { + if v7 = v5 || v4 != 0 && **(**uint8)(__ccgo_up(val)) != 0; !v7 { v6 = __ccgo_ts + 531 val = v6 } @@ -99443,7 +99443,7 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { /* Limit name length and forbid leading dot or any slashes. */ n = uint64(0) for { - if !(n < uint64(LOCALE_NAME_MAX) && *(*uint8)(unsafe.Pointer(val + uintptr(n))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(val + uintptr(n)))) != int32('/')) { + if !(n < uint64(LOCALE_NAME_MAX) && **(**uint8)(__ccgo_up(val + uintptr(n))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(val + uintptr(n)))) != int32('/')) { break } goto _8 @@ -99451,12 +99451,12 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { ; n = n + 1 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(val))) == int32('.') || *(*uint8)(unsafe.Pointer(val + uintptr(n))) != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(val))) == int32('.') || **(**uint8)(__ccgo_up(val + uintptr(n))) != 0 { val = __ccgo_ts + 531 } - builtin = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(val))) == int32('C') && !(*(*uint8)(unsafe.Pointer(val + 1)) != 0) || !(Xstrcmp(tls, val, __ccgo_ts+531) != 0) || !(Xstrcmp(tls, val, __ccgo_ts+539) != 0)) + builtin = BoolInt32(Int32FromUint8(**(**uint8)(__ccgo_up(val))) == int32('C') && !(**(**uint8)(__ccgo_up(val + 1)) != 0) || !(Xstrcmp(tls, val, __ccgo_ts+531) != 0) || !(Xstrcmp(tls, val, __ccgo_ts+539) != 0)) if builtin != 0 { - if cat == LC_CTYPE && Int32FromUint8(*(*uint8)(unsafe.Pointer(val + 1))) == int32('.') { + if cat == LC_CTYPE && Int32FromUint8(**(**uint8)(__ccgo_up(val + 1))) == int32('.') { return uintptr(unsafe.Pointer(&X__c_dot_utf8)) } return uintptr(0) @@ -99480,7 +99480,7 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { /* FIXME: add a default path? */ if path != 0 { for { - if !(*(*uint8)(unsafe.Pointer(path)) != 0) { + if !(**(**uint8)(__ccgo_up(path)) != 0) { break } z = X__strchrnul(tls, path, int32(':')) @@ -99489,20 +99489,20 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { goto _10 } Xmemcpy(tls, bp, path, l) - (*(*[256]uint8)(unsafe.Pointer(bp)))[l] = uint8('/') + (**(**[256]uint8)(__ccgo_up(bp)))[l] = uint8('/') Xmemcpy(tls, bp+uintptr(l)+uintptr(1), val, n) - (*(*[256]uint8)(unsafe.Pointer(bp)))[l+uint64(1)+n] = uint8(0) + (**(**[256]uint8)(__ccgo_up(bp)))[l+uint64(1)+n] = uint8(0) map1 = X__map_file(tls, bp, bp+256) if map1 != 0 { new1 = Xmalloc(tls, uint64(48)) if !(new1 != 0) { - X__munmap(tls, map1, *(*Tsize_t)(unsafe.Pointer(bp + 256))) + X__munmap(tls, map1, **(**Tsize_t)(__ccgo_up(bp + 256))) break } (*t__locale_map)(unsafe.Pointer(new1)).Fmap1 = map1 - (*t__locale_map)(unsafe.Pointer(new1)).Fmap_size = *(*Tsize_t)(unsafe.Pointer(bp + 256)) + (*t__locale_map)(unsafe.Pointer(new1)).Fmap_size = **(**Tsize_t)(__ccgo_up(bp + 256)) Xmemcpy(tls, new1+16, val, n) - *(*uint8)(unsafe.Pointer(new1 + 16 + uintptr(n))) = uint8(0) + **(**uint8)(__ccgo_up(new1 + 16 + uintptr(n))) = uint8(0) (*t__locale_map)(unsafe.Pointer(new1)).Fnext = AtomicLoadPUintptr(uintptr(unsafe.Pointer(&_loc_head))) AtomicStorePUintptr(uintptr(unsafe.Pointer(&_loc_head)), new1) break @@ -99510,7 +99510,7 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { goto _10 _10: ; - path = z + BoolUintptr(!!(*(*uint8)(unsafe.Pointer(z)) != 0)) + path = z + BoolUintptr(!!(**(**uint8)(__ccgo_up(z)) != 0)) } } /* If no locale definition was found, make a locale map @@ -99525,7 +99525,7 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { (*t__locale_map)(unsafe.Pointer(new1)).Fmap1 = X__c_dot_utf8.Fmap1 (*t__locale_map)(unsafe.Pointer(new1)).Fmap_size = X__c_dot_utf8.Fmap_size Xmemcpy(tls, new1+16, val, n) - *(*uint8)(unsafe.Pointer(new1 + 16 + uintptr(n))) = uint8(0) + **(**uint8)(__ccgo_up(new1 + 16 + uintptr(n))) = uint8(0) (*t__locale_map)(unsafe.Pointer(new1)).Fnext = AtomicLoadPUintptr(uintptr(unsafe.Pointer(&_loc_head))) AtomicStorePUintptr(uintptr(unsafe.Pointer(&_loc_head)), new1) } @@ -99609,7 +99609,7 @@ func _do_newlocale(tls *TLS, mask int32, name uintptr, loc Tlocale_t) (r Tlocale break } if !(mask&(Int32FromInt32(1)<,< are accepted with or without = */ - if i < int32(6) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) == Int32FromUint8(_opch2[i]) { + if i < int32(6) && Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) == Int32FromUint8(_opch2[i]) { (*Tst)(unsafe.Pointer(st)).Fop = i return s + uintptr(2) } @@ -99915,12 +99915,12 @@ func _evalexpr(tls *TLS, st uintptr, s uintptr, d int32) (r uintptr) { return __ccgo_ts } s = _evalbinop(tls, st, s, 0, d) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('?') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32('?') { return s } a = (*Tst)(unsafe.Pointer(st)).Fr s = _evalexpr(tls, st, s+uintptr(1), d) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32(':') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32(':') { return __ccgo_ts } b = (*Tst)(unsafe.Pointer(st)).Fr @@ -99944,10 +99944,10 @@ func X__pleval(tls *TLS, s uintptr, n uint64) (r uint64) { var v1 uint64 var _ /* st at bp+0 */ Tst _ = v1 - (*(*Tst)(unsafe.Pointer(bp))).Fn = n + (**(**Tst)(__ccgo_up(bp))).Fn = n s = _evalexpr(tls, bp, s, int32(100)) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32(';') { - v1 = (*(*Tst)(unsafe.Pointer(bp))).Fr + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32(';') { + v1 = (**(**Tst)(__ccgo_up(bp))).Fr } else { v1 = Uint64FromInt32(-Int32FromInt32(1)) } @@ -99980,7 +99980,7 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { * on the format, so it can easily be changed if needed. */ if cat == int32(LC_ALL) { if name != 0 { - *(*[24]uint8)(unsafe.Pointer(bp + 48)) = [24]uint8{'C', '.', 'U', 'T', 'F', '-', '8'} + **(**[24]uint8)(__ccgo_up(bp + 48)) = [24]uint8{'C', '.', 'U', 'T', 'F', '-', '8'} p = name i = 0 for { @@ -99990,8 +99990,8 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { z = X__strchrnul(tls, p, int32(';')) if int64(z)-int64(p) <= int64(LOCALE_NAME_MAX) { Xmemcpy(tls, bp+48, p, Uint64FromInt64(int64(z)-int64(p))) - (*(*[24]uint8)(unsafe.Pointer(bp + 48)))[int64(z)-int64(p)] = uint8(0) - if *(*uint8)(unsafe.Pointer(z)) != 0 { + (**(**[24]uint8)(__ccgo_up(bp + 48)))[int64(z)-int64(p)] = uint8(0) + if **(**uint8)(__ccgo_up(z)) != 0 { p = z + uintptr(1) } } @@ -100000,13 +100000,13 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { ___unlock(tls, uintptr(unsafe.Pointer(&X__locale_lock))) return uintptr(0) } - *(*uintptr)(unsafe.Pointer(bp + uintptr(i)*8)) = lm + **(**uintptr)(__ccgo_up(bp + uintptr(i)*8)) = lm goto _1 _1: ; i = i + 1 } - X__libc.Fglobal_locale = *(*t__locale_struct)(unsafe.Pointer(bp)) + X__libc.Fglobal_locale = **(**t__locale_struct)(__ccgo_up(bp)) } s = uintptr(unsafe.Pointer(&_buf1)) same = 0 @@ -100015,8 +100015,8 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { if !(i < int32(LC_ALL)) { break } - lm1 = *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 56 + uintptr(i)*8)) - if lm1 == *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 56)) { + lm1 = **(**uintptr)(__ccgo_up(uintptr(unsafe.Pointer(&X__libc)) + 56 + uintptr(i)*8)) + if lm1 == **(**uintptr)(__ccgo_up(uintptr(unsafe.Pointer(&X__libc)) + 56)) { same = same + 1 } if lm1 != 0 { @@ -100027,7 +100027,7 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { part1 = v3 l = _strlen(tls, part1) Xmemcpy(tls, s, part1, l) - *(*uint8)(unsafe.Pointer(s + uintptr(l))) = uint8(';') + **(**uint8)(__ccgo_up(s + uintptr(l))) = uint8(';') s = s + uintptr(l+uint64(1)) goto _2 _2: @@ -100036,7 +100036,7 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { } s = s - 1 v3 = s - *(*uint8)(unsafe.Pointer(v3)) = uint8(0) + **(**uint8)(__ccgo_up(v3)) = uint8(0) ___unlock(tls, uintptr(unsafe.Pointer(&X__locale_lock))) if same == int32(LC_ALL) { v3 = part1 @@ -100051,9 +100051,9 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { ___unlock(tls, uintptr(unsafe.Pointer(&X__locale_lock))) return uintptr(0) } - *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 56 + uintptr(cat)*8)) = lm + **(**uintptr)(__ccgo_up(uintptr(unsafe.Pointer(&X__libc)) + 56 + uintptr(cat)*8)) = lm } else { - lm = *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 56 + uintptr(cat)*8)) + lm = **(**uintptr)(__ccgo_up(uintptr(unsafe.Pointer(&X__libc)) + 56 + uintptr(cat)*8)) } if lm != 0 { v3 = lm + 16 @@ -100100,10 +100100,10 @@ func _vstrfmon_l(tls *TLS, s uintptr, n Tsize_t, loc Tlocale_t, fmt uintptr, ap s0 = s _3: ; - if !(n != 0 && *(*uint8)(unsafe.Pointer(fmt)) != 0) { + if !(n != 0 && **(**uint8)(__ccgo_up(fmt)) != 0) { goto _1 } - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) != int32('%')) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(fmt))) != int32('%')) { goto _4 } goto literal @@ -100113,13 +100113,13 @@ literal: s = s + 1 v6 = fmt fmt = fmt + 1 - *(*uint8)(unsafe.Pointer(v5)) = *(*uint8)(unsafe.Pointer(v6)) + **(**uint8)(__ccgo_up(v5)) = **(**uint8)(__ccgo_up(v6)) n = n - 1 goto _2 _4: ; fmt = fmt + 1 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) == int32('%') { + if Int32FromUint8(**(**uint8)(__ccgo_up(fmt))) == int32('%') { goto literal } fill = int32(' ') @@ -100128,11 +100128,11 @@ _4: nosym = 0 left = 0 for { - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(fmt))) { case int32('='): fmt = fmt + 1 v5 = fmt - fill = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + fill = Int32FromUint8(**(**uint8)(__ccgo_up(v5))) goto _7 case int32('^'): nogrp = int32(1) @@ -100157,10 +100157,10 @@ _4: } fw = 0 for { - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(fmt)))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(fmt)))-uint32('0') < uint32(10)) != 0) { break } - fw = int32(10)*fw + (Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) - int32('0')) + fw = int32(10)*fw + (Int32FromUint8(**(**uint8)(__ccgo_up(fmt))) - int32('0')) goto _9 _9: ; @@ -100168,28 +100168,28 @@ _4: } lp = 0 rp = int32(2) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) == int32('#') { + if Int32FromUint8(**(**uint8)(__ccgo_up(fmt))) == int32('#') { lp = 0 fmt = fmt + 1 for { - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(fmt)))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(fmt)))-uint32('0') < uint32(10)) != 0) { break } - lp = int32(10)*lp + (Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) - int32('0')) + lp = int32(10)*lp + (Int32FromUint8(**(**uint8)(__ccgo_up(fmt))) - int32('0')) goto _10 _10: ; fmt = fmt + 1 } } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) == int32('.') { + if Int32FromUint8(**(**uint8)(__ccgo_up(fmt))) == int32('.') { rp = 0 fmt = fmt + 1 for { - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(fmt)))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(fmt)))-uint32('0') < uint32(10)) != 0) { break } - rp = int32(10)*rp + (Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) - int32('0')) + rp = int32(10)*rp + (Int32FromUint8(**(**uint8)(__ccgo_up(fmt))) - int32('0')) goto _11 _11: ; @@ -100198,7 +100198,7 @@ _4: } v5 = fmt fmt = fmt + 1 - intl = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) == int32('i')) + intl = BoolInt32(Int32FromUint8(**(**uint8)(__ccgo_up(v5))) == int32('i')) w = lp + int32(1) + rp if !(left != 0) && fw > w { w = fw @@ -100206,7 +100206,7 @@ _4: x = VaFloat64(&ap) l = Uint64FromInt32(Xsnprintf(tls, s, n, __ccgo_ts+560, VaList(bp+8, w, rp, x))) if l >= n { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(E2BIG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(E2BIG) return int64(-int32(1)) } s = s + uintptr(l) @@ -100371,7 +100371,7 @@ func Xtextdomain(tls *TLS, domainname uintptr) (r uintptr) { } domlen = _strlen(tls, domainname) if domlen > uint64(NAME_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } if !(_current_domain != 0) { @@ -100481,7 +100481,7 @@ func X__wcsxfrm_l(tls *TLS, dest uintptr, src uintptr, n Tsize_t, loc Tlocale_t) } else { if n != 0 { Xwmemcpy(tls, dest, src, n-uint64(1)) - *(*Twchar_t)(unsafe.Pointer(dest + uintptr(n-uint64(1))*4)) = uint32(0) + **(**Twchar_t)(__ccgo_up(dest + uintptr(n-uint64(1))*4)) = uint32(0) } } return l @@ -100512,7 +100512,7 @@ func Xreallocarray(tls *TLS, ptr uintptr, m Tsize_t, n Tsize_t) (r uintptr) { defer func() { trc("-> %v", r) }() } if n != 0 && m > Uint64FromInt32(-Int32FromInt32(1))/n { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return uintptr(0) } return Xrealloc(tls, ptr, m*n) @@ -100905,25 +100905,25 @@ func X__rem_pio2(tls *TLS, x float64, y uintptr) (r1 int32) { if ix <= uint32(0x4002d97c) { /* |x| ~<= 3pi/4 */ if !(sign != 0) { z = x - _pio2_1 /* one round good to 85 bits */ - *(*float64)(unsafe.Pointer(y)) = z - _pio2_1t - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) - _pio2_1t + **(**float64)(__ccgo_up(y)) = z - _pio2_1t + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) - _pio2_1t return int32(1) } else { z = x + _pio2_1 - *(*float64)(unsafe.Pointer(y)) = z + _pio2_1t - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) + _pio2_1t + **(**float64)(__ccgo_up(y)) = z + _pio2_1t + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) + _pio2_1t return -int32(1) } } else { if !(sign != 0) { z = x - float64(Float64FromInt32(2)*_pio2_1) - *(*float64)(unsafe.Pointer(y)) = z - Tdouble_t(Float64FromInt32(2)*_pio2_1t) - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) - Tdouble_t(Float64FromInt32(2)*_pio2_1t) + **(**float64)(__ccgo_up(y)) = z - Tdouble_t(Float64FromInt32(2)*_pio2_1t) + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) - Tdouble_t(Float64FromInt32(2)*_pio2_1t) return int32(2) } else { z = x + float64(Float64FromInt32(2)*_pio2_1) - *(*float64)(unsafe.Pointer(y)) = z + Tdouble_t(Float64FromInt32(2)*_pio2_1t) - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) + Tdouble_t(Float64FromInt32(2)*_pio2_1t) + **(**float64)(__ccgo_up(y)) = z + Tdouble_t(Float64FromInt32(2)*_pio2_1t) + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) + Tdouble_t(Float64FromInt32(2)*_pio2_1t) return -int32(2) } } @@ -100935,13 +100935,13 @@ func X__rem_pio2(tls *TLS, x float64, y uintptr) (r1 int32) { } if !(sign != 0) { z = x - float64(Float64FromInt32(3)*_pio2_1) - *(*float64)(unsafe.Pointer(y)) = z - Tdouble_t(Float64FromInt32(3)*_pio2_1t) - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) - Tdouble_t(Float64FromInt32(3)*_pio2_1t) + **(**float64)(__ccgo_up(y)) = z - Tdouble_t(Float64FromInt32(3)*_pio2_1t) + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) - Tdouble_t(Float64FromInt32(3)*_pio2_1t) return int32(3) } else { z = x + float64(Float64FromInt32(3)*_pio2_1) - *(*float64)(unsafe.Pointer(y)) = z + Tdouble_t(Float64FromInt32(3)*_pio2_1t) - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) + Tdouble_t(Float64FromInt32(3)*_pio2_1t) + **(**float64)(__ccgo_up(y)) = z + Tdouble_t(Float64FromInt32(3)*_pio2_1t) + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) + Tdouble_t(Float64FromInt32(3)*_pio2_1t) return -int32(3) } } else { @@ -100950,13 +100950,13 @@ func X__rem_pio2(tls *TLS, x float64, y uintptr) (r1 int32) { } if !(sign != 0) { z = x - float64(Float64FromInt32(4)*_pio2_1) - *(*float64)(unsafe.Pointer(y)) = z - Tdouble_t(Float64FromInt32(4)*_pio2_1t) - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) - Tdouble_t(Float64FromInt32(4)*_pio2_1t) + **(**float64)(__ccgo_up(y)) = z - Tdouble_t(Float64FromInt32(4)*_pio2_1t) + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) - Tdouble_t(Float64FromInt32(4)*_pio2_1t) return int32(4) } else { z = x + float64(Float64FromInt32(4)*_pio2_1) - *(*float64)(unsafe.Pointer(y)) = z + Tdouble_t(Float64FromInt32(4)*_pio2_1t) - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) + Tdouble_t(Float64FromInt32(4)*_pio2_1t) + **(**float64)(__ccgo_up(y)) = z + Tdouble_t(Float64FromInt32(4)*_pio2_1t) + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) + Tdouble_t(Float64FromInt32(4)*_pio2_1t) return -int32(4) } } @@ -100986,8 +100986,8 @@ medium: w = Tdouble_t(fn * _pio2_1t) } } - *(*float64)(unsafe.Pointer(y)) = r - w - *(*float64)(unsafe.Pointer(bp)) = *(*float64)(unsafe.Pointer(y)) + **(**float64)(__ccgo_up(y)) = r - w + *(*float64)(unsafe.Pointer(bp)) = **(**float64)(__ccgo_up(y)) ey = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(52) & uint64(0x7ff)) ex = Int32FromUint32(ix >> int32(20)) if ex-ey > int32(16) { /* 2nd round, good to 118 bits */ @@ -100995,18 +100995,18 @@ medium: w = Tdouble_t(fn * _pio2_2) r = t - w w = Tdouble_t(fn*_pio2_2t) - (t - r - w) - *(*float64)(unsafe.Pointer(y)) = r - w - *(*float64)(unsafe.Pointer(bp)) = *(*float64)(unsafe.Pointer(y)) + **(**float64)(__ccgo_up(y)) = r - w + *(*float64)(unsafe.Pointer(bp)) = **(**float64)(__ccgo_up(y)) ey = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(52) & uint64(0x7ff)) if ex-ey > int32(49) { /* 3rd round, good to 151 bits, covers all cases */ t = r w = Tdouble_t(fn * _pio2_3) r = t - w w = Tdouble_t(fn*_pio2_3t) - (t - r - w) - *(*float64)(unsafe.Pointer(y)) = r - w + **(**float64)(__ccgo_up(y)) = r - w } } - *(*float64)(unsafe.Pointer(y + 1*8)) = r - *(*float64)(unsafe.Pointer(y)) - w + **(**float64)(__ccgo_up(y + 1*8)) = r - **(**float64)(__ccgo_up(y)) - w return n _1: ; @@ -101015,8 +101015,8 @@ _1: */ if ix >= uint32(0x7ff00000) { /* x is inf or NaN */ v2 = x - x - *(*float64)(unsafe.Pointer(y + 1*8)) = v2 - *(*float64)(unsafe.Pointer(y)) = v2 + **(**float64)(__ccgo_up(y + 1*8)) = v2 + **(**float64)(__ccgo_up(y)) = v2 return 0 } /* set z = scalbn(|x|,-ilogb(x)+23) */ @@ -101029,26 +101029,26 @@ _1: if !(i < int32(2)) { break } - (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i] = float64(int32(z)) - z = Tdouble_t((z - (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i]) * float64(1.6777216e+07)) + (**(**[3]float64)(__ccgo_up(bp + 8)))[i] = float64(int32(z)) + z = Tdouble_t((z - (**(**[3]float64)(__ccgo_up(bp + 8)))[i]) * float64(1.6777216e+07)) goto _3 _3: ; i = i + 1 } - (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i] = z + (**(**[3]float64)(__ccgo_up(bp + 8)))[i] = z /* skip zero terms, first term is non-zero */ - for (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i] == float64(0) { + for (**(**[3]float64)(__ccgo_up(bp + 8)))[i] == float64(0) { i = i - 1 } n = X__rem_pio2_large(tls, bp+8, bp+32, Int32FromUint32(ix>>Int32FromInt32(20))-(Int32FromInt32(0x3ff)+Int32FromInt32(23)), i+int32(1), int32(1)) if sign != 0 { - *(*float64)(unsafe.Pointer(y)) = -(*(*[2]float64)(unsafe.Pointer(bp + 32)))[0] - *(*float64)(unsafe.Pointer(y + 1*8)) = -(*(*[2]float64)(unsafe.Pointer(bp + 32)))[int32(1)] + **(**float64)(__ccgo_up(y)) = -(**(**[2]float64)(__ccgo_up(bp + 32)))[0] + **(**float64)(__ccgo_up(y + 1*8)) = -(**(**[2]float64)(__ccgo_up(bp + 32)))[int32(1)] return -n } - *(*float64)(unsafe.Pointer(y)) = (*(*[2]float64)(unsafe.Pointer(bp + 32)))[0] - *(*float64)(unsafe.Pointer(y + 1*8)) = (*(*[2]float64)(unsafe.Pointer(bp + 32)))[int32(1)] + **(**float64)(__ccgo_up(y)) = (**(**[2]float64)(__ccgo_up(bp + 32)))[0] + **(**float64)(__ccgo_up(y + 1*8)) = (**(**[2]float64)(__ccgo_up(bp + 32)))[int32(1)] return n } @@ -101210,7 +101210,7 @@ func X__rem_pio2_large(tls *TLS, x uintptr, y uintptr, e0 int32, nx int32, prec if !(j <= jx) { break } - fw = fw + float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8))*f[jx+i-j]) + fw = fw + float64(**(**float64)(__ccgo_up(x + uintptr(j)*8))*f[jx+i-j]) goto _4 _4: ; @@ -101235,7 +101235,7 @@ recompute: break } fw = float64(int32(float64(Float64FromFloat64(5.960464477539063e-08) * z))) - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] = int32(z - float64(Float64FromFloat64(1.6777216e+07)*fw)) + (**(**[20]Tint32_t)(__ccgo_up(bp)))[i] = int32(z - float64(Float64FromFloat64(1.6777216e+07)*fw)) z = q[j-int32(1)] + fw goto _5 _5: @@ -101250,13 +101250,13 @@ recompute: z = z - float64(n) ih = 0 if q0 > 0 { /* need iq[jz-1] to determine n */ - i = (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz-int32(1)] >> (int32(24) - q0) + i = (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz-int32(1)] >> (int32(24) - q0) n = n + i - *(*Tint32_t)(unsafe.Pointer(bp + uintptr(jz-int32(1))*4)) -= i << (int32(24) - q0) - ih = (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz-int32(1)] >> (int32(23) - q0) + **(**Tint32_t)(__ccgo_up(bp + uintptr(jz-int32(1))*4)) -= i << (int32(24) - q0) + ih = (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz-int32(1)] >> (int32(23) - q0) } else { if q0 == 0 { - ih = (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz-int32(1)] >> int32(23) + ih = (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz-int32(1)] >> int32(23) } else { if z >= float64(0.5) { ih = int32(2) @@ -101271,14 +101271,14 @@ recompute: if !(i < jz) { break } /* compute 1-q */ - j = (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] + j = (**(**[20]Tint32_t)(__ccgo_up(bp)))[i] if carry == 0 { if j != 0 { carry = int32(1) - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] = int32(0x1000000) - j + (**(**[20]Tint32_t)(__ccgo_up(bp)))[i] = int32(0x1000000) - j } } else { - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] = int32(0xffffff) - j + (**(**[20]Tint32_t)(__ccgo_up(bp)))[i] = int32(0xffffff) - j } goto _6 _6: @@ -101288,9 +101288,9 @@ recompute: if q0 > 0 { /* rare case: chance is 1 in 12 */ switch q0 { case int32(1): - *(*Tint32_t)(unsafe.Pointer(bp + uintptr(jz-int32(1))*4)) &= int32(0x7fffff) + **(**Tint32_t)(__ccgo_up(bp + uintptr(jz-int32(1))*4)) &= int32(0x7fffff) case int32(2): - *(*Tint32_t)(unsafe.Pointer(bp + uintptr(jz-int32(1))*4)) &= int32(0x3fffff) + **(**Tint32_t)(__ccgo_up(bp + uintptr(jz-int32(1))*4)) &= int32(0x3fffff) break } } @@ -101309,7 +101309,7 @@ recompute: if !(i >= jk) { break } - j = j | (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] + j = j | (**(**[20]Tint32_t)(__ccgo_up(bp)))[i] goto _7 _7: ; @@ -101318,7 +101318,7 @@ recompute: if j == 0 { /* need recomputation */ k = int32(1) for { - if !((*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jk-k] == 0) { + if !((**(**[20]Tint32_t)(__ccgo_up(bp)))[jk-k] == 0) { break } goto _8 @@ -101338,7 +101338,7 @@ recompute: if !(j <= jx) { break } - fw = fw + float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8))*f[jx+i-j]) + fw = fw + float64(**(**float64)(__ccgo_up(x + uintptr(j)*8))*f[jx+i-j]) goto _10 _10: ; @@ -101358,7 +101358,7 @@ recompute: if z == float64(0) { jz = jz - int32(1) q0 = q0 - int32(24) - for (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] == 0 { + for (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz] == 0 { jz = jz - 1 q0 = q0 - int32(24) } @@ -101366,12 +101366,12 @@ recompute: z = Xscalbn(tls, z, -q0) if z >= float64(1.6777216e+07) { fw = float64(int32(float64(Float64FromFloat64(5.960464477539063e-08) * z))) - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(z - float64(Float64FromFloat64(1.6777216e+07)*fw)) + (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz] = int32(z - float64(Float64FromFloat64(1.6777216e+07)*fw)) jz = jz + int32(1) q0 = q0 + int32(24) - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(fw) + (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz] = int32(fw) } else { - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(z) + (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz] = int32(z) } } /* convert integer "bit" chunk to floating-point value */ @@ -101381,7 +101381,7 @@ recompute: if !(i >= 0) { break } - q[i] = float64(fw * float64((*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i])) + q[i] = float64(fw * float64((**(**[20]Tint32_t)(__ccgo_up(bp)))[i])) fw = fw * float64(5.960464477539063e-08) goto _11 _11: @@ -101406,7 +101406,7 @@ recompute: ; k = k + 1 } - (*(*[20]float64)(unsafe.Pointer(bp + 80)))[jz-i] = fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[jz-i] = fw goto _12 _12: ; @@ -101432,7 +101432,7 @@ _14: if !(i >= 0) { break } - fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[i] goto _19 _19: ; @@ -101443,7 +101443,7 @@ _14: } else { v2 = -fw } - *(*float64)(unsafe.Pointer(y)) = v2 + **(**float64)(__ccgo_up(y)) = v2 goto _18 _16: ; @@ -101455,7 +101455,7 @@ _15: if !(i >= 0) { break } - fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[i] goto _21 _21: ; @@ -101468,14 +101468,14 @@ _15: } else { v2 = -fw } - *(*float64)(unsafe.Pointer(y)) = v2 - fw = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[0] - fw + **(**float64)(__ccgo_up(y)) = v2 + fw = (**(**[20]float64)(__ccgo_up(bp + 80)))[0] - fw i = int32(1) for { if !(i <= jz) { break } - fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[i] goto _23 _23: ; @@ -101486,7 +101486,7 @@ _15: } else { v2 = -fw } - *(*float64)(unsafe.Pointer(y + 1*8)) = v2 + **(**float64)(__ccgo_up(y + 1*8)) = v2 goto _18 _17: ; /* painful */ @@ -101496,9 +101496,9 @@ _27: if !(i > 0) { goto _25 } - fw = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i-int32(1)] + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] - *(*float64)(unsafe.Pointer(bp + 80 + uintptr(i)*8)) += (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i-int32(1)] - fw - (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i-int32(1)] = fw + fw = (**(**[20]float64)(__ccgo_up(bp + 80)))[i-int32(1)] + (**(**[20]float64)(__ccgo_up(bp + 80)))[i] + **(**float64)(__ccgo_up(bp + 80 + uintptr(i)*8)) += (**(**[20]float64)(__ccgo_up(bp + 80)))[i-int32(1)] - fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[i-int32(1)] = fw goto _26 _26: ; @@ -101512,9 +101512,9 @@ _25: if !(i > int32(1)) { break } - fw = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i-int32(1)] + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] - *(*float64)(unsafe.Pointer(bp + 80 + uintptr(i)*8)) += (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i-int32(1)] - fw - (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i-int32(1)] = fw + fw = (**(**[20]float64)(__ccgo_up(bp + 80)))[i-int32(1)] + (**(**[20]float64)(__ccgo_up(bp + 80)))[i] + **(**float64)(__ccgo_up(bp + 80 + uintptr(i)*8)) += (**(**[20]float64)(__ccgo_up(bp + 80)))[i-int32(1)] - fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[i-int32(1)] = fw goto _28 _28: ; @@ -101526,20 +101526,20 @@ _25: if !(i >= int32(2)) { break } - fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[i] goto _29 _29: ; i = i - 1 } if ih == 0 { - *(*float64)(unsafe.Pointer(y)) = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[0] - *(*float64)(unsafe.Pointer(y + 1*8)) = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[int32(1)] - *(*float64)(unsafe.Pointer(y + 2*8)) = fw + **(**float64)(__ccgo_up(y)) = (**(**[20]float64)(__ccgo_up(bp + 80)))[0] + **(**float64)(__ccgo_up(y + 1*8)) = (**(**[20]float64)(__ccgo_up(bp + 80)))[int32(1)] + **(**float64)(__ccgo_up(y + 2*8)) = fw } else { - *(*float64)(unsafe.Pointer(y)) = -(*(*[20]float64)(unsafe.Pointer(bp + 80)))[0] - *(*float64)(unsafe.Pointer(y + 1*8)) = -(*(*[20]float64)(unsafe.Pointer(bp + 80)))[int32(1)] - *(*float64)(unsafe.Pointer(y + 2*8)) = -fw + **(**float64)(__ccgo_up(y)) = -(**(**[20]float64)(__ccgo_up(bp + 80)))[0] + **(**float64)(__ccgo_up(y + 1*8)) = -(**(**[20]float64)(__ccgo_up(bp + 80)))[int32(1)] + **(**float64)(__ccgo_up(y + 2*8)) = -fw } _18: ; @@ -101593,36 +101593,36 @@ func X__rem_pio2f(tls *TLS, x float32, y uintptr) (r int32) { /* Use a specialized rint() to get fn. */ fn = Tdouble_t(float64(x)*_invpio21) + _toint1 - _toint1 n = int32(fn) - *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) + **(**float64)(__ccgo_up(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) /* Matters with directed rounding. */ - if *(*float64)(unsafe.Pointer(y)) < -_pio41 { + if **(**float64)(__ccgo_up(y)) < -_pio41 { n = n - 1 fn = fn - 1 - *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) + **(**float64)(__ccgo_up(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) } else { - if *(*float64)(unsafe.Pointer(y)) > _pio41 { + if **(**float64)(__ccgo_up(y)) > _pio41 { n = n + 1 fn = fn + 1 - *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) + **(**float64)(__ccgo_up(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) } } return n } if ix >= uint32(0x7f800000) { /* x is inf or NaN */ - *(*float64)(unsafe.Pointer(y)) = float64(x - x) + **(**float64)(__ccgo_up(y)) = float64(x - x) return 0 } /* scale x into [2^23, 2^24-1] */ sign = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(bp)) >> int32(31)) e0 = Int32FromUint32(ix>>Int32FromInt32(23) - Uint32FromInt32(Int32FromInt32(0x7f)+Int32FromInt32(23))) /* e0 = ilogb(|x|)-23, positive */ *(*Tuint32_t)(unsafe.Pointer(bp)) = ix - Uint32FromInt32(e0<>int32(52)&uint64(0x7ff) < Uint64FromInt32(Int32FromInt32(0x3ff)+Int32FromInt32(4)) { if !(y != 0) { - return _p10[int32(*(*float64)(unsafe.Pointer(bp)))+int32(15)] + return _p10[int32(**(**float64)(__ccgo_up(bp)))+int32(15)] } y = Xexp2(tls, float64(float64(3.321928094887362)*y)) - return float64(y * _p10[int32(*(*float64)(unsafe.Pointer(bp)))+int32(15)]) + return float64(y * _p10[int32(**(**float64)(__ccgo_up(bp)))+int32(15)]) } return Xpow(tls, float64(10), x) } @@ -104271,14 +104271,14 @@ func Xexp10f(tls *TLS, x float32) (r float32) { Fi [0]Tuint32_t Ff float32 }{} - *(*float32)(unsafe.Pointer(bp + 4)) = *(*float32)(unsafe.Pointer(bp)) + *(*float32)(unsafe.Pointer(bp + 4)) = **(**float32)(__ccgo_up(bp)) /* fabsf(n) < 8 without raising invalid on nan */ if *(*Tuint32_t)(unsafe.Pointer(bp + 4))>>int32(23)&uint32(0xff) < Uint32FromInt32(Int32FromInt32(0x7f)+Int32FromInt32(3)) { if !(y != 0) { - return _p101[int32(*(*float32)(unsafe.Pointer(bp)))+int32(7)] + return _p101[int32(**(**float32)(__ccgo_up(bp)))+int32(7)] } y = Xexp2f(tls, float32(Float32FromFloat32(3.321928094887362)*y)) - return float32(y * _p101[int32(*(*float32)(unsafe.Pointer(bp)))+int32(7)]) + return float32(y * _p101[int32(**(**float32)(__ccgo_up(bp)))+int32(7)]) } return float32(Xexp2(tls, float64(float64(3.321928094887362)*float64(x)))) } @@ -104442,16 +104442,16 @@ _5: /* 2^(k/N) ~= scale * (1 + tail). */ idx = uint64(2) * (ki % Uint64FromInt32(Int32FromInt32(1)<>Int32FromInt32(32) + BoolUint64(t1 > *(*Tuint64_t)(unsafe.Pointer(lo))) + **(**Tuint64_t)(__ccgo_up(lo)) = t1 + t2<>Int32FromInt32(32) + BoolUint64(t1 > **(**Tuint64_t)(__ccgo_up(lo))) } func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { @@ -105356,11 +105356,11 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { if d == 0 { } else { if d < int32(64) { - *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = *(*Tuint64_t)(unsafe.Pointer(bp))<<(int32(64)-d) | *(*Tuint64_t)(unsafe.Pointer(bp + 8))>>d | BoolUint64(!!(*(*Tuint64_t)(unsafe.Pointer(bp + 8))<<(Int32FromInt32(64)-d) != 0)) - *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp)) >> d + **(**Tuint64_t)(__ccgo_up(bp + 8)) = **(**Tuint64_t)(__ccgo_up(bp))<<(int32(64)-d) | **(**Tuint64_t)(__ccgo_up(bp + 8))>>d | BoolUint64(!!(**(**Tuint64_t)(__ccgo_up(bp + 8))<<(Int32FromInt32(64)-d) != 0)) + **(**Tuint64_t)(__ccgo_up(bp)) = **(**Tuint64_t)(__ccgo_up(bp)) >> d } else { - *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = uint64(1) - *(*Tuint64_t)(unsafe.Pointer(bp)) = uint64(0) + **(**Tuint64_t)(__ccgo_up(bp + 8)) = uint64(1) + **(**Tuint64_t)(__ccgo_up(bp)) = uint64(0) } } } @@ -105383,24 +105383,24 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { nonzero = int32(1) if samesign != 0 { /* r += z */ - *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) + zlo - *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp)) + (zhi + BoolUint64(*(*Tuint64_t)(unsafe.Pointer(bp + 8)) < zlo)) + **(**Tuint64_t)(__ccgo_up(bp + 8)) = **(**Tuint64_t)(__ccgo_up(bp + 8)) + zlo + **(**Tuint64_t)(__ccgo_up(bp)) = **(**Tuint64_t)(__ccgo_up(bp)) + (zhi + BoolUint64(**(**Tuint64_t)(__ccgo_up(bp + 8)) < zlo)) } else { /* r -= z */ - t = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) - *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) - zlo - *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp)) - zhi - BoolUint64(t < *(*Tuint64_t)(unsafe.Pointer(bp + 8))) - if *(*Tuint64_t)(unsafe.Pointer(bp))>>int32(63) != 0 { - *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = -*(*Tuint64_t)(unsafe.Pointer(bp + 8)) - *(*Tuint64_t)(unsafe.Pointer(bp)) = -*(*Tuint64_t)(unsafe.Pointer(bp)) - BoolUint64(!!(*(*Tuint64_t)(unsafe.Pointer(bp + 8)) != 0)) + t = **(**Tuint64_t)(__ccgo_up(bp + 8)) + **(**Tuint64_t)(__ccgo_up(bp + 8)) = **(**Tuint64_t)(__ccgo_up(bp + 8)) - zlo + **(**Tuint64_t)(__ccgo_up(bp)) = **(**Tuint64_t)(__ccgo_up(bp)) - zhi - BoolUint64(t < **(**Tuint64_t)(__ccgo_up(bp + 8))) + if **(**Tuint64_t)(__ccgo_up(bp))>>int32(63) != 0 { + **(**Tuint64_t)(__ccgo_up(bp + 8)) = -**(**Tuint64_t)(__ccgo_up(bp + 8)) + **(**Tuint64_t)(__ccgo_up(bp)) = -**(**Tuint64_t)(__ccgo_up(bp)) - BoolUint64(!!(**(**Tuint64_t)(__ccgo_up(bp + 8)) != 0)) sign = BoolInt32(!(sign != 0)) } - nonzero = BoolInt32(!!(*(*Tuint64_t)(unsafe.Pointer(bp)) != 0)) + nonzero = BoolInt32(!!(**(**Tuint64_t)(__ccgo_up(bp)) != 0)) } /* set rhi to top 63bit of the result (last bit is sticky) */ if nonzero != 0 { e = e + int32(64) - v1 = *(*Tuint64_t)(unsafe.Pointer(bp)) + v1 = **(**Tuint64_t)(__ccgo_up(bp)) // __asm__("clz %0, %1" : "=r"(x) : "r"(x)); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 80, __ccgo_ts+566) v2 = Int32FromUint64(v1) @@ -105408,10 +105408,10 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { _3: d = v2 - int32(1) /* note: d > 0 */ - *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp))<>(int32(64)-d) | BoolUint64(!!(*(*Tuint64_t)(unsafe.Pointer(bp + 8))<>(int32(64)-d) | BoolUint64(!!(**(**Tuint64_t)(__ccgo_up(bp + 8))<>int32(1) | *(*Tuint64_t)(unsafe.Pointer(bp + 8))&uint64(1) + **(**Tuint64_t)(__ccgo_up(bp)) = **(**Tuint64_t)(__ccgo_up(bp + 8))>>int32(1) | **(**Tuint64_t)(__ccgo_up(bp + 8))&uint64(1) } else { - *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) << d + **(**Tuint64_t)(__ccgo_up(bp)) = **(**Tuint64_t)(__ccgo_up(bp + 8)) << d } } else { /* exact +-0 */ @@ -105430,7 +105430,7 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { } e = e - d /* convert to double */ - i = Int64FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp))) /* i is in [1<<62,(1<<63)-1] */ + i = Int64FromUint64(**(**Tuint64_t)(__ccgo_up(bp))) /* i is in [1<<62,(1<<63)-1] */ if sign != 0 { i = -i } @@ -105451,8 +105451,8 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { } /* one bit is lost when scaled, add another top bit to only round once at conversion if it is inexact */ - if *(*Tuint64_t)(unsafe.Pointer(bp))<>int32(1) | *(*Tuint64_t)(unsafe.Pointer(bp))&uint64(1) | Uint64FromUint64(1)<>int32(1)|**(**Tuint64_t)(__ccgo_up(bp))&uint64(1)) | Uint64FromUint64(1)<>d | BoolUint64(!!(*(*Tuint64_t)(unsafe.Pointer(bp))<<(Int32FromInt32(64)-d) != 0))) << d) + i = Int64FromUint64((**(**Tuint64_t)(__ccgo_up(bp))>>d | BoolUint64(!!(**(**Tuint64_t)(__ccgo_up(bp))<<(Int32FromInt32(64)-d) != 0))) << d) if sign != 0 { i = -i } @@ -106052,9 +106052,9 @@ func Xfrexp(tls *TLS, x float64, e uintptr) (r float64) { if !(ee != 0) { if x != 0 { x = Xfrexp(tls, float64(x*float64(1.8446744073709552e+19)), e) - *(*int32)(unsafe.Pointer(e)) -= int32(64) + **(**int32)(__ccgo_up(e)) -= int32(64) } else { - *(*int32)(unsafe.Pointer(e)) = 0 + **(**int32)(__ccgo_up(e)) = 0 } return x } else { @@ -106062,7 +106062,7 @@ func Xfrexp(tls *TLS, x float64, e uintptr) (r float64) { return x } } - *(*int32)(unsafe.Pointer(e)) = ee - int32(0x3fe) + **(**int32)(__ccgo_up(e)) = ee - int32(0x3fe) v1 = bp *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & Uint64FromUint64(0x800fffffffffffff)) v1 = bp @@ -106096,9 +106096,9 @@ func Xfrexpf(tls *TLS, x float32, e uintptr) (r float32) { if !(ee != 0) { if x != 0 { x = Xfrexpf(tls, float32(float64(x)*float64(1.8446744073709552e+19)), e) - *(*int32)(unsafe.Pointer(e)) -= int32(64) + **(**int32)(__ccgo_up(e)) -= int32(64) } else { - *(*int32)(unsafe.Pointer(e)) = 0 + **(**int32)(__ccgo_up(e)) = 0 } return x } else { @@ -106106,7 +106106,7 @@ func Xfrexpf(tls *TLS, x float32, e uintptr) (r float32) { return x } } - *(*int32)(unsafe.Pointer(e)) = ee - int32(0x7e) + **(**int32)(__ccgo_up(e)) = ee - int32(0x7e) v1 = bp *(*Tuint32_t)(unsafe.Pointer(v1)) = Tuint32_t(uint64(*(*Tuint32_t)(unsafe.Pointer(v1))) & Uint64FromUint64(0x807fffff)) v1 = bp @@ -106130,8 +106130,8 @@ func _sq(tls *TLS, hi uintptr, lo uintptr, x float64) { xc = Tdouble_t(x * (Float64FromFloat64(1.34217728e+08) + Float64FromInt32(1))) xh = x - xc + xc xl = x - xh - *(*Tdouble_t)(unsafe.Pointer(hi)) = Tdouble_t(x * x) - *(*Tdouble_t)(unsafe.Pointer(lo)) = Tdouble_t(xh*xh) - *(*Tdouble_t)(unsafe.Pointer(hi)) + Tdouble_t(Tdouble_t(Float64FromInt32(2)*xh)*xl) + Tdouble_t(xl*xl) + **(**Tdouble_t)(__ccgo_up(hi)) = Tdouble_t(x * x) + **(**Tdouble_t)(__ccgo_up(lo)) = Tdouble_t(xh*xh) - **(**Tdouble_t)(__ccgo_up(hi)) + Tdouble_t(Tdouble_t(Float64FromInt32(2)*xh)*xl) + Tdouble_t(xl*xl) } func Xhypot(tls *TLS, x float64, y float64) (r float64) { @@ -106183,21 +106183,21 @@ func Xhypot(tls *TLS, x float64, y float64) (r float64) { v1 = bp + 8 *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & (-Uint64FromUint64(1) >> Int32FromInt32(1))) if *(*Tuint64_t)(unsafe.Pointer(bp)) < *(*Tuint64_t)(unsafe.Pointer(bp + 8)) { - ut = *(*struct { + ut = **(**struct { Fi [0]Tuint64_t Ff float64 - })(unsafe.Pointer(bp)) - *(*struct { + })(__ccgo_up(bp)) + **(**struct { Fi [0]Tuint64_t Ff float64 - })(unsafe.Pointer(bp)) = *(*struct { + })(__ccgo_up(bp)) = **(**struct { Fi [0]Tuint64_t Ff float64 - })(unsafe.Pointer(bp + 8)) - *(*struct { + })(__ccgo_up(bp + 8)) + **(**struct { Fi [0]Tuint64_t Ff float64 - })(unsafe.Pointer(bp + 8)) = ut + })(__ccgo_up(bp + 8)) = ut } /* special cases */ ex = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(52)) @@ -106232,7 +106232,7 @@ func Xhypot(tls *TLS, x float64, y float64) (r float64) { } _sq(tls, bp+16, bp+24, x) _sq(tls, bp+32, bp+40, y) - return float64(z * Xsqrt(tls, *(*Tdouble_t)(unsafe.Pointer(bp + 40))+*(*Tdouble_t)(unsafe.Pointer(bp + 24))+*(*Tdouble_t)(unsafe.Pointer(bp + 32))+*(*Tdouble_t)(unsafe.Pointer(bp + 16)))) + return float64(z * Xsqrt(tls, **(**Tdouble_t)(__ccgo_up(bp + 40))+**(**Tdouble_t)(__ccgo_up(bp + 24))+**(**Tdouble_t)(__ccgo_up(bp + 32))+**(**Tdouble_t)(__ccgo_up(bp + 16)))) } func Xhypotf(tls *TLS, x float32, y float32) (r float32) { @@ -106275,21 +106275,21 @@ func Xhypotf(tls *TLS, x float32, y float32) (r float32) { *(*Tuint32_t)(unsafe.Pointer(bp)) &= -Uint32FromUint32(1) >> Int32FromInt32(1) *(*Tuint32_t)(unsafe.Pointer(bp + 4)) &= -Uint32FromUint32(1) >> Int32FromInt32(1) if *(*Tuint32_t)(unsafe.Pointer(bp)) < *(*Tuint32_t)(unsafe.Pointer(bp + 4)) { - ut = *(*struct { + ut = **(**struct { Fi [0]Tuint32_t Ff float32 - })(unsafe.Pointer(bp)) - *(*struct { + })(__ccgo_up(bp)) + **(**struct { Fi [0]Tuint32_t Ff float32 - })(unsafe.Pointer(bp)) = *(*struct { + })(__ccgo_up(bp)) = **(**struct { Fi [0]Tuint32_t Ff float32 - })(unsafe.Pointer(bp + 4)) - *(*struct { + })(__ccgo_up(bp + 4)) + **(**struct { Fi [0]Tuint32_t Ff float32 - })(unsafe.Pointer(bp + 4)) = ut + })(__ccgo_up(bp + 4)) = ut } x = *(*float32)(unsafe.Pointer(bp)) y = *(*float32)(unsafe.Pointer(bp + 4)) @@ -106717,8 +106717,8 @@ func _pzero(tls *TLS, x float64) (r1 float64) { } } z = float64(1) / float64(x*x) - r = *(*float64)(unsafe.Pointer(p)) + float64(z*(*(*float64)(unsafe.Pointer(p + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 4*8))+float64(z**(*float64)(unsafe.Pointer(p + 5*8))))))))))) - s = float64(1) + float64(z*(*(*float64)(unsafe.Pointer(q))+float64(z*(*(*float64)(unsafe.Pointer(q + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 3*8))+float64(z**(*float64)(unsafe.Pointer(q + 4*8))))))))))) + r = **(**float64)(__ccgo_up(p)) + float64(z*(**(**float64)(__ccgo_up(p + 1*8))+float64(z*(**(**float64)(__ccgo_up(p + 2*8))+float64(z*(**(**float64)(__ccgo_up(p + 3*8))+float64(z*(**(**float64)(__ccgo_up(p + 4*8))+float64(z***(**float64)(__ccgo_up(p + 5*8))))))))))) + s = float64(1) + float64(z*(**(**float64)(__ccgo_up(q))+float64(z*(**(**float64)(__ccgo_up(q + 1*8))+float64(z*(**(**float64)(__ccgo_up(q + 2*8))+float64(z*(**(**float64)(__ccgo_up(q + 3*8))+float64(z***(**float64)(__ccgo_up(q + 4*8))))))))))) return float64(1) + r/s } @@ -106825,8 +106825,8 @@ func _qzero(tls *TLS, x float64) (r1 float64) { } } z = float64(1) / float64(x*x) - r = *(*float64)(unsafe.Pointer(p)) + float64(z*(*(*float64)(unsafe.Pointer(p + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 4*8))+float64(z**(*float64)(unsafe.Pointer(p + 5*8))))))))))) - s = float64(1) + float64(z*(*(*float64)(unsafe.Pointer(q))+float64(z*(*(*float64)(unsafe.Pointer(q + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 4*8))+float64(z**(*float64)(unsafe.Pointer(q + 5*8))))))))))))) + r = **(**float64)(__ccgo_up(p)) + float64(z*(**(**float64)(__ccgo_up(p + 1*8))+float64(z*(**(**float64)(__ccgo_up(p + 2*8))+float64(z*(**(**float64)(__ccgo_up(p + 3*8))+float64(z*(**(**float64)(__ccgo_up(p + 4*8))+float64(z***(**float64)(__ccgo_up(p + 5*8))))))))))) + s = float64(1) + float64(z*(**(**float64)(__ccgo_up(q))+float64(z*(**(**float64)(__ccgo_up(q + 1*8))+float64(z*(**(**float64)(__ccgo_up(q + 2*8))+float64(z*(**(**float64)(__ccgo_up(q + 3*8))+float64(z*(**(**float64)(__ccgo_up(q + 4*8))+float64(z***(**float64)(__ccgo_up(q + 5*8))))))))))))) return (-Float64FromFloat64(0.125) + r/s) / x } @@ -107050,8 +107050,8 @@ func _pzerof(tls *TLS, x float32) (r1 float32) { } } z = Float32FromFloat32(1) / float32(x*x) - r = *(*float32)(unsafe.Pointer(p)) + float32(z*(*(*float32)(unsafe.Pointer(p + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 3*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 4*4))+float32(z**(*float32)(unsafe.Pointer(p + 5*4))))))))))) - s = Float32FromFloat32(1) + float32(z*(*(*float32)(unsafe.Pointer(q))+float32(z*(*(*float32)(unsafe.Pointer(q + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 3*4))+float32(z**(*float32)(unsafe.Pointer(q + 4*4))))))))))) + r = **(**float32)(__ccgo_up(p)) + float32(z*(**(**float32)(__ccgo_up(p + 1*4))+float32(z*(**(**float32)(__ccgo_up(p + 2*4))+float32(z*(**(**float32)(__ccgo_up(p + 3*4))+float32(z*(**(**float32)(__ccgo_up(p + 4*4))+float32(z***(**float32)(__ccgo_up(p + 5*4))))))))))) + s = Float32FromFloat32(1) + float32(z*(**(**float32)(__ccgo_up(q))+float32(z*(**(**float32)(__ccgo_up(q + 1*4))+float32(z*(**(**float32)(__ccgo_up(q + 2*4))+float32(z*(**(**float32)(__ccgo_up(q + 3*4))+float32(z***(**float32)(__ccgo_up(q + 4*4))))))))))) return Float32FromFloat32(1) + r/s } @@ -107158,8 +107158,8 @@ func _qzerof(tls *TLS, x float32) (r1 float32) { } } z = Float32FromFloat32(1) / float32(x*x) - r = *(*float32)(unsafe.Pointer(p)) + float32(z*(*(*float32)(unsafe.Pointer(p + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 3*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 4*4))+float32(z**(*float32)(unsafe.Pointer(p + 5*4))))))))))) - s = Float32FromFloat32(1) + float32(z*(*(*float32)(unsafe.Pointer(q))+float32(z*(*(*float32)(unsafe.Pointer(q + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 3*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 4*4))+float32(z**(*float32)(unsafe.Pointer(q + 5*4))))))))))))) + r = **(**float32)(__ccgo_up(p)) + float32(z*(**(**float32)(__ccgo_up(p + 1*4))+float32(z*(**(**float32)(__ccgo_up(p + 2*4))+float32(z*(**(**float32)(__ccgo_up(p + 3*4))+float32(z*(**(**float32)(__ccgo_up(p + 4*4))+float32(z***(**float32)(__ccgo_up(p + 5*4))))))))))) + s = Float32FromFloat32(1) + float32(z*(**(**float32)(__ccgo_up(q))+float32(z*(**(**float32)(__ccgo_up(q + 1*4))+float32(z*(**(**float32)(__ccgo_up(q + 2*4))+float32(z*(**(**float32)(__ccgo_up(q + 3*4))+float32(z*(**(**float32)(__ccgo_up(q + 4*4))+float32(z***(**float32)(__ccgo_up(q + 5*4))))))))))))) return (-Float32FromFloat32(0.125) + r/s) / x } @@ -107396,8 +107396,8 @@ func _pone(tls *TLS, x float64) (r1 float64) { } } z = float64(1) / float64(x*x) - r = *(*float64)(unsafe.Pointer(p)) + float64(z*(*(*float64)(unsafe.Pointer(p + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 4*8))+float64(z**(*float64)(unsafe.Pointer(p + 5*8))))))))))) - s = float64(1) + float64(z*(*(*float64)(unsafe.Pointer(q))+float64(z*(*(*float64)(unsafe.Pointer(q + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 3*8))+float64(z**(*float64)(unsafe.Pointer(q + 4*8))))))))))) + r = **(**float64)(__ccgo_up(p)) + float64(z*(**(**float64)(__ccgo_up(p + 1*8))+float64(z*(**(**float64)(__ccgo_up(p + 2*8))+float64(z*(**(**float64)(__ccgo_up(p + 3*8))+float64(z*(**(**float64)(__ccgo_up(p + 4*8))+float64(z***(**float64)(__ccgo_up(p + 5*8))))))))))) + s = float64(1) + float64(z*(**(**float64)(__ccgo_up(q))+float64(z*(**(**float64)(__ccgo_up(q + 1*8))+float64(z*(**(**float64)(__ccgo_up(q + 2*8))+float64(z*(**(**float64)(__ccgo_up(q + 3*8))+float64(z***(**float64)(__ccgo_up(q + 4*8))))))))))) return float64(1) + r/s } @@ -107503,8 +107503,8 @@ func _qone(tls *TLS, x float64) (r1 float64) { } } z = float64(1) / float64(x*x) - r = *(*float64)(unsafe.Pointer(p)) + float64(z*(*(*float64)(unsafe.Pointer(p + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 4*8))+float64(z**(*float64)(unsafe.Pointer(p + 5*8))))))))))) - s = float64(1) + float64(z*(*(*float64)(unsafe.Pointer(q))+float64(z*(*(*float64)(unsafe.Pointer(q + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 4*8))+float64(z**(*float64)(unsafe.Pointer(q + 5*8))))))))))))) + r = **(**float64)(__ccgo_up(p)) + float64(z*(**(**float64)(__ccgo_up(p + 1*8))+float64(z*(**(**float64)(__ccgo_up(p + 2*8))+float64(z*(**(**float64)(__ccgo_up(p + 3*8))+float64(z*(**(**float64)(__ccgo_up(p + 4*8))+float64(z***(**float64)(__ccgo_up(p + 5*8))))))))))) + s = float64(1) + float64(z*(**(**float64)(__ccgo_up(q))+float64(z*(**(**float64)(__ccgo_up(q + 1*8))+float64(z*(**(**float64)(__ccgo_up(q + 2*8))+float64(z*(**(**float64)(__ccgo_up(q + 3*8))+float64(z*(**(**float64)(__ccgo_up(q + 4*8))+float64(z***(**float64)(__ccgo_up(q + 5*8))))))))))))) return (float64(0.375) + r/s) / x } @@ -107727,8 +107727,8 @@ func _ponef(tls *TLS, x float32) (r1 float32) { } } z = Float32FromFloat32(1) / float32(x*x) - r = *(*float32)(unsafe.Pointer(p)) + float32(z*(*(*float32)(unsafe.Pointer(p + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 3*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 4*4))+float32(z**(*float32)(unsafe.Pointer(p + 5*4))))))))))) - s = Float32FromFloat32(1) + float32(z*(*(*float32)(unsafe.Pointer(q))+float32(z*(*(*float32)(unsafe.Pointer(q + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 3*4))+float32(z**(*float32)(unsafe.Pointer(q + 4*4))))))))))) + r = **(**float32)(__ccgo_up(p)) + float32(z*(**(**float32)(__ccgo_up(p + 1*4))+float32(z*(**(**float32)(__ccgo_up(p + 2*4))+float32(z*(**(**float32)(__ccgo_up(p + 3*4))+float32(z*(**(**float32)(__ccgo_up(p + 4*4))+float32(z***(**float32)(__ccgo_up(p + 5*4))))))))))) + s = Float32FromFloat32(1) + float32(z*(**(**float32)(__ccgo_up(q))+float32(z*(**(**float32)(__ccgo_up(q + 1*4))+float32(z*(**(**float32)(__ccgo_up(q + 2*4))+float32(z*(**(**float32)(__ccgo_up(q + 3*4))+float32(z***(**float32)(__ccgo_up(q + 4*4))))))))))) return Float32FromFloat32(1) + r/s } @@ -107834,8 +107834,8 @@ func _qonef(tls *TLS, x float32) (r1 float32) { } } z = Float32FromFloat32(1) / float32(x*x) - r = *(*float32)(unsafe.Pointer(p)) + float32(z*(*(*float32)(unsafe.Pointer(p + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 3*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 4*4))+float32(z**(*float32)(unsafe.Pointer(p + 5*4))))))))))) - s = Float32FromFloat32(1) + float32(z*(*(*float32)(unsafe.Pointer(q))+float32(z*(*(*float32)(unsafe.Pointer(q + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 3*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 4*4))+float32(z**(*float32)(unsafe.Pointer(q + 5*4))))))))))))) + r = **(**float32)(__ccgo_up(p)) + float32(z*(**(**float32)(__ccgo_up(p + 1*4))+float32(z*(**(**float32)(__ccgo_up(p + 2*4))+float32(z*(**(**float32)(__ccgo_up(p + 3*4))+float32(z*(**(**float32)(__ccgo_up(p + 4*4))+float32(z***(**float32)(__ccgo_up(p + 5*4))))))))))) + s = Float32FromFloat32(1) + float32(z*(**(**float32)(__ccgo_up(q))+float32(z*(**(**float32)(__ccgo_up(q + 1*4))+float32(z*(**(**float32)(__ccgo_up(q + 2*4))+float32(z*(**(**float32)(__ccgo_up(q + 3*4))+float32(z*(**(**float32)(__ccgo_up(q + 4*4))+float32(z***(**float32)(__ccgo_up(q + 5*4))))))))))))) return (Float32FromFloat32(0.375) + r/s) / x } @@ -108516,7 +108516,7 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { }{} *(*float64)(unsafe.Pointer(bp)) = x /* purge off +-inf, NaN, +-0, tiny and negative arguments */ - *(*int32)(unsafe.Pointer(signgamp)) = int32(1) + **(**int32)(__ccgo_up(signgamp)) = int32(1) sign = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(63)) ix = uint32(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(32) & uint64(0x7fffffff)) if ix >= uint32(0x7ff00000) { @@ -108525,7 +108525,7 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { if ix < Uint32FromInt32((Int32FromInt32(0x3ff)-Int32FromInt32(70))< float64(0) { - *(*int32)(unsafe.Pointer(signgamp)) = -int32(1) + **(**int32)(__ccgo_up(signgamp)) = -int32(1) } else { t = -t } @@ -108773,7 +108773,7 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { }{} *(*float32)(unsafe.Pointer(bp)) = x /* purge off +-inf, NaN, +-0, tiny and negative arguments */ - *(*int32)(unsafe.Pointer(signgamp)) = int32(1) + **(**int32)(__ccgo_up(signgamp)) = int32(1) sign = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(bp)) >> int32(31)) ix = *(*Tuint32_t)(unsafe.Pointer(bp)) & uint32(0x7fffffff) if ix >= uint32(0x7f800000) { @@ -108781,7 +108781,7 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { } if ix < uint32(0x35000000) { /* |x| < 2**-21, return -log(|x|) */ if sign != 0 { - *(*int32)(unsafe.Pointer(signgamp)) = -int32(1) + **(**int32)(__ccgo_up(signgamp)) = -int32(1) x = -x } return -Xlogf(tls, x) @@ -108793,7 +108793,7 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { return Float32FromFloat32(1) / (x - x) } if t > Float32FromFloat32(0) { - *(*int32)(unsafe.Pointer(signgamp)) = -int32(1) + **(**int32)(__ccgo_up(signgamp)) = -int32(1) } else { t = -t } @@ -109024,15 +109024,15 @@ func Xlog(tls *TLS, x1 float64) (r1 float64) { r = x1 - float64(1) r2 = Tdouble_t(r * r) r3 = Tdouble_t(r * r2) - y1 = Tdouble_t(r3 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 1*8)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 2*8))) + float64(r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 3*8))) + float64(r3*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 4*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 5*8)))+float64(r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 6*8)))+float64(r3*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 7*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 8*8)))+float64(r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 9*8)))+float64(r3**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 10*8))))))))) + y1 = Tdouble_t(r3 * (**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 1*8)) + float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 2*8))) + float64(r2***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 3*8))) + float64(r3*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 4*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 5*8)))+float64(r2***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 6*8)))+float64(r3*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 7*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 8*8)))+float64(r2***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 9*8)))+float64(r3***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 10*8))))))))) /* Worst-case error is around 0.507 ULP. */ w = Tdouble_t(r * float64(1.34217728e+08)) rhi = r + w - w rlo = r - rhi - w = Tdouble_t(Tdouble_t(rhi*rhi) * *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56))) /* B[0] == -0.5. */ + w = Tdouble_t(Tdouble_t(rhi*rhi) * **(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56))) /* B[0] == -0.5. */ hi = r + w lo = r - hi + w - lo = lo + Tdouble_t(float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56))*rlo)*(rhi+r)) + lo = lo + Tdouble_t(float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56))*rlo)*(rhi+r)) y1 = y1 + lo y1 = y1 + hi y = y1 @@ -109065,14 +109065,14 @@ func Xlog(tls *TLS, x1 float64) (r1 float64) { i = Int32FromUint64(tmp >> (Int32FromInt32(52) - Int32FromInt32(LOG_TABLE_BITS)) % Uint64FromInt32(Int32FromInt32(1)<> int32(52)) /* arithmetic shift */ iz = uint64(ix - tmp&(Uint64FromUint64(0xfff)< 0x1p-4: 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma). */ - y1 = lo + Tdouble_t(r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16))) + Tdouble_t(Tdouble_t(r*r2)*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 1*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 2*8)))+float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 3*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 4*8))))))) + hi + y1 = lo + Tdouble_t(r2***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 16))) + Tdouble_t(Tdouble_t(r*r2)*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 1*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 2*8)))+float64(r2*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 3*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 4*8))))))) + hi y = y1 v1 = y goto _11 @@ -109534,10 +109534,10 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { r2 = Tdouble_t(r * r) /* rounding error: 0x1p-62. */ r4 = Tdouble_t(r2 * r2) /* Worst-case error is less than 0.54 ULP (0.55 ULP without fma). */ - p = Tdouble_t(r2 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 1*8))))) + p = Tdouble_t(r2 * (**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64)) + float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 1*8))))) y1 = hi + p lo = lo + (hi - y1 + p) - lo = lo + Tdouble_t(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 2*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 3*8)))+float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 4*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 5*8)))))+float64(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 6*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 7*8)))+float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 8*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 9*8))))))))) + lo = lo + Tdouble_t(r4*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 2*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 3*8)))+float64(r2*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 4*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 5*8)))))+float64(r4*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 6*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 7*8)))+float64(r2*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 8*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 9*8))))))))) y1 = y1 + lo y = y1 v1 = y @@ -109569,14 +109569,14 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { i = Int32FromUint64(tmp >> (Int32FromInt32(52) - Int32FromInt32(LOG2_TABLE_BITS)) % Uint64FromInt32(Int32FromInt32(1)<> int32(52)) /* arithmetic shift */ iz = uint64(ix - tmp&(Uint64FromUint64(0xfff)< 0x1p-4: 0.547 ULP (0.550 ULP without fma). ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma). */ - p = *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 1*8))) + float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 2*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 3*8))))) + float64(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 4*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 5*8))))) + p = **(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 16)) + float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 1*8))) + float64(r2*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 2*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 3*8))))) + float64(r4*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 4*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 5*8))))) y1 = lo + Tdouble_t(r2*p) + hi y = y1 v1 = y @@ -109667,23 +109667,23 @@ func Xlog2f(tls *TLS, x1 float32) (r1 float32) { top = tmp & uint32(0xff800000) iz = ix - top k = Int32FromUint32(tmp) >> int32(23) /* arithmetic shift */ - invc = (*(*struct { + invc = (**(**struct { Finvc float64 Flogc float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + uintptr(i)*16))).Finvc - logc = (*(*struct { + })(__ccgo_up(uintptr(unsafe.Pointer(&X__log2f_data)) + uintptr(i)*16))).Finvc + logc = (**(**struct { Finvc float64 Flogc float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + uintptr(i)*16))).Flogc + })(__ccgo_up(uintptr(unsafe.Pointer(&X__log2f_data)) + uintptr(i)*16))).Flogc z = float64(*(*float32)(unsafe.Pointer(&iz))) /* log2(x) = log1p(z/c-1)/ln2 + log2(c) + k */ r = Tdouble_t(z*invc) - Float64FromInt32(1) y0 = logc + float64(k) /* Pipelined polynomial evaluation to approximate log1p(r)/ln2. */ r2 = Tdouble_t(r * r) - y1 = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 1*8))*r) + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 2*8)) - y1 = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256))*r2) + y1 - p = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 3*8))*r) + y0 + y1 = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 1*8))*r) + **(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 2*8)) + y1 = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2f_data)) + 256))*r2) + y1 + p = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 3*8))*r) + y0 y1 = Tdouble_t(y1*r2) + p y = float32(y1) v1 = y @@ -109856,22 +109856,22 @@ func Xlogf(tls *TLS, x1 float32) (r1 float32) { i = Int32FromUint32(tmp >> (Int32FromInt32(23) - Int32FromInt32(LOGF_TABLE_BITS)) % Uint32FromInt32(Int32FromInt32(1)<> int32(23) /* arithmetic shift */ iz = ix - tmp&uint32(0xff800000) - invc = (*(*struct { + invc = (**(**struct { Finvc float64 Flogc float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + uintptr(i)*16))).Finvc - logc = (*(*struct { + })(__ccgo_up(uintptr(unsafe.Pointer(&X__logf_data)) + uintptr(i)*16))).Finvc + logc = (**(**struct { Finvc float64 Flogc float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + uintptr(i)*16))).Flogc + })(__ccgo_up(uintptr(unsafe.Pointer(&X__logf_data)) + uintptr(i)*16))).Flogc z = float64(*(*float32)(unsafe.Pointer(&iz))) /* log(x) = log1p(z/c-1) + log(c) + k*Ln2 */ r = Tdouble_t(z*invc) - Float64FromInt32(1) y0 = logc + Tdouble_t(float64(k)*X__logf_data.Fln2) /* Pipelined polynomial evaluation to approximate log1p(r). */ r2 = Tdouble_t(r * r) - y1 = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + 264 + 1*8))*r) + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + 264 + 2*8)) - y1 = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + 264))*r2) + y1 + y1 = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__logf_data)) + 264 + 1*8))*r) + **(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__logf_data)) + 264 + 2*8)) + y1 = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__logf_data)) + 264))*r2) + y1 y1 = Tdouble_t(y1*r2) + (y0 + r) y = float32(y1) v1 = y @@ -109996,7 +109996,7 @@ func Xmodf(tls *TLS, x float64, iptr uintptr) (r float64) { e = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp))>>Int32FromInt32(52)&Uint64FromInt32(0x7ff)) - int32(0x3ff) /* no fractional part */ if e >= int32(52) { - *(*float64)(unsafe.Pointer(iptr)) = x + **(**float64)(__ccgo_up(iptr)) = x if e == int32(0x400) && *(*Tuint64_t)(unsafe.Pointer(bp))<> Int32FromInt32(12) >> e) if *(*Tuint64_t)(unsafe.Pointer(bp))&mask == uint64(0) { - *(*float64)(unsafe.Pointer(iptr)) = x + **(**float64)(__ccgo_up(iptr)) = x v1 = bp *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & (Uint64FromUint64(1) << Int32FromInt32(63))) return *(*float64)(unsafe.Pointer(bp)) } *(*Tuint64_t)(unsafe.Pointer(bp)) &= ^mask - *(*float64)(unsafe.Pointer(iptr)) = *(*float64)(unsafe.Pointer(bp)) + **(**float64)(__ccgo_up(iptr)) = *(*float64)(unsafe.Pointer(bp)) return x - *(*float64)(unsafe.Pointer(bp)) } @@ -110048,7 +110048,7 @@ func Xmodff(tls *TLS, x float32, iptr uintptr) (r float32) { e = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(bp))>>Int32FromInt32(23)&Uint32FromInt32(0xff)) - int32(0x7f) /* no fractional part */ if e >= int32(23) { - *(*float32)(unsafe.Pointer(iptr)) = x + **(**float32)(__ccgo_up(iptr)) = x if e == int32(0x80) && *(*Tuint32_t)(unsafe.Pointer(bp))<> e) if *(*Tuint32_t)(unsafe.Pointer(bp))&mask == uint32(0) { - *(*float32)(unsafe.Pointer(iptr)) = x + **(**float32)(__ccgo_up(iptr)) = x *(*Tuint32_t)(unsafe.Pointer(bp)) &= uint32(0x80000000) return *(*float32)(unsafe.Pointer(bp)) } *(*Tuint32_t)(unsafe.Pointer(bp)) &= ^mask - *(*float32)(unsafe.Pointer(iptr)) = *(*float32)(unsafe.Pointer(bp)) + **(**float32)(__ccgo_up(iptr)) = *(*float32)(unsafe.Pointer(bp)) return x - *(*float32)(unsafe.Pointer(bp)) } @@ -110083,7 +110083,7 @@ func Xmodfl(tls *TLS, x float64, iptr uintptr) (r1 float64) { var _ /* d at bp+0 */ float64 _ = r r = Xmodf(tls, x, bp) - *(*float64)(unsafe.Pointer(iptr)) = *(*float64)(unsafe.Pointer(bp)) + **(**float64)(__ccgo_up(iptr)) = float64(**(**float64)(__ccgo_up(bp))) return r } @@ -110485,24 +110485,24 @@ func _log_inline(tls *TLS, ix Tuint64_t, tail uintptr) (r1 Tdouble_t) { z = *(*float64)(unsafe.Pointer(&iz)) kd = float64(k) /* log(x) = k*Ln2 + log(c) + log1p(z/c-1). */ - invc = (*(*struct { + invc = (**(**struct { Finvc float64 Fpad float64 Flogc float64 Flogctail float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Finvc - logc = (*(*struct { + })(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Finvc + logc = (**(**struct { Finvc float64 Fpad float64 Flogc float64 Flogctail float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Flogc - logctail = (*(*struct { + })(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Flogc + logctail = (**(**struct { Finvc float64 Fpad float64 Flogc float64 Flogctail float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Flogctail + })(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Flogctail /* Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible. */ r = float64(X__builtin_fma(tls, z, invc, -Float64FromFloat64(1))) @@ -110511,7 +110511,7 @@ func _log_inline(tls *TLS, ix Tuint64_t, tail uintptr) (r1 Tdouble_t) { t2 = t1 + r lo1 = Tdouble_t(kd*X__pow_log_data.Fln2lo) + logctail lo2 = t1 - t2 + r - ar = Tdouble_t(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16)) * r) /* A[0] = -0.5. */ + ar = Tdouble_t(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16)) * r) /* A[0] = -0.5. */ ar2 = Tdouble_t(r * ar) ar3 = Tdouble_t(r * ar2) /* k*Ln2 + log(c) + r + A[0]*r*r. */ @@ -110519,10 +110519,10 @@ func _log_inline(tls *TLS, ix Tuint64_t, tail uintptr) (r1 Tdouble_t) { lo3 = float64(X__builtin_fma(tls, ar, r, -ar2)) lo4 = t2 - hi + ar2 /* p = log1p(r) - r - A[0]*r*r. */ - p = Tdouble_t(ar3 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 1*8)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 2*8))) + float64(ar2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 3*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 4*8)))+float64(ar2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 5*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 6*8))))))))) + p = Tdouble_t(ar3 * (**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 1*8)) + float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 2*8))) + float64(ar2*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 3*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 4*8)))+float64(ar2*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 5*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 6*8))))))))) lo = lo1 + lo2 + lo3 + lo4 + p y = hi + lo - *(*Tdouble_t)(unsafe.Pointer(tail)) = hi - y + lo + **(**Tdouble_t)(__ccgo_up(tail)) = hi - y + lo return y } @@ -110642,16 +110642,16 @@ _4: /* 2^(k/N) ~= scale * (1 + tail). */ idx = uint64(2) * (ki % Uint64FromInt32(Int32FromInt32(1)<> (Int32FromInt32(23) - Int32FromInt32(POWF_SCALE_BITS)) /* arithmetic shift */ - invc = (*(*struct { + invc = (**(**struct { Finvc float64 Flogc float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + uintptr(i)*16))).Finvc - logc = (*(*struct { + })(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + uintptr(i)*16))).Finvc + logc = (**(**struct { Finvc float64 Flogc float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + uintptr(i)*16))).Flogc + })(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + uintptr(i)*16))).Flogc z = float64(*(*float32)(unsafe.Pointer(&iz))) /* log2(x) = log1p(z/c-1)/ln2 + log2(c) + k */ r = Tdouble_t(z*invc) - Float64FromInt32(1) y0 = logc + float64(k) /* Pipelined polynomial evaluation to approximate log1p(r)/ln2. */ r2 = Tdouble_t(r * r) - y = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256))*r) + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 1*8)) - p = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 2*8))*r) + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 3*8)) + y = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256))*r) + **(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 1*8)) + p = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 2*8))*r) + **(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 3*8)) r4 = Tdouble_t(r2 * r2) - q = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 4*8))*r) + y0 + q = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 4*8))*r) + y0 q = Tdouble_t(p*r2) + q y = Tdouble_t(y*r4) + q return y @@ -110913,13 +110913,13 @@ _2: kd = kd - X__exp2f_data.Fshift_scaled /* k/N */ r = xd - kd /* exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1) */ - t = *(*Tuint64_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + uintptr(ki%Uint64FromInt32(Int32FromInt32(1)<> int32(63)) sy = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp + 16)) >> int32(63)) uxi = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) - *(*int32)(unsafe.Pointer(quo)) = 0 + **(**int32)(__ccgo_up(quo)) = 0 if v3 = *(*Tuint64_t)(unsafe.Pointer(bp + 16))<> int32(31)) sy = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(bp + 8)) >> int32(31)) uxi = *(*Tuint32_t)(unsafe.Pointer(bp + 4)) - *(*int32)(unsafe.Pointer(quo)) = 0 + **(**int32)(__ccgo_up(quo)) = 0 if v3 = *(*Tuint32_t)(unsafe.Pointer(bp + 8))<= uint32(0x7ff00000) { v1 = x3 - x3 - *(*float64)(unsafe.Pointer(cos)) = v1 - *(*float64)(unsafe.Pointer(sin)) = v1 + **(**float64)(__ccgo_up(cos)) = v1 + **(**float64)(__ccgo_up(sin)) = v1 return } /* argument reduction needed */ n = Uint32FromInt32(X__rem_pio2(tls, x3, bp)) - s = X__sin(tls, (*(*[2]float64)(unsafe.Pointer(bp)))[0], (*(*[2]float64)(unsafe.Pointer(bp)))[int32(1)], int32(1)) - c = X__cos(tls, (*(*[2]float64)(unsafe.Pointer(bp)))[0], (*(*[2]float64)(unsafe.Pointer(bp)))[int32(1)]) + s = X__sin(tls, (**(**[2]float64)(__ccgo_up(bp)))[0], (**(**[2]float64)(__ccgo_up(bp)))[int32(1)], int32(1)) + c = X__cos(tls, (**(**[2]float64)(__ccgo_up(bp)))[0], (**(**[2]float64)(__ccgo_up(bp)))[int32(1)]) switch n & Uint32FromInt32(3) { case uint32(0): - *(*float64)(unsafe.Pointer(sin)) = s - *(*float64)(unsafe.Pointer(cos)) = c + **(**float64)(__ccgo_up(sin)) = s + **(**float64)(__ccgo_up(cos)) = c case uint32(1): - *(*float64)(unsafe.Pointer(sin)) = c - *(*float64)(unsafe.Pointer(cos)) = -s + **(**float64)(__ccgo_up(sin)) = c + **(**float64)(__ccgo_up(cos)) = -s case uint32(2): - *(*float64)(unsafe.Pointer(sin)) = -s - *(*float64)(unsafe.Pointer(cos)) = -c + **(**float64)(__ccgo_up(sin)) = -s + **(**float64)(__ccgo_up(cos)) = -c case uint32(3): fallthrough default: - *(*float64)(unsafe.Pointer(sin)) = -c - *(*float64)(unsafe.Pointer(cos)) = s + **(**float64)(__ccgo_up(sin)) = -c + **(**float64)(__ccgo_up(cos)) = s break } } @@ -112160,23 +112160,23 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { y2 = float64(v1) } } - *(*float32)(unsafe.Pointer(sin)) = x3 - *(*float32)(unsafe.Pointer(cos)) = Float32FromFloat32(1) + **(**float32)(__ccgo_up(sin)) = x3 + **(**float32)(__ccgo_up(cos)) = Float32FromFloat32(1) return } - *(*float32)(unsafe.Pointer(sin)) = X__sindf(tls, float64(x3)) - *(*float32)(unsafe.Pointer(cos)) = X__cosdf(tls, float64(x3)) + **(**float32)(__ccgo_up(sin)) = X__sindf(tls, float64(x3)) + **(**float32)(__ccgo_up(cos)) = X__cosdf(tls, float64(x3)) return } /* |x| ~<= 5*pi/4 */ if ix <= uint32(0x407b53d1) { if ix <= uint32(0x4016cbe3) { /* |x| ~<= 3pi/4 */ if sign != 0 { - *(*float32)(unsafe.Pointer(sin)) = -X__cosdf(tls, float64(x3)+_s1pio2) - *(*float32)(unsafe.Pointer(cos)) = X__sindf(tls, float64(x3)+_s1pio2) + **(**float32)(__ccgo_up(sin)) = -X__cosdf(tls, float64(x3)+_s1pio2) + **(**float32)(__ccgo_up(cos)) = X__sindf(tls, float64(x3)+_s1pio2) } else { - *(*float32)(unsafe.Pointer(sin)) = X__cosdf(tls, _s1pio2-float64(x3)) - *(*float32)(unsafe.Pointer(cos)) = X__sindf(tls, _s1pio2-float64(x3)) + **(**float32)(__ccgo_up(sin)) = X__cosdf(tls, _s1pio2-float64(x3)) + **(**float32)(__ccgo_up(cos)) = X__sindf(tls, _s1pio2-float64(x3)) } return } @@ -112186,24 +112186,24 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { } else { v4 = float64(x3) - _s2pio2 } - *(*float32)(unsafe.Pointer(sin)) = -X__sindf(tls, v4) + **(**float32)(__ccgo_up(sin)) = -X__sindf(tls, v4) if sign != 0 { v4 = float64(x3) + _s2pio2 } else { v4 = float64(x3) - _s2pio2 } - *(*float32)(unsafe.Pointer(cos)) = -X__cosdf(tls, v4) + **(**float32)(__ccgo_up(cos)) = -X__cosdf(tls, v4) return } /* |x| ~<= 9*pi/4 */ if ix <= uint32(0x40e231d5) { if ix <= uint32(0x40afeddf) { /* |x| ~<= 7*pi/4 */ if sign != 0 { - *(*float32)(unsafe.Pointer(sin)) = X__cosdf(tls, float64(x3)+_s3pio2) - *(*float32)(unsafe.Pointer(cos)) = -X__sindf(tls, float64(x3)+_s3pio2) + **(**float32)(__ccgo_up(sin)) = X__cosdf(tls, float64(x3)+_s3pio2) + **(**float32)(__ccgo_up(cos)) = -X__sindf(tls, float64(x3)+_s3pio2) } else { - *(*float32)(unsafe.Pointer(sin)) = -X__cosdf(tls, float64(x3)-_s3pio2) - *(*float32)(unsafe.Pointer(cos)) = X__sindf(tls, float64(x3)-_s3pio2) + **(**float32)(__ccgo_up(sin)) = -X__cosdf(tls, float64(x3)-_s3pio2) + **(**float32)(__ccgo_up(cos)) = X__sindf(tls, float64(x3)-_s3pio2) } return } @@ -112212,41 +112212,41 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { } else { v4 = float64(x3) - _s4pio2 } - *(*float32)(unsafe.Pointer(sin)) = X__sindf(tls, v4) + **(**float32)(__ccgo_up(sin)) = X__sindf(tls, v4) if sign != 0 { v4 = float64(x3) + _s4pio2 } else { v4 = float64(x3) - _s4pio2 } - *(*float32)(unsafe.Pointer(cos)) = X__cosdf(tls, v4) + **(**float32)(__ccgo_up(cos)) = X__cosdf(tls, v4) return } /* sin(Inf or NaN) is NaN */ if ix >= uint32(0x7f800000) { v1 = x3 - x3 - *(*float32)(unsafe.Pointer(cos)) = v1 - *(*float32)(unsafe.Pointer(sin)) = v1 + **(**float32)(__ccgo_up(cos)) = v1 + **(**float32)(__ccgo_up(sin)) = v1 return } /* general argument reduction needed */ n = Uint32FromInt32(X__rem_pio2f(tls, x3, bp)) - s = X__sindf(tls, *(*float64)(unsafe.Pointer(bp))) - c = X__cosdf(tls, *(*float64)(unsafe.Pointer(bp))) + s = X__sindf(tls, **(**float64)(__ccgo_up(bp))) + c = X__cosdf(tls, **(**float64)(__ccgo_up(bp))) switch n & Uint32FromInt32(3) { case uint32(0): - *(*float32)(unsafe.Pointer(sin)) = s - *(*float32)(unsafe.Pointer(cos)) = c + **(**float32)(__ccgo_up(sin)) = s + **(**float32)(__ccgo_up(cos)) = c case uint32(1): - *(*float32)(unsafe.Pointer(sin)) = c - *(*float32)(unsafe.Pointer(cos)) = -s + **(**float32)(__ccgo_up(sin)) = c + **(**float32)(__ccgo_up(cos)) = -s case uint32(2): - *(*float32)(unsafe.Pointer(sin)) = -s - *(*float32)(unsafe.Pointer(cos)) = -c + **(**float32)(__ccgo_up(sin)) = -s + **(**float32)(__ccgo_up(cos)) = -c case uint32(3): fallthrough default: - *(*float32)(unsafe.Pointer(sin)) = -c - *(*float32)(unsafe.Pointer(cos)) = s + **(**float32)(__ccgo_up(sin)) = -c + **(**float32)(__ccgo_up(cos)) = s break } } @@ -112262,8 +112262,8 @@ func Xsincosl(tls *TLS, x float64, sin uintptr, cos uintptr) { var _ /* cosd at bp+8 */ float64 var _ /* sind at bp+0 */ float64 Xsincos(tls, x, bp, bp+8) - *(*float64)(unsafe.Pointer(sin)) = *(*float64)(unsafe.Pointer(bp)) - *(*float64)(unsafe.Pointer(cos)) = *(*float64)(unsafe.Pointer(bp + 8)) + **(**float64)(__ccgo_up(sin)) = float64(**(**float64)(__ccgo_up(bp))) + **(**float64)(__ccgo_up(cos)) = float64(**(**float64)(__ccgo_up(bp + 8))) } const M_PI_27 = 1.5707963267948966 @@ -112362,13 +112362,13 @@ func Xsinf(tls *TLS, x3 float32) (r float32) { n = X__rem_pio2f(tls, x3, bp) switch n & Int32FromInt32(3) { case 0: - return X__sindf(tls, *(*float64)(unsafe.Pointer(bp))) + return X__sindf(tls, **(**float64)(__ccgo_up(bp))) case int32(1): - return X__cosdf(tls, *(*float64)(unsafe.Pointer(bp))) + return X__cosdf(tls, **(**float64)(__ccgo_up(bp))) case int32(2): - return X__sindf(tls, -*(*float64)(unsafe.Pointer(bp))) + return X__sindf(tls, -**(**float64)(__ccgo_up(bp))) default: - return -X__cosdf(tls, *(*float64)(unsafe.Pointer(bp))) + return -X__cosdf(tls, **(**float64)(__ccgo_up(bp))) } return r } @@ -112814,7 +112814,7 @@ func Xtan(tls *TLS, x3 float64) (r float64) { } /* argument reduction */ n = Uint32FromInt32(X__rem_pio2(tls, x3, bp)) - return X__tan(tls, (*(*[2]float64)(unsafe.Pointer(bp)))[0], (*(*[2]float64)(unsafe.Pointer(bp)))[int32(1)], Int32FromUint32(n&uint32(1))) + return X__tan(tls, (**(**[2]float64)(__ccgo_up(bp)))[0], (**(**[2]float64)(__ccgo_up(bp)))[int32(1)], Int32FromUint32(n&uint32(1))) } const M_PI_29 = 1.5707963267948966 @@ -112915,7 +112915,7 @@ func Xtanf(tls *TLS, x3 float32) (r float32) { } /* argument reduction */ n = Uint32FromInt32(X__rem_pio2f(tls, x3, bp)) - return X__tandf(tls, *(*float64)(unsafe.Pointer(bp)), Int32FromUint32(n&uint32(1))) + return X__tandf(tls, **(**float64)(__ccgo_up(bp)), Int32FromUint32(n&uint32(1))) } const M_PI_210 = 0 @@ -113455,10 +113455,10 @@ func Xa64l(tls *TLS, s uintptr) (r int64) { x = uint32(0) e = 0 for { - if !(e < int32(36) && *(*uint8)(unsafe.Pointer(s)) != 0) { + if !(e < int32(36) && **(**uint8)(__ccgo_up(s)) != 0) { break } - d = Xstrchr(tls, uintptr(unsafe.Pointer(&_digits)), Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))) + d = Xstrchr(tls, uintptr(unsafe.Pointer(&_digits)), Int32FromUint8(**(**uint8)(__ccgo_up(s)))) if !(d != 0) { break } @@ -113486,14 +113486,14 @@ func Xl64a(tls *TLS, x0 int64) (r uintptr) { if !(x != 0) { break } - *(*uint8)(unsafe.Pointer(p)) = _digits[x&uint32(63)] + **(**uint8)(__ccgo_up(p)) = _digits[x&uint32(63)] goto _1 _1: ; p = p + 1 x = x >> uint32(6) } - *(*uint8)(unsafe.Pointer(p)) = uint8(0) + **(**uint8)(__ccgo_up(p)) = uint8(0) return uintptr(unsafe.Pointer(&_s)) } @@ -113506,22 +113506,22 @@ func Xbasename(tls *TLS, s uintptr) (r uintptr) { } var i Tsize_t _ = i - if !(s != 0) || !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(s != 0) || !(**(**uint8)(__ccgo_up(s)) != 0) { return __ccgo_ts + 558 } i = _strlen(tls, s) - uint64(1) for { - if !(i != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(i)))) == int32('/')) { + if !(i != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(i)))) == int32('/')) { break } - *(*uint8)(unsafe.Pointer(s + uintptr(i))) = uint8(0) + **(**uint8)(__ccgo_up(s + uintptr(i))) = uint8(0) goto _1 _1: ; i = i - 1 } for { - if !(i != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(i-uint64(1))))) != int32('/')) { + if !(i != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(i-uint64(1))))) != int32('/')) { break } goto _2 @@ -113547,12 +113547,12 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { } var i Tsize_t _ = i - if !(s != 0) || !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(s != 0) || !(**(**uint8)(__ccgo_up(s)) != 0) { return __ccgo_ts + 558 } i = _strlen(tls, s) - uint64(1) for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(i)))) == int32('/')) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(i)))) == int32('/')) { break } if !(i != 0) { @@ -113564,7 +113564,7 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { i = i - 1 } for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(i)))) != int32('/')) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(i)))) != int32('/')) { break } if !(i != 0) { @@ -113576,7 +113576,7 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { i = i - 1 } for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(i)))) == int32('/')) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(i)))) == int32('/')) { break } if !(i != 0) { @@ -113587,7 +113587,7 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { ; i = i - 1 } - *(*uint8)(unsafe.Pointer(s + uintptr(i+uint64(1)))) = uint8(0) + **(**uint8)(__ccgo_up(s + uintptr(i+uint64(1)))) = uint8(0) return s } @@ -113678,10 +113678,10 @@ func __strcolcmp(tls *TLS, lstr uintptr, bstr uintptr) (r int32) { var i Tsize_t _ = i i = uint64(0) - for *(*uint8)(unsafe.Pointer(lstr + uintptr(i))) != 0 && *(*uint8)(unsafe.Pointer(bstr + uintptr(i))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(bstr + uintptr(i)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(lstr + uintptr(i)))) { + for **(**uint8)(__ccgo_up(lstr + uintptr(i))) != 0 && **(**uint8)(__ccgo_up(bstr + uintptr(i))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(bstr + uintptr(i)))) == Int32FromUint8(**(**uint8)(__ccgo_up(lstr + uintptr(i)))) { i = i + 1 } - if *(*uint8)(unsafe.Pointer(lstr + uintptr(i))) != 0 || *(*uint8)(unsafe.Pointer(bstr + uintptr(i))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(bstr + uintptr(i)))) != int32(':') { + if **(**uint8)(__ccgo_up(lstr + uintptr(i))) != 0 || **(**uint8)(__ccgo_up(bstr + uintptr(i))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(bstr + uintptr(i)))) != int32(':') { return int32(1) } return 0 @@ -113779,7 +113779,7 @@ func Xfmtmsg(tls *TLS, classification int64, label uintptr, severity int32, text } } if classification&int64(MM_PRINT) != 0 { - for cmsg != 0 && *(*uint8)(unsafe.Pointer(cmsg)) != 0 { + for cmsg != 0 && **(**uint8)(__ccgo_up(cmsg)) != 0 { i = 0 for { if !(msgs[i] != 0) { @@ -113855,7 +113855,7 @@ func Xfmtmsg(tls *TLS, classification int64, label uintptr, severity int32, text if ret&(Int32FromInt32(MM_NOCON)|Int32FromInt32(MM_NOMSG)) == Int32FromInt32(MM_NOCON)|Int32FromInt32(MM_NOMSG) { ret = -int32(1) } - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) return ret } @@ -113871,7 +113871,7 @@ func Xget_current_dir_name(tls *TLS) (r uintptr) { var _ /* b at bp+128 */ Tstat _ = res res = Xgetenv(tls, __ccgo_ts+692) - if res != 0 && *(*uint8)(unsafe.Pointer(res)) != 0 && !(Xstat(tls, res, bp) != 0) && !(Xstat(tls, __ccgo_ts+558, bp+128) != 0) && (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev == (*(*Tstat)(unsafe.Pointer(bp + 128))).Fst_dev && (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino == (*(*Tstat)(unsafe.Pointer(bp + 128))).Fst_ino { + if res != 0 && **(**uint8)(__ccgo_up(res)) != 0 && !(Xstat(tls, res, bp) != 0) && !(Xstat(tls, __ccgo_ts+558, bp+128) != 0) && (**(**Tstat)(__ccgo_up(bp))).Fst_dev == (**(**Tstat)(__ccgo_up(bp + 128))).Fst_dev && (**(**Tstat)(__ccgo_up(bp))).Fst_ino == (**(**Tstat)(__ccgo_up(bp + 128))).Fst_ino { return Xstrdup(tls, res) } return Xgetcwd(tls, uintptr(0), uint64(0)) @@ -113889,18 +113889,18 @@ func X__getauxval(tls *TLS, item uint64) (r uint64) { return uint64(X__libc.Fsecure) } for { - if !(*(*Tsize_t)(unsafe.Pointer(auxv)) != 0) { + if !(**(**Tsize_t)(__ccgo_up(auxv)) != 0) { break } - if *(*Tsize_t)(unsafe.Pointer(auxv)) == item { - return *(*Tsize_t)(unsafe.Pointer(auxv + 1*8)) + if **(**Tsize_t)(__ccgo_up(auxv)) == item { + return **(**Tsize_t)(__ccgo_up(auxv + 1*8)) } goto _1 _1: ; auxv = auxv + uintptr(2)*8 } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOENT) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOENT) return uint64(0) } @@ -113931,7 +113931,7 @@ func Xgetdomainname(tls *TLS, name uintptr, len1 Tsize_t) (r int32) { var _ /* temp at bp+0 */ Tutsname Xuname(tls, bp) if !(len1 != 0) || _strlen(tls, bp+325) >= len1 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } Xstrcpy(tls, name, bp+325) @@ -113952,14 +113952,14 @@ func Xgetentropy(tls *TLS, buffer uintptr, len1 Tsize_t) (r int32) { ret = 0 pos = buffer if len1 > uint64(256) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EIO) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EIO) return -int32(1) } _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp) for len1 != 0 { ret = int32(Xgetrandom(tls, pos, len1, uint32(0))) if ret < 0 { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EINTR) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EINTR) { continue } else { break @@ -113969,7 +113969,7 @@ func Xgetentropy(tls *TLS, buffer uintptr, len1 Tsize_t) (r int32) { len1 = len1 - Uint64FromInt32(ret) ret = 0 } - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) return ret } @@ -114023,46 +114023,46 @@ func Xgetopt(tls *TLS, argc int32, argv uintptr, optstring uintptr) (r int32) { X__optpos = 0 Xoptind = int32(1) } - if Xoptind >= argc || !(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) != 0) { + if Xoptind >= argc || !(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) != 0) { return -int32(1) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))))) != int32('-') { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) == int32('-') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8))))) != int32('-') { + if Int32FromUint8(**(**uint8)(__ccgo_up(optstring))) == int32('-') { v1 = Xoptind Xoptind = Xoptind + 1 - Xoptarg = *(*uintptr)(unsafe.Pointer(argv + uintptr(v1)*8)) + Xoptarg = **(**uintptr)(__ccgo_up(argv + uintptr(v1)*8)) return int32(1) } return -int32(1) } - if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1)) != 0) { + if !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + 1)) != 0) { return -int32(1) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1))) == int32('-') && !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 2)) != 0) { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + 1))) == int32('-') && !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + 2)) != 0) { Xoptind = Xoptind + 1 return -Int32FromInt32(1) } if !(X__optpos != 0) { X__optpos = X__optpos + 1 } - v1 = Xmbtowc(tls, bp, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))+uintptr(X__optpos), uint64(MB_LEN_MAX)) + v1 = Xmbtowc(tls, bp, **(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8))+uintptr(X__optpos), uint64(MB_LEN_MAX)) k = v1 if v1 < 0 { k = int32(1) - *(*Twchar_t)(unsafe.Pointer(bp)) = uint32(0xfffd) /* replacement char */ + **(**Twchar_t)(__ccgo_up(bp)) = uint32(0xfffd) /* replacement char */ } - optchar = *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + uintptr(X__optpos) + optchar = **(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + uintptr(X__optpos) X__optpos = X__optpos + k - if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + uintptr(X__optpos))) != 0) { + if !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + uintptr(X__optpos))) != 0) { Xoptind = Xoptind + 1 X__optpos = 0 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) == int32('-') || Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) == int32('+') { + if Int32FromUint8(**(**uint8)(__ccgo_up(optstring))) == int32('-') || Int32FromUint8(**(**uint8)(__ccgo_up(optstring))) == int32('+') { optstring = optstring + 1 } i = 0 - *(*Twchar_t)(unsafe.Pointer(bp + 4)) = uint32(0) - for cond := true; cond; cond = l != 0 && *(*Twchar_t)(unsafe.Pointer(bp + 4)) != *(*Twchar_t)(unsafe.Pointer(bp)) { + **(**Twchar_t)(__ccgo_up(bp + 4)) = uint32(0) + for cond := true; cond; cond = l != 0 && **(**Twchar_t)(__ccgo_up(bp + 4)) != **(**Twchar_t)(__ccgo_up(bp)) { l = Xmbtowc(tls, bp+4, optstring+uintptr(i), uint64(MB_LEN_MAX)) if l > 0 { i = i + l @@ -114070,36 +114070,36 @@ func Xgetopt(tls *TLS, argc int32, argv uintptr, optstring uintptr) (r int32) { i = i + 1 } } - if *(*Twchar_t)(unsafe.Pointer(bp + 4)) != *(*Twchar_t)(unsafe.Pointer(bp)) || *(*Twchar_t)(unsafe.Pointer(bp)) == uint32(':') { - Xoptopt = Int32FromUint32(*(*Twchar_t)(unsafe.Pointer(bp))) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) != int32(':') && Xopterr != 0 { - X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), __ccgo_ts+696, optchar, Uint64FromInt32(k)) + if **(**Twchar_t)(__ccgo_up(bp + 4)) != **(**Twchar_t)(__ccgo_up(bp)) || **(**Twchar_t)(__ccgo_up(bp)) == uint32(':') { + Xoptopt = Int32FromUint32(**(**Twchar_t)(__ccgo_up(bp))) + if Int32FromUint8(**(**uint8)(__ccgo_up(optstring))) != int32(':') && Xopterr != 0 { + X__getopt_msg(tls, **(**uintptr)(__ccgo_up(argv)), __ccgo_ts+696, optchar, Uint64FromInt32(k)) } return int32('?') } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring + uintptr(i)))) == int32(':') { + if Int32FromUint8(**(**uint8)(__ccgo_up(optstring + uintptr(i)))) == int32(':') { Xoptarg = uintptr(0) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring + uintptr(i+int32(1))))) != int32(':') || X__optpos != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(optstring + uintptr(i+int32(1))))) != int32(':') || X__optpos != 0 { v1 = Xoptind Xoptind = Xoptind + 1 - Xoptarg = *(*uintptr)(unsafe.Pointer(argv + uintptr(v1)*8)) + Xoptarg = **(**uintptr)(__ccgo_up(argv + uintptr(v1)*8)) if X__optpos != 0 { Xoptarg = Xoptarg + uintptr(X__optpos) } X__optpos = 0 } if Xoptind > argc { - Xoptopt = Int32FromUint32(*(*Twchar_t)(unsafe.Pointer(bp))) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) == int32(':') { + Xoptopt = Int32FromUint32(**(**Twchar_t)(__ccgo_up(bp))) + if Int32FromUint8(**(**uint8)(__ccgo_up(optstring))) == int32(':') { return int32(':') } if Xopterr != 0 { - X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), __ccgo_ts+720, optchar, Uint64FromInt32(k)) + X__getopt_msg(tls, **(**uintptr)(__ccgo_up(argv)), __ccgo_ts+720, optchar, Uint64FromInt32(k)) } return int32('?') } } - return Int32FromUint32(*(*Twchar_t)(unsafe.Pointer(bp))) + return Int32FromUint32(**(**Twchar_t)(__ccgo_up(bp))) } func X__posix_getopt(tls *TLS, argc int32, argv uintptr, optstring uintptr) (r int32) { @@ -114126,19 +114126,19 @@ func _permute(tls *TLS, argv uintptr, dest int32, src int32) { var i int32 _, _, _ = av, i, tmp av = argv - tmp = *(*uintptr)(unsafe.Pointer(av + uintptr(src)*8)) + tmp = **(**uintptr)(__ccgo_up(av + uintptr(src)*8)) i = src for { if !(i > dest) { break } - *(*uintptr)(unsafe.Pointer(av + uintptr(i)*8)) = *(*uintptr)(unsafe.Pointer(av + uintptr(i-int32(1))*8)) + **(**uintptr)(__ccgo_up(av + uintptr(i)*8)) = **(**uintptr)(__ccgo_up(av + uintptr(i-int32(1))*8)) goto _1 _1: ; i = i - 1 } - *(*uintptr)(unsafe.Pointer(av + uintptr(dest)*8)) = tmp + **(**uintptr)(__ccgo_up(av + uintptr(dest)*8)) = tmp } func ___getopt_long(tls *TLS, argc int32, argv uintptr, optstring uintptr, longopts uintptr, idx uintptr, longonly int32) (r int32) { @@ -114149,17 +114149,17 @@ func ___getopt_long(tls *TLS, argc int32, argv uintptr, optstring uintptr, longo X__optpos = 0 Xoptind = int32(1) } - if Xoptind >= argc || !(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) != 0) { + if Xoptind >= argc || !(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) != 0) { return -int32(1) } skipped = Xoptind - if Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) != int32('+') && Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) != int32('-') { + if Int32FromUint8(**(**uint8)(__ccgo_up(optstring))) != int32('+') && Int32FromUint8(**(**uint8)(__ccgo_up(optstring))) != int32('-') { i = Xoptind for { - if i >= argc || !(*(*uintptr)(unsafe.Pointer(argv + uintptr(i)*8)) != 0) { + if i >= argc || !(**(**uintptr)(__ccgo_up(argv + uintptr(i)*8)) != 0) { return -int32(1) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(i)*8))))) == int32('-') && *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(i)*8)) + 1)) != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(i)*8))))) == int32('-') && **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(i)*8)) + 1)) != 0 { break } goto _1 @@ -114194,31 +114194,31 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, var cnt, colon, i, j, l, match, v2 int32 _, _, _, _, _, _, _, _, _, _, _, _ = arg, cnt, colon, i, j, l, match, name, opt, start, v2, v5 Xoptarg = uintptr(0) - if longopts != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))))) == int32('-') && (longonly != 0 && *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1))) != int32('-') || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1))) == int32('-') && *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 2)) != 0) { - colon = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring + BoolUintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) == int32('+') || Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) == int32('-'))))) == int32(':')) - start = *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + uintptr(1) + if longopts != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8))))) == int32('-') && (longonly != 0 && **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + 1)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + 1))) != int32('-') || Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + 1))) == int32('-') && **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + 2)) != 0) { + colon = BoolInt32(Int32FromUint8(**(**uint8)(__ccgo_up(optstring + BoolUintptr(Int32FromUint8(**(**uint8)(__ccgo_up(optstring))) == int32('+') || Int32FromUint8(**(**uint8)(__ccgo_up(optstring))) == int32('-'))))) == int32(':')) + start = **(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + uintptr(1) v2 = Int32FromInt32(0) i = v2 cnt = v2 for { - if !((*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname != 0) { + if !((**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fname != 0) { break } - name = (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname + name = (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fname opt = start - if Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) == int32('-') { + if Int32FromUint8(**(**uint8)(__ccgo_up(opt))) == int32('-') { opt = opt + 1 } - for *(*uint8)(unsafe.Pointer(opt)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) != int32('=') && Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) { + for **(**uint8)(__ccgo_up(opt)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(opt))) != int32('=') && Int32FromUint8(**(**uint8)(__ccgo_up(opt))) == Int32FromUint8(**(**uint8)(__ccgo_up(name))) { name = name + 1 opt = opt + 1 } - if *(*uint8)(unsafe.Pointer(opt)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) != int32('=') { + if **(**uint8)(__ccgo_up(opt)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(opt))) != int32('=') { goto _1 } arg = opt match = i - if !(*(*uint8)(unsafe.Pointer(name)) != 0) { + if !(**(**uint8)(__ccgo_up(name)) != 0) { cnt = int32(1) break } @@ -114232,12 +114232,12 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, l = int32(int64(arg) - int64(start)) i = 0 for { - if !(*(*uint8)(unsafe.Pointer(optstring + uintptr(i))) != 0) { + if !(**(**uint8)(__ccgo_up(optstring + uintptr(i))) != 0) { break } j = 0 for { - if !(j < l && Int32FromUint8(*(*uint8)(unsafe.Pointer(start + uintptr(j)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring + uintptr(i+j))))) { + if !(j < l && Int32FromUint8(**(**uint8)(__ccgo_up(start + uintptr(j)))) == Int32FromUint8(**(**uint8)(__ccgo_up(optstring + uintptr(i+j))))) { break } goto _4 @@ -114259,44 +114259,44 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, i = match opt = arg Xoptind = Xoptind + 1 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) == int32('=') { - if !((*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fhas_arg != 0) { - Xoptopt = (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fval + if Int32FromUint8(**(**uint8)(__ccgo_up(opt))) == int32('=') { + if !((**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fhas_arg != 0) { + Xoptopt = (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fval if colon != 0 || !(Xopterr != 0) { return int32('?') } - X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), __ccgo_ts+752, (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname, _strlen(tls, (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname)) + X__getopt_msg(tls, **(**uintptr)(__ccgo_up(argv)), __ccgo_ts+752, (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fname, _strlen(tls, (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fname)) return int32('?') } Xoptarg = opt + uintptr(1) } else { - if (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fhas_arg == int32(required_argument) { - v5 = *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + if (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fhas_arg == int32(required_argument) { + v5 = **(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) Xoptarg = v5 if !(v5 != 0) { - Xoptopt = (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fval + Xoptopt = (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fval if colon != 0 { return int32(':') } if !(Xopterr != 0) { return int32('?') } - X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), __ccgo_ts+720, (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname, _strlen(tls, (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname)) + X__getopt_msg(tls, **(**uintptr)(__ccgo_up(argv)), __ccgo_ts+720, (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fname, _strlen(tls, (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fname)) return int32('?') } Xoptind = Xoptind + 1 } } if idx != 0 { - *(*int32)(unsafe.Pointer(idx)) = i + **(**int32)(__ccgo_up(idx)) = i } - if (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fflag != 0 { - *(*int32)(unsafe.Pointer((*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fflag)) = (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fval + if (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fflag != 0 { + **(**int32)(__ccgo_up((**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fflag)) = (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fval return 0 } - return (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fval + return (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fval } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1))) == int32('-') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + 1))) == int32('-') { Xoptopt = 0 if !(colon != 0) && Xopterr != 0 { if cnt != 0 { @@ -114304,7 +114304,7 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, } else { v5 = __ccgo_ts + 696 } - X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), v5, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))+uintptr(2), _strlen(tls, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))+uintptr(2))) + X__getopt_msg(tls, **(**uintptr)(__ccgo_up(argv)), v5, **(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8))+uintptr(2), _strlen(tls, **(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8))+uintptr(2))) } Xoptind = Xoptind + 1 return int32('?') @@ -114379,22 +114379,22 @@ func Xgetrlimit(tls *TLS, resource int32, rlim uintptr) (r int32) { (*Trlimit)(unsafe.Pointer(rlim)).Frlim_max = ^Uint64FromUint64(0) } } - if !(ret != 0) || *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(ENOSYS) { + if !(ret != 0) || **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(ENOSYS) { return ret } if X__syscall_ret(tls, Uint64FromInt64(X__syscall2(tls, int64(SYS_getrlimit), int64(resource), int64(bp)))) < 0 { return -int32(1) } - if (*(*[2]uint64)(unsafe.Pointer(bp)))[0] == -Uint64FromUint64(1) { + if (**(**[2]uint64)(__ccgo_up(bp)))[0] == -Uint64FromUint64(1) { v1 = ^Uint64FromUint64(0) } else { - v1 = (*(*[2]uint64)(unsafe.Pointer(bp)))[0] + v1 = (**(**[2]uint64)(__ccgo_up(bp)))[0] } (*Trlimit)(unsafe.Pointer(rlim)).Frlim_cur = v1 - if (*(*[2]uint64)(unsafe.Pointer(bp)))[int32(1)] == -Uint64FromUint64(1) { + if (**(**[2]uint64)(__ccgo_up(bp)))[int32(1)] == -Uint64FromUint64(1) { v1 = ^Uint64FromUint64(0) } else { - v1 = (*(*[2]uint64)(unsafe.Pointer(bp)))[int32(1)] + v1 = (**(**[2]uint64)(__ccgo_up(bp)))[int32(1)] } (*Trlimit)(unsafe.Pointer(rlim)).Frlim_max = v1 if (*Trlimit)(unsafe.Pointer(rlim)).Frlim_cur >= ^Uint64FromUint64(0) { @@ -114422,12 +114422,12 @@ func Xgetrusage(tls *TLS, who int32, ru uintptr) (r1 int32) { if !(r != 0) && Bool(uint64(8) > uint64(8)) { Xmemcpy(tls, bp, dest, Uint64FromInt32(4)*Uint64FromInt64(8)) (*Trusage)(unsafe.Pointer(ru)).Fru_utime = Ttimeval{ - Ftv_sec: (*(*[4]int64)(unsafe.Pointer(bp)))[0], - Ftv_usec: (*(*[4]int64)(unsafe.Pointer(bp)))[int32(1)], + Ftv_sec: (**(**[4]int64)(__ccgo_up(bp)))[0], + Ftv_usec: (**(**[4]int64)(__ccgo_up(bp)))[int32(1)], } (*Trusage)(unsafe.Pointer(ru)).Fru_stime = Ttimeval{ - Ftv_sec: (*(*[4]int64)(unsafe.Pointer(bp)))[int32(2)], - Ftv_usec: (*(*[4]int64)(unsafe.Pointer(bp)))[int32(3)], + Ftv_sec: (**(**[4]int64)(__ccgo_up(bp)))[int32(2)], + Ftv_usec: (**(**[4]int64)(__ccgo_up(bp)))[int32(3)], } } return int32(X__syscall_ret(tls, Uint64FromInt32(r))) @@ -114442,30 +114442,30 @@ func Xgetsubopt(tls *TLS, opt uintptr, keys uintptr, val uintptr) (r int32) { var l Tsize_t var s, v1, v2 uintptr _, _, _, _, _ = i, l, s, v1, v2 - s = *(*uintptr)(unsafe.Pointer(opt)) - *(*uintptr)(unsafe.Pointer(val)) = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(opt)) = Xstrchr(tls, s, int32(',')) - if *(*uintptr)(unsafe.Pointer(opt)) != 0 { + s = **(**uintptr)(__ccgo_up(opt)) + **(**uintptr)(__ccgo_up(val)) = UintptrFromInt32(0) + **(**uintptr)(__ccgo_up(opt)) = Xstrchr(tls, s, int32(',')) + if **(**uintptr)(__ccgo_up(opt)) != 0 { v2 = opt v1 = *(*uintptr)(unsafe.Pointer(v2)) *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(v2)) + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) } else { - *(*uintptr)(unsafe.Pointer(opt)) = s + uintptr(_strlen(tls, s)) + **(**uintptr)(__ccgo_up(opt)) = s + uintptr(_strlen(tls, s)) } i = 0 for { - if !(*(*uintptr)(unsafe.Pointer(keys + uintptr(i)*8)) != 0) { + if !(**(**uintptr)(__ccgo_up(keys + uintptr(i)*8)) != 0) { break } - l = _strlen(tls, *(*uintptr)(unsafe.Pointer(keys + uintptr(i)*8))) - if Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(keys + uintptr(i)*8)), s, l) != 0 { + l = _strlen(tls, **(**uintptr)(__ccgo_up(keys + uintptr(i)*8))) + if Xstrncmp(tls, **(**uintptr)(__ccgo_up(keys + uintptr(i)*8)), s, l) != 0 { goto _3 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(l)))) == int32('=') { - *(*uintptr)(unsafe.Pointer(val)) = s + uintptr(l) + uintptr(1) + if Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(l)))) == int32('=') { + **(**uintptr)(__ccgo_up(val)) = s + uintptr(l) + uintptr(1) } else { - if *(*uint8)(unsafe.Pointer(s + uintptr(l))) != 0 { + if **(**uint8)(__ccgo_up(s + uintptr(l))) != 0 { goto _3 } } @@ -114754,7 +114754,7 @@ func _convert_ioctl_struct(tls *TLS, map1 uintptr, old uintptr, new1 uintptr, di if !(i < Int32FromUint8((*Tioctl_compat_map)(unsafe.Pointer(map1)).Fnoffs)) { break } - ts_offset = Int32FromUint8(*(*uint8)(unsafe.Pointer(map1 + 12 + uintptr(i)))) + ts_offset = Int32FromUint8(**(**uint8)(__ccgo_up(map1 + 12 + uintptr(i)))) len1 = ts_offset - old_offset if dir == int32(W) { Xmemcpy(tls, old+uintptr(old_offset), new1+uintptr(new_offset), Uint64FromInt32(len1)) @@ -114772,11 +114772,11 @@ func _convert_ioctl_struct(tls *TLS, map1 uintptr, old uintptr, new1 uintptr, di new_offset = new_offset + (align-int32(1))&-new_offset if dir == int32(W) { Xmemcpy(tls, bp, new1+uintptr(new_offset), uint64(8)) - *(*int64)(unsafe.Pointer(bp + 8)) = *(*int64)(unsafe.Pointer(bp)) + **(**int64)(__ccgo_up(bp + 8)) = int64(**(**int64)(__ccgo_up(bp))) Xmemcpy(tls, old+uintptr(old_offset), bp+8, uint64(8)) } else { Xmemcpy(tls, bp+8, old+uintptr(old_offset), uint64(8)) - *(*int64)(unsafe.Pointer(bp)) = *(*int64)(unsafe.Pointer(bp + 8)) + **(**int64)(__ccgo_up(bp)) = int64(**(**int64)(__ccgo_up(bp + 8))) Xmemcpy(tls, new1+uintptr(new_offset), bp, uint64(8)) } new_offset = Int32FromUint64(uint64(new_offset) + Uint64FromInt64(8)) @@ -114854,31 +114854,31 @@ func Xlockf(tls *TLS, fd int32, op int32, size Toff_t) (r int32) { bp := tls.Alloc(48) defer tls.Free(48) var _ /* l at bp+0 */ Tflock - *(*Tflock)(unsafe.Pointer(bp)) = Tflock{ + **(**Tflock)(__ccgo_up(bp)) = Tflock{ Fl_type: int16(F_WRLCK), Fl_whence: int16(1), Fl_len: size, } switch op { case int32(F_TEST): - (*(*Tflock)(unsafe.Pointer(bp))).Fl_type = F_RDLCK + (**(**Tflock)(__ccgo_up(bp))).Fl_type = F_RDLCK if Xfcntl(tls, fd, int32(F_GETLK), VaList(bp+40, bp)) < 0 { return -int32(1) } - if int32((*(*Tflock)(unsafe.Pointer(bp))).Fl_type) == int32(F_UNLCK) || (*(*Tflock)(unsafe.Pointer(bp))).Fl_pid == Xgetpid(tls) { + if int32((**(**Tflock)(__ccgo_up(bp))).Fl_type) == int32(F_UNLCK) || (**(**Tflock)(__ccgo_up(bp))).Fl_pid == Xgetpid(tls) { return 0 } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EACCES) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EACCES) return -int32(1) case F_ULOCK: - (*(*Tflock)(unsafe.Pointer(bp))).Fl_type = int16(F_UNLCK) + (**(**Tflock)(__ccgo_up(bp))).Fl_type = int16(F_UNLCK) fallthrough case int32(F_TLOCK): return Xfcntl(tls, fd, int32(F_SETLK), VaList(bp+40, bp)) case int32(F_LOCK): return Xfcntl(tls, fd, int32(F_SETLKW), VaList(bp+40, bp)) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } @@ -114980,23 +114980,23 @@ func _unescape_ent(tls *TLS, beg uintptr) (r uintptr) { _, _, _, _, _, _, _ = cval, dest, i, src, val, v1, v2 dest = beg src = beg - for *(*uint8)(unsafe.Pointer(src)) != 0 { + for **(**uint8)(__ccgo_up(src)) != 0 { cval = uint8(0) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) != int32('\\') { + if Int32FromUint8(**(**uint8)(__ccgo_up(src))) != int32('\\') { v1 = dest dest = dest + 1 v2 = src src = src + 1 - *(*uint8)(unsafe.Pointer(v1)) = *(*uint8)(unsafe.Pointer(v2)) + **(**uint8)(__ccgo_up(v1)) = **(**uint8)(__ccgo_up(v2)) continue } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 1))) == int32('\\') { + if Int32FromUint8(**(**uint8)(__ccgo_up(src + 1))) == int32('\\') { src = src + 1 v1 = dest dest = dest + 1 v2 = src src = src + 1 - *(*uint8)(unsafe.Pointer(v1)) = *(*uint8)(unsafe.Pointer(v2)) + **(**uint8)(__ccgo_up(v1)) = **(**uint8)(__ccgo_up(v2)) continue } val = src + uintptr(1) @@ -115005,11 +115005,11 @@ func _unescape_ent(tls *TLS, beg uintptr) (r uintptr) { if !(i < int32(3)) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(val))) >= int32('0') && Int32FromUint8(*(*uint8)(unsafe.Pointer(val))) <= int32('7') { + if Int32FromUint8(**(**uint8)(__ccgo_up(val))) >= int32('0') && Int32FromUint8(**(**uint8)(__ccgo_up(val))) <= int32('7') { cval = Uint8FromInt32(int32(cval) << Int32FromInt32(3)) v1 = val val = val + 1 - cval = Uint8FromInt32(int32(cval) + (Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) - Int32FromUint8('0'))) + cval = Uint8FromInt32(int32(cval) + (Int32FromUint8(**(**uint8)(__ccgo_up(v1))) - Int32FromUint8('0'))) } else { break } @@ -115021,17 +115021,17 @@ func _unescape_ent(tls *TLS, beg uintptr) (r uintptr) { if cval != 0 { v1 = dest dest = dest + 1 - *(*uint8)(unsafe.Pointer(v1)) = cval + **(**uint8)(__ccgo_up(v1)) = cval src = val } else { v1 = dest dest = dest + 1 v2 = src src = src + 1 - *(*uint8)(unsafe.Pointer(v1)) = *(*uint8)(unsafe.Pointer(v2)) + **(**uint8)(__ccgo_up(v1)) = **(**uint8)(__ccgo_up(v2)) } } - *(*uint8)(unsafe.Pointer(dest)) = uint8(0) + **(**uint8)(__ccgo_up(dest)) = uint8(0) return beg } @@ -115049,7 +115049,7 @@ func Xgetmntent_r(tls *TLS, f uintptr, mnt uintptr, linebuf uintptr, buflen int3 use_internal = BoolInt32(linebuf == uintptr(unsafe.Pointer(&_internal_buf))) (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_freq = 0 (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_passno = 0 - for cond := true; cond; cond = Int32FromUint8(*(*uint8)(unsafe.Pointer(linebuf + uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[0])))) == int32('#') || Uint64FromInt32((*(*[8]int32)(unsafe.Pointer(bp)))[int32(1)]) == len1 { + for cond := true; cond; cond = Int32FromUint8(**(**uint8)(__ccgo_up(linebuf + uintptr((**(**[8]int32)(__ccgo_up(bp)))[0])))) == int32('#') || Uint64FromInt32((**(**[8]int32)(__ccgo_up(bp)))[int32(1)]) == len1 { if use_internal != 0 { Xgetline(tls, uintptr(unsafe.Pointer(&_internal_buf)), uintptr(unsafe.Pointer(&_internal_bufsize)), f) linebuf = _internal_buf @@ -115061,7 +115061,7 @@ func Xgetmntent_r(tls *TLS, f uintptr, mnt uintptr, linebuf uintptr, buflen int3 } if !(Xstrchr(tls, linebuf, int32('\n')) != 0) { Xfscanf(tls, f, __ccgo_ts+813, 0) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return uintptr(0) } len1 = _strlen(tls, linebuf) @@ -115073,7 +115073,7 @@ func Xgetmntent_r(tls *TLS, f uintptr, mnt uintptr, linebuf uintptr, buflen int3 if !(i < Uint64FromInt64(32)/Uint64FromInt64(4)) { break } - (*(*[8]int32)(unsafe.Pointer(bp)))[i] = Int32FromUint64(len1) + (**(**[8]int32)(__ccgo_up(bp)))[i] = Int32FromUint64(len1) goto _1 _1: ; @@ -115081,14 +115081,14 @@ func Xgetmntent_r(tls *TLS, f uintptr, mnt uintptr, linebuf uintptr, buflen int3 } Xsscanf(tls, linebuf, __ccgo_ts+825, VaList(bp+40, bp, bp+uintptr(1)*4, bp+uintptr(2)*4, bp+uintptr(3)*4, bp+uintptr(4)*4, bp+uintptr(5)*4, bp+uintptr(6)*4, bp+uintptr(7)*4, mnt+32, mnt+36)) } - *(*uint8)(unsafe.Pointer(linebuf + uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(1)]))) = uint8(0) - *(*uint8)(unsafe.Pointer(linebuf + uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(3)]))) = uint8(0) - *(*uint8)(unsafe.Pointer(linebuf + uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(5)]))) = uint8(0) - *(*uint8)(unsafe.Pointer(linebuf + uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(7)]))) = uint8(0) - (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_fsname = _unescape_ent(tls, linebuf+uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[0])) - (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_dir = _unescape_ent(tls, linebuf+uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(2)])) - (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_type = _unescape_ent(tls, linebuf+uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(4)])) - (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_opts = _unescape_ent(tls, linebuf+uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(6)])) + **(**uint8)(__ccgo_up(linebuf + uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(1)]))) = uint8(0) + **(**uint8)(__ccgo_up(linebuf + uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(3)]))) = uint8(0) + **(**uint8)(__ccgo_up(linebuf + uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(5)]))) = uint8(0) + **(**uint8)(__ccgo_up(linebuf + uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(7)]))) = uint8(0) + (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_fsname = _unescape_ent(tls, linebuf+uintptr((**(**[8]int32)(__ccgo_up(bp)))[0])) + (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_dir = _unescape_ent(tls, linebuf+uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(2)])) + (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_type = _unescape_ent(tls, linebuf+uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(4)])) + (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_opts = _unescape_ent(tls, linebuf+uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(6)])) return mnt } @@ -115145,39 +115145,39 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag var _ /* st at bp+0 */ Tstat _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, de, dfd, err, j, k, l, r, type1, v1, v10, v2, v3, v8 l = _strlen(tls, path) - if l != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(path + uintptr(l-uint64(1))))) == int32('/') { + if l != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(path + uintptr(l-uint64(1))))) == int32('/') { v1 = l - uint64(1) } else { v1 = l } j = v1 v2 = Uint64FromInt32(0) - (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino = v2 - (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev = v2 + (**(**Tstat)(__ccgo_up(bp))).Fst_ino = v2 + (**(**Tstat)(__ccgo_up(bp))).Fst_dev = v2 if flags&int32(FTW_PHYS) != 0 { v3 = Xlstat(tls, path, bp) } else { v3 = BoolInt32(Xstat(tls, path, bp) < 0) } if v3 != 0 { - if !(flags&Int32FromInt32(FTW_PHYS) != 0) && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENOENT) && !(Xlstat(tls, path, bp) != 0) { + if !(flags&Int32FromInt32(FTW_PHYS) != 0) && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENOENT) && !(Xlstat(tls, path, bp) != 0) { type1 = int32(FTW_SLN) } else { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(EACCES) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(EACCES) { return -int32(1) } else { type1 = int32(FTW_NS) } } } else { - if (*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFDIR) { + if (**(**Tstat)(__ccgo_up(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFDIR) { if flags&int32(FTW_DEPTH) != 0 { type1 = int32(FTW_DP) } else { type1 = int32(FTW_D) } } else { - if (*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { + if (**(**Tstat)(__ccgo_up(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { if flags&int32(FTW_PHYS) != 0 { type1 = int32(FTW_SL) } else { @@ -115188,26 +115188,26 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag } } } - if flags&int32(FTW_MOUNT) != 0 && h != 0 && type1 != int32(FTW_NS) && (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev != (*Thistory)(unsafe.Pointer(h)).Fdev { + if flags&int32(FTW_MOUNT) != 0 && h != 0 && type1 != int32(FTW_NS) && (**(**Tstat)(__ccgo_up(bp))).Fst_dev != (*Thistory)(unsafe.Pointer(h)).Fdev { return 0 } - (*(*Thistory)(unsafe.Pointer(bp + 128))).Fchain = h - (*(*Thistory)(unsafe.Pointer(bp + 128))).Fdev = (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev - (*(*Thistory)(unsafe.Pointer(bp + 128))).Fino = (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino + (**(**Thistory)(__ccgo_up(bp + 128))).Fchain = h + (**(**Thistory)(__ccgo_up(bp + 128))).Fdev = (**(**Tstat)(__ccgo_up(bp))).Fst_dev + (**(**Thistory)(__ccgo_up(bp + 128))).Fino = (**(**Tstat)(__ccgo_up(bp))).Fst_ino if h != 0 { v3 = (*Thistory)(unsafe.Pointer(h)).Flevel + int32(1) } else { v3 = 0 } - (*(*Thistory)(unsafe.Pointer(bp + 128))).Flevel = v3 - (*(*Thistory)(unsafe.Pointer(bp + 128))).Fbase = Int32FromUint64(j + uint64(1)) - (*(*TFTW)(unsafe.Pointer(bp + 160))).Flevel = (*(*Thistory)(unsafe.Pointer(bp + 128))).Flevel + (**(**Thistory)(__ccgo_up(bp + 128))).Flevel = v3 + (**(**Thistory)(__ccgo_up(bp + 128))).Fbase = Int32FromUint64(j + uint64(1)) + (**(**TFTW)(__ccgo_up(bp + 160))).Flevel = (**(**Thistory)(__ccgo_up(bp + 128))).Flevel if h != 0 { - (*(*TFTW)(unsafe.Pointer(bp + 160))).Fbase = (*Thistory)(unsafe.Pointer(h)).Fbase + (**(**TFTW)(__ccgo_up(bp + 160))).Fbase = (*Thistory)(unsafe.Pointer(h)).Fbase } else { k = j for { - if !(k != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(path + uintptr(k)))) == int32('/')) { + if !(k != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(path + uintptr(k)))) == int32('/')) { break } goto _5 @@ -115216,7 +115216,7 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag k = k - 1 } for { - if !(k != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(path + uintptr(k-uint64(1))))) != int32('/')) { + if !(k != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(path + uintptr(k-uint64(1))))) != int32('/')) { break } goto _6 @@ -115224,11 +115224,11 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag ; k = k - 1 } - (*(*TFTW)(unsafe.Pointer(bp + 160))).Fbase = Int32FromUint64(k) + (**(**TFTW)(__ccgo_up(bp + 160))).Fbase = Int32FromUint64(k) } if type1 == int32(FTW_D) || type1 == int32(FTW_DP) { dfd = Xopen(tls, path, O_RDONLY, 0) - err = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + err = **(**int32)(__ccgo_up(X__errno_location(tls))) if dfd < 0 && err == int32(EACCES) { type1 = int32(FTW_DNR) } @@ -115247,7 +115247,7 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag if !(h != 0) { break } - if (*Thistory)(unsafe.Pointer(h)).Fdev == (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev && (*Thistory)(unsafe.Pointer(h)).Fino == (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino { + if (*Thistory)(unsafe.Pointer(h)).Fdev == (**(**Tstat)(__ccgo_up(bp))).Fst_dev && (*Thistory)(unsafe.Pointer(h)).Fino == (**(**Tstat)(__ccgo_up(bp))).Fst_ino { return 0 } goto _9 @@ -115257,7 +115257,7 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag } if (type1 == int32(FTW_D) || type1 == int32(FTW_DP)) && fd_limit != 0 { if dfd < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = err + **(**int32)(__ccgo_up(X__errno_location(tls))) = err return -int32(1) } d = Xfdopendir(tls, dfd) @@ -115268,15 +115268,15 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag if !(v10 != 0) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(de + 19))) == int32('.') && (!(*(*uint8)(unsafe.Pointer(de + 19 + 1)) != 0) || Int32FromUint8(*(*uint8)(unsafe.Pointer(de + 19 + 1))) == int32('.') && !(*(*uint8)(unsafe.Pointer(de + 19 + 2)) != 0)) { + if Int32FromUint8(**(**uint8)(__ccgo_up(de + 19))) == int32('.') && (!(**(**uint8)(__ccgo_up(de + 19 + 1)) != 0) || Int32FromUint8(**(**uint8)(__ccgo_up(de + 19 + 1))) == int32('.') && !(**(**uint8)(__ccgo_up(de + 19 + 2)) != 0)) { continue } if _strlen(tls, de+19) >= uint64(PATH_MAX)-l { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENAMETOOLONG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENAMETOOLONG) Xclosedir(tls, d) return -int32(1) } - *(*uint8)(unsafe.Pointer(path + uintptr(j))) = uint8('/') + **(**uint8)(__ccgo_up(path + uintptr(j))) = uint8('/') Xstrcpy(tls, path+uintptr(j)+uintptr(1), de+19) v3 = _do_nftw(tls, path, __ccgo_fp_fn, fd_limit-int32(1), flags, bp+128) r = v3 @@ -115291,7 +115291,7 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag return -int32(1) } } - *(*uint8)(unsafe.Pointer(path + uintptr(l))) = uint8(0) + **(**uint8)(__ccgo_up(path + uintptr(l))) = uint8(0) if v8 = flags&int32(FTW_DEPTH) != 0; v8 { v3 = (*(*func(*TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_fn})))(tls, path, bp, type1, bp+160) r = v3 @@ -115321,13 +115321,13 @@ func Xnftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flags i } l = _strlen(tls, path) if l > uint64(PATH_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENAMETOOLONG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENAMETOOLONG) return -int32(1) } Xmemcpy(tls, bp+4, path, l+uint64(1)) _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp) r = _do_nftw(tls, bp+4, __ccgo_fp_fn, fd_limit, flags, UintptrFromInt32(0)) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) return r } @@ -115345,7 +115345,7 @@ func Xopenpty(tls *TLS, pm uintptr, ps uintptr, name uintptr, tio uintptr, ws ui var _ /* cs at bp+4 */ int32 var _ /* n at bp+0 */ int32 _, _, _ = m, s, v1 - *(*int32)(unsafe.Pointer(bp)) = 0 + **(**int32)(__ccgo_up(bp)) = 0 m = Xopen(tls, __ccgo_ts+899, Int32FromInt32(O_RDWR)|Int32FromInt32(O_NOCTTY), 0) if m < 0 { return -int32(1) @@ -115357,7 +115357,7 @@ func Xopenpty(tls *TLS, pm uintptr, ps uintptr, name uintptr, tio uintptr, ws ui if !(name != 0) { name = bp + 8 } - Xsnprintf(tls, name, uint64(20), __ccgo_ts+909, VaList(bp+40, *(*int32)(unsafe.Pointer(bp)))) + Xsnprintf(tls, name, uint64(20), __ccgo_ts+909, VaList(bp+40, **(**int32)(__ccgo_up(bp)))) v1 = Xopen(tls, name, Int32FromInt32(O_RDWR)|Int32FromInt32(O_NOCTTY), 0) s = v1 if v1 < 0 { @@ -115369,15 +115369,15 @@ func Xopenpty(tls *TLS, pm uintptr, ps uintptr, name uintptr, tio uintptr, ws ui if ws != 0 { Xioctl(tls, s, int32(TIOCSWINSZ), VaList(bp+40, ws)) } - *(*int32)(unsafe.Pointer(pm)) = m - *(*int32)(unsafe.Pointer(ps)) = s - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 4)), uintptr(0)) + **(**int32)(__ccgo_up(pm)) = m + **(**int32)(__ccgo_up(ps)) = s + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 4)), uintptr(0)) return 0 goto fail fail: ; Xclose(tls, m) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 4)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 4)), uintptr(0)) return -int32(1) } @@ -115390,7 +115390,7 @@ func Xptsname(tls *TLS, fd int32) (r uintptr) { _ = err err = X__ptsname_r(tls, fd, uintptr(unsafe.Pointer(&_buf2)), uint64(22)) if err != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = err + **(**int32)(__ccgo_up(X__errno_location(tls))) = err return uintptr(0) } return uintptr(unsafe.Pointer(&_buf2)) @@ -115406,8 +115406,8 @@ func Xposix_openpt(tls *TLS, flags int32) (r1 int32) { var r int32 _ = r r = Xopen(tls, __ccgo_ts+899, flags, 0) - if r < 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENOSPC) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EAGAIN) + if r < 0 && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENOSPC) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EAGAIN) } return r } @@ -115428,7 +115428,7 @@ func Xunlockpt(tls *TLS, fd int32) (r int32) { bp := tls.Alloc(32) defer tls.Free(32) var _ /* unlock at bp+0 */ int32 - *(*int32)(unsafe.Pointer(bp)) = 0 + **(**int32)(__ccgo_up(bp)) = 0 return Xioctl(tls, fd, int32(TIOCSPTLCK), VaList(bp+16, bp)) } @@ -115450,7 +115450,7 @@ func X__ptsname_r(tls *TLS, fd int32, buf uintptr, len1 Tsize_t) (r int32) { if v1 != 0 { return -err } - if Uint64FromInt32(Xsnprintf(tls, buf, len1, __ccgo_ts+909, VaList(bp+16, *(*int32)(unsafe.Pointer(bp))))) >= len1 { + if Uint64FromInt32(Xsnprintf(tls, buf, len1, __ccgo_ts+909, VaList(bp+16, **(**int32)(__ccgo_up(bp))))) >= len1 { return int32(ERANGE) } return 0 @@ -115468,7 +115468,7 @@ func _slash_len(tls *TLS, s uintptr) (r Tsize_t) { var s0 uintptr _ = s0 s0 = s - for Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('/') { + for Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('/') { s = s + 1 } return Uint64FromInt64(int64(s) - int64(s0)) @@ -115492,12 +115492,12 @@ func Xrealpath(tls *TLS, filename uintptr, resolved uintptr) (r uintptr) { nup = uint64(0) check_dir = 0 if !(filename != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } l = Xstrnlen(tls, filename, uint64(4097)) if !(l != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOENT) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOENT) return uintptr(0) } if l >= uint64(PATH_MAX) { @@ -115517,19 +115517,19 @@ _3: ; /* If stack starts with /, the whole component is / or // * and the output state must be reset. */ - if Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p]) == int32('/') { + if Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[p]) == int32('/') { check_dir = 0 nup = uint64(0) q = uint64(0) v4 = q q = q + 1 - (*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[v4] = uint8('/') + (**(**[4096]uint8)(__ccgo_up(bp + 4097)))[v4] = uint8('/') p = p + 1 /* Initial // is special. */ - if Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p]) == int32('/') && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p+uint64(1)]) != int32('/') { + if Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[p]) == int32('/') && Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[p+uint64(1)]) != int32('/') { v4 = q q = q + 1 - (*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[v4] = uint8('/') + (**(**[4096]uint8)(__ccgo_up(bp + 4097)))[v4] = uint8('/') } goto _2 } @@ -115541,30 +115541,30 @@ _3: goto _1 } /* Skip any . component but preserve check_dir status. */ - if l == uint64(1) && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p]) == int32('.') { + if l == uint64(1) && Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[p]) == int32('.') { p = p + l goto _2 } /* Copy next component onto output at least temporarily, to * call readlink, but wait to advance output position until * determining it's not a link. */ - if q != 0 && Int32FromUint8((*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[q-uint64(1)]) != int32('/') { + if q != 0 && Int32FromUint8((**(**[4096]uint8)(__ccgo_up(bp + 4097)))[q-uint64(1)]) != int32('/') { if !(p != 0) { goto toolong } p = p - 1 v4 = p - (*(*[4097]uint8)(unsafe.Pointer(bp)))[v4] = uint8('/') + (**(**[4097]uint8)(__ccgo_up(bp)))[v4] = uint8('/') l = l + 1 } if q+l >= uint64(PATH_MAX) { goto toolong } Xmemcpy(tls, bp+4097+uintptr(q), bp+uintptr(p), l) - (*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[q+l] = uint8(0) + (**(**[4096]uint8)(__ccgo_up(bp + 4097)))[q+l] = uint8(0) p = p + l up = 0 - if l0 == uint64(2) && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p-uint64(2)]) == int32('.') && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p-uint64(1)]) == int32('.') { + if l0 == uint64(2) && Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[p-uint64(2)]) == int32('.') && Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[p-uint64(1)]) == int32('.') { up = int32(1) /* Any non-.. path components we could cancel start * after nup repetitions of the 3-byte string "../"; @@ -115586,13 +115586,13 @@ _3: goto toolong } if !(k != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOENT) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOENT) return uintptr(0) } if !(k < 0) { goto _8 } - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(EINVAL) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(EINVAL) { return uintptr(0) } goto skip_readlink @@ -115600,10 +115600,10 @@ skip_readlink: ; check_dir = 0 if up != 0 { - for q != 0 && Int32FromUint8((*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[q-uint64(1)]) != int32('/') { + for q != 0 && Int32FromUint8((**(**[4096]uint8)(__ccgo_up(bp + 4097)))[q-uint64(1)]) != int32('/') { q = q - 1 } - if q > uint64(1) && (q > uint64(2) || Int32FromUint8((*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[0]) != int32('/')) { + if q > uint64(1) && (q > uint64(2) || Int32FromUint8((**(**[4096]uint8)(__ccgo_up(bp + 4097)))[0]) != int32('/')) { q = q - 1 } goto _2 @@ -115611,20 +115611,20 @@ skip_readlink: if l0 != 0 { q = q + l } - check_dir = Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p]) + check_dir = Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[p]) goto _2 _8: ; cnt = cnt + 1 v4 = cnt if v4 == uint64(SYMLOOP_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ELOOP) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ELOOP) return uintptr(0) } /* If link contents end in /, strip any slashes already on * stack to avoid /->// or //->/// or spurious toolong. */ - if Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[k-int64(1)]) == int32('/') { - for Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p]) == int32('/') { + if Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[k-int64(1)]) == int32('/') { + for Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[p]) == int32('/') { p = p + 1 } } @@ -115641,8 +115641,8 @@ _2: goto _1 _1: ; - (*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[q] = uint8(0) - if Int32FromUint8((*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[0]) != int32('/') { + (**(**[4096]uint8)(__ccgo_up(bp + 4097)))[q] = uint8(0) + if Int32FromUint8((**(**[4096]uint8)(__ccgo_up(bp + 4097)))[0]) != int32('/') { if !(Xgetcwd(tls, bp, uint64(4097)) != 0) { return uintptr(0) } @@ -115655,7 +115655,7 @@ _1: if !(v4 != 0) { break } - for l > uint64(1) && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[l-uint64(1)]) != int32('/') { + for l > uint64(1) && Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[l-uint64(1)]) != int32('/') { l = l - 1 } if l > uint64(1) { @@ -115666,10 +115666,10 @@ _1: p = p + 1 } } - if q-p != 0 && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[l-uint64(1)]) != int32('/') { + if q-p != 0 && Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[l-uint64(1)]) != int32('/') { v4 = l l = l + 1 - (*(*[4097]uint8)(unsafe.Pointer(bp)))[v4] = uint8('/') + (**(**[4097]uint8)(__ccgo_up(bp)))[v4] = uint8('/') } if l+(q-p)+uint64(1) >= uint64(PATH_MAX) { goto toolong @@ -115686,7 +115686,7 @@ _1: goto toolong toolong: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENAMETOOLONG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENAMETOOLONG) return uintptr(0) } @@ -115735,12 +115735,12 @@ func Xsetrlimit(tls *TLS, resource int32, rlim uintptr) (r int32) { var _ /* tmp at bp+0 */ Trlimit _, _, _ = ret, v1, v2 if ^Uint64FromUint64(0) != ^Uint64FromUint64(0) { - *(*Trlimit)(unsafe.Pointer(bp)) = *(*Trlimit)(unsafe.Pointer(rlim)) - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur >= ^Uint64FromUint64(0) { - (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur = ^Uint64FromUint64(0) + **(**Trlimit)(__ccgo_up(bp)) = **(**Trlimit)(__ccgo_up(rlim)) + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur >= ^Uint64FromUint64(0) { + (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur = ^Uint64FromUint64(0) } - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_max >= ^Uint64FromUint64(0) { - (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_max = ^Uint64FromUint64(0) + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_max >= ^Uint64FromUint64(0) { + (**(**Trlimit)(__ccgo_up(bp))).Frlim_max = ^Uint64FromUint64(0) } rlim = bp } @@ -115758,7 +115758,7 @@ func Xsetrlimit(tls *TLS, resource int32, rlim uintptr) (r int32) { } else { v2 = ^Uint64FromUint64(0) } - *(*Tctx)(unsafe.Pointer(bp + 16)) = Tctx{ + **(**Tctx)(__ccgo_up(bp + 16)) = Tctx{ Flim: [2]uint64{ 0: v1, 1: v2, @@ -115767,9 +115767,9 @@ func Xsetrlimit(tls *TLS, resource int32, rlim uintptr) (r int32) { Ferr: -int32(1), } ___synccall(tls, __ccgo_fp(_do_setrlimit), bp+16) - if (*(*Tctx)(unsafe.Pointer(bp + 16))).Ferr != 0 { - if (*(*Tctx)(unsafe.Pointer(bp + 16))).Ferr > 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = (*(*Tctx)(unsafe.Pointer(bp + 16))).Ferr + if (**(**Tctx)(__ccgo_up(bp + 16))).Ferr != 0 { + if (**(**Tctx)(__ccgo_up(bp + 16))).Ferr > 0 { + **(**int32)(__ccgo_up(X__errno_location(tls))) = (**(**Tctx)(__ccgo_up(bp + 16))).Ferr } return -int32(1) } @@ -116149,7 +116149,7 @@ func Xcloselog(tls *TLS) { Xclose(tls, _log_fd) _log_fd = -int32(1) ___unlock(tls, uintptr(unsafe.Pointer(&_lock2))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) } func ___openlog(tls *TLS) { @@ -116183,7 +116183,7 @@ func Xopenlog(tls *TLS, ident uintptr, opt int32, facility int32) { ___openlog(tls) } ___unlock(tls, uintptr(unsafe.Pointer(&_lock2))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) } func _is_lost_conn(tls *TLS, e int32) (r int32) { @@ -116200,14 +116200,14 @@ func __vsyslog(tls *TLS, priority int32, message uintptr, ap Tva_list) { var _ /* timebuf at bp+0 */ [16]uint8 var _ /* tm at bp+24 */ Ttm _, _, _, _, _, _ = errno_save, fd, l, l2, pid, v1 - errno_save = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + errno_save = **(**int32)(__ccgo_up(X__errno_location(tls))) if _log_fd < 0 { ___openlog(tls) } if !(priority&Int32FromInt32(LOG_FACMASK) != 0) { priority = priority | _log_facility } - *(*Ttime_t)(unsafe.Pointer(bp + 16)) = Xtime(tls, UintptrFromInt32(0)) + **(**Ttime_t)(__ccgo_up(bp + 16)) = Xtime(tls, UintptrFromInt32(0)) Xgmtime_r(tls, bp+16, bp+24) Xstrftime_l(tls, bp, uint64(16), __ccgo_ts+921, bp+24, uintptr(unsafe.Pointer(&X__c_locale))) if _log_opt&int32(LOG_PID) != 0 { @@ -116217,7 +116217,7 @@ func __vsyslog(tls *TLS, priority int32, message uintptr, ap Tva_list) { } pid = v1 l = Xsnprintf(tls, bp+80, uint64(1024), __ccgo_ts+930, VaList(bp+1120, priority, bp, bp+1104, uintptr(unsafe.Pointer(&_log_ident)), __ccgo_ts+952+BoolUintptr(!(pid != 0)), pid, __ccgo_ts+954+BoolUintptr(!(pid != 0)))) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = errno_save + **(**int32)(__ccgo_up(X__errno_location(tls))) = errno_save l2 = Xvsnprintf(tls, bp+80+uintptr(l), uint64(1024)-Uint64FromInt32(l), message, ap) if l2 >= 0 { if Uint64FromInt32(l2) >= uint64(1024)-Uint64FromInt32(l) { @@ -116225,20 +116225,20 @@ func __vsyslog(tls *TLS, priority int32, message uintptr, ap Tva_list) { } else { l = l + l2 } - if Int32FromUint8((*(*[1024]uint8)(unsafe.Pointer(bp + 80)))[l-int32(1)]) != int32('\n') { + if Int32FromUint8((**(**[1024]uint8)(__ccgo_up(bp + 80)))[l-int32(1)]) != int32('\n') { v1 = l l = l + 1 - (*(*[1024]uint8)(unsafe.Pointer(bp + 80)))[v1] = uint8('\n') + (**(**[1024]uint8)(__ccgo_up(bp + 80)))[v1] = uint8('\n') } - if Xsend(tls, _log_fd, bp+80, Uint64FromInt32(l), 0) < 0 && (!(_is_lost_conn(tls, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) != 0) || Xconnect(tls, _log_fd, uintptr(unsafe.Pointer(&_log_addr)), uint32(12)) < 0 || Xsend(tls, _log_fd, bp+80, Uint64FromInt32(l), 0) < 0) && _log_opt&int32(LOG_CONS) != 0 { + if Xsend(tls, _log_fd, bp+80, Uint64FromInt32(l), 0) < 0 && (!(_is_lost_conn(tls, **(**int32)(__ccgo_up(X__errno_location(tls)))) != 0) || Xconnect(tls, _log_fd, uintptr(unsafe.Pointer(&_log_addr)), uint32(12)) < 0 || Xsend(tls, _log_fd, bp+80, Uint64FromInt32(l), 0) < 0) && _log_opt&int32(LOG_CONS) != 0 { fd = Xopen(tls, __ccgo_ts+649, Int32FromInt32(O_WRONLY)|Int32FromInt32(O_NOCTTY)|Int32FromInt32(O_CLOEXEC), 0) if fd >= 0 { - Xdprintf(tls, fd, __ccgo_ts+956, VaList(bp+1120, l-*(*int32)(unsafe.Pointer(bp + 1104)), bp+80+uintptr(*(*int32)(unsafe.Pointer(bp + 1104))))) + Xdprintf(tls, fd, __ccgo_ts+956, VaList(bp+1120, l-**(**int32)(__ccgo_up(bp + 1104)), bp+80+uintptr(**(**int32)(__ccgo_up(bp + 1104))))) Xclose(tls, fd) } } if _log_opt&int32(LOG_PERROR) != 0 { - Xdprintf(tls, int32(2), __ccgo_ts+956, VaList(bp+1120, l-*(*int32)(unsafe.Pointer(bp + 1104)), bp+80+uintptr(*(*int32)(unsafe.Pointer(bp + 1104))))) + Xdprintf(tls, int32(2), __ccgo_ts+956, VaList(bp+1120, l-**(**int32)(__ccgo_up(bp + 1104)), bp+80+uintptr(**(**int32)(__ccgo_up(bp + 1104))))) } } } @@ -116254,7 +116254,7 @@ func ___vsyslog(tls *TLS, priority int32, message uintptr, ap Tva_list) { ___lock(tls, uintptr(unsafe.Pointer(&_lock2))) __vsyslog(tls, priority, message, ap) ___unlock(tls, uintptr(unsafe.Pointer(&_lock2))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) } func Xsyslog(tls *TLS, priority int32, message uintptr, va uintptr) { @@ -116339,11 +116339,11 @@ func X__mmap(tls *TLS, start uintptr, len1 Tsize_t, prot int32, flags int32, fd var ret int64 _ = ret if Uint64FromInt64(off)&(-Uint64FromUint64(0x2000)<<(Uint64FromInt32(8)*Uint64FromInt64(8)-Uint64FromInt32(1))|(Uint64FromUint64(4096)-Uint64FromInt32(1))) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(-Int32FromInt32(1)) } if len1 >= Uint64FromInt64(Int64FromInt64(INT64_MAX)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return uintptr(-Int32FromInt32(1)) } if flags&int32(MAP_FIXED) != 0 { @@ -116398,7 +116398,7 @@ func X__mremap(tls *TLS, old_addr uintptr, old_len Tsize_t, new_len Tsize_t, fla _, _ = ap, new_addr new_addr = uintptr(0) if new_len >= Uint64FromInt64(Int64FromInt64(INT64_MAX)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return uintptr(-Int32FromInt32(1)) } if flags&int32(MREMAP_FIXED) != 0 { @@ -116480,17 +116480,17 @@ func X__shm_mapname(tls *TLS, name uintptr, buf uintptr) (r uintptr) { } var p, v1 uintptr _, _ = p, v1 - for Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) == int32('/') { + for Int32FromUint8(**(**uint8)(__ccgo_up(name))) == int32('/') { name = name + 1 } v1 = X__strchrnul(tls, name, int32('/')) p = v1 - if *(*uint8)(unsafe.Pointer(v1)) != 0 || p == name || int64(p)-int64(name) <= int64(2) && Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) == int32('.') && Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) == int32('.') { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if **(**uint8)(__ccgo_up(v1)) != 0 || p == name || int64(p)-int64(name) <= int64(2) && Int32FromUint8(**(**uint8)(__ccgo_up(name))) == int32('.') && Int32FromUint8(**(**uint8)(__ccgo_up(p + uintptr(-Int32FromInt32(1))))) == int32('.') { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } if int64(p)-int64(name) > int64(NAME_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENAMETOOLONG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENAMETOOLONG) return uintptr(0) } Xmemcpy(tls, buf, __ccgo_ts+961, uint64(9)) @@ -116517,7 +116517,7 @@ func Xshm_open(tls *TLS, name uintptr, flag int32, mode Tmode_t) (r int32) { } _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp) fd = Xopen(tls, name, flag|int32(O_NOFOLLOW)|int32(O_CLOEXEC)|int32(O_NONBLOCK), VaList(bp+280, mode)) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) return fd } @@ -116555,7 +116555,7 @@ func Xbtowc(tls *TLS, c int32) (r Twint_t) { if Uint32FromInt32(b) < uint32(128) { v1 = Uint32FromInt32(b) } else { - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v3 = int32(4) } else { v3 = int32(1) @@ -116587,22 +116587,22 @@ func Xc16rtomb(tls *TLS, s uintptr, c16 Tchar16_t, ps uintptr) (r Tsize_t) { } x = ps if !(s != 0) { - if *(*uint32)(unsafe.Pointer(x)) != 0 { + if **(**uint32)(__ccgo_up(x)) != 0 { goto ilseq } return uint64(1) } - if !(*(*uint32)(unsafe.Pointer(x)) != 0) && uint32(c16)-uint32(0xd800) < uint32(0x400) { - *(*uint32)(unsafe.Pointer(x)) = Uint32FromInt32((Int32FromUint16(c16) - int32(0xd7c0)) << int32(10)) + if !(**(**uint32)(__ccgo_up(x)) != 0) && uint32(c16)-uint32(0xd800) < uint32(0x400) { + **(**uint32)(__ccgo_up(x)) = Uint32FromInt32((Int32FromUint16(c16) - int32(0xd7c0)) << int32(10)) return uint64(0) } - if *(*uint32)(unsafe.Pointer(x)) != 0 { + if **(**uint32)(__ccgo_up(x)) != 0 { if uint32(c16)-uint32(0xdc00) >= uint32(0x400) { goto ilseq } else { - wc = *(*uint32)(unsafe.Pointer(x)) + uint32(c16) - uint32(0xdc00) + wc = **(**uint32)(__ccgo_up(x)) + uint32(c16) - uint32(0xdc00) } - *(*uint32)(unsafe.Pointer(x)) = uint32(0) + **(**uint32)(__ccgo_up(x)) = uint32(0) } else { wc = uint32(c16) } @@ -116610,8 +116610,8 @@ func Xc16rtomb(tls *TLS, s uintptr, c16 Tchar16_t, ps uintptr) (r Tsize_t) { goto ilseq ilseq: ; - *(*uint32)(unsafe.Pointer(x)) = uint32(0) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EILSEQ) + **(**uint32)(__ccgo_up(x)) = uint32(0) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EILSEQ) return Uint64FromInt32(-Int32FromInt32(1)) } @@ -116670,21 +116670,21 @@ func Xmbrtoc16(tls *TLS, pc16 uintptr, s uintptr, n Tsize_t, ps uintptr) (r Tsiz } /* mbrtowc states for partial UTF-8 characters have the high bit set; * we use nonzero states without high bit for pending surrogates. */ - if Int32FromUint32(*(*uint32)(unsafe.Pointer(pending))) > 0 { + if Int32FromUint32(**(**uint32)(__ccgo_up(pending))) > 0 { if pc16 != 0 { - *(*Tchar16_t)(unsafe.Pointer(pc16)) = uint16(*(*uint32)(unsafe.Pointer(pending))) + **(**Tchar16_t)(__ccgo_up(pc16)) = uint16(**(**uint32)(__ccgo_up(pending))) } - *(*uint32)(unsafe.Pointer(pending)) = uint32(0) + **(**uint32)(__ccgo_up(pending)) = uint32(0) return Uint64FromInt32(-Int32FromInt32(3)) } ret = Xmbrtowc(tls, bp, s, n, ps) if ret <= uint64(4) { - if *(*Twchar_t)(unsafe.Pointer(bp)) >= uint32(0x10000) { - *(*uint32)(unsafe.Pointer(pending)) = *(*Twchar_t)(unsafe.Pointer(bp))&uint32(0x3ff) + uint32(0xdc00) - *(*Twchar_t)(unsafe.Pointer(bp)) = uint32(0xd7c0) + *(*Twchar_t)(unsafe.Pointer(bp))>>Int32FromInt32(10) + if **(**Twchar_t)(__ccgo_up(bp)) >= uint32(0x10000) { + **(**uint32)(__ccgo_up(pending)) = **(**Twchar_t)(__ccgo_up(bp))&uint32(0x3ff) + uint32(0xdc00) + **(**Twchar_t)(__ccgo_up(bp)) = uint32(0xd7c0) + **(**Twchar_t)(__ccgo_up(bp))>>Int32FromInt32(10) } if pc16 != 0 { - *(*Tchar16_t)(unsafe.Pointer(pc16)) = uint16(*(*Twchar_t)(unsafe.Pointer(bp))) + **(**Tchar16_t)(__ccgo_up(pc16)) = uint16(**(**Twchar_t)(__ccgo_up(bp))) } } return ret @@ -116710,7 +116710,7 @@ func Xmbrtoc32(tls *TLS, pc32 uintptr, s uintptr, n Tsize_t, ps uintptr) (r Tsiz } ret = Xmbrtowc(tls, bp, s, n, ps) if ret <= uint64(4) && pc32 != 0 { - *(*Tchar32_t)(unsafe.Pointer(pc32)) = *(*Twchar_t)(unsafe.Pointer(bp)) + **(**Tchar32_t)(__ccgo_up(pc32)) = **(**Twchar_t)(__ccgo_up(bp)) } return ret } @@ -116736,7 +116736,7 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize if !(st != 0) { st = uintptr(unsafe.Pointer(&_internal_state3)) } - c = *(*uint32)(unsafe.Pointer(st)) + c = **(**uint32)(__ccgo_up(st)) if !(s != 0) { if c != 0 { goto ilseq @@ -116751,30 +116751,30 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize return Uint64FromInt32(-Int32FromInt32(2)) } if !(c != 0) { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) < int32(0x80) { - v1 = uint32(*(*uint8)(unsafe.Pointer(s))) - *(*Twchar_t)(unsafe.Pointer(wc)) = v1 + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) < int32(0x80) { + v1 = uint32(**(**uint8)(__ccgo_up(s))) + **(**Twchar_t)(__ccgo_up(wc)) = v1 return BoolUint64(!!(v1 != 0)) } - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v2 = int32(4) } else { v2 = int32(1) } if v2 == int32(1) { - *(*Twchar_t)(unsafe.Pointer(wc)) = Uint32FromInt32(Int32FromInt32(0xdfff) & int32(Int8FromUint8(*(*uint8)(unsafe.Pointer(s))))) + **(**Twchar_t)(__ccgo_up(wc)) = Uint32FromInt32(Int32FromInt32(0xdfff) & int32(Int8FromUint8(**(**uint8)(__ccgo_up(s))))) return Uint64FromInt32(1) } - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { goto ilseq } v3 = s s = s + 1 - c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v3)))-uint32(0xc2)] + c = X__fsmu8[uint32(**(**uint8)(__ccgo_up(v3)))-uint32(0xc2)] n = n - 1 } if n != 0 { - if (Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { + if (Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { goto ilseq } goto loop @@ -116782,27 +116782,27 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize ; v3 = s s = s + 1 - c = c<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { goto ilseq } goto loop } } - *(*uint32)(unsafe.Pointer(st)) = c + **(**uint32)(__ccgo_up(st)) = c return Uint64FromInt32(-Int32FromInt32(2)) goto ilseq ilseq: ; - *(*uint32)(unsafe.Pointer(st)) = uint32(0) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EILSEQ) + **(**uint32)(__ccgo_up(st)) = uint32(0) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EILSEQ) return Uint64FromInt32(-Int32FromInt32(1)) } @@ -116813,7 +116813,7 @@ func Xmbsinit(tls *TLS, st uintptr) (r int32) { trc("tls=%v st=%v, (%v:)", tls, st, origin(2)) defer func() { trc("-> %v", r) }() } - return BoolInt32(!(st != 0) || !(*(*uint32)(unsafe.Pointer(st)) != 0)) + return BoolInt32(!(st != 0) || !(**(**uint32)(__ccgo_up(st)) != 0)) } func Xmbsnrtowcs(tls *TLS, wcs uintptr, src uintptr, n Tsize_t, wn Tsize_t, st uintptr) (r Tsize_t) { @@ -116831,7 +116831,7 @@ func Xmbsnrtowcs(tls *TLS, wcs uintptr, src uintptr, n Tsize_t, wn Tsize_t, st u var _ /* wbuf at bp+0 */ [256]Twchar_t _, _, _, _, _, _, _, _ = cnt, l, n2, tmp_s, ws, v1, v2, v3 cnt = uint64(0) - *(*uintptr)(unsafe.Pointer(bp + 1024)) = *(*uintptr)(unsafe.Pointer(src)) + **(**uintptr)(__ccgo_up(bp + 1024)) = **(**uintptr)(__ccgo_up(src)) if !(wcs != 0) { ws = bp wn = Uint64FromInt64(1024) / Uint64FromInt64(4) @@ -116842,7 +116842,7 @@ func Xmbsnrtowcs(tls *TLS, wcs uintptr, src uintptr, n Tsize_t, wn Tsize_t, st u * that mbsrtowcs never reads more than n input bytes. thus * we can use mbsrtowcs as long as it's practical.. */ for { - if v2 = *(*uintptr)(unsafe.Pointer(bp + 1024)) != 0 && wn != 0; v2 { + if v2 = **(**uintptr)(__ccgo_up(bp + 1024)) != 0 && wn != 0; v2 { v1 = n / Uint64FromInt32(4) n2 = v1 } @@ -116852,7 +116852,7 @@ func Xmbsnrtowcs(tls *TLS, wcs uintptr, src uintptr, n Tsize_t, wn Tsize_t, st u if n2 >= wn { n2 = wn } - tmp_s = *(*uintptr)(unsafe.Pointer(bp + 1024)) + tmp_s = **(**uintptr)(__ccgo_up(bp + 1024)) l = Xmbsrtowcs(tls, ws, bp+1024, n2, st) if !(l+Uint64FromInt32(1) != 0) { cnt = l @@ -116863,31 +116863,31 @@ func Xmbsnrtowcs(tls *TLS, wcs uintptr, src uintptr, n Tsize_t, wn Tsize_t, st u ws = ws + uintptr(l)*4 wn = wn - l } - if *(*uintptr)(unsafe.Pointer(bp + 1024)) != 0 { - v3 = n - Uint64FromInt64(int64(*(*uintptr)(unsafe.Pointer(bp + 1024)))-int64(tmp_s)) + if **(**uintptr)(__ccgo_up(bp + 1024)) != 0 { + v3 = n - Uint64FromInt64(int64(**(**uintptr)(__ccgo_up(bp + 1024)))-int64(tmp_s)) } else { v3 = uint64(0) } n = v3 cnt = cnt + l } - if *(*uintptr)(unsafe.Pointer(bp + 1024)) != 0 { + if **(**uintptr)(__ccgo_up(bp + 1024)) != 0 { for wn != 0 && n != 0 { - l = Xmbrtowc(tls, ws, *(*uintptr)(unsafe.Pointer(bp + 1024)), n, st) + l = Xmbrtowc(tls, ws, **(**uintptr)(__ccgo_up(bp + 1024)), n, st) if l+uint64(2) <= uint64(2) { if !(l+Uint64FromInt32(1) != 0) { cnt = l break } if !(l != 0) { - *(*uintptr)(unsafe.Pointer(bp + 1024)) = uintptr(0) + **(**uintptr)(__ccgo_up(bp + 1024)) = uintptr(0) break } /* have to roll back partial character */ - *(*uint32)(unsafe.Pointer(st)) = uint32(0) + **(**uint32)(__ccgo_up(st)) = uint32(0) break } - *(*uintptr)(unsafe.Pointer(bp + 1024)) = *(*uintptr)(unsafe.Pointer(bp + 1024)) + uintptr(l) + **(**uintptr)(__ccgo_up(bp + 1024)) = **(**uintptr)(__ccgo_up(bp + 1024)) + uintptr(l) n = n - l /* safe - this loop runs fewer than sizeof(wbuf)/8 times */ ws += 4 @@ -116896,7 +116896,7 @@ func Xmbsnrtowcs(tls *TLS, wcs uintptr, src uintptr, n Tsize_t, wn Tsize_t, st u } } if wcs != 0 { - *(*uintptr)(unsafe.Pointer(src)) = *(*uintptr)(unsafe.Pointer(bp + 1024)) + **(**uintptr)(__ccgo_up(src)) = **(**uintptr)(__ccgo_up(bp + 1024)) } return cnt } @@ -116912,22 +116912,22 @@ func Xmbsrtowcs(tls *TLS, ws uintptr, src uintptr, wn Tsize_t, st uintptr) (r Ts var v2 bool var v3 int32 _, _, _, _, _, _, _, _ = c, s, wn0, v1, v2, v3, v5, v6 - s = *(*uintptr)(unsafe.Pointer(src)) + s = **(**uintptr)(__ccgo_up(src)) wn0 = wn c = uint32(0) if v2 = st != 0; v2 { - v1 = *(*uint32)(unsafe.Pointer(st)) + v1 = **(**uint32)(__ccgo_up(st)) c = v1 } if v2 && v1 != 0 { if ws != 0 { - *(*uint32)(unsafe.Pointer(st)) = uint32(0) + **(**uint32)(__ccgo_up(st)) = uint32(0) goto resume } else { goto resume0 } } - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v3 = int32(4) } else { v3 = int32(1) @@ -116938,24 +116938,24 @@ func Xmbsrtowcs(tls *TLS, ws uintptr, src uintptr, wn Tsize_t, st uintptr) (r Ts } for { if !(wn != 0) { - *(*uintptr)(unsafe.Pointer(src)) = s + **(**uintptr)(__ccgo_up(src)) = s return wn0 } - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { break } v5 = s s = s + 1 - c = uint32(*(*uint8)(unsafe.Pointer(v5))) + c = uint32(**(**uint8)(__ccgo_up(v5))) v5 = ws ws += 4 - *(*Twchar_t)(unsafe.Pointer(v5)) = Uint32FromInt32(Int32FromInt32(0xdfff) & int32(Int8FromUint32(c))) + **(**Twchar_t)(__ccgo_up(v5)) = Uint32FromInt32(Int32FromInt32(0xdfff) & int32(Int8FromUint32(c))) wn = wn - 1 goto _4 _4: } - *(*Twchar_t)(unsafe.Pointer(ws)) = uint32(0) - *(*uintptr)(unsafe.Pointer(src)) = uintptr(0) + **(**Twchar_t)(__ccgo_up(ws)) = uint32(0) + **(**uintptr)(__ccgo_up(src)) = uintptr(0) return wn0 - wn } if !!(ws != 0) { @@ -116963,39 +116963,39 @@ func Xmbsrtowcs(tls *TLS, ws uintptr, src uintptr, wn Tsize_t, st uintptr) (r Ts } _11: ; - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) && uint64(s)%uint64(4) == uint64(0) { - for !((*(*uint32)(unsafe.Pointer(s))|(*(*uint32)(unsafe.Pointer(s))-Uint32FromInt32(0x01010101)))&Uint32FromUint32(0x80808080) != 0) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(1) < uint32(0x7f) && uint64(s)%uint64(4) == uint64(0) { + for !((**(**uint32)(__ccgo_up(s))|(**(**uint32)(__ccgo_up(s))-Uint32FromInt32(0x01010101)))&Uint32FromUint32(0x80808080) != 0) { s = s + uintptr(4) wn = wn - uint64(4) } } - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(1) < uint32(0x7f) { s = s + 1 wn = wn - 1 goto _10 } - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { goto _9 } v5 = s s = s + 1 - c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v5)))-uint32(0xc2)] + c = X__fsmu8[uint32(**(**uint8)(__ccgo_up(v5)))-uint32(0xc2)] goto resume0 resume0: ; - if (Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { + if (Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { s = s - 1 goto _9 } s = s + 1 if c&(Uint32FromUint32(1)<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { s = s - uintptr(2) goto _9 } s = s + 1 if c&(Uint32FromUint32(1)<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { s = s - uintptr(3) goto _9 } @@ -117017,80 +117017,80 @@ _7: _15: ; if !(wn != 0) { - *(*uintptr)(unsafe.Pointer(src)) = s + **(**uintptr)(__ccgo_up(src)) = s return wn0 } - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) && uint64(s)%uint64(4) == uint64(0) { - for wn >= uint64(5) && !((*(*uint32)(unsafe.Pointer(s))|(*(*uint32)(unsafe.Pointer(s))-Uint32FromInt32(0x01010101)))&Uint32FromUint32(0x80808080) != 0) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(1) < uint32(0x7f) && uint64(s)%uint64(4) == uint64(0) { + for wn >= uint64(5) && !((**(**uint32)(__ccgo_up(s))|(**(**uint32)(__ccgo_up(s))-Uint32FromInt32(0x01010101)))&Uint32FromUint32(0x80808080) != 0) { v5 = ws ws += 4 v6 = s s = s + 1 - *(*Twchar_t)(unsafe.Pointer(v5)) = uint32(*(*uint8)(unsafe.Pointer(v6))) + **(**Twchar_t)(__ccgo_up(v5)) = uint32(**(**uint8)(__ccgo_up(v6))) v5 = ws ws += 4 v6 = s s = s + 1 - *(*Twchar_t)(unsafe.Pointer(v5)) = uint32(*(*uint8)(unsafe.Pointer(v6))) + **(**Twchar_t)(__ccgo_up(v5)) = uint32(**(**uint8)(__ccgo_up(v6))) v5 = ws ws += 4 v6 = s s = s + 1 - *(*Twchar_t)(unsafe.Pointer(v5)) = uint32(*(*uint8)(unsafe.Pointer(v6))) + **(**Twchar_t)(__ccgo_up(v5)) = uint32(**(**uint8)(__ccgo_up(v6))) v5 = ws ws += 4 v6 = s s = s + 1 - *(*Twchar_t)(unsafe.Pointer(v5)) = uint32(*(*uint8)(unsafe.Pointer(v6))) + **(**Twchar_t)(__ccgo_up(v5)) = uint32(**(**uint8)(__ccgo_up(v6))) wn = wn - uint64(4) } } - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(1) < uint32(0x7f) { v5 = ws ws += 4 v6 = s s = s + 1 - *(*Twchar_t)(unsafe.Pointer(v5)) = uint32(*(*uint8)(unsafe.Pointer(v6))) + **(**Twchar_t)(__ccgo_up(v5)) = uint32(**(**uint8)(__ccgo_up(v6))) wn = wn - 1 goto _14 } - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { goto _13 } v5 = s s = s + 1 - c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v5)))-uint32(0xc2)] + c = X__fsmu8[uint32(**(**uint8)(__ccgo_up(v5)))-uint32(0xc2)] goto resume resume: ; - if (Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { + if (Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { s = s - 1 goto _13 } v5 = s s = s + 1 - c = c<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { s = s - uintptr(2) goto _13 } v5 = s s = s + 1 - c = c<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { s = s - uintptr(3) goto _13 } v5 = s s = s + 1 - c = c< Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { goto ilseq } v3 = s s = s + 1 - c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v3)))-uint32(0xc2)] + c = X__fsmu8[uint32(**(**uint8)(__ccgo_up(v3)))-uint32(0xc2)] /* Avoid excessive checks against n: If shifting the state n-1 * times does not clear the high bit, then the value of n is * insufficient to read a character */ if n < uint64(4) && c<<(uint64(6)*n-uint64(6))&(Uint32FromUint32(1)<>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { + if (Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { goto ilseq } v3 = s s = s + 1 - c = c<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { goto ilseq } v3 = s s = s + 1 - c = c<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { goto ilseq } v3 = s s = s + 1 - *(*Twchar_t)(unsafe.Pointer(wc)) = c<>Int32FromInt32(6)) - *(*uint8)(unsafe.Pointer(s)) = uint8(uint32(0x80) | wc&uint32(0x3f)) + **(**uint8)(__ccgo_up(v2)) = uint8(uint32(0xc0) | wc>>Int32FromInt32(6)) + **(**uint8)(__ccgo_up(s)) = uint8(uint32(0x80) | wc&uint32(0x3f)) return uint64(2) } else { if wc < uint32(0xd800) || wc-uint32(0xe000) < uint32(0x2000) { v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8(uint32(0xe0) | wc>>Int32FromInt32(12)) + **(**uint8)(__ccgo_up(v2)) = uint8(uint32(0xe0) | wc>>Int32FromInt32(12)) v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8(uint32(0x80) | wc>>Int32FromInt32(6)&uint32(0x3f)) - *(*uint8)(unsafe.Pointer(s)) = uint8(uint32(0x80) | wc&uint32(0x3f)) + **(**uint8)(__ccgo_up(v2)) = uint8(uint32(0x80) | wc>>Int32FromInt32(6)&uint32(0x3f)) + **(**uint8)(__ccgo_up(s)) = uint8(uint32(0x80) | wc&uint32(0x3f)) return uint64(3) } else { if wc-uint32(0x10000) < uint32(0x100000) { v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8(uint32(0xf0) | wc>>Int32FromInt32(18)) + **(**uint8)(__ccgo_up(v2)) = uint8(uint32(0xf0) | wc>>Int32FromInt32(18)) v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8(uint32(0x80) | wc>>Int32FromInt32(12)&uint32(0x3f)) + **(**uint8)(__ccgo_up(v2)) = uint8(uint32(0x80) | wc>>Int32FromInt32(12)&uint32(0x3f)) v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8(uint32(0x80) | wc>>Int32FromInt32(6)&uint32(0x3f)) - *(*uint8)(unsafe.Pointer(s)) = uint8(uint32(0x80) | wc&uint32(0x3f)) + **(**uint8)(__ccgo_up(v2)) = uint8(uint32(0x80) | wc>>Int32FromInt32(6)&uint32(0x3f)) + **(**uint8)(__ccgo_up(s)) = uint8(uint32(0x80) | wc&uint32(0x3f)) return uint64(4) } } } } } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EILSEQ) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EILSEQ) return Uint64FromInt32(-Int32FromInt32(1)) } @@ -117287,7 +117287,7 @@ func Xwcsnrtombs(tls *TLS, dst uintptr, wcs uintptr, wn Tsize_t, n Tsize_t, st u var ws, v1 uintptr var _ /* tmp at bp+0 */ [4]uint8 _, _, _, _ = cnt, l, ws, v1 - ws = *(*uintptr)(unsafe.Pointer(wcs)) + ws = **(**uintptr)(__ccgo_up(wcs)) cnt = uint64(0) if !(dst != 0) { n = uint64(0) @@ -117298,7 +117298,7 @@ func Xwcsnrtombs(tls *TLS, dst uintptr, wcs uintptr, wn Tsize_t, n Tsize_t, st u } else { v1 = dst } - l = Xwcrtomb(tls, v1, *(*Twchar_t)(unsafe.Pointer(ws)), uintptr(0)) + l = Xwcrtomb(tls, v1, **(**Twchar_t)(__ccgo_up(ws)), uintptr(0)) if l == Uint64FromInt32(-Int32FromInt32(1)) { cnt = Uint64FromInt32(-Int32FromInt32(1)) break @@ -117313,7 +117313,7 @@ func Xwcsnrtombs(tls *TLS, dst uintptr, wcs uintptr, wn Tsize_t, n Tsize_t, st u dst = dst + uintptr(l) n = n - l } - if !(*(*Twchar_t)(unsafe.Pointer(ws)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(ws)) != 0) { ws = uintptr(0) break } @@ -117322,7 +117322,7 @@ func Xwcsnrtombs(tls *TLS, dst uintptr, wcs uintptr, wn Tsize_t, n Tsize_t, st u cnt = cnt + l } if dst != 0 { - *(*uintptr)(unsafe.Pointer(wcs)) = ws + **(**uintptr)(__ccgo_up(wcs)) = ws } return cnt } @@ -117341,13 +117341,13 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize N = n if !(s != 0) { n = uint64(0) - ws2 = *(*uintptr)(unsafe.Pointer(ws)) + ws2 = **(**uintptr)(__ccgo_up(ws)) for { - if !(*(*Twchar_t)(unsafe.Pointer(ws2)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(ws2)) != 0) { break } - if *(*Twchar_t)(unsafe.Pointer(ws2)) >= uint32(0x80) { - l = Xwcrtomb(tls, bp, *(*Twchar_t)(unsafe.Pointer(ws2)), uintptr(0)) + if **(**Twchar_t)(__ccgo_up(ws2)) >= uint32(0x80) { + l = Xwcrtomb(tls, bp, **(**Twchar_t)(__ccgo_up(ws2)), uintptr(0)) if !(l+Uint64FromInt32(1) != 0) { return Uint64FromInt32(-Int32FromInt32(1)) } @@ -117363,13 +117363,13 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize return n } for n >= uint64(4) { - if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))-uint32(1) >= uint32(0x7f) { - if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))) != 0) { - *(*uint8)(unsafe.Pointer(s)) = uint8(0) - *(*uintptr)(unsafe.Pointer(ws)) = uintptr(0) + if **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws))))-uint32(1) >= uint32(0x7f) { + if !(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))) != 0) { + **(**uint8)(__ccgo_up(s)) = uint8(0) + **(**uintptr)(__ccgo_up(ws)) = uintptr(0) return N - n } - l = Xwcrtomb(tls, s, *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))), uintptr(0)) + l = Xwcrtomb(tls, s, **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))), uintptr(0)) if !(l+Uint64FromInt32(1) != 0) { return Uint64FromInt32(-Int32FromInt32(1)) } @@ -117378,35 +117378,35 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize } else { v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) + **(**uint8)(__ccgo_up(v2)) = uint8(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws))))) n = n - 1 } - *(*uintptr)(unsafe.Pointer(ws)) += 4 + **(**uintptr)(__ccgo_up(ws)) += 4 } for n != 0 { - if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))-uint32(1) >= uint32(0x7f) { - if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))) != 0) { - *(*uint8)(unsafe.Pointer(s)) = uint8(0) - *(*uintptr)(unsafe.Pointer(ws)) = uintptr(0) + if **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws))))-uint32(1) >= uint32(0x7f) { + if !(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))) != 0) { + **(**uint8)(__ccgo_up(s)) = uint8(0) + **(**uintptr)(__ccgo_up(ws)) = uintptr(0) return N - n } - l = Xwcrtomb(tls, bp, *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))), uintptr(0)) + l = Xwcrtomb(tls, bp, **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))), uintptr(0)) if !(l+Uint64FromInt32(1) != 0) { return Uint64FromInt32(-Int32FromInt32(1)) } if l > n { return N - n } - Xwcrtomb(tls, s, *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))), uintptr(0)) + Xwcrtomb(tls, s, **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))), uintptr(0)) s = s + uintptr(l) n = n - l } else { v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) + **(**uint8)(__ccgo_up(v2)) = uint8(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws))))) n = n - 1 } - *(*uintptr)(unsafe.Pointer(ws)) += 4 + **(**uintptr)(__ccgo_up(ws)) += 4 } return N } @@ -117432,7 +117432,7 @@ func Xwctob(tls *TLS, c Twint_t) (r int32) { if c < uint32(128) { return Int32FromUint32(c) } - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v1 = int32(4) } else { v1 = int32(1) @@ -117530,11 +117530,11 @@ func Xaccept4(tls *TLS, fd int32, addr uintptr, len1 uintptr, flg int32) (r1 int goto _9 _9: ret = int32(X__syscall_ret(tls, Uint64FromInt64(v8))) - if ret >= 0 || *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(ENOSYS) && *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(EINVAL) { + if ret >= 0 || **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(ENOSYS) && **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(EINVAL) { return ret } if flg & ^(Int32FromInt32(SOCK_CLOEXEC)|Int32FromInt32(SOCK_NONBLOCK)) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } ret = Xaccept(tls, fd, addr, len1) @@ -118506,13 +118506,13 @@ func _getoffs(tls *TLS, offs uintptr, base uintptr, s uintptr) (r int32) { _, _ = i, v2 i = 0 for { - for Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))&int32(0xc0) != 0 { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))&int32(0xc0) != int32(0xc0) { + for Int32FromUint8(**(**uint8)(__ccgo_up(s)))&int32(0xc0) != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(s)))&int32(0xc0) != int32(0xc0) { return 0 } - s = base + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))&Int32FromInt32(0x3f)<= int64(0x4000) { @@ -118520,8 +118520,8 @@ func _getoffs(tls *TLS, offs uintptr, base uintptr, s uintptr) (r int32) { } v2 = i i = i + 1 - *(*int16)(unsafe.Pointer(offs + uintptr(v2)*2)) = int16(int64(s) - int64(base)) - s = s + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))+int32(1)) + **(**int16)(__ccgo_up(offs + uintptr(v2)*2)) = int16(int64(s) - int64(base)) + s = s + uintptr(Int32FromUint8(**(**uint8)(__ccgo_up(s)))+int32(1)) goto _1 _1: } @@ -118539,7 +118539,7 @@ func _getlens(tls *TLS, lens uintptr, s uintptr, l int32) (r int32) { k = 0 for { for { - if !(j < l && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(j)))) != int32('.')) { + if !(j < l && Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(j)))) != int32('.')) { break } goto _2 @@ -118552,7 +118552,7 @@ func _getlens(tls *TLS, lens uintptr, s uintptr, l int32) (r int32) { } v3 = i i = i + 1 - *(*uint8)(unsafe.Pointer(lens + uintptr(v3))) = Uint8FromInt32(j - k) + **(**uint8)(__ccgo_up(lens + uintptr(v3))) = Uint8FromInt32(j - k) if j == l { return i } @@ -118582,15 +118582,15 @@ func _match(tls *TLS, offset uintptr, base uintptr, dn uintptr, end uintptr, len for { nlen = nlen - 1 v2 = nlen - l = Int32FromUint8(*(*uint8)(unsafe.Pointer(lens + uintptr(v2)))) + l = Int32FromUint8(**(**uint8)(__ccgo_up(lens + uintptr(v2)))) noff = noff - 1 v2 = noff - o = int32((*(*[128]int16)(unsafe.Pointer(bp)))[v2]) + o = int32((**(**[128]int16)(__ccgo_up(bp)))[v2]) end = end - uintptr(l) - if l != Int32FromUint8(*(*uint8)(unsafe.Pointer(base + uintptr(o)))) || Xmemcmp(tls, base+uintptr(o)+uintptr(1), end, Uint64FromInt32(l)) != 0 { + if l != Int32FromUint8(**(**uint8)(__ccgo_up(base + uintptr(o)))) || Xmemcmp(tls, base+uintptr(o)+uintptr(1), end, Uint64FromInt32(l)) != 0 { return m } - *(*int32)(unsafe.Pointer(offset)) = o + **(**int32)(__ccgo_up(offset)) = o m = m + l if nlen != 0 { m = m + 1 @@ -118621,14 +118621,14 @@ func Xdn_comp(tls *TLS, src uintptr, dst uintptr, space int32, dnptrs uintptr, l m = 0 bestlen = 0 l = Xstrnlen(tls, src, uint64(255)) - if l != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(src + uintptr(l-uint64(1))))) == int32('.') { + if l != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(src + uintptr(l-uint64(1))))) == int32('.') { l = l - 1 } if l > uint64(253) || space <= 0 { return -int32(1) } if !(l != 0) { - *(*uint8)(unsafe.Pointer(dst)) = uint8(0) + **(**uint8)(__ccgo_up(dst)) = uint8(0) return int32(1) } end = src + uintptr(l) @@ -118637,16 +118637,16 @@ func Xdn_comp(tls *TLS, src uintptr, dst uintptr, space int32, dnptrs uintptr, l return -int32(1) } p = dnptrs - if p != 0 && *(*uintptr)(unsafe.Pointer(p)) != 0 { + if p != 0 && **(**uintptr)(__ccgo_up(p)) != 0 { p += 8 for { - if !(*(*uintptr)(unsafe.Pointer(p)) != 0) { + if !(**(**uintptr)(__ccgo_up(p)) != 0) { break } - m = _match(tls, bp, *(*uintptr)(unsafe.Pointer(dnptrs)), *(*uintptr)(unsafe.Pointer(p)), end, bp+4, n) + m = _match(tls, bp, **(**uintptr)(__ccgo_up(dnptrs)), **(**uintptr)(__ccgo_up(p)), end, bp+4, n) if m > bestlen { bestlen = m - bestoff = *(*int32)(unsafe.Pointer(bp)) + bestoff = **(**int32)(__ccgo_up(bp)) if Uint64FromInt32(m) == l { break } @@ -118669,37 +118669,37 @@ func Xdn_comp(tls *TLS, src uintptr, dst uintptr, space int32, dnptrs uintptr, l if !(Uint64FromInt32(i) < l-Uint64FromInt32(bestlen)) { break } - *(*uint8)(unsafe.Pointer(dst + uintptr(i))) = (*(*[127]uint8)(unsafe.Pointer(bp + 4)))[j] + **(**uint8)(__ccgo_up(dst + uintptr(i))) = (**(**[127]uint8)(__ccgo_up(bp + 4)))[j] goto _2 _2: ; v3 = j j = j + 1 - i = i + (Int32FromUint8((*(*[127]uint8)(unsafe.Pointer(bp + 4)))[v3]) + int32(1)) + i = i + (Int32FromUint8((**(**[127]uint8)(__ccgo_up(bp + 4)))[v3]) + int32(1)) } /* add tail */ if bestlen != 0 { v3 = i i = i + 1 - *(*uint8)(unsafe.Pointer(dst + uintptr(v3))) = Uint8FromInt32(int32(0xc0) | bestoff>>int32(8)) + **(**uint8)(__ccgo_up(dst + uintptr(v3))) = Uint8FromInt32(int32(0xc0) | bestoff>>int32(8)) v3 = i i = i + 1 - *(*uint8)(unsafe.Pointer(dst + uintptr(v3))) = Uint8FromInt32(bestoff) + **(**uint8)(__ccgo_up(dst + uintptr(v3))) = Uint8FromInt32(bestoff) } else { v3 = i i = i + 1 - *(*uint8)(unsafe.Pointer(dst + uintptr(v3))) = uint8(0) + **(**uint8)(__ccgo_up(dst + uintptr(v3))) = uint8(0) } /* save dst pointer */ - if i > int32(2) && lastdnptr != 0 && dnptrs != 0 && *(*uintptr)(unsafe.Pointer(dnptrs)) != 0 { - for *(*uintptr)(unsafe.Pointer(p)) != 0 { + if i > int32(2) && lastdnptr != 0 && dnptrs != 0 && **(**uintptr)(__ccgo_up(dnptrs)) != 0 { + for **(**uintptr)(__ccgo_up(p)) != 0 { p += 8 } if p+uintptr(1)*8 < lastdnptr { v8 = p p += 8 - *(*uintptr)(unsafe.Pointer(v8)) = dst - *(*uintptr)(unsafe.Pointer(p)) = uintptr(0) + **(**uintptr)(__ccgo_up(v8)) = dst + **(**uintptr)(__ccgo_up(p)) = uintptr(0) } } return i @@ -118732,11 +118732,11 @@ func X__dn_expand(tls *TLS, base uintptr, end uintptr, src uintptr, dest uintptr break } /* loop invariants: p= int64(end)-int64(p) || int64(j) >= int64(dend)-int64(dest) { return -int32(1) } @@ -118767,10 +118767,10 @@ func X__dn_expand(tls *TLS, base uintptr, end uintptr, src uintptr, dest uintptr dest = dest + 1 v4 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v3)) = *(*uint8)(unsafe.Pointer(v4)) + **(**uint8)(__ccgo_up(v3)) = uint8(**(**uint8)(__ccgo_up(v4))) } } else { - *(*uint8)(unsafe.Pointer(dest)) = uint8(0) + **(**uint8)(__ccgo_up(dest)) = uint8(0) if len1 < 0 { len1 = int32(int64(p+uintptr(1)) - int64(src)) } @@ -118802,20 +118802,20 @@ func Xdn_skipname(tls *TLS, s uintptr, end uintptr) (r int32) { _ = p p = s for p < end { - if !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if !(**(**uint8)(__ccgo_up(p)) != 0) { return int32(int64(p) - int64(s) + int64(1)) } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) >= int32(192) { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) >= int32(192) { if p+uintptr(1) < end { return int32(int64(p) - int64(s) + int64(2)) } else { break } } else { - if int64(end)-int64(p) < int64(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))+int32(1)) { + if int64(end)-int64(p) < int64(Int32FromUint8(**(**uint8)(__ccgo_up(p)))+int32(1)) { break } else { - p = p + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))+int32(1)) + p = p + uintptr(Int32FromUint8(**(**uint8)(__ccgo_up(p)))+int32(1)) } } } @@ -118931,25 +118931,25 @@ func X__dns_parse(tls *TLS, r uintptr, rlen int32, __ccgo_fp_callback uintptr, c if rlen < int32(12) { return -int32(1) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 3)))&int32(15) != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(r + 3)))&int32(15) != 0 { return 0 } p = r + uintptr(12) - qdcount = Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 4)))*int32(256) + Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 5))) - ancount = Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 6)))*int32(256) + Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 7))) + qdcount = Int32FromUint8(**(**uint8)(__ccgo_up(r + 4)))*int32(256) + Int32FromUint8(**(**uint8)(__ccgo_up(r + 5))) + ancount = Int32FromUint8(**(**uint8)(__ccgo_up(r + 6)))*int32(256) + Int32FromUint8(**(**uint8)(__ccgo_up(r + 7))) for { v1 = qdcount qdcount = qdcount - 1 if !(v1 != 0) { break } - for int64(p)-int64(r) < int64(rlen) && uint32(*(*uint8)(unsafe.Pointer(p)))-uint32(1) < uint32(127) { + for int64(p)-int64(r) < int64(rlen) && uint32(**(**uint8)(__ccgo_up(p)))-uint32(1) < uint32(127) { p = p + 1 } if p > r+uintptr(rlen)-uintptr(6) { return -int32(1) } - p = p + uintptr(int32(5)+BoolInt32(!!(*(*uint8)(unsafe.Pointer(p)) != 0))) + p = p + uintptr(int32(5)+BoolInt32(!!(**(**uint8)(__ccgo_up(p)) != 0))) } for { v1 = ancount @@ -118957,18 +118957,18 @@ func X__dns_parse(tls *TLS, r uintptr, rlen int32, __ccgo_fp_callback uintptr, c if !(v1 != 0) { break } - for int64(p)-int64(r) < int64(rlen) && uint32(*(*uint8)(unsafe.Pointer(p)))-uint32(1) < uint32(127) { + for int64(p)-int64(r) < int64(rlen) && uint32(**(**uint8)(__ccgo_up(p)))-uint32(1) < uint32(127) { p = p + 1 } if p > r+uintptr(rlen)-uintptr(12) { return -int32(1) } - p = p + uintptr(int32(1)+BoolInt32(!!(*(*uint8)(unsafe.Pointer(p)) != 0))) - len1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 8)))*int32(256) + Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 9))) + p = p + uintptr(int32(1)+BoolInt32(!!(**(**uint8)(__ccgo_up(p)) != 0))) + len1 = Int32FromUint8(**(**uint8)(__ccgo_up(p + 8)))*int32(256) + Int32FromUint8(**(**uint8)(__ccgo_up(p + 9))) if int64(len1+int32(10)) > int64(r+uintptr(rlen))-int64(p) { return -int32(1) } - if (*(*func(*TLS, uintptr, int32, uintptr, int32, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_callback})))(tls, ctx, Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))), p+uintptr(10), len1, r, rlen) < 0 { + if (*(*func(*TLS, uintptr, int32, uintptr, int32, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_callback})))(tls, ctx, Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))), p+uintptr(10), len1, r, rlen) < 0 { return -int32(1) } p = p + uintptr(int32(10)+len1) @@ -119310,27 +119310,27 @@ func Xether_aton_r(tls *TLS, x uintptr, p_a uintptr) (r uintptr) { break } if ii != 0 { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(x))) != int32(':') { + if Int32FromUint8(**(**uint8)(__ccgo_up(x))) != int32(':') { return uintptr(0) } else { x = x + 1 } } n = Xstrtoul(tls, x, bp+8, int32(16)) - x = *(*uintptr)(unsafe.Pointer(bp + 8)) + x = **(**uintptr)(__ccgo_up(bp + 8)) if n > uint64(0xFF) { return uintptr(0) } /* bad byte */ - *(*Tuint8_t)(unsafe.Pointer(bp + uintptr(ii))) = uint8(n) + **(**Tuint8_t)(__ccgo_up(bp + uintptr(ii))) = uint8(n) goto _1 _1: ; ii = ii + 1 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(x))) != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(x))) != 0 { return uintptr(0) } /* bad format */ - *(*Tether_addr)(unsafe.Pointer(p_a)) = *(*Tether_addr)(unsafe.Pointer(bp)) + **(**Tether_addr)(__ccgo_up(p_a)) = **(**Tether_addr)(__ccgo_up(bp)) return p_a } @@ -119365,7 +119365,7 @@ func Xether_ntoa_r(tls *TLS, p_a uintptr, x uintptr) (r uintptr) { } else { v2 = __ccgo_ts + 976 } - x = x + uintptr(Xsprintf(tls, x, v2, VaList(bp+8, Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(p_a + uintptr(ii))))))) + x = x + uintptr(Xsprintf(tls, x, v2, VaList(bp+8, Int32FromUint8(**(**Tuint8_t)(__ccgo_up(p_a + uintptr(ii))))))) goto _1 _1: ; @@ -119450,11 +119450,11 @@ func Xgai_strerror(tls *TLS, ecode int32) (r uintptr) { s = uintptr(unsafe.Pointer(&_msgs)) ecode = ecode + 1 for { - if !(ecode != 0 && *(*uint8)(unsafe.Pointer(s)) != 0) { + if !(ecode != 0 && **(**uint8)(__ccgo_up(s)) != 0) { break } for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { break } goto _2 @@ -119468,7 +119468,7 @@ func Xgai_strerror(tls *TLS, ecode int32) (r uintptr) { ecode = ecode + 1 s = s + 1 } - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { s = s + 1 } return X__lctrans_cur(tls, s) @@ -119544,15 +119544,15 @@ func Xgetaddrinfo(tls *TLS, host uintptr, serv uintptr, hint uintptr, res uintpt if s >= 0 { _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp+1608) r = Xconnect(tls, s, ta[i], tl[i]) - saved_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 1608)), uintptr(0)) + saved_errno = **(**int32)(__ccgo_up(X__errno_location(tls))) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 1608)), uintptr(0)) Xclose(tls, s) if !(r != 0) { goto _1 } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = saved_errno + **(**int32)(__ccgo_up(X__errno_location(tls))) = saved_errno } - switch *(*int32)(unsafe.Pointer(X__errno_location(tls))) { + switch **(**int32)(__ccgo_up(X__errno_location(tls))) { case int32(EADDRNOTAVAIL): fallthrough case int32(EAFNOSUPPORT): @@ -119610,32 +119610,32 @@ func Xgetaddrinfo(tls *TLS, host uintptr, serv uintptr, hint uintptr, res uintpt if !(j < nservs) { break } - (*(*Taibuf)(unsafe.Pointer(out + uintptr(k)*88))).Fslot = int16(k) - if (*(*[48]Taddress)(unsafe.Pointer(bp + 8)))[i].Ffamily == int32(PF_INET) { + (**(**Taibuf)(__ccgo_up(out + uintptr(k)*88))).Fslot = int16(k) + if (**(**[48]Taddress)(__ccgo_up(bp + 8)))[i].Ffamily == int32(PF_INET) { v5 = uint64(16) } else { v5 = uint64(28) } - (*(*Taibuf)(unsafe.Pointer(out + uintptr(k)*88))).Fai = Taddrinfo{ - Fai_family: (*(*[48]Taddress)(unsafe.Pointer(bp + 8)))[i].Ffamily, - Fai_socktype: Int32FromUint8((*(*[2]Tservice)(unsafe.Pointer(bp)))[j].Fsocktype), - Fai_protocol: Int32FromUint8((*(*[2]Tservice)(unsafe.Pointer(bp)))[j].Fproto), + (**(**Taibuf)(__ccgo_up(out + uintptr(k)*88))).Fai = Taddrinfo{ + Fai_family: (**(**[48]Taddress)(__ccgo_up(bp + 8)))[i].Ffamily, + Fai_socktype: Int32FromUint8((**(**[2]Tservice)(__ccgo_up(bp)))[j].Fsocktype), + Fai_protocol: Int32FromUint8((**(**[2]Tservice)(__ccgo_up(bp)))[j].Fproto), Fai_addrlen: uint32(v5), Fai_addr: out + uintptr(k)*88 + 48, Fai_canonname: outcanon, } if k != 0 { - (*(*Taibuf)(unsafe.Pointer(out + uintptr(k-int32(1))*88))).Fai.Fai_next = out + uintptr(k)*88 + (**(**Taibuf)(__ccgo_up(out + uintptr(k-int32(1))*88))).Fai.Fai_next = out + uintptr(k)*88 } - switch (*(*[48]Taddress)(unsafe.Pointer(bp + 8)))[i].Ffamily { + switch (**(**[48]Taddress)(__ccgo_up(bp + 8)))[i].Ffamily { case int32(PF_INET): *(*Tsa_family_t)(unsafe.Pointer(out + uintptr(k)*88 + 48)) = uint16(PF_INET) - *(*Tin_port_t)(unsafe.Pointer(out + uintptr(k)*88 + 48 + 2)) = Xhtons(tls, (*(*[2]Tservice)(unsafe.Pointer(bp)))[j].Fport) + *(*Tin_port_t)(unsafe.Pointer(out + uintptr(k)*88 + 48 + 2)) = Xhtons(tls, (**(**[2]Tservice)(__ccgo_up(bp)))[j].Fport) Xmemcpy(tls, out+uintptr(k)*88+48+4, bp+8+uintptr(i)*28+8, uint64(4)) case int32(PF_INET6): *(*Tsa_family_t)(unsafe.Pointer(out + uintptr(k)*88 + 48)) = uint16(PF_INET6) - *(*Tin_port_t)(unsafe.Pointer(out + uintptr(k)*88 + 48 + 2)) = Xhtons(tls, (*(*[2]Tservice)(unsafe.Pointer(bp)))[j].Fport) - *(*Tuint32_t)(unsafe.Pointer(out + uintptr(k)*88 + 48 + 24)) = (*(*[48]Taddress)(unsafe.Pointer(bp + 8)))[i].Fscopeid + *(*Tin_port_t)(unsafe.Pointer(out + uintptr(k)*88 + 48 + 2)) = Xhtons(tls, (**(**[2]Tservice)(__ccgo_up(bp)))[j].Fport) + *(*Tuint32_t)(unsafe.Pointer(out + uintptr(k)*88 + 48 + 24)) = (**(**[48]Taddress)(__ccgo_up(bp + 8)))[i].Fscopeid Xmemcpy(tls, out+uintptr(k)*88+48+8, bp+8+uintptr(i)*28+8, uint64(16)) break } @@ -119650,8 +119650,8 @@ func Xgetaddrinfo(tls *TLS, host uintptr, serv uintptr, hint uintptr, res uintpt ; i = i + 1 } - (*(*Taibuf)(unsafe.Pointer(out))).Fref = int16(nais) - *(*uintptr)(unsafe.Pointer(res)) = out + (**(**Taibuf)(__ccgo_up(out))).Fref = int16(nais) + **(**uintptr)(__ccgo_up(res)) = out return 0 } @@ -119782,12 +119782,12 @@ func Xgethostbyaddr(tls *TLS, a uintptr, l Tsocklen_t, af int32) (r uintptr) { size = size + (size + uint64(1)) _h = Xmalloc(tls, size) if !(_h != 0) { - *(*int32)(unsafe.Pointer(X__h_errno_location(tls))) = int32(NO_RECOVERY) + **(**int32)(__ccgo_up(X__h_errno_location(tls))) = int32(NO_RECOVERY) return uintptr(0) } err = Xgethostbyaddr_r(tls, a, l, af, _h, _h+UintptrFromInt32(1)*32, size-uint64(32), bp, X__h_errno_location(tls)) } - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } var _h uintptr @@ -119824,7 +119824,7 @@ func Xgethostbyaddr_r(tls *TLS, a uintptr, l Tsocklen_t, af int32, h uintptr, bu v1 = uint64(16) } sl = uint32(v1) - *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) + **(**uintptr)(__ccgo_up(res)) = uintptr(0) /* Load address argument into sockaddr structure */ if af == int32(PF_INET6) && l == uint32(16) { Xmemcpy(tls, bp+8, a, uint64(16)) @@ -119832,7 +119832,7 @@ func Xgethostbyaddr_r(tls *TLS, a uintptr, l Tsocklen_t, af int32, h uintptr, bu if af == int32(PF_INET) && l == uint32(4) { Xmemcpy(tls, bp+4, a, uint64(4)) } else { - *(*int32)(unsafe.Pointer(err)) = int32(NO_RECOVERY) + **(**int32)(__ccgo_up(err)) = int32(NO_RECOVERY) return int32(EINVAL) } } @@ -119850,33 +119850,33 @@ func Xgethostbyaddr_r(tls *TLS, a uintptr, l Tsocklen_t, af int32, h uintptr, bu buf = buf + uintptr(Uint64FromInt32(2)*Uint64FromInt64(8)) (*Thostent)(unsafe.Pointer(h)).Fh_aliases = buf buf = buf + uintptr(Uint64FromInt32(2)*Uint64FromInt64(8)) - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list)) = buf - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list)), a, uint64(l)) + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_addr_list)) = buf + Xmemcpy(tls, **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_addr_list)), a, uint64(l)) buf = buf + uintptr(l) - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + 1*8)) = uintptr(0) - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) = buf - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = uintptr(0) + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + 1*8)) = uintptr(0) + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) = buf + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = uintptr(0) switch Xgetnameinfo(tls, bp, sl, buf, uint32(buflen), uintptr(0), uint32(0), 0) { case -int32(3): - *(*int32)(unsafe.Pointer(err)) = int32(TRY_AGAIN) + **(**int32)(__ccgo_up(err)) = int32(TRY_AGAIN) return int32(EAGAIN) case -int32(12): return int32(ERANGE) default: fallthrough case -int32(4): - *(*int32)(unsafe.Pointer(err)) = int32(NO_RECOVERY) + **(**int32)(__ccgo_up(err)) = int32(NO_RECOVERY) return int32(EBADMSG) case -int32(11): - *(*int32)(unsafe.Pointer(err)) = int32(NO_RECOVERY) - return *(*int32)(unsafe.Pointer(X__errno_location(tls))) + **(**int32)(__ccgo_up(err)) = int32(NO_RECOVERY) + return **(**int32)(__ccgo_up(X__errno_location(tls))) case 0: break } (*Thostent)(unsafe.Pointer(h)).Fh_addrtype = af (*Thostent)(unsafe.Pointer(h)).Fh_length = Int32FromUint32(l) - (*Thostent)(unsafe.Pointer(h)).Fh_name = *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) - *(*uintptr)(unsafe.Pointer(res)) = h + (*Thostent)(unsafe.Pointer(h)).Fh_name = **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) + **(**uintptr)(__ccgo_up(res)) = h return 0 } @@ -119905,12 +119905,12 @@ func Xgethostbyname2(tls *TLS, name uintptr, af int32) (r uintptr) { size = size + (size + uint64(1)) _h1 = Xmalloc(tls, size) if !(_h1 != 0) { - *(*int32)(unsafe.Pointer(X__h_errno_location(tls))) = int32(NO_RECOVERY) + **(**int32)(__ccgo_up(X__h_errno_location(tls))) = int32(NO_RECOVERY) return uintptr(0) } err = Xgethostbyname2_r(tls, name, af, _h1, _h1+UintptrFromInt32(1)*32, size-uint64(32), bp, X__h_errno_location(tls)) } - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } var _h1 uintptr @@ -119928,27 +119928,27 @@ func Xgethostbyname2_r(tls *TLS, name uintptr, af int32, h uintptr, buf uintptr, var _ /* addrs at bp+0 */ [48]Taddress var _ /* canon at bp+1344 */ [256]uint8 _, _, _, _, _, _ = align, cnt, i, need, v1, v3 - *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) + **(**uintptr)(__ccgo_up(res)) = uintptr(0) cnt = X__lookup_name(tls, bp, bp+1344, name, af, int32(AI_CANONNAME)) if cnt < 0 { switch cnt { case -int32(2): - *(*int32)(unsafe.Pointer(err)) = int32(HOST_NOT_FOUND) + **(**int32)(__ccgo_up(err)) = int32(HOST_NOT_FOUND) return 0 case -int32(5): - *(*int32)(unsafe.Pointer(err)) = int32(NO_DATA) + **(**int32)(__ccgo_up(err)) = int32(NO_DATA) return 0 case -int32(3): - *(*int32)(unsafe.Pointer(err)) = int32(TRY_AGAIN) + **(**int32)(__ccgo_up(err)) = int32(TRY_AGAIN) return int32(EAGAIN) default: fallthrough case -int32(4): - *(*int32)(unsafe.Pointer(err)) = int32(NO_RECOVERY) + **(**int32)(__ccgo_up(err)) = int32(NO_RECOVERY) return int32(EBADMSG) case -int32(11): - *(*int32)(unsafe.Pointer(err)) = int32(NO_RECOVERY) - return *(*int32)(unsafe.Pointer(X__errno_location(tls))) + **(**int32)(__ccgo_up(err)) = int32(NO_RECOVERY) + return **(**int32)(__ccgo_up(X__errno_location(tls))) } } (*Thostent)(unsafe.Pointer(h)).Fh_addrtype = af @@ -119978,29 +119978,29 @@ func Xgethostbyname2_r(tls *TLS, name uintptr, af int32, h uintptr, buf uintptr, if !(i < cnt) { break } - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)) = buf + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)) = buf buf = buf + uintptr((*Thostent)(unsafe.Pointer(h)).Fh_length) - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)), bp+uintptr(i)*28+8, Uint64FromInt32((*Thostent)(unsafe.Pointer(h)).Fh_length)) + Xmemcpy(tls, **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)), bp+uintptr(i)*28+8, Uint64FromInt32((*Thostent)(unsafe.Pointer(h)).Fh_length)) goto _2 _2: ; i = i + 1 } - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)) = uintptr(0) + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)) = uintptr(0) v3 = buf - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) = v3 + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) = v3 (*Thostent)(unsafe.Pointer(h)).Fh_name = v3 Xstrcpy(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name, bp+1344) buf = buf + uintptr(_strlen(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name)+uint64(1)) if Xstrcmp(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name, name) != 0 { - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = buf - Xstrcpy(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)), name) - buf = buf + uintptr(_strlen(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)))+uint64(1)) + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = buf + Xstrcpy(tls, **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)), name) + buf = buf + uintptr(_strlen(tls, **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)))+uint64(1)) } else { - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = uintptr(0) + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = uintptr(0) } - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 2*8)) = uintptr(0) - *(*uintptr)(unsafe.Pointer(res)) = h + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 2*8)) = uintptr(0) + **(**uintptr)(__ccgo_up(res)) = h return 0 } @@ -120229,7 +120229,7 @@ func _copy_addr(tls *TLS, r uintptr, af int32, sa uintptr, addr uintptr, addrlen case int32(PF_INET6): dst = sa + 8 len1 = int32(16) - if Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(addr))) == int32(0xfe) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(addr + 1)))&int32(0xc0) == int32(0x80) || Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(addr))) == int32(0xff) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(addr + 1)))&int32(0xf) == int32(0x2) { + if Int32FromUint8(**(**Tuint8_t)(__ccgo_up(addr))) == int32(0xfe) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(addr + 1)))&int32(0xc0) == int32(0x80) || Int32FromUint8(**(**Tuint8_t)(__ccgo_up(addr))) == int32(0xff) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(addr + 1)))&int32(0xf) == int32(0x2) { (*(*Tsockaddr_in6)(unsafe.Pointer(sa))).Fsin6_scope_id = Uint32FromInt32(ifindex) } default: @@ -120240,7 +120240,7 @@ func _copy_addr(tls *TLS, r uintptr, af int32, sa uintptr, addr uintptr, addrlen } (*Tsockany)(unsafe.Pointer(sa)).Fsa.Fsa_family = Uint16FromInt32(af) Xmemcpy(tls, dst, addr, Uint64FromInt32(len1)) - *(*uintptr)(unsafe.Pointer(r)) = sa + **(**uintptr)(__ccgo_up(r)) = sa } func _gen_netmask(tls *TLS, r uintptr, af int32, sa uintptr, prefixlen int32) { @@ -120249,7 +120249,7 @@ func _gen_netmask(tls *TLS, r uintptr, af int32, sa uintptr, prefixlen int32) { var i, v1 int32 var _ /* addr at bp+0 */ [16]Tuint8_t _, _ = i, v1 - *(*[16]Tuint8_t)(unsafe.Pointer(bp)) = [16]Tuint8_t{} + **(**[16]Tuint8_t)(__ccgo_up(bp)) = [16]Tuint8_t{} if Uint64FromInt32(prefixlen) > Uint64FromInt32(8)*Uint64FromInt64(16) { prefixlen = Int32FromUint64(Uint64FromInt32(8) * Uint64FromInt64(16)) } @@ -120258,7 +120258,7 @@ func _gen_netmask(tls *TLS, r uintptr, af int32, sa uintptr, prefixlen int32) { if Uint64FromInt32(i) < uint64(16) { v1 = i i = i + 1 - (*(*[16]Tuint8_t)(unsafe.Pointer(bp)))[v1] = Uint8FromInt32(int32(0xff) << (int32(8) - prefixlen%int32(8))) + (**(**[16]Tuint8_t)(__ccgo_up(bp)))[v1] = Uint8FromInt32(int32(0xff) << (int32(8) - prefixlen%int32(8))) } _copy_addr(tls, r, af, sa, bp, uint64(16), 0) } @@ -120272,7 +120272,7 @@ func _copy_lladdr(tls *TLS, r uintptr, sa uintptr, addr uintptr, addrlen Tsize_t (*(*Tsockaddr_ll_hack)(unsafe.Pointer(sa))).Fsll_hatype = hatype (*(*Tsockaddr_ll_hack)(unsafe.Pointer(sa))).Fsll_halen = uint8(addrlen) Xmemcpy(tls, sa+12, addr, addrlen) - *(*uintptr)(unsafe.Pointer(r)) = sa + **(**uintptr)(__ccgo_up(r)) = sa } func _netlink_msg_to_ifaddr(tls *TLS, pctx uintptr, h uintptr) (r int32) { @@ -120301,7 +120301,7 @@ func _netlink_msg_to_ifaddr(tls *TLS, pctx uintptr, h uintptr) (r int32) { rta = rta + uintptr((Int32FromUint16((*Trtattr)(unsafe.Pointer(rta)).Frta_len)+Int32FromInt32(3)) & ^Int32FromInt32(3)) } } else { - ifs0 = *(*uintptr)(unsafe.Pointer(ctx + 16 + uintptr((*Tifaddrmsg)(unsafe.Pointer(ifa)).Fifa_index%uint32(IFADDRS_HASH_SIZE))*8)) + ifs0 = **(**uintptr)(__ccgo_up(ctx + 16 + uintptr((*Tifaddrmsg)(unsafe.Pointer(ifa)).Fifa_index%uint32(IFADDRS_HASH_SIZE))*8)) for { if !(ifs0 != 0) { break @@ -120352,8 +120352,8 @@ func _netlink_msg_to_ifaddr(tls *TLS, pctx uintptr, h uintptr) (r int32) { } if (*Tifaddrs_storage)(unsafe.Pointer(ifs)).Fifa.Fifa_name != 0 { bucket = (*Tifaddrs_storage)(unsafe.Pointer(ifs)).Findex % uint32(IFADDRS_HASH_SIZE) - (*Tifaddrs_storage)(unsafe.Pointer(ifs)).Fhash_next = *(*uintptr)(unsafe.Pointer(ctx + 16 + uintptr(bucket)*8)) - *(*uintptr)(unsafe.Pointer(ctx + 16 + uintptr(bucket)*8)) = ifs + (*Tifaddrs_storage)(unsafe.Pointer(ifs)).Fhash_next = **(**uintptr)(__ccgo_up(ctx + 16 + uintptr(bucket)*8)) + **(**uintptr)(__ccgo_up(ctx + 16 + uintptr(bucket)*8)) = ifs } } else { (*Tifaddrs_storage)(unsafe.Pointer(ifs)).Fifa.Fifa_name = (*Tifaddrs_storage)(unsafe.Pointer(ifs0)).Fifa.Fifa_name @@ -120428,7 +120428,7 @@ func Xgetifaddrs(tls *TLS, ifap uintptr) (r1 int32) { Xmemset(tls, ctx, 0, uint64(528)) r = X__rtnetlink_enumerate(tls, PF_UNSPEC, PF_UNSPEC, __ccgo_fp(_netlink_msg_to_ifaddr), ctx) if r == 0 { - *(*uintptr)(unsafe.Pointer(ifap)) = (*Tifaddrs_ctx)(unsafe.Pointer(ctx)).Ffirst + **(**uintptr)(__ccgo_up(ifap)) = (*Tifaddrs_ctx)(unsafe.Pointer(ctx)).Ffirst } else { Xfreeifaddrs(tls, (*Tifaddrs_ctx)(unsafe.Pointer(ctx)).Ffirst) } @@ -120443,11 +120443,11 @@ func _itoa(tls *TLS, p uintptr, x uint32) (r uintptr) { p = p + uintptr(Uint64FromInt32(3)*Uint64FromInt64(4)) p = p - 1 v1 = p - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) for cond := true; cond; cond = x != 0 { p = p - 1 v1 = p - *(*uint8)(unsafe.Pointer(v1)) = uint8(uint32('0') + x%uint32(10)) + **(**uint8)(__ccgo_up(v1)) = uint8(uint32('0') + x%uint32(10)) x = x / uint32(10) } return p @@ -120456,7 +120456,7 @@ func _itoa(tls *TLS, p uintptr, x uint32) (r uintptr) { func _mkptr4(tls *TLS, s uintptr, ip uintptr) { bp := tls.Alloc(48) defer tls.Free(48) - Xsprintf(tls, s, __ccgo_ts+982, VaList(bp+8, Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + 3))), Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + 2))), Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + 1))), Int32FromUint8(*(*uint8)(unsafe.Pointer(ip))))) + Xsprintf(tls, s, __ccgo_ts+982, VaList(bp+8, Int32FromUint8(**(**uint8)(__ccgo_up(ip + 3))), Int32FromUint8(**(**uint8)(__ccgo_up(ip + 2))), Int32FromUint8(**(**uint8)(__ccgo_up(ip + 1))), Int32FromUint8(**(**uint8)(__ccgo_up(ip))))) } func _mkptr6(tls *TLS, s uintptr, ip uintptr) { @@ -120470,16 +120470,16 @@ func _mkptr6(tls *TLS, s uintptr, ip uintptr) { } v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = _xdigits[Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + uintptr(i))))&int32(15)] + **(**uint8)(__ccgo_up(v2)) = _xdigits[Int32FromUint8(**(**uint8)(__ccgo_up(ip + uintptr(i))))&int32(15)] v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8('.') + **(**uint8)(__ccgo_up(v2)) = uint8('.') v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = _xdigits[Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + uintptr(i))))>>int32(4)] + **(**uint8)(__ccgo_up(v2)) = _xdigits[Int32FromUint8(**(**uint8)(__ccgo_up(ip + uintptr(i))))>>int32(4)] v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8('.') + **(**uint8)(__ccgo_up(v2)) = uint8('.') goto _1 _1: ; @@ -120517,13 +120517,13 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int if v1 != 0 { v2 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8('\n') - *(*uint8)(unsafe.Pointer(p)) = Uint8FromInt32(0) + **(**uint8)(__ccgo_up(v2)) = uint8('\n') + **(**uint8)(__ccgo_up(p)) = Uint8FromInt32(0) } p = bp for { - if v7 = *(*uint8)(unsafe.Pointer(p)) != 0; v7 { - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + if v7 = **(**uint8)(__ccgo_up(p)) != 0; v7 { + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v5 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _6 _6: @@ -120536,26 +120536,26 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int ; p = p + 1 } - if !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if !(**(**uint8)(__ccgo_up(p)) != 0) { continue } v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) if X__lookup_ipliteral(tls, bp+1560, bp, PF_UNSPEC) <= 0 { continue } - if (*(*Taddress)(unsafe.Pointer(bp + 1560))).Ffamily == int32(PF_INET) { + if (**(**Taddress)(__ccgo_up(bp + 1560))).Ffamily == int32(PF_INET) { Xmemcpy(tls, bp+1560+8+uintptr(12), bp+1560+8, uint64(4)) Xmemcpy(tls, bp+1560+8, __ccgo_ts+1027, uint64(12)) - (*(*Taddress)(unsafe.Pointer(bp + 1560))).Fscopeid = uint32(0) + (**(**Taddress)(__ccgo_up(bp + 1560))).Fscopeid = uint32(0) } - if Xmemcmp(tls, a, bp+1560+8, uint64(16)) != 0 || (*(*Taddress)(unsafe.Pointer(bp + 1560))).Fscopeid != scopeid { + if Xmemcmp(tls, a, bp+1560+8, uint64(16)) != 0 || (**(**Taddress)(__ccgo_up(bp + 1560))).Fscopeid != scopeid { continue } for { - if v7 = *(*uint8)(unsafe.Pointer(p)) != 0; v7 { - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + if v7 = **(**uint8)(__ccgo_up(p)) != 0; v7 { + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v5 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _12 _12: @@ -120570,8 +120570,8 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int } z = p for { - if v7 = *(*uint8)(unsafe.Pointer(z)) != 0; v7 { - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(z))) + if v7 = **(**uint8)(__ccgo_up(z)) != 0; v7 { + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(z))) v5 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _17 _17: @@ -120584,7 +120584,7 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int ; z = z + 1 } - *(*uint8)(unsafe.Pointer(z)) = uint8(0) + **(**uint8)(__ccgo_up(z)) = uint8(0) if int64(z)-int64(p) < int64(256) { Xmemcpy(tls, buf, p, Uint64FromInt64(int64(z)-int64(p)+int64(1))) break @@ -120615,13 +120615,13 @@ func _reverse_services(tls *TLS, buf uintptr, port int32, dgram int32) { if v1 != 0 { v2 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8('\n') - *(*uint8)(unsafe.Pointer(p)) = Uint8FromInt32(0) + **(**uint8)(__ccgo_up(v2)) = uint8('\n') + **(**uint8)(__ccgo_up(p)) = Uint8FromInt32(0) } p = bp for { - if v7 = *(*uint8)(unsafe.Pointer(p)) != 0; v7 { - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + if v7 = **(**uint8)(__ccgo_up(p)) != 0; v7 { + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v5 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _6 _6: @@ -120634,20 +120634,20 @@ func _reverse_services(tls *TLS, buf uintptr, port int32, dgram int32) { ; p = p + 1 } - if !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if !(**(**uint8)(__ccgo_up(p)) != 0) { continue } v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) svport = Xstrtoul(tls, p, bp+128, int32(10)) - if svport != Uint64FromInt32(port) || *(*uintptr)(unsafe.Pointer(bp + 128)) == p { + if svport != Uint64FromInt32(port) || **(**uintptr)(__ccgo_up(bp + 128)) == p { continue } - if dgram != 0 && Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(bp + 128)), __ccgo_ts+1054, uint64(4)) != 0 { + if dgram != 0 && Xstrncmp(tls, **(**uintptr)(__ccgo_up(bp + 128)), __ccgo_ts+1054, uint64(4)) != 0 { continue } - if !(dgram != 0) && Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(bp + 128)), __ccgo_ts+1059, uint64(4)) != 0 { + if !(dgram != 0) && Xstrncmp(tls, **(**uintptr)(__ccgo_up(bp + 128)), __ccgo_ts+1059, uint64(4)) != 0 { continue } if int64(p)-t__predefined_ptrdiff_t(bp) > int64(32) { @@ -120664,7 +120664,7 @@ func _dns_parse_callback(tls *TLS, c uintptr, rr int32, data uintptr, len1 int32 return 0 } if X__dn_expand(tls, packet, packet+uintptr(plen), data, c, int32(256)) <= 0 { - *(*uint8)(unsafe.Pointer(c)) = uint8(0) + **(**uint8)(__ccgo_up(c)) = uint8(0) } return 0 } @@ -120710,15 +120710,15 @@ func Xgetnameinfo(tls *TLS, sa uintptr, sl Tsocklen_t, node uintptr, nodelen Tso return -int32(6) } if node != 0 && nodelen != 0 { - (*(*[256]uint8)(unsafe.Pointer(bp + 78)))[0] = uint8(0) + (**(**[256]uint8)(__ccgo_up(bp + 78)))[0] = uint8(0) if !(flags&Int32FromInt32(NI_NUMERICHOST) != 0) { _reverse_hosts(tls, bp+78, a, scopeid, af) } - if !(*(*uint8)(unsafe.Pointer(bp + 78)) != 0) && !(flags&Int32FromInt32(NI_NUMERICHOST) != 0) { + if !(**(**uint8)(__ccgo_up(bp + 78)) != 0) && !(flags&Int32FromInt32(NI_NUMERICHOST) != 0) { qlen = X__res_mkquery(tls, 0, bp, int32(1), int32(RR_PTR), uintptr(0), 0, uintptr(0), bp+347, int32(96)) - (*(*[96]uint8)(unsafe.Pointer(bp + 347)))[int32(3)] = uint8(0) /* don't need AD flag */ + (**(**[96]uint8)(__ccgo_up(bp + 347)))[int32(3)] = uint8(0) /* don't need AD flag */ rlen = X__res_send(tls, bp+347, qlen, bp+443, int32(512)) - (*(*[256]uint8)(unsafe.Pointer(bp + 78)))[0] = uint8(0) + (**(**[256]uint8)(__ccgo_up(bp + 78)))[0] = uint8(0) if rlen > 0 { if Uint64FromInt32(rlen) > uint64(512) { rlen = int32(512) @@ -120726,14 +120726,14 @@ func Xgetnameinfo(tls *TLS, sa uintptr, sl Tsocklen_t, node uintptr, nodelen Tso X__dns_parse(tls, bp+443, rlen, __ccgo_fp(_dns_parse_callback), bp+78) } } - if !(*(*uint8)(unsafe.Pointer(bp + 78)) != 0) { + if !(**(**uint8)(__ccgo_up(bp + 78)) != 0) { if flags&int32(NI_NAMEREQD) != 0 { return -int32(2) } Xinet_ntop(tls, af, a, bp+78, uint32(256)) if scopeid != 0 { p = uintptr(0) - if !(flags&Int32FromInt32(NI_NUMERICSCOPE) != 0) && (Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a))) == int32(0xfe) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 1)))&int32(0xc0) == int32(0x80) || Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a))) == int32(0xff) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 1)))&int32(0xf) == int32(0x2)) { + if !(flags&Int32FromInt32(NI_NUMERICSCOPE) != 0) && (Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a))) == int32(0xfe) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 1)))&int32(0xc0) == int32(0x80) || Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a))) == int32(0xff) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 1)))&int32(0xf) == int32(0x2)) { p = Xif_indextoname(tls, scopeid, bp+955+uintptr(1)) } if !(p != 0) { @@ -120741,7 +120741,7 @@ func Xgetnameinfo(tls *TLS, sa uintptr, sl Tsocklen_t, node uintptr, nodelen Tso } p = p - 1 v1 = p - *(*uint8)(unsafe.Pointer(v1)) = uint8('%') + **(**uint8)(__ccgo_up(v1)) = uint8('%') Xstrcat(tls, bp+78, p) } } @@ -120753,11 +120753,11 @@ func Xgetnameinfo(tls *TLS, sa uintptr, sl Tsocklen_t, node uintptr, nodelen Tso if serv != 0 && servlen != 0 { p1 = bp + 78 port = Int32FromUint16(Xntohs(tls, (*Tsockaddr_in)(unsafe.Pointer(sa)).Fsin_port)) - (*(*[256]uint8)(unsafe.Pointer(bp + 78)))[0] = uint8(0) + (**(**[256]uint8)(__ccgo_up(bp + 78)))[0] = uint8(0) if !(flags&Int32FromInt32(NI_NUMERICSERV) != 0) { _reverse_services(tls, bp+78, port, flags&int32(NI_DGRAM)) } - if !(*(*uint8)(unsafe.Pointer(p1)) != 0) { + if !(**(**uint8)(__ccgo_up(p1)) != 0) { p1 = _itoa(tls, bp+334, Uint32FromInt32(port)) } if _strlen(tls, p1) >= uint64(servlen) { @@ -120832,11 +120832,11 @@ func Xgetservbyname_r(tls *TLS, name uintptr, prots uintptr, se uintptr, buf uin var _ /* end at bp+8 */ uintptr var _ /* servs at bp+0 */ [2]Tservice _, _, _, _ = align, cnt, proto, v1 - *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) + **(**uintptr)(__ccgo_up(res)) = uintptr(0) /* Don't treat numeric port number strings as service records. */ - *(*uintptr)(unsafe.Pointer(bp + 8)) = __ccgo_ts + **(**uintptr)(__ccgo_up(bp + 8)) = __ccgo_ts Xstrtoul(tls, name, bp+8, int32(10)) - if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) != 0) { + if !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) != 0) { return int32(ENOENT) } /* Align buffer */ @@ -120871,16 +120871,16 @@ func Xgetservbyname_r(tls *TLS, name uintptr, prots uintptr, se uintptr, buf uin } (*Tservent)(unsafe.Pointer(se)).Fs_name = name (*Tservent)(unsafe.Pointer(se)).Fs_aliases = buf - *(*uintptr)(unsafe.Pointer((*Tservent)(unsafe.Pointer(se)).Fs_aliases)) = (*Tservent)(unsafe.Pointer(se)).Fs_name - *(*uintptr)(unsafe.Pointer((*Tservent)(unsafe.Pointer(se)).Fs_aliases + 1*8)) = uintptr(0) - (*Tservent)(unsafe.Pointer(se)).Fs_port = Int32FromUint16(Xhtons(tls, (*(*[2]Tservice)(unsafe.Pointer(bp)))[0].Fport)) - if Int32FromUint8((*(*[2]Tservice)(unsafe.Pointer(bp)))[0].Fproto) == int32(IPPROTO_TCP) { + **(**uintptr)(__ccgo_up((*Tservent)(unsafe.Pointer(se)).Fs_aliases)) = (*Tservent)(unsafe.Pointer(se)).Fs_name + **(**uintptr)(__ccgo_up((*Tservent)(unsafe.Pointer(se)).Fs_aliases + 1*8)) = uintptr(0) + (*Tservent)(unsafe.Pointer(se)).Fs_port = Int32FromUint16(Xhtons(tls, (**(**[2]Tservice)(__ccgo_up(bp)))[0].Fport)) + if Int32FromUint8((**(**[2]Tservice)(__ccgo_up(bp)))[0].Fproto) == int32(IPPROTO_TCP) { v1 = __ccgo_ts + 1064 } else { v1 = __ccgo_ts + 1068 } (*Tservent)(unsafe.Pointer(se)).Fs_proto = v1 - *(*uintptr)(unsafe.Pointer(res)) = se + **(**uintptr)(__ccgo_up(res)) = se return 0 } @@ -120960,7 +120960,7 @@ _9: if true { break } - if uint64(*(*Tsocklen_t)(unsafe.Pointer(optlen))) < uint64(16) { + if uint64(**(**Tsocklen_t)(__ccgo_up(optlen))) < uint64(16) { return int32(X__syscall_ret(tls, Uint64FromInt32(-Int32FromInt32(EINVAL)))) } if optname == int32(SO_RCVTIMEO) { @@ -120997,9 +120997,9 @@ _9: break } tv = optval - (*Ttimeval)(unsafe.Pointer(tv)).Ftv_sec = (*(*[2]int64)(unsafe.Pointer(bp + 8)))[0] - (*Ttimeval)(unsafe.Pointer(tv)).Ftv_usec = (*(*[2]int64)(unsafe.Pointer(bp + 8)))[int32(1)] - *(*Tsocklen_t)(unsafe.Pointer(optlen)) = uint32(16) + (*Ttimeval)(unsafe.Pointer(tv)).Ftv_sec = (**(**[2]int64)(__ccgo_up(bp + 8)))[0] + (*Ttimeval)(unsafe.Pointer(tv)).Ftv_usec = (**(**[2]int64)(__ccgo_up(bp + 8)))[int32(1)] + **(**Tsocklen_t)(__ccgo_up(optlen)) = uint32(16) case int32(SO_TIMESTAMP): fallthrough case int32(SO_TIMESTAMPNS): @@ -121069,7 +121069,7 @@ func Xherror(tls *TLS, msg uintptr) { } else { v2 = __ccgo_ts } - Xfprintf(tls, uintptr(unsafe.Pointer(&X__stderr_FILE)), __ccgo_ts+1072, VaList(bp+8, v1, v2, Xhstrerror(tls, *(*int32)(unsafe.Pointer(X__h_errno_location(tls)))))) + Xfprintf(tls, uintptr(unsafe.Pointer(&X__stderr_FILE)), __ccgo_ts+1072, VaList(bp+8, v1, v2, Xhstrerror(tls, **(**int32)(__ccgo_up(X__h_errno_location(tls)))))) } var _msgs1 = [84]uint8{'H', 'o', 's', 't', ' ', 'n', 'o', 't', ' ', 'f', 'o', 'u', 'n', 'd', 0, 'T', 'r', 'y', ' ', 'a', 'g', 'a', 'i', 'n', 0, 'N', 'o', 'n', '-', 'r', 'e', 'c', 'o', 'v', 'e', 'r', 'a', 'b', 'l', 'e', ' ', 'e', 'r', 'r', 'o', 'r', 0, 'A', 'd', 'd', 'r', 'e', 's', 's', ' ', 'n', 'o', 't', ' ', 'a', 'v', 'a', 'i', 'l', 'a', 'b', 'l', 'e', 0, 0, 'U', 'n', 'k', 'n', 'o', 'w', 'n', ' ', 'e', 'r', 'r', 'o', 'r'} @@ -121084,11 +121084,11 @@ func Xhstrerror(tls *TLS, ecode int32) (r uintptr) { s = uintptr(unsafe.Pointer(&_msgs1)) ecode = ecode - 1 for { - if !(ecode != 0 && *(*uint8)(unsafe.Pointer(s)) != 0) { + if !(ecode != 0 && **(**uint8)(__ccgo_up(s)) != 0) { break } for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { break } goto _2 @@ -121102,7 +121102,7 @@ func Xhstrerror(tls *TLS, ecode int32) (r uintptr) { ecode = ecode - 1 s = s + 1 } - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { s = s + 1 } return X__lctrans_cur(tls, s) @@ -121190,8 +121190,8 @@ func Xif_indextoname(tls *TLS, index uint32, name uintptr) (r1 uintptr) { r = Xioctl(tls, fd, int32(SIOCGIFNAME), VaList(bp+48, bp)) X__syscall1(tls, int64(SYS_close), int64(fd)) if r < 0 { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENODEV) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENXIO) + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENODEV) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENXIO) } return uintptr(0) } @@ -121244,7 +121244,7 @@ func _netlink_msg_to_nameindex(tls *TLS, pctx uintptr, h uintptr) (r int32) { } /* suppress duplicates */ bucket = index % int32(IFADDRS_HASH_SIZE) - i = *(*uint32)(unsafe.Pointer(ctx + 24 + uintptr(bucket)*4)) + i = **(**uint32)(__ccgo_up(ctx + 24 + uintptr(bucket)*4)) for i != 0 { map1 = (*Tifnameindexctx)(unsafe.Pointer(ctx)).Flist + uintptr(i-uint32(1))*28 if (*Tifnamemap)(unsafe.Pointer(map1)).Findex == Uint32FromInt32(index) && Int32FromUint8((*Tifnamemap)(unsafe.Pointer(map1)).Fnamelen) == namelen && Xmemcmp(tls, map1+9, rta+UintptrFromInt64(4), Uint64FromInt32(namelen)) == 0 { @@ -121273,10 +121273,10 @@ func _netlink_msg_to_nameindex(tls *TLS, pctx uintptr, h uintptr) (r int32) { (*Tifnamemap)(unsafe.Pointer(map1)).Findex = Uint32FromInt32(index) (*Tifnamemap)(unsafe.Pointer(map1)).Fnamelen = Uint8FromInt32(namelen) Xmemcpy(tls, map1+9, rta+UintptrFromInt64(4), Uint64FromInt32(namelen)) - *(*uint32)(unsafe.Pointer(ctx + 8)) += Uint32FromInt32(namelen + int32(1)) + **(**uint32)(__ccgo_up(ctx + 8)) += Uint32FromInt32(namelen + int32(1)) (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum = (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum + 1 - (*Tifnamemap)(unsafe.Pointer(map1)).Fhash_next = *(*uint32)(unsafe.Pointer(ctx + 24 + uintptr(bucket)*4)) - *(*uint32)(unsafe.Pointer(ctx + 24 + uintptr(bucket)*4)) = (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum + (*Tifnamemap)(unsafe.Pointer(map1)).Fhash_next = **(**uint32)(__ccgo_up(ctx + 24 + uintptr(bucket)*4)) + **(**uint32)(__ccgo_up(ctx + 24 + uintptr(bucket)*4)) = (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum return 0 goto _1 _1: @@ -121323,7 +121323,7 @@ func Xif_nameindex(tls *TLS) (r uintptr) { p = p + uintptr((*Tifnamemap)(unsafe.Pointer(s)).Fnamelen) v2 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8(0) + **(**uint8)(__ccgo_up(v2)) = uint8(0) goto _1 _1: ; @@ -121336,9 +121336,9 @@ func Xif_nameindex(tls *TLS) (r uintptr) { goto err err: ; - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 280)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 280)), uintptr(0)) Xfree(tls, (*Tifnameindexctx)(unsafe.Pointer(ctx)).Flist) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOBUFS) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOBUFS) return ifs } @@ -121379,7 +121379,7 @@ func Xinet_addr(tls *TLS, p uintptr) (r Tin_addr_t) { if !(X__inet_aton(tls, p, bp) != 0) { return Uint32FromInt32(-Int32FromInt32(1)) } - return (*(*Tin_addr)(unsafe.Pointer(bp))).Fs_addr + return (**(**Tin_addr)(__ccgo_up(bp))).Fs_addr } func X__inet_aton(tls *TLS, s0 uintptr, dest uintptr) (r int32) { @@ -121396,20 +121396,20 @@ func X__inet_aton(tls *TLS, s0 uintptr, dest uintptr) (r int32) { _, _, _ = d, i, s s = s0 d = dest - *(*[4]uint64)(unsafe.Pointer(bp)) = [4]uint64{} + **(**[4]uint64)(__ccgo_up(bp)) = [4]uint64{} i = 0 for { if !(i < int32(4)) { break } - (*(*[4]uint64)(unsafe.Pointer(bp)))[i] = Xstrtoul(tls, s, bp+32, 0) - if *(*uintptr)(unsafe.Pointer(bp + 32)) == s || *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32))))) != int32('.') || !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + (**(**[4]uint64)(__ccgo_up(bp)))[i] = Xstrtoul(tls, s, bp+32, 0) + if **(**uintptr)(__ccgo_up(bp + 32)) == s || **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 32)))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 32))))) != int32('.') || !(BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return 0 } - if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)))) != 0) { + if !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 32)))) != 0) { break } - s = *(*uintptr)(unsafe.Pointer(bp + 32)) + uintptr(1) + s = **(**uintptr)(__ccgo_up(bp + 32)) + uintptr(1) goto _1 _1: ; @@ -121420,26 +121420,26 @@ func X__inet_aton(tls *TLS, s0 uintptr, dest uintptr) (r int32) { } switch i { case 0: - (*(*[4]uint64)(unsafe.Pointer(bp)))[int32(1)] = (*(*[4]uint64)(unsafe.Pointer(bp)))[0] & uint64(0xffffff) - *(*uint64)(unsafe.Pointer(bp)) >>= uint64(24) + (**(**[4]uint64)(__ccgo_up(bp)))[int32(1)] = (**(**[4]uint64)(__ccgo_up(bp)))[0] & uint64(0xffffff) + **(**uint64)(__ccgo_up(bp)) >>= uint64(24) fallthrough case int32(1): - (*(*[4]uint64)(unsafe.Pointer(bp)))[int32(2)] = (*(*[4]uint64)(unsafe.Pointer(bp)))[int32(1)] & uint64(0xffff) - *(*uint64)(unsafe.Pointer(bp + 1*8)) >>= uint64(16) + (**(**[4]uint64)(__ccgo_up(bp)))[int32(2)] = (**(**[4]uint64)(__ccgo_up(bp)))[int32(1)] & uint64(0xffff) + **(**uint64)(__ccgo_up(bp + 1*8)) >>= uint64(16) fallthrough case int32(2): - (*(*[4]uint64)(unsafe.Pointer(bp)))[int32(3)] = (*(*[4]uint64)(unsafe.Pointer(bp)))[int32(2)] & uint64(0xff) - *(*uint64)(unsafe.Pointer(bp + 2*8)) >>= uint64(8) + (**(**[4]uint64)(__ccgo_up(bp)))[int32(3)] = (**(**[4]uint64)(__ccgo_up(bp)))[int32(2)] & uint64(0xff) + **(**uint64)(__ccgo_up(bp + 2*8)) >>= uint64(8) } i = 0 for { if !(i < int32(4)) { break } - if (*(*[4]uint64)(unsafe.Pointer(bp)))[i] > uint64(255) { + if (**(**[4]uint64)(__ccgo_up(bp)))[i] > uint64(255) { return 0 } - *(*uint8)(unsafe.Pointer(d + uintptr(i))) = uint8((*(*[4]uint64)(unsafe.Pointer(bp)))[i]) + **(**uint8)(__ccgo_up(d + uintptr(i))) = uint8((**(**[4]uint64)(__ccgo_up(bp)))[i]) goto _2 _2: ; @@ -121528,7 +121528,7 @@ func Xinet_ntoa(tls *TLS, _in Tin_addr) (r uintptr) { var a uintptr _ = a a = bp - Xsnprintf(tls, uintptr(unsafe.Pointer(&_buf4)), uint64(16), __ccgo_ts+1080, VaList(bp+16, Int32FromUint8(*(*uint8)(unsafe.Pointer(a))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 1))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 2))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 3))))) + Xsnprintf(tls, uintptr(unsafe.Pointer(&_buf4)), uint64(16), __ccgo_ts+1080, VaList(bp+16, Int32FromUint8(**(**uint8)(__ccgo_up(a))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 1))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 2))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 3))))) return uintptr(unsafe.Pointer(&_buf4)) } @@ -121549,14 +121549,14 @@ func Xinet_ntop(tls *TLS, af int32, a0 uintptr, s uintptr, l Tsocklen_t) (r uint a = a0 switch af { case int32(PF_INET): - if Uint32FromInt32(Xsnprintf(tls, s, uint64(l), __ccgo_ts+1080, VaList(bp+112, Int32FromUint8(*(*uint8)(unsafe.Pointer(a))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 1))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 2))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 3)))))) < l { + if Uint32FromInt32(Xsnprintf(tls, s, uint64(l), __ccgo_ts+1080, VaList(bp+112, Int32FromUint8(**(**uint8)(__ccgo_up(a))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 1))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 2))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 3)))))) < l { return s } case int32(PF_INET6): if Xmemcmp(tls, a, __ccgo_ts+1027, uint64(12)) != 0 { - Xsnprintf(tls, bp, uint64(100), __ccgo_ts+1092, VaList(bp+112, int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 1))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 2)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 3))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 4)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 5))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 6)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 7))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 8)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 9))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 10)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 11))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 12)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 13))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 14)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 15))))) + Xsnprintf(tls, bp, uint64(100), __ccgo_ts+1092, VaList(bp+112, int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 1))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 2)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 3))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 4)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 5))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 6)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 7))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 8)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 9))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 10)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 11))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 12)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 13))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 14)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 15))))) } else { - Xsnprintf(tls, bp, uint64(100), __ccgo_ts+1116, VaList(bp+112, int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 1))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 2)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 3))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 4)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 5))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 6)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 7))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 8)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 9))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 10)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 11))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 12))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 13))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 14))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 15))))) + Xsnprintf(tls, bp, uint64(100), __ccgo_ts+1116, VaList(bp+112, int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 1))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 2)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 3))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 4)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 5))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 6)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 7))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 8)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 9))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 10)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 11))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 12))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 13))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 14))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 15))))) } /* Replace longest /(^0|:)[:0]{2,}/ with "::" */ v2 = Int32FromInt32(0) @@ -121564,10 +121564,10 @@ func Xinet_ntop(tls *TLS, af int32, a0 uintptr, s uintptr, l Tsocklen_t) (r uint i = v2 max = Int32FromInt32(2) for { - if !((*(*[100]uint8)(unsafe.Pointer(bp)))[i] != 0) { + if !((**(**[100]uint8)(__ccgo_up(bp)))[i] != 0) { break } - if i != 0 && Int32FromUint8((*(*[100]uint8)(unsafe.Pointer(bp)))[i]) != int32(':') { + if i != 0 && Int32FromUint8((**(**[100]uint8)(__ccgo_up(bp)))[i]) != int32(':') { goto _1 } j = Int32FromUint64(Xstrspn(tls, bp+uintptr(i), __ccgo_ts+1146)) @@ -121582,8 +121582,8 @@ func Xinet_ntop(tls *TLS, af int32, a0 uintptr, s uintptr, l Tsocklen_t) (r uint } if max > int32(3) { v3 = Uint8FromUint8(':') - (*(*[100]uint8)(unsafe.Pointer(bp)))[best+int32(1)] = v3 - (*(*[100]uint8)(unsafe.Pointer(bp)))[best] = v3 + (**(**[100]uint8)(__ccgo_up(bp)))[best+int32(1)] = v3 + (**(**[100]uint8)(__ccgo_up(bp)))[best] = v3 Xmemmove(tls, bp+uintptr(best)+uintptr(2), bp+uintptr(best)+uintptr(max), Uint64FromInt32(i-best-max+int32(1))) } if _strlen(tls, bp) < uint64(l) { @@ -121591,10 +121591,10 @@ func Xinet_ntop(tls *TLS, af int32, a0 uintptr, s uintptr, l Tsocklen_t) (r uint return s } default: - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EAFNOSUPPORT) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EAFNOSUPPORT) return uintptr(0) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOSPC) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOSPC) return uintptr(0) } @@ -121634,23 +121634,23 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { j = v3 v = v3 for { - if !(j < int32(3) && BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s + uintptr(j))))-uint32('0') < uint32(10)) != 0) { + if !(j < int32(3) && BoolInt32(uint32(**(**uint8)(__ccgo_up(s + uintptr(j))))-uint32('0') < uint32(10)) != 0) { break } - v = int32(10)*v + Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(j)))) - int32('0') + v = int32(10)*v + Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(j)))) - int32('0') goto _2 _2: ; j = j + 1 } - if j == 0 || j > int32(1) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('0') || v > int32(255) { + if j == 0 || j > int32(1) && Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('0') || v > int32(255) { return 0 } - *(*uint8)(unsafe.Pointer(a + uintptr(i))) = Uint8FromInt32(v) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(j)))) == 0 && i == int32(3) { + **(**uint8)(__ccgo_up(a + uintptr(i))) = Uint8FromInt32(v) + if Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(j)))) == 0 && i == int32(3) { return int32(1) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(j)))) != int32('.') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(j)))) != int32('.') { return 0 } s = s + uintptr(j+int32(1)) @@ -121662,25 +121662,25 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { return 0 } else { if af != int32(PF_INET6) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EAFNOSUPPORT) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EAFNOSUPPORT) return -int32(1) } } - if v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32(':'); v5 { + if v5 = Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32(':'); v5 { s = s + 1 v4 = s } - if v5 && Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) != int32(':') { + if v5 && Int32FromUint8(**(**uint8)(__ccgo_up(v4))) != int32(':') { return 0 } i = 0 for { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32(':') && brk < 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32(':') && brk < 0 { brk = i - (*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[i&int32(7)] = uint16(0) + (**(**[8]Tuint16_t)(__ccgo_up(bp)))[i&int32(7)] = uint16(0) s = s + 1 v4 = s - if !(*(*uint8)(unsafe.Pointer(v4)) != 0) { + if !(**(**uint8)(__ccgo_up(v4)) != 0) { break } if i == int32(7) { @@ -121693,7 +121693,7 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { v = v3 for { if v5 = j < int32(4); v5 { - v9 = _hexval(tls, uint32(*(*uint8)(unsafe.Pointer(s + uintptr(j))))) + v9 = _hexval(tls, uint32(**(**uint8)(__ccgo_up(s + uintptr(j))))) d = v9 } if !(v5 && v9 >= 0) { @@ -121708,20 +121708,20 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { if j == 0 { return 0 } - (*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[i&int32(7)] = Uint16FromInt32(v) - if !(*(*uint8)(unsafe.Pointer(s + uintptr(j))) != 0) && (brk >= 0 || i == int32(7)) { + (**(**[8]Tuint16_t)(__ccgo_up(bp)))[i&int32(7)] = Uint16FromInt32(v) + if !(**(**uint8)(__ccgo_up(s + uintptr(j))) != 0) && (brk >= 0 || i == int32(7)) { break } if i == int32(7) { return 0 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(j)))) != int32(':') { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(j)))) != int32('.') || i < int32(6) && brk < 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(j)))) != int32(':') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(j)))) != int32('.') || i < int32(6) && brk < 0 { return 0 } need_v4 = int32(1) i = i + 1 - (*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[i&int32(7)] = uint16(0) + (**(**[8]Tuint16_t)(__ccgo_up(bp)))[i&int32(7)] = uint16(0) break } s = s + uintptr(j+int32(1)) @@ -121737,7 +121737,7 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { if !(j < int32(7)-i) { break } - (*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[brk+j] = uint16(0) + (**(**[8]Tuint16_t)(__ccgo_up(bp)))[brk+j] = uint16(0) goto _12 _12: ; @@ -121751,10 +121751,10 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { } v4 = a a = a + 1 - *(*uint8)(unsafe.Pointer(v4)) = Uint8FromInt32(Int32FromUint16((*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[j]) >> int32(8)) + **(**uint8)(__ccgo_up(v4)) = Uint8FromInt32(Int32FromUint16((**(**[8]Tuint16_t)(__ccgo_up(bp)))[j]) >> int32(8)) v4 = a a = a + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8((*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[j]) + **(**uint8)(__ccgo_up(v4)) = uint8((**(**[8]Tuint16_t)(__ccgo_up(bp)))[j]) goto _13 _13: ; @@ -121817,15 +121817,15 @@ func X__lookup_ipliteral(tls *TLS, buf uintptr, name uintptr, family int32) (r i return -int32(5) } Xmemcpy(tls, buf+8, bp, uint64(4)) - (*(*Taddress)(unsafe.Pointer(buf))).Ffamily = int32(PF_INET) - (*(*Taddress)(unsafe.Pointer(buf))).Fscopeid = uint32(0) + (**(**Taddress)(__ccgo_up(buf))).Ffamily = int32(PF_INET) + (**(**Taddress)(__ccgo_up(buf))).Fscopeid = uint32(0) return int32(1) } p = Xstrchr(tls, name, int32('%')) scopeid = uint64(0) if p != 0 && int64(p)-int64(name) < int64(64) { Xmemcpy(tls, bp+20, name, Uint64FromInt64(int64(p)-int64(name))) - (*(*[64]uint8)(unsafe.Pointer(bp + 20)))[int64(p)-int64(name)] = uint8(0) + (**(**[64]uint8)(__ccgo_up(bp + 20)))[int64(p)-int64(name)] = uint8(0) name = bp + 20 } if Xinet_pton(tls, int32(PF_INET6), name, bp+4) <= 0 { @@ -121835,17 +121835,17 @@ func X__lookup_ipliteral(tls *TLS, buf uintptr, name uintptr, family int32) (r i return -int32(5) } Xmemcpy(tls, buf+8, bp+4, uint64(16)) - (*(*Taddress)(unsafe.Pointer(buf))).Ffamily = int32(PF_INET6) + (**(**Taddress)(__ccgo_up(buf))).Ffamily = int32(PF_INET6) if p != 0 { p = p + 1 v1 = p - if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(v1)))-uint32('0') < uint32(10)) != 0 { + if BoolInt32(uint32(**(**uint8)(__ccgo_up(v1)))-uint32('0') < uint32(10)) != 0 { scopeid = Xstrtoull(tls, p, bp+88, int32(10)) } else { - *(*uintptr)(unsafe.Pointer(bp + 88)) = p - uintptr(1) + **(**uintptr)(__ccgo_up(bp + 88)) = p - uintptr(1) } - if *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 88)))) != 0 { - if !(Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(bp + 4))) == int32(0xfe) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(bp + 4 + 1)))&int32(0xc0) == int32(0x80)) && !(Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(bp + 4))) == int32(0xff) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(bp + 4 + 1)))&int32(0xf) == int32(0x2)) { + if **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 88)))) != 0 { + if !(Int32FromUint8(**(**Tuint8_t)(__ccgo_up(bp + 4))) == int32(0xfe) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(bp + 4 + 1)))&int32(0xc0) == int32(0x80)) && !(Int32FromUint8(**(**Tuint8_t)(__ccgo_up(bp + 4))) == int32(0xff) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(bp + 4 + 1)))&int32(0xf) == int32(0x2)) { return -int32(2) } scopeid = uint64(Xif_nametoindex(tls, p)) @@ -121857,7 +121857,7 @@ func X__lookup_ipliteral(tls *TLS, buf uintptr, name uintptr, family int32) (r i return -int32(2) } } - (*(*Taddress)(unsafe.Pointer(buf))).Fscopeid = uint32(scopeid) + (**(**Taddress)(__ccgo_up(buf))).Fscopeid = uint32(scopeid) return int32(1) } @@ -121881,7 +121881,7 @@ func _is_valid_hostname(tls *TLS, host uintptr) (r int32) { } s = host for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) >= int32(0x80) || Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('.') || Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('-') || Xisalnum(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))) != 0) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(s))) >= int32(0x80) || Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('.') || Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('-') || Xisalnum(tls, Int32FromUint8(**(**uint8)(__ccgo_up(s)))) != 0) { break } goto _1 @@ -121889,7 +121889,7 @@ func _is_valid_hostname(tls *TLS, host uintptr) (r int32) { ; s = s + 1 } - return BoolInt32(!(*(*uint8)(unsafe.Pointer(s)) != 0)) + return BoolInt32(!(**(**uint8)(__ccgo_up(s)) != 0)) } func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags int32) (r int32) { @@ -121903,14 +121903,14 @@ func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags in if family != int32(PF_INET6) { v1 = cnt cnt = cnt + 1 - *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ + **(**Taddress)(__ccgo_up(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET), } } if family != int32(PF_INET) { v1 = cnt cnt = cnt + 1 - *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ + **(**Taddress)(__ccgo_up(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET6), } } @@ -121918,7 +121918,7 @@ func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags in if family != int32(PF_INET6) { v1 = cnt cnt = cnt + 1 - *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ + **(**Taddress)(__ccgo_up(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET), Faddr: [16]Tuint8_t{ 0: uint8(127), @@ -121929,7 +121929,7 @@ func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags in if family != int32(PF_INET) { v1 = cnt cnt = cnt + 1 - *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ + **(**Taddress)(__ccgo_up(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET6), Faddr: [16]Tuint8_t{ 15: uint8(1), @@ -121961,7 +121961,7 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family have_canon = 0 f = X__fopen_rb_ca(tls, __ccgo_ts+1016, bp+1544, bp+512, uint64(1032)) if !(f != 0) { - switch *(*int32)(unsafe.Pointer(X__errno_location(tls))) { + switch **(**int32)(__ccgo_up(X__errno_location(tls))) { case int32(ENOENT): fallthrough case int32(ENOTDIR): @@ -121978,21 +121978,21 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family if v1 != 0 { v2 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8('\n') - *(*uint8)(unsafe.Pointer(p)) = Uint8FromInt32(0) + **(**uint8)(__ccgo_up(v2)) = uint8('\n') + **(**uint8)(__ccgo_up(p)) = Uint8FromInt32(0) } p = bp + uintptr(1) for { v1 = Xstrstr(tls, p, name) p = v1 if v12 = v1 != 0; v12 { - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) + v5 = Int32FromUint8(**(**uint8)(__ccgo_up(p + uintptr(-Int32FromInt32(1))))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _7 _7: ; if v11 = !(v6 != 0); !v11 { - v8 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(l)))) + v8 = Int32FromUint8(**(**uint8)(__ccgo_up(p + uintptr(l)))) v9 = BoolInt32(v8 == int32(' ') || Uint32FromInt32(v8)-uint32('\t') < uint32(5)) goto _10 _10: @@ -122012,8 +122012,8 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family /* Isolate IP address to parse */ p = bp for { - if v11 = *(*uint8)(unsafe.Pointer(p)) != 0; v11 { - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + if v11 = **(**uint8)(__ccgo_up(p)) != 0; v11 { + v5 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _16 _16: @@ -122028,7 +122028,7 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family } v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) switch _name_from_numeric(tls, buf+uintptr(cnt)*28, bp, family) { case int32(1): cnt = cnt + 1 @@ -122043,8 +122043,8 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family } /* Extract first name as canonical name */ for { - if v11 = *(*uint8)(unsafe.Pointer(p)) != 0; v11 { - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + if v11 = **(**uint8)(__ccgo_up(p)) != 0; v11 { + v5 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _22 _22: @@ -122059,8 +122059,8 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family } z = p for { - if v11 = *(*uint8)(unsafe.Pointer(z)) != 0; v11 { - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(z))) + if v11 = **(**uint8)(__ccgo_up(z)) != 0; v11 { + v5 = Int32FromUint8(**(**uint8)(__ccgo_up(z))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _27 _27: @@ -122073,7 +122073,7 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family ; z = z + 1 } - *(*uint8)(unsafe.Pointer(z)) = uint8(0) + **(**uint8)(__ccgo_up(z)) = uint8(0) if _is_valid_hostname(tls, p) != 0 { have_canon = int32(1) Xmemcpy(tls, canon, p, Uint64FromInt64(int64(z)-int64(p)+int64(1))) @@ -122128,8 +122128,8 @@ func _dns_parse_callback1(tls *TLS, c uintptr, rr int32, data uintptr, len1 int3 family = int32(PF_INET6) break } - (*(*Taddress)(unsafe.Pointer((*Tdpc_ctx)(unsafe.Pointer(ctx)).Faddrs + uintptr((*Tdpc_ctx)(unsafe.Pointer(ctx)).Fcnt)*28))).Ffamily = family - (*(*Taddress)(unsafe.Pointer((*Tdpc_ctx)(unsafe.Pointer(ctx)).Faddrs + uintptr((*Tdpc_ctx)(unsafe.Pointer(ctx)).Fcnt)*28))).Fscopeid = uint32(0) + (**(**Taddress)(__ccgo_up((*Tdpc_ctx)(unsafe.Pointer(ctx)).Faddrs + uintptr((*Tdpc_ctx)(unsafe.Pointer(ctx)).Fcnt)*28))).Ffamily = family + (**(**Taddress)(__ccgo_up((*Tdpc_ctx)(unsafe.Pointer(ctx)).Faddrs + uintptr((*Tdpc_ctx)(unsafe.Pointer(ctx)).Fcnt)*28))).Fscopeid = uint32(0) v2 = ctx + 16 v1 = *(*int32)(unsafe.Pointer(v2)) *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) + 1 @@ -122150,16 +122150,16 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i var _ /* qlens at bp+10192 */ [2]int32 var _ /* qp at bp+10160 */ [2]uintptr _, _, _ = i, nq, qtypes - *(*[2]uintptr)(unsafe.Pointer(bp + 10160)) = [2]uintptr{ + **(**[2]uintptr)(__ccgo_up(bp + 10160)) = [2]uintptr{ 0: bp, 1: bp + 1*280, } - *(*[2]uintptr)(unsafe.Pointer(bp + 10176)) = [2]uintptr{ + **(**[2]uintptr)(__ccgo_up(bp + 10176)) = [2]uintptr{ 0: bp + 560, 1: bp + 560 + 1*4800, } nq = 0 - *(*Tdpc_ctx)(unsafe.Pointer(bp + 10208)) = Tdpc_ctx{ + **(**Tdpc_ctx)(__ccgo_up(bp + 10208)) = Tdpc_ctx{ Faddrs: buf, Fcanon: canon, } @@ -122169,15 +122169,15 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i break } if family != _afrr[i].Faf { - (*(*[2]int32)(unsafe.Pointer(bp + 10192)))[nq] = X__res_mkquery(tls, 0, name, int32(1), _afrr[i].Frr, uintptr(0), 0, uintptr(0), bp+uintptr(nq)*280, int32(280)) - if (*(*[2]int32)(unsafe.Pointer(bp + 10192)))[nq] == -int32(1) { + (**(**[2]int32)(__ccgo_up(bp + 10192)))[nq] = X__res_mkquery(tls, 0, name, int32(1), _afrr[i].Frr, uintptr(0), 0, uintptr(0), bp+uintptr(nq)*280, int32(280)) + if (**(**[2]int32)(__ccgo_up(bp + 10192)))[nq] == -int32(1) { return 0 } qtypes[nq] = _afrr[i].Frr - *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280 + 3)) = uint8(0) /* don't need AD flag */ + **(**uint8)(__ccgo_up(bp + uintptr(nq)*280 + 3)) = uint8(0) /* don't need AD flag */ /* Ensure query IDs are distinct. */ - if nq != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) { - *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280)) = *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280)) + 1 + if nq != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(bp + uintptr(nq)*280))) == Int32FromUint8(**(**uint8)(__ccgo_up(bp))) { + **(**uint8)(__ccgo_up(bp + uintptr(nq)*280)) = **(**uint8)(__ccgo_up(bp + uintptr(nq)*280)) + 1 } nq = nq + 1 } @@ -122194,13 +122194,13 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if !(i < nq) { break } - if (*(*[2]int32)(unsafe.Pointer(bp + 10200)))[i] < int32(4) || Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + 560 + uintptr(i)*4800 + 3)))&int32(15) == int32(2) { + if (**(**[2]int32)(__ccgo_up(bp + 10200)))[i] < int32(4) || Int32FromUint8(**(**uint8)(__ccgo_up(bp + 560 + uintptr(i)*4800 + 3)))&int32(15) == int32(2) { return -int32(3) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + 560 + uintptr(i)*4800 + 3)))&int32(15) == int32(3) { + if Int32FromUint8(**(**uint8)(__ccgo_up(bp + 560 + uintptr(i)*4800 + 3)))&int32(15) == int32(3) { return 0 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + 560 + uintptr(i)*4800 + 3)))&int32(15) != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(bp + 560 + uintptr(i)*4800 + 3)))&int32(15) != 0 { return -int32(4) } goto _2 @@ -122213,18 +122213,18 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if !(i >= 0) { break } - (*(*Tdpc_ctx)(unsafe.Pointer(bp + 10208))).Frrtype = qtypes[i] - if Uint64FromInt32((*(*[2]int32)(unsafe.Pointer(bp + 10200)))[i]) > uint64(4800) { - (*(*[2]int32)(unsafe.Pointer(bp + 10200)))[i] = int32(4800) + (**(**Tdpc_ctx)(__ccgo_up(bp + 10208))).Frrtype = qtypes[i] + if Uint64FromInt32((**(**[2]int32)(__ccgo_up(bp + 10200)))[i]) > uint64(4800) { + (**(**[2]int32)(__ccgo_up(bp + 10200)))[i] = int32(4800) } - X__dns_parse(tls, bp+560+uintptr(i)*4800, (*(*[2]int32)(unsafe.Pointer(bp + 10200)))[i], __ccgo_fp(_dns_parse_callback1), bp+10208) + X__dns_parse(tls, bp+560+uintptr(i)*4800, (**(**[2]int32)(__ccgo_up(bp + 10200)))[i], __ccgo_fp(_dns_parse_callback1), bp+10208) goto _3 _3: ; i = i - 1 } - if (*(*Tdpc_ctx)(unsafe.Pointer(bp + 10208))).Fcnt != 0 { - return (*(*Tdpc_ctx)(unsafe.Pointer(bp + 10208))).Fcnt + if (**(**Tdpc_ctx)(__ccgo_up(bp + 10208))).Fcnt != 0 { + return (**(**Tdpc_ctx)(__ccgo_up(bp + 10208))).Fcnt } return -int32(5) } @@ -122262,10 +122262,10 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f l = v2 dots = v2 for { - if !(*(*uint8)(unsafe.Pointer(name + uintptr(l))) != 0) { + if !(**(**uint8)(__ccgo_up(name + uintptr(l))) != 0) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(name + uintptr(l)))) == int32('.') { + if Int32FromUint8(**(**uint8)(__ccgo_up(name + uintptr(l)))) == int32('.') { dots = dots + 1 } goto _1 @@ -122273,14 +122273,14 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f ; l = l + 1 } - if dots >= uint64((*(*Tresolvconf)(unsafe.Pointer(bp + 256))).Fndots) || Int32FromUint8(*(*uint8)(unsafe.Pointer(name + uintptr(l-uint64(1))))) == int32('.') { - *(*uint8)(unsafe.Pointer(bp)) = uint8(0) + if dots >= uint64((**(**Tresolvconf)(__ccgo_up(bp + 256))).Fndots) || Int32FromUint8(**(**uint8)(__ccgo_up(name + uintptr(l-uint64(1))))) == int32('.') { + **(**uint8)(__ccgo_up(bp)) = uint8(0) } /* Strip final dot for canon, fail if multiple trailing dots. */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(name + uintptr(l-uint64(1))))) == int32('.') { + if Int32FromUint8(**(**uint8)(__ccgo_up(name + uintptr(l-uint64(1))))) == int32('.') { l = l - 1 } - if !(l != 0) || Int32FromUint8(*(*uint8)(unsafe.Pointer(name + uintptr(l-uint64(1))))) == int32('.') { + if !(l != 0) || Int32FromUint8(**(**uint8)(__ccgo_up(name + uintptr(l-uint64(1))))) == int32('.') { return -int32(2) } /* This can never happen; the caller already checked length. */ @@ -122292,14 +122292,14 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f * name is not a CNAME record) and serves as a buffer for passing * the full requested name to name_from_dns. */ Xmemcpy(tls, canon, name, l) - *(*uint8)(unsafe.Pointer(canon + uintptr(l))) = uint8('.') + **(**uint8)(__ccgo_up(canon + uintptr(l))) = uint8('.') p = bp for { - if !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if !(**(**uint8)(__ccgo_up(p)) != 0) { break } for { - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v5 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _7 _7: @@ -122313,8 +122313,8 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f } z = p for { - if v12 = *(*uint8)(unsafe.Pointer(z)) != 0; v12 { - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(z))) + if v12 = **(**uint8)(__ccgo_up(z)) != 0; v12 { + v5 = Int32FromUint8(**(**uint8)(__ccgo_up(z))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _11 _11: @@ -122332,7 +122332,7 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f } if Uint64FromInt64(int64(z)-int64(p)) < uint64(256)-l-uint64(1) { Xmemcpy(tls, canon+uintptr(l)+uintptr(1), p, Uint64FromInt64(int64(z)-int64(p))) - *(*uint8)(unsafe.Pointer(canon + uintptr(Uint64FromInt64(int64(z)-int64(p)+int64(1))+l))) = uint8(0) + **(**uint8)(__ccgo_up(canon + uintptr(Uint64FromInt64(int64(z)-int64(p)+int64(1))+l))) = uint8(0) cnt = _name_from_dns(tls, buf, canon, canon, family, bp+256) if cnt != 0 { return cnt @@ -122343,7 +122343,7 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f ; p = z } - *(*uint8)(unsafe.Pointer(canon + uintptr(l))) = uint8(0) + **(**uint8)(__ccgo_up(canon + uintptr(l))) = uint8(0) return _name_from_dns(tls, buf, canon, name, family, bp+256) } @@ -122404,7 +122404,7 @@ func _policyof(tls *TLS, a uintptr) (r uintptr) { if Xmemcmp(tls, a, uintptr(unsafe.Pointer(&_defpolicy))+uintptr(i)*20, uint64(_defpolicy[i].Flen1)) != 0 { goto _1 } - if Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + uintptr(_defpolicy[i].Flen1))))&Int32FromUint8(_defpolicy[i].Fmask) != Int32FromUint8(*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_defpolicy)) + uintptr(i)*20 + uintptr(_defpolicy[i].Flen1)))) { + if Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + uintptr(_defpolicy[i].Flen1))))&Int32FromUint8(_defpolicy[i].Fmask) != Int32FromUint8(**(**uint8)(__ccgo_up(uintptr(unsafe.Pointer(&_defpolicy)) + uintptr(i)*20 + uintptr(_defpolicy[i].Flen1)))) { goto _1 } return uintptr(unsafe.Pointer(&_defpolicy)) + uintptr(i)*20 @@ -122421,16 +122421,16 @@ func _labelof(tls *TLS, a uintptr) (r int32) { } func _scopeof(tls *TLS, a uintptr) (r int32) { - if Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a))) == int32(0xff) { - return Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 1))) & int32(15) + if Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a))) == int32(0xff) { + return Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 1))) & int32(15) } - if Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a))) == int32(0xfe) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 1)))&int32(0xc0) == int32(0x80) { + if Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a))) == int32(0xfe) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 1)))&int32(0xc0) == int32(0x80) { return int32(2) } - if *(*Tuint32_t)(unsafe.Pointer(a)) == uint32(0) && *(*Tuint32_t)(unsafe.Pointer(a + 1*4)) == uint32(0) && *(*Tuint32_t)(unsafe.Pointer(a + 2*4)) == uint32(0) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 12))) == 0 && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 13))) == 0 && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 14))) == 0 && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 15))) == int32(1) { + if **(**Tuint32_t)(__ccgo_up(a)) == uint32(0) && **(**Tuint32_t)(__ccgo_up(a + 1*4)) == uint32(0) && **(**Tuint32_t)(__ccgo_up(a + 2*4)) == uint32(0) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 12))) == 0 && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 13))) == 0 && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 14))) == 0 && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 15))) == int32(1) { return int32(2) } - if Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a))) == int32(0xfe) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 1)))&int32(0xc0) == int32(0xc0) { + if Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a))) == int32(0xfe) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 1)))&int32(0xc0) == int32(0xc0) { return int32(5) } return int32(14) @@ -122441,7 +122441,7 @@ func _prefixmatch(tls *TLS, s uintptr, d uintptr) (r int32) { _ = i i = uint32(0) for { - if !(i < uint32(128) && !((Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(s + uintptr(i/uint32(8)))))^Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(d + uintptr(i/uint32(8))))))&(Int32FromInt32(128)>>(i%Uint32FromInt32(8))) != 0)) { + if !(i < uint32(128) && !((Int32FromUint8(**(**Tuint8_t)(__ccgo_up(s + uintptr(i/uint32(8)))))^Int32FromUint8(**(**Tuint8_t)(__ccgo_up(d + uintptr(i/uint32(8))))))&(Int32FromInt32(128)>>(i%Uint32FromInt32(8))) != 0)) { break } goto _1 @@ -122479,7 +122479,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i var _ /* salen at bp+92 */ Tsocklen_t _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cnt, da, dalen, dlabel, dpolicy, dprec, dscope, family1, fd, i, j, key, l, prefixlen, sa, v1 cnt = 0 - *(*uint8)(unsafe.Pointer(canon)) = uint8(0) + **(**uint8)(__ccgo_up(canon)) = uint8(0) if name != 0 { /* reject empty name and check len so it fits into temp bufs */ l = Xstrnlen(tls, name, uint64(255)) @@ -122523,7 +122523,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i /* If any v6 results exist, remove v4 results. */ i = 0 for { - if !(i < cnt && (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily != int32(PF_INET6)) { + if !(i < cnt && (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Ffamily != int32(PF_INET6)) { break } goto _2 @@ -122537,10 +122537,10 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if !(i < cnt) { break } - if (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily == int32(PF_INET6) { + if (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Ffamily == int32(PF_INET6) { v1 = j j = j + 1 - *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = *(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28)) + **(**Taddress)(__ccgo_up(buf + uintptr(v1)*28)) = **(**Taddress)(__ccgo_up(buf + uintptr(i)*28)) } goto _3 _3: @@ -122558,12 +122558,12 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if !(i < cnt) { break } - if (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily != int32(PF_INET) { + if (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Ffamily != int32(PF_INET) { goto _6 } Xmemcpy(tls, buf+uintptr(i)*28+8+uintptr(12), buf+uintptr(i)*28+8, uint64(4)) Xmemcpy(tls, buf+uintptr(i)*28+8, __ccgo_ts+1027, uint64(12)) - (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily = int32(PF_INET6) + (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Ffamily = int32(PF_INET6) goto _6 _6: ; @@ -122580,7 +122580,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if !(i < cnt) { break } - if (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily != int32(PF_INET) { + if (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Ffamily != int32(PF_INET) { break } goto _7 @@ -122602,16 +122602,16 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if !(i < cnt) { break } - family1 = (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily + family1 = (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Ffamily key = 0 - *(*Tsockaddr_in6)(unsafe.Pointer(bp + 4)) = Tsockaddr_in6{} - *(*Tsockaddr_in6)(unsafe.Pointer(bp + 32)) = Tsockaddr_in6{ + **(**Tsockaddr_in6)(__ccgo_up(bp + 4)) = Tsockaddr_in6{} + **(**Tsockaddr_in6)(__ccgo_up(bp + 32)) = Tsockaddr_in6{ Fsin6_family: uint16(PF_INET6), Fsin6_port: uint16(65535), - Fsin6_scope_id: (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Fscopeid, + Fsin6_scope_id: (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Fscopeid, } - *(*Tsockaddr_in)(unsafe.Pointer(bp + 60)) = Tsockaddr_in{} - *(*Tsockaddr_in)(unsafe.Pointer(bp + 76)) = Tsockaddr_in{ + **(**Tsockaddr_in)(__ccgo_up(bp + 60)) = Tsockaddr_in{} + **(**Tsockaddr_in)(__ccgo_up(bp + 76)) = Tsockaddr_in{ Fsin_family: uint16(PF_INET), Fsin_port: uint16(65535), } @@ -122620,7 +122620,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i da = bp + 32 dalen = uint32(28) sa = bp + 4 - *(*Tsocklen_t)(unsafe.Pointer(bp + 92)) = uint32(28) + **(**Tsocklen_t)(__ccgo_up(bp + 92)) = uint32(28) } else { Xmemcpy(tls, bp+4+8, __ccgo_ts+1027, uint64(12)) Xmemcpy(tls, bp+32+8+uintptr(12), buf+uintptr(i)*28+8, uint64(4)) @@ -122630,7 +122630,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i da = bp + 76 dalen = uint32(16) sa = bp + 60 - *(*Tsocklen_t)(unsafe.Pointer(bp + 92)) = uint32(16) + **(**Tsocklen_t)(__ccgo_up(bp + 92)) = uint32(16) } dpolicy = _policyof(tls, bp+32+8) dscope = _scopeof(tls, bp+32+8) @@ -122660,14 +122660,14 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i key = key | (int32(15)-dscope)< uint64(65535) { return -int32(8) } if proto != int32(IPPROTO_UDP) { - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fport = uint16(port) - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_STREAM) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fport = uint16(port) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_STREAM) v1 = cnt cnt = cnt + 1 - (*(*Tservice)(unsafe.Pointer(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_TCP) + (**(**Tservice)(__ccgo_up(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_TCP) } if proto != int32(IPPROTO_TCP) { - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fport = uint16(port) - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_DGRAM) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fport = uint16(port) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_DGRAM) v1 = cnt cnt = cnt + 1 - (*(*Tservice)(unsafe.Pointer(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_UDP) + (**(**Tservice)(__ccgo_up(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_UDP) } return cnt } @@ -122753,7 +122753,7 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i l = _strlen(tls, name) f = X__fopen_rb_ca(tls, __ccgo_ts+1040, bp+1168, bp+136, uint64(1032)) if !(f != 0) { - switch *(*int32)(unsafe.Pointer(X__errno_location(tls))) { + switch **(**int32)(__ccgo_up(X__errno_location(tls))) { case int32(ENOENT): fallthrough case int32(ENOTDIR): @@ -122770,8 +122770,8 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i if v3 != 0 { v4 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8('\n') - *(*uint8)(unsafe.Pointer(p)) = Uint8FromInt32(0) + **(**uint8)(__ccgo_up(v4)) = uint8('\n') + **(**uint8)(__ccgo_up(p)) = Uint8FromInt32(0) } /* Find service name */ p = bp @@ -122782,7 +122782,7 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i break } if v10 = p > bp; v10 { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(p + uintptr(-Int32FromInt32(1))))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _9 _9: @@ -122790,8 +122790,8 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i if v10 && !(v2 != 0) { goto _5 } - if v10 = *(*uint8)(unsafe.Pointer(p + uintptr(l))) != 0; v10 { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(l)))) + if v10 = **(**uint8)(__ccgo_up(p + uintptr(l))) != 0; v10 { + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(p + uintptr(l)))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _13 _13: @@ -122811,8 +122811,8 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i /* Skip past canonical name at beginning of line */ p = bp for { - if v10 = *(*uint8)(unsafe.Pointer(p)) != 0; v10 { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + if v10 = **(**uint8)(__ccgo_up(p)) != 0; v10 { + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _18 _18: @@ -122826,28 +122826,28 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i p = p + 1 } port = Xstrtoul(tls, p, bp+128, int32(10)) - if port > uint64(65535) || *(*uintptr)(unsafe.Pointer(bp + 128)) == p { + if port > uint64(65535) || **(**uintptr)(__ccgo_up(bp + 128)) == p { continue } - if !(Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(bp + 128)), __ccgo_ts+1054, uint64(4)) != 0) { + if !(Xstrncmp(tls, **(**uintptr)(__ccgo_up(bp + 128)), __ccgo_ts+1054, uint64(4)) != 0) { if proto == int32(IPPROTO_TCP) { continue } - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fport = uint16(port) - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_DGRAM) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fport = uint16(port) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_DGRAM) v1 = cnt cnt = cnt + 1 - (*(*Tservice)(unsafe.Pointer(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_UDP) + (**(**Tservice)(__ccgo_up(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_UDP) } - if !(Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(bp + 128)), __ccgo_ts+1059, uint64(4)) != 0) { + if !(Xstrncmp(tls, **(**uintptr)(__ccgo_up(bp + 128)), __ccgo_ts+1059, uint64(4)) != 0) { if proto == int32(IPPROTO_UDP) { continue } - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fport = uint16(port) - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_STREAM) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fport = uint16(port) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_STREAM) v1 = cnt cnt = cnt + 1 - (*(*Tservice)(unsafe.Pointer(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_TCP) + (**(**Tservice)(__ccgo_up(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_TCP) } } X__fclose_ca(tls, f) @@ -122877,58 +122877,58 @@ func ___netlink_enumerate(tls *TLS, fd int32, seq uint32, type1 int32, af int32, (*(*struct { Fnlh Tnlmsghdr Fg Trtgenmsg - })(unsafe.Pointer(&*(*struct { + })(unsafe.Pointer(&**(**struct { Freq [0]struct { Fnlh Tnlmsghdr Fg Trtgenmsg } Freply [0]Tnlmsghdr Fbuf [8192]Tuint8_t - })(unsafe.Pointer(bp))))).Fnlh.Fnlmsg_len = uint32(20) + })(__ccgo_up(bp))))).Fnlh.Fnlmsg_len = uint32(20) (*(*struct { Fnlh Tnlmsghdr Fg Trtgenmsg - })(unsafe.Pointer(&*(*struct { + })(unsafe.Pointer(&**(**struct { Freq [0]struct { Fnlh Tnlmsghdr Fg Trtgenmsg } Freply [0]Tnlmsghdr Fbuf [8192]Tuint8_t - })(unsafe.Pointer(bp))))).Fnlh.Fnlmsg_type = Uint16FromInt32(type1) + })(__ccgo_up(bp))))).Fnlh.Fnlmsg_type = Uint16FromInt32(type1) (*(*struct { Fnlh Tnlmsghdr Fg Trtgenmsg - })(unsafe.Pointer(&*(*struct { + })(unsafe.Pointer(&**(**struct { Freq [0]struct { Fnlh Tnlmsghdr Fg Trtgenmsg } Freply [0]Tnlmsghdr Fbuf [8192]Tuint8_t - })(unsafe.Pointer(bp))))).Fnlh.Fnlmsg_flags = Uint16FromInt32(Int32FromInt32(NLM_F_ROOT) | Int32FromInt32(NLM_F_MATCH) | Int32FromInt32(NLM_F_REQUEST)) + })(__ccgo_up(bp))))).Fnlh.Fnlmsg_flags = Uint16FromInt32(Int32FromInt32(NLM_F_ROOT) | Int32FromInt32(NLM_F_MATCH) | Int32FromInt32(NLM_F_REQUEST)) (*(*struct { Fnlh Tnlmsghdr Fg Trtgenmsg - })(unsafe.Pointer(&*(*struct { + })(unsafe.Pointer(&**(**struct { Freq [0]struct { Fnlh Tnlmsghdr Fg Trtgenmsg } Freply [0]Tnlmsghdr Fbuf [8192]Tuint8_t - })(unsafe.Pointer(bp))))).Fnlh.Fnlmsg_seq = seq + })(__ccgo_up(bp))))).Fnlh.Fnlmsg_seq = seq (*(*struct { Fnlh Tnlmsghdr Fg Trtgenmsg - })(unsafe.Pointer(&*(*struct { + })(unsafe.Pointer(&**(**struct { Freq [0]struct { Fnlh Tnlmsghdr Fg Trtgenmsg } Freply [0]Tnlmsghdr Fbuf [8192]Tuint8_t - })(unsafe.Pointer(bp))))).Fg.Frtgen_family = Uint8FromInt32(af) + })(__ccgo_up(bp))))).Fg.Frtgen_family = Uint8FromInt32(af) r = int32(Xsend(tls, fd, bp, uint64(20), 0)) if r < 0 { return r @@ -123004,7 +123004,7 @@ func Xns_get16(tls *TLS, cp uintptr) (r uint32) { trc("tls=%v cp=%v, (%v:)", tls, cp, origin(2)) defer func() { trc("-> %v", r) }() } - return Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(cp)))< %v", r) }() } - return uint64(uint32(*(*uint8)(unsafe.Pointer(cp)))<> int32(8)) + **(**uint8)(__ccgo_up(v1)) = uint8(s >> int32(8)) v1 = cp cp = cp + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(s) + **(**uint8)(__ccgo_up(v1)) = uint8(s) } func Xns_put32(tls *TLS, l uint64, cp uintptr) { @@ -123037,16 +123037,16 @@ func Xns_put32(tls *TLS, l uint64, cp uintptr) { _ = v1 v1 = cp cp = cp + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(l >> int32(24)) + **(**uint8)(__ccgo_up(v1)) = uint8(l >> int32(24)) v1 = cp cp = cp + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(l >> int32(16)) + **(**uint8)(__ccgo_up(v1)) = uint8(l >> int32(16)) v1 = cp cp = cp + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(l >> int32(8)) + **(**uint8)(__ccgo_up(v1)) = uint8(l >> int32(8)) v1 = cp cp = cp + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(l) + **(**uint8)(__ccgo_up(v1)) = uint8(l) } func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int32) { @@ -123071,7 +123071,7 @@ func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int3 break } msg = msg + uintptr(2) - *(*Tuint16_t)(unsafe.Pointer(handle + 20 + uintptr(i)*2)) = uint16(Xns_get16(tls, msg-uintptr(2))) + **(**Tuint16_t)(__ccgo_up(handle + 20 + uintptr(i)*2)) = uint16(Xns_get16(tls, msg-uintptr(2))) goto _1 _1: ; @@ -123082,15 +123082,15 @@ func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int3 if !(i < int32(_ns_s_max)) { break } - if *(*Tuint16_t)(unsafe.Pointer(handle + 20 + uintptr(i)*2)) != 0 { - *(*uintptr)(unsafe.Pointer(handle + 32 + uintptr(i)*8)) = msg - r = Xns_skiprr(tls, msg, (*Tns_msg)(unsafe.Pointer(handle)).F_eom, i, Int32FromUint16(*(*Tuint16_t)(unsafe.Pointer(handle + 20 + uintptr(i)*2)))) + if **(**Tuint16_t)(__ccgo_up(handle + 20 + uintptr(i)*2)) != 0 { + **(**uintptr)(__ccgo_up(handle + 32 + uintptr(i)*8)) = msg + r = Xns_skiprr(tls, msg, (*Tns_msg)(unsafe.Pointer(handle)).F_eom, i, Int32FromUint16(**(**Tuint16_t)(__ccgo_up(handle + 20 + uintptr(i)*2)))) if r < 0 { return -int32(1) } msg = msg + uintptr(r) } else { - *(*uintptr)(unsafe.Pointer(handle + 32 + uintptr(i)*8)) = UintptrFromInt32(0) + **(**uintptr)(__ccgo_up(handle + 32 + uintptr(i)*8)) = UintptrFromInt32(0) } goto _2 _2: @@ -123107,7 +123107,7 @@ func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int3 goto bad bad: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EMSGSIZE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EMSGSIZE) return -int32(1) } @@ -123151,7 +123151,7 @@ func Xns_skiprr(tls *TLS, ptr uintptr, eom uintptr, section Tns_sect, count int3 goto bad bad: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EMSGSIZE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EMSGSIZE) return -int32(1) } @@ -123169,31 +123169,31 @@ func Xns_parserr(tls *TLS, handle uintptr, section Tns_sect, rrnum int32, rr uin if section != (*Tns_msg)(unsafe.Pointer(handle)).F_sect { (*Tns_msg)(unsafe.Pointer(handle)).F_sect = section (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum = 0 - (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr = *(*uintptr)(unsafe.Pointer(handle + 32 + uintptr(section)*8)) + (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr = **(**uintptr)(__ccgo_up(handle + 32 + uintptr(section)*8)) } if rrnum == -int32(1) { rrnum = (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum } - if rrnum < 0 || rrnum >= Int32FromUint16(*(*Tuint16_t)(unsafe.Pointer(handle + 20 + uintptr(section)*2))) { + if rrnum < 0 || rrnum >= Int32FromUint16(**(**Tuint16_t)(__ccgo_up(handle + 20 + uintptr(section)*2))) { goto bad } if rrnum < (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum { (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum = 0 - (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr = *(*uintptr)(unsafe.Pointer(handle + 32 + uintptr(section)*8)) + (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr = **(**uintptr)(__ccgo_up(handle + 32 + uintptr(section)*8)) } if rrnum > (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum { r = Xns_skiprr(tls, (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr, (*Tns_msg)(unsafe.Pointer(handle)).F_eom, section, rrnum-(*Tns_msg)(unsafe.Pointer(handle)).F_rrnum) if r < 0 { return -int32(1) } - *(*uintptr)(unsafe.Pointer(handle + 72)) += uintptr(r) + **(**uintptr)(__ccgo_up(handle + 72)) += uintptr(r) (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum = rrnum } r = Xns_name_uncompress(tls, (*Tns_msg)(unsafe.Pointer(handle)).F_msg, (*Tns_msg)(unsafe.Pointer(handle)).F_eom, (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr, rr, uint64(NS_MAXDNAME)) if r < 0 { return -int32(1) } - *(*uintptr)(unsafe.Pointer(handle + 72)) += uintptr(r) + **(**uintptr)(__ccgo_up(handle + 72)) += uintptr(r) if int64(Int32FromInt32(2)*Int32FromInt32(NS_INT16SZ)) > int64((*Tns_msg)(unsafe.Pointer(handle)).F_eom)-int64((*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr) { goto size } @@ -123217,14 +123217,14 @@ func Xns_parserr(tls *TLS, handle uintptr, section Tns_sect, rrnum int32, rr uin goto size } (*Tns_rr)(unsafe.Pointer(rr)).Frdata = (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr - *(*uintptr)(unsafe.Pointer(handle + 72)) += uintptr((*Tns_rr)(unsafe.Pointer(rr)).Frdlength) + **(**uintptr)(__ccgo_up(handle + 72)) += uintptr((*Tns_rr)(unsafe.Pointer(rr)).Frdlength) } else { (*Tns_rr)(unsafe.Pointer(rr)).Fttl = uint32(0) (*Tns_rr)(unsafe.Pointer(rr)).Frdlength = uint16(0) (*Tns_rr)(unsafe.Pointer(rr)).Frdata = UintptrFromInt32(0) } (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum = (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum + 1 - if (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum > Int32FromUint16(*(*Tuint16_t)(unsafe.Pointer(handle + 20 + uintptr(section)*2))) { + if (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum > Int32FromUint16(**(**Tuint16_t)(__ccgo_up(handle + 20 + uintptr(section)*2))) { (*Tns_msg)(unsafe.Pointer(handle)).F_sect = section + int32(1) if (*Tns_msg)(unsafe.Pointer(handle)).F_sect == int32(_ns_s_max) { (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum = -int32(1) @@ -123237,12 +123237,12 @@ func Xns_parserr(tls *TLS, handle uintptr, section Tns_sect, rrnum int32, rr uin goto bad bad: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENODEV) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENODEV) return -int32(1) goto size size: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EMSGSIZE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EMSGSIZE) return -int32(1) } @@ -123255,7 +123255,7 @@ func Xns_name_uncompress(tls *TLS, msg uintptr, eom uintptr, src uintptr, dst ui _ = r r = Xdn_expand(tls, msg, eom, src, dst, Int32FromUint64(dstsiz)) if r < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EMSGSIZE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EMSGSIZE) } return r } @@ -123500,9 +123500,9 @@ func X__convert_scm_timestamps(tls *TLS, msg uintptr, csize Tsocklen_t) { common: ; Xmemcpy(tls, bp, cmsg+UintptrFromInt32(1)*16, uint64(8)) - (*(*[2]int64)(unsafe.Pointer(bp + 8)))[0] = *(*int64)(unsafe.Pointer(bp)) + (**(**[2]int64)(__ccgo_up(bp + 8)))[0] = int64(**(**int64)(__ccgo_up(bp))) Xmemcpy(tls, bp, cmsg+UintptrFromInt32(1)*16+uintptr(8), uint64(8)) - (*(*[2]int64)(unsafe.Pointer(bp + 8)))[int32(1)] = *(*int64)(unsafe.Pointer(bp)) + (**(**[2]int64)(__ccgo_up(bp + 8)))[int32(1)] = int64(**(**int64)(__ccgo_up(bp))) goto _5 _5: } @@ -123521,7 +123521,7 @@ func X__convert_scm_timestamps(tls *TLS, msg uintptr, csize Tsocklen_t) { return } if (Uint64FromInt64(16)+Uint64FromInt64(8)-Uint64FromInt32(1)) & ^(Uint64FromInt64(8)-Uint64FromInt32(1)) + (Uint64FromInt64(16)+Uint64FromInt64(8)-Uint64FromInt32(1)) & ^(Uint64FromInt64(8)-Uint64FromInt32(1)) > uint64(csize-(*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_controllen) { - *(*int32)(unsafe.Pointer(msg + 48)) |= int32(MSG_CTRUNC) + **(**int32)(__ccgo_up(msg + 48)) |= int32(MSG_CTRUNC) return } v2 = msg + 40 @@ -123556,10 +123556,10 @@ func Xrecvmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r2 Tssize_t) { orig_controllen = (*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_controllen orig = msg if msg != 0 { - *(*Tmsghdr)(unsafe.Pointer(bp)) = *(*Tmsghdr)(unsafe.Pointer(msg)) + **(**Tmsghdr)(__ccgo_up(bp)) = **(**Tmsghdr)(__ccgo_up(msg)) v1 = Int32FromInt32(0) - (*(*Tmsghdr)(unsafe.Pointer(bp))).F__pad2 = v1 - (*(*Tmsghdr)(unsafe.Pointer(bp))).F__pad1 = v1 + (**(**Tmsghdr)(__ccgo_up(bp))).F__pad2 = v1 + (**(**Tmsghdr)(__ccgo_up(bp))).F__pad1 = v1 msg = bp } v1 = int32(SYS_recvmsg) @@ -123587,7 +123587,7 @@ _10: X__convert_scm_timestamps(tls, msg, orig_controllen) } if orig != 0 { - *(*Tmsghdr)(unsafe.Pointer(orig)) = *(*Tmsghdr)(unsafe.Pointer(bp)) + **(**Tmsghdr)(__ccgo_up(orig)) = **(**Tmsghdr)(__ccgo_up(bp)) } return r1 } @@ -123613,10 +123613,10 @@ func X__res_mkquery(tls *TLS, op int32, dname uintptr, class int32, type1 int32, var _ /* ts at bp+280 */ Ttimespec _, _, _, _, _ = i, id, j, l, n l = Xstrnlen(tls, dname, uint64(255)) - if l != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(dname + uintptr(l-uint64(1))))) == int32('.') { + if l != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(dname + uintptr(l-uint64(1))))) == int32('.') { l = l - 1 } - if l != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(dname + uintptr(l-uint64(1))))) == int32('.') { + if l != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(dname + uintptr(l-uint64(1))))) == int32('.') { return -int32(1) } n = Int32FromUint64(uint64(17) + l + BoolUint64(!!(l != 0))) @@ -123625,18 +123625,18 @@ func X__res_mkquery(tls *TLS, op int32, dname uintptr, class int32, type1 int32, } /* Construct query template - ID will be filled later */ Xmemset(tls, bp, 0, Uint64FromInt32(n)) - (*(*[280]uint8)(unsafe.Pointer(bp)))[int32(2)] = Uint8FromInt32(op*int32(8) + int32(1)) - (*(*[280]uint8)(unsafe.Pointer(bp)))[int32(3)] = uint8(32) /* AD */ - (*(*[280]uint8)(unsafe.Pointer(bp)))[int32(5)] = uint8(1) + (**(**[280]uint8)(__ccgo_up(bp)))[int32(2)] = Uint8FromInt32(op*int32(8) + int32(1)) + (**(**[280]uint8)(__ccgo_up(bp)))[int32(3)] = uint8(32) /* AD */ + (**(**[280]uint8)(__ccgo_up(bp)))[int32(5)] = uint8(1) Xmemcpy(tls, bp+uintptr(13), dname, l) i = int32(13) for { - if !((*(*[280]uint8)(unsafe.Pointer(bp)))[i] != 0) { + if !((**(**[280]uint8)(__ccgo_up(bp)))[i] != 0) { break } j = i for { - if !((*(*[280]uint8)(unsafe.Pointer(bp)))[j] != 0 && Int32FromUint8((*(*[280]uint8)(unsafe.Pointer(bp)))[j]) != int32('.')) { + if !((**(**[280]uint8)(__ccgo_up(bp)))[j] != 0 && Int32FromUint8((**(**[280]uint8)(__ccgo_up(bp)))[j]) != int32('.')) { break } goto _2 @@ -123647,19 +123647,19 @@ func X__res_mkquery(tls *TLS, op int32, dname uintptr, class int32, type1 int32, if Uint32FromInt32(j-i)-uint32(1) > uint32(62) { return -int32(1) } - (*(*[280]uint8)(unsafe.Pointer(bp)))[i-int32(1)] = Uint8FromInt32(j - i) + (**(**[280]uint8)(__ccgo_up(bp)))[i-int32(1)] = Uint8FromInt32(j - i) goto _1 _1: ; i = j + int32(1) } - (*(*[280]uint8)(unsafe.Pointer(bp)))[i+int32(1)] = Uint8FromInt32(type1) - (*(*[280]uint8)(unsafe.Pointer(bp)))[i+int32(3)] = Uint8FromInt32(class) + (**(**[280]uint8)(__ccgo_up(bp)))[i+int32(1)] = Uint8FromInt32(type1) + (**(**[280]uint8)(__ccgo_up(bp)))[i+int32(3)] = Uint8FromInt32(class) /* Make a reasonably unpredictable id */ Xclock_gettime(tls, CLOCK_REALTIME, bp+280) - id = Int32FromUint64((Uint64FromInt64((*(*Ttimespec)(unsafe.Pointer(bp + 280))).Ftv_nsec) + Uint64FromInt64((*(*Ttimespec)(unsafe.Pointer(bp + 280))).Ftv_nsec)/uint64(65536)) & uint64(0xffff)) - (*(*[280]uint8)(unsafe.Pointer(bp)))[0] = Uint8FromInt32(id / int32(256)) - (*(*[280]uint8)(unsafe.Pointer(bp)))[int32(1)] = Uint8FromInt32(id) + id = Int32FromUint64((Uint64FromInt64((**(**Ttimespec)(__ccgo_up(bp + 280))).Ftv_nsec) + Uint64FromInt64((**(**Ttimespec)(__ccgo_up(bp + 280))).Ftv_nsec)/uint64(65536)) & uint64(0xffff)) + (**(**[280]uint8)(__ccgo_up(bp)))[0] = Uint8FromInt32(id / int32(256)) + (**(**[280]uint8)(__ccgo_up(bp)))[int32(1)] = Uint8FromInt32(id) Xmemcpy(tls, buf, bp, Uint64FromInt32(n)) return n } @@ -123776,11 +123776,11 @@ func _cleanup(tls *TLS, p uintptr) { pfd = p i = 0 for { - if !((*(*Tpollfd)(unsafe.Pointer(pfd + uintptr(i)*8))).Ffd >= -int32(1)) { + if !((**(**Tpollfd)(__ccgo_up(pfd + uintptr(i)*8))).Ffd >= -int32(1)) { break } - if (*(*Tpollfd)(unsafe.Pointer(pfd + uintptr(i)*8))).Ffd >= 0 { - X__syscall1(tls, int64(SYS_close), int64((*(*Tpollfd)(unsafe.Pointer(pfd + uintptr(i)*8))).Ffd)) + if (**(**Tpollfd)(__ccgo_up(pfd + uintptr(i)*8))).Ffd >= 0 { + X__syscall1(tls, int64(SYS_close), int64((**(**Tpollfd)(__ccgo_up(pfd + uintptr(i)*8))).Ffd)) } goto _1 _1: @@ -123793,10 +123793,10 @@ func _mtime(tls *TLS) (r uint64) { bp := tls.Alloc(16) defer tls.Free(16) var _ /* ts at bp+0 */ Ttimespec - if Xclock_gettime(tls, int32(CLOCK_MONOTONIC), bp) < 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENOSYS) { + if Xclock_gettime(tls, int32(CLOCK_MONOTONIC), bp) < 0 && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENOSYS) { Xclock_gettime(tls, CLOCK_REALTIME, bp) } - return Uint64FromInt64((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec)*uint64(1000) + Uint64FromInt64((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_nsec/int64(1000000)) + return Uint64FromInt64((**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec)*uint64(1000) + Uint64FromInt64((**(**Ttimespec)(__ccgo_up(bp))).Ftv_nsec/int64(1000000)) } func _start_tcp(tls *TLS, pfd uintptr, family int32, sa uintptr, sl Tsocklen_t, q uintptr, ql int32) (r1 int32) { @@ -123819,7 +123819,7 @@ func _start_tcp(tls *TLS, pfd uintptr, family int32, sa uintptr, sl Tsocklen_t, Fiov_len: Uint64FromInt32(ql), }, } - *(*Tmsghdr)(unsafe.Pointer(bp + 40)) = Tmsghdr{ + **(**Tmsghdr)(__ccgo_up(bp + 40)) = Tmsghdr{ Fmsg_name: sa, Fmsg_namelen: sl, Fmsg_iov: bp, @@ -123837,12 +123837,12 @@ func _start_tcp(tls *TLS, pfd uintptr, family int32, sa uintptr, sl Tsocklen_t, if r >= 0 { return r } - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EINPROGRESS) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EINPROGRESS) { return 0 } } r = Xconnect(tls, fd, sa, sl) - if !(r != 0) || *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EINPROGRESS) { + if !(r != 0) || **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EINPROGRESS) { return 0 } Xclose(tls, fd) @@ -123861,7 +123861,7 @@ func _step_mh(tls *TLS, mh uintptr, n Tsize_t) { return } (*Tiovec)(unsafe.Pointer((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov)).Fiov_base = (*Tiovec)(unsafe.Pointer((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov)).Fiov_base + uintptr(n) - *(*Tsize_t)(unsafe.Pointer((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov + 8)) -= n + **(**Tsize_t)(__ccgo_up((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov + 8)) -= n } /* Internal contract for __res_msend[_rc]: asize must be >=512, nqueries @@ -123913,11 +123913,11 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a F__ccgo_pad2 [12]byte }{} *(*uint16)(unsafe.Pointer(bp + 88)) = uint16(0) - *(*[3]struct { + **(**[3]struct { Fsin6 [0]Tsockaddr_in6 Fsin Tsockaddr_in F__ccgo_pad2 [12]byte - })(unsafe.Pointer(bp + 116)) = [3]struct { + })(__ccgo_up(bp + 116)) = [3]struct { Fsin6 [0]Tsockaddr_in6 Fsin Tsockaddr_in F__ccgo_pad2 [12]byte @@ -123944,16 +123944,16 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a iplit = conf + uintptr(nns)*28 if (*Taddress)(unsafe.Pointer(iplit)).Ffamily == int32(PF_INET) { Xmemcpy(tls, bp+116+uintptr(nns)*28+4, iplit+8, uint64(4)) - (*(*[3]struct { + (**(**[3]struct { Fsin6 [0]Tsockaddr_in6 Fsin Tsockaddr_in F__ccgo_pad2 [12]byte - })(unsafe.Pointer(bp + 116)))[nns].Fsin.Fsin_port = Xhtons(tls, uint16(53)) - (*(*[3]struct { + })(__ccgo_up(bp + 116)))[nns].Fsin.Fsin_port = Xhtons(tls, uint16(53)) + (**(**[3]struct { Fsin6 [0]Tsockaddr_in6 Fsin Tsockaddr_in F__ccgo_pad2 [12]byte - })(unsafe.Pointer(bp + 116)))[nns].Fsin.Fsin_family = uint16(PF_INET) + })(__ccgo_up(bp + 116)))[nns].Fsin.Fsin_family = uint16(PF_INET) } else { sl = uint32(28) Xmemcpy(tls, bp+116+uintptr(nns)*28+8, iplit+8, uint64(16)) @@ -123971,10 +123971,10 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a /* Get local address and open/bind a socket */ fd = Xsocket(tls, family, Int32FromInt32(SOCK_DGRAM)|Int32FromInt32(SOCK_CLOEXEC)|Int32FromInt32(SOCK_NONBLOCK), 0) /* Handle case where system lacks IPv6 support */ - if fd < 0 && family == int32(PF_INET6) && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EAFNOSUPPORT) { + if fd < 0 && family == int32(PF_INET6) && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EAFNOSUPPORT) { i = 0 for { - if !(i < nns && (*(*Taddress)(unsafe.Pointer(conf + uintptr(nns)*28))).Ffamily == int32(PF_INET6)) { + if !(i < nns && (**(**Taddress)(__ccgo_up(conf + uintptr(nns)*28))).Ffamily == int32(PF_INET6)) { break } goto _7 @@ -123983,7 +123983,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a i = i + 1 } if i == nns { - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 200)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 200)), uintptr(0)) return -int32(1) } fd = Xsocket(tls, int32(PF_INET), Int32FromInt32(SOCK_DGRAM)|Int32FromInt32(SOCK_CLOEXEC)|Int32FromInt32(SOCK_NONBLOCK), 0) @@ -123999,11 +123999,11 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a if !(i < nns) { break } - if Int32FromUint16((*(*[3]struct { + if Int32FromUint16((**(**[3]struct { Fsin6 [0]Tsockaddr_in6 Fsin Tsockaddr_in F__ccgo_pad2 [12]byte - })(unsafe.Pointer(bp + 116)))[i].Fsin.Fsin_family) != int32(PF_INET) { + })(__ccgo_up(bp + 116)))[i].Fsin.Fsin_family) != int32(PF_INET) { goto _8 } Xmemcpy(tls, bp+116+uintptr(i)*28+8+uintptr(12), bp+116+uintptr(i)*28+4, uint64(4)) @@ -124017,16 +124017,16 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a i = i + 1 } } - (*(*struct { + (**(**struct { Fsin6 [0]Tsockaddr_in6 Fsin Tsockaddr_in F__ccgo_pad2 [12]byte - })(unsafe.Pointer(bp + 88))).Fsin.Fsin_family = Uint16FromInt32(family) + })(__ccgo_up(bp + 88))).Fsin.Fsin_family = Uint16FromInt32(family) if fd < 0 || Xbind(tls, fd, bp+88, sl) < 0 { if fd >= 0 { Xclose(tls, fd) } - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 200)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 200)), uintptr(0)) return -int32(1) } /* Past this point, there are no errors. Each individual query will @@ -124047,7 +124047,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), nqueries*8))).Fevents = int16(POLLIN) (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), (nqueries+int32(1))*8))).Ffd = -int32(2) __pthread_cleanup_push(tls, bp+208, __ccgo_fp(_cleanup), pfd) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 200)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 200)), uintptr(0)) Xmemset(tls, alens, 0, uint64(4)*Uint64FromInt32(nqueries)) retry_interval = timeout / attempts next = 0 @@ -124063,7 +124063,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a * have an accepted answer. */ i = 0 for { - if !(i < nqueries && *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) > 0) { + if !(i < nqueries && **(**int32)(__ccgo_up(alens + uintptr(i)*4)) > 0) { break } goto _12 @@ -124081,13 +124081,13 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a if !(i < nqueries) { break } - if !(*(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) != 0) { + if !(**(**int32)(__ccgo_up(alens + uintptr(i)*4)) != 0) { j = 0 for { if !(j < nns) { break } - Xsendto(tls, fd, *(*uintptr)(unsafe.Pointer(queries + uintptr(i)*8)), Uint64FromInt32(*(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))), int32(MSG_NOSIGNAL), bp+116+uintptr(j)*28, sl) + Xsendto(tls, fd, **(**uintptr)(__ccgo_up(queries + uintptr(i)*8)), Uint64FromInt32(**(**int32)(__ccgo_up(qlens + uintptr(i)*4))), int32(MSG_NOSIGNAL), bp+116+uintptr(j)*28, sl) goto _14 _14: ; @@ -124109,11 +124109,11 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a for next < nqueries { *(*[1]Tiovec)(unsafe.Pointer(bp + 8)) = [1]Tiovec{ 0: { - Fiov_base: *(*uintptr)(unsafe.Pointer(answers + uintptr(next)*8)), + Fiov_base: **(**uintptr)(__ccgo_up(answers + uintptr(next)*8)), Fiov_len: Uint64FromInt32(asize), }, } - *(*Tmsghdr)(unsafe.Pointer(bp + 232)) = Tmsghdr{ + **(**Tmsghdr)(__ccgo_up(bp + 232)) = Tmsghdr{ Fmsg_name: bp + 88, Fmsg_namelen: sl, Fmsg_iov: bp + 8, @@ -124144,7 +124144,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a /* Find which query this answer goes with, if any */ i = next for { - if !(i < nqueries && (Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(answers + uintptr(next)*8))))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(queries + uintptr(i)*8))))) || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(answers + uintptr(next)*8)) + 1))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(queries + uintptr(i)*8)) + 1))))) { + if !(i < nqueries && (Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(answers + uintptr(next)*8))))) != Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(queries + uintptr(i)*8))))) || Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(answers + uintptr(next)*8)) + 1))) != Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(queries + uintptr(i)*8)) + 1))))) { break } goto _16 @@ -124155,13 +124155,13 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a if i == nqueries { continue } - if *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) != 0 { + if **(**int32)(__ccgo_up(alens + uintptr(i)*4)) != 0 { continue } /* Only accept positive or negative responses; * retry immediately on server failure, and ignore * all other codes such as refusal. */ - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(answers + uintptr(next)*8)) + 3))) & Int32FromInt32(15) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(answers + uintptr(next)*8)) + 3))) & Int32FromInt32(15) { case 0: fallthrough case int32(3): @@ -124171,7 +124171,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a servfail_retry = servfail_retry - 1 } if v18 && v6 != 0 { - Xsendto(tls, fd, *(*uintptr)(unsafe.Pointer(queries + uintptr(i)*8)), Uint64FromInt32(*(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))), int32(MSG_NOSIGNAL), bp+116+uintptr(j)*28, sl) + Xsendto(tls, fd, **(**uintptr)(__ccgo_up(queries + uintptr(i)*8)), Uint64FromInt32(**(**int32)(__ccgo_up(qlens + uintptr(i)*4))), int32(MSG_NOSIGNAL), bp+116+uintptr(j)*28, sl) } fallthrough default: @@ -124179,10 +124179,10 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a } /* Store answer in the right slot, or update next * available temp slot if it's already in place. */ - *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) = rlen + **(**int32)(__ccgo_up(alens + uintptr(i)*4)) = rlen if i == next { for { - if !(next < nqueries && *(*int32)(unsafe.Pointer(alens + uintptr(next)*4)) != 0) { + if !(next < nqueries && **(**int32)(__ccgo_up(alens + uintptr(next)*4)) != 0) { break } goto _19 @@ -124191,18 +124191,18 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a next = next + 1 } } else { - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(answers + uintptr(i)*8)), *(*uintptr)(unsafe.Pointer(answers + uintptr(next)*8)), Uint64FromInt32(rlen)) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(answers + uintptr(i)*8)), **(**uintptr)(__ccgo_up(answers + uintptr(next)*8)), Uint64FromInt32(rlen)) } /* Ignore further UDP if all slots full or TCP-mode */ if next == nqueries { (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), nqueries*8))).Fevents = 0 } /* If answer is truncated (TC bit), fallback to TCP */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(answers + uintptr(i)*8)) + 2)))&int32(2) != 0 || (*(*Tmsghdr)(unsafe.Pointer(bp + 232))).Fmsg_flags&int32(MSG_TRUNC) != 0 { - *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) = -int32(1) + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(answers + uintptr(i)*8)) + 2)))&int32(2) != 0 || (**(**Tmsghdr)(__ccgo_up(bp + 232))).Fmsg_flags&int32(MSG_TRUNC) != 0 { + **(**int32)(__ccgo_up(alens + uintptr(i)*4)) = -int32(1) _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), uintptr(0)) - r = _start_tcp(tls, pfd+uintptr(i)*8, family, bp+116+uintptr(j)*28, sl, *(*uintptr)(unsafe.Pointer(queries + uintptr(i)*8)), *(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 200)), uintptr(0)) + r = _start_tcp(tls, pfd+uintptr(i)*8, family, bp+116+uintptr(j)*28, sl, **(**uintptr)(__ccgo_up(queries + uintptr(i)*8)), **(**int32)(__ccgo_up(qlens + uintptr(i)*4))) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 200)), uintptr(0)) if r >= 0 { *(*int32)(unsafe.Add(unsafe.Pointer(qpos), i*4)) = r *(*int32)(unsafe.Add(unsafe.Pointer(apos), i*4)) = 0 @@ -124217,8 +124217,8 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a } if int32((*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), i*8))).Frevents)&int32(POLLOUT) != 0 { *(*[2]Tuint8_t)(unsafe.Pointer(bp + 52)) = [2]Tuint8_t{ - 0: Uint8FromInt32(*(*int32)(unsafe.Pointer(qlens + uintptr(i)*4)) >> int32(8)), - 1: Uint8FromInt32(*(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))), + 0: Uint8FromInt32(**(**int32)(__ccgo_up(qlens + uintptr(i)*4)) >> int32(8)), + 1: Uint8FromInt32(**(**int32)(__ccgo_up(qlens + uintptr(i)*4))), } *(*[2]Tiovec)(unsafe.Pointer(bp + 24)) = [2]Tiovec{ 0: { @@ -124226,11 +124226,11 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a Fiov_len: uint64(2), }, 1: { - Fiov_base: *(*uintptr)(unsafe.Pointer(queries + uintptr(i)*8)), - Fiov_len: Uint64FromInt32(*(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))), + Fiov_base: **(**uintptr)(__ccgo_up(queries + uintptr(i)*8)), + Fiov_len: Uint64FromInt32(**(**int32)(__ccgo_up(qlens + uintptr(i)*4))), }, } - *(*Tmsghdr)(unsafe.Pointer(bp + 288)) = Tmsghdr{ + **(**Tmsghdr)(__ccgo_up(bp + 288)) = Tmsghdr{ Fmsg_iov: bp + 24, Fmsg_iovlen: int32(2), } @@ -124239,8 +124239,8 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a if r < 0 { goto out } - *(*int32)(unsafe.Pointer(qpos + uintptr(i)*4)) += r - if *(*int32)(unsafe.Add(unsafe.Pointer(qpos), i*4)) == *(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))+int32(2) { + **(**int32)(__ccgo_up(qpos + uintptr(i)*4)) += r + if *(*int32)(unsafe.Add(unsafe.Pointer(qpos), i*4)) == **(**int32)(__ccgo_up(qlens + uintptr(i)*4))+int32(2) { (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), i*8))).Fevents = int16(POLLIN) } } @@ -124261,11 +124261,11 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a Fiov_len: uint64(2), }, 1: { - Fiov_base: *(*uintptr)(unsafe.Pointer(answers + uintptr(i)*8)), + Fiov_base: **(**uintptr)(__ccgo_up(answers + uintptr(i)*8)), Fiov_len: Uint64FromInt32(asize), }, } - *(*Tmsghdr)(unsafe.Pointer(bp + 344)) = Tmsghdr{ + **(**Tmsghdr)(__ccgo_up(bp + 344)) = Tmsghdr{ Fmsg_iov: bp + 56, Fmsg_iovlen: int32(2), } @@ -124274,25 +124274,25 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a if r <= 0 { goto out } - *(*int32)(unsafe.Pointer(apos + uintptr(i)*4)) += r + **(**int32)(__ccgo_up(apos + uintptr(i)*4)) += r if *(*int32)(unsafe.Add(unsafe.Pointer(apos), i*4)) < int32(2) { goto _21 } - alen = Int32FromUint8(*(*uint8)(unsafe.Pointer(alen_buf + uintptr(i)*2)))*int32(256) + Int32FromUint8(*(*uint8)(unsafe.Pointer(alen_buf + uintptr(i)*2 + 1))) + alen = Int32FromUint8(**(**uint8)(__ccgo_up(alen_buf + uintptr(i)*2)))*int32(256) + Int32FromUint8(**(**uint8)(__ccgo_up(alen_buf + uintptr(i)*2 + 1))) if alen < int32(13) { goto out } if *(*int32)(unsafe.Add(unsafe.Pointer(apos), i*4)) < alen+int32(2) && *(*int32)(unsafe.Add(unsafe.Pointer(apos), i*4)) < asize+int32(2) { goto _21 } - rcode = Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(answers + uintptr(i)*8)) + 3))) & int32(15) + rcode = Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(answers + uintptr(i)*8)) + 3))) & int32(15) if rcode != 0 && rcode != int32(3) { goto out } /* Storing the length here commits the accepted answer. * Immediately close TCP socket so as not to consume * resources we no longer need. */ - *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) = alen + **(**int32)(__ccgo_up(alens + uintptr(i)*4)) = alen X__syscall1(tls, int64(SYS_close), int64((*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), i*8))).Ffd)) (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), i*8))).Ffd = -int32(1) } @@ -124316,8 +124316,8 @@ out: if !(i < nqueries) { break } - if *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) < 0 { - *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) = 0 + if **(**int32)(__ccgo_up(alens + uintptr(i)*4)) < 0 { + **(**int32)(__ccgo_up(alens + uintptr(i)*4)) = 0 } goto _22 _22: @@ -124355,23 +124355,23 @@ func X__res_send(tls *TLS, _msg uintptr, _msglen int32, _answer uintptr, _anslen var r, v1 int32 var _ /* buf at bp+28 */ [512]uint8 _, _ = r, v1 - if *(*int32)(unsafe.Pointer(bp + 24)) < int32(512) { - r = X__res_send(tls, *(*uintptr)(unsafe.Pointer(bp)), *(*int32)(unsafe.Pointer(bp + 8)), bp+28, int32(512)) + if **(**int32)(__ccgo_up(bp + 24)) < int32(512) { + r = X__res_send(tls, **(**uintptr)(__ccgo_up(bp)), **(**int32)(__ccgo_up(bp + 8)), bp+28, int32(512)) if r >= 0 { - if r < *(*int32)(unsafe.Pointer(bp + 24)) { + if r < **(**int32)(__ccgo_up(bp + 24)) { v1 = r } else { - v1 = *(*int32)(unsafe.Pointer(bp + 24)) + v1 = **(**int32)(__ccgo_up(bp + 24)) } - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(bp + 16)), bp+28, Uint64FromInt32(v1)) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(bp + 16)), bp+28, Uint64FromInt32(v1)) } return r } - r = X__res_msend(tls, int32(1), bp, bp+8, bp+16, bp+24, *(*int32)(unsafe.Pointer(bp + 24))) - if r < 0 || !(*(*int32)(unsafe.Pointer(bp + 24)) != 0) { + r = X__res_msend(tls, int32(1), bp, bp+8, bp+16, bp+24, **(**int32)(__ccgo_up(bp + 24))) + if r < 0 || !(**(**int32)(__ccgo_up(bp + 24)) != 0) { v1 = -int32(1) } else { - v1 = *(*int32)(unsafe.Pointer(bp + 24)) + v1 = **(**int32)(__ccgo_up(bp + 24)) } return v1 } @@ -124418,11 +124418,11 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ (*Tresolvconf)(unsafe.Pointer(conf)).Ftimeout = uint32(5) (*Tresolvconf)(unsafe.Pointer(conf)).Fattempts = uint32(2) if search != 0 { - *(*uint8)(unsafe.Pointer(search)) = uint8(0) + **(**uint8)(__ccgo_up(search)) = uint8(0) } f = X__fopen_rb_ca(tls, __ccgo_ts+1149, bp+512, bp+256, uint64(256)) if !(f != 0) { - switch *(*int32)(unsafe.Pointer(X__errno_location(tls))) { + switch **(**int32)(__ccgo_up(X__errno_location(tls))) { case int32(ENOENT): fallthrough case int32(ENOTDIR): @@ -124441,17 +124441,17 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ continue } if v4 = !(Xstrncmp(tls, bp, __ccgo_ts+1166, uint64(7)) != 0); v4 { - v1 = Int32FromUint8((*(*[256]uint8)(unsafe.Pointer(bp)))[int32(7)]) + v1 = Int32FromUint8((**(**[256]uint8)(__ccgo_up(bp)))[int32(7)]) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _3 _3: } if v4 && v2 != 0 { p = Xstrstr(tls, bp, __ccgo_ts+1174) - if p != 0 && BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p + 6)))-uint32('0') < uint32(10)) != 0 { + if p != 0 && BoolInt32(uint32(**(**uint8)(__ccgo_up(p + 6)))-uint32('0') < uint32(10)) != 0 { p = p + uintptr(6) x = Xstrtoul(tls, p, bp+744, int32(10)) - if *(*uintptr)(unsafe.Pointer(bp + 744)) != p { + if **(**uintptr)(__ccgo_up(bp + 744)) != p { if x > uint64(15) { v5 = uint64(15) } else { @@ -124461,10 +124461,10 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ } } p = Xstrstr(tls, bp, __ccgo_ts+1181) - if p != 0 && BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p + 9)))-uint32('0') < uint32(10)) != 0 { + if p != 0 && BoolInt32(uint32(**(**uint8)(__ccgo_up(p + 9)))-uint32('0') < uint32(10)) != 0 { p = p + uintptr(9) x1 = Xstrtoul(tls, p, bp+744, int32(10)) - if *(*uintptr)(unsafe.Pointer(bp + 744)) != p { + if **(**uintptr)(__ccgo_up(bp + 744)) != p { if x1 > uint64(10) { v5 = uint64(10) } else { @@ -124474,10 +124474,10 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ } } p = Xstrstr(tls, bp, __ccgo_ts+1191) - if p != 0 && (BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p + 8)))-uint32('0') < uint32(10)) != 0 || Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 8))) == int32('.')) { + if p != 0 && (BoolInt32(uint32(**(**uint8)(__ccgo_up(p + 8)))-uint32('0') < uint32(10)) != 0 || Int32FromUint8(**(**uint8)(__ccgo_up(p + 8))) == int32('.')) { p = p + uintptr(8) x2 = Xstrtoul(tls, p, bp+744, int32(10)) - if *(*uintptr)(unsafe.Pointer(bp + 744)) != p { + if **(**uintptr)(__ccgo_up(bp + 744)) != p { if x2 > uint64(60) { v5 = uint64(60) } else { @@ -124489,7 +124489,7 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ continue } if v4 = !(Xstrncmp(tls, bp, __ccgo_ts+1200, uint64(10)) != 0); v4 { - v1 = Int32FromUint8((*(*[256]uint8)(unsafe.Pointer(bp)))[int32(10)]) + v1 = Int32FromUint8((**(**[256]uint8)(__ccgo_up(bp)))[int32(10)]) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _10 _10: @@ -124500,7 +124500,7 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ } p = bp + uintptr(11) for { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _15 _15: @@ -124512,10 +124512,10 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ ; p = p + 1 } - *(*uintptr)(unsafe.Pointer(bp + 744)) = p + **(**uintptr)(__ccgo_up(bp + 744)) = p for { - if v4 = *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 744)))) != 0; v4 { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 744))))) + if v4 = **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 744)))) != 0; v4 { + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 744))))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _19 _19: @@ -124526,9 +124526,9 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ goto _16 _16: ; - *(*uintptr)(unsafe.Pointer(bp + 744)) = *(*uintptr)(unsafe.Pointer(bp + 744)) + 1 + **(**uintptr)(__ccgo_up(bp + 744)) = **(**uintptr)(__ccgo_up(bp + 744)) + 1 } - *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 744)))) = uint8(0) + **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 744)))) = uint8(0) if X__lookup_ipliteral(tls, conf+uintptr(nns)*28, p, PF_UNSPEC) > 0 { nns = nns + 1 } @@ -124538,7 +124538,7 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ continue } if v4 = Xstrncmp(tls, bp, __ccgo_ts+1211, uint64(6)) != 0 && Xstrncmp(tls, bp, __ccgo_ts+1218, uint64(6)) != 0; !v4 { - v1 = Int32FromUint8((*(*[256]uint8)(unsafe.Pointer(bp)))[int32(6)]) + v1 = Int32FromUint8((**(**[256]uint8)(__ccgo_up(bp)))[int32(6)]) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _23 _23: @@ -124548,7 +124548,7 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ } p = bp + uintptr(7) for { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _28 _28: @@ -124614,7 +124614,7 @@ func Xsendmmsg(tls *TLS, fd int32, msgvec uintptr, vlen uint32, flags uint32) (r if r < 0 { goto error } - (*(*Tmmsghdr)(unsafe.Pointer(msgvec + uintptr(i)*64))).Fmsg_len = Uint32FromInt64(r) + (**(**Tmmsghdr)(__ccgo_up(msgvec + uintptr(i)*64))).Fmsg_len = Uint32FromInt64(r) goto _1 _1: ; @@ -124647,18 +124647,18 @@ func Xsendmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r1 Tssize_t) { var _ /* h at bp+0 */ Tmsghdr _, _, _, _, _, _, _, _, _, _, _ = c1, r, v1, v10, v11, v12, v3, v6, v7, v8, v9 if msg != 0 { - *(*Tmsghdr)(unsafe.Pointer(bp)) = *(*Tmsghdr)(unsafe.Pointer(msg)) + **(**Tmsghdr)(__ccgo_up(bp)) = **(**Tmsghdr)(__ccgo_up(msg)) v1 = Int32FromInt32(0) - (*(*Tmsghdr)(unsafe.Pointer(bp))).F__pad2 = v1 - (*(*Tmsghdr)(unsafe.Pointer(bp))).F__pad1 = v1 + (**(**Tmsghdr)(__ccgo_up(bp))).F__pad2 = v1 + (**(**Tmsghdr)(__ccgo_up(bp))).F__pad1 = v1 msg = bp - if (*(*Tmsghdr)(unsafe.Pointer(bp))).Fmsg_controllen != 0 { - if uint64((*(*Tmsghdr)(unsafe.Pointer(bp))).Fmsg_controllen) > uint64(1056) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + if (**(**Tmsghdr)(__ccgo_up(bp))).Fmsg_controllen != 0 { + if uint64((**(**Tmsghdr)(__ccgo_up(bp))).Fmsg_controllen) > uint64(1056) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return int64(-int32(1)) } - Xmemcpy(tls, bp+56, (*(*Tmsghdr)(unsafe.Pointer(bp))).Fmsg_control, uint64((*(*Tmsghdr)(unsafe.Pointer(bp))).Fmsg_controllen)) - (*(*Tmsghdr)(unsafe.Pointer(bp))).Fmsg_control = bp + 56 + Xmemcpy(tls, bp+56, (**(**Tmsghdr)(__ccgo_up(bp))).Fmsg_control, uint64((**(**Tmsghdr)(__ccgo_up(bp))).Fmsg_controllen)) + (**(**Tmsghdr)(__ccgo_up(bp))).Fmsg_control = bp + 56 if uint64((*Tmsghdr)(unsafe.Pointer(bp)).Fmsg_controllen) >= uint64(16) { v3 = (*Tmsghdr)(unsafe.Pointer(bp)).Fmsg_control } else { @@ -124931,7 +124931,7 @@ func Xsockatmark(tls *TLS, s int32) (r int32) { if Xioctl(tls, s, int32(SIOCATMARK), VaList(bp+16, bp)) < 0 { return -int32(1) } - return *(*int32)(unsafe.Pointer(bp)) + return **(**int32)(__ccgo_up(bp)) } func Xsocket(tls *TLS, domain int32, type1 int32, protocol int32) (r1 int32) { @@ -125029,7 +125029,7 @@ func Xsocketpair(tls *TLS, domain int32, type1 int32, protocol int32, fd uintptr goto _9 _9: r1 = int32(X__syscall_ret(tls, Uint64FromInt64(v8))) - if r1 < 0 && (*(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EINVAL) || *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EPROTONOSUPPORT)) && type1&(Int32FromInt32(SOCK_CLOEXEC)|Int32FromInt32(SOCK_NONBLOCK)) != 0 { + if r1 < 0 && (**(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EINVAL) || **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EPROTONOSUPPORT)) && type1&(Int32FromInt32(SOCK_CLOEXEC)|Int32FromInt32(SOCK_NONBLOCK)) != 0 { v10 = int32(SYS_socketpair) _ = int32(__SC_socketpair) v11 = int64(domain) @@ -125055,12 +125055,12 @@ _9: return r1 } if type1&int32(SOCK_CLOEXEC) != 0 { - X__syscall3(tls, int64(SYS_fcntl), int64(*(*int32)(unsafe.Pointer(fd))), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) - X__syscall3(tls, int64(SYS_fcntl), int64(*(*int32)(unsafe.Pointer(fd + 1*4))), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) + X__syscall3(tls, int64(SYS_fcntl), int64(**(**int32)(__ccgo_up(fd))), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) + X__syscall3(tls, int64(SYS_fcntl), int64(**(**int32)(__ccgo_up(fd + 1*4))), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) } if type1&int32(SOCK_NONBLOCK) != 0 { - X__syscall3(tls, int64(SYS_fcntl), int64(*(*int32)(unsafe.Pointer(fd))), int64(Int32FromInt32(F_SETFL)), int64(Int32FromInt32(O_NONBLOCK))) - X__syscall3(tls, int64(SYS_fcntl), int64(*(*int32)(unsafe.Pointer(fd + 1*4))), int64(Int32FromInt32(F_SETFL)), int64(Int32FromInt32(O_NONBLOCK))) + X__syscall3(tls, int64(SYS_fcntl), int64(**(**int32)(__ccgo_up(fd))), int64(Int32FromInt32(F_SETFL)), int64(Int32FromInt32(O_NONBLOCK))) + X__syscall3(tls, int64(SYS_fcntl), int64(**(**int32)(__ccgo_up(fd + 1*4))), int64(Int32FromInt32(F_SETFL)), int64(Int32FromInt32(O_NONBLOCK))) } } return r1 @@ -125097,10 +125097,10 @@ func Xfgetgrent(tls *TLS, f uintptr) (r uintptr) { var _ /* nmem at bp+16 */ Tsize_t var _ /* res at bp+0 */ uintptr var _ /* size at bp+8 */ Tsize_t - *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint64(0) - *(*Tsize_t)(unsafe.Pointer(bp + 16)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp + 8)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp + 16)) = uint64(0) X__getgrent_a(tls, f, uintptr(unsafe.Pointer(&_gr)), uintptr(unsafe.Pointer(&_line1)), bp+8, uintptr(unsafe.Pointer(&_mem)), bp+16, bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } var _line1 uintptr @@ -125118,9 +125118,9 @@ func Xfgetpwent(tls *TLS, f uintptr) (r uintptr) { defer tls.Free(16) var _ /* res at bp+8 */ uintptr var _ /* size at bp+0 */ Tsize_t - *(*Tsize_t)(unsafe.Pointer(bp)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp)) = uint64(0) X__getpwent_a(tls, f, uintptr(unsafe.Pointer(&_pw)), uintptr(unsafe.Pointer(&_line2)), bp, bp+8) - return *(*uintptr)(unsafe.Pointer(bp + 8)) + return **(**uintptr)(__ccgo_up(bp + 8)) } var _line2 uintptr @@ -125166,11 +125166,11 @@ func _itoa1(tls *TLS, p uintptr, x Tuint32_t) (r uintptr) { p = p + uintptr(11) p = p - 1 v1 = p - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) for cond := true; cond; cond = x != 0 { p = p - 1 v1 = p - *(*uint8)(unsafe.Pointer(v1)) = uint8(uint32('0') + x%uint32(10)) + **(**uint8)(__ccgo_up(v1)) = uint8(uint32('0') + x%uint32(10)) x = x / uint32(10) } return p @@ -125195,36 +125195,36 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz var _ /* swap at bp+40 */ int32 _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, grlist_len, i, key, len1, ptr, req, rv, tmp, tmp1, v1, v10, v5, v6 rv = 0 - *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) + **(**uintptr)(__ccgo_up(res)) = uintptr(0) _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp) f = Xfopen(tls, __ccgo_ts+1235, __ccgo_ts+315) if !(f != 0) { - rv = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + rv = **(**int32)(__ccgo_up(X__errno_location(tls))) goto done } for { v1 = X__getgrent_a(tls, f, gr, buf, size, mem, nmem, res) rv = v1 - if !(!(v1 != 0) && *(*uintptr)(unsafe.Pointer(res)) != 0) { + if !(!(v1 != 0) && **(**uintptr)(__ccgo_up(res)) != 0) { break } - if name != 0 && !(Xstrcmp(tls, name, (*Tgroup)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(res)))).Fgr_name) != 0) || !(name != 0) && (*Tgroup)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(res)))).Fgr_gid == gid { + if name != 0 && !(Xstrcmp(tls, name, (*Tgroup)(unsafe.Pointer(**(**uintptr)(__ccgo_up(res)))).Fgr_name) != 0) || !(name != 0) && (*Tgroup)(unsafe.Pointer(**(**uintptr)(__ccgo_up(res)))).Fgr_gid == gid { break } } Xfclose(tls, f) - if !(*(*uintptr)(unsafe.Pointer(res)) != 0) && (rv == 0 || rv == int32(ENOENT) || rv == int32(ENOTDIR)) { + if !(**(**uintptr)(__ccgo_up(res)) != 0) && (rv == 0 || rv == int32(ENOENT) || rv == int32(ENOTDIR)) { if name != 0 { v1 = int32(GETGRBYNAME) } else { v1 = int32(GETGRBYGID) } req = v1 - *(*[6]Tint32_t)(unsafe.Pointer(bp + 4)) = [6]Tint32_t{} + **(**[6]Tint32_t)(__ccgo_up(bp + 4)) = [6]Tint32_t{} len1 = uint64(0) grlist_len = uint64(0) - *(*[11]uint8)(unsafe.Pointer(bp + 28)) = [11]uint8{} - *(*int32)(unsafe.Pointer(bp + 40)) = 0 + **(**[11]uint8)(__ccgo_up(bp + 28)) = [11]uint8{} + **(**int32)(__ccgo_up(bp + 40)) = 0 if name != 0 { key = name } else { @@ -125236,116 +125236,116 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz } f = X__nscd_query(tls, req, key, bp+4, uint64(24), bp+40) if !(f != 0) { - rv = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + rv = **(**int32)(__ccgo_up(X__errno_location(tls))) goto done } - if !((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRFOUND)] != 0) { + if !((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRFOUND)] != 0) { rv = 0 goto cleanup_f } - if !((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRNAMELEN)] != 0) || !((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRPASSWDLEN)] != 0) { + if !((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRNAMELEN)] != 0) || !((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRPASSWDLEN)] != 0) { rv = int32(EIO) goto cleanup_f } - if Uint64FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRNAMELEN)]) > uint64(0xffffffffffffffff)-Uint64FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRPASSWDLEN)]) { + if Uint64FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRNAMELEN)]) > uint64(0xffffffffffffffff)-Uint64FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRPASSWDLEN)]) { rv = int32(ENOMEM) goto cleanup_f } - len1 = Uint64FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRNAMELEN)] + (*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRPASSWDLEN)]) + len1 = Uint64FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRNAMELEN)] + (**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRPASSWDLEN)]) i = 0 for { - if !(i < (*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)]) { + if !(i < (**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)]) { break } if Xfread(tls, bp+44, uint64(4), uint64(1), f) < uint64(1) { if Xferror(tls, f) != 0 { - v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = **(**int32)(__ccgo_up(X__errno_location(tls))) } else { v1 = int32(EIO) } rv = v1 goto cleanup_f } - if *(*int32)(unsafe.Pointer(bp + 40)) != 0 { - v5 = *(*Tuint32_t)(unsafe.Pointer(bp + 44)) + if **(**int32)(__ccgo_up(bp + 40)) != 0 { + v5 = **(**Tuint32_t)(__ccgo_up(bp + 44)) v6 = v5>>int32(24) | v5>>int32(8)&uint32(0xff00) | v5< uint64(0xffffffffffffffff)-grlist_len || uint64(*(*Tuint32_t)(unsafe.Pointer(bp + 44))) > uint64(0xffffffffffffffff)-len1 { + if uint64(**(**Tuint32_t)(__ccgo_up(bp + 44))) > uint64(0xffffffffffffffff)-grlist_len || uint64(**(**Tuint32_t)(__ccgo_up(bp + 44))) > uint64(0xffffffffffffffff)-len1 { rv = int32(ENOMEM) goto cleanup_f } - len1 = len1 + uint64(*(*Tuint32_t)(unsafe.Pointer(bp + 44))) - grlist_len = grlist_len + uint64(*(*Tuint32_t)(unsafe.Pointer(bp + 44))) + len1 = len1 + uint64(**(**Tuint32_t)(__ccgo_up(bp + 44))) + grlist_len = grlist_len + uint64(**(**Tuint32_t)(__ccgo_up(bp + 44))) goto _3 _3: ; i = i + 1 } - if len1 > *(*Tsize_t)(unsafe.Pointer(size)) || !(*(*uintptr)(unsafe.Pointer(buf)) != 0) { - tmp = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(buf)), len1) + if len1 > **(**Tsize_t)(__ccgo_up(size)) || !(**(**uintptr)(__ccgo_up(buf)) != 0) { + tmp = Xrealloc(tls, **(**uintptr)(__ccgo_up(buf)), len1) if !(tmp != 0) { - rv = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + rv = **(**int32)(__ccgo_up(X__errno_location(tls))) goto cleanup_f } - *(*uintptr)(unsafe.Pointer(buf)) = tmp - *(*Tsize_t)(unsafe.Pointer(size)) = len1 + **(**uintptr)(__ccgo_up(buf)) = tmp + **(**Tsize_t)(__ccgo_up(size)) = len1 } - if !(Xfread(tls, *(*uintptr)(unsafe.Pointer(buf)), len1, uint64(1), f) != 0) { + if !(Xfread(tls, **(**uintptr)(__ccgo_up(buf)), len1, uint64(1), f) != 0) { if Xferror(tls, f) != 0 { - v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = **(**int32)(__ccgo_up(X__errno_location(tls))) } else { v1 = int32(EIO) } rv = v1 goto cleanup_f } - if Uint64FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)]+int32(1)) > *(*Tsize_t)(unsafe.Pointer(nmem)) { - if Uint64FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)]+int32(1)) > Uint64FromUint64(0xffffffffffffffff)/Uint64FromInt64(8) { + if Uint64FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)]+int32(1)) > **(**Tsize_t)(__ccgo_up(nmem)) { + if Uint64FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)]+int32(1)) > Uint64FromUint64(0xffffffffffffffff)/Uint64FromInt64(8) { rv = int32(ENOMEM) goto cleanup_f } - tmp1 = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(mem)), Uint64FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)]+Int32FromInt32(1))*uint64(8)) + tmp1 = Xrealloc(tls, **(**uintptr)(__ccgo_up(mem)), Uint64FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)]+Int32FromInt32(1))*uint64(8)) if !(tmp1 != 0) { - rv = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + rv = **(**int32)(__ccgo_up(X__errno_location(tls))) goto cleanup_f } - *(*uintptr)(unsafe.Pointer(mem)) = tmp1 - *(*Tsize_t)(unsafe.Pointer(nmem)) = Uint64FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)] + int32(1)) + **(**uintptr)(__ccgo_up(mem)) = tmp1 + **(**Tsize_t)(__ccgo_up(nmem)) = Uint64FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)] + int32(1)) } - if (*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)] != 0 { - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)))) = *(*uintptr)(unsafe.Pointer(buf)) + uintptr((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRNAMELEN)]) + uintptr((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRPASSWDLEN)]) - ptr = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)))) + if (**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)] != 0 { + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)))) = **(**uintptr)(__ccgo_up(buf)) + uintptr((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRNAMELEN)]) + uintptr((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRPASSWDLEN)]) + ptr = **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)))) i = Int32FromInt32(0) for { - if !(ptr != *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem))))+uintptr(grlist_len)) { + if !(ptr != **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem))))+uintptr(grlist_len)) { break } - if !(*(*uint8)(unsafe.Pointer(ptr)) != 0) { + if !(**(**uint8)(__ccgo_up(ptr)) != 0) { i = i + 1 v10 = i - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v10)*8)) = ptr + uintptr(1) + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)) + uintptr(v10)*8)) = ptr + uintptr(1) } goto _9 _9: ; ptr = ptr + 1 } - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(i)*8)) = uintptr(0) - if i != (*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)] { + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)) + uintptr(i)*8)) = uintptr(0) + if i != (**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)] { rv = int32(EIO) goto cleanup_f } } else { - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)))) = uintptr(0) + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)))) = uintptr(0) } - (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = *(*uintptr)(unsafe.Pointer(buf)) - (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = (*Tgroup)(unsafe.Pointer(gr)).Fgr_name + uintptr((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRNAMELEN)]) - (*Tgroup)(unsafe.Pointer(gr)).Fgr_gid = Uint32FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRGID)]) - (*Tgroup)(unsafe.Pointer(gr)).Fgr_mem = *(*uintptr)(unsafe.Pointer(mem)) - if *(*uint8)(unsafe.Pointer((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd + uintptr(-Int32FromInt32(1)))) != 0 || *(*uint8)(unsafe.Pointer((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd + uintptr((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRPASSWDLEN)]-int32(1)))) != 0 { + (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = **(**uintptr)(__ccgo_up(buf)) + (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = (*Tgroup)(unsafe.Pointer(gr)).Fgr_name + uintptr((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRNAMELEN)]) + (*Tgroup)(unsafe.Pointer(gr)).Fgr_gid = Uint32FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRGID)]) + (*Tgroup)(unsafe.Pointer(gr)).Fgr_mem = **(**uintptr)(__ccgo_up(mem)) + if **(**uint8)(__ccgo_up((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd + uintptr(-Int32FromInt32(1)))) != 0 || **(**uint8)(__ccgo_up((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd + uintptr((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRPASSWDLEN)]-int32(1)))) != 0 { rv = int32(EIO) goto cleanup_f } @@ -125353,7 +125353,7 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz rv = int32(EIO) goto cleanup_f } - *(*uintptr)(unsafe.Pointer(res)) = gr + **(**uintptr)(__ccgo_up(res)) = gr goto cleanup_f cleanup_f: ; @@ -125363,9 +125363,9 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz goto done done: ; - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) if rv != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = rv + **(**int32)(__ccgo_up(X__errno_location(tls))) = rv } return rv } @@ -125381,42 +125381,42 @@ func _getgr_r(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, size var _ /* mem at bp+16 */ uintptr var _ /* nmem at bp+24 */ Tsize_t _, _ = i, rv - *(*uintptr)(unsafe.Pointer(bp)) = uintptr(0) - *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint64(0) - *(*uintptr)(unsafe.Pointer(bp + 16)) = uintptr(0) - *(*Tsize_t)(unsafe.Pointer(bp + 24)) = uint64(0) + **(**uintptr)(__ccgo_up(bp)) = uintptr(0) + **(**Tsize_t)(__ccgo_up(bp + 8)) = uint64(0) + **(**uintptr)(__ccgo_up(bp + 16)) = uintptr(0) + **(**Tsize_t)(__ccgo_up(bp + 24)) = uint64(0) rv = 0 _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp+32) rv = X__getgr_a(tls, name, gid, gr, bp, bp+8, bp+16, bp+24, res) - if *(*uintptr)(unsafe.Pointer(res)) != 0 && size < *(*Tsize_t)(unsafe.Pointer(bp + 8))+(*(*Tsize_t)(unsafe.Pointer(bp + 24))+uint64(1))*uint64(8)+uint64(32) { - *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) + if **(**uintptr)(__ccgo_up(res)) != 0 && size < **(**Tsize_t)(__ccgo_up(bp + 8))+(**(**Tsize_t)(__ccgo_up(bp + 24))+uint64(1))*uint64(8)+uint64(32) { + **(**uintptr)(__ccgo_up(res)) = uintptr(0) rv = int32(ERANGE) } - if *(*uintptr)(unsafe.Pointer(res)) != 0 { + if **(**uintptr)(__ccgo_up(res)) != 0 { buf = buf + uintptr((uint64(16)-uint64(buf))%uint64(16)) (*Tgroup)(unsafe.Pointer(gr)).Fgr_mem = buf - buf = buf + uintptr((*(*Tsize_t)(unsafe.Pointer(bp + 24))+uint64(1))*uint64(8)) - Xmemcpy(tls, buf, *(*uintptr)(unsafe.Pointer(bp)), *(*Tsize_t)(unsafe.Pointer(bp + 8))) - (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = uintptr(int64((*Tgroup)(unsafe.Pointer(gr)).Fgr_name)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf - (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = uintptr(int64((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf + buf = buf + uintptr((**(**Tsize_t)(__ccgo_up(bp + 24))+uint64(1))*uint64(8)) + Xmemcpy(tls, buf, **(**uintptr)(__ccgo_up(bp)), **(**Tsize_t)(__ccgo_up(bp + 8))) + (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = uintptr(int64((*Tgroup)(unsafe.Pointer(gr)).Fgr_name)-int64(**(**uintptr)(__ccgo_up(bp)))) + buf + (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = uintptr(int64((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd)-int64(**(**uintptr)(__ccgo_up(bp)))) + buf i = uint64(0) for { - if !(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + uintptr(i)*8)) != 0) { + if !(**(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 16)) + uintptr(i)*8)) != 0) { break } - *(*uintptr)(unsafe.Pointer((*Tgroup)(unsafe.Pointer(gr)).Fgr_mem + uintptr(i)*8)) = uintptr(int64(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + uintptr(i)*8)))-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf + **(**uintptr)(__ccgo_up((*Tgroup)(unsafe.Pointer(gr)).Fgr_mem + uintptr(i)*8)) = uintptr(int64(**(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 16)) + uintptr(i)*8)))-int64(**(**uintptr)(__ccgo_up(bp)))) + buf goto _1 _1: ; i = i + 1 } - *(*uintptr)(unsafe.Pointer((*Tgroup)(unsafe.Pointer(gr)).Fgr_mem + uintptr(i)*8)) = uintptr(0) + **(**uintptr)(__ccgo_up((*Tgroup)(unsafe.Pointer(gr)).Fgr_mem + uintptr(i)*8)) = uintptr(0) } - Xfree(tls, *(*uintptr)(unsafe.Pointer(bp + 16))) - Xfree(tls, *(*uintptr)(unsafe.Pointer(bp))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 32)), uintptr(0)) + Xfree(tls, **(**uintptr)(__ccgo_up(bp + 16))) + Xfree(tls, **(**uintptr)(__ccgo_up(bp))) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 32)), uintptr(0)) if rv != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = rv + **(**int32)(__ccgo_up(X__errno_location(tls))) = rv } return rv } @@ -125462,8 +125462,8 @@ func Xgetgrent(tls *TLS) (r uintptr) { var _ /* nmem at bp+16 */ Tsize_t var _ /* res at bp+0 */ uintptr var _ /* size at bp+8 */ Tsize_t - *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint64(0) - *(*Tsize_t)(unsafe.Pointer(bp + 16)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp + 8)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp + 16)) = uint64(0) if !(_f1 != 0) { _f1 = Xfopen(tls, __ccgo_ts+1235, __ccgo_ts+315) } @@ -125471,7 +125471,7 @@ func Xgetgrent(tls *TLS) (r uintptr) { return uintptr(0) } X__getgrent_a(tls, _f1, uintptr(unsafe.Pointer(&_gr1)), uintptr(unsafe.Pointer(&_line3)), bp+8, uintptr(unsafe.Pointer(&_mem1)), bp+16, bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func Xgetgrgid(tls *TLS, gid Tgid_t) (r uintptr) { @@ -125484,10 +125484,10 @@ func Xgetgrgid(tls *TLS, gid Tgid_t) (r uintptr) { var _ /* nmem at bp+16 */ Tsize_t var _ /* res at bp+0 */ uintptr var _ /* size at bp+8 */ Tsize_t - *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint64(0) - *(*Tsize_t)(unsafe.Pointer(bp + 16)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp + 8)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp + 16)) = uint64(0) X__getgr_a(tls, uintptr(0), gid, uintptr(unsafe.Pointer(&_gr1)), uintptr(unsafe.Pointer(&_line3)), bp+8, uintptr(unsafe.Pointer(&_mem1)), bp+16, bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func Xgetgrnam(tls *TLS, name uintptr) (r uintptr) { @@ -125500,10 +125500,10 @@ func Xgetgrnam(tls *TLS, name uintptr) (r uintptr) { var _ /* nmem at bp+16 */ Tsize_t var _ /* res at bp+0 */ uintptr var _ /* size at bp+8 */ Tsize_t - *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint64(0) - *(*Tsize_t)(unsafe.Pointer(bp + 16)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp + 8)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp + 16)) = uint64(0) X__getgr_a(tls, name, uint32(0), uintptr(unsafe.Pointer(&_gr1)), uintptr(unsafe.Pointer(&_line3)), bp+8, uintptr(unsafe.Pointer(&_mem1)), bp+16, bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func Xendgrent(tls *TLS) { @@ -125518,14 +125518,14 @@ func _atou(tls *TLS, s uintptr) (r uint32) { _ = x x = uint32(0) for { - if !(Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-int32('0')) < uint32(10)) { + if !(Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-int32('0')) < uint32(10)) { break } - x = uint32(10)*x + Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-Int32FromUint8('0')) + x = uint32(10)*x + Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-Int32FromUint8('0')) goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s)) = *(*uintptr)(unsafe.Pointer(s)) + 1 + **(**uintptr)(__ccgo_up(s)) = **(**uintptr)(__ccgo_up(s)) + 1 } return x } @@ -125551,107 +125551,107 @@ func X__getgrent_a(tls *TLS, f uintptr, gr uintptr, line uintptr, size uintptr, l = v2 if v2 < 0 { if Xferror(tls, f) != 0 { - v3 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v3 = **(**int32)(__ccgo_up(X__errno_location(tls))) } else { v3 = 0 } rv = v3 - Xfree(tls, *(*uintptr)(unsafe.Pointer(line))) - *(*uintptr)(unsafe.Pointer(line)) = uintptr(0) + Xfree(tls, **(**uintptr)(__ccgo_up(line))) + **(**uintptr)(__ccgo_up(line)) = uintptr(0) gr = uintptr(0) goto end } - *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(line)) + uintptr(l-int64(1)))) = uint8(0) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(line)) - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(line)) + uintptr(l-int64(1)))) = uint8(0) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(line)) + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = v4 - v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v4 + v4 = Xstrchr(tls, **(**uintptr)(__ccgo_up(bp)), int32(':')) + **(**uintptr)(__ccgo_up(bp)) = v4 if !(v4 != 0) { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) - (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = *(*uintptr)(unsafe.Pointer(bp)) - v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v4 + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) + (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = **(**uintptr)(__ccgo_up(bp)) + v4 = Xstrchr(tls, **(**uintptr)(__ccgo_up(bp)), int32(':')) + **(**uintptr)(__ccgo_up(bp)) = v4 if !(v4 != 0) { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) (*Tgroup)(unsafe.Pointer(gr)).Fgr_gid = _atou(tls, bp) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32(':') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) != int32(':') { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) - mems = *(*uintptr)(unsafe.Pointer(bp)) + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) + mems = **(**uintptr)(__ccgo_up(bp)) break goto _1 _1: } - *(*Tsize_t)(unsafe.Pointer(nmem)) = BoolUint64(!!(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) != 0)) + **(**Tsize_t)(__ccgo_up(nmem)) = BoolUint64(!!(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))) != 0)) for { - if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) != 0) { + if !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))) != 0) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32(',') { - *(*Tsize_t)(unsafe.Pointer(nmem)) = *(*Tsize_t)(unsafe.Pointer(nmem)) + 1 + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) == int32(',') { + **(**Tsize_t)(__ccgo_up(nmem)) = **(**Tsize_t)(__ccgo_up(nmem)) + 1 } goto _10 _10: ; - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - } - Xfree(tls, *(*uintptr)(unsafe.Pointer(mem))) - *(*uintptr)(unsafe.Pointer(mem)) = Xcalloc(tls, uint64(8), *(*Tsize_t)(unsafe.Pointer(nmem))+uint64(1)) - if !(*(*uintptr)(unsafe.Pointer(mem)) != 0) { - rv = *(*int32)(unsafe.Pointer(X__errno_location(tls))) - Xfree(tls, *(*uintptr)(unsafe.Pointer(line))) - *(*uintptr)(unsafe.Pointer(line)) = uintptr(0) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + } + Xfree(tls, **(**uintptr)(__ccgo_up(mem))) + **(**uintptr)(__ccgo_up(mem)) = Xcalloc(tls, uint64(8), **(**Tsize_t)(__ccgo_up(nmem))+uint64(1)) + if !(**(**uintptr)(__ccgo_up(mem)) != 0) { + rv = **(**int32)(__ccgo_up(X__errno_location(tls))) + Xfree(tls, **(**uintptr)(__ccgo_up(line))) + **(**uintptr)(__ccgo_up(line)) = uintptr(0) gr = uintptr(0) goto end } - if *(*uint8)(unsafe.Pointer(mems)) != 0 { - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)))) = mems - *(*uintptr)(unsafe.Pointer(bp)) = mems + if **(**uint8)(__ccgo_up(mems)) != 0 { + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)))) = mems + **(**uintptr)(__ccgo_up(bp)) = mems i = Uint64FromInt32(0) for { - if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) != 0) { + if !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))) != 0) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32(',') { - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) == int32(',') { + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) i = i + 1 v13 = i - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v13)*8)) = *(*uintptr)(unsafe.Pointer(bp)) + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)) + uintptr(v13)*8)) = **(**uintptr)(__ccgo_up(bp)) } goto _11 _11: ; - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 } i = i + 1 v13 = i - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v13)*8)) = uintptr(0) + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)) + uintptr(v13)*8)) = uintptr(0) } else { - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)))) = uintptr(0) + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)))) = uintptr(0) } - (*Tgroup)(unsafe.Pointer(gr)).Fgr_mem = *(*uintptr)(unsafe.Pointer(mem)) + (*Tgroup)(unsafe.Pointer(gr)).Fgr_mem = **(**uintptr)(__ccgo_up(mem)) goto end end: ; - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 8)), uintptr(0)) - *(*uintptr)(unsafe.Pointer(res)) = gr + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 8)), uintptr(0)) + **(**uintptr)(__ccgo_up(res)) = gr if rv != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = rv + **(**int32)(__ccgo_up(X__errno_location(tls))) = rv } return rv } @@ -125680,44 +125680,44 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, i, n, nbytes, nlim, nscdbuf, ret, rv, v1, v14, v3, v4, v6, v9 ret = -int32(1) n = int64(1) - *(*int32)(unsafe.Pointer(bp + 40)) = 0 + **(**int32)(__ccgo_up(bp + 40)) = 0 nscdbuf = uintptr(0) - *(*uintptr)(unsafe.Pointer(bp + 56)) = uintptr(0) - *(*uintptr)(unsafe.Pointer(bp + 64)) = uintptr(0) - *(*Tsize_t)(unsafe.Pointer(bp + 72)) = uint64(0) - nlim = *(*int32)(unsafe.Pointer(ngroups)) + **(**uintptr)(__ccgo_up(bp + 56)) = uintptr(0) + **(**uintptr)(__ccgo_up(bp + 64)) = uintptr(0) + **(**Tsize_t)(__ccgo_up(bp + 72)) = uint64(0) + nlim = **(**int32)(__ccgo_up(ngroups)) if nlim >= int32(1) { v1 = groups groups += 4 - *(*Tgid_t)(unsafe.Pointer(v1)) = gid + **(**Tgid_t)(__ccgo_up(v1)) = gid } f = X__nscd_query(tls, int32(GETINITGR), user, bp+44, uint64(12), bp+40) if !(f != 0) { goto cleanup } - if (*(*[3]Tint32_t)(unsafe.Pointer(bp + 44)))[int32(INITGRFOUND)] != 0 { - nscdbuf = Xcalloc(tls, Uint64FromInt32((*(*[3]Tint32_t)(unsafe.Pointer(bp + 44)))[int32(INITGRNGRPS)]), uint64(4)) + if (**(**[3]Tint32_t)(__ccgo_up(bp + 44)))[int32(INITGRFOUND)] != 0 { + nscdbuf = Xcalloc(tls, Uint64FromInt32((**(**[3]Tint32_t)(__ccgo_up(bp + 44)))[int32(INITGRNGRPS)]), uint64(4)) if !(nscdbuf != 0) { goto cleanup } - nbytes = uint64(4) * Uint64FromInt32((*(*[3]Tint32_t)(unsafe.Pointer(bp + 44)))[int32(INITGRNGRPS)]) + nbytes = uint64(4) * Uint64FromInt32((**(**[3]Tint32_t)(__ccgo_up(bp + 44)))[int32(INITGRNGRPS)]) if nbytes != 0 && !(Xfread(tls, nscdbuf, nbytes, uint64(1), f) != 0) { if !(Xferror(tls, f) != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EIO) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EIO) } goto cleanup } - if *(*int32)(unsafe.Pointer(bp + 40)) != 0 { + if **(**int32)(__ccgo_up(bp + 40)) != 0 { i = 0 for { - if !(i < int64((*(*[3]Tint32_t)(unsafe.Pointer(bp + 44)))[int32(INITGRNGRPS)])) { + if !(i < int64((**(**[3]Tint32_t)(__ccgo_up(bp + 44)))[int32(INITGRNGRPS)])) { break } - v3 = *(*Tuint32_t)(unsafe.Pointer(nscdbuf + uintptr(i)*4)) + v3 = **(**Tuint32_t)(__ccgo_up(nscdbuf + uintptr(i)*4)) v4 = v3>>int32(24) | v3>>int32(8)&uint32(0xff00) | v3<= Uint64FromUint64(0xffffffffffffffff)/Uint64FromInt32(8) { + if Uint64FromInt32((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWNAMELEN)]|(**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWPASSWDLEN)]|(**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWGECOSLEN)]|(**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWDIRLEN)]|(**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWSHELLLEN)]) >= Uint64FromUint64(0xffffffffffffffff)/Uint64FromInt32(8) { rv = int32(ENOMEM) goto cleanup_f } - len1 = Uint64FromInt32((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWNAMELEN)] + (*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWPASSWDLEN)] + (*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWGECOSLEN)] + (*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWDIRLEN)] + (*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWSHELLLEN)]) - if len1 > *(*Tsize_t)(unsafe.Pointer(size)) || !(*(*uintptr)(unsafe.Pointer(buf)) != 0) { - tmp = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(buf)), len1) + len1 = Uint64FromInt32((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWNAMELEN)] + (**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWPASSWDLEN)] + (**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWGECOSLEN)] + (**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWDIRLEN)] + (**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWSHELLLEN)]) + if len1 > **(**Tsize_t)(__ccgo_up(size)) || !(**(**uintptr)(__ccgo_up(buf)) != 0) { + tmp = Xrealloc(tls, **(**uintptr)(__ccgo_up(buf)), len1) if !(tmp != 0) { - rv = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + rv = **(**int32)(__ccgo_up(X__errno_location(tls))) goto cleanup_f } - *(*uintptr)(unsafe.Pointer(buf)) = tmp - *(*Tsize_t)(unsafe.Pointer(size)) = len1 + **(**uintptr)(__ccgo_up(buf)) = tmp + **(**Tsize_t)(__ccgo_up(size)) = len1 } - if !(Xfread(tls, *(*uintptr)(unsafe.Pointer(buf)), len1, uint64(1), f) != 0) { + if !(Xfread(tls, **(**uintptr)(__ccgo_up(buf)), len1, uint64(1), f) != 0) { if Xferror(tls, f) != 0 { - v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = **(**int32)(__ccgo_up(X__errno_location(tls))) } else { v1 = int32(EIO) } rv = v1 goto cleanup_f } - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = *(*uintptr)(unsafe.Pointer(buf)) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name + uintptr((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWNAMELEN)]) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd + uintptr((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWPASSWDLEN)]) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos + uintptr((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWGECOSLEN)]) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir + uintptr((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWDIRLEN)]) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_uid = Uint32FromInt32((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWUID)]) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gid = Uint32FromInt32((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWGID)]) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = **(**uintptr)(__ccgo_up(buf)) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name + uintptr((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWNAMELEN)]) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd + uintptr((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWPASSWDLEN)]) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos + uintptr((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWGECOSLEN)]) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir + uintptr((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWDIRLEN)]) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_uid = Uint32FromInt32((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWUID)]) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gid = Uint32FromInt32((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWGID)]) /* Don't assume that nscd made sure to null terminate strings. * It's supposed to, but malicious nscd should be ignored * rather than causing a crash. */ - if *(*uint8)(unsafe.Pointer((*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd + uintptr(-Int32FromInt32(1)))) != 0 || *(*uint8)(unsafe.Pointer((*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos + uintptr(-Int32FromInt32(1)))) != 0 || *(*uint8)(unsafe.Pointer((*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir + uintptr(-Int32FromInt32(1)))) != 0 || *(*uint8)(unsafe.Pointer((*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell + uintptr((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWSHELLLEN)]-int32(1)))) != 0 { + if **(**uint8)(__ccgo_up((*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd + uintptr(-Int32FromInt32(1)))) != 0 || **(**uint8)(__ccgo_up((*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos + uintptr(-Int32FromInt32(1)))) != 0 || **(**uint8)(__ccgo_up((*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir + uintptr(-Int32FromInt32(1)))) != 0 || **(**uint8)(__ccgo_up((*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell + uintptr((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWSHELLLEN)]-int32(1)))) != 0 { rv = int32(EIO) goto cleanup_f } @@ -125953,7 +125953,7 @@ func X__getpw_a(tls *TLS, name uintptr, uid Tuid_t, pw uintptr, buf uintptr, siz rv = int32(EIO) goto cleanup_f } - *(*uintptr)(unsafe.Pointer(res)) = pw + **(**uintptr)(__ccgo_up(res)) = pw goto cleanup_f cleanup_f: ; @@ -125963,9 +125963,9 @@ func X__getpw_a(tls *TLS, name uintptr, uid Tuid_t, pw uintptr, buf uintptr, siz goto done done: ; - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 4)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 4)), uintptr(0)) if rv != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = rv + **(**int32)(__ccgo_up(X__errno_location(tls))) = rv } return rv } @@ -125978,27 +125978,27 @@ func _getpw_r(tls *TLS, name uintptr, uid Tuid_t, pw uintptr, buf uintptr, size var _ /* len at bp+8 */ Tsize_t var _ /* line at bp+0 */ uintptr _ = rv - *(*uintptr)(unsafe.Pointer(bp)) = uintptr(0) - *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint64(0) + **(**uintptr)(__ccgo_up(bp)) = uintptr(0) + **(**Tsize_t)(__ccgo_up(bp + 8)) = uint64(0) rv = 0 _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp+16) rv = X__getpw_a(tls, name, uid, pw, bp, bp+8, res) - if *(*uintptr)(unsafe.Pointer(res)) != 0 && size < *(*Tsize_t)(unsafe.Pointer(bp + 8)) { - *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) + if **(**uintptr)(__ccgo_up(res)) != 0 && size < **(**Tsize_t)(__ccgo_up(bp + 8)) { + **(**uintptr)(__ccgo_up(res)) = uintptr(0) rv = int32(ERANGE) } - if *(*uintptr)(unsafe.Pointer(res)) != 0 { - Xmemcpy(tls, buf, *(*uintptr)(unsafe.Pointer(bp)), *(*Tsize_t)(unsafe.Pointer(bp + 8))) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_name)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf + if **(**uintptr)(__ccgo_up(res)) != 0 { + Xmemcpy(tls, buf, **(**uintptr)(__ccgo_up(bp)), **(**Tsize_t)(__ccgo_up(bp + 8))) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_name)-int64(**(**uintptr)(__ccgo_up(bp)))) + buf + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd)-int64(**(**uintptr)(__ccgo_up(bp)))) + buf + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos)-int64(**(**uintptr)(__ccgo_up(bp)))) + buf + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir)-int64(**(**uintptr)(__ccgo_up(bp)))) + buf + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell)-int64(**(**uintptr)(__ccgo_up(bp)))) + buf } - Xfree(tls, *(*uintptr)(unsafe.Pointer(bp))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 16)), uintptr(0)) + Xfree(tls, **(**uintptr)(__ccgo_up(bp))) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 16)), uintptr(0)) if rv != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = rv + **(**int32)(__ccgo_up(X__errno_location(tls))) = rv } return rv } @@ -126049,7 +126049,7 @@ func Xgetpwent(tls *TLS) (r uintptr) { return uintptr(0) } X__getpwent_a(tls, _f2, uintptr(unsafe.Pointer(&_pw1)), uintptr(unsafe.Pointer(&_line4)), uintptr(unsafe.Pointer(&_size)), bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func Xgetpwuid(tls *TLS, uid Tuid_t) (r uintptr) { @@ -126061,7 +126061,7 @@ func Xgetpwuid(tls *TLS, uid Tuid_t) (r uintptr) { defer tls.Free(16) var _ /* res at bp+0 */ uintptr X__getpw_a(tls, uintptr(0), uid, uintptr(unsafe.Pointer(&_pw1)), uintptr(unsafe.Pointer(&_line4)), uintptr(unsafe.Pointer(&_size)), bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func Xgetpwnam(tls *TLS, name uintptr) (r uintptr) { @@ -126073,7 +126073,7 @@ func Xgetpwnam(tls *TLS, name uintptr) (r uintptr) { defer tls.Free(16) var _ /* res at bp+0 */ uintptr X__getpw_a(tls, name, uint32(0), uintptr(unsafe.Pointer(&_pw1)), uintptr(unsafe.Pointer(&_line4)), uintptr(unsafe.Pointer(&_size)), bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func Xendpwent(tls *TLS) { @@ -126088,14 +126088,14 @@ func _atou1(tls *TLS, s uintptr) (r uint32) { _ = x x = uint32(0) for { - if !(Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-int32('0')) < uint32(10)) { + if !(Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-int32('0')) < uint32(10)) { break } - x = uint32(10)*x + Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-Int32FromUint8('0')) + x = uint32(10)*x + Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-Int32FromUint8('0')) goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s)) = *(*uintptr)(unsafe.Pointer(s)) + 1 + **(**uintptr)(__ccgo_up(s)) = **(**uintptr)(__ccgo_up(s)) + 1 } return x } @@ -126120,79 +126120,79 @@ func X__getpwent_a(tls *TLS, f uintptr, pw uintptr, line uintptr, size uintptr, l = v2 if v2 < 0 { if Xferror(tls, f) != 0 { - v3 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v3 = **(**int32)(__ccgo_up(X__errno_location(tls))) } else { v3 = 0 } rv = v3 - Xfree(tls, *(*uintptr)(unsafe.Pointer(line))) - *(*uintptr)(unsafe.Pointer(line)) = uintptr(0) + Xfree(tls, **(**uintptr)(__ccgo_up(line))) + **(**uintptr)(__ccgo_up(line)) = uintptr(0) pw = uintptr(0) break } - *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(line)) + uintptr(l-int64(1)))) = uint8(0) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(line)) - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(line)) + uintptr(l-int64(1)))) = uint8(0) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(line)) + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = v4 - v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v4 + v4 = Xstrchr(tls, **(**uintptr)(__ccgo_up(bp)), int32(':')) + **(**uintptr)(__ccgo_up(bp)) = v4 if !(v4 != 0) { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = *(*uintptr)(unsafe.Pointer(bp)) - v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v4 + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = **(**uintptr)(__ccgo_up(bp)) + v4 = Xstrchr(tls, **(**uintptr)(__ccgo_up(bp)), int32(':')) + **(**uintptr)(__ccgo_up(bp)) = v4 if !(v4 != 0) { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) (*Tpasswd)(unsafe.Pointer(pw)).Fpw_uid = _atou1(tls, bp) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32(':') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) != int32(':') { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gid = _atou1(tls, bp) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32(':') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) != int32(':') { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = *(*uintptr)(unsafe.Pointer(bp)) - v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v4 + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = **(**uintptr)(__ccgo_up(bp)) + v4 = Xstrchr(tls, **(**uintptr)(__ccgo_up(bp)), int32(':')) + **(**uintptr)(__ccgo_up(bp)) = v4 if !(v4 != 0) { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = *(*uintptr)(unsafe.Pointer(bp)) - v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v4 + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = **(**uintptr)(__ccgo_up(bp)) + v4 = Xstrchr(tls, **(**uintptr)(__ccgo_up(bp)), int32(':')) + **(**uintptr)(__ccgo_up(bp)) = v4 if !(v4 != 0) { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = *(*uintptr)(unsafe.Pointer(bp)) + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = **(**uintptr)(__ccgo_up(bp)) break goto _1 _1: } - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 8)), uintptr(0)) - *(*uintptr)(unsafe.Pointer(res)) = pw + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 8)), uintptr(0)) + **(**uintptr)(__ccgo_up(res)) = pw if rv != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = rv + **(**int32)(__ccgo_up(X__errno_location(tls))) = rv } return rv } @@ -126256,7 +126256,7 @@ func X__nscd_query(tls *TLS, req Tint32_t, key uintptr, buf uintptr, len1 Tsize_ var _ /* req_buf at bp+32 */ [3]Tint32_t _, _, _, _, _, _, _ = errno_save, f, fd, i, v1, v3, v4 f = uintptr(0) - *(*[3]Tint32_t)(unsafe.Pointer(bp + 32)) = [3]Tint32_t{ + **(**[3]Tint32_t)(__ccgo_up(bp + 32)) = [3]Tint32_t{ 0: int32(NSCDVERSION), 1: req, 2: Int32FromUint64(Xstrnlen(tls, key, uint64(LOGIN_NAME_MAX)) + uint64(1)), @@ -126271,23 +126271,23 @@ func X__nscd_query(tls *TLS, req Tint32_t, key uintptr, buf uintptr, len1 Tsize_ Fiov_len: _strlen(tls, key) + uint64(1), }, } - *(*Tmsghdr)(unsafe.Pointer(bp + 48)) = Tmsghdr{ + **(**Tmsghdr)(__ccgo_up(bp + 48)) = Tmsghdr{ Fmsg_iov: bp, Fmsg_iovlen: int32(2), } - errno_save = *(*int32)(unsafe.Pointer(X__errno_location(tls))) - *(*int32)(unsafe.Pointer(swap)) = 0 + errno_save = **(**int32)(__ccgo_up(X__errno_location(tls))) + **(**int32)(__ccgo_up(swap)) = 0 goto retry retry: ; Xmemset(tls, buf, 0, len1) - *(*Tint32_t)(unsafe.Pointer(buf)) = int32(NSCDVERSION) + **(**Tint32_t)(__ccgo_up(buf)) = int32(NSCDVERSION) fd = Xsocket(tls, int32(PF_LOCAL), Int32FromInt32(SOCK_STREAM)|Int32FromInt32(SOCK_CLOEXEC), 0) if fd < 0 { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EAFNOSUPPORT) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EAFNOSUPPORT) { f = Xfopen(tls, __ccgo_ts+1258, __ccgo_ts+1268) if f != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = errno_save + **(**int32)(__ccgo_up(X__errno_location(tls))) = errno_save } return f } @@ -126299,7 +126299,7 @@ retry: Xclose(tls, fd) return uintptr(0) } - if (*(*[3]Tint32_t)(unsafe.Pointer(bp + 32)))[int32(2)] > int32(LOGIN_NAME_MAX) { + if (**(**[3]Tint32_t)(__ccgo_up(bp + 32)))[int32(2)] > int32(LOGIN_NAME_MAX) { return f } if Xconnect(tls, fd, uintptr(unsafe.Pointer(&_addr)), uint32(24)) < 0 { @@ -126307,8 +126307,8 @@ retry: * result and the caller is responsible for calling * fclose on the (unconnected) socket. The value of * errno must be left unchanged in this case. */ - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EACCES) || *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ECONNREFUSED) || *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENOENT) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = errno_save + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EACCES) || **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ECONNREFUSED) || **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENOENT) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = errno_save return f } goto error @@ -126325,41 +126325,41 @@ retry: if Xferror(tls, f) != 0 { goto error } - if !(*(*int32)(unsafe.Pointer(swap)) != 0) { + if !(**(**int32)(__ccgo_up(swap)) != 0) { Xfclose(tls, f) i = uint64(0) for { if !(i < Uint64FromInt64(12)/Uint64FromInt64(4)) { break } - v3 = Uint32FromInt32((*(*[3]Tint32_t)(unsafe.Pointer(bp + 32)))[i]) + v3 = Uint32FromInt32((**(**[3]Tint32_t)(__ccgo_up(bp + 32)))[i]) v4 = v3>>int32(24) | v3>>int32(8)&uint32(0xff00) | v3<>int32(24) | v3>>int32(8)&uint32(0xff00) | v3<> int32(16)) - *(*uint16)(unsafe.Pointer(xi + 2*2)) = uint16(x >> int32(32)) + x = uint64(uint32(**(**uint16)(__ccgo_up(xi)))|(uint32(**(**uint16)(__ccgo_up(xi + 1*2)))+0)<> int32(16)) + **(**uint16)(__ccgo_up(xi + 2*2)) = uint16(x >> int32(32)) return x & uint64(0xffffffffffff) } @@ -126669,8 +126669,8 @@ func Xrand_r(tls *TLS, seed uintptr) (r int32) { } var v1 uint32 _ = v1 - v1 = *(*uint32)(unsafe.Pointer(seed))*Uint32FromInt32(1103515245) + Uint32FromInt32(12345) - *(*uint32)(unsafe.Pointer(seed)) = v1 + v1 = **(**uint32)(__ccgo_up(seed))*Uint32FromInt32(1103515245) + Uint32FromInt32(12345) + **(**uint32)(__ccgo_up(seed)) = v1 return Int32FromUint32(_temper(tls, v1) / uint32(2)) } @@ -126729,15 +126729,15 @@ func _lcg64(tls *TLS, x Tuint64_t) (r Tuint64_t) { } func _savestate(tls *TLS) (r uintptr) { - *(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(-Int32FromInt32(1))*4)) = Uint32FromInt32(_n<> int32(16)) - _i = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(-Int32FromInt32(1))*4)) >> Int32FromInt32(8) & uint32(0xff)) - _j = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(-Int32FromInt32(1))*4)) & uint32(0xff)) + _n = Int32FromUint32(**(**Tuint32_t)(__ccgo_up(_x1 + uintptr(-Int32FromInt32(1))*4)) >> int32(16)) + _i = Int32FromUint32(**(**Tuint32_t)(__ccgo_up(_x1 + uintptr(-Int32FromInt32(1))*4)) >> Int32FromInt32(8) & uint32(0xff)) + _j = Int32FromUint32(**(**Tuint32_t)(__ccgo_up(_x1 + uintptr(-Int32FromInt32(1))*4)) & uint32(0xff)) } func ___srandom(tls *TLS, seed uint32) { @@ -126746,7 +126746,7 @@ func ___srandom(tls *TLS, seed uint32) { _, _, _ = k, s, v1 s = uint64(seed) if _n == 0 { - *(*Tuint32_t)(unsafe.Pointer(_x1)) = uint32(s) + **(**Tuint32_t)(__ccgo_up(_x1)) = uint32(s) return } if _n == int32(31) || _n == int32(7) { @@ -126762,14 +126762,14 @@ func ___srandom(tls *TLS, seed uint32) { break } s = _lcg64(tls, s) - *(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(k)*4)) = uint32(s >> int32(32)) + **(**Tuint32_t)(__ccgo_up(_x1 + uintptr(k)*4)) = uint32(s >> int32(32)) goto _2 _2: ; k = k + 1 } /* make sure x contains at least one odd number */ - *(*Tuint32_t)(unsafe.Pointer(_x1)) |= uint32(1) + **(**Tuint32_t)(__ccgo_up(_x1)) |= uint32(1) } func Xsrandom(tls *TLS, seed uint32) { @@ -126842,13 +126842,13 @@ func Xrandom(tls *TLS) (r int64) { _, _, _ = k, v1, v2 ___lock(tls, uintptr(unsafe.Pointer(&_lock3))) if _n == 0 { - v1 = _lcg31(tls, *(*Tuint32_t)(unsafe.Pointer(_x1))) - *(*Tuint32_t)(unsafe.Pointer(_x1)) = v1 + v1 = _lcg31(tls, **(**Tuint32_t)(__ccgo_up(_x1))) + **(**Tuint32_t)(__ccgo_up(_x1)) = v1 k = Int64FromUint32(v1) goto end } - *(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(_i)*4)) += *(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(_j)*4)) - k = Int64FromUint32(*(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(_i)*4)) >> int32(1)) + **(**Tuint32_t)(__ccgo_up(_x1 + uintptr(_i)*4)) += **(**Tuint32_t)(__ccgo_up(_x1 + uintptr(_j)*4)) + k = Int64FromUint32(**(**Tuint32_t)(__ccgo_up(_x1 + uintptr(_i)*4)) >> int32(1)) _i = _i + 1 v2 = _i if v2 == _n { @@ -127054,8 +127054,8 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { defer func() { Xrealloc(tls, b, 0) }() path = Xgetenv(tls, __ccgo_ts+1361) seen_eacces = 0 - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOENT) - if !(*(*uint8)(unsafe.Pointer(file)) != 0) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOENT) + if !(**(**uint8)(__ccgo_up(file)) != 0) { return -int32(1) } if Xstrchr(tls, file, int32('/')) != 0 { @@ -127066,7 +127066,7 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { } k = Xstrnlen(tls, file, Uint64FromInt32(Int32FromInt32(NAME_MAX)+Int32FromInt32(1))) if k > uint64(NAME_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENAMETOOLONG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENAMETOOLONG) return -int32(1) } l = Xstrnlen(tls, path, Uint64FromInt32(Int32FromInt32(PATH_MAX)-Int32FromInt32(1))) + uint64(1) @@ -127078,7 +127078,7 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { if Uint64FromInt64(int64(z)-int64(p)) >= l { v3 = z z = z + 1 - if !(*(*uint8)(unsafe.Pointer(v3)) != 0) { + if !(**(**uint8)(__ccgo_up(v3)) != 0) { break } goto _1 @@ -127087,7 +127087,7 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { *(*uint8)(unsafe.Add(unsafe.Pointer(b), int64(z)-int64(p))) = uint8('/') Xmemcpy(tls, b+uintptr(int64(z)-int64(p))+BoolUintptr(z > p), file, k+uint64(1)) Xexecve(tls, b, argv, envp) - switch *(*int32)(unsafe.Pointer(X__errno_location(tls))) { + switch **(**int32)(__ccgo_up(X__errno_location(tls))) { case int32(EACCES): seen_eacces = int32(1) fallthrough @@ -127099,7 +127099,7 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { } v3 = z z = z + 1 - if !(*(*uint8)(unsafe.Pointer(v3)) != 0) { + if !(**(**uint8)(__ccgo_up(v3)) != 0) { break } goto _1 @@ -127108,7 +127108,7 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { p = z } if seen_eacces != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EACCES) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EACCES) } return -int32(1) } @@ -127145,8 +127145,8 @@ func Xfexecve(tls *TLS, fd int32, argv uintptr, envp uintptr) (r1 int32) { } X__procfdname(tls, bp, Uint32FromInt32(fd)) Xexecve(tls, bp, argv, envp) - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENOENT) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EBADF) + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENOENT) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EBADF) } return -int32(1) } @@ -127383,7 +127383,7 @@ func Xposix_spawnattr_getflags(tls *TLS, attr uintptr, flags uintptr) (r int32) trc("tls=%v attr=%v flags=%v, (%v:)", tls, attr, flags, origin(2)) defer func() { trc("-> %v", r) }() } - *(*int16)(unsafe.Pointer(flags)) = int16((*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__flags) + **(**int16)(__ccgo_up(flags)) = int16((*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__flags) return 0 } @@ -127392,7 +127392,7 @@ func Xposix_spawnattr_getpgroup(tls *TLS, attr uintptr, pgrp uintptr) (r int32) trc("tls=%v attr=%v pgrp=%v, (%v:)", tls, attr, pgrp, origin(2)) defer func() { trc("-> %v", r) }() } - *(*Tpid_t)(unsafe.Pointer(pgrp)) = (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__pgrp + **(**Tpid_t)(__ccgo_up(pgrp)) = (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__pgrp return 0 } @@ -127401,7 +127401,7 @@ func Xposix_spawnattr_getsigdefault(tls *TLS, attr uintptr, def uintptr) (r int3 trc("tls=%v attr=%v def=%v, (%v:)", tls, attr, def, origin(2)) defer func() { trc("-> %v", r) }() } - *(*Tsigset_t)(unsafe.Pointer(def)) = (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__def + **(**Tsigset_t)(__ccgo_up(def)) = (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__def return 0 } @@ -127410,7 +127410,7 @@ func Xposix_spawnattr_getsigmask(tls *TLS, attr uintptr, mask uintptr) (r int32) trc("tls=%v attr=%v mask=%v, (%v:)", tls, attr, mask, origin(2)) defer func() { trc("-> %v", r) }() } - *(*Tsigset_t)(unsafe.Pointer(mask)) = (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__mask + **(**Tsigset_t)(__ccgo_up(mask)) = (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__mask return 0 } @@ -127419,7 +127419,7 @@ func Xposix_spawnattr_init(tls *TLS, attr uintptr) (r int32) { trc("tls=%v attr=%v, (%v:)", tls, attr, origin(2)) defer func() { trc("-> %v", r) }() } - *(*Tposix_spawnattr_t)(unsafe.Pointer(attr)) = Tposix_spawnattr_t{} + **(**Tposix_spawnattr_t)(__ccgo_up(attr)) = Tposix_spawnattr_t{} return 0 } @@ -127484,7 +127484,7 @@ func Xposix_spawnattr_setsigdefault(tls *TLS, attr uintptr, def uintptr) (r int3 trc("tls=%v attr=%v def=%v, (%v:)", tls, attr, def, origin(2)) defer func() { trc("-> %v", r) }() } - (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__def = *(*Tsigset_t)(unsafe.Pointer(def)) + (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__def = **(**Tsigset_t)(__ccgo_up(def)) return 0 } @@ -127493,7 +127493,7 @@ func Xposix_spawnattr_setsigmask(tls *TLS, attr uintptr, mask uintptr) (r int32) trc("tls=%v attr=%v mask=%v, (%v:)", tls, attr, mask, origin(2)) defer func() { trc("-> %v", r) }() } - (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__mask = *(*Tsigset_t)(unsafe.Pointer(mask)) + (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__mask = **(**Tsigset_t)(__ccgo_up(mask)) return 0 } @@ -127551,20 +127551,20 @@ func _str_next(tls *TLS, str uintptr, n Tsize_t, step uintptr) (r int32) { var _ /* wc at bp+0 */ Twchar_t _ = k if !(n != 0) { - *(*Tsize_t)(unsafe.Pointer(step)) = uint64(0) + **(**Tsize_t)(__ccgo_up(step)) = uint64(0) return 0 } - if uint32(*(*uint8)(unsafe.Pointer(str))) >= uint32(128) { + if uint32(**(**uint8)(__ccgo_up(str))) >= uint32(128) { k = Xmbtowc(tls, bp, str, n) if k < 0 { - *(*Tsize_t)(unsafe.Pointer(step)) = uint64(1) + **(**Tsize_t)(__ccgo_up(step)) = uint64(1) return -int32(1) } - *(*Tsize_t)(unsafe.Pointer(step)) = Uint64FromInt32(k) - return Int32FromUint32(*(*Twchar_t)(unsafe.Pointer(bp))) + **(**Tsize_t)(__ccgo_up(step)) = Uint64FromInt32(k) + return Int32FromUint32(**(**Twchar_t)(__ccgo_up(bp))) } - *(*Tsize_t)(unsafe.Pointer(step)) = uint64(1) - return Int32FromUint8(*(*uint8)(unsafe.Pointer(str))) + **(**Tsize_t)(__ccgo_up(step)) = uint64(1) + return Int32FromUint8(**(**uint8)(__ccgo_up(str))) } func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r int32) { @@ -127575,43 +127575,43 @@ func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r i var _ /* wc at bp+0 */ Twchar_t _, _, _, _ = esc, k, k1, z esc = 0 - if !(m != 0) || !(*(*uint8)(unsafe.Pointer(pat)) != 0) { - *(*Tsize_t)(unsafe.Pointer(step)) = uint64(0) + if !(m != 0) || !(**(**uint8)(__ccgo_up(pat)) != 0) { + **(**Tsize_t)(__ccgo_up(step)) = uint64(0) return END } - *(*Tsize_t)(unsafe.Pointer(step)) = uint64(1) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) == int32('\\') && *(*uint8)(unsafe.Pointer(pat + 1)) != 0 && !(flags&Int32FromInt32(FNM_NOESCAPE) != 0) { - *(*Tsize_t)(unsafe.Pointer(step)) = uint64(2) + **(**Tsize_t)(__ccgo_up(step)) = uint64(1) + if Int32FromUint8(**(**uint8)(__ccgo_up(pat))) == int32('\\') && **(**uint8)(__ccgo_up(pat + 1)) != 0 && !(flags&Int32FromInt32(FNM_NOESCAPE) != 0) { + **(**Tsize_t)(__ccgo_up(step)) = uint64(2) pat = pat + 1 esc = int32(1) goto escaped } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) == int32('[') { + if Int32FromUint8(**(**uint8)(__ccgo_up(pat))) == int32('[') { k = uint64(1) if k < m { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) == int32('^') || Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) == int32('!') { + if Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k)))) == int32('^') || Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k)))) == int32('!') { k = k + 1 } } if k < m { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) == int32(']') { + if Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k)))) == int32(']') { k = k + 1 } } for { - if !(k < m && *(*uint8)(unsafe.Pointer(pat + uintptr(k))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) != int32(']')) { + if !(k < m && **(**uint8)(__ccgo_up(pat + uintptr(k))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k)))) != int32(']')) { break } - if k+uint64(1) < m && *(*uint8)(unsafe.Pointer(pat + uintptr(k+uint64(1)))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) == int32('[') && (Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k+uint64(1))))) == int32(':') || Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k+uint64(1))))) == int32('.') || Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k+uint64(1))))) == int32('=')) { - z = Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k+uint64(1))))) + if k+uint64(1) < m && **(**uint8)(__ccgo_up(pat + uintptr(k+uint64(1)))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k)))) == int32('[') && (Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k+uint64(1))))) == int32(':') || Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k+uint64(1))))) == int32('.') || Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k+uint64(1))))) == int32('=')) { + z = Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k+uint64(1))))) k = k + uint64(2) - if k < m && *(*uint8)(unsafe.Pointer(pat + uintptr(k))) != 0 { + if k < m && **(**uint8)(__ccgo_up(pat + uintptr(k))) != 0 { k = k + 1 } - for k < m && *(*uint8)(unsafe.Pointer(pat + uintptr(k))) != 0 && (Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k-uint64(1))))) != z || Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) != int32(']')) { + for k < m && **(**uint8)(__ccgo_up(pat + uintptr(k))) != 0 && (Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k-uint64(1))))) != z || Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k)))) != int32(']')) { k = k + 1 } - if k == m || !(*(*uint8)(unsafe.Pointer(pat + uintptr(k))) != 0) { + if k == m || !(**(**uint8)(__ccgo_up(pat + uintptr(k))) != 0) { break } } @@ -127620,32 +127620,32 @@ func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r i ; k = k + 1 } - if k == m || !(*(*uint8)(unsafe.Pointer(pat + uintptr(k))) != 0) { - *(*Tsize_t)(unsafe.Pointer(step)) = uint64(1) + if k == m || !(**(**uint8)(__ccgo_up(pat + uintptr(k))) != 0) { + **(**Tsize_t)(__ccgo_up(step)) = uint64(1) return int32('[') } - *(*Tsize_t)(unsafe.Pointer(step)) = k + uint64(1) + **(**Tsize_t)(__ccgo_up(step)) = k + uint64(1) return -int32(3) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) == int32('*') { + if Int32FromUint8(**(**uint8)(__ccgo_up(pat))) == int32('*') { return -int32(5) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) == int32('?') { + if Int32FromUint8(**(**uint8)(__ccgo_up(pat))) == int32('?') { return -int32(4) } goto escaped escaped: ; - if uint32(*(*uint8)(unsafe.Pointer(pat))) >= uint32(128) { + if uint32(**(**uint8)(__ccgo_up(pat))) >= uint32(128) { k1 = Xmbtowc(tls, bp, pat, m) if k1 < 0 { - *(*Tsize_t)(unsafe.Pointer(step)) = uint64(0) + **(**Tsize_t)(__ccgo_up(step)) = uint64(0) return -int32(2) } - *(*Tsize_t)(unsafe.Pointer(step)) = Uint64FromInt32(k1 + esc) - return Int32FromUint32(*(*Twchar_t)(unsafe.Pointer(bp))) + **(**Tsize_t)(__ccgo_up(step)) = Uint64FromInt32(k1 + esc) + return Int32FromUint32(**(**Twchar_t)(__ccgo_up(bp))) } - return Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) + return Int32FromUint8(**(**uint8)(__ccgo_up(pat))) } func _casefold(tls *TLS, k int32) (r int32) { @@ -127672,59 +127672,59 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { _, _, _, _, _ = inv, l, l1, p0, z inv = 0 p = p + 1 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('^') || Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('!') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('^') || Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('!') { inv = int32(1) p = p + 1 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32(']') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32(']') { if k == int32(']') { return BoolInt32(!(inv != 0)) } p = p + 1 } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('-') { if k == int32('-') { return BoolInt32(!(inv != 0)) } p = p + 1 } } - *(*Twchar_t)(unsafe.Pointer(bp)) = uint32(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) + **(**Twchar_t)(__ccgo_up(bp)) = uint32(**(**uint8)(__ccgo_up(p + uintptr(-Int32FromInt32(1))))) for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32(']')) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(p))) != int32(']')) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') && Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) != int32(']') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('-') && Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) != int32(']') { l = Xmbtowc(tls, bp+4, p+uintptr(1), uint64(4)) if l < 0 { return 0 } - if *(*Twchar_t)(unsafe.Pointer(bp)) <= *(*Twchar_t)(unsafe.Pointer(bp + 4)) { - if Uint32FromInt32(k)-*(*Twchar_t)(unsafe.Pointer(bp)) <= *(*Twchar_t)(unsafe.Pointer(bp + 4))-*(*Twchar_t)(unsafe.Pointer(bp)) || Uint32FromInt32(kfold)-*(*Twchar_t)(unsafe.Pointer(bp)) <= *(*Twchar_t)(unsafe.Pointer(bp + 4))-*(*Twchar_t)(unsafe.Pointer(bp)) { + if **(**Twchar_t)(__ccgo_up(bp)) <= **(**Twchar_t)(__ccgo_up(bp + 4)) { + if Uint32FromInt32(k)-**(**Twchar_t)(__ccgo_up(bp)) <= **(**Twchar_t)(__ccgo_up(bp + 4))-**(**Twchar_t)(__ccgo_up(bp)) || Uint32FromInt32(kfold)-**(**Twchar_t)(__ccgo_up(bp)) <= **(**Twchar_t)(__ccgo_up(bp + 4))-**(**Twchar_t)(__ccgo_up(bp)) { return BoolInt32(!(inv != 0)) } } p = p + uintptr(l-int32(1)) goto _1 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('[') && (Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32(':') || Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('.') || Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('=')) { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('[') && (Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) == int32(':') || Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) == int32('.') || Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) == int32('=')) { p0 = p + uintptr(2) - z = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) + z = Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) p = p + uintptr(3) - for Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) != z || Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32(']') { + for Int32FromUint8(**(**uint8)(__ccgo_up(p + uintptr(-Int32FromInt32(1))))) != z || Int32FromUint8(**(**uint8)(__ccgo_up(p))) != int32(']') { p = p + 1 } if z == int32(':') && int64(p-uintptr(1))-int64(p0) < int64(16) { Xmemcpy(tls, bp+8, p0, Uint64FromInt64(int64(p-uintptr(1))-int64(p0))) - (*(*[16]uint8)(unsafe.Pointer(bp + 8)))[int64(p-uintptr(1))-int64(p0)] = uint8(0) + (**(**[16]uint8)(__ccgo_up(bp + 8)))[int64(p-uintptr(1))-int64(p0)] = uint8(0) if Xiswctype(tls, Uint32FromInt32(k), Xwctype(tls, bp+8)) != 0 || Xiswctype(tls, Uint32FromInt32(kfold), Xwctype(tls, bp+8)) != 0 { return BoolInt32(!(inv != 0)) } } goto _1 } - if uint32(*(*uint8)(unsafe.Pointer(p))) < uint32(128) { - *(*Twchar_t)(unsafe.Pointer(bp)) = uint32(*(*uint8)(unsafe.Pointer(p))) + if uint32(**(**uint8)(__ccgo_up(p))) < uint32(128) { + **(**Twchar_t)(__ccgo_up(bp)) = uint32(uint8(**(**uint8)(__ccgo_up(p)))) } else { l1 = Xmbtowc(tls, bp, p, uint64(4)) if l1 < 0 { @@ -127732,7 +127732,7 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { } p = p + uintptr(l1-int32(1)) } - if *(*Twchar_t)(unsafe.Pointer(bp)) == Uint32FromInt32(k) || *(*Twchar_t)(unsafe.Pointer(bp)) == Uint32FromInt32(kfold) { + if **(**Twchar_t)(__ccgo_up(bp)) == Uint32FromInt32(k) || **(**Twchar_t)(__ccgo_up(bp)) == Uint32FromInt32(kfold) { return BoolInt32(!(inv != 0)) } goto _1 @@ -127755,7 +127755,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, endpat, endstr, k, kfold, p, ptail, s, stail, tailcnt, v2, v6, v9 tailcnt = uint64(0) if flags&int32(FNM_PERIOD) != 0 { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(str))) == int32('.') && Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) != int32('.') { + if Int32FromUint8(**(**uint8)(__ccgo_up(str))) == int32('.') && Int32FromUint8(**(**uint8)(__ccgo_up(pat))) != int32('.') { return int32(FNM_NOMATCH) } } @@ -127778,8 +127778,8 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, } return v2 } - str = str + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) - n = n - *(*Tsize_t)(unsafe.Pointer(bp + 8)) + str = str + uintptr(**(**Tsize_t)(__ccgo_up(bp + 8))) + n = n - **(**Tsize_t)(__ccgo_up(bp + 8)) if flags&int32(FNM_CASEFOLD) != 0 { v2 = _casefold(tls, k) } else { @@ -127795,8 +127795,8 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, return int32(FNM_NOMATCH) } } - pat = pat + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) - m = m - *(*Tsize_t)(unsafe.Pointer(bp)) + pat = pat + uintptr(**(**Tsize_t)(__ccgo_up(bp))) + m = m - **(**Tsize_t)(__ccgo_up(bp)) goto _1 } break @@ -127827,7 +127827,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, goto _5 _5: ; - p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(**(**Tsize_t)(__ccgo_up(bp))) } /* Past this point we need not check for UNMATCHABLE in pat, * because all of pat has already been parsed once. */ @@ -127845,8 +127845,8 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, if !(s > str && tailcnt != 0) { break } - if v9 = uint32(*(*uint8)(unsafe.Pointer(s + uintptr(-Int32FromInt32(1))))) < uint32(128); !v9 { - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if v9 = uint32(**(**uint8)(__ccgo_up(s + uintptr(-Int32FromInt32(1))))) < uint32(128); !v9 { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v2 = int32(4) } else { v2 = int32(1) @@ -127858,7 +127858,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, for { s = s - 1 v6 = s - if !(uint32(*(*uint8)(unsafe.Pointer(v6)))-uint32(0x80) < uint32(0x40) && s > str) { + if !(uint32(uint8(**(**uint8)(__ccgo_up(v6))))-uint32(0x80) < uint32(0x40) && s > str) { break } } @@ -127876,7 +127876,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, p = ptail for { c = _pat_next(tls, p, Uint64FromInt64(int64(endpat)-int64(p)), bp, flags) - p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(**(**Tsize_t)(__ccgo_up(bp))) v2 = _str_next(tls, s, Uint64FromInt64(int64(endstr)-int64(s)), bp+8) k = v2 if v2 <= 0 { @@ -127885,7 +127885,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, } break } - s = s + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) + s = s + uintptr(**(**Tsize_t)(__ccgo_up(bp + 8))) if flags&int32(FNM_CASEFOLD) != 0 { v2 = _casefold(tls, k) } else { @@ -127893,7 +127893,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, } kfold = v2 if c == -int32(3) { - if !(_match_bracket(tls, p-uintptr(*(*Tsize_t)(unsafe.Pointer(bp))), k, kfold) != 0) { + if !(_match_bracket(tls, p-uintptr(**(**Tsize_t)(__ccgo_up(bp))), k, kfold) != 0) { return int32(FNM_NOMATCH) } } else { @@ -127913,7 +127913,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, s = str for { c = _pat_next(tls, p, Uint64FromInt64(int64(endpat)-int64(p)), bp, flags) - p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(**(**Tsize_t)(__ccgo_up(bp))) /* Encountering * completes/commits a component */ if c == -int32(5) { pat = p @@ -127931,7 +127931,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, } kfold = v2 if c == -int32(3) { - if !(_match_bracket(tls, p-uintptr(*(*Tsize_t)(unsafe.Pointer(bp))), k, kfold) != 0) { + if !(_match_bracket(tls, p-uintptr(**(**Tsize_t)(__ccgo_up(bp))), k, kfold) != 0) { break } } else { @@ -127939,7 +127939,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, break } } - s = s + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) + s = s + uintptr(**(**Tsize_t)(__ccgo_up(bp + 8))) goto _14 _14: } @@ -127950,7 +127950,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, * char, or past all invalid bytes otherwise. */ k = _str_next(tls, str, Uint64FromInt64(int64(endstr)-int64(str)), bp+8) if k > 0 { - str = str + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) + str = str + uintptr(**(**Tsize_t)(__ccgo_up(bp + 8))) } else { str = str + 1 for { @@ -127982,7 +127982,7 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { for { s = str for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('/')) { + if !(**(**uint8)(__ccgo_up(s)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32('/')) { break } goto _2 @@ -128000,9 +128000,9 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { goto _3 _3: ; - p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(**(**Tsize_t)(__ccgo_up(bp))) } - if c != Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) && (!(*(*uint8)(unsafe.Pointer(s)) != 0) || !(flags&Int32FromInt32(FNM_LEADING_DIR) != 0)) { + if c != Int32FromUint8(**(**uint8)(__ccgo_up(s))) && (!(**(**uint8)(__ccgo_up(s)) != 0) || !(flags&Int32FromInt32(FNM_LEADING_DIR) != 0)) { return int32(FNM_NOMATCH) } if _fnmatch_internal(tls, pat, Uint64FromInt64(int64(p)-int64(pat)), str, Uint64FromInt64(int64(s)-int64(str)), flags) != 0 { @@ -128012,7 +128012,7 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { return 0 } str = s + uintptr(1) - pat = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + pat = p + uintptr(**(**Tsize_t)(__ccgo_up(bp))) goto _1 _1: } @@ -128020,10 +128020,10 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { if flags&int32(FNM_LEADING_DIR) != 0 { s = str for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('/') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32('/') { goto _5 } if !(_fnmatch_internal(tls, pat, Uint64FromInt32(-Int32FromInt32(1)), str, Uint64FromInt64(int64(s)-int64(str)), flags) != 0) { @@ -128073,14 +128073,14 @@ func _append(tls *TLS, tail uintptr, name uintptr, len1 Tsize_t, mark int32) (r if !(new1 != 0) { return -int32(1) } - (*Tmatch)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tail)))).Fnext = new1 + (*Tmatch)(unsafe.Pointer(**(**uintptr)(__ccgo_up(tail)))).Fnext = new1 (*Tmatch)(unsafe.Pointer(new1)).Fnext = UintptrFromInt32(0) Xmemcpy(tls, new1+8, name, len1+uint64(1)) - if mark != 0 && len1 != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(name + uintptr(len1-uint64(1))))) != int32('/') { + if mark != 0 && len1 != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(name + uintptr(len1-uint64(1))))) != int32('/') { *(*uint8)(unsafe.Pointer(new1 + 8 + uintptr(len1))) = uint8('/') *(*uint8)(unsafe.Pointer(new1 + 8 + uintptr(len1+uint64(1)))) = uint8(0) } - *(*uintptr)(unsafe.Pointer(tail)) = new1 + **(**uintptr)(__ccgo_up(tail)) = new1 return 0 } @@ -128100,15 +128100,15 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag } /* Special-case the remaining pattern being all slashes, in * which case we can use caller-passed type if it's a dir. */ - if *(*uint8)(unsafe.Pointer(pat)) != 0 && type1 != int32(DT_DIR) { + if **(**uint8)(__ccgo_up(pat)) != 0 && type1 != int32(DT_DIR) { type1 = 0 } - for pos+uint64(1) < uint64(PATH_MAX) && Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) == int32('/') { + for pos+uint64(1) < uint64(PATH_MAX) && Int32FromUint8(**(**uint8)(__ccgo_up(pat))) == int32('/') { v1 = pos pos = pos + 1 v2 = pat pat = pat + 1 - *(*uint8)(unsafe.Pointer(buf + uintptr(v1))) = *(*uint8)(unsafe.Pointer(v2)) + **(**uint8)(__ccgo_up(buf + uintptr(v1))) = **(**uint8)(__ccgo_up(v2)) } /* Consume maximal [escaped-]literal prefix of pattern, copying * and un-escaping it to the running buffer as we go. */ @@ -128117,10 +128117,10 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag in_bracket = 0 overflow = 0 for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(i)))) != int32('*') && Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(i)))) != int32('?') && (!(in_bracket != 0) || Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(i)))) != int32(']'))) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(i)))) != int32('*') && Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(i)))) != int32('?') && (!(in_bracket != 0) || Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(i)))) != int32(']'))) { break } - if !(*(*uint8)(unsafe.Pointer(pat + uintptr(i))) != 0) { + if !(**(**uint8)(__ccgo_up(pat + uintptr(i))) != 0) { if overflow != 0 { return 0 } @@ -128131,25 +128131,25 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag i = v4 break } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(i)))) == int32('[') { + if Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(i)))) == int32('[') { in_bracket = int32(1) } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(i)))) == int32('\\') && !(flags&Int32FromInt32(GLOB_NOESCAPE) != 0) { + if Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(i)))) == int32('\\') && !(flags&Int32FromInt32(GLOB_NOESCAPE) != 0) { /* Backslashes inside a bracket are (at least by * our interpretation) non-special, so if next * char is ']' we have a complete expression. */ - if in_bracket != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(i+int64(1))))) == int32(']') { + if in_bracket != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(i+int64(1))))) == int32(']') { break } /* Unpaired final backslash never matches. */ - if !(*(*uint8)(unsafe.Pointer(pat + uintptr(i+int64(1)))) != 0) { + if !(**(**uint8)(__ccgo_up(pat + uintptr(i+int64(1)))) != 0) { return 0 } i = i + 1 } } } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(i)))) == int32('/') { + if Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(i)))) == int32('/') { if overflow != 0 { return 0 } @@ -128167,7 +128167,7 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag if pos+Uint64FromInt64(j+Int64FromInt32(1)) < uint64(PATH_MAX) { v4 = j j = j + 1 - *(*uint8)(unsafe.Pointer(buf + uintptr(pos+Uint64FromInt64(v4)))) = *(*uint8)(unsafe.Pointer(pat + uintptr(i))) + **(**uint8)(__ccgo_up(buf + uintptr(pos+Uint64FromInt64(v4)))) = **(**uint8)(__ccgo_up(pat + uintptr(i))) } else { if in_bracket != 0 { overflow = int32(1) @@ -128183,17 +128183,17 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag ; i = i + 1 } - *(*uint8)(unsafe.Pointer(buf + uintptr(pos))) = uint8(0) - if !(*(*uint8)(unsafe.Pointer(pat)) != 0) { + **(**uint8)(__ccgo_up(buf + uintptr(pos))) = uint8(0) + if !(**(**uint8)(__ccgo_up(pat)) != 0) { if flags&int32(GLOB_MARK) != 0 && (!(type1 != 0) || type1 == int32(DT_LNK)) && !(Xstat(tls, buf, bp) != 0) { - if (*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFDIR) { + if (**(**Tstat)(__ccgo_up(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFDIR) { type1 = int32(DT_DIR) } else { type1 = int32(DT_REG) } } if !(type1 != 0) && Xlstat(tls, buf, bp) != 0 { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(ENOENT) && ((*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(ENOENT) && ((*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, **(**int32)(__ccgo_up(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0) { return int32(GLOB_ABORTED) } return 0 @@ -128210,7 +128210,7 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag if p2 != 0 && !(flags&Int32FromInt32(GLOB_NOESCAPE) != 0) { p = p2 for { - if !(p > pat && Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) == int32('\\')) { + if !(p > pat && Int32FromUint8(**(**uint8)(__ccgo_up(p + uintptr(-Int32FromInt32(1))))) == int32('\\')) { break } goto _6 @@ -128230,14 +128230,14 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag } dir = Xopendir(tls, v2) if !(dir != 0) { - if (*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0 { + if (*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, **(**int32)(__ccgo_up(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0 { return int32(GLOB_ABORTED) } return 0 } - old_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + old_errno = **(**int32)(__ccgo_up(X__errno_location(tls))) for { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = 0 + **(**int32)(__ccgo_up(X__errno_location(tls))) = 0 v2 = Xreaddir(tls, dir) de = v2 if !(v2 != 0) { @@ -128252,7 +128252,7 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag continue } if p2 != 0 { - *(*uint8)(unsafe.Pointer(p2)) = uint8(0) + **(**uint8)(__ccgo_up(p2)) = uint8(0) } if flags&int32(GLOB_NOESCAPE) != 0 { v9 = int32(FNM_NOESCAPE) @@ -128270,12 +128270,12 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag } /* With GLOB_PERIOD, don't allow matching . or .. unless * fnmatch would match them with FNM_PERIOD rules in effect. */ - if p2 != 0 && flags&int32(GLOB_PERIOD) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(de + 19))) == int32('.') && (!(*(*uint8)(unsafe.Pointer(de + 19 + 1)) != 0) || Int32FromUint8(*(*uint8)(unsafe.Pointer(de + 19 + 1))) == int32('.') && !(*(*uint8)(unsafe.Pointer(de + 19 + 2)) != 0)) && Xfnmatch(tls, pat, de+19, fnm_flags|int32(FNM_PERIOD)) != 0 { + if p2 != 0 && flags&int32(GLOB_PERIOD) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(de + 19))) == int32('.') && (!(**(**uint8)(__ccgo_up(de + 19 + 1)) != 0) || Int32FromUint8(**(**uint8)(__ccgo_up(de + 19 + 1))) == int32('.') && !(**(**uint8)(__ccgo_up(de + 19 + 2)) != 0)) && Xfnmatch(tls, pat, de+19, fnm_flags|int32(FNM_PERIOD)) != 0 { continue } Xmemcpy(tls, buf+uintptr(pos), de+19, l+uint64(1)) if p2 != 0 { - *(*uint8)(unsafe.Pointer(p2)) = saved_sep + **(**uint8)(__ccgo_up(p2)) = saved_sep } if p2 != 0 { v2 = p2 @@ -128288,15 +128288,15 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag return r } } - readerr = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + readerr = **(**int32)(__ccgo_up(X__errno_location(tls))) if p2 != 0 { - *(*uint8)(unsafe.Pointer(p2)) = saved_sep + **(**uint8)(__ccgo_up(p2)) = saved_sep } Xclosedir(tls, dir) - if readerr != 0 && ((*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0) { + if readerr != 0 && ((*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, **(**int32)(__ccgo_up(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0) { return int32(GLOB_ABORTED) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = old_errno + **(**int32)(__ccgo_up(X__errno_location(tls))) = old_errno return 0 } @@ -128322,7 +128322,7 @@ func _freelist(tls *TLS, head uintptr) { } func _sort(tls *TLS, a uintptr, b uintptr) (r int32) { - return Xstrcmp(tls, *(*uintptr)(unsafe.Pointer(a)), *(*uintptr)(unsafe.Pointer(b))) + return Xstrcmp(tls, **(**uintptr)(__ccgo_up(a)), **(**uintptr)(__ccgo_up(b))) } func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { @@ -128335,25 +128335,25 @@ func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { var _ /* pw at bp+0 */ Tpasswd var _ /* res at bp+48 */ uintptr _, _, _, _, _, _, _, _, _ = delim, home, i, name_end, p, v1, v10, v2, v4 - p = *(*uintptr)(unsafe.Pointer(pat)) + uintptr(1) + p = **(**uintptr)(__ccgo_up(pat)) + uintptr(1) i = uint64(0) name_end = X__strchrnul(tls, p, int32('/')) - v1 = *(*uint8)(unsafe.Pointer(name_end)) + v1 = **(**uint8)(__ccgo_up(name_end)) delim = v1 if v1 != 0 { v2 = name_end name_end = name_end + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8(0) + **(**uint8)(__ccgo_up(v2)) = uint8(0) } - *(*uintptr)(unsafe.Pointer(pat)) = name_end - if *(*uint8)(unsafe.Pointer(p)) != 0 { + **(**uintptr)(__ccgo_up(pat)) = name_end + if **(**uint8)(__ccgo_up(p)) != 0 { v2 = UintptrFromInt32(0) } else { v2 = Xgetenv(tls, __ccgo_ts+1395) } home = v2 if !(home != 0) { - if *(*uint8)(unsafe.Pointer(p)) != 0 { + if **(**uint8)(__ccgo_up(p)) != 0 { v4 = Xgetpwnam_r(tls, p, bp, buf, uint64(PATH_MAX), bp+48) } else { v4 = Xgetpwuid_r(tls, Xgetuid(tls), bp, buf, uint64(PATH_MAX), bp+48) @@ -128372,7 +128372,7 @@ func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { return int32(GLOB_NOSPACE) _7: ; - if !!(*(*uintptr)(unsafe.Pointer(bp + 48)) != 0) { + if !!(**(**uintptr)(__ccgo_up(bp + 48)) != 0) { goto _9 } _6: @@ -128382,26 +128382,26 @@ func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { ; _8: ; - home = (*(*Tpasswd)(unsafe.Pointer(bp))).Fpw_dir + home = (**(**Tpasswd)(__ccgo_up(bp))).Fpw_dir } - for i < Uint64FromInt32(Int32FromInt32(PATH_MAX)-Int32FromInt32(2)) && *(*uint8)(unsafe.Pointer(home)) != 0 { + for i < Uint64FromInt32(Int32FromInt32(PATH_MAX)-Int32FromInt32(2)) && **(**uint8)(__ccgo_up(home)) != 0 { v10 = i i = i + 1 v2 = home home = home + 1 - *(*uint8)(unsafe.Pointer(buf + uintptr(v10))) = *(*uint8)(unsafe.Pointer(v2)) + **(**uint8)(__ccgo_up(buf + uintptr(v10))) = **(**uint8)(__ccgo_up(v2)) } - if *(*uint8)(unsafe.Pointer(home)) != 0 { + if **(**uint8)(__ccgo_up(home)) != 0 { return int32(GLOB_NOMATCH) } v1 = delim - *(*uint8)(unsafe.Pointer(buf + uintptr(i))) = v1 + **(**uint8)(__ccgo_up(buf + uintptr(i))) = v1 if v1 != 0 { i = i + 1 v10 = i - *(*uint8)(unsafe.Pointer(buf + uintptr(v10))) = uint8(0) + **(**uint8)(__ccgo_up(buf + uintptr(v10))) = uint8(0) } - *(*Tsize_t)(unsafe.Pointer(pos)) = i + **(**Tsize_t)(__ccgo_up(pos)) = i return 0 } @@ -128424,10 +128424,10 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint var _ /* s at bp+4120 */ uintptr var _ /* tail at bp+8 */ uintptr _, _, _, _, _, _, _ = cnt, error1, i, offs, p, pathv, v1 - *(*Tmatch)(unsafe.Pointer(bp)) = struct { + **(**Tmatch)(__ccgo_up(bp)) = struct { Fnext uintptr }{} - *(*uintptr)(unsafe.Pointer(bp + 8)) = bp + **(**uintptr)(__ccgo_up(bp + 8)) = bp if flags&int32(GLOB_DOOFFS) != 0 { v1 = (*Tglob_t)(unsafe.Pointer(g)).Fgl_offs } else { @@ -128443,19 +128443,19 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathc = uint64(0) (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv = UintptrFromInt32(0) } - if *(*uint8)(unsafe.Pointer(pat)) != 0 { + if **(**uint8)(__ccgo_up(pat)) != 0 { p = Xstrdup(tls, pat) if !(p != 0) { return int32(GLOB_NOSPACE) } - (*(*[4096]uint8)(unsafe.Pointer(bp + 16)))[0] = uint8(0) - *(*Tsize_t)(unsafe.Pointer(bp + 4112)) = uint64(0) - *(*uintptr)(unsafe.Pointer(bp + 4120)) = p - if flags&(Int32FromInt32(GLOB_TILDE)|Int32FromInt32(GLOB_TILDE_CHECK)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('~') { + (**(**[4096]uint8)(__ccgo_up(bp + 16)))[0] = uint8(0) + **(**Tsize_t)(__ccgo_up(bp + 4112)) = uint64(0) + **(**uintptr)(__ccgo_up(bp + 4120)) = p + if flags&(Int32FromInt32(GLOB_TILDE)|Int32FromInt32(GLOB_TILDE_CHECK)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('~') { error1 = _expand_tilde(tls, bp+4120, bp+16, bp+4112) } if !(error1 != 0) { - error1 = _do_glob(tls, bp+16, *(*Tsize_t)(unsafe.Pointer(bp + 4112)), 0, *(*uintptr)(unsafe.Pointer(bp + 4120)), flags, __ccgo_fp_errfunc, bp+8) + error1 = _do_glob(tls, bp+16, **(**Tsize_t)(__ccgo_up(bp + 4112)), 0, **(**uintptr)(__ccgo_up(bp + 4120)), flags, __ccgo_fp_errfunc, bp+8) } Xfree(tls, p) } @@ -128464,20 +128464,20 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint return error1 } cnt = uint64(0) - *(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*Tmatch)(unsafe.Pointer(bp))).Fnext + **(**uintptr)(__ccgo_up(bp + 8)) = (**(**Tmatch)(__ccgo_up(bp))).Fnext for { - if !(*(*uintptr)(unsafe.Pointer(bp + 8)) != 0) { + if !(**(**uintptr)(__ccgo_up(bp + 8)) != 0) { break } goto _2 _2: ; - *(*uintptr)(unsafe.Pointer(bp + 8)) = (*Tmatch)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fnext + **(**uintptr)(__ccgo_up(bp + 8)) = (*Tmatch)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp + 8)))).Fnext cnt = cnt + 1 } if !(cnt != 0) { if flags&int32(GLOB_NOCHECK) != 0 { - *(*uintptr)(unsafe.Pointer(bp + 8)) = bp + **(**uintptr)(__ccgo_up(bp + 8)) = bp if _append(tls, bp+8, pat, _strlen(tls, pat), 0) != 0 { return int32(GLOB_NOSPACE) } @@ -128507,7 +128507,7 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint if !(i < offs) { break } - *(*uintptr)(unsafe.Pointer((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(i)*8)) = UintptrFromInt32(0) + **(**uintptr)(__ccgo_up((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(i)*8)) = UintptrFromInt32(0) goto _3 _3: ; @@ -128515,20 +128515,20 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint } } i = uint64(0) - *(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*Tmatch)(unsafe.Pointer(bp))).Fnext + **(**uintptr)(__ccgo_up(bp + 8)) = (**(**Tmatch)(__ccgo_up(bp))).Fnext for { if !(i < cnt) { break } - *(*uintptr)(unsafe.Pointer((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(offs+i)*8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + **(**uintptr)(__ccgo_up((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(offs+i)*8)) = **(**uintptr)(__ccgo_up(bp + 8)) + 8 goto _4 _4: ; - *(*uintptr)(unsafe.Pointer(bp + 8)) = (*Tmatch)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fnext + **(**uintptr)(__ccgo_up(bp + 8)) = (*Tmatch)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp + 8)))).Fnext i = i + 1 } - *(*uintptr)(unsafe.Pointer((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(offs+i)*8)) = UintptrFromInt32(0) - *(*Tsize_t)(unsafe.Pointer(g)) += cnt + **(**uintptr)(__ccgo_up((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(offs+i)*8)) = UintptrFromInt32(0) + **(**Tsize_t)(__ccgo_up(g)) += cnt if !(flags&Int32FromInt32(GLOB_NOSORT) != 0) { Xqsort(tls, (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv+uintptr(offs)*8, cnt, uint64(8), __ccgo_fp(_sort)) } @@ -128546,7 +128546,7 @@ func Xglobfree(tls *TLS, g uintptr) { if !(i < (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathc) { break } - Xfree(tls, *(*uintptr)(unsafe.Pointer((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr((*Tglob_t)(unsafe.Pointer(g)).Fgl_offs+i)*8))-uintptr(uint64(UintptrFromInt32(0)+8))) + Xfree(tls, **(**uintptr)(__ccgo_up((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr((*Tglob_t)(unsafe.Pointer(g)).Fgl_offs+i)*8))-uintptr(uint64(UintptrFromInt32(0)+8))) goto _1 _1: ; @@ -128945,7 +128945,7 @@ func _tre_stack_push(tls *TLS, s uintptr, value Ttre_stack_item) (r Treg_errcode var new_size int32 _, _ = new_buffer, new_size if (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr < (*Ttre_stack_t)(unsafe.Pointer(s)).Fsize { - *(*Ttre_stack_item)(unsafe.Pointer((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr((*Ttre_stack_t)(unsafe.Pointer(s)).Fptr)*8)) = value + **(**Ttre_stack_item)(__ccgo_up((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr((*Ttre_stack_t)(unsafe.Pointer(s)).Fptr)*8)) = value (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr = (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr + 1 } else { if (*Ttre_stack_t)(unsafe.Pointer(s)).Fsize >= (*Ttre_stack_t)(unsafe.Pointer(s)).Fmax_size { @@ -128979,7 +128979,7 @@ func _tre_stack_push_voidptr(tls *TLS, s uintptr, value uintptr) (r Treg_errcode defer tls.Free(16) var _ /* item at bp+0 */ Ttre_stack_item *(*uintptr)(unsafe.Pointer(bp)) = value - return _tre_stack_push(tls, s, *(*Ttre_stack_item)(unsafe.Pointer(bp))) + return _tre_stack_push(tls, s, **(**Ttre_stack_item)(__ccgo_up(bp))) } func _tre_stack_pop_int(tls *TLS, s uintptr) (r int32) { @@ -128989,7 +128989,7 @@ func _tre_stack_pop_int(tls *TLS, s uintptr) (r int32) { v2 = s + 12 *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) - 1 v1 = *(*int32)(unsafe.Pointer(v2)) - return *(*int32)(unsafe.Pointer(&*(*Ttre_stack_item)(unsafe.Pointer((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr(v1)*8)))) + return *(*int32)(unsafe.Pointer(&**(**Ttre_stack_item)(__ccgo_up((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr(v1)*8)))) } func _tre_stack_pop_voidptr(tls *TLS, s uintptr) (r uintptr) { @@ -129089,7 +129089,7 @@ func _tre_expand_macro(tls *TLS, s uintptr) (r uintptr) { _ = i i = 0 for { - if !(_tre_macros[i].Fc != 0 && Int32FromUint8(_tre_macros[i].Fc) != Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))) { + if !(_tre_macros[i].Fc != 0 && Int32FromUint8(_tre_macros[i].Fc) != Int32FromUint8(**(**uint8)(__ccgo_up(s)))) { break } goto _1 @@ -129106,7 +129106,7 @@ func _tre_compare_lit(tls *TLS, a uintptr, b uintptr) (r int32) { la = a lb = b /* assumes the range of valid code_min is < INT_MAX */ - return int32((*Ttre_literal_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(la)))).Fcode_min - (*Ttre_literal_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(lb)))).Fcode_min) + return int32((*Ttre_literal_t)(unsafe.Pointer(**(**uintptr)(__ccgo_up(la)))).Fcode_min - (*Ttre_literal_t)(unsafe.Pointer(**(**uintptr)(__ccgo_up(lb)))).Fcode_min) } type Tliterals = struct { @@ -129124,7 +129124,7 @@ func _tre_new_lit(tls *TLS, p uintptr) (r uintptr) { if (*Tliterals)(unsafe.Pointer(p)).Fcap1 >= Int32FromInt32(1)< max { @@ -129316,7 +129316,7 @@ func _parse_bracket_terms(tls *TLS, ctx uintptr, s uintptr, ls uintptr, neg uint v6 = neg + 4 v2 = *(*int32)(unsafe.Pointer(v6)) *(*int32)(unsafe.Pointer(v6)) = *(*int32)(unsafe.Pointer(v6)) + 1 - *(*Ttre_ctype_t)(unsafe.Pointer(neg + 8 + uintptr(v2)*8)) = class + **(**Ttre_ctype_t)(__ccgo_up(neg + 8 + uintptr(v2)*8)) = class } else { lit = _tre_new_lit(tls, ls) if !(lit != 0) { @@ -129356,23 +129356,23 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { _, _, _, _, _, _, _, _, _, _, _ = err, i, lit, max, min, n, nc, negmax, negmin, node, v1 node = uintptr(0) nc = uintptr(0) - (*(*Tliterals)(unsafe.Pointer(bp))).Fmem = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem - (*(*Tliterals)(unsafe.Pointer(bp))).Flen1 = 0 - (*(*Tliterals)(unsafe.Pointer(bp))).Fcap1 = int32(32) - (*(*Tliterals)(unsafe.Pointer(bp))).Fa = Xmalloc(tls, Uint64FromInt32((*(*Tliterals)(unsafe.Pointer(bp))).Fcap1)*uint64(8)) - if !((*(*Tliterals)(unsafe.Pointer(bp))).Fa != 0) { + (**(**Tliterals)(__ccgo_up(bp))).Fmem = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem + (**(**Tliterals)(__ccgo_up(bp))).Flen1 = 0 + (**(**Tliterals)(__ccgo_up(bp))).Fcap1 = int32(32) + (**(**Tliterals)(__ccgo_up(bp))).Fa = Xmalloc(tls, Uint64FromInt32((**(**Tliterals)(__ccgo_up(bp))).Fcap1)*uint64(8)) + if !((**(**Tliterals)(__ccgo_up(bp))).Fa != 0) { return int32(REG_ESPACE) } - (*(*Tneg)(unsafe.Pointer(bp + 24))).Flen1 = 0 - (*(*Tneg)(unsafe.Pointer(bp + 24))).Fnegate = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('^')) - if (*(*Tneg)(unsafe.Pointer(bp + 24))).Fnegate != 0 { + (**(**Tneg)(__ccgo_up(bp + 24))).Flen1 = 0 + (**(**Tneg)(__ccgo_up(bp + 24))).Fnegate = BoolInt32(Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('^')) + if (**(**Tneg)(__ccgo_up(bp + 24))).Fnegate != 0 { s = s + 1 } err = _parse_bracket_terms(tls, ctx, s, bp, bp+24) if err != REG_OK { goto parse_bracket_done } - if (*(*Tneg)(unsafe.Pointer(bp + 24))).Fnegate != 0 { + if (**(**Tneg)(__ccgo_up(bp + 24))).Fnegate != 0 { /* * With REG_NEWLINE, POSIX requires that newlines are not matched by * any form of a non-matching list. @@ -129388,7 +129388,7 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition = -int32(1) } /* Sort the array if we need to negate it. */ - Xqsort(tls, (*(*Tliterals)(unsafe.Pointer(bp))).Fa, Uint64FromInt32((*(*Tliterals)(unsafe.Pointer(bp))).Flen1), uint64(8), __ccgo_fp(_tre_compare_lit)) + Xqsort(tls, (**(**Tliterals)(__ccgo_up(bp))).Fa, Uint64FromInt32((**(**Tliterals)(__ccgo_up(bp))).Flen1), uint64(8), __ccgo_fp(_tre_compare_lit)) /* extra lit for the last negated range */ lit = _tre_new_lit(tls, bp) if !(lit != 0) { @@ -129399,14 +129399,14 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max = int64(Int32FromInt32(TRE_CHAR_MAX) + Int32FromInt32(1)) (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition = -int32(1) /* negated classes */ - if (*(*Tneg)(unsafe.Pointer(bp + 24))).Flen1 != 0 { - nc = X__tre_mem_alloc_impl(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, 0, UintptrFromInt32(0), 0, Uint64FromInt32((*(*Tneg)(unsafe.Pointer(bp + 24))).Flen1+Int32FromInt32(1))*uint64(8)) + if (**(**Tneg)(__ccgo_up(bp + 24))).Flen1 != 0 { + nc = X__tre_mem_alloc_impl(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, 0, UintptrFromInt32(0), 0, Uint64FromInt32((**(**Tneg)(__ccgo_up(bp + 24))).Flen1+Int32FromInt32(1))*uint64(8)) if !(nc != 0) { err = int32(REG_ESPACE) goto parse_bracket_done } - Xmemcpy(tls, nc, bp+24+8, Uint64FromInt32((*(*Tneg)(unsafe.Pointer(bp + 24))).Flen1)*uint64(8)) - *(*Ttre_ctype_t)(unsafe.Pointer(nc + uintptr((*(*Tneg)(unsafe.Pointer(bp + 24))).Flen1)*8)) = uint64(0) + Xmemcpy(tls, nc, bp+24+8, Uint64FromInt32((**(**Tneg)(__ccgo_up(bp + 24))).Flen1)*uint64(8)) + **(**Ttre_ctype_t)(__ccgo_up(nc + uintptr((**(**Tneg)(__ccgo_up(bp + 24))).Flen1)*8)) = uint64(0) } } /* Build a union of the items in the array, negated if necessary. */ @@ -129415,13 +129415,13 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { negmax = v1 i = 0 for { - if !(i < (*(*Tliterals)(unsafe.Pointer(bp))).Flen1) { + if !(i < (**(**Tliterals)(__ccgo_up(bp))).Flen1) { break } - lit = *(*uintptr)(unsafe.Pointer((*(*Tliterals)(unsafe.Pointer(bp))).Fa + uintptr(i)*8)) + lit = **(**uintptr)(__ccgo_up((**(**Tliterals)(__ccgo_up(bp))).Fa + uintptr(i)*8)) min = int32((*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min) max = int32((*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max) - if (*(*Tneg)(unsafe.Pointer(bp + 24))).Fnegate != 0 { + if (**(**Tneg)(__ccgo_up(bp + 24))).Fnegate != 0 { if min <= negmin { /* Overlap. */ if max+int32(1) >= negmin { @@ -129453,22 +129453,22 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { goto parse_bracket_done parse_bracket_done: ; - Xfree(tls, (*(*Tliterals)(unsafe.Pointer(bp))).Fa) + Xfree(tls, (**(**Tliterals)(__ccgo_up(bp))).Fa) (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition + 1 (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = node return err } func _parse_dup_count(tls *TLS, s uintptr, n uintptr) (r uintptr) { - *(*int32)(unsafe.Pointer(n)) = -int32(1) - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + **(**int32)(__ccgo_up(n)) = -int32(1) + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return s } - *(*int32)(unsafe.Pointer(n)) = 0 + **(**int32)(__ccgo_up(n)) = 0 for { - *(*int32)(unsafe.Pointer(n)) = int32(10)**(*int32)(unsafe.Pointer(n)) + (Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) - int32('0')) + **(**int32)(__ccgo_up(n)) = int32(10)***(**int32)(__ccgo_up(n)) + (Int32FromUint8(**(**uint8)(__ccgo_up(s))) - int32('0')) s = s + 1 - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) || *(*int32)(unsafe.Pointer(n)) > int32(RE_DUP_MAX) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) || **(**int32)(__ccgo_up(n)) > int32(RE_DUP_MAX) { break } goto _1 @@ -129486,26 +129486,26 @@ func _parse_dup(tls *TLS, s uintptr, ere int32, pmin uintptr, pmax uintptr) (r u var _ /* min at bp+0 */ int32 _, _, _, _, _ = v1, v2, v3, v4, v5 s = _parse_dup_count(tls, s, bp) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32(',') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32(',') { s = _parse_dup_count(tls, s+uintptr(1), bp+4) } else { - *(*int32)(unsafe.Pointer(bp + 4)) = *(*int32)(unsafe.Pointer(bp)) + **(**int32)(__ccgo_up(bp + 4)) = **(**int32)(__ccgo_up(bp)) } - if v3 = *(*int32)(unsafe.Pointer(bp + 4)) < *(*int32)(unsafe.Pointer(bp)) && *(*int32)(unsafe.Pointer(bp + 4)) >= 0 || *(*int32)(unsafe.Pointer(bp + 4)) > int32(RE_DUP_MAX) || *(*int32)(unsafe.Pointer(bp)) > int32(RE_DUP_MAX) || *(*int32)(unsafe.Pointer(bp)) < 0; !v3 { + if v3 = **(**int32)(__ccgo_up(bp + 4)) < **(**int32)(__ccgo_up(bp)) && **(**int32)(__ccgo_up(bp + 4)) >= 0 || **(**int32)(__ccgo_up(bp + 4)) > int32(RE_DUP_MAX) || **(**int32)(__ccgo_up(bp)) > int32(RE_DUP_MAX) || **(**int32)(__ccgo_up(bp)) < 0; !v3 { if v2 = !(ere != 0); v2 { v1 = s s = s + 1 } } - if v5 = v3 || v2 && Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) != int32('\\'); !v5 { + if v5 = v3 || v2 && Int32FromUint8(**(**uint8)(__ccgo_up(v1))) != int32('\\'); !v5 { v4 = s s = s + 1 } - if v5 || Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) != int32('}') { + if v5 || Int32FromUint8(**(**uint8)(__ccgo_up(v4))) != int32('}') { return uintptr(0) } - *(*int32)(unsafe.Pointer(pmin)) = *(*int32)(unsafe.Pointer(bp)) - *(*int32)(unsafe.Pointer(pmax)) = *(*int32)(unsafe.Pointer(bp + 4)) + **(**int32)(__ccgo_up(pmin)) = **(**int32)(__ccgo_up(bp)) + **(**int32)(__ccgo_up(pmax)) = **(**int32)(__ccgo_up(bp + 4)) return s } @@ -129568,7 +129568,7 @@ func _parse_atom(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { var _ /* wc at bp+0 */ Twchar_t _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, ere, err, i, len1, node, p, tmp1, tmp11, tmp2, tmp21, v, val, v14, v16 ere = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fcflags & int32(REG_EXTENDED) - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(s))) { case int32('['): goto _1 case int32('\\'): @@ -129610,7 +129610,7 @@ _2: /* extensions: \b, \B, \<, \>, \xHH \x{HHHH} */ s = s + 1 v14 = s - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(v14))) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(v14))) { case 0: return int32(REG_EESCAPE) case int32('b'): @@ -129625,7 +129625,7 @@ _2: s = s + 1 v = 0 len1 = int32(2) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('{') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('{') { len1 = int32(8) s = s + 1 } @@ -129634,7 +129634,7 @@ _2: if !(i < len1 && v < int32(0x110000)) { break } - c = _hexval1(tls, uint32(*(*uint8)(unsafe.Pointer(s + uintptr(i))))) + c = _hexval1(tls, uint32(**(**uint8)(__ccgo_up(s + uintptr(i))))) if c < 0 { break } @@ -129646,7 +129646,7 @@ _2: } s = s + uintptr(i) if len1 == int32(8) { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('}') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32('}') { return int32(REG_EBRACE) } s = s + 1 @@ -129677,9 +129677,9 @@ _2: /* fallthrough */ fallthrough default: - if !(ere != 0) && uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('1') < uint32(9) { + if !(ere != 0) && uint32(**(**uint8)(__ccgo_up(s)))-uint32('1') < uint32(9) { /* back reference */ - val = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) - int32('0') + val = Int32FromUint8(**(**uint8)(__ccgo_up(s))) - int32('0') v14 = ctx + 44 v16 = *(*int32)(unsafe.Pointer(v14)) *(*int32)(unsafe.Pointer(v14)) = *(*int32)(unsafe.Pointer(v14)) + 1 @@ -129734,7 +129734,7 @@ _4: _5: ; /* '$' is special everywhere in EREs, and at the end of a BRE subexpression. */ - if !(ere != 0) && *(*uint8)(unsafe.Pointer(s + 1)) != 0 && (Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) != int32('\\') || Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 2))) != int32(')') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 2))) != int32('|')) { + if !(ere != 0) && **(**uint8)(__ccgo_up(s + 1)) != 0 && (Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) != int32('\\') || Int32FromUint8(**(**uint8)(__ccgo_up(s + 2))) != int32(')') && Int32FromUint8(**(**uint8)(__ccgo_up(s + 2))) != int32('|')) { goto parse_literal } node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(2), int32(ASSERT_AT_EOL), -int32(1)) @@ -129770,17 +129770,17 @@ parse_literal: if len1 < 0 { return int32(REG_BADPAT) } - if (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fcflags&int32(REG_ICASE) != 0 && (Xiswupper(tls, *(*Twchar_t)(unsafe.Pointer(bp))) != 0 || Xiswlower(tls, *(*Twchar_t)(unsafe.Pointer(bp))) != 0) { + if (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fcflags&int32(REG_ICASE) != 0 && (Xiswupper(tls, **(**Twchar_t)(__ccgo_up(bp))) != 0 || Xiswlower(tls, **(**Twchar_t)(__ccgo_up(bp))) != 0) { /* multiple opposite case characters are not supported */ - tmp11 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint32(Xtowupper(tls, *(*Twchar_t)(unsafe.Pointer(bp)))), Int32FromUint32(Xtowupper(tls, *(*Twchar_t)(unsafe.Pointer(bp)))), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) - tmp21 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint32(Xtowlower(tls, *(*Twchar_t)(unsafe.Pointer(bp)))), Int32FromUint32(Xtowlower(tls, *(*Twchar_t)(unsafe.Pointer(bp)))), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) + tmp11 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint32(Xtowupper(tls, **(**Twchar_t)(__ccgo_up(bp)))), Int32FromUint32(Xtowupper(tls, **(**Twchar_t)(__ccgo_up(bp)))), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) + tmp21 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint32(Xtowlower(tls, **(**Twchar_t)(__ccgo_up(bp)))), Int32FromUint32(Xtowlower(tls, **(**Twchar_t)(__ccgo_up(bp)))), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) if tmp11 != 0 && tmp21 != 0 { node = _tre_ast_new_union(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, tmp11, tmp21) } else { node = uintptr(0) } } else { - node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint32(*(*Twchar_t)(unsafe.Pointer(bp))), Int32FromUint32(*(*Twchar_t)(unsafe.Pointer(bp))), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) + node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint32(**(**Twchar_t)(__ccgo_up(bp))), Int32FromUint32(**(**Twchar_t)(__ccgo_up(bp))), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) } (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition + 1 s = s + uintptr(len1) @@ -129822,7 +129822,7 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { return err } for { - if !(ere != 0) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('\\') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) == int32('(') || ere != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('(') { + if !(ere != 0) && Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('\\') && Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) == int32('(') || ere != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('(') { v1 = _tre_stack_push_voidptr(tls, stack, nunion) err = v1 if v1 != REG_OK { @@ -129851,7 +129851,7 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart = s goto _3 } - if !(ere != 0) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('\\') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) == int32(')') || ere != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32(')') && depth != 0 { + if !(ere != 0) && Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('\\') && Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) == int32(')') || ere != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32(')') && depth != 0 { (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(1), -int32(1), -int32(1)) if !((*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn != 0) { return int32(REG_ESPACE) @@ -129867,52 +129867,52 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { parse_iter: ; for { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('\\') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('*') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32('\\') && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32('*') { if !(ere != 0) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('+') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('?') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('{') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32('+') && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32('?') && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32('{') { break } } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('\\') && ere != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('\\') && ere != 0 { break } /* extension: treat \+, \? as repetitions in BRE */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('\\') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) != int32('+') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) != int32('?') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) != int32('{') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('\\') && Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) != int32('+') && Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) != int32('?') && Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) != int32('{') { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('\\') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('\\') { s = s + 1 } /* handle ^* at the start of a BRE. */ - if !(ere != 0) && s == (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart+uintptr(1) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(-Int32FromInt32(1))))) == int32('^') { + if !(ere != 0) && s == (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart+uintptr(1) && Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(-Int32FromInt32(1))))) == int32('^') { break } /* extension: multiple consecutive *+?{,} is unspecified, but (a+)+ has to be supported so accepting a++ makes sense, note however that the RE_DUP_MAX limit can be circumvented: (a{255}){255} uses a lot of memory.. */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('{') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('{') { s = _parse_dup(tls, s+uintptr(1), ere, bp, bp+4) if !(s != 0) { return int32(REG_BADBR) } } else { - *(*int32)(unsafe.Pointer(bp)) = 0 - *(*int32)(unsafe.Pointer(bp + 4)) = -int32(1) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('+') { - *(*int32)(unsafe.Pointer(bp)) = int32(1) + **(**int32)(__ccgo_up(bp)) = 0 + **(**int32)(__ccgo_up(bp + 4)) = -int32(1) + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('+') { + **(**int32)(__ccgo_up(bp)) = int32(1) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('?') { - *(*int32)(unsafe.Pointer(bp + 4)) = int32(1) + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('?') { + **(**int32)(__ccgo_up(bp + 4)) = int32(1) } s = s + 1 } - if *(*int32)(unsafe.Pointer(bp + 4)) == 0 { + if **(**int32)(__ccgo_up(bp + 4)) == 0 { (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(1), -int32(1), -int32(1)) } else { - (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = _tre_ast_new_iter(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn, *(*int32)(unsafe.Pointer(bp)), *(*int32)(unsafe.Pointer(bp + 4)), 0) + (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = _tre_ast_new_iter(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn, **(**int32)(__ccgo_up(bp)), **(**int32)(__ccgo_up(bp + 4)), 0) } if !((*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn != 0) { return int32(REG_ESPACE) @@ -129921,13 +129921,13 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { _9: } nbranch = _tre_ast_new_catenation(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, nbranch, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn) - if ere != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('|') || ere != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32(')') && depth != 0 || !(ere != 0) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('\\') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) == int32(')') || !(ere != 0) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('\\') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) == int32('|') || !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if ere != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('|') || ere != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32(')') && depth != 0 || !(ere != 0) && Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('\\') && Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) == int32(')') || !(ere != 0) && Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('\\') && Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) == int32('|') || !(**(**uint8)(__ccgo_up(s)) != 0) { /* extension: empty branch is unspecified (), (|a), (a|) here they are not rejected but match on empty string */ - c = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) + c = Int32FromUint8(**(**uint8)(__ccgo_up(s))) nunion = _tre_ast_new_union(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, nunion, nbranch) nbranch = uintptr(0) - if c == int32('\\') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) == int32('|') { + if c == int32('\\') && Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) == int32('|') { s = s + uintptr(2) (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart = s } else { @@ -130073,22 +130073,22 @@ func _tre_purge_regset(tls *TLS, regset uintptr, tnfa uintptr, tag int32) { _, _, _ = i, id, start i = 0 for { - if !(*(*int32)(unsafe.Pointer(regset + uintptr(i)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(regset + uintptr(i)*4)) >= 0) { break } - id = *(*int32)(unsafe.Pointer(regset + uintptr(i)*4)) / int32(2) - start = BoolInt32(!(*(*int32)(unsafe.Pointer(regset + uintptr(i)*4))%Int32FromInt32(2) != 0)) + id = **(**int32)(__ccgo_up(regset + uintptr(i)*4)) / int32(2) + start = BoolInt32(!(**(**int32)(__ccgo_up(regset + uintptr(i)*4))%Int32FromInt32(2) != 0)) if start != 0 { - (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id)*16))).Fso_tag = tag + (**(**Ttre_submatch_data_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id)*16))).Fso_tag = tag } else { - (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id)*16))).Feo_tag = tag + (**(**Ttre_submatch_data_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id)*16))).Feo_tag = tag } goto _1 _1: ; i = i + 1 } - *(*int32)(unsafe.Pointer(regset)) = -int32(1) + **(**int32)(__ccgo_up(regset)) = -int32(1) } // C documentation @@ -130117,20 +130117,20 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u direction = int32(_TRE_TAG_MINIMIZE) if !(first_pass != 0) { (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fend_tag = 0 - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags)) = -int32(1) + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags)) = -int32(1) } regset = Xmalloc(tls, uint64(4)*uint64(((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches+Uint32FromInt32(1))*Uint32FromInt32(2))) if regset == UintptrFromInt32(0) { return int32(REG_ESPACE) } - *(*int32)(unsafe.Pointer(regset)) = -int32(1) + **(**int32)(__ccgo_up(regset)) = -int32(1) orig_regset = regset parents = Xmalloc(tls, uint64(4)*uint64((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches+Uint32FromInt32(1))) if parents == UintptrFromInt32(0) { Xfree(tls, regset) return int32(REG_ESPACE) } - *(*int32)(unsafe.Pointer(parents)) = -int32(1) + **(**int32)(__ccgo_up(parents)) = -int32(1) saved_states = Xmalloc(tls, uint64(8)*uint64((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches+Uint32FromInt32(1))) if saved_states == UintptrFromInt32(0) { Xfree(tls, regset) @@ -130142,7 +130142,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u if !(i <= (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches) { break } - (*(*Ttre_tag_states_t)(unsafe.Pointer(saved_states + uintptr(i)*8))).Ftag = -int32(1) + (**(**Ttre_tag_states_t)(__ccgo_up(saved_states + uintptr(i)*8))).Ftag = -int32(1) goto _1 _1: ; @@ -130181,7 +130181,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u /* Add end of this submatch to regset. */ i1 = 0 for { - if !(*(*int32)(unsafe.Pointer(regset + uintptr(i1)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(regset + uintptr(i1)*4)) >= 0) { break } goto _11 @@ -130189,12 +130189,12 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i1 = i1 + 1 } - *(*int32)(unsafe.Pointer(regset + uintptr(i1)*4)) = id*int32(2) + int32(1) - *(*int32)(unsafe.Pointer(regset + uintptr(i1+int32(1))*4)) = -int32(1) + **(**int32)(__ccgo_up(regset + uintptr(i1)*4)) = id*int32(2) + int32(1) + **(**int32)(__ccgo_up(regset + uintptr(i1+int32(1))*4)) = -int32(1) /* Pop this submatch from the parents stack. */ i1 = 0 for { - if !(*(*int32)(unsafe.Pointer(parents + uintptr(i1)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(parents + uintptr(i1)*4)) >= 0) { break } goto _12 @@ -130202,7 +130202,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i1 = i1 + 1 } - *(*int32)(unsafe.Pointer(parents + uintptr(i1-int32(1))*4)) = -int32(1) + **(**int32)(__ccgo_up(parents + uintptr(i1-int32(1))*4)) = -int32(1) goto _10 _3: ; @@ -130212,7 +130212,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u /* Add start of this submatch to regset. */ i2 = 0 for { - if !(*(*int32)(unsafe.Pointer(regset + uintptr(i2)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(regset + uintptr(i2)*4)) >= 0) { break } goto _13 @@ -130220,12 +130220,12 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i2 = i2 + 1 } - *(*int32)(unsafe.Pointer(regset + uintptr(i2)*4)) = id1 * int32(2) - *(*int32)(unsafe.Pointer(regset + uintptr(i2+int32(1))*4)) = -int32(1) + **(**int32)(__ccgo_up(regset + uintptr(i2)*4)) = id1 * int32(2) + **(**int32)(__ccgo_up(regset + uintptr(i2+int32(1))*4)) = -int32(1) if !(first_pass != 0) { i2 = 0 for { - if !(*(*int32)(unsafe.Pointer(parents + uintptr(i2)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(parents + uintptr(i2)*4)) >= 0) { break } goto _14 @@ -130233,26 +130233,26 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i2 = i2 + 1 } - (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id1)*16))).Fparents = UintptrFromInt32(0) + (**(**Ttre_submatch_data_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id1)*16))).Fparents = UintptrFromInt32(0) if i2 > 0 { p = Xmalloc(tls, uint64(4)*Uint64FromInt32(i2+Int32FromInt32(1))) if p == UintptrFromInt32(0) { status = int32(REG_ESPACE) goto _10 } - (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id1)*16))).Fparents = p + (**(**Ttre_submatch_data_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id1)*16))).Fparents = p i2 = 0 for { - if !(*(*int32)(unsafe.Pointer(parents + uintptr(i2)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(parents + uintptr(i2)*4)) >= 0) { break } - *(*int32)(unsafe.Pointer(p + uintptr(i2)*4)) = *(*int32)(unsafe.Pointer(parents + uintptr(i2)*4)) + **(**int32)(__ccgo_up(p + uintptr(i2)*4)) = **(**int32)(__ccgo_up(parents + uintptr(i2)*4)) goto _15 _15: ; i2 = i2 + 1 } - *(*int32)(unsafe.Pointer(p + uintptr(i2)*4)) = -int32(1) + **(**int32)(__ccgo_up(p + uintptr(i2)*4)) = -int32(1) } } /* Add end of this submatch to regset after processing this @@ -130270,16 +130270,16 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u case int32(_LITERAL): lit = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj if !((*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min < Int64FromInt32(0)) || (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min == int64(-int32(4)) { - if *(*int32)(unsafe.Pointer(regset)) >= 0 { + if **(**int32)(__ccgo_up(regset)) >= 0 { /* Regset is not empty, so add a tag before the literal or backref. */ if !(first_pass != 0) { status = _tre_add_tag_left(tls, mem, node, tag) - *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = direction + **(**Ttre_tag_direction_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = direction if minimal_tag >= 0 { i3 = 0 for { - if !(*(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3)*4)) >= 0) { break } goto _16 @@ -130287,9 +130287,9 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i3 = i3 + 1 } - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3)*4)) = tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3+int32(1))*4)) = minimal_tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3+int32(2))*4)) = -int32(1) + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3)*4)) = tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3+int32(1))*4)) = minimal_tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) num_minimals = num_minimals + 1 } @@ -130297,7 +130297,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u } else { (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fnum_tags = int32(1) } - *(*int32)(unsafe.Pointer(regset)) = -int32(1) + **(**int32)(__ccgo_up(regset)) = -int32(1) tag = next_tag num_tags = num_tags + 1 next_tag = next_tag + 1 @@ -130357,7 +130357,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u case int32(_ITERATION): iter = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj if first_pass != 0 { - status = _tre_stack_push_int(tls, stack, BoolInt32(*(*int32)(unsafe.Pointer(regset)) >= 0 || int32(uint32(*(*uint8)(unsafe.Pointer(iter + 16))&0x1>>0)) != 0)) + status = _tre_stack_push_int(tls, stack, BoolInt32(**(**int32)(__ccgo_up(regset)) >= 0 || int32(uint32(*(*uint8)(unsafe.Pointer(iter + 16))&0x1>>0)) != 0)) if status != REG_OK { break } @@ -130388,18 +130388,18 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u break } /* Regset is not empty, so add a tag here. */ - if *(*int32)(unsafe.Pointer(regset)) >= 0 || int32(uint32(*(*uint8)(unsafe.Pointer(iter + 16))&0x1>>0)) != 0 { + if **(**int32)(__ccgo_up(regset)) >= 0 || int32(uint32(*(*uint8)(unsafe.Pointer(iter + 16))&0x1>>0)) != 0 { if !(first_pass != 0) { status = _tre_add_tag_left(tls, mem, node, tag) if int32(uint32(*(*uint8)(unsafe.Pointer(iter + 16))&0x1>>0)) != 0 { - *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = int32(_TRE_TAG_MAXIMIZE) + **(**Ttre_tag_direction_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = int32(_TRE_TAG_MAXIMIZE) } else { - *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = direction + **(**Ttre_tag_direction_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = direction } if minimal_tag >= 0 { i4 = 0 for { - if !(*(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4)*4)) >= 0) { break } goto _17 @@ -130407,15 +130407,15 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i4 = i4 + 1 } - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4)*4)) = tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4+int32(1))*4)) = minimal_tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4+int32(2))*4)) = -int32(1) + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4)*4)) = tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4+int32(1))*4)) = minimal_tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) num_minimals = num_minimals + 1 } _tre_purge_regset(tls, regset, tnfa, tag) } - *(*int32)(unsafe.Pointer(regset)) = -int32(1) + **(**int32)(__ccgo_up(regset)) = -int32(1) tag = next_tag num_tags = num_tags + 1 next_tag = next_tag + 1 @@ -130425,7 +130425,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u uni = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj left1 = (*Ttre_union_t)(unsafe.Pointer(uni)).Fleft right1 = (*Ttre_union_t)(unsafe.Pointer(uni)).Fright - if *(*int32)(unsafe.Pointer(regset)) >= 0 { + if **(**int32)(__ccgo_up(regset)) >= 0 { left_tag = next_tag right_tag = next_tag + int32(1) } else { @@ -130445,7 +130445,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u if status != REG_OK { break } - status = _tre_stack_push_int(tls, stack, BoolInt32(*(*int32)(unsafe.Pointer(regset)) >= 0)) + status = _tre_stack_push_int(tls, stack, BoolInt32(**(**int32)(__ccgo_up(regset)) >= 0)) if status != REG_OK { break } @@ -130489,14 +130489,14 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u break } /* Regset is not empty, so add a tag here. */ - if *(*int32)(unsafe.Pointer(regset)) >= 0 { + if **(**int32)(__ccgo_up(regset)) >= 0 { if !(first_pass != 0) { status = _tre_add_tag_left(tls, mem, node, tag) - *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = direction + **(**Ttre_tag_direction_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = direction if minimal_tag >= 0 { i5 = 0 for { - if !(*(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5)*4)) >= 0) { break } goto _18 @@ -130504,15 +130504,15 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i5 = i5 + 1 } - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5)*4)) = tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5+int32(1))*4)) = minimal_tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5+int32(2))*4)) = -int32(1) + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5)*4)) = tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5+int32(1))*4)) = minimal_tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) num_minimals = num_minimals + 1 } _tre_purge_regset(tls, regset, tnfa, tag) } - *(*int32)(unsafe.Pointer(regset)) = -int32(1) + **(**int32)(__ccgo_up(regset)) = -int32(1) tag = next_tag num_tags = num_tags + 1 next_tag = next_tag + 1 @@ -130529,7 +130529,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u /* Push this submatch on the parents stack. */ i6 = 0 for { - if !(*(*int32)(unsafe.Pointer(parents + uintptr(i6)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(parents + uintptr(i6)*4)) >= 0) { break } goto _19 @@ -130537,8 +130537,8 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i6 = i6 + 1 } - *(*int32)(unsafe.Pointer(parents + uintptr(i6)*4)) = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fsubmatch_id - *(*int32)(unsafe.Pointer(parents + uintptr(i6+int32(1))*4)) = -int32(1) + **(**int32)(__ccgo_up(parents + uintptr(i6)*4)) = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fsubmatch_id + **(**int32)(__ccgo_up(parents + uintptr(i6+int32(1))*4)) = -int32(1) } goto _10 /* end case: ADDTAGS_RECURSE */ _4: @@ -130586,7 +130586,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u will be restored at ADDTAGS_AFTER_UNION_RIGHT below. */ _21: ; - if !(*(*int32)(unsafe.Pointer(regset)) >= 0) { + if !(**(**int32)(__ccgo_up(regset)) >= 0) { goto _20 } regset += 4 @@ -130623,11 +130623,11 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u if (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fnum_submatches > 0 { if !(first_pass != 0) { status = _tre_add_tag_right(tls, mem, left2, tag_left) - *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag_left)*4)) = int32(_TRE_TAG_MAXIMIZE) + **(**Ttre_tag_direction_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag_left)*4)) = int32(_TRE_TAG_MAXIMIZE) if status == REG_OK { status = _tre_add_tag_right(tls, mem, right2, tag_right) } - *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag_right)*4)) = int32(_TRE_TAG_MAXIMIZE) + **(**Ttre_tag_direction_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag_right)*4)) = int32(_TRE_TAG_MAXIMIZE) } num_tags = num_tags + int32(2) } @@ -130645,7 +130645,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u if !(first_pass != 0) && minimal_tag >= 0 { i7 = 0 for { - if !(*(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7)*4)) >= 0) { break } goto _23 @@ -130653,9 +130653,9 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i7 = i7 + 1 } - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7)*4)) = tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7+int32(1))*4)) = minimal_tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7+int32(2))*4)) = -int32(1) + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7)*4)) = tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7+int32(1))*4)) = minimal_tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) num_minimals = num_minimals + 1 } @@ -130712,7 +130712,7 @@ func _tre_copy_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, flags i /* XXX - e.g. [ab] has only one position but two nodes, so we are creating holes in the state space here. Not fatal, just wastes memory. */ - pos = pos + *(*int32)(unsafe.Pointer(pos_add)) + pos = pos + **(**int32)(__ccgo_up(pos_add)) num_copied = num_copied + 1 } else { if (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min == int64(-int32(3)) && flags&int32(COPY_REMOVE_TAGS) != 0 { @@ -130724,30 +130724,30 @@ func _tre_copy_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, flags i } else { if (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min == int64(-int32(3)) && flags&int32(COPY_MAXIMIZE_FIRST_TAG) != 0 && first_tag != 0 { /* Maximize the first tag. */ - *(*Ttre_tag_direction_t)(unsafe.Pointer(tag_directions + uintptr(max)*4)) = int32(_TRE_TAG_MAXIMIZE) + **(**Ttre_tag_direction_t)(__ccgo_up(tag_directions + uintptr(max)*4)) = int32(_TRE_TAG_MAXIMIZE) first_tag = 0 } } } - *(*uintptr)(unsafe.Pointer(result)) = _tre_ast_new_literal(tls, mem, min, max, pos) - if *(*uintptr)(unsafe.Pointer(result)) == UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(result)) = _tre_ast_new_literal(tls, mem, min, max, pos) + if **(**uintptr)(__ccgo_up(result)) == UintptrFromInt32(0) { status = int32(REG_ESPACE) } else { - p = (*Ttre_ast_node_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(result)))).Fobj + p = (*Ttre_ast_node_t)(unsafe.Pointer(**(**uintptr)(__ccgo_up(result)))).Fobj (*Ttre_literal_t)(unsafe.Pointer(p)).Fclass = (*Ttre_literal_t)(unsafe.Pointer(lit)).Fclass (*Ttre_literal_t)(unsafe.Pointer(p)).Fneg_classes = (*Ttre_literal_t)(unsafe.Pointer(lit)).Fneg_classes } - if pos > *(*int32)(unsafe.Pointer(max_pos)) { - *(*int32)(unsafe.Pointer(max_pos)) = pos + if pos > **(**int32)(__ccgo_up(max_pos)) { + **(**int32)(__ccgo_up(max_pos)) = pos } case int32(_UNION): uni = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj - *(*uintptr)(unsafe.Pointer(result)) = _tre_ast_new_union(tls, mem, (*Ttre_union_t)(unsafe.Pointer(uni)).Fleft, (*Ttre_union_t)(unsafe.Pointer(uni)).Fright) - if *(*uintptr)(unsafe.Pointer(result)) == UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(result)) = _tre_ast_new_union(tls, mem, (*Ttre_union_t)(unsafe.Pointer(uni)).Fleft, (*Ttre_union_t)(unsafe.Pointer(uni)).Fright) + if **(**uintptr)(__ccgo_up(result)) == UintptrFromInt32(0) { status = int32(REG_ESPACE) break } - tmp = (*Ttre_ast_node_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(result)))).Fobj + tmp = (*Ttre_ast_node_t)(unsafe.Pointer(**(**uintptr)(__ccgo_up(result)))).Fobj result = tmp status = _tre_stack_push_voidptr(tls, stack, (*Ttre_union_t)(unsafe.Pointer(uni)).Fright) if status != REG_OK { @@ -130775,12 +130775,12 @@ func _tre_copy_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, flags i } case int32(_CATENATION): cat = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj - *(*uintptr)(unsafe.Pointer(result)) = _tre_ast_new_catenation(tls, mem, (*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft, (*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright) - if *(*uintptr)(unsafe.Pointer(result)) == UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(result)) = _tre_ast_new_catenation(tls, mem, (*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft, (*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright) + if **(**uintptr)(__ccgo_up(result)) == UintptrFromInt32(0) { status = int32(REG_ESPACE) break } - tmp1 = (*Ttre_ast_node_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(result)))).Fobj + tmp1 = (*Ttre_ast_node_t)(unsafe.Pointer(**(**uintptr)(__ccgo_up(result)))).Fobj (*Ttre_catenation_t)(unsafe.Pointer(tmp1)).Fleft = UintptrFromInt32(0) (*Ttre_catenation_t)(unsafe.Pointer(tmp1)).Fright = UintptrFromInt32(0) result = tmp1 @@ -130818,12 +130818,12 @@ func _tre_copy_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, flags i if status != REG_OK { break } - *(*uintptr)(unsafe.Pointer(result)) = _tre_ast_new_iter(tls, mem, (*Ttre_iteration_t)(unsafe.Pointer(iter)).Farg, (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmin, (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmax, int32(uint32(*(*uint8)(unsafe.Pointer(iter + 16))&0x1>>0))) - if *(*uintptr)(unsafe.Pointer(result)) == UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(result)) = _tre_ast_new_iter(tls, mem, (*Ttre_iteration_t)(unsafe.Pointer(iter)).Farg, (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmin, (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmax, int32(uint32(*(*uint8)(unsafe.Pointer(iter + 16))&0x1>>0))) + if **(**uintptr)(__ccgo_up(result)) == UintptrFromInt32(0) { status = int32(REG_ESPACE) break } - iter = (*Ttre_ast_node_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(result)))).Fobj + iter = (*Ttre_ast_node_t)(unsafe.Pointer(**(**uintptr)(__ccgo_up(result)))).Fobj result = iter default: break @@ -130831,7 +130831,7 @@ func _tre_copy_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, flags i break } } - *(*int32)(unsafe.Pointer(pos_add)) += num_copied + **(**int32)(__ccgo_up(pos_add)) += num_copied return status } @@ -130859,9 +130859,9 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _status, _status1, bottom, cat, flags, iter, iter1, iter_depth, j, lit, node, pos_add_last, pos_add_save, pos_add_total, seq1, status, symbol, tmp, uni, v2 status = REG_OK bottom = _tre_stack_num_objects(tls, stack) - *(*int32)(unsafe.Pointer(bp)) = 0 + **(**int32)(__ccgo_up(bp)) = 0 pos_add_total = 0 - *(*int32)(unsafe.Pointer(bp + 4)) = 0 + **(**int32)(__ccgo_up(bp + 4)) = 0 iter_depth = 0 _status = _tre_stack_push_voidptr(tls, stack, ast) if _status != REG_OK { @@ -130883,9 +130883,9 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit case int32(_LITERAL): lit = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj if !((*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min < Int64FromInt32(0)) || (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min == int64(-int32(4)) { - *(*int32)(unsafe.Pointer(lit + 16)) += *(*int32)(unsafe.Pointer(bp)) - if (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition > *(*int32)(unsafe.Pointer(bp + 4)) { - *(*int32)(unsafe.Pointer(bp + 4)) = (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition + **(**int32)(__ccgo_up(lit + 16)) += **(**int32)(__ccgo_up(bp)) + if (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition > **(**int32)(__ccgo_up(bp + 4)) { + **(**int32)(__ccgo_up(bp + 4)) = (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition } } case int32(_UNION): @@ -130926,7 +130926,7 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit } case int32(_ITERATION): iter = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj - status = _tre_stack_push_int(tls, stack, *(*int32)(unsafe.Pointer(bp))) + status = _tre_stack_push_int(tls, stack, **(**int32)(__ccgo_up(bp))) if status != REG_OK { break } @@ -130950,7 +130950,7 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit then don't increase the `pos' fields of the nodes now, it will get done when expanding. */ if (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmin > int32(1) || (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmax > int32(1) { - *(*int32)(unsafe.Pointer(bp)) = 0 + **(**int32)(__ccgo_up(bp)) = 0 } iter_depth = iter_depth + 1 default: @@ -130958,12 +130958,12 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit } case int32(_EXPAND_AFTER_ITER): iter1 = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj - *(*int32)(unsafe.Pointer(bp)) = _tre_stack_pop_int(tls, stack) - pos_add_last = *(*int32)(unsafe.Pointer(bp)) + **(**int32)(__ccgo_up(bp)) = _tre_stack_pop_int(tls, stack) + pos_add_last = **(**int32)(__ccgo_up(bp)) if (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Fmin > int32(1) || (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Fmax > int32(1) { seq1 = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(bp + 8)) = UintptrFromInt32(0) - pos_add_save = *(*int32)(unsafe.Pointer(bp)) + **(**uintptr)(__ccgo_up(bp + 8)) = UintptrFromInt32(0) + pos_add_save = **(**int32)(__ccgo_up(bp)) /* Create a catenated sequence of copies of the node. */ j = 0 for { @@ -130977,15 +130977,15 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit } /* Remove tags from all but the last copy. */ flags = v2 - pos_add_save = *(*int32)(unsafe.Pointer(bp)) + pos_add_save = **(**int32)(__ccgo_up(bp)) status = _tre_copy_ast(tls, mem, stack, (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Farg, flags, bp, tag_directions, bp+16, bp+4) if status != REG_OK { return status } if seq1 != UintptrFromInt32(0) { - seq1 = _tre_ast_new_catenation(tls, mem, seq1, *(*uintptr)(unsafe.Pointer(bp + 16))) + seq1 = _tre_ast_new_catenation(tls, mem, seq1, **(**uintptr)(__ccgo_up(bp + 16))) } else { - seq1 = *(*uintptr)(unsafe.Pointer(bp + 16)) + seq1 = **(**uintptr)(__ccgo_up(bp + 16)) } if seq1 == UintptrFromInt32(0) { return int32(REG_ESPACE) @@ -130997,13 +130997,13 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit } if (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Fmax == -int32(1) { /* No upper limit. */ - pos_add_save = *(*int32)(unsafe.Pointer(bp)) + pos_add_save = **(**int32)(__ccgo_up(bp)) status = _tre_copy_ast(tls, mem, stack, (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Farg, 0, bp, UintptrFromInt32(0), bp+8, bp+4) if status != REG_OK { return status } - *(*uintptr)(unsafe.Pointer(bp + 8)) = _tre_ast_new_iter(tls, mem, *(*uintptr)(unsafe.Pointer(bp + 8)), 0, -int32(1), 0) - if *(*uintptr)(unsafe.Pointer(bp + 8)) == UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(bp + 8)) = _tre_ast_new_iter(tls, mem, **(**uintptr)(__ccgo_up(bp + 8)), 0, -int32(1), 0) + if **(**uintptr)(__ccgo_up(bp + 8)) == UintptrFromInt32(0) { return int32(REG_ESPACE) } } else { @@ -131012,25 +131012,25 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit if !(j < (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Fmax) { break } - pos_add_save = *(*int32)(unsafe.Pointer(bp)) + pos_add_save = **(**int32)(__ccgo_up(bp)) status = _tre_copy_ast(tls, mem, stack, (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Farg, 0, bp, UintptrFromInt32(0), bp+24, bp+4) if status != REG_OK { return status } - if *(*uintptr)(unsafe.Pointer(bp + 8)) != UintptrFromInt32(0) { - *(*uintptr)(unsafe.Pointer(bp + 8)) = _tre_ast_new_catenation(tls, mem, *(*uintptr)(unsafe.Pointer(bp + 24)), *(*uintptr)(unsafe.Pointer(bp + 8))) + if **(**uintptr)(__ccgo_up(bp + 8)) != UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(bp + 8)) = _tre_ast_new_catenation(tls, mem, **(**uintptr)(__ccgo_up(bp + 24)), **(**uintptr)(__ccgo_up(bp + 8))) } else { - *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 24)) + **(**uintptr)(__ccgo_up(bp + 8)) = **(**uintptr)(__ccgo_up(bp + 24)) } - if *(*uintptr)(unsafe.Pointer(bp + 8)) == UintptrFromInt32(0) { + if **(**uintptr)(__ccgo_up(bp + 8)) == UintptrFromInt32(0) { return int32(REG_ESPACE) } tmp = _tre_ast_new_literal(tls, mem, -int32(1), -int32(1), -int32(1)) if tmp == UintptrFromInt32(0) { return int32(REG_ESPACE) } - *(*uintptr)(unsafe.Pointer(bp + 8)) = _tre_ast_new_union(tls, mem, tmp, *(*uintptr)(unsafe.Pointer(bp + 8))) - if *(*uintptr)(unsafe.Pointer(bp + 8)) == UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(bp + 8)) = _tre_ast_new_union(tls, mem, tmp, **(**uintptr)(__ccgo_up(bp + 8))) + if **(**uintptr)(__ccgo_up(bp + 8)) == UintptrFromInt32(0) { return int32(REG_ESPACE) } goto _3 @@ -131039,12 +131039,12 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit j = j + 1 } } - *(*int32)(unsafe.Pointer(bp)) = pos_add_save + **(**int32)(__ccgo_up(bp)) = pos_add_save if seq1 == UintptrFromInt32(0) { - seq1 = *(*uintptr)(unsafe.Pointer(bp + 8)) + seq1 = **(**uintptr)(__ccgo_up(bp + 8)) } else { - if *(*uintptr)(unsafe.Pointer(bp + 8)) != UintptrFromInt32(0) { - seq1 = _tre_ast_new_catenation(tls, mem, seq1, *(*uintptr)(unsafe.Pointer(bp + 8))) + if **(**uintptr)(__ccgo_up(bp + 8)) != UintptrFromInt32(0) { + seq1 = _tre_ast_new_catenation(tls, mem, seq1, **(**uintptr)(__ccgo_up(bp + 8))) } } if seq1 == UintptrFromInt32(0) { @@ -131054,21 +131054,21 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit (*Ttre_ast_node_t)(unsafe.Pointer(node)).Ftype1 = (*Ttre_ast_node_t)(unsafe.Pointer(seq1)).Ftype1 } iter_depth = iter_depth - 1 - pos_add_total = pos_add_total + (*(*int32)(unsafe.Pointer(bp)) - pos_add_last) + pos_add_total = pos_add_total + (**(**int32)(__ccgo_up(bp)) - pos_add_last) if iter_depth == 0 { - *(*int32)(unsafe.Pointer(bp)) = pos_add_total + **(**int32)(__ccgo_up(bp)) = pos_add_total } default: break } } - *(*int32)(unsafe.Pointer(position)) += pos_add_total + **(**int32)(__ccgo_up(position)) += pos_add_total /* `max_pos' should never be larger than `*position' if the above code works, but just an extra safeguard let's make sure `*position' is set large enough so enough memory will be allocated for the transition table. */ - if *(*int32)(unsafe.Pointer(bp + 4)) > *(*int32)(unsafe.Pointer(position)) { - *(*int32)(unsafe.Pointer(position)) = *(*int32)(unsafe.Pointer(bp + 4)) + if **(**int32)(__ccgo_up(bp + 4)) > **(**int32)(__ccgo_up(position)) { + **(**int32)(__ccgo_up(position)) = **(**int32)(__ccgo_up(bp + 4)) } return status } @@ -131080,9 +131080,9 @@ func _tre_set_empty(tls *TLS, mem Ttre_mem_t) (r uintptr) { if new_set == UintptrFromInt32(0) { return UintptrFromInt32(0) } - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fposition = -int32(1) - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fcode_min = -int32(1) - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fcode_max = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fposition = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fcode_min = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fcode_max = -int32(1) return new_set } @@ -131093,15 +131093,15 @@ func _tre_set_one(tls *TLS, mem Ttre_mem_t, position int32, code_min int32, code if new_set == UintptrFromInt32(0) { return UintptrFromInt32(0) } - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fposition = position - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fcode_min = code_min - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fcode_max = code_max - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fclass = class - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fneg_classes = neg_classes - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fbackref = backref - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + 1*56))).Fposition = -int32(1) - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + 1*56))).Fcode_min = -int32(1) - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + 1*56))).Fcode_max = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fposition = position + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fcode_min = code_min + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fcode_max = code_max + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fclass = class + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fneg_classes = neg_classes + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fbackref = backref + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + 1*56))).Fposition = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + 1*56))).Fcode_min = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + 1*56))).Fcode_max = -int32(1) return new_set } @@ -131111,7 +131111,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u _, _, _, _, _, _, _ = i, j, new_set, new_tags, num_tags, s1, s2 num_tags = 0 for { - if !(tags != UintptrFromInt32(0) && *(*int32)(unsafe.Pointer(tags + uintptr(num_tags)*4)) >= 0) { + if !(tags != UintptrFromInt32(0) && **(**int32)(__ccgo_up(tags + uintptr(num_tags)*4)) >= 0) { break } goto _1 @@ -131121,7 +131121,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u } s1 = 0 for { - if !((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fposition >= 0) { + if !((**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fposition >= 0) { break } goto _2 @@ -131131,7 +131131,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u } s2 = 0 for { - if !((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fposition >= 0) { + if !((**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fposition >= 0) { break } goto _3 @@ -131145,22 +131145,22 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u } s1 = 0 for { - if !((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fposition >= 0) { + if !((**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fposition >= 0) { break } - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Fposition = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fposition - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Fcode_min = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fcode_min - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Fcode_max = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fcode_max - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Fassertions = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fassertions | assertions - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Fclass = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fclass - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Fneg_classes = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fneg_classes - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Fbackref = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fbackref - if (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Ftags == UintptrFromInt32(0) && tags == UintptrFromInt32(0) { - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Ftags = UintptrFromInt32(0) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Fposition = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fposition + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Fcode_min = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fcode_min + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Fcode_max = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fcode_max + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Fassertions = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fassertions | assertions + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Fclass = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fclass + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Fneg_classes = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fneg_classes + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Fbackref = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fbackref + if (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Ftags == UintptrFromInt32(0) && tags == UintptrFromInt32(0) { + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Ftags = UintptrFromInt32(0) } else { i = 0 for { - if !((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Ftags != UintptrFromInt32(0) && *(*int32)(unsafe.Pointer((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Ftags + uintptr(i)*4)) >= 0) { + if !((**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Ftags != UintptrFromInt32(0) && **(**int32)(__ccgo_up((**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Ftags + uintptr(i)*4)) >= 0) { break } goto _5 @@ -131177,7 +131177,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u if !(j < i) { break } - *(*int32)(unsafe.Pointer(new_tags + uintptr(j)*4)) = *(*int32)(unsafe.Pointer((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Ftags + uintptr(j)*4)) + **(**int32)(__ccgo_up(new_tags + uintptr(j)*4)) = **(**int32)(__ccgo_up((**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Ftags + uintptr(j)*4)) goto _6 _6: ; @@ -131188,14 +131188,14 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u if !(i < num_tags) { break } - *(*int32)(unsafe.Pointer(new_tags + uintptr(j+i)*4)) = *(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) + **(**int32)(__ccgo_up(new_tags + uintptr(j+i)*4)) = **(**int32)(__ccgo_up(tags + uintptr(i)*4)) goto _7 _7: ; i = i + 1 } - *(*int32)(unsafe.Pointer(new_tags + uintptr(j+i)*4)) = -int32(1) - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Ftags = new_tags + **(**int32)(__ccgo_up(new_tags + uintptr(j+i)*4)) = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Ftags = new_tags } goto _4 _4: @@ -131204,23 +131204,23 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u } s2 = 0 for { - if !((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fposition >= 0) { + if !((**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fposition >= 0) { break } - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fposition = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fposition - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fcode_min = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fcode_min - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fcode_max = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fcode_max + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Fposition = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fposition + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Fcode_min = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fcode_min + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Fcode_max = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fcode_max /* XXX - why not | assertions here as well? */ - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fassertions = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fassertions - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fclass = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fclass - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fneg_classes = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fneg_classes - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fbackref = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fbackref - if (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Ftags == UintptrFromInt32(0) { - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Ftags = UintptrFromInt32(0) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Fassertions = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fassertions + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Fclass = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fclass + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Fneg_classes = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fneg_classes + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Fbackref = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fbackref + if (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Ftags == UintptrFromInt32(0) { + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Ftags = UintptrFromInt32(0) } else { i = 0 for { - if !(*(*int32)(unsafe.Pointer((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Ftags + uintptr(i)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Ftags + uintptr(i)*4)) >= 0) { break } goto _9 @@ -131237,21 +131237,21 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u if !(j < i) { break } - *(*int32)(unsafe.Pointer(new_tags + uintptr(j)*4)) = *(*int32)(unsafe.Pointer((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Ftags + uintptr(j)*4)) + **(**int32)(__ccgo_up(new_tags + uintptr(j)*4)) = **(**int32)(__ccgo_up((**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Ftags + uintptr(j)*4)) goto _10 _10: ; j = j + 1 } - *(*int32)(unsafe.Pointer(new_tags + uintptr(j)*4)) = -int32(1) - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Ftags = new_tags + **(**int32)(__ccgo_up(new_tags + uintptr(j)*4)) = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Ftags = new_tags } goto _8 _8: ; s2 = s2 + 1 } - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fposition = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Fposition = -int32(1) return new_set } @@ -131269,7 +131269,7 @@ func _tre_match_empty(tls *TLS, stack uintptr, node uintptr, tags uintptr, asser bottom = _tre_stack_num_objects(tls, stack) status = REG_OK if num_tags_seen != 0 { - *(*int32)(unsafe.Pointer(num_tags_seen)) = 0 + **(**int32)(__ccgo_up(num_tags_seen)) = 0 } status = _tre_stack_push_voidptr(tls, stack, node) /* Walk through the tree recursively. */ @@ -131285,10 +131285,10 @@ func _tre_match_empty(tls *TLS, stack uintptr, node uintptr, tags uintptr, asser /* Add the tag to `tags'. */ i = 0 for { - if !(*(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(tags + uintptr(i)*4)) >= 0) { break } - if int64(*(*int32)(unsafe.Pointer(tags + uintptr(i)*4))) == (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max { + if int64(**(**int32)(__ccgo_up(tags + uintptr(i)*4))) == (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max { break } goto _1 @@ -131296,13 +131296,13 @@ func _tre_match_empty(tls *TLS, stack uintptr, node uintptr, tags uintptr, asser ; i = i + 1 } - if *(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) < 0 { - *(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) = int32((*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max) - *(*int32)(unsafe.Pointer(tags + uintptr(i+int32(1))*4)) = -int32(1) + if **(**int32)(__ccgo_up(tags + uintptr(i)*4)) < 0 { + **(**int32)(__ccgo_up(tags + uintptr(i)*4)) = int32((*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max) + **(**int32)(__ccgo_up(tags + uintptr(i+int32(1))*4)) = -int32(1) } } if num_tags_seen != 0 { - *(*int32)(unsafe.Pointer(num_tags_seen)) = *(*int32)(unsafe.Pointer(num_tags_seen)) + 1 + **(**int32)(__ccgo_up(num_tags_seen)) = **(**int32)(__ccgo_up(num_tags_seen)) + 1 } } case int64(-int32(2)): @@ -131546,12 +131546,12 @@ func _tre_compute_nfl(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr) (r return status } /* Allocate arrays for the tags and parameters. */ - tags = Xmalloc(tls, uint64(4)*Uint64FromInt32(*(*int32)(unsafe.Pointer(bp))+Int32FromInt32(1))) + tags = Xmalloc(tls, uint64(4)*Uint64FromInt32(**(**int32)(__ccgo_up(bp))+Int32FromInt32(1))) if !(tags != 0) { return int32(REG_ESPACE) } - *(*int32)(unsafe.Pointer(tags)) = -int32(1) - *(*int32)(unsafe.Pointer(bp + 4)) = 0 + **(**int32)(__ccgo_up(tags)) = -int32(1) + **(**int32)(__ccgo_up(bp + 4)) = 0 /* Second pass with tre_mach_empty() to get the list of tags and parameters. */ status = _tre_match_empty(tls, stack, (*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft, tags, bp+4, UintptrFromInt32(0)) @@ -131559,7 +131559,7 @@ func _tre_compute_nfl(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr) (r Xfree(tls, tags) return status } - (*Ttre_ast_node_t)(unsafe.Pointer(node)).Ffirstpos = _tre_set_union(tls, mem, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright)).Ffirstpos, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft)).Ffirstpos, tags, *(*int32)(unsafe.Pointer(bp + 4))) + (*Ttre_ast_node_t)(unsafe.Pointer(node)).Ffirstpos = _tre_set_union(tls, mem, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright)).Ffirstpos, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft)).Ffirstpos, tags, **(**int32)(__ccgo_up(bp + 4))) Xfree(tls, tags) if !((*Ttre_ast_node_t)(unsafe.Pointer(node)).Ffirstpos != 0) { return int32(REG_ESPACE) @@ -131577,12 +131577,12 @@ func _tre_compute_nfl(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr) (r return status } /* Allocate arrays for the tags and parameters. */ - tags = Xmalloc(tls, uint64(4)*Uint64FromInt32(*(*int32)(unsafe.Pointer(bp))+Int32FromInt32(1))) + tags = Xmalloc(tls, uint64(4)*Uint64FromInt32(**(**int32)(__ccgo_up(bp))+Int32FromInt32(1))) if !(tags != 0) { return int32(REG_ESPACE) } - *(*int32)(unsafe.Pointer(tags)) = -int32(1) - *(*int32)(unsafe.Pointer(bp + 4)) = 0 + **(**int32)(__ccgo_up(tags)) = -int32(1) + **(**int32)(__ccgo_up(bp + 4)) = 0 /* Second pass with tre_mach_empty() to get the list of tags and parameters. */ status = _tre_match_empty(tls, stack, (*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright, tags, bp+4, UintptrFromInt32(0)) @@ -131590,7 +131590,7 @@ func _tre_compute_nfl(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr) (r Xfree(tls, tags) return status } - (*Ttre_ast_node_t)(unsafe.Pointer(node)).Flastpos = _tre_set_union(tls, mem, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft)).Flastpos, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright)).Flastpos, tags, *(*int32)(unsafe.Pointer(bp + 4))) + (*Ttre_ast_node_t)(unsafe.Pointer(node)).Flastpos = _tre_set_union(tls, mem, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft)).Flastpos, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright)).Flastpos, tags, **(**int32)(__ccgo_up(bp + 4))) Xfree(tls, tags) if !((*Ttre_ast_node_t)(unsafe.Pointer(node)).Flastpos != 0) { return int32(REG_ESPACE) @@ -131626,7 +131626,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun prev_p2_pos = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fposition /* Set `trans' to point to the next unused transition from position `p1->position'. */ - trans = transitions + uintptr(*(*int32)(unsafe.Pointer(offs + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)))*56 + trans = transitions + uintptr(**(**int32)(__ccgo_up(offs + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)))*56 for (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fstate != UintptrFromInt32(0) { trans += 56 } @@ -131637,7 +131637,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun the transition from `p1' to `p2'. */ (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fcode_min = Uint32FromInt32((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fcode_min) (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fcode_max = Uint32FromInt32((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fcode_max) - (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fstate = transitions + uintptr(*(*int32)(unsafe.Pointer(offs + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fposition)*4)))*56 + (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fstate = transitions + uintptr(**(**int32)(__ccgo_up(offs + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fposition)*4)))*56 (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fstate_id = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fposition if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fclass != 0 { v1 = int32(ASSERT_CHAR_CLASS) @@ -131652,14 +131652,14 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fassertions = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fassertions | (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fassertions | v1 | v2 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fbackref >= 0 { *(*int32)(unsafe.Pointer(&(*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fu)) = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fbackref - *(*int32)(unsafe.Pointer(trans + 32)) |= int32(ASSERT_BACKREF) + **(**int32)(__ccgo_up(trans + 32)) |= int32(ASSERT_BACKREF) } else { *(*Ttre_ctype_t)(unsafe.Pointer(trans + 40)) = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fclass } if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes != UintptrFromInt32(0) { i = 0 for { - if !(*(*Ttre_ctype_t)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes + uintptr(i)*8)) != Uint64FromInt32(0)) { + if !(**(**Ttre_ctype_t)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes + uintptr(i)*8)) != Uint64FromInt32(0)) { break } goto _3 @@ -131673,29 +131673,29 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun } i = 0 for { - if !(*(*Ttre_ctype_t)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes + uintptr(i)*8)) != Uint64FromInt32(0)) { + if !(**(**Ttre_ctype_t)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes + uintptr(i)*8)) != Uint64FromInt32(0)) { break } - *(*Ttre_ctype_t)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes + uintptr(i)*8)) = *(*Ttre_ctype_t)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes + uintptr(i)*8)) + **(**Ttre_ctype_t)(__ccgo_up((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes + uintptr(i)*8)) = **(**Ttre_ctype_t)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes + uintptr(i)*8)) goto _4 _4: ; i = i + 1 } - *(*Ttre_ctype_t)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes + uintptr(i)*8)) = Uint64FromInt32(0) + **(**Ttre_ctype_t)(__ccgo_up((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes + uintptr(i)*8)) = Uint64FromInt32(0) } else { (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes = UintptrFromInt32(0) } /* Find out how many tags this transition has. */ i = 0 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags != UintptrFromInt32(0) { - for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) >= 0 { + for **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) >= 0 { i = i + 1 } } j = 0 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags != UintptrFromInt32(0) { - for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) >= 0 { + for **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) >= 0 { j = j + 1 } } @@ -131712,15 +131712,15 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun } i = 0 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags != UintptrFromInt32(0) { - for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) >= 0 { - *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(i)*4)) = *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) + for **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) >= 0 { + **(**int32)(__ccgo_up((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(i)*4)) = **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) i = i + 1 } } l = i j = 0 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags != UintptrFromInt32(0) { - for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) >= 0 { + for **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) >= 0 { /* Don't add duplicates. */ dup = 0 k = 0 @@ -131728,7 +131728,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun if !(k < i) { break } - if *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(k)*4)) == *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) { + if **(**int32)(__ccgo_up((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(k)*4)) == **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) { dup = int32(1) break } @@ -131740,12 +131740,12 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun if !(dup != 0) { v1 = l l = l + 1 - *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(v1)*4)) = *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) + **(**int32)(__ccgo_up((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(v1)*4)) = **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) } j = j + 1 } } - *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(l)*4)) = -int32(1) + **(**int32)(__ccgo_up((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(l)*4)) = -int32(1) } p2 += 56 } @@ -131757,7 +131757,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun for (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition >= 0 { p2 = orig_p2 for (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fposition >= 0 { - *(*int32)(unsafe.Pointer(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)) = *(*int32)(unsafe.Pointer(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)) + 1 + **(**int32)(__ccgo_up(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)) = **(**int32)(__ccgo_up(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)) + 1 p2 += 56 } p1 += 56 @@ -131848,11 +131848,11 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { } /* Parse the regexp. */ Xmemset(tls, bp, 0, uint64(56)) - (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fmem = mem - (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fstack = stack - (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fstart = regex - (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fcflags = cflags - (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fmax_backref = -int32(1) + (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fmem = mem + (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fstack = stack + (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fstart = regex + (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fcflags = cflags + (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fmax_backref = -int32(1) errcode = _tre_parse(tls, bp) if errcode != REG_OK { errcode = errcode @@ -131860,10 +131860,10 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { goto error_exit } } - (*Tregex_t)(unsafe.Pointer(preg)).Fre_nsub = Uint64FromInt32((*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fsubmatch_id - int32(1)) - tree = (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fn + (*Tregex_t)(unsafe.Pointer(preg)).Fre_nsub = Uint64FromInt32((**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fsubmatch_id - int32(1)) + tree = (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fn /* Referring to nonexistent subexpressions is illegal. */ - if (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fmax_backref > Int32FromUint64((*Tregex_t)(unsafe.Pointer(preg)).Fre_nsub) { + if (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fmax_backref > Int32FromUint64((*Tregex_t)(unsafe.Pointer(preg)).Fre_nsub) { errcode = int32(REG_ESUBREG) if int32(1) != 0 { goto error_exit @@ -131877,9 +131877,9 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { goto error_exit } } - (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fhave_backrefs = BoolInt32((*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fmax_backref >= 0) + (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fhave_backrefs = BoolInt32((**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fmax_backref >= 0) (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fhave_approx = 0 - (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches = Uint32FromInt32((*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fsubmatch_id) + (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches = Uint32FromInt32((**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fsubmatch_id) /* Set up tags for submatch addressing. If REG_NOSUB is set and the regexp does not have back references, this can be skipped. */ if (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fhave_backrefs != 0 || !(cflags&Int32FromInt32(REG_NOSUB) != 0) { @@ -131909,7 +131909,7 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { goto error_exit } } - submatch_data = Xcalloc(tls, uint64(Uint32FromInt32((*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fsubmatch_id)), uint64(16)) + submatch_data = Xcalloc(tls, uint64(Uint32FromInt32((**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fsubmatch_id)), uint64(16)) if submatch_data == UintptrFromInt32(0) { errcode = int32(REG_ESPACE) if int32(1) != 0 { @@ -131962,14 +131962,14 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { goto error_exit } } - counts = Xmalloc(tls, uint64(4)*Uint64FromInt32((*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fposition)) + counts = Xmalloc(tls, uint64(4)*Uint64FromInt32((**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fposition)) if counts == UintptrFromInt32(0) { errcode = int32(REG_ESPACE) if int32(1) != 0 { goto error_exit } } - offs = Xmalloc(tls, uint64(4)*Uint64FromInt32((*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fposition)) + offs = Xmalloc(tls, uint64(4)*Uint64FromInt32((**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fposition)) if offs == UintptrFromInt32(0) { errcode = int32(REG_ESPACE) if int32(1) != 0 { @@ -131978,10 +131978,10 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { } i = 0 for { - if !(i < (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fposition) { + if !(i < (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fposition) { break } - *(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) = 0 + **(**int32)(__ccgo_up(counts + uintptr(i)*4)) = 0 goto _3 _3: ; @@ -131991,12 +131991,12 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { add = 0 i = 0 for { - if !(i < (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fposition) { + if !(i < (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fposition) { break } - *(*int32)(unsafe.Pointer(offs + uintptr(i)*4)) = add - add = add + (*(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) + int32(1)) - *(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) = 0 + **(**int32)(__ccgo_up(offs + uintptr(i)*4)) = add + add = add + (**(**int32)(__ccgo_up(counts + uintptr(i)*4)) + int32(1)) + **(**int32)(__ccgo_up(counts + uintptr(i)*4)) = 0 goto _4 _4: ; @@ -132039,15 +132039,15 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { if !((*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fposition >= 0) { break } - (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Fstate = transitions + uintptr(*(*int32)(unsafe.Pointer(offs + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fposition)*4)))*56 - (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Fstate_id = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fposition - (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Ftags = UintptrFromInt32(0) + (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*56))).Fstate = transitions + uintptr(**(**int32)(__ccgo_up(offs + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fposition)*4)))*56 + (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*56))).Fstate_id = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fposition + (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*56))).Ftags = UintptrFromInt32(0) /* Copy the arrays p->tags, and p->params, they are allocated from a tre_mem object. */ if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Ftags != 0 { j = 0 for { - if !(*(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Ftags + uintptr(j)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Ftags + uintptr(j)*4)) >= 0) { break } goto _6 @@ -132055,26 +132055,26 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { ; j = j + 1 } - (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Ftags = Xmalloc(tls, uint64(4)*Uint64FromInt32(j+Int32FromInt32(1))) - if !((*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Ftags != 0) { + (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*56))).Ftags = Xmalloc(tls, uint64(4)*Uint64FromInt32(j+Int32FromInt32(1))) + if !((**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*56))).Ftags != 0) { errcode = int32(REG_ESPACE) if int32(1) != 0 { goto error_exit } } - Xmemcpy(tls, (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Ftags, (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Ftags, uint64(4)*Uint64FromInt32(j+Int32FromInt32(1))) + Xmemcpy(tls, (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*56))).Ftags, (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Ftags, uint64(4)*Uint64FromInt32(j+Int32FromInt32(1))) } - (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Fassertions = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fassertions + (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*56))).Fassertions = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fassertions i = i + 1 goto _5 _5: ; p += 56 } - (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Fstate = UintptrFromInt32(0) + (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*56))).Fstate = UintptrFromInt32(0) (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_transitions = Uint32FromInt32(add) - (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ffinal = transitions + uintptr(*(*int32)(unsafe.Pointer(offs + uintptr((*(*Ttre_pos_and_tags_t)(unsafe.Pointer((*Ttre_ast_node_t)(unsafe.Pointer(tree)).Flastpos))).Fposition)*4)))*56 - (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_states = (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fposition + (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ffinal = transitions + uintptr(**(**int32)(__ccgo_up(offs + uintptr((**(**Ttre_pos_and_tags_t)(__ccgo_up((*Ttre_ast_node_t)(unsafe.Pointer(tree)).Flastpos))).Fposition)*4)))*56 + (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_states = (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fposition (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags = cflags X__tre_mem_destroy(tls, mem) _tre_stack_destroy(tls, stack) @@ -132117,12 +132117,12 @@ func Xregfree(tls *TLS, preg uintptr) { if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_transitions) { break } - if (*(*Ttre_tnfa_transition_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Fstate != 0 { - if (*(*Ttre_tnfa_transition_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Ftags != 0 { - Xfree(tls, (*(*Ttre_tnfa_transition_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Ftags) + if (**(**Ttre_tnfa_transition_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Fstate != 0 { + if (**(**Ttre_tnfa_transition_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Ftags != 0 { + Xfree(tls, (**(**Ttre_tnfa_transition_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Ftags) } - if (*(*Ttre_tnfa_transition_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Fneg_classes != 0 { - Xfree(tls, (*(*Ttre_tnfa_transition_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Fneg_classes) + if (**(**Ttre_tnfa_transition_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Fneg_classes != 0 { + Xfree(tls, (**(**Ttre_tnfa_transition_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Fneg_classes) } } goto _1 @@ -132155,8 +132155,8 @@ func Xregfree(tls *TLS, preg uintptr) { if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches) { break } - if (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(i)*16))).Fparents != 0 { - Xfree(tls, (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(i)*16))).Fparents) + if (**(**Ttre_submatch_data_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(i)*16))).Fparents != 0 { + Xfree(tls, (**(**Ttre_submatch_data_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(i)*16))).Fparents) } goto _3 _3: @@ -132196,7 +132196,7 @@ func Xregerror(tls *TLS, e int32, preg uintptr, buf uintptr, size Tsize_t) (r Ts _ = s s = uintptr(unsafe.Pointer(&_messages)) for { - if !(e != 0 && *(*uint8)(unsafe.Pointer(s)) != 0) { + if !(e != 0 && **(**uint8)(__ccgo_up(s)) != 0) { break } goto _1 @@ -132205,7 +132205,7 @@ func Xregerror(tls *TLS, e int32, preg uintptr, buf uintptr, size Tsize_t) (r Ts e = e - 1 s = s + uintptr(_strlen(tls, s)+uint64(1)) } - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { s = s + 1 } s = X__lctrans_cur(tls, s) @@ -132231,18 +132231,18 @@ func _tre_tag_order(tls *TLS, num_tags int32, tag_directions uintptr, t1 uintptr if !(i < num_tags) { break } - if *(*Ttre_tag_direction_t)(unsafe.Pointer(tag_directions + uintptr(i)*4)) == int32(_TRE_TAG_MINIMIZE) { - if *(*Tregoff_t)(unsafe.Pointer(t1 + uintptr(i)*8)) < *(*Tregoff_t)(unsafe.Pointer(t2 + uintptr(i)*8)) { + if **(**Ttre_tag_direction_t)(__ccgo_up(tag_directions + uintptr(i)*4)) == int32(_TRE_TAG_MINIMIZE) { + if **(**Tregoff_t)(__ccgo_up(t1 + uintptr(i)*8)) < **(**Tregoff_t)(__ccgo_up(t2 + uintptr(i)*8)) { return int32(1) } - if *(*Tregoff_t)(unsafe.Pointer(t1 + uintptr(i)*8)) > *(*Tregoff_t)(unsafe.Pointer(t2 + uintptr(i)*8)) { + if **(**Tregoff_t)(__ccgo_up(t1 + uintptr(i)*8)) > **(**Tregoff_t)(__ccgo_up(t2 + uintptr(i)*8)) { return 0 } } else { - if *(*Tregoff_t)(unsafe.Pointer(t1 + uintptr(i)*8)) > *(*Tregoff_t)(unsafe.Pointer(t2 + uintptr(i)*8)) { + if **(**Tregoff_t)(__ccgo_up(t1 + uintptr(i)*8)) > **(**Tregoff_t)(__ccgo_up(t2 + uintptr(i)*8)) { return int32(1) } - if *(*Tregoff_t)(unsafe.Pointer(t1 + uintptr(i)*8)) < *(*Tregoff_t)(unsafe.Pointer(t2 + uintptr(i)*8)) { + if **(**Tregoff_t)(__ccgo_up(t1 + uintptr(i)*8)) < **(**Tregoff_t)(__ccgo_up(t2 + uintptr(i)*8)) { return 0 } } @@ -132256,8 +132256,8 @@ func _tre_tag_order(tls *TLS, num_tags int32, tag_directions uintptr, t1 uintptr } func _tre_neg_char_classes_match(tls *TLS, classes uintptr, wc Ttre_cint_t, icase int32) (r int32) { - for *(*Ttre_ctype_t)(unsafe.Pointer(classes)) != Uint64FromInt32(0) { - if !(icase != 0) && Xiswctype(tls, wc, *(*Ttre_ctype_t)(unsafe.Pointer(classes))) != 0 || icase != 0 && (Xiswctype(tls, Xtowupper(tls, wc), *(*Ttre_ctype_t)(unsafe.Pointer(classes))) != 0 || Xiswctype(tls, Xtowlower(tls, wc), *(*Ttre_ctype_t)(unsafe.Pointer(classes))) != 0) { + for **(**Ttre_ctype_t)(__ccgo_up(classes)) != Uint64FromInt32(0) { + if !(icase != 0) && Xiswctype(tls, wc, **(**Ttre_ctype_t)(__ccgo_up(classes))) != 0 || icase != 0 && (Xiswctype(tls, Xtowupper(tls, wc), **(**Ttre_ctype_t)(__ccgo_up(classes))) != 0 || Xiswctype(tls, Xtowlower(tls, wc), **(**Ttre_ctype_t)(__ccgo_up(classes))) != 0) { return int32(1) } else { classes += 8 @@ -132310,7 +132310,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = buf, end, i, match_eo, new_match, num_tags, pbytes, pos, pos_add_next, prev_c, rbytes, reach, reach_i, reach_next, reach_next_i, reach_pos, reg_newline, reg_notbol, reg_noteol, ret, skip, start, str_byte, tag_i, tbytes, tmp_buf, tmp_iptr, tmp_tags, total_bytes, trans_i, xbytes, v1, v18, v7 /* State variables required by GET_NEXT_WCHAR. */ prev_c = uint32(0) - *(*Ttre_char_t)(unsafe.Pointer(bp)) = uint32(0) + **(**Ttre_char_t)(__ccgo_up(bp)) = uint32(0) str_byte = string1 pos = int64(-int32(1)) pos_add_next = int64(1) @@ -132390,9 +132390,9 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_states) { break } - (*(*Ttre_tnfa_reach_t)(unsafe.Pointer(reach + uintptr(i)*16))).Ftags = tmp_buf + (**(**Ttre_tnfa_reach_t)(__ccgo_up(reach + uintptr(i)*16))).Ftags = tmp_buf tmp_buf = tmp_buf + uintptr(xbytes) - (*(*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next + uintptr(i)*16))).Ftags = tmp_buf + (**(**Ttre_tnfa_reach_t)(__ccgo_up(reach_next + uintptr(i)*16))).Ftags = tmp_buf tmp_buf = tmp_buf + uintptr(xbytes) goto _5 _5: @@ -132404,13 +132404,13 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_states) { break } - (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr(i)*16))).Fpos = int64(-int32(1)) + (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr(i)*16))).Fpos = int64(-int32(1)) goto _6 _6: ; i = i + 1 } - prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + prev_c = **(**Ttre_char_t)(__ccgo_up(bp)) pos = pos + pos_add_next v7 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) pos_add_next = v7 @@ -132430,8 +132430,8 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if match_eo < 0 { trans_i = (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Finitial for (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate != UintptrFromInt32(0) { - if (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos < pos { - if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != uint32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != uint32('\000') || reg_noteol != 0) && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != uint32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0 || !(*(*Ttre_char_t)(unsafe.Pointer(bp)) == uint32('_') || Xiswalnum(tls, *(*Ttre_char_t)(unsafe.Pointer(bp))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0) || (*(*Ttre_char_t)(unsafe.Pointer(bp)) == uint32('_') || Xiswalnum(tls, *(*Ttre_char_t)(unsafe.Pointer(bp))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && *(*Ttre_char_t)(unsafe.Pointer(bp)) != uint32('\000') && BoolInt32(prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0) == BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == uint32('_') || Xiswalnum(tls, *(*Ttre_char_t)(unsafe.Pointer(bp))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || *(*Ttre_char_t)(unsafe.Pointer(bp)) == uint32('\000') || BoolInt32(prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0) != BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == uint32('_') || Xiswalnum(tls, *(*Ttre_char_t)(unsafe.Pointer(bp))) != 0))) { + if (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos < pos { + if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != uint32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (**(**Ttre_char_t)(__ccgo_up(bp)) != uint32('\000') || reg_noteol != 0) && (**(**Ttre_char_t)(__ccgo_up(bp)) != uint32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0 || !(**(**Ttre_char_t)(__ccgo_up(bp)) == uint32('_') || Xiswalnum(tls, **(**Ttre_char_t)(__ccgo_up(bp))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0) || (**(**Ttre_char_t)(__ccgo_up(bp)) == uint32('_') || Xiswalnum(tls, **(**Ttre_char_t)(__ccgo_up(bp))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && **(**Ttre_char_t)(__ccgo_up(bp)) != uint32('\000') && BoolInt32(prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0) == BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == uint32('_') || Xiswalnum(tls, **(**Ttre_char_t)(__ccgo_up(bp))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || **(**Ttre_char_t)(__ccgo_up(bp)) == uint32('\000') || BoolInt32(prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0) != BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == uint32('_') || Xiswalnum(tls, **(**Ttre_char_t)(__ccgo_up(bp))) != 0))) { trans_i += 56 continue } @@ -132441,7 +132441,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < num_tags) { break } - *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(i)*8)) = int64(-int32(1)) + **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(i)*8)) = int64(-int32(1)) goto _8 _8: ; @@ -132449,9 +132449,9 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags } tag_i = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags if tag_i != 0 { - for *(*int32)(unsafe.Pointer(tag_i)) >= 0 { - if *(*int32)(unsafe.Pointer(tag_i)) < num_tags { - *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(*(*int32)(unsafe.Pointer(tag_i)))*8)) = pos + for **(**int32)(__ccgo_up(tag_i)) >= 0 { + if **(**int32)(__ccgo_up(tag_i)) < num_tags { + **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(**(**int32)(__ccgo_up(tag_i)))*8)) = pos } tag_i += 4 } @@ -132464,15 +132464,15 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < num_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(i)*8)) = *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(i)*8)) + **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(i)*8)) = **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(i)*8)) goto _9 _9: ; i = i + 1 } } - (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos = pos - (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags = reach_next_i + 8 + (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos = pos + (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags = reach_next_i + 8 reach_next_i += 16 } trans_i += 56 @@ -132485,10 +132485,10 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags } } /* Check for end of string. */ - if !(*(*Ttre_char_t)(unsafe.Pointer(bp)) != 0) { + if !(**(**Ttre_char_t)(__ccgo_up(bp)) != 0) { break } - prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + prev_c = **(**Ttre_char_t)(__ccgo_up(bp)) pos = pos + pos_add_next v7 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) pos_add_next = v7 @@ -132518,16 +132518,16 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags skip = 0 i = 0 for { - if !(*(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i)*4)) >= 0) { break } - end = *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i)*4)) - start = *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i+int32(1))*4)) + end = **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i)*4)) + start = **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i+int32(1))*4)) if end >= num_tags { skip = int32(1) break } else { - if *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Ftags + uintptr(start)*8)) == *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(start)*8)) && *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Ftags + uintptr(end)*8)) < *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(end)*8)) { + if **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Ftags + uintptr(start)*8)) == **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(start)*8)) && **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Ftags + uintptr(end)*8)) < **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(end)*8)) { skip = int32(1) break } @@ -132571,7 +132571,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags } /* Does this transition match the input symbol? */ if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fcode_min <= prev_c && (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fcode_max >= prev_c { - if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != uint32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != uint32('\000') || reg_noteol != 0) && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != uint32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0 || !(*(*Ttre_char_t)(unsafe.Pointer(bp)) == uint32('_') || Xiswalnum(tls, *(*Ttre_char_t)(unsafe.Pointer(bp))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0) || (*(*Ttre_char_t)(unsafe.Pointer(bp)) == uint32('_') || Xiswalnum(tls, *(*Ttre_char_t)(unsafe.Pointer(bp))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && *(*Ttre_char_t)(unsafe.Pointer(bp)) != uint32('\000') && BoolInt32(prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0) == BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == uint32('_') || Xiswalnum(tls, *(*Ttre_char_t)(unsafe.Pointer(bp))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || *(*Ttre_char_t)(unsafe.Pointer(bp)) == uint32('\000') || BoolInt32(prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0) != BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == uint32('_') || Xiswalnum(tls, *(*Ttre_char_t)(unsafe.Pointer(bp))) != 0)) || ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && !((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&Int32FromInt32(REG_ICASE) != 0) && !(Xiswctype(tls, prev_c, *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE) != 0 && !(Xiswctype(tls, Xtowlower(tls, prev_c), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) && !(Xiswctype(tls, Xtowupper(tls, prev_c), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS_NEG) != 0 && _tre_neg_char_classes_match(tls, (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fneg_classes, prev_c, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE)) != 0)) { + if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != uint32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (**(**Ttre_char_t)(__ccgo_up(bp)) != uint32('\000') || reg_noteol != 0) && (**(**Ttre_char_t)(__ccgo_up(bp)) != uint32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0 || !(**(**Ttre_char_t)(__ccgo_up(bp)) == uint32('_') || Xiswalnum(tls, **(**Ttre_char_t)(__ccgo_up(bp))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0) || (**(**Ttre_char_t)(__ccgo_up(bp)) == uint32('_') || Xiswalnum(tls, **(**Ttre_char_t)(__ccgo_up(bp))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && **(**Ttre_char_t)(__ccgo_up(bp)) != uint32('\000') && BoolInt32(prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0) == BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == uint32('_') || Xiswalnum(tls, **(**Ttre_char_t)(__ccgo_up(bp))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || **(**Ttre_char_t)(__ccgo_up(bp)) == uint32('\000') || BoolInt32(prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0) != BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == uint32('_') || Xiswalnum(tls, **(**Ttre_char_t)(__ccgo_up(bp))) != 0)) || ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && !((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&Int32FromInt32(REG_ICASE) != 0) && !(Xiswctype(tls, prev_c, *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE) != 0 && !(Xiswctype(tls, Xtowlower(tls, prev_c), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) && !(Xiswctype(tls, Xtowupper(tls, prev_c), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS_NEG) != 0 && _tre_neg_char_classes_match(tls, (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fneg_classes, prev_c, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE)) != 0)) { goto _14 } /* Compute the tags after this transition. */ @@ -132580,7 +132580,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < num_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(tmp_tags + uintptr(i)*8)) = *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Ftags + uintptr(i)*8)) + **(**Tregoff_t)(__ccgo_up(tmp_tags + uintptr(i)*8)) = **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Ftags + uintptr(i)*8)) goto _15 _15: ; @@ -132588,22 +132588,22 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags } tag_i = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags if tag_i != UintptrFromInt32(0) { - for *(*int32)(unsafe.Pointer(tag_i)) >= 0 { - if *(*int32)(unsafe.Pointer(tag_i)) < num_tags { - *(*Tregoff_t)(unsafe.Pointer(tmp_tags + uintptr(*(*int32)(unsafe.Pointer(tag_i)))*8)) = pos + for **(**int32)(__ccgo_up(tag_i)) >= 0 { + if **(**int32)(__ccgo_up(tag_i)) < num_tags { + **(**Tregoff_t)(__ccgo_up(tmp_tags + uintptr(**(**int32)(__ccgo_up(tag_i)))*8)) = pos } tag_i += 4 } } - if (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos < pos { + if (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos < pos { /* Found an unvisited node. */ (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Fstate = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate tmp_iptr = (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags = tmp_tags tmp_tags = tmp_iptr - (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos = pos - (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags = reach_next_i + 8 - if (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Fstate == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ffinal && (match_eo == int64(-int32(1)) || num_tags > 0 && *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags)) <= *(*Tregoff_t)(unsafe.Pointer(match_tags))) { + (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos = pos + (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags = reach_next_i + 8 + if (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Fstate == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ffinal && (match_eo == int64(-int32(1)) || num_tags > 0 && **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags)) <= **(**Tregoff_t)(__ccgo_up(match_tags))) { match_eo = pos new_match = int32(1) i = 0 @@ -132611,7 +132611,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < num_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(i)*8)) = *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(i)*8)) + **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(i)*8)) = **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(i)*8)) goto _16 _16: ; @@ -132623,10 +132623,10 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags /* Another path has also reached this state. We choose the winner by examining the tag values for both paths. */ - if _tre_tag_order(tls, num_tags, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions, tmp_tags, *(*uintptr)(unsafe.Pointer((*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags))) != 0 { + if _tre_tag_order(tls, num_tags, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions, tmp_tags, **(**uintptr)(__ccgo_up((**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags))) != 0 { /* The new path wins. */ - tmp_iptr = *(*uintptr)(unsafe.Pointer((*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags)) - *(*uintptr)(unsafe.Pointer((*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags)) = tmp_tags + tmp_iptr = **(**uintptr)(__ccgo_up((**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags)) + **(**uintptr)(__ccgo_up((**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags)) = tmp_tags if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ffinal { match_eo = pos new_match = int32(1) @@ -132635,7 +132635,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < num_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(i)*8)) = *(*Tregoff_t)(unsafe.Pointer(tmp_tags + uintptr(i)*8)) + **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(i)*8)) = **(**Tregoff_t)(__ccgo_up(tmp_tags + uintptr(i)*8)) goto _17 _17: ; @@ -132658,7 +132658,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags } (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Fstate = UintptrFromInt32(0) } - *(*Tregoff_t)(unsafe.Pointer(match_end_ofs)) = match_eo + **(**Tregoff_t)(__ccgo_up(match_end_ofs)) = match_eo if match_eo >= 0 { v18 = REG_OK } else { @@ -132729,7 +132729,7 @@ func _tre_tnfa_run_backtrack(tls *TLS, tnfa uintptr, string1 uintptr, match_tags _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bt, bt_len, empty_br_match, eo, i, i1, i2, i3, i4, match_eo, mem, next_c_start, next_state, next_tags, pmatch, pos, pos_add_next, pos_start, prev_c, reg_newline, reg_notbol, reg_noteol, result, ret, s, s1, so, stack, state, states_seen, str_byte, str_byte_start, tags, tmp, tmp1, trans_i, v20, v3, v6 /* State variables required by GET_NEXT_WCHAR. */ prev_c = uint32(0) - *(*Ttre_char_t)(unsafe.Pointer(bp)) = uint32(0) + **(**Ttre_char_t)(__ccgo_up(bp)) = uint32(0) str_byte = string1 pos = 0 pos_add_next = int64(1) @@ -132783,9 +132783,9 @@ retry: if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(i)*8)) = int64(-int32(1)) + **(**Tregoff_t)(__ccgo_up(tags + uintptr(i)*8)) = int64(-int32(1)) if match_tags != 0 { - *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(i)*8)) = int64(-int32(1)) + **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(i)*8)) = int64(-int32(1)) } goto _1 _1: @@ -132797,7 +132797,7 @@ retry: if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_states) { break } - *(*int32)(unsafe.Pointer(states_seen + uintptr(i)*4)) = 0 + **(**int32)(__ccgo_up(states_seen + uintptr(i)*4)) = 0 goto _2 _2: ; @@ -132805,7 +132805,7 @@ retry: } state = UintptrFromInt32(0) pos = pos_start - prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + prev_c = **(**Ttre_char_t)(__ccgo_up(bp)) pos = pos + pos_add_next v3 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) pos_add_next = v3 @@ -132819,7 +132819,7 @@ retry: } str_byte = str_byte + uintptr(pos_add_next) pos_start = pos - next_c_start = Int32FromUint32(*(*Ttre_char_t)(unsafe.Pointer(bp))) + next_c_start = Int32FromUint32(**(**Ttre_char_t)(__ccgo_up(bp))) str_byte_start = str_byte /* Handle initial states. */ next_tags = UintptrFromInt32(0) @@ -132828,7 +132828,7 @@ retry: if !((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate != 0) { break } - if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != uint32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != uint32('\000') || reg_noteol != 0) && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != uint32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0 || !(*(*Ttre_char_t)(unsafe.Pointer(bp)) == uint32('_') || Xiswalnum(tls, *(*Ttre_char_t)(unsafe.Pointer(bp))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0) || (*(*Ttre_char_t)(unsafe.Pointer(bp)) == uint32('_') || Xiswalnum(tls, *(*Ttre_char_t)(unsafe.Pointer(bp))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && *(*Ttre_char_t)(unsafe.Pointer(bp)) != uint32('\000') && BoolInt32(prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0) == BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == uint32('_') || Xiswalnum(tls, *(*Ttre_char_t)(unsafe.Pointer(bp))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || *(*Ttre_char_t)(unsafe.Pointer(bp)) == uint32('\000') || BoolInt32(prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0) != BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == uint32('_') || Xiswalnum(tls, *(*Ttre_char_t)(unsafe.Pointer(bp))) != 0))) { + if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != uint32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (**(**Ttre_char_t)(__ccgo_up(bp)) != uint32('\000') || reg_noteol != 0) && (**(**Ttre_char_t)(__ccgo_up(bp)) != uint32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0 || !(**(**Ttre_char_t)(__ccgo_up(bp)) == uint32('_') || Xiswalnum(tls, **(**Ttre_char_t)(__ccgo_up(bp))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0) || (**(**Ttre_char_t)(__ccgo_up(bp)) == uint32('_') || Xiswalnum(tls, **(**Ttre_char_t)(__ccgo_up(bp))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && **(**Ttre_char_t)(__ccgo_up(bp)) != uint32('\000') && BoolInt32(prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0) == BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == uint32('_') || Xiswalnum(tls, **(**Ttre_char_t)(__ccgo_up(bp))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || **(**Ttre_char_t)(__ccgo_up(bp)) == uint32('\000') || BoolInt32(prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0) != BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == uint32('_') || Xiswalnum(tls, **(**Ttre_char_t)(__ccgo_up(bp))) != 0))) { goto _4 } if state == UintptrFromInt32(0) { @@ -132877,13 +132877,13 @@ retry: (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstr_byte = str_byte (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate_id = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id - (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fnext_c = Int32FromUint32(*(*Ttre_char_t)(unsafe.Pointer(bp))) + (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fnext_c = Int32FromUint32(**(**Ttre_char_t)(__ccgo_up(bp))) i1 = 0 for { if !(i1 < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_tags) { break } - *(*Tregoff_t)(unsafe.Pointer((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(i1)*8)) = *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(i1)*8)) + **(**Tregoff_t)(__ccgo_up((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(i1)*8)) = **(**Tregoff_t)(__ccgo_up(tags + uintptr(i1)*8)) goto _5 _5: ; @@ -132891,10 +132891,10 @@ retry: } tmp = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags if tmp != 0 { - for *(*int32)(unsafe.Pointer(tmp)) >= 0 { + for **(**int32)(__ccgo_up(tmp)) >= 0 { v6 = tmp tmp += 4 - *(*Tregoff_t)(unsafe.Pointer((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(*(*int32)(unsafe.Pointer(v6)))*8)) = pos + **(**Tregoff_t)(__ccgo_up((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(**(**int32)(__ccgo_up(v6)))*8)) = pos } } } @@ -132905,10 +132905,10 @@ retry: } if next_tags != 0 { for { - if !(*(*int32)(unsafe.Pointer(next_tags)) >= 0) { + if !(**(**int32)(__ccgo_up(next_tags)) >= 0) { break } - *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(*(*int32)(unsafe.Pointer(next_tags)))*8)) = pos + **(**Tregoff_t)(__ccgo_up(tags + uintptr(**(**int32)(__ccgo_up(next_tags)))*8)) = pos goto _7 _7: ; @@ -132933,7 +132933,7 @@ _9: if !(i2 < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(i2)*8)) = *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(i2)*8)) + **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(i2)*8)) = **(**Tregoff_t)(__ccgo_up(tags + uintptr(i2)*8)) goto _10 _10: ; @@ -132953,8 +132953,8 @@ _9: /* Get the substring we need to match against. Remember to turn off REG_NOSUB temporarily. */ _tre_fill_pmatch(tls, Uint64FromInt32(bt+int32(1)), pmatch, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags & ^Int32FromInt32(REG_NOSUB), tnfa, tags, pos) - so = (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(bt)*16))).Frm_so - eo = (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(bt)*16))).Frm_eo + so = (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(bt)*16))).Frm_so + eo = (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(bt)*16))).Frm_eo bt_len = eo - so result = Xstrncmp(tls, string1+uintptr(so), str_byte-uintptr(1), Uint64FromInt64(bt_len)) if result == 0 { @@ -132962,15 +132962,15 @@ _9: if bt_len == 0 { empty_br_match = int32(1) } - if empty_br_match != 0 && *(*int32)(unsafe.Pointer(states_seen + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*4)) != 0 { + if empty_br_match != 0 && **(**int32)(__ccgo_up(states_seen + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*4)) != 0 { goto backtrack } - *(*int32)(unsafe.Pointer(states_seen + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*4)) = empty_br_match + **(**int32)(__ccgo_up(states_seen + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*4)) = empty_br_match /* Advance in input string and resync `prev_c', `next_c' and pos. */ str_byte = str_byte + uintptr(bt_len-int64(1)) pos = pos + (bt_len - int64(1)) - prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + prev_c = **(**Ttre_char_t)(__ccgo_up(bp)) pos = pos + pos_add_next v3 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) pos_add_next = v3 @@ -132988,11 +132988,11 @@ _9: } } else { /* Check for end of string. */ - if *(*Ttre_char_t)(unsafe.Pointer(bp)) == uint32('\000') { + if **(**Ttre_char_t)(__ccgo_up(bp)) == uint32('\000') { goto backtrack } /* Read the next character. */ - prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + prev_c = **(**Ttre_char_t)(__ccgo_up(bp)) pos = pos + pos_add_next v3 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) pos_add_next = v3 @@ -133013,7 +133013,7 @@ _9: break } if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fcode_min <= prev_c && (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fcode_max >= prev_c { - if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != uint32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != uint32('\000') || reg_noteol != 0) && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != uint32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0 || !(*(*Ttre_char_t)(unsafe.Pointer(bp)) == uint32('_') || Xiswalnum(tls, *(*Ttre_char_t)(unsafe.Pointer(bp))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0) || (*(*Ttre_char_t)(unsafe.Pointer(bp)) == uint32('_') || Xiswalnum(tls, *(*Ttre_char_t)(unsafe.Pointer(bp))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && *(*Ttre_char_t)(unsafe.Pointer(bp)) != uint32('\000') && BoolInt32(prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0) == BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == uint32('_') || Xiswalnum(tls, *(*Ttre_char_t)(unsafe.Pointer(bp))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || *(*Ttre_char_t)(unsafe.Pointer(bp)) == uint32('\000') || BoolInt32(prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0) != BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == uint32('_') || Xiswalnum(tls, *(*Ttre_char_t)(unsafe.Pointer(bp))) != 0)) || ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && !((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&Int32FromInt32(REG_ICASE) != 0) && !(Xiswctype(tls, prev_c, *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE) != 0 && !(Xiswctype(tls, Xtowlower(tls, prev_c), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) && !(Xiswctype(tls, Xtowupper(tls, prev_c), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS_NEG) != 0 && _tre_neg_char_classes_match(tls, (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fneg_classes, prev_c, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE)) != 0)) { + if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != uint32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (**(**Ttre_char_t)(__ccgo_up(bp)) != uint32('\000') || reg_noteol != 0) && (**(**Ttre_char_t)(__ccgo_up(bp)) != uint32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0 || !(**(**Ttre_char_t)(__ccgo_up(bp)) == uint32('_') || Xiswalnum(tls, **(**Ttre_char_t)(__ccgo_up(bp))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0) || (**(**Ttre_char_t)(__ccgo_up(bp)) == uint32('_') || Xiswalnum(tls, **(**Ttre_char_t)(__ccgo_up(bp))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && **(**Ttre_char_t)(__ccgo_up(bp)) != uint32('\000') && BoolInt32(prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0) == BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == uint32('_') || Xiswalnum(tls, **(**Ttre_char_t)(__ccgo_up(bp))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || **(**Ttre_char_t)(__ccgo_up(bp)) == uint32('\000') || BoolInt32(prev_c == uint32('_') || Xiswalnum(tls, prev_c) != 0) != BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == uint32('_') || Xiswalnum(tls, **(**Ttre_char_t)(__ccgo_up(bp))) != 0)) || ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && !((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&Int32FromInt32(REG_ICASE) != 0) && !(Xiswctype(tls, prev_c, *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE) != 0 && !(Xiswctype(tls, Xtowlower(tls, prev_c), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) && !(Xiswctype(tls, Xtowupper(tls, prev_c), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS_NEG) != 0 && _tre_neg_char_classes_match(tls, (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fneg_classes, prev_c, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE)) != 0)) { goto _13 } if next_state == UintptrFromInt32(0) { @@ -133065,13 +133065,13 @@ _9: (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstr_byte = str_byte (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate_id = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id - (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fnext_c = Int32FromUint32(*(*Ttre_char_t)(unsafe.Pointer(bp))) + (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fnext_c = Int32FromUint32(**(**Ttre_char_t)(__ccgo_up(bp))) i3 = 0 for { if !(i3 < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_tags) { break } - *(*Tregoff_t)(unsafe.Pointer((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(i3)*8)) = *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(i3)*8)) + **(**Tregoff_t)(__ccgo_up((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(i3)*8)) = **(**Tregoff_t)(__ccgo_up(tags + uintptr(i3)*8)) goto _14 _14: ; @@ -133079,10 +133079,10 @@ _9: } tmp1 = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags for { - if !(tmp1 != 0 && *(*int32)(unsafe.Pointer(tmp1)) >= 0) { + if !(tmp1 != 0 && **(**int32)(__ccgo_up(tmp1)) >= 0) { break } - *(*Tregoff_t)(unsafe.Pointer((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(*(*int32)(unsafe.Pointer(tmp1)))*8)) = pos + **(**Tregoff_t)(__ccgo_up((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(**(**int32)(__ccgo_up(tmp1)))*8)) = pos goto _15 _15: ; @@ -133102,10 +133102,10 @@ _9: state = next_state /* Update the tag values. */ if next_tags != 0 { - for *(*int32)(unsafe.Pointer(next_tags)) >= 0 { + for **(**int32)(__ccgo_up(next_tags)) >= 0 { v6 = next_tags next_tags += 4 - *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(*(*int32)(unsafe.Pointer(v6)))*8)) = pos + **(**Tregoff_t)(__ccgo_up(tags + uintptr(**(**int32)(__ccgo_up(v6)))*8)) = pos } } goto _17 @@ -133117,18 +133117,18 @@ backtrack: /* A matching transition was not found. Try to backtrack. */ if (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fprev != 0 { if (*Ttre_tnfa_transition_t)(unsafe.Pointer((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate)).Fassertions&int32(ASSERT_BACKREF) != 0 { - *(*int32)(unsafe.Pointer(states_seen + uintptr((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate_id)*4)) = 0 + **(**int32)(__ccgo_up(states_seen + uintptr((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate_id)*4)) = 0 } pos = (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fpos str_byte = (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstr_byte state = (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate - *(*Ttre_char_t)(unsafe.Pointer(bp)) = Uint32FromInt32((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fnext_c) + **(**Ttre_char_t)(__ccgo_up(bp)) = Uint32FromInt32((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fnext_c) i4 = 0 for { if !(i4 < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(i4)*8)) = *(*Tregoff_t)(unsafe.Pointer((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(i4)*8)) + **(**Tregoff_t)(__ccgo_up(tags + uintptr(i4)*8)) = **(**Tregoff_t)(__ccgo_up((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(i4)*8)) goto _19 _19: ; @@ -133139,10 +133139,10 @@ backtrack: if match_eo < 0 { /* Try starting from a later position in the input string. */ /* Check for end of string. */ - if *(*Ttre_char_t)(unsafe.Pointer(bp)) == uint32('\000') { + if **(**Ttre_char_t)(__ccgo_up(bp)) == uint32('\000') { goto _8 } - *(*Ttre_char_t)(unsafe.Pointer(bp)) = Uint32FromInt32(next_c_start) + **(**Ttre_char_t)(__ccgo_up(bp)) = Uint32FromInt32(next_c_start) str_byte = str_byte_start goto retry } else { @@ -133160,7 +133160,7 @@ _8: v20 = int32(REG_NOMATCH) } ret = v20 - *(*Tregoff_t)(unsafe.Pointer(match_end_ofs)) = match_eo + **(**Tregoff_t)(__ccgo_up(match_end_ofs)) = match_eo goto error_exit error_exit: ; @@ -133195,22 +133195,22 @@ func _tre_fill_pmatch(tls *TLS, nmatch Tsize_t, pmatch uintptr, cflags int32, tn /* Construct submatch offsets from the tags. */ submatch_data = (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data for i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches && uint64(i) < nmatch { - if (*(*Ttre_submatch_data_t)(unsafe.Pointer(submatch_data + uintptr(i)*16))).Fso_tag == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fend_tag { - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = match_eo + if (**(**Ttre_submatch_data_t)(__ccgo_up(submatch_data + uintptr(i)*16))).Fso_tag == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fend_tag { + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_so = match_eo } else { - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = *(*Tregoff_t)(unsafe.Pointer(tags + uintptr((*(*Ttre_submatch_data_t)(unsafe.Pointer(submatch_data + uintptr(i)*16))).Fso_tag)*8)) + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_so = **(**Tregoff_t)(__ccgo_up(tags + uintptr((**(**Ttre_submatch_data_t)(__ccgo_up(submatch_data + uintptr(i)*16))).Fso_tag)*8)) } - if (*(*Ttre_submatch_data_t)(unsafe.Pointer(submatch_data + uintptr(i)*16))).Feo_tag == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fend_tag { - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = match_eo + if (**(**Ttre_submatch_data_t)(__ccgo_up(submatch_data + uintptr(i)*16))).Feo_tag == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fend_tag { + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_eo = match_eo } else { - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = *(*Tregoff_t)(unsafe.Pointer(tags + uintptr((*(*Ttre_submatch_data_t)(unsafe.Pointer(submatch_data + uintptr(i)*16))).Feo_tag)*8)) + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_eo = **(**Tregoff_t)(__ccgo_up(tags + uintptr((**(**Ttre_submatch_data_t)(__ccgo_up(submatch_data + uintptr(i)*16))).Feo_tag)*8)) } /* If either of the endpoints were not used, this submatch was not part of the match. */ - if (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so == int64(-int32(1)) || (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo == int64(-int32(1)) { + if (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_so == int64(-int32(1)) || (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_eo == int64(-int32(1)) { v1 = int64(-Int32FromInt32(1)) - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = v1 - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = v1 + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_eo = v1 + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_so = v1 } i = i + 1 } @@ -133218,19 +133218,19 @@ func _tre_fill_pmatch(tls *TLS, nmatch Tsize_t, pmatch uintptr, cflags int32, tn submatches. */ i = uint32(0) for i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches && uint64(i) < nmatch { - if (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo == int64(-int32(1)) { + if (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_eo == int64(-int32(1)) { } - parents = (*(*Ttre_submatch_data_t)(unsafe.Pointer(submatch_data + uintptr(i)*16))).Fparents + parents = (**(**Ttre_submatch_data_t)(__ccgo_up(submatch_data + uintptr(i)*16))).Fparents if parents != UintptrFromInt32(0) { j = uint32(0) for { - if !(*(*int32)(unsafe.Pointer(parents + uintptr(j)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(parents + uintptr(j)*4)) >= 0) { break } - if (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so < (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(*(*int32)(unsafe.Pointer(parents + uintptr(j)*4)))*16))).Frm_so || (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo > (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(*(*int32)(unsafe.Pointer(parents + uintptr(j)*4)))*16))).Frm_eo { + if (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_so < (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(**(**int32)(__ccgo_up(parents + uintptr(j)*4)))*16))).Frm_so || (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_eo > (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(**(**int32)(__ccgo_up(parents + uintptr(j)*4)))*16))).Frm_eo { v1 = int64(-Int32FromInt32(1)) - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = v1 - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = v1 + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_eo = v1 + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_so = v1 } goto _2 _2: @@ -133242,8 +133242,8 @@ func _tre_fill_pmatch(tls *TLS, nmatch Tsize_t, pmatch uintptr, cflags int32, tn } } for uint64(i) < nmatch { - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = int64(-int32(1)) - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = int64(-int32(1)) + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_so = int64(-int32(1)) + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_eo = int64(-int32(1)) i = i + 1 } } @@ -133284,7 +133284,7 @@ func Xregexec(tls *TLS, preg uintptr, string1 uintptr, nmatch Tsize_t, pmatch ui } if status == REG_OK { /* A match was found, so fill the submatch registers. */ - _tre_fill_pmatch(tls, nmatch, pmatch, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags, tnfa, tags, *(*Tregoff_t)(unsafe.Pointer(bp))) + _tre_fill_pmatch(tls, nmatch, pmatch, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags, tnfa, tags, **(**Tregoff_t)(__ccgo_up(bp))) } if tags != 0 { Xfree(tls, tags) @@ -133402,8 +133402,8 @@ func X__tre_mem_alloc_impl(tls *TLS, mem Ttre_mem_t, provided int32, provided_bl size = size + v1 /* Allocate from current block. */ ptr = (*Ttre_mem_struct)(unsafe.Pointer(mem)).Fptr - *(*uintptr)(unsafe.Pointer(mem + 16)) += uintptr(size) - *(*Tsize_t)(unsafe.Pointer(mem + 24)) -= size + **(**uintptr)(__ccgo_up(mem + 16)) += uintptr(size) + **(**Tsize_t)(__ccgo_up(mem + 24)) -= size /* Set to zero if needed. */ if zero != 0 { Xmemset(tls, ptr, 0, size) @@ -133468,10 +133468,10 @@ func _keyhash(tls *TLS, k uintptr) (r Tsize_t) { _, _, _ = h, p, v1 p = k h = uint64(0) - for *(*uint8)(unsafe.Pointer(p)) != 0 { + for **(**uint8)(__ccgo_up(p)) != 0 { v1 = p p = p + 1 - h = uint64(31)*h + uint64(*(*uint8)(unsafe.Pointer(v1))) + h = uint64(31)*h + uint64(**(**uint8)(__ccgo_up(v1))) } return h } @@ -133524,7 +133524,7 @@ func _resize(tls *TLS, nel Tsize_t, htab uintptr) (r int32) { j = j + 1 i = i + v4 } - *(*TENTRY)(unsafe.Pointer(newe)) = *(*TENTRY)(unsafe.Pointer(e)) + **(**TENTRY)(__ccgo_up(newe)) = **(**TENTRY)(__ccgo_up(e)) } goto _2 _2: @@ -133580,7 +133580,7 @@ func Xhsearch(tls *TLS, item TENTRY, action TACTION) (r uintptr) { defer tls.Free(16) var _ /* e at bp+0 */ uintptr ___hsearch_r(tls, item, action, bp, uintptr(unsafe.Pointer(&_htab))) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func ___hcreate_r(tls *TLS, nel Tsize_t, htab uintptr) (r1 int32) { @@ -133613,14 +133613,14 @@ func ___hsearch_r(tls *TLS, item TENTRY, action TACTION, retval uintptr, htab ui hash = _keyhash(tls, item.Fkey) e = _lookup(tls, item.Fkey, hash, htab) if (*TENTRY)(unsafe.Pointer(e)).Fkey != 0 { - *(*uintptr)(unsafe.Pointer(retval)) = e + **(**uintptr)(__ccgo_up(retval)) = e return int32(1) } if action == int32(_FIND) { - *(*uintptr)(unsafe.Pointer(retval)) = uintptr(0) + **(**uintptr)(__ccgo_up(retval)) = uintptr(0) return 0 } - *(*TENTRY)(unsafe.Pointer(e)) = item + **(**TENTRY)(__ccgo_up(e)) = item v2 = (*Thsearch_data)(unsafe.Pointer(htab)).F__tab + 16 *(*Tsize_t)(unsafe.Pointer(v2)) = *(*Tsize_t)(unsafe.Pointer(v2)) + 1 v1 = *(*Tsize_t)(unsafe.Pointer(v2)) @@ -133628,12 +133628,12 @@ func ___hsearch_r(tls *TLS, item TENTRY, action TACTION, retval uintptr, htab ui if !(_resize(tls, uint64(2)*(*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused, htab) != 0) { (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused = (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused - 1 (*TENTRY)(unsafe.Pointer(e)).Fkey = uintptr(0) - *(*uintptr)(unsafe.Pointer(retval)) = uintptr(0) + **(**uintptr)(__ccgo_up(retval)) = uintptr(0) return 0 } e = _lookup(tls, item.Fkey, hash, htab) } - *(*uintptr)(unsafe.Pointer(retval)) = e + **(**uintptr)(__ccgo_up(retval)) = e return int32(1) } @@ -133693,7 +133693,7 @@ func Xlsearch(tls *TLS, key uintptr, base uintptr, nelp uintptr, width Tsize_t, defer func() {}() v1 = width p = base - n = *(*Tsize_t)(unsafe.Pointer(nelp)) + n = **(**Tsize_t)(__ccgo_up(nelp)) i = uint64(0) for { if !(i < n) { @@ -133707,7 +133707,7 @@ func Xlsearch(tls *TLS, key uintptr, base uintptr, nelp uintptr, width Tsize_t, ; i = i + 1 } - *(*Tsize_t)(unsafe.Pointer(nelp)) = n + uint64(1) + **(**Tsize_t)(__ccgo_up(nelp)) = n + uint64(1) return Xmemcpy(tls, p+uintptr(n)*uintptr(v1), key, width) } @@ -133725,7 +133725,7 @@ func Xlfind(tls *TLS, key uintptr, base uintptr, nelp uintptr, width Tsize_t, __ defer func() {}() v1 = width p = base - n = *(*Tsize_t)(unsafe.Pointer(nelp)) + n = **(**Tsize_t)(__ccgo_up(nelp)) i = uint64(0) for { if !(i < n) { @@ -133764,7 +133764,7 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui if !(rootp != 0) { return uintptr(0) } - n = *(*uintptr)(unsafe.Pointer(rootp)) + n = **(**uintptr)(__ccgo_up(rootp)) i = 0 /* *a[0] is an arbitrary non-null pointer that is returned when the root node is deleted. */ @@ -133785,34 +133785,34 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui v1 = i i = i + 1 a[v1] = n + 8 + BoolUintptr(c > 0)*8 - n = *(*uintptr)(unsafe.Pointer(n + 8 + BoolUintptr(c > 0)*8)) + n = **(**uintptr)(__ccgo_up(n + 8 + BoolUintptr(c > 0)*8)) goto _3 _3: } - parent = *(*uintptr)(unsafe.Pointer(a[i-int32(2)])) - if *(*uintptr)(unsafe.Pointer(n + 8)) != 0 { + parent = **(**uintptr)(__ccgo_up(a[i-int32(2)])) + if **(**uintptr)(__ccgo_up(n + 8)) != 0 { /* free the preceding node instead of the deleted one. */ deleted = n v1 = i i = i + 1 a[v1] = n + 8 - n = *(*uintptr)(unsafe.Pointer(n + 8)) - for *(*uintptr)(unsafe.Pointer(n + 8 + 1*8)) != 0 { + n = **(**uintptr)(__ccgo_up(n + 8)) + for **(**uintptr)(__ccgo_up(n + 8 + 1*8)) != 0 { v1 = i i = i + 1 a[v1] = n + 8 + 1*8 - n = *(*uintptr)(unsafe.Pointer(n + 8 + 1*8)) + n = **(**uintptr)(__ccgo_up(n + 8 + 1*8)) } (*Tnode1)(unsafe.Pointer(deleted)).Fkey = (*Tnode1)(unsafe.Pointer(n)).Fkey - child = *(*uintptr)(unsafe.Pointer(n + 8)) + child = **(**uintptr)(__ccgo_up(n + 8)) } else { - child = *(*uintptr)(unsafe.Pointer(n + 8 + 1*8)) + child = **(**uintptr)(__ccgo_up(n + 8 + 1*8)) } /* freed node has at most one child, move it up and rebalance. */ Xfree(tls, n) i = i - 1 v1 = i - *(*uintptr)(unsafe.Pointer(a[v1])) = child + **(**uintptr)(__ccgo_up(a[v1])) = child for { i = i - 1 v1 = i @@ -133835,8 +133835,8 @@ func Xtdestroy(tls *TLS, root uintptr, __ccgo_fp_freekey uintptr) { if r == uintptr(0) { return } - Xtdestroy(tls, *(*uintptr)(unsafe.Pointer(r + 8)), __ccgo_fp_freekey) - Xtdestroy(tls, *(*uintptr)(unsafe.Pointer(r + 8 + 1*8)), __ccgo_fp_freekey) + Xtdestroy(tls, **(**uintptr)(__ccgo_up(r + 8)), __ccgo_fp_freekey) + Xtdestroy(tls, **(**uintptr)(__ccgo_up(r + 8 + 1*8)), __ccgo_fp_freekey) if __ccgo_fp_freekey != 0 { (*(*func(*TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_freekey})))(tls, (*Tnode1)(unsafe.Pointer(r)).Fkey) } @@ -133856,7 +133856,7 @@ func Xtfind(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r uint if !(rootp != 0) { return uintptr(0) } - n = *(*uintptr)(unsafe.Pointer(rootp)) + n = **(**uintptr)(__ccgo_up(rootp)) for { if !(n != 0) { break @@ -133865,7 +133865,7 @@ func Xtfind(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r uint if !(c != 0) { break } - n = *(*uintptr)(unsafe.Pointer(n + 8 + BoolUintptr(c > 0)*8)) + n = **(**uintptr)(__ccgo_up(n + 8 + BoolUintptr(c > 0)*8)) goto _1 _1: } @@ -133887,11 +133887,11 @@ func _rot(tls *TLS, p uintptr, x uintptr, dir int32) (r int32) { var hx, hz int32 var y, z uintptr _, _, _, _ = hx, hz, y, z - y = *(*uintptr)(unsafe.Pointer(x + 8 + uintptr(dir)*8)) - z = *(*uintptr)(unsafe.Pointer(y + 8 + BoolUintptr(!(dir != 0))*8)) + y = **(**uintptr)(__ccgo_up(x + 8 + uintptr(dir)*8)) + z = **(**uintptr)(__ccgo_up(y + 8 + BoolUintptr(!(dir != 0))*8)) hx = (*Tnode1)(unsafe.Pointer(x)).Fh hz = _height(tls, z) - if hz > _height(tls, *(*uintptr)(unsafe.Pointer(y + 8 + uintptr(dir)*8))) { + if hz > _height(tls, **(**uintptr)(__ccgo_up(y + 8 + uintptr(dir)*8))) { /* * x * / \ dir z @@ -133899,10 +133899,10 @@ func _rot(tls *TLS, p uintptr, x uintptr, dir int32) (r int32) { * z D /| | * / \ A B C D * B C */ - *(*uintptr)(unsafe.Pointer(x + 8 + uintptr(dir)*8)) = *(*uintptr)(unsafe.Pointer(z + 8 + BoolUintptr(!(dir != 0))*8)) - *(*uintptr)(unsafe.Pointer(y + 8 + BoolUintptr(!(dir != 0))*8)) = *(*uintptr)(unsafe.Pointer(z + 8 + uintptr(dir)*8)) - *(*uintptr)(unsafe.Pointer(z + 8 + BoolUintptr(!(dir != 0))*8)) = x - *(*uintptr)(unsafe.Pointer(z + 8 + uintptr(dir)*8)) = y + **(**uintptr)(__ccgo_up(x + 8 + uintptr(dir)*8)) = **(**uintptr)(__ccgo_up(z + 8 + BoolUintptr(!(dir != 0))*8)) + **(**uintptr)(__ccgo_up(y + 8 + BoolUintptr(!(dir != 0))*8)) = **(**uintptr)(__ccgo_up(z + 8 + uintptr(dir)*8)) + **(**uintptr)(__ccgo_up(z + 8 + BoolUintptr(!(dir != 0))*8)) = x + **(**uintptr)(__ccgo_up(z + 8 + uintptr(dir)*8)) = y (*Tnode1)(unsafe.Pointer(x)).Fh = hz (*Tnode1)(unsafe.Pointer(y)).Fh = hz (*Tnode1)(unsafe.Pointer(z)).Fh = hz + int32(1) @@ -133912,13 +133912,13 @@ func _rot(tls *TLS, p uintptr, x uintptr, dir int32) (r int32) { * / \ / * A y --> x D * / \ / * z D A z */ - *(*uintptr)(unsafe.Pointer(x + 8 + uintptr(dir)*8)) = z - *(*uintptr)(unsafe.Pointer(y + 8 + BoolUintptr(!(dir != 0))*8)) = x + **(**uintptr)(__ccgo_up(x + 8 + uintptr(dir)*8)) = z + **(**uintptr)(__ccgo_up(y + 8 + BoolUintptr(!(dir != 0))*8)) = x (*Tnode1)(unsafe.Pointer(x)).Fh = hz + int32(1) (*Tnode1)(unsafe.Pointer(y)).Fh = hz + int32(2) z = y } - *(*uintptr)(unsafe.Pointer(p)) = z + **(**uintptr)(__ccgo_up(p)) = z return (*Tnode1)(unsafe.Pointer(z)).Fh - hx } @@ -133933,9 +133933,9 @@ func X__tsearch_balance(tls *TLS, p uintptr) (r int32) { var h0, h1, old, v1 int32 var n uintptr _, _, _, _, _ = h0, h1, n, old, v1 - n = *(*uintptr)(unsafe.Pointer(p)) - h0 = _height(tls, *(*uintptr)(unsafe.Pointer(n + 8))) - h1 = _height(tls, *(*uintptr)(unsafe.Pointer(n + 8 + 1*8))) + n = **(**uintptr)(__ccgo_up(p)) + h0 = _height(tls, **(**uintptr)(__ccgo_up(n + 8))) + h1 = _height(tls, **(**uintptr)(__ccgo_up(n + 8 + 1*8))) if Uint32FromInt32(h0-h1)+uint32(1) < uint32(3) { old = (*Tnode1)(unsafe.Pointer(n)).Fh if h0 < h1 { @@ -133964,7 +133964,7 @@ func Xtsearch(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r1 u if !(rootp != 0) { return uintptr(0) } - n = *(*uintptr)(unsafe.Pointer(rootp)) + n = **(**uintptr)(__ccgo_up(rootp)) i = 0 v1 = i i = i + 1 @@ -133980,7 +133980,7 @@ func Xtsearch(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r1 u v1 = i i = i + 1 a[v1] = n + 8 + BoolUintptr(c > 0)*8 - n = *(*uintptr)(unsafe.Pointer(n + 8 + BoolUintptr(c > 0)*8)) + n = **(**uintptr)(__ccgo_up(n + 8 + BoolUintptr(c > 0)*8)) goto _2 _2: } @@ -133990,13 +133990,13 @@ func Xtsearch(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r1 u } (*Tnode1)(unsafe.Pointer(r)).Fkey = key v4 = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(r + 8 + 1*8)) = v4 - *(*uintptr)(unsafe.Pointer(r + 8)) = v4 + **(**uintptr)(__ccgo_up(r + 8 + 1*8)) = v4 + **(**uintptr)(__ccgo_up(r + 8)) = v4 (*Tnode1)(unsafe.Pointer(r)).Fh = int32(1) /* insert new node, rebalance ancestors. */ i = i - 1 v1 = i - *(*uintptr)(unsafe.Pointer(a[v1])) = r + **(**uintptr)(__ccgo_up(a[v1])) = r for { if v7 = i != 0; v7 { i = i - 1 @@ -134017,9 +134017,9 @@ func _walk(tls *TLS, r uintptr, __ccgo_fp_action uintptr, d int32) { (*(*func(*TLS, uintptr, TVISIT, int32))(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_action})))(tls, r, int32(_leaf), d) } else { (*(*func(*TLS, uintptr, TVISIT, int32))(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_action})))(tls, r, int32(_preorder), d) - _walk(tls, *(*uintptr)(unsafe.Pointer(r + 8)), __ccgo_fp_action, d+int32(1)) + _walk(tls, **(**uintptr)(__ccgo_up(r + 8)), __ccgo_fp_action, d+int32(1)) (*(*func(*TLS, uintptr, TVISIT, int32))(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_action})))(tls, r, int32(_postorder), d) - _walk(tls, *(*uintptr)(unsafe.Pointer(r + 8 + 1*8)), __ccgo_fp_action, d+int32(1)) + _walk(tls, **(**uintptr)(__ccgo_up(r + 8 + 1*8)), __ccgo_fp_action, d+int32(1)) (*(*func(*TLS, uintptr, TVISIT, int32))(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_action})))(tls, r, int32(_endorder), d) } } @@ -134101,7 +134101,7 @@ func Xpselect(tls *TLS, n int32, rfds uintptr, wfds uintptr, efds uintptr, ts ui var v3 uintptr var _ /* data at bp+16 */ [2]Tsyscall_arg_t _, _, _, _, _ = ns, s, v1, v2, v3 - *(*[2]Tsyscall_arg_t)(unsafe.Pointer(bp + 16)) = [2]Tsyscall_arg_t{ + **(**[2]Tsyscall_arg_t)(__ccgo_up(bp + 16)) = [2]Tsyscall_arg_t{ 0: Int64FromUint64(uint64(mask)), 1: int64(Int32FromInt32(_NSIG) / Int32FromInt32(8)), } @@ -134223,10 +134223,10 @@ func Xgetitimer(tls *TLS, which int32, old uintptr) (r1 int32) { if uint64(8) > uint64(8) { r = int32(X__syscall2(tls, int64(SYS_getitimer), int64(which), int64(bp))) if !(r != 0) { - (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_sec = (*(*[4]int64)(unsafe.Pointer(bp)))[0] - (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_usec = (*(*[4]int64)(unsafe.Pointer(bp)))[int32(1)] - (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_sec = (*(*[4]int64)(unsafe.Pointer(bp)))[int32(2)] - (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_usec = (*(*[4]int64)(unsafe.Pointer(bp)))[int32(3)] + (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_sec = (**(**[4]int64)(__ccgo_up(bp)))[0] + (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_usec = (**(**[4]int64)(__ccgo_up(bp)))[int32(1)] + (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_sec = (**(**[4]int64)(__ccgo_up(bp)))[int32(2)] + (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_usec = (**(**[4]int64)(__ccgo_up(bp)))[int32(3)] } return int32(X__syscall_ret(tls, Uint64FromInt32(r))) } @@ -134247,7 +134247,7 @@ func Xkillpg(tls *TLS, pgid Tpid_t, sig int32) (r int32) { defer func() { trc("-> %v", r) }() } if pgid < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } return Xkill(tls, -pgid, sig) @@ -134283,7 +134283,7 @@ func Xpsignal(tls *TLS, sig int32, msg uintptr) { * not permitted to do so. */ old_locale = (*TFILE)(unsafe.Pointer(f)).Flocale old_mode = (*TFILE)(unsafe.Pointer(f)).Fmode - old_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + old_errno = **(**int32)(__ccgo_up(X__errno_location(tls))) if msg != 0 { v2 = msg } else { @@ -134295,7 +134295,7 @@ func Xpsignal(tls *TLS, sig int32, msg uintptr) { v3 = __ccgo_ts } if Xfprintf(tls, f, __ccgo_ts+1072, VaList(bp+8, v2, v3, s)) >= 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = old_errno + **(**int32)(__ccgo_up(X__errno_location(tls))) = old_errno } (*TFILE)(unsafe.Pointer(f)).Fmode = old_mode (*TFILE)(unsafe.Pointer(f)).Flocale = old_locale @@ -134362,10 +134362,10 @@ func Xsetitimer(tls *TLS, which int32, new1 uintptr, old uintptr) (r1 int32) { } r = int32(X__syscall3(tls, int64(SYS_setitimer), int64(which), int64(bp), int64(bp+32))) if !(r != 0) && old != 0 { - (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_sec = (*(*[4]int64)(unsafe.Pointer(bp + 32)))[0] - (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_usec = (*(*[4]int64)(unsafe.Pointer(bp + 32)))[int32(1)] - (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_sec = (*(*[4]int64)(unsafe.Pointer(bp + 32)))[int32(2)] - (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_usec = (*(*[4]int64)(unsafe.Pointer(bp + 32)))[int32(3)] + (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_sec = (**(**[4]int64)(__ccgo_up(bp + 32)))[0] + (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_usec = (**(**[4]int64)(__ccgo_up(bp + 32)))[int32(1)] + (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_sec = (**(**[4]int64)(__ccgo_up(bp + 32)))[int32(2)] + (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_usec = (**(**[4]int64)(__ccgo_up(bp + 32)))[int32(3)] } return int32(X__syscall_ret(tls, Uint64FromInt32(r))) } @@ -134445,7 +134445,7 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old1 uintptr) (r2 int32) Fv Tuint64_t }{} *(*uint64)(unsafe.Pointer(bp + 8)) = Uint64FromInt64(v2) - if *(*Tuint32_t)(unsafe.Pointer(bp + 8)) != 0 { + if **(**Tuint32_t)(__ccgo_up(bp + 8)) != 0 { v11 = v10 for { // __asm__ __volatile__ ("ldaxr %w0,%1" : "=r"(v) : "Q"(*p)); @@ -134471,7 +134471,7 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old1 uintptr) (r2 int32) goto _17 _17: } - if *(*Tuint32_t)(unsafe.Pointer(bp + 8 + 1*4)) != 0 { + if **(**Tuint32_t)(__ccgo_up(bp + 8 + 1*4)) != 0 { v18 = v10 + uintptr(1)*4 for { // __asm__ __volatile__ ("ldaxr %w0,%1" : "=r"(v) : "Q"(*p)); @@ -134521,15 +134521,15 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old1 uintptr) (r2 int32) X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 20, __ccgo_ts+1487) } } - (*(*Tk_sigaction)(unsafe.Pointer(bp + 16))).Fhandler = *(*uintptr)(unsafe.Pointer(sa)) - (*(*Tk_sigaction)(unsafe.Pointer(bp + 16))).Fflags = Uint64FromInt32((*Tsigaction)(unsafe.Pointer(sa)).Fsa_flags) - (*(*Tk_sigaction)(unsafe.Pointer(bp + 16))).Fflags |= uint64(SA_RESTORER) + (**(**Tk_sigaction)(__ccgo_up(bp + 16))).Fhandler = *(*uintptr)(unsafe.Pointer(sa)) + (**(**Tk_sigaction)(__ccgo_up(bp + 16))).Fflags = Uint64FromInt32((*Tsigaction)(unsafe.Pointer(sa)).Fsa_flags) + (**(**Tk_sigaction)(__ccgo_up(bp + 16))).Fflags |= uint64(SA_RESTORER) if (*Tsigaction)(unsafe.Pointer(sa)).Fsa_flags&int32(SA_SIGINFO) != 0 { v1 = __ccgo_fp(X__restore_rt) } else { v1 = __ccgo_fp(X__restore) } - (*(*Tk_sigaction)(unsafe.Pointer(bp + 16))).Frestorer = v1 + (**(**Tk_sigaction)(__ccgo_up(bp + 16))).Frestorer = v1 Xmemcpy(tls, bp+16+24, sa+8, Uint64FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))) } if sa != 0 { @@ -134544,8 +134544,8 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old1 uintptr) (r2 int32) } r1 = int32(X__syscall4(tls, int64(SYS_rt_sigaction), int64(sig), int64(v1), int64(v3), int64(Int32FromInt32(_NSIG)/Int32FromInt32(8)))) if old1 != 0 && !(r1 != 0) { - *(*uintptr)(unsafe.Pointer(old1)) = (*(*Tk_sigaction)(unsafe.Pointer(bp + 48))).Fhandler - (*Tsigaction)(unsafe.Pointer(old1)).Fsa_flags = Int32FromUint64((*(*Tk_sigaction)(unsafe.Pointer(bp + 48))).Fflags) + *(*uintptr)(unsafe.Pointer(old1)) = (**(**Tk_sigaction)(__ccgo_up(bp + 48))).Fhandler + (*Tsigaction)(unsafe.Pointer(old1)).Fsa_flags = Int32FromUint64((**(**Tk_sigaction)(__ccgo_up(bp + 48))).Fflags) Xmemcpy(tls, old1+8, bp+48+24, Uint64FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))) } return int32(X__syscall_ret(tls, Uint64FromInt32(r1))) @@ -134562,7 +134562,7 @@ func X__sigaction(tls *TLS, sig int32, sa uintptr, old uintptr) (r1 int32) { var _ /* set at bp+0 */ [1]uint64 _ = r if Uint32FromInt32(sig)-uint32(32) < uint32(3) || Uint32FromInt32(sig)-uint32(1) >= Uint32FromInt32(Int32FromInt32(_NSIG)-Int32FromInt32(1)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } /* Doing anything with the disposition of SIGABRT requires a lock, @@ -134597,10 +134597,10 @@ func Xsigaddset(tls *TLS, set uintptr, sig int32) (r int32) { _ = s s = Uint32FromInt32(sig - int32(1)) if s >= Uint32FromInt32(Int32FromInt32(_NSIG)-Int32FromInt32(1)) || Uint32FromInt32(sig)-uint32(32) < uint32(3) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } - *(*uint64)(unsafe.Pointer(set + uintptr(uint64(s/uint32(8))/uint64(8))*8)) |= uint64(1) << (uint64(s) & (Uint64FromInt32(8)*Uint64FromInt64(8) - Uint64FromInt32(1))) + **(**uint64)(__ccgo_up(set + uintptr(uint64(s/uint32(8))/uint64(8))*8)) |= uint64(1) << (uint64(s) & (Uint64FromInt32(8)*Uint64FromInt64(8) - Uint64FromInt32(1))) return 0 } @@ -134611,11 +134611,11 @@ func Xsigaltstack(tls *TLS, ss uintptr, old uintptr) (r int32) { } if ss != 0 { if !((*Tstack_t)(unsafe.Pointer(ss)).Fss_flags&Int32FromInt32(SS_DISABLE) != 0) && (*Tstack_t)(unsafe.Pointer(ss)).Fss_size < uint64(MINSIGSTKSZ) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return -int32(1) } if (*Tstack_t)(unsafe.Pointer(ss)).Fss_flags&int32(SS_ONSTACK) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } } @@ -134640,7 +134640,7 @@ func Xsigandset(tls *TLS, dest uintptr, left uintptr, right uintptr) (r1 int32) if !(i < Uint64FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))/Uint64FromInt64(8)) { break } - *(*uint64)(unsafe.Pointer(d + uintptr(i)*8)) = *(*uint64)(unsafe.Pointer(l + uintptr(i)*8)) & *(*uint64)(unsafe.Pointer(r + uintptr(i)*8)) + **(**uint64)(__ccgo_up(d + uintptr(i)*8)) = **(**uint64)(__ccgo_up(l + uintptr(i)*8)) & **(**uint64)(__ccgo_up(r + uintptr(i)*8)) goto _1 _1: ; @@ -134658,10 +134658,10 @@ func Xsigdelset(tls *TLS, set uintptr, sig int32) (r int32) { _ = s s = Uint32FromInt32(sig - int32(1)) if s >= Uint32FromInt32(Int32FromInt32(_NSIG)-Int32FromInt32(1)) || Uint32FromInt32(sig)-uint32(32) < uint32(3) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } - *(*uint64)(unsafe.Pointer(set + uintptr(uint64(s/uint32(8))/uint64(8))*8)) &= ^(Uint64FromUint64(1) << (uint64(s) & (Uint64FromInt32(8)*Uint64FromInt64(8) - Uint64FromInt32(1)))) + **(**uint64)(__ccgo_up(set + uintptr(uint64(s/uint32(8))/uint64(8))*8)) &= ^(Uint64FromUint64(1) << (uint64(s) & (Uint64FromInt32(8)*Uint64FromInt64(8) - Uint64FromInt32(1)))) return 0 } @@ -134670,13 +134670,13 @@ func Xsigemptyset(tls *TLS, set uintptr) (r int32) { trc("tls=%v set=%v, (%v:)", tls, set, origin(2)) defer func() { trc("-> %v", r) }() } - *(*uint64)(unsafe.Pointer(set)) = uint64(0) + **(**uint64)(__ccgo_up(set)) = uint64(0) if Bool(uint64(8) == uint64(4)) || Bool(int32(_NSIG) > int32(65)) { - *(*uint64)(unsafe.Pointer(set + 1*8)) = uint64(0) + **(**uint64)(__ccgo_up(set + 1*8)) = uint64(0) } if Bool(uint64(8) == uint64(4)) && Bool(int32(_NSIG) > int32(65)) { - *(*uint64)(unsafe.Pointer(set + 2*8)) = uint64(0) - *(*uint64)(unsafe.Pointer(set + 3*8)) = uint64(0) + **(**uint64)(__ccgo_up(set + 2*8)) = uint64(0) + **(**uint64)(__ccgo_up(set + 3*8)) = uint64(0) } return 0 } @@ -134695,9 +134695,9 @@ func Xsigfillset(tls *TLS, set uintptr) (r int32) { trc("tls=%v set=%v, (%v:)", tls, set, origin(2)) defer func() { trc("-> %v", r) }() } - *(*uint64)(unsafe.Pointer(set)) = uint64(0xfffffffc7fffffff) + **(**uint64)(__ccgo_up(set)) = uint64(0xfffffffc7fffffff) if int32(_NSIG) > int32(65) { - *(*uint64)(unsafe.Pointer(set + 1*8)) = uint64(0xffffffffffffffff) + **(**uint64)(__ccgo_up(set + 1*8)) = uint64(0xffffffffffffffff) } return 0 } @@ -134714,7 +134714,7 @@ func Xsigisemptyset(tls *TLS, set uintptr) (r int32) { if !(i < Uint64FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))/Uint64FromInt64(8)) { break } - if *(*uint64)(unsafe.Pointer(set + uintptr(i)*8)) != 0 { + if **(**uint64)(__ccgo_up(set + uintptr(i)*8)) != 0 { return 0 } goto _1 @@ -134736,7 +134736,7 @@ func Xsigismember(tls *TLS, set uintptr, sig int32) (r int32) { if s >= Uint32FromInt32(Int32FromInt32(_NSIG)-Int32FromInt32(1)) { return 0 } - return BoolInt32(!!(*(*uint64)(unsafe.Pointer(set + uintptr(uint64(s/uint32(8))/uint64(8))*8))&(Uint64FromUint64(1)<<(uint64(s)&(Uint64FromInt32(8)*Uint64FromInt64(8)-Uint64FromInt32(1)))) != 0)) + return BoolInt32(!!(**(**uint64)(__ccgo_up(set + uintptr(uint64(s/uint32(8))/uint64(8))*8))&(Uint64FromUint64(1)<<(uint64(s)&(Uint64FromInt32(8)*Uint64FromInt64(8)-Uint64FromInt32(1)))) != 0)) } func Xsigorset(tls *TLS, dest uintptr, left uintptr, right uintptr) (r1 int32) { @@ -134755,7 +134755,7 @@ func Xsigorset(tls *TLS, dest uintptr, left uintptr, right uintptr) (r1 int32) { if !(i < Uint64FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))/Uint64FromInt64(8)) { break } - *(*uint64)(unsafe.Pointer(d + uintptr(i)*8)) = *(*uint64)(unsafe.Pointer(l + uintptr(i)*8)) | *(*uint64)(unsafe.Pointer(r + uintptr(i)*8)) + **(**uint64)(__ccgo_up(d + uintptr(i)*8)) = **(**uint64)(__ccgo_up(l + uintptr(i)*8)) | **(**uint64)(__ccgo_up(r + uintptr(i)*8)) goto _1 _1: ; @@ -134783,7 +134783,7 @@ func Xsigprocmask(tls *TLS, how int32, set uintptr, old uintptr) (r1 int32) { if !(r != 0) { return r } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = r + **(**int32)(__ccgo_up(X__errno_location(tls))) = r return -int32(1) } @@ -134799,8 +134799,8 @@ func Xsigqueue(tls *TLS, pid Tpid_t, sig int32, value Tsigval) (r1 int32) { var _ /* si at bp+0 */ Tsiginfo_t _ = r Xmemset(tls, bp, 0, uint64(128)) - (*(*Tsiginfo_t)(unsafe.Pointer(bp))).Fsi_signo = sig - (*(*Tsiginfo_t)(unsafe.Pointer(bp))).Fsi_code = -int32(1) + (**(**Tsiginfo_t)(__ccgo_up(bp))).Fsi_signo = sig + (**(**Tsiginfo_t)(__ccgo_up(bp))).Fsi_code = -int32(1) *(*Tsigval)(unsafe.Pointer(bp + 16 + 8)) = value *(*Tuid_t)(unsafe.Pointer(bp + 16 + 4)) = Xgetuid(tls) X__block_app_sigs(tls, bp+128) @@ -134896,7 +134896,7 @@ func Xsigwait(tls *TLS, mask uintptr, sig uintptr) (r int32) { if Xsigtimedwait(tls, mask, bp, uintptr(0)) < 0 { return -int32(1) } - *(*int32)(unsafe.Pointer(sig)) = (*(*Tsiginfo_t)(unsafe.Pointer(bp))).Fsi_signo + **(**int32)(__ccgo_up(sig)) = (**(**Tsiginfo_t)(__ccgo_up(bp))).Fsi_signo return 0 } @@ -134945,7 +134945,7 @@ func X__xmknod(tls *TLS, ver int32, path uintptr, mode Tmode_t, dev uintptr) (r trc("tls=%v ver=%v path=%v mode=%v dev=%v, (%v:)", tls, ver, path, mode, dev, origin(2)) defer func() { trc("-> %v", r) }() } - return Xmknod(tls, path, mode, *(*Tdev_t)(unsafe.Pointer(dev))) + return Xmknod(tls, path, mode, **(**Tdev_t)(__ccgo_up(dev))) } func X__xmknodat(tls *TLS, ver int32, fd int32, path uintptr, mode Tmode_t, dev uintptr) (r int32) { @@ -134953,7 +134953,7 @@ func X__xmknodat(tls *TLS, ver int32, fd int32, path uintptr, mode Tmode_t, dev trc("tls=%v ver=%v fd=%v path=%v mode=%v dev=%v, (%v:)", tls, ver, fd, path, mode, dev, origin(2)) defer func() { trc("-> %v", r) }() } - return Xmknodat(tls, fd, path, mode, *(*Tdev_t)(unsafe.Pointer(dev))) + return Xmknodat(tls, fd, path, mode, **(**Tdev_t)(__ccgo_up(dev))) } func Xchmod(tls *TLS, path uintptr, mode Tmode_t) (r int32) { @@ -135006,7 +135006,7 @@ func Xfchmodat(tls *TLS, fd int32, path uintptr, mode Tmode_t, flag int32) (r in if Xfstatat(tls, fd, path, bp, flag) != 0 { return -int32(1) } - if (*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { + if (**(**Tstat)(__ccgo_up(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { return int32(X__syscall_ret(tls, Uint64FromInt32(-Int32FromInt32(EOPNOTSUPP)))) } v1 = int32(X__syscall3(tls, int64(SYS_openat), int64(fd), int64(path), int64(Int32FromInt32(O_RDONLY)|Int32FromInt32(O_PATH)|Int32FromInt32(O_NOFOLLOW)|Int32FromInt32(O_NOCTTY)|Int32FromInt32(O_CLOEXEC)))) @@ -135020,7 +135020,7 @@ func Xfchmodat(tls *TLS, fd int32, path uintptr, mode Tmode_t, flag int32) (r in X__procfdname(tls, bp+128, Uint32FromInt32(fd2)) ret = Xstat(tls, bp+128, bp) if !(ret != 0) { - if (*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { + if (**(**Tstat)(__ccgo_up(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { ret = int32(X__syscall_ret(tls, Uint64FromInt32(-Int32FromInt32(EOPNOTSUPP)))) } else { ret = int32(X__syscall_ret(tls, Uint64FromInt64(X__syscall3(tls, int64(SYS_fchmodat), int64(-Int32FromInt32(100)), int64(bp+128), Int64FromUint32(mode))))) @@ -135100,28 +135100,28 @@ func _fstatat_statx(tls *TLS, fd int32, path uintptr, st uintptr, flag int32) (r if ret != 0 { return ret } - *(*Tstat)(unsafe.Pointer(st)) = Tstat{ - Fst_dev: uint64(uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_dev_major)&Uint64FromUint64(0xfffff000)<= 0 && !(*(*uint8)(unsafe.Pointer(path)) != 0) { + if flag == int32(AT_EMPTY_PATH) && fd >= 0 && !(**(**uint8)(__ccgo_up(path)) != 0) { ret = int32(X__syscall2(tls, int64(SYS_fstat), int64(fd), int64(bp))) if ret == -int32(EBADF) && X__syscall2(tls, int64(SYS_fcntl), int64(fd), int64(Int32FromInt32(F_GETFD))) >= 0 { ret = int32(X__syscall4(tls, int64(SYS_newfstatat), int64(fd), int64(path), int64(bp), int64(flag))) @@ -135171,28 +135171,28 @@ func _fstatat_kstat(tls *TLS, fd int32, path uintptr, st uintptr, flag int32) (r if ret != 0 { return ret } - *(*Tstat)(unsafe.Pointer(st)) = Tstat{ - Fst_dev: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_dev, - Fst_ino: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_ino, - Fst_mode: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_mode, - Fst_nlink: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_nlink, - Fst_uid: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_uid, - Fst_gid: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_gid, - Fst_rdev: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_rdev, - Fst_size: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_size, - Fst_blksize: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_blksize, - Fst_blocks: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_blocks, + **(**Tstat)(__ccgo_up(st)) = Tstat{ + Fst_dev: (**(**Tkstat)(__ccgo_up(bp))).Fst_dev, + Fst_ino: (**(**Tkstat)(__ccgo_up(bp))).Fst_ino, + Fst_mode: (**(**Tkstat)(__ccgo_up(bp))).Fst_mode, + Fst_nlink: (**(**Tkstat)(__ccgo_up(bp))).Fst_nlink, + Fst_uid: (**(**Tkstat)(__ccgo_up(bp))).Fst_uid, + Fst_gid: (**(**Tkstat)(__ccgo_up(bp))).Fst_gid, + Fst_rdev: (**(**Tkstat)(__ccgo_up(bp))).Fst_rdev, + Fst_size: (**(**Tkstat)(__ccgo_up(bp))).Fst_size, + Fst_blksize: (**(**Tkstat)(__ccgo_up(bp))).Fst_blksize, + Fst_blocks: (**(**Tkstat)(__ccgo_up(bp))).Fst_blocks, Fst_atim: Ttimespec{ - Ftv_sec: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_atime_sec, - Ftv_nsec: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_atime_nsec, + Ftv_sec: (**(**Tkstat)(__ccgo_up(bp))).Fst_atime_sec, + Ftv_nsec: (**(**Tkstat)(__ccgo_up(bp))).Fst_atime_nsec, }, Fst_mtim: Ttimespec{ - Ftv_sec: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_mtime_sec, - Ftv_nsec: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_mtime_nsec, + Ftv_sec: (**(**Tkstat)(__ccgo_up(bp))).Fst_mtime_sec, + Ftv_nsec: (**(**Tkstat)(__ccgo_up(bp))).Fst_mtime_nsec, }, Fst_ctim: Ttimespec{ - Ftv_sec: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_ctime_sec, - Ftv_nsec: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_ctime_nsec, + Ftv_sec: (**(**Tkstat)(__ccgo_up(bp))).Fst_ctime_sec, + Ftv_nsec: (**(**Tkstat)(__ccgo_up(bp))).Fst_ctime_nsec, }, } return 0 @@ -135248,11 +135248,11 @@ func X__futimesat(tls *TLS, dirfd int32, pathname uintptr, times uintptr) (r int if !(i < int32(2)) { break } - if Uint64FromInt64((*(*Ttimeval)(unsafe.Pointer(times + uintptr(i)*16))).Ftv_usec) >= uint64(1000000) { + if Uint64FromInt64((**(**Ttimeval)(__ccgo_up(times + uintptr(i)*16))).Ftv_usec) >= uint64(1000000) { return int32(X__syscall_ret(tls, Uint64FromInt32(-Int32FromInt32(EINVAL)))) } - (*(*[2]Ttimespec)(unsafe.Pointer(bp)))[i].Ftv_sec = (*(*Ttimeval)(unsafe.Pointer(times + uintptr(i)*16))).Ftv_sec - (*(*[2]Ttimespec)(unsafe.Pointer(bp)))[i].Ftv_nsec = (*(*Ttimeval)(unsafe.Pointer(times + uintptr(i)*16))).Ftv_usec * int64(1000) + (**(**[2]Ttimespec)(__ccgo_up(bp)))[i].Ftv_sec = (**(**Ttimeval)(__ccgo_up(times + uintptr(i)*16))).Ftv_sec + (**(**[2]Ttimespec)(__ccgo_up(bp)))[i].Ftv_nsec = (**(**Ttimeval)(__ccgo_up(times + uintptr(i)*16))).Ftv_usec * int64(1000) goto _1 _1: ; @@ -135348,7 +135348,7 @@ func Xstat(tls *TLS, path uintptr, buf uintptr) (r int32) { } func ___statfs(tls *TLS, path uintptr, buf uintptr) (r int32) { - *(*Tstatfs)(unsafe.Pointer(buf)) = Tstatfs{} + **(**Tstatfs)(__ccgo_up(buf)) = Tstatfs{} return int32(X__syscall_ret(tls, Uint64FromInt64(X__syscall2(tls, int64(SYS_statfs), int64(path), int64(buf))))) } @@ -135357,14 +135357,14 @@ func Xfstatfs(tls *TLS, fd int32, buf uintptr) (r int32) { trc("tls=%v fd=%v buf=%v, (%v:)", tls, fd, buf, origin(2)) defer func() { trc("-> %v", r) }() } - *(*Tstatfs)(unsafe.Pointer(buf)) = Tstatfs{} + **(**Tstatfs)(__ccgo_up(buf)) = Tstatfs{} return int32(X__syscall_ret(tls, Uint64FromInt64(X__syscall2(tls, int64(SYS_fstatfs), int64(fd), int64(buf))))) } func _fixup(tls *TLS, out uintptr, in uintptr) { var v1 uint64 _ = v1 - *(*Tstatvfs)(unsafe.Pointer(out)) = Tstatvfs{} + **(**Tstatvfs)(__ccgo_up(out)) = Tstatvfs{} (*Tstatvfs)(unsafe.Pointer(out)).Ff_bsize = (*Tstatfs)(unsafe.Pointer(in)).Ff_bsize if (*Tstatfs)(unsafe.Pointer(in)).Ff_frsize != 0 { v1 = (*Tstatfs)(unsafe.Pointer(in)).Ff_frsize @@ -135378,7 +135378,7 @@ func _fixup(tls *TLS, out uintptr, in uintptr) { (*Tstatvfs)(unsafe.Pointer(out)).Ff_files = (*Tstatfs)(unsafe.Pointer(in)).Ff_files (*Tstatvfs)(unsafe.Pointer(out)).Ff_ffree = (*Tstatfs)(unsafe.Pointer(in)).Ff_ffree (*Tstatvfs)(unsafe.Pointer(out)).Ff_favail = (*Tstatfs)(unsafe.Pointer(in)).Ff_ffree - (*Tstatvfs)(unsafe.Pointer(out)).Ff_fsid = Uint64FromInt32(*(*int32)(unsafe.Pointer(in + 56))) + (*Tstatvfs)(unsafe.Pointer(out)).Ff_fsid = Uint64FromInt32(**(**int32)(__ccgo_up(in + 56))) (*Tstatvfs)(unsafe.Pointer(out)).Ff_flag = (*Tstatfs)(unsafe.Pointer(in)).Ff_flags (*Tstatvfs)(unsafe.Pointer(out)).Ff_namemax = (*Tstatfs)(unsafe.Pointer(in)).Ff_namelen (*Tstatvfs)(unsafe.Pointer(out)).Ff_type = uint32((*Tstatfs)(unsafe.Pointer(in)).Ff_type) @@ -135429,7 +135429,7 @@ func Xutimensat(tls *TLS, fd int32, path uintptr, times uintptr, flags int32) (r } var r int32 _ = r - if times != 0 && (*(*Ttimespec)(unsafe.Pointer(times))).Ftv_nsec == int64(UTIME_NOW) && (*(*Ttimespec)(unsafe.Pointer(times + 1*16))).Ftv_nsec == int64(UTIME_NOW) { + if times != 0 && (**(**Ttimespec)(__ccgo_up(times))).Ftv_nsec == int64(UTIME_NOW) && (**(**Ttimespec)(__ccgo_up(times + 1*16))).Ftv_nsec == int64(UTIME_NOW) { times = uintptr(0) } r = int32(X__syscall4(tls, int64(SYS_utimensat), int64(fd), int64(path), int64(times), int64(flags))) @@ -135456,8 +135456,8 @@ func X__fdopen(tls *TLS, fd int32, mode uintptr) (r uintptr) { var _ /* wsz at bp+0 */ Twinsize _, _, _, _ = f, flags, v1, v2 /* Check for valid initial mode character */ - if !(Xstrchr(tls, __ccgo_ts+1504, Int32FromUint8(*(*uint8)(unsafe.Pointer(mode)))) != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if !(Xstrchr(tls, __ccgo_ts+1504, Int32FromUint8(**(**uint8)(__ccgo_up(mode)))) != 0) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } /* Allocate FILE+buffer or fail */ @@ -135470,7 +135470,7 @@ func X__fdopen(tls *TLS, fd int32, mode uintptr) (r uintptr) { Xmemset(tls, f, 0, uint64(232)) /* Impose mode restrictions */ if !(Xstrchr(tls, mode, int32('+')) != 0) { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('r') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) == int32('r') { v2 = int32(F_NOWR) } else { v2 = int32(F_NORD) @@ -135482,12 +135482,12 @@ func X__fdopen(tls *TLS, fd int32, mode uintptr) (r uintptr) { X__syscall3(tls, int64(SYS_fcntl), int64(fd), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) } /* Set append mode on fd if opened for append */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('a') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) == int32('a') { flags = int32(X__syscall2(tls, int64(SYS_fcntl), int64(fd), int64(Int32FromInt32(F_GETFL)))) if !(flags&Int32FromInt32(O_APPEND) != 0) { X__syscall3(tls, int64(SYS_fcntl), int64(fd), int64(Int32FromInt32(F_SETFL)), int64(flags|Int32FromInt32(O_APPEND))) } - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_APP) + **(**uint32)(__ccgo_up(f)) |= uint32(F_APP) } (*TFILE)(unsafe.Pointer(f)).Ffd = fd (*TFILE)(unsafe.Pointer(f)).Fbuf = f + uintptr(232) + uintptr(UNGET) @@ -135527,7 +135527,7 @@ func X__fmodeflags(tls *TLS, mode uintptr) (r int32) { if Xstrchr(tls, mode, int32('+')) != 0 { flags = int32(O_RDWR) } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('r') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) == int32('r') { flags = O_RDONLY } else { flags = int32(O_WRONLY) @@ -135539,13 +135539,13 @@ func X__fmodeflags(tls *TLS, mode uintptr) (r int32) { if Xstrchr(tls, mode, int32('e')) != 0 { flags = flags | int32(O_CLOEXEC) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) != int32('r') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) != int32('r') { flags = flags | int32(O_CREAT) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('w') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) == int32('w') { flags = flags | int32(O_TRUNC) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('a') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) == int32('a') { flags = flags | int32(O_APPEND) } return flags @@ -135583,22 +135583,22 @@ func X__overflow(tls *TLS, f uintptr, _c int32) (r int32) { var v2, v3 uintptr var _ /* c at bp+0 */ uint8 _, _, _ = v1, v2, v3 - *(*uint8)(unsafe.Pointer(bp)) = Uint8FromInt32(_c) + **(**uint8)(__ccgo_up(bp)) = Uint8FromInt32(_c) if !((*TFILE)(unsafe.Pointer(f)).Fwend != 0) && X__towrite(tls, f) != 0 { return -int32(1) } - if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwend && Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) != (*TFILE)(unsafe.Pointer(f)).Flbf { - v1 = *(*uint8)(unsafe.Pointer(bp)) + if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwend && Int32FromUint8(**(**uint8)(__ccgo_up(bp))) != (*TFILE)(unsafe.Pointer(f)).Flbf { + v1 = **(**uint8)(__ccgo_up(bp)) v3 = f + 40 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - *(*uint8)(unsafe.Pointer(v2)) = v1 + **(**uint8)(__ccgo_up(v2)) = v1 return Int32FromUint8(v1) } if (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fwrite})))(tls, f, bp, uint64(1)) != uint64(1) { return -int32(1) } - return Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) + return Int32FromUint8(**(**uint8)(__ccgo_up(bp))) } func _dummy9(tls *TLS, fd int32) (r int32) { @@ -135636,7 +135636,7 @@ func X__stdio_exit(tls *TLS) { } var f uintptr _ = f - f = *(*uintptr)(unsafe.Pointer(X__ofl_lock(tls))) + f = **(**uintptr)(__ccgo_up(X__ofl_lock(tls))) for { if !(f != 0) { break @@ -135672,7 +135672,7 @@ func X__stdio_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { var v3, v4 uintptr var _ /* iov at bp+0 */ [2]Tiovec _, _, _, _, _ = cnt, v1, v2, v3, v4 - *(*[2]Tiovec)(unsafe.Pointer(bp)) = [2]Tiovec{ + **(**[2]Tiovec)(__ccgo_up(bp)) = [2]Tiovec{ 0: { Fiov_base: buf, Fiov_len: len1 - BoolUint64(!!((*TFILE)(unsafe.Pointer(f)).Fbuf_size != 0)), @@ -135682,10 +135682,10 @@ func X__stdio_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { Fiov_len: (*TFILE)(unsafe.Pointer(f)).Fbuf_size, }, } - if (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len != 0 { + if (**(**[2]Tiovec)(__ccgo_up(bp)))[0].Fiov_len != 0 { v1 = X__syscall_ret(tls, Uint64FromInt64(X__syscall3(tls, int64(SYS_readv), int64((*TFILE)(unsafe.Pointer(f)).Ffd), int64(bp), int64(Int32FromInt32(2))))) } else { - v1 = X__syscall_ret(tls, Uint64FromInt64(X__syscall3(tls, int64(SYS_read), int64((*TFILE)(unsafe.Pointer(f)).Ffd), int64((*(*[2]Tiovec)(unsafe.Pointer(bp)))[int32(1)].Fiov_base), Int64FromUint64((*(*[2]Tiovec)(unsafe.Pointer(bp)))[int32(1)].Fiov_len)))) + v1 = X__syscall_ret(tls, Uint64FromInt64(X__syscall3(tls, int64(SYS_read), int64((*TFILE)(unsafe.Pointer(f)).Ffd), int64((**(**[2]Tiovec)(__ccgo_up(bp)))[int32(1)].Fiov_base), Int64FromUint64((**(**[2]Tiovec)(__ccgo_up(bp)))[int32(1)].Fiov_len)))) } cnt = v1 if cnt <= 0 { @@ -135694,20 +135694,20 @@ func X__stdio_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { } else { v2 = int32(F_EOF) } - *(*uint32)(unsafe.Pointer(f)) |= Uint32FromInt32(v2) + **(**uint32)(__ccgo_up(f)) |= Uint32FromInt32(v2) return uint64(0) } - if Uint64FromInt64(cnt) <= (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len { + if Uint64FromInt64(cnt) <= (**(**[2]Tiovec)(__ccgo_up(bp)))[0].Fiov_len { return Uint64FromInt64(cnt) } - cnt = Int64FromUint64(uint64(cnt) - (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len) + cnt = Int64FromUint64(uint64(cnt) - (**(**[2]Tiovec)(__ccgo_up(bp)))[0].Fiov_len) (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(cnt) if (*TFILE)(unsafe.Pointer(f)).Fbuf_size != 0 { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(buf + uintptr(len1-uint64(1)))) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(buf + uintptr(len1-uint64(1)))) = **(**uint8)(__ccgo_up(v3)) } return len1 } @@ -135734,7 +135734,7 @@ func X__stdio_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) var v5 uint64 var _ /* iovs at bp+0 */ [2]Tiovec _, _, _, _, _, _, _ = cnt, iov, iovcnt, rem, v2, v3, v5 - *(*[2]Tiovec)(unsafe.Pointer(bp)) = [2]Tiovec{ + **(**[2]Tiovec)(__ccgo_up(bp)) = [2]Tiovec{ 0: { Fiov_base: (*TFILE)(unsafe.Pointer(f)).Fwbase, Fiov_len: Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Fwpos) - int64((*TFILE)(unsafe.Pointer(f)).Fwbase)), @@ -135745,7 +135745,7 @@ func X__stdio_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) }, } iov = bp - rem = (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len + (*(*Tiovec)(unsafe.Pointer(iov + 1*16))).Fiov_len + rem = (**(**Tiovec)(__ccgo_up(iov))).Fiov_len + (**(**Tiovec)(__ccgo_up(iov + 1*16))).Fiov_len iovcnt = int32(2) for { cnt = X__syscall_ret(tls, Uint64FromInt64(X__syscall3(tls, int64(SYS_writev), int64((*TFILE)(unsafe.Pointer(f)).Ffd), int64(iov), int64(iovcnt)))) @@ -135762,22 +135762,22 @@ func X__stdio_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) v2 = v3 (*TFILE)(unsafe.Pointer(f)).Fwbase = v2 (*TFILE)(unsafe.Pointer(f)).Fwpos = v2 - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) if iovcnt == int32(2) { v5 = uint64(0) } else { - v5 = len1 - (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len + v5 = len1 - (**(**Tiovec)(__ccgo_up(iov))).Fiov_len } return v5 } rem = rem - Uint64FromInt64(cnt) - if Uint64FromInt64(cnt) > (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len { - cnt = Int64FromUint64(uint64(cnt) - (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len) + if Uint64FromInt64(cnt) > (**(**Tiovec)(__ccgo_up(iov))).Fiov_len { + cnt = Int64FromUint64(uint64(cnt) - (**(**Tiovec)(__ccgo_up(iov))).Fiov_len) iov += 16 iovcnt = iovcnt - 1 } - (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_base = (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_base + uintptr(cnt) - (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len -= Uint64FromInt64(cnt) + (**(**Tiovec)(__ccgo_up(iov))).Fiov_base = (**(**Tiovec)(__ccgo_up(iov))).Fiov_base + uintptr(cnt) + (**(**Tiovec)(__ccgo_up(iov))).Fiov_len -= Uint64FromInt64(cnt) goto _1 _1: } @@ -135807,7 +135807,7 @@ func X__toread(tls *TLS, f uintptr) (r int32) { var v1, v2 uintptr var v4 int32 _, _, _ = v1, v2, v4 - *(*int32)(unsafe.Pointer(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) + **(**int32)(__ccgo_up(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwbase { (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fwrite})))(tls, f, uintptr(0), uint64(0)) } @@ -135817,7 +135817,7 @@ func X__toread(tls *TLS, f uintptr) (r int32) { (*TFILE)(unsafe.Pointer(f)).Fwbase = v1 (*TFILE)(unsafe.Pointer(f)).Fwpos = v1 if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_NORD) != 0 { - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) return -int32(1) } v1 = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr((*TFILE)(unsafe.Pointer(f)).Fbuf_size) @@ -135845,9 +135845,9 @@ func X__towrite(tls *TLS, f uintptr) (r int32) { } var v1 uintptr _ = v1 - *(*int32)(unsafe.Pointer(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) + **(**int32)(__ccgo_up(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_NOWR) != 0 { - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) return -int32(1) } /* Clear read buffer (easier than summoning nasal demons) */ @@ -135881,7 +135881,7 @@ func X__uflow(tls *TLS, f uintptr) (r int32) { defer tls.Free(16) var _ /* c at bp+0 */ uint8 if !(X__toread(tls, f) != 0) && (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fread})))(tls, f, bp, uint64(1)) == uint64(1) { - return Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) + return Int32FromUint8(**(**uint8)(__ccgo_up(bp))) } return -int32(1) } @@ -135912,7 +135912,7 @@ func Xclearerr(tls *TLS, f uintptr) { v1 = 0 } __need_unlock = v1 - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^(Int32FromInt32(F_EOF) | Int32FromInt32(F_ERR))) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^(Int32FromInt32(F_EOF) | Int32FromInt32(F_ERR))) if __need_unlock != 0 { ___unlockfile(tls, f) } @@ -136073,7 +136073,7 @@ func X__freadptr(tls *TLS, f uintptr, sizep uintptr) (r uintptr) { if (*TFILE)(unsafe.Pointer(f)).Frpos == (*TFILE)(unsafe.Pointer(f)).Frend { return uintptr(0) } - *(*Tsize_t)(unsafe.Pointer(sizep)) = Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Frend) - int64((*TFILE)(unsafe.Pointer(f)).Frpos)) + **(**Tsize_t)(__ccgo_up(sizep)) = Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Frend) - int64((*TFILE)(unsafe.Pointer(f)).Frpos)) return (*TFILE)(unsafe.Pointer(f)).Frpos } @@ -136081,14 +136081,14 @@ func X__freadptrinc(tls *TLS, f uintptr, inc Tsize_t) { if __ccgo_strace { trc("tls=%v f=%v inc=%v, (%v:)", tls, f, inc, origin(2)) } - *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(inc) + **(**uintptr)(__ccgo_up(f + 8)) += uintptr(inc) } func X__fseterr(tls *TLS, f uintptr) { if __ccgo_strace { trc("tls=%v f=%v, (%v:)", tls, f, origin(2)) } - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) } func _dummy10(tls *TLS, f uintptr) { @@ -136131,8 +136131,8 @@ func Xfclose(tls *TLS, f uintptr) (r1 int32) { if (*TFILE)(unsafe.Pointer(f)).Fnext != 0 { (*TFILE)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Fnext)).Fprev = (*TFILE)(unsafe.Pointer(f)).Fprev } - if *(*uintptr)(unsafe.Pointer(head)) == f { - *(*uintptr)(unsafe.Pointer(head)) = (*TFILE)(unsafe.Pointer(f)).Fnext + if **(**uintptr)(__ccgo_up(head)) == f { + **(**uintptr)(__ccgo_up(head)) = (*TFILE)(unsafe.Pointer(f)).Fnext } X__ofl_unlock(tls) Xfree(tls, (*TFILE)(unsafe.Pointer(f)).Fgetln_buf) @@ -136233,7 +136233,7 @@ func Xfflush(tls *TLS, f uintptr) (r1 int32) { if AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stderr_used))) != 0 { r = r | Xfflush(tls, AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stderr_used)))) } - f = *(*uintptr)(unsafe.Pointer(X__ofl_lock(tls))) + f = **(**uintptr)(__ccgo_up(X__ofl_lock(tls))) for { if !(f != 0) { break @@ -136341,7 +136341,7 @@ _8: v10 = f + 8 v1 = *(*uintptr)(unsafe.Pointer(v10)) *(*uintptr)(unsafe.Pointer(v10)) = *(*uintptr)(unsafe.Pointer(v10)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v1))) } else { v2 = X__uflow(tls, f) } @@ -136400,7 +136400,7 @@ func Xfgetc(tls *TLS, f1 uintptr) (r int32) { v6 = v1 + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(v5))) } else { v4 = X__uflow(tls, v1) } @@ -136436,7 +136436,7 @@ func Xfgetln(tls *TLS, f uintptr, plen uintptr) (r uintptr) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__uflow(tls, f) } @@ -136449,14 +136449,14 @@ func Xfgetln(tls *TLS, f uintptr, plen uintptr) (r uintptr) { ret = (*TFILE)(unsafe.Pointer(f)).Frpos z = z + 1 v3 = z - *(*Tsize_t)(unsafe.Pointer(plen)) = Uint64FromInt64(int64(v3) - int64(ret)) + **(**Tsize_t)(__ccgo_up(plen)) = Uint64FromInt64(int64(v3) - int64(ret)) (*TFILE)(unsafe.Pointer(f)).Frpos = z } else { *(*[1]Tsize_t)(unsafe.Pointer(bp)) = [1]Tsize_t{} v8 = Xgetline(tls, f+168, bp, f) l = v8 if v8 > 0 { - *(*Tsize_t)(unsafe.Pointer(plen)) = Uint64FromInt64(l) + **(**Tsize_t)(__ccgo_up(plen)) = Uint64FromInt64(l) ret = (*TFILE)(unsafe.Pointer(f)).Fgetln_buf } } @@ -136477,7 +136477,7 @@ func Xfgetpos(tls *TLS, f uintptr, pos uintptr) (r int32) { if off < 0 { return -int32(1) } - *(*int64)(unsafe.Pointer(pos)) = off + **(**int64)(__ccgo_up(pos)) = off return 0 } @@ -136501,14 +136501,14 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { } __need_unlock = v1 if n <= int32(1) { - *(*int32)(unsafe.Pointer(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) + **(**int32)(__ccgo_up(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) if __need_unlock != 0 { ___unlockfile(tls, f) } if n < int32(1) { return uintptr(0) } - *(*uint8)(unsafe.Pointer(s)) = uint8(0) + **(**uint8)(__ccgo_up(s)) = uint8(0) return s } n = n - 1 @@ -136528,7 +136528,7 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { } k = v3 Xmemcpy(tls, p, (*TFILE)(unsafe.Pointer(f)).Frpos, k) - *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(k) + **(**uintptr)(__ccgo_up(f + 8)) += uintptr(k) p = p + uintptr(k) n = Int32FromUint64(uint64(n) - k) if z != 0 || !(n != 0) { @@ -136539,7 +136539,7 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { v7 = f + 8 v6 = *(*uintptr)(unsafe.Pointer(v7)) *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) + 1 - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(v6))) } else { v4 = X__uflow(tls, f) } @@ -136555,13 +136555,13 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { v8 = Uint8FromInt32(c) v6 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v6)) = v8 + **(**uint8)(__ccgo_up(v6)) = v8 if Int32FromUint8(v8) == int32('\n') { break } } if s != 0 { - *(*uint8)(unsafe.Pointer(p)) = uint8(0) + **(**uint8)(__ccgo_up(p)) = uint8(0) } if __need_unlock != 0 { ___unlockfile(tls, f) @@ -136591,43 +136591,43 @@ func ___fgetwc_unlocked_internal(tls *TLS, f uintptr) (r Twint_t) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { l = Uint64FromInt32(Xmbtowc(tls, bp, (*TFILE)(unsafe.Pointer(f)).Frpos, Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Frend)-int64((*TFILE)(unsafe.Pointer(f)).Frpos)))) if l+uint64(1) >= uint64(1) { - *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(l + BoolUint64(!(l != 0))) /* l==0 means 1 byte, null */ - return *(*Twchar_t)(unsafe.Pointer(bp)) + **(**uintptr)(__ccgo_up(f + 8)) += uintptr(l + BoolUint64(!(l != 0))) /* l==0 means 1 byte, null */ + return **(**Twchar_t)(__ccgo_up(bp)) } } /* Convert character byte-by-byte */ - *(*Tmbstate_t)(unsafe.Pointer(bp + 8)) = Tmbstate_t{} + **(**Tmbstate_t)(__ccgo_up(bp + 8)) = Tmbstate_t{} first = int32(1) for cond := true; cond; cond = l == Uint64FromInt32(-Int32FromInt32(2)) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__uflow(tls, f) } v1 = v2 c = v1 - *(*uint8)(unsafe.Pointer(bp + 16)) = Uint8FromInt32(v1) + **(**uint8)(__ccgo_up(bp + 16)) = Uint8FromInt32(v1) if c < 0 { if !(first != 0) { - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EILSEQ) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EILSEQ) } return uint32(0xffffffff) } l = Xmbrtowc(tls, bp, bp+16, uint64(1), bp+8) if l == Uint64FromInt32(-Int32FromInt32(1)) { if !(first != 0) { - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) - Xungetc(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + 16))), f) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) + Xungetc(tls, Int32FromUint8(**(**uint8)(__ccgo_up(bp + 16))), f) } return uint32(0xffffffff) } first = 0 } - return *(*Twchar_t)(unsafe.Pointer(bp)) + return **(**Twchar_t)(__ccgo_up(bp)) } func X__fgetwc_unlocked(tls *TLS, f uintptr) (r Twint_t) { @@ -136640,13 +136640,13 @@ func X__fgetwc_unlocked(tls *TLS, f uintptr) (r Twint_t) { var wc Twchar_t _, _, _ = loc, ploc, wc ploc = uintptr(___get_tp(tls)) + 152 - loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) + loc = **(**Tlocale_t)(__ccgo_up(ploc)) if (*TFILE)(unsafe.Pointer(f)).Fmode <= 0 { Xfwide(tls, f, int32(1)) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale + **(**Tlocale_t)(__ccgo_up(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale wc = ___fgetwc_unlocked_internal(tls, f) - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return wc } @@ -136718,7 +136718,7 @@ func Xfgetws(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { } v4 = p p += 4 - *(*Twchar_t)(unsafe.Pointer(v4)) = c + **(**Twchar_t)(__ccgo_up(v4)) = c if c == uint32('\n') { break } @@ -136727,7 +136727,7 @@ func Xfgetws(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { ; n = n - 1 } - *(*Twchar_t)(unsafe.Pointer(p)) = uint32(0) + **(**Twchar_t)(__ccgo_up(p)) = uint32(0) if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_ERR) != 0 { p = s } @@ -136768,7 +136768,7 @@ func Xfileno(tls *TLS, f uintptr) (r int32) { ___unlockfile(tls, f) } if fd < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EBADF) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EBADF) return -int32(1) } return fd @@ -136821,7 +136821,7 @@ func _mseek(tls *TLS, f uintptr, off Toff_t, whence int32) (r Toff_t) { goto fail fail: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) _1: ; @@ -136829,7 +136829,7 @@ _1: 1: (*Tcookie)(unsafe.Pointer(c)).Fpos, 2: (*Tcookie)(unsafe.Pointer(c)).Flen1, } - base = Int64FromUint64(*(*Tsize_t)(unsafe.Pointer(bp + uintptr(whence)*8))) + base = Int64FromUint64(**(**Tsize_t)(__ccgo_up(bp + uintptr(whence)*8))) if off < -base || off > Int64FromUint64((*Tcookie)(unsafe.Pointer(c)).Fsize)-base { goto fail } @@ -136849,10 +136849,10 @@ func _mread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { } if len1 > rem { len1 = rem - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_EOF) + **(**uint32)(__ccgo_up(f)) |= uint32(F_EOF) } Xmemcpy(tls, buf, (*Tcookie)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie)(unsafe.Pointer(c)).Fpos), len1) - *(*Tsize_t)(unsafe.Pointer(c)) += len1 + **(**Tsize_t)(__ccgo_up(c)) += len1 rem = rem - len1 if rem > (*TFILE)(unsafe.Pointer(f)).Fbuf_size { rem = (*TFILE)(unsafe.Pointer(f)).Fbuf_size @@ -136860,7 +136860,7 @@ func _mread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(rem) Xmemcpy(tls, (*TFILE)(unsafe.Pointer(f)).Frpos, (*Tcookie)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie)(unsafe.Pointer(c)).Fpos), rem) - *(*Tsize_t)(unsafe.Pointer(c)) += rem + **(**Tsize_t)(__ccgo_up(c)) += rem return len1 } @@ -136884,14 +136884,14 @@ func _mwrite(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { len1 = rem } Xmemcpy(tls, (*Tcookie)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie)(unsafe.Pointer(c)).Fpos), buf, len1) - *(*Tsize_t)(unsafe.Pointer(c)) += len1 + **(**Tsize_t)(__ccgo_up(c)) += len1 if (*Tcookie)(unsafe.Pointer(c)).Fpos > (*Tcookie)(unsafe.Pointer(c)).Flen1 { (*Tcookie)(unsafe.Pointer(c)).Flen1 = (*Tcookie)(unsafe.Pointer(c)).Fpos if (*Tcookie)(unsafe.Pointer(c)).Flen1 < (*Tcookie)(unsafe.Pointer(c)).Fsize { - *(*uint8)(unsafe.Pointer((*Tcookie)(unsafe.Pointer(c)).Fbuf + uintptr((*Tcookie)(unsafe.Pointer(c)).Flen1))) = uint8(0) + **(**uint8)(__ccgo_up((*Tcookie)(unsafe.Pointer(c)).Fbuf + uintptr((*Tcookie)(unsafe.Pointer(c)).Flen1))) = uint8(0) } else { if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_NORD) != 0 && (*Tcookie)(unsafe.Pointer(c)).Fsize != 0 { - *(*uint8)(unsafe.Pointer((*Tcookie)(unsafe.Pointer(c)).Fbuf + uintptr((*Tcookie)(unsafe.Pointer(c)).Fsize-uint64(1)))) = uint8(0) + **(**uint8)(__ccgo_up((*Tcookie)(unsafe.Pointer(c)).Fbuf + uintptr((*Tcookie)(unsafe.Pointer(c)).Fsize-uint64(1)))) = uint8(0) } } } @@ -136913,12 +136913,12 @@ func Xfmemopen(tls *TLS, buf uintptr, size Tsize_t, mode uintptr) (r uintptr) { var v3 Tsize_t _, _, _, _, _ = f, plus, v1, v2, v3 plus = BoolInt32(!!(Xstrchr(tls, mode, int32('+')) != 0)) - if !(Xstrchr(tls, __ccgo_ts+1504, Int32FromUint8(*(*uint8)(unsafe.Pointer(mode)))) != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if !(Xstrchr(tls, __ccgo_ts+1504, Int32FromUint8(**(**uint8)(__ccgo_up(mode)))) != 0) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } if !(buf != 0) && size > Uint64FromInt64(Int64FromInt64(INT64_MAX)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return uintptr(0) } if buf != 0 { @@ -136942,25 +136942,25 @@ func Xfmemopen(tls *TLS, buf uintptr, size Tsize_t, mode uintptr) (r uintptr) { } (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fbuf = buf (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fsize = size - (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fmode = Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) + (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fmode = Int32FromUint8(**(**uint8)(__ccgo_up(mode))) if !(plus != 0) { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('r') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) == int32('r') { v2 = int32(F_NOWR) } else { v2 = int32(F_NORD) } (*Tmem_FILE)(unsafe.Pointer(f)).Ff.Fflags = Uint32FromInt32(v2) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('r') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) == int32('r') { (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Flen1 = size } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('a') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) == int32('a') { v3 = Xstrnlen(tls, buf, size) (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fpos = v3 (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Flen1 = v3 } else { if plus != 0 { - *(*uint8)(unsafe.Pointer((*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fbuf)) = uint8(0) + **(**uint8)(__ccgo_up((*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fbuf)) = uint8(0) } } } @@ -136983,8 +136983,8 @@ func Xfopen(tls *TLS, filename uintptr, mode uintptr) (r uintptr) { var fd, flags int32 _, _, _ = f, fd, flags /* Check for valid initial mode character */ - if !(Xstrchr(tls, __ccgo_ts+1504, Int32FromUint8(*(*uint8)(unsafe.Pointer(mode)))) != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if !(Xstrchr(tls, __ccgo_ts+1504, Int32FromUint8(**(**uint8)(__ccgo_up(mode)))) != 0) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } /* Compute the flags to pass to open() */ @@ -137051,7 +137051,7 @@ func _cookieread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - *(*uint8)(unsafe.Pointer(buf + uintptr(v1))) = *(*uint8)(unsafe.Pointer(v2)) + **(**uint8)(__ccgo_up(buf + uintptr(v1))) = **(**uint8)(__ccgo_up(v2)) return readlen goto bail bail: @@ -137061,7 +137061,7 @@ bail: } else { v4 = int32(F_ERR) } - *(*uint32)(unsafe.Pointer(f)) |= Uint32FromInt32(v4) + **(**uint32)(__ccgo_up(f)) |= Uint32FromInt32(v4) v2 = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = v2 (*TFILE)(unsafe.Pointer(f)).Frpos = v2 @@ -137091,7 +137091,7 @@ func _cookiewrite(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { v1 = v2 (*TFILE)(unsafe.Pointer(f)).Fwbase = v1 (*TFILE)(unsafe.Pointer(f)).Fwpos = v1 - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) return uint64(0) } return Uint64FromInt64(ret) @@ -137106,18 +137106,18 @@ func _cookieseek(tls *TLS, f uintptr, _off Toff_t, whence int32) (r Toff_t) { _, _ = fc, res fc = (*TFILE)(unsafe.Pointer(f)).Fcookie if Uint32FromInt32(whence) > uint32(2) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) } if !((*Tfcookie)(unsafe.Pointer(fc)).Fiofuncs.Fseek != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOPNOTSUPP) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOPNOTSUPP) return int64(-int32(1)) } res = (*(*func(*TLS, uintptr, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{(*Tfcookie)(unsafe.Pointer(fc)).Fiofuncs.Fseek})))(tls, (*Tfcookie)(unsafe.Pointer(fc)).Fcookie, bp, whence) if res < 0 { return int64(res) } - return *(*Toff_t)(unsafe.Pointer(bp)) + return **(**Toff_t)(__ccgo_up(bp)) } func _cookieclose(tls *TLS, f uintptr) (r int32) { @@ -137139,8 +137139,8 @@ func Xfopencookie(tls *TLS, cookie uintptr, mode uintptr, iofuncs Tcookie_io_fun var v2 int32 _, _, _ = f, v1, v2 /* Check for valid initial mode character */ - if !(Xstrchr(tls, __ccgo_ts+1504, Int32FromUint8(*(*uint8)(unsafe.Pointer(mode)))) != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if !(Xstrchr(tls, __ccgo_ts+1504, Int32FromUint8(**(**uint8)(__ccgo_up(mode)))) != 0) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } /* Allocate FILE+fcookie+buffer or fail */ @@ -137153,7 +137153,7 @@ func Xfopencookie(tls *TLS, cookie uintptr, mode uintptr, iofuncs Tcookie_io_fun Xmemset(tls, f, 0, uint64(232)) /* Impose mode restrictions */ if !(Xstrchr(tls, mode, int32('+')) != 0) { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('r') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) == int32('r') { v2 = int32(F_NOWR) } else { v2 = int32(F_NORD) @@ -137233,7 +137233,7 @@ _8: v11 = f + 40 v1 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - *(*uint8)(unsafe.Pointer(v1)) = v10 + **(**uint8)(__ccgo_up(v1)) = v10 v2 = Int32FromUint8(v10) } else { v2 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) @@ -137296,7 +137296,7 @@ func Xfputc(tls *TLS, c1 int32, f1 uintptr) (r int32) { v8 = v2 + 40 v7 = *(*uintptr)(unsafe.Pointer(v8)) *(*uintptr)(unsafe.Pointer(v8)) = *(*uintptr)(unsafe.Pointer(v8)) + 1 - *(*uint8)(unsafe.Pointer(v7)) = v6 + **(**uint8)(__ccgo_up(v7)) = v6 v5 = Int32FromUint8(v6) } else { v5 = X__overflow(tls, v2, Int32FromUint8(Uint8FromInt32(v1))) @@ -137343,18 +137343,18 @@ func X__fputwc_unlocked(tls *TLS, c Twchar_t, f uintptr) (r Twint_t) { var _ /* mbc at bp+0 */ [4]uint8 _, _, _, _, _, _, _ = l, loc, ploc, v1, v2, v3, v4 ploc = uintptr(___get_tp(tls)) + 152 - loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) + loc = **(**Tlocale_t)(__ccgo_up(ploc)) if (*TFILE)(unsafe.Pointer(f)).Fmode <= 0 { Xfwide(tls, f, int32(1)) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale + **(**Tlocale_t)(__ccgo_up(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale if BoolInt32(c < uint32(128)) != 0 { if Int32FromUint8(uint8(c)) != (*TFILE)(unsafe.Pointer(f)).Flbf && (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwend { v2 = uint8(c) v4 = f + 40 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(v3)) = v2 + **(**uint8)(__ccgo_up(v3)) = v2 v1 = Int32FromUint8(v2) } else { v1 = X__overflow(tls, f, Int32FromUint8(uint8(c))) @@ -137366,7 +137366,7 @@ func X__fputwc_unlocked(tls *TLS, c Twchar_t, f uintptr) (r Twint_t) { if l < 0 { c = uint32(0xffffffff) } else { - *(*uintptr)(unsafe.Pointer(f + 40)) += uintptr(l) + **(**uintptr)(__ccgo_up(f + 40)) += uintptr(l) } } else { l = Xwctomb(tls, bp, c) @@ -137376,9 +137376,9 @@ func X__fputwc_unlocked(tls *TLS, c Twchar_t, f uintptr) (r Twint_t) { } } if c == uint32(0xffffffff) { - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return c } @@ -137435,7 +137435,7 @@ func Xfputws(tls *TLS, _ws uintptr, f uintptr) (r int32) { _, _, _, _, _, _, _ = __need_unlock, l, loc, ploc, v1, v2, v3 l = uint64(0) ploc = uintptr(___get_tp(tls)) + 152 - loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) + loc = **(**Tlocale_t)(__ccgo_up(ploc)) if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) } else { @@ -137443,9 +137443,9 @@ func Xfputws(tls *TLS, _ws uintptr, f uintptr) (r int32) { } __need_unlock = v1 Xfwide(tls, f, int32(1)) - *(*Tlocale_t)(unsafe.Pointer(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale + **(**Tlocale_t)(__ccgo_up(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale for { - if v3 = *(*uintptr)(unsafe.Pointer(bp)) != 0; v3 { + if v3 = **(**uintptr)(__ccgo_up(bp)) != 0; v3 { v2 = Xwcsrtombs(tls, bp+8, bp, uint64(1024), uintptr(0)) l = v2 } @@ -137456,14 +137456,14 @@ func Xfputws(tls *TLS, _ws uintptr, f uintptr) (r int32) { if __need_unlock != 0 { ___unlockfile(tls, f) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return -int32(1) } } if __need_unlock != 0 { ___unlockfile(tls, f) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return Int32FromUint64(l) /* 0 or -1 */ } @@ -137497,7 +137497,7 @@ func Xfread(tls *TLS, destv uintptr, size Tsize_t, nmemb Tsize_t, f uintptr) (r v1 = 0 } __need_unlock = v1 - *(*int32)(unsafe.Pointer(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) + **(**int32)(__ccgo_up(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { /* First exhaust the buffer. */ if Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Frend)-int64((*TFILE)(unsafe.Pointer(f)).Frpos)) < l { @@ -137507,7 +137507,7 @@ func Xfread(tls *TLS, destv uintptr, size Tsize_t, nmemb Tsize_t, f uintptr) (r } k = v2 Xmemcpy(tls, dest, (*TFILE)(unsafe.Pointer(f)).Frpos, k) - *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(k) + **(**uintptr)(__ccgo_up(f + 8)) += uintptr(k) dest = dest + uintptr(k) l = l - k } @@ -137647,7 +137647,7 @@ func X__fseeko_unlocked(tls *TLS, f uintptr, off Toff_t, whence int32) (r int32) _, _ = v1, v2 /* Fail immediately for invalid whence argument. */ if whence != int32(1) && whence != 0 && whence != int32(2) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } /* Adjust relative offset for unread data in buffer, if any. */ @@ -137675,7 +137675,7 @@ func X__fseeko_unlocked(tls *TLS, f uintptr, off Toff_t, whence int32) (r int32) v1 = UintptrFromInt32(0) (*TFILE)(unsafe.Pointer(f)).Frend = v1 (*TFILE)(unsafe.Pointer(f)).Frpos = v1 - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) return 0 } @@ -137720,7 +137720,7 @@ func Xfsetpos(tls *TLS, f uintptr, pos uintptr) (r int32) { trc("tls=%v f=%v pos=%v, (%v:)", tls, f, pos, origin(2)) defer func() { trc("-> %v", r) }() } - return X__fseeko(tls, f, *(*int64)(unsafe.Pointer(pos)), 0) + return X__fseeko(tls, f, int64(**(**int64)(__ccgo_up(pos))), 0) } /* Support signed or unsigned plain-char */ @@ -137790,7 +137790,7 @@ func Xftell(tls *TLS, f uintptr) (r int64) { _ = pos pos = X__ftello(tls, f) if pos > int64(0x7fffffffffffffff) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return int64(-int32(1)) } return pos @@ -137948,7 +137948,7 @@ func Xfwide(tls *TLS, f uintptr, mode int32) (r int32) { __need_unlock = v1 if mode != 0 { if !((*TFILE)(unsafe.Pointer(f)).Flocale != 0) { - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v3 = int32(4) } else { v3 = int32(1) @@ -138008,7 +138008,7 @@ func X__fwritex(tls *TLS, s uintptr, l Tsize_t, f uintptr) (r Tsize_t) { /* Match /^(.*\n|)/ */ i = l for { - if !(i != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(i-uint64(1))))) != int32('\n')) { + if !(i != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(i-uint64(1))))) != int32('\n')) { break } goto _1 @@ -138026,7 +138026,7 @@ func X__fwritex(tls *TLS, s uintptr, l Tsize_t, f uintptr) (r Tsize_t) { } } Xmemcpy(tls, (*TFILE)(unsafe.Pointer(f)).Fwpos, s, l) - *(*uintptr)(unsafe.Pointer(f + 40)) += uintptr(l) + **(**uintptr)(__ccgo_up(f + 40)) += uintptr(l) return l + i } @@ -138131,7 +138131,7 @@ _8: v10 = f + 8 v1 = *(*uintptr)(unsafe.Pointer(v10)) *(*uintptr)(unsafe.Pointer(v10)) = *(*uintptr)(unsafe.Pointer(v10)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v1))) } else { v2 = X__uflow(tls, f) } @@ -138190,7 +138190,7 @@ func Xgetc(tls *TLS, f1 uintptr) (r int32) { v6 = v1 + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(v5))) } else { v4 = X__uflow(tls, v1) } @@ -138223,7 +138223,7 @@ func Xgetc_unlocked(tls *TLS, f uintptr) (r int32) { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__uflow(tls, f) } @@ -138286,7 +138286,7 @@ _8: v10 = f + 8 v1 = *(*uintptr)(unsafe.Pointer(v10)) *(*uintptr)(unsafe.Pointer(v10)) = *(*uintptr)(unsafe.Pointer(v10)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v1))) } else { v2 = X__uflow(tls, f) } @@ -138345,7 +138345,7 @@ func Xgetchar(tls *TLS) (r int32) { v6 = v1 + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(v5))) } else { v4 = X__uflow(tls, v1) } @@ -138370,7 +138370,7 @@ func Xgetchar_unlocked(tls *TLS) (r int32) { v3 = uintptr(unsafe.Pointer(&X__stdin_FILE)) + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__uflow(tls, uintptr(unsafe.Pointer(&X__stdin_FILE))) } @@ -138396,16 +138396,16 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize } __need_unlock = v1 if !(n != 0) || !(s != 0) { - *(*int32)(unsafe.Pointer(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**int32)(__ccgo_up(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) if __need_unlock != 0 { ___unlockfile(tls, f) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) } - if !(*(*uintptr)(unsafe.Pointer(s)) != 0) { - *(*Tsize_t)(unsafe.Pointer(n)) = uint64(0) + if !(**(**uintptr)(__ccgo_up(s)) != 0) { + **(**Tsize_t)(__ccgo_up(n)) = uint64(0) } for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { @@ -138420,36 +138420,36 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize z = uintptr(0) k = uint64(0) } - if i+k >= *(*Tsize_t)(unsafe.Pointer(n)) { + if i+k >= **(**Tsize_t)(__ccgo_up(n)) { m = i + k + uint64(2) if !(z != 0) && m < Uint64FromUint64(0xffffffffffffffff)/Uint64FromInt32(4) { m = m + m/uint64(2) } - tmp = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(s)), m) + tmp = Xrealloc(tls, **(**uintptr)(__ccgo_up(s)), m) if !(tmp != 0) { m = i + k + uint64(2) - tmp = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(s)), m) + tmp = Xrealloc(tls, **(**uintptr)(__ccgo_up(s)), m) if !(tmp != 0) { /* Copy as much as fits and ensure no * pushback remains in the FILE buf. */ - k = *(*Tsize_t)(unsafe.Pointer(n)) - i - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(s))+uintptr(i), (*TFILE)(unsafe.Pointer(f)).Frpos, k) - *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(k) - *(*int32)(unsafe.Pointer(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + k = **(**Tsize_t)(__ccgo_up(n)) - i + Xmemcpy(tls, **(**uintptr)(__ccgo_up(s))+uintptr(i), (*TFILE)(unsafe.Pointer(f)).Frpos, k) + **(**uintptr)(__ccgo_up(f + 8)) += uintptr(k) + **(**int32)(__ccgo_up(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) if __need_unlock != 0 { ___unlockfile(tls, f) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return int64(-int32(1)) } } - *(*uintptr)(unsafe.Pointer(s)) = tmp - *(*Tsize_t)(unsafe.Pointer(n)) = m + **(**uintptr)(__ccgo_up(s)) = tmp + **(**Tsize_t)(__ccgo_up(n)) = m } if k != 0 { - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(s))+uintptr(i), (*TFILE)(unsafe.Pointer(f)).Frpos, k) - *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(k) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(s))+uintptr(i), (*TFILE)(unsafe.Pointer(f)).Frpos, k) + **(**uintptr)(__ccgo_up(f + 8)) += uintptr(k) i = i + k } if z != 0 { @@ -138459,7 +138459,7 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize v7 = f + 8 v6 = *(*uintptr)(unsafe.Pointer(v7)) *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) + 1 - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(v6))) } else { v4 = X__uflow(tls, f) } @@ -138476,16 +138476,16 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize } /* If the byte read by getc won't fit without growing the * output buffer, push it back for next iteration. */ - if i+uint64(1) >= *(*Tsize_t)(unsafe.Pointer(n)) { + if i+uint64(1) >= **(**Tsize_t)(__ccgo_up(n)) { v7 = f + 8 *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) - 1 v6 = *(*uintptr)(unsafe.Pointer(v7)) - *(*uint8)(unsafe.Pointer(v6)) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(v6)) = Uint8FromInt32(c) } else { v10 = Uint8FromInt32(c) v11 = i i = i + 1 - *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)) + uintptr(v11))) = v10 + **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)) + uintptr(v11))) = v10 if Int32FromUint8(v10) == delim { break } @@ -138493,7 +138493,7 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize goto _2 _2: } - *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)) + uintptr(i))) = uint8(0) + **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)) + uintptr(i))) = uint8(0) if __need_unlock != 0 { ___unlockfile(tls, f) } @@ -138537,7 +138537,7 @@ func Xgets(tls *TLS, s uintptr) (r uintptr) { v5 = uintptr(unsafe.Pointer(&X__stdin_FILE)) + 8 v4 = *(*uintptr)(unsafe.Pointer(v5)) *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v4))) } else { v3 = X__uflow(tls, uintptr(unsafe.Pointer(&X__stdin_FILE))) } @@ -138548,9 +138548,9 @@ func Xgets(tls *TLS, s uintptr) (r uintptr) { } v6 = i i = i + 1 - *(*uint8)(unsafe.Pointer(s + uintptr(v6))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + uintptr(v6))) = Uint8FromInt32(c) } - *(*uint8)(unsafe.Pointer(s + uintptr(i))) = uint8(0) + **(**uint8)(__ccgo_up(s + uintptr(i))) = uint8(0) if c != int32('\n') && (!((*TFILE)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stdin_FILE)))).Fflags&Uint32FromInt32(F_EOF) != 0) || !(i != 0)) { s = uintptr(0) } @@ -138571,7 +138571,7 @@ func Xgetw(tls *TLS, f uintptr) (r int32) { var _ /* x at bp+0 */ int32 _ = v1 if Xfread(tls, bp, uint64(4), uint64(1), f) != 0 { - v1 = *(*int32)(unsafe.Pointer(bp)) + v1 = **(**int32)(__ccgo_up(bp)) } else { v1 = -int32(1) } @@ -138629,11 +138629,11 @@ func X__ofl_add(tls *TLS, f uintptr) (r uintptr) { var head uintptr _ = head head = X__ofl_lock(tls) - (*TFILE)(unsafe.Pointer(f)).Fnext = *(*uintptr)(unsafe.Pointer(head)) - if *(*uintptr)(unsafe.Pointer(head)) != 0 { - (*TFILE)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(head)))).Fprev = f + (*TFILE)(unsafe.Pointer(f)).Fnext = **(**uintptr)(__ccgo_up(head)) + if **(**uintptr)(__ccgo_up(head)) != 0 { + (*TFILE)(unsafe.Pointer(**(**uintptr)(__ccgo_up(head)))).Fprev = f } - *(*uintptr)(unsafe.Pointer(head)) = f + **(**uintptr)(__ccgo_up(head)) = f X__ofl_unlock(tls) return f } @@ -138667,7 +138667,7 @@ func _ms_seek(tls *TLS, f uintptr, off Toff_t, whence int32) (r Toff_t) { goto fail fail: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) _1: ; @@ -138675,7 +138675,7 @@ _1: 1: (*Tcookie1)(unsafe.Pointer(c)).Fpos, 2: (*Tcookie1)(unsafe.Pointer(c)).Flen1, } - base = Int64FromUint64(*(*Tsize_t)(unsafe.Pointer(bp + uintptr(whence)*8))) + base = Int64FromUint64(**(**Tsize_t)(__ccgo_up(bp + uintptr(whence)*8))) if off < -base || off > int64(0x7fffffffffffffff)-base { goto fail } @@ -138704,16 +138704,16 @@ func _ms_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { } v1 = newbuf (*Tcookie1)(unsafe.Pointer(c)).Fbuf = v1 - *(*uintptr)(unsafe.Pointer((*Tcookie1)(unsafe.Pointer(c)).Fbufp)) = v1 + **(**uintptr)(__ccgo_up((*Tcookie1)(unsafe.Pointer(c)).Fbufp)) = v1 Xmemset(tls, (*Tcookie1)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie1)(unsafe.Pointer(c)).Fspace), 0, len2-(*Tcookie1)(unsafe.Pointer(c)).Fspace) (*Tcookie1)(unsafe.Pointer(c)).Fspace = len2 } Xmemcpy(tls, (*Tcookie1)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie1)(unsafe.Pointer(c)).Fpos), buf, len1) - *(*Tsize_t)(unsafe.Pointer(c + 16)) += len1 + **(**Tsize_t)(__ccgo_up(c + 16)) += len1 if (*Tcookie1)(unsafe.Pointer(c)).Fpos >= (*Tcookie1)(unsafe.Pointer(c)).Flen1 { (*Tcookie1)(unsafe.Pointer(c)).Flen1 = (*Tcookie1)(unsafe.Pointer(c)).Fpos } - *(*Tsize_t)(unsafe.Pointer((*Tcookie1)(unsafe.Pointer(c)).Fsizep)) = (*Tcookie1)(unsafe.Pointer(c)).Fpos + **(**Tsize_t)(__ccgo_up((*Tcookie1)(unsafe.Pointer(c)).Fsizep)) = (*Tcookie1)(unsafe.Pointer(c)).Fpos return len1 } @@ -138746,16 +138746,16 @@ func Xopen_memstream(tls *TLS, bufp uintptr, sizep uintptr) (r uintptr) { (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fbufp = bufp (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fsizep = sizep v5 = Uint64FromInt32(0) - *(*Tsize_t)(unsafe.Pointer(sizep)) = v5 + **(**Tsize_t)(__ccgo_up(sizep)) = v5 v4 = v5 (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fspace = v4 v3 = v4 (*Tms_FILE)(unsafe.Pointer(f)).Fc.Flen1 = v3 (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fpos = v3 v1 = buf - *(*uintptr)(unsafe.Pointer(bufp)) = v1 + **(**uintptr)(__ccgo_up(bufp)) = v1 (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fbuf = v1 - *(*uint8)(unsafe.Pointer(buf)) = uint8(0) + **(**uint8)(__ccgo_up(buf)) = uint8(0) (*Tms_FILE)(unsafe.Pointer(f)).Ff.Fflags = uint32(F_NORD) (*Tms_FILE)(unsafe.Pointer(f)).Ff.Ffd = -int32(1) (*Tms_FILE)(unsafe.Pointer(f)).Ff.Fbuf = f + 280 @@ -138801,7 +138801,7 @@ func _wms_seek(tls *TLS, f uintptr, off Toff_t, whence int32) (r Toff_t) { goto fail fail: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) _1: ; @@ -138809,7 +138809,7 @@ _1: 1: (*Tcookie2)(unsafe.Pointer(c)).Fpos, 2: (*Tcookie2)(unsafe.Pointer(c)).Flen1, } - base = Int64FromUint64(*(*Tsize_t)(unsafe.Pointer(bp + uintptr(whence)*8))) + base = Int64FromUint64(**(**Tsize_t)(__ccgo_up(bp + uintptr(whence)*8))) if off < -base || off > Int64FromInt64(0x7fffffffffffffff)/Int64FromInt32(4)-base { goto fail } @@ -138845,7 +138845,7 @@ func _wms_write(tls *TLS, f uintptr, _buf uintptr, len1 Tsize_t) (r Tsize_t) { } v1 = newbuf (*Tcookie2)(unsafe.Pointer(c)).Fbuf = v1 - *(*uintptr)(unsafe.Pointer((*Tcookie2)(unsafe.Pointer(c)).Fbufp)) = v1 + **(**uintptr)(__ccgo_up((*Tcookie2)(unsafe.Pointer(c)).Fbufp)) = v1 Xmemset(tls, (*Tcookie2)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie2)(unsafe.Pointer(c)).Fspace)*4, 0, uint64(4)*(len2-(*Tcookie2)(unsafe.Pointer(c)).Fspace)) (*Tcookie2)(unsafe.Pointer(c)).Fspace = len2 } @@ -138853,11 +138853,11 @@ func _wms_write(tls *TLS, f uintptr, _buf uintptr, len1 Tsize_t) (r Tsize_t) { if len2 == Uint64FromInt32(-Int32FromInt32(1)) { return uint64(0) } - *(*Tsize_t)(unsafe.Pointer(c + 16)) += len2 + **(**Tsize_t)(__ccgo_up(c + 16)) += len2 if (*Tcookie2)(unsafe.Pointer(c)).Fpos >= (*Tcookie2)(unsafe.Pointer(c)).Flen1 { (*Tcookie2)(unsafe.Pointer(c)).Flen1 = (*Tcookie2)(unsafe.Pointer(c)).Fpos } - *(*Tsize_t)(unsafe.Pointer((*Tcookie2)(unsafe.Pointer(c)).Fsizep)) = (*Tcookie2)(unsafe.Pointer(c)).Fpos + **(**Tsize_t)(__ccgo_up((*Tcookie2)(unsafe.Pointer(c)).Fsizep)) = (*Tcookie2)(unsafe.Pointer(c)).Fpos return len1 } @@ -138890,16 +138890,16 @@ func Xopen_wmemstream(tls *TLS, bufp uintptr, sizep uintptr) (r uintptr) { (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fbufp = bufp (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fsizep = sizep v5 = Uint64FromInt32(0) - *(*Tsize_t)(unsafe.Pointer(sizep)) = v5 + **(**Tsize_t)(__ccgo_up(sizep)) = v5 v4 = v5 (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fspace = v4 v3 = v4 (*Twms_FILE)(unsafe.Pointer(f)).Fc.Flen1 = v3 (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fpos = v3 v1 = buf - *(*uintptr)(unsafe.Pointer(bufp)) = v1 + **(**uintptr)(__ccgo_up(bufp)) = v1 (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fbuf = v1 - *(*Twchar_t)(unsafe.Pointer(buf)) = uint32(0) + **(**Twchar_t)(__ccgo_up(buf)) = uint32(0) (*Twms_FILE)(unsafe.Pointer(f)).Ff.Fflags = uint32(F_NORD) (*Twms_FILE)(unsafe.Pointer(f)).Ff.Ffd = -int32(1) (*Twms_FILE)(unsafe.Pointer(f)).Ff.Fbuf = f + 288 @@ -138938,7 +138938,7 @@ func Xpclose(tls *TLS, f uintptr) (r1 int32) { if r < 0 { return int32(X__syscall_ret(tls, Uint64FromInt32(r))) } - return *(*int32)(unsafe.Pointer(bp)) + return **(**int32)(__ccgo_up(bp)) } func Xperror(tls *TLS, msg uintptr) { @@ -138949,7 +138949,7 @@ func Xperror(tls *TLS, msg uintptr) { var errstr, f, old_locale uintptr _, _, _, _, _, _ = __need_unlock, errstr, f, old_locale, old_mode, v1 f = uintptr(unsafe.Pointer(&X__stderr_FILE)) - errstr = Xstrerror(tls, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) + errstr = Xstrerror(tls, **(**int32)(__ccgo_up(X__errno_location(tls)))) if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) } else { @@ -138960,7 +138960,7 @@ func Xperror(tls *TLS, msg uintptr) { * permitted to change them. */ old_locale = (*TFILE)(unsafe.Pointer(f)).Flocale old_mode = (*TFILE)(unsafe.Pointer(f)).Fmode - if msg != 0 && *(*uint8)(unsafe.Pointer(msg)) != 0 { + if msg != 0 && **(**uint8)(__ccgo_up(msg)) != 0 { Xfwrite(tls, msg, _strlen(tls, msg), uint64(1), f) Xfputc(tls, int32(':'), f) Xfputc(tls, int32(' '), f) @@ -139030,7 +139030,7 @@ _8: v11 = f + 40 v1 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - *(*uint8)(unsafe.Pointer(v1)) = v10 + **(**uint8)(__ccgo_up(v1)) = v10 v2 = Int32FromUint8(v10) } else { v2 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) @@ -139093,7 +139093,7 @@ func Xputc(tls *TLS, c1 int32, f1 uintptr) (r int32) { v8 = v2 + 40 v7 = *(*uintptr)(unsafe.Pointer(v8)) *(*uintptr)(unsafe.Pointer(v8)) = *(*uintptr)(unsafe.Pointer(v8)) + 1 - *(*uint8)(unsafe.Pointer(v7)) = v6 + **(**uint8)(__ccgo_up(v7)) = v6 v5 = Int32FromUint8(v6) } else { v5 = X__overflow(tls, v2, Int32FromUint8(Uint8FromInt32(v1))) @@ -139129,7 +139129,7 @@ func Xputc_unlocked(tls *TLS, c int32, f uintptr) (r int32) { v4 = f + 40 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(v3)) = v2 + **(**uint8)(__ccgo_up(v3)) = v2 v1 = Int32FromUint8(v2) } else { v1 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) @@ -139195,7 +139195,7 @@ _8: v11 = f + 40 v1 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - *(*uint8)(unsafe.Pointer(v1)) = v10 + **(**uint8)(__ccgo_up(v1)) = v10 v2 = Int32FromUint8(v10) } else { v2 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) @@ -139258,7 +139258,7 @@ func Xputchar(tls *TLS, c1 int32) (r int32) { v8 = v2 + 40 v7 = *(*uintptr)(unsafe.Pointer(v8)) *(*uintptr)(unsafe.Pointer(v8)) = *(*uintptr)(unsafe.Pointer(v8)) + 1 - *(*uint8)(unsafe.Pointer(v7)) = v6 + **(**uint8)(__ccgo_up(v7)) = v6 v5 = Int32FromUint8(v6) } else { v5 = X__overflow(tls, v2, Int32FromUint8(Uint8FromInt32(v1))) @@ -139286,7 +139286,7 @@ func Xputchar_unlocked(tls *TLS, c int32) (r int32) { v4 = uintptr(unsafe.Pointer(&X__stdout_FILE)) + 40 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(v3)) = v2 + **(**uint8)(__ccgo_up(v3)) = v2 v1 = Int32FromUint8(v2) } else { v1 = X__overflow(tls, uintptr(unsafe.Pointer(&X__stdout_FILE)), Int32FromUint8(Uint8FromInt32(c))) @@ -139316,7 +139316,7 @@ func Xputs(tls *TLS, s uintptr) (r1 int32) { v5 = uintptr(unsafe.Pointer(&X__stdout_FILE)) + 40 v4 = *(*uintptr)(unsafe.Pointer(v5)) *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = v3 + **(**uint8)(__ccgo_up(v4)) = v3 v2 = Int32FromUint8(v3) } else { v2 = X__overflow(tls, uintptr(unsafe.Pointer(&X__stdout_FILE)), Int32FromUint8(Uint8FromInt32(Int32FromUint8('\n')))) @@ -139399,7 +139399,7 @@ func Xrewind(tls *TLS, f uintptr) { } __need_unlock = v1 X__fseeko_unlocked(tls, f, 0, 0) - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_ERR)) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^Int32FromInt32(F_ERR)) if __need_unlock != 0 { ___unlockfile(tls, f) } @@ -139489,7 +139489,7 @@ func Xsetvbuf(tls *TLS, f uintptr, buf uintptr, type1 int32, size Tsize_t) (r in return -int32(1) } } - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_SVB) + **(**uint32)(__ccgo_up(f)) |= uint32(F_SVB) return 0 } @@ -139629,14 +139629,14 @@ func Xtempnam(tls *TLS, dir uintptr, pfx uintptr) (r1 uintptr) { pl = _strlen(tls, pfx) l = dl + uint64(1) + pl + uint64(1) + uint64(6) if l >= uint64(PATH_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENAMETOOLONG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENAMETOOLONG) return uintptr(0) } Xmemcpy(tls, bp+1, dir, dl) - (*(*[4096]uint8)(unsafe.Pointer(bp + 1)))[dl] = uint8('/') + (**(**[4096]uint8)(__ccgo_up(bp + 1)))[dl] = uint8('/') Xmemcpy(tls, bp+1+uintptr(dl)+uintptr(1), pfx, pl) - (*(*[4096]uint8)(unsafe.Pointer(bp + 1)))[dl+uint64(1)+pl] = uint8('_') - (*(*[4096]uint8)(unsafe.Pointer(bp + 1)))[l] = uint8(0) + (**(**[4096]uint8)(__ccgo_up(bp + 1)))[dl+uint64(1)+pl] = uint8('_') + (**(**[4096]uint8)(__ccgo_up(bp + 1)))[l] = uint8(0) try = 0 for { if !(try < int32(MAXTRIES)) { @@ -139667,7 +139667,7 @@ func Xtmpfile(tls *TLS) (r uintptr) { var fd, try int32 var _ /* s at bp+0 */ [20]uint8 _, _, _ = f, fd, try - *(*[20]uint8)(unsafe.Pointer(bp)) = [20]uint8{'/', 't', 'm', 'p', '/', 't', 'm', 'p', 'f', 'i', 'l', 'e', '_', 'X', 'X', 'X', 'X', 'X', 'X'} + **(**[20]uint8)(__ccgo_up(bp)) = [20]uint8{'/', 't', 'm', 'p', '/', 't', 'm', 'p', 'f', 'i', 'l', 'e', '_', 'X', 'X', 'X', 'X', 'X', 'X'} try = 0 for { if !(try < int32(MAXTRIES)) { @@ -139702,7 +139702,7 @@ func Xtmpnam(tls *TLS, buf uintptr) (r1 uintptr) { var v2 uintptr var _ /* s at bp+1 */ [19]uint8 _, _, _ = r, try, v2 - *(*[19]uint8)(unsafe.Pointer(bp + 1)) = [19]uint8{'/', 't', 'm', 'p', '/', 't', 'm', 'p', 'n', 'a', 'm', '_', 'X', 'X', 'X', 'X', 'X', 'X'} + **(**[19]uint8)(__ccgo_up(bp + 1)) = [19]uint8{'/', 't', 'm', 'p', '/', 't', 'm', 'p', 'n', 'a', 'm', '_', 'X', 'X', 'X', 'X', 'X', 'X'} try = 0 for { if !(try < int32(MAXTRIES)) { @@ -139758,8 +139758,8 @@ func Xungetc(tls *TLS, c int32, f uintptr) (r int32) { v3 = f + 8 *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) - 1 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(c) - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) + **(**uint8)(__ccgo_up(v2)) = Uint8FromInt32(c) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) if __need_unlock != 0 { ___unlockfile(tls, f) } @@ -139780,7 +139780,7 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { var _ /* mbc at bp+0 */ [4]uint8 _, _, _, _, _, _, _, _ = __need_unlock, l, loc, ploc, v1, v3, v4, v5 ploc = uintptr(___get_tp(tls)) + 152 - loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) + loc = **(**Tlocale_t)(__ccgo_up(ploc)) if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) } else { @@ -139790,7 +139790,7 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { if (*TFILE)(unsafe.Pointer(f)).Fmode <= 0 { Xfwide(tls, f, int32(1)) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale + **(**Tlocale_t)(__ccgo_up(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale if !((*TFILE)(unsafe.Pointer(f)).Frpos != 0) { X__toread(tls, f) } @@ -139802,24 +139802,24 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { if __need_unlock != 0 { ___unlockfile(tls, f) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return uint32(0xffffffff) } if BoolInt32(c < uint32(128)) != 0 { v5 = f + 8 *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) - 1 v4 = *(*uintptr)(unsafe.Pointer(v5)) - *(*uint8)(unsafe.Pointer(v4)) = uint8(c) + **(**uint8)(__ccgo_up(v4)) = uint8(c) } else { v4 = f + 8 *(*uintptr)(unsafe.Pointer(v4)) -= uintptr(l) Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(v4)), bp, Uint64FromInt32(l)) } - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) if __need_unlock != 0 { ___unlockfile(tls, f) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return c } @@ -139838,12 +139838,12 @@ func Xvasprintf(tls *TLS, s uintptr, fmt uintptr, ap Tva_list) (r int32) { _ = ap2 if v2 = l < 0; !v2 { v1 = Xmalloc(tls, uint64(Uint32FromInt32(l)+uint32(1))) - *(*uintptr)(unsafe.Pointer(s)) = v1 + **(**uintptr)(__ccgo_up(s)) = v1 } if v2 || !(v1 != 0) { return -int32(1) } - return Xvsnprintf(tls, *(*uintptr)(unsafe.Pointer(s)), uint64(Uint32FromInt32(l)+uint32(1)), fmt, ap) + return Xvsnprintf(tls, **(**uintptr)(__ccgo_up(s)), uint64(Uint32FromInt32(l)+uint32(1)), fmt, ap) } func Xvdprintf(tls *TLS, fd int32, fmt uintptr, ap Tva_list) (r int32) { @@ -139854,7 +139854,7 @@ func Xvdprintf(tls *TLS, fd int32, fmt uintptr, ap Tva_list) (r int32) { bp := tls.Alloc(240) defer tls.Free(240) var _ /* f at bp+0 */ TFILE - *(*TFILE)(unsafe.Pointer(bp)) = TFILE{ + **(**TFILE)(__ccgo_up(bp)) = TFILE{ Fwrite: __ccgo_fp(X__stdio_write), Fbuf: fmt, Ffd: fd, @@ -140021,41 +140021,41 @@ type Targ = struct { func _pop_arg(tls *TLS, arg uintptr, type1 int32, ap uintptr) { switch type1 { case int32(_PTR): - *(*uintptr)(unsafe.Pointer(arg)) = VaUintptr(&*(*Tva_list)(unsafe.Pointer(ap))) + *(*uintptr)(unsafe.Pointer(arg)) = VaUintptr(&**(**Tva_list)(__ccgo_up(ap))) case int32(_INT): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_UINT): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint32(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint32(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_LONG): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_ULONG): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&**(**Tva_list)(__ccgo_up(ap))) case int32(_ULLONG): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_SHORT): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt16(int16(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt16(int16(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_USHORT): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint16FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint16FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_CHAR): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt8(int8(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt8(int8(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_UCHAR): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint8FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint8FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_LLONG): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_SIZET): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&**(**Tva_list)(__ccgo_up(ap))) case int32(_IMAX): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_UMAX): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&**(**Tva_list)(__ccgo_up(ap))) case int32(_PDIFF): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_UIPTR): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUintptr(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUintptr(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_DBL): - *(*float64)(unsafe.Pointer(arg)) = float64(VaFloat64(&*(*Tva_list)(unsafe.Pointer(ap)))) + *(*float64)(unsafe.Pointer(arg)) = float64(VaFloat64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_LDBL): - *(*float64)(unsafe.Pointer(arg)) = VaFloat64(&*(*Tva_list)(unsafe.Pointer(ap))) + *(*float64)(unsafe.Pointer(arg)) = VaFloat64(&**(**Tva_list)(__ccgo_up(ap))) } } @@ -140105,7 +140105,7 @@ func _fmt_x(tls *TLS, x Tuintmax_t, s uintptr, lower int32) (r uintptr) { } s = s - 1 v2 = s - *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(Int32FromUint8(_xdigits1[x&uint64(15)]) | lower) + **(**uint8)(__ccgo_up(v2)) = Uint8FromInt32(Int32FromUint8(_xdigits1[x&uint64(15)]) | lower) goto _1 _1: ; @@ -140123,7 +140123,7 @@ func _fmt_o(tls *TLS, x Tuintmax_t, s uintptr) (r uintptr) { } s = s - 1 v2 = s - *(*uint8)(unsafe.Pointer(v2)) = uint8(uint64('0') + x&uint64(7)) + **(**uint8)(__ccgo_up(v2)) = uint8(uint64('0') + x&uint64(7)) goto _1 _1: ; @@ -140142,7 +140142,7 @@ func _fmt_u(tls *TLS, x Tuintmax_t, s uintptr) (r uintptr) { } s = s - 1 v2 = s - *(*uint8)(unsafe.Pointer(v2)) = uint8(uint64('0') + x%uint64(10)) + **(**uint8)(__ccgo_up(v2)) = uint8(uint64('0') + x%uint64(10)) goto _1 _1: ; @@ -140155,7 +140155,7 @@ func _fmt_u(tls *TLS, x Tuintmax_t, s uintptr) (r uintptr) { } s = s - 1 v2 = s - *(*uint8)(unsafe.Pointer(v2)) = uint8(uint64('0') + y%uint64(10)) + **(**uint8)(__ccgo_up(v2)) = uint8(uint64('0') + y%uint64(10)) goto _3 _3: ; @@ -140190,7 +140190,7 @@ func _fmt_fp(tls *TLS, f uintptr, y float64, w int32, p int32, fl int32, t int32 var _ /* e2 at bp+512 */ int32 var _ /* ebuf0 at bp+538 */ [12]uint8 _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, b, carry, carry1, d, e, ebuf, estr, i, j, l, need, pl, prefix, r, re, rm, round, round1, s, s1, s2, s3, s4, sh, sh1, small, x, x1, x2, z, v1, v36, v37, v38, v5, v6, v7 - *(*int32)(unsafe.Pointer(bp + 512)) = 0 + **(**int32)(__ccgo_up(bp + 512)) = 0 prefix = __ccgo_ts + 1586 ebuf = bp + 538 + uintptr(Uint64FromInt32(3)*Uint64FromInt64(4)) pl = int32(1) @@ -140244,7 +140244,7 @@ _4: } y = float64(Xfrexpl(tls, y, bp+512) * Float64FromInt32(2)) if y != 0 { - *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) - 1 + **(**int32)(__ccgo_up(bp + 512)) = **(**int32)(__ccgo_up(bp + 512)) - 1 } if t|int32(32) == int32('a') { round = Float64FromFloat64(8) @@ -140267,7 +140267,7 @@ _4: } round = round * Float64FromInt32(16) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(prefix))) == int32('-') { + if Int32FromUint8(**(**uint8)(__ccgo_up(prefix))) == int32('-') { y = -y y = y - round y = y + round @@ -140277,39 +140277,39 @@ _4: y = y - round } } - if *(*int32)(unsafe.Pointer(bp + 512)) < 0 { - v7 = -*(*int32)(unsafe.Pointer(bp + 512)) + if **(**int32)(__ccgo_up(bp + 512)) < 0 { + v7 = -**(**int32)(__ccgo_up(bp + 512)) } else { - v7 = *(*int32)(unsafe.Pointer(bp + 512)) + v7 = **(**int32)(__ccgo_up(bp + 512)) } estr = _fmt_u(tls, Uint64FromInt32(v7), ebuf) if estr == ebuf { estr = estr - 1 v5 = estr - *(*uint8)(unsafe.Pointer(v5)) = uint8('0') + **(**uint8)(__ccgo_up(v5)) = uint8('0') } estr = estr - 1 v5 = estr - if *(*int32)(unsafe.Pointer(bp + 512)) < 0 { + if **(**int32)(__ccgo_up(bp + 512)) < 0 { v7 = int32('-') } else { v7 = int32('+') } - *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(v7) + **(**uint8)(__ccgo_up(v5)) = Uint8FromInt32(v7) estr = estr - 1 v5 = estr - *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(t + (Int32FromUint8('p') - Int32FromUint8('a'))) + **(**uint8)(__ccgo_up(v5)) = Uint8FromInt32(t + (Int32FromUint8('p') - Int32FromUint8('a'))) s = bp + 516 for cond := true; cond; cond = y != 0 { x = int32(y) v5 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(Int32FromUint8(_xdigits1[x]) | t&int32(32)) + **(**uint8)(__ccgo_up(v5)) = Uint8FromInt32(Int32FromUint8(_xdigits1[x]) | t&int32(32)) y = float64(Float64FromInt32(16) * (y - float64(x))) if int64(s)-t__predefined_ptrdiff_t(bp+516) == int64(1) && (y != 0 || p > 0 || Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0) { v5 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v5)) = uint8('.') + **(**uint8)(__ccgo_up(v5)) = uint8('.') } } if int64(p) > int64(Int32FromInt32(INT_MAX)-Int32FromInt32(2))-(int64(ebuf)-int64(estr))-int64(pl) { @@ -140339,9 +140339,9 @@ _4: } if y != 0 { y = y * Float64FromFloat64(2.68435456e+08) - *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) - int32(28) + **(**int32)(__ccgo_up(bp + 512)) = **(**int32)(__ccgo_up(bp + 512)) - int32(28) } - if *(*int32)(unsafe.Pointer(bp + 512)) < 0 { + if **(**int32)(__ccgo_up(bp + 512)) < 0 { v6 = bp + 8 z = v6 v5 = v6 @@ -140355,17 +140355,17 @@ _4: a = v5 } for cond := true; cond; cond = y != 0 { - *(*Tuint32_t)(unsafe.Pointer(z)) = uint32(y) + **(**Tuint32_t)(__ccgo_up(z)) = uint32(y) v5 = z z += 4 - y = float64(Float64FromInt32(1000000000) * (y - float64(*(*Tuint32_t)(unsafe.Pointer(v5))))) + y = float64(Float64FromInt32(1000000000) * (y - float64(**(**Tuint32_t)(__ccgo_up(v5))))) } - for *(*int32)(unsafe.Pointer(bp + 512)) > 0 { + for **(**int32)(__ccgo_up(bp + 512)) > 0 { carry = uint32(0) - if int32(29) < *(*int32)(unsafe.Pointer(bp + 512)) { + if int32(29) < **(**int32)(__ccgo_up(bp + 512)) { v7 = int32(29) } else { - v7 = *(*int32)(unsafe.Pointer(bp + 512)) + v7 = **(**int32)(__ccgo_up(bp + 512)) } sh = v7 d = z - uintptr(1)*4 @@ -140373,8 +140373,8 @@ _4: if !(d >= a) { break } - x1 = uint64(*(*Tuint32_t)(unsafe.Pointer(d)))< a && !(*(*Tuint32_t)(unsafe.Pointer(z + uintptr(-Int32FromInt32(1))*4)) != 0) { + for z > a && !(**(**Tuint32_t)(__ccgo_up(z + uintptr(-Int32FromInt32(1))*4)) != 0) { z -= 4 } - *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) - sh + **(**int32)(__ccgo_up(bp + 512)) = **(**int32)(__ccgo_up(bp + 512)) - sh } - for *(*int32)(unsafe.Pointer(bp + 512)) < 0 { + for **(**int32)(__ccgo_up(bp + 512)) < 0 { carry1 = uint32(0) - if int32(9) < -*(*int32)(unsafe.Pointer(bp + 512)) { + if int32(9) < -**(**int32)(__ccgo_up(bp + 512)) { v7 = int32(9) } else { - v7 = -*(*int32)(unsafe.Pointer(bp + 512)) + v7 = -**(**int32)(__ccgo_up(bp + 512)) } sh1 = v7 need = Int32FromUint32(uint32(1) + (Uint32FromInt32(p)+Uint32FromInt32(LDBL_MANT_DIG)/Uint32FromUint32(3)+uint32(8))/uint32(9)) @@ -140405,21 +140405,21 @@ _4: if !(d < z) { break } - rm = *(*Tuint32_t)(unsafe.Pointer(d)) & Uint32FromInt32(int32(1)<>sh1 + carry1 + rm = **(**Tuint32_t)(__ccgo_up(d)) & Uint32FromInt32(int32(1)<>sh1 + carry1 carry1 = Uint32FromInt32(Int32FromInt32(1000000000)>>sh1) * rm goto _26 _26: ; d += 4 } - if !(*(*Tuint32_t)(unsafe.Pointer(a)) != 0) { + if !(**(**Tuint32_t)(__ccgo_up(a)) != 0) { a += 4 } if carry1 != 0 { v5 = z z += 4 - *(*Tuint32_t)(unsafe.Pointer(v5)) = carry1 + **(**Tuint32_t)(__ccgo_up(v5)) = carry1 } /* Avoid (slow!) computation past requested precision */ if t|int32(32) == int32('f') { @@ -140431,13 +140431,13 @@ _4: if (int64(z)-int64(b))/4 > int64(need) { z = b + uintptr(need)*4 } - *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) + sh1 + **(**int32)(__ccgo_up(bp + 512)) = **(**int32)(__ccgo_up(bp + 512)) + sh1 } if a < z { i = int32(10) e = int32(Int64FromInt32(9) * ((int64(r) - int64(a)) / 4)) for { - if !(*(*Tuint32_t)(unsafe.Pointer(a)) >= Uint32FromInt32(i)) { + if !(**(**Tuint32_t)(__ccgo_up(a)) >= Uint32FromInt32(i)) { break } goto _29 @@ -140468,11 +140468,11 @@ _4: i = i * int32(10) j = j + 1 } - x2 = *(*Tuint32_t)(unsafe.Pointer(d)) % Uint32FromInt32(i) + x2 = **(**Tuint32_t)(__ccgo_up(d)) % Uint32FromInt32(i) /* Are there any significant digits past j? */ if x2 != 0 || d+uintptr(1)*4 != z { round1 = Float64FromInt32(2) / Float64FromFloat64(2.22044604925031308085e-16) - if *(*Tuint32_t)(unsafe.Pointer(d))/Uint32FromInt32(i)&uint32(1) != 0 || i == int32(1000000000) && d > a && *(*Tuint32_t)(unsafe.Pointer(d + uintptr(-Int32FromInt32(1))*4))&uint32(1) != 0 { + if **(**Tuint32_t)(__ccgo_up(d))/Uint32FromInt32(i)&uint32(1) != 0 || i == int32(1000000000) && d > a && **(**Tuint32_t)(__ccgo_up(d + uintptr(-Int32FromInt32(1))*4))&uint32(1) != 0 { round1 = round1 + Float64FromInt32(2) } if x2 < Uint32FromInt32(i/int32(2)) { @@ -140484,29 +140484,29 @@ _4: small = Float64FromFloat64(1.5) } } - if pl != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(prefix))) == int32('-') { + if pl != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(prefix))) == int32('-') { round1 = round1 * float64(-Int32FromInt32(1)) small = small * float64(-Int32FromInt32(1)) } - *(*Tuint32_t)(unsafe.Pointer(d)) -= x2 + **(**Tuint32_t)(__ccgo_up(d)) -= x2 /* Decide whether to round by probing round+small */ if round1+small != round1 { - *(*Tuint32_t)(unsafe.Pointer(d)) = *(*Tuint32_t)(unsafe.Pointer(d)) + Uint32FromInt32(i) - for *(*Tuint32_t)(unsafe.Pointer(d)) > uint32(999999999) { + **(**Tuint32_t)(__ccgo_up(d)) = **(**Tuint32_t)(__ccgo_up(d)) + Uint32FromInt32(i) + for **(**Tuint32_t)(__ccgo_up(d)) > uint32(999999999) { v5 = d d -= 4 - *(*Tuint32_t)(unsafe.Pointer(v5)) = uint32(0) + **(**Tuint32_t)(__ccgo_up(v5)) = uint32(0) if d < a { a -= 4 v5 = a - *(*Tuint32_t)(unsafe.Pointer(v5)) = uint32(0) + **(**Tuint32_t)(__ccgo_up(v5)) = uint32(0) } - *(*Tuint32_t)(unsafe.Pointer(d)) = *(*Tuint32_t)(unsafe.Pointer(d)) + 1 + **(**Tuint32_t)(__ccgo_up(d)) = **(**Tuint32_t)(__ccgo_up(d)) + 1 } i = int32(10) e = int32(Int64FromInt32(9) * ((int64(r) - int64(a)) / 4)) for { - if !(*(*Tuint32_t)(unsafe.Pointer(a)) >= Uint32FromInt32(i)) { + if !(**(**Tuint32_t)(__ccgo_up(a)) >= Uint32FromInt32(i)) { break } goto _33 @@ -140522,7 +140522,7 @@ _4: } } for { - if !(z > a && !(*(*Tuint32_t)(unsafe.Pointer(z + uintptr(-Int32FromInt32(1))*4)) != 0)) { + if !(z > a && !(**(**Tuint32_t)(__ccgo_up(z + uintptr(-Int32FromInt32(1))*4)) != 0)) { break } goto _34 @@ -140543,11 +140543,11 @@ _4: } if !(Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0) { /* Count trailing zeros in last place */ - if z > a && *(*Tuint32_t)(unsafe.Pointer(z + uintptr(-Int32FromInt32(1))*4)) != 0 { + if z > a && **(**Tuint32_t)(__ccgo_up(z + uintptr(-Int32FromInt32(1))*4)) != 0 { i = int32(10) j = Int32FromInt32(0) for { - if !(*(*Tuint32_t)(unsafe.Pointer(z + uintptr(-Int32FromInt32(1))*4))%Uint32FromInt32(i) == uint32(0)) { + if !(**(**Tuint32_t)(__ccgo_up(z + uintptr(-Int32FromInt32(1))*4))%Uint32FromInt32(i) == uint32(0)) { break } goto _35 @@ -140617,7 +140617,7 @@ _4: for int64(ebuf)-int64(estr) < int64(2) { estr = estr - 1 v5 = estr - *(*uint8)(unsafe.Pointer(v5)) = uint8('0') + **(**uint8)(__ccgo_up(v5)) = uint8('0') } estr = estr - 1 v5 = estr @@ -140626,10 +140626,10 @@ _4: } else { v7 = int32('+') } - *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(v7) + **(**uint8)(__ccgo_up(v5)) = Uint8FromInt32(v7) estr = estr - 1 v5 = estr - *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(t) + **(**uint8)(__ccgo_up(v5)) = Uint8FromInt32(t) if int64(ebuf)-int64(estr) > int64(int32(INT_MAX)-l) { return -int32(1) } @@ -140650,18 +140650,18 @@ _4: if !(d <= r) { break } - s2 = _fmt_u(tls, uint64(*(*Tuint32_t)(unsafe.Pointer(d))), bp+516+uintptr(9)) + s2 = _fmt_u(tls, uint64(**(**Tuint32_t)(__ccgo_up(d))), bp+516+uintptr(9)) if d != a { for s2 > bp+516 { s2 = s2 - 1 v5 = s2 - *(*uint8)(unsafe.Pointer(v5)) = uint8('0') + **(**uint8)(__ccgo_up(v5)) = uint8('0') } } else { if s2 == bp+516+uintptr(9) { s2 = s2 - 1 v5 = s2 - *(*uint8)(unsafe.Pointer(v5)) = uint8('0') + **(**uint8)(__ccgo_up(v5)) = uint8('0') } } _out(tls, f, s2, Uint64FromInt64(int64(bp+516+uintptr(9))-int64(s2))) @@ -140677,11 +140677,11 @@ _4: if !(d < z && p > 0) { break } - s3 = _fmt_u(tls, uint64(*(*Tuint32_t)(unsafe.Pointer(d))), bp+516+uintptr(9)) + s3 = _fmt_u(tls, uint64(**(**Tuint32_t)(__ccgo_up(d))), bp+516+uintptr(9)) for s3 > bp+516 { s3 = s3 - 1 v5 = s3 - *(*uint8)(unsafe.Pointer(v5)) = uint8('0') + **(**uint8)(__ccgo_up(v5)) = uint8('0') } if int32(9) < p { v7 = int32(9) @@ -140705,17 +140705,17 @@ _4: if !(d < z && p >= 0) { break } - s4 = _fmt_u(tls, uint64(*(*Tuint32_t)(unsafe.Pointer(d))), bp+516+uintptr(9)) + s4 = _fmt_u(tls, uint64(**(**Tuint32_t)(__ccgo_up(d))), bp+516+uintptr(9)) if s4 == bp+516+uintptr(9) { s4 = s4 - 1 v5 = s4 - *(*uint8)(unsafe.Pointer(v5)) = uint8('0') + **(**uint8)(__ccgo_up(v5)) = uint8('0') } if d != a { for s4 > bp+516 { s4 = s4 - 1 v5 = s4 - *(*uint8)(unsafe.Pointer(v5)) = uint8('0') + **(**uint8)(__ccgo_up(v5)) = uint8('0') } } else { v5 = s4 @@ -140754,18 +140754,18 @@ func _getint(tls *TLS, s uintptr) (r int32) { _ = i i = 0 for { - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-uint32('0') < uint32(10)) != 0) { break } - if Uint32FromInt32(i) > Uint32FromInt32(INT_MAX)/Uint32FromUint32(10) || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-int32('0') > int32(INT_MAX)-int32(10)*i { + if Uint32FromInt32(i) > Uint32FromInt32(INT_MAX)/Uint32FromUint32(10) || Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-int32('0') > int32(INT_MAX)-int32(10)*i { i = -int32(1) } else { - i = int32(10)*i + (Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s))))) - int32('0')) + i = int32(10)*i + (Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(s))))) - int32('0')) } goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s)) = *(*uintptr)(unsafe.Pointer(s)) + 1 + **(**uintptr)(__ccgo_up(s)) = **(**uintptr)(__ccgo_up(s)) + 1 } return i } @@ -140786,7 +140786,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, var _ /* s at bp+0 */ uintptr var _ /* wc at bp+40 */ [2]Twchar_t _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argpos, cnt, fl, i, l, l10n, p, pl, prefix, ps, st, t, w, ws, xp, z, v31, v34, v45, v5, v6, v8 - *(*uintptr)(unsafe.Pointer(bp)) = fmt + **(**uintptr)(__ccgo_up(bp)) = fmt l10n = uint32(0) cnt = 0 l = 0 @@ -140799,30 +140799,30 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } /* Update output count, end loop when fmt is exhausted */ cnt = cnt + l - if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) != 0) { + if !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))) != 0) { break } /* Handle literal text and %% format specifiers */ - a = *(*uintptr)(unsafe.Pointer(bp)) + a = **(**uintptr)(__ccgo_up(bp)) for { - if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32('%')) { + if !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) != int32('%')) { break } goto _2 _2: ; - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 } - z = *(*uintptr)(unsafe.Pointer(bp)) + z = **(**uintptr)(__ccgo_up(bp)) for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('%') && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1))) == int32('%')) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) == int32('%') && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1))) == int32('%')) { break } goto _3 _3: ; z = z + 1 - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(2) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + uintptr(2) } if int64(z)-int64(a) > int64(int32(INT_MAX)-cnt) { goto overflow @@ -140834,46 +140834,46 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if l != 0 { goto _1 } - if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2))) == int32('$') { + if BoolInt32(uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 2))) == int32('$') { l10n = uint32(1) - argpos = Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1))) - int32('0') - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(3) + argpos = Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1))) - int32('0') + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + uintptr(3) } else { argpos = -int32(1) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 } /* Read modifier flags */ fl = uint32(0) for { - if !(uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-uint32(' ') < uint32(32) && (Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('0')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('\'')-Int32FromUint8(' ')))&(uint32(1)<<(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-int32(' '))) != 0) { + if !(uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))))-uint32(' ') < uint32(32) && (Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('0')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('\'')-Int32FromUint8(' ')))&(uint32(1)<<(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))))-int32(' '))) != 0) { break } - fl = fl | uint32(1)<<(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-int32(' ')) + fl = fl | uint32(1)<<(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))))-int32(' ')) goto _4 _4: ; - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 } /* Read field width */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('*') { - if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2))) == int32('$') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) == int32('*') { + if BoolInt32(uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 2))) == int32('$') { l10n = uint32(1) if !(f != 0) { - *(*int32)(unsafe.Pointer(nl_type + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))-int32('0'))*4)) = int32(_INT) + **(**int32)(__ccgo_up(nl_type + uintptr(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1)))-int32('0'))*4)) = int32(_INT) w = Int32FromInt32(0) } else { - w = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))-int32('0'))*8))) + w = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1)))-int32('0'))*8))) } - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(3) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + uintptr(3) } else { if !(l10n != 0) { if f != 0 { - v5 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) + v5 = VaInt32(&**(**Tva_list)(__ccgo_up(ap))) } else { v5 = 0 } w = v5 - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 } else { goto inval } @@ -140890,32 +140890,32 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } } /* Read precision */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('.') && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1))) == int32('*') { - if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 3))) == int32('$') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) == int32('.') && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1))) == int32('*') { + if BoolInt32(uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 2)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 3))) == int32('$') { if !(f != 0) { - *(*int32)(unsafe.Pointer(nl_type + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2)))-int32('0'))*4)) = int32(_INT) + **(**int32)(__ccgo_up(nl_type + uintptr(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 2)))-int32('0'))*4)) = int32(_INT) p = Int32FromInt32(0) } else { - p = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2)))-int32('0'))*8))) + p = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 2)))-int32('0'))*8))) } - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(4) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + uintptr(4) } else { if !(l10n != 0) { if f != 0 { - v5 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) + v5 = VaInt32(&**(**Tva_list)(__ccgo_up(ap))) } else { v5 = 0 } p = v5 - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(2) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + uintptr(2) } else { goto inval } } xp = BoolInt32(p >= 0) } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('.') { - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) == int32('.') { + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 p = _getint(tls, bp) xp = int32(1) } else { @@ -140926,13 +140926,13 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, /* Format specifier state machine */ st = uint32(0) for cond := true; cond; cond = st-uint32(1) < uint32(_STOP) { - if uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-uint32('A') > Uint32FromInt32(Int32FromUint8('z')-Int32FromUint8('A')) { + if uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))))-uint32('A') > Uint32FromInt32(Int32FromUint8('z')-Int32FromUint8('A')) { goto inval } ps = st - v8 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - st = uint32(*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_states)) + uintptr(st)*58 + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(v8)))-int32('A'))))) + v8 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + st = uint32(**(**uint8)(__ccgo_up(uintptr(unsafe.Pointer(&_states)) + uintptr(st)*58 + uintptr(Int32FromUint8(**(**uint8)(__ccgo_up(v8)))-int32('A'))))) } if !(st != 0) { goto inval @@ -140945,9 +140945,9 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } else { if argpos >= 0 { if !(f != 0) { - *(*int32)(unsafe.Pointer(nl_type + uintptr(argpos)*4)) = Int32FromUint32(st) + **(**int32)(__ccgo_up(nl_type + uintptr(argpos)*4)) = Int32FromUint32(st) } else { - *(*Targ)(unsafe.Pointer(bp + 8)) = *(*Targ)(unsafe.Pointer(nl_arg + uintptr(argpos)*8)) + **(**Targ)(__ccgo_up(bp + 8)) = **(**Targ)(__ccgo_up(nl_arg + uintptr(argpos)*8)) } } else { if f != 0 { @@ -140967,7 +140967,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, z = bp + 16 + uintptr(24) prefix = __ccgo_ts + 1617 pl = 0 - t = Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + uintptr(-Int32FromInt32(1))))) + t = Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + uintptr(-Int32FromInt32(1))))) /* Transform ls,lc -> S,C */ if ps != 0 && t&int32(15) == int32(3) { t = t & ^Int32FromInt32(32) @@ -141025,19 +141025,19 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, ; switch ps { case uint32(_BARE): - *(*int32)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) = cnt + **(**int32)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 8)))) = cnt case uint32(_LPRE): - *(*int64)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) = int64(cnt) + **(**int64)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 8)))) = int64(cnt) case uint32(_LLPRE): - *(*int64)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) = int64(cnt) + **(**int64)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 8)))) = int64(cnt) case uint32(_HPRE): - *(*uint16)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) = Uint16FromInt32(cnt) + **(**uint16)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 8)))) = Uint16FromInt32(cnt) case uint32(_HHPRE): - *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) = Uint8FromInt32(cnt) + **(**uint8)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 8)))) = Uint8FromInt32(cnt) case uint32(_ZTPRE): - *(*Tsize_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) = Uint64FromInt32(cnt) + **(**Tsize_t)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 8)))) = Uint64FromInt32(cnt) case uint32(_JPRE): - *(*Tuintmax_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) = Uint64FromInt32(cnt) + **(**Tuintmax_t)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 8)))) = Uint64FromInt32(cnt) break } goto _1 @@ -141123,7 +141123,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, p = v5 v8 = z - uintptr(v5) a = v8 - *(*uint8)(unsafe.Pointer(v8)) = uint8(*(*Tuintmax_t)(unsafe.Pointer(bp + 8))) + **(**uint8)(__ccgo_up(v8)) = uint8(*(*Tuintmax_t)(unsafe.Pointer(bp + 8))) fl = fl & ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) goto _30 _19: @@ -141131,7 +141131,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if !(int32(1) != 0) { goto _37 } - a = Xstrerror(tls, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) + a = Xstrerror(tls, **(**int32)(__ccgo_up(X__errno_location(tls)))) goto _38 _37: ; @@ -141151,7 +141151,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, v5 = p } z = a + uintptr(Xstrnlen(tls, a, Uint64FromInt32(v5))) - if p < 0 && *(*uint8)(unsafe.Pointer(z)) != 0 { + if p < 0 && **(**uint8)(__ccgo_up(z)) != 0 { goto overflow } p = int32(int64(z) - int64(a)) @@ -141162,8 +141162,8 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if !(*(*Tuintmax_t)(unsafe.Pointer(bp + 8)) != 0) { goto narrow_c } - (*(*[2]Twchar_t)(unsafe.Pointer(bp + 40)))[0] = uint32(*(*Tuintmax_t)(unsafe.Pointer(bp + 8))) - (*(*[2]Twchar_t)(unsafe.Pointer(bp + 40)))[int32(1)] = uint32(0) + (**(**[2]Twchar_t)(__ccgo_up(bp + 40)))[0] = uint32(*(*Tuintmax_t)(unsafe.Pointer(bp + 8))) + (**(**[2]Twchar_t)(__ccgo_up(bp + 40)))[int32(1)] = uint32(0) *(*uintptr)(unsafe.Pointer(bp + 8)) = bp + 40 p = -int32(1) _21: @@ -141173,10 +141173,10 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, l = v5 i = Uint64FromInt32(v5) for { - if v45 = i < Uint64FromInt32(p) && *(*Twchar_t)(unsafe.Pointer(ws)) != 0; v45 { + if v45 = i < Uint64FromInt32(p) && **(**Twchar_t)(__ccgo_up(ws)) != 0; v45 { v8 = ws ws += 4 - v6 = Xwctomb(tls, bp+48, *(*Twchar_t)(unsafe.Pointer(v8))) + v6 = Xwctomb(tls, bp+48, **(**Twchar_t)(__ccgo_up(v8))) l = v6 } if !(v45 && v6 >= 0 && Uint64FromInt32(l) <= Uint64FromInt32(p)-i) { @@ -141198,10 +141198,10 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, ws = *(*uintptr)(unsafe.Pointer(bp + 8)) i = uint64(0) for { - if v45 = i < uint64(0+Uint32FromInt32(p)) && *(*Twchar_t)(unsafe.Pointer(ws)) != 0; v45 { + if v45 = i < uint64(0+Uint32FromInt32(p)) && **(**Twchar_t)(__ccgo_up(ws)) != 0; v45 { v8 = ws ws += 4 - v5 = Xwctomb(tls, bp+48, *(*Twchar_t)(unsafe.Pointer(v8))) + v5 = Xwctomb(tls, bp+48, **(**Twchar_t)(__ccgo_up(v8))) l = v5 } if !(v45 && i+Uint64FromInt32(v5) <= Uint64FromInt32(p)) { @@ -141277,17 +141277,17 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } i = uint64(1) for { - if !(i <= uint64(NL_ARGMAX) && *(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)) != 0) { + if !(i <= uint64(NL_ARGMAX) && **(**int32)(__ccgo_up(nl_type + uintptr(i)*4)) != 0) { break } - _pop_arg(tls, nl_arg+uintptr(i)*8, *(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)), ap) + _pop_arg(tls, nl_arg+uintptr(i)*8, **(**int32)(__ccgo_up(nl_type + uintptr(i)*4)), ap) goto _51 _51: ; i = i + 1 } for { - if !(i <= uint64(NL_ARGMAX) && !(*(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)) != 0)) { + if !(i <= uint64(NL_ARGMAX) && !(**(**int32)(__ccgo_up(nl_type + uintptr(i)*4)) != 0)) { break } goto _52 @@ -141302,12 +141302,12 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto inval inval: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) goto overflow overflow: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return -int32(1) } @@ -141325,12 +141325,12 @@ func Xvfprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { var _ /* nl_arg at bp+48 */ [10]Targ var _ /* nl_type at bp+8 */ [10]int32 _, _, _, _, _, _, _ = __need_unlock, olderr, ret, saved_buf, v1, v2, v3 - *(*[10]int32)(unsafe.Pointer(bp + 8)) = [10]int32{} + **(**[10]int32)(__ccgo_up(bp + 8)) = [10]int32{} saved_buf = uintptr(0) /* the copy allows passing va_list* even if va_list is an array */ - *(*Tva_list)(unsafe.Pointer(bp)) = ap + **(**Tva_list)(__ccgo_up(bp)) = ap if _printf_core(tls, uintptr(0), fmt, bp, bp+48, bp+8) < 0 { - _ = *(*Tva_list)(unsafe.Pointer(bp)) + _ = **(**Tva_list)(__ccgo_up(bp)) return -int32(1) } if AtomicLoadPInt32(f+140) >= 0 { @@ -141340,7 +141340,7 @@ func Xvfprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } __need_unlock = v1 olderr = Int32FromUint32((*TFILE)(unsafe.Pointer(f)).Fflags & uint32(F_ERR)) - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_ERR)) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^Int32FromInt32(F_ERR)) if !((*TFILE)(unsafe.Pointer(f)).Fbuf_size != 0) { saved_buf = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Fbuf = bp + 128 @@ -141372,11 +141372,11 @@ func Xvfprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_ERR) != 0 { ret = -int32(1) } - *(*uint32)(unsafe.Pointer(f)) |= Uint32FromInt32(olderr) + **(**uint32)(__ccgo_up(f)) |= Uint32FromInt32(olderr) if __need_unlock != 0 { ___unlockfile(tls, f) } - _ = *(*Tva_list)(unsafe.Pointer(bp)) + _ = **(**Tva_list)(__ccgo_up(bp)) return ret } @@ -141393,15 +141393,15 @@ func _store_int(tls *TLS, dest uintptr, size int32, i uint64) { } switch size { case -int32(2): - *(*uint8)(unsafe.Pointer(dest)) = uint8(i) + **(**uint8)(__ccgo_up(dest)) = uint8(i) case -int32(1): - *(*int16)(unsafe.Pointer(dest)) = Int16FromUint64(i) + **(**int16)(__ccgo_up(dest)) = Int16FromUint64(i) case SIZE_def: - *(*int32)(unsafe.Pointer(dest)) = Int32FromUint64(i) + **(**int32)(__ccgo_up(dest)) = Int32FromUint64(i) case int32(SIZE_l): - *(*int64)(unsafe.Pointer(dest)) = Int64FromUint64(i) + **(**int64)(__ccgo_up(dest)) = Int64FromUint64(i) case int32(SIZE_ll): - *(*int64)(unsafe.Pointer(dest)) = Int64FromUint64(i) + **(**int64)(__ccgo_up(dest)) = Int64FromUint64(i) break } } @@ -141464,17 +141464,17 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } p = fmt for { - if !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if !(**(**uint8)(__ccgo_up(p)) != 0) { break } alloc = 0 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v3 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _5 _5: if v3 != 0 { for { - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) v6 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _8 _8: @@ -141489,7 +141489,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v1 = X__shgetc(tls, f) } @@ -141507,16 +141507,16 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { pos = pos + ((*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf))) goto _2 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32('%') || Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('%') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) != int32('%') || Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) == int32('%') { X__shlim(tls, f, int64(Int32FromInt32(0))) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('%') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('%') { p = p + 1 for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v3 = X__shgetc(tls, f) } @@ -141535,13 +141535,13 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v1 = X__shgetc(tls, f) } c = v1 } - if c != Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) { + if c != Int32FromUint8(**(**uint8)(__ccgo_up(p))) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } @@ -141554,12 +141554,12 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { goto _2 } p = p + 1 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('*') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('*') { dest = uintptr(0) p = p + 1 } else { - if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('$') { - dest = _arg_n(tls, ap, Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))-int32('0'))) + if BoolInt32(uint32(**(**uint8)(__ccgo_up(p)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) == int32('$') { + dest = _arg_n(tls, ap, Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(p)))-int32('0'))) p = p + uintptr(2) } else { dest = VaUintptr(&ap) @@ -141567,16 +141567,16 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } width = 0 for { - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p)))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(p)))-uint32('0') < uint32(10)) != 0) { break } - width = int32(10)*width + Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - int32('0') + width = int32(10)*width + Int32FromUint8(**(**uint8)(__ccgo_up(p))) - int32('0') goto _25 _25: ; p = p + 1 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('m') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('m') { wcs = uintptr(0) s = uintptr(0) alloc = BoolInt32(!!(dest != 0)) @@ -141587,16 +141587,16 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { size = SIZE_def v10 = p p = p + 1 - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(v10))) { case int32('h'): - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('h') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('h') { p = p + 1 size = -Int32FromInt32(2) } else { size = -int32(1) } case int32('l'): - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('l') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('l') { p = p + 1 size = Int32FromInt32(SIZE_ll) } else { @@ -141655,7 +141655,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { default: goto fmt_fail } - t = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + t = Int32FromUint8(**(**uint8)(__ccgo_up(p))) /* C or S */ if t&int32(0x2f) == int32(3) { t = t | int32(32) @@ -141679,7 +141679,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v1 = X__shgetc(tls, f) } @@ -141701,7 +141701,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v1 = X__shgetc(tls, f) } @@ -141758,58 +141758,58 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { ; if t == int32('c') || t == int32('s') { Xmemset(tls, bp+16, -int32(1), uint64(257)) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[0] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[0] = uint8(0) if t == int32('s') { - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\t')] = uint8(0) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\n')] = uint8(0) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\v')] = uint8(0) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\f')] = uint8(0) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\r')] = uint8(0) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8(' ')] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\t')] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\n')] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\v')] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\f')] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\r')] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8(' ')] = uint8(0) } } else { p = p + 1 v10 = p - if Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) == int32('^') { + if Int32FromUint8(**(**uint8)(__ccgo_up(v10))) == int32('^') { p = p + 1 invert = Int32FromInt32(1) } else { invert = 0 } Xmemset(tls, bp+16, invert, uint64(257)) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[0] = uint8(0) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') { + (**(**[257]uint8)(__ccgo_up(bp + 16)))[0] = uint8(0) + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('-') { p = p + 1 - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('-')] = Uint8FromInt32(Int32FromInt32(1) - invert) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('-')] = Uint8FromInt32(Int32FromInt32(1) - invert) } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32(']') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32(']') { p = p + 1 - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8(']')] = Uint8FromInt32(Int32FromInt32(1) - invert) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8(']')] = Uint8FromInt32(Int32FromInt32(1) - invert) } } for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32(']')) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(p))) != int32(']')) { break } - if !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if !(**(**uint8)(__ccgo_up(p)) != 0) { goto fmt_fail } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') && *(*uint8)(unsafe.Pointer(p + 1)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) != int32(']') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('-') && **(**uint8)(__ccgo_up(p + 1)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) != int32(']') { v10 = p p = p + 1 - c = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10 + uintptr(-Int32FromInt32(1))))) + c = Int32FromUint8(**(**uint8)(__ccgo_up(v10 + uintptr(-Int32FromInt32(1))))) for { - if !(c < Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))) { + if !(c < Int32FromUint8(**(**uint8)(__ccgo_up(p)))) { break } - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[int32(1)+c] = Uint8FromInt32(int32(1) - invert) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[int32(1)+c] = Uint8FromInt32(int32(1) - invert) goto _57 _57: ; c = c + 1 } } - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[int32(1)+Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))] = Uint8FromInt32(int32(1) - invert) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[int32(1)+Int32FromUint8(**(**uint8)(__ccgo_up(p)))] = Uint8FromInt32(int32(1) - invert) goto _56 _56: ; @@ -141834,19 +141834,19 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } else { wcs = dest } - *(*Tmbstate_t)(unsafe.Pointer(bp + 8)) = Tmbstate_t{} + **(**Tmbstate_t)(__ccgo_up(bp + 8)) = Tmbstate_t{} for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v3 = X__shgetc(tls, f) } v1 = v3 c = v1 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { + if !((**(**[257]uint8)(__ccgo_up(bp + 16)))[v1+int32(1)] != 0) { break } *(*uint8)(unsafe.Pointer(bp)) = Uint8FromInt32(c) @@ -141859,7 +141859,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if wcs != 0 { v64 = i i = i + 1 - *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(v64)*4)) = *(*Twchar_t)(unsafe.Pointer(bp + 276)) + **(**Twchar_t)(__ccgo_up(wcs + uintptr(v64)*4)) = **(**Twchar_t)(__ccgo_up(bp + 276)) } if alloc != 0 && i == k { k = k + (k + uint64(1)) @@ -141884,18 +141884,18 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v3 = X__shgetc(tls, f) } v1 = v3 c = v1 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { + if !((**(**[257]uint8)(__ccgo_up(bp + 16)))[v1+int32(1)] != 0) { break } v64 = i i = i + 1 - *(*uint8)(unsafe.Pointer(s + uintptr(v64))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + uintptr(v64))) = Uint8FromInt32(c) if i == k { k = k + (k + uint64(1)) tmp1 = Xrealloc(tls, s, k) @@ -141914,18 +141914,18 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v17 = f + 8 v11 = *(*uintptr)(unsafe.Pointer(v17)) *(*uintptr)(unsafe.Pointer(v17)) = *(*uintptr)(unsafe.Pointer(v17)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v11))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v11))) } else { v3 = X__shgetc(tls, f) } v1 = v3 c = v1 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { + if !((**(**[257]uint8)(__ccgo_up(bp + 16)))[v1+int32(1)] != 0) { break } v64 = i i = i + 1 - *(*uint8)(unsafe.Pointer(s + uintptr(v64))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + uintptr(v64))) = Uint8FromInt32(c) } } else { for { @@ -141933,13 +141933,13 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v3 = X__shgetc(tls, f) } v1 = v3 c = v1 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { + if !((**(**[257]uint8)(__ccgo_up(bp + 16)))[v1+int32(1)] != 0) { break } } @@ -141957,17 +141957,17 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } if alloc != 0 { if size == int32(SIZE_l) { - *(*uintptr)(unsafe.Pointer(dest)) = wcs + **(**uintptr)(__ccgo_up(dest)) = wcs } else { - *(*uintptr)(unsafe.Pointer(dest)) = s + **(**uintptr)(__ccgo_up(dest)) = s } } if t != int32('c') { if wcs != 0 { - *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) = uint32(0) + **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) = uint32(0) } if s != 0 { - *(*uint8)(unsafe.Pointer(s + uintptr(i))) = uint8(0) + **(**uint8)(__ccgo_up(s + uintptr(i))) = uint8(0) } } goto _54 @@ -142000,7 +142000,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { goto match_fail } if t == int32('p') && dest != 0 { - *(*uintptr)(unsafe.Pointer(dest)) = uintptr(x) + **(**uintptr)(__ccgo_up(dest)) = uintptr(x) } else { _store_int(tls, dest, size, x) } @@ -142028,11 +142028,11 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if dest != 0 { switch size { case SIZE_def: - *(*float32)(unsafe.Pointer(dest)) = float32(y) + **(**float32)(__ccgo_up(dest)) = float32(y) case int32(SIZE_l): - *(*float64)(unsafe.Pointer(dest)) = y + **(**float64)(__ccgo_up(dest)) = y case int32(SIZE_L): - *(*float64)(unsafe.Pointer(dest)) = y + **(**float64)(__ccgo_up(dest)) = y break } } @@ -142198,41 +142198,41 @@ var _states1 = [8][58]uint8{ func _pop_arg1(tls *TLS, arg uintptr, type1 int32, ap uintptr) { switch type1 { case int32(_PTR): - *(*uintptr)(unsafe.Pointer(arg)) = VaUintptr(&*(*Tva_list)(unsafe.Pointer(ap))) + *(*uintptr)(unsafe.Pointer(arg)) = VaUintptr(&**(**Tva_list)(__ccgo_up(ap))) case int32(_INT): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_UINT): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint32(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint32(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_LONG): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_ULONG): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&**(**Tva_list)(__ccgo_up(ap))) case int32(_ULLONG): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_SHORT): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt16(int16(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt16(int16(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_USHORT): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint16FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint16FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_CHAR): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt8(int8(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt8(int8(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_UCHAR): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint8FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint8FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_LLONG): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_SIZET): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&**(**Tva_list)(__ccgo_up(ap))) case int32(_IMAX): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_UMAX): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&**(**Tva_list)(__ccgo_up(ap))) case int32(_PDIFF): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_UIPTR): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUintptr(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUintptr(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_DBL): - *(*float64)(unsafe.Pointer(arg)) = float64(VaFloat64(&*(*Tva_list)(unsafe.Pointer(ap)))) + *(*float64)(unsafe.Pointer(arg)) = float64(VaFloat64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_LDBL): - *(*float64)(unsafe.Pointer(arg)) = VaFloat64(&*(*Tva_list)(unsafe.Pointer(ap))) + *(*float64)(unsafe.Pointer(arg)) = VaFloat64(&**(**Tva_list)(__ccgo_up(ap))) } } @@ -142248,7 +142248,7 @@ func _out1(tls *TLS, f uintptr, s uintptr, l Tsize_t) { } v2 = s s += 4 - Xfputwc(tls, *(*Twchar_t)(unsafe.Pointer(v2)), f) + Xfputwc(tls, **(**Twchar_t)(__ccgo_up(v2)), f) } } @@ -142266,18 +142266,18 @@ func _getint1(tls *TLS, s uintptr) (r int32) { _ = i i = 0 for { - if !(BoolInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s))))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(s))))-uint32('0') < uint32(10)) != 0) { break } - if Uint32FromInt32(i) > Uint32FromInt32(INT_MAX)/Uint32FromUint32(10) || *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s))))-uint32('0') > Uint32FromInt32(int32(INT_MAX)-int32(10)*i) { + if Uint32FromInt32(i) > Uint32FromInt32(INT_MAX)/Uint32FromUint32(10) || **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(s))))-uint32('0') > Uint32FromInt32(int32(INT_MAX)-int32(10)*i) { i = -int32(1) } else { - i = Int32FromUint32(Uint32FromInt32(int32(10)*i) + (*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))) - uint32('0'))) + i = Int32FromUint32(Uint32FromInt32(int32(10)*i) + (**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))) - uint32('0'))) } goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s)) += 4 + **(**uintptr)(__ccgo_up(s)) += 4 } return i } @@ -142308,7 +142308,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, var _ /* s at bp+8 */ uintptr var _ /* wc at bp+40 */ Twchar_t _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argpos, bs, cnt, fl, i, l, l10n, p, ps, st, t, w, xp, z, v15, v5, v6, v7, v8, v9 - *(*uintptr)(unsafe.Pointer(bp + 8)) = fmt + **(**uintptr)(__ccgo_up(bp + 8)) = fmt l10n = uint32(0) cnt = 0 l = 0 @@ -142321,30 +142321,30 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } /* Update output count, end loop when fmt is exhausted */ cnt = cnt + l - if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) != 0) { + if !(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) != 0) { break } /* Handle literal text and %% format specifiers */ - a = *(*uintptr)(unsafe.Pointer(bp + 8)) + a = **(**uintptr)(__ccgo_up(bp + 8)) for { - if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) != 0 && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) != uint32('%')) { + if !(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) != 0 && **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) != uint32('%')) { break } goto _2 _2: ; - *(*uintptr)(unsafe.Pointer(bp + 8)) += 4 + **(**uintptr)(__ccgo_up(bp + 8)) += 4 } - z = *(*uintptr)(unsafe.Pointer(bp + 8)) + z = **(**uintptr)(__ccgo_up(bp + 8)) for { - if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) == uint32('%') && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4)) == uint32('%')) { + if !(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) == uint32('%') && **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 1*4)) == uint32('%')) { break } goto _3 _3: ; z += 4 - *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(2)*4 + **(**uintptr)(__ccgo_up(bp + 8)) = **(**uintptr)(__ccgo_up(bp + 8)) + uintptr(2)*4 } if (int64(z)-int64(a))/4 > int64(int32(INT_MAX)-cnt) { goto overflow @@ -142356,42 +142356,42 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if l != 0 { goto _1 } - if BoolInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4)) == uint32('$') { + if BoolInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 1*4))-uint32('0') < uint32(10)) != 0 && **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 2*4)) == uint32('$') { l10n = uint32(1) - argpos = Int32FromUint32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4)) - uint32('0')) - *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(3)*4 + argpos = Int32FromUint32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 1*4)) - uint32('0')) + **(**uintptr)(__ccgo_up(bp + 8)) = **(**uintptr)(__ccgo_up(bp + 8)) + uintptr(3)*4 } else { argpos = -int32(1) - *(*uintptr)(unsafe.Pointer(bp + 8)) += 4 + **(**uintptr)(__ccgo_up(bp + 8)) += 4 } /* Read modifier flags */ fl = uint32(0) for { - if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8))))-uint32(' ') < uint32(32) && (Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('0')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('\'')-Int32FromUint8(' ')))&(uint32(1)<<(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8))))-uint32(' '))) != 0) { + if !(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8))))-uint32(' ') < uint32(32) && (Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('0')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('\'')-Int32FromUint8(' ')))&(uint32(1)<<(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8))))-uint32(' '))) != 0) { break } - fl = fl | uint32(1)<<(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8))))-uint32(' ')) + fl = fl | uint32(1)<<(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8))))-uint32(' ')) goto _4 _4: ; - *(*uintptr)(unsafe.Pointer(bp + 8)) += 4 + **(**uintptr)(__ccgo_up(bp + 8)) += 4 } /* Read field width */ - if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) == uint32('*') { - if BoolInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4)) == uint32('$') { + if **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) == uint32('*') { + if BoolInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 1*4))-uint32('0') < uint32(10)) != 0 && **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 2*4)) == uint32('$') { l10n = uint32(1) - *(*int32)(unsafe.Pointer(nl_type + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4))-uint32('0'))*4)) = int32(_INT) - w = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4))-uint32('0'))*8))) - *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(3)*4 + **(**int32)(__ccgo_up(nl_type + uintptr(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 1*4))-uint32('0'))*4)) = int32(_INT) + w = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 1*4))-uint32('0'))*8))) + **(**uintptr)(__ccgo_up(bp + 8)) = **(**uintptr)(__ccgo_up(bp + 8)) + uintptr(3)*4 } else { if !(l10n != 0) { if f != 0 { - v5 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) + v5 = VaInt32(&**(**Tva_list)(__ccgo_up(ap))) } else { v5 = 0 } w = v5 - *(*uintptr)(unsafe.Pointer(bp + 8)) += 4 + **(**uintptr)(__ccgo_up(bp + 8)) += 4 } else { goto inval } @@ -142408,28 +142408,28 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } } /* Read precision */ - if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) == uint32('.') && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4)) == uint32('*') { - if BoolInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 3*4)) == uint32('$') { - *(*int32)(unsafe.Pointer(nl_type + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4))-uint32('0'))*4)) = int32(_INT) - p = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4))-uint32('0'))*8))) - *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(4)*4 + if **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) == uint32('.') && **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 1*4)) == uint32('*') { + if BoolInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 2*4))-uint32('0') < uint32(10)) != 0 && **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 3*4)) == uint32('$') { + **(**int32)(__ccgo_up(nl_type + uintptr(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 2*4))-uint32('0'))*4)) = int32(_INT) + p = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 2*4))-uint32('0'))*8))) + **(**uintptr)(__ccgo_up(bp + 8)) = **(**uintptr)(__ccgo_up(bp + 8)) + uintptr(4)*4 } else { if !(l10n != 0) { if f != 0 { - v5 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) + v5 = VaInt32(&**(**Tva_list)(__ccgo_up(ap))) } else { v5 = 0 } p = v5 - *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(2)*4 + **(**uintptr)(__ccgo_up(bp + 8)) = **(**uintptr)(__ccgo_up(bp + 8)) + uintptr(2)*4 } else { goto inval } } xp = BoolInt32(p >= 0) } else { - if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) == uint32('.') { - *(*uintptr)(unsafe.Pointer(bp + 8)) += 4 + if **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) == uint32('.') { + **(**uintptr)(__ccgo_up(bp + 8)) += 4 p = _getint1(tls, bp+8) xp = int32(1) } else { @@ -142440,13 +142440,13 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, /* Format specifier state machine */ st = uint32(0) for cond := true; cond; cond = st-uint32(1) < uint32(_STOP) { - if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8))))-uint32('A') > Uint32FromInt32(Int32FromUint8('z')-Int32FromUint8('A')) { + if **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8))))-uint32('A') > Uint32FromInt32(Int32FromUint8('z')-Int32FromUint8('A')) { goto inval } ps = st - v8 = *(*uintptr)(unsafe.Pointer(bp + 8)) - *(*uintptr)(unsafe.Pointer(bp + 8)) += 4 - st = uint32(*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_states1)) + uintptr(st)*58 + uintptr(*(*Twchar_t)(unsafe.Pointer(v8))-uint32('A'))))) + v8 = **(**uintptr)(__ccgo_up(bp + 8)) + **(**uintptr)(__ccgo_up(bp + 8)) += 4 + st = uint32(**(**uint8)(__ccgo_up(uintptr(unsafe.Pointer(&_states1)) + uintptr(st)*58 + uintptr(**(**Twchar_t)(__ccgo_up(v8))-uint32('A'))))) } if !(st != 0) { goto inval @@ -142458,8 +142458,8 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } } else { if argpos >= 0 { - *(*int32)(unsafe.Pointer(nl_type + uintptr(argpos)*4)) = Int32FromUint32(st) - *(*Targ)(unsafe.Pointer(bp + 16)) = *(*Targ)(unsafe.Pointer(nl_arg + uintptr(argpos)*8)) + **(**int32)(__ccgo_up(nl_type + uintptr(argpos)*4)) = Int32FromUint32(st) + **(**Targ)(__ccgo_up(bp + 16)) = **(**Targ)(__ccgo_up(nl_arg + uintptr(argpos)*8)) } else { if f != 0 { _pop_arg1(tls, bp+16, Int32FromUint32(st), ap) @@ -142475,7 +142475,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_ERR) != 0 { return -int32(1) } - t = Int32FromUint32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(-Int32FromInt32(1))*4))) + t = Int32FromUint32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + uintptr(-Int32FromInt32(1))*4))) if ps != 0 && t&int32(15) == int32(3) { t = t & ^Int32FromInt32(32) } @@ -142483,19 +142483,19 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, case int32('n'): switch ps { case uint32(_BARE): - *(*int32)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))) = cnt + **(**int32)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 16)))) = cnt case uint32(_LPRE): - *(*int64)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))) = int64(cnt) + **(**int64)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 16)))) = int64(cnt) case uint32(_LLPRE): - *(*int64)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))) = int64(cnt) + **(**int64)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 16)))) = int64(cnt) case uint32(_HPRE): - *(*uint16)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))) = Uint16FromInt32(cnt) + **(**uint16)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 16)))) = Uint16FromInt32(cnt) case uint32(_HHPRE): - *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))) = Uint8FromInt32(cnt) + **(**uint8)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 16)))) = Uint8FromInt32(cnt) case uint32(_ZTPRE): - *(*Tsize_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))) = Uint64FromInt32(cnt) + **(**Tsize_t)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 16)))) = Uint64FromInt32(cnt) case uint32(_JPRE): - *(*Tuintmax_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))) = Uint64FromInt32(cnt) + **(**Tuintmax_t)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 16)))) = Uint64FromInt32(cnt) break } goto _1 @@ -142524,7 +142524,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, v5 = p } z = a + uintptr(Xwcsnlen(tls, a, Uint64FromInt32(v5)))*4 - if p < 0 && *(*Twchar_t)(unsafe.Pointer(z)) != 0 { + if p < 0 && **(**Twchar_t)(__ccgo_up(z)) != 0 { goto overflow } p = int32((int64(z) - int64(a)) / 4) @@ -142537,7 +142537,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, l = w goto _1 case int32('m'): - *(*uintptr)(unsafe.Pointer(bp + 16)) = Xstrerror(tls, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) + *(*uintptr)(unsafe.Pointer(bp + 16)) = Xstrerror(tls, **(**int32)(__ccgo_up(X__errno_location(tls)))) fallthrough case int32('s'): if !(*(*uintptr)(unsafe.Pointer(bp + 16)) != 0) { @@ -142569,7 +142569,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if i < 0 { return -int32(1) } - if p < 0 && *(*uint8)(unsafe.Pointer(bs)) != 0 { + if p < 0 && **(**uint8)(__ccgo_up(bs)) != 0 { goto overflow } p = l @@ -142630,17 +142630,17 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } i = int32(1) for { - if !(i <= int32(NL_ARGMAX) && *(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)) != 0) { + if !(i <= int32(NL_ARGMAX) && **(**int32)(__ccgo_up(nl_type + uintptr(i)*4)) != 0) { break } - _pop_arg1(tls, nl_arg+uintptr(i)*8, *(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)), ap) + _pop_arg1(tls, nl_arg+uintptr(i)*8, **(**int32)(__ccgo_up(nl_type + uintptr(i)*4)), ap) goto _17 _17: ; i = i + 1 } for { - if !(i <= int32(NL_ARGMAX) && !(*(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)) != 0)) { + if !(i <= int32(NL_ARGMAX) && !(**(**int32)(__ccgo_up(nl_type + uintptr(i)*4)) != 0)) { break } goto _18 @@ -142655,12 +142655,12 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto inval inval: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) goto overflow overflow: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return -int32(1) } @@ -142676,11 +142676,11 @@ func Xvfwprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { var _ /* nl_arg at bp+48 */ [10]Targ var _ /* nl_type at bp+8 */ [10]int32 _, _, _, _ = __need_unlock, olderr, ret, v1 - *(*[10]int32)(unsafe.Pointer(bp + 8)) = [10]int32{} + **(**[10]int32)(__ccgo_up(bp + 8)) = [10]int32{} /* the copy allows passing va_list* even if va_list is an array */ - *(*Tva_list)(unsafe.Pointer(bp)) = ap + **(**Tva_list)(__ccgo_up(bp)) = ap if _wprintf_core(tls, uintptr(0), fmt, bp, bp+48, bp+8) < 0 { - _ = *(*Tva_list)(unsafe.Pointer(bp)) + _ = **(**Tva_list)(__ccgo_up(bp)) return -int32(1) } if AtomicLoadPInt32(f+140) >= 0 { @@ -142691,16 +142691,16 @@ func Xvfwprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { __need_unlock = v1 Xfwide(tls, f, int32(1)) olderr = Int32FromUint32((*TFILE)(unsafe.Pointer(f)).Fflags & uint32(F_ERR)) - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_ERR)) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^Int32FromInt32(F_ERR)) ret = _wprintf_core(tls, f, fmt, bp, bp+48, bp+8) if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_ERR) != 0 { ret = -int32(1) } - *(*uint32)(unsafe.Pointer(f)) |= Uint32FromInt32(olderr) + **(**uint32)(__ccgo_up(f)) |= Uint32FromInt32(olderr) if __need_unlock != 0 { ___unlockfile(tls, f) } - _ = *(*Tva_list)(unsafe.Pointer(bp)) + _ = **(**Tva_list)(__ccgo_up(bp)) return ret } @@ -142710,15 +142710,15 @@ func _store_int1(tls *TLS, dest uintptr, size int32, i uint64) { } switch size { case -int32(2): - *(*uint8)(unsafe.Pointer(dest)) = uint8(i) + **(**uint8)(__ccgo_up(dest)) = uint8(i) case -int32(1): - *(*int16)(unsafe.Pointer(dest)) = Int16FromUint64(i) + **(**int16)(__ccgo_up(dest)) = Int16FromUint64(i) case SIZE_def: - *(*int32)(unsafe.Pointer(dest)) = Int32FromUint64(i) + **(**int32)(__ccgo_up(dest)) = Int32FromUint64(i) case int32(SIZE_l): - *(*int64)(unsafe.Pointer(dest)) = Int64FromUint64(i) + **(**int64)(__ccgo_up(dest)) = Int64FromUint64(i) case int32(SIZE_ll): - *(*int64)(unsafe.Pointer(dest)) = Int64FromUint64(i) + **(**int64)(__ccgo_up(dest)) = Int64FromUint64(i) break } } @@ -142750,13 +142750,13 @@ func _in_set(tls *TLS, set uintptr, c int32) (r int32) { var p, v3 uintptr _, _, _ = j, p, v3 p = set - if *(*Twchar_t)(unsafe.Pointer(p)) == uint32('-') { + if **(**Twchar_t)(__ccgo_up(p)) == uint32('-') { if c == int32('-') { return int32(1) } p += 4 } else { - if *(*Twchar_t)(unsafe.Pointer(p)) == uint32(']') { + if **(**Twchar_t)(__ccgo_up(p)) == uint32(']') { if c == int32(']') { return int32(1) } @@ -142764,15 +142764,15 @@ func _in_set(tls *TLS, set uintptr, c int32) (r int32) { } } for { - if !(*(*Twchar_t)(unsafe.Pointer(p)) != 0 && *(*Twchar_t)(unsafe.Pointer(p)) != uint32(']')) { + if !(**(**Twchar_t)(__ccgo_up(p)) != 0 && **(**Twchar_t)(__ccgo_up(p)) != uint32(']')) { break } - if *(*Twchar_t)(unsafe.Pointer(p)) == uint32('-') && *(*Twchar_t)(unsafe.Pointer(p + 1*4)) != 0 && *(*Twchar_t)(unsafe.Pointer(p + 1*4)) != uint32(']') { + if **(**Twchar_t)(__ccgo_up(p)) == uint32('-') && **(**Twchar_t)(__ccgo_up(p + 1*4)) != 0 && **(**Twchar_t)(__ccgo_up(p + 1*4)) != uint32(']') { v3 = p p += 4 - j = Int32FromUint32(*(*Twchar_t)(unsafe.Pointer(v3 + uintptr(-Int32FromInt32(1))*4))) + j = Int32FromUint32(**(**Twchar_t)(__ccgo_up(v3 + uintptr(-Int32FromInt32(1))*4))) for { - if !(Uint32FromInt32(j) < *(*Twchar_t)(unsafe.Pointer(p))) { + if !(Uint32FromInt32(j) < **(**Twchar_t)(__ccgo_up(p))) { break } if c == j { @@ -142784,7 +142784,7 @@ func _in_set(tls *TLS, set uintptr, c int32) (r int32) { j = j + 1 } } - if Uint32FromInt32(c) == *(*Twchar_t)(unsafe.Pointer(p)) { + if Uint32FromInt32(c) == **(**Twchar_t)(__ccgo_up(p)) { return int32(1) } goto _1 @@ -142822,20 +142822,20 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { Xfwide(tls, f, int32(1)) p = fmt for { - if !(*(*Twchar_t)(unsafe.Pointer(p)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(p)) != 0) { break } alloc = 0 - if Xiswspace(tls, *(*Twchar_t)(unsafe.Pointer(p))) != 0 { - for Xiswspace(tls, *(*Twchar_t)(unsafe.Pointer(p + 1*4))) != 0 { + if Xiswspace(tls, **(**Twchar_t)(__ccgo_up(p))) != 0 { + for Xiswspace(tls, **(**Twchar_t)(__ccgo_up(p + 1*4))) != 0 { p += 4 } for { - if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { + if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(**(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) + v4 = uint32(**(**uint8)(__ccgo_up(v5))) } else { v4 = Xgetwc(tls, f) } @@ -142850,21 +142850,21 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v6 = f + 8 *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 v5 = *(*uintptr)(unsafe.Pointer(v6)) - _ = *(*uint8)(unsafe.Pointer(v5)) + _ = **(**uint8)(__ccgo_up(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } goto _2 } - if *(*Twchar_t)(unsafe.Pointer(p)) != uint32('%') || *(*Twchar_t)(unsafe.Pointer(p + 1*4)) == uint32('%') { - if *(*Twchar_t)(unsafe.Pointer(p)) == uint32('%') { + if **(**Twchar_t)(__ccgo_up(p)) != uint32('%') || **(**Twchar_t)(__ccgo_up(p + 1*4)) == uint32('%') { + if **(**Twchar_t)(__ccgo_up(p)) == uint32('%') { p += 4 for { - if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { + if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(**(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) + v4 = uint32(**(**uint8)(__ccgo_up(v5))) } else { v4 = Xgetwc(tls, f) } @@ -142876,22 +142876,22 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { pos = pos + 1 } } else { - if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { + if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(**(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) + v4 = uint32(**(**uint8)(__ccgo_up(v5))) } else { v4 = Xgetwc(tls, f) } c = Int32FromUint32(v4) } - if Uint32FromInt32(c) != *(*Twchar_t)(unsafe.Pointer(p)) { + if Uint32FromInt32(c) != **(**Twchar_t)(__ccgo_up(p)) { if (*TFILE)(unsafe.Pointer(f)).Frend != 0 && Uint32FromInt32(c) < uint32(128) { v6 = f + 8 *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 v5 = *(*uintptr)(unsafe.Pointer(v6)) - _ = *(*uint8)(unsafe.Pointer(v5)) + _ = **(**uint8)(__ccgo_up(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -142904,12 +142904,12 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { goto _2 } p += 4 - if *(*Twchar_t)(unsafe.Pointer(p)) == uint32('*') { + if **(**Twchar_t)(__ccgo_up(p)) == uint32('*') { dest = uintptr(0) p += 4 } else { - if BoolInt32(*(*Twchar_t)(unsafe.Pointer(p))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(p + 1*4)) == uint32('$') { - dest = _arg_n1(tls, ap, *(*Twchar_t)(unsafe.Pointer(p))-uint32('0')) + if BoolInt32(**(**Twchar_t)(__ccgo_up(p))-uint32('0') < uint32(10)) != 0 && **(**Twchar_t)(__ccgo_up(p + 1*4)) == uint32('$') { + dest = _arg_n1(tls, ap, **(**Twchar_t)(__ccgo_up(p))-uint32('0')) p = p + uintptr(2)*4 } else { dest = VaUintptr(&ap) @@ -142917,16 +142917,16 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } width = 0 for { - if !(BoolInt32(*(*Twchar_t)(unsafe.Pointer(p))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(**(**Twchar_t)(__ccgo_up(p))-uint32('0') < uint32(10)) != 0) { break } - width = Int32FromUint32(Uint32FromInt32(int32(10)*width) + *(*Twchar_t)(unsafe.Pointer(p)) - uint32('0')) + width = Int32FromUint32(Uint32FromInt32(int32(10)*width) + **(**Twchar_t)(__ccgo_up(p)) - uint32('0')) goto _18 _18: ; p += 4 } - if *(*Twchar_t)(unsafe.Pointer(p)) == uint32('m') { + if **(**Twchar_t)(__ccgo_up(p)) == uint32('m') { wcs = uintptr(0) s = uintptr(0) alloc = BoolInt32(!!(dest != 0)) @@ -142937,16 +142937,16 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { size = SIZE_def v5 = p p += 4 - switch *(*Twchar_t)(unsafe.Pointer(v5)) { + switch **(**Twchar_t)(__ccgo_up(v5)) { case uint32('h'): - if *(*Twchar_t)(unsafe.Pointer(p)) == uint32('h') { + if **(**Twchar_t)(__ccgo_up(p)) == uint32('h') { p += 4 size = -Int32FromInt32(2) } else { size = -int32(1) } case uint32('l'): - if *(*Twchar_t)(unsafe.Pointer(p)) == uint32('l') { + if **(**Twchar_t)(__ccgo_up(p)) == uint32('l') { p += 4 size = Int32FromInt32(SIZE_ll) } else { @@ -143005,7 +143005,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { default: goto fmt_fail } - t = Int32FromUint32(*(*Twchar_t)(unsafe.Pointer(p))) + t = Int32FromUint32(**(**Twchar_t)(__ccgo_up(p))) /* Transform S,C -> ls,lc */ if t&int32(0x2f) == int32(3) { size = int32(SIZE_l) @@ -143014,11 +143014,11 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if t != int32('n') { if t != int32('[') && t|int32(32) != int32('c') { for { - if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { + if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(**(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) + v4 = uint32(**(**uint8)(__ccgo_up(v5))) } else { v4 = Xgetwc(tls, f) } @@ -143030,11 +143030,11 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { pos = pos + 1 } } else { - if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { + if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(**(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) + v4 = uint32(**(**uint8)(__ccgo_up(v5))) } else { v4 = Xgetwc(tls, f) } @@ -143047,7 +143047,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v6 = f + 8 *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 v5 = *(*uintptr)(unsafe.Pointer(v6)) - _ = *(*uint8)(unsafe.Pointer(v5)) + _ = **(**uint8)(__ccgo_up(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -143075,18 +143075,18 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } else { p += 4 v5 = p - if *(*Twchar_t)(unsafe.Pointer(v5)) == uint32('^') { + if **(**Twchar_t)(__ccgo_up(v5)) == uint32('^') { p += 4 invert = Int32FromInt32(1) } else { invert = 0 } set = p - if *(*Twchar_t)(unsafe.Pointer(p)) == uint32(']') { + if **(**Twchar_t)(__ccgo_up(p)) == uint32(']') { p += 4 } - for *(*Twchar_t)(unsafe.Pointer(p)) != uint32(']') { - if !(*(*Twchar_t)(unsafe.Pointer(p)) != 0) { + for **(**Twchar_t)(__ccgo_up(p)) != uint32(']') { + if !(**(**Twchar_t)(__ccgo_up(p)) != 0) { goto fmt_fail } p += 4 @@ -143130,11 +143130,11 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } } for width != 0 { - if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { + if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(**(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) + v4 = uint32(**(**uint8)(__ccgo_up(v5))) } else { v4 = Xgetwc(tls, f) } @@ -143149,7 +143149,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if wcs != 0 { v37 = i i = i + 1 - *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(v37)*4)) = Uint32FromInt32(c) + **(**Twchar_t)(__ccgo_up(wcs + uintptr(v37)*4)) = Uint32FromInt32(c) if alloc != 0 && i == k { k = k + (k + uint64(1)) tmp1 = Xrealloc(tls, wcs, k*uint64(4)) @@ -143189,7 +143189,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v6 = f + 8 *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 v5 = *(*uintptr)(unsafe.Pointer(v6)) - _ = *(*uint8)(unsafe.Pointer(v5)) + _ = **(**uint8)(__ccgo_up(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -143199,17 +143199,17 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } if alloc != 0 { if size == int32(SIZE_l) { - *(*uintptr)(unsafe.Pointer(dest)) = wcs + **(**uintptr)(__ccgo_up(dest)) = wcs } else { - *(*uintptr)(unsafe.Pointer(dest)) = s + **(**uintptr)(__ccgo_up(dest)) = s } } if t != int32('c') { if wcs != 0 { - *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) = uint32(0) + **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) = uint32(0) } if s != 0 { - *(*uint8)(unsafe.Pointer(s + uintptr(i))) = uint8(0) + **(**uint8)(__ccgo_up(s + uintptr(i))) = uint8(0) } } case int32('d'): @@ -143245,7 +143245,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { width = 0 } Xsnprintf(tls, bp+8, uint64(22), __ccgo_ts+1670, VaList(bp+40, int32(1)+BoolInt32(!(dest != 0)), __ccgo_ts+1688, width, uintptr(unsafe.Pointer(&_size_pfx))+uintptr(size+int32(2))*3, t)) - *(*Toff_t)(unsafe.Pointer(bp)) = 0 + **(**Toff_t)(__ccgo_up(bp)) = 0 if dest != 0 { v5 = dest } else { @@ -143254,11 +143254,11 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if Xfscanf(tls, f, bp+8, VaList(bp+40, v5, bp)) == -int32(1) { goto input_fail } else { - if !(*(*Toff_t)(unsafe.Pointer(bp)) != 0) { + if !(**(**Toff_t)(__ccgo_up(bp)) != 0) { goto match_fail } } - pos = pos + *(*Toff_t)(unsafe.Pointer(bp)) + pos = pos + **(**Toff_t)(__ccgo_up(bp)) default: goto fmt_fail } @@ -143384,8 +143384,8 @@ func _sn_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { k = v1 if k != 0 { Xmemcpy(tls, (*Tcookie3)(unsafe.Pointer(c)).Fs, (*TFILE)(unsafe.Pointer(f)).Fwbase, k) - *(*uintptr)(unsafe.Pointer(c)) += uintptr(k) - *(*Tsize_t)(unsafe.Pointer(c + 8)) -= k + **(**uintptr)(__ccgo_up(c)) += uintptr(k) + **(**Tsize_t)(__ccgo_up(c + 8)) -= k } if (*Tcookie3)(unsafe.Pointer(c)).Fn < l { v1 = (*Tcookie3)(unsafe.Pointer(c)).Fn @@ -143395,10 +143395,10 @@ func _sn_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { k = v1 if k != 0 { Xmemcpy(tls, (*Tcookie3)(unsafe.Pointer(c)).Fs, s, k) - *(*uintptr)(unsafe.Pointer(c)) += uintptr(k) - *(*Tsize_t)(unsafe.Pointer(c + 8)) -= k + **(**uintptr)(__ccgo_up(c)) += uintptr(k) + **(**Tsize_t)(__ccgo_up(c + 8)) -= k } - *(*uint8)(unsafe.Pointer((*Tcookie3)(unsafe.Pointer(c)).Fs)) = uint8(0) + **(**uint8)(__ccgo_up((*Tcookie3)(unsafe.Pointer(c)).Fs)) = uint8(0) v3 = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Fwbase = v3 (*TFILE)(unsafe.Pointer(f)).Fwpos = v3 @@ -143430,18 +143430,18 @@ func Xvsnprintf(tls *TLS, s uintptr, n Tsize_t, fmt uintptr, ap Tva_list) (r int } else { v2 = uint64(0) } - *(*Tcookie3)(unsafe.Pointer(bp + 8)) = Tcookie3{ + **(**Tcookie3)(__ccgo_up(bp + 8)) = Tcookie3{ Fs: v1, Fn: v2, } - *(*TFILE)(unsafe.Pointer(bp + 24)) = TFILE{ + **(**TFILE)(__ccgo_up(bp + 24)) = TFILE{ Fwrite: __ccgo_fp(_sn_write), Fbuf: bp, Flock: -int32(1), Flbf: -int32(1), Fcookie: bp + 8, } - *(*uint8)(unsafe.Pointer((*(*Tcookie3)(unsafe.Pointer(bp + 8))).Fs)) = uint8(0) + **(**uint8)(__ccgo_up((**(**Tcookie3)(__ccgo_up(bp + 8))).Fs)) = uint8(0) return Xvfprintf(tls, bp+24, fmt, ap) } @@ -143490,7 +143490,7 @@ func Xvsscanf(tls *TLS, s uintptr, fmt uintptr, ap Tva_list) (r int32) { bp := tls.Alloc(240) defer tls.Free(240) var _ /* f at bp+0 */ TFILE - *(*TFILE)(unsafe.Pointer(bp)) = TFILE{ + **(**TFILE)(__ccgo_up(bp)) = TFILE{ Fread: __ccgo_fp(_string_read), Fbuf: s, Flock: -int32(1), @@ -143540,14 +143540,14 @@ func _sw_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { (*Tcookie4)(unsafe.Pointer(c)).Fl = (*Tcookie4)(unsafe.Pointer(c)).Fl - 1 (*Tcookie4)(unsafe.Pointer(c)).Fws += 4 } - *(*Twchar_t)(unsafe.Pointer((*Tcookie4)(unsafe.Pointer(c)).Fws)) = uint32(0) + **(**Twchar_t)(__ccgo_up((*Tcookie4)(unsafe.Pointer(c)).Fws)) = uint32(0) if i < 0 { v4 = UintptrFromInt32(0) (*TFILE)(unsafe.Pointer(f)).Fwend = v4 v3 = v4 (*TFILE)(unsafe.Pointer(f)).Fwbase = v3 (*TFILE)(unsafe.Pointer(f)).Fwpos = v3 - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) return Uint64FromInt32(i) } (*TFILE)(unsafe.Pointer(f)).Fwend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr((*TFILE)(unsafe.Pointer(f)).Fbuf_size) @@ -143569,11 +143569,11 @@ func Xvswprintf(tls *TLS, s uintptr, n Tsize_t, fmt uintptr, ap Tva_list) (r1 in var _ /* c at bp+256 */ Tcookie4 var _ /* f at bp+272 */ TFILE _, _ = r, v1 - *(*Tcookie4)(unsafe.Pointer(bp + 256)) = Tcookie4{ + **(**Tcookie4)(__ccgo_up(bp + 256)) = Tcookie4{ Fws: s, Fl: n - uint64(1), } - *(*TFILE)(unsafe.Pointer(bp + 272)) = TFILE{ + **(**TFILE)(__ccgo_up(bp + 272)) = TFILE{ Fwrite: __ccgo_fp(_sw_write), Fbuf: bp, Fbuf_size: uint64(256), @@ -143601,8 +143601,8 @@ func _wstring_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { var v1, v2 uintptr var _ /* src at bp+0 */ uintptr _, _, _ = k, v1, v2 - *(*uintptr)(unsafe.Pointer(bp)) = (*TFILE)(unsafe.Pointer(f)).Fcookie - if !(*(*uintptr)(unsafe.Pointer(bp)) != 0) { + **(**uintptr)(__ccgo_up(bp)) = (*TFILE)(unsafe.Pointer(f)).Fcookie + if !(**(**uintptr)(__ccgo_up(bp)) != 0) { return uint64(0) } k = Xwcsrtombs(tls, (*TFILE)(unsafe.Pointer(f)).Fbuf, bp, (*TFILE)(unsafe.Pointer(f)).Fbuf_size, uintptr(0)) @@ -143614,14 +143614,14 @@ func _wstring_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { } (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(k) - (*TFILE)(unsafe.Pointer(f)).Fcookie = *(*uintptr)(unsafe.Pointer(bp)) + (*TFILE)(unsafe.Pointer(f)).Fcookie = **(**uintptr)(__ccgo_up(bp)) if !(len1 != 0) || !(k != 0) { return uint64(0) } v2 = f + 8 v1 = *(*uintptr)(unsafe.Pointer(v2)) *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(v2)) + 1 - *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v1)) + **(**uint8)(__ccgo_up(buf)) = **(**uint8)(__ccgo_up(v1)) return uint64(1) } @@ -143634,7 +143634,7 @@ func Xvswscanf(tls *TLS, s uintptr, fmt uintptr, ap Tva_list) (r int32) { defer tls.Free(496) var _ /* buf at bp+0 */ [256]uint8 var _ /* f at bp+256 */ TFILE - *(*TFILE)(unsafe.Pointer(bp + 256)) = TFILE{ + **(**TFILE)(__ccgo_up(bp + 256)) = TFILE{ Fread: __ccgo_fp(_wstring_read), Fbuf: bp, Fbuf_size: uint64(256), @@ -143746,7 +143746,7 @@ func Xatoi(tls *TLS, s uintptr) (r int32) { n = 0 neg = 0 for { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(s))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _3 _3: @@ -143755,7 +143755,7 @@ func Xatoi(tls *TLS, s uintptr) (r int32) { } s = s + 1 } - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(s))) { case int32('-'): neg = int32(1) fallthrough @@ -143763,10 +143763,10 @@ func Xatoi(tls *TLS, s uintptr) (r int32) { s = s + 1 } /* Compute n as a negative number to avoid overflow on INT_MIN */ - for BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { + for BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-uint32('0') < uint32(10)) != 0 { v4 = s s = s + 1 - n = int32(10)*n - (Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) - int32('0')) + n = int32(10)*n - (Int32FromUint8(**(**uint8)(__ccgo_up(v4))) - int32('0')) } if neg != 0 { v1 = n @@ -143788,7 +143788,7 @@ func Xatol(tls *TLS, s uintptr) (r int64) { n = 0 neg = 0 for { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(s))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _3 _3: @@ -143797,7 +143797,7 @@ func Xatol(tls *TLS, s uintptr) (r int64) { } s = s + 1 } - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(s))) { case int32('-'): neg = int32(1) fallthrough @@ -143805,10 +143805,10 @@ func Xatol(tls *TLS, s uintptr) (r int64) { s = s + 1 } /* Compute n as a negative number to avoid overflow on LONG_MIN */ - for BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { + for BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-uint32('0') < uint32(10)) != 0 { v4 = s s = s + 1 - n = int64(10)*n - int64(Int32FromUint8(*(*uint8)(unsafe.Pointer(v4)))-Int32FromUint8('0')) + n = int64(10)*n - int64(Int32FromUint8(**(**uint8)(__ccgo_up(v4)))-Int32FromUint8('0')) } if neg != 0 { v5 = n @@ -143830,7 +143830,7 @@ func Xatoll(tls *TLS, s uintptr) (r int64) { n = 0 neg = 0 for { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(s))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _3 _3: @@ -143839,7 +143839,7 @@ func Xatoll(tls *TLS, s uintptr) (r int64) { } s = s + 1 } - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(s))) { case int32('-'): neg = int32(1) fallthrough @@ -143847,10 +143847,10 @@ func Xatoll(tls *TLS, s uintptr) (r int64) { s = s + 1 } /* Compute n as a negative number to avoid overflow on LLONG_MIN */ - for BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { + for BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-uint32('0') < uint32(10)) != 0 { v4 = s s = s + 1 - n = int64(10)*n - int64(Int32FromUint8(*(*uint8)(unsafe.Pointer(v4)))-Int32FromUint8('0')) + n = int64(10)*n - int64(Int32FromUint8(**(**uint8)(__ccgo_up(v4)))-Int32FromUint8('0')) } if neg != 0 { v5 = n @@ -143912,24 +143912,24 @@ func Xecvt(tls *TLS, x float64, n int32, dp uintptr, sign uintptr) (r uintptr) { n = int32(15) } Xsprintf(tls, bp, __ccgo_ts+1691, VaList(bp+40, n-int32(1), x)) - v1 = BoolInt32(Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp)))[0]) == Int32FromUint8('-')) - *(*int32)(unsafe.Pointer(sign)) = v1 + v1 = BoolInt32(Int32FromUint8((**(**[32]uint8)(__ccgo_up(bp)))[0]) == Int32FromUint8('-')) + **(**int32)(__ccgo_up(sign)) = v1 i = v1 j = 0 for { - if !(Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp)))[i]) != int32('e')) { + if !(Int32FromUint8((**(**[32]uint8)(__ccgo_up(bp)))[i]) != int32('e')) { break } - _buf8[j] = (*(*[32]uint8)(unsafe.Pointer(bp)))[i] + _buf8[j] = (**(**[32]uint8)(__ccgo_up(bp)))[i] goto _2 _2: ; v1 = i i = i + 1 - j = j + BoolInt32(Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp)))[v1]) != int32('.')) + j = j + BoolInt32(Int32FromUint8((**(**[32]uint8)(__ccgo_up(bp)))[v1]) != int32('.')) } _buf8[j] = uint8(0) - *(*int32)(unsafe.Pointer(dp)) = Xatoi(tls, bp+uintptr(i)+uintptr(1)) + int32(1) + **(**int32)(__ccgo_up(dp)) = Xatoi(tls, bp+uintptr(i)+uintptr(1)) + int32(1) return uintptr(unsafe.Pointer(&_buf8)) } @@ -143949,15 +143949,15 @@ func Xfcvt(tls *TLS, x float64, n int32, dp uintptr, sign uintptr) (r uintptr) { n = int32(1400) } Xsprintf(tls, bp, __ccgo_ts+1696, VaList(bp+1512, n, x)) - i = BoolInt32(Int32FromUint8((*(*[1500]uint8)(unsafe.Pointer(bp)))[0]) == int32('-')) - if Int32FromUint8((*(*[1500]uint8)(unsafe.Pointer(bp)))[i]) == int32('0') { + i = BoolInt32(Int32FromUint8((**(**[1500]uint8)(__ccgo_up(bp)))[0]) == int32('-')) + if Int32FromUint8((**(**[1500]uint8)(__ccgo_up(bp)))[i]) == int32('0') { lz = Int32FromUint64(Xstrspn(tls, bp+uintptr(i)+uintptr(2), __ccgo_ts+1664)) } else { lz = -Int32FromUint64(Xstrcspn(tls, bp+uintptr(i), __ccgo_ts+558)) } if n <= lz { - *(*int32)(unsafe.Pointer(sign)) = i - *(*int32)(unsafe.Pointer(dp)) = int32(1) + **(**int32)(__ccgo_up(sign)) = i + **(**int32)(__ccgo_up(dp)) = int32(1) if Uint32FromInt32(n) > uint32(14) { n = int32(14) } @@ -144061,9 +144061,9 @@ func _pntz(tls *TLS, p uintptr) (r1 int32) { var r, v1 int32 var v2 bool _, _, _ = r, v1, v2 - r = _a_ctz_l(tls, *(*Tsize_t)(unsafe.Pointer(p))-uint64(1)) + r = _a_ctz_l(tls, **(**Tsize_t)(__ccgo_up(p))-uint64(1)) if v2 = r != 0; !v2 { - v1 = Int32FromUint64(Uint64FromInt32(8)*Uint64FromInt64(8) + Uint64FromInt32(_a_ctz_l(tls, *(*Tsize_t)(unsafe.Pointer(p + 1*8))))) + v1 = Int32FromUint64(Uint64FromInt32(8)*Uint64FromInt64(8) + Uint64FromInt32(_a_ctz_l(tls, **(**Tsize_t)(__ccgo_up(p + 1*8))))) r = v1 } if v2 || Uint64FromInt32(v1) != Uint64FromInt32(8)*Uint64FromInt64(8) { @@ -144083,7 +144083,7 @@ func _cycle(tls *TLS, width Tsize_t, ar uintptr, n int32) { if n < int32(2) { return } - *(*uintptr)(unsafe.Pointer(ar + uintptr(n)*8)) = bp + **(**uintptr)(__ccgo_up(ar + uintptr(n)*8)) = bp for width != 0 { if uint64(256) < width { v1 = uint64(256) @@ -144091,14 +144091,14 @@ func _cycle(tls *TLS, width Tsize_t, ar uintptr, n int32) { v1 = width } l = v1 - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(ar + uintptr(n)*8)), *(*uintptr)(unsafe.Pointer(ar)), l) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(ar + uintptr(n)*8)), **(**uintptr)(__ccgo_up(ar)), l) i = 0 for { if !(i < n) { break } - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(ar + uintptr(i)*8)), *(*uintptr)(unsafe.Pointer(ar + uintptr(i+int32(1))*8)), l) - *(*uintptr)(unsafe.Pointer(ar + uintptr(i)*8)) += uintptr(l) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(ar + uintptr(i)*8)), **(**uintptr)(__ccgo_up(ar + uintptr(i+int32(1))*8)), l) + **(**uintptr)(__ccgo_up(ar + uintptr(i)*8)) += uintptr(l) goto _2 _2: ; @@ -144114,23 +144114,23 @@ func _cycle(tls *TLS, width Tsize_t, ar uintptr, n int32) { func _shl(tls *TLS, p uintptr, n int32) { if Uint64FromInt32(n) >= Uint64FromInt32(8)*Uint64FromInt64(8) { n = Int32FromUint64(uint64(n) - Uint64FromInt32(8)*Uint64FromInt64(8)) - *(*Tsize_t)(unsafe.Pointer(p + 1*8)) = *(*Tsize_t)(unsafe.Pointer(p)) - *(*Tsize_t)(unsafe.Pointer(p)) = uint64(0) + **(**Tsize_t)(__ccgo_up(p + 1*8)) = **(**Tsize_t)(__ccgo_up(p)) + **(**Tsize_t)(__ccgo_up(p)) = uint64(0) } - *(*Tsize_t)(unsafe.Pointer(p + 1*8)) <<= Uint64FromInt32(n) - *(*Tsize_t)(unsafe.Pointer(p + 1*8)) |= *(*Tsize_t)(unsafe.Pointer(p)) >> (Uint64FromInt64(8)*Uint64FromInt32(8) - Uint64FromInt32(n)) - *(*Tsize_t)(unsafe.Pointer(p)) <<= Uint64FromInt32(n) + **(**Tsize_t)(__ccgo_up(p + 1*8)) <<= Uint64FromInt32(n) + **(**Tsize_t)(__ccgo_up(p + 1*8)) |= **(**Tsize_t)(__ccgo_up(p)) >> (Uint64FromInt64(8)*Uint64FromInt32(8) - Uint64FromInt32(n)) + **(**Tsize_t)(__ccgo_up(p)) <<= Uint64FromInt32(n) } func _shr(tls *TLS, p uintptr, n int32) { if Uint64FromInt32(n) >= Uint64FromInt32(8)*Uint64FromInt64(8) { n = Int32FromUint64(uint64(n) - Uint64FromInt32(8)*Uint64FromInt64(8)) - *(*Tsize_t)(unsafe.Pointer(p)) = *(*Tsize_t)(unsafe.Pointer(p + 1*8)) - *(*Tsize_t)(unsafe.Pointer(p + 1*8)) = uint64(0) + **(**Tsize_t)(__ccgo_up(p)) = **(**Tsize_t)(__ccgo_up(p + 1*8)) + **(**Tsize_t)(__ccgo_up(p + 1*8)) = uint64(0) } - *(*Tsize_t)(unsafe.Pointer(p)) >>= Uint64FromInt32(n) - *(*Tsize_t)(unsafe.Pointer(p)) |= *(*Tsize_t)(unsafe.Pointer(p + 1*8)) << (Uint64FromInt64(8)*Uint64FromInt32(8) - Uint64FromInt32(n)) - *(*Tsize_t)(unsafe.Pointer(p + 1*8)) >>= Uint64FromInt32(n) + **(**Tsize_t)(__ccgo_up(p)) >>= Uint64FromInt32(n) + **(**Tsize_t)(__ccgo_up(p)) |= **(**Tsize_t)(__ccgo_up(p + 1*8)) << (Uint64FromInt64(8)*Uint64FromInt32(8) - Uint64FromInt32(n)) + **(**Tsize_t)(__ccgo_up(p + 1*8)) >>= Uint64FromInt32(n) } func _sift(tls *TLS, head uintptr, width Tsize_t, __ccgo_fp_cmp Tcmpfun, arg uintptr, pshift int32, lp uintptr) { @@ -144141,23 +144141,23 @@ func _sift(tls *TLS, head uintptr, width Tsize_t, __ccgo_fp_cmp Tcmpfun, arg uin var _ /* ar at bp+0 */ [113]uintptr _, _, _, _ = i, lf, rt, v1 i = int32(1) - (*(*[113]uintptr)(unsafe.Pointer(bp)))[0] = head + (**(**[113]uintptr)(__ccgo_up(bp)))[0] = head for pshift > int32(1) { rt = head - uintptr(width) - lf = head - uintptr(width) - uintptr(*(*Tsize_t)(unsafe.Pointer(lp + uintptr(pshift-int32(2))*8))) - if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, (*(*[113]uintptr)(unsafe.Pointer(bp)))[0], lf, arg) >= 0 && (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, (*(*[113]uintptr)(unsafe.Pointer(bp)))[0], rt, arg) >= 0 { + lf = head - uintptr(width) - uintptr(**(**Tsize_t)(__ccgo_up(lp + uintptr(pshift-int32(2))*8))) + if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, (**(**[113]uintptr)(__ccgo_up(bp)))[0], lf, arg) >= 0 && (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, (**(**[113]uintptr)(__ccgo_up(bp)))[0], rt, arg) >= 0 { break } if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, lf, rt, arg) >= 0 { v1 = i i = i + 1 - (*(*[113]uintptr)(unsafe.Pointer(bp)))[v1] = lf + (**(**[113]uintptr)(__ccgo_up(bp)))[v1] = lf head = lf pshift = pshift - int32(1) } else { v1 = i i = i + 1 - (*(*[113]uintptr)(unsafe.Pointer(bp)))[v1] = rt + (**(**[113]uintptr)(__ccgo_up(bp)))[v1] = rt head = rt pshift = pshift - int32(2) } @@ -144174,24 +144174,24 @@ func _trinkle(tls *TLS, head uintptr, width Tsize_t, __ccgo_fp_cmp Tcmpfun, arg var _ /* p at bp+0 */ [2]Tsize_t _, _, _, _, _, _ = i, lf, rt, stepson, trail, v1 i = int32(1) - (*(*[2]Tsize_t)(unsafe.Pointer(bp)))[0] = *(*Tsize_t)(unsafe.Pointer(pp)) - (*(*[2]Tsize_t)(unsafe.Pointer(bp)))[int32(1)] = *(*Tsize_t)(unsafe.Pointer(pp + 1*8)) - (*(*[113]uintptr)(unsafe.Pointer(bp + 16)))[0] = head - for (*(*[2]Tsize_t)(unsafe.Pointer(bp)))[0] != uint64(1) || (*(*[2]Tsize_t)(unsafe.Pointer(bp)))[int32(1)] != uint64(0) { - stepson = head - uintptr(*(*Tsize_t)(unsafe.Pointer(lp + uintptr(pshift)*8))) - if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, stepson, (*(*[113]uintptr)(unsafe.Pointer(bp + 16)))[0], arg) <= 0 { + (**(**[2]Tsize_t)(__ccgo_up(bp)))[0] = **(**Tsize_t)(__ccgo_up(pp)) + (**(**[2]Tsize_t)(__ccgo_up(bp)))[int32(1)] = **(**Tsize_t)(__ccgo_up(pp + 1*8)) + (**(**[113]uintptr)(__ccgo_up(bp + 16)))[0] = head + for (**(**[2]Tsize_t)(__ccgo_up(bp)))[0] != uint64(1) || (**(**[2]Tsize_t)(__ccgo_up(bp)))[int32(1)] != uint64(0) { + stepson = head - uintptr(**(**Tsize_t)(__ccgo_up(lp + uintptr(pshift)*8))) + if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, stepson, (**(**[113]uintptr)(__ccgo_up(bp + 16)))[0], arg) <= 0 { break } if !(trusty != 0) && pshift > int32(1) { rt = head - uintptr(width) - lf = head - uintptr(width) - uintptr(*(*Tsize_t)(unsafe.Pointer(lp + uintptr(pshift-int32(2))*8))) + lf = head - uintptr(width) - uintptr(**(**Tsize_t)(__ccgo_up(lp + uintptr(pshift-int32(2))*8))) if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, rt, stepson, arg) >= 0 || (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, lf, stepson, arg) >= 0 { break } } v1 = i i = i + 1 - (*(*[113]uintptr)(unsafe.Pointer(bp + 16)))[v1] = stepson + (**(**[113]uintptr)(__ccgo_up(bp + 16)))[v1] = stepson head = stepson trail = _pntz(tls, bp) _shr(tls, bp, trail) @@ -144219,7 +144219,7 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm var _ /* p at bp+768 */ [2]Tsize_t _, _, _, _, _, _, _, _ = head, high, i, pshift, size, trail, v2, v3 size = width * nel - *(*[2]Tsize_t)(unsafe.Pointer(bp + 768)) = [2]Tsize_t{ + **(**[2]Tsize_t)(__ccgo_up(bp + 768)) = [2]Tsize_t{ 0: uint64(1), } pshift = int32(1) @@ -144230,12 +144230,12 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm high = head + uintptr(size) - uintptr(width) /* Precompute Leonardo numbers, scaled by element width */ v2 = width - (*(*[96]Tsize_t)(unsafe.Pointer(bp)))[int32(1)] = v2 - (*(*[96]Tsize_t)(unsafe.Pointer(bp)))[0] = v2 + (**(**[96]Tsize_t)(__ccgo_up(bp)))[int32(1)] = v2 + (**(**[96]Tsize_t)(__ccgo_up(bp)))[0] = v2 i = Uint64FromInt32(2) for { - v3 = (*(*[96]Tsize_t)(unsafe.Pointer(bp)))[i-uint64(2)] + (*(*[96]Tsize_t)(unsafe.Pointer(bp)))[i-uint64(1)] + width - (*(*[96]Tsize_t)(unsafe.Pointer(bp)))[i] = v3 + v3 = (**(**[96]Tsize_t)(__ccgo_up(bp)))[i-uint64(2)] + (**(**[96]Tsize_t)(__ccgo_up(bp)))[i-uint64(1)] + width + (**(**[96]Tsize_t)(__ccgo_up(bp)))[i] = v3 if !(v3 < size) { break } @@ -144245,12 +144245,12 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm i = i + 1 } for head < high { - if (*(*[2]Tsize_t)(unsafe.Pointer(bp + 768)))[0]&uint64(3) == uint64(3) { + if (**(**[2]Tsize_t)(__ccgo_up(bp + 768)))[0]&uint64(3) == uint64(3) { _sift(tls, head, width, __ccgo_fp_cmp, arg, pshift, bp) _shr(tls, bp+768, int32(2)) pshift = pshift + int32(2) } else { - if (*(*[96]Tsize_t)(unsafe.Pointer(bp)))[pshift-int32(1)] >= Uint64FromInt64(int64(high)-int64(head)) { + if (**(**[96]Tsize_t)(__ccgo_up(bp)))[pshift-int32(1)] >= Uint64FromInt64(int64(high)-int64(head)) { _trinkle(tls, head, width, __ccgo_fp_cmp, arg, bp+768, pshift, 0, bp) } else { _sift(tls, head, width, __ccgo_fp_cmp, arg, pshift, bp) @@ -144263,11 +144263,11 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm pshift = int32(1) } } - *(*Tsize_t)(unsafe.Pointer(bp + 768)) |= uint64(1) + **(**Tsize_t)(__ccgo_up(bp + 768)) |= uint64(1) head = head + uintptr(width) } _trinkle(tls, head, width, __ccgo_fp_cmp, arg, bp+768, pshift, 0, bp) - for pshift != int32(1) || (*(*[2]Tsize_t)(unsafe.Pointer(bp + 768)))[0] != uint64(1) || (*(*[2]Tsize_t)(unsafe.Pointer(bp + 768)))[int32(1)] != uint64(0) { + for pshift != int32(1) || (**(**[2]Tsize_t)(__ccgo_up(bp + 768)))[0] != uint64(1) || (**(**[2]Tsize_t)(__ccgo_up(bp + 768)))[int32(1)] != uint64(0) { if pshift <= int32(1) { trail = _pntz(tls, bp+768) _shr(tls, bp+768, trail) @@ -144275,11 +144275,11 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm } else { _shl(tls, bp+768, int32(2)) pshift = pshift - int32(2) - *(*Tsize_t)(unsafe.Pointer(bp + 768)) ^= uint64(7) + **(**Tsize_t)(__ccgo_up(bp + 768)) ^= uint64(7) _shr(tls, bp+768, int32(1)) - _trinkle(tls, head-uintptr((*(*[96]Tsize_t)(unsafe.Pointer(bp)))[pshift])-uintptr(width), width, __ccgo_fp_cmp, arg, bp+768, pshift+int32(1), int32(1), bp) + _trinkle(tls, head-uintptr((**(**[96]Tsize_t)(__ccgo_up(bp)))[pshift])-uintptr(width), width, __ccgo_fp_cmp, arg, bp+768, pshift+int32(1), int32(1), bp) _shl(tls, bp+768, int32(1)) - *(*Tsize_t)(unsafe.Pointer(bp + 768)) |= uint64(1) + **(**Tsize_t)(__ccgo_up(bp + 768)) |= uint64(1) _trinkle(tls, head-uintptr(width), width, __ccgo_fp_cmp, arg, bp+768, pshift, int32(1), bp) } head = head - uintptr(width) @@ -144329,7 +144329,7 @@ func _strtox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { } else { v1 = s } - *(*uintptr)(unsafe.Pointer(p)) = v1 + **(**uintptr)(__ccgo_up(p)) = v1 } return y } @@ -144374,7 +144374,7 @@ func _strtox1(tls *TLS, s uintptr, p uintptr, base int32, lim uint64) (r uint64) y = X__intscan(tls, bp, Uint32FromInt32(base), int32(1), lim) if p != 0 { cnt = Uint64FromInt64((*TFILE)(unsafe.Pointer(bp)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(bp)).Frpos) - int64((*TFILE)(unsafe.Pointer(bp)).Fbuf))) - *(*uintptr)(unsafe.Pointer(p)) = s + uintptr(cnt) + **(**uintptr)(__ccgo_up(p)) = s + uintptr(cnt) } return y } @@ -144485,20 +144485,20 @@ func _do_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { var v2 uint32 _, _, _, _, _ = i, wcs, v2, v3, v4 wcs = (*TFILE)(unsafe.Pointer(f)).Fcookie - if !(*(*Twchar_t)(unsafe.Pointer(wcs)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(wcs)) != 0) { wcs = __ccgo_ts + 1722 } i = uint64(0) for { - if !(i < (*TFILE)(unsafe.Pointer(f)).Fbuf_size && *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) != 0) { + if !(i < (*TFILE)(unsafe.Pointer(f)).Fbuf_size && **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) != 0) { break } - if *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) < uint32(128) { - v2 = *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) + if **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) < uint32(128) { + v2 = **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) } else { v2 = uint32('@') } - *(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(i))) = uint8(v2) + **(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(i))) = uint8(v2) goto _1 _1: ; @@ -144511,7 +144511,7 @@ func _do_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(buf)) = **(**uint8)(__ccgo_up(v3)) return uint64(1) } return uint64(0) @@ -144527,20 +144527,20 @@ func _wcstox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { var _ /* f at bp+64 */ TFILE _, _, _, _, _ = cnt, t, y, v1, v2 t = s - *(*TFILE)(unsafe.Pointer(bp + 64)) = TFILE{} - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fflags = uint32(0) + **(**TFILE)(__ccgo_up(bp + 64)) = TFILE{} + (**(**TFILE)(__ccgo_up(bp + 64))).Fflags = uint32(0) v2 = bp + UintptrFromInt32(4) - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fbuf = v2 + (**(**TFILE)(__ccgo_up(bp + 64))).Fbuf = v2 v1 = v2 - (*(*TFILE)(unsafe.Pointer(bp + 64))).Frend = v1 - (*(*TFILE)(unsafe.Pointer(bp + 64))).Frpos = v1 - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fbuf_size = Uint64FromInt64(64) - Uint64FromInt32(4) + (**(**TFILE)(__ccgo_up(bp + 64))).Frend = v1 + (**(**TFILE)(__ccgo_up(bp + 64))).Frpos = v1 + (**(**TFILE)(__ccgo_up(bp + 64))).Fbuf_size = Uint64FromInt64(64) - Uint64FromInt32(4) AtomicStorePInt32(bp+64+140, -int32(1)) - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fread = __ccgo_fp(_do_read) - for Xiswspace(tls, *(*Twchar_t)(unsafe.Pointer(t))) != 0 { + (**(**TFILE)(__ccgo_up(bp + 64))).Fread = __ccgo_fp(_do_read) + for Xiswspace(tls, **(**Twchar_t)(__ccgo_up(t))) != 0 { t += 4 } - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fcookie = t + (**(**TFILE)(__ccgo_up(bp + 64))).Fcookie = t X__shlim(tls, bp+64, int64(Int32FromInt32(0))) y = X__floatscan(tls, bp+64, prec, int32(1)) if p != 0 { @@ -144550,7 +144550,7 @@ func _wcstox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { } else { v1 = s } - *(*uintptr)(unsafe.Pointer(p)) = v1 + **(**uintptr)(__ccgo_up(p)) = v1 } return y } @@ -144589,20 +144589,20 @@ func _do_read1(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { var v2 uint32 _, _, _, _, _ = i, wcs, v2, v3, v4 wcs = (*TFILE)(unsafe.Pointer(f)).Fcookie - if !(*(*Twchar_t)(unsafe.Pointer(wcs)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(wcs)) != 0) { wcs = __ccgo_ts + 1722 } i = uint64(0) for { - if !(i < (*TFILE)(unsafe.Pointer(f)).Fbuf_size && *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) != 0) { + if !(i < (*TFILE)(unsafe.Pointer(f)).Fbuf_size && **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) != 0) { break } - if *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) < uint32(128) { - v2 = *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) + if **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) < uint32(128) { + v2 = **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) } else { v2 = uint32('@') } - *(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(i))) = uint8(v2) + **(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(i))) = uint8(v2) goto _1 _1: ; @@ -144615,7 +144615,7 @@ func _do_read1(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(buf)) = **(**uint8)(__ccgo_up(v3)) return uint64(1) } return uint64(0) @@ -144631,20 +144631,20 @@ func _wcstox1(tls *TLS, s uintptr, p uintptr, base int32, lim uint64) (r uint64) var _ /* f at bp+64 */ TFILE _, _, _, _, _ = cnt, t, y, v1, v2 t = s - *(*TFILE)(unsafe.Pointer(bp + 64)) = TFILE{} - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fflags = uint32(0) + **(**TFILE)(__ccgo_up(bp + 64)) = TFILE{} + (**(**TFILE)(__ccgo_up(bp + 64))).Fflags = uint32(0) v2 = bp + UintptrFromInt32(4) - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fbuf = v2 + (**(**TFILE)(__ccgo_up(bp + 64))).Fbuf = v2 v1 = v2 - (*(*TFILE)(unsafe.Pointer(bp + 64))).Frend = v1 - (*(*TFILE)(unsafe.Pointer(bp + 64))).Frpos = v1 - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fbuf_size = Uint64FromInt64(64) - Uint64FromInt32(4) + (**(**TFILE)(__ccgo_up(bp + 64))).Frend = v1 + (**(**TFILE)(__ccgo_up(bp + 64))).Frpos = v1 + (**(**TFILE)(__ccgo_up(bp + 64))).Fbuf_size = Uint64FromInt64(64) - Uint64FromInt32(4) AtomicStorePInt32(bp+64+140, -int32(1)) - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fread = __ccgo_fp(_do_read1) - for Xiswspace(tls, *(*Twchar_t)(unsafe.Pointer(t))) != 0 { + (**(**TFILE)(__ccgo_up(bp + 64))).Fread = __ccgo_fp(_do_read1) + for Xiswspace(tls, **(**Twchar_t)(__ccgo_up(t))) != 0 { t += 4 } - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fcookie = t + (**(**TFILE)(__ccgo_up(bp + 64))).Fcookie = t X__shlim(tls, bp+64, int64(Int32FromInt32(0))) y = X__intscan(tls, bp+64, Uint32FromInt32(base), int32(1), lim) if p != 0 { @@ -144654,7 +144654,7 @@ func _wcstox1(tls *TLS, s uintptr, p uintptr, base int32, lim uint64) (r uint64) } else { v1 = s } - *(*uintptr)(unsafe.Pointer(p)) = v1 + **(**uintptr)(__ccgo_up(p)) = v1 } return y } @@ -144773,8 +144773,8 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt if uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) == uint64(d)&(Uint64FromInt64(8)-Uint64FromInt32(1)) { for { if v3 = uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) != 0 && n != 0; v3 { - v2 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v2 + v2 = **(**uint8)(__ccgo_up(s)) + **(**uint8)(__ccgo_up(d)) = v2 } if !(v3 && Int32FromUint8(v2) != c) { break @@ -144793,10 +144793,10 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt wd = d ws = s for { - if !(n >= uint64(8) && !((*(*uint64)(unsafe.Pointer(ws))^k-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^(*(*uint64)(unsafe.Pointer(ws))^k) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { + if !(n >= uint64(8) && !((**(**uint64)(__ccgo_up(ws))^k-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^(**(**uint64)(__ccgo_up(ws))^k) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { break } - *(*uint64)(unsafe.Pointer(wd)) = *(*uint64)(unsafe.Pointer(ws)) + **(**uint64)(__ccgo_up(wd)) = **(**uint64)(__ccgo_up(ws)) goto _4 _4: ; @@ -144809,8 +144809,8 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt } for { if v3 = n != 0; v3 { - v2 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v2 + v2 = **(**uint8)(__ccgo_up(s)) + **(**uint8)(__ccgo_up(d)) = v2 } if !(v3 && Int32FromUint8(v2) != c) { break @@ -144853,7 +144853,7 @@ func Xmemchr(tls *TLS, src uintptr, c int32, n Tsize_t) (r uintptr) { s = src c = Int32FromUint8(Uint8FromInt32(c)) for { - if !(uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) != 0 && n != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != c) { + if !(uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) != 0 && n != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != c) { break } goto _1 @@ -144862,11 +144862,11 @@ func Xmemchr(tls *TLS, src uintptr, c int32, n Tsize_t) (r uintptr) { s = s + 1 n = n - 1 } - if n != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != c { + if n != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != c { k = Uint64FromInt32(-Int32FromInt32(1)) / Uint64FromInt32(UCHAR_MAX) * Uint64FromInt32(c) w = s for { - if !(n >= Uint64FromInt64(8) && !((*(*uint64)(unsafe.Pointer(w))^k-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^(*(*uint64)(unsafe.Pointer(w))^k) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { + if !(n >= Uint64FromInt64(8) && !((**(**uint64)(__ccgo_up(w))^k-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^(**(**uint64)(__ccgo_up(w))^k) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { break } goto _2 @@ -144878,7 +144878,7 @@ func Xmemchr(tls *TLS, src uintptr, c int32, n Tsize_t) (r uintptr) { s = w } for { - if !(n != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != c) { + if !(n != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != c) { break } goto _3 @@ -144906,7 +144906,7 @@ func Xmemcmp(tls *TLS, vl uintptr, vr uintptr, n Tsize_t) (r1 int32) { l = vl r = vr for { - if !(n != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))) { + if !(n != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(l))) == Int32FromUint8(**(**uint8)(__ccgo_up(r)))) { break } goto _1 @@ -144917,7 +144917,7 @@ func Xmemcmp(tls *TLS, vl uintptr, vr uintptr, n Tsize_t) (r1 int32) { r = r + 1 } if n != 0 { - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(l))) - Int32FromUint8(**(**uint8)(__ccgo_up(r))) } else { v2 = 0 } @@ -144945,7 +144945,7 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) goto _1 _1: ; @@ -144956,10 +144956,10 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { if !(n >= uint64(16)) { break } - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(0))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(4))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(4))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(8))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(8))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(12))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(12))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(0))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(0))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(4))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(4))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(8))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(8))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(12))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(12))) goto _4 _4: ; @@ -144968,13 +144968,13 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { n = n - uint64(16) } if n&uint64(8) != 0 { - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(0))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(4))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(4))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(0))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(0))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(4))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(4))) d = d + uintptr(8) s = s + uintptr(8) } if n&uint64(4) != 0 { - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(0))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(0))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(0))) d = d + uintptr(4) s = s + uintptr(4) } @@ -144983,50 +144983,50 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) } if n&uint64(1) != 0 { - *(*uint8)(unsafe.Pointer(d)) = *(*uint8)(unsafe.Pointer(s)) + **(**uint8)(__ccgo_up(d)) = **(**uint8)(__ccgo_up(s)) } return dest } if n >= uint64(32) { switch uint64(d) % Uint64FromInt32(4) { case uint64(1): - w = *(*uint32)(unsafe.Pointer(s)) + w = **(**uint32)(__ccgo_up(s)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) n = n - uint64(3) for { if !(n >= uint64(17)) { break } - x = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(1))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = w>>Int32FromInt32(24) | x<>Int32FromInt32(24) | w<>Int32FromInt32(24) | x<>Int32FromInt32(24) | w<>Int32FromInt32(24) | x<>Int32FromInt32(24) | w<>Int32FromInt32(24) | x<>Int32FromInt32(24) | w<= uint64(18)) { break } - x = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(2))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = w>>Int32FromInt32(16) | x<>Int32FromInt32(16) | w<>Int32FromInt32(16) | x<>Int32FromInt32(16) | w<>Int32FromInt32(16) | x<>Int32FromInt32(16) | w<>Int32FromInt32(16) | x<>Int32FromInt32(16) | w<= uint64(19)) { break } - x = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(3))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = w>>Int32FromInt32(8) | x<>Int32FromInt32(8) | w<>Int32FromInt32(8) | x<>Int32FromInt32(8) | w<>Int32FromInt32(8) | x<>Int32FromInt32(8) | w<>Int32FromInt32(8) | x<>Int32FromInt32(8) | w< Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(ip+k)))) > Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(jp+k)))) { jp = jp + k k = uint64(1) p = jp - ip @@ -145428,7 +145428,7 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin p = v2 k = v2 for jp+k < l { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(ip+k)))) == Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(jp+k)))) { if k == p { jp = jp + p k = uint64(1) @@ -145436,7 +145436,7 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin k = k + 1 } } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) < Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(ip+k)))) < Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(jp+k)))) { jp = jp + k k = uint64(1) p = jp - ip @@ -145475,8 +145475,8 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin return uintptr(0) } /* Check last byte first; advance by shift on mismatch */ - if (*(*[4]Tsize_t)(unsafe.Pointer(bp)))[uint64(*(*uint8)(unsafe.Pointer(h + uintptr(l-uint64(1)))))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(*(*uint8)(unsafe.Pointer(h + uintptr(l-uint64(1)))))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0 { - k = l - shift[*(*uint8)(unsafe.Pointer(h + uintptr(l-uint64(1))))] + if (**(**[4]Tsize_t)(__ccgo_up(bp)))[uint64(**(**uint8)(__ccgo_up(h + uintptr(l-uint64(1)))))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(**(**uint8)(__ccgo_up(h + uintptr(l-uint64(1)))))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0 { + k = l - shift[**(**uint8)(__ccgo_up(h + uintptr(l-uint64(1))))] if k != 0 { if k < mem { k = mem @@ -145498,7 +145498,7 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin } k = v8 for { - if !(k < l && Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(h + uintptr(k))))) { + if !(k < l && Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(k)))) == Int32FromUint8(**(**uint8)(__ccgo_up(h + uintptr(k))))) { break } goto _10 @@ -145514,7 +145514,7 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin /* Compare left half */ k = ms + uint64(1) for { - if !(k > mem && Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(k-uint64(1))))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(h + uintptr(k-uint64(1)))))) { + if !(k > mem && Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(k-uint64(1))))) == Int32FromUint8(**(**uint8)(__ccgo_up(h + uintptr(k-uint64(1)))))) { break } goto _12 @@ -145551,7 +145551,7 @@ func Xmemmem(tls *TLS, h0 uintptr, k Tsize_t, n0 uintptr, l Tsize_t) (r uintptr) return uintptr(0) } /* Use faster algorithms for short needles */ - h = Xmemchr(tls, h0, Int32FromUint8(*(*uint8)(unsafe.Pointer(n))), k) + h = Xmemchr(tls, h0, Int32FromUint8(**(**uint8)(__ccgo_up(n))), k) if !(h != 0) || l == uint64(1) { return h } @@ -145603,13 +145603,13 @@ func Xmemmove(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) } for { if !(n >= Uint64FromInt64(8)) { break } - *(*TWT)(unsafe.Pointer(d)) = *(*TWT)(unsafe.Pointer(s)) + **(**TWT)(__ccgo_up(d)) = **(**TWT)(__ccgo_up(s)) goto _4 _4: ; @@ -145626,7 +145626,7 @@ func Xmemmove(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) goto _5 _5: ; @@ -145640,16 +145640,16 @@ func Xmemmove(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { if !(v1 != 0) { return dest } - *(*uint8)(unsafe.Pointer(d + uintptr(n))) = *(*uint8)(unsafe.Pointer(s + uintptr(n))) + **(**uint8)(__ccgo_up(d + uintptr(n))) = **(**uint8)(__ccgo_up(s + uintptr(n))) } for n >= Uint64FromInt64(8) { n = n - Uint64FromInt64(8) - *(*TWT)(unsafe.Pointer(d + uintptr(n))) = *(*TWT)(unsafe.Pointer(s + uintptr(n))) + **(**TWT)(__ccgo_up(d + uintptr(n))) = **(**TWT)(__ccgo_up(s + uintptr(n))) } } for n != 0 { n = n - 1 - *(*uint8)(unsafe.Pointer(d + uintptr(n))) = *(*uint8)(unsafe.Pointer(s + uintptr(n))) + **(**uint8)(__ccgo_up(d + uintptr(n))) = **(**uint8)(__ccgo_up(s + uintptr(n))) } } return dest @@ -145679,7 +145679,7 @@ func X__memrchr(tls *TLS, m uintptr, c int32, n Tsize_t) (r uintptr) { if !(v1 != 0) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(n)))) == c { + if Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(n)))) == c { return s + uintptr(n) } } @@ -145711,20 +145711,20 @@ func Xmemset(tls *TLS, dest uintptr, c int32, n Tsize_t) (r uintptr) { if !(n != 0) { return dest } - *(*uint8)(unsafe.Pointer(s)) = Uint8FromInt32(c) - *(*uint8)(unsafe.Pointer(s + uintptr(n-uint64(1)))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s)) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + uintptr(n-uint64(1)))) = Uint8FromInt32(c) if n <= uint64(2) { return dest } - *(*uint8)(unsafe.Pointer(s + 1)) = Uint8FromInt32(c) - *(*uint8)(unsafe.Pointer(s + 2)) = Uint8FromInt32(c) - *(*uint8)(unsafe.Pointer(s + uintptr(n-uint64(2)))) = Uint8FromInt32(c) - *(*uint8)(unsafe.Pointer(s + uintptr(n-uint64(3)))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + 1)) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + 2)) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + uintptr(n-uint64(2)))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + uintptr(n-uint64(3)))) = Uint8FromInt32(c) if n <= uint64(6) { return dest } - *(*uint8)(unsafe.Pointer(s + 3)) = Uint8FromInt32(c) - *(*uint8)(unsafe.Pointer(s + uintptr(n-uint64(4)))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + 3)) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + uintptr(n-uint64(4)))) = Uint8FromInt32(c) if n <= uint64(8) { return dest } @@ -145742,26 +145742,26 @@ func Xmemset(tls *TLS, dest uintptr, c int32, n Tsize_t) (r uintptr) { * As in the initial byte-based head/tail fill, each * conditional below ensures that the subsequent offsets * are valid (e.g. !(n<=24) implies n>=28). */ - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(0))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(4))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(0))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(4))) = c32 if n <= uint64(8) { return dest } - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(4))) = c32 - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(8))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(12))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(8))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(4))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(8))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(12))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(8))) = c32 if n <= uint64(24) { return dest } - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(12))) = c32 - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(16))) = c32 - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(20))) = c32 - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(24))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(28))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(24))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(20))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(16))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(12))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(16))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(20))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(24))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(28))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(24))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(20))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(16))) = c32 /* Align to a multiple of 8 so we can fill 64 bits at a time, * and avoid writing the same bytes twice as much as is * practical without introducing additional branching. */ @@ -145776,10 +145776,10 @@ func Xmemset(tls *TLS, dest uintptr, c int32, n Tsize_t) (r uintptr) { if !(n >= uint64(32)) { break } - *(*uint64)(unsafe.Pointer(s + UintptrFromInt32(0))) = c64 - *(*uint64)(unsafe.Pointer(s + UintptrFromInt32(8))) = c64 - *(*uint64)(unsafe.Pointer(s + UintptrFromInt32(16))) = c64 - *(*uint64)(unsafe.Pointer(s + UintptrFromInt32(24))) = c64 + **(**uint64)(__ccgo_up(s + UintptrFromInt32(0))) = c64 + **(**uint64)(__ccgo_up(s + UintptrFromInt32(8))) = c64 + **(**uint64)(__ccgo_up(s + UintptrFromInt32(16))) = c64 + **(**uint64)(__ccgo_up(s + UintptrFromInt32(24))) = c64 goto _1 _1: ; @@ -145821,8 +145821,8 @@ func X__stpcpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { if !(uint64(s)%Uint64FromInt64(8) != 0) { break } - v2 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v2 + v2 = **(**uint8)(__ccgo_up(s)) + **(**uint8)(__ccgo_up(d)) = v2 if !(v2 != 0) { return d } @@ -145835,7 +145835,7 @@ func X__stpcpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { wd = d ws = s for { - if !!((*(*uint64)(unsafe.Pointer(ws))-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^*(*uint64)(unsafe.Pointer(ws)) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0) { + if !!((**(**uint64)(__ccgo_up(ws))-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^**(**uint64)(__ccgo_up(ws)) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0) { break } goto _3 @@ -145845,14 +145845,14 @@ func X__stpcpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { wd += 8 v5 = ws ws += 8 - *(*uint64)(unsafe.Pointer(v4)) = *(*uint64)(unsafe.Pointer(v5)) + **(**uint64)(__ccgo_up(v4)) = **(**uint64)(__ccgo_up(v5)) } d = wd s = ws } for { - v2 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v2 + v2 = **(**uint8)(__ccgo_up(s)) + **(**uint8)(__ccgo_up(d)) = v2 if !(v2 != 0) { break } @@ -145905,8 +145905,8 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { if uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) == uint64(d)&(Uint64FromInt64(8)-Uint64FromInt32(1)) { for { if v3 = uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) != 0 && n != 0; v3 { - v2 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v2 + v2 = **(**uint8)(__ccgo_up(s)) + **(**uint8)(__ccgo_up(d)) = v2 } if !(v3 && v2 != 0) { break @@ -145918,16 +145918,16 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { s = s + 1 d = d + 1 } - if !(n != 0) || !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(n != 0) || !(**(**uint8)(__ccgo_up(s)) != 0) { goto tail } wd = d ws = s for { - if !(n >= uint64(8) && !((*(*uint64)(unsafe.Pointer(ws))-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^*(*uint64)(unsafe.Pointer(ws)) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { + if !(n >= uint64(8) && !((**(**uint64)(__ccgo_up(ws))-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^**(**uint64)(__ccgo_up(ws)) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { break } - *(*uint64)(unsafe.Pointer(wd)) = *(*uint64)(unsafe.Pointer(ws)) + **(**uint64)(__ccgo_up(wd)) = **(**uint64)(__ccgo_up(ws)) goto _4 _4: ; @@ -145940,8 +145940,8 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { } for { if v3 = n != 0; v3 { - v2 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v2 + v2 = **(**uint8)(__ccgo_up(s)) + **(**uint8)(__ccgo_up(d)) = v2 } if !(v3 && v2 != 0) { break @@ -145987,7 +145987,7 @@ func Xstrcasecmp(tls *TLS, _l uintptr, _r uintptr) (r1 int32) { l = _l r = _r for { - if !(*(*uint8)(unsafe.Pointer(l)) != 0 && *(*uint8)(unsafe.Pointer(r)) != 0 && (Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) || Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(l)))) == Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))))) { + if !(**(**uint8)(__ccgo_up(l)) != 0 && **(**uint8)(__ccgo_up(r)) != 0 && (Int32FromUint8(**(**uint8)(__ccgo_up(l))) == Int32FromUint8(**(**uint8)(__ccgo_up(r))) || Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(l)))) == Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(r)))))) { break } goto _1 @@ -145996,7 +145996,7 @@ func Xstrcasecmp(tls *TLS, _l uintptr, _r uintptr) (r1 int32) { l = l + 1 r = r + 1 } - return Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(l)))) - Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))) + return Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(l)))) - Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(r)))) } func X__strcasecmp_l(tls *TLS, l uintptr, r uintptr, loc Tlocale_t) (r1 int32) { @@ -146024,7 +146024,7 @@ func Xstrcasestr(tls *TLS, h uintptr, n uintptr) (r uintptr) { _ = l l = _strlen(tls, n) for { - if !(*(*uint8)(unsafe.Pointer(h)) != 0) { + if !(**(**uint8)(__ccgo_up(h)) != 0) { break } if !(Xstrncasecmp(tls, h, n, l) != 0) { @@ -146055,7 +146055,7 @@ func Xstrchr(tls *TLS, s uintptr, c int32) (r1 uintptr) { var r, v1 uintptr _, _ = r, v1 r = X__strchrnul(tls, s, c) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) == Int32FromUint8(Uint8FromInt32(c)) { + if Int32FromUint8(**(**uint8)(__ccgo_up(r))) == Int32FromUint8(Uint8FromInt32(c)) { v1 = r } else { v1 = uintptr(0) @@ -146090,7 +146090,7 @@ func X__strchrnul(tls *TLS, s uintptr, c int32) (r uintptr) { if !(uint64(s)%Uint64FromInt64(8) != 0) { break } - if !(*(*uint8)(unsafe.Pointer(s)) != 0) || Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == c { + if !(**(**uint8)(__ccgo_up(s)) != 0) || Int32FromUint8(**(**uint8)(__ccgo_up(s))) == c { return s } goto _1 @@ -146101,7 +146101,7 @@ func X__strchrnul(tls *TLS, s uintptr, c int32) (r uintptr) { k = Uint64FromInt32(-Int32FromInt32(1)) / Uint64FromInt32(UCHAR_MAX) * Uint64FromInt32(c) w = s for { - if !(!((*(*uint64)(unsafe.Pointer(w))-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^*(*uint64)(unsafe.Pointer(w)) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0) && !((*(*uint64)(unsafe.Pointer(w))^k-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^(*(*uint64)(unsafe.Pointer(w))^k) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { + if !(!((**(**uint64)(__ccgo_up(w))-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^**(**uint64)(__ccgo_up(w)) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0) && !((**(**uint64)(__ccgo_up(w))^k-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^(**(**uint64)(__ccgo_up(w))^k) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { break } goto _2 @@ -146111,7 +146111,7 @@ func X__strchrnul(tls *TLS, s uintptr, c int32) (r uintptr) { } s = w for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != c) { + if !(**(**uint8)(__ccgo_up(s)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != c) { break } goto _3 @@ -146145,7 +146145,7 @@ func Xstrcmp(tls *TLS, l uintptr, r uintptr) (r1 int32) { defer func() { trc("-> %v", r1) }() } for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) && *(*uint8)(unsafe.Pointer(l)) != 0) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(l))) == Int32FromUint8(**(**uint8)(__ccgo_up(r))) && **(**uint8)(__ccgo_up(l)) != 0) { break } goto _1 @@ -146154,7 +146154,7 @@ func Xstrcmp(tls *TLS, l uintptr, r uintptr) (r1 int32) { l = l + 1 r = r + 1 } - return Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) + return Int32FromUint8(**(**uint8)(__ccgo_up(l))) - Int32FromUint8(**(**uint8)(__ccgo_up(r))) } func Xstrcpy(tls *TLS, dest uintptr, src uintptr) (r uintptr) { @@ -146178,14 +146178,14 @@ func Xstrcspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { var _ /* byteset at bp+0 */ [4]Tsize_t _, _, _ = a, v2, v3 a = s - if !(*(*uint8)(unsafe.Pointer(c)) != 0) || !(*(*uint8)(unsafe.Pointer(c + 1)) != 0) { - return Uint64FromInt64(int64(X__strchrnul(tls, s, Int32FromUint8(*(*uint8)(unsafe.Pointer(c))))) - int64(a)) + if !(**(**uint8)(__ccgo_up(c)) != 0) || !(**(**uint8)(__ccgo_up(c + 1)) != 0) { + return Uint64FromInt64(int64(X__strchrnul(tls, s, Int32FromUint8(**(**uint8)(__ccgo_up(c))))) - int64(a)) } Xmemset(tls, bp, 0, uint64(32)) for { - if v3 = *(*uint8)(unsafe.Pointer(c)) != 0; v3 { - v2 = bp + uintptr(uint64(*(*uint8)(unsafe.Pointer(c)))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 - *(*Tsize_t)(unsafe.Pointer(v2)) |= Uint64FromInt32(1) << (uint64(*(*uint8)(unsafe.Pointer(c))) % (Uint64FromInt32(8) * Uint64FromInt64(8))) + if v3 = **(**uint8)(__ccgo_up(c)) != 0; v3 { + v2 = bp + uintptr(uint64(**(**uint8)(__ccgo_up(c)))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 + *(*Tsize_t)(unsafe.Pointer(v2)) |= Uint64FromInt32(1) << (uint64(**(**uint8)(__ccgo_up(c))) % (Uint64FromInt32(8) * Uint64FromInt64(8))) } if !(v3 && *(*Tsize_t)(unsafe.Pointer(v2)) != 0) { break @@ -146196,7 +146196,7 @@ func Xstrcspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { c = c + 1 } for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0 && !((*(*[4]Tsize_t)(unsafe.Pointer(bp)))[uint64(*(*uint8)(unsafe.Pointer(s)))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(*(*uint8)(unsafe.Pointer(s)))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0)) { + if !(**(**uint8)(__ccgo_up(s)) != 0 && !((**(**[4]Tsize_t)(__ccgo_up(bp)))[uint64(**(**uint8)(__ccgo_up(s)))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(**(**uint8)(__ccgo_up(s)))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0)) { break } goto _4 @@ -146236,7 +146236,7 @@ func Xstrerror_r(tls *TLS, err int32, buf uintptr, buflen Tsize_t) (r int32) { if l >= buflen { if buflen != 0 { Xmemcpy(tls, buf, msg, buflen-uint64(1)) - *(*uint8)(unsafe.Pointer(buf + uintptr(buflen-uint64(1)))) = uint8(0) + **(**uint8)(__ccgo_up(buf + uintptr(buflen-uint64(1)))) = uint8(0) } return int32(ERANGE) } @@ -146296,8 +146296,8 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { if uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) == uint64(d)&(Uint64FromInt64(8)-Uint64FromInt32(1)) { for { if v4 = uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) != 0 && n != 0; v4 { - v3 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v3 + v3 = **(**uint8)(__ccgo_up(s)) + **(**uint8)(__ccgo_up(d)) = v3 } if !(v4 && v3 != 0) { break @@ -146309,14 +146309,14 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { s = s + 1 d = d + 1 } - if n != 0 && *(*uint8)(unsafe.Pointer(s)) != 0 { + if n != 0 && **(**uint8)(__ccgo_up(s)) != 0 { wd = d ws = s for { - if !(n >= uint64(8) && !((*(*uint64)(unsafe.Pointer(ws))-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^*(*uint64)(unsafe.Pointer(ws)) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { + if !(n >= uint64(8) && !((**(**uint64)(__ccgo_up(ws))-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^**(**uint64)(__ccgo_up(ws)) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { break } - *(*Tsize_t)(unsafe.Pointer(wd)) = *(*uint64)(unsafe.Pointer(ws)) + **(**Tsize_t)(__ccgo_up(wd)) = **(**uint64)(__ccgo_up(ws)) goto _5 _5: ; @@ -146330,8 +146330,8 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { } for { if v4 = n != 0; v4 { - v3 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v3 + v3 = **(**uint8)(__ccgo_up(s)) + **(**uint8)(__ccgo_up(d)) = v3 } if !(v4 && v3 != 0) { break @@ -146343,7 +146343,7 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { s = s + 1 d = d + 1 } - *(*uint8)(unsafe.Pointer(d)) = uint8(0) + **(**uint8)(__ccgo_up(d)) = uint8(0) goto finish finish: ; @@ -146369,7 +146369,7 @@ func Xstrncasecmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { return 0 } for { - if !(*(*uint8)(unsafe.Pointer(l)) != 0 && *(*uint8)(unsafe.Pointer(r)) != 0 && n != 0 && (Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) || Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(l)))) == Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))))) { + if !(**(**uint8)(__ccgo_up(l)) != 0 && **(**uint8)(__ccgo_up(r)) != 0 && n != 0 && (Int32FromUint8(**(**uint8)(__ccgo_up(l))) == Int32FromUint8(**(**uint8)(__ccgo_up(r))) || Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(l)))) == Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(r)))))) { break } goto _2 @@ -146379,7 +146379,7 @@ func Xstrncasecmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { r = r + 1 n = n - 1 } - return Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(l)))) - Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))) + return Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(l)))) - Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(r)))) } func X__strncasecmp_l(tls *TLS, l uintptr, r uintptr, n Tsize_t, loc Tlocale_t) (r1 int32) { @@ -146407,17 +146407,17 @@ func Xstrncat(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { _, _, _ = a, v1, v2 a = d d = d + uintptr(_strlen(tls, d)) - for n != 0 && *(*uint8)(unsafe.Pointer(s)) != 0 { + for n != 0 && **(**uint8)(__ccgo_up(s)) != 0 { n = n - 1 v1 = d d = d + 1 v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v1)) = *(*uint8)(unsafe.Pointer(v2)) + **(**uint8)(__ccgo_up(v1)) = **(**uint8)(__ccgo_up(v2)) } v1 = d d = d + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) return a } @@ -146437,7 +146437,7 @@ func Xstrncmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { return 0 } for { - if !(*(*uint8)(unsafe.Pointer(l)) != 0 && *(*uint8)(unsafe.Pointer(r)) != 0 && n != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))) { + if !(**(**uint8)(__ccgo_up(l)) != 0 && **(**uint8)(__ccgo_up(r)) != 0 && n != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(l))) == Int32FromUint8(**(**uint8)(__ccgo_up(r)))) { break } goto _2 @@ -146447,7 +146447,7 @@ func Xstrncmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { r = r + 1 n = n - 1 } - return Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) + return Int32FromUint8(**(**uint8)(__ccgo_up(l))) - Int32FromUint8(**(**uint8)(__ccgo_up(r))) } func Xstrncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { @@ -146473,7 +146473,7 @@ func Xstrndup(tls *TLS, s uintptr, n Tsize_t) (r uintptr) { return UintptrFromInt32(0) } Xmemcpy(tls, d, s, l) - *(*uint8)(unsafe.Pointer(d + uintptr(l))) = uint8(0) + **(**uint8)(__ccgo_up(d + uintptr(l))) = uint8(0) return d } @@ -146502,7 +146502,7 @@ func Xstrpbrk(tls *TLS, s uintptr, b uintptr) (r uintptr) { var v1 uintptr _ = v1 s = s + uintptr(Xstrcspn(tls, s, b)) - if *(*uint8)(unsafe.Pointer(s)) != 0 { + if **(**uint8)(__ccgo_up(s)) != 0 { v1 = s } else { v1 = uintptr(0) @@ -146525,19 +146525,19 @@ func Xstrsep(tls *TLS, str uintptr, sep uintptr) (r uintptr) { } var end, s, v1 uintptr _, _, _ = end, s, v1 - s = *(*uintptr)(unsafe.Pointer(str)) + s = **(**uintptr)(__ccgo_up(str)) if !(s != 0) { return UintptrFromInt32(0) } end = s + uintptr(Xstrcspn(tls, s, sep)) - if *(*uint8)(unsafe.Pointer(end)) != 0 { + if **(**uint8)(__ccgo_up(end)) != 0 { v1 = end end = end + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) } else { end = uintptr(0) } - *(*uintptr)(unsafe.Pointer(str)) = end + **(**uintptr)(__ccgo_up(str)) = end return s } @@ -146563,7 +146563,7 @@ func Xstrsignal(tls *TLS, signum int32) (r uintptr) { break } for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { break } goto _3 @@ -146591,13 +146591,13 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { var _ /* byteset at bp+0 */ [4]Tsize_t _, _, _ = a, v3, v4 a = s - *(*[4]Tsize_t)(unsafe.Pointer(bp)) = [4]Tsize_t{} - if !(*(*uint8)(unsafe.Pointer(c)) != 0) { + **(**[4]Tsize_t)(__ccgo_up(bp)) = [4]Tsize_t{} + if !(**(**uint8)(__ccgo_up(c)) != 0) { return uint64(0) } - if !(*(*uint8)(unsafe.Pointer(c + 1)) != 0) { + if !(**(**uint8)(__ccgo_up(c + 1)) != 0) { for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(c)))) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(s))) == Int32FromUint8(**(**uint8)(__ccgo_up(c)))) { break } goto _1 @@ -146608,9 +146608,9 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { return Uint64FromInt64(int64(s) - int64(a)) } for { - if v4 = *(*uint8)(unsafe.Pointer(c)) != 0; v4 { - v3 = bp + uintptr(uint64(*(*uint8)(unsafe.Pointer(c)))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 - *(*Tsize_t)(unsafe.Pointer(v3)) |= Uint64FromInt32(1) << (uint64(*(*uint8)(unsafe.Pointer(c))) % (Uint64FromInt32(8) * Uint64FromInt64(8))) + if v4 = **(**uint8)(__ccgo_up(c)) != 0; v4 { + v3 = bp + uintptr(uint64(**(**uint8)(__ccgo_up(c)))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 + *(*Tsize_t)(unsafe.Pointer(v3)) |= Uint64FromInt32(1) << (uint64(**(**uint8)(__ccgo_up(c))) % (Uint64FromInt32(8) * Uint64FromInt64(8))) } if !(v4 && *(*Tsize_t)(unsafe.Pointer(v3)) != 0) { break @@ -146621,7 +146621,7 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { c = c + 1 } for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0 && (*(*[4]Tsize_t)(unsafe.Pointer(bp)))[uint64(*(*uint8)(unsafe.Pointer(s)))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(*(*uint8)(unsafe.Pointer(s)))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0 && (**(**[4]Tsize_t)(__ccgo_up(bp)))[uint64(**(**uint8)(__ccgo_up(s)))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(**(**uint8)(__ccgo_up(s)))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0) { break } goto _5 @@ -146636,11 +146636,11 @@ func _twobyte_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { var hw, nw Tuint16_t var v2 uintptr _, _, _ = hw, nw, v2 - nw = Uint16FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(n)))< Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(ip+k)))) > Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(jp+k)))) { jp = jp + k k = uint64(1) p = jp - ip @@ -146774,7 +146774,7 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { p = v2 k = v2 for jp+k < l { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(ip+k)))) == Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(jp+k)))) { if k == p { jp = jp + p k = uint64(1) @@ -146782,7 +146782,7 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { k = k + 1 } } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) < Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(ip+k)))) < Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(jp+k)))) { jp = jp + k k = uint64(1) p = jp - ip @@ -146833,8 +146833,8 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { } } /* Check last byte first; advance by shift on mismatch */ - if (*(*[4]Tsize_t)(unsafe.Pointer(bp)))[uint64(*(*uint8)(unsafe.Pointer(h + uintptr(l-uint64(1)))))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(*(*uint8)(unsafe.Pointer(h + uintptr(l-uint64(1)))))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0 { - k = l - shift[*(*uint8)(unsafe.Pointer(h + uintptr(l-uint64(1))))] + if (**(**[4]Tsize_t)(__ccgo_up(bp)))[uint64(**(**uint8)(__ccgo_up(h + uintptr(l-uint64(1)))))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(**(**uint8)(__ccgo_up(h + uintptr(l-uint64(1)))))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0 { + k = l - shift[**(**uint8)(__ccgo_up(h + uintptr(l-uint64(1))))] if k != 0 { if k < mem { k = mem @@ -146856,7 +146856,7 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { } k = v8 for { - if !(*(*uint8)(unsafe.Pointer(n + uintptr(k))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(h + uintptr(k))))) { + if !(**(**uint8)(__ccgo_up(n + uintptr(k))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(k)))) == Int32FromUint8(**(**uint8)(__ccgo_up(h + uintptr(k))))) { break } goto _10 @@ -146864,7 +146864,7 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { ; k = k + 1 } - if *(*uint8)(unsafe.Pointer(n + uintptr(k))) != 0 { + if **(**uint8)(__ccgo_up(n + uintptr(k))) != 0 { h = h + uintptr(k-ms) mem = uint64(0) goto _9 @@ -146872,7 +146872,7 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { /* Compare left half */ k = ms + uint64(1) for { - if !(k > mem && Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(k-uint64(1))))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(h + uintptr(k-uint64(1)))))) { + if !(k > mem && Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(k-uint64(1))))) == Int32FromUint8(**(**uint8)(__ccgo_up(h + uintptr(k-uint64(1)))))) { break } goto _12 @@ -146897,30 +146897,30 @@ func Xstrstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { defer func() { trc("-> %v", r) }() } /* Return immediately on empty needle */ - if !(*(*uint8)(unsafe.Pointer(n)) != 0) { + if !(**(**uint8)(__ccgo_up(n)) != 0) { return h } /* Use faster algorithms for short needles */ - h = Xstrchr(tls, h, Int32FromUint8(*(*uint8)(unsafe.Pointer(n)))) - if !(h != 0) || !(*(*uint8)(unsafe.Pointer(n + 1)) != 0) { + h = Xstrchr(tls, h, Int32FromUint8(**(**uint8)(__ccgo_up(n)))) + if !(h != 0) || !(**(**uint8)(__ccgo_up(n + 1)) != 0) { return h } - if !(*(*uint8)(unsafe.Pointer(h + 1)) != 0) { + if !(**(**uint8)(__ccgo_up(h + 1)) != 0) { return uintptr(0) } - if !(*(*uint8)(unsafe.Pointer(n + 2)) != 0) { + if !(**(**uint8)(__ccgo_up(n + 2)) != 0) { return _twobyte_strstr(tls, h, n) } - if !(*(*uint8)(unsafe.Pointer(h + 2)) != 0) { + if !(**(**uint8)(__ccgo_up(h + 2)) != 0) { return uintptr(0) } - if !(*(*uint8)(unsafe.Pointer(n + 3)) != 0) { + if !(**(**uint8)(__ccgo_up(n + 3)) != 0) { return _threebyte_strstr(tls, h, n) } - if !(*(*uint8)(unsafe.Pointer(h + 3)) != 0) { + if !(**(**uint8)(__ccgo_up(h + 3)) != 0) { return uintptr(0) } - if !(*(*uint8)(unsafe.Pointer(n + 4)) != 0) { + if !(**(**uint8)(__ccgo_up(n + 4)) != 0) { return _fourbyte_strstr(tls, h, n) } return _twoway_strstr(tls, h, n) @@ -146942,16 +146942,16 @@ func Xstrtok(tls *TLS, s uintptr, sep uintptr) (r uintptr) { return UintptrFromInt32(0) } s = s + uintptr(Xstrspn(tls, s, sep)) - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { v1 = UintptrFromInt32(0) _p2 = v1 return v1 } _p2 = s + uintptr(Xstrcspn(tls, s, sep)) - if *(*uint8)(unsafe.Pointer(_p2)) != 0 { + if **(**uint8)(__ccgo_up(_p2)) != 0 { v1 = _p2 _p2 = _p2 + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) } else { _p2 = uintptr(0) } @@ -146969,26 +146969,26 @@ func Xstrtok_r(tls *TLS, s uintptr, sep uintptr, p uintptr) (r uintptr) { var v2 bool _, _, _ = v1, v2, v3 if v2 = !(s != 0); v2 { - v1 = *(*uintptr)(unsafe.Pointer(p)) + v1 = **(**uintptr)(__ccgo_up(p)) s = v1 } if v2 && !(v1 != 0) { return UintptrFromInt32(0) } s = s + uintptr(Xstrspn(tls, s, sep)) - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { v1 = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(p)) = v1 + **(**uintptr)(__ccgo_up(p)) = v1 return v1 } - *(*uintptr)(unsafe.Pointer(p)) = s + uintptr(Xstrcspn(tls, s, sep)) - if *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)))) != 0 { + **(**uintptr)(__ccgo_up(p)) = s + uintptr(Xstrcspn(tls, s, sep)) + if **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)))) != 0 { v3 = p v1 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) } else { - *(*uintptr)(unsafe.Pointer(p)) = uintptr(0) + **(**uintptr)(__ccgo_up(p)) = uintptr(0) } return s } @@ -147011,10 +147011,10 @@ func Xstrverscmp(tls *TLS, l0 uintptr, r0 uintptr) (r1 int32) { i = v2 dp = v2 for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(l + uintptr(i)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(r + uintptr(i))))) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(l + uintptr(i)))) == Int32FromUint8(**(**uint8)(__ccgo_up(r + uintptr(i))))) { break } - c = Int32FromUint8(*(*uint8)(unsafe.Pointer(l + uintptr(i)))) + c = Int32FromUint8(**(**uint8)(__ccgo_up(l + uintptr(i)))) if !(c != 0) { return 0 } @@ -147031,15 +147031,15 @@ func Xstrverscmp(tls *TLS, l0 uintptr, r0 uintptr) (r1 int32) { ; i = i + 1 } - if Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(l + uintptr(dp))))-int32('1')) < uint32(9) && Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(r + uintptr(dp))))-int32('1')) < uint32(9) { + if Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(l + uintptr(dp))))-int32('1')) < uint32(9) && Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(r + uintptr(dp))))-int32('1')) < uint32(9) { /* If we're looking at non-degenerate digit sequences starting * with nonzero digits, longest digit string is greater. */ j = i for { - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(l + uintptr(j))))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(l + uintptr(j))))-uint32('0') < uint32(10)) != 0) { break } - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(r + uintptr(j))))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(r + uintptr(j))))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return int32(1) } goto _3 @@ -147047,17 +147047,17 @@ func Xstrverscmp(tls *TLS, l0 uintptr, r0 uintptr) (r1 int32) { ; j = j + 1 } - if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(r + uintptr(j))))-uint32('0') < uint32(10)) != 0 { + if BoolInt32(uint32(**(**uint8)(__ccgo_up(r + uintptr(j))))-uint32('0') < uint32(10)) != 0 { return -int32(1) } } else { - if z != 0 && dp < i && (BoolInt32(uint32(*(*uint8)(unsafe.Pointer(l + uintptr(i))))-uint32('0') < uint32(10)) != 0 || BoolInt32(uint32(*(*uint8)(unsafe.Pointer(r + uintptr(i))))-uint32('0') < uint32(10)) != 0) { + if z != 0 && dp < i && (BoolInt32(uint32(**(**uint8)(__ccgo_up(l + uintptr(i))))-uint32('0') < uint32(10)) != 0 || BoolInt32(uint32(**(**uint8)(__ccgo_up(r + uintptr(i))))-uint32('0') < uint32(10)) != 0) { /* Otherwise, if common prefix of digit sequence is * all zeros, digits order less than non-digits. */ - return Int32FromUint8(Uint8FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(l + uintptr(i))))-Int32FromUint8('0'))) - Int32FromUint8(Uint8FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(r + uintptr(i))))-Int32FromUint8('0'))) + return Int32FromUint8(Uint8FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(l + uintptr(i))))-Int32FromUint8('0'))) - Int32FromUint8(Uint8FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(r + uintptr(i))))-Int32FromUint8('0'))) } } - return Int32FromUint8(*(*uint8)(unsafe.Pointer(l + uintptr(i)))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r + uintptr(i)))) + return Int32FromUint8(**(**uint8)(__ccgo_up(l + uintptr(i)))) - Int32FromUint8(**(**uint8)(__ccgo_up(r + uintptr(i)))) } func Xswab(tls *TLS, _src uintptr, _dest uintptr, n Tssize_t) { @@ -147072,8 +147072,8 @@ func Xswab(tls *TLS, _src uintptr, _dest uintptr, n Tssize_t) { if !(n > int64(1)) { break } - *(*uint8)(unsafe.Pointer(dest)) = *(*uint8)(unsafe.Pointer(src + 1)) - *(*uint8)(unsafe.Pointer(dest + 1)) = *(*uint8)(unsafe.Pointer(src)) + **(**uint8)(__ccgo_up(dest)) = **(**uint8)(__ccgo_up(src + 1)) + **(**uint8)(__ccgo_up(dest + 1)) = **(**uint8)(__ccgo_up(src)) dest = dest + uintptr(2) src = src + uintptr(2) goto _1 @@ -147135,7 +147135,7 @@ func Xwcschr(tls *TLS, s uintptr, c Twchar_t) (r uintptr) { return s + uintptr(Xwcslen(tls, s))*4 } for { - if !(*(*Twchar_t)(unsafe.Pointer(s)) != 0 && *(*Twchar_t)(unsafe.Pointer(s)) != c) { + if !(**(**Twchar_t)(__ccgo_up(s)) != 0 && **(**Twchar_t)(__ccgo_up(s)) != c) { break } goto _1 @@ -147143,7 +147143,7 @@ func Xwcschr(tls *TLS, s uintptr, c Twchar_t) (r uintptr) { ; s += 4 } - if *(*Twchar_t)(unsafe.Pointer(s)) != 0 { + if **(**Twchar_t)(__ccgo_up(s)) != 0 { v2 = s } else { v2 = uintptr(0) @@ -147159,7 +147159,7 @@ func Xwcscmp(tls *TLS, l uintptr, r uintptr) (r1 int32) { var v2 int32 _ = v2 for { - if !(*(*Twchar_t)(unsafe.Pointer(l)) == *(*Twchar_t)(unsafe.Pointer(r)) && *(*Twchar_t)(unsafe.Pointer(l)) != 0 && *(*Twchar_t)(unsafe.Pointer(r)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(l)) == **(**Twchar_t)(__ccgo_up(r)) && **(**Twchar_t)(__ccgo_up(l)) != 0 && **(**Twchar_t)(__ccgo_up(r)) != 0) { break } goto _1 @@ -147168,10 +147168,10 @@ func Xwcscmp(tls *TLS, l uintptr, r uintptr) (r1 int32) { l += 4 r += 4 } - if *(*Twchar_t)(unsafe.Pointer(l)) < *(*Twchar_t)(unsafe.Pointer(r)) { + if **(**Twchar_t)(__ccgo_up(l)) < **(**Twchar_t)(__ccgo_up(r)) { v2 = -int32(1) } else { - v2 = BoolInt32(*(*Twchar_t)(unsafe.Pointer(l)) > *(*Twchar_t)(unsafe.Pointer(r))) + v2 = BoolInt32(**(**Twchar_t)(__ccgo_up(l)) > **(**Twchar_t)(__ccgo_up(r))) } return v2 } @@ -147188,10 +147188,10 @@ func Xwcscpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { for { v2 = s s += 4 - v1 = *(*Twchar_t)(unsafe.Pointer(v2)) + v1 = **(**Twchar_t)(__ccgo_up(v2)) v3 = d d += 4 - *(*Twchar_t)(unsafe.Pointer(v3)) = v1 + **(**Twchar_t)(__ccgo_up(v3)) = v1 if !(v1 != 0) { break } @@ -147207,13 +147207,13 @@ func Xwcscspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { var a, v2, v3 uintptr var v1 uint64 _, _, _, _ = a, v1, v2, v3 - if !(*(*Twchar_t)(unsafe.Pointer(c)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(c)) != 0) { return Xwcslen(tls, s) } - if !(*(*Twchar_t)(unsafe.Pointer(c + 1*4)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(c + 1*4)) != 0) { v3 = s a = v3 - v2 = Xwcschr(tls, v3, *(*Twchar_t)(unsafe.Pointer(c))) + v2 = Xwcschr(tls, v3, **(**Twchar_t)(__ccgo_up(c))) s = v2 if v2 != 0 { v1 = Uint64FromInt64((int64(s) - int64(a)) / 4) @@ -147224,7 +147224,7 @@ func Xwcscspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { } a = s for { - if !(*(*Twchar_t)(unsafe.Pointer(s)) != 0 && !(Xwcschr(tls, c, *(*Twchar_t)(unsafe.Pointer(s))) != 0)) { + if !(**(**Twchar_t)(__ccgo_up(s)) != 0 && !(Xwcschr(tls, c, **(**Twchar_t)(__ccgo_up(s))) != 0)) { break } goto _4 @@ -147260,7 +147260,7 @@ func Xwcslen(tls *TLS, s uintptr) (r Tsize_t) { _ = a a = s for { - if !(*(*Twchar_t)(unsafe.Pointer(s)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(s)) != 0) { break } goto _1 @@ -147284,7 +147284,7 @@ func Xwcsncasecmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { return 0 } for { - if !(*(*Twchar_t)(unsafe.Pointer(l)) != 0 && *(*Twchar_t)(unsafe.Pointer(r)) != 0 && n != 0 && (*(*Twchar_t)(unsafe.Pointer(l)) == *(*Twchar_t)(unsafe.Pointer(r)) || Xtowlower(tls, *(*Twchar_t)(unsafe.Pointer(l))) == Xtowlower(tls, *(*Twchar_t)(unsafe.Pointer(r))))) { + if !(**(**Twchar_t)(__ccgo_up(l)) != 0 && **(**Twchar_t)(__ccgo_up(r)) != 0 && n != 0 && (**(**Twchar_t)(__ccgo_up(l)) == **(**Twchar_t)(__ccgo_up(r)) || Xtowlower(tls, **(**Twchar_t)(__ccgo_up(l))) == Xtowlower(tls, **(**Twchar_t)(__ccgo_up(r))))) { break } goto _2 @@ -147294,7 +147294,7 @@ func Xwcsncasecmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { r += 4 n = n - 1 } - return Int32FromUint32(Xtowlower(tls, *(*Twchar_t)(unsafe.Pointer(l))) - Xtowlower(tls, *(*Twchar_t)(unsafe.Pointer(r)))) + return Int32FromUint32(Xtowlower(tls, **(**Twchar_t)(__ccgo_up(l))) - Xtowlower(tls, **(**Twchar_t)(__ccgo_up(r)))) } func Xwcsncasecmp_l(tls *TLS, l uintptr, r uintptr, n Tsize_t, locale Tlocale_t) (r1 int32) { @@ -147314,17 +147314,17 @@ func Xwcsncat(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { _, _, _ = a, v1, v2 a = d d = d + uintptr(Xwcslen(tls, d))*4 - for n != 0 && *(*Twchar_t)(unsafe.Pointer(s)) != 0 { + for n != 0 && **(**Twchar_t)(__ccgo_up(s)) != 0 { n = n - 1 v1 = d d += 4 v2 = s s += 4 - *(*Twchar_t)(unsafe.Pointer(v1)) = *(*Twchar_t)(unsafe.Pointer(v2)) + **(**Twchar_t)(__ccgo_up(v1)) = **(**Twchar_t)(__ccgo_up(v2)) } v1 = d d += 4 - *(*Twchar_t)(unsafe.Pointer(v1)) = uint32(0) + **(**Twchar_t)(__ccgo_up(v1)) = uint32(0) return a } @@ -147336,7 +147336,7 @@ func Xwcsncmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { var v2, v3 int32 _, _ = v2, v3 for { - if !(n != 0 && *(*Twchar_t)(unsafe.Pointer(l)) == *(*Twchar_t)(unsafe.Pointer(r)) && *(*Twchar_t)(unsafe.Pointer(l)) != 0 && *(*Twchar_t)(unsafe.Pointer(r)) != 0) { + if !(n != 0 && **(**Twchar_t)(__ccgo_up(l)) == **(**Twchar_t)(__ccgo_up(r)) && **(**Twchar_t)(__ccgo_up(l)) != 0 && **(**Twchar_t)(__ccgo_up(r)) != 0) { break } goto _1 @@ -147347,10 +147347,10 @@ func Xwcsncmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { r += 4 } if n != 0 { - if *(*Twchar_t)(unsafe.Pointer(l)) < *(*Twchar_t)(unsafe.Pointer(r)) { + if **(**Twchar_t)(__ccgo_up(l)) < **(**Twchar_t)(__ccgo_up(r)) { v3 = -int32(1) } else { - v3 = BoolInt32(*(*Twchar_t)(unsafe.Pointer(l)) > *(*Twchar_t)(unsafe.Pointer(r))) + v3 = BoolInt32(**(**Twchar_t)(__ccgo_up(l)) > **(**Twchar_t)(__ccgo_up(r))) } v2 = v3 } else { @@ -147367,13 +147367,13 @@ func Xwcsncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { var a, v1, v2 uintptr _, _, _ = a, v1, v2 a = d - for n != 0 && *(*Twchar_t)(unsafe.Pointer(s)) != 0 { + for n != 0 && **(**Twchar_t)(__ccgo_up(s)) != 0 { n = n - 1 v1 = d d += 4 v2 = s s += 4 - *(*Twchar_t)(unsafe.Pointer(v1)) = *(*Twchar_t)(unsafe.Pointer(v2)) + **(**Twchar_t)(__ccgo_up(v1)) = **(**Twchar_t)(__ccgo_up(v2)) } Xwmemset(tls, d, uint32(0), n) return a @@ -147401,7 +147401,7 @@ func Xwcspbrk(tls *TLS, s uintptr, b uintptr) (r uintptr) { var v1 uintptr _ = v1 s = s + uintptr(Xwcscspn(tls, s, b))*4 - if *(*Twchar_t)(unsafe.Pointer(s)) != 0 { + if **(**Twchar_t)(__ccgo_up(s)) != 0 { v1 = s } else { v1 = UintptrFromInt32(0) @@ -147418,7 +147418,7 @@ func Xwcsrchr(tls *TLS, s uintptr, c Twchar_t) (r uintptr) { _, _ = p, v2 p = s + uintptr(Xwcslen(tls, s))*4 for { - if !(p >= s && *(*Twchar_t)(unsafe.Pointer(p)) != c) { + if !(p >= s && **(**Twchar_t)(__ccgo_up(p)) != c) { break } goto _1 @@ -147443,7 +147443,7 @@ func Xwcsspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { _ = a a = s for { - if !(*(*Twchar_t)(unsafe.Pointer(s)) != 0 && Xwcschr(tls, c, *(*Twchar_t)(unsafe.Pointer(s))) != 0) { + if !(**(**Twchar_t)(__ccgo_up(s)) != 0 && Xwcschr(tls, c, **(**Twchar_t)(__ccgo_up(s))) != 0) { break } goto _1 @@ -147462,7 +147462,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { /* Computing length of needle */ l = uint64(0) for { - if !(*(*Twchar_t)(unsafe.Pointer(n + uintptr(l)*4)) != 0 && *(*Twchar_t)(unsafe.Pointer(h + uintptr(l)*4)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(n + uintptr(l)*4)) != 0 && **(**Twchar_t)(__ccgo_up(h + uintptr(l)*4)) != 0) { break } goto _1 @@ -147470,7 +147470,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { ; l = l + 1 } - if *(*Twchar_t)(unsafe.Pointer(n + uintptr(l)*4)) != 0 { + if **(**Twchar_t)(__ccgo_up(n + uintptr(l)*4)) != 0 { return uintptr(0) } /* hit the end of h */ /* Compute maximal suffix */ @@ -147480,7 +147480,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { p = v2 k = v2 for jp+k < l { - if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) == *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { + if **(**Twchar_t)(__ccgo_up(n + uintptr(ip+k)*4)) == **(**Twchar_t)(__ccgo_up(n + uintptr(jp+k)*4)) { if k == p { jp = jp + p k = uint64(1) @@ -147488,7 +147488,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { k = k + 1 } } else { - if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) > *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { + if **(**Twchar_t)(__ccgo_up(n + uintptr(ip+k)*4)) > **(**Twchar_t)(__ccgo_up(n + uintptr(jp+k)*4)) { jp = jp + k k = uint64(1) p = jp - ip @@ -147511,7 +147511,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { p = v2 k = v2 for jp+k < l { - if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) == *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { + if **(**Twchar_t)(__ccgo_up(n + uintptr(ip+k)*4)) == **(**Twchar_t)(__ccgo_up(n + uintptr(jp+k)*4)) { if k == p { jp = jp + p k = uint64(1) @@ -147519,7 +147519,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { k = k + 1 } } else { - if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) < *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { + if **(**Twchar_t)(__ccgo_up(n + uintptr(ip+k)*4)) < **(**Twchar_t)(__ccgo_up(n + uintptr(jp+k)*4)) { jp = jp + k k = uint64(1) p = jp - ip @@ -147577,7 +147577,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { } k = v8 for { - if !(*(*Twchar_t)(unsafe.Pointer(n + uintptr(k)*4)) != 0 && *(*Twchar_t)(unsafe.Pointer(n + uintptr(k)*4)) == *(*Twchar_t)(unsafe.Pointer(h + uintptr(k)*4))) { + if !(**(**Twchar_t)(__ccgo_up(n + uintptr(k)*4)) != 0 && **(**Twchar_t)(__ccgo_up(n + uintptr(k)*4)) == **(**Twchar_t)(__ccgo_up(h + uintptr(k)*4))) { break } goto _10 @@ -147585,7 +147585,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { ; k = k + 1 } - if *(*Twchar_t)(unsafe.Pointer(n + uintptr(k)*4)) != 0 { + if **(**Twchar_t)(__ccgo_up(n + uintptr(k)*4)) != 0 { h = h + uintptr(k-ms)*4 mem = uint64(0) goto _9 @@ -147593,7 +147593,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { /* Compare left half */ k = ms + uint64(1) for { - if !(k > mem && *(*Twchar_t)(unsafe.Pointer(n + uintptr(k-uint64(1))*4)) == *(*Twchar_t)(unsafe.Pointer(h + uintptr(k-uint64(1))*4))) { + if !(k > mem && **(**Twchar_t)(__ccgo_up(n + uintptr(k-uint64(1))*4)) == **(**Twchar_t)(__ccgo_up(h + uintptr(k-uint64(1))*4))) { break } goto _12 @@ -147618,18 +147618,18 @@ func Xwcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { defer func() { trc("-> %v", r) }() } /* Return immediately on empty needle or haystack */ - if !(*(*Twchar_t)(unsafe.Pointer(n)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(n)) != 0) { return h } - if !(*(*Twchar_t)(unsafe.Pointer(h)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(h)) != 0) { return uintptr(0) } /* Use faster algorithms for short needles */ - h = Xwcschr(tls, h, *(*Twchar_t)(unsafe.Pointer(n))) - if !(h != 0) || !(*(*Twchar_t)(unsafe.Pointer(n + 1*4)) != 0) { + h = Xwcschr(tls, h, **(**Twchar_t)(__ccgo_up(n))) + if !(h != 0) || !(**(**Twchar_t)(__ccgo_up(n + 1*4)) != 0) { return h } - if !(*(*Twchar_t)(unsafe.Pointer(h + 1*4)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(h + 1*4)) != 0) { return uintptr(0) } return _twoway_wcsstr(tls, h, n) @@ -147644,26 +147644,26 @@ func Xwcstok(tls *TLS, s uintptr, sep uintptr, p uintptr) (r uintptr) { var v2 bool _, _, _ = v1, v2, v3 if v2 = !(s != 0); v2 { - v1 = *(*uintptr)(unsafe.Pointer(p)) + v1 = **(**uintptr)(__ccgo_up(p)) s = v1 } if v2 && !(v1 != 0) { return UintptrFromInt32(0) } s = s + uintptr(Xwcsspn(tls, s, sep))*4 - if !(*(*Twchar_t)(unsafe.Pointer(s)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(s)) != 0) { v1 = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(p)) = v1 + **(**uintptr)(__ccgo_up(p)) = v1 return v1 } - *(*uintptr)(unsafe.Pointer(p)) = s + uintptr(Xwcscspn(tls, s, sep))*4 - if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)))) != 0 { + **(**uintptr)(__ccgo_up(p)) = s + uintptr(Xwcscspn(tls, s, sep))*4 + if **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(p)))) != 0 { v3 = p v1 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) += 4 - *(*Twchar_t)(unsafe.Pointer(v1)) = uint32(0) + **(**Twchar_t)(__ccgo_up(v1)) = uint32(0) } else { - *(*uintptr)(unsafe.Pointer(p)) = uintptr(0) + **(**uintptr)(__ccgo_up(p)) = uintptr(0) } return s } @@ -147684,7 +147684,7 @@ func Xwmemchr(tls *TLS, s uintptr, c Twchar_t, n Tsize_t) (r uintptr) { var v2 uintptr _ = v2 for { - if !(n != 0 && *(*Twchar_t)(unsafe.Pointer(s)) != c) { + if !(n != 0 && **(**Twchar_t)(__ccgo_up(s)) != c) { break } goto _1 @@ -147709,7 +147709,7 @@ func Xwmemcmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { var v2, v3 int32 _, _ = v2, v3 for { - if !(n != 0 && *(*Twchar_t)(unsafe.Pointer(l)) == *(*Twchar_t)(unsafe.Pointer(r))) { + if !(n != 0 && **(**Twchar_t)(__ccgo_up(l)) == **(**Twchar_t)(__ccgo_up(r))) { break } goto _1 @@ -147720,10 +147720,10 @@ func Xwmemcmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { r += 4 } if n != 0 { - if *(*Twchar_t)(unsafe.Pointer(l)) < *(*Twchar_t)(unsafe.Pointer(r)) { + if **(**Twchar_t)(__ccgo_up(l)) < **(**Twchar_t)(__ccgo_up(r)) { v3 = -int32(1) } else { - v3 = BoolInt32(*(*Twchar_t)(unsafe.Pointer(l)) > *(*Twchar_t)(unsafe.Pointer(r))) + v3 = BoolInt32(**(**Twchar_t)(__ccgo_up(l)) > **(**Twchar_t)(__ccgo_up(r))) } v2 = v3 } else { @@ -147751,7 +147751,7 @@ func Xwmemcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { d += 4 v3 = s s += 4 - *(*Twchar_t)(unsafe.Pointer(v2)) = *(*Twchar_t)(unsafe.Pointer(v3)) + **(**Twchar_t)(__ccgo_up(v2)) = **(**Twchar_t)(__ccgo_up(v3)) } return a } @@ -147775,7 +147775,7 @@ func Xwmemmove(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { if !(v1 != 0) { break } - *(*Twchar_t)(unsafe.Pointer(d + uintptr(n)*4)) = *(*Twchar_t)(unsafe.Pointer(s + uintptr(n)*4)) + **(**Twchar_t)(__ccgo_up(d + uintptr(n)*4)) = **(**Twchar_t)(__ccgo_up(s + uintptr(n)*4)) } } else { for { @@ -147788,7 +147788,7 @@ func Xwmemmove(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { d += 4 v4 = s s += 4 - *(*Twchar_t)(unsafe.Pointer(v3)) = *(*Twchar_t)(unsafe.Pointer(v4)) + **(**Twchar_t)(__ccgo_up(v3)) = **(**Twchar_t)(__ccgo_up(v4)) } } return d0 @@ -147811,7 +147811,7 @@ func Xwmemset(tls *TLS, d uintptr, c Twchar_t, n Tsize_t) (r uintptr) { } v2 = d d += 4 - *(*Twchar_t)(unsafe.Pointer(v2)) = c + **(**Twchar_t)(__ccgo_up(v2)) = c } return ret } @@ -147827,7 +147827,7 @@ func Xmkdtemp(tls *TLS, template uintptr) (r uintptr) { l = _strlen(tls, template) retries = int32(100) if l < uint64(6) || Xmemcmp(tls, template+uintptr(l)-uintptr(6), __ccgo_ts+1730, uint64(6)) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } for { @@ -147840,7 +147840,7 @@ func Xmkdtemp(tls *TLS, template uintptr) (r uintptr) { ; retries = retries - 1 v1 = retries - if !(v1 != 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EEXIST)) { + if !(v1 != 0 && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EEXIST)) { break } } @@ -147868,7 +147868,7 @@ func X__mkostemps(tls *TLS, template uintptr, len1 int32, flags int32) (r int32) _, _, _, _ = fd, l, retries, v1 l = _strlen(tls, template) if l < uint64(6) || Uint64FromInt32(len1) > l-uint64(6) || Xmemcmp(tls, template+uintptr(l)-uintptr(len1)-uintptr(6), __ccgo_ts+1730, uint64(6)) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } flags = flags - flags&(Int32FromInt32(03)|Int32FromInt32(O_PATH)) @@ -147885,7 +147885,7 @@ func X__mkostemps(tls *TLS, template uintptr, len1 int32, flags int32) (r int32) ; retries = retries - 1 v1 = retries - if !(v1 != 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EEXIST)) { + if !(v1 != 0 && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EEXIST)) { break } } @@ -147931,15 +147931,15 @@ func Xmktemp(tls *TLS, template uintptr) (r uintptr) { l = _strlen(tls, template) retries = int32(100) if l < uint64(6) || Xmemcmp(tls, template+uintptr(l)-uintptr(6), __ccgo_ts+1730, uint64(6)) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) - *(*uint8)(unsafe.Pointer(template)) = uint8(0) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) + **(**uint8)(__ccgo_up(template)) = uint8(0) return template } for { ___randname(tls, template+uintptr(l)-uintptr(6)) if Xstat(tls, template, bp) != 0 { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(ENOENT) { - *(*uint8)(unsafe.Pointer(template)) = uint8(0) + if **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(ENOENT) { + **(**uint8)(__ccgo_up(template)) = uint8(0) } return template } @@ -147952,8 +147952,8 @@ func Xmktemp(tls *TLS, template uintptr) (r uintptr) { break } } - *(*uint8)(unsafe.Pointer(template)) = uint8(0) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EEXIST) + **(**uint8)(__ccgo_up(template)) = uint8(0) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EEXIST) return template } @@ -147977,13 +147977,13 @@ func Xcfmakeraw(tls *TLS, t uintptr) { if __ccgo_strace { trc("tls=%v t=%v, (%v:)", tls, t, origin(2)) } - *(*Ttcflag_t)(unsafe.Pointer(t)) &= Uint32FromInt32(^(Int32FromInt32(IGNBRK) | Int32FromInt32(BRKINT) | Int32FromInt32(PARMRK) | Int32FromInt32(ISTRIP) | Int32FromInt32(INLCR) | Int32FromInt32(IGNCR) | Int32FromInt32(ICRNL) | Int32FromInt32(IXON))) - *(*Ttcflag_t)(unsafe.Pointer(t + 4)) &= Uint32FromInt32(^Int32FromInt32(OPOST)) - *(*Ttcflag_t)(unsafe.Pointer(t + 12)) &= Uint32FromInt32(^(Int32FromInt32(ECHO) | Int32FromInt32(ECHONL) | Int32FromInt32(ICANON) | Int32FromInt32(ISIG) | Int32FromInt32(IEXTEN))) - *(*Ttcflag_t)(unsafe.Pointer(t + 8)) &= Uint32FromInt32(^(Int32FromInt32(CSIZE) | Int32FromInt32(PARENB))) - *(*Ttcflag_t)(unsafe.Pointer(t + 8)) |= uint32(CS8) - *(*Tcc_t)(unsafe.Pointer(t + 17 + 6)) = uint8(1) - *(*Tcc_t)(unsafe.Pointer(t + 17 + 5)) = uint8(0) + **(**Ttcflag_t)(__ccgo_up(t)) &= Uint32FromInt32(^(Int32FromInt32(IGNBRK) | Int32FromInt32(BRKINT) | Int32FromInt32(PARMRK) | Int32FromInt32(ISTRIP) | Int32FromInt32(INLCR) | Int32FromInt32(IGNCR) | Int32FromInt32(ICRNL) | Int32FromInt32(IXON))) + **(**Ttcflag_t)(__ccgo_up(t + 4)) &= Uint32FromInt32(^Int32FromInt32(OPOST)) + **(**Ttcflag_t)(__ccgo_up(t + 12)) &= Uint32FromInt32(^(Int32FromInt32(ECHO) | Int32FromInt32(ECHONL) | Int32FromInt32(ICANON) | Int32FromInt32(ISIG) | Int32FromInt32(IEXTEN))) + **(**Ttcflag_t)(__ccgo_up(t + 8)) &= Uint32FromInt32(^(Int32FromInt32(CSIZE) | Int32FromInt32(PARENB))) + **(**Ttcflag_t)(__ccgo_up(t + 8)) |= uint32(CS8) + **(**Tcc_t)(__ccgo_up(t + 17 + 6)) = uint8(1) + **(**Tcc_t)(__ccgo_up(t + 17 + 5)) = uint8(0) } func Xcfsetospeed(tls *TLS, tio uintptr, speed Tspeed_t) (r int32) { @@ -147992,11 +147992,11 @@ func Xcfsetospeed(tls *TLS, tio uintptr, speed Tspeed_t) (r int32) { defer func() { trc("-> %v", r) }() } if speed&Uint32FromInt32(^Int32FromInt32(CBAUD)) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } - *(*Ttcflag_t)(unsafe.Pointer(tio + 8)) &= Uint32FromInt32(^Int32FromInt32(CBAUD)) - *(*Ttcflag_t)(unsafe.Pointer(tio + 8)) |= speed + **(**Ttcflag_t)(__ccgo_up(tio + 8)) &= Uint32FromInt32(^Int32FromInt32(CBAUD)) + **(**Ttcflag_t)(__ccgo_up(tio + 8)) |= speed return 0 } @@ -148075,7 +148075,7 @@ func Xtcgetsid(tls *TLS, fd int32) (r Tpid_t) { if Xioctl(tls, fd, int32(TIOCGSID), VaList(bp+16, bp)) < 0 { return -int32(1) } - return *(*int32)(unsafe.Pointer(bp)) + return **(**int32)(__ccgo_up(bp)) } func Xtcgetwinsize(tls *TLS, fd int32, wsz uintptr) (r int32) { @@ -148105,7 +148105,7 @@ func Xtcsetattr(tls *TLS, fd int32, act int32, tio uintptr) (r int32) { bp := tls.Alloc(16) defer tls.Free(16) if act < 0 || act > int32(2) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } return Xioctl(tls, fd, int32(TCSETS)+act, VaList(bp+8, tio)) @@ -148136,8 +148136,8 @@ func X__map_file(tls *TLS, pathname uintptr, size uintptr) (r uintptr) { return uintptr(0) } if !(X__fstat(tls, fd, bp) != 0) { - map1 = X__mmap(tls, uintptr(0), Uint64FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_size), int32(PROT_READ), int32(MAP_SHARED), fd, 0) - *(*Tsize_t)(unsafe.Pointer(size)) = Uint64FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_size) + map1 = X__mmap(tls, uintptr(0), Uint64FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_size), int32(PROT_READ), int32(MAP_SHARED), fd, 0) + **(**Tsize_t)(__ccgo_up(size)) = Uint64FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_size) } X__syscall1(tls, int64(SYS_close), int64(fd)) if map1 == uintptr(-Int32FromInt32(1)) { @@ -148309,7 +148309,7 @@ func X__tm_to_secs(tls *TLS, tm uintptr) (r int64) { year = year + int64(adj) } t = X__year_to_secs(tls, year, bp) - t = t + int64(X__month_to_secs(tls, month, *(*int32)(unsafe.Pointer(bp)))) + t = t + int64(X__month_to_secs(tls, month, **(**int32)(__ccgo_up(bp)))) t = t + int64(86400)*int64((*Ttm)(unsafe.Pointer(tm)).Ftm_mday-Int32FromInt32(1)) t = t + int64(3600)*int64((*Ttm)(unsafe.Pointer(tm)).Ftm_hour) t = t + int64(60)*int64((*Ttm)(unsafe.Pointer(tm)).Ftm_min) @@ -148343,14 +148343,14 @@ func _getint2(tls *TLS, p uintptr) (r int32) { _ = x x = uint32(0) for { - if !(Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)))))-int32('0')) < uint32(10)) { + if !(Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)))))-int32('0')) < uint32(10)) { break } - x = Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)))))-int32('0')) + uint32(10)*x + x = Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)))))-int32('0')) + uint32(10)*x goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 } return Int32FromUint32(x) } @@ -148359,20 +148359,20 @@ func _getoff(tls *TLS, p uintptr) (r int32) { var neg, off, v1 int32 _, _, _ = neg, off, v1 neg = 0 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('-') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) == int32('-') { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 neg = int32(1) } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('+') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) == int32('+') { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 } } off = int32(3600) * _getint2(tls, p) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32(':') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) == int32(':') { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 off = off + int32(60)*_getint2(tls, p) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32(':') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) == int32(':') { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 off = off + _getint2(tls, p) } } @@ -148387,61 +148387,61 @@ func _getoff(tls *TLS, p uintptr) (r int32) { func _getrule(tls *TLS, p uintptr, rule uintptr) { var r, v1 int32 _, _ = r, v1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) - *(*int32)(unsafe.Pointer(rule)) = v1 + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) + **(**int32)(__ccgo_up(rule)) = v1 r = v1 if r != int32('M') { if r == int32('J') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 } else { - *(*int32)(unsafe.Pointer(rule)) = 0 + **(**int32)(__ccgo_up(rule)) = 0 } - *(*int32)(unsafe.Pointer(rule + 1*4)) = _getint2(tls, p) + **(**int32)(__ccgo_up(rule + 1*4)) = _getint2(tls, p) } else { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 - *(*int32)(unsafe.Pointer(rule + 1*4)) = _getint2(tls, p) - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 - *(*int32)(unsafe.Pointer(rule + 2*4)) = _getint2(tls, p) - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 - *(*int32)(unsafe.Pointer(rule + 3*4)) = _getint2(tls, p) - } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('/') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 - *(*int32)(unsafe.Pointer(rule + 4*4)) = _getoff(tls, p) + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 + **(**int32)(__ccgo_up(rule + 1*4)) = _getint2(tls, p) + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 + **(**int32)(__ccgo_up(rule + 2*4)) = _getint2(tls, p) + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 + **(**int32)(__ccgo_up(rule + 3*4)) = _getint2(tls, p) + } + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) == int32('/') { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 + **(**int32)(__ccgo_up(rule + 4*4)) = _getoff(tls, p) } else { - *(*int32)(unsafe.Pointer(rule + 4*4)) = int32(7200) + **(**int32)(__ccgo_up(rule + 4*4)) = int32(7200) } } func _getname(tls *TLS, d uintptr, p uintptr) { var i, v3 int32 _, _ = i, v3 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('<') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) == int32('<') { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 i = 0 for { - if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i)))) != int32('>')) { + if !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)) + uintptr(i))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)) + uintptr(i)))) != int32('>')) { break } if i < int32(TZNAME_MAX) { - *(*uint8)(unsafe.Pointer(d + uintptr(i))) = *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))) + **(**uint8)(__ccgo_up(d + uintptr(i))) = **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)) + uintptr(i))) } goto _1 _1: ; i = i + 1 } - if *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))) != 0 { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + if **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)) + uintptr(i))) != 0 { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 } } else { i = 0 for { - if !(Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))))|int32(32)-int32('a')) < uint32(26)) { + if !(Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)) + uintptr(i))))|int32(32)-int32('a')) < uint32(26)) { break } if i < int32(TZNAME_MAX) { - *(*uint8)(unsafe.Pointer(d + uintptr(i))) = *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))) + **(**uint8)(__ccgo_up(d + uintptr(i))) = **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)) + uintptr(i))) } goto _2 _2: @@ -148449,17 +148449,17 @@ func _getname(tls *TLS, d uintptr, p uintptr) { i = i + 1 } } - *(*uintptr)(unsafe.Pointer(p)) += uintptr(i) + **(**uintptr)(__ccgo_up(p)) += uintptr(i) if i < int32(TZNAME_MAX) { v3 = i } else { v3 = int32(TZNAME_MAX) } - *(*uint8)(unsafe.Pointer(d + uintptr(v3))) = uint8(0) + **(**uint8)(__ccgo_up(d + uintptr(v3))) = uint8(0) } func _zi_read32(tls *TLS, z uintptr) (r Tuint32_t) { - return uint32(*(*uint8)(unsafe.Pointer(z)))< Uint64FromInt32(Int32FromInt32(PATH_MAX)+Int32FromInt32(1)) { - *(*uintptr)(unsafe.Pointer(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) + **(**uintptr)(__ccgo_up(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) i = Uint64FromInt32(3) } if i >= _old_tz_size { @@ -148542,13 +148542,13 @@ func _do_tzset(tls *TLS) { _old_tz = Xmalloc(tls, _old_tz_size) } if _old_tz != 0 { - Xmemcpy(tls, _old_tz, *(*uintptr)(unsafe.Pointer(bp + 288)), i+uint64(1)) + Xmemcpy(tls, _old_tz, **(**uintptr)(__ccgo_up(bp + 288)), i+uint64(1)) } posix_form = 0 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) != int32(':') { - *(*uintptr)(unsafe.Pointer(bp + 296)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) != int32(':') { + **(**uintptr)(__ccgo_up(bp + 296)) = **(**uintptr)(__ccgo_up(bp + 288)) _getname(tls, bp+308, bp+296) - if *(*uintptr)(unsafe.Pointer(bp + 296)) != *(*uintptr)(unsafe.Pointer(bp + 288)) && (Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 296))))) == int32('+') || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 296))))) == int32('-') || BoolInt32(uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 296)))))-uint32('0') < uint32(10)) != 0 || !(Xstrcmp(tls, bp+308, __ccgo_ts+1755) != 0) || !(Xstrcmp(tls, bp+308, __ccgo_ts+1759) != 0)) { + if **(**uintptr)(__ccgo_up(bp + 296)) != **(**uintptr)(__ccgo_up(bp + 288)) && (Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 296))))) == int32('+') || Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 296))))) == int32('-') || BoolInt32(uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 296)))))-uint32('0') < uint32(10)) != 0 || !(Xstrcmp(tls, bp+308, __ccgo_ts+1755) != 0) || !(Xstrcmp(tls, bp+308, __ccgo_ts+1759) != 0)) { posix_form = int32(1) } } @@ -148556,21 +148556,21 @@ func _do_tzset(tls *TLS) { * pathame beginning with "."; in secure mode, only the * standard path will be searched. */ if !(posix_form != 0) { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32(':') { - *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32(':') { + **(**uintptr)(__ccgo_up(bp + 288)) = **(**uintptr)(__ccgo_up(bp + 288)) + 1 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32('/') || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32('.') { - if !(X__libc.Fsecure != 0) || !(Xstrcmp(tls, *(*uintptr)(unsafe.Pointer(bp + 288)), __ccgo_ts+1740) != 0) { - map1 = X__map_file(tls, *(*uintptr)(unsafe.Pointer(bp + 288)), uintptr(unsafe.Pointer(&_map_size))) + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32('/') || Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32('.') { + if !(X__libc.Fsecure != 0) || !(Xstrcmp(tls, **(**uintptr)(__ccgo_up(bp + 288)), __ccgo_ts+1740) != 0) { + map1 = X__map_file(tls, **(**uintptr)(__ccgo_up(bp + 288)), uintptr(unsafe.Pointer(&_map_size))) } } else { - l = _strlen(tls, *(*uintptr)(unsafe.Pointer(bp + 288))) - if l <= uint64(NAME_MAX) && !(Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp + 288)), int32('.')) != 0) { - Xmemcpy(tls, pathname, *(*uintptr)(unsafe.Pointer(bp + 288)), l+uint64(1)) - *(*uint8)(unsafe.Pointer(pathname + uintptr(l))) = uint8(0) + l = _strlen(tls, **(**uintptr)(__ccgo_up(bp + 288))) + if l <= uint64(NAME_MAX) && !(Xstrchr(tls, **(**uintptr)(__ccgo_up(bp + 288)), int32('.')) != 0) { + Xmemcpy(tls, pathname, **(**uintptr)(__ccgo_up(bp + 288)), l+uint64(1)) + **(**uint8)(__ccgo_up(pathname + uintptr(l))) = uint8(0) try = uintptr(unsafe.Pointer(&_search)) for { - if !(!(map1 != 0) && *(*uint8)(unsafe.Pointer(try)) != 0) { + if !(!(map1 != 0) && **(**uint8)(__ccgo_up(try)) != 0) { break } l = _strlen(tls, try) @@ -148584,18 +148584,18 @@ func _do_tzset(tls *TLS) { } } if !(map1 != 0) { - *(*uintptr)(unsafe.Pointer(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) + **(**uintptr)(__ccgo_up(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) } } if map1 != 0 && (_map_size < uint64(44) || Xmemcmp(tls, map1, __ccgo_ts+1763, uint64(4)) != 0) { X__munmap(tls, map1, _map_size) map1 = uintptr(0) - *(*uintptr)(unsafe.Pointer(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) + **(**uintptr)(__ccgo_up(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) } _zi = map1 if map1 != 0 { scale = int32(2) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(map1 + 4))) != int32('1') { + if Int32FromUint8(**(**uint8)(__ccgo_up(map1 + 4))) != int32('1') { *(*[6]uint8)(unsafe.Pointer(bp)) = [6]uint8{ 0: uint8(1), 1: uint8(1), @@ -148614,18 +148614,18 @@ func _do_tzset(tls *TLS) { _types = _index + uintptr(_zi_read32(tls, _trans-uintptr(12))) _abbrevs = _types + uintptr(uint32(6)*_zi_read32(tls, _trans-uintptr(8))) _abbrevs_end = _abbrevs + uintptr(_zi_read32(tls, _trans-uintptr(4))) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(_zi + uintptr(_map_size-uint64(1))))) == int32('\n') { - *(*uintptr)(unsafe.Pointer(bp + 288)) = _zi + uintptr(_map_size) - uintptr(2) + if Int32FromUint8(**(**uint8)(__ccgo_up(_zi + uintptr(_map_size-uint64(1))))) == int32('\n') { + **(**uintptr)(__ccgo_up(bp + 288)) = _zi + uintptr(_map_size) - uintptr(2) for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) != int32('\n')) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) != int32('\n')) { break } goto _4 _4: ; - *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) - 1 + **(**uintptr)(__ccgo_up(bp + 288)) = **(**uintptr)(__ccgo_up(bp + 288)) - 1 } - *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 + **(**uintptr)(__ccgo_up(bp + 288)) = **(**uintptr)(__ccgo_up(bp + 288)) + 1 } else { v5 = UintptrFromInt32(0) Xtzname[int32(1)] = v5 @@ -148640,12 +148640,12 @@ func _do_tzset(tls *TLS) { if !(p1 < _abbrevs) { break } - if !(*(*uint8)(unsafe.Pointer(p1 + 4)) != 0) && !(Xtzname[0] != 0) { - Xtzname[0] = _abbrevs + uintptr(*(*uint8)(unsafe.Pointer(p1 + 5))) + if !(**(**uint8)(__ccgo_up(p1 + 4)) != 0) && !(Xtzname[0] != 0) { + Xtzname[0] = _abbrevs + uintptr(**(**uint8)(__ccgo_up(p1 + 5))) Xtimezone = Int64FromUint32(-_zi_read32(tls, p1)) } - if *(*uint8)(unsafe.Pointer(p1 + 4)) != 0 && !(Xtzname[int32(1)] != 0) { - Xtzname[int32(1)] = _abbrevs + uintptr(*(*uint8)(unsafe.Pointer(p1 + 5))) + if **(**uint8)(__ccgo_up(p1 + 4)) != 0 && !(Xtzname[int32(1)] != 0) { + Xtzname[int32(1)] = _abbrevs + uintptr(**(**uint8)(__ccgo_up(p1 + 5))) _dst_off = Int32FromUint32(-_zi_read32(tls, p1)) Xdaylight = int32(1) } @@ -148667,8 +148667,8 @@ func _do_tzset(tls *TLS) { return } } - if !(*(*uintptr)(unsafe.Pointer(bp + 288)) != 0) { - *(*uintptr)(unsafe.Pointer(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) + if !(**(**uintptr)(__ccgo_up(bp + 288)) != 0) { + **(**uintptr)(__ccgo_up(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) } _getname(tls, uintptr(unsafe.Pointer(&_std_name)), bp+288) Xtzname[0] = uintptr(unsafe.Pointer(&_std_name)) @@ -148677,7 +148677,7 @@ func _do_tzset(tls *TLS) { Xtzname[int32(1)] = uintptr(unsafe.Pointer(&_dst_name)) if _dst_name[0] != 0 { Xdaylight = int32(1) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32('+') || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32('-') || Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288)))))-int32('0')) < uint32(10) { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32('+') || Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32('-') || Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288)))))-int32('0')) < uint32(10) { _dst_off = _getoff(tls, bp+288) } else { _dst_off = int32(Xtimezone - int64(3600)) @@ -148686,12 +148686,12 @@ func _do_tzset(tls *TLS) { Xdaylight = 0 _dst_off = int32(Xtimezone) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32(',') { - *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32(',') { + **(**uintptr)(__ccgo_up(bp + 288)) = **(**uintptr)(__ccgo_up(bp + 288)) + 1 _getrule(tls, bp+288, uintptr(unsafe.Pointer(&_r0))) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32(',') { - *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32(',') { + **(**uintptr)(__ccgo_up(bp + 288)) = **(**uintptr)(__ccgo_up(bp + 288)) + 1 _getrule(tls, bp+288, uintptr(unsafe.Pointer(&_r12))) } } @@ -148712,7 +148712,7 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { n = Uint64FromInt64((int64(_index) - int64(_trans)) >> scale) if !(n != 0) { if alt != 0 { - *(*Tsize_t)(unsafe.Pointer(alt)) = uint64(0) + **(**Tsize_t)(__ccgo_up(alt)) = uint64(0) } return uint64(0) } @@ -148726,7 +148726,7 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { x = Uint64FromInt32(Int32FromUint64(x)) } if local != 0 { - off = Int32FromUint32(_zi_read32(tls, _types+uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(m-uint64(1)))))))) + off = Int32FromUint32(_zi_read32(tls, _types+uintptr(int32(6)*Int32FromUint8(**(**uint8)(__ccgo_up(_index + uintptr(m-uint64(1)))))))) } if t-int64(off) < int64(Int64FromUint64(x)) { n = n / uint64(2) @@ -148755,7 +148755,7 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { if !(i != 0) { break } - if !(*(*uint8)(unsafe.Pointer(_types + uintptr(i-uint64(6)+uint64(4)))) != 0) { + if !(**(**uint8)(__ccgo_up(_types + uintptr(i-uint64(6)+uint64(4)))) != 0) { j = i - uint64(6) } goto _1 @@ -148770,24 +148770,24 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { * and the index-zero (after transition) type as the alt. */ if t-int64(off) < int64(Int64FromUint64(x)) { if alt != 0 { - *(*Tsize_t)(unsafe.Pointer(alt)) = uint64(*(*uint8)(unsafe.Pointer(_index))) + **(**Tsize_t)(__ccgo_up(alt)) = uint64(**(**uint8)(__ccgo_up(_index))) } return j / uint64(6) } } /* Try to find a neighboring opposite-DST-status rule. */ if alt != 0 { - if a != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(_types + uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(a-uint64(1)))))+int32(4))))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(_types + uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(a))))+int32(4))))) { - *(*Tsize_t)(unsafe.Pointer(alt)) = uint64(*(*uint8)(unsafe.Pointer(_index + uintptr(a-uint64(1))))) + if a != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(_types + uintptr(int32(6)*Int32FromUint8(**(**uint8)(__ccgo_up(_index + uintptr(a-uint64(1)))))+int32(4))))) != Int32FromUint8(**(**uint8)(__ccgo_up(_types + uintptr(int32(6)*Int32FromUint8(**(**uint8)(__ccgo_up(_index + uintptr(a))))+int32(4))))) { + **(**Tsize_t)(__ccgo_up(alt)) = uint64(**(**uint8)(__ccgo_up(_index + uintptr(a-uint64(1))))) } else { - if a+uint64(1) < n && Int32FromUint8(*(*uint8)(unsafe.Pointer(_types + uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(a+uint64(1)))))+int32(4))))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(_types + uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(a))))+int32(4))))) { - *(*Tsize_t)(unsafe.Pointer(alt)) = uint64(*(*uint8)(unsafe.Pointer(_index + uintptr(a+uint64(1))))) + if a+uint64(1) < n && Int32FromUint8(**(**uint8)(__ccgo_up(_types + uintptr(int32(6)*Int32FromUint8(**(**uint8)(__ccgo_up(_index + uintptr(a+uint64(1)))))+int32(4))))) != Int32FromUint8(**(**uint8)(__ccgo_up(_types + uintptr(int32(6)*Int32FromUint8(**(**uint8)(__ccgo_up(_index + uintptr(a))))+int32(4))))) { + **(**Tsize_t)(__ccgo_up(alt)) = uint64(**(**uint8)(__ccgo_up(_index + uintptr(a+uint64(1))))) } else { - *(*Tsize_t)(unsafe.Pointer(alt)) = uint64(*(*uint8)(unsafe.Pointer(_index + uintptr(a)))) + **(**Tsize_t)(__ccgo_up(alt)) = uint64(**(**uint8)(__ccgo_up(_index + uintptr(a)))) } } } - return uint64(*(*uint8)(unsafe.Pointer(_index + uintptr(a)))) + return uint64(**(**uint8)(__ccgo_up(_index + uintptr(a)))) } func _days_in_month1(tls *TLS, m int32, is_leap int32) (r int32) { @@ -148809,28 +148809,28 @@ func _rule_to_secs(tls *TLS, rule uintptr, year int32) (r int64) { var _ /* is_leap at bp+0 */ int32 _, _, _, _, _, _, _ = d, days, m, n, t, wday, x t = X__year_to_secs(tls, int64(year), bp) - if *(*int32)(unsafe.Pointer(rule)) != int32('M') { - x = *(*int32)(unsafe.Pointer(rule + 1*4)) - if *(*int32)(unsafe.Pointer(rule)) == int32('J') && (x < int32(60) || !(*(*int32)(unsafe.Pointer(bp)) != 0)) { + if **(**int32)(__ccgo_up(rule)) != int32('M') { + x = **(**int32)(__ccgo_up(rule + 1*4)) + if **(**int32)(__ccgo_up(rule)) == int32('J') && (x < int32(60) || !(**(**int32)(__ccgo_up(bp)) != 0)) { x = x - 1 } t = t + int64(int32(86400)*x) } else { - m = *(*int32)(unsafe.Pointer(rule + 1*4)) - n = *(*int32)(unsafe.Pointer(rule + 2*4)) - d = *(*int32)(unsafe.Pointer(rule + 3*4)) - t = t + int64(X__month_to_secs(tls, m-int32(1), *(*int32)(unsafe.Pointer(bp)))) + m = **(**int32)(__ccgo_up(rule + 1*4)) + n = **(**int32)(__ccgo_up(rule + 2*4)) + d = **(**int32)(__ccgo_up(rule + 3*4)) + t = t + int64(X__month_to_secs(tls, m-int32(1), **(**int32)(__ccgo_up(bp)))) wday = int32((t+int64(Int32FromInt32(4)*Int32FromInt32(86400)))%int64(Int32FromInt32(7)*Int32FromInt32(86400))) / int32(86400) days = d - wday if days < 0 { days = days + int32(7) } - if n == int32(5) && days+int32(28) >= _days_in_month1(tls, m, *(*int32)(unsafe.Pointer(bp))) { + if n == int32(5) && days+int32(28) >= _days_in_month1(tls, m, **(**int32)(__ccgo_up(bp))) { n = int32(4) } t = t + int64(int32(86400)*(days+int32(7)*(n-int32(1)))) } - t = t + int64(*(*int32)(unsafe.Pointer(rule + 4*4))) + t = t + int64(**(**int32)(__ccgo_up(rule + 4*4))) return t } @@ -148856,11 +148856,11 @@ func X__secs_to_zone(tls *TLS, t int64, local int32, isdst uintptr, offset uintp if _zi != 0 { i = _scan_trans(tls, t, local, bp) if i != Uint64FromInt32(-Int32FromInt32(1)) { - *(*int32)(unsafe.Pointer(isdst)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(_types + uintptr(uint64(6)*i+uint64(4))))) - *(*int64)(unsafe.Pointer(offset)) = int64(Int32FromUint32(_zi_read32(tls, _types+uintptr(uint64(6)*i)))) - *(*uintptr)(unsafe.Pointer(zonename)) = _abbrevs + uintptr(*(*uint8)(unsafe.Pointer(_types + uintptr(uint64(6)*i+uint64(5))))) + **(**int32)(__ccgo_up(isdst)) = Int32FromUint8(**(**uint8)(__ccgo_up(_types + uintptr(uint64(6)*i+uint64(4))))) + **(**int64)(__ccgo_up(offset)) = int64(Int32FromUint32(_zi_read32(tls, _types+uintptr(uint64(6)*i)))) + **(**uintptr)(__ccgo_up(zonename)) = _abbrevs + uintptr(**(**uint8)(__ccgo_up(_types + uintptr(uint64(6)*i+uint64(5))))) if oppoff != 0 { - *(*int64)(unsafe.Pointer(oppoff)) = int64(Int32FromUint32(_zi_read32(tls, _types+uintptr(uint64(6)**(*Tsize_t)(unsafe.Pointer(bp)))))) + **(**int64)(__ccgo_up(oppoff)) = int64(Int32FromUint32(_zi_read32(tls, _types+uintptr(uint64(6)***(**Tsize_t)(__ccgo_up(bp)))))) } ___unlock(tls, uintptr(unsafe.Pointer(&_lock4))) return @@ -148898,23 +148898,23 @@ func X__secs_to_zone(tls *TLS, t int64, local int32, isdst uintptr, offset uintp goto std std: ; - *(*int32)(unsafe.Pointer(isdst)) = 0 - *(*int64)(unsafe.Pointer(offset)) = -Xtimezone + **(**int32)(__ccgo_up(isdst)) = 0 + **(**int64)(__ccgo_up(offset)) = -Xtimezone if oppoff != 0 { - *(*int64)(unsafe.Pointer(oppoff)) = int64(-_dst_off) + **(**int64)(__ccgo_up(oppoff)) = int64(-_dst_off) } - *(*uintptr)(unsafe.Pointer(zonename)) = Xtzname[0] + **(**uintptr)(__ccgo_up(zonename)) = Xtzname[0] ___unlock(tls, uintptr(unsafe.Pointer(&_lock4))) return goto dst dst: ; - *(*int32)(unsafe.Pointer(isdst)) = int32(1) - *(*int64)(unsafe.Pointer(offset)) = int64(-_dst_off) + **(**int32)(__ccgo_up(isdst)) = int32(1) + **(**int64)(__ccgo_up(offset)) = int64(-_dst_off) if oppoff != 0 { - *(*int64)(unsafe.Pointer(oppoff)) = -Xtimezone + **(**int64)(__ccgo_up(oppoff)) = -Xtimezone } - *(*uintptr)(unsafe.Pointer(zonename)) = Xtzname[int32(1)] + **(**uintptr)(__ccgo_up(zonename)) = Xtzname[int32(1)] ___unlock(tls, uintptr(unsafe.Pointer(&_lock4))) } @@ -148957,11 +148957,11 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { if !((y-Int32FromInt32(68))&Int32FromInt32(3) != 0) { leaps = leaps - 1 if is_leap != 0 { - *(*int32)(unsafe.Pointer(is_leap)) = int32(1) + **(**int32)(__ccgo_up(is_leap)) = int32(1) } } else { if is_leap != 0 { - *(*int32)(unsafe.Pointer(is_leap)) = 0 + **(**int32)(__ccgo_up(is_leap)) = 0 } } return int64(int32(31536000)*(y-int32(70)) + int32(86400)*leaps) @@ -148976,7 +148976,7 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { rem = rem + int32(400) } if !(rem != 0) { - *(*int32)(unsafe.Pointer(is_leap)) = int32(1) + **(**int32)(__ccgo_up(is_leap)) = int32(1) centuries = 0 leaps1 = 0 } else { @@ -148997,15 +148997,15 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { } } if !(rem != 0) { - *(*int32)(unsafe.Pointer(is_leap)) = 0 + **(**int32)(__ccgo_up(is_leap)) = 0 leaps1 = 0 } else { leaps1 = Int32FromUint32(Uint32FromInt32(rem) / uint32(4)) rem = Int32FromUint32(uint32(rem) % Uint32FromUint32(4)) - *(*int32)(unsafe.Pointer(is_leap)) = BoolInt32(!(rem != 0)) + **(**int32)(__ccgo_up(is_leap)) = BoolInt32(!(rem != 0)) } } - leaps1 = leaps1 + (int32(97)*cycles + int32(24)*centuries - *(*int32)(unsafe.Pointer(is_leap))) + leaps1 = leaps1 + (int32(97)*cycles + int32(24)*centuries - **(**int32)(__ccgo_up(is_leap))) return (year-int64(100))*int64(31536000) + int64(leaps1)*int64(86400) + int64(946684800) + int64(86400) } @@ -149034,7 +149034,7 @@ func X__asctime_r(tls *TLS, tm uintptr, buf uintptr) (r uintptr) { * application developers that they may not be so lucky * on other implementations (e.g. stack smashing..). */ - *(*uint8)(unsafe.Pointer(UintptrFromInt32(0))) = uint8(0) + **(**uint8)(__ccgo_up(UintptrFromInt32(0))) = uint8(0) } return buf } @@ -149067,10 +149067,10 @@ func Xclock(tls *TLS) (r Tclock_t) { if X__clock_gettime(tls, int32(CLOCK_PROCESS_CPUTIME_ID), bp) != 0 { return int64(-int32(1)) } - if (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec > Int64FromInt64(0x7fffffffffffffff)/Int64FromInt32(1000000) || (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_nsec/int64(1000) > int64(0x7fffffffffffffff)-int64(1000000)*(*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec { + if (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec > Int64FromInt64(0x7fffffffffffffff)/Int64FromInt32(1000000) || (**(**Ttimespec)(__ccgo_up(bp))).Ftv_nsec/int64(1000) > int64(0x7fffffffffffffff)-int64(1000000)*(**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec { return int64(-int32(1)) } - return (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec*int64(1000000) + (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_nsec/int64(1000) + return (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec*int64(1000000) + (**(**Ttimespec)(__ccgo_up(bp))).Ftv_nsec/int64(1000) } func Xclock_getcpuclockid(tls *TLS, pid Tpid_t, clk uintptr) (r int32) { @@ -149092,7 +149092,7 @@ func Xclock_getcpuclockid(tls *TLS, pid Tpid_t, clk uintptr) (r int32) { if ret != 0 { return -ret } - *(*Tclockid_t)(unsafe.Pointer(clk)) = id + **(**Tclockid_t)(__ccgo_up(clk)) = id return 0 } @@ -149222,8 +149222,8 @@ func Xftime(tls *TLS, tp uintptr) (r int32) { var _ /* ts at bp+0 */ Ttimespec _ = v1 Xclock_gettime(tls, CLOCK_REALTIME, bp) - (*Ttimeb)(unsafe.Pointer(tp)).Ftime = (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec - (*Ttimeb)(unsafe.Pointer(tp)).Fmillitm = Uint16FromInt64((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_nsec / int64(1000000)) + (*Ttimeb)(unsafe.Pointer(tp)).Ftime = (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec + (*Ttimeb)(unsafe.Pointer(tp)).Fmillitm = Uint16FromInt64((**(**Ttimespec)(__ccgo_up(bp))).Ftv_nsec / int64(1000000)) v1 = Int16FromInt32(0) (*Ttimeb)(unsafe.Pointer(tp)).Fdstflag = v1 (*Ttimeb)(unsafe.Pointer(tp)).Ftimezone = v1 @@ -149251,7 +149251,7 @@ func Xgetdate(tls *TLS, s uintptr) (r uintptr) { } f = Xfopen(tls, datemsk, __ccgo_ts+315) if !(f != 0) { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENOMEM) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENOMEM) { Xgetdate_err = int32(6) } else { Xgetdate_err = int32(2) @@ -149260,7 +149260,7 @@ func Xgetdate(tls *TLS, s uintptr) (r uintptr) { } for Xfgets(tls, bp, int32(100), f) != 0 { p = Xstrptime(tls, s, bp, uintptr(unsafe.Pointer(&_tmbuf))) - if p != 0 && !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if p != 0 && !(**(**uint8)(__ccgo_up(p)) != 0) { ret = uintptr(unsafe.Pointer(&_tmbuf)) goto out } @@ -149276,7 +149276,7 @@ out: if f != 0 { Xfclose(tls, f) } - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 100)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 100)), uintptr(0)) return ret } @@ -149294,8 +149294,8 @@ func Xgettimeofday(tls *TLS, tv uintptr, tz uintptr) (r int32) { return 0 } Xclock_gettime(tls, CLOCK_REALTIME, bp) - (*Ttimeval)(unsafe.Pointer(tv)).Ftv_sec = (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec - (*Ttimeval)(unsafe.Pointer(tv)).Ftv_usec = int64(int32((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_nsec) / int32(1000)) + (*Ttimeval)(unsafe.Pointer(tv)).Ftv_sec = (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec + (*Ttimeval)(unsafe.Pointer(tv)).Ftv_usec = int64(int32((**(**Ttimespec)(__ccgo_up(bp))).Ftv_nsec) / int32(1000)) return 0 } @@ -149314,8 +149314,8 @@ func X__gmtime_r(tls *TLS, t uintptr, tm uintptr) (r uintptr) { trc("tls=%v t=%v tm=%v, (%v:)", tls, t, tm, origin(2)) defer func() { trc("-> %v", r) }() } - if X__secs_to_tm(tls, *(*Ttime_t)(unsafe.Pointer(t)), tm) < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + if X__secs_to_tm(tls, int64(**(**Ttime_t)(__ccgo_up(t))), tm) < 0 { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return uintptr(0) } (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst = 0 @@ -149358,13 +149358,13 @@ func X__localtime_r(tls *TLS, t uintptr, tm uintptr) (r uintptr) { } /* Reject time_t values whose year would overflow int because * __secs_to_zone cannot safely handle them. */ - if *(*Ttime_t)(unsafe.Pointer(t)) < int64(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff))*Int64FromInt64(31622400) || *(*Ttime_t)(unsafe.Pointer(t)) > Int64FromInt32(INT_MAX)*Int64FromInt64(31622400) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + if int64(**(**Ttime_t)(__ccgo_up(t))) < int64(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff))*Int64FromInt64(31622400) || int64(**(**Ttime_t)(__ccgo_up(t))) > Int64FromInt32(INT_MAX)*Int64FromInt64(31622400) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return uintptr(0) } - X__secs_to_zone(tls, *(*Ttime_t)(unsafe.Pointer(t)), 0, tm+32, tm+40, uintptr(0), tm+48) - if X__secs_to_tm(tls, *(*Ttime_t)(unsafe.Pointer(t))+(*Ttm)(unsafe.Pointer(tm)).F__tm_gmtoff, tm) < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + X__secs_to_zone(tls, int64(**(**Ttime_t)(__ccgo_up(t))), 0, tm+32, tm+40, uintptr(0), tm+48) + if X__secs_to_tm(tls, int64(**(**Ttime_t)(__ccgo_up(t)))+(*Ttm)(unsafe.Pointer(tm)).F__tm_gmtoff, tm) < 0 { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return uintptr(0) } return tm @@ -149400,23 +149400,23 @@ func Xmktime(tls *TLS, tm uintptr) (r Ttime_t) { _ = t t = X__tm_to_secs(tls, tm) X__secs_to_zone(tls, t, int32(1), bp+32, bp+40, bp+56, bp+48) - if (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst >= 0 && (*(*Ttm)(unsafe.Pointer(bp))).Ftm_isdst != (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst { - t = t - (*(*int64)(unsafe.Pointer(bp + 56)) - (*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff) + if (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst >= 0 && (**(**Ttm)(__ccgo_up(bp))).Ftm_isdst != (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst { + t = t - int64(**(**int64)(__ccgo_up(bp + 56))-(**(**Ttm)(__ccgo_up(bp))).F__tm_gmtoff) } - t = t - (*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff + t = t - int64((**(**Ttm)(__ccgo_up(bp))).F__tm_gmtoff) if t != t { goto error } X__secs_to_zone(tls, t, 0, bp+32, bp+40, bp+56, bp+48) - if X__secs_to_tm(tls, t+(*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff, bp) < 0 { + if X__secs_to_tm(tls, t+int64((**(**Ttm)(__ccgo_up(bp))).F__tm_gmtoff), bp) < 0 { goto error } - *(*Ttm)(unsafe.Pointer(tm)) = *(*Ttm)(unsafe.Pointer(bp)) + **(**Ttm)(__ccgo_up(tm)) = **(**Ttm)(__ccgo_up(bp)) return t goto error error: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return int64(-int32(1)) } @@ -149577,7 +149577,7 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc val = int64((*Ttm)(unsafe.Pointer(tm)).Ftm_min) goto number case int32('n'): - *(*Tsize_t)(unsafe.Pointer(l)) = uint64(1) + **(**Tsize_t)(__ccgo_up(l)) = uint64(1) return __ccgo_ts + 301 case int32('p'): if (*Ttm)(unsafe.Pointer(tm)).Ftm_hour >= int32(12) { @@ -149596,20 +149596,20 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc item = v1 fmt = X__nl_langinfo_l(tls, item, loc) d = s - *(*Tsize_t)(unsafe.Pointer(l)) = uint64(0) + **(**Tsize_t)(__ccgo_up(l)) = uint64(0) for { - if !(*(*uint8)(unsafe.Pointer(fmt)) != 0) { + if !(**(**uint8)(__ccgo_up(fmt)) != 0) { break } v4 = d d = d + 1 v5 = fmt fmt = fmt + 1 - *(*uint8)(unsafe.Pointer(v4)) = Uint8FromInt32(Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))))) + **(**uint8)(__ccgo_up(v4)) = Uint8FromInt32(Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(v5))))) goto _3 _3: ; - *(*Tsize_t)(unsafe.Pointer(l)) = *(*Tsize_t)(unsafe.Pointer(l)) + 1 + **(**Tsize_t)(__ccgo_up(l)) = **(**Tsize_t)(__ccgo_up(l)) + 1 } return s case int32('r'): @@ -149626,7 +149626,7 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc val = int64((*Ttm)(unsafe.Pointer(tm)).Ftm_sec) goto number case int32('t'): - *(*Tsize_t)(unsafe.Pointer(l)) = uint64(1) + **(**Tsize_t)(__ccgo_up(l)) = uint64(1) return __ccgo_ts + 1400 case int32('T'): fmt = __ccgo_ts + 1832 @@ -149668,27 +149668,27 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc case int32('Y'): val = int64((*Ttm)(unsafe.Pointer(tm)).Ftm_year) + int64(1900) if val >= int64(10000) { - *(*Tsize_t)(unsafe.Pointer(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1841, VaList(bp+8, val))) + **(**Tsize_t)(__ccgo_up(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1841, VaList(bp+8, val))) return s } width = int32(4) goto number case int32('z'): if (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst < 0 { - *(*Tsize_t)(unsafe.Pointer(l)) = uint64(0) + **(**Tsize_t)(__ccgo_up(l)) = uint64(0) return __ccgo_ts } - *(*Tsize_t)(unsafe.Pointer(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1847, VaList(bp+8, (*Ttm)(unsafe.Pointer(tm)).F__tm_gmtoff/int64(3600)*int64(100)+(*Ttm)(unsafe.Pointer(tm)).F__tm_gmtoff%int64(3600)/int64(60)))) + **(**Tsize_t)(__ccgo_up(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1847, VaList(bp+8, (*Ttm)(unsafe.Pointer(tm)).F__tm_gmtoff/int64(3600)*int64(100)+(*Ttm)(unsafe.Pointer(tm)).F__tm_gmtoff%int64(3600)/int64(60)))) return s case int32('Z'): if (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst < 0 { - *(*Tsize_t)(unsafe.Pointer(l)) = uint64(0) + **(**Tsize_t)(__ccgo_up(l)) = uint64(0) return __ccgo_ts } fmt = X__tm_to_tzname(tls, tm) goto string case int32('%'): - *(*Tsize_t)(unsafe.Pointer(l)) = uint64(1) + **(**Tsize_t)(__ccgo_up(l)) = uint64(1) return __ccgo_ts + 348 default: return uintptr(0) @@ -149703,13 +149703,13 @@ number: } switch v1 { case int32('-'): - *(*Tsize_t)(unsafe.Pointer(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1854, VaList(bp+8, val))) + **(**Tsize_t)(__ccgo_up(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1854, VaList(bp+8, val))) case int32('_'): - *(*Tsize_t)(unsafe.Pointer(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1859, VaList(bp+8, width, val))) + **(**Tsize_t)(__ccgo_up(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1859, VaList(bp+8, width, val))) case int32('0'): fallthrough default: - *(*Tsize_t)(unsafe.Pointer(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1865, VaList(bp+8, width, val))) + **(**Tsize_t)(__ccgo_up(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1865, VaList(bp+8, width, val))) break } return s @@ -149720,7 +149720,7 @@ nl_strcat: goto string string: ; - *(*Tsize_t)(unsafe.Pointer(l)) = _strlen(tls, fmt) + **(**Tsize_t)(__ccgo_up(l)) = _strlen(tls, fmt) return fmt goto nl_strftime nl_strftime: @@ -149729,8 +149729,8 @@ nl_strftime: goto recu_strftime recu_strftime: ; - *(*Tsize_t)(unsafe.Pointer(l)) = X__strftime_l(tls, s, uint64(100), fmt, tm, loc) - if !(*(*Tsize_t)(unsafe.Pointer(l)) != 0) { + **(**Tsize_t)(__ccgo_up(l)) = X__strftime_l(tls, s, uint64(100), fmt, tm, loc) + if !(**(**Tsize_t)(__ccgo_up(l)) != 0) { return uintptr(0) } return s @@ -149757,46 +149757,46 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl if !(l < n) { break } - if !(*(*uint8)(unsafe.Pointer(f)) != 0) { - *(*uint8)(unsafe.Pointer(s + uintptr(l))) = uint8(0) + if !(**(**uint8)(__ccgo_up(f)) != 0) { + **(**uint8)(__ccgo_up(s + uintptr(l))) = uint8(0) return l } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) != int32('%') { + if Int32FromUint8(**(**uint8)(__ccgo_up(f))) != int32('%') { v2 = l l = l + 1 - *(*uint8)(unsafe.Pointer(s + uintptr(v2))) = *(*uint8)(unsafe.Pointer(f)) + **(**uint8)(__ccgo_up(s + uintptr(v2))) = **(**uint8)(__ccgo_up(f)) goto _1 } f = f + 1 pad = 0 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('-') || Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('_') || Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('0') { + if Int32FromUint8(**(**uint8)(__ccgo_up(f))) == int32('-') || Int32FromUint8(**(**uint8)(__ccgo_up(f))) == int32('_') || Int32FromUint8(**(**uint8)(__ccgo_up(f))) == int32('0') { v3 = f f = f + 1 - pad = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + pad = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } - v4 = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == Int32FromUint8('+')) + v4 = BoolInt32(Int32FromUint8(**(**uint8)(__ccgo_up(f))) == Int32FromUint8('+')) plus = v4 if v4 != 0 { f = f + 1 } - if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(f)))-uint32('0') < uint32(10)) != 0 { + if BoolInt32(uint32(**(**uint8)(__ccgo_up(f)))-uint32('0') < uint32(10)) != 0 { width = Xstrtoul(tls, f, bp+112, int32(10)) } else { width = uint64(0) - *(*uintptr)(unsafe.Pointer(bp + 112)) = f + **(**uintptr)(__ccgo_up(bp + 112)) = f } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 112))))) == int32('C') || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 112))))) == int32('F') || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 112))))) == int32('G') || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 112))))) == int32('Y') { - if !(width != 0) && *(*uintptr)(unsafe.Pointer(bp + 112)) != f { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 112))))) == int32('C') || Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 112))))) == int32('F') || Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 112))))) == int32('G') || Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 112))))) == int32('Y') { + if !(width != 0) && **(**uintptr)(__ccgo_up(bp + 112)) != f { width = uint64(1) } } else { width = uint64(0) } - f = *(*uintptr)(unsafe.Pointer(bp + 112)) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('E') || Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('O') { + f = **(**uintptr)(__ccgo_up(bp + 112)) + if Int32FromUint8(**(**uint8)(__ccgo_up(f))) == int32('E') || Int32FromUint8(**(**uint8)(__ccgo_up(f))) == int32('O') { f = f + 1 } - t = X__strftime_fmt_1(tls, bp+8, bp, Int32FromUint8(*(*uint8)(unsafe.Pointer(f))), tm, loc, pad) + t = X__strftime_fmt_1(tls, bp+8, bp, Int32FromUint8(**(**uint8)(__ccgo_up(f))), tm, loc, pad) if !(t != 0) { break } @@ -149804,26 +149804,26 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl /* Trim off any sign and leading zeros, then * count remaining digits to determine behavior * for the + flag. */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(t))) == int32('+') || Int32FromUint8(*(*uint8)(unsafe.Pointer(t))) == int32('-') { + if Int32FromUint8(**(**uint8)(__ccgo_up(t))) == int32('+') || Int32FromUint8(**(**uint8)(__ccgo_up(t))) == int32('-') { t = t + 1 - *(*Tsize_t)(unsafe.Pointer(bp)) = *(*Tsize_t)(unsafe.Pointer(bp)) - 1 + **(**Tsize_t)(__ccgo_up(bp)) = **(**Tsize_t)(__ccgo_up(bp)) - 1 } for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(t))) == int32('0') && Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(t + 1)))-int32('0')) < uint32(10)) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(t))) == int32('0') && Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(t + 1)))-int32('0')) < uint32(10)) { break } goto _5 _5: ; t = t + 1 - *(*Tsize_t)(unsafe.Pointer(bp)) = *(*Tsize_t)(unsafe.Pointer(bp)) - 1 + **(**Tsize_t)(__ccgo_up(bp)) = **(**Tsize_t)(__ccgo_up(bp)) - 1 } - if width < *(*Tsize_t)(unsafe.Pointer(bp)) { - width = *(*Tsize_t)(unsafe.Pointer(bp)) + if width < **(**Tsize_t)(__ccgo_up(bp)) { + width = **(**Tsize_t)(__ccgo_up(bp)) } d = uint64(0) for { - if !(Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(t + uintptr(d))))-int32('0')) < uint32(10)) { + if !(Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(t + uintptr(d))))-int32('0')) < uint32(10)) { break } goto _6 @@ -149834,41 +149834,41 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl if (*Ttm)(unsafe.Pointer(tm)).Ftm_year < -int32(1900) { v2 = l l = l + 1 - *(*uint8)(unsafe.Pointer(s + uintptr(v2))) = uint8('-') + **(**uint8)(__ccgo_up(s + uintptr(v2))) = uint8('-') width = width - 1 } else { if v9 = plus != 0; v9 { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 112))))) == int32('C') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 112))))) == int32('C') { v4 = int32(3) } else { v4 = int32(5) } } - if v9 && d+(width-*(*Tsize_t)(unsafe.Pointer(bp))) >= Uint64FromInt32(v4) { + if v9 && d+(width-**(**Tsize_t)(__ccgo_up(bp))) >= Uint64FromInt32(v4) { v2 = l l = l + 1 - *(*uint8)(unsafe.Pointer(s + uintptr(v2))) = uint8('+') + **(**uint8)(__ccgo_up(s + uintptr(v2))) = uint8('+') width = width - 1 } } for { - if !(width > *(*Tsize_t)(unsafe.Pointer(bp)) && l < n) { + if !(width > **(**Tsize_t)(__ccgo_up(bp)) && l < n) { break } v2 = l l = l + 1 - *(*uint8)(unsafe.Pointer(s + uintptr(v2))) = uint8('0') + **(**uint8)(__ccgo_up(s + uintptr(v2))) = uint8('0') goto _11 _11: ; width = width - 1 } } - if *(*Tsize_t)(unsafe.Pointer(bp)) > n-l { - *(*Tsize_t)(unsafe.Pointer(bp)) = n - l + if **(**Tsize_t)(__ccgo_up(bp)) > n-l { + **(**Tsize_t)(__ccgo_up(bp)) = n - l } - Xmemcpy(tls, s+uintptr(l), t, *(*Tsize_t)(unsafe.Pointer(bp))) - l = l + *(*Tsize_t)(unsafe.Pointer(bp)) + Xmemcpy(tls, s+uintptr(l), t, **(**Tsize_t)(__ccgo_up(bp))) + l = l + **(**Tsize_t)(__ccgo_up(bp)) goto _1 _1: ; @@ -149878,7 +149878,7 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl if l == n { l = n - uint64(1) } - *(*uint8)(unsafe.Pointer(s + uintptr(l))) = uint8(0) + **(**uint8)(__ccgo_up(s + uintptr(l))) = uint8(0) } return uint64(0) } @@ -149916,18 +149916,18 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { var _ /* relyear at bp+8 */ int32 _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = adj, dest, ex, i, len1, min, neg, range1, w, want_century, v1, v2, v5, v6, v8, v9 want_century = 0 - *(*int32)(unsafe.Pointer(bp + 4)) = 0 - *(*int32)(unsafe.Pointer(bp + 8)) = 0 - for *(*uint8)(unsafe.Pointer(f)) != 0 { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) != int32('%') { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) + **(**int32)(__ccgo_up(bp + 4)) = 0 + **(**int32)(__ccgo_up(bp + 8)) = 0 + for **(**uint8)(__ccgo_up(f)) != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(f))) != int32('%') { + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(f))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _3 _3: if v2 != 0 { for { - if v8 = *(*uint8)(unsafe.Pointer(s)) != 0; v8 { - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) + if v8 = **(**uint8)(__ccgo_up(s)) != 0; v8 { + v5 = Int32FromUint8(**(**uint8)(__ccgo_up(s))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _7 _7: @@ -149941,7 +149941,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { s = s + 1 } } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) != Int32FromUint8(**(**uint8)(__ccgo_up(f))) { return uintptr(0) } else { s = s + 1 @@ -149951,19 +149951,19 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { continue } f = f + 1 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('+') { + if Int32FromUint8(**(**uint8)(__ccgo_up(f))) == int32('+') { f = f + 1 } - if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(f)))-uint32('0') < uint32(10)) != 0 { + if BoolInt32(uint32(**(**uint8)(__ccgo_up(f)))-uint32('0') < uint32(10)) != 0 { w = Int32FromUint64(Xstrtoul(tls, f, bp+16, int32(10))) - f = *(*uintptr)(unsafe.Pointer(bp + 16)) + f = **(**uintptr)(__ccgo_up(bp + 16)) } else { w = -int32(1) } adj = 0 v9 = f f = f + 1 - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(v9))) { case int32('A'): goto _10 case int32('a'): @@ -150114,8 +150114,8 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { ; _44: ; - if v8 = *(*uint8)(unsafe.Pointer(s)) != 0; v8 { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) + if v8 = **(**uint8)(__ccgo_up(s)) != 0; v8 { + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(s))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _47 _47: @@ -150137,15 +150137,15 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { ex = Xnl_langinfo(tls, int32(AM_STR)) len1 = _strlen(tls, ex) if !(Xstrncasecmp(tls, s, ex, len1) != 0) { - *(*int32)(unsafe.Pointer(tm + 8)) %= int32(12) + **(**int32)(__ccgo_up(tm + 8)) %= int32(12) s = s + uintptr(len1) goto _41 } ex = Xnl_langinfo(tls, int32(PM_STR)) len1 = _strlen(tls, ex) if !(Xstrncasecmp(tls, s, ex, len1) != 0) { - *(*int32)(unsafe.Pointer(tm + 8)) %= int32(12) - *(*int32)(unsafe.Pointer(tm + 8)) += int32(12) + **(**int32)(__ccgo_up(tm + 8)) %= int32(12) + **(**int32)(__ccgo_up(tm + 8)) += int32(12) s = s + uintptr(len1) goto _41 } @@ -150225,7 +150225,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { ; v9 = s s = s + 1 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) != int32('%') { + if Int32FromUint8(**(**uint8)(__ccgo_up(v9))) != int32('%') { return uintptr(0) } goto _41 @@ -150235,27 +150235,27 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { goto numeric_range numeric_range: ; - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } - *(*int32)(unsafe.Pointer(dest)) = 0 + **(**int32)(__ccgo_up(dest)) = 0 i = int32(1) for { - if !(i <= min+range1 && BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0) { + if !(i <= min+range1 && BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-uint32('0') < uint32(10)) != 0) { break } v9 = s s = s + 1 - *(*int32)(unsafe.Pointer(dest)) = *(*int32)(unsafe.Pointer(dest))*int32(10) + Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) - int32('0') + **(**int32)(__ccgo_up(dest)) = **(**int32)(__ccgo_up(dest))*int32(10) + Int32FromUint8(**(**uint8)(__ccgo_up(v9))) - int32('0') goto _50 _50: ; i = i * int32(10) } - if Uint32FromInt32(*(*int32)(unsafe.Pointer(dest))-min) >= Uint32FromInt32(range1) { + if Uint32FromInt32(**(**int32)(__ccgo_up(dest))-min) >= Uint32FromInt32(range1) { return uintptr(0) } - *(*int32)(unsafe.Pointer(dest)) -= adj + **(**int32)(__ccgo_up(dest)) -= adj switch int64(dest) - int64(tm) { case Int64FromUint64(uint64(UintptrFromInt32(0) + 28)): } @@ -150264,36 +150264,36 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { numeric_digits: ; neg = 0 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('+') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('+') { s = s + 1 } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('-') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('-') { neg = int32(1) s = s + 1 } } - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } v1 = Int32FromInt32(0) i = v1 - *(*int32)(unsafe.Pointer(dest)) = v1 + **(**int32)(__ccgo_up(dest)) = v1 for { - if !(i < w && BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0) { + if !(i < w && BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-uint32('0') < uint32(10)) != 0) { break } v9 = s s = s + 1 - *(*int32)(unsafe.Pointer(dest)) = *(*int32)(unsafe.Pointer(dest))*int32(10) + Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) - int32('0') + **(**int32)(__ccgo_up(dest)) = **(**int32)(__ccgo_up(dest))*int32(10) + Int32FromUint8(**(**uint8)(__ccgo_up(v9))) - int32('0') goto _52 _52: ; i = i + 1 } if neg != 0 { - *(*int32)(unsafe.Pointer(dest)) = -*(*int32)(unsafe.Pointer(dest)) + **(**int32)(__ccgo_up(dest)) = -**(**int32)(__ccgo_up(dest)) } - *(*int32)(unsafe.Pointer(dest)) -= adj + **(**int32)(__ccgo_up(dest)) -= adj goto update goto symbolic_range symbolic_range: @@ -150309,7 +150309,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { goto _55 } s = s + uintptr(len1) - *(*int32)(unsafe.Pointer(dest)) = i % range1 + **(**int32)(__ccgo_up(dest)) = i % range1 break goto _55 _55: @@ -150327,12 +150327,12 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { _41: } if want_century != 0 { - (*Ttm)(unsafe.Pointer(tm)).Ftm_year = *(*int32)(unsafe.Pointer(bp + 8)) + (*Ttm)(unsafe.Pointer(tm)).Ftm_year = **(**int32)(__ccgo_up(bp + 8)) if want_century&int32(2) != 0 { - *(*int32)(unsafe.Pointer(tm + 20)) += *(*int32)(unsafe.Pointer(bp + 4))*int32(100) - int32(1900) + **(**int32)(__ccgo_up(tm + 20)) += **(**int32)(__ccgo_up(bp + 4))*int32(100) - int32(1900) } else { if (*Ttm)(unsafe.Pointer(tm)).Ftm_year <= int32(68) { - *(*int32)(unsafe.Pointer(tm + 20)) += int32(100) + **(**int32)(__ccgo_up(tm + 20)) += int32(100) } } } @@ -150349,9 +150349,9 @@ func Xtime(tls *TLS, t uintptr) (r Ttime_t) { var _ /* ts at bp+0 */ Ttimespec X__clock_gettime(tls, CLOCK_REALTIME, bp) if t != 0 { - *(*Ttime_t)(unsafe.Pointer(t)) = (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec + **(**Ttime_t)(__ccgo_up(t)) = (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec } - return (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec + return (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec } func Xtimegm(tls *TLS, tm uintptr) (r Ttime_t) { @@ -150366,10 +150366,10 @@ func Xtimegm(tls *TLS, tm uintptr) (r Ttime_t) { _ = t t = X__tm_to_secs(tls, tm) if X__secs_to_tm(tls, t, bp) < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return int64(-int32(1)) } - *(*Ttm1)(unsafe.Pointer(tm)) = *(*Ttm1)(unsafe.Pointer(bp)) + **(**Ttm1)(__ccgo_up(tm)) = **(**Ttm1)(__ccgo_up(bp)) (*Ttm1)(unsafe.Pointer(tm)).Ftm_isdst = 0 (*Ttm1)(unsafe.Pointer(tm)).Ftm_gmtoff = 0 (*Ttm1)(unsafe.Pointer(tm)).Ftm_zone = uintptr(unsafe.Pointer(&X__utc)) @@ -150527,92 +150527,92 @@ func X__wcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl if !(l < n) { break } - if !(*(*Twchar_t)(unsafe.Pointer(f)) != 0) { - *(*Twchar_t)(unsafe.Pointer(s + uintptr(l)*4)) = uint32(0) + if !(**(**Twchar_t)(__ccgo_up(f)) != 0) { + **(**Twchar_t)(__ccgo_up(s + uintptr(l)*4)) = uint32(0) return l } - if *(*Twchar_t)(unsafe.Pointer(f)) != uint32('%') { + if **(**Twchar_t)(__ccgo_up(f)) != uint32('%') { v2 = l l = l + 1 - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = *(*Twchar_t)(unsafe.Pointer(f)) + **(**Twchar_t)(__ccgo_up(s + uintptr(v2)*4)) = **(**Twchar_t)(__ccgo_up(f)) goto _1 } f += 4 pad = 0 - if *(*Twchar_t)(unsafe.Pointer(f)) == uint32('-') || *(*Twchar_t)(unsafe.Pointer(f)) == uint32('_') || *(*Twchar_t)(unsafe.Pointer(f)) == uint32('0') { + if **(**Twchar_t)(__ccgo_up(f)) == uint32('-') || **(**Twchar_t)(__ccgo_up(f)) == uint32('_') || **(**Twchar_t)(__ccgo_up(f)) == uint32('0') { v3 = f f += 4 - pad = Int32FromUint32(*(*Twchar_t)(unsafe.Pointer(v3))) + pad = Int32FromUint32(**(**Twchar_t)(__ccgo_up(v3))) } - v4 = BoolInt32(*(*Twchar_t)(unsafe.Pointer(f)) == Uint32FromUint8('+')) + v4 = BoolInt32(**(**Twchar_t)(__ccgo_up(f)) == Uint32FromUint8('+')) plus = v4 if v4 != 0 { f += 4 } width = Xwcstoul(tls, f, bp+512, int32(10)) - if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 512)))) == uint32('C') || *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 512)))) == uint32('F') || *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 512)))) == uint32('G') || *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 512)))) == uint32('Y') { - if !(width != 0) && *(*uintptr)(unsafe.Pointer(bp + 512)) != f { + if **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 512)))) == uint32('C') || **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 512)))) == uint32('F') || **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 512)))) == uint32('G') || **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 512)))) == uint32('Y') { + if !(width != 0) && **(**uintptr)(__ccgo_up(bp + 512)) != f { width = uint64(1) } } else { width = uint64(0) } - f = *(*uintptr)(unsafe.Pointer(bp + 512)) - if *(*Twchar_t)(unsafe.Pointer(f)) == uint32('E') || *(*Twchar_t)(unsafe.Pointer(f)) == uint32('O') { + f = **(**uintptr)(__ccgo_up(bp + 512)) + if **(**Twchar_t)(__ccgo_up(f)) == uint32('E') || **(**Twchar_t)(__ccgo_up(f)) == uint32('O') { f += 4 } - t_mb = X__strftime_fmt_1(tls, bp+8, bp, Int32FromUint32(*(*Twchar_t)(unsafe.Pointer(f))), tm, loc, pad) + t_mb = X__strftime_fmt_1(tls, bp+8, bp, Int32FromUint32(**(**Twchar_t)(__ccgo_up(f))), tm, loc, pad) if !(t_mb != 0) { break } - *(*Tsize_t)(unsafe.Pointer(bp)) = Xmbstowcs(tls, bp+108, t_mb, Uint64FromInt64(400)/Uint64FromInt64(4)) - if *(*Tsize_t)(unsafe.Pointer(bp)) == Uint64FromInt32(-Int32FromInt32(1)) { + **(**Tsize_t)(__ccgo_up(bp)) = Xmbstowcs(tls, bp+108, t_mb, Uint64FromInt64(400)/Uint64FromInt64(4)) + if **(**Tsize_t)(__ccgo_up(bp)) == Uint64FromInt32(-Int32FromInt32(1)) { return uint64(0) } t = bp + 108 if width != 0 { for { - if !(*(*Twchar_t)(unsafe.Pointer(t)) == uint32('+') || *(*Twchar_t)(unsafe.Pointer(t)) == uint32('-') || *(*Twchar_t)(unsafe.Pointer(t)) == uint32('0') && *(*Twchar_t)(unsafe.Pointer(t + 1*4)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(t)) == uint32('+') || **(**Twchar_t)(__ccgo_up(t)) == uint32('-') || **(**Twchar_t)(__ccgo_up(t)) == uint32('0') && **(**Twchar_t)(__ccgo_up(t + 1*4)) != 0) { break } goto _5 _5: ; t += 4 - *(*Tsize_t)(unsafe.Pointer(bp)) = *(*Tsize_t)(unsafe.Pointer(bp)) - 1 + **(**Tsize_t)(__ccgo_up(bp)) = **(**Tsize_t)(__ccgo_up(bp)) - 1 } width = width - 1 if plus != 0 && (*Ttm)(unsafe.Pointer(tm)).Ftm_year >= Int32FromInt32(10000)-Int32FromInt32(1900) { v2 = l l = l + 1 - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = uint32('+') + **(**Twchar_t)(__ccgo_up(s + uintptr(v2)*4)) = uint32('+') } else { if (*Ttm)(unsafe.Pointer(tm)).Ftm_year < -int32(1900) { v2 = l l = l + 1 - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = uint32('-') + **(**Twchar_t)(__ccgo_up(s + uintptr(v2)*4)) = uint32('-') } else { width = width + 1 } } for { - if !(width > *(*Tsize_t)(unsafe.Pointer(bp)) && l < n) { + if !(width > **(**Tsize_t)(__ccgo_up(bp)) && l < n) { break } v2 = l l = l + 1 - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = uint32('0') + **(**Twchar_t)(__ccgo_up(s + uintptr(v2)*4)) = uint32('0') goto _8 _8: ; width = width - 1 } } - if *(*Tsize_t)(unsafe.Pointer(bp)) >= n-l { - *(*Tsize_t)(unsafe.Pointer(bp)) = n - l + if **(**Tsize_t)(__ccgo_up(bp)) >= n-l { + **(**Tsize_t)(__ccgo_up(bp)) = n - l } - Xwmemcpy(tls, s+uintptr(l)*4, t, *(*Tsize_t)(unsafe.Pointer(bp))) - l = l + *(*Tsize_t)(unsafe.Pointer(bp)) + Xwmemcpy(tls, s+uintptr(l)*4, t, **(**Tsize_t)(__ccgo_up(bp))) + l = l + **(**Tsize_t)(__ccgo_up(bp)) goto _1 _1: ; @@ -150622,7 +150622,7 @@ func X__wcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl if l == n { l = n - uint64(1) } - *(*Twchar_t)(unsafe.Pointer(s + uintptr(l)*4)) = uint32(0) + **(**Twchar_t)(__ccgo_up(s + uintptr(l)*4)) = uint32(0) } return uint64(0) } @@ -150675,14 +150675,14 @@ func Xalarm(tls *TLS, seconds uint32) (r uint32) { defer tls.Free(64) var _ /* it at bp+0 */ Titimerval var _ /* old at bp+32 */ Titimerval - *(*Titimerval)(unsafe.Pointer(bp)) = Titimerval{ + **(**Titimerval)(__ccgo_up(bp)) = Titimerval{ Fit_value: Ttimeval{ Ftv_sec: Int64FromUint32(seconds), }, } - *(*Titimerval)(unsafe.Pointer(bp + 32)) = Titimerval{} + **(**Titimerval)(__ccgo_up(bp + 32)) = Titimerval{} Xsetitimer(tls, ITIMER_REAL, bp, bp+32) - return Uint32FromInt64((*(*Titimerval)(unsafe.Pointer(bp + 32))).Fit_value.Ftv_sec + BoolInt64(!!((*(*Titimerval)(unsafe.Pointer(bp + 32))).Fit_value.Ftv_usec != 0))) + return Uint32FromInt64((**(**Titimerval)(__ccgo_up(bp + 32))).Fit_value.Ftv_sec + BoolInt64(!!((**(**Titimerval)(__ccgo_up(bp + 32))).Fit_value.Ftv_usec != 0))) } func Xchdir(tls *TLS, path uintptr) (r int32) { @@ -150809,7 +150809,7 @@ func _checker(tls *TLS, p uintptr) (r int32) { if X__syscall2(tls, int64(SYS_setregid), X__syscall0(tls, int64(SYS_getegid)), int64(-Int32FromInt32(1))) != 0 || X__syscall2(tls, int64(SYS_setreuid), X__syscall0(tls, int64(SYS_geteuid)), int64(-Int32FromInt32(1))) != 0 { X__syscall1(tls, int64(SYS_exit), int64(Int32FromInt32(1))) } - *(*int32)(unsafe.Pointer(bp)) = int32(X__syscall4(tls, int64(SYS_faccessat), int64((*Tctx1)(unsafe.Pointer(c)).Ffd), int64((*Tctx1)(unsafe.Pointer(c)).Ffilename), int64((*Tctx1)(unsafe.Pointer(c)).Famode), int64(Int32FromInt32(0)))) + **(**int32)(__ccgo_up(bp)) = int32(X__syscall4(tls, int64(SYS_faccessat), int64((*Tctx1)(unsafe.Pointer(c)).Ffd), int64((*Tctx1)(unsafe.Pointer(c)).Ffilename), int64((*Tctx1)(unsafe.Pointer(c)).Famode), int64(Int32FromInt32(0)))) X__syscall3(tls, int64(SYS_write), int64((*Tctx1)(unsafe.Pointer(c)).Fp), int64(bp), Int64FromUint64(Uint64FromInt64(4))) return 0 } @@ -150924,7 +150924,7 @@ func Xgetcwd(tls *TLS, buf uintptr, size Tsize_t) (r uintptr) { size = v1 } else { if !(size != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } } @@ -150932,8 +150932,8 @@ func Xgetcwd(tls *TLS, buf uintptr, size Tsize_t) (r uintptr) { if ret < 0 { return uintptr(0) } - if ret == 0 || Int32FromUint8(*(*uint8)(unsafe.Pointer(buf))) != int32('/') { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOENT) + if ret == 0 || Int32FromUint8(**(**uint8)(__ccgo_up(buf))) != int32('/') { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOENT) return uintptr(0) } if buf == tmp { @@ -150997,8 +150997,8 @@ func Xgethostname(tls *TLS, name uintptr, len1 Tsize_t) (r int32) { i = uint64(0) for { if v3 = i < len1; v3 { - v2 = *(*uint8)(unsafe.Pointer(bp + 65 + uintptr(i))) - *(*uint8)(unsafe.Pointer(name + uintptr(i))) = v2 + v2 = **(**uint8)(__ccgo_up(bp + 65 + uintptr(i))) + **(**uint8)(__ccgo_up(name + uintptr(i))) = v2 } if !(v3 && v2 != 0) { break @@ -151009,7 +151009,7 @@ func Xgethostname(tls *TLS, name uintptr, len1 Tsize_t) (r int32) { i = i + 1 } if i != 0 && i == len1 { - *(*uint8)(unsafe.Pointer(name + uintptr(i-uint64(1)))) = uint8(0) + **(**uint8)(__ccgo_up(name + uintptr(i-uint64(1)))) = uint8(0) } return 0 } @@ -151102,8 +151102,8 @@ func Xisatty(tls *TLS, fd int32) (r1 int32) { if r == uint64(0) { return int32(1) } - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(EBADF) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOTTY) + if **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(EBADF) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOTTY) } return 0 } @@ -151168,8 +151168,8 @@ func Xnice(tls *TLS, inc int32) (r int32) { prio = -int32(NZERO) } if Xsetpriority(tls, PRIO_PROCESS, uint32(0), prio) != 0 { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EACCES) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EPERM) + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EACCES) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EPERM) } return -int32(1) } else { @@ -151216,12 +151216,12 @@ func Xpipe2(tls *TLS, fd uintptr, flag int32) (r int32) { return ret } if flag&int32(O_CLOEXEC) != 0 { - X__syscall3(tls, int64(SYS_fcntl), int64(*(*int32)(unsafe.Pointer(fd))), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) - X__syscall3(tls, int64(SYS_fcntl), int64(*(*int32)(unsafe.Pointer(fd + 1*4))), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) + X__syscall3(tls, int64(SYS_fcntl), int64(**(**int32)(__ccgo_up(fd))), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) + X__syscall3(tls, int64(SYS_fcntl), int64(**(**int32)(__ccgo_up(fd + 1*4))), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) } if flag&int32(O_NONBLOCK) != 0 { - X__syscall3(tls, int64(SYS_fcntl), int64(*(*int32)(unsafe.Pointer(fd))), int64(Int32FromInt32(F_SETFL)), int64(Int32FromInt32(O_NONBLOCK))) - X__syscall3(tls, int64(SYS_fcntl), int64(*(*int32)(unsafe.Pointer(fd + 1*4))), int64(Int32FromInt32(F_SETFL)), int64(Int32FromInt32(O_NONBLOCK))) + X__syscall3(tls, int64(SYS_fcntl), int64(**(**int32)(__ccgo_up(fd))), int64(Int32FromInt32(F_SETFL)), int64(Int32FromInt32(O_NONBLOCK))) + X__syscall3(tls, int64(SYS_fcntl), int64(**(**int32)(__ccgo_up(fd + 1*4))), int64(Int32FromInt32(F_SETFL)), int64(Int32FromInt32(O_NONBLOCK))) } return 0 } @@ -151420,7 +151420,7 @@ func X__setxid(tls *TLS, nr int32, id int32, eid int32, sid int32) (r int32) { _ = v1 /* ret is initially nonzero so that failure of the first thread does not * trigger the safety kill above. */ - *(*Tctx2)(unsafe.Pointer(bp)) = Tctx2{ + **(**Tctx2)(__ccgo_up(bp)) = Tctx2{ Fid: id, Feid: eid, Fsid: sid, @@ -151428,10 +151428,10 @@ func X__setxid(tls *TLS, nr int32, id int32, eid int32, sid int32) (r int32) { Fret: int32(1), } ___synccall(tls, __ccgo_fp(_do_setxid), bp) - if (*(*Tctx2)(unsafe.Pointer(bp))).Fret > 0 { + if (**(**Tctx2)(__ccgo_up(bp))).Fret > 0 { v1 = -int32(EAGAIN) } else { - v1 = (*(*Tctx2)(unsafe.Pointer(bp))).Fret + v1 = (**(**Tctx2)(__ccgo_up(bp))).Fret } return int32(X__syscall_ret(tls, Uint64FromInt32(v1))) } @@ -151444,11 +151444,11 @@ func Xsleep(tls *TLS, seconds uint32) (r uint32) { bp := tls.Alloc(16) defer tls.Free(16) var _ /* tv at bp+0 */ Ttimespec - *(*Ttimespec)(unsafe.Pointer(bp)) = Ttimespec{ + **(**Ttimespec)(__ccgo_up(bp)) = Ttimespec{ Ftv_sec: Int64FromUint32(seconds), } if Xnanosleep(tls, bp, bp) != 0 { - return Uint32FromInt64((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec) + return Uint32FromInt64((**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec) } return uint32(0) } @@ -151487,7 +151487,7 @@ func Xtcgetpgrp(tls *TLS, fd int32) (r Tpid_t) { if Xioctl(tls, fd, int32(TIOCGPGRP), VaList(bp+16, bp)) < 0 { return -int32(1) } - return *(*int32)(unsafe.Pointer(bp)) + return **(**int32)(__ccgo_up(bp)) } func Xtcsetpgrp(tls *TLS, fd int32, pgrp Tpid_t) (r int32) { @@ -151498,7 +151498,7 @@ func Xtcsetpgrp(tls *TLS, fd int32, pgrp Tpid_t) (r int32) { bp := tls.Alloc(32) defer tls.Free(32) var _ /* pgrp_int at bp+0 */ int32 - *(*int32)(unsafe.Pointer(bp)) = pgrp + **(**int32)(__ccgo_up(bp)) = pgrp return Xioctl(tls, fd, int32(TIOCSPGRP), VaList(bp+16, bp)) } @@ -151529,7 +151529,7 @@ func Xttyname(tls *TLS, fd int32) (r uintptr) { v1 = Xttyname_r(tls, fd, uintptr(unsafe.Pointer(&_buf10)), uint64(32)) result = v1 if v1 != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = result + **(**int32)(__ccgo_up(X__errno_location(tls))) = result return UintptrFromInt32(0) } return uintptr(unsafe.Pointer(&_buf10)) @@ -151550,22 +151550,22 @@ func Xttyname_r(tls *TLS, fd int32, name uintptr, size Tsize_t) (r int32) { var _ /* st2 at bp+128 */ Tstat _ = l if !(Xisatty(tls, fd) != 0) { - return *(*int32)(unsafe.Pointer(X__errno_location(tls))) + return **(**int32)(__ccgo_up(X__errno_location(tls))) } X__procfdname(tls, bp+256, Uint32FromInt32(fd)) l = Xreadlink(tls, bp+256, name, size) if l < 0 { - return *(*int32)(unsafe.Pointer(X__errno_location(tls))) + return **(**int32)(__ccgo_up(X__errno_location(tls))) } else { if Uint64FromInt64(l) == size { return int32(ERANGE) } } - *(*uint8)(unsafe.Pointer(name + uintptr(l))) = uint8(0) + **(**uint8)(__ccgo_up(name + uintptr(l))) = uint8(0) if Xstat(tls, name, bp) != 0 || Xfstat(tls, fd, bp+128) != 0 { - return *(*int32)(unsafe.Pointer(X__errno_location(tls))) + return **(**int32)(__ccgo_up(X__errno_location(tls))) } - if (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev != (*(*Tstat)(unsafe.Pointer(bp + 128))).Fst_dev || (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino != (*(*Tstat)(unsafe.Pointer(bp + 128))).Fst_ino { + if (**(**Tstat)(__ccgo_up(bp))).Fst_dev != (**(**Tstat)(__ccgo_up(bp + 128))).Fst_dev || (**(**Tstat)(__ccgo_up(bp))).Fst_ino != (**(**Tstat)(__ccgo_up(bp + 128))).Fst_ino { return int32(ENODEV) } return 0 @@ -151580,7 +151580,7 @@ func Xualarm(tls *TLS, value uint32, interval uint32) (r uint32) { defer tls.Free(64) var _ /* it at bp+0 */ Titimerval var _ /* it_old at bp+32 */ Titimerval - *(*Titimerval)(unsafe.Pointer(bp)) = Titimerval{ + **(**Titimerval)(__ccgo_up(bp)) = Titimerval{ Fit_interval: Ttimeval{ Ftv_usec: Int64FromUint32(interval), }, @@ -151589,7 +151589,7 @@ func Xualarm(tls *TLS, value uint32, interval uint32) (r uint32) { }, } Xsetitimer(tls, ITIMER_REAL, bp, bp+32) - return Uint32FromInt64((*(*Titimerval)(unsafe.Pointer(bp + 32))).Fit_value.Ftv_sec*int64(1000000) + (*(*Titimerval)(unsafe.Pointer(bp + 32))).Fit_value.Ftv_usec) + return Uint32FromInt64((**(**Titimerval)(__ccgo_up(bp + 32))).Fit_value.Ftv_sec*int64(1000000) + (**(**Titimerval)(__ccgo_up(bp + 32))).Fit_value.Ftv_usec) } func Xunlink(tls *TLS, path uintptr) (r int32) { @@ -151616,7 +151616,7 @@ func Xusleep(tls *TLS, useconds uint32) (r int32) { bp := tls.Alloc(16) defer tls.Free(16) var _ /* tv at bp+0 */ Ttimespec - *(*Ttimespec)(unsafe.Pointer(bp)) = Ttimespec{ + **(**Ttimespec)(__ccgo_up(bp)) = Ttimespec{ Ftv_sec: Int64FromUint32(useconds / uint32(1000000)), Ftv_nsec: Int64FromUint32(useconds % uint32(1000000) * uint32(1000)), } @@ -151644,6 +151644,10 @@ func __ccgo_fp(f interface{}) uintptr { return (*iface)(unsafe.Pointer(&f))[1] } +func __ccgo_up(n uintptr) unsafe.Pointer { + return unsafe.Pointer(&n) +} + var X__abort_lock [1]int32 var X__at_quick_exit_lockptr = uintptr(unsafe.Pointer(&_lock)) diff --git a/vendor/modernc.org/libc/ccgo_linux_loong64.go b/vendor/modernc.org/libc/ccgo_linux_loong64.go index 33f6f3aea3..a2a6cd8c4e 100644 --- a/vendor/modernc.org/libc/ccgo_linux_loong64.go +++ b/vendor/modernc.org/libc/ccgo_linux_loong64.go @@ -663,7 +663,7 @@ func ___frexp_exp(tls *TLS, x float64, expt uintptr) (r float64) { */ exp_x = Xexp(tls, x-_kln2) hx = uint32(*(*Tuint64_t)(unsafe.Pointer(&exp_x)) >> int32(32)) - *(*int32)(unsafe.Pointer(expt)) = Int32FromUint32(hx>>Int32FromInt32(20) - Uint32FromInt32(Int32FromInt32(0x3ff)+Int32FromInt32(1023)) + _k) + **(**int32)(__ccgo_up(expt)) = Int32FromUint32(hx>>Int32FromInt32(20) - Uint32FromInt32(Int32FromInt32(0x3ff)+Int32FromInt32(1023)) + _k) v1 = uint64(hx&Uint32FromInt32(0xfffff)|Uint32FromInt32((Int32FromInt32(0x3ff)+Int32FromInt32(1023))<>Int32FromInt32(23) - Uint32FromInt32(Int32FromInt32(0x7f)+Int32FromInt32(127)) + _k1) + **(**int32)(__ccgo_up(expt)) = Int32FromUint32(hx>>Int32FromInt32(23) - Uint32FromInt32(Int32FromInt32(0x7f)+Int32FromInt32(127)) + _k1) v1 = hx&uint32(0x7fffff) | Uint32FromInt32((Int32FromInt32(0x7f)+Int32FromInt32(127))< uint32(35) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uint64(0) } } @@ -3394,7 +3394,7 @@ func Xfpathconf(tls *TLS, fd int32, name int32) (r int64) { defer func() { trc("-> %v", r) }() } if Uint64FromInt32(name) >= Uint64FromInt64(42)/Uint64FromInt64(2) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) } return int64(_values[name]) @@ -7443,7 +7443,7 @@ func Xsysconf(tls *TLS, name int32) (r int64) { var _ /* si at bp+144 */ Tsysinfo _, _, _, _, _, _, _ = cnt, i, mem, val, v1, v3, v5 if Uint64FromInt32(name) >= Uint64FromInt64(502)/Uint64FromInt64(2) || !(_values1[name] != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) } else { if int32(_values1[name]) >= -int32(1) { @@ -7451,13 +7451,13 @@ func Xsysconf(tls *TLS, name int32) (r int64) { } else { if int32(_values1[name]) < -int32(256) { Xgetrlimit(tls, int32(_values1[name])&int32(16383), bp) - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur == ^Uint64FromUint64(0) { + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur == ^Uint64FromUint64(0) { return int64(-int32(1)) } - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur > uint64(0x7fffffffffffffff) { + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur > uint64(0x7fffffffffffffff) { v1 = uint64(0x7fffffffffffffff) } else { - v1 = (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur + v1 = (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur } return Int64FromUint64(v1) } @@ -7479,7 +7479,7 @@ func Xsysconf(tls *TLS, name int32) (r int64) { case (-Int32FromInt32(256) | Int32FromInt32(6)) & Int32FromInt32(255): fallthrough case (-Int32FromInt32(256) | Int32FromInt32(7)) & Int32FromInt32(255): - *(*[128]uint8)(unsafe.Pointer(bp + 16)) = [128]uint8{ + **(**[128]uint8)(__ccgo_up(bp + 16)) = [128]uint8{ 0: uint8(1), } X__syscall3(tls, int64(SYS_sched_getaffinity), int64(Int32FromInt32(0)), Int64FromUint64(Uint64FromInt64(128)), int64(bp+16)) @@ -7491,14 +7491,14 @@ func Xsysconf(tls *TLS, name int32) (r int64) { break } for { - if !((*(*[128]uint8)(unsafe.Pointer(bp + 16)))[i] != 0) { + if !((**(**[128]uint8)(__ccgo_up(bp + 16)))[i] != 0) { break } goto _4 _4: ; v5 = bp + 16 + uintptr(i) - *(*uint8)(unsafe.Pointer(v5)) = uint8(int32(*(*uint8)(unsafe.Pointer(v5))) & (Int32FromUint8((*(*[128]uint8)(unsafe.Pointer(bp + 16)))[i]) - Int32FromInt32(1))) + *(*uint8)(unsafe.Pointer(v5)) = uint8(int32(*(*uint8)(unsafe.Pointer(v5))) & (Int32FromUint8((**(**[128]uint8)(__ccgo_up(bp + 16)))[i]) - Int32FromInt32(1))) cnt = cnt + 1 } goto _2 @@ -7511,15 +7511,15 @@ func Xsysconf(tls *TLS, name int32) (r int64) { fallthrough case (-Int32FromInt32(256) | Int32FromInt32(9)) & Int32FromInt32(255): X__lsysinfo(tls, bp+144) - if !((*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fmem_unit != 0) { - (*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fmem_unit = uint32(1) + if !((**(**Tsysinfo)(__ccgo_up(bp + 144))).Fmem_unit != 0) { + (**(**Tsysinfo)(__ccgo_up(bp + 144))).Fmem_unit = uint32(1) } if name == int32(_SC_PHYS_PAGES) { - mem = (*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Ftotalram + mem = uint64((**(**Tsysinfo)(__ccgo_up(bp + 144))).Ftotalram) } else { - mem = (*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Ffreeram + (*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fbufferram + mem = uint64((**(**Tsysinfo)(__ccgo_up(bp + 144))).Ffreeram + (**(**Tsysinfo)(__ccgo_up(bp + 144))).Fbufferram) } - mem = mem * uint64((*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fmem_unit) + mem = mem * uint64((**(**Tsysinfo)(__ccgo_up(bp + 144))).Fmem_unit) mem = mem / X__libc.Fpage_size if mem > uint64(0x7fffffffffffffff) { v1 = uint64(0x7fffffffffffffff) @@ -8919,7 +8919,7 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { for cond := true; cond; cond = dptr < end { v1 = sptr sptr = sptr + 1 - tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = uint32(**(**uint8)(__ccgo_up(v1))) tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) @@ -8931,7 +8931,7 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { c1 = tmp v1 = sptr sptr = sptr + 1 - tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = uint32(**(**uint8)(__ccgo_up(v1))) tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) @@ -8943,13 +8943,13 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { c2 = tmp v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(c1<>int32(4)) + **(**uint8)(__ccgo_up(v1)) = uint8(c1<>int32(4)) if dptr >= end { break } v1 = sptr sptr = sptr + 1 - tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = uint32(**(**uint8)(__ccgo_up(v1))) tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) @@ -8961,13 +8961,13 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { c3 = tmp v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(c2&uint32(0x0F)<>int32(2)) + **(**uint8)(__ccgo_up(v1)) = uint8(c2&uint32(0x0F)<>int32(2)) if dptr >= end { break } v1 = sptr sptr = sptr + 1 - tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = uint32(**(**uint8)(__ccgo_up(v1))) tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) @@ -8979,7 +8979,7 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { c4 = tmp v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(c3&uint32(0x03)<>int32(2)] + **(**uint8)(__ccgo_up(v1)) = _BF_itoa64[c1>>int32(2)] c1 = c1 & uint32(0x03) << int32(4) if sptr >= end { v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] + **(**uint8)(__ccgo_up(v1)) = _BF_itoa64[c1] break } v1 = sptr sptr = sptr + 1 - c2 = uint32(*(*uint8)(unsafe.Pointer(v1))) + c2 = uint32(**(**uint8)(__ccgo_up(v1))) c1 = c1 | c2>>int32(4) v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] + **(**uint8)(__ccgo_up(v1)) = _BF_itoa64[c1] c1 = c2 & uint32(0x0f) << int32(2) if sptr >= end { v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] + **(**uint8)(__ccgo_up(v1)) = _BF_itoa64[c1] break } v1 = sptr sptr = sptr + 1 - c2 = uint32(*(*uint8)(unsafe.Pointer(v1))) + c2 = uint32(**(**uint8)(__ccgo_up(v1))) c1 = c1 | c2>>int32(6) v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] + **(**uint8)(__ccgo_up(v1)) = _BF_itoa64[c1] v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c2&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _BF_itoa64[c2&uint32(0x3f)] } } @@ -9040,11 +9040,11 @@ func _BF_swap(tls *TLS, x uintptr, count int32) { v1 = int32(1) if *(*int8)(unsafe.Pointer(&v1)) != 0 { for { - tmp = *(*TBF_word)(unsafe.Pointer(x)) + tmp = **(**TBF_word)(__ccgo_up(x)) tmp = tmp<>Int32FromInt32(16) v4 = x x += 4 - *(*TBF_word)(unsafe.Pointer(v4)) = tmp&uint32(0x00FF00FF)<>Int32FromInt32(8)&uint32(0x00FF00FF) + **(**TBF_word)(__ccgo_up(v4)) = tmp&uint32(0x00FF00FF)<>Int32FromInt32(8)&uint32(0x00FF00FF) goto _3 _3: ; @@ -9064,7 +9064,7 @@ func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, e _, _, _, _, _, _, _ = i, ptr, tmp1, tmp2, tmp3, tmp4, v2 ptr = start for cond := true; cond; cond = ptr < end { - L = L ^ *(*TBF_word)(unsafe.Pointer(ctx)) + L = L ^ **(**TBF_word)(__ccgo_up(ctx)) i = 0 for { if !(i < int32(16)) { @@ -9076,12 +9076,12 @@ func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, e tmp3 = L >> int32(16) tmp3 = tmp3 & uint32(0xFF) tmp4 = L >> int32(24) - tmp1 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 3*1024 + uintptr(tmp1)*4)) - tmp2 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 2*1024 + uintptr(tmp2)*4)) - tmp3 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 1*1024 + uintptr(tmp3)*4)) - tmp3 = tmp3 + *(*TBF_word)(unsafe.Pointer(ctx + 72 + uintptr(tmp4)*4)) + tmp1 = **(**TBF_word)(__ccgo_up(ctx + 72 + 3*1024 + uintptr(tmp1)*4)) + tmp2 = **(**TBF_word)(__ccgo_up(ctx + 72 + 2*1024 + uintptr(tmp2)*4)) + tmp3 = **(**TBF_word)(__ccgo_up(ctx + 72 + 1*1024 + uintptr(tmp3)*4)) + tmp3 = tmp3 + **(**TBF_word)(__ccgo_up(ctx + 72 + uintptr(tmp4)*4)) tmp3 = tmp3 ^ tmp2 - R = R ^ *(*TBF_word)(unsafe.Pointer(ctx + uintptr(i+int32(1))*4)) + R = R ^ **(**TBF_word)(__ccgo_up(ctx + uintptr(i+int32(1))*4)) tmp3 = tmp3 + tmp1 R = R ^ tmp3 tmp1 = R & uint32(0xFF) @@ -9090,12 +9090,12 @@ func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, e tmp3 = R >> int32(16) tmp3 = tmp3 & uint32(0xFF) tmp4 = R >> int32(24) - tmp1 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 3*1024 + uintptr(tmp1)*4)) - tmp2 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 2*1024 + uintptr(tmp2)*4)) - tmp3 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 1*1024 + uintptr(tmp3)*4)) - tmp3 = tmp3 + *(*TBF_word)(unsafe.Pointer(ctx + 72 + uintptr(tmp4)*4)) + tmp1 = **(**TBF_word)(__ccgo_up(ctx + 72 + 3*1024 + uintptr(tmp1)*4)) + tmp2 = **(**TBF_word)(__ccgo_up(ctx + 72 + 2*1024 + uintptr(tmp2)*4)) + tmp3 = **(**TBF_word)(__ccgo_up(ctx + 72 + 1*1024 + uintptr(tmp3)*4)) + tmp3 = tmp3 + **(**TBF_word)(__ccgo_up(ctx + 72 + uintptr(tmp4)*4)) tmp3 = tmp3 ^ tmp2 - L = L ^ *(*TBF_word)(unsafe.Pointer(ctx + uintptr(i+int32(1)+int32(1))*4)) + L = L ^ **(**TBF_word)(__ccgo_up(ctx + uintptr(i+int32(1)+int32(1))*4)) tmp3 = tmp3 + tmp1 L = L ^ tmp3 goto _1 @@ -9105,13 +9105,13 @@ func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, e } tmp4 = R R = L - L = tmp4 ^ *(*TBF_word)(unsafe.Pointer(ctx + uintptr(Int32FromInt32(BF_N)+Int32FromInt32(1))*4)) + L = tmp4 ^ **(**TBF_word)(__ccgo_up(ctx + uintptr(Int32FromInt32(BF_N)+Int32FromInt32(1))*4)) v2 = ptr ptr += 4 - *(*TBF_word)(unsafe.Pointer(v2)) = L + **(**TBF_word)(__ccgo_up(v2)) = L v2 = ptr ptr += 4 - *(*TBF_word)(unsafe.Pointer(v2)) = R + **(**TBF_word)(__ccgo_up(v2)) = R } return L } @@ -9171,17 +9171,17 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags break } v1 = Uint32FromInt32(0) - (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)] = v1 - (*(*[2]TBF_word)(unsafe.Pointer(bp)))[0] = v1 + (**(**[2]TBF_word)(__ccgo_up(bp)))[int32(1)] = v1 + (**(**[2]TBF_word)(__ccgo_up(bp)))[0] = v1 j = uint32(0) for { if !(j < uint32(4)) { break } - *(*TBF_word)(unsafe.Pointer(bp)) <<= uint32(8) - *(*TBF_word)(unsafe.Pointer(bp)) |= uint32(Uint8FromInt8(*(*int8)(unsafe.Pointer(ptr)))) /* correct */ - *(*TBF_word)(unsafe.Pointer(bp + 1*4)) <<= uint32(8) - *(*TBF_word)(unsafe.Pointer(bp + 1*4)) |= Uint32FromInt8(*(*int8)(unsafe.Pointer(ptr))) /* bug */ + **(**TBF_word)(__ccgo_up(bp)) <<= uint32(8) + **(**TBF_word)(__ccgo_up(bp)) |= uint32(Uint8FromInt8(**(**int8)(__ccgo_up(ptr)))) /* correct */ + **(**TBF_word)(__ccgo_up(bp + 1*4)) <<= uint32(8) + **(**TBF_word)(__ccgo_up(bp + 1*4)) |= Uint32FromInt8(int8(**(**int8)(__ccgo_up(ptr)))) /* bug */ /* * Sign extension in the first char has no effect - nothing to overwrite yet, * and those extra 24 bits will be fully shifted out of the 32-bit word. For @@ -9189,9 +9189,9 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags * extension in tmp[1] occurs. Once this flag is set, it remains set. */ if j != 0 { - sign = sign | (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)]&uint32(0x80) + sign = sign | (**(**[2]TBF_word)(__ccgo_up(bp)))[int32(1)]&uint32(0x80) } - if !(*(*int8)(unsafe.Pointer(ptr)) != 0) { + if !(**(**int8)(__ccgo_up(ptr)) != 0) { ptr = key } else { ptr = ptr + 1 @@ -9201,9 +9201,9 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags ; j = j + 1 } - diff = diff | ((*(*[2]TBF_word)(unsafe.Pointer(bp)))[0] ^ (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)]) /* Non-zero on any differences */ - *(*TBF_word)(unsafe.Pointer(expanded + uintptr(i)*4)) = (*(*[2]TBF_word)(unsafe.Pointer(bp)))[bug] - *(*TBF_word)(unsafe.Pointer(initial + uintptr(i)*4)) = *(*TBF_word)(unsafe.Pointer(uintptr(unsafe.Pointer(&_BF_init_state)) + uintptr(i)*4)) ^ (*(*[2]TBF_word)(unsafe.Pointer(bp)))[bug] + diff = diff | ((**(**[2]TBF_word)(__ccgo_up(bp)))[0] ^ (**(**[2]TBF_word)(__ccgo_up(bp)))[int32(1)]) /* Non-zero on any differences */ + **(**TBF_word)(__ccgo_up(expanded + uintptr(i)*4)) = (**(**[2]TBF_word)(__ccgo_up(bp)))[bug] + **(**TBF_word)(__ccgo_up(initial + uintptr(i)*4)) = **(**TBF_word)(__ccgo_up(uintptr(unsafe.Pointer(&_BF_init_state)) + uintptr(i)*4)) ^ (**(**[2]TBF_word)(__ccgo_up(bp)))[bug] goto _2 _2: ; @@ -9234,7 +9234,7 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags * state that could be directly specified by a password to the buggy algorithm * (and to the fully correct one as well, but that's a side-effect). */ - *(*TBF_word)(unsafe.Pointer(initial)) ^= sign + **(**TBF_word)(__ccgo_up(initial)) ^= sign } var _flags_by_subtype = [26]uint8{ @@ -9261,28 +9261,28 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w } } _, _, _, _, _, _, _, _, _, _, _, _ = L, L1, R, count, done, i, ptr, tmp1, tmp2, tmp3, tmp4, v1 - if int32(*(*int8)(unsafe.Pointer(setting))) != int32('$') || int32(*(*int8)(unsafe.Pointer(setting + 1))) != int32('2') || Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(setting + 2)))-int32('a')) > uint32(25) || !(_flags_by_subtype[int32(*(*int8)(unsafe.Pointer(setting + 2)))-int32('a')] != 0) || int32(*(*int8)(unsafe.Pointer(setting + 3))) != int32('$') || Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(setting + 4)))-int32('0')) > uint32(1) || Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(setting + 5)))-int32('0')) > uint32(9) || int32(*(*int8)(unsafe.Pointer(setting + 6))) != int32('$') { + if int32(**(**int8)(__ccgo_up(setting))) != int32('$') || int32(**(**int8)(__ccgo_up(setting + 1))) != int32('2') || Uint32FromInt32(int32(**(**int8)(__ccgo_up(setting + 2)))-int32('a')) > uint32(25) || !(_flags_by_subtype[int32(**(**int8)(__ccgo_up(setting + 2)))-int32('a')] != 0) || int32(**(**int8)(__ccgo_up(setting + 3))) != int32('$') || Uint32FromInt32(int32(**(**int8)(__ccgo_up(setting + 4)))-int32('0')) > uint32(1) || Uint32FromInt32(int32(**(**int8)(__ccgo_up(setting + 5)))-int32('0')) > uint32(9) || int32(**(**int8)(__ccgo_up(setting + 6))) != int32('$') { return UintptrFromInt32(0) } - count = Uint32FromInt32(1) << ((int32(*(*int8)(unsafe.Pointer(setting + 4)))-int32('0'))*int32(10) + (int32(*(*int8)(unsafe.Pointer(setting + 5))) - int32('0'))) + count = Uint32FromInt32(1) << ((int32(**(**int8)(__ccgo_up(setting + 4)))-int32('0'))*int32(10) + (int32(**(**int8)(__ccgo_up(setting + 5))) - int32('0'))) if count < min || _BF_decode(tls, bp+4240, setting+7, int32(16)) != 0 { return UintptrFromInt32(0) } _BF_swap(tls, bp+4240, int32(4)) - _BF_set_key(tls, key, bp+4168, bp, _flags_by_subtype[int32(*(*int8)(unsafe.Pointer(setting + 2)))-int32('a')]) + _BF_set_key(tls, key, bp+4168, bp, _flags_by_subtype[int32(**(**int8)(__ccgo_up(setting + 2)))-int32('a')]) Xmemcpy(tls, bp+72, uintptr(unsafe.Pointer(&_BF_init_state))+72, uint64(4096)) L = uint32(0) R = uint32(0) ptr = bp for cond := true; cond; cond = int32(1) != 0 { - L = _BF_encrypt(tls, bp, L^*(*TBF_word)(unsafe.Pointer(bp + 4240)), R^*(*TBF_word)(unsafe.Pointer(bp + 4240 + 1*4)), ptr, ptr) - R = *(*TBF_word)(unsafe.Pointer(ptr + UintptrFromInt32(1)*4)) + L = _BF_encrypt(tls, bp, L^**(**TBF_word)(__ccgo_up(bp + 4240)), R^**(**TBF_word)(__ccgo_up(bp + 4240 + 1*4)), ptr, ptr) + R = **(**TBF_word)(__ccgo_up(ptr + UintptrFromInt32(1)*4)) ptr = ptr + uintptr(2)*4 if ptr >= bp+uintptr(Int32FromInt32(BF_N)+Int32FromInt32(2)+Int32FromInt32(4)*Int32FromInt32(0x100))*4 { break } - L = _BF_encrypt(tls, bp, L^*(*TBF_word)(unsafe.Pointer(bp + 4240 + 2*4)), R^*(*TBF_word)(unsafe.Pointer(bp + 4240 + 3*4)), ptr, ptr) - R = *(*TBF_word)(unsafe.Pointer(ptr + UintptrFromInt32(1)*4)) + L = _BF_encrypt(tls, bp, L^**(**TBF_word)(__ccgo_up(bp + 4240 + 2*4)), R^**(**TBF_word)(__ccgo_up(bp + 4240 + 3*4)), ptr, ptr) + R = **(**TBF_word)(__ccgo_up(ptr + UintptrFromInt32(1)*4)) ptr = ptr + uintptr(2)*4 } for { @@ -9291,8 +9291,8 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w if !(i < Int32FromInt32(BF_N)+Int32FromInt32(2)) { break } - *(*TBF_word)(unsafe.Pointer(bp + uintptr(i)*4)) ^= *(*TBF_word)(unsafe.Pointer(bp + 4168 + uintptr(i)*4)) - *(*TBF_word)(unsafe.Pointer(bp + uintptr(i+int32(1))*4)) ^= *(*TBF_word)(unsafe.Pointer(bp + 4168 + uintptr(i+int32(1))*4)) + **(**TBF_word)(__ccgo_up(bp + uintptr(i)*4)) ^= **(**TBF_word)(__ccgo_up(bp + 4168 + uintptr(i)*4)) + **(**TBF_word)(__ccgo_up(bp + uintptr(i+int32(1))*4)) ^= **(**TBF_word)(__ccgo_up(bp + 4168 + uintptr(i+int32(1))*4)) goto _3 _3: ; @@ -9305,26 +9305,26 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w break } done = int32(1) - tmp1 = *(*TBF_word)(unsafe.Pointer(bp + 4240)) - tmp2 = *(*TBF_word)(unsafe.Pointer(bp + 4240 + 1*4)) - tmp3 = *(*TBF_word)(unsafe.Pointer(bp + 4240 + 2*4)) - tmp4 = *(*TBF_word)(unsafe.Pointer(bp + 4240 + 3*4)) + tmp1 = **(**TBF_word)(__ccgo_up(bp + 4240)) + tmp2 = **(**TBF_word)(__ccgo_up(bp + 4240 + 1*4)) + tmp3 = **(**TBF_word)(__ccgo_up(bp + 4240 + 2*4)) + tmp4 = **(**TBF_word)(__ccgo_up(bp + 4240 + 3*4)) i = 0 for { if !(i < int32(BF_N)) { break } - *(*TBF_word)(unsafe.Pointer(bp + uintptr(i)*4)) ^= tmp1 - *(*TBF_word)(unsafe.Pointer(bp + uintptr(i+int32(1))*4)) ^= tmp2 - *(*TBF_word)(unsafe.Pointer(bp + uintptr(i+int32(2))*4)) ^= tmp3 - *(*TBF_word)(unsafe.Pointer(bp + uintptr(i+int32(3))*4)) ^= tmp4 + **(**TBF_word)(__ccgo_up(bp + uintptr(i)*4)) ^= tmp1 + **(**TBF_word)(__ccgo_up(bp + uintptr(i+int32(1))*4)) ^= tmp2 + **(**TBF_word)(__ccgo_up(bp + uintptr(i+int32(2))*4)) ^= tmp3 + **(**TBF_word)(__ccgo_up(bp + uintptr(i+int32(3))*4)) ^= tmp4 goto _4 _4: ; i = i + int32(4) } - *(*TBF_word)(unsafe.Pointer(bp + 16*4)) ^= tmp1 - *(*TBF_word)(unsafe.Pointer(bp + 17*4)) ^= tmp2 + **(**TBF_word)(__ccgo_up(bp + 16*4)) ^= tmp1 + **(**TBF_word)(__ccgo_up(bp + 17*4)) ^= tmp2 } goto _2 _2: @@ -9341,10 +9341,10 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w break } L1 = _BF_magic_w[i] - (*(*[2]TBF_word)(unsafe.Pointer(bp + 4264)))[int32(1)] = _BF_magic_w[i+int32(1)] + (**(**[2]TBF_word)(__ccgo_up(bp + 4264)))[int32(1)] = _BF_magic_w[i+int32(1)] count = uint32(64) for { - L1 = _BF_encrypt(tls, bp, L1, (*(*[2]TBF_word)(unsafe.Pointer(bp + 4264)))[int32(1)], bp+4264, bp+4264) + L1 = _BF_encrypt(tls, bp, L1, (**(**[2]TBF_word)(__ccgo_up(bp + 4264)))[int32(1)], bp+4264, bp+4264) goto _7 _7: ; @@ -9354,20 +9354,20 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w break } } - *(*TBF_word)(unsafe.Pointer(bp + 4240 + uintptr(i)*4)) = L1 - *(*TBF_word)(unsafe.Pointer(bp + 4240 + uintptr(i+int32(1))*4)) = (*(*[2]TBF_word)(unsafe.Pointer(bp + 4264)))[int32(1)] + **(**TBF_word)(__ccgo_up(bp + 4240 + uintptr(i)*4)) = L1 + **(**TBF_word)(__ccgo_up(bp + 4240 + uintptr(i+int32(1))*4)) = (**(**[2]TBF_word)(__ccgo_up(bp + 4264)))[int32(1)] goto _5 _5: ; i = i + int32(2) } Xmemcpy(tls, output, setting, Uint64FromInt32(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1))) - *(*int8)(unsafe.Pointer(output + uintptr(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1)))) = Int8FromUint8(_BF_itoa64[Int32FromUint8(_BF_atoi64[int32(*(*int8)(unsafe.Pointer(setting + uintptr(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1)))))-int32(0x20)])&int32(0x30)]) + **(**int8)(__ccgo_up(output + uintptr(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1)))) = Int8FromUint8(_BF_itoa64[Int32FromUint8(_BF_atoi64[int32(**(**int8)(__ccgo_up(setting + uintptr(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1)))))-int32(0x20)])&int32(0x30)]) /* This has to be bug-compatible with the original implementation, so * only encode 23 of the 24 bytes. :-) */ _BF_swap(tls, bp+4240, int32(6)) _BF_encode(tls, output+uintptr(Int32FromInt32(7)+Int32FromInt32(22)), bp+4240, int32(23)) - *(*int8)(unsafe.Pointer(output + uintptr(Int32FromInt32(7)+Int32FromInt32(22)+Int32FromInt32(31)))) = int8('\000') + **(**int8)(__ccgo_up(output + uintptr(Int32FromInt32(7)+Int32FromInt32(22)+Int32FromInt32(31)))) = int8('\000') return output } @@ -9426,19 +9426,19 @@ func X__crypt_blowfish(tls *TLS, key uintptr, setting uintptr, output uintptr) ( */ Xmemcpy(tls, bp, test_setting, uint64(30)) if retval != 0 { - flags = uint32(_flags_by_subtype[int32(*(*int8)(unsafe.Pointer(setting + 2)))-int32('a')]) + flags = uint32(_flags_by_subtype[int32(**(**int8)(__ccgo_up(setting + 2)))-int32('a')]) test_hash = uintptr(unsafe.Pointer(&_test_hashes)) + uintptr(flags&uint32(1))*34 - *(*int8)(unsafe.Pointer(bp + 2)) = *(*int8)(unsafe.Pointer(setting + 2)) + **(**int8)(__ccgo_up(bp + 2)) = **(**int8)(__ccgo_up(setting + 2)) } Xmemset(tls, bp+30, int32(0x55), uint64(63)) - *(*int8)(unsafe.Pointer(bp + 30 + uintptr(Uint64FromInt64(63)-Uint64FromInt32(1)))) = 0 + **(**int8)(__ccgo_up(bp + 30 + uintptr(Uint64FromInt64(63)-Uint64FromInt32(1)))) = 0 p = _BF_crypt(tls, test_key, bp, bp+30, uint32(1)) ok = BoolInt32(p == bp+30 && !(Xmemcmp(tls, p, bp, Uint64FromInt32(Int32FromInt32(7)+Int32FromInt32(22))) != 0) && !(Xmemcmp(tls, p+uintptr(Int32FromInt32(7)+Int32FromInt32(22)), test_hash, Uint64FromInt32(Int32FromInt32(31)+Int32FromInt32(1)+Int32FromInt32(1)+Int32FromInt32(1))) != 0)) k = __ccgo_ts + 58 - _BF_set_key(tls, k, bp+96, bp+168, uint8(2)) /* $2a$ */ - _BF_set_key(tls, k, bp+240, bp+312, uint8(4)) /* $2y$ */ - *(*TBF_word)(unsafe.Pointer(bp + 168)) ^= uint32(0x10000) /* undo the safety (for comparison) */ - ok = BoolInt32(ok != 0 && (*(*TBF_key)(unsafe.Pointer(bp + 168)))[0] == uint32(0xdb9c59bc) && (*(*TBF_key)(unsafe.Pointer(bp + 240)))[int32(17)] == uint32(0x33343500) && !(Xmemcmp(tls, bp+96, bp+240, uint64(72)) != 0) && !(Xmemcmp(tls, bp+168, bp+312, uint64(72)) != 0)) + _BF_set_key(tls, k, bp+96, bp+168, uint8(2)) /* $2a$ */ + _BF_set_key(tls, k, bp+240, bp+312, uint8(4)) /* $2y$ */ + **(**TBF_word)(__ccgo_up(bp + 168)) ^= uint32(0x10000) /* undo the safety (for comparison) */ + ok = BoolInt32(ok != 0 && (**(**TBF_key)(__ccgo_up(bp + 168)))[0] == uint32(0xdb9c59bc) && (**(**TBF_key)(__ccgo_up(bp + 240)))[int32(17)] == uint32(0x33343500) && !(Xmemcmp(tls, bp+96, bp+240, uint64(72)) != 0) && !(Xmemcmp(tls, bp+168, bp+312, uint64(72)) != 0)) if ok != 0 && retval != 0 { return retval } @@ -11288,8 +11288,8 @@ func X__des_setkey(tls *TLS, key uintptr, ekey uintptr) { var i, ibit, j, round, shifts uint32 var k0, k1, kl, kr, rawkey0, rawkey1, t0, t1, v1 Tuint32_t _, _, _, _, _, _, _, _, _, _, _, _, _, _ = i, ibit, j, k0, k1, kl, kr, rawkey0, rawkey1, round, shifts, t0, t1, v1 - rawkey0 = uint32(*(*uint8)(unsafe.Pointer(key + 3))) | uint32(*(*uint8)(unsafe.Pointer(key + 2)))<>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskl)) + uintptr(i+uint32(4))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4))) - k1 = k1 | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j)*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) + k0 = k0 | (**(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_key_perm_maskl)) + uintptr(i)*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_key_perm_maskl)) + uintptr(i+uint32(4))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4))) + k1 = k1 | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j)*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) ibit = ibit - uint32(4) - k1 = k1 | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j+uint32(1))*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(i+uint32(8))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4))) + k1 = k1 | (**(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j+uint32(1))*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(i+uint32(8))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4))) goto _2 _2: ; @@ -11334,19 +11334,19 @@ func X__des_setkey(tls *TLS, key uintptr, ekey uintptr) { if !(i < uint32(4)) { break } - kl = kl | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskl0)) + uintptr(i)*32 + uintptr(t0>>ibit&uint32(7))*4)) - kr = kr | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskr0)) + uintptr(i)*32 + uintptr(t1>>ibit&uint32(7))*4)) + kl = kl | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_comp_maskl0)) + uintptr(i)*32 + uintptr(t0>>ibit&uint32(7))*4)) + kr = kr | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_comp_maskr0)) + uintptr(i)*32 + uintptr(t1>>ibit&uint32(7))*4)) ibit = ibit - uint32(4) - kl = kl | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskl1)) + uintptr(i)*64 + uintptr(t0>>ibit&uint32(0xf))*4)) - kr = kr | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskr1)) + uintptr(i)*64 + uintptr(t1>>ibit&uint32(0xf))*4)) + kl = kl | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_comp_maskl1)) + uintptr(i)*64 + uintptr(t0>>ibit&uint32(0xf))*4)) + kr = kr | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_comp_maskr1)) + uintptr(i)*64 + uintptr(t1>>ibit&uint32(0xf))*4)) ibit = ibit - uint32(3) goto _5 _5: ; i = i + 1 } - *(*Tuint32_t)(unsafe.Pointer(ekey + uintptr(round)*4)) = kl - *(*Tuint32_t)(unsafe.Pointer(ekey + 64 + uintptr(round)*4)) = kr + **(**Tuint32_t)(__ccgo_up(ekey + uintptr(round)*4)) = kl + **(**Tuint32_t)(__ccgo_up(ekey + 64 + uintptr(round)*4)) = kr goto _3 _3: ; @@ -11380,8 +11380,8 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui if !(i < uint32(8)) { break } - l = l | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4))) - r = r | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4))) + l = l | (**(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4))) + r = r | (**(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4))) goto _2 _2: ; @@ -11419,15 +11419,15 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui f = (r48l ^ r48r) & saltbits v5 = kl kl += 4 - r48l = r48l ^ (f ^ *(*Tuint32_t)(unsafe.Pointer(v5))) + r48l = r48l ^ (f ^ **(**Tuint32_t)(__ccgo_up(v5))) v5 = kr kr += 4 - r48r = r48r ^ (f ^ *(*Tuint32_t)(unsafe.Pointer(v5))) + r48r = r48r ^ (f ^ **(**Tuint32_t)(__ccgo_up(v5))) /* * Do S-box lookups (which shrink it back to 32 bits) * and do the P-box permutation at the same time. */ - f = *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + uintptr(r48l>>int32(18))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 1*256 + uintptr(r48l>>Int32FromInt32(12)&uint32(0x3f))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 2*256 + uintptr(r48l>>Int32FromInt32(6)&uint32(0x3f))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 3*256 + uintptr(r48l&uint32(0x3f))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 4*256 + uintptr(r48r>>int32(18))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 5*256 + uintptr(r48r>>Int32FromInt32(12)&uint32(0x3f))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 6*256 + uintptr(r48r>>Int32FromInt32(6)&uint32(0x3f))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 7*256 + uintptr(r48r&uint32(0x3f))*4)) + f = **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + uintptr(r48l>>int32(18))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 1*256 + uintptr(r48l>>Int32FromInt32(12)&uint32(0x3f))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 2*256 + uintptr(r48l>>Int32FromInt32(6)&uint32(0x3f))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 3*256 + uintptr(r48l&uint32(0x3f))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 4*256 + uintptr(r48r>>int32(18))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 5*256 + uintptr(r48r>>Int32FromInt32(12)&uint32(0x3f))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 6*256 + uintptr(r48r>>Int32FromInt32(6)&uint32(0x3f))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 7*256 + uintptr(r48r&uint32(0x3f))*4)) /* * Now that we've permuted things, complete f(). */ @@ -11450,17 +11450,17 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui if !(i1 < uint32(4)) { break } - ro = ro | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4))) + ro = ro | (**(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4))) ibit1 = ibit1 - uint32(4) - lo = lo | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4))) + lo = lo | (**(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4))) goto _8 _8: ; i1 = i1 + 1 ibit1 = ibit1 - uint32(4) } - *(*Tuint32_t)(unsafe.Pointer(l_out)) = lo - *(*Tuint32_t)(unsafe.Pointer(r_out)) = ro + **(**Tuint32_t)(__ccgo_up(l_out)) = lo + **(**Tuint32_t)(__ccgo_up(r_out)) = ro } func _des_cipher(tls *TLS, in uintptr, out uintptr, count Tuint32_t, saltbits Tuint32_t, ekey uintptr) { @@ -11470,17 +11470,17 @@ func _des_cipher(tls *TLS, in uintptr, out uintptr, count Tuint32_t, saltbits Tu var _ /* l_out at bp+0 */ Tuint32_t var _ /* r_out at bp+4 */ Tuint32_t _, _ = rawl, rawr - rawl = uint32(*(*uint8)(unsafe.Pointer(in + 3))) | uint32(*(*uint8)(unsafe.Pointer(in + 2)))<> int32(24)) - *(*uint8)(unsafe.Pointer(out + 1)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp)) >> int32(16)) - *(*uint8)(unsafe.Pointer(out + 2)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp)) >> int32(8)) - *(*uint8)(unsafe.Pointer(out + 3)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp))) - *(*uint8)(unsafe.Pointer(out + 4)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp + 4)) >> int32(24)) - *(*uint8)(unsafe.Pointer(out + 5)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp + 4)) >> int32(16)) - *(*uint8)(unsafe.Pointer(out + 6)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp + 4)) >> int32(8)) - *(*uint8)(unsafe.Pointer(out + 7)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp + 4))) + **(**uint8)(__ccgo_up(out)) = uint8(**(**Tuint32_t)(__ccgo_up(bp)) >> int32(24)) + **(**uint8)(__ccgo_up(out + 1)) = uint8(**(**Tuint32_t)(__ccgo_up(bp)) >> int32(16)) + **(**uint8)(__ccgo_up(out + 2)) = uint8(**(**Tuint32_t)(__ccgo_up(bp)) >> int32(8)) + **(**uint8)(__ccgo_up(out + 3)) = uint8(**(**Tuint32_t)(__ccgo_up(bp))) + **(**uint8)(__ccgo_up(out + 4)) = uint8(**(**Tuint32_t)(__ccgo_up(bp + 4)) >> int32(24)) + **(**uint8)(__ccgo_up(out + 5)) = uint8(**(**Tuint32_t)(__ccgo_up(bp + 4)) >> int32(16)) + **(**uint8)(__ccgo_up(out + 6)) = uint8(**(**Tuint32_t)(__ccgo_up(bp + 4)) >> int32(8)) + **(**uint8)(__ccgo_up(out + 7)) = uint8(**(**Tuint32_t)(__ccgo_up(bp + 4))) } func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uintptr) (r uintptr) { @@ -11504,13 +11504,13 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin for q <= bp+128+uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) { v1 = q q = q + 1 - *(*uint8)(unsafe.Pointer(v1)) = Uint8FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(key))) << int32(1)) - if *(*uint8)(unsafe.Pointer(key)) != 0 { + **(**uint8)(__ccgo_up(v1)) = Uint8FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(key))) << int32(1)) + if **(**uint8)(__ccgo_up(key)) != 0 { key = key + 1 } } X__des_setkey(tls, bp+128, bp) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(setting))) == int32('_') { + if Int32FromUint8(**(**uint8)(__ccgo_up(setting))) == int32('_') { /* * "new"-style: * setting - underscore, 4 chars of count, 4 chars of salt @@ -11522,8 +11522,8 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin if !(i < uint32(5)) { break } - value = _ascii_to_bin(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(i))))) - if Int32FromUint8(_ascii64[value]) != Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(i)))) { + value = _ascii_to_bin(tls, Int32FromUint8(**(**uint8)(__ccgo_up(setting + uintptr(i))))) + if Int32FromUint8(_ascii64[value]) != Int32FromUint8(**(**uint8)(__ccgo_up(setting + uintptr(i)))) { return UintptrFromInt32(0) } count = count | value<<((i-uint32(1))*uint32(6)) @@ -11541,8 +11541,8 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin if !(i < uint32(9)) { break } - value1 = _ascii_to_bin(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(i))))) - if Int32FromUint8(_ascii64[value1]) != Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(i)))) { + value1 = _ascii_to_bin(tls, Int32FromUint8(**(**uint8)(__ccgo_up(setting + uintptr(i))))) + if Int32FromUint8(_ascii64[value1]) != Int32FromUint8(**(**uint8)(__ccgo_up(setting + uintptr(i)))) { return UintptrFromInt32(0) } salt = salt | value1<<((i-uint32(5))*uint32(6)) @@ -11551,7 +11551,7 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin ; i = i + 1 } - for *(*uint8)(unsafe.Pointer(key)) != 0 { + for **(**uint8)(__ccgo_up(key)) != 0 { /* * Encrypt the key with itself. */ @@ -11560,18 +11560,18 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin * And XOR with the next 8 characters of the key. */ q = bp + 128 - for q <= bp+128+uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) && *(*uint8)(unsafe.Pointer(key)) != 0 { + for q <= bp+128+uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) && **(**uint8)(__ccgo_up(key)) != 0 { v4 = q q = q + 1 v1 = v4 v5 = key key = key + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(int32(*(*uint8)(unsafe.Pointer(v1))) ^ Int32FromUint8(*(*uint8)(unsafe.Pointer(v5)))<> int32(8) + l = **(**Tuint32_t)(__ccgo_up(bp + 136)) >> int32(8) v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l&uint32(0x3f)] - l = *(*Tuint32_t)(unsafe.Pointer(bp + 136))<>Int32FromInt32(16)&uint32(0xffff) + **(**uint8)(__ccgo_up(v1)) = _ascii64[l&uint32(0x3f)] + l = **(**Tuint32_t)(__ccgo_up(bp + 136))<>Int32FromInt32(16)&uint32(0xffff) v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l&uint32(0x3f)] - l = *(*Tuint32_t)(unsafe.Pointer(bp + 140)) << int32(2) + **(**uint8)(__ccgo_up(v1)) = _ascii64[l&uint32(0x3f)] + l = **(**Tuint32_t)(__ccgo_up(bp + 140)) << int32(2) v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l&uint32(0x3f)] - *(*uint8)(unsafe.Pointer(p)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = _ascii64[l&uint32(0x3f)] + **(**uint8)(__ccgo_up(p)) = uint8(0) return output } @@ -11648,7 +11648,7 @@ func X__crypt_des(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uin test_key = __ccgo_ts + 72 test_setting = __ccgo_ts + 93 test_hash = __ccgo_ts + 103 - if int32(*(*int8)(unsafe.Pointer(setting))) != int32('_') { + if int32(**(**int8)(__ccgo_up(setting))) != int32('_') { test_setting = __ccgo_ts + 124 test_hash = __ccgo_ts + 127 } @@ -11667,7 +11667,7 @@ func X__crypt_des(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uin if p != 0 && !(Xstrcmp(tls, p, test_hash) != 0) && retval != 0 { return retval } - if int32(*(*int8)(unsafe.Pointer(setting))) == int32('*') { + if int32(**(**int8)(__ccgo_up(setting))) == int32('*') { v1 = __ccgo_ts + 141 } else { v1 = __ccgo_ts + 70 @@ -11768,80 +11768,80 @@ func _processblock(tls *TLS, s uintptr, buf uintptr) { if !(i < uint32(16)) { break } - (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] = uint32(*(*Tuint8_t)(unsafe.Pointer(buf + uintptr(uint32(4)*i)))) - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(i)*4)) |= uint32(*(*Tuint8_t)(unsafe.Pointer(buf + uintptr(uint32(4)*i+uint32(1))))) << int32(8) - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(i)*4)) |= uint32(*(*Tuint8_t)(unsafe.Pointer(buf + uintptr(uint32(4)*i+uint32(2))))) << int32(16) - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(i)*4)) |= uint32(*(*Tuint8_t)(unsafe.Pointer(buf + uintptr(uint32(4)*i+uint32(3))))) << int32(24) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[i] = uint32(**(**Tuint8_t)(__ccgo_up(buf + uintptr(uint32(4)*i)))) + **(**Tuint32_t)(__ccgo_up(bp + uintptr(i)*4)) |= uint32(**(**Tuint8_t)(__ccgo_up(buf + uintptr(uint32(4)*i+uint32(1))))) << int32(8) + **(**Tuint32_t)(__ccgo_up(bp + uintptr(i)*4)) |= uint32(**(**Tuint8_t)(__ccgo_up(buf + uintptr(uint32(4)*i+uint32(2))))) << int32(16) + **(**Tuint32_t)(__ccgo_up(bp + uintptr(i)*4)) |= uint32(**(**Tuint8_t)(__ccgo_up(buf + uintptr(uint32(4)*i+uint32(3))))) << int32(24) goto _1 _1: ; i = i + 1 } - a = *(*Tuint32_t)(unsafe.Pointer(s + 8)) - b = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) - c = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 2*4)) - d = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) + a = **(**Tuint32_t)(__ccgo_up(s + 8)) + b = **(**Tuint32_t)(__ccgo_up(s + 8 + 1*4)) + c = **(**Tuint32_t)(__ccgo_up(s + 8 + 2*4)) + d = **(**Tuint32_t)(__ccgo_up(s + 8 + 3*4)) i = uint32(0) for i < uint32(16) { - a = a + (d ^ b&(c^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) + a = a + (d ^ b&(c^d) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[i] + _tab[i]) a = _rol(tls, a, int32(7)) + b i = i + 1 - d = d + (c ^ a&(b^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) + d = d + (c ^ a&(b^c) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[i] + _tab[i]) d = _rol(tls, d, int32(12)) + a i = i + 1 - c = c + (b ^ d&(a^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) + c = c + (b ^ d&(a^b) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[i] + _tab[i]) c = _rol(tls, c, int32(17)) + d i = i + 1 - b = b + (a ^ c&(d^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) + b = b + (a ^ c&(d^a) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[i] + _tab[i]) b = _rol(tls, b, int32(22)) + c i = i + 1 } for i < uint32(32) { - a = a + (c ^ d&(c^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) + a = a + (c ^ d&(c^b) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) a = _rol(tls, a, int32(5)) + b i = i + 1 - d = d + (b ^ c&(b^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) + d = d + (b ^ c&(b^a) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) d = _rol(tls, d, int32(9)) + a i = i + 1 - c = c + (a ^ b&(a^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) + c = c + (a ^ b&(a^d) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) c = _rol(tls, c, int32(14)) + d i = i + 1 - b = b + (d ^ a&(d^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) + b = b + (d ^ a&(d^c) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) b = _rol(tls, b, int32(20)) + c i = i + 1 } for i < uint32(48) { - a = a + (b ^ c ^ d + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) + a = a + (b ^ c ^ d + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) a = _rol(tls, a, int32(4)) + b i = i + 1 - d = d + (a ^ b ^ c + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) + d = d + (a ^ b ^ c + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) d = _rol(tls, d, int32(11)) + a i = i + 1 - c = c + (d ^ a ^ b + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) + c = c + (d ^ a ^ b + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) c = _rol(tls, c, int32(16)) + d i = i + 1 - b = b + (c ^ d ^ a + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) + b = b + (c ^ d ^ a + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) b = _rol(tls, b, int32(23)) + c i = i + 1 } for i < uint32(64) { - a = a + (c ^ (b | ^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) + a = a + (c ^ (b | ^d) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) a = _rol(tls, a, int32(6)) + b i = i + 1 - d = d + (b ^ (a | ^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) + d = d + (b ^ (a | ^c) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) d = _rol(tls, d, int32(10)) + a i = i + 1 - c = c + (a ^ (d | ^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) + c = c + (a ^ (d | ^b) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) c = _rol(tls, c, int32(15)) + d i = i + 1 - b = b + (d ^ (c | ^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) + b = b + (d ^ (c | ^a) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) b = _rol(tls, b, int32(21)) + c i = i + 1 } - *(*Tuint32_t)(unsafe.Pointer(s + 8)) += a - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) += b - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 2*4)) += c - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) += d + **(**Tuint32_t)(__ccgo_up(s + 8)) += a + **(**Tuint32_t)(__ccgo_up(s + 8 + 1*4)) += b + **(**Tuint32_t)(__ccgo_up(s + 8 + 2*4)) += c + **(**Tuint32_t)(__ccgo_up(s + 8 + 3*4)) += d } func _pad(tls *TLS, s uintptr) { @@ -11850,31 +11850,31 @@ func _pad(tls *TLS, s uintptr) { r = uint32((*Tmd5)(unsafe.Pointer(s)).Flen1 % uint64(64)) v1 = r r = r + 1 - *(*Tuint8_t)(unsafe.Pointer(s + 24 + uintptr(v1))) = uint8(0x80) + **(**Tuint8_t)(__ccgo_up(s + 24 + uintptr(v1))) = uint8(0x80) if r > uint32(56) { Xmemset(tls, s+24+uintptr(r), 0, uint64(uint32(64)-r)) r = uint32(0) _processblock(tls, s, s+24) } Xmemset(tls, s+24+uintptr(r), 0, uint64(uint32(56)-r)) - *(*Tuint64_t)(unsafe.Pointer(s)) *= uint64(8) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 56)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 57)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(8)) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 58)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(16)) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 59)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(24)) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 60)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(32)) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 61)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(40)) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 62)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(48)) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 63)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(56)) + **(**Tuint64_t)(__ccgo_up(s)) *= uint64(8) + **(**Tuint8_t)(__ccgo_up(s + 24 + 56)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1) + **(**Tuint8_t)(__ccgo_up(s + 24 + 57)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(8)) + **(**Tuint8_t)(__ccgo_up(s + 24 + 58)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(16)) + **(**Tuint8_t)(__ccgo_up(s + 24 + 59)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(24)) + **(**Tuint8_t)(__ccgo_up(s + 24 + 60)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(32)) + **(**Tuint8_t)(__ccgo_up(s + 24 + 61)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(40)) + **(**Tuint8_t)(__ccgo_up(s + 24 + 62)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(48)) + **(**Tuint8_t)(__ccgo_up(s + 24 + 63)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(56)) _processblock(tls, s, s+24) } func _md5_init(tls *TLS, s uintptr) { (*Tmd5)(unsafe.Pointer(s)).Flen1 = uint64(0) - *(*Tuint32_t)(unsafe.Pointer(s + 8)) = uint32(0x67452301) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) = uint32(0xefcdab89) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 2*4)) = uint32(0x98badcfe) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) = uint32(0x10325476) + **(**Tuint32_t)(__ccgo_up(s + 8)) = uint32(0x67452301) + **(**Tuint32_t)(__ccgo_up(s + 8 + 1*4)) = uint32(0xefcdab89) + **(**Tuint32_t)(__ccgo_up(s + 8 + 2*4)) = uint32(0x98badcfe) + **(**Tuint32_t)(__ccgo_up(s + 8 + 3*4)) = uint32(0x10325476) } func _md5_sum(tls *TLS, s uintptr, md uintptr) { @@ -11886,10 +11886,10 @@ func _md5_sum(tls *TLS, s uintptr, md uintptr) { if !(i < int32(4)) { break } - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4))) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i+int32(1)))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4)) >> int32(8)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i+int32(2)))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4)) >> int32(16)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i+int32(3)))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4)) >> int32(24)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4))) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i+int32(1)))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4)) >> int32(8)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i+int32(2)))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4)) >> int32(16)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i+int32(3)))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4)) >> int32(24)) goto _1 _1: ; @@ -11903,7 +11903,7 @@ func _md5_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { _, _ = p, r p = m r = uint32((*Tmd5)(unsafe.Pointer(s)).Flen1 % uint64(64)) - *(*Tuint64_t)(unsafe.Pointer(s)) += len1 + **(**Tuint64_t)(__ccgo_up(s)) += len1 if r != 0 { if len1 < uint64(uint32(64)-r) { Xmemcpy(tls, s+24+uintptr(r), p, len1) @@ -11970,7 +11970,7 @@ func _to64(tls *TLS, s uintptr, u uint32, n int32) (r uintptr) { } v2 = s s = s + 1 - *(*int8)(unsafe.Pointer(v2)) = Int8FromUint8(_b64[u%uint32(64)]) + **(**int8)(__ccgo_up(v2)) = Int8FromUint8(_b64[u%uint32(64)]) u = u / uint32(64) } return s @@ -11996,7 +11996,7 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt salt = setting + uintptr(3) i = uint32(0) for { - if !(i < uint32(SALT_MAX) && *(*int8)(unsafe.Pointer(salt + uintptr(i))) != 0 && int32(*(*int8)(unsafe.Pointer(salt + uintptr(i)))) != int32('$')) { + if !(i < uint32(SALT_MAX) && **(**int8)(__ccgo_up(salt + uintptr(i))) != 0 && int32(**(**int8)(__ccgo_up(salt + uintptr(i)))) != int32('$')) { break } goto _1 @@ -12027,7 +12027,7 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt i = uint32(uint64(i) - Uint64FromInt64(16)) } _md5_update(tls, bp, bp+88, uint64(i)) - (*(*[16]uint8)(unsafe.Pointer(bp + 88)))[0] = uint8(0) + (**(**[16]uint8)(__ccgo_up(bp + 88)))[0] = uint8(0) i = klen for { if !(i != 0) { @@ -12078,20 +12078,20 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt p = output + uintptr(3) + uintptr(slen) v5 = p p = p + 1 - *(*int8)(unsafe.Pointer(v5)) = int8('$') + **(**int8)(__ccgo_up(v5)) = int8('$') i = uint32(0) for { if !(i < uint32(5)) { break } - p = _to64(tls, p, Uint32FromInt32(Int32FromUint8((*(*[16]uint8)(unsafe.Pointer(bp + 88)))[*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_perm)) + uintptr(i)*3))])<>Int32FromInt32(10) + (*(*[64]Tuint32_t)(unsafe.Pointer(bp)))[i-int32(7)] + (_ror(tls, (*(*[64]Tuint32_t)(unsafe.Pointer(bp)))[i-int32(15)], int32(7)) ^ _ror(tls, (*(*[64]Tuint32_t)(unsafe.Pointer(bp)))[i-int32(15)], int32(18)) ^ (*(*[64]Tuint32_t)(unsafe.Pointer(bp)))[i-int32(15)]>>Int32FromInt32(3)) + (*(*[64]Tuint32_t)(unsafe.Pointer(bp)))[i-int32(16)] + (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i] = _ror(tls, (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(2)], int32(17)) ^ _ror(tls, (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(2)], int32(19)) ^ (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(2)]>>Int32FromInt32(10) + (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(7)] + (_ror(tls, (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(15)], int32(7)) ^ _ror(tls, (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(15)], int32(18)) ^ (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(15)]>>Int32FromInt32(3)) + (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(16)] goto _2 _2: ; i = i + 1 } - a = *(*Tuint32_t)(unsafe.Pointer(s + 8)) - b = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) - c = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 2*4)) - d = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) - e = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 4*4)) - f = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 5*4)) - g = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 6*4)) - h = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 7*4)) + a = **(**Tuint32_t)(__ccgo_up(s + 8)) + b = **(**Tuint32_t)(__ccgo_up(s + 8 + 1*4)) + c = **(**Tuint32_t)(__ccgo_up(s + 8 + 2*4)) + d = **(**Tuint32_t)(__ccgo_up(s + 8 + 3*4)) + e = **(**Tuint32_t)(__ccgo_up(s + 8 + 4*4)) + f = **(**Tuint32_t)(__ccgo_up(s + 8 + 5*4)) + g = **(**Tuint32_t)(__ccgo_up(s + 8 + 6*4)) + h = **(**Tuint32_t)(__ccgo_up(s + 8 + 7*4)) i = 0 for { if !(i < int32(64)) { break } - t1 = h + (_ror(tls, e, int32(6)) ^ _ror(tls, e, int32(11)) ^ _ror(tls, e, int32(25))) + (g ^ e&(f^g)) + _K[i] + (*(*[64]Tuint32_t)(unsafe.Pointer(bp)))[i] + t1 = h + (_ror(tls, e, int32(6)) ^ _ror(tls, e, int32(11)) ^ _ror(tls, e, int32(25))) + (g ^ e&(f^g)) + _K[i] + (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i] t2 = _ror(tls, a, int32(2)) ^ _ror(tls, a, int32(13)) ^ _ror(tls, a, int32(22)) + (a&b | c&(a|b)) h = g g = f @@ -12328,14 +12328,14 @@ func _processblock1(tls *TLS, s uintptr, buf uintptr) { ; i = i + 1 } - *(*Tuint32_t)(unsafe.Pointer(s + 8)) += a - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) += b - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 2*4)) += c - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) += d - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 4*4)) += e - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 5*4)) += f - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 6*4)) += g - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 7*4)) += h + **(**Tuint32_t)(__ccgo_up(s + 8)) += a + **(**Tuint32_t)(__ccgo_up(s + 8 + 1*4)) += b + **(**Tuint32_t)(__ccgo_up(s + 8 + 2*4)) += c + **(**Tuint32_t)(__ccgo_up(s + 8 + 3*4)) += d + **(**Tuint32_t)(__ccgo_up(s + 8 + 4*4)) += e + **(**Tuint32_t)(__ccgo_up(s + 8 + 5*4)) += f + **(**Tuint32_t)(__ccgo_up(s + 8 + 6*4)) += g + **(**Tuint32_t)(__ccgo_up(s + 8 + 7*4)) += h } func _pad1(tls *TLS, s uintptr) { @@ -12344,35 +12344,35 @@ func _pad1(tls *TLS, s uintptr) { r = uint32((*Tsha256)(unsafe.Pointer(s)).Flen1 % uint64(64)) v1 = r r = r + 1 - *(*Tuint8_t)(unsafe.Pointer(s + 40 + uintptr(v1))) = uint8(0x80) + **(**Tuint8_t)(__ccgo_up(s + 40 + uintptr(v1))) = uint8(0x80) if r > uint32(56) { Xmemset(tls, s+40+uintptr(r), 0, uint64(uint32(64)-r)) r = uint32(0) _processblock1(tls, s, s+40) } Xmemset(tls, s+40+uintptr(r), 0, uint64(uint32(56)-r)) - *(*Tuint64_t)(unsafe.Pointer(s)) *= uint64(8) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 56)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(56)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 57)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(48)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 58)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(40)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 59)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(32)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 60)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(24)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 61)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(16)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 62)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(8)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 63)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1) + **(**Tuint64_t)(__ccgo_up(s)) *= uint64(8) + **(**Tuint8_t)(__ccgo_up(s + 40 + 56)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(56)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 57)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(48)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 58)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(40)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 59)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(32)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 60)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(24)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 61)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(16)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 62)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(8)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 63)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1) _processblock1(tls, s, s+40) } func _sha256_init(tls *TLS, s uintptr) { (*Tsha256)(unsafe.Pointer(s)).Flen1 = uint64(0) - *(*Tuint32_t)(unsafe.Pointer(s + 8)) = uint32(0x6a09e667) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) = uint32(0xbb67ae85) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 2*4)) = uint32(0x3c6ef372) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) = uint32(0xa54ff53a) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 4*4)) = uint32(0x510e527f) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 5*4)) = uint32(0x9b05688c) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 6*4)) = uint32(0x1f83d9ab) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 7*4)) = uint32(0x5be0cd19) + **(**Tuint32_t)(__ccgo_up(s + 8)) = uint32(0x6a09e667) + **(**Tuint32_t)(__ccgo_up(s + 8 + 1*4)) = uint32(0xbb67ae85) + **(**Tuint32_t)(__ccgo_up(s + 8 + 2*4)) = uint32(0x3c6ef372) + **(**Tuint32_t)(__ccgo_up(s + 8 + 3*4)) = uint32(0xa54ff53a) + **(**Tuint32_t)(__ccgo_up(s + 8 + 4*4)) = uint32(0x510e527f) + **(**Tuint32_t)(__ccgo_up(s + 8 + 5*4)) = uint32(0x9b05688c) + **(**Tuint32_t)(__ccgo_up(s + 8 + 6*4)) = uint32(0x1f83d9ab) + **(**Tuint32_t)(__ccgo_up(s + 8 + 7*4)) = uint32(0x5be0cd19) } func _sha256_sum(tls *TLS, s uintptr, md uintptr) { @@ -12384,10 +12384,10 @@ func _sha256_sum(tls *TLS, s uintptr, md uintptr) { if !(i < int32(8)) { break } - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4)) >> int32(24)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i+int32(1)))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4)) >> int32(16)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i+int32(2)))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4)) >> int32(8)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i+int32(3)))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4))) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4)) >> int32(24)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i+int32(1)))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4)) >> int32(16)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i+int32(2)))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4)) >> int32(8)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i+int32(3)))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4))) goto _1 _1: ; @@ -12401,7 +12401,7 @@ func _sha256_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { _, _ = p, r p = m r = uint32((*Tsha256)(unsafe.Pointer(s)).Flen1 % uint64(64)) - *(*Tuint64_t)(unsafe.Pointer(s)) += len1 + **(**Tuint64_t)(__ccgo_up(s)) += len1 if r != 0 { if len1 < uint64(uint32(64)-r) { Xmemcpy(tls, s+40+uintptr(r), p, len1) @@ -12440,7 +12440,7 @@ func _to641(tls *TLS, s uintptr, u uint32, n int32) (r uintptr) { } v2 = s s = s + 1 - *(*int8)(unsafe.Pointer(v2)) = Int8FromUint8(_b641[u%uint32(64)]) + **(**int8)(__ccgo_up(v2)) = Int8FromUint8(_b641[u%uint32(64)]) u = u / uint32(64) } return s @@ -12483,7 +12483,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui var _ /* rounds at bp+200 */ [20]int8 var _ /* smd at bp+168 */ [32]uint8 _, _, _, _, _, _, _ = i, klen, p, r, salt, slen, u - *(*[20]int8)(unsafe.Pointer(bp + 200)) = [20]int8{} + **(**[20]int8)(__ccgo_up(bp + 200)) = [20]int8{} /* reject large keys */ klen = uint32(Xstrnlen(tls, key, Uint64FromInt32(Int32FromInt32(KEY_MAX1)+Int32FromInt32(1)))) if klen > uint32(KEY_MAX1) { @@ -12509,14 +12509,14 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui * the host's value of ULONG_MAX. */ salt = salt + uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) - if !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(salt)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + if !(BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(salt)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } u = Xstrtoul(tls, salt, bp+224, int32(10)) - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 224))))) != int32('$') { + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 224))))) != int32('$') { return uintptr(0) } - salt = *(*uintptr)(unsafe.Pointer(bp + 224)) + uintptr(1) + salt = **(**uintptr)(__ccgo_up(bp + 224)) + uintptr(1) if u < uint64(ROUNDS_MIN) { r = uint32(ROUNDS_MIN) } else { @@ -12531,11 +12531,11 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui } i = uint32(0) for { - if !(i < uint32(SALT_MAX1) && *(*int8)(unsafe.Pointer(salt + uintptr(i))) != 0 && int32(*(*int8)(unsafe.Pointer(salt + uintptr(i)))) != int32('$')) { + if !(i < uint32(SALT_MAX1) && **(**int8)(__ccgo_up(salt + uintptr(i))) != 0 && int32(**(**int8)(__ccgo_up(salt + uintptr(i)))) != int32('$')) { break } /* reject characters that interfere with /etc/shadow parsing */ - if int32(*(*int8)(unsafe.Pointer(salt + uintptr(i)))) == int32('\n') || int32(*(*int8)(unsafe.Pointer(salt + uintptr(i)))) == int32(':') { + if int32(**(**int8)(__ccgo_up(salt + uintptr(i)))) == int32('\n') || int32(**(**int8)(__ccgo_up(salt + uintptr(i)))) == int32(':') { return uintptr(0) } goto _1 @@ -12589,7 +12589,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui _sha256_init(tls, bp) i = uint32(0) for { - if !(i < Uint32FromInt32(int32(16)+Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp + 104)))[0]))) { + if !(i < Uint32FromInt32(int32(16)+Int32FromUint8((**(**[32]uint8)(__ccgo_up(bp + 104)))[0]))) { break } _sha256_update(tls, bp, salt, uint64(slen)) @@ -12636,14 +12636,14 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui if !(i < uint32(10)) { break } - p = _to641(tls, p, Uint32FromInt32(Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp + 104)))[*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_perm1)) + uintptr(i)*3))])<>Int32FromInt32(6) + (*(*[80]Tuint64_t)(unsafe.Pointer(bp)))[i-int32(7)] + (_ror1(tls, (*(*[80]Tuint64_t)(unsafe.Pointer(bp)))[i-int32(15)], int32(1)) ^ _ror1(tls, (*(*[80]Tuint64_t)(unsafe.Pointer(bp)))[i-int32(15)], int32(8)) ^ (*(*[80]Tuint64_t)(unsafe.Pointer(bp)))[i-int32(15)]>>Int32FromInt32(7)) + (*(*[80]Tuint64_t)(unsafe.Pointer(bp)))[i-int32(16)] + (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i] = _ror1(tls, (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(2)], int32(19)) ^ _ror1(tls, (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(2)], int32(61)) ^ (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(2)]>>Int32FromInt32(6) + (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(7)] + (_ror1(tls, (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(15)], int32(1)) ^ _ror1(tls, (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(15)], int32(8)) ^ (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(15)]>>Int32FromInt32(7)) + (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(16)] goto _2 _2: ; i = i + 1 } - a = *(*Tuint64_t)(unsafe.Pointer(s + 8)) - b = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 1*8)) - c = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 2*8)) - d = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 3*8)) - e = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 4*8)) - f = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 5*8)) - g = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 6*8)) - h = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 7*8)) + a = **(**Tuint64_t)(__ccgo_up(s + 8)) + b = **(**Tuint64_t)(__ccgo_up(s + 8 + 1*8)) + c = **(**Tuint64_t)(__ccgo_up(s + 8 + 2*8)) + d = **(**Tuint64_t)(__ccgo_up(s + 8 + 3*8)) + e = **(**Tuint64_t)(__ccgo_up(s + 8 + 4*8)) + f = **(**Tuint64_t)(__ccgo_up(s + 8 + 5*8)) + g = **(**Tuint64_t)(__ccgo_up(s + 8 + 6*8)) + h = **(**Tuint64_t)(__ccgo_up(s + 8 + 7*8)) i = 0 for { if !(i < int32(80)) { break } - t1 = h + (_ror1(tls, e, int32(14)) ^ _ror1(tls, e, int32(18)) ^ _ror1(tls, e, int32(41))) + (g ^ e&(f^g)) + _K1[i] + (*(*[80]Tuint64_t)(unsafe.Pointer(bp)))[i] + t1 = h + (_ror1(tls, e, int32(14)) ^ _ror1(tls, e, int32(18)) ^ _ror1(tls, e, int32(41))) + (g ^ e&(f^g)) + _K1[i] + (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i] t2 = _ror1(tls, a, int32(28)) ^ _ror1(tls, a, int32(34)) ^ _ror1(tls, a, int32(39)) + (a&b | c&(a|b)) h = g g = f @@ -12883,14 +12883,14 @@ func _processblock2(tls *TLS, s uintptr, buf uintptr) { ; i = i + 1 } - *(*Tuint64_t)(unsafe.Pointer(s + 8)) += a - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 1*8)) += b - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 2*8)) += c - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 3*8)) += d - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 4*8)) += e - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 5*8)) += f - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 6*8)) += g - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 7*8)) += h + **(**Tuint64_t)(__ccgo_up(s + 8)) += a + **(**Tuint64_t)(__ccgo_up(s + 8 + 1*8)) += b + **(**Tuint64_t)(__ccgo_up(s + 8 + 2*8)) += c + **(**Tuint64_t)(__ccgo_up(s + 8 + 3*8)) += d + **(**Tuint64_t)(__ccgo_up(s + 8 + 4*8)) += e + **(**Tuint64_t)(__ccgo_up(s + 8 + 5*8)) += f + **(**Tuint64_t)(__ccgo_up(s + 8 + 6*8)) += g + **(**Tuint64_t)(__ccgo_up(s + 8 + 7*8)) += h } func _pad2(tls *TLS, s uintptr) { @@ -12899,35 +12899,35 @@ func _pad2(tls *TLS, s uintptr) { r = uint32((*Tsha512)(unsafe.Pointer(s)).Flen1 % uint64(128)) v1 = r r = r + 1 - *(*Tuint8_t)(unsafe.Pointer(s + 72 + uintptr(v1))) = uint8(0x80) + **(**Tuint8_t)(__ccgo_up(s + 72 + uintptr(v1))) = uint8(0x80) if r > uint32(112) { Xmemset(tls, s+72+uintptr(r), 0, uint64(uint32(128)-r)) r = uint32(0) _processblock2(tls, s, s+72) } Xmemset(tls, s+72+uintptr(r), 0, uint64(uint32(120)-r)) - *(*Tuint64_t)(unsafe.Pointer(s)) *= uint64(8) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 120)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(56)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 121)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(48)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 122)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(40)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 123)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(32)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 124)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(24)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 125)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(16)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 126)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(8)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 127)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1) + **(**Tuint64_t)(__ccgo_up(s)) *= uint64(8) + **(**Tuint8_t)(__ccgo_up(s + 72 + 120)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(56)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 121)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(48)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 122)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(40)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 123)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(32)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 124)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(24)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 125)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(16)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 126)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(8)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 127)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1) _processblock2(tls, s, s+72) } func _sha512_init(tls *TLS, s uintptr) { (*Tsha512)(unsafe.Pointer(s)).Flen1 = uint64(0) - *(*Tuint64_t)(unsafe.Pointer(s + 8)) = uint64(0x6a09e667f3bcc908) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 1*8)) = uint64(0xbb67ae8584caa73b) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 2*8)) = uint64(0x3c6ef372fe94f82b) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 3*8)) = uint64(0xa54ff53a5f1d36f1) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 4*8)) = uint64(0x510e527fade682d1) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 5*8)) = uint64(0x9b05688c2b3e6c1f) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 6*8)) = uint64(0x1f83d9abfb41bd6b) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 7*8)) = uint64(0x5be0cd19137e2179) + **(**Tuint64_t)(__ccgo_up(s + 8)) = uint64(0x6a09e667f3bcc908) + **(**Tuint64_t)(__ccgo_up(s + 8 + 1*8)) = uint64(0xbb67ae8584caa73b) + **(**Tuint64_t)(__ccgo_up(s + 8 + 2*8)) = uint64(0x3c6ef372fe94f82b) + **(**Tuint64_t)(__ccgo_up(s + 8 + 3*8)) = uint64(0xa54ff53a5f1d36f1) + **(**Tuint64_t)(__ccgo_up(s + 8 + 4*8)) = uint64(0x510e527fade682d1) + **(**Tuint64_t)(__ccgo_up(s + 8 + 5*8)) = uint64(0x9b05688c2b3e6c1f) + **(**Tuint64_t)(__ccgo_up(s + 8 + 6*8)) = uint64(0x1f83d9abfb41bd6b) + **(**Tuint64_t)(__ccgo_up(s + 8 + 7*8)) = uint64(0x5be0cd19137e2179) } func _sha512_sum(tls *TLS, s uintptr, md uintptr) { @@ -12939,14 +12939,14 @@ func _sha512_sum(tls *TLS, s uintptr, md uintptr) { if !(i < int32(8)) { break } - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(56)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(1)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(48)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(2)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(40)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(3)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(32)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(4)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(24)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(5)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(16)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(6)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(8)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(7)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8))) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(56)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(1)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(48)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(2)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(40)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(3)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(32)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(4)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(24)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(5)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(16)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(6)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(8)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(7)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8))) goto _1 _1: ; @@ -12960,7 +12960,7 @@ func _sha512_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { _, _ = p, r p = m r = uint32((*Tsha512)(unsafe.Pointer(s)).Flen1 % uint64(128)) - *(*Tuint64_t)(unsafe.Pointer(s)) += len1 + **(**Tuint64_t)(__ccgo_up(s)) += len1 if r != 0 { if len1 < uint64(uint32(128)-r) { Xmemcpy(tls, s+72+uintptr(r), p, len1) @@ -12999,7 +12999,7 @@ func _to642(tls *TLS, s uintptr, u uint32, n int32) (r uintptr) { } v2 = s s = s + 1 - *(*int8)(unsafe.Pointer(v2)) = Int8FromUint8(_b642[u%uint32(64)]) + **(**int8)(__ccgo_up(v2)) = Int8FromUint8(_b642[u%uint32(64)]) u = u / uint32(64) } return s @@ -13042,11 +13042,11 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui var _ /* rounds at bp+392 */ [20]int8 var _ /* smd at bp+328 */ [64]uint8 _, _, _, _, _, _, _ = i, klen, p, r, salt, slen, u - *(*[20]int8)(unsafe.Pointer(bp + 392)) = [20]int8{} + **(**[20]int8)(__ccgo_up(bp + 392)) = [20]int8{} /* reject large keys */ i = uint32(0) for { - if !(i <= uint32(KEY_MAX1) && *(*int8)(unsafe.Pointer(key + uintptr(i))) != 0) { + if !(i <= uint32(KEY_MAX1) && **(**int8)(__ccgo_up(key + uintptr(i))) != 0) { break } goto _1 @@ -13078,14 +13078,14 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui * the host's value of ULONG_MAX. */ salt = salt + uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) - if !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(salt)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + if !(BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(salt)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } u = Xstrtoul(tls, salt, bp+416, int32(10)) - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 416))))) != int32('$') { + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 416))))) != int32('$') { return uintptr(0) } - salt = *(*uintptr)(unsafe.Pointer(bp + 416)) + uintptr(1) + salt = **(**uintptr)(__ccgo_up(bp + 416)) + uintptr(1) if u < uint64(ROUNDS_MIN) { r = uint32(ROUNDS_MIN) } else { @@ -13100,11 +13100,11 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui } i = uint32(0) for { - if !(i < uint32(SALT_MAX1) && *(*int8)(unsafe.Pointer(salt + uintptr(i))) != 0 && int32(*(*int8)(unsafe.Pointer(salt + uintptr(i)))) != int32('$')) { + if !(i < uint32(SALT_MAX1) && **(**int8)(__ccgo_up(salt + uintptr(i))) != 0 && int32(**(**int8)(__ccgo_up(salt + uintptr(i)))) != int32('$')) { break } /* reject characters that interfere with /etc/shadow parsing */ - if int32(*(*int8)(unsafe.Pointer(salt + uintptr(i)))) == int32('\n') || int32(*(*int8)(unsafe.Pointer(salt + uintptr(i)))) == int32(':') { + if int32(**(**int8)(__ccgo_up(salt + uintptr(i)))) == int32('\n') || int32(**(**int8)(__ccgo_up(salt + uintptr(i)))) == int32(':') { return uintptr(0) } goto _2 @@ -13158,7 +13158,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui _sha512_init(tls, bp) i = uint32(0) for { - if !(i < Uint32FromInt32(int32(16)+Int32FromUint8((*(*[64]uint8)(unsafe.Pointer(bp + 200)))[0]))) { + if !(i < Uint32FromInt32(int32(16)+Int32FromUint8((**(**[64]uint8)(__ccgo_up(bp + 200)))[0]))) { break } _sha512_update(tls, bp, salt, uint64(slen)) @@ -13205,14 +13205,14 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui if !(i < uint32(21)) { break } - p = _to642(tls, p, Uint32FromInt32(Int32FromUint8((*(*[64]uint8)(unsafe.Pointer(bp + 200)))[*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_perm2)) + uintptr(i)*3))])<= 0) { break } v3 = bp + uintptr(i) - *(*uint8)(unsafe.Pointer(v3)) = uint8(uint32(*(*uint8)(unsafe.Pointer(v3))) | Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(key)))&Int32FromInt32(1))<= 0) { break } - *(*Tuint32_t)(unsafe.Pointer(bp + 128 + uintptr(i)*4)) |= Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(p)))&Int32FromInt32(1)) << j + **(**Tuint32_t)(__ccgo_up(bp + 128 + uintptr(i)*4)) |= Uint32FromInt32(int32(**(**int8)(__ccgo_up(p)))&Int32FromInt32(1)) << j goto _2 _2: ; @@ -13430,15 +13430,15 @@ func Xencrypt(tls *TLS, block uintptr, edflag int32) { if !(i < int32(16)) { break } - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(i)*4)) = *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&___encrypt_key)) + uintptr(int32(15)-i)*4)) - *(*Tuint32_t)(unsafe.Pointer(bp + 64 + uintptr(i)*4)) = *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&___encrypt_key)) + 64 + uintptr(int32(15)-i)*4)) + **(**Tuint32_t)(__ccgo_up(bp + uintptr(i)*4)) = **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&___encrypt_key)) + uintptr(int32(15)-i)*4)) + **(**Tuint32_t)(__ccgo_up(bp + 64 + uintptr(i)*4)) = **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&___encrypt_key)) + 64 + uintptr(int32(15)-i)*4)) goto _3 _3: ; i = i + 1 } } - X__do_des(tls, (*(*[2]Tuint32_t)(unsafe.Pointer(bp + 128)))[0], (*(*[2]Tuint32_t)(unsafe.Pointer(bp + 128)))[int32(1)], bp+128, bp+128+uintptr(1)*4, uint32(1), uint32(0), key) + X__do_des(tls, (**(**[2]Tuint32_t)(__ccgo_up(bp + 128)))[0], (**(**[2]Tuint32_t)(__ccgo_up(bp + 128)))[int32(1)], bp+128, bp+128+uintptr(1)*4, uint32(1), uint32(0), key) p = block i = 0 for { @@ -13452,7 +13452,7 @@ func Xencrypt(tls *TLS, block uintptr, edflag int32) { } v6 = p p = p + 1 - *(*int8)(unsafe.Pointer(v6)) = Int8FromUint32((*(*[2]Tuint32_t)(unsafe.Pointer(bp + 128)))[i] >> j & uint32(1)) + **(**int8)(__ccgo_up(v6)) = Int8FromUint32((**(**[2]Tuint32_t)(__ccgo_up(bp + 128)))[i] >> j & uint32(1)) goto _5 _5: ; @@ -13931,7 +13931,7 @@ func X__ctype_get_mb_cur_max(tls *TLS) (r Tsize_t) { } var v1 int32 _ = v1 - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v1 = int32(4) } else { v1 = int32(1) @@ -17495,10 +17495,10 @@ func Xwctype(tls *TLS, s uintptr) (r Twctype_t) { i = int32(1) p = uintptr(unsafe.Pointer(&_names)) for { - if !(*(*int8)(unsafe.Pointer(p)) != 0) { + if !(**(**int8)(__ccgo_up(p)) != 0) { break } - if int32(*(*int8)(unsafe.Pointer(s))) == int32(*(*int8)(unsafe.Pointer(p))) && !(Xstrcmp(tls, s, p) != 0) { + if int32(**(**int8)(__ccgo_up(s))) == int32(**(**int8)(__ccgo_up(p))) && !(Xstrcmp(tls, s, p) != 0) { return Uint64FromInt32(i) } goto _1 @@ -22244,9 +22244,9 @@ func _casemap(tls *TLS, c uint32, dir int32) (r1 int32) { xn = Uint32FromInt32(rd & int32(0xff)) xb = Uint32FromInt32(rd) >> int32(8) for xn != 0 { - try = uint32(*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_exceptions)) + uintptr(xb+xn/uint32(2))*2))) + try = uint32(**(**uint8)(__ccgo_up(uintptr(unsafe.Pointer(&_exceptions)) + uintptr(xb+xn/uint32(2))*2))) if try == c { - r = _rules[*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_exceptions)) + uintptr(xb+xn/uint32(2))*2 + 1))] + r = _rules[**(**uint8)(__ccgo_up(uintptr(unsafe.Pointer(&_exceptions)) + uintptr(xb+xn/uint32(2))*2 + 1))] rt = Uint32FromInt32(r & int32(255)) rd = r >> int32(8) if rt < uint32(2) { @@ -22339,8 +22339,8 @@ func Xwcswidth(tls *TLS, wcs uintptr, n Tsize_t) (r int32) { for { v2 = n n = n - 1 - if v4 = v2 != 0 && *(*Twchar_t)(unsafe.Pointer(wcs)) != 0; v4 { - v3 = Xwcwidth(tls, *(*Twchar_t)(unsafe.Pointer(wcs))) + if v4 = v2 != 0 && **(**Twchar_t)(__ccgo_up(wcs)) != 0; v4 { + v3 = Xwcwidth(tls, **(**Twchar_t)(__ccgo_up(wcs))) k = v3 } if !(v4 && v3 >= 0) { @@ -24540,7 +24540,7 @@ func Xalphasort(tls *TLS, a uintptr, b uintptr) (r int32) { trc("tls=%v a=%v b=%v, (%v:)", tls, a, b, origin(2)) defer func() { trc("-> %v", r) }() } - return Xstrcoll(tls, *(*uintptr)(unsafe.Pointer(a))+19, *(*uintptr)(unsafe.Pointer(b))+19) + return Xstrcoll(tls, **(**uintptr)(__ccgo_up(a))+19, **(**uintptr)(__ccgo_up(b))+19) } type TDIR = struct { @@ -24709,11 +24709,11 @@ func Xfdopendir(tls *TLS, fd int32) (r uintptr) { return uintptr(0) } if Xfcntl(tls, fd, int32(F_GETFL), 0)&int32(O_PATH) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EBADF) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EBADF) return uintptr(0) } - if !((*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&Uint32FromInt32(S_IFMT) == Uint32FromInt32(S_IFDIR)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOTDIR) + if !((**(**Tstat)(__ccgo_up(bp))).Fst_mode&Uint32FromInt32(S_IFMT) == Uint32FromInt32(S_IFDIR)) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOTDIR) return uintptr(0) } v1 = Xcalloc(tls, uint64(1), uint64(2072)) @@ -24848,7 +24848,7 @@ func Xreaddir(tls *TLS, dir uintptr) (r uintptr) { len1 = int32(X__syscall3(tls, int64(SYS_getdents64), int64((*TDIR)(unsafe.Pointer(dir)).Ffd), int64(dir+24), Int64FromUint64(Uint64FromInt64(2048)))) if len1 <= 0 { if len1 < 0 && len1 != -int32(ENOENT) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = -len1 + **(**int32)(__ccgo_up(X__errno_location(tls))) = -len1 } return uintptr(0) } @@ -24856,7 +24856,7 @@ func Xreaddir(tls *TLS, dir uintptr) (r uintptr) { (*TDIR)(unsafe.Pointer(dir)).Fbuf_pos = 0 } de = dir + 24 + uintptr((*TDIR)(unsafe.Pointer(dir)).Fbuf_pos) - *(*int32)(unsafe.Pointer(dir + 12)) += Int32FromUint16((*Tdirent)(unsafe.Pointer(de)).Fd_reclen) + **(**int32)(__ccgo_up(dir + 12)) += Int32FromUint16((*Tdirent)(unsafe.Pointer(de)).Fd_reclen) (*TDIR)(unsafe.Pointer(dir)).Ftell = (*Tdirent)(unsafe.Pointer(de)).Fd_off return de } @@ -24869,24 +24869,24 @@ func Xreaddir_r(tls *TLS, dir uintptr, buf uintptr, result uintptr) (r int32) { var de uintptr var errno_save, ret, v1 int32 _, _, _, _ = de, errno_save, ret, v1 - errno_save = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + errno_save = **(**int32)(__ccgo_up(X__errno_location(tls))) ___lock(tls, dir+20) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = 0 + **(**int32)(__ccgo_up(X__errno_location(tls))) = 0 de = Xreaddir(tls, dir) - v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = **(**int32)(__ccgo_up(X__errno_location(tls))) ret = v1 if v1 != 0 { ___unlock(tls, dir+20) return ret } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = errno_save + **(**int32)(__ccgo_up(X__errno_location(tls))) = errno_save if de != 0 { Xmemcpy(tls, buf, de, uint64((*Tdirent)(unsafe.Pointer(de)).Fd_reclen)) } else { buf = UintptrFromInt32(0) } ___unlock(tls, dir+20) - *(*uintptr)(unsafe.Pointer(result)) = buf + **(**uintptr)(__ccgo_up(result)) = buf return 0 } @@ -24922,12 +24922,12 @@ func Xscandir(tls *TLS, path uintptr, res uintptr, __ccgo_fp_sel uintptr, __ccgo names = uintptr(0) cnt = uint64(0) len1 = uint64(0) - old_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + old_errno = **(**int32)(__ccgo_up(X__errno_location(tls))) if !(d != 0) { return -int32(1) } for { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = 0 + **(**int32)(__ccgo_up(X__errno_location(tls))) = 0 v1 = Xreaddir(tls, d) de = v1 if !(v1 != 0) { @@ -24947,16 +24947,16 @@ func Xscandir(tls *TLS, path uintptr, res uintptr, __ccgo_fp_sel uintptr, __ccgo } names = tmp } - *(*uintptr)(unsafe.Pointer(names + uintptr(cnt)*8)) = Xmalloc(tls, uint64((*Tdirent)(unsafe.Pointer(de)).Fd_reclen)) - if !(*(*uintptr)(unsafe.Pointer(names + uintptr(cnt)*8)) != 0) { + **(**uintptr)(__ccgo_up(names + uintptr(cnt)*8)) = Xmalloc(tls, uint64((*Tdirent)(unsafe.Pointer(de)).Fd_reclen)) + if !(**(**uintptr)(__ccgo_up(names + uintptr(cnt)*8)) != 0) { break } v2 = cnt cnt = cnt + 1 - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(names + uintptr(v2)*8)), de, uint64((*Tdirent)(unsafe.Pointer(de)).Fd_reclen)) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(names + uintptr(v2)*8)), de, uint64((*Tdirent)(unsafe.Pointer(de)).Fd_reclen)) } Xclosedir(tls, d) - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != 0 { + if **(**int32)(__ccgo_up(X__errno_location(tls))) != 0 { if names != 0 { for { v2 = cnt @@ -24964,17 +24964,17 @@ func Xscandir(tls *TLS, path uintptr, res uintptr, __ccgo_fp_sel uintptr, __ccgo if !(v2 > uint64(0)) { break } - Xfree(tls, *(*uintptr)(unsafe.Pointer(names + uintptr(cnt)*8))) + Xfree(tls, **(**uintptr)(__ccgo_up(names + uintptr(cnt)*8))) } } Xfree(tls, names) return -int32(1) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = old_errno + **(**int32)(__ccgo_up(X__errno_location(tls))) = old_errno if __ccgo_fp_cmp != 0 { Xqsort(tls, names, cnt, uint64(8), __ccgo_fp_cmp) } - *(*uintptr)(unsafe.Pointer(res)) = names + **(**uintptr)(__ccgo_up(res)) = names return Int32FromUint64(cnt) } @@ -25005,7 +25005,7 @@ func Xversionsort(tls *TLS, a uintptr, b uintptr) (r int32) { trc("tls=%v a=%v b=%v, (%v:)", tls, a, b, origin(2)) defer func() { trc("-> %v", r) }() } - return Xstrverscmp(tls, *(*uintptr)(unsafe.Pointer(a))+19, *(*uintptr)(unsafe.Pointer(b))+19) + return Xstrverscmp(tls, **(**uintptr)(__ccgo_up(a))+19, **(**uintptr)(__ccgo_up(b))+19) } func X__reset_tls(tls *TLS) { @@ -25017,7 +25017,7 @@ func X__reset_tls(tls *TLS) { var self Tpthread_t _, _, _, _, _ = i, mem, n, p, self self = uintptr(___get_tp(tls)) - n = *(*Tuintptr_t)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(self)).Fdtv)) + n = **(**Tuintptr_t)(__ccgo_up((*t__pthread)(unsafe.Pointer(self)).Fdtv)) if n != 0 { p = X__libc.Ftls_head i = Uint64FromInt32(1) @@ -25025,7 +25025,7 @@ func X__reset_tls(tls *TLS) { if !(i <= n) { break } - mem = uintptr(*(*Tuintptr_t)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(self)).Fdtv + uintptr(i)*8)) - Uint64FromInt32(DTP_OFFSET)) + mem = uintptr(**(**Tuintptr_t)(__ccgo_up((*t__pthread)(unsafe.Pointer(self)).Fdtv + uintptr(i)*8)) - Uint64FromInt32(DTP_OFFSET)) Xmemcpy(tls, mem, (*Ttls_module)(unsafe.Pointer(p)).Fimage, (*Ttls_module)(unsafe.Pointer(p)).Flen1) Xmemset(tls, mem+uintptr((*Ttls_module)(unsafe.Pointer(p)).Flen1), 0, (*Ttls_module)(unsafe.Pointer(p)).Fsize-(*Ttls_module)(unsafe.Pointer(p)).Flen1) goto _1 @@ -25051,7 +25051,7 @@ func X__init_ssp(tls *TLS, entropy uintptr) { * The NULL byte is on the second byte so that off-by-ones can * still be detected. Endianness is taken care of * automatically. */ - *(*int8)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stack_chk_guard)) + 1)) = 0 + **(**int8)(__ccgo_up(uintptr(unsafe.Pointer(&X__stack_chk_guard)) + 1)) = 0 (*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Fcanary = X__stack_chk_guard } @@ -25059,7 +25059,7 @@ func X__stack_chk_fail(tls *TLS) { if __ccgo_strace { trc("tls=%v, (%v:)", tls, origin(2)) } - *(*int8)(unsafe.Pointer(UintptrFromInt32(0))) = 0 + **(**int8)(__ccgo_up(UintptrFromInt32(0))) = 0 } func X__stack_chk_fail_local(tls *TLS) { @@ -25086,10 +25086,10 @@ func Xclearenv(tls *TLS) (r int32) { e = Xenviron Xenviron = uintptr(0) if e != 0 { - for *(*uintptr)(unsafe.Pointer(e)) != 0 { + for **(**uintptr)(__ccgo_up(e)) != 0 { v1 = e e += 8 - X__env_rm_add(tls, *(*uintptr)(unsafe.Pointer(v1)), uintptr(0)) + X__env_rm_add(tls, **(**uintptr)(__ccgo_up(v1)), uintptr(0)) } } return 0 @@ -25104,14 +25104,14 @@ func Xgetenv(tls *TLS, name uintptr) (r uintptr) { var l Tsize_t _, _ = e, l l = Uint64FromInt64(int64(X__strchrnul(tls, name, int32('='))) - int64(name)) - if l != 0 && !(*(*int8)(unsafe.Pointer(name + uintptr(l))) != 0) && Xenviron != 0 { + if l != 0 && !(**(**int8)(__ccgo_up(name + uintptr(l))) != 0) && Xenviron != 0 { e = Xenviron for { - if !(*(*uintptr)(unsafe.Pointer(e)) != 0) { + if !(**(**uintptr)(__ccgo_up(e)) != 0) { break } - if !(Xstrncmp(tls, name, *(*uintptr)(unsafe.Pointer(e)), l) != 0) && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(e)) + uintptr(l)))) == int32('=') { - return *(*uintptr)(unsafe.Pointer(e)) + uintptr(l) + uintptr(1) + if !(Xstrncmp(tls, name, **(**uintptr)(__ccgo_up(e)), l) != 0) && int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(e)) + uintptr(l)))) == int32('=') { + return **(**uintptr)(__ccgo_up(e)) + uintptr(l) + uintptr(1) } goto _1 _1: @@ -25137,12 +25137,12 @@ func X__putenv(tls *TLS, s uintptr, l Tsize_t, r uintptr) (r1 int32) { if Xenviron != 0 { e = Xenviron for { - if !(*(*uintptr)(unsafe.Pointer(e)) != 0) { + if !(**(**uintptr)(__ccgo_up(e)) != 0) { break } - if !(Xstrncmp(tls, s, *(*uintptr)(unsafe.Pointer(e)), l+uint64(1)) != 0) { - tmp = *(*uintptr)(unsafe.Pointer(e)) - *(*uintptr)(unsafe.Pointer(e)) = s + if !(Xstrncmp(tls, s, **(**uintptr)(__ccgo_up(e)), l+uint64(1)) != 0) { + tmp = **(**uintptr)(__ccgo_up(e)) + **(**uintptr)(__ccgo_up(e)) = s X__env_rm_add(tls, tmp, r) return 0 } @@ -25168,8 +25168,8 @@ func X__putenv(tls *TLS, s uintptr, l Tsize_t, r uintptr) (r1 int32) { } Xfree(tls, _oldenv) } - *(*uintptr)(unsafe.Pointer(newenv + uintptr(i)*8)) = s - *(*uintptr)(unsafe.Pointer(newenv + uintptr(i+uint64(1))*8)) = uintptr(0) + **(**uintptr)(__ccgo_up(newenv + uintptr(i)*8)) = s + **(**uintptr)(__ccgo_up(newenv + uintptr(i+uint64(1))*8)) = uintptr(0) v2 = newenv _oldenv = v2 Xenviron = v2 @@ -25194,7 +25194,7 @@ func Xputenv(tls *TLS, s uintptr) (r int32) { var l Tsize_t _ = l l = Uint64FromInt64(int64(X__strchrnul(tls, s, int32('='))) - int64(s)) - if !(l != 0) || !(*(*int8)(unsafe.Pointer(s + uintptr(l))) != 0) { + if !(l != 0) || !(**(**int8)(__ccgo_up(s + uintptr(l))) != 0) { return Xunsetenv(tls, s) } return X__putenv(tls, s, l, uintptr(0)) @@ -25239,13 +25239,13 @@ func X__env_rm_add(tls *TLS, old uintptr, new1 uintptr) { if !(i < _env_alloced_n) { break } - if *(*uintptr)(unsafe.Pointer(_env_alloced + uintptr(i)*8)) == old { - *(*uintptr)(unsafe.Pointer(_env_alloced + uintptr(i)*8)) = new1 + if **(**uintptr)(__ccgo_up(_env_alloced + uintptr(i)*8)) == old { + **(**uintptr)(__ccgo_up(_env_alloced + uintptr(i)*8)) = new1 Xfree(tls, old) return } else { - if !(*(*uintptr)(unsafe.Pointer(_env_alloced + uintptr(i)*8)) != 0) && new1 != 0 { - *(*uintptr)(unsafe.Pointer(_env_alloced + uintptr(i)*8)) = new1 + if !(**(**uintptr)(__ccgo_up(_env_alloced + uintptr(i)*8)) != 0) && new1 != 0 { + **(**uintptr)(__ccgo_up(_env_alloced + uintptr(i)*8)) = new1 new1 = uintptr(0) } } @@ -25265,7 +25265,7 @@ func X__env_rm_add(tls *TLS, old uintptr, new1 uintptr) { _env_alloced = v2 v3 = _env_alloced_n _env_alloced_n = _env_alloced_n + 1 - *(*uintptr)(unsafe.Pointer(v2 + uintptr(v3)*8)) = new1 + **(**uintptr)(__ccgo_up(v2 + uintptr(v3)*8)) = new1 } var _env_alloced uintptr @@ -25285,8 +25285,8 @@ func Xsetenv(tls *TLS, var1 uintptr, value uintptr, overwrite int32) (r int32) { v1 = Uint64FromInt64(int64(X__strchrnul(tls, var1, int32('='))) - int64(var1)) l1 = v1 } - if v2 || !(v1 != 0) || *(*int8)(unsafe.Pointer(var1 + uintptr(l1))) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if v2 || !(v1 != 0) || **(**int8)(__ccgo_up(var1 + uintptr(l1))) != 0 { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } if !(overwrite != 0) && Xgetenv(tls, var1) != 0 { @@ -25298,7 +25298,7 @@ func Xsetenv(tls *TLS, var1 uintptr, value uintptr, overwrite int32) (r int32) { return -int32(1) } Xmemcpy(tls, s, var1, l1) - *(*int8)(unsafe.Pointer(s + uintptr(l1))) = int8('=') + **(**int8)(__ccgo_up(s + uintptr(l1))) = int8('=') Xmemcpy(tls, s+uintptr(l1)+uintptr(1), value, l2+uint64(1)) return X__putenv(tls, s, l1, s) } @@ -25315,24 +25315,24 @@ func Xunsetenv(tls *TLS, name uintptr) (r int32) { var l Tsize_t _, _, _, _ = e, eo, l, v2 l = Uint64FromInt64(int64(X__strchrnul(tls, name, int32('='))) - int64(name)) - if !(l != 0) || *(*int8)(unsafe.Pointer(name + uintptr(l))) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if !(l != 0) || **(**int8)(__ccgo_up(name + uintptr(l))) != 0 { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } if Xenviron != 0 { e = Xenviron eo = e for { - if !(*(*uintptr)(unsafe.Pointer(e)) != 0) { + if !(**(**uintptr)(__ccgo_up(e)) != 0) { break } - if !(Xstrncmp(tls, name, *(*uintptr)(unsafe.Pointer(e)), l) != 0) && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(e)) + uintptr(l)))) == int32('=') { - X__env_rm_add(tls, *(*uintptr)(unsafe.Pointer(e)), uintptr(0)) + if !(Xstrncmp(tls, name, **(**uintptr)(__ccgo_up(e)), l) != 0) && int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(e)) + uintptr(l)))) == int32('=') { + X__env_rm_add(tls, **(**uintptr)(__ccgo_up(e)), uintptr(0)) } else { if eo != e { v2 = eo eo += 8 - *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(e)) + **(**uintptr)(__ccgo_up(v2)) = **(**uintptr)(__ccgo_up(e)) } else { eo += 8 } @@ -25343,7 +25343,7 @@ func Xunsetenv(tls *TLS, name uintptr) (r int32) { e += 8 } if eo != e { - *(*uintptr)(unsafe.Pointer(eo)) = uintptr(0) + **(**uintptr)(__ccgo_up(eo)) = uintptr(0) } } return 0 @@ -25653,7 +25653,7 @@ func X__strerror_l(tls *TLS, e int32, loc Tlocale_t) (r uintptr) { e = 0 } s = uintptr(unsafe.Pointer(&_errmsgstr)) + uintptr(_errmsgidx[e]) - return X__lctrans(tls, s, *(*uintptr)(unsafe.Pointer(loc + 5*8))) + return X__lctrans(tls, s, **(**uintptr)(__ccgo_up(loc + 5*8))) } func Xstrerror(tls *TLS, e int32) (r uintptr) { @@ -25790,10 +25790,10 @@ func Xfcntl(tls *TLS, fd int32, cmd int32, va uintptr) (r int32) { if ret != 0 { return int32(X__syscall_ret(tls, Uint64FromInt32(ret))) } - if (*(*Tf_owner_ex)(unsafe.Pointer(bp))).Ftype1 == int32(F_OWNER_PGRP) { - v1 = -(*(*Tf_owner_ex)(unsafe.Pointer(bp))).Fpid + if (**(**Tf_owner_ex)(__ccgo_up(bp))).Ftype1 == int32(F_OWNER_PGRP) { + v1 = -(**(**Tf_owner_ex)(__ccgo_up(bp))).Fpid } else { - v1 = (*(*Tf_owner_ex)(unsafe.Pointer(bp))).Fpid + v1 = (**(**Tf_owner_ex)(__ccgo_up(bp))).Fpid } return v1 } @@ -25965,7 +25965,7 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -25976,7 +25976,7 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26006,7 +26006,7 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26025,7 +26025,7 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26042,7 +26042,7 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26095,7 +26095,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__shgetc(tls, f) } @@ -26107,7 +26107,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__shgetc(tls, f) } @@ -26125,14 +26125,14 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__shgetc(tls, f) } c = v2 } } - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0] = uint32(0) + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[0] = uint32(0) for { if !(Uint32FromInt32(c-int32('0')) < uint32(10) || c == int32('.')) { break @@ -26150,9 +26150,9 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, lnz = int32(dc) } if j != 0 { - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k]*uint32(10) + Uint32FromInt32(c) - uint32('0') + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] = (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k]*uint32(10) + Uint32FromInt32(c) - uint32('0') } else { - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] = Uint32FromInt32(c - int32('0')) + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] = Uint32FromInt32(c - int32('0')) } j = j + 1 v2 = j @@ -26165,7 +26165,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, dc = dc + 1 if c != int32('0') { lnz = (Int32FromInt32(KMAX) - Int32FromInt32(4)) * Int32FromInt32(9) - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(Int32FromInt32(KMAX)-Int32FromInt32(4))*4)) |= uint32(1) + **(**Tuint32_t)(__ccgo_up(bp + uintptr(Int32FromInt32(KMAX)-Int32FromInt32(4))*4)) |= uint32(1) } } } @@ -26176,7 +26176,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__shgetc(tls, f) } @@ -26207,24 +26207,24 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, } } if !(gotdig != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) X__shlim(tls, f, int64(Int32FromInt32(0))) return Float64FromInt32(0) } /* Handle zero specially to avoid nasty special cases later */ - if !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0] != 0) { + if !((**(**[128]Tuint32_t)(__ccgo_up(bp)))[0] != 0) { return float64(float64(sign) * float64(0)) } /* Optimize small integers (w/no exponent) and over/under-flow */ - if lrp == dc && dc < int64(10) && (bits > int32(30) || (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0]>>bits == uint32(0)) { - return float64(float64(sign) * float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0])) + if lrp == dc && dc < int64(10) && (bits > int32(30) || (**(**[128]Tuint32_t)(__ccgo_up(bp)))[0]>>bits == uint32(0)) { + return float64(float64(sign) * float64((**(**[128]Tuint32_t)(__ccgo_up(bp)))[0])) } if lrp > int64(-emin/int32(2)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return float64(float64(float64(sign)*Float64FromFloat64(1.79769313486231570815e+308)) * Float64FromFloat64(1.79769313486231570815e+308)) } if lrp < int64(emin-Int32FromInt32(2)*Int32FromInt32(LDBL_MANT_DIG)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return float64(float64(float64(sign)*Float64FromFloat64(2.22507385850720138309e-308)) * Float64FromFloat64(2.22507385850720138309e-308)) } /* Align incomplete final B1B digit */ @@ -26233,7 +26233,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if !(j < int32(9)) { break } - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(k)*4)) *= uint32(10) + **(**Tuint32_t)(__ccgo_up(bp + uintptr(k)*4)) *= uint32(10) goto _17 _17: ; @@ -26249,19 +26249,19 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, /* Optimize small to mid-size integers (even in exp. notation) */ if lnz < int32(9) && lnz <= rp && rp < int32(18) { if rp == int32(9) { - return float64(float64(sign) * float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0])) + return float64(float64(sign) * float64((**(**[128]Tuint32_t)(__ccgo_up(bp)))[0])) } if rp < int32(9) { - return float64(float64(sign)*float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0])) / float64(_p10s[int32(8)-rp]) + return float64(float64(sign)*float64((**(**[128]Tuint32_t)(__ccgo_up(bp)))[0])) / float64(_p10s[int32(8)-rp]) } bitlim = bits - int32(3)*(rp-Int32FromInt32(9)) - if bitlim > int32(30) || (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0]>>bitlim == uint32(0) { - return float64(float64(float64(sign)*float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0])) * float64(_p10s[rp-int32(10)])) + if bitlim > int32(30) || (**(**[128]Tuint32_t)(__ccgo_up(bp)))[0]>>bitlim == uint32(0) { + return float64(float64(float64(sign)*float64((**(**[128]Tuint32_t)(__ccgo_up(bp)))[0])) * float64(_p10s[rp-int32(10)])) } } /* Drop trailing zeros */ for { - if !!((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[z-int32(1)] != 0) { + if !!((**(**[128]Tuint32_t)(__ccgo_up(bp)))[z-int32(1)] != 0) { break } goto _18 @@ -26284,10 +26284,10 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if !(k != z) { break } - tmp = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] % Uint32FromInt32(p10) - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k]/Uint32FromInt32(p10) + carry + tmp = (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] % Uint32FromInt32(p10) + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] = (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k]/Uint32FromInt32(p10) + carry carry = Uint32FromInt32(int32(1000000000)/p10) * tmp - if k == a && !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] != 0) { + if k == a && !((**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] != 0) { a = (a + int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) rp = rp - int32(9) } @@ -26299,25 +26299,25 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if carry != 0 { v2 = z z = z + 1 - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v2] = carry + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[v2] = carry } rp = rp + (int32(9) - rpm9) } /* Upscale until desired number of bits are left of radix point */ - for rp < Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) || rp == Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) && (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[a] < _th[0] { + for rp < Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) || rp == Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) && (**(**[128]Tuint32_t)(__ccgo_up(bp)))[a] < _th[0] { carry1 = uint32(0) e2 = e2 - int32(29) k = (z - int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) for { - tmp1 = uint64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k])< uint64(1000000000) { carry1 = uint32(tmp1 / uint64(1000000000)) - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] = uint32(tmp1 % uint64(1000000000)) + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] = uint32(tmp1 % uint64(1000000000)) } else { carry1 = uint32(0) - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] = uint32(tmp1) + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] = uint32(tmp1) } - if k == (z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) && k != a && !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] != 0) { + if k == (z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) && k != a && !((**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] != 0) { z = k } if k == a { @@ -26333,9 +26333,9 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, a = (a - int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) if a == z { z = (z - int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr((z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)))*4)) |= (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[z] + **(**Tuint32_t)(__ccgo_up(bp + uintptr((z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)))*4)) |= (**(**[128]Tuint32_t)(__ccgo_up(bp)))[z] } - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[a] = carry1 + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[a] = carry1 } } /* Downscale until exactly number of bits are left of radix point */ @@ -26348,11 +26348,11 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, break } k = (a + i) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) - if k == z || (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] < _th[i] { + if k == z || (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] < _th[i] { i = int32(LD_B1B_DIG) break } - if (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))] > _th[i] { + if (**(**[128]Tuint32_t)(__ccgo_up(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))] > _th[i] { break } goto _24 @@ -26373,10 +26373,10 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if !(k != z) { break } - tmp2 = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] & Uint32FromInt32(int32(1)<>sh + carry2 + tmp2 = (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] & Uint32FromInt32(int32(1)<>sh + carry2 carry2 = Uint32FromInt32(Int32FromInt32(1000000000)>>sh) * tmp2 - if k == a && !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] != 0) { + if k == a && !((**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] != 0) { a = (a + int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) i = i - 1 rp = rp - int32(9) @@ -26388,10 +26388,10 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, } if carry2 != 0 { if (z+int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) != a { - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[z] = carry2 + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[z] = carry2 z = (z + int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) } else { - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr((z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)))*4)) |= uint32(1) + **(**Tuint32_t)(__ccgo_up(bp + uintptr((z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)))*4)) |= uint32(1) } } goto _23 @@ -26408,9 +26408,9 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if (a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1)) == z { v6 = (z + Int32FromInt32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) z = v6 - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v6-int32(1)] = uint32(0) + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[v6-int32(1)] = uint32(0) } - y = float64(Float64FromFloat64(1e+09)*y) + float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))]) + y = float64(Float64FromFloat64(1e+09)*y) + float64((**(**[128]Tuint32_t)(__ccgo_up(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))]) goto _26 _26: ; @@ -26434,7 +26434,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, } /* Process tail of decimal input so it can affect rounding */ if (a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1)) != z { - t = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))] + t = (**(**[128]Tuint32_t)(__ccgo_up(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))] if t < uint32(500000000) && (t != 0 || (a+i+int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) != z) { frac = frac + float64(float64(0.25)*float64(sign)) } else { @@ -26465,7 +26465,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, e2 = e2 + 1 } if e2+int32(LDBL_MANT_DIG) > emax || denormal != 0 && frac != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) } } return Xscalbnl(tls, y, e2) @@ -26508,7 +26508,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26526,7 +26526,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26538,7 +26538,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26557,7 +26557,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26604,7 +26604,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26658,11 +26658,11 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 return float64(float64(sign) * float64(0)) } if e2 > int64(-emin) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return float64(float64(float64(sign)*Float64FromFloat64(1.79769313486231570815e+308)) * Float64FromFloat64(1.79769313486231570815e+308)) } if e2 < int64(emin-Int32FromInt32(2)*Int32FromInt32(LDBL_MANT_DIG)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return float64(float64(float64(sign)*Float64FromFloat64(2.22507385850720138309e-308)) * Float64FromFloat64(2.22507385850720138309e-308)) } for x < uint32(0x80000000) { @@ -26691,7 +26691,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 y = bias + float64(float64(sign)*float64(x)) + float64(float64(sign)*y) y = y - bias if !(y != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) } return Xscalbnl(tls, y, int32(e2)) } @@ -26724,7 +26724,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__shgetc(tls, f) } @@ -26744,7 +26744,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -26752,7 +26752,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { } i = uint64(0) for { - if !(i < uint64(8) && c|int32(32) == int32(*(*int8)(unsafe.Pointer(__ccgo_ts + 247 + uintptr(i))))) { + if !(i < uint64(8) && c|int32(32) == int32(**(**int8)(__ccgo_up(__ccgo_ts + 247 + uintptr(i))))) { break } if i < uint64(7) { @@ -26760,7 +26760,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -26796,7 +26796,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { if !(i != 0) { i = uint64(0) for { - if !(i < uint64(3) && c|int32(32) == int32(*(*int8)(unsafe.Pointer(__ccgo_ts + 256 + uintptr(i))))) { + if !(i < uint64(3) && c|int32(32) == int32(**(**int8)(__ccgo_up(__ccgo_ts + 256 + uintptr(i))))) { break } if i < uint64(2) { @@ -26804,7 +26804,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -26821,7 +26821,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -26837,7 +26837,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -26852,7 +26852,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if !(pok != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) X__shlim(tls, f, int64(Int32FromInt32(0))) return Float64FromInt32(0) } @@ -26878,7 +26878,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) X__shlim(tls, f, int64(Int32FromInt32(0))) return Float64FromInt32(0) } @@ -26887,7 +26887,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27178,7 +27178,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint val = uintptr(unsafe.Pointer(&_table6)) + uintptr(1) neg = 0 if base > uint32(36) || base == uint32(1) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uint64(0) } for { @@ -27186,7 +27186,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__shgetc(tls, f) } @@ -27206,7 +27206,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27217,7 +27217,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27227,12 +27227,12 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } c = v1 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) >= int32(16) { + if Int32FromUint8(**(**uint8)(__ccgo_up(val + uintptr(c)))) >= int32(16) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } @@ -27255,12 +27255,12 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint if base == uint32(0) { base = uint32(10) } - if uint32(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) >= base { + if uint32(**(**uint8)(__ccgo_up(val + uintptr(c)))) >= base { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } X__shlim(tls, f, int64(Int32FromInt32(0))) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uint64(0) } } @@ -27278,7 +27278,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27297,7 +27297,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27308,13 +27308,13 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint } } else { if !(base&(base-Uint32FromInt32(1)) != 0) { - bs = int32(*(*int8)(unsafe.Pointer(__ccgo_ts + 260 + uintptr(uint32(0x17)*base>>int32(5)&uint32(7))))) + bs = int32(**(**int8)(__ccgo_up(__ccgo_ts + 260 + uintptr(uint32(0x17)*base>>int32(5)&uint32(7))))) x = uint32(0) for { - if !(uint32(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) < base && x <= Uint32FromUint32(0xffffffff)/Uint32FromInt32(32)) { + if !(uint32(**(**uint8)(__ccgo_up(val + uintptr(c)))) < base && x <= Uint32FromUint32(0xffffffff)/Uint32FromInt32(32)) { break } - x = x<>bs) { + if !(uint32(**(**uint8)(__ccgo_up(val + uintptr(c)))) < base && y <= (Uint64FromUint64(2)*Uint64FromInt64(0x7fffffffffffffff)+Uint64FromInt32(1))>>bs) { break } - y = y<= lim { if !(lim&Uint64FromInt32(1) != 0) && !(neg != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return lim - uint64(1) } else { if y > lim { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return lim } } @@ -27441,8 +27441,8 @@ func X__procfdname(tls *TLS, buf uintptr, fd uint32) { _, _, _, _ = i, j, v2, v5 i = uint32(0) for { - v2 = *(*int8)(unsafe.Pointer(__ccgo_ts + 269 + uintptr(i))) - *(*int8)(unsafe.Pointer(buf + uintptr(i))) = v2 + v2 = **(**int8)(__ccgo_up(__ccgo_ts + 269 + uintptr(i))) + **(**int8)(__ccgo_up(buf + uintptr(i))) = v2 if !(v2 != 0) { break } @@ -27452,8 +27452,8 @@ func X__procfdname(tls *TLS, buf uintptr, fd uint32) { i = i + 1 } if !(fd != 0) { - *(*int8)(unsafe.Pointer(buf + uintptr(i))) = int8('0') - *(*int8)(unsafe.Pointer(buf + uintptr(i+uint32(1)))) = 0 + **(**int8)(__ccgo_up(buf + uintptr(i))) = int8('0') + **(**int8)(__ccgo_up(buf + uintptr(i+uint32(1)))) = 0 return } j = fd @@ -27467,14 +27467,14 @@ func X__procfdname(tls *TLS, buf uintptr, fd uint32) { j = j / uint32(10) i = i + 1 } - *(*int8)(unsafe.Pointer(buf + uintptr(i))) = 0 + **(**int8)(__ccgo_up(buf + uintptr(i))) = 0 for { if !(fd != 0) { break } i = i - 1 v5 = i - *(*int8)(unsafe.Pointer(buf + uintptr(v5))) = Int8FromUint32(uint32('0') + fd%uint32(10)) + **(**int8)(__ccgo_up(buf + uintptr(v5))) = Int8FromUint32(uint32('0') + fd%uint32(10)) goto _4 _4: ; @@ -27529,7 +27529,7 @@ func X__shgetc(tls *TLS, f uintptr) (r int32) { } (*TFILE)(unsafe.Pointer(f)).Fshcnt = int64((*TFILE)(unsafe.Pointer(f)).Fbuf) - int64((*TFILE)(unsafe.Pointer(f)).Frpos) + cnt if (*TFILE)(unsafe.Pointer(f)).Frpos <= (*TFILE)(unsafe.Pointer(f)).Fbuf { - *(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos + uintptr(-Int32FromInt32(1)))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos + uintptr(-Int32FromInt32(1)))) = Uint8FromInt32(c) } return c } @@ -27540,7 +27540,7 @@ func X__syscall_ret(tls *TLS, r uint64) (r1 int64) { defer func() { trc("-> %v", r1) }() } if r > -Uint64FromUint64(4096) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = Int32FromUint64(-r) + **(**int32)(__ccgo_up(X__errno_location(tls))) = Int32FromUint64(-r) return int64(-int32(1)) } return Int64FromUint64(r) @@ -27615,7 +27615,7 @@ func Xftok(tls *TLS, path uintptr, id int32) (r Tkey_t) { if Xstat(tls, path, bp) < 0 { return -int32(1) } - return Int32FromUint64((*(*Tstat)(unsafe.Pointer(bp))).Fst_ino&Uint64FromInt32(0xffff) | (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev&Uint64FromInt32(0xff)< int64(1000) || (*Ttimeval)(unsafe.Pointer(in)).Ftv_usec > int64(1000000000) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } - (*(*Ttimex)(unsafe.Pointer(bp))).Foffset = (*Ttimeval)(unsafe.Pointer(in)).Ftv_sec*int64(1000000) + (*Ttimeval)(unsafe.Pointer(in)).Ftv_usec - (*(*Ttimex)(unsafe.Pointer(bp))).Fmodes = uint32(ADJ_OFFSET_SINGLESHOT) + (**(**Ttimex)(__ccgo_up(bp))).Foffset = (*Ttimeval)(unsafe.Pointer(in)).Ftv_sec*int64(1000000) + (*Ttimeval)(unsafe.Pointer(in)).Ftv_usec + (**(**Ttimex)(__ccgo_up(bp))).Fmodes = uint32(ADJ_OFFSET_SINGLESHOT) } if Xadjtimex(tls, bp) < 0 { return -int32(1) } if out != 0 { - (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec = (*(*Ttimex)(unsafe.Pointer(bp))).Foffset / int64(1000000) - v1 = (*(*Ttimex)(unsafe.Pointer(bp))).Foffset % Int64FromInt32(1000000) + (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec = (**(**Ttimex)(__ccgo_up(bp))).Foffset / int64(1000000) + v1 = (**(**Ttimex)(__ccgo_up(bp))).Foffset % Int64FromInt32(1000000) (*Ttimeval)(unsafe.Pointer(out)).Ftv_usec = v1 if v1 < 0 { (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec = (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec - 1 - *(*Tsuseconds_t)(unsafe.Pointer(out + 8)) += int64(1000000) + **(**Tsuseconds_t)(__ccgo_up(out + 8)) += int64(1000000) } } return 0 @@ -29058,7 +29058,7 @@ func Xclock_adjtime(tls *TLS, clock_id Tclockid_t, utx uintptr) (r1 int32) { _ = r r = -int32(ENOSYS) if uint64(8) > uint64(8) { - *(*Tktimex)(unsafe.Pointer(bp)) = Tktimex{ + **(**Tktimex)(__ccgo_up(bp)) = Tktimex{ Fmodes: (*Ttimex)(unsafe.Pointer(utx)).Fmodes, Foffset: (*Ttimex)(unsafe.Pointer(utx)).Foffset, Ffreq: (*Ttimex)(unsafe.Pointer(utx)).Ffreq, @@ -29087,27 +29087,27 @@ func Xclock_adjtime(tls *TLS, clock_id Tclockid_t, utx uintptr) (r1 int32) { r = int32(X__syscall2(tls, int64(SYS_clock_adjtime), int64(clock_id), int64(bp))) } if r >= 0 { - (*Ttimex)(unsafe.Pointer(utx)).Fmodes = (*(*Tktimex)(unsafe.Pointer(bp))).Fmodes - (*Ttimex)(unsafe.Pointer(utx)).Foffset = (*(*Tktimex)(unsafe.Pointer(bp))).Foffset - (*Ttimex)(unsafe.Pointer(utx)).Ffreq = (*(*Tktimex)(unsafe.Pointer(bp))).Ffreq - (*Ttimex)(unsafe.Pointer(utx)).Fmaxerror = (*(*Tktimex)(unsafe.Pointer(bp))).Fmaxerror - (*Ttimex)(unsafe.Pointer(utx)).Festerror = (*(*Tktimex)(unsafe.Pointer(bp))).Festerror - (*Ttimex)(unsafe.Pointer(utx)).Fstatus = (*(*Tktimex)(unsafe.Pointer(bp))).Fstatus - (*Ttimex)(unsafe.Pointer(utx)).Fconstant = (*(*Tktimex)(unsafe.Pointer(bp))).Fconstant - (*Ttimex)(unsafe.Pointer(utx)).Fprecision = (*(*Tktimex)(unsafe.Pointer(bp))).Fprecision - (*Ttimex)(unsafe.Pointer(utx)).Ftolerance = (*(*Tktimex)(unsafe.Pointer(bp))).Ftolerance - (*Ttimex)(unsafe.Pointer(utx)).Ftime.Ftv_sec = (*(*Tktimex)(unsafe.Pointer(bp))).Ftime_sec - (*Ttimex)(unsafe.Pointer(utx)).Ftime.Ftv_usec = (*(*Tktimex)(unsafe.Pointer(bp))).Ftime_usec - (*Ttimex)(unsafe.Pointer(utx)).Ftick = (*(*Tktimex)(unsafe.Pointer(bp))).Ftick - (*Ttimex)(unsafe.Pointer(utx)).Fppsfreq = (*(*Tktimex)(unsafe.Pointer(bp))).Fppsfreq - (*Ttimex)(unsafe.Pointer(utx)).Fjitter = (*(*Tktimex)(unsafe.Pointer(bp))).Fjitter - (*Ttimex)(unsafe.Pointer(utx)).Fshift = (*(*Tktimex)(unsafe.Pointer(bp))).Fshift - (*Ttimex)(unsafe.Pointer(utx)).Fstabil = (*(*Tktimex)(unsafe.Pointer(bp))).Fstabil - (*Ttimex)(unsafe.Pointer(utx)).Fjitcnt = (*(*Tktimex)(unsafe.Pointer(bp))).Fjitcnt - (*Ttimex)(unsafe.Pointer(utx)).Fcalcnt = (*(*Tktimex)(unsafe.Pointer(bp))).Fcalcnt - (*Ttimex)(unsafe.Pointer(utx)).Ferrcnt = (*(*Tktimex)(unsafe.Pointer(bp))).Ferrcnt - (*Ttimex)(unsafe.Pointer(utx)).Fstbcnt = (*(*Tktimex)(unsafe.Pointer(bp))).Fstbcnt - (*Ttimex)(unsafe.Pointer(utx)).Ftai = (*(*Tktimex)(unsafe.Pointer(bp))).Ftai + (*Ttimex)(unsafe.Pointer(utx)).Fmodes = (**(**Tktimex)(__ccgo_up(bp))).Fmodes + (*Ttimex)(unsafe.Pointer(utx)).Foffset = (**(**Tktimex)(__ccgo_up(bp))).Foffset + (*Ttimex)(unsafe.Pointer(utx)).Ffreq = (**(**Tktimex)(__ccgo_up(bp))).Ffreq + (*Ttimex)(unsafe.Pointer(utx)).Fmaxerror = (**(**Tktimex)(__ccgo_up(bp))).Fmaxerror + (*Ttimex)(unsafe.Pointer(utx)).Festerror = (**(**Tktimex)(__ccgo_up(bp))).Festerror + (*Ttimex)(unsafe.Pointer(utx)).Fstatus = (**(**Tktimex)(__ccgo_up(bp))).Fstatus + (*Ttimex)(unsafe.Pointer(utx)).Fconstant = (**(**Tktimex)(__ccgo_up(bp))).Fconstant + (*Ttimex)(unsafe.Pointer(utx)).Fprecision = (**(**Tktimex)(__ccgo_up(bp))).Fprecision + (*Ttimex)(unsafe.Pointer(utx)).Ftolerance = (**(**Tktimex)(__ccgo_up(bp))).Ftolerance + (*Ttimex)(unsafe.Pointer(utx)).Ftime.Ftv_sec = (**(**Tktimex)(__ccgo_up(bp))).Ftime_sec + (*Ttimex)(unsafe.Pointer(utx)).Ftime.Ftv_usec = (**(**Tktimex)(__ccgo_up(bp))).Ftime_usec + (*Ttimex)(unsafe.Pointer(utx)).Ftick = (**(**Tktimex)(__ccgo_up(bp))).Ftick + (*Ttimex)(unsafe.Pointer(utx)).Fppsfreq = (**(**Tktimex)(__ccgo_up(bp))).Fppsfreq + (*Ttimex)(unsafe.Pointer(utx)).Fjitter = (**(**Tktimex)(__ccgo_up(bp))).Fjitter + (*Ttimex)(unsafe.Pointer(utx)).Fshift = (**(**Tktimex)(__ccgo_up(bp))).Fshift + (*Ttimex)(unsafe.Pointer(utx)).Fstabil = (**(**Tktimex)(__ccgo_up(bp))).Fstabil + (*Ttimex)(unsafe.Pointer(utx)).Fjitcnt = (**(**Tktimex)(__ccgo_up(bp))).Fjitcnt + (*Ttimex)(unsafe.Pointer(utx)).Fcalcnt = (**(**Tktimex)(__ccgo_up(bp))).Fcalcnt + (*Ttimex)(unsafe.Pointer(utx)).Ferrcnt = (**(**Tktimex)(__ccgo_up(bp))).Ferrcnt + (*Ttimex)(unsafe.Pointer(utx)).Fstbcnt = (**(**Tktimex)(__ccgo_up(bp))).Fstbcnt + (*Ttimex)(unsafe.Pointer(utx)).Ftai = (**(**Tktimex)(__ccgo_up(bp))).Ftai } return int32(X__syscall_ret(tls, Uint64FromInt32(r))) } @@ -30149,12 +30149,12 @@ func Xprlimit(tls *TLS, pid Tpid_t, resource int32, new_limit uintptr, old_limit var _ /* tmp at bp+0 */ Trlimit _ = r if new_limit != 0 && Bool(^Uint64FromUint64(0) != ^Uint64FromUint64(0)) { - *(*Trlimit)(unsafe.Pointer(bp)) = *(*Trlimit)(unsafe.Pointer(new_limit)) - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur >= ^Uint64FromUint64(0) { - (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur = ^Uint64FromUint64(0) + **(**Trlimit)(__ccgo_up(bp)) = **(**Trlimit)(__ccgo_up(new_limit)) + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur >= ^Uint64FromUint64(0) { + (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur = ^Uint64FromUint64(0) } - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_max >= ^Uint64FromUint64(0) { - (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_max = ^Uint64FromUint64(0) + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_max >= ^Uint64FromUint64(0) { + (**(**Trlimit)(__ccgo_up(bp))).Frlim_max = ^Uint64FromUint64(0) } new_limit = bp } @@ -30339,7 +30339,7 @@ func Xptrace(tls *TLS, req int32, va uintptr) (r int64) { if ret < 0 || Uint32FromInt32(req)-uint32(1) >= uint32(3) { return ret } - return *(*int64)(unsafe.Pointer(bp)) + return **(**int64)(__ccgo_up(bp)) } func Xpwritev2(tls *TLS, fd int32, iov uintptr, count int32, ofs Toff_t, flags int32) (r Tssize_t) { @@ -30640,22 +30640,22 @@ func Xstatx(tls *TLS, dirfd int32, path uintptr, flags int32, mask uint32, stx u if ret != 0 { return ret } - (*Tstatx)(unsafe.Pointer(stx)).Fstx_dev_major = uint32((*(*Tstat)(unsafe.Pointer(bp))).Fst_dev>>Int32FromInt32(31)>>Int32FromInt32(1)&Uint64FromUint32(0xfffff000) | (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev>>Int32FromInt32(8)&Uint64FromInt32(0x00000fff)) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_dev_minor = uint32((*(*Tstat)(unsafe.Pointer(bp))).Fst_dev>>Int32FromInt32(12)&Uint64FromUint32(0xffffff00) | (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev&Uint64FromInt32(0x000000ff)) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_ino = (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino - (*Tstatx)(unsafe.Pointer(stx)).Fstx_mode = uint16((*(*Tstat)(unsafe.Pointer(bp))).Fst_mode) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_nlink = (*(*Tstat)(unsafe.Pointer(bp))).Fst_nlink - (*Tstatx)(unsafe.Pointer(stx)).Fstx_uid = (*(*Tstat)(unsafe.Pointer(bp))).Fst_uid - (*Tstatx)(unsafe.Pointer(stx)).Fstx_gid = (*(*Tstat)(unsafe.Pointer(bp))).Fst_gid - (*Tstatx)(unsafe.Pointer(stx)).Fstx_size = Uint64FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_size) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_blksize = Uint32FromInt32((*(*Tstat)(unsafe.Pointer(bp))).Fst_blksize) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_blocks = Uint64FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_blocks) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_atime.Ftv_sec = (*(*Tstat)(unsafe.Pointer(bp))).Fst_atim.Ftv_sec - (*Tstatx)(unsafe.Pointer(stx)).Fstx_atime.Ftv_nsec = Uint32FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_atim.Ftv_nsec) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_mtime.Ftv_sec = (*(*Tstat)(unsafe.Pointer(bp))).Fst_mtim.Ftv_sec - (*Tstatx)(unsafe.Pointer(stx)).Fstx_mtime.Ftv_nsec = Uint32FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_mtim.Ftv_nsec) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_ctime.Ftv_sec = (*(*Tstat)(unsafe.Pointer(bp))).Fst_ctim.Ftv_sec - (*Tstatx)(unsafe.Pointer(stx)).Fstx_ctime.Ftv_nsec = Uint32FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_ctim.Ftv_nsec) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_dev_major = uint32((**(**Tstat)(__ccgo_up(bp))).Fst_dev>>Int32FromInt32(31)>>Int32FromInt32(1)&Uint64FromUint32(0xfffff000) | (**(**Tstat)(__ccgo_up(bp))).Fst_dev>>Int32FromInt32(8)&Uint64FromInt32(0x00000fff)) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_dev_minor = uint32((**(**Tstat)(__ccgo_up(bp))).Fst_dev>>Int32FromInt32(12)&Uint64FromUint32(0xffffff00) | (**(**Tstat)(__ccgo_up(bp))).Fst_dev&Uint64FromInt32(0x000000ff)) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_ino = (**(**Tstat)(__ccgo_up(bp))).Fst_ino + (*Tstatx)(unsafe.Pointer(stx)).Fstx_mode = uint16((**(**Tstat)(__ccgo_up(bp))).Fst_mode) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_nlink = (**(**Tstat)(__ccgo_up(bp))).Fst_nlink + (*Tstatx)(unsafe.Pointer(stx)).Fstx_uid = (**(**Tstat)(__ccgo_up(bp))).Fst_uid + (*Tstatx)(unsafe.Pointer(stx)).Fstx_gid = (**(**Tstat)(__ccgo_up(bp))).Fst_gid + (*Tstatx)(unsafe.Pointer(stx)).Fstx_size = Uint64FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_size) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_blksize = Uint32FromInt32((**(**Tstat)(__ccgo_up(bp))).Fst_blksize) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_blocks = Uint64FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_blocks) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_atime.Ftv_sec = (**(**Tstat)(__ccgo_up(bp))).Fst_atim.Ftv_sec + (*Tstatx)(unsafe.Pointer(stx)).Fstx_atime.Ftv_nsec = Uint32FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_atim.Ftv_nsec) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_mtime.Ftv_sec = (**(**Tstat)(__ccgo_up(bp))).Fst_mtim.Ftv_sec + (*Tstatx)(unsafe.Pointer(stx)).Fstx_mtime.Ftv_nsec = Uint32FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_mtim.Ftv_nsec) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_ctime.Ftv_sec = (**(**Tstat)(__ccgo_up(bp))).Fst_ctim.Ftv_sec + (*Tstatx)(unsafe.Pointer(stx)).Fstx_ctime.Ftv_nsec = Uint32FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_ctim.Ftv_nsec) (*Tstatx)(unsafe.Pointer(stx)).Fstx_btime = Tstatx_timestamp{} (*Tstatx)(unsafe.Pointer(stx)).Fstx_mask = uint32(0x7ff) return 0 @@ -30669,8 +30669,8 @@ func Xstime(tls *TLS, t uintptr) (r int32) { bp := tls.Alloc(16) defer tls.Free(16) var _ /* tv at bp+0 */ Ttimeval - *(*Ttimeval)(unsafe.Pointer(bp)) = Ttimeval{ - Ftv_sec: *(*Ttime_t)(unsafe.Pointer(t)), + **(**Ttimeval)(__ccgo_up(bp)) = Ttimeval{ + Ftv_sec: **(**Ttime_t)(__ccgo_up(t)), } return Xsettimeofday(tls, bp, UintptrFromInt32(0)) } @@ -30857,12 +30857,12 @@ func Xwait4(tls *TLS, pid Tpid_t, status uintptr, options int32, ru uintptr) (r1 if r > 0 && ru != 0 && Bool(uint64(8) > uint64(8)) { Xmemcpy(tls, bp, dest, Uint64FromInt32(4)*Uint64FromInt64(8)) (*Trusage)(unsafe.Pointer(ru)).Fru_utime = Ttimeval{ - Ftv_sec: (*(*[4]int64)(unsafe.Pointer(bp)))[0], - Ftv_usec: (*(*[4]int64)(unsafe.Pointer(bp)))[int32(1)], + Ftv_sec: (**(**[4]int64)(__ccgo_up(bp)))[0], + Ftv_usec: (**(**[4]int64)(__ccgo_up(bp)))[int32(1)], } (*Trusage)(unsafe.Pointer(ru)).Fru_stime = Ttimeval{ - Ftv_sec: (*(*[4]int64)(unsafe.Pointer(bp)))[int32(2)], - Ftv_usec: (*(*[4]int64)(unsafe.Pointer(bp)))[int32(3)], + Ftv_sec: (**(**[4]int64)(__ccgo_up(bp)))[int32(2)], + Ftv_usec: (**(**[4]int64)(__ccgo_up(bp)))[int32(3)], } } return int32(X__syscall_ret(tls, Uint64FromInt32(r))) @@ -30985,7 +30985,7 @@ func X__lctrans_cur(tls *TLS, msg uintptr) (r uintptr) { trc("tls=%v msg=%v, (%v:)", tls, msg, origin(2)) defer func() { trc("-> %v", r) }() } - return X__lctrans_impl(tls, msg, *(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale + 5*8))) + return X__lctrans_impl(tls, msg, **(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale + 5*8))) } func _swapc(tls *TLS, x Tuint32_t, c int32) (r Tuint32_t) { @@ -31009,27 +31009,27 @@ func X__mo_lookup(tls *TLS, p uintptr, size Tsize_t, s uintptr) (r uintptr) { var sign, sw int32 _, _, _, _, _, _, _, _, _, _, _ = b, mo, n, o, ol, os, sign, sw, t, tl, ts mo = p - sw = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(mo)) - uint32(0x950412de)) + sw = Int32FromUint32(**(**Tuint32_t)(__ccgo_up(mo)) - uint32(0x950412de)) b = uint32(0) - n = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + 2*4)), sw) - o = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + 3*4)), sw) - t = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + 4*4)), sw) + n = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + 2*4)), sw) + o = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + 3*4)), sw) + t = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + 4*4)), sw) if uint64(n) >= size/uint64(4) || uint64(o) >= size-uint64(uint32(4)*n) || uint64(t) >= size-uint64(uint32(4)*n) || (o|t)%uint32(4) != 0 { return uintptr(0) } o = o / uint32(4) t = t / uint32(4) for { - ol = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + uintptr(o+uint32(2)*(b+n/uint32(2)))*4)), sw) - os = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + uintptr(o+uint32(2)*(b+n/uint32(2))+uint32(1))*4)), sw) - if uint64(os) >= size || uint64(ol) >= size-uint64(os) || *(*int8)(unsafe.Pointer(p + uintptr(os+ol))) != 0 { + ol = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + uintptr(o+uint32(2)*(b+n/uint32(2)))*4)), sw) + os = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + uintptr(o+uint32(2)*(b+n/uint32(2))+uint32(1))*4)), sw) + if uint64(os) >= size || uint64(ol) >= size-uint64(os) || **(**int8)(__ccgo_up(p + uintptr(os+ol))) != 0 { return uintptr(0) } sign = Xstrcmp(tls, s, p+uintptr(os)) if !(sign != 0) { - tl = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + uintptr(t+uint32(2)*(b+n/uint32(2)))*4)), sw) - ts = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + uintptr(t+uint32(2)*(b+n/uint32(2))+uint32(1))*4)), sw) - if uint64(ts) >= size || uint64(tl) >= size-uint64(ts) || *(*int8)(unsafe.Pointer(p + uintptr(ts+tl))) != 0 { + tl = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + uintptr(t+uint32(2)*(b+n/uint32(2)))*4)), sw) + ts = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + uintptr(t+uint32(2)*(b+n/uint32(2))+uint32(1))*4)), sw) + if uint64(ts) >= size || uint64(tl) >= size-uint64(ts) || **(**int8)(__ccgo_up(p + uintptr(ts+tl))) != 0 { return uintptr(0) } return p + uintptr(ts) @@ -31059,7 +31059,7 @@ func Xbind_textdomain_codeset(tls *TLS, domainname uintptr, codeset uintptr) (r defer func() { trc("-> %v", r) }() } if codeset != 0 && Xstrcasecmp(tls, codeset, __ccgo_ts+322) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) } return UintptrFromInt32(0) } @@ -31087,7 +31087,7 @@ func Xcatclose(tls *TLS, catd Tnl_catd) (r int32) { var v1, v2 Tuint32_t _, _, _ = map1, v1, v2 map1 = catd - v1 = *(*Tuint32_t)(unsafe.Pointer(map1 + UintptrFromInt32(8))) + v1 = **(**Tuint32_t)(__ccgo_up(map1 + UintptrFromInt32(8))) v2 = v1>>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v4>>int32(8)&uint32(0xff00) | v4<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v4>>int32(8)&uint32(0xff00) | v4<>int32(24) | v7>>int32(8)&uint32(0xff00) | v7<>int32(24) | v10>>int32(8)&uint32(0xff00) | v10<>int32(24) | v13>>int32(8)&uint32(0xff00) | v13<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v4>>int32(8)&uint32(0xff00) | v4<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v5>>int32(8)&uint32(0xff00) | v5< uint64(NAME_MAX) || dirlen >= uint64(PATH_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } ___lock(tls, uintptr(unsafe.Pointer(&_lock1))) @@ -31600,7 +31600,7 @@ func Xdcngettext(tls *TLS, domainname uintptr, msgid1 uintptr, msgid2 uintptr, n _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = alt_modlen, catlen, catname, csp, dirlen, dirname, domlen, l, lm, loc, loclen, locname, locp, map1, modlen, modname, name, np, old, old_cats, old_errno, p3, plural, q, r, r1, rem, rule, trans, v, v11, v12, v20, v27, v3, v5, v6, v8, v9 defer func() { Xrealloc(tls, name, 0) }() loc = (*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale - old_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + old_errno = **(**int32)(__ccgo_up(X__errno_location(tls))) /* match gnu gettext behaviour */ if !(msgid1 != 0) { goto notrans @@ -31631,14 +31631,14 @@ func Xdcngettext(tls *TLS, domainname uintptr, msgid1 uintptr, msgid2 uintptr, n if !(q != 0) { goto notrans } - lm = *(*uintptr)(unsafe.Pointer(loc + uintptr(category)*8)) + lm = **(**uintptr)(__ccgo_up(loc + uintptr(category)*8)) if !!(lm != 0) { goto _2 } goto notrans notrans: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = old_errno + **(**int32)(__ccgo_up(X__errno_location(tls))) = old_errno if n == uint64(1) { v3 = msgid1 } else { @@ -31711,21 +31711,21 @@ _2: } p3 = Xcalloc(tls, uint64(64), uint64(1)) if !(p3 != 0) { - X__munmap(tls, map1, *(*Tsize_t)(unsafe.Pointer(bp))) + X__munmap(tls, map1, **(**Tsize_t)(__ccgo_up(bp))) goto notrans } (*Tmsgcat)(unsafe.Pointer(p3)).Fcat = category (*Tmsgcat)(unsafe.Pointer(p3)).Fbinding = q (*Tmsgcat)(unsafe.Pointer(p3)).Flm = lm (*Tmsgcat)(unsafe.Pointer(p3)).Fmap1 = map1 - (*Tmsgcat)(unsafe.Pointer(p3)).Fmap_size = *(*Tsize_t)(unsafe.Pointer(bp)) + (*Tmsgcat)(unsafe.Pointer(p3)).Fmap_size = **(**Tsize_t)(__ccgo_up(bp)) rule = __ccgo_ts + 445 np = uint64(2) r1 = X__mo_lookup(tls, (*Tmsgcat)(unsafe.Pointer(p3)).Fmap1, (*Tmsgcat)(unsafe.Pointer(p3)).Fmap_size, __ccgo_ts) for r1 != 0 && Xstrncmp(tls, r1, __ccgo_ts+451, uint64(13)) != 0 { - *(*uintptr)(unsafe.Pointer(bp + 8)) = Xstrchr(tls, r1, int32('\n')) - if *(*uintptr)(unsafe.Pointer(bp + 8)) != 0 { - v3 = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(1) + **(**uintptr)(__ccgo_up(bp + 8)) = Xstrchr(tls, r1, int32('\n')) + if **(**uintptr)(__ccgo_up(bp + 8)) != 0 { + v3 = **(**uintptr)(__ccgo_up(bp + 8)) + uintptr(1) } else { v3 = uintptr(0) } @@ -31734,7 +31734,7 @@ _2: if r1 != 0 { r1 = r1 + uintptr(13) for { - v11 = int32(*(*int8)(unsafe.Pointer(r1))) + v11 = int32(**(**int8)(__ccgo_up(r1))) v12 = BoolInt32(v11 == int32(' ') || Uint32FromInt32(v11)-uint32('\t') < uint32(5)) goto _13 _13: @@ -31745,15 +31745,15 @@ _2: } if !(Xstrncmp(tls, r1, __ccgo_ts+465, uint64(9)) != 0) { np = Xstrtoul(tls, r1+uintptr(9), bp+8, int32(10)) - r1 = *(*uintptr)(unsafe.Pointer(bp + 8)) + r1 = **(**uintptr)(__ccgo_up(bp + 8)) } - for *(*int8)(unsafe.Pointer(r1)) != 0 && int32(*(*int8)(unsafe.Pointer(r1))) != int32(';') { + for **(**int8)(__ccgo_up(r1)) != 0 && int32(**(**int8)(__ccgo_up(r1))) != int32(';') { r1 = r1 + 1 } - if *(*int8)(unsafe.Pointer(r1)) != 0 { + if **(**int8)(__ccgo_up(r1)) != 0 { r1 = r1 + 1 for { - v11 = int32(*(*int8)(unsafe.Pointer(r1))) + v11 = int32(**(**int8)(__ccgo_up(r1))) v12 = BoolInt32(v11 == int32(' ') || Uint32FromInt32(v11)-uint32('\t') < uint32(5)) goto _16 _16: @@ -31844,7 +31844,7 @@ _2: trans = trans + uintptr(l+uint64(1)) } } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = old_errno + **(**int32)(__ccgo_up(X__errno_location(tls))) = old_errno return trans } @@ -31888,7 +31888,7 @@ func X__duplocale(tls *TLS, old Tlocale_t) (r Tlocale_t) { if old == uintptr(-Int32FromInt32(1)) { old = uintptr(unsafe.Pointer(&X__libc)) + 56 } - *(*t__locale_struct)(unsafe.Pointer(new1)) = *(*t__locale_struct)(unsafe.Pointer(old)) + **(**t__locale_struct)(__ccgo_up(new1)) = **(**t__locale_struct)(__ccgo_up(old)) return new1 } @@ -98062,13 +98062,13 @@ var _rev_jis = [6879]uint16{ func _fuzzycmp(tls *TLS, a uintptr, b uintptr) (r int32) { for { - if !(*(*uint8)(unsafe.Pointer(a)) != 0 && *(*uint8)(unsafe.Pointer(b)) != 0) { + if !(**(**uint8)(__ccgo_up(a)) != 0 && **(**uint8)(__ccgo_up(b)) != 0) { break } - for *(*uint8)(unsafe.Pointer(a)) != 0 && uint32(*(*uint8)(unsafe.Pointer(a)))|uint32(32)-uint32('a') > uint32(26) && Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(a)))-int32('0')) > uint32(10) { + for **(**uint8)(__ccgo_up(a)) != 0 && uint32(**(**uint8)(__ccgo_up(a)))|uint32(32)-uint32('a') > uint32(26) && Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(a)))-int32('0')) > uint32(10) { a = a + 1 } - if uint32(*(*uint8)(unsafe.Pointer(a)))|uint32(32) != uint32(*(*uint8)(unsafe.Pointer(b))) { + if uint32(**(**uint8)(__ccgo_up(a)))|uint32(32) != uint32(**(**uint8)(__ccgo_up(b))) { return int32(1) } goto _1 @@ -98077,23 +98077,23 @@ func _fuzzycmp(tls *TLS, a uintptr, b uintptr) (r int32) { a = a + 1 b = b + 1 } - return BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(a))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(b)))) + return BoolInt32(Int32FromUint8(**(**uint8)(__ccgo_up(a))) != Int32FromUint8(**(**uint8)(__ccgo_up(b)))) } func _find_charmap(tls *TLS, name uintptr) (r Tsize_t) { var s uintptr _ = s - if !(*(*int8)(unsafe.Pointer(name)) != 0) { + if !(**(**int8)(__ccgo_up(name)) != 0) { name = uintptr(unsafe.Pointer(&_charmaps)) } /* "utf8" */ s = uintptr(unsafe.Pointer(&_charmaps)) for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { break } if !(_fuzzycmp(tls, name, s) != 0) { for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { break } goto _2 @@ -98104,11 +98104,11 @@ func _find_charmap(tls *TLS, name uintptr) (r Tsize_t) { return Uint64FromInt64(int64(s+uintptr(1)) - t__predefined_ptrdiff_t(uintptr(unsafe.Pointer(&_charmaps)))) } s = s + uintptr(_strlen(tls, s)+uint64(1)) - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) > int32(0200) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { + if Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) > int32(0200) { s = s + uintptr(2) } else { - s = s + uintptr(uint32(2)+(uint32(64)-uint32(*(*uint8)(unsafe.Pointer(s + 1))))*uint32(5)) + s = s + uintptr(uint32(2)+(uint32(64)-uint32(**(**uint8)(__ccgo_up(s + 1))))*uint32(5)) } } goto _1 @@ -98151,7 +98151,7 @@ func Xiconv_open(tls *TLS, to uintptr, from uintptr) (r Ticonv_t) { f = v2 } if v3 || v2 == Uint64FromInt32(-Int32FromInt32(1)) || Int32FromUint8(_charmaps[t]) >= int32(0330) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(-Int32FromInt32(1)) } cd = _combine_to_from(tls, t, f) @@ -98176,26 +98176,26 @@ func Xiconv_open(tls *TLS, to uintptr, from uintptr) (r Ticonv_t) { func _get_16(tls *TLS, s uintptr, e int32) (r uint32) { e = e & int32(1) - return Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(e))))<> int32(8)) - *(*uint8)(unsafe.Pointer(s + uintptr(int32(1)-e))) = uint8(c) + **(**uint8)(__ccgo_up(s + uintptr(e))) = uint8(c >> int32(8)) + **(**uint8)(__ccgo_up(s + uintptr(int32(1)-e))) = uint8(c) } func _get_32(tls *TLS, s uintptr, e int32) (r uint32) { e = e & int32(3) - return (uint32(*(*uint8)(unsafe.Pointer(s + uintptr(e))))+0)<> int32(24)) - *(*uint8)(unsafe.Pointer(s + uintptr(e^int32(1)))) = uint8(c >> int32(16)) - *(*uint8)(unsafe.Pointer(s + uintptr(e^int32(2)))) = uint8(c >> int32(8)) - *(*uint8)(unsafe.Pointer(s + uintptr(e^int32(3)))) = uint8(c) + **(**uint8)(__ccgo_up(s + uintptr(e^0))) = uint8(c >> int32(24)) + **(**uint8)(__ccgo_up(s + uintptr(e^int32(1)))) = uint8(c >> int32(16)) + **(**uint8)(__ccgo_up(s + uintptr(e^int32(2)))) = uint8(c >> int32(8)) + **(**uint8)(__ccgo_up(s + uintptr(e^int32(3)))) = uint8(c) } /* Adapt as needed */ @@ -98203,11 +98203,11 @@ func _put_32(tls *TLS, s uintptr, c uint32, e int32) { func _legacy_map(tls *TLS, map1 uintptr, c uint32) (r uint32) { var x, v1 uint32 _, _ = x, v1 - if c < Uint32FromInt32(int32(4)*Int32FromUint8(*(*uint8)(unsafe.Pointer(map1 + uintptr(-Int32FromInt32(1)))))) { + if c < Uint32FromInt32(int32(4)*Int32FromUint8(**(**uint8)(__ccgo_up(map1 + uintptr(-Int32FromInt32(1)))))) { return c } - x = c - Uint32FromInt32(int32(4)*Int32FromUint8(*(*uint8)(unsafe.Pointer(map1 + uintptr(-Int32FromInt32(1)))))) - x = Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(map1 + uintptr(x*uint32(5)/uint32(4)))))>>(uint32(2)*x%uint32(8)) | Int32FromUint8(*(*uint8)(unsafe.Pointer(map1 + uintptr(x*uint32(5)/uint32(4)+uint32(1)))))<<(uint32(8)-uint32(2)*x%uint32(8))&int32(1023)) + x = c - Uint32FromInt32(int32(4)*Int32FromUint8(**(**uint8)(__ccgo_up(map1 + uintptr(-Int32FromInt32(1)))))) + x = Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(map1 + uintptr(x*uint32(5)/uint32(4)))))>>(uint32(2)*x%uint32(8)) | Int32FromUint8(**(**uint8)(__ccgo_up(map1 + uintptr(x*uint32(5)/uint32(4)+uint32(1)))))<<(uint32(8)-uint32(2)*x%uint32(8))&int32(1023)) if x < uint32(256) { v1 = x } else { @@ -98224,7 +98224,7 @@ func _uni_to_jis(tls *TLS, c uint32) (r uint32) { for { i = nel / uint32(2) j = uint32(_rev_jis[b+i]) - d = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(j/uint32(256))*188 + uintptr(j%uint32(256))*2))) + d = uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(j/uint32(256))*188 + uintptr(j%uint32(256))*2))) if d == c { return j + uint32(0x2121) } else { @@ -98277,20 +98277,20 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui from = uint32(_extract_from(tls, cd)) map1 = uintptr(unsafe.Pointer(&_charmaps)) + uintptr(from) + uintptr(1) tomap = uintptr(unsafe.Pointer(&_charmaps)) + uintptr(to) + uintptr(1) - *(*Tmbstate_t)(unsafe.Pointer(bp + 24)) = Tmbstate_t{} - type1 = *(*uint8)(unsafe.Pointer(map1 + uintptr(-Int32FromInt32(1)))) - totype = *(*uint8)(unsafe.Pointer(tomap + uintptr(-Int32FromInt32(1)))) + **(**Tmbstate_t)(__ccgo_up(bp + 24)) = Tmbstate_t{} + type1 = **(**uint8)(__ccgo_up(map1 + uintptr(-Int32FromInt32(1)))) + totype = **(**uint8)(__ccgo_up(tomap + uintptr(-Int32FromInt32(1)))) ploc = uintptr(___get_tp(tls)) + 152 - loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) - if !(in != 0) || !(*(*uintptr)(unsafe.Pointer(in)) != 0) || !(*(*Tsize_t)(unsafe.Pointer(inb)) != 0) { + loc = **(**Tlocale_t)(__ccgo_up(ploc)) + if !(in != 0) || !(**(**uintptr)(__ccgo_up(in)) != 0) || !(**(**Tsize_t)(__ccgo_up(inb)) != 0) { return uint64(0) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = uintptr(unsafe.Pointer(&X__c_dot_utf8_locale)) + **(**Tlocale_t)(__ccgo_up(ploc)) = uintptr(unsafe.Pointer(&X__c_dot_utf8_locale)) for { - if !(*(*Tsize_t)(unsafe.Pointer(inb)) != 0) { + if !(**(**Tsize_t)(__ccgo_up(inb)) != 0) { break } - c = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in))))) + c = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in))))) l = uint64(1) switch Int32FromUint8(type1) { case int32(UTF_8): @@ -98342,14 +98342,14 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if c < uint32(128) { goto _23 } - l = Xmbrtowc(tls, bp+32, *(*uintptr)(unsafe.Pointer(in)), *(*Tsize_t)(unsafe.Pointer(inb)), bp+24) + l = Xmbrtowc(tls, bp+32, **(**uintptr)(__ccgo_up(in)), **(**Tsize_t)(__ccgo_up(inb)), bp+24) if l == Uint64FromInt32(-Int32FromInt32(1)) { goto ilseq } if l == Uint64FromInt32(-Int32FromInt32(2)) { goto starved } - c = Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp + 32))) + c = Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp + 32))) goto _23 _3: ; @@ -98360,10 +98360,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui _4: ; l = uint64(4) - if *(*Tsize_t)(unsafe.Pointer(inb)) < l { + if **(**Tsize_t)(__ccgo_up(inb)) < l { goto starved } - c = Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in))))) + c = Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(in))))) if !(0 != 0) { goto _24 } @@ -98372,10 +98372,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui _5: ; l = uint64(4) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(4) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(4) { goto starved } - c = _get_32(tls, *(*uintptr)(unsafe.Pointer(in)), Int32FromUint8(type1)) + c = _get_32(tls, **(**uintptr)(__ccgo_up(in)), Int32FromUint8(type1)) _24: ; if c-uint32(0xd800) < uint32(0x800) || c >= uint32(0x110000) { @@ -98391,10 +98391,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui _7: ; l = uint64(2) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(2) { goto starved } - c = _get_16(tls, *(*uintptr)(unsafe.Pointer(in)), Int32FromUint8(type1)) + c = _get_16(tls, **(**uintptr)(__ccgo_up(in)), Int32FromUint8(type1)) if c-Uint32FromInt32(0xdc00) < uint32(0x400) { goto ilseq } @@ -98403,10 +98403,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto ilseq } l = uint64(4) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(4) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(4) { goto starved } - d = _get_16(tls, *(*uintptr)(unsafe.Pointer(in))+UintptrFromInt32(2), Int32FromUint8(type1)) + d = _get_16(tls, **(**uintptr)(__ccgo_up(in))+UintptrFromInt32(2), Int32FromUint8(type1)) if d-Uint32FromInt32(0xdc00) >= uint32(0x400) { goto ilseq } @@ -98419,10 +98419,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui ; l = uint64(0) if !((*Tstateful_cd)(unsafe.Pointer(scd)).Fstate != 0) { - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(2) { goto starved } - c = _get_16(tls, *(*uintptr)(unsafe.Pointer(in)), 0) + c = _get_16(tls, **(**uintptr)(__ccgo_up(in)), 0) if Int32FromUint8(type1) == int32(UCS2) { if c == uint32(0xfffe) { v26 = int32(UCS2LE) @@ -98449,10 +98449,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui ; l = uint64(0) if !((*Tstateful_cd)(unsafe.Pointer(scd)).Fstate != 0) { - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(4) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(4) { goto starved } - c = _get_32(tls, *(*uintptr)(unsafe.Pointer(in)), 0) + c = _get_32(tls, **(**uintptr)(__ccgo_up(in)), 0) if c == uint32(0xfffe0000) { v25 = int32(UTF_32LE) } else { @@ -98475,10 +98475,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _23 } l = uint64(2) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(2) { goto starved } - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(1)))) if c-uint32(129) <= Uint32FromInt32(Int32FromInt32(159)-Int32FromInt32(129)) { c = c - uint32(129) } else { @@ -98506,7 +98506,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if c >= uint32(84) { goto ilseq } - c = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(c)*188 + uintptr(d)*2))) + c = uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(c)*188 + uintptr(d)*2))) if !(c != 0) { goto ilseq } @@ -98517,10 +98517,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _23 } l = uint64(2) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(2) { goto starved } - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(1)))) if c == uint32(0x8e) { c = d if c-uint32(0xa1) > Uint32FromInt32(Int32FromInt32(0xdf)-Int32FromInt32(0xa1)) { @@ -98534,7 +98534,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if c >= uint32(84) || d >= uint32(94) { goto ilseq } - c = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(c)*188 + uintptr(d)*2))) + c = uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(c)*188 + uintptr(d)*2))) if !(c != 0) { goto ilseq } @@ -98546,11 +98546,11 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } if c == uint32('\033') { l = uint64(3) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(3) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(3) { goto starved } - c = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(2)))) + c = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(1)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(2)))) if c != uint32('(') && c != uint32('$') { goto ilseq } @@ -98585,16 +98585,16 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui fallthrough case uint32(3): l = uint64(2) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(2) { goto starved } - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(1)))) c = c - uint32(0x21) d = d - uint32(0x21) if c >= uint32(84) || d >= uint32(94) { goto ilseq } - c = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(c)*188 + uintptr(d)*2))) + c = uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(c)*188 + uintptr(d)*2))) if !(c != 0) { goto ilseq } @@ -98632,10 +98632,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto ilseq } l = uint64(2) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(2) { goto starved } - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(1)))) if d < uint32(0xa1) && Int32FromUint8(type1) == int32(GB2312) { goto ilseq } @@ -98644,16 +98644,16 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto ilseq } l = uint64(4) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(4) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(4) { goto starved } c = (uint32(10)*c + d - uint32('0')) * uint32(1260) - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(2)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(2)))) if d-uint32(0x81) > uint32(126) { goto ilseq } c = c + uint32(10)*(d-uint32(0x81)) - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(3)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(3)))) if d-uint32('0') > uint32(9) { goto ilseq } @@ -98675,7 +98675,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if !(j < int32(190)) { break } - if uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_gb18030)) + uintptr(i)*380 + uintptr(j)*2)))-d <= c-d { + if uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_gb18030)) + uintptr(i)*380 + uintptr(j)*2)))-d <= c-d { k = k + 1 } goto _31 @@ -98699,7 +98699,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if d > uint32(63) { d = d - 1 } - c = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_gb18030)) + uintptr(c)*380 + uintptr(d)*2))) + c = uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_gb18030)) + uintptr(c)*380 + uintptr(d)*2))) goto _23 _20: ; @@ -98707,10 +98707,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _23 } l = uint64(2) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(2) { goto starved } - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(1)))) if d-uint32(0x40) >= Uint32FromInt32(Int32FromInt32(0xff)-Int32FromInt32(0x40)) || d-uint32(0x7f) < Uint32FromInt32(Int32FromInt32(0xa1)-Int32FromInt32(0x7f)) { goto ilseq } @@ -98733,21 +98733,21 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui * range in the hkscs table then hard-coded * here. Ugly, yes. */ if c/uint32(256) == uint32(0xdc) { - *(*uintptr)(unsafe.Pointer(bp + 48)) = bp + 40 + **(**uintptr)(__ccgo_up(bp + 48)) = bp + 40 *(*uintptr)(unsafe.Pointer(bp)) = __ccgo_ts + 494 + uintptr(c%uint32(256)) *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint64(4) *(*Tsize_t)(unsafe.Pointer(bp + 16)) = uint64(8) tmpx = Xiconv(tls, _combine_to_from(tls, uint64(to), _find_charmap(tls, __ccgo_ts+511)), bp, bp+8, bp+48, bp+16) - tmplen = Uint64FromInt64(int64(*(*uintptr)(unsafe.Pointer(bp + 48))) - t__predefined_ptrdiff_t(bp+40)) - if tmplen > *(*Tsize_t)(unsafe.Pointer(outb)) { + tmplen = Uint64FromInt64(int64(**(**uintptr)(__ccgo_up(bp + 48))) - t__predefined_ptrdiff_t(bp+40)) + if tmplen > **(**Tsize_t)(__ccgo_up(outb)) { goto toobig } if tmpx != 0 { x = x + 1 } - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(out)), bp+40, tmplen) - *(*uintptr)(unsafe.Pointer(out)) += uintptr(tmplen) - *(*Tsize_t)(unsafe.Pointer(outb)) -= tmplen + Xmemcpy(tls, **(**uintptr)(__ccgo_up(out)), bp+40, tmplen) + **(**uintptr)(__ccgo_up(out)) += uintptr(tmplen) + **(**Tsize_t)(__ccgo_up(outb)) -= tmplen goto _1 } if !(c != 0) { @@ -98756,7 +98756,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _23 } c = c - uint32(0xa1) - c = Uint32FromInt32(Int32FromUint16(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_big5)) + uintptr(c)*314 + uintptr(d)*2))) | BoolInt32(c == uint32(0x27) && (d == uint32(0x3a) || d == uint32(0x3c) || d == uint32(0x42)))<= uint32(93) || d >= uint32(94) { @@ -98814,7 +98814,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if !(j1 < int32(94)) { break } - if uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ksc)) + uintptr(i1)*188 + uintptr(j1)*2)))-d <= c-d { + if uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_ksc)) + uintptr(i1)*188 + uintptr(j1)*2)))-d <= c-d { k = k + 1 } goto _34 @@ -98834,7 +98834,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } goto _23 } - c = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ksc)) + uintptr(c)*188 + uintptr(d)*2))) + c = uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_ksc)) + uintptr(c)*188 + uintptr(d)*2))) if !(c != 0) { goto ilseq } @@ -98887,26 +98887,26 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _51 _35: ; - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(4) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(4) { goto toobig } - *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(out)))) = Int32FromUint32(c) - *(*uintptr)(unsafe.Pointer(out)) += uintptr(4) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(4) + **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(out)))) = Int32FromUint32(c) + **(**uintptr)(__ccgo_up(out)) += uintptr(4) + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(4) goto _51 _36: ; - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(4) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(4) { k = Uint64FromInt32(Xwctomb(tls, bp+56, Int32FromUint32(c))) - if *(*Tsize_t)(unsafe.Pointer(outb)) < k { + if **(**Tsize_t)(__ccgo_up(outb)) < k { goto toobig } - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(out)), bp+56, k) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(out)), bp+56, k) } else { - k = Uint64FromInt32(Xwctomb(tls, *(*uintptr)(unsafe.Pointer(out)), Int32FromUint32(c))) + k = Uint64FromInt32(Xwctomb(tls, **(**uintptr)(__ccgo_up(out)), Int32FromUint32(c))) } - *(*uintptr)(unsafe.Pointer(out)) += uintptr(k) - *(*Tsize_t)(unsafe.Pointer(outb)) -= k + **(**uintptr)(__ccgo_up(out)) += uintptr(k) + **(**Tsize_t)(__ccgo_up(outb)) -= k goto _51 _37: ; @@ -98922,7 +98922,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui ; _38: ; - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(1) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(1) { goto toobig } if !(c < uint32(256) && c == _legacy_map(tls, tomap, c)) { @@ -98931,14 +98931,14 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto revout revout: ; - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(1) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(1) { goto toobig } v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = Int8FromUint32(c) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(1) + **(**int8)(__ccgo_up(v54)) = Int8FromUint32(c) + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(1) goto _51 _53: ; @@ -98980,7 +98980,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if !(c != 0) { goto subst } - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(2) { goto toobig } d = c % uint32(256) @@ -98993,7 +98993,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } else { v25 = int32(176) } - *(*int8)(unsafe.Pointer(v54)) = Int8FromUint32((c+uint32(1))/uint32(2) + Uint32FromInt32(v25)) + **(**int8)(__ccgo_up(v54)) = Int8FromUint32((c+uint32(1))/uint32(2) + Uint32FromInt32(v25)) v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 @@ -99002,8 +99002,8 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } else { v62 = d + uint32(126) } - *(*int8)(unsafe.Pointer(v54)) = Int8FromUint32(v62) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(2) + **(**int8)(__ccgo_up(v54)) = Int8FromUint32(v62) + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(2) goto _51 _40: ; @@ -99018,18 +99018,18 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if !(c != 0) { goto subst } - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(2) { goto toobig } v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = Int8FromUint32(c/uint32(256) + uint32(0x80)) + **(**int8)(__ccgo_up(v54)) = Int8FromUint32(c/uint32(256) + uint32(0x80)) v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = Int8FromUint32(c%uint32(256) + uint32(0x80)) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(2) + **(**int8)(__ccgo_up(v54)) = Int8FromUint32(c%uint32(256) + uint32(0x80)) + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(2) goto _51 _41: ; @@ -99037,102 +99037,102 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto revout } if c-uint32(0xff61) <= Uint32FromInt32(Int32FromInt32(0xdf)-Int32FromInt32(0xa1)) || c == uint32(0xa5) || c == uint32(0x203e) { - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(7) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(7) { goto toobig } v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = int8('\033') + **(**int8)(__ccgo_up(v54)) = int8('\033') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = int8('(') + **(**int8)(__ccgo_up(v54)) = int8('(') if c == uint32(0xa5) { v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = int8('J') + **(**int8)(__ccgo_up(v54)) = int8('J') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = int8('\\') + **(**int8)(__ccgo_up(v54)) = int8('\\') } else { if c == uint32(0x203e) { v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = int8('J') + **(**int8)(__ccgo_up(v54)) = int8('J') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = int8('~') + **(**int8)(__ccgo_up(v54)) = int8('~') } else { v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = int8('I') + **(**int8)(__ccgo_up(v54)) = int8('I') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = Int8FromUint32(c - uint32(0xff61) + uint32(0x21)) + **(**int8)(__ccgo_up(v54)) = Int8FromUint32(c - uint32(0xff61) + uint32(0x21)) } } v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = int8('\033') + **(**int8)(__ccgo_up(v54)) = int8('\033') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = int8('(') + **(**int8)(__ccgo_up(v54)) = int8('(') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = int8('B') - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(7) + **(**int8)(__ccgo_up(v54)) = int8('B') + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(7) goto _51 } c = _uni_to_jis(tls, c) if !(c != 0) { goto subst } - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(8) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(8) { goto toobig } v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = int8('\033') + **(**int8)(__ccgo_up(v54)) = int8('\033') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = int8('$') + **(**int8)(__ccgo_up(v54)) = int8('$') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = int8('B') + **(**int8)(__ccgo_up(v54)) = int8('B') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = Int8FromUint32(c / uint32(256)) + **(**int8)(__ccgo_up(v54)) = Int8FromUint32(c / uint32(256)) v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = Int8FromUint32(c % uint32(256)) + **(**int8)(__ccgo_up(v54)) = Int8FromUint32(c % uint32(256)) v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = int8('\033') + **(**int8)(__ccgo_up(v54)) = int8('\033') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = int8('(') + **(**int8)(__ccgo_up(v54)) = int8('(') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*int8)(unsafe.Pointer(v54)) = int8('B') - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(8) + **(**int8)(__ccgo_up(v54)) = int8('B') + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(8) goto _51 _42: ; @@ -99151,22 +99151,22 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if c >= uint32(0x10000) { c = uint32(0xFFFD) } - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(2) { goto toobig } - _put_16(tls, *(*uintptr)(unsafe.Pointer(out)), c, Int32FromUint8(totype)) - *(*uintptr)(unsafe.Pointer(out)) += uintptr(2) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(2) + _put_16(tls, **(**uintptr)(__ccgo_up(out)), c, Int32FromUint8(totype)) + **(**uintptr)(__ccgo_up(out)) += uintptr(2) + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(2) goto _51 } - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(4) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(4) { goto toobig } c = c - uint32(0x10000) - _put_16(tls, *(*uintptr)(unsafe.Pointer(out)), c>>int32(10)|uint32(0xd800), Int32FromUint8(totype)) - _put_16(tls, *(*uintptr)(unsafe.Pointer(out))+UintptrFromInt32(2), c&uint32(0x3ff)|uint32(0xdc00), Int32FromUint8(totype)) - *(*uintptr)(unsafe.Pointer(out)) += uintptr(4) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(4) + _put_16(tls, **(**uintptr)(__ccgo_up(out)), c>>int32(10)|uint32(0xd800), Int32FromUint8(totype)) + _put_16(tls, **(**uintptr)(__ccgo_up(out))+UintptrFromInt32(2), c&uint32(0x3ff)|uint32(0xdc00), Int32FromUint8(totype)) + **(**uintptr)(__ccgo_up(out)) += uintptr(4) + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(4) goto _51 _48: ; @@ -99175,22 +99175,22 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui ; _49: ; - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(4) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(4) { goto toobig } - _put_32(tls, *(*uintptr)(unsafe.Pointer(out)), c, Int32FromUint8(totype)) - *(*uintptr)(unsafe.Pointer(out)) += uintptr(4) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(4) + _put_32(tls, **(**uintptr)(__ccgo_up(out)), c, Int32FromUint8(totype)) + **(**uintptr)(__ccgo_up(out)) += uintptr(4) + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(4) goto _51 _51: ; goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(in)) += uintptr(l) - *(*Tsize_t)(unsafe.Pointer(inb)) -= l + **(**uintptr)(__ccgo_up(in)) += uintptr(l) + **(**Tsize_t)(__ccgo_up(inb)) -= l } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return x goto ilseq ilseq: @@ -99212,8 +99212,8 @@ starved: goto end end: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = err - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**int32)(__ccgo_up(X__errno_location(tls))) = err + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return x } @@ -99244,7 +99244,7 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { cat = item >> int32(16) idx = item & int32(65535) if item == int32(CODESET) { - if *(*uintptr)(unsafe.Pointer(loc)) != 0 { + if **(**uintptr)(__ccgo_up(loc)) != 0 { v1 = __ccgo_ts + 322 } else { v1 = __ccgo_ts + 516 @@ -99253,8 +99253,8 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { } /* _NL_LOCALE_NAME extension */ if idx == int32(65535) && cat < int32(LC_ALL) { - if *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*8)) != 0 { - v1 = *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*8)) + 16 + if **(**uintptr)(__ccgo_up(loc + uintptr(cat)*8)) != 0 { + v1 = **(**uintptr)(__ccgo_up(loc + uintptr(cat)*8)) + 16 } else { v1 = __ccgo_ts + 522 } @@ -99289,7 +99289,7 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { break } for { - if !(*(*int8)(unsafe.Pointer(str)) != 0) { + if !(**(**int8)(__ccgo_up(str)) != 0) { break } goto _4 @@ -99303,8 +99303,8 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { idx = idx - 1 str = str + 1 } - if cat != int32(LC_NUMERIC) && *(*int8)(unsafe.Pointer(str)) != 0 { - str = X__lctrans(tls, str, *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*8))) + if cat != int32(LC_NUMERIC) && **(**int8)(__ccgo_up(str)) != 0 { + str = X__lctrans(tls, str, **(**uintptr)(__ccgo_up(loc + uintptr(cat)*8))) } return str } @@ -99377,18 +99377,18 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = builtin, l, map1, n, new1, p, path, z, v1, v2, v3, v4, v5, v6, v7 new1 = uintptr(0) path = uintptr(0) - if !(*(*int8)(unsafe.Pointer(val)) != 0) { + if !(**(**int8)(__ccgo_up(val)) != 0) { v1 = Xgetenv(tls, __ccgo_ts+524) val = v1 - if v3 = v1 != 0 && *(*int8)(unsafe.Pointer(val)) != 0; !v3 { + if v3 = v1 != 0 && **(**int8)(__ccgo_up(val)) != 0; !v3 { v2 = Xgetenv(tls, uintptr(unsafe.Pointer(&_envvars))+uintptr(cat)*12) val = v2 } - if v5 = v3 || v2 != 0 && *(*int8)(unsafe.Pointer(val)) != 0; !v5 { + if v5 = v3 || v2 != 0 && **(**int8)(__ccgo_up(val)) != 0; !v5 { v4 = Xgetenv(tls, __ccgo_ts+336) val = v4 } - if v7 = v5 || v4 != 0 && *(*int8)(unsafe.Pointer(val)) != 0; !v7 { + if v7 = v5 || v4 != 0 && **(**int8)(__ccgo_up(val)) != 0; !v7 { v6 = __ccgo_ts + 531 val = v6 } @@ -99397,7 +99397,7 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { /* Limit name length and forbid leading dot or any slashes. */ n = uint64(0) for { - if !(n < uint64(LOCALE_NAME_MAX) && *(*int8)(unsafe.Pointer(val + uintptr(n))) != 0 && int32(*(*int8)(unsafe.Pointer(val + uintptr(n)))) != int32('/')) { + if !(n < uint64(LOCALE_NAME_MAX) && **(**int8)(__ccgo_up(val + uintptr(n))) != 0 && int32(**(**int8)(__ccgo_up(val + uintptr(n)))) != int32('/')) { break } goto _8 @@ -99405,12 +99405,12 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { ; n = n + 1 } - if int32(*(*int8)(unsafe.Pointer(val))) == int32('.') || *(*int8)(unsafe.Pointer(val + uintptr(n))) != 0 { + if int32(**(**int8)(__ccgo_up(val))) == int32('.') || **(**int8)(__ccgo_up(val + uintptr(n))) != 0 { val = __ccgo_ts + 531 } - builtin = BoolInt32(int32(*(*int8)(unsafe.Pointer(val))) == int32('C') && !(*(*int8)(unsafe.Pointer(val + 1)) != 0) || !(Xstrcmp(tls, val, __ccgo_ts+531) != 0) || !(Xstrcmp(tls, val, __ccgo_ts+539) != 0)) + builtin = BoolInt32(int32(**(**int8)(__ccgo_up(val))) == int32('C') && !(**(**int8)(__ccgo_up(val + 1)) != 0) || !(Xstrcmp(tls, val, __ccgo_ts+531) != 0) || !(Xstrcmp(tls, val, __ccgo_ts+539) != 0)) if builtin != 0 { - if cat == LC_CTYPE && int32(*(*int8)(unsafe.Pointer(val + 1))) == int32('.') { + if cat == LC_CTYPE && int32(**(**int8)(__ccgo_up(val + 1))) == int32('.') { return uintptr(unsafe.Pointer(&X__c_dot_utf8)) } return uintptr(0) @@ -99434,7 +99434,7 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { /* FIXME: add a default path? */ if path != 0 { for { - if !(*(*int8)(unsafe.Pointer(path)) != 0) { + if !(**(**int8)(__ccgo_up(path)) != 0) { break } z = X__strchrnul(tls, path, int32(':')) @@ -99443,20 +99443,20 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { goto _10 } Xmemcpy(tls, bp, path, l) - (*(*[256]int8)(unsafe.Pointer(bp)))[l] = int8('/') + (**(**[256]int8)(__ccgo_up(bp)))[l] = int8('/') Xmemcpy(tls, bp+uintptr(l)+uintptr(1), val, n) - (*(*[256]int8)(unsafe.Pointer(bp)))[l+uint64(1)+n] = 0 + (**(**[256]int8)(__ccgo_up(bp)))[l+uint64(1)+n] = 0 map1 = X__map_file(tls, bp, bp+256) if map1 != 0 { new1 = Xmalloc(tls, uint64(48)) if !(new1 != 0) { - X__munmap(tls, map1, *(*Tsize_t)(unsafe.Pointer(bp + 256))) + X__munmap(tls, map1, **(**Tsize_t)(__ccgo_up(bp + 256))) break } (*t__locale_map)(unsafe.Pointer(new1)).Fmap1 = map1 - (*t__locale_map)(unsafe.Pointer(new1)).Fmap_size = *(*Tsize_t)(unsafe.Pointer(bp + 256)) + (*t__locale_map)(unsafe.Pointer(new1)).Fmap_size = **(**Tsize_t)(__ccgo_up(bp + 256)) Xmemcpy(tls, new1+16, val, n) - *(*int8)(unsafe.Pointer(new1 + 16 + uintptr(n))) = 0 + **(**int8)(__ccgo_up(new1 + 16 + uintptr(n))) = 0 (*t__locale_map)(unsafe.Pointer(new1)).Fnext = AtomicLoadPUintptr(uintptr(unsafe.Pointer(&_loc_head))) AtomicStorePUintptr(uintptr(unsafe.Pointer(&_loc_head)), new1) break @@ -99464,7 +99464,7 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { goto _10 _10: ; - path = z + BoolUintptr(!!(*(*int8)(unsafe.Pointer(z)) != 0)) + path = z + BoolUintptr(!!(**(**int8)(__ccgo_up(z)) != 0)) } } /* If no locale definition was found, make a locale map @@ -99479,7 +99479,7 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { (*t__locale_map)(unsafe.Pointer(new1)).Fmap1 = X__c_dot_utf8.Fmap1 (*t__locale_map)(unsafe.Pointer(new1)).Fmap_size = X__c_dot_utf8.Fmap_size Xmemcpy(tls, new1+16, val, n) - *(*int8)(unsafe.Pointer(new1 + 16 + uintptr(n))) = 0 + **(**int8)(__ccgo_up(new1 + 16 + uintptr(n))) = 0 (*t__locale_map)(unsafe.Pointer(new1)).Fnext = AtomicLoadPUintptr(uintptr(unsafe.Pointer(&_loc_head))) AtomicStorePUintptr(uintptr(unsafe.Pointer(&_loc_head)), new1) } @@ -99563,7 +99563,7 @@ func _do_newlocale(tls *TLS, mask int32, name uintptr, loc Tlocale_t) (r Tlocale break } if !(mask&(Int32FromInt32(1)<,< are accepted with or without = */ - if i < int32(6) && int32(*(*int8)(unsafe.Pointer(s + 1))) == int32(_opch2[i]) { + if i < int32(6) && int32(**(**int8)(__ccgo_up(s + 1))) == int32(_opch2[i]) { (*Tst)(unsafe.Pointer(st)).Fop = i return s + uintptr(2) } @@ -99869,12 +99869,12 @@ func _evalexpr(tls *TLS, st uintptr, s uintptr, d int32) (r uintptr) { return __ccgo_ts } s = _evalbinop(tls, st, s, 0, d) - if int32(*(*int8)(unsafe.Pointer(s))) != int32('?') { + if int32(**(**int8)(__ccgo_up(s))) != int32('?') { return s } a = (*Tst)(unsafe.Pointer(st)).Fr s = _evalexpr(tls, st, s+uintptr(1), d) - if int32(*(*int8)(unsafe.Pointer(s))) != int32(':') { + if int32(**(**int8)(__ccgo_up(s))) != int32(':') { return __ccgo_ts } b = (*Tst)(unsafe.Pointer(st)).Fr @@ -99898,10 +99898,10 @@ func X__pleval(tls *TLS, s uintptr, n uint64) (r uint64) { var v1 uint64 var _ /* st at bp+0 */ Tst _ = v1 - (*(*Tst)(unsafe.Pointer(bp))).Fn = n + (**(**Tst)(__ccgo_up(bp))).Fn = n s = _evalexpr(tls, bp, s, int32(100)) - if int32(*(*int8)(unsafe.Pointer(s))) == int32(';') { - v1 = (*(*Tst)(unsafe.Pointer(bp))).Fr + if int32(**(**int8)(__ccgo_up(s))) == int32(';') { + v1 = (**(**Tst)(__ccgo_up(bp))).Fr } else { v1 = Uint64FromInt32(-Int32FromInt32(1)) } @@ -99934,7 +99934,7 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { * on the format, so it can easily be changed if needed. */ if cat == int32(LC_ALL) { if name != 0 { - *(*[24]int8)(unsafe.Pointer(bp + 48)) = [24]int8{'C', '.', 'U', 'T', 'F', '-', '8'} + **(**[24]int8)(__ccgo_up(bp + 48)) = [24]int8{'C', '.', 'U', 'T', 'F', '-', '8'} p = name i = 0 for { @@ -99944,8 +99944,8 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { z = X__strchrnul(tls, p, int32(';')) if int64(z)-int64(p) <= int64(LOCALE_NAME_MAX) { Xmemcpy(tls, bp+48, p, Uint64FromInt64(int64(z)-int64(p))) - (*(*[24]int8)(unsafe.Pointer(bp + 48)))[int64(z)-int64(p)] = 0 - if *(*int8)(unsafe.Pointer(z)) != 0 { + (**(**[24]int8)(__ccgo_up(bp + 48)))[int64(z)-int64(p)] = 0 + if **(**int8)(__ccgo_up(z)) != 0 { p = z + uintptr(1) } } @@ -99954,13 +99954,13 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { ___unlock(tls, uintptr(unsafe.Pointer(&X__locale_lock))) return uintptr(0) } - *(*uintptr)(unsafe.Pointer(bp + uintptr(i)*8)) = lm + **(**uintptr)(__ccgo_up(bp + uintptr(i)*8)) = lm goto _1 _1: ; i = i + 1 } - X__libc.Fglobal_locale = *(*t__locale_struct)(unsafe.Pointer(bp)) + X__libc.Fglobal_locale = **(**t__locale_struct)(__ccgo_up(bp)) } s = uintptr(unsafe.Pointer(&_buf1)) same = 0 @@ -99969,8 +99969,8 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { if !(i < int32(LC_ALL)) { break } - lm1 = *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 56 + uintptr(i)*8)) - if lm1 == *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 56)) { + lm1 = **(**uintptr)(__ccgo_up(uintptr(unsafe.Pointer(&X__libc)) + 56 + uintptr(i)*8)) + if lm1 == **(**uintptr)(__ccgo_up(uintptr(unsafe.Pointer(&X__libc)) + 56)) { same = same + 1 } if lm1 != 0 { @@ -99981,7 +99981,7 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { part1 = v3 l = _strlen(tls, part1) Xmemcpy(tls, s, part1, l) - *(*int8)(unsafe.Pointer(s + uintptr(l))) = int8(';') + **(**int8)(__ccgo_up(s + uintptr(l))) = int8(';') s = s + uintptr(l+uint64(1)) goto _2 _2: @@ -99990,7 +99990,7 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { } s = s - 1 v3 = s - *(*int8)(unsafe.Pointer(v3)) = 0 + **(**int8)(__ccgo_up(v3)) = 0 ___unlock(tls, uintptr(unsafe.Pointer(&X__locale_lock))) if same == int32(LC_ALL) { v3 = part1 @@ -100005,9 +100005,9 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { ___unlock(tls, uintptr(unsafe.Pointer(&X__locale_lock))) return uintptr(0) } - *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 56 + uintptr(cat)*8)) = lm + **(**uintptr)(__ccgo_up(uintptr(unsafe.Pointer(&X__libc)) + 56 + uintptr(cat)*8)) = lm } else { - lm = *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 56 + uintptr(cat)*8)) + lm = **(**uintptr)(__ccgo_up(uintptr(unsafe.Pointer(&X__libc)) + 56 + uintptr(cat)*8)) } if lm != 0 { v3 = lm + 16 @@ -100054,10 +100054,10 @@ func _vstrfmon_l(tls *TLS, s uintptr, n Tsize_t, loc Tlocale_t, fmt uintptr, ap s0 = s _3: ; - if !(n != 0 && *(*int8)(unsafe.Pointer(fmt)) != 0) { + if !(n != 0 && **(**int8)(__ccgo_up(fmt)) != 0) { goto _1 } - if !(int32(*(*int8)(unsafe.Pointer(fmt))) != int32('%')) { + if !(int32(**(**int8)(__ccgo_up(fmt))) != int32('%')) { goto _4 } goto literal @@ -100067,13 +100067,13 @@ literal: s = s + 1 v6 = fmt fmt = fmt + 1 - *(*int8)(unsafe.Pointer(v5)) = *(*int8)(unsafe.Pointer(v6)) + **(**int8)(__ccgo_up(v5)) = **(**int8)(__ccgo_up(v6)) n = n - 1 goto _2 _4: ; fmt = fmt + 1 - if int32(*(*int8)(unsafe.Pointer(fmt))) == int32('%') { + if int32(**(**int8)(__ccgo_up(fmt))) == int32('%') { goto literal } fill = int32(' ') @@ -100082,11 +100082,11 @@ _4: nosym = 0 left = 0 for { - switch int32(*(*int8)(unsafe.Pointer(fmt))) { + switch int32(**(**int8)(__ccgo_up(fmt))) { case int32('='): fmt = fmt + 1 v5 = fmt - fill = int32(*(*int8)(unsafe.Pointer(v5))) + fill = int32(**(**int8)(__ccgo_up(v5))) goto _7 case int32('^'): nogrp = int32(1) @@ -100111,10 +100111,10 @@ _4: } fw = 0 for { - if !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(fmt)))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(fmt)))-uint32('0') < uint32(10)) != 0) { break } - fw = int32(10)*fw + (int32(*(*int8)(unsafe.Pointer(fmt))) - int32('0')) + fw = int32(10)*fw + (int32(**(**int8)(__ccgo_up(fmt))) - int32('0')) goto _9 _9: ; @@ -100122,28 +100122,28 @@ _4: } lp = 0 rp = int32(2) - if int32(*(*int8)(unsafe.Pointer(fmt))) == int32('#') { + if int32(**(**int8)(__ccgo_up(fmt))) == int32('#') { lp = 0 fmt = fmt + 1 for { - if !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(fmt)))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(fmt)))-uint32('0') < uint32(10)) != 0) { break } - lp = int32(10)*lp + (int32(*(*int8)(unsafe.Pointer(fmt))) - int32('0')) + lp = int32(10)*lp + (int32(**(**int8)(__ccgo_up(fmt))) - int32('0')) goto _10 _10: ; fmt = fmt + 1 } } - if int32(*(*int8)(unsafe.Pointer(fmt))) == int32('.') { + if int32(**(**int8)(__ccgo_up(fmt))) == int32('.') { rp = 0 fmt = fmt + 1 for { - if !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(fmt)))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(fmt)))-uint32('0') < uint32(10)) != 0) { break } - rp = int32(10)*rp + (int32(*(*int8)(unsafe.Pointer(fmt))) - int32('0')) + rp = int32(10)*rp + (int32(**(**int8)(__ccgo_up(fmt))) - int32('0')) goto _11 _11: ; @@ -100152,7 +100152,7 @@ _4: } v5 = fmt fmt = fmt + 1 - intl = BoolInt32(int32(*(*int8)(unsafe.Pointer(v5))) == int32('i')) + intl = BoolInt32(int32(**(**int8)(__ccgo_up(v5))) == int32('i')) w = lp + int32(1) + rp if !(left != 0) && fw > w { w = fw @@ -100160,7 +100160,7 @@ _4: x = VaFloat64(&ap) l = Uint64FromInt32(Xsnprintf(tls, s, n, __ccgo_ts+560, VaList(bp+8, w, rp, x))) if l >= n { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(E2BIG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(E2BIG) return int64(-int32(1)) } s = s + uintptr(l) @@ -100325,7 +100325,7 @@ func Xtextdomain(tls *TLS, domainname uintptr) (r uintptr) { } domlen = _strlen(tls, domainname) if domlen > uint64(NAME_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } if !(_current_domain != 0) { @@ -100435,7 +100435,7 @@ func X__wcsxfrm_l(tls *TLS, dest uintptr, src uintptr, n Tsize_t, loc Tlocale_t) } else { if n != 0 { Xwmemcpy(tls, dest, src, n-uint64(1)) - *(*Twchar_t)(unsafe.Pointer(dest + uintptr(n-uint64(1))*4)) = 0 + **(**Twchar_t)(__ccgo_up(dest + uintptr(n-uint64(1))*4)) = 0 } } return l @@ -100466,7 +100466,7 @@ func Xreallocarray(tls *TLS, ptr uintptr, m Tsize_t, n Tsize_t) (r uintptr) { defer func() { trc("-> %v", r) }() } if n != 0 && m > Uint64FromInt32(-Int32FromInt32(1))/n { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return uintptr(0) } return Xrealloc(tls, ptr, m*n) @@ -100859,25 +100859,25 @@ func X__rem_pio2(tls *TLS, x float64, y uintptr) (r1 int32) { if ix <= uint32(0x4002d97c) { /* |x| ~<= 3pi/4 */ if !(sign != 0) { z = x - _pio2_1 /* one round good to 85 bits */ - *(*float64)(unsafe.Pointer(y)) = z - _pio2_1t - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) - _pio2_1t + **(**float64)(__ccgo_up(y)) = z - _pio2_1t + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) - _pio2_1t return int32(1) } else { z = x + _pio2_1 - *(*float64)(unsafe.Pointer(y)) = z + _pio2_1t - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) + _pio2_1t + **(**float64)(__ccgo_up(y)) = z + _pio2_1t + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) + _pio2_1t return -int32(1) } } else { if !(sign != 0) { z = x - float64(Float64FromInt32(2)*_pio2_1) - *(*float64)(unsafe.Pointer(y)) = z - Tdouble_t(Float64FromInt32(2)*_pio2_1t) - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) - Tdouble_t(Float64FromInt32(2)*_pio2_1t) + **(**float64)(__ccgo_up(y)) = z - Tdouble_t(Float64FromInt32(2)*_pio2_1t) + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) - Tdouble_t(Float64FromInt32(2)*_pio2_1t) return int32(2) } else { z = x + float64(Float64FromInt32(2)*_pio2_1) - *(*float64)(unsafe.Pointer(y)) = z + Tdouble_t(Float64FromInt32(2)*_pio2_1t) - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) + Tdouble_t(Float64FromInt32(2)*_pio2_1t) + **(**float64)(__ccgo_up(y)) = z + Tdouble_t(Float64FromInt32(2)*_pio2_1t) + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) + Tdouble_t(Float64FromInt32(2)*_pio2_1t) return -int32(2) } } @@ -100889,13 +100889,13 @@ func X__rem_pio2(tls *TLS, x float64, y uintptr) (r1 int32) { } if !(sign != 0) { z = x - float64(Float64FromInt32(3)*_pio2_1) - *(*float64)(unsafe.Pointer(y)) = z - Tdouble_t(Float64FromInt32(3)*_pio2_1t) - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) - Tdouble_t(Float64FromInt32(3)*_pio2_1t) + **(**float64)(__ccgo_up(y)) = z - Tdouble_t(Float64FromInt32(3)*_pio2_1t) + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) - Tdouble_t(Float64FromInt32(3)*_pio2_1t) return int32(3) } else { z = x + float64(Float64FromInt32(3)*_pio2_1) - *(*float64)(unsafe.Pointer(y)) = z + Tdouble_t(Float64FromInt32(3)*_pio2_1t) - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) + Tdouble_t(Float64FromInt32(3)*_pio2_1t) + **(**float64)(__ccgo_up(y)) = z + Tdouble_t(Float64FromInt32(3)*_pio2_1t) + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) + Tdouble_t(Float64FromInt32(3)*_pio2_1t) return -int32(3) } } else { @@ -100904,13 +100904,13 @@ func X__rem_pio2(tls *TLS, x float64, y uintptr) (r1 int32) { } if !(sign != 0) { z = x - float64(Float64FromInt32(4)*_pio2_1) - *(*float64)(unsafe.Pointer(y)) = z - Tdouble_t(Float64FromInt32(4)*_pio2_1t) - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) - Tdouble_t(Float64FromInt32(4)*_pio2_1t) + **(**float64)(__ccgo_up(y)) = z - Tdouble_t(Float64FromInt32(4)*_pio2_1t) + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) - Tdouble_t(Float64FromInt32(4)*_pio2_1t) return int32(4) } else { z = x + float64(Float64FromInt32(4)*_pio2_1) - *(*float64)(unsafe.Pointer(y)) = z + Tdouble_t(Float64FromInt32(4)*_pio2_1t) - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) + Tdouble_t(Float64FromInt32(4)*_pio2_1t) + **(**float64)(__ccgo_up(y)) = z + Tdouble_t(Float64FromInt32(4)*_pio2_1t) + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) + Tdouble_t(Float64FromInt32(4)*_pio2_1t) return -int32(4) } } @@ -100940,8 +100940,8 @@ medium: w = Tdouble_t(fn * _pio2_1t) } } - *(*float64)(unsafe.Pointer(y)) = r - w - *(*float64)(unsafe.Pointer(bp)) = *(*float64)(unsafe.Pointer(y)) + **(**float64)(__ccgo_up(y)) = r - w + *(*float64)(unsafe.Pointer(bp)) = **(**float64)(__ccgo_up(y)) ey = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(52) & uint64(0x7ff)) ex = Int32FromUint32(ix >> int32(20)) if ex-ey > int32(16) { /* 2nd round, good to 118 bits */ @@ -100949,18 +100949,18 @@ medium: w = Tdouble_t(fn * _pio2_2) r = t - w w = Tdouble_t(fn*_pio2_2t) - (t - r - w) - *(*float64)(unsafe.Pointer(y)) = r - w - *(*float64)(unsafe.Pointer(bp)) = *(*float64)(unsafe.Pointer(y)) + **(**float64)(__ccgo_up(y)) = r - w + *(*float64)(unsafe.Pointer(bp)) = **(**float64)(__ccgo_up(y)) ey = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(52) & uint64(0x7ff)) if ex-ey > int32(49) { /* 3rd round, good to 151 bits, covers all cases */ t = r w = Tdouble_t(fn * _pio2_3) r = t - w w = Tdouble_t(fn*_pio2_3t) - (t - r - w) - *(*float64)(unsafe.Pointer(y)) = r - w + **(**float64)(__ccgo_up(y)) = r - w } } - *(*float64)(unsafe.Pointer(y + 1*8)) = r - *(*float64)(unsafe.Pointer(y)) - w + **(**float64)(__ccgo_up(y + 1*8)) = r - **(**float64)(__ccgo_up(y)) - w return n _1: ; @@ -100969,8 +100969,8 @@ _1: */ if ix >= uint32(0x7ff00000) { /* x is inf or NaN */ v2 = x - x - *(*float64)(unsafe.Pointer(y + 1*8)) = v2 - *(*float64)(unsafe.Pointer(y)) = v2 + **(**float64)(__ccgo_up(y + 1*8)) = v2 + **(**float64)(__ccgo_up(y)) = v2 return 0 } /* set z = scalbn(|x|,-ilogb(x)+23) */ @@ -100983,26 +100983,26 @@ _1: if !(i < int32(2)) { break } - (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i] = float64(int32(z)) - z = Tdouble_t((z - (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i]) * float64(1.6777216e+07)) + (**(**[3]float64)(__ccgo_up(bp + 8)))[i] = float64(int32(z)) + z = Tdouble_t((z - (**(**[3]float64)(__ccgo_up(bp + 8)))[i]) * float64(1.6777216e+07)) goto _3 _3: ; i = i + 1 } - (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i] = z + (**(**[3]float64)(__ccgo_up(bp + 8)))[i] = z /* skip zero terms, first term is non-zero */ - for (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i] == float64(0) { + for (**(**[3]float64)(__ccgo_up(bp + 8)))[i] == float64(0) { i = i - 1 } n = X__rem_pio2_large(tls, bp+8, bp+32, Int32FromUint32(ix>>Int32FromInt32(20))-(Int32FromInt32(0x3ff)+Int32FromInt32(23)), i+int32(1), int32(1)) if sign != 0 { - *(*float64)(unsafe.Pointer(y)) = -(*(*[2]float64)(unsafe.Pointer(bp + 32)))[0] - *(*float64)(unsafe.Pointer(y + 1*8)) = -(*(*[2]float64)(unsafe.Pointer(bp + 32)))[int32(1)] + **(**float64)(__ccgo_up(y)) = -(**(**[2]float64)(__ccgo_up(bp + 32)))[0] + **(**float64)(__ccgo_up(y + 1*8)) = -(**(**[2]float64)(__ccgo_up(bp + 32)))[int32(1)] return -n } - *(*float64)(unsafe.Pointer(y)) = (*(*[2]float64)(unsafe.Pointer(bp + 32)))[0] - *(*float64)(unsafe.Pointer(y + 1*8)) = (*(*[2]float64)(unsafe.Pointer(bp + 32)))[int32(1)] + **(**float64)(__ccgo_up(y)) = (**(**[2]float64)(__ccgo_up(bp + 32)))[0] + **(**float64)(__ccgo_up(y + 1*8)) = (**(**[2]float64)(__ccgo_up(bp + 32)))[int32(1)] return n } @@ -101164,7 +101164,7 @@ func X__rem_pio2_large(tls *TLS, x uintptr, y uintptr, e0 int32, nx int32, prec if !(j <= jx) { break } - fw = fw + float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8))*f[jx+i-j]) + fw = fw + float64(**(**float64)(__ccgo_up(x + uintptr(j)*8))*f[jx+i-j]) goto _4 _4: ; @@ -101189,7 +101189,7 @@ recompute: break } fw = float64(int32(float64(Float64FromFloat64(5.960464477539063e-08) * z))) - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] = int32(z - float64(Float64FromFloat64(1.6777216e+07)*fw)) + (**(**[20]Tint32_t)(__ccgo_up(bp)))[i] = int32(z - float64(Float64FromFloat64(1.6777216e+07)*fw)) z = q[j-int32(1)] + fw goto _5 _5: @@ -101204,13 +101204,13 @@ recompute: z = z - float64(n) ih = 0 if q0 > 0 { /* need iq[jz-1] to determine n */ - i = (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz-int32(1)] >> (int32(24) - q0) + i = (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz-int32(1)] >> (int32(24) - q0) n = n + i - *(*Tint32_t)(unsafe.Pointer(bp + uintptr(jz-int32(1))*4)) -= i << (int32(24) - q0) - ih = (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz-int32(1)] >> (int32(23) - q0) + **(**Tint32_t)(__ccgo_up(bp + uintptr(jz-int32(1))*4)) -= i << (int32(24) - q0) + ih = (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz-int32(1)] >> (int32(23) - q0) } else { if q0 == 0 { - ih = (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz-int32(1)] >> int32(23) + ih = (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz-int32(1)] >> int32(23) } else { if z >= float64(0.5) { ih = int32(2) @@ -101225,14 +101225,14 @@ recompute: if !(i < jz) { break } /* compute 1-q */ - j = (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] + j = (**(**[20]Tint32_t)(__ccgo_up(bp)))[i] if carry == 0 { if j != 0 { carry = int32(1) - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] = int32(0x1000000) - j + (**(**[20]Tint32_t)(__ccgo_up(bp)))[i] = int32(0x1000000) - j } } else { - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] = int32(0xffffff) - j + (**(**[20]Tint32_t)(__ccgo_up(bp)))[i] = int32(0xffffff) - j } goto _6 _6: @@ -101242,9 +101242,9 @@ recompute: if q0 > 0 { /* rare case: chance is 1 in 12 */ switch q0 { case int32(1): - *(*Tint32_t)(unsafe.Pointer(bp + uintptr(jz-int32(1))*4)) &= int32(0x7fffff) + **(**Tint32_t)(__ccgo_up(bp + uintptr(jz-int32(1))*4)) &= int32(0x7fffff) case int32(2): - *(*Tint32_t)(unsafe.Pointer(bp + uintptr(jz-int32(1))*4)) &= int32(0x3fffff) + **(**Tint32_t)(__ccgo_up(bp + uintptr(jz-int32(1))*4)) &= int32(0x3fffff) break } } @@ -101263,7 +101263,7 @@ recompute: if !(i >= jk) { break } - j = j | (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] + j = j | (**(**[20]Tint32_t)(__ccgo_up(bp)))[i] goto _7 _7: ; @@ -101272,7 +101272,7 @@ recompute: if j == 0 { /* need recomputation */ k = int32(1) for { - if !((*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jk-k] == 0) { + if !((**(**[20]Tint32_t)(__ccgo_up(bp)))[jk-k] == 0) { break } goto _8 @@ -101292,7 +101292,7 @@ recompute: if !(j <= jx) { break } - fw = fw + float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8))*f[jx+i-j]) + fw = fw + float64(**(**float64)(__ccgo_up(x + uintptr(j)*8))*f[jx+i-j]) goto _10 _10: ; @@ -101312,7 +101312,7 @@ recompute: if z == float64(0) { jz = jz - int32(1) q0 = q0 - int32(24) - for (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] == 0 { + for (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz] == 0 { jz = jz - 1 q0 = q0 - int32(24) } @@ -101320,12 +101320,12 @@ recompute: z = Xscalbn(tls, z, -q0) if z >= float64(1.6777216e+07) { fw = float64(int32(float64(Float64FromFloat64(5.960464477539063e-08) * z))) - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(z - float64(Float64FromFloat64(1.6777216e+07)*fw)) + (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz] = int32(z - float64(Float64FromFloat64(1.6777216e+07)*fw)) jz = jz + int32(1) q0 = q0 + int32(24) - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(fw) + (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz] = int32(fw) } else { - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(z) + (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz] = int32(z) } } /* convert integer "bit" chunk to floating-point value */ @@ -101335,7 +101335,7 @@ recompute: if !(i >= 0) { break } - q[i] = float64(fw * float64((*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i])) + q[i] = float64(fw * float64((**(**[20]Tint32_t)(__ccgo_up(bp)))[i])) fw = fw * float64(5.960464477539063e-08) goto _11 _11: @@ -101360,7 +101360,7 @@ recompute: ; k = k + 1 } - (*(*[20]float64)(unsafe.Pointer(bp + 80)))[jz-i] = fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[jz-i] = fw goto _12 _12: ; @@ -101386,7 +101386,7 @@ _14: if !(i >= 0) { break } - fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[i] goto _19 _19: ; @@ -101397,7 +101397,7 @@ _14: } else { v2 = -fw } - *(*float64)(unsafe.Pointer(y)) = v2 + **(**float64)(__ccgo_up(y)) = v2 goto _18 _16: ; @@ -101409,7 +101409,7 @@ _15: if !(i >= 0) { break } - fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[i] goto _21 _21: ; @@ -101422,14 +101422,14 @@ _15: } else { v2 = -fw } - *(*float64)(unsafe.Pointer(y)) = v2 - fw = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[0] - fw + **(**float64)(__ccgo_up(y)) = v2 + fw = (**(**[20]float64)(__ccgo_up(bp + 80)))[0] - fw i = int32(1) for { if !(i <= jz) { break } - fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[i] goto _23 _23: ; @@ -101440,7 +101440,7 @@ _15: } else { v2 = -fw } - *(*float64)(unsafe.Pointer(y + 1*8)) = v2 + **(**float64)(__ccgo_up(y + 1*8)) = v2 goto _18 _17: ; /* painful */ @@ -101450,9 +101450,9 @@ _27: if !(i > 0) { goto _25 } - fw = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i-int32(1)] + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] - *(*float64)(unsafe.Pointer(bp + 80 + uintptr(i)*8)) += (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i-int32(1)] - fw - (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i-int32(1)] = fw + fw = (**(**[20]float64)(__ccgo_up(bp + 80)))[i-int32(1)] + (**(**[20]float64)(__ccgo_up(bp + 80)))[i] + **(**float64)(__ccgo_up(bp + 80 + uintptr(i)*8)) += (**(**[20]float64)(__ccgo_up(bp + 80)))[i-int32(1)] - fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[i-int32(1)] = fw goto _26 _26: ; @@ -101466,9 +101466,9 @@ _25: if !(i > int32(1)) { break } - fw = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i-int32(1)] + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] - *(*float64)(unsafe.Pointer(bp + 80 + uintptr(i)*8)) += (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i-int32(1)] - fw - (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i-int32(1)] = fw + fw = (**(**[20]float64)(__ccgo_up(bp + 80)))[i-int32(1)] + (**(**[20]float64)(__ccgo_up(bp + 80)))[i] + **(**float64)(__ccgo_up(bp + 80 + uintptr(i)*8)) += (**(**[20]float64)(__ccgo_up(bp + 80)))[i-int32(1)] - fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[i-int32(1)] = fw goto _28 _28: ; @@ -101480,20 +101480,20 @@ _25: if !(i >= int32(2)) { break } - fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[i] goto _29 _29: ; i = i - 1 } if ih == 0 { - *(*float64)(unsafe.Pointer(y)) = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[0] - *(*float64)(unsafe.Pointer(y + 1*8)) = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[int32(1)] - *(*float64)(unsafe.Pointer(y + 2*8)) = fw + **(**float64)(__ccgo_up(y)) = (**(**[20]float64)(__ccgo_up(bp + 80)))[0] + **(**float64)(__ccgo_up(y + 1*8)) = (**(**[20]float64)(__ccgo_up(bp + 80)))[int32(1)] + **(**float64)(__ccgo_up(y + 2*8)) = fw } else { - *(*float64)(unsafe.Pointer(y)) = -(*(*[20]float64)(unsafe.Pointer(bp + 80)))[0] - *(*float64)(unsafe.Pointer(y + 1*8)) = -(*(*[20]float64)(unsafe.Pointer(bp + 80)))[int32(1)] - *(*float64)(unsafe.Pointer(y + 2*8)) = -fw + **(**float64)(__ccgo_up(y)) = -(**(**[20]float64)(__ccgo_up(bp + 80)))[0] + **(**float64)(__ccgo_up(y + 1*8)) = -(**(**[20]float64)(__ccgo_up(bp + 80)))[int32(1)] + **(**float64)(__ccgo_up(y + 2*8)) = -fw } _18: ; @@ -101547,36 +101547,36 @@ func X__rem_pio2f(tls *TLS, x float32, y uintptr) (r int32) { /* Use a specialized rint() to get fn. */ fn = Tdouble_t(float64(x)*_invpio21) + _toint1 - _toint1 n = int32(fn) - *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) + **(**float64)(__ccgo_up(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) /* Matters with directed rounding. */ - if *(*float64)(unsafe.Pointer(y)) < -_pio41 { + if **(**float64)(__ccgo_up(y)) < -_pio41 { n = n - 1 fn = fn - 1 - *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) + **(**float64)(__ccgo_up(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) } else { - if *(*float64)(unsafe.Pointer(y)) > _pio41 { + if **(**float64)(__ccgo_up(y)) > _pio41 { n = n + 1 fn = fn + 1 - *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) + **(**float64)(__ccgo_up(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) } } return n } if ix >= uint32(0x7f800000) { /* x is inf or NaN */ - *(*float64)(unsafe.Pointer(y)) = float64(x - x) + **(**float64)(__ccgo_up(y)) = float64(x - x) return 0 } /* scale x into [2^23, 2^24-1] */ sign = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(bp)) >> int32(31)) e0 = Int32FromUint32(ix>>Int32FromInt32(23) - Uint32FromInt32(Int32FromInt32(0x7f)+Int32FromInt32(23))) /* e0 = ilogb(|x|)-23, positive */ *(*Tuint32_t)(unsafe.Pointer(bp)) = ix - Uint32FromInt32(e0<>int32(52)&uint64(0x7ff) < Uint64FromInt32(Int32FromInt32(0x3ff)+Int32FromInt32(4)) { if !(y != 0) { - return _p10[int32(*(*float64)(unsafe.Pointer(bp)))+int32(15)] + return _p10[int32(**(**float64)(__ccgo_up(bp)))+int32(15)] } y = Xexp2(tls, float64(float64(3.321928094887362)*y)) - return float64(y * _p10[int32(*(*float64)(unsafe.Pointer(bp)))+int32(15)]) + return float64(y * _p10[int32(**(**float64)(__ccgo_up(bp)))+int32(15)]) } return Xpow(tls, float64(10), x) } @@ -104225,14 +104225,14 @@ func Xexp10f(tls *TLS, x float32) (r float32) { Fi [0]Tuint32_t Ff float32 }{} - *(*float32)(unsafe.Pointer(bp + 4)) = *(*float32)(unsafe.Pointer(bp)) + *(*float32)(unsafe.Pointer(bp + 4)) = **(**float32)(__ccgo_up(bp)) /* fabsf(n) < 8 without raising invalid on nan */ if *(*Tuint32_t)(unsafe.Pointer(bp + 4))>>int32(23)&uint32(0xff) < Uint32FromInt32(Int32FromInt32(0x7f)+Int32FromInt32(3)) { if !(y != 0) { - return _p101[int32(*(*float32)(unsafe.Pointer(bp)))+int32(7)] + return _p101[int32(**(**float32)(__ccgo_up(bp)))+int32(7)] } y = Xexp2f(tls, float32(Float32FromFloat32(3.321928094887362)*y)) - return float32(y * _p101[int32(*(*float32)(unsafe.Pointer(bp)))+int32(7)]) + return float32(y * _p101[int32(**(**float32)(__ccgo_up(bp)))+int32(7)]) } return float32(Xexp2(tls, float64(float64(3.321928094887362)*float64(x)))) } @@ -104396,16 +104396,16 @@ _5: /* 2^(k/N) ~= scale * (1 + tail). */ idx = uint64(2) * (ki % Uint64FromInt32(Int32FromInt32(1)<>Int32FromInt32(32) + BoolUint64(t1 > *(*Tuint64_t)(unsafe.Pointer(lo))) + **(**Tuint64_t)(__ccgo_up(lo)) = t1 + t2<>Int32FromInt32(32) + BoolUint64(t1 > **(**Tuint64_t)(__ccgo_up(lo))) } func Xfma(tls *TLS, x1 float64, y1 float64, z float64) (r2 float64) { @@ -105311,11 +105311,11 @@ func Xfma(tls *TLS, x1 float64, y1 float64, z float64) (r2 float64) { if d == 0 { } else { if d < int32(64) { - *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = *(*Tuint64_t)(unsafe.Pointer(bp))<<(int32(64)-d) | *(*Tuint64_t)(unsafe.Pointer(bp + 8))>>d | BoolUint64(!!(*(*Tuint64_t)(unsafe.Pointer(bp + 8))<<(Int32FromInt32(64)-d) != 0)) - *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp)) >> d + **(**Tuint64_t)(__ccgo_up(bp + 8)) = **(**Tuint64_t)(__ccgo_up(bp))<<(int32(64)-d) | **(**Tuint64_t)(__ccgo_up(bp + 8))>>d | BoolUint64(!!(**(**Tuint64_t)(__ccgo_up(bp + 8))<<(Int32FromInt32(64)-d) != 0)) + **(**Tuint64_t)(__ccgo_up(bp)) = **(**Tuint64_t)(__ccgo_up(bp)) >> d } else { - *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = uint64(1) - *(*Tuint64_t)(unsafe.Pointer(bp)) = uint64(0) + **(**Tuint64_t)(__ccgo_up(bp + 8)) = uint64(1) + **(**Tuint64_t)(__ccgo_up(bp)) = uint64(0) } } } @@ -105338,24 +105338,24 @@ func Xfma(tls *TLS, x1 float64, y1 float64, z float64) (r2 float64) { nonzero = int32(1) if samesign != 0 { /* r += z */ - *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) + zlo - *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp)) + (zhi + BoolUint64(*(*Tuint64_t)(unsafe.Pointer(bp + 8)) < zlo)) + **(**Tuint64_t)(__ccgo_up(bp + 8)) = **(**Tuint64_t)(__ccgo_up(bp + 8)) + zlo + **(**Tuint64_t)(__ccgo_up(bp)) = **(**Tuint64_t)(__ccgo_up(bp)) + (zhi + BoolUint64(**(**Tuint64_t)(__ccgo_up(bp + 8)) < zlo)) } else { /* r -= z */ - t = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) - *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) - zlo - *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp)) - zhi - BoolUint64(t < *(*Tuint64_t)(unsafe.Pointer(bp + 8))) - if *(*Tuint64_t)(unsafe.Pointer(bp))>>int32(63) != 0 { - *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = -*(*Tuint64_t)(unsafe.Pointer(bp + 8)) - *(*Tuint64_t)(unsafe.Pointer(bp)) = -*(*Tuint64_t)(unsafe.Pointer(bp)) - BoolUint64(!!(*(*Tuint64_t)(unsafe.Pointer(bp + 8)) != 0)) + t = **(**Tuint64_t)(__ccgo_up(bp + 8)) + **(**Tuint64_t)(__ccgo_up(bp + 8)) = **(**Tuint64_t)(__ccgo_up(bp + 8)) - zlo + **(**Tuint64_t)(__ccgo_up(bp)) = **(**Tuint64_t)(__ccgo_up(bp)) - zhi - BoolUint64(t < **(**Tuint64_t)(__ccgo_up(bp + 8))) + if **(**Tuint64_t)(__ccgo_up(bp))>>int32(63) != 0 { + **(**Tuint64_t)(__ccgo_up(bp + 8)) = -**(**Tuint64_t)(__ccgo_up(bp + 8)) + **(**Tuint64_t)(__ccgo_up(bp)) = -**(**Tuint64_t)(__ccgo_up(bp)) - BoolUint64(!!(**(**Tuint64_t)(__ccgo_up(bp + 8)) != 0)) sign = BoolInt32(!(sign != 0)) } - nonzero = BoolInt32(!!(*(*Tuint64_t)(unsafe.Pointer(bp)) != 0)) + nonzero = BoolInt32(!!(**(**Tuint64_t)(__ccgo_up(bp)) != 0)) } /* set rhi to top 63bit of the result (last bit is sticky) */ if nonzero != 0 { e = e + int32(64) - v1 = *(*Tuint64_t)(unsafe.Pointer(bp)) + v1 = **(**Tuint64_t)(__ccgo_up(bp)) if v1>>Int32FromInt32(32) != 0 { y = uint32(v1 >> int32(32)) r = Int32FromInt32(0) @@ -105388,10 +105388,10 @@ func Xfma(tls *TLS, x1 float64, y1 float64, z float64) (r2 float64) { _3: d = v2 - int32(1) /* note: d > 0 */ - *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp))<>(int32(64)-d) | BoolUint64(!!(*(*Tuint64_t)(unsafe.Pointer(bp + 8))<>(int32(64)-d) | BoolUint64(!!(**(**Tuint64_t)(__ccgo_up(bp + 8))<>Int32FromInt32(32) != 0 { y = uint32(v1 >> int32(32)) r = Int32FromInt32(0) @@ -105424,9 +105424,9 @@ func Xfma(tls *TLS, x1 float64, y1 float64, z float64) (r2 float64) { _6: d = v2 - int32(1) if d < 0 { - *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp + 8))>>int32(1) | *(*Tuint64_t)(unsafe.Pointer(bp + 8))&uint64(1) + **(**Tuint64_t)(__ccgo_up(bp)) = **(**Tuint64_t)(__ccgo_up(bp + 8))>>int32(1) | **(**Tuint64_t)(__ccgo_up(bp + 8))&uint64(1) } else { - *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) << d + **(**Tuint64_t)(__ccgo_up(bp)) = **(**Tuint64_t)(__ccgo_up(bp + 8)) << d } } else { /* exact +-0 */ @@ -105435,7 +105435,7 @@ func Xfma(tls *TLS, x1 float64, y1 float64, z float64) (r2 float64) { } e = e - d /* convert to double */ - i = Int64FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp))) /* i is in [1<<62,(1<<63)-1] */ + i = Int64FromUint64(**(**Tuint64_t)(__ccgo_up(bp))) /* i is in [1<<62,(1<<63)-1] */ if sign != 0 { i = -i } @@ -105456,8 +105456,8 @@ func Xfma(tls *TLS, x1 float64, y1 float64, z float64) (r2 float64) { } /* one bit is lost when scaled, add another top bit to only round once at conversion if it is inexact */ - if *(*Tuint64_t)(unsafe.Pointer(bp))<>int32(1) | *(*Tuint64_t)(unsafe.Pointer(bp))&uint64(1) | Uint64FromUint64(1)<>int32(1)|**(**Tuint64_t)(__ccgo_up(bp))&uint64(1)) | Uint64FromUint64(1)<>d | BoolUint64(!!(*(*Tuint64_t)(unsafe.Pointer(bp))<<(Int32FromInt32(64)-d) != 0))) << d) + i = Int64FromUint64((**(**Tuint64_t)(__ccgo_up(bp))>>d | BoolUint64(!!(**(**Tuint64_t)(__ccgo_up(bp))<<(Int32FromInt32(64)-d) != 0))) << d) if sign != 0 { i = -i } @@ -106057,9 +106057,9 @@ func Xfrexp(tls *TLS, x float64, e uintptr) (r float64) { if !(ee != 0) { if x != 0 { x = Xfrexp(tls, float64(x*float64(1.8446744073709552e+19)), e) - *(*int32)(unsafe.Pointer(e)) -= int32(64) + **(**int32)(__ccgo_up(e)) -= int32(64) } else { - *(*int32)(unsafe.Pointer(e)) = 0 + **(**int32)(__ccgo_up(e)) = 0 } return x } else { @@ -106067,7 +106067,7 @@ func Xfrexp(tls *TLS, x float64, e uintptr) (r float64) { return x } } - *(*int32)(unsafe.Pointer(e)) = ee - int32(0x3fe) + **(**int32)(__ccgo_up(e)) = ee - int32(0x3fe) v1 = bp *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & Uint64FromUint64(0x800fffffffffffff)) v1 = bp @@ -106101,9 +106101,9 @@ func Xfrexpf(tls *TLS, x float32, e uintptr) (r float32) { if !(ee != 0) { if x != 0 { x = Xfrexpf(tls, float32(float64(x)*float64(1.8446744073709552e+19)), e) - *(*int32)(unsafe.Pointer(e)) -= int32(64) + **(**int32)(__ccgo_up(e)) -= int32(64) } else { - *(*int32)(unsafe.Pointer(e)) = 0 + **(**int32)(__ccgo_up(e)) = 0 } return x } else { @@ -106111,7 +106111,7 @@ func Xfrexpf(tls *TLS, x float32, e uintptr) (r float32) { return x } } - *(*int32)(unsafe.Pointer(e)) = ee - int32(0x7e) + **(**int32)(__ccgo_up(e)) = ee - int32(0x7e) v1 = bp *(*Tuint32_t)(unsafe.Pointer(v1)) = Tuint32_t(uint64(*(*Tuint32_t)(unsafe.Pointer(v1))) & Uint64FromUint64(0x807fffff)) v1 = bp @@ -106135,8 +106135,8 @@ func _sq(tls *TLS, hi uintptr, lo uintptr, x float64) { xc = Tdouble_t(x * (Float64FromFloat64(1.34217728e+08) + Float64FromInt32(1))) xh = x - xc + xc xl = x - xh - *(*Tdouble_t)(unsafe.Pointer(hi)) = Tdouble_t(x * x) - *(*Tdouble_t)(unsafe.Pointer(lo)) = Tdouble_t(xh*xh) - *(*Tdouble_t)(unsafe.Pointer(hi)) + Tdouble_t(Tdouble_t(Float64FromInt32(2)*xh)*xl) + Tdouble_t(xl*xl) + **(**Tdouble_t)(__ccgo_up(hi)) = Tdouble_t(x * x) + **(**Tdouble_t)(__ccgo_up(lo)) = Tdouble_t(xh*xh) - **(**Tdouble_t)(__ccgo_up(hi)) + Tdouble_t(Tdouble_t(Float64FromInt32(2)*xh)*xl) + Tdouble_t(xl*xl) } func Xhypot(tls *TLS, x float64, y float64) (r float64) { @@ -106188,21 +106188,21 @@ func Xhypot(tls *TLS, x float64, y float64) (r float64) { v1 = bp + 8 *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & (-Uint64FromUint64(1) >> Int32FromInt32(1))) if *(*Tuint64_t)(unsafe.Pointer(bp)) < *(*Tuint64_t)(unsafe.Pointer(bp + 8)) { - ut = *(*struct { + ut = **(**struct { Fi [0]Tuint64_t Ff float64 - })(unsafe.Pointer(bp)) - *(*struct { + })(__ccgo_up(bp)) + **(**struct { Fi [0]Tuint64_t Ff float64 - })(unsafe.Pointer(bp)) = *(*struct { + })(__ccgo_up(bp)) = **(**struct { Fi [0]Tuint64_t Ff float64 - })(unsafe.Pointer(bp + 8)) - *(*struct { + })(__ccgo_up(bp + 8)) + **(**struct { Fi [0]Tuint64_t Ff float64 - })(unsafe.Pointer(bp + 8)) = ut + })(__ccgo_up(bp + 8)) = ut } /* special cases */ ex = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(52)) @@ -106237,7 +106237,7 @@ func Xhypot(tls *TLS, x float64, y float64) (r float64) { } _sq(tls, bp+16, bp+24, x) _sq(tls, bp+32, bp+40, y) - return float64(z * Xsqrt(tls, *(*Tdouble_t)(unsafe.Pointer(bp + 40))+*(*Tdouble_t)(unsafe.Pointer(bp + 24))+*(*Tdouble_t)(unsafe.Pointer(bp + 32))+*(*Tdouble_t)(unsafe.Pointer(bp + 16)))) + return float64(z * Xsqrt(tls, **(**Tdouble_t)(__ccgo_up(bp + 40))+**(**Tdouble_t)(__ccgo_up(bp + 24))+**(**Tdouble_t)(__ccgo_up(bp + 32))+**(**Tdouble_t)(__ccgo_up(bp + 16)))) } func Xhypotf(tls *TLS, x float32, y float32) (r float32) { @@ -106280,21 +106280,21 @@ func Xhypotf(tls *TLS, x float32, y float32) (r float32) { *(*Tuint32_t)(unsafe.Pointer(bp)) &= -Uint32FromUint32(1) >> Int32FromInt32(1) *(*Tuint32_t)(unsafe.Pointer(bp + 4)) &= -Uint32FromUint32(1) >> Int32FromInt32(1) if *(*Tuint32_t)(unsafe.Pointer(bp)) < *(*Tuint32_t)(unsafe.Pointer(bp + 4)) { - ut = *(*struct { + ut = **(**struct { Fi [0]Tuint32_t Ff float32 - })(unsafe.Pointer(bp)) - *(*struct { + })(__ccgo_up(bp)) + **(**struct { Fi [0]Tuint32_t Ff float32 - })(unsafe.Pointer(bp)) = *(*struct { + })(__ccgo_up(bp)) = **(**struct { Fi [0]Tuint32_t Ff float32 - })(unsafe.Pointer(bp + 4)) - *(*struct { + })(__ccgo_up(bp + 4)) + **(**struct { Fi [0]Tuint32_t Ff float32 - })(unsafe.Pointer(bp + 4)) = ut + })(__ccgo_up(bp + 4)) = ut } x = *(*float32)(unsafe.Pointer(bp)) y = *(*float32)(unsafe.Pointer(bp + 4)) @@ -106722,8 +106722,8 @@ func _pzero(tls *TLS, x float64) (r1 float64) { } } z = float64(1) / float64(x*x) - r = *(*float64)(unsafe.Pointer(p)) + float64(z*(*(*float64)(unsafe.Pointer(p + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 4*8))+float64(z**(*float64)(unsafe.Pointer(p + 5*8))))))))))) - s = float64(1) + float64(z*(*(*float64)(unsafe.Pointer(q))+float64(z*(*(*float64)(unsafe.Pointer(q + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 3*8))+float64(z**(*float64)(unsafe.Pointer(q + 4*8))))))))))) + r = **(**float64)(__ccgo_up(p)) + float64(z*(**(**float64)(__ccgo_up(p + 1*8))+float64(z*(**(**float64)(__ccgo_up(p + 2*8))+float64(z*(**(**float64)(__ccgo_up(p + 3*8))+float64(z*(**(**float64)(__ccgo_up(p + 4*8))+float64(z***(**float64)(__ccgo_up(p + 5*8))))))))))) + s = float64(1) + float64(z*(**(**float64)(__ccgo_up(q))+float64(z*(**(**float64)(__ccgo_up(q + 1*8))+float64(z*(**(**float64)(__ccgo_up(q + 2*8))+float64(z*(**(**float64)(__ccgo_up(q + 3*8))+float64(z***(**float64)(__ccgo_up(q + 4*8))))))))))) return float64(1) + r/s } @@ -106830,8 +106830,8 @@ func _qzero(tls *TLS, x float64) (r1 float64) { } } z = float64(1) / float64(x*x) - r = *(*float64)(unsafe.Pointer(p)) + float64(z*(*(*float64)(unsafe.Pointer(p + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 4*8))+float64(z**(*float64)(unsafe.Pointer(p + 5*8))))))))))) - s = float64(1) + float64(z*(*(*float64)(unsafe.Pointer(q))+float64(z*(*(*float64)(unsafe.Pointer(q + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 4*8))+float64(z**(*float64)(unsafe.Pointer(q + 5*8))))))))))))) + r = **(**float64)(__ccgo_up(p)) + float64(z*(**(**float64)(__ccgo_up(p + 1*8))+float64(z*(**(**float64)(__ccgo_up(p + 2*8))+float64(z*(**(**float64)(__ccgo_up(p + 3*8))+float64(z*(**(**float64)(__ccgo_up(p + 4*8))+float64(z***(**float64)(__ccgo_up(p + 5*8))))))))))) + s = float64(1) + float64(z*(**(**float64)(__ccgo_up(q))+float64(z*(**(**float64)(__ccgo_up(q + 1*8))+float64(z*(**(**float64)(__ccgo_up(q + 2*8))+float64(z*(**(**float64)(__ccgo_up(q + 3*8))+float64(z*(**(**float64)(__ccgo_up(q + 4*8))+float64(z***(**float64)(__ccgo_up(q + 5*8))))))))))))) return (-Float64FromFloat64(0.125) + r/s) / x } @@ -107055,8 +107055,8 @@ func _pzerof(tls *TLS, x float32) (r1 float32) { } } z = Float32FromFloat32(1) / float32(x*x) - r = *(*float32)(unsafe.Pointer(p)) + float32(z*(*(*float32)(unsafe.Pointer(p + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 3*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 4*4))+float32(z**(*float32)(unsafe.Pointer(p + 5*4))))))))))) - s = Float32FromFloat32(1) + float32(z*(*(*float32)(unsafe.Pointer(q))+float32(z*(*(*float32)(unsafe.Pointer(q + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 3*4))+float32(z**(*float32)(unsafe.Pointer(q + 4*4))))))))))) + r = **(**float32)(__ccgo_up(p)) + float32(z*(**(**float32)(__ccgo_up(p + 1*4))+float32(z*(**(**float32)(__ccgo_up(p + 2*4))+float32(z*(**(**float32)(__ccgo_up(p + 3*4))+float32(z*(**(**float32)(__ccgo_up(p + 4*4))+float32(z***(**float32)(__ccgo_up(p + 5*4))))))))))) + s = Float32FromFloat32(1) + float32(z*(**(**float32)(__ccgo_up(q))+float32(z*(**(**float32)(__ccgo_up(q + 1*4))+float32(z*(**(**float32)(__ccgo_up(q + 2*4))+float32(z*(**(**float32)(__ccgo_up(q + 3*4))+float32(z***(**float32)(__ccgo_up(q + 4*4))))))))))) return Float32FromFloat32(1) + r/s } @@ -107163,8 +107163,8 @@ func _qzerof(tls *TLS, x float32) (r1 float32) { } } z = Float32FromFloat32(1) / float32(x*x) - r = *(*float32)(unsafe.Pointer(p)) + float32(z*(*(*float32)(unsafe.Pointer(p + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 3*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 4*4))+float32(z**(*float32)(unsafe.Pointer(p + 5*4))))))))))) - s = Float32FromFloat32(1) + float32(z*(*(*float32)(unsafe.Pointer(q))+float32(z*(*(*float32)(unsafe.Pointer(q + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 3*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 4*4))+float32(z**(*float32)(unsafe.Pointer(q + 5*4))))))))))))) + r = **(**float32)(__ccgo_up(p)) + float32(z*(**(**float32)(__ccgo_up(p + 1*4))+float32(z*(**(**float32)(__ccgo_up(p + 2*4))+float32(z*(**(**float32)(__ccgo_up(p + 3*4))+float32(z*(**(**float32)(__ccgo_up(p + 4*4))+float32(z***(**float32)(__ccgo_up(p + 5*4))))))))))) + s = Float32FromFloat32(1) + float32(z*(**(**float32)(__ccgo_up(q))+float32(z*(**(**float32)(__ccgo_up(q + 1*4))+float32(z*(**(**float32)(__ccgo_up(q + 2*4))+float32(z*(**(**float32)(__ccgo_up(q + 3*4))+float32(z*(**(**float32)(__ccgo_up(q + 4*4))+float32(z***(**float32)(__ccgo_up(q + 5*4))))))))))))) return (-Float32FromFloat32(0.125) + r/s) / x } @@ -107401,8 +107401,8 @@ func _pone(tls *TLS, x float64) (r1 float64) { } } z = float64(1) / float64(x*x) - r = *(*float64)(unsafe.Pointer(p)) + float64(z*(*(*float64)(unsafe.Pointer(p + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 4*8))+float64(z**(*float64)(unsafe.Pointer(p + 5*8))))))))))) - s = float64(1) + float64(z*(*(*float64)(unsafe.Pointer(q))+float64(z*(*(*float64)(unsafe.Pointer(q + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 3*8))+float64(z**(*float64)(unsafe.Pointer(q + 4*8))))))))))) + r = **(**float64)(__ccgo_up(p)) + float64(z*(**(**float64)(__ccgo_up(p + 1*8))+float64(z*(**(**float64)(__ccgo_up(p + 2*8))+float64(z*(**(**float64)(__ccgo_up(p + 3*8))+float64(z*(**(**float64)(__ccgo_up(p + 4*8))+float64(z***(**float64)(__ccgo_up(p + 5*8))))))))))) + s = float64(1) + float64(z*(**(**float64)(__ccgo_up(q))+float64(z*(**(**float64)(__ccgo_up(q + 1*8))+float64(z*(**(**float64)(__ccgo_up(q + 2*8))+float64(z*(**(**float64)(__ccgo_up(q + 3*8))+float64(z***(**float64)(__ccgo_up(q + 4*8))))))))))) return float64(1) + r/s } @@ -107508,8 +107508,8 @@ func _qone(tls *TLS, x float64) (r1 float64) { } } z = float64(1) / float64(x*x) - r = *(*float64)(unsafe.Pointer(p)) + float64(z*(*(*float64)(unsafe.Pointer(p + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 4*8))+float64(z**(*float64)(unsafe.Pointer(p + 5*8))))))))))) - s = float64(1) + float64(z*(*(*float64)(unsafe.Pointer(q))+float64(z*(*(*float64)(unsafe.Pointer(q + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 4*8))+float64(z**(*float64)(unsafe.Pointer(q + 5*8))))))))))))) + r = **(**float64)(__ccgo_up(p)) + float64(z*(**(**float64)(__ccgo_up(p + 1*8))+float64(z*(**(**float64)(__ccgo_up(p + 2*8))+float64(z*(**(**float64)(__ccgo_up(p + 3*8))+float64(z*(**(**float64)(__ccgo_up(p + 4*8))+float64(z***(**float64)(__ccgo_up(p + 5*8))))))))))) + s = float64(1) + float64(z*(**(**float64)(__ccgo_up(q))+float64(z*(**(**float64)(__ccgo_up(q + 1*8))+float64(z*(**(**float64)(__ccgo_up(q + 2*8))+float64(z*(**(**float64)(__ccgo_up(q + 3*8))+float64(z*(**(**float64)(__ccgo_up(q + 4*8))+float64(z***(**float64)(__ccgo_up(q + 5*8))))))))))))) return (float64(0.375) + r/s) / x } @@ -107732,8 +107732,8 @@ func _ponef(tls *TLS, x float32) (r1 float32) { } } z = Float32FromFloat32(1) / float32(x*x) - r = *(*float32)(unsafe.Pointer(p)) + float32(z*(*(*float32)(unsafe.Pointer(p + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 3*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 4*4))+float32(z**(*float32)(unsafe.Pointer(p + 5*4))))))))))) - s = Float32FromFloat32(1) + float32(z*(*(*float32)(unsafe.Pointer(q))+float32(z*(*(*float32)(unsafe.Pointer(q + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 3*4))+float32(z**(*float32)(unsafe.Pointer(q + 4*4))))))))))) + r = **(**float32)(__ccgo_up(p)) + float32(z*(**(**float32)(__ccgo_up(p + 1*4))+float32(z*(**(**float32)(__ccgo_up(p + 2*4))+float32(z*(**(**float32)(__ccgo_up(p + 3*4))+float32(z*(**(**float32)(__ccgo_up(p + 4*4))+float32(z***(**float32)(__ccgo_up(p + 5*4))))))))))) + s = Float32FromFloat32(1) + float32(z*(**(**float32)(__ccgo_up(q))+float32(z*(**(**float32)(__ccgo_up(q + 1*4))+float32(z*(**(**float32)(__ccgo_up(q + 2*4))+float32(z*(**(**float32)(__ccgo_up(q + 3*4))+float32(z***(**float32)(__ccgo_up(q + 4*4))))))))))) return Float32FromFloat32(1) + r/s } @@ -107839,8 +107839,8 @@ func _qonef(tls *TLS, x float32) (r1 float32) { } } z = Float32FromFloat32(1) / float32(x*x) - r = *(*float32)(unsafe.Pointer(p)) + float32(z*(*(*float32)(unsafe.Pointer(p + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 3*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 4*4))+float32(z**(*float32)(unsafe.Pointer(p + 5*4))))))))))) - s = Float32FromFloat32(1) + float32(z*(*(*float32)(unsafe.Pointer(q))+float32(z*(*(*float32)(unsafe.Pointer(q + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 3*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 4*4))+float32(z**(*float32)(unsafe.Pointer(q + 5*4))))))))))))) + r = **(**float32)(__ccgo_up(p)) + float32(z*(**(**float32)(__ccgo_up(p + 1*4))+float32(z*(**(**float32)(__ccgo_up(p + 2*4))+float32(z*(**(**float32)(__ccgo_up(p + 3*4))+float32(z*(**(**float32)(__ccgo_up(p + 4*4))+float32(z***(**float32)(__ccgo_up(p + 5*4))))))))))) + s = Float32FromFloat32(1) + float32(z*(**(**float32)(__ccgo_up(q))+float32(z*(**(**float32)(__ccgo_up(q + 1*4))+float32(z*(**(**float32)(__ccgo_up(q + 2*4))+float32(z*(**(**float32)(__ccgo_up(q + 3*4))+float32(z*(**(**float32)(__ccgo_up(q + 4*4))+float32(z***(**float32)(__ccgo_up(q + 5*4))))))))))))) return (Float32FromFloat32(0.375) + r/s) / x } @@ -108521,7 +108521,7 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { }{} *(*float64)(unsafe.Pointer(bp)) = x /* purge off +-inf, NaN, +-0, tiny and negative arguments */ - *(*int32)(unsafe.Pointer(signgamp)) = int32(1) + **(**int32)(__ccgo_up(signgamp)) = int32(1) sign = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(63)) ix = uint32(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(32) & uint64(0x7fffffff)) if ix >= uint32(0x7ff00000) { @@ -108530,7 +108530,7 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { if ix < Uint32FromInt32((Int32FromInt32(0x3ff)-Int32FromInt32(70))< float64(0) { - *(*int32)(unsafe.Pointer(signgamp)) = -int32(1) + **(**int32)(__ccgo_up(signgamp)) = -int32(1) } else { t = -t } @@ -108778,7 +108778,7 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { }{} *(*float32)(unsafe.Pointer(bp)) = x /* purge off +-inf, NaN, +-0, tiny and negative arguments */ - *(*int32)(unsafe.Pointer(signgamp)) = int32(1) + **(**int32)(__ccgo_up(signgamp)) = int32(1) sign = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(bp)) >> int32(31)) ix = *(*Tuint32_t)(unsafe.Pointer(bp)) & uint32(0x7fffffff) if ix >= uint32(0x7f800000) { @@ -108786,7 +108786,7 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { } if ix < uint32(0x35000000) { /* |x| < 2**-21, return -log(|x|) */ if sign != 0 { - *(*int32)(unsafe.Pointer(signgamp)) = -int32(1) + **(**int32)(__ccgo_up(signgamp)) = -int32(1) x = -x } return -Xlogf(tls, x) @@ -108798,7 +108798,7 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { return Float32FromFloat32(1) / (x - x) } if t > Float32FromFloat32(0) { - *(*int32)(unsafe.Pointer(signgamp)) = -int32(1) + **(**int32)(__ccgo_up(signgamp)) = -int32(1) } else { t = -t } @@ -109046,15 +109046,15 @@ func Xlog(tls *TLS, x1 float64) (r1 float64) { r = x1 - float64(1) r2 = Tdouble_t(r * r) r3 = Tdouble_t(r * r2) - y1 = Tdouble_t(r3 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 1*8)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 2*8))) + float64(r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 3*8))) + float64(r3*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 4*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 5*8)))+float64(r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 6*8)))+float64(r3*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 7*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 8*8)))+float64(r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 9*8)))+float64(r3**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 10*8))))))))) + y1 = Tdouble_t(r3 * (**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 1*8)) + float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 2*8))) + float64(r2***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 3*8))) + float64(r3*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 4*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 5*8)))+float64(r2***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 6*8)))+float64(r3*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 7*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 8*8)))+float64(r2***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 9*8)))+float64(r3***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 10*8))))))))) /* Worst-case error is around 0.507 ULP. */ w = Tdouble_t(r * float64(1.34217728e+08)) rhi = r + w - w rlo = r - rhi - w = Tdouble_t(Tdouble_t(rhi*rhi) * *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56))) /* B[0] == -0.5. */ + w = Tdouble_t(Tdouble_t(rhi*rhi) * **(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56))) /* B[0] == -0.5. */ hi = r + w lo = r - hi + w - lo = lo + Tdouble_t(float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56))*rlo)*(rhi+r)) + lo = lo + Tdouble_t(float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56))*rlo)*(rhi+r)) y1 = y1 + lo y1 = y1 + hi y = y1 @@ -109087,14 +109087,14 @@ func Xlog(tls *TLS, x1 float64) (r1 float64) { i = Int32FromUint64(tmp >> (Int32FromInt32(52) - Int32FromInt32(LOG_TABLE_BITS)) % Uint64FromInt32(Int32FromInt32(1)<> int32(52)) /* arithmetic shift */ iz = uint64(ix - tmp&(Uint64FromUint64(0xfff)< 0x1p-4: 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma). */ - y1 = lo + Tdouble_t(r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16))) + Tdouble_t(Tdouble_t(r*r2)*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 1*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 2*8)))+float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 3*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 4*8))))))) + hi + y1 = lo + Tdouble_t(r2***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 16))) + Tdouble_t(Tdouble_t(r*r2)*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 1*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 2*8)))+float64(r2*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 3*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 4*8))))))) + hi y = y1 v1 = y goto _11 @@ -109556,10 +109556,10 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { r2 = Tdouble_t(r * r) /* rounding error: 0x1p-62. */ r4 = Tdouble_t(r2 * r2) /* Worst-case error is less than 0.54 ULP (0.55 ULP without fma). */ - p = Tdouble_t(r2 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 1*8))))) + p = Tdouble_t(r2 * (**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64)) + float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 1*8))))) y1 = hi + p lo = lo + (hi - y1 + p) - lo = lo + Tdouble_t(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 2*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 3*8)))+float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 4*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 5*8)))))+float64(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 6*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 7*8)))+float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 8*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 9*8))))))))) + lo = lo + Tdouble_t(r4*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 2*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 3*8)))+float64(r2*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 4*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 5*8)))))+float64(r4*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 6*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 7*8)))+float64(r2*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 8*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 9*8))))))))) y1 = y1 + lo y = y1 v1 = y @@ -109591,14 +109591,14 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { i = Int32FromUint64(tmp >> (Int32FromInt32(52) - Int32FromInt32(LOG2_TABLE_BITS)) % Uint64FromInt32(Int32FromInt32(1)<> int32(52)) /* arithmetic shift */ iz = uint64(ix - tmp&(Uint64FromUint64(0xfff)< 0x1p-4: 0.547 ULP (0.550 ULP without fma). ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma). */ - p = *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 1*8))) + float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 2*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 3*8))))) + float64(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 4*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 5*8))))) + p = **(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 16)) + float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 1*8))) + float64(r2*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 2*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 3*8))))) + float64(r4*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 4*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 5*8))))) y1 = lo + Tdouble_t(r2*p) + hi y = y1 v1 = y @@ -109689,23 +109689,23 @@ func Xlog2f(tls *TLS, x1 float32) (r1 float32) { top = tmp & uint32(0xff800000) iz = ix - top k = Int32FromUint32(tmp) >> int32(23) /* arithmetic shift */ - invc = (*(*struct { + invc = (**(**struct { Finvc float64 Flogc float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + uintptr(i)*16))).Finvc - logc = (*(*struct { + })(__ccgo_up(uintptr(unsafe.Pointer(&X__log2f_data)) + uintptr(i)*16))).Finvc + logc = (**(**struct { Finvc float64 Flogc float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + uintptr(i)*16))).Flogc + })(__ccgo_up(uintptr(unsafe.Pointer(&X__log2f_data)) + uintptr(i)*16))).Flogc z = float64(*(*float32)(unsafe.Pointer(&iz))) /* log2(x) = log1p(z/c-1)/ln2 + log2(c) + k */ r = Tdouble_t(z*invc) - Float64FromInt32(1) y0 = logc + float64(k) /* Pipelined polynomial evaluation to approximate log1p(r)/ln2. */ r2 = Tdouble_t(r * r) - y1 = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 1*8))*r) + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 2*8)) - y1 = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256))*r2) + y1 - p = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 3*8))*r) + y0 + y1 = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 1*8))*r) + **(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 2*8)) + y1 = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2f_data)) + 256))*r2) + y1 + p = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 3*8))*r) + y0 y1 = Tdouble_t(y1*r2) + p y = float32(y1) v1 = y @@ -109878,22 +109878,22 @@ func Xlogf(tls *TLS, x1 float32) (r1 float32) { i = Int32FromUint32(tmp >> (Int32FromInt32(23) - Int32FromInt32(LOGF_TABLE_BITS)) % Uint32FromInt32(Int32FromInt32(1)<> int32(23) /* arithmetic shift */ iz = ix - tmp&uint32(0xff800000) - invc = (*(*struct { + invc = (**(**struct { Finvc float64 Flogc float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + uintptr(i)*16))).Finvc - logc = (*(*struct { + })(__ccgo_up(uintptr(unsafe.Pointer(&X__logf_data)) + uintptr(i)*16))).Finvc + logc = (**(**struct { Finvc float64 Flogc float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + uintptr(i)*16))).Flogc + })(__ccgo_up(uintptr(unsafe.Pointer(&X__logf_data)) + uintptr(i)*16))).Flogc z = float64(*(*float32)(unsafe.Pointer(&iz))) /* log(x) = log1p(z/c-1) + log(c) + k*Ln2 */ r = Tdouble_t(z*invc) - Float64FromInt32(1) y0 = logc + Tdouble_t(float64(k)*X__logf_data.Fln2) /* Pipelined polynomial evaluation to approximate log1p(r). */ r2 = Tdouble_t(r * r) - y1 = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + 264 + 1*8))*r) + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + 264 + 2*8)) - y1 = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + 264))*r2) + y1 + y1 = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__logf_data)) + 264 + 1*8))*r) + **(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__logf_data)) + 264 + 2*8)) + y1 = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__logf_data)) + 264))*r2) + y1 y1 = Tdouble_t(y1*r2) + (y0 + r) y = float32(y1) v1 = y @@ -110018,7 +110018,7 @@ func Xmodf(tls *TLS, x float64, iptr uintptr) (r float64) { e = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp))>>Int32FromInt32(52)&Uint64FromInt32(0x7ff)) - int32(0x3ff) /* no fractional part */ if e >= int32(52) { - *(*float64)(unsafe.Pointer(iptr)) = x + **(**float64)(__ccgo_up(iptr)) = x if e == int32(0x400) && *(*Tuint64_t)(unsafe.Pointer(bp))<> Int32FromInt32(12) >> e) if *(*Tuint64_t)(unsafe.Pointer(bp))&mask == uint64(0) { - *(*float64)(unsafe.Pointer(iptr)) = x + **(**float64)(__ccgo_up(iptr)) = x v1 = bp *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & (Uint64FromUint64(1) << Int32FromInt32(63))) return *(*float64)(unsafe.Pointer(bp)) } *(*Tuint64_t)(unsafe.Pointer(bp)) &= ^mask - *(*float64)(unsafe.Pointer(iptr)) = *(*float64)(unsafe.Pointer(bp)) + **(**float64)(__ccgo_up(iptr)) = *(*float64)(unsafe.Pointer(bp)) return x - *(*float64)(unsafe.Pointer(bp)) } @@ -110070,7 +110070,7 @@ func Xmodff(tls *TLS, x float32, iptr uintptr) (r float32) { e = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(bp))>>Int32FromInt32(23)&Uint32FromInt32(0xff)) - int32(0x7f) /* no fractional part */ if e >= int32(23) { - *(*float32)(unsafe.Pointer(iptr)) = x + **(**float32)(__ccgo_up(iptr)) = x if e == int32(0x80) && *(*Tuint32_t)(unsafe.Pointer(bp))<> e) if *(*Tuint32_t)(unsafe.Pointer(bp))&mask == uint32(0) { - *(*float32)(unsafe.Pointer(iptr)) = x + **(**float32)(__ccgo_up(iptr)) = x *(*Tuint32_t)(unsafe.Pointer(bp)) &= uint32(0x80000000) return *(*float32)(unsafe.Pointer(bp)) } *(*Tuint32_t)(unsafe.Pointer(bp)) &= ^mask - *(*float32)(unsafe.Pointer(iptr)) = *(*float32)(unsafe.Pointer(bp)) + **(**float32)(__ccgo_up(iptr)) = *(*float32)(unsafe.Pointer(bp)) return x - *(*float32)(unsafe.Pointer(bp)) } @@ -110105,7 +110105,7 @@ func Xmodfl(tls *TLS, x float64, iptr uintptr) (r1 float64) { var _ /* d at bp+0 */ float64 _ = r r = Xmodf(tls, x, bp) - *(*float64)(unsafe.Pointer(iptr)) = *(*float64)(unsafe.Pointer(bp)) + **(**float64)(__ccgo_up(iptr)) = float64(**(**float64)(__ccgo_up(bp))) return r } @@ -110507,24 +110507,24 @@ func _log_inline(tls *TLS, ix Tuint64_t, tail uintptr) (r1 Tdouble_t) { z = *(*float64)(unsafe.Pointer(&iz)) kd = float64(k) /* log(x) = k*Ln2 + log(c) + log1p(z/c-1). */ - invc = (*(*struct { + invc = (**(**struct { Finvc float64 Fpad float64 Flogc float64 Flogctail float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Finvc - logc = (*(*struct { + })(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Finvc + logc = (**(**struct { Finvc float64 Fpad float64 Flogc float64 Flogctail float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Flogc - logctail = (*(*struct { + })(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Flogc + logctail = (**(**struct { Finvc float64 Fpad float64 Flogc float64 Flogctail float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Flogctail + })(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Flogctail /* Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible. */ r = float64(X__builtin_fma(tls, z, invc, -Float64FromFloat64(1))) @@ -110533,7 +110533,7 @@ func _log_inline(tls *TLS, ix Tuint64_t, tail uintptr) (r1 Tdouble_t) { t2 = t1 + r lo1 = Tdouble_t(kd*X__pow_log_data.Fln2lo) + logctail lo2 = t1 - t2 + r - ar = Tdouble_t(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16)) * r) /* A[0] = -0.5. */ + ar = Tdouble_t(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16)) * r) /* A[0] = -0.5. */ ar2 = Tdouble_t(r * ar) ar3 = Tdouble_t(r * ar2) /* k*Ln2 + log(c) + r + A[0]*r*r. */ @@ -110541,10 +110541,10 @@ func _log_inline(tls *TLS, ix Tuint64_t, tail uintptr) (r1 Tdouble_t) { lo3 = float64(X__builtin_fma(tls, ar, r, -ar2)) lo4 = t2 - hi + ar2 /* p = log1p(r) - r - A[0]*r*r. */ - p = Tdouble_t(ar3 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 1*8)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 2*8))) + float64(ar2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 3*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 4*8)))+float64(ar2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 5*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 6*8))))))))) + p = Tdouble_t(ar3 * (**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 1*8)) + float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 2*8))) + float64(ar2*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 3*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 4*8)))+float64(ar2*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 5*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 6*8))))))))) lo = lo1 + lo2 + lo3 + lo4 + p y = hi + lo - *(*Tdouble_t)(unsafe.Pointer(tail)) = hi - y + lo + **(**Tdouble_t)(__ccgo_up(tail)) = hi - y + lo return y } @@ -110664,16 +110664,16 @@ _4: /* 2^(k/N) ~= scale * (1 + tail). */ idx = uint64(2) * (ki % Uint64FromInt32(Int32FromInt32(1)<> (Int32FromInt32(23) - Int32FromInt32(POWF_SCALE_BITS)) /* arithmetic shift */ - invc = (*(*struct { + invc = (**(**struct { Finvc float64 Flogc float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + uintptr(i)*16))).Finvc - logc = (*(*struct { + })(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + uintptr(i)*16))).Finvc + logc = (**(**struct { Finvc float64 Flogc float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + uintptr(i)*16))).Flogc + })(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + uintptr(i)*16))).Flogc z = float64(*(*float32)(unsafe.Pointer(&iz))) /* log2(x) = log1p(z/c-1)/ln2 + log2(c) + k */ r = Tdouble_t(z*invc) - Float64FromInt32(1) y0 = logc + float64(k) /* Pipelined polynomial evaluation to approximate log1p(r)/ln2. */ r2 = Tdouble_t(r * r) - y = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256))*r) + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 1*8)) - p = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 2*8))*r) + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 3*8)) + y = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256))*r) + **(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 1*8)) + p = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 2*8))*r) + **(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 3*8)) r4 = Tdouble_t(r2 * r2) - q = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 4*8))*r) + y0 + q = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 4*8))*r) + y0 q = Tdouble_t(p*r2) + q y = Tdouble_t(y*r4) + q return y @@ -110935,13 +110935,13 @@ _2: kd = kd - X__exp2f_data.Fshift_scaled /* k/N */ r = xd - kd /* exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1) */ - t = *(*Tuint64_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + uintptr(ki%Uint64FromInt32(Int32FromInt32(1)<> int32(63)) sy = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp + 16)) >> int32(63)) uxi = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) - *(*int32)(unsafe.Pointer(quo)) = 0 + **(**int32)(__ccgo_up(quo)) = 0 if v3 = *(*Tuint64_t)(unsafe.Pointer(bp + 16))<> int32(31)) sy = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(bp + 8)) >> int32(31)) uxi = *(*Tuint32_t)(unsafe.Pointer(bp + 4)) - *(*int32)(unsafe.Pointer(quo)) = 0 + **(**int32)(__ccgo_up(quo)) = 0 if v3 = *(*Tuint32_t)(unsafe.Pointer(bp + 8))<= uint32(0x7ff00000) { v1 = x3 - x3 - *(*float64)(unsafe.Pointer(cos)) = v1 - *(*float64)(unsafe.Pointer(sin)) = v1 + **(**float64)(__ccgo_up(cos)) = v1 + **(**float64)(__ccgo_up(sin)) = v1 return } /* argument reduction needed */ n = Uint32FromInt32(X__rem_pio2(tls, x3, bp)) - s = X__sin(tls, (*(*[2]float64)(unsafe.Pointer(bp)))[0], (*(*[2]float64)(unsafe.Pointer(bp)))[int32(1)], int32(1)) - c = X__cos(tls, (*(*[2]float64)(unsafe.Pointer(bp)))[0], (*(*[2]float64)(unsafe.Pointer(bp)))[int32(1)]) + s = X__sin(tls, (**(**[2]float64)(__ccgo_up(bp)))[0], (**(**[2]float64)(__ccgo_up(bp)))[int32(1)], int32(1)) + c = X__cos(tls, (**(**[2]float64)(__ccgo_up(bp)))[0], (**(**[2]float64)(__ccgo_up(bp)))[int32(1)]) switch n & Uint32FromInt32(3) { case uint32(0): - *(*float64)(unsafe.Pointer(sin)) = s - *(*float64)(unsafe.Pointer(cos)) = c + **(**float64)(__ccgo_up(sin)) = s + **(**float64)(__ccgo_up(cos)) = c case uint32(1): - *(*float64)(unsafe.Pointer(sin)) = c - *(*float64)(unsafe.Pointer(cos)) = -s + **(**float64)(__ccgo_up(sin)) = c + **(**float64)(__ccgo_up(cos)) = -s case uint32(2): - *(*float64)(unsafe.Pointer(sin)) = -s - *(*float64)(unsafe.Pointer(cos)) = -c + **(**float64)(__ccgo_up(sin)) = -s + **(**float64)(__ccgo_up(cos)) = -c case uint32(3): fallthrough default: - *(*float64)(unsafe.Pointer(sin)) = -c - *(*float64)(unsafe.Pointer(cos)) = s + **(**float64)(__ccgo_up(sin)) = -c + **(**float64)(__ccgo_up(cos)) = s break } } @@ -112182,23 +112182,23 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { y2 = float64(v1) } } - *(*float32)(unsafe.Pointer(sin)) = x3 - *(*float32)(unsafe.Pointer(cos)) = Float32FromFloat32(1) + **(**float32)(__ccgo_up(sin)) = x3 + **(**float32)(__ccgo_up(cos)) = Float32FromFloat32(1) return } - *(*float32)(unsafe.Pointer(sin)) = X__sindf(tls, float64(x3)) - *(*float32)(unsafe.Pointer(cos)) = X__cosdf(tls, float64(x3)) + **(**float32)(__ccgo_up(sin)) = X__sindf(tls, float64(x3)) + **(**float32)(__ccgo_up(cos)) = X__cosdf(tls, float64(x3)) return } /* |x| ~<= 5*pi/4 */ if ix <= uint32(0x407b53d1) { if ix <= uint32(0x4016cbe3) { /* |x| ~<= 3pi/4 */ if sign != 0 { - *(*float32)(unsafe.Pointer(sin)) = -X__cosdf(tls, float64(x3)+_s1pio2) - *(*float32)(unsafe.Pointer(cos)) = X__sindf(tls, float64(x3)+_s1pio2) + **(**float32)(__ccgo_up(sin)) = -X__cosdf(tls, float64(x3)+_s1pio2) + **(**float32)(__ccgo_up(cos)) = X__sindf(tls, float64(x3)+_s1pio2) } else { - *(*float32)(unsafe.Pointer(sin)) = X__cosdf(tls, _s1pio2-float64(x3)) - *(*float32)(unsafe.Pointer(cos)) = X__sindf(tls, _s1pio2-float64(x3)) + **(**float32)(__ccgo_up(sin)) = X__cosdf(tls, _s1pio2-float64(x3)) + **(**float32)(__ccgo_up(cos)) = X__sindf(tls, _s1pio2-float64(x3)) } return } @@ -112208,24 +112208,24 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { } else { v4 = float64(x3) - _s2pio2 } - *(*float32)(unsafe.Pointer(sin)) = -X__sindf(tls, v4) + **(**float32)(__ccgo_up(sin)) = -X__sindf(tls, v4) if sign != 0 { v4 = float64(x3) + _s2pio2 } else { v4 = float64(x3) - _s2pio2 } - *(*float32)(unsafe.Pointer(cos)) = -X__cosdf(tls, v4) + **(**float32)(__ccgo_up(cos)) = -X__cosdf(tls, v4) return } /* |x| ~<= 9*pi/4 */ if ix <= uint32(0x40e231d5) { if ix <= uint32(0x40afeddf) { /* |x| ~<= 7*pi/4 */ if sign != 0 { - *(*float32)(unsafe.Pointer(sin)) = X__cosdf(tls, float64(x3)+_s3pio2) - *(*float32)(unsafe.Pointer(cos)) = -X__sindf(tls, float64(x3)+_s3pio2) + **(**float32)(__ccgo_up(sin)) = X__cosdf(tls, float64(x3)+_s3pio2) + **(**float32)(__ccgo_up(cos)) = -X__sindf(tls, float64(x3)+_s3pio2) } else { - *(*float32)(unsafe.Pointer(sin)) = -X__cosdf(tls, float64(x3)-_s3pio2) - *(*float32)(unsafe.Pointer(cos)) = X__sindf(tls, float64(x3)-_s3pio2) + **(**float32)(__ccgo_up(sin)) = -X__cosdf(tls, float64(x3)-_s3pio2) + **(**float32)(__ccgo_up(cos)) = X__sindf(tls, float64(x3)-_s3pio2) } return } @@ -112234,41 +112234,41 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { } else { v4 = float64(x3) - _s4pio2 } - *(*float32)(unsafe.Pointer(sin)) = X__sindf(tls, v4) + **(**float32)(__ccgo_up(sin)) = X__sindf(tls, v4) if sign != 0 { v4 = float64(x3) + _s4pio2 } else { v4 = float64(x3) - _s4pio2 } - *(*float32)(unsafe.Pointer(cos)) = X__cosdf(tls, v4) + **(**float32)(__ccgo_up(cos)) = X__cosdf(tls, v4) return } /* sin(Inf or NaN) is NaN */ if ix >= uint32(0x7f800000) { v1 = x3 - x3 - *(*float32)(unsafe.Pointer(cos)) = v1 - *(*float32)(unsafe.Pointer(sin)) = v1 + **(**float32)(__ccgo_up(cos)) = v1 + **(**float32)(__ccgo_up(sin)) = v1 return } /* general argument reduction needed */ n = Uint32FromInt32(X__rem_pio2f(tls, x3, bp)) - s = X__sindf(tls, *(*float64)(unsafe.Pointer(bp))) - c = X__cosdf(tls, *(*float64)(unsafe.Pointer(bp))) + s = X__sindf(tls, **(**float64)(__ccgo_up(bp))) + c = X__cosdf(tls, **(**float64)(__ccgo_up(bp))) switch n & Uint32FromInt32(3) { case uint32(0): - *(*float32)(unsafe.Pointer(sin)) = s - *(*float32)(unsafe.Pointer(cos)) = c + **(**float32)(__ccgo_up(sin)) = s + **(**float32)(__ccgo_up(cos)) = c case uint32(1): - *(*float32)(unsafe.Pointer(sin)) = c - *(*float32)(unsafe.Pointer(cos)) = -s + **(**float32)(__ccgo_up(sin)) = c + **(**float32)(__ccgo_up(cos)) = -s case uint32(2): - *(*float32)(unsafe.Pointer(sin)) = -s - *(*float32)(unsafe.Pointer(cos)) = -c + **(**float32)(__ccgo_up(sin)) = -s + **(**float32)(__ccgo_up(cos)) = -c case uint32(3): fallthrough default: - *(*float32)(unsafe.Pointer(sin)) = -c - *(*float32)(unsafe.Pointer(cos)) = s + **(**float32)(__ccgo_up(sin)) = -c + **(**float32)(__ccgo_up(cos)) = s break } } @@ -112284,8 +112284,8 @@ func Xsincosl(tls *TLS, x float64, sin uintptr, cos uintptr) { var _ /* cosd at bp+8 */ float64 var _ /* sind at bp+0 */ float64 Xsincos(tls, x, bp, bp+8) - *(*float64)(unsafe.Pointer(sin)) = *(*float64)(unsafe.Pointer(bp)) - *(*float64)(unsafe.Pointer(cos)) = *(*float64)(unsafe.Pointer(bp + 8)) + **(**float64)(__ccgo_up(sin)) = float64(**(**float64)(__ccgo_up(bp))) + **(**float64)(__ccgo_up(cos)) = float64(**(**float64)(__ccgo_up(bp + 8))) } const M_PI_27 = 1.5707963267948966 @@ -112384,13 +112384,13 @@ func Xsinf(tls *TLS, x3 float32) (r float32) { n = X__rem_pio2f(tls, x3, bp) switch n & Int32FromInt32(3) { case 0: - return X__sindf(tls, *(*float64)(unsafe.Pointer(bp))) + return X__sindf(tls, **(**float64)(__ccgo_up(bp))) case int32(1): - return X__cosdf(tls, *(*float64)(unsafe.Pointer(bp))) + return X__cosdf(tls, **(**float64)(__ccgo_up(bp))) case int32(2): - return X__sindf(tls, -*(*float64)(unsafe.Pointer(bp))) + return X__sindf(tls, -**(**float64)(__ccgo_up(bp))) default: - return -X__cosdf(tls, *(*float64)(unsafe.Pointer(bp))) + return -X__cosdf(tls, **(**float64)(__ccgo_up(bp))) } return r } @@ -112836,7 +112836,7 @@ func Xtan(tls *TLS, x3 float64) (r float64) { } /* argument reduction */ n = Uint32FromInt32(X__rem_pio2(tls, x3, bp)) - return X__tan(tls, (*(*[2]float64)(unsafe.Pointer(bp)))[0], (*(*[2]float64)(unsafe.Pointer(bp)))[int32(1)], Int32FromUint32(n&uint32(1))) + return X__tan(tls, (**(**[2]float64)(__ccgo_up(bp)))[0], (**(**[2]float64)(__ccgo_up(bp)))[int32(1)], Int32FromUint32(n&uint32(1))) } const M_PI_29 = 1.5707963267948966 @@ -112937,7 +112937,7 @@ func Xtanf(tls *TLS, x3 float32) (r float32) { } /* argument reduction */ n = Uint32FromInt32(X__rem_pio2f(tls, x3, bp)) - return X__tandf(tls, *(*float64)(unsafe.Pointer(bp)), Int32FromUint32(n&uint32(1))) + return X__tandf(tls, **(**float64)(__ccgo_up(bp)), Int32FromUint32(n&uint32(1))) } const M_PI_210 = 0 @@ -113477,10 +113477,10 @@ func Xa64l(tls *TLS, s uintptr) (r int64) { x = uint32(0) e = 0 for { - if !(e < int32(36) && *(*int8)(unsafe.Pointer(s)) != 0) { + if !(e < int32(36) && **(**int8)(__ccgo_up(s)) != 0) { break } - d = Xstrchr(tls, uintptr(unsafe.Pointer(&_digits)), int32(*(*int8)(unsafe.Pointer(s)))) + d = Xstrchr(tls, uintptr(unsafe.Pointer(&_digits)), int32(**(**int8)(__ccgo_up(s)))) if !(d != 0) { break } @@ -113508,14 +113508,14 @@ func Xl64a(tls *TLS, x0 int64) (r uintptr) { if !(x != 0) { break } - *(*int8)(unsafe.Pointer(p)) = _digits[x&uint32(63)] + **(**int8)(__ccgo_up(p)) = _digits[x&uint32(63)] goto _1 _1: ; p = p + 1 x = x >> uint32(6) } - *(*int8)(unsafe.Pointer(p)) = 0 + **(**int8)(__ccgo_up(p)) = 0 return uintptr(unsafe.Pointer(&_s)) } @@ -113528,22 +113528,22 @@ func Xbasename(tls *TLS, s uintptr) (r uintptr) { } var i Tsize_t _ = i - if !(s != 0) || !(*(*int8)(unsafe.Pointer(s)) != 0) { + if !(s != 0) || !(**(**int8)(__ccgo_up(s)) != 0) { return __ccgo_ts + 558 } i = _strlen(tls, s) - uint64(1) for { - if !(i != 0 && int32(*(*int8)(unsafe.Pointer(s + uintptr(i)))) == int32('/')) { + if !(i != 0 && int32(**(**int8)(__ccgo_up(s + uintptr(i)))) == int32('/')) { break } - *(*int8)(unsafe.Pointer(s + uintptr(i))) = 0 + **(**int8)(__ccgo_up(s + uintptr(i))) = 0 goto _1 _1: ; i = i - 1 } for { - if !(i != 0 && int32(*(*int8)(unsafe.Pointer(s + uintptr(i-uint64(1))))) != int32('/')) { + if !(i != 0 && int32(**(**int8)(__ccgo_up(s + uintptr(i-uint64(1))))) != int32('/')) { break } goto _2 @@ -113569,12 +113569,12 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { } var i Tsize_t _ = i - if !(s != 0) || !(*(*int8)(unsafe.Pointer(s)) != 0) { + if !(s != 0) || !(**(**int8)(__ccgo_up(s)) != 0) { return __ccgo_ts + 558 } i = _strlen(tls, s) - uint64(1) for { - if !(int32(*(*int8)(unsafe.Pointer(s + uintptr(i)))) == int32('/')) { + if !(int32(**(**int8)(__ccgo_up(s + uintptr(i)))) == int32('/')) { break } if !(i != 0) { @@ -113586,7 +113586,7 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { i = i - 1 } for { - if !(int32(*(*int8)(unsafe.Pointer(s + uintptr(i)))) != int32('/')) { + if !(int32(**(**int8)(__ccgo_up(s + uintptr(i)))) != int32('/')) { break } if !(i != 0) { @@ -113598,7 +113598,7 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { i = i - 1 } for { - if !(int32(*(*int8)(unsafe.Pointer(s + uintptr(i)))) == int32('/')) { + if !(int32(**(**int8)(__ccgo_up(s + uintptr(i)))) == int32('/')) { break } if !(i != 0) { @@ -113609,7 +113609,7 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { ; i = i - 1 } - *(*int8)(unsafe.Pointer(s + uintptr(i+uint64(1)))) = 0 + **(**int8)(__ccgo_up(s + uintptr(i+uint64(1)))) = 0 return s } @@ -113700,10 +113700,10 @@ func __strcolcmp(tls *TLS, lstr uintptr, bstr uintptr) (r int32) { var i Tsize_t _ = i i = uint64(0) - for *(*int8)(unsafe.Pointer(lstr + uintptr(i))) != 0 && *(*int8)(unsafe.Pointer(bstr + uintptr(i))) != 0 && int32(*(*int8)(unsafe.Pointer(bstr + uintptr(i)))) == int32(*(*int8)(unsafe.Pointer(lstr + uintptr(i)))) { + for **(**int8)(__ccgo_up(lstr + uintptr(i))) != 0 && **(**int8)(__ccgo_up(bstr + uintptr(i))) != 0 && int32(**(**int8)(__ccgo_up(bstr + uintptr(i)))) == int32(**(**int8)(__ccgo_up(lstr + uintptr(i)))) { i = i + 1 } - if *(*int8)(unsafe.Pointer(lstr + uintptr(i))) != 0 || *(*int8)(unsafe.Pointer(bstr + uintptr(i))) != 0 && int32(*(*int8)(unsafe.Pointer(bstr + uintptr(i)))) != int32(':') { + if **(**int8)(__ccgo_up(lstr + uintptr(i))) != 0 || **(**int8)(__ccgo_up(bstr + uintptr(i))) != 0 && int32(**(**int8)(__ccgo_up(bstr + uintptr(i)))) != int32(':') { return int32(1) } return 0 @@ -113801,7 +113801,7 @@ func Xfmtmsg(tls *TLS, classification int64, label uintptr, severity int32, text } } if classification&int64(MM_PRINT) != 0 { - for cmsg != 0 && *(*int8)(unsafe.Pointer(cmsg)) != 0 { + for cmsg != 0 && **(**int8)(__ccgo_up(cmsg)) != 0 { i = 0 for { if !(msgs[i] != 0) { @@ -113877,7 +113877,7 @@ func Xfmtmsg(tls *TLS, classification int64, label uintptr, severity int32, text if ret&(Int32FromInt32(MM_NOCON)|Int32FromInt32(MM_NOMSG)) == Int32FromInt32(MM_NOCON)|Int32FromInt32(MM_NOMSG) { ret = -int32(1) } - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) return ret } @@ -113893,7 +113893,7 @@ func Xget_current_dir_name(tls *TLS) (r uintptr) { var _ /* b at bp+128 */ Tstat _ = res res = Xgetenv(tls, __ccgo_ts+682) - if res != 0 && *(*int8)(unsafe.Pointer(res)) != 0 && !(Xstat(tls, res, bp) != 0) && !(Xstat(tls, __ccgo_ts+558, bp+128) != 0) && (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev == (*(*Tstat)(unsafe.Pointer(bp + 128))).Fst_dev && (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino == (*(*Tstat)(unsafe.Pointer(bp + 128))).Fst_ino { + if res != 0 && **(**int8)(__ccgo_up(res)) != 0 && !(Xstat(tls, res, bp) != 0) && !(Xstat(tls, __ccgo_ts+558, bp+128) != 0) && (**(**Tstat)(__ccgo_up(bp))).Fst_dev == (**(**Tstat)(__ccgo_up(bp + 128))).Fst_dev && (**(**Tstat)(__ccgo_up(bp))).Fst_ino == (**(**Tstat)(__ccgo_up(bp + 128))).Fst_ino { return Xstrdup(tls, res) } return Xgetcwd(tls, uintptr(0), uint64(0)) @@ -113911,18 +113911,18 @@ func X__getauxval(tls *TLS, item uint64) (r uint64) { return Uint64FromInt8(X__libc.Fsecure) } for { - if !(*(*Tsize_t)(unsafe.Pointer(auxv)) != 0) { + if !(**(**Tsize_t)(__ccgo_up(auxv)) != 0) { break } - if *(*Tsize_t)(unsafe.Pointer(auxv)) == item { - return *(*Tsize_t)(unsafe.Pointer(auxv + 1*8)) + if **(**Tsize_t)(__ccgo_up(auxv)) == item { + return **(**Tsize_t)(__ccgo_up(auxv + 1*8)) } goto _1 _1: ; auxv = auxv + uintptr(2)*8 } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOENT) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOENT) return uint64(0) } @@ -113953,7 +113953,7 @@ func Xgetdomainname(tls *TLS, name uintptr, len1 Tsize_t) (r int32) { var _ /* temp at bp+0 */ Tutsname Xuname(tls, bp) if !(len1 != 0) || _strlen(tls, bp+325) >= len1 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } Xstrcpy(tls, name, bp+325) @@ -113974,14 +113974,14 @@ func Xgetentropy(tls *TLS, buffer uintptr, len1 Tsize_t) (r int32) { ret = 0 pos = buffer if len1 > uint64(256) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EIO) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EIO) return -int32(1) } _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp) for len1 != 0 { ret = int32(Xgetrandom(tls, pos, len1, uint32(0))) if ret < 0 { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EINTR) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EINTR) { continue } else { break @@ -113991,7 +113991,7 @@ func Xgetentropy(tls *TLS, buffer uintptr, len1 Tsize_t) (r int32) { len1 = len1 - Uint64FromInt32(ret) ret = 0 } - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) return ret } @@ -114043,46 +114043,46 @@ func Xgetopt(tls *TLS, argc int32, argv uintptr, optstring uintptr) (r int32) { X__optpos = 0 Xoptind = int32(1) } - if Xoptind >= argc || !(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) != 0) { + if Xoptind >= argc || !(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) != 0) { return -int32(1) } - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))))) != int32('-') { - if int32(*(*int8)(unsafe.Pointer(optstring))) == int32('-') { + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8))))) != int32('-') { + if int32(**(**int8)(__ccgo_up(optstring))) == int32('-') { v1 = Xoptind Xoptind = Xoptind + 1 - Xoptarg = *(*uintptr)(unsafe.Pointer(argv + uintptr(v1)*8)) + Xoptarg = **(**uintptr)(__ccgo_up(argv + uintptr(v1)*8)) return int32(1) } return -int32(1) } - if !(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1)) != 0) { + if !(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + 1)) != 0) { return -int32(1) } - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1))) == int32('-') && !(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 2)) != 0) { + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + 1))) == int32('-') && !(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + 2)) != 0) { Xoptind = Xoptind + 1 return -Int32FromInt32(1) } if !(X__optpos != 0) { X__optpos = X__optpos + 1 } - v1 = Xmbtowc(tls, bp, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))+uintptr(X__optpos), uint64(MB_LEN_MAX)) + v1 = Xmbtowc(tls, bp, **(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8))+uintptr(X__optpos), uint64(MB_LEN_MAX)) k = v1 if v1 < 0 { k = int32(1) - *(*Twchar_t)(unsafe.Pointer(bp)) = int32(0xfffd) /* replacement char */ + **(**Twchar_t)(__ccgo_up(bp)) = int32(0xfffd) /* replacement char */ } - optchar = *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + uintptr(X__optpos) + optchar = **(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + uintptr(X__optpos) X__optpos = X__optpos + k - if !(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + uintptr(X__optpos))) != 0) { + if !(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + uintptr(X__optpos))) != 0) { Xoptind = Xoptind + 1 X__optpos = 0 } - if int32(*(*int8)(unsafe.Pointer(optstring))) == int32('-') || int32(*(*int8)(unsafe.Pointer(optstring))) == int32('+') { + if int32(**(**int8)(__ccgo_up(optstring))) == int32('-') || int32(**(**int8)(__ccgo_up(optstring))) == int32('+') { optstring = optstring + 1 } i = 0 - *(*Twchar_t)(unsafe.Pointer(bp + 4)) = 0 - for cond := true; cond; cond = l != 0 && *(*Twchar_t)(unsafe.Pointer(bp + 4)) != *(*Twchar_t)(unsafe.Pointer(bp)) { + **(**Twchar_t)(__ccgo_up(bp + 4)) = 0 + for cond := true; cond; cond = l != 0 && **(**Twchar_t)(__ccgo_up(bp + 4)) != **(**Twchar_t)(__ccgo_up(bp)) { l = Xmbtowc(tls, bp+4, optstring+uintptr(i), uint64(MB_LEN_MAX)) if l > 0 { i = i + l @@ -114090,36 +114090,36 @@ func Xgetopt(tls *TLS, argc int32, argv uintptr, optstring uintptr) (r int32) { i = i + 1 } } - if *(*Twchar_t)(unsafe.Pointer(bp + 4)) != *(*Twchar_t)(unsafe.Pointer(bp)) || *(*Twchar_t)(unsafe.Pointer(bp)) == int32(':') { - Xoptopt = *(*Twchar_t)(unsafe.Pointer(bp)) - if int32(*(*int8)(unsafe.Pointer(optstring))) != int32(':') && Xopterr != 0 { - X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), __ccgo_ts+686, optchar, Uint64FromInt32(k)) + if **(**Twchar_t)(__ccgo_up(bp + 4)) != **(**Twchar_t)(__ccgo_up(bp)) || **(**Twchar_t)(__ccgo_up(bp)) == int32(':') { + Xoptopt = **(**Twchar_t)(__ccgo_up(bp)) + if int32(**(**int8)(__ccgo_up(optstring))) != int32(':') && Xopterr != 0 { + X__getopt_msg(tls, **(**uintptr)(__ccgo_up(argv)), __ccgo_ts+686, optchar, Uint64FromInt32(k)) } return int32('?') } - if int32(*(*int8)(unsafe.Pointer(optstring + uintptr(i)))) == int32(':') { + if int32(**(**int8)(__ccgo_up(optstring + uintptr(i)))) == int32(':') { Xoptarg = uintptr(0) - if int32(*(*int8)(unsafe.Pointer(optstring + uintptr(i+int32(1))))) != int32(':') || X__optpos != 0 { + if int32(**(**int8)(__ccgo_up(optstring + uintptr(i+int32(1))))) != int32(':') || X__optpos != 0 { v1 = Xoptind Xoptind = Xoptind + 1 - Xoptarg = *(*uintptr)(unsafe.Pointer(argv + uintptr(v1)*8)) + Xoptarg = **(**uintptr)(__ccgo_up(argv + uintptr(v1)*8)) if X__optpos != 0 { Xoptarg = Xoptarg + uintptr(X__optpos) } X__optpos = 0 } if Xoptind > argc { - Xoptopt = *(*Twchar_t)(unsafe.Pointer(bp)) - if int32(*(*int8)(unsafe.Pointer(optstring))) == int32(':') { + Xoptopt = **(**Twchar_t)(__ccgo_up(bp)) + if int32(**(**int8)(__ccgo_up(optstring))) == int32(':') { return int32(':') } if Xopterr != 0 { - X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), __ccgo_ts+710, optchar, Uint64FromInt32(k)) + X__getopt_msg(tls, **(**uintptr)(__ccgo_up(argv)), __ccgo_ts+710, optchar, Uint64FromInt32(k)) } return int32('?') } } - return *(*Twchar_t)(unsafe.Pointer(bp)) + return **(**Twchar_t)(__ccgo_up(bp)) } func X__posix_getopt(tls *TLS, argc int32, argv uintptr, optstring uintptr) (r int32) { @@ -114146,19 +114146,19 @@ func _permute(tls *TLS, argv uintptr, dest int32, src int32) { var i int32 _, _, _ = av, i, tmp av = argv - tmp = *(*uintptr)(unsafe.Pointer(av + uintptr(src)*8)) + tmp = **(**uintptr)(__ccgo_up(av + uintptr(src)*8)) i = src for { if !(i > dest) { break } - *(*uintptr)(unsafe.Pointer(av + uintptr(i)*8)) = *(*uintptr)(unsafe.Pointer(av + uintptr(i-int32(1))*8)) + **(**uintptr)(__ccgo_up(av + uintptr(i)*8)) = **(**uintptr)(__ccgo_up(av + uintptr(i-int32(1))*8)) goto _1 _1: ; i = i - 1 } - *(*uintptr)(unsafe.Pointer(av + uintptr(dest)*8)) = tmp + **(**uintptr)(__ccgo_up(av + uintptr(dest)*8)) = tmp } func ___getopt_long(tls *TLS, argc int32, argv uintptr, optstring uintptr, longopts uintptr, idx uintptr, longonly int32) (r int32) { @@ -114169,17 +114169,17 @@ func ___getopt_long(tls *TLS, argc int32, argv uintptr, optstring uintptr, longo X__optpos = 0 Xoptind = int32(1) } - if Xoptind >= argc || !(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) != 0) { + if Xoptind >= argc || !(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) != 0) { return -int32(1) } skipped = Xoptind - if int32(*(*int8)(unsafe.Pointer(optstring))) != int32('+') && int32(*(*int8)(unsafe.Pointer(optstring))) != int32('-') { + if int32(**(**int8)(__ccgo_up(optstring))) != int32('+') && int32(**(**int8)(__ccgo_up(optstring))) != int32('-') { i = Xoptind for { - if i >= argc || !(*(*uintptr)(unsafe.Pointer(argv + uintptr(i)*8)) != 0) { + if i >= argc || !(**(**uintptr)(__ccgo_up(argv + uintptr(i)*8)) != 0) { return -int32(1) } - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(i)*8))))) == int32('-') && *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(i)*8)) + 1)) != 0 { + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(i)*8))))) == int32('-') && **(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(i)*8)) + 1)) != 0 { break } goto _1 @@ -114214,31 +114214,31 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, var cnt, colon, i, j, l, match, v2 int32 _, _, _, _, _, _, _, _, _, _, _, _ = arg, cnt, colon, i, j, l, match, name, opt, start, v2, v5 Xoptarg = uintptr(0) - if longopts != 0 && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))))) == int32('-') && (longonly != 0 && *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1)) != 0 && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1))) != int32('-') || int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1))) == int32('-') && *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 2)) != 0) { - colon = BoolInt32(int32(*(*int8)(unsafe.Pointer(optstring + BoolUintptr(int32(*(*int8)(unsafe.Pointer(optstring))) == int32('+') || int32(*(*int8)(unsafe.Pointer(optstring))) == int32('-'))))) == int32(':')) - start = *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + uintptr(1) + if longopts != 0 && int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8))))) == int32('-') && (longonly != 0 && **(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + 1)) != 0 && int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + 1))) != int32('-') || int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + 1))) == int32('-') && **(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + 2)) != 0) { + colon = BoolInt32(int32(**(**int8)(__ccgo_up(optstring + BoolUintptr(int32(**(**int8)(__ccgo_up(optstring))) == int32('+') || int32(**(**int8)(__ccgo_up(optstring))) == int32('-'))))) == int32(':')) + start = **(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + uintptr(1) v2 = Int32FromInt32(0) i = v2 cnt = v2 for { - if !((*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname != 0) { + if !((**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fname != 0) { break } - name = (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname + name = (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fname opt = start - if int32(*(*int8)(unsafe.Pointer(opt))) == int32('-') { + if int32(**(**int8)(__ccgo_up(opt))) == int32('-') { opt = opt + 1 } - for *(*int8)(unsafe.Pointer(opt)) != 0 && int32(*(*int8)(unsafe.Pointer(opt))) != int32('=') && int32(*(*int8)(unsafe.Pointer(opt))) == int32(*(*int8)(unsafe.Pointer(name))) { + for **(**int8)(__ccgo_up(opt)) != 0 && int32(**(**int8)(__ccgo_up(opt))) != int32('=') && int32(**(**int8)(__ccgo_up(opt))) == int32(**(**int8)(__ccgo_up(name))) { name = name + 1 opt = opt + 1 } - if *(*int8)(unsafe.Pointer(opt)) != 0 && int32(*(*int8)(unsafe.Pointer(opt))) != int32('=') { + if **(**int8)(__ccgo_up(opt)) != 0 && int32(**(**int8)(__ccgo_up(opt))) != int32('=') { goto _1 } arg = opt match = i - if !(*(*int8)(unsafe.Pointer(name)) != 0) { + if !(**(**int8)(__ccgo_up(name)) != 0) { cnt = int32(1) break } @@ -114252,12 +114252,12 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, l = int32(int64(arg) - int64(start)) i = 0 for { - if !(*(*int8)(unsafe.Pointer(optstring + uintptr(i))) != 0) { + if !(**(**int8)(__ccgo_up(optstring + uintptr(i))) != 0) { break } j = 0 for { - if !(j < l && int32(*(*int8)(unsafe.Pointer(start + uintptr(j)))) == int32(*(*int8)(unsafe.Pointer(optstring + uintptr(i+j))))) { + if !(j < l && int32(**(**int8)(__ccgo_up(start + uintptr(j)))) == int32(**(**int8)(__ccgo_up(optstring + uintptr(i+j))))) { break } goto _4 @@ -114279,44 +114279,44 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, i = match opt = arg Xoptind = Xoptind + 1 - if int32(*(*int8)(unsafe.Pointer(opt))) == int32('=') { - if !((*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fhas_arg != 0) { - Xoptopt = (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fval + if int32(**(**int8)(__ccgo_up(opt))) == int32('=') { + if !((**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fhas_arg != 0) { + Xoptopt = (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fval if colon != 0 || !(Xopterr != 0) { return int32('?') } - X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), __ccgo_ts+742, (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname, _strlen(tls, (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname)) + X__getopt_msg(tls, **(**uintptr)(__ccgo_up(argv)), __ccgo_ts+742, (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fname, _strlen(tls, (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fname)) return int32('?') } Xoptarg = opt + uintptr(1) } else { - if (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fhas_arg == int32(required_argument) { - v5 = *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + if (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fhas_arg == int32(required_argument) { + v5 = **(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) Xoptarg = v5 if !(v5 != 0) { - Xoptopt = (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fval + Xoptopt = (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fval if colon != 0 { return int32(':') } if !(Xopterr != 0) { return int32('?') } - X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), __ccgo_ts+710, (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname, _strlen(tls, (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname)) + X__getopt_msg(tls, **(**uintptr)(__ccgo_up(argv)), __ccgo_ts+710, (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fname, _strlen(tls, (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fname)) return int32('?') } Xoptind = Xoptind + 1 } } if idx != 0 { - *(*int32)(unsafe.Pointer(idx)) = i + **(**int32)(__ccgo_up(idx)) = i } - if (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fflag != 0 { - *(*int32)(unsafe.Pointer((*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fflag)) = (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fval + if (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fflag != 0 { + **(**int32)(__ccgo_up((**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fflag)) = (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fval return 0 } - return (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fval + return (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fval } - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1))) == int32('-') { + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + 1))) == int32('-') { Xoptopt = 0 if !(colon != 0) && Xopterr != 0 { if cnt != 0 { @@ -114324,7 +114324,7 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, } else { v5 = __ccgo_ts + 686 } - X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), v5, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))+uintptr(2), _strlen(tls, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))+uintptr(2))) + X__getopt_msg(tls, **(**uintptr)(__ccgo_up(argv)), v5, **(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8))+uintptr(2), _strlen(tls, **(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8))+uintptr(2))) } Xoptind = Xoptind + 1 return int32('?') @@ -114414,12 +114414,12 @@ func Xgetrusage(tls *TLS, who int32, ru uintptr) (r1 int32) { if !(r != 0) && Bool(uint64(8) > uint64(8)) { Xmemcpy(tls, bp, dest, Uint64FromInt32(4)*Uint64FromInt64(8)) (*Trusage)(unsafe.Pointer(ru)).Fru_utime = Ttimeval{ - Ftv_sec: (*(*[4]int64)(unsafe.Pointer(bp)))[0], - Ftv_usec: (*(*[4]int64)(unsafe.Pointer(bp)))[int32(1)], + Ftv_sec: (**(**[4]int64)(__ccgo_up(bp)))[0], + Ftv_usec: (**(**[4]int64)(__ccgo_up(bp)))[int32(1)], } (*Trusage)(unsafe.Pointer(ru)).Fru_stime = Ttimeval{ - Ftv_sec: (*(*[4]int64)(unsafe.Pointer(bp)))[int32(2)], - Ftv_usec: (*(*[4]int64)(unsafe.Pointer(bp)))[int32(3)], + Ftv_sec: (**(**[4]int64)(__ccgo_up(bp)))[int32(2)], + Ftv_usec: (**(**[4]int64)(__ccgo_up(bp)))[int32(3)], } } return int32(X__syscall_ret(tls, Uint64FromInt32(r))) @@ -114434,30 +114434,30 @@ func Xgetsubopt(tls *TLS, opt uintptr, keys uintptr, val uintptr) (r int32) { var l Tsize_t var s, v1, v2 uintptr _, _, _, _, _ = i, l, s, v1, v2 - s = *(*uintptr)(unsafe.Pointer(opt)) - *(*uintptr)(unsafe.Pointer(val)) = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(opt)) = Xstrchr(tls, s, int32(',')) - if *(*uintptr)(unsafe.Pointer(opt)) != 0 { + s = **(**uintptr)(__ccgo_up(opt)) + **(**uintptr)(__ccgo_up(val)) = UintptrFromInt32(0) + **(**uintptr)(__ccgo_up(opt)) = Xstrchr(tls, s, int32(',')) + if **(**uintptr)(__ccgo_up(opt)) != 0 { v2 = opt v1 = *(*uintptr)(unsafe.Pointer(v2)) *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(v2)) + 1 - *(*int8)(unsafe.Pointer(v1)) = 0 + **(**int8)(__ccgo_up(v1)) = 0 } else { - *(*uintptr)(unsafe.Pointer(opt)) = s + uintptr(_strlen(tls, s)) + **(**uintptr)(__ccgo_up(opt)) = s + uintptr(_strlen(tls, s)) } i = 0 for { - if !(*(*uintptr)(unsafe.Pointer(keys + uintptr(i)*8)) != 0) { + if !(**(**uintptr)(__ccgo_up(keys + uintptr(i)*8)) != 0) { break } - l = _strlen(tls, *(*uintptr)(unsafe.Pointer(keys + uintptr(i)*8))) - if Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(keys + uintptr(i)*8)), s, l) != 0 { + l = _strlen(tls, **(**uintptr)(__ccgo_up(keys + uintptr(i)*8))) + if Xstrncmp(tls, **(**uintptr)(__ccgo_up(keys + uintptr(i)*8)), s, l) != 0 { goto _3 } - if int32(*(*int8)(unsafe.Pointer(s + uintptr(l)))) == int32('=') { - *(*uintptr)(unsafe.Pointer(val)) = s + uintptr(l) + uintptr(1) + if int32(**(**int8)(__ccgo_up(s + uintptr(l)))) == int32('=') { + **(**uintptr)(__ccgo_up(val)) = s + uintptr(l) + uintptr(1) } else { - if *(*int8)(unsafe.Pointer(s + uintptr(l))) != 0 { + if **(**int8)(__ccgo_up(s + uintptr(l))) != 0 { goto _3 } } @@ -114746,7 +114746,7 @@ func _convert_ioctl_struct(tls *TLS, map1 uintptr, old uintptr, new1 uintptr, di if !(i < Int32FromUint8((*Tioctl_compat_map)(unsafe.Pointer(map1)).Fnoffs)) { break } - ts_offset = Int32FromUint8(*(*uint8)(unsafe.Pointer(map1 + 12 + uintptr(i)))) + ts_offset = Int32FromUint8(**(**uint8)(__ccgo_up(map1 + 12 + uintptr(i)))) len1 = ts_offset - old_offset if dir == int32(W) { Xmemcpy(tls, old+uintptr(old_offset), new1+uintptr(new_offset), Uint64FromInt32(len1)) @@ -114764,11 +114764,11 @@ func _convert_ioctl_struct(tls *TLS, map1 uintptr, old uintptr, new1 uintptr, di new_offset = new_offset + (align-int32(1))&-new_offset if dir == int32(W) { Xmemcpy(tls, bp, new1+uintptr(new_offset), uint64(8)) - *(*int64)(unsafe.Pointer(bp + 8)) = *(*int64)(unsafe.Pointer(bp)) + **(**int64)(__ccgo_up(bp + 8)) = int64(**(**int64)(__ccgo_up(bp))) Xmemcpy(tls, old+uintptr(old_offset), bp+8, uint64(8)) } else { Xmemcpy(tls, bp+8, old+uintptr(old_offset), uint64(8)) - *(*int64)(unsafe.Pointer(bp)) = *(*int64)(unsafe.Pointer(bp + 8)) + **(**int64)(__ccgo_up(bp)) = int64(**(**int64)(__ccgo_up(bp + 8))) Xmemcpy(tls, new1+uintptr(new_offset), bp, uint64(8)) } new_offset = Int32FromUint64(uint64(new_offset) + Uint64FromInt64(8)) @@ -114846,31 +114846,31 @@ func Xlockf(tls *TLS, fd int32, op int32, size Toff_t) (r int32) { bp := tls.Alloc(48) defer tls.Free(48) var _ /* l at bp+0 */ Tflock - *(*Tflock)(unsafe.Pointer(bp)) = Tflock{ + **(**Tflock)(__ccgo_up(bp)) = Tflock{ Fl_type: int16(F_WRLCK), Fl_whence: int16(1), Fl_len: size, } switch op { case int32(F_TEST): - (*(*Tflock)(unsafe.Pointer(bp))).Fl_type = F_RDLCK + (**(**Tflock)(__ccgo_up(bp))).Fl_type = F_RDLCK if Xfcntl(tls, fd, int32(F_GETLK), VaList(bp+40, bp)) < 0 { return -int32(1) } - if int32((*(*Tflock)(unsafe.Pointer(bp))).Fl_type) == int32(F_UNLCK) || (*(*Tflock)(unsafe.Pointer(bp))).Fl_pid == Xgetpid(tls) { + if int32((**(**Tflock)(__ccgo_up(bp))).Fl_type) == int32(F_UNLCK) || (**(**Tflock)(__ccgo_up(bp))).Fl_pid == Xgetpid(tls) { return 0 } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EACCES) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EACCES) return -int32(1) case F_ULOCK: - (*(*Tflock)(unsafe.Pointer(bp))).Fl_type = int16(F_UNLCK) + (**(**Tflock)(__ccgo_up(bp))).Fl_type = int16(F_UNLCK) fallthrough case int32(F_TLOCK): return Xfcntl(tls, fd, int32(F_SETLK), VaList(bp+40, bp)) case int32(F_LOCK): return Xfcntl(tls, fd, int32(F_SETLKW), VaList(bp+40, bp)) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } @@ -114972,23 +114972,23 @@ func _unescape_ent(tls *TLS, beg uintptr) (r uintptr) { _, _, _, _, _, _, _ = cval, dest, i, src, val, v1, v2 dest = beg src = beg - for *(*int8)(unsafe.Pointer(src)) != 0 { + for **(**int8)(__ccgo_up(src)) != 0 { cval = uint8(0) - if int32(*(*int8)(unsafe.Pointer(src))) != int32('\\') { + if int32(**(**int8)(__ccgo_up(src))) != int32('\\') { v1 = dest dest = dest + 1 v2 = src src = src + 1 - *(*int8)(unsafe.Pointer(v1)) = *(*int8)(unsafe.Pointer(v2)) + **(**int8)(__ccgo_up(v1)) = **(**int8)(__ccgo_up(v2)) continue } - if int32(*(*int8)(unsafe.Pointer(src + 1))) == int32('\\') { + if int32(**(**int8)(__ccgo_up(src + 1))) == int32('\\') { src = src + 1 v1 = dest dest = dest + 1 v2 = src src = src + 1 - *(*int8)(unsafe.Pointer(v1)) = *(*int8)(unsafe.Pointer(v2)) + **(**int8)(__ccgo_up(v1)) = **(**int8)(__ccgo_up(v2)) continue } val = src + uintptr(1) @@ -114997,11 +114997,11 @@ func _unescape_ent(tls *TLS, beg uintptr) (r uintptr) { if !(i < int32(3)) { break } - if int32(*(*int8)(unsafe.Pointer(val))) >= int32('0') && int32(*(*int8)(unsafe.Pointer(val))) <= int32('7') { + if int32(**(**int8)(__ccgo_up(val))) >= int32('0') && int32(**(**int8)(__ccgo_up(val))) <= int32('7') { cval = Uint8FromInt32(int32(cval) << Int32FromInt32(3)) v1 = val val = val + 1 - cval = Uint8FromInt32(int32(cval) + (int32(*(*int8)(unsafe.Pointer(v1))) - Int32FromUint8('0'))) + cval = Uint8FromInt32(int32(cval) + (int32(**(**int8)(__ccgo_up(v1))) - Int32FromUint8('0'))) } else { break } @@ -115013,17 +115013,17 @@ func _unescape_ent(tls *TLS, beg uintptr) (r uintptr) { if cval != 0 { v1 = dest dest = dest + 1 - *(*int8)(unsafe.Pointer(v1)) = Int8FromUint8(cval) + **(**int8)(__ccgo_up(v1)) = Int8FromUint8(cval) src = val } else { v1 = dest dest = dest + 1 v2 = src src = src + 1 - *(*int8)(unsafe.Pointer(v1)) = *(*int8)(unsafe.Pointer(v2)) + **(**int8)(__ccgo_up(v1)) = **(**int8)(__ccgo_up(v2)) } } - *(*int8)(unsafe.Pointer(dest)) = 0 + **(**int8)(__ccgo_up(dest)) = 0 return beg } @@ -115041,7 +115041,7 @@ func Xgetmntent_r(tls *TLS, f uintptr, mnt uintptr, linebuf uintptr, buflen int3 use_internal = BoolInt32(linebuf == uintptr(unsafe.Pointer(&_internal_buf))) (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_freq = 0 (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_passno = 0 - for cond := true; cond; cond = int32(*(*int8)(unsafe.Pointer(linebuf + uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[0])))) == int32('#') || Uint64FromInt32((*(*[8]int32)(unsafe.Pointer(bp)))[int32(1)]) == len1 { + for cond := true; cond; cond = int32(**(**int8)(__ccgo_up(linebuf + uintptr((**(**[8]int32)(__ccgo_up(bp)))[0])))) == int32('#') || Uint64FromInt32((**(**[8]int32)(__ccgo_up(bp)))[int32(1)]) == len1 { if use_internal != 0 { Xgetline(tls, uintptr(unsafe.Pointer(&_internal_buf)), uintptr(unsafe.Pointer(&_internal_bufsize)), f) linebuf = _internal_buf @@ -115053,7 +115053,7 @@ func Xgetmntent_r(tls *TLS, f uintptr, mnt uintptr, linebuf uintptr, buflen int3 } if !(Xstrchr(tls, linebuf, int32('\n')) != 0) { Xfscanf(tls, f, __ccgo_ts+803, 0) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return uintptr(0) } len1 = _strlen(tls, linebuf) @@ -115065,7 +115065,7 @@ func Xgetmntent_r(tls *TLS, f uintptr, mnt uintptr, linebuf uintptr, buflen int3 if !(i < Uint64FromInt64(32)/Uint64FromInt64(4)) { break } - (*(*[8]int32)(unsafe.Pointer(bp)))[i] = Int32FromUint64(len1) + (**(**[8]int32)(__ccgo_up(bp)))[i] = Int32FromUint64(len1) goto _1 _1: ; @@ -115073,14 +115073,14 @@ func Xgetmntent_r(tls *TLS, f uintptr, mnt uintptr, linebuf uintptr, buflen int3 } Xsscanf(tls, linebuf, __ccgo_ts+815, VaList(bp+40, bp, bp+uintptr(1)*4, bp+uintptr(2)*4, bp+uintptr(3)*4, bp+uintptr(4)*4, bp+uintptr(5)*4, bp+uintptr(6)*4, bp+uintptr(7)*4, mnt+32, mnt+36)) } - *(*int8)(unsafe.Pointer(linebuf + uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(1)]))) = 0 - *(*int8)(unsafe.Pointer(linebuf + uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(3)]))) = 0 - *(*int8)(unsafe.Pointer(linebuf + uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(5)]))) = 0 - *(*int8)(unsafe.Pointer(linebuf + uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(7)]))) = 0 - (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_fsname = _unescape_ent(tls, linebuf+uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[0])) - (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_dir = _unescape_ent(tls, linebuf+uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(2)])) - (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_type = _unescape_ent(tls, linebuf+uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(4)])) - (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_opts = _unescape_ent(tls, linebuf+uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(6)])) + **(**int8)(__ccgo_up(linebuf + uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(1)]))) = 0 + **(**int8)(__ccgo_up(linebuf + uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(3)]))) = 0 + **(**int8)(__ccgo_up(linebuf + uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(5)]))) = 0 + **(**int8)(__ccgo_up(linebuf + uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(7)]))) = 0 + (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_fsname = _unescape_ent(tls, linebuf+uintptr((**(**[8]int32)(__ccgo_up(bp)))[0])) + (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_dir = _unescape_ent(tls, linebuf+uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(2)])) + (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_type = _unescape_ent(tls, linebuf+uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(4)])) + (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_opts = _unescape_ent(tls, linebuf+uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(6)])) return mnt } @@ -115137,39 +115137,39 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag var _ /* st at bp+0 */ Tstat _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, de, dfd, err, j, k, l, r, type1, v1, v10, v2, v3, v8 l = _strlen(tls, path) - if l != 0 && int32(*(*int8)(unsafe.Pointer(path + uintptr(l-uint64(1))))) == int32('/') { + if l != 0 && int32(**(**int8)(__ccgo_up(path + uintptr(l-uint64(1))))) == int32('/') { v1 = l - uint64(1) } else { v1 = l } j = v1 v2 = Uint64FromInt32(0) - (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino = v2 - (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev = v2 + (**(**Tstat)(__ccgo_up(bp))).Fst_ino = v2 + (**(**Tstat)(__ccgo_up(bp))).Fst_dev = v2 if flags&int32(FTW_PHYS) != 0 { v3 = Xlstat(tls, path, bp) } else { v3 = BoolInt32(Xstat(tls, path, bp) < 0) } if v3 != 0 { - if !(flags&Int32FromInt32(FTW_PHYS) != 0) && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENOENT) && !(Xlstat(tls, path, bp) != 0) { + if !(flags&Int32FromInt32(FTW_PHYS) != 0) && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENOENT) && !(Xlstat(tls, path, bp) != 0) { type1 = int32(FTW_SLN) } else { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(EACCES) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(EACCES) { return -int32(1) } else { type1 = int32(FTW_NS) } } } else { - if (*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFDIR) { + if (**(**Tstat)(__ccgo_up(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFDIR) { if flags&int32(FTW_DEPTH) != 0 { type1 = int32(FTW_DP) } else { type1 = int32(FTW_D) } } else { - if (*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { + if (**(**Tstat)(__ccgo_up(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { if flags&int32(FTW_PHYS) != 0 { type1 = int32(FTW_SL) } else { @@ -115180,26 +115180,26 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag } } } - if flags&int32(FTW_MOUNT) != 0 && h != 0 && type1 != int32(FTW_NS) && (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev != (*Thistory)(unsafe.Pointer(h)).Fdev { + if flags&int32(FTW_MOUNT) != 0 && h != 0 && type1 != int32(FTW_NS) && (**(**Tstat)(__ccgo_up(bp))).Fst_dev != (*Thistory)(unsafe.Pointer(h)).Fdev { return 0 } - (*(*Thistory)(unsafe.Pointer(bp + 128))).Fchain = h - (*(*Thistory)(unsafe.Pointer(bp + 128))).Fdev = (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev - (*(*Thistory)(unsafe.Pointer(bp + 128))).Fino = (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino + (**(**Thistory)(__ccgo_up(bp + 128))).Fchain = h + (**(**Thistory)(__ccgo_up(bp + 128))).Fdev = (**(**Tstat)(__ccgo_up(bp))).Fst_dev + (**(**Thistory)(__ccgo_up(bp + 128))).Fino = (**(**Tstat)(__ccgo_up(bp))).Fst_ino if h != 0 { v3 = (*Thistory)(unsafe.Pointer(h)).Flevel + int32(1) } else { v3 = 0 } - (*(*Thistory)(unsafe.Pointer(bp + 128))).Flevel = v3 - (*(*Thistory)(unsafe.Pointer(bp + 128))).Fbase = Int32FromUint64(j + uint64(1)) - (*(*TFTW)(unsafe.Pointer(bp + 160))).Flevel = (*(*Thistory)(unsafe.Pointer(bp + 128))).Flevel + (**(**Thistory)(__ccgo_up(bp + 128))).Flevel = v3 + (**(**Thistory)(__ccgo_up(bp + 128))).Fbase = Int32FromUint64(j + uint64(1)) + (**(**TFTW)(__ccgo_up(bp + 160))).Flevel = (**(**Thistory)(__ccgo_up(bp + 128))).Flevel if h != 0 { - (*(*TFTW)(unsafe.Pointer(bp + 160))).Fbase = (*Thistory)(unsafe.Pointer(h)).Fbase + (**(**TFTW)(__ccgo_up(bp + 160))).Fbase = (*Thistory)(unsafe.Pointer(h)).Fbase } else { k = j for { - if !(k != 0 && int32(*(*int8)(unsafe.Pointer(path + uintptr(k)))) == int32('/')) { + if !(k != 0 && int32(**(**int8)(__ccgo_up(path + uintptr(k)))) == int32('/')) { break } goto _5 @@ -115208,7 +115208,7 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag k = k - 1 } for { - if !(k != 0 && int32(*(*int8)(unsafe.Pointer(path + uintptr(k-uint64(1))))) != int32('/')) { + if !(k != 0 && int32(**(**int8)(__ccgo_up(path + uintptr(k-uint64(1))))) != int32('/')) { break } goto _6 @@ -115216,11 +115216,11 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag ; k = k - 1 } - (*(*TFTW)(unsafe.Pointer(bp + 160))).Fbase = Int32FromUint64(k) + (**(**TFTW)(__ccgo_up(bp + 160))).Fbase = Int32FromUint64(k) } if type1 == int32(FTW_D) || type1 == int32(FTW_DP) { dfd = Xopen(tls, path, O_RDONLY, 0) - err = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + err = **(**int32)(__ccgo_up(X__errno_location(tls))) if dfd < 0 && err == int32(EACCES) { type1 = int32(FTW_DNR) } @@ -115239,7 +115239,7 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag if !(h != 0) { break } - if (*Thistory)(unsafe.Pointer(h)).Fdev == (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev && (*Thistory)(unsafe.Pointer(h)).Fino == (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino { + if (*Thistory)(unsafe.Pointer(h)).Fdev == (**(**Tstat)(__ccgo_up(bp))).Fst_dev && (*Thistory)(unsafe.Pointer(h)).Fino == (**(**Tstat)(__ccgo_up(bp))).Fst_ino { return 0 } goto _9 @@ -115249,7 +115249,7 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag } if (type1 == int32(FTW_D) || type1 == int32(FTW_DP)) && fd_limit != 0 { if dfd < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = err + **(**int32)(__ccgo_up(X__errno_location(tls))) = err return -int32(1) } d = Xfdopendir(tls, dfd) @@ -115260,15 +115260,15 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag if !(v10 != 0) { break } - if int32(*(*int8)(unsafe.Pointer(de + 19))) == int32('.') && (!(*(*int8)(unsafe.Pointer(de + 19 + 1)) != 0) || int32(*(*int8)(unsafe.Pointer(de + 19 + 1))) == int32('.') && !(*(*int8)(unsafe.Pointer(de + 19 + 2)) != 0)) { + if int32(**(**int8)(__ccgo_up(de + 19))) == int32('.') && (!(**(**int8)(__ccgo_up(de + 19 + 1)) != 0) || int32(**(**int8)(__ccgo_up(de + 19 + 1))) == int32('.') && !(**(**int8)(__ccgo_up(de + 19 + 2)) != 0)) { continue } if _strlen(tls, de+19) >= uint64(PATH_MAX)-l { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENAMETOOLONG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENAMETOOLONG) Xclosedir(tls, d) return -int32(1) } - *(*int8)(unsafe.Pointer(path + uintptr(j))) = int8('/') + **(**int8)(__ccgo_up(path + uintptr(j))) = int8('/') Xstrcpy(tls, path+uintptr(j)+uintptr(1), de+19) v3 = _do_nftw(tls, path, __ccgo_fp_fn, fd_limit-int32(1), flags, bp+128) r = v3 @@ -115283,7 +115283,7 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag return -int32(1) } } - *(*int8)(unsafe.Pointer(path + uintptr(l))) = 0 + **(**int8)(__ccgo_up(path + uintptr(l))) = 0 if v8 = flags&int32(FTW_DEPTH) != 0; v8 { v3 = (*(*func(*TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_fn})))(tls, path, bp, type1, bp+160) r = v3 @@ -115313,13 +115313,13 @@ func Xnftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flags i } l = _strlen(tls, path) if l > uint64(PATH_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENAMETOOLONG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENAMETOOLONG) return -int32(1) } Xmemcpy(tls, bp+4, path, l+uint64(1)) _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp) r = _do_nftw(tls, bp+4, __ccgo_fp_fn, fd_limit, flags, UintptrFromInt32(0)) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) return r } @@ -115337,7 +115337,7 @@ func Xopenpty(tls *TLS, pm uintptr, ps uintptr, name uintptr, tio uintptr, ws ui var _ /* cs at bp+4 */ int32 var _ /* n at bp+0 */ int32 _, _, _ = m, s, v1 - *(*int32)(unsafe.Pointer(bp)) = 0 + **(**int32)(__ccgo_up(bp)) = 0 m = Xopen(tls, __ccgo_ts+889, Int32FromInt32(O_RDWR)|Int32FromInt32(O_NOCTTY), 0) if m < 0 { return -int32(1) @@ -115349,7 +115349,7 @@ func Xopenpty(tls *TLS, pm uintptr, ps uintptr, name uintptr, tio uintptr, ws ui if !(name != 0) { name = bp + 8 } - Xsnprintf(tls, name, uint64(20), __ccgo_ts+899, VaList(bp+40, *(*int32)(unsafe.Pointer(bp)))) + Xsnprintf(tls, name, uint64(20), __ccgo_ts+899, VaList(bp+40, **(**int32)(__ccgo_up(bp)))) v1 = Xopen(tls, name, Int32FromInt32(O_RDWR)|Int32FromInt32(O_NOCTTY), 0) s = v1 if v1 < 0 { @@ -115361,15 +115361,15 @@ func Xopenpty(tls *TLS, pm uintptr, ps uintptr, name uintptr, tio uintptr, ws ui if ws != 0 { Xioctl(tls, s, int32(TIOCSWINSZ), VaList(bp+40, ws)) } - *(*int32)(unsafe.Pointer(pm)) = m - *(*int32)(unsafe.Pointer(ps)) = s - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 4)), uintptr(0)) + **(**int32)(__ccgo_up(pm)) = m + **(**int32)(__ccgo_up(ps)) = s + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 4)), uintptr(0)) return 0 goto fail fail: ; Xclose(tls, m) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 4)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 4)), uintptr(0)) return -int32(1) } @@ -115382,7 +115382,7 @@ func Xptsname(tls *TLS, fd int32) (r uintptr) { _ = err err = X__ptsname_r(tls, fd, uintptr(unsafe.Pointer(&_buf2)), uint64(22)) if err != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = err + **(**int32)(__ccgo_up(X__errno_location(tls))) = err return uintptr(0) } return uintptr(unsafe.Pointer(&_buf2)) @@ -115398,8 +115398,8 @@ func Xposix_openpt(tls *TLS, flags int32) (r1 int32) { var r int32 _ = r r = Xopen(tls, __ccgo_ts+889, flags, 0) - if r < 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENOSPC) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EAGAIN) + if r < 0 && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENOSPC) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EAGAIN) } return r } @@ -115420,7 +115420,7 @@ func Xunlockpt(tls *TLS, fd int32) (r int32) { bp := tls.Alloc(32) defer tls.Free(32) var _ /* unlock at bp+0 */ int32 - *(*int32)(unsafe.Pointer(bp)) = 0 + **(**int32)(__ccgo_up(bp)) = 0 return Xioctl(tls, fd, int32(TIOCSPTLCK), VaList(bp+16, bp)) } @@ -115442,7 +115442,7 @@ func X__ptsname_r(tls *TLS, fd int32, buf uintptr, len1 Tsize_t) (r int32) { if v1 != 0 { return -err } - if Uint64FromInt32(Xsnprintf(tls, buf, len1, __ccgo_ts+899, VaList(bp+16, *(*int32)(unsafe.Pointer(bp))))) >= len1 { + if Uint64FromInt32(Xsnprintf(tls, buf, len1, __ccgo_ts+899, VaList(bp+16, **(**int32)(__ccgo_up(bp))))) >= len1 { return int32(ERANGE) } return 0 @@ -115460,7 +115460,7 @@ func _slash_len(tls *TLS, s uintptr) (r Tsize_t) { var s0 uintptr _ = s0 s0 = s - for int32(*(*int8)(unsafe.Pointer(s))) == int32('/') { + for int32(**(**int8)(__ccgo_up(s))) == int32('/') { s = s + 1 } return Uint64FromInt64(int64(s) - int64(s0)) @@ -115484,12 +115484,12 @@ func Xrealpath(tls *TLS, filename uintptr, resolved uintptr) (r uintptr) { nup = uint64(0) check_dir = 0 if !(filename != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } l = Xstrnlen(tls, filename, uint64(4097)) if !(l != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOENT) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOENT) return uintptr(0) } if l >= uint64(PATH_MAX) { @@ -115509,19 +115509,19 @@ _3: ; /* If stack starts with /, the whole component is / or // * and the output state must be reset. */ - if int32((*(*[4097]int8)(unsafe.Pointer(bp)))[p]) == int32('/') { + if int32((**(**[4097]int8)(__ccgo_up(bp)))[p]) == int32('/') { check_dir = 0 nup = uint64(0) q = uint64(0) v4 = q q = q + 1 - (*(*[4096]int8)(unsafe.Pointer(bp + 4097)))[v4] = int8('/') + (**(**[4096]int8)(__ccgo_up(bp + 4097)))[v4] = int8('/') p = p + 1 /* Initial // is special. */ - if int32((*(*[4097]int8)(unsafe.Pointer(bp)))[p]) == int32('/') && int32((*(*[4097]int8)(unsafe.Pointer(bp)))[p+uint64(1)]) != int32('/') { + if int32((**(**[4097]int8)(__ccgo_up(bp)))[p]) == int32('/') && int32((**(**[4097]int8)(__ccgo_up(bp)))[p+uint64(1)]) != int32('/') { v4 = q q = q + 1 - (*(*[4096]int8)(unsafe.Pointer(bp + 4097)))[v4] = int8('/') + (**(**[4096]int8)(__ccgo_up(bp + 4097)))[v4] = int8('/') } goto _2 } @@ -115533,30 +115533,30 @@ _3: goto _1 } /* Skip any . component but preserve check_dir status. */ - if l == uint64(1) && int32((*(*[4097]int8)(unsafe.Pointer(bp)))[p]) == int32('.') { + if l == uint64(1) && int32((**(**[4097]int8)(__ccgo_up(bp)))[p]) == int32('.') { p = p + l goto _2 } /* Copy next component onto output at least temporarily, to * call readlink, but wait to advance output position until * determining it's not a link. */ - if q != 0 && int32((*(*[4096]int8)(unsafe.Pointer(bp + 4097)))[q-uint64(1)]) != int32('/') { + if q != 0 && int32((**(**[4096]int8)(__ccgo_up(bp + 4097)))[q-uint64(1)]) != int32('/') { if !(p != 0) { goto toolong } p = p - 1 v4 = p - (*(*[4097]int8)(unsafe.Pointer(bp)))[v4] = int8('/') + (**(**[4097]int8)(__ccgo_up(bp)))[v4] = int8('/') l = l + 1 } if q+l >= uint64(PATH_MAX) { goto toolong } Xmemcpy(tls, bp+4097+uintptr(q), bp+uintptr(p), l) - (*(*[4096]int8)(unsafe.Pointer(bp + 4097)))[q+l] = 0 + (**(**[4096]int8)(__ccgo_up(bp + 4097)))[q+l] = 0 p = p + l up = 0 - if l0 == uint64(2) && int32((*(*[4097]int8)(unsafe.Pointer(bp)))[p-uint64(2)]) == int32('.') && int32((*(*[4097]int8)(unsafe.Pointer(bp)))[p-uint64(1)]) == int32('.') { + if l0 == uint64(2) && int32((**(**[4097]int8)(__ccgo_up(bp)))[p-uint64(2)]) == int32('.') && int32((**(**[4097]int8)(__ccgo_up(bp)))[p-uint64(1)]) == int32('.') { up = int32(1) /* Any non-.. path components we could cancel start * after nup repetitions of the 3-byte string "../"; @@ -115578,13 +115578,13 @@ _3: goto toolong } if !(k != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOENT) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOENT) return uintptr(0) } if !(k < 0) { goto _8 } - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(EINVAL) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(EINVAL) { return uintptr(0) } goto skip_readlink @@ -115592,10 +115592,10 @@ skip_readlink: ; check_dir = 0 if up != 0 { - for q != 0 && int32((*(*[4096]int8)(unsafe.Pointer(bp + 4097)))[q-uint64(1)]) != int32('/') { + for q != 0 && int32((**(**[4096]int8)(__ccgo_up(bp + 4097)))[q-uint64(1)]) != int32('/') { q = q - 1 } - if q > uint64(1) && (q > uint64(2) || int32((*(*[4096]int8)(unsafe.Pointer(bp + 4097)))[0]) != int32('/')) { + if q > uint64(1) && (q > uint64(2) || int32((**(**[4096]int8)(__ccgo_up(bp + 4097)))[0]) != int32('/')) { q = q - 1 } goto _2 @@ -115603,20 +115603,20 @@ skip_readlink: if l0 != 0 { q = q + l } - check_dir = int32((*(*[4097]int8)(unsafe.Pointer(bp)))[p]) + check_dir = int32((**(**[4097]int8)(__ccgo_up(bp)))[p]) goto _2 _8: ; cnt = cnt + 1 v4 = cnt if v4 == uint64(SYMLOOP_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ELOOP) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ELOOP) return uintptr(0) } /* If link contents end in /, strip any slashes already on * stack to avoid /->// or //->/// or spurious toolong. */ - if int32((*(*[4097]int8)(unsafe.Pointer(bp)))[k-int64(1)]) == int32('/') { - for int32((*(*[4097]int8)(unsafe.Pointer(bp)))[p]) == int32('/') { + if int32((**(**[4097]int8)(__ccgo_up(bp)))[k-int64(1)]) == int32('/') { + for int32((**(**[4097]int8)(__ccgo_up(bp)))[p]) == int32('/') { p = p + 1 } } @@ -115633,8 +115633,8 @@ _2: goto _1 _1: ; - (*(*[4096]int8)(unsafe.Pointer(bp + 4097)))[q] = 0 - if int32((*(*[4096]int8)(unsafe.Pointer(bp + 4097)))[0]) != int32('/') { + (**(**[4096]int8)(__ccgo_up(bp + 4097)))[q] = 0 + if int32((**(**[4096]int8)(__ccgo_up(bp + 4097)))[0]) != int32('/') { if !(Xgetcwd(tls, bp, uint64(4097)) != 0) { return uintptr(0) } @@ -115647,7 +115647,7 @@ _1: if !(v4 != 0) { break } - for l > uint64(1) && int32((*(*[4097]int8)(unsafe.Pointer(bp)))[l-uint64(1)]) != int32('/') { + for l > uint64(1) && int32((**(**[4097]int8)(__ccgo_up(bp)))[l-uint64(1)]) != int32('/') { l = l - 1 } if l > uint64(1) { @@ -115658,10 +115658,10 @@ _1: p = p + 1 } } - if q-p != 0 && int32((*(*[4097]int8)(unsafe.Pointer(bp)))[l-uint64(1)]) != int32('/') { + if q-p != 0 && int32((**(**[4097]int8)(__ccgo_up(bp)))[l-uint64(1)]) != int32('/') { v4 = l l = l + 1 - (*(*[4097]int8)(unsafe.Pointer(bp)))[v4] = int8('/') + (**(**[4097]int8)(__ccgo_up(bp)))[v4] = int8('/') } if l+(q-p)+uint64(1) >= uint64(PATH_MAX) { goto toolong @@ -115678,7 +115678,7 @@ _1: goto toolong toolong: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENAMETOOLONG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENAMETOOLONG) return uintptr(0) } @@ -115715,12 +115715,12 @@ func Xsetrlimit(tls *TLS, resource int32, rlim uintptr) (r int32) { var _ /* tmp at bp+0 */ Trlimit _ = ret if ^Uint64FromUint64(0) != ^Uint64FromUint64(0) { - *(*Trlimit)(unsafe.Pointer(bp)) = *(*Trlimit)(unsafe.Pointer(rlim)) - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur >= ^Uint64FromUint64(0) { - (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur = ^Uint64FromUint64(0) + **(**Trlimit)(__ccgo_up(bp)) = **(**Trlimit)(__ccgo_up(rlim)) + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur >= ^Uint64FromUint64(0) { + (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur = ^Uint64FromUint64(0) } - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_max >= ^Uint64FromUint64(0) { - (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_max = ^Uint64FromUint64(0) + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_max >= ^Uint64FromUint64(0) { + (**(**Trlimit)(__ccgo_up(bp))).Frlim_max = ^Uint64FromUint64(0) } rlim = bp } @@ -116101,7 +116101,7 @@ func Xcloselog(tls *TLS) { Xclose(tls, _log_fd) _log_fd = -int32(1) ___unlock(tls, uintptr(unsafe.Pointer(&_lock2))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) } func ___openlog(tls *TLS) { @@ -116135,7 +116135,7 @@ func Xopenlog(tls *TLS, ident uintptr, opt int32, facility int32) { ___openlog(tls) } ___unlock(tls, uintptr(unsafe.Pointer(&_lock2))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) } func _is_lost_conn(tls *TLS, e int32) (r int32) { @@ -116152,14 +116152,14 @@ func __vsyslog(tls *TLS, priority int32, message uintptr, ap Tva_list) { var _ /* timebuf at bp+0 */ [16]int8 var _ /* tm at bp+24 */ Ttm _, _, _, _, _, _ = errno_save, fd, l, l2, pid, v1 - errno_save = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + errno_save = **(**int32)(__ccgo_up(X__errno_location(tls))) if _log_fd < 0 { ___openlog(tls) } if !(priority&Int32FromInt32(LOG_FACMASK) != 0) { priority = priority | _log_facility } - *(*Ttime_t)(unsafe.Pointer(bp + 16)) = Xtime(tls, UintptrFromInt32(0)) + **(**Ttime_t)(__ccgo_up(bp + 16)) = Xtime(tls, UintptrFromInt32(0)) Xgmtime_r(tls, bp+16, bp+24) Xstrftime_l(tls, bp, uint64(16), __ccgo_ts+911, bp+24, uintptr(unsafe.Pointer(&X__c_locale))) if _log_opt&int32(LOG_PID) != 0 { @@ -116169,7 +116169,7 @@ func __vsyslog(tls *TLS, priority int32, message uintptr, ap Tva_list) { } pid = v1 l = Xsnprintf(tls, bp+80, uint64(1024), __ccgo_ts+920, VaList(bp+1120, priority, bp, bp+1104, uintptr(unsafe.Pointer(&_log_ident)), __ccgo_ts+942+BoolUintptr(!(pid != 0)), pid, __ccgo_ts+944+BoolUintptr(!(pid != 0)))) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = errno_save + **(**int32)(__ccgo_up(X__errno_location(tls))) = errno_save l2 = Xvsnprintf(tls, bp+80+uintptr(l), uint64(1024)-Uint64FromInt32(l), message, ap) if l2 >= 0 { if Uint64FromInt32(l2) >= uint64(1024)-Uint64FromInt32(l) { @@ -116177,20 +116177,20 @@ func __vsyslog(tls *TLS, priority int32, message uintptr, ap Tva_list) { } else { l = l + l2 } - if int32((*(*[1024]int8)(unsafe.Pointer(bp + 80)))[l-int32(1)]) != int32('\n') { + if int32((**(**[1024]int8)(__ccgo_up(bp + 80)))[l-int32(1)]) != int32('\n') { v1 = l l = l + 1 - (*(*[1024]int8)(unsafe.Pointer(bp + 80)))[v1] = int8('\n') + (**(**[1024]int8)(__ccgo_up(bp + 80)))[v1] = int8('\n') } - if Xsend(tls, _log_fd, bp+80, Uint64FromInt32(l), 0) < 0 && (!(_is_lost_conn(tls, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) != 0) || Xconnect(tls, _log_fd, uintptr(unsafe.Pointer(&_log_addr)), uint32(12)) < 0 || Xsend(tls, _log_fd, bp+80, Uint64FromInt32(l), 0) < 0) && _log_opt&int32(LOG_CONS) != 0 { + if Xsend(tls, _log_fd, bp+80, Uint64FromInt32(l), 0) < 0 && (!(_is_lost_conn(tls, **(**int32)(__ccgo_up(X__errno_location(tls)))) != 0) || Xconnect(tls, _log_fd, uintptr(unsafe.Pointer(&_log_addr)), uint32(12)) < 0 || Xsend(tls, _log_fd, bp+80, Uint64FromInt32(l), 0) < 0) && _log_opt&int32(LOG_CONS) != 0 { fd = Xopen(tls, __ccgo_ts+639, Int32FromInt32(O_WRONLY)|Int32FromInt32(O_NOCTTY)|Int32FromInt32(O_CLOEXEC), 0) if fd >= 0 { - Xdprintf(tls, fd, __ccgo_ts+946, VaList(bp+1120, l-*(*int32)(unsafe.Pointer(bp + 1104)), bp+80+uintptr(*(*int32)(unsafe.Pointer(bp + 1104))))) + Xdprintf(tls, fd, __ccgo_ts+946, VaList(bp+1120, l-**(**int32)(__ccgo_up(bp + 1104)), bp+80+uintptr(**(**int32)(__ccgo_up(bp + 1104))))) Xclose(tls, fd) } } if _log_opt&int32(LOG_PERROR) != 0 { - Xdprintf(tls, int32(2), __ccgo_ts+946, VaList(bp+1120, l-*(*int32)(unsafe.Pointer(bp + 1104)), bp+80+uintptr(*(*int32)(unsafe.Pointer(bp + 1104))))) + Xdprintf(tls, int32(2), __ccgo_ts+946, VaList(bp+1120, l-**(**int32)(__ccgo_up(bp + 1104)), bp+80+uintptr(**(**int32)(__ccgo_up(bp + 1104))))) } } } @@ -116206,7 +116206,7 @@ func ___vsyslog(tls *TLS, priority int32, message uintptr, ap Tva_list) { ___lock(tls, uintptr(unsafe.Pointer(&_lock2))) __vsyslog(tls, priority, message, ap) ___unlock(tls, uintptr(unsafe.Pointer(&_lock2))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) } func Xsyslog(tls *TLS, priority int32, message uintptr, va uintptr) { @@ -116291,11 +116291,11 @@ func X__mmap(tls *TLS, start uintptr, len1 Tsize_t, prot int32, flags int32, fd var ret int64 _ = ret if Uint64FromInt64(off)&(-Uint64FromUint64(0x2000)<<(Uint64FromInt32(8)*Uint64FromInt64(8)-Uint64FromInt32(1))|(Uint64FromUint64(4096)-Uint64FromInt32(1))) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(-Int32FromInt32(1)) } if len1 >= Uint64FromInt64(Int64FromInt64(INT64_MAX)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return uintptr(-Int32FromInt32(1)) } if flags&int32(MAP_FIXED) != 0 { @@ -116350,7 +116350,7 @@ func X__mremap(tls *TLS, old_addr uintptr, old_len Tsize_t, new_len Tsize_t, fla _, _ = ap, new_addr new_addr = uintptr(0) if new_len >= Uint64FromInt64(Int64FromInt64(INT64_MAX)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return uintptr(-Int32FromInt32(1)) } if flags&int32(MREMAP_FIXED) != 0 { @@ -116432,17 +116432,17 @@ func X__shm_mapname(tls *TLS, name uintptr, buf uintptr) (r uintptr) { } var p, v1 uintptr _, _ = p, v1 - for int32(*(*int8)(unsafe.Pointer(name))) == int32('/') { + for int32(**(**int8)(__ccgo_up(name))) == int32('/') { name = name + 1 } v1 = X__strchrnul(tls, name, int32('/')) p = v1 - if *(*int8)(unsafe.Pointer(v1)) != 0 || p == name || int64(p)-int64(name) <= int64(2) && int32(*(*int8)(unsafe.Pointer(name))) == int32('.') && int32(*(*int8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) == int32('.') { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if **(**int8)(__ccgo_up(v1)) != 0 || p == name || int64(p)-int64(name) <= int64(2) && int32(**(**int8)(__ccgo_up(name))) == int32('.') && int32(**(**int8)(__ccgo_up(p + uintptr(-Int32FromInt32(1))))) == int32('.') { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } if int64(p)-int64(name) > int64(NAME_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENAMETOOLONG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENAMETOOLONG) return uintptr(0) } Xmemcpy(tls, buf, __ccgo_ts+951, uint64(9)) @@ -116469,7 +116469,7 @@ func Xshm_open(tls *TLS, name uintptr, flag int32, mode Tmode_t) (r int32) { } _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp) fd = Xopen(tls, name, flag|int32(O_NOFOLLOW)|int32(O_CLOEXEC)|int32(O_NONBLOCK), VaList(bp+280, mode)) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) return fd } @@ -116507,7 +116507,7 @@ func Xbtowc(tls *TLS, c int32) (r Twint_t) { if Uint32FromInt32(b) < uint32(128) { v1 = Uint32FromInt32(b) } else { - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v3 = int32(4) } else { v3 = int32(1) @@ -116539,22 +116539,22 @@ func Xc16rtomb(tls *TLS, s uintptr, c16 Tchar16_t, ps uintptr) (r Tsize_t) { } x = ps if !(s != 0) { - if *(*uint32)(unsafe.Pointer(x)) != 0 { + if **(**uint32)(__ccgo_up(x)) != 0 { goto ilseq } return uint64(1) } - if !(*(*uint32)(unsafe.Pointer(x)) != 0) && uint32(c16)-uint32(0xd800) < uint32(0x400) { - *(*uint32)(unsafe.Pointer(x)) = Uint32FromInt32((Int32FromUint16(c16) - int32(0xd7c0)) << int32(10)) + if !(**(**uint32)(__ccgo_up(x)) != 0) && uint32(c16)-uint32(0xd800) < uint32(0x400) { + **(**uint32)(__ccgo_up(x)) = Uint32FromInt32((Int32FromUint16(c16) - int32(0xd7c0)) << int32(10)) return uint64(0) } - if *(*uint32)(unsafe.Pointer(x)) != 0 { + if **(**uint32)(__ccgo_up(x)) != 0 { if uint32(c16)-uint32(0xdc00) >= uint32(0x400) { goto ilseq } else { - wc = Int32FromUint32(*(*uint32)(unsafe.Pointer(x)) + uint32(c16) - uint32(0xdc00)) + wc = Int32FromUint32(**(**uint32)(__ccgo_up(x)) + uint32(c16) - uint32(0xdc00)) } - *(*uint32)(unsafe.Pointer(x)) = uint32(0) + **(**uint32)(__ccgo_up(x)) = uint32(0) } else { wc = Int32FromUint16(c16) } @@ -116562,8 +116562,8 @@ func Xc16rtomb(tls *TLS, s uintptr, c16 Tchar16_t, ps uintptr) (r Tsize_t) { goto ilseq ilseq: ; - *(*uint32)(unsafe.Pointer(x)) = uint32(0) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EILSEQ) + **(**uint32)(__ccgo_up(x)) = uint32(0) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EILSEQ) return Uint64FromInt32(-Int32FromInt32(1)) } @@ -116622,21 +116622,21 @@ func Xmbrtoc16(tls *TLS, pc16 uintptr, s uintptr, n Tsize_t, ps uintptr) (r Tsiz } /* mbrtowc states for partial UTF-8 characters have the high bit set; * we use nonzero states without high bit for pending surrogates. */ - if Int32FromUint32(*(*uint32)(unsafe.Pointer(pending))) > 0 { + if Int32FromUint32(**(**uint32)(__ccgo_up(pending))) > 0 { if pc16 != 0 { - *(*Tchar16_t)(unsafe.Pointer(pc16)) = uint16(*(*uint32)(unsafe.Pointer(pending))) + **(**Tchar16_t)(__ccgo_up(pc16)) = uint16(**(**uint32)(__ccgo_up(pending))) } - *(*uint32)(unsafe.Pointer(pending)) = uint32(0) + **(**uint32)(__ccgo_up(pending)) = uint32(0) return Uint64FromInt32(-Int32FromInt32(3)) } ret = Xmbrtowc(tls, bp, s, n, ps) if ret <= uint64(4) { - if *(*Twchar_t)(unsafe.Pointer(bp)) >= int32(0x10000) { - *(*uint32)(unsafe.Pointer(pending)) = Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))&int32(0x3ff) + int32(0xdc00)) - *(*Twchar_t)(unsafe.Pointer(bp)) = int32(0xd7c0) + *(*Twchar_t)(unsafe.Pointer(bp))>>Int32FromInt32(10) + if **(**Twchar_t)(__ccgo_up(bp)) >= int32(0x10000) { + **(**uint32)(__ccgo_up(pending)) = Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))&int32(0x3ff) + int32(0xdc00)) + **(**Twchar_t)(__ccgo_up(bp)) = int32(0xd7c0) + **(**Twchar_t)(__ccgo_up(bp))>>Int32FromInt32(10) } if pc16 != 0 { - *(*Tchar16_t)(unsafe.Pointer(pc16)) = Uint16FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))) + **(**Tchar16_t)(__ccgo_up(pc16)) = Uint16FromInt32(**(**Twchar_t)(__ccgo_up(bp))) } } return ret @@ -116662,7 +116662,7 @@ func Xmbrtoc32(tls *TLS, pc32 uintptr, s uintptr, n Tsize_t, ps uintptr) (r Tsiz } ret = Xmbrtowc(tls, bp, s, n, ps) if ret <= uint64(4) && pc32 != 0 { - *(*Tchar32_t)(unsafe.Pointer(pc32)) = Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))) + **(**Tchar32_t)(__ccgo_up(pc32)) = Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))) } return ret } @@ -116688,7 +116688,7 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize if !(st != 0) { st = uintptr(unsafe.Pointer(&_internal_state3)) } - c = *(*uint32)(unsafe.Pointer(st)) + c = **(**uint32)(__ccgo_up(st)) if !(s != 0) { if c != 0 { goto ilseq @@ -116703,30 +116703,30 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize return Uint64FromInt32(-Int32FromInt32(2)) } if !(c != 0) { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) < int32(0x80) { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) - *(*Twchar_t)(unsafe.Pointer(wc)) = v1 + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) < int32(0x80) { + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(s))) + **(**Twchar_t)(__ccgo_up(wc)) = v1 return BoolUint64(!!(v1 != 0)) } - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v2 = int32(4) } else { v2 = int32(1) } if v2 == int32(1) { - *(*Twchar_t)(unsafe.Pointer(wc)) = Int32FromInt32(0xdfff) & int32(Int8FromUint8(*(*uint8)(unsafe.Pointer(s)))) + **(**Twchar_t)(__ccgo_up(wc)) = Int32FromInt32(0xdfff) & int32(Int8FromUint8(**(**uint8)(__ccgo_up(s)))) return Uint64FromInt32(1) } - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { goto ilseq } v3 = s s = s + 1 - c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v3)))-uint32(0xc2)] + c = X__fsmu8[uint32(**(**uint8)(__ccgo_up(v3)))-uint32(0xc2)] n = n - 1 } if n != 0 { - if (Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { + if (Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { goto ilseq } goto loop @@ -116734,27 +116734,27 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize ; v3 = s s = s + 1 - c = c<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { goto ilseq } goto loop } } - *(*uint32)(unsafe.Pointer(st)) = c + **(**uint32)(__ccgo_up(st)) = c return Uint64FromInt32(-Int32FromInt32(2)) goto ilseq ilseq: ; - *(*uint32)(unsafe.Pointer(st)) = uint32(0) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EILSEQ) + **(**uint32)(__ccgo_up(st)) = uint32(0) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EILSEQ) return Uint64FromInt32(-Int32FromInt32(1)) } @@ -116765,7 +116765,7 @@ func Xmbsinit(tls *TLS, st uintptr) (r int32) { trc("tls=%v st=%v, (%v:)", tls, st, origin(2)) defer func() { trc("-> %v", r) }() } - return BoolInt32(!(st != 0) || !(*(*uint32)(unsafe.Pointer(st)) != 0)) + return BoolInt32(!(st != 0) || !(**(**uint32)(__ccgo_up(st)) != 0)) } func Xmbsnrtowcs(tls *TLS, wcs uintptr, src uintptr, n Tsize_t, wn Tsize_t, st uintptr) (r Tsize_t) { @@ -116783,7 +116783,7 @@ func Xmbsnrtowcs(tls *TLS, wcs uintptr, src uintptr, n Tsize_t, wn Tsize_t, st u var _ /* wbuf at bp+0 */ [256]Twchar_t _, _, _, _, _, _, _, _ = cnt, l, n2, tmp_s, ws, v1, v2, v3 cnt = uint64(0) - *(*uintptr)(unsafe.Pointer(bp + 1024)) = *(*uintptr)(unsafe.Pointer(src)) + **(**uintptr)(__ccgo_up(bp + 1024)) = **(**uintptr)(__ccgo_up(src)) if !(wcs != 0) { ws = bp wn = Uint64FromInt64(1024) / Uint64FromInt64(4) @@ -116794,7 +116794,7 @@ func Xmbsnrtowcs(tls *TLS, wcs uintptr, src uintptr, n Tsize_t, wn Tsize_t, st u * that mbsrtowcs never reads more than n input bytes. thus * we can use mbsrtowcs as long as it's practical.. */ for { - if v2 = *(*uintptr)(unsafe.Pointer(bp + 1024)) != 0 && wn != 0; v2 { + if v2 = **(**uintptr)(__ccgo_up(bp + 1024)) != 0 && wn != 0; v2 { v1 = n / Uint64FromInt32(4) n2 = v1 } @@ -116804,7 +116804,7 @@ func Xmbsnrtowcs(tls *TLS, wcs uintptr, src uintptr, n Tsize_t, wn Tsize_t, st u if n2 >= wn { n2 = wn } - tmp_s = *(*uintptr)(unsafe.Pointer(bp + 1024)) + tmp_s = **(**uintptr)(__ccgo_up(bp + 1024)) l = Xmbsrtowcs(tls, ws, bp+1024, n2, st) if !(l+Uint64FromInt32(1) != 0) { cnt = l @@ -116815,31 +116815,31 @@ func Xmbsnrtowcs(tls *TLS, wcs uintptr, src uintptr, n Tsize_t, wn Tsize_t, st u ws = ws + uintptr(l)*4 wn = wn - l } - if *(*uintptr)(unsafe.Pointer(bp + 1024)) != 0 { - v3 = n - Uint64FromInt64(int64(*(*uintptr)(unsafe.Pointer(bp + 1024)))-int64(tmp_s)) + if **(**uintptr)(__ccgo_up(bp + 1024)) != 0 { + v3 = n - Uint64FromInt64(int64(**(**uintptr)(__ccgo_up(bp + 1024)))-int64(tmp_s)) } else { v3 = uint64(0) } n = v3 cnt = cnt + l } - if *(*uintptr)(unsafe.Pointer(bp + 1024)) != 0 { + if **(**uintptr)(__ccgo_up(bp + 1024)) != 0 { for wn != 0 && n != 0 { - l = Xmbrtowc(tls, ws, *(*uintptr)(unsafe.Pointer(bp + 1024)), n, st) + l = Xmbrtowc(tls, ws, **(**uintptr)(__ccgo_up(bp + 1024)), n, st) if l+uint64(2) <= uint64(2) { if !(l+Uint64FromInt32(1) != 0) { cnt = l break } if !(l != 0) { - *(*uintptr)(unsafe.Pointer(bp + 1024)) = uintptr(0) + **(**uintptr)(__ccgo_up(bp + 1024)) = uintptr(0) break } /* have to roll back partial character */ - *(*uint32)(unsafe.Pointer(st)) = uint32(0) + **(**uint32)(__ccgo_up(st)) = uint32(0) break } - *(*uintptr)(unsafe.Pointer(bp + 1024)) = *(*uintptr)(unsafe.Pointer(bp + 1024)) + uintptr(l) + **(**uintptr)(__ccgo_up(bp + 1024)) = **(**uintptr)(__ccgo_up(bp + 1024)) + uintptr(l) n = n - l /* safe - this loop runs fewer than sizeof(wbuf)/8 times */ ws += 4 @@ -116848,7 +116848,7 @@ func Xmbsnrtowcs(tls *TLS, wcs uintptr, src uintptr, n Tsize_t, wn Tsize_t, st u } } if wcs != 0 { - *(*uintptr)(unsafe.Pointer(src)) = *(*uintptr)(unsafe.Pointer(bp + 1024)) + **(**uintptr)(__ccgo_up(src)) = **(**uintptr)(__ccgo_up(bp + 1024)) } return cnt } @@ -116864,22 +116864,22 @@ func Xmbsrtowcs(tls *TLS, ws uintptr, src uintptr, wn Tsize_t, st uintptr) (r Ts var v2 bool var v3 int32 _, _, _, _, _, _, _, _ = c, s, wn0, v1, v2, v3, v5, v6 - s = *(*uintptr)(unsafe.Pointer(src)) + s = **(**uintptr)(__ccgo_up(src)) wn0 = wn c = uint32(0) if v2 = st != 0; v2 { - v1 = *(*uint32)(unsafe.Pointer(st)) + v1 = **(**uint32)(__ccgo_up(st)) c = v1 } if v2 && v1 != 0 { if ws != 0 { - *(*uint32)(unsafe.Pointer(st)) = uint32(0) + **(**uint32)(__ccgo_up(st)) = uint32(0) goto resume } else { goto resume0 } } - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v3 = int32(4) } else { v3 = int32(1) @@ -116890,24 +116890,24 @@ func Xmbsrtowcs(tls *TLS, ws uintptr, src uintptr, wn Tsize_t, st uintptr) (r Ts } for { if !(wn != 0) { - *(*uintptr)(unsafe.Pointer(src)) = s + **(**uintptr)(__ccgo_up(src)) = s return wn0 } - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { break } v5 = s s = s + 1 - c = uint32(*(*uint8)(unsafe.Pointer(v5))) + c = uint32(**(**uint8)(__ccgo_up(v5))) v5 = ws ws += 4 - *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromInt32(0xdfff) & int32(Int8FromUint32(c)) + **(**Twchar_t)(__ccgo_up(v5)) = Int32FromInt32(0xdfff) & int32(Int8FromUint32(c)) wn = wn - 1 goto _4 _4: } - *(*Twchar_t)(unsafe.Pointer(ws)) = 0 - *(*uintptr)(unsafe.Pointer(src)) = uintptr(0) + **(**Twchar_t)(__ccgo_up(ws)) = 0 + **(**uintptr)(__ccgo_up(src)) = uintptr(0) return wn0 - wn } if !!(ws != 0) { @@ -116915,39 +116915,39 @@ func Xmbsrtowcs(tls *TLS, ws uintptr, src uintptr, wn Tsize_t, st uintptr) (r Ts } _11: ; - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) && uint64(s)%uint64(4) == uint64(0) { - for !((*(*uint32)(unsafe.Pointer(s))|(*(*uint32)(unsafe.Pointer(s))-Uint32FromInt32(0x01010101)))&Uint32FromUint32(0x80808080) != 0) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(1) < uint32(0x7f) && uint64(s)%uint64(4) == uint64(0) { + for !((**(**uint32)(__ccgo_up(s))|(**(**uint32)(__ccgo_up(s))-Uint32FromInt32(0x01010101)))&Uint32FromUint32(0x80808080) != 0) { s = s + uintptr(4) wn = wn - uint64(4) } } - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(1) < uint32(0x7f) { s = s + 1 wn = wn - 1 goto _10 } - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { goto _9 } v5 = s s = s + 1 - c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v5)))-uint32(0xc2)] + c = X__fsmu8[uint32(**(**uint8)(__ccgo_up(v5)))-uint32(0xc2)] goto resume0 resume0: ; - if (Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { + if (Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { s = s - 1 goto _9 } s = s + 1 if c&(Uint32FromUint32(1)<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { s = s - uintptr(2) goto _9 } s = s + 1 if c&(Uint32FromUint32(1)<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { s = s - uintptr(3) goto _9 } @@ -116969,80 +116969,80 @@ _7: _15: ; if !(wn != 0) { - *(*uintptr)(unsafe.Pointer(src)) = s + **(**uintptr)(__ccgo_up(src)) = s return wn0 } - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) && uint64(s)%uint64(4) == uint64(0) { - for wn >= uint64(5) && !((*(*uint32)(unsafe.Pointer(s))|(*(*uint32)(unsafe.Pointer(s))-Uint32FromInt32(0x01010101)))&Uint32FromUint32(0x80808080) != 0) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(1) < uint32(0x7f) && uint64(s)%uint64(4) == uint64(0) { + for wn >= uint64(5) && !((**(**uint32)(__ccgo_up(s))|(**(**uint32)(__ccgo_up(s))-Uint32FromInt32(0x01010101)))&Uint32FromUint32(0x80808080) != 0) { v5 = ws ws += 4 v6 = s s = s + 1 - *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + **(**Twchar_t)(__ccgo_up(v5)) = Int32FromUint8(**(**uint8)(__ccgo_up(v6))) v5 = ws ws += 4 v6 = s s = s + 1 - *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + **(**Twchar_t)(__ccgo_up(v5)) = Int32FromUint8(**(**uint8)(__ccgo_up(v6))) v5 = ws ws += 4 v6 = s s = s + 1 - *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + **(**Twchar_t)(__ccgo_up(v5)) = Int32FromUint8(**(**uint8)(__ccgo_up(v6))) v5 = ws ws += 4 v6 = s s = s + 1 - *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + **(**Twchar_t)(__ccgo_up(v5)) = Int32FromUint8(**(**uint8)(__ccgo_up(v6))) wn = wn - uint64(4) } } - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(1) < uint32(0x7f) { v5 = ws ws += 4 v6 = s s = s + 1 - *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + **(**Twchar_t)(__ccgo_up(v5)) = Int32FromUint8(**(**uint8)(__ccgo_up(v6))) wn = wn - 1 goto _14 } - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { goto _13 } v5 = s s = s + 1 - c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v5)))-uint32(0xc2)] + c = X__fsmu8[uint32(**(**uint8)(__ccgo_up(v5)))-uint32(0xc2)] goto resume resume: ; - if (Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { + if (Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { s = s - 1 goto _13 } v5 = s s = s + 1 - c = c<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { s = s - uintptr(2) goto _13 } v5 = s s = s + 1 - c = c<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { s = s - uintptr(3) goto _13 } v5 = s s = s + 1 - c = c< Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { goto ilseq } v3 = s s = s + 1 - c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v3)))-uint32(0xc2)] + c = X__fsmu8[uint32(**(**uint8)(__ccgo_up(v3)))-uint32(0xc2)] /* Avoid excessive checks against n: If shifting the state n-1 * times does not clear the high bit, then the value of n is * insufficient to read a character */ if n < uint64(4) && c<<(uint64(6)*n-uint64(6))&(Uint32FromUint32(1)<>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { + if (Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { goto ilseq } v3 = s s = s + 1 - c = c<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { goto ilseq } v3 = s s = s + 1 - c = c<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { goto ilseq } v3 = s s = s + 1 - *(*Twchar_t)(unsafe.Pointer(wc)) = Int32FromUint32(c<>Int32FromInt32(6)) - *(*int8)(unsafe.Pointer(s)) = int8(int32(0x80) | wc&int32(0x3f)) + **(**int8)(__ccgo_up(v2)) = int8(int32(0xc0) | wc>>Int32FromInt32(6)) + **(**int8)(__ccgo_up(s)) = int8(int32(0x80) | wc&int32(0x3f)) return uint64(2) } else { if Uint32FromInt32(wc) < uint32(0xd800) || Uint32FromInt32(wc)-uint32(0xe000) < uint32(0x2000) { v2 = s s = s + 1 - *(*int8)(unsafe.Pointer(v2)) = int8(int32(0xe0) | wc>>Int32FromInt32(12)) + **(**int8)(__ccgo_up(v2)) = int8(int32(0xe0) | wc>>Int32FromInt32(12)) v2 = s s = s + 1 - *(*int8)(unsafe.Pointer(v2)) = int8(int32(0x80) | wc>>Int32FromInt32(6)&int32(0x3f)) - *(*int8)(unsafe.Pointer(s)) = int8(int32(0x80) | wc&int32(0x3f)) + **(**int8)(__ccgo_up(v2)) = int8(int32(0x80) | wc>>Int32FromInt32(6)&int32(0x3f)) + **(**int8)(__ccgo_up(s)) = int8(int32(0x80) | wc&int32(0x3f)) return uint64(3) } else { if Uint32FromInt32(wc)-uint32(0x10000) < uint32(0x100000) { v2 = s s = s + 1 - *(*int8)(unsafe.Pointer(v2)) = int8(int32(0xf0) | wc>>Int32FromInt32(18)) + **(**int8)(__ccgo_up(v2)) = int8(int32(0xf0) | wc>>Int32FromInt32(18)) v2 = s s = s + 1 - *(*int8)(unsafe.Pointer(v2)) = int8(int32(0x80) | wc>>Int32FromInt32(12)&int32(0x3f)) + **(**int8)(__ccgo_up(v2)) = int8(int32(0x80) | wc>>Int32FromInt32(12)&int32(0x3f)) v2 = s s = s + 1 - *(*int8)(unsafe.Pointer(v2)) = int8(int32(0x80) | wc>>Int32FromInt32(6)&int32(0x3f)) - *(*int8)(unsafe.Pointer(s)) = int8(int32(0x80) | wc&int32(0x3f)) + **(**int8)(__ccgo_up(v2)) = int8(int32(0x80) | wc>>Int32FromInt32(6)&int32(0x3f)) + **(**int8)(__ccgo_up(s)) = int8(int32(0x80) | wc&int32(0x3f)) return uint64(4) } } } } } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EILSEQ) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EILSEQ) return Uint64FromInt32(-Int32FromInt32(1)) } @@ -117239,7 +117239,7 @@ func Xwcsnrtombs(tls *TLS, dst uintptr, wcs uintptr, wn Tsize_t, n Tsize_t, st u var ws, v1 uintptr var _ /* tmp at bp+0 */ [4]int8 _, _, _, _ = cnt, l, ws, v1 - ws = *(*uintptr)(unsafe.Pointer(wcs)) + ws = **(**uintptr)(__ccgo_up(wcs)) cnt = uint64(0) if !(dst != 0) { n = uint64(0) @@ -117250,7 +117250,7 @@ func Xwcsnrtombs(tls *TLS, dst uintptr, wcs uintptr, wn Tsize_t, n Tsize_t, st u } else { v1 = dst } - l = Xwcrtomb(tls, v1, *(*Twchar_t)(unsafe.Pointer(ws)), uintptr(0)) + l = Xwcrtomb(tls, v1, **(**Twchar_t)(__ccgo_up(ws)), uintptr(0)) if l == Uint64FromInt32(-Int32FromInt32(1)) { cnt = Uint64FromInt32(-Int32FromInt32(1)) break @@ -117265,7 +117265,7 @@ func Xwcsnrtombs(tls *TLS, dst uintptr, wcs uintptr, wn Tsize_t, n Tsize_t, st u dst = dst + uintptr(l) n = n - l } - if !(*(*Twchar_t)(unsafe.Pointer(ws)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(ws)) != 0) { ws = uintptr(0) break } @@ -117274,7 +117274,7 @@ func Xwcsnrtombs(tls *TLS, dst uintptr, wcs uintptr, wn Tsize_t, n Tsize_t, st u cnt = cnt + l } if dst != 0 { - *(*uintptr)(unsafe.Pointer(wcs)) = ws + **(**uintptr)(__ccgo_up(wcs)) = ws } return cnt } @@ -117293,13 +117293,13 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize N = n if !(s != 0) { n = uint64(0) - ws2 = *(*uintptr)(unsafe.Pointer(ws)) + ws2 = **(**uintptr)(__ccgo_up(ws)) for { - if !(*(*Twchar_t)(unsafe.Pointer(ws2)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(ws2)) != 0) { break } - if Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(ws2))) >= uint32(0x80) { - l = Xwcrtomb(tls, bp, *(*Twchar_t)(unsafe.Pointer(ws2)), uintptr(0)) + if Uint32FromInt32(**(**Twchar_t)(__ccgo_up(ws2))) >= uint32(0x80) { + l = Xwcrtomb(tls, bp, **(**Twchar_t)(__ccgo_up(ws2)), uintptr(0)) if !(l+Uint64FromInt32(1) != 0) { return Uint64FromInt32(-Int32FromInt32(1)) } @@ -117315,13 +117315,13 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize return n } for n >= uint64(4) { - if Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))))-uint32(1) >= uint32(0x7f) { - if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))) != 0) { - *(*int8)(unsafe.Pointer(s)) = 0 - *(*uintptr)(unsafe.Pointer(ws)) = uintptr(0) + if Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))))-uint32(1) >= uint32(0x7f) { + if !(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))) != 0) { + **(**int8)(__ccgo_up(s)) = 0 + **(**uintptr)(__ccgo_up(ws)) = uintptr(0) return N - n } - l = Xwcrtomb(tls, s, *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))), uintptr(0)) + l = Xwcrtomb(tls, s, **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))), uintptr(0)) if !(l+Uint64FromInt32(1) != 0) { return Uint64FromInt32(-Int32FromInt32(1)) } @@ -117330,35 +117330,35 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize } else { v2 = s s = s + 1 - *(*int8)(unsafe.Pointer(v2)) = int8(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) + **(**int8)(__ccgo_up(v2)) = int8(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws))))) n = n - 1 } - *(*uintptr)(unsafe.Pointer(ws)) += 4 + **(**uintptr)(__ccgo_up(ws)) += 4 } for n != 0 { - if Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))))-uint32(1) >= uint32(0x7f) { - if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))) != 0) { - *(*int8)(unsafe.Pointer(s)) = 0 - *(*uintptr)(unsafe.Pointer(ws)) = uintptr(0) + if Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))))-uint32(1) >= uint32(0x7f) { + if !(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))) != 0) { + **(**int8)(__ccgo_up(s)) = 0 + **(**uintptr)(__ccgo_up(ws)) = uintptr(0) return N - n } - l = Xwcrtomb(tls, bp, *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))), uintptr(0)) + l = Xwcrtomb(tls, bp, **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))), uintptr(0)) if !(l+Uint64FromInt32(1) != 0) { return Uint64FromInt32(-Int32FromInt32(1)) } if l > n { return N - n } - Xwcrtomb(tls, s, *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))), uintptr(0)) + Xwcrtomb(tls, s, **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))), uintptr(0)) s = s + uintptr(l) n = n - l } else { v2 = s s = s + 1 - *(*int8)(unsafe.Pointer(v2)) = int8(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) + **(**int8)(__ccgo_up(v2)) = int8(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws))))) n = n - 1 } - *(*uintptr)(unsafe.Pointer(ws)) += 4 + **(**uintptr)(__ccgo_up(ws)) += 4 } return N } @@ -117384,7 +117384,7 @@ func Xwctob(tls *TLS, c Twint_t) (r int32) { if c < uint32(128) { return Int32FromUint32(c) } - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v1 = int32(4) } else { v1 = int32(1) @@ -117482,11 +117482,11 @@ func Xaccept4(tls *TLS, fd int32, addr uintptr, len1 uintptr, flg int32) (r1 int goto _9 _9: ret = int32(X__syscall_ret(tls, Uint64FromInt64(v8))) - if ret >= 0 || *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(ENOSYS) && *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(EINVAL) { + if ret >= 0 || **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(ENOSYS) && **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(EINVAL) { return ret } if flg & ^(Int32FromInt32(SOCK_CLOEXEC)|Int32FromInt32(SOCK_NONBLOCK)) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } ret = Xaccept(tls, fd, addr, len1) @@ -118458,13 +118458,13 @@ func _getoffs(tls *TLS, offs uintptr, base uintptr, s uintptr) (r int32) { _, _ = i, v2 i = 0 for { - for Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))&int32(0xc0) != 0 { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))&int32(0xc0) != int32(0xc0) { + for Int32FromUint8(**(**uint8)(__ccgo_up(s)))&int32(0xc0) != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(s)))&int32(0xc0) != int32(0xc0) { return 0 } - s = base + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))&Int32FromInt32(0x3f)<= int64(0x4000) { @@ -118472,8 +118472,8 @@ func _getoffs(tls *TLS, offs uintptr, base uintptr, s uintptr) (r int32) { } v2 = i i = i + 1 - *(*int16)(unsafe.Pointer(offs + uintptr(v2)*2)) = int16(int64(s) - int64(base)) - s = s + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))+int32(1)) + **(**int16)(__ccgo_up(offs + uintptr(v2)*2)) = int16(int64(s) - int64(base)) + s = s + uintptr(Int32FromUint8(**(**uint8)(__ccgo_up(s)))+int32(1)) goto _1 _1: } @@ -118491,7 +118491,7 @@ func _getlens(tls *TLS, lens uintptr, s uintptr, l int32) (r int32) { k = 0 for { for { - if !(j < l && int32(*(*int8)(unsafe.Pointer(s + uintptr(j)))) != int32('.')) { + if !(j < l && int32(**(**int8)(__ccgo_up(s + uintptr(j)))) != int32('.')) { break } goto _2 @@ -118504,7 +118504,7 @@ func _getlens(tls *TLS, lens uintptr, s uintptr, l int32) (r int32) { } v3 = i i = i + 1 - *(*uint8)(unsafe.Pointer(lens + uintptr(v3))) = Uint8FromInt32(j - k) + **(**uint8)(__ccgo_up(lens + uintptr(v3))) = Uint8FromInt32(j - k) if j == l { return i } @@ -118534,15 +118534,15 @@ func _match(tls *TLS, offset uintptr, base uintptr, dn uintptr, end uintptr, len for { nlen = nlen - 1 v2 = nlen - l = Int32FromUint8(*(*uint8)(unsafe.Pointer(lens + uintptr(v2)))) + l = Int32FromUint8(**(**uint8)(__ccgo_up(lens + uintptr(v2)))) noff = noff - 1 v2 = noff - o = int32((*(*[128]int16)(unsafe.Pointer(bp)))[v2]) + o = int32((**(**[128]int16)(__ccgo_up(bp)))[v2]) end = end - uintptr(l) - if l != Int32FromUint8(*(*uint8)(unsafe.Pointer(base + uintptr(o)))) || Xmemcmp(tls, base+uintptr(o)+uintptr(1), end, Uint64FromInt32(l)) != 0 { + if l != Int32FromUint8(**(**uint8)(__ccgo_up(base + uintptr(o)))) || Xmemcmp(tls, base+uintptr(o)+uintptr(1), end, Uint64FromInt32(l)) != 0 { return m } - *(*int32)(unsafe.Pointer(offset)) = o + **(**int32)(__ccgo_up(offset)) = o m = m + l if nlen != 0 { m = m + 1 @@ -118573,14 +118573,14 @@ func Xdn_comp(tls *TLS, src uintptr, dst uintptr, space int32, dnptrs uintptr, l m = 0 bestlen = 0 l = Xstrnlen(tls, src, uint64(255)) - if l != 0 && int32(*(*int8)(unsafe.Pointer(src + uintptr(l-uint64(1))))) == int32('.') { + if l != 0 && int32(**(**int8)(__ccgo_up(src + uintptr(l-uint64(1))))) == int32('.') { l = l - 1 } if l > uint64(253) || space <= 0 { return -int32(1) } if !(l != 0) { - *(*uint8)(unsafe.Pointer(dst)) = uint8(0) + **(**uint8)(__ccgo_up(dst)) = uint8(0) return int32(1) } end = src + uintptr(l) @@ -118589,16 +118589,16 @@ func Xdn_comp(tls *TLS, src uintptr, dst uintptr, space int32, dnptrs uintptr, l return -int32(1) } p = dnptrs - if p != 0 && *(*uintptr)(unsafe.Pointer(p)) != 0 { + if p != 0 && **(**uintptr)(__ccgo_up(p)) != 0 { p += 8 for { - if !(*(*uintptr)(unsafe.Pointer(p)) != 0) { + if !(**(**uintptr)(__ccgo_up(p)) != 0) { break } - m = _match(tls, bp, *(*uintptr)(unsafe.Pointer(dnptrs)), *(*uintptr)(unsafe.Pointer(p)), end, bp+4, n) + m = _match(tls, bp, **(**uintptr)(__ccgo_up(dnptrs)), **(**uintptr)(__ccgo_up(p)), end, bp+4, n) if m > bestlen { bestlen = m - bestoff = *(*int32)(unsafe.Pointer(bp)) + bestoff = **(**int32)(__ccgo_up(bp)) if Uint64FromInt32(m) == l { break } @@ -118621,37 +118621,37 @@ func Xdn_comp(tls *TLS, src uintptr, dst uintptr, space int32, dnptrs uintptr, l if !(Uint64FromInt32(i) < l-Uint64FromInt32(bestlen)) { break } - *(*uint8)(unsafe.Pointer(dst + uintptr(i))) = (*(*[127]uint8)(unsafe.Pointer(bp + 4)))[j] + **(**uint8)(__ccgo_up(dst + uintptr(i))) = (**(**[127]uint8)(__ccgo_up(bp + 4)))[j] goto _2 _2: ; v3 = j j = j + 1 - i = i + (Int32FromUint8((*(*[127]uint8)(unsafe.Pointer(bp + 4)))[v3]) + int32(1)) + i = i + (Int32FromUint8((**(**[127]uint8)(__ccgo_up(bp + 4)))[v3]) + int32(1)) } /* add tail */ if bestlen != 0 { v3 = i i = i + 1 - *(*uint8)(unsafe.Pointer(dst + uintptr(v3))) = Uint8FromInt32(int32(0xc0) | bestoff>>int32(8)) + **(**uint8)(__ccgo_up(dst + uintptr(v3))) = Uint8FromInt32(int32(0xc0) | bestoff>>int32(8)) v3 = i i = i + 1 - *(*uint8)(unsafe.Pointer(dst + uintptr(v3))) = Uint8FromInt32(bestoff) + **(**uint8)(__ccgo_up(dst + uintptr(v3))) = Uint8FromInt32(bestoff) } else { v3 = i i = i + 1 - *(*uint8)(unsafe.Pointer(dst + uintptr(v3))) = uint8(0) + **(**uint8)(__ccgo_up(dst + uintptr(v3))) = uint8(0) } /* save dst pointer */ - if i > int32(2) && lastdnptr != 0 && dnptrs != 0 && *(*uintptr)(unsafe.Pointer(dnptrs)) != 0 { - for *(*uintptr)(unsafe.Pointer(p)) != 0 { + if i > int32(2) && lastdnptr != 0 && dnptrs != 0 && **(**uintptr)(__ccgo_up(dnptrs)) != 0 { + for **(**uintptr)(__ccgo_up(p)) != 0 { p += 8 } if p+uintptr(1)*8 < lastdnptr { v8 = p p += 8 - *(*uintptr)(unsafe.Pointer(v8)) = dst - *(*uintptr)(unsafe.Pointer(p)) = uintptr(0) + **(**uintptr)(__ccgo_up(v8)) = dst + **(**uintptr)(__ccgo_up(p)) = uintptr(0) } } return i @@ -118684,11 +118684,11 @@ func X__dn_expand(tls *TLS, base uintptr, end uintptr, src uintptr, dest uintptr break } /* loop invariants: p= int64(end)-int64(p) || int64(j) >= int64(dend)-int64(dest) { return -int32(1) } @@ -118719,10 +118719,10 @@ func X__dn_expand(tls *TLS, base uintptr, end uintptr, src uintptr, dest uintptr dest = dest + 1 v4 = p p = p + 1 - *(*int8)(unsafe.Pointer(v3)) = Int8FromUint8(*(*uint8)(unsafe.Pointer(v4))) + **(**int8)(__ccgo_up(v3)) = Int8FromUint8(**(**uint8)(__ccgo_up(v4))) } } else { - *(*int8)(unsafe.Pointer(dest)) = 0 + **(**int8)(__ccgo_up(dest)) = 0 if len1 < 0 { len1 = int32(int64(p+uintptr(1)) - int64(src)) } @@ -118754,20 +118754,20 @@ func Xdn_skipname(tls *TLS, s uintptr, end uintptr) (r int32) { _ = p p = s for p < end { - if !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if !(**(**uint8)(__ccgo_up(p)) != 0) { return int32(int64(p) - int64(s) + int64(1)) } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) >= int32(192) { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) >= int32(192) { if p+uintptr(1) < end { return int32(int64(p) - int64(s) + int64(2)) } else { break } } else { - if int64(end)-int64(p) < int64(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))+int32(1)) { + if int64(end)-int64(p) < int64(Int32FromUint8(**(**uint8)(__ccgo_up(p)))+int32(1)) { break } else { - p = p + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))+int32(1)) + p = p + uintptr(Int32FromUint8(**(**uint8)(__ccgo_up(p)))+int32(1)) } } } @@ -118883,25 +118883,25 @@ func X__dns_parse(tls *TLS, r uintptr, rlen int32, __ccgo_fp_callback uintptr, c if rlen < int32(12) { return -int32(1) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 3)))&int32(15) != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(r + 3)))&int32(15) != 0 { return 0 } p = r + uintptr(12) - qdcount = Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 4)))*int32(256) + Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 5))) - ancount = Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 6)))*int32(256) + Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 7))) + qdcount = Int32FromUint8(**(**uint8)(__ccgo_up(r + 4)))*int32(256) + Int32FromUint8(**(**uint8)(__ccgo_up(r + 5))) + ancount = Int32FromUint8(**(**uint8)(__ccgo_up(r + 6)))*int32(256) + Int32FromUint8(**(**uint8)(__ccgo_up(r + 7))) for { v1 = qdcount qdcount = qdcount - 1 if !(v1 != 0) { break } - for int64(p)-int64(r) < int64(rlen) && uint32(*(*uint8)(unsafe.Pointer(p)))-uint32(1) < uint32(127) { + for int64(p)-int64(r) < int64(rlen) && uint32(**(**uint8)(__ccgo_up(p)))-uint32(1) < uint32(127) { p = p + 1 } if p > r+uintptr(rlen)-uintptr(6) { return -int32(1) } - p = p + uintptr(int32(5)+BoolInt32(!!(*(*uint8)(unsafe.Pointer(p)) != 0))) + p = p + uintptr(int32(5)+BoolInt32(!!(**(**uint8)(__ccgo_up(p)) != 0))) } for { v1 = ancount @@ -118909,18 +118909,18 @@ func X__dns_parse(tls *TLS, r uintptr, rlen int32, __ccgo_fp_callback uintptr, c if !(v1 != 0) { break } - for int64(p)-int64(r) < int64(rlen) && uint32(*(*uint8)(unsafe.Pointer(p)))-uint32(1) < uint32(127) { + for int64(p)-int64(r) < int64(rlen) && uint32(**(**uint8)(__ccgo_up(p)))-uint32(1) < uint32(127) { p = p + 1 } if p > r+uintptr(rlen)-uintptr(12) { return -int32(1) } - p = p + uintptr(int32(1)+BoolInt32(!!(*(*uint8)(unsafe.Pointer(p)) != 0))) - len1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 8)))*int32(256) + Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 9))) + p = p + uintptr(int32(1)+BoolInt32(!!(**(**uint8)(__ccgo_up(p)) != 0))) + len1 = Int32FromUint8(**(**uint8)(__ccgo_up(p + 8)))*int32(256) + Int32FromUint8(**(**uint8)(__ccgo_up(p + 9))) if int64(len1+int32(10)) > int64(r+uintptr(rlen))-int64(p) { return -int32(1) } - if (*(*func(*TLS, uintptr, int32, uintptr, int32, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_callback})))(tls, ctx, Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))), p+uintptr(10), len1, r, rlen) < 0 { + if (*(*func(*TLS, uintptr, int32, uintptr, int32, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_callback})))(tls, ctx, Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))), p+uintptr(10), len1, r, rlen) < 0 { return -int32(1) } p = p + uintptr(int32(10)+len1) @@ -119262,27 +119262,27 @@ func Xether_aton_r(tls *TLS, x uintptr, p_a uintptr) (r uintptr) { break } if ii != 0 { - if int32(*(*int8)(unsafe.Pointer(x))) != int32(':') { + if int32(**(**int8)(__ccgo_up(x))) != int32(':') { return uintptr(0) } else { x = x + 1 } } n = Xstrtoul(tls, x, bp+8, int32(16)) - x = *(*uintptr)(unsafe.Pointer(bp + 8)) + x = **(**uintptr)(__ccgo_up(bp + 8)) if n > uint64(0xFF) { return uintptr(0) } /* bad byte */ - *(*Tuint8_t)(unsafe.Pointer(bp + uintptr(ii))) = uint8(n) + **(**Tuint8_t)(__ccgo_up(bp + uintptr(ii))) = uint8(n) goto _1 _1: ; ii = ii + 1 } - if int32(*(*int8)(unsafe.Pointer(x))) != 0 { + if int32(**(**int8)(__ccgo_up(x))) != 0 { return uintptr(0) } /* bad format */ - *(*Tether_addr)(unsafe.Pointer(p_a)) = *(*Tether_addr)(unsafe.Pointer(bp)) + **(**Tether_addr)(__ccgo_up(p_a)) = **(**Tether_addr)(__ccgo_up(bp)) return p_a } @@ -119317,7 +119317,7 @@ func Xether_ntoa_r(tls *TLS, p_a uintptr, x uintptr) (r uintptr) { } else { v2 = __ccgo_ts + 966 } - x = x + uintptr(Xsprintf(tls, x, v2, VaList(bp+8, Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(p_a + uintptr(ii))))))) + x = x + uintptr(Xsprintf(tls, x, v2, VaList(bp+8, Int32FromUint8(**(**Tuint8_t)(__ccgo_up(p_a + uintptr(ii))))))) goto _1 _1: ; @@ -119402,11 +119402,11 @@ func Xgai_strerror(tls *TLS, ecode int32) (r uintptr) { s = uintptr(unsafe.Pointer(&_msgs)) ecode = ecode + 1 for { - if !(ecode != 0 && *(*int8)(unsafe.Pointer(s)) != 0) { + if !(ecode != 0 && **(**int8)(__ccgo_up(s)) != 0) { break } for { - if !(*(*int8)(unsafe.Pointer(s)) != 0) { + if !(**(**int8)(__ccgo_up(s)) != 0) { break } goto _2 @@ -119420,7 +119420,7 @@ func Xgai_strerror(tls *TLS, ecode int32) (r uintptr) { ecode = ecode + 1 s = s + 1 } - if !(*(*int8)(unsafe.Pointer(s)) != 0) { + if !(**(**int8)(__ccgo_up(s)) != 0) { s = s + 1 } return X__lctrans_cur(tls, s) @@ -119496,15 +119496,15 @@ func Xgetaddrinfo(tls *TLS, host uintptr, serv uintptr, hint uintptr, res uintpt if s >= 0 { _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp+1608) r = Xconnect(tls, s, ta[i], tl[i]) - saved_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 1608)), uintptr(0)) + saved_errno = **(**int32)(__ccgo_up(X__errno_location(tls))) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 1608)), uintptr(0)) Xclose(tls, s) if !(r != 0) { goto _1 } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = saved_errno + **(**int32)(__ccgo_up(X__errno_location(tls))) = saved_errno } - switch *(*int32)(unsafe.Pointer(X__errno_location(tls))) { + switch **(**int32)(__ccgo_up(X__errno_location(tls))) { case int32(EADDRNOTAVAIL): fallthrough case int32(EAFNOSUPPORT): @@ -119562,32 +119562,32 @@ func Xgetaddrinfo(tls *TLS, host uintptr, serv uintptr, hint uintptr, res uintpt if !(j < nservs) { break } - (*(*Taibuf)(unsafe.Pointer(out + uintptr(k)*88))).Fslot = int16(k) - if (*(*[48]Taddress)(unsafe.Pointer(bp + 8)))[i].Ffamily == int32(PF_INET) { + (**(**Taibuf)(__ccgo_up(out + uintptr(k)*88))).Fslot = int16(k) + if (**(**[48]Taddress)(__ccgo_up(bp + 8)))[i].Ffamily == int32(PF_INET) { v5 = uint64(16) } else { v5 = uint64(28) } - (*(*Taibuf)(unsafe.Pointer(out + uintptr(k)*88))).Fai = Taddrinfo{ - Fai_family: (*(*[48]Taddress)(unsafe.Pointer(bp + 8)))[i].Ffamily, - Fai_socktype: Int32FromUint8((*(*[2]Tservice)(unsafe.Pointer(bp)))[j].Fsocktype), - Fai_protocol: Int32FromUint8((*(*[2]Tservice)(unsafe.Pointer(bp)))[j].Fproto), + (**(**Taibuf)(__ccgo_up(out + uintptr(k)*88))).Fai = Taddrinfo{ + Fai_family: (**(**[48]Taddress)(__ccgo_up(bp + 8)))[i].Ffamily, + Fai_socktype: Int32FromUint8((**(**[2]Tservice)(__ccgo_up(bp)))[j].Fsocktype), + Fai_protocol: Int32FromUint8((**(**[2]Tservice)(__ccgo_up(bp)))[j].Fproto), Fai_addrlen: uint32(v5), Fai_addr: out + uintptr(k)*88 + 48, Fai_canonname: outcanon, } if k != 0 { - (*(*Taibuf)(unsafe.Pointer(out + uintptr(k-int32(1))*88))).Fai.Fai_next = out + uintptr(k)*88 + (**(**Taibuf)(__ccgo_up(out + uintptr(k-int32(1))*88))).Fai.Fai_next = out + uintptr(k)*88 } - switch (*(*[48]Taddress)(unsafe.Pointer(bp + 8)))[i].Ffamily { + switch (**(**[48]Taddress)(__ccgo_up(bp + 8)))[i].Ffamily { case int32(PF_INET): *(*Tsa_family_t)(unsafe.Pointer(out + uintptr(k)*88 + 48)) = uint16(PF_INET) - *(*Tin_port_t)(unsafe.Pointer(out + uintptr(k)*88 + 48 + 2)) = Xhtons(tls, (*(*[2]Tservice)(unsafe.Pointer(bp)))[j].Fport) + *(*Tin_port_t)(unsafe.Pointer(out + uintptr(k)*88 + 48 + 2)) = Xhtons(tls, (**(**[2]Tservice)(__ccgo_up(bp)))[j].Fport) Xmemcpy(tls, out+uintptr(k)*88+48+4, bp+8+uintptr(i)*28+8, uint64(4)) case int32(PF_INET6): *(*Tsa_family_t)(unsafe.Pointer(out + uintptr(k)*88 + 48)) = uint16(PF_INET6) - *(*Tin_port_t)(unsafe.Pointer(out + uintptr(k)*88 + 48 + 2)) = Xhtons(tls, (*(*[2]Tservice)(unsafe.Pointer(bp)))[j].Fport) - *(*Tuint32_t)(unsafe.Pointer(out + uintptr(k)*88 + 48 + 24)) = (*(*[48]Taddress)(unsafe.Pointer(bp + 8)))[i].Fscopeid + *(*Tin_port_t)(unsafe.Pointer(out + uintptr(k)*88 + 48 + 2)) = Xhtons(tls, (**(**[2]Tservice)(__ccgo_up(bp)))[j].Fport) + *(*Tuint32_t)(unsafe.Pointer(out + uintptr(k)*88 + 48 + 24)) = (**(**[48]Taddress)(__ccgo_up(bp + 8)))[i].Fscopeid Xmemcpy(tls, out+uintptr(k)*88+48+8, bp+8+uintptr(i)*28+8, uint64(16)) break } @@ -119602,8 +119602,8 @@ func Xgetaddrinfo(tls *TLS, host uintptr, serv uintptr, hint uintptr, res uintpt ; i = i + 1 } - (*(*Taibuf)(unsafe.Pointer(out))).Fref = int16(nais) - *(*uintptr)(unsafe.Pointer(res)) = out + (**(**Taibuf)(__ccgo_up(out))).Fref = int16(nais) + **(**uintptr)(__ccgo_up(res)) = out return 0 } @@ -119734,12 +119734,12 @@ func Xgethostbyaddr(tls *TLS, a uintptr, l Tsocklen_t, af int32) (r uintptr) { size = size + (size + uint64(1)) _h = Xmalloc(tls, size) if !(_h != 0) { - *(*int32)(unsafe.Pointer(X__h_errno_location(tls))) = int32(NO_RECOVERY) + **(**int32)(__ccgo_up(X__h_errno_location(tls))) = int32(NO_RECOVERY) return uintptr(0) } err = Xgethostbyaddr_r(tls, a, l, af, _h, _h+UintptrFromInt32(1)*32, size-uint64(32), bp, X__h_errno_location(tls)) } - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } var _h uintptr @@ -119776,7 +119776,7 @@ func Xgethostbyaddr_r(tls *TLS, a uintptr, l Tsocklen_t, af int32, h uintptr, bu v1 = uint64(16) } sl = uint32(v1) - *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) + **(**uintptr)(__ccgo_up(res)) = uintptr(0) /* Load address argument into sockaddr structure */ if af == int32(PF_INET6) && l == uint32(16) { Xmemcpy(tls, bp+8, a, uint64(16)) @@ -119784,7 +119784,7 @@ func Xgethostbyaddr_r(tls *TLS, a uintptr, l Tsocklen_t, af int32, h uintptr, bu if af == int32(PF_INET) && l == uint32(4) { Xmemcpy(tls, bp+4, a, uint64(4)) } else { - *(*int32)(unsafe.Pointer(err)) = int32(NO_RECOVERY) + **(**int32)(__ccgo_up(err)) = int32(NO_RECOVERY) return int32(EINVAL) } } @@ -119802,33 +119802,33 @@ func Xgethostbyaddr_r(tls *TLS, a uintptr, l Tsocklen_t, af int32, h uintptr, bu buf = buf + uintptr(Uint64FromInt32(2)*Uint64FromInt64(8)) (*Thostent)(unsafe.Pointer(h)).Fh_aliases = buf buf = buf + uintptr(Uint64FromInt32(2)*Uint64FromInt64(8)) - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list)) = buf - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list)), a, uint64(l)) + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_addr_list)) = buf + Xmemcpy(tls, **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_addr_list)), a, uint64(l)) buf = buf + uintptr(l) - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + 1*8)) = uintptr(0) - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) = buf - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = uintptr(0) + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + 1*8)) = uintptr(0) + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) = buf + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = uintptr(0) switch Xgetnameinfo(tls, bp, sl, buf, uint32(buflen), uintptr(0), uint32(0), 0) { case -int32(3): - *(*int32)(unsafe.Pointer(err)) = int32(TRY_AGAIN) + **(**int32)(__ccgo_up(err)) = int32(TRY_AGAIN) return int32(EAGAIN) case -int32(12): return int32(ERANGE) default: fallthrough case -int32(4): - *(*int32)(unsafe.Pointer(err)) = int32(NO_RECOVERY) + **(**int32)(__ccgo_up(err)) = int32(NO_RECOVERY) return int32(EBADMSG) case -int32(11): - *(*int32)(unsafe.Pointer(err)) = int32(NO_RECOVERY) - return *(*int32)(unsafe.Pointer(X__errno_location(tls))) + **(**int32)(__ccgo_up(err)) = int32(NO_RECOVERY) + return **(**int32)(__ccgo_up(X__errno_location(tls))) case 0: break } (*Thostent)(unsafe.Pointer(h)).Fh_addrtype = af (*Thostent)(unsafe.Pointer(h)).Fh_length = Int32FromUint32(l) - (*Thostent)(unsafe.Pointer(h)).Fh_name = *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) - *(*uintptr)(unsafe.Pointer(res)) = h + (*Thostent)(unsafe.Pointer(h)).Fh_name = **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) + **(**uintptr)(__ccgo_up(res)) = h return 0 } @@ -119857,12 +119857,12 @@ func Xgethostbyname2(tls *TLS, name uintptr, af int32) (r uintptr) { size = size + (size + uint64(1)) _h1 = Xmalloc(tls, size) if !(_h1 != 0) { - *(*int32)(unsafe.Pointer(X__h_errno_location(tls))) = int32(NO_RECOVERY) + **(**int32)(__ccgo_up(X__h_errno_location(tls))) = int32(NO_RECOVERY) return uintptr(0) } err = Xgethostbyname2_r(tls, name, af, _h1, _h1+UintptrFromInt32(1)*32, size-uint64(32), bp, X__h_errno_location(tls)) } - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } var _h1 uintptr @@ -119880,27 +119880,27 @@ func Xgethostbyname2_r(tls *TLS, name uintptr, af int32, h uintptr, buf uintptr, var _ /* addrs at bp+0 */ [48]Taddress var _ /* canon at bp+1344 */ [256]int8 _, _, _, _, _, _ = align, cnt, i, need, v1, v3 - *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) + **(**uintptr)(__ccgo_up(res)) = uintptr(0) cnt = X__lookup_name(tls, bp, bp+1344, name, af, int32(AI_CANONNAME)) if cnt < 0 { switch cnt { case -int32(2): - *(*int32)(unsafe.Pointer(err)) = int32(HOST_NOT_FOUND) + **(**int32)(__ccgo_up(err)) = int32(HOST_NOT_FOUND) return 0 case -int32(5): - *(*int32)(unsafe.Pointer(err)) = int32(NO_DATA) + **(**int32)(__ccgo_up(err)) = int32(NO_DATA) return 0 case -int32(3): - *(*int32)(unsafe.Pointer(err)) = int32(TRY_AGAIN) + **(**int32)(__ccgo_up(err)) = int32(TRY_AGAIN) return int32(EAGAIN) default: fallthrough case -int32(4): - *(*int32)(unsafe.Pointer(err)) = int32(NO_RECOVERY) + **(**int32)(__ccgo_up(err)) = int32(NO_RECOVERY) return int32(EBADMSG) case -int32(11): - *(*int32)(unsafe.Pointer(err)) = int32(NO_RECOVERY) - return *(*int32)(unsafe.Pointer(X__errno_location(tls))) + **(**int32)(__ccgo_up(err)) = int32(NO_RECOVERY) + return **(**int32)(__ccgo_up(X__errno_location(tls))) } } (*Thostent)(unsafe.Pointer(h)).Fh_addrtype = af @@ -119930,29 +119930,29 @@ func Xgethostbyname2_r(tls *TLS, name uintptr, af int32, h uintptr, buf uintptr, if !(i < cnt) { break } - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)) = buf + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)) = buf buf = buf + uintptr((*Thostent)(unsafe.Pointer(h)).Fh_length) - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)), bp+uintptr(i)*28+8, Uint64FromInt32((*Thostent)(unsafe.Pointer(h)).Fh_length)) + Xmemcpy(tls, **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)), bp+uintptr(i)*28+8, Uint64FromInt32((*Thostent)(unsafe.Pointer(h)).Fh_length)) goto _2 _2: ; i = i + 1 } - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)) = uintptr(0) + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)) = uintptr(0) v3 = buf - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) = v3 + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) = v3 (*Thostent)(unsafe.Pointer(h)).Fh_name = v3 Xstrcpy(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name, bp+1344) buf = buf + uintptr(_strlen(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name)+uint64(1)) if Xstrcmp(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name, name) != 0 { - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = buf - Xstrcpy(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)), name) - buf = buf + uintptr(_strlen(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)))+uint64(1)) + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = buf + Xstrcpy(tls, **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)), name) + buf = buf + uintptr(_strlen(tls, **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)))+uint64(1)) } else { - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = uintptr(0) + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = uintptr(0) } - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 2*8)) = uintptr(0) - *(*uintptr)(unsafe.Pointer(res)) = h + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 2*8)) = uintptr(0) + **(**uintptr)(__ccgo_up(res)) = h return 0 } @@ -120181,7 +120181,7 @@ func _copy_addr(tls *TLS, r uintptr, af int32, sa uintptr, addr uintptr, addrlen case int32(PF_INET6): dst = sa + 8 len1 = int32(16) - if Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(addr))) == int32(0xfe) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(addr + 1)))&int32(0xc0) == int32(0x80) || Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(addr))) == int32(0xff) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(addr + 1)))&int32(0xf) == int32(0x2) { + if Int32FromUint8(**(**Tuint8_t)(__ccgo_up(addr))) == int32(0xfe) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(addr + 1)))&int32(0xc0) == int32(0x80) || Int32FromUint8(**(**Tuint8_t)(__ccgo_up(addr))) == int32(0xff) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(addr + 1)))&int32(0xf) == int32(0x2) { (*(*Tsockaddr_in6)(unsafe.Pointer(sa))).Fsin6_scope_id = Uint32FromInt32(ifindex) } default: @@ -120192,7 +120192,7 @@ func _copy_addr(tls *TLS, r uintptr, af int32, sa uintptr, addr uintptr, addrlen } (*Tsockany)(unsafe.Pointer(sa)).Fsa.Fsa_family = Uint16FromInt32(af) Xmemcpy(tls, dst, addr, Uint64FromInt32(len1)) - *(*uintptr)(unsafe.Pointer(r)) = sa + **(**uintptr)(__ccgo_up(r)) = sa } func _gen_netmask(tls *TLS, r uintptr, af int32, sa uintptr, prefixlen int32) { @@ -120201,7 +120201,7 @@ func _gen_netmask(tls *TLS, r uintptr, af int32, sa uintptr, prefixlen int32) { var i, v1 int32 var _ /* addr at bp+0 */ [16]Tuint8_t _, _ = i, v1 - *(*[16]Tuint8_t)(unsafe.Pointer(bp)) = [16]Tuint8_t{} + **(**[16]Tuint8_t)(__ccgo_up(bp)) = [16]Tuint8_t{} if Uint64FromInt32(prefixlen) > Uint64FromInt32(8)*Uint64FromInt64(16) { prefixlen = Int32FromUint64(Uint64FromInt32(8) * Uint64FromInt64(16)) } @@ -120210,7 +120210,7 @@ func _gen_netmask(tls *TLS, r uintptr, af int32, sa uintptr, prefixlen int32) { if Uint64FromInt32(i) < uint64(16) { v1 = i i = i + 1 - (*(*[16]Tuint8_t)(unsafe.Pointer(bp)))[v1] = Uint8FromInt32(int32(0xff) << (int32(8) - prefixlen%int32(8))) + (**(**[16]Tuint8_t)(__ccgo_up(bp)))[v1] = Uint8FromInt32(int32(0xff) << (int32(8) - prefixlen%int32(8))) } _copy_addr(tls, r, af, sa, bp, uint64(16), 0) } @@ -120224,7 +120224,7 @@ func _copy_lladdr(tls *TLS, r uintptr, sa uintptr, addr uintptr, addrlen Tsize_t (*(*Tsockaddr_ll_hack)(unsafe.Pointer(sa))).Fsll_hatype = hatype (*(*Tsockaddr_ll_hack)(unsafe.Pointer(sa))).Fsll_halen = uint8(addrlen) Xmemcpy(tls, sa+12, addr, addrlen) - *(*uintptr)(unsafe.Pointer(r)) = sa + **(**uintptr)(__ccgo_up(r)) = sa } func _netlink_msg_to_ifaddr(tls *TLS, pctx uintptr, h uintptr) (r int32) { @@ -120253,7 +120253,7 @@ func _netlink_msg_to_ifaddr(tls *TLS, pctx uintptr, h uintptr) (r int32) { rta = rta + uintptr((Int32FromUint16((*Trtattr)(unsafe.Pointer(rta)).Frta_len)+Int32FromInt32(3)) & ^Int32FromInt32(3)) } } else { - ifs0 = *(*uintptr)(unsafe.Pointer(ctx + 16 + uintptr((*Tifaddrmsg)(unsafe.Pointer(ifa)).Fifa_index%uint32(IFADDRS_HASH_SIZE))*8)) + ifs0 = **(**uintptr)(__ccgo_up(ctx + 16 + uintptr((*Tifaddrmsg)(unsafe.Pointer(ifa)).Fifa_index%uint32(IFADDRS_HASH_SIZE))*8)) for { if !(ifs0 != 0) { break @@ -120304,8 +120304,8 @@ func _netlink_msg_to_ifaddr(tls *TLS, pctx uintptr, h uintptr) (r int32) { } if (*Tifaddrs_storage)(unsafe.Pointer(ifs)).Fifa.Fifa_name != 0 { bucket = (*Tifaddrs_storage)(unsafe.Pointer(ifs)).Findex % uint32(IFADDRS_HASH_SIZE) - (*Tifaddrs_storage)(unsafe.Pointer(ifs)).Fhash_next = *(*uintptr)(unsafe.Pointer(ctx + 16 + uintptr(bucket)*8)) - *(*uintptr)(unsafe.Pointer(ctx + 16 + uintptr(bucket)*8)) = ifs + (*Tifaddrs_storage)(unsafe.Pointer(ifs)).Fhash_next = **(**uintptr)(__ccgo_up(ctx + 16 + uintptr(bucket)*8)) + **(**uintptr)(__ccgo_up(ctx + 16 + uintptr(bucket)*8)) = ifs } } else { (*Tifaddrs_storage)(unsafe.Pointer(ifs)).Fifa.Fifa_name = (*Tifaddrs_storage)(unsafe.Pointer(ifs0)).Fifa.Fifa_name @@ -120380,7 +120380,7 @@ func Xgetifaddrs(tls *TLS, ifap uintptr) (r1 int32) { Xmemset(tls, ctx, 0, uint64(528)) r = X__rtnetlink_enumerate(tls, PF_UNSPEC, PF_UNSPEC, __ccgo_fp(_netlink_msg_to_ifaddr), ctx) if r == 0 { - *(*uintptr)(unsafe.Pointer(ifap)) = (*Tifaddrs_ctx)(unsafe.Pointer(ctx)).Ffirst + **(**uintptr)(__ccgo_up(ifap)) = (*Tifaddrs_ctx)(unsafe.Pointer(ctx)).Ffirst } else { Xfreeifaddrs(tls, (*Tifaddrs_ctx)(unsafe.Pointer(ctx)).Ffirst) } @@ -120395,11 +120395,11 @@ func _itoa(tls *TLS, p uintptr, x uint32) (r uintptr) { p = p + uintptr(Uint64FromInt32(3)*Uint64FromInt64(4)) p = p - 1 v1 = p - *(*int8)(unsafe.Pointer(v1)) = 0 + **(**int8)(__ccgo_up(v1)) = 0 for cond := true; cond; cond = x != 0 { p = p - 1 v1 = p - *(*int8)(unsafe.Pointer(v1)) = Int8FromUint32(uint32('0') + x%uint32(10)) + **(**int8)(__ccgo_up(v1)) = Int8FromUint32(uint32('0') + x%uint32(10)) x = x / uint32(10) } return p @@ -120408,7 +120408,7 @@ func _itoa(tls *TLS, p uintptr, x uint32) (r uintptr) { func _mkptr4(tls *TLS, s uintptr, ip uintptr) { bp := tls.Alloc(48) defer tls.Free(48) - Xsprintf(tls, s, __ccgo_ts+972, VaList(bp+8, Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + 3))), Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + 2))), Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + 1))), Int32FromUint8(*(*uint8)(unsafe.Pointer(ip))))) + Xsprintf(tls, s, __ccgo_ts+972, VaList(bp+8, Int32FromUint8(**(**uint8)(__ccgo_up(ip + 3))), Int32FromUint8(**(**uint8)(__ccgo_up(ip + 2))), Int32FromUint8(**(**uint8)(__ccgo_up(ip + 1))), Int32FromUint8(**(**uint8)(__ccgo_up(ip))))) } func _mkptr6(tls *TLS, s uintptr, ip uintptr) { @@ -120422,16 +120422,16 @@ func _mkptr6(tls *TLS, s uintptr, ip uintptr) { } v2 = s s = s + 1 - *(*int8)(unsafe.Pointer(v2)) = _xdigits[Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + uintptr(i))))&int32(15)] + **(**int8)(__ccgo_up(v2)) = _xdigits[Int32FromUint8(**(**uint8)(__ccgo_up(ip + uintptr(i))))&int32(15)] v2 = s s = s + 1 - *(*int8)(unsafe.Pointer(v2)) = int8('.') + **(**int8)(__ccgo_up(v2)) = int8('.') v2 = s s = s + 1 - *(*int8)(unsafe.Pointer(v2)) = _xdigits[Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + uintptr(i))))>>int32(4)] + **(**int8)(__ccgo_up(v2)) = _xdigits[Int32FromUint8(**(**uint8)(__ccgo_up(ip + uintptr(i))))>>int32(4)] v2 = s s = s + 1 - *(*int8)(unsafe.Pointer(v2)) = int8('.') + **(**int8)(__ccgo_up(v2)) = int8('.') goto _1 _1: ; @@ -120469,13 +120469,13 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int if v1 != 0 { v2 = p p = p + 1 - *(*int8)(unsafe.Pointer(v2)) = int8('\n') - *(*int8)(unsafe.Pointer(p)) = Int8FromInt32(0) + **(**int8)(__ccgo_up(v2)) = int8('\n') + **(**int8)(__ccgo_up(p)) = Int8FromInt32(0) } p = bp for { - if v7 = *(*int8)(unsafe.Pointer(p)) != 0; v7 { - v4 = int32(*(*int8)(unsafe.Pointer(p))) + if v7 = **(**int8)(__ccgo_up(p)) != 0; v7 { + v4 = int32(**(**int8)(__ccgo_up(p))) v5 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _6 _6: @@ -120488,26 +120488,26 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int ; p = p + 1 } - if !(*(*int8)(unsafe.Pointer(p)) != 0) { + if !(**(**int8)(__ccgo_up(p)) != 0) { continue } v1 = p p = p + 1 - *(*int8)(unsafe.Pointer(v1)) = 0 + **(**int8)(__ccgo_up(v1)) = 0 if X__lookup_ipliteral(tls, bp+1560, bp, PF_UNSPEC) <= 0 { continue } - if (*(*Taddress)(unsafe.Pointer(bp + 1560))).Ffamily == int32(PF_INET) { + if (**(**Taddress)(__ccgo_up(bp + 1560))).Ffamily == int32(PF_INET) { Xmemcpy(tls, bp+1560+8+uintptr(12), bp+1560+8, uint64(4)) Xmemcpy(tls, bp+1560+8, __ccgo_ts+1017, uint64(12)) - (*(*Taddress)(unsafe.Pointer(bp + 1560))).Fscopeid = uint32(0) + (**(**Taddress)(__ccgo_up(bp + 1560))).Fscopeid = uint32(0) } - if Xmemcmp(tls, a, bp+1560+8, uint64(16)) != 0 || (*(*Taddress)(unsafe.Pointer(bp + 1560))).Fscopeid != scopeid { + if Xmemcmp(tls, a, bp+1560+8, uint64(16)) != 0 || (**(**Taddress)(__ccgo_up(bp + 1560))).Fscopeid != scopeid { continue } for { - if v7 = *(*int8)(unsafe.Pointer(p)) != 0; v7 { - v4 = int32(*(*int8)(unsafe.Pointer(p))) + if v7 = **(**int8)(__ccgo_up(p)) != 0; v7 { + v4 = int32(**(**int8)(__ccgo_up(p))) v5 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _12 _12: @@ -120522,8 +120522,8 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int } z = p for { - if v7 = *(*int8)(unsafe.Pointer(z)) != 0; v7 { - v4 = int32(*(*int8)(unsafe.Pointer(z))) + if v7 = **(**int8)(__ccgo_up(z)) != 0; v7 { + v4 = int32(**(**int8)(__ccgo_up(z))) v5 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _17 _17: @@ -120536,7 +120536,7 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int ; z = z + 1 } - *(*int8)(unsafe.Pointer(z)) = 0 + **(**int8)(__ccgo_up(z)) = 0 if int64(z)-int64(p) < int64(256) { Xmemcpy(tls, buf, p, Uint64FromInt64(int64(z)-int64(p)+int64(1))) break @@ -120567,13 +120567,13 @@ func _reverse_services(tls *TLS, buf uintptr, port int32, dgram int32) { if v1 != 0 { v2 = p p = p + 1 - *(*int8)(unsafe.Pointer(v2)) = int8('\n') - *(*int8)(unsafe.Pointer(p)) = Int8FromInt32(0) + **(**int8)(__ccgo_up(v2)) = int8('\n') + **(**int8)(__ccgo_up(p)) = Int8FromInt32(0) } p = bp for { - if v7 = *(*int8)(unsafe.Pointer(p)) != 0; v7 { - v4 = int32(*(*int8)(unsafe.Pointer(p))) + if v7 = **(**int8)(__ccgo_up(p)) != 0; v7 { + v4 = int32(**(**int8)(__ccgo_up(p))) v5 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _6 _6: @@ -120586,20 +120586,20 @@ func _reverse_services(tls *TLS, buf uintptr, port int32, dgram int32) { ; p = p + 1 } - if !(*(*int8)(unsafe.Pointer(p)) != 0) { + if !(**(**int8)(__ccgo_up(p)) != 0) { continue } v1 = p p = p + 1 - *(*int8)(unsafe.Pointer(v1)) = 0 + **(**int8)(__ccgo_up(v1)) = 0 svport = Xstrtoul(tls, p, bp+128, int32(10)) - if svport != Uint64FromInt32(port) || *(*uintptr)(unsafe.Pointer(bp + 128)) == p { + if svport != Uint64FromInt32(port) || **(**uintptr)(__ccgo_up(bp + 128)) == p { continue } - if dgram != 0 && Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(bp + 128)), __ccgo_ts+1044, uint64(4)) != 0 { + if dgram != 0 && Xstrncmp(tls, **(**uintptr)(__ccgo_up(bp + 128)), __ccgo_ts+1044, uint64(4)) != 0 { continue } - if !(dgram != 0) && Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(bp + 128)), __ccgo_ts+1049, uint64(4)) != 0 { + if !(dgram != 0) && Xstrncmp(tls, **(**uintptr)(__ccgo_up(bp + 128)), __ccgo_ts+1049, uint64(4)) != 0 { continue } if int64(p)-t__predefined_ptrdiff_t(bp) > int64(32) { @@ -120616,7 +120616,7 @@ func _dns_parse_callback(tls *TLS, c uintptr, rr int32, data uintptr, len1 int32 return 0 } if X__dn_expand(tls, packet, packet+uintptr(plen), data, c, int32(256)) <= 0 { - *(*int8)(unsafe.Pointer(c)) = 0 + **(**int8)(__ccgo_up(c)) = 0 } return 0 } @@ -120662,15 +120662,15 @@ func Xgetnameinfo(tls *TLS, sa uintptr, sl Tsocklen_t, node uintptr, nodelen Tso return -int32(6) } if node != 0 && nodelen != 0 { - (*(*[256]int8)(unsafe.Pointer(bp + 78)))[0] = 0 + (**(**[256]int8)(__ccgo_up(bp + 78)))[0] = 0 if !(flags&Int32FromInt32(NI_NUMERICHOST) != 0) { _reverse_hosts(tls, bp+78, a, scopeid, af) } - if !(*(*int8)(unsafe.Pointer(bp + 78)) != 0) && !(flags&Int32FromInt32(NI_NUMERICHOST) != 0) { + if !(**(**int8)(__ccgo_up(bp + 78)) != 0) && !(flags&Int32FromInt32(NI_NUMERICHOST) != 0) { qlen = X__res_mkquery(tls, 0, bp, int32(1), int32(RR_PTR), uintptr(0), 0, uintptr(0), bp+347, int32(96)) - (*(*[96]uint8)(unsafe.Pointer(bp + 347)))[int32(3)] = uint8(0) /* don't need AD flag */ + (**(**[96]uint8)(__ccgo_up(bp + 347)))[int32(3)] = uint8(0) /* don't need AD flag */ rlen = X__res_send(tls, bp+347, qlen, bp+443, int32(512)) - (*(*[256]int8)(unsafe.Pointer(bp + 78)))[0] = 0 + (**(**[256]int8)(__ccgo_up(bp + 78)))[0] = 0 if rlen > 0 { if Uint64FromInt32(rlen) > uint64(512) { rlen = int32(512) @@ -120678,14 +120678,14 @@ func Xgetnameinfo(tls *TLS, sa uintptr, sl Tsocklen_t, node uintptr, nodelen Tso X__dns_parse(tls, bp+443, rlen, __ccgo_fp(_dns_parse_callback), bp+78) } } - if !(*(*int8)(unsafe.Pointer(bp + 78)) != 0) { + if !(**(**int8)(__ccgo_up(bp + 78)) != 0) { if flags&int32(NI_NAMEREQD) != 0 { return -int32(2) } Xinet_ntop(tls, af, a, bp+78, uint32(256)) if scopeid != 0 { p = uintptr(0) - if !(flags&Int32FromInt32(NI_NUMERICSCOPE) != 0) && (Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a))) == int32(0xfe) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 1)))&int32(0xc0) == int32(0x80) || Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a))) == int32(0xff) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 1)))&int32(0xf) == int32(0x2)) { + if !(flags&Int32FromInt32(NI_NUMERICSCOPE) != 0) && (Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a))) == int32(0xfe) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 1)))&int32(0xc0) == int32(0x80) || Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a))) == int32(0xff) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 1)))&int32(0xf) == int32(0x2)) { p = Xif_indextoname(tls, scopeid, bp+955+uintptr(1)) } if !(p != 0) { @@ -120693,7 +120693,7 @@ func Xgetnameinfo(tls *TLS, sa uintptr, sl Tsocklen_t, node uintptr, nodelen Tso } p = p - 1 v1 = p - *(*int8)(unsafe.Pointer(v1)) = int8('%') + **(**int8)(__ccgo_up(v1)) = int8('%') Xstrcat(tls, bp+78, p) } } @@ -120705,11 +120705,11 @@ func Xgetnameinfo(tls *TLS, sa uintptr, sl Tsocklen_t, node uintptr, nodelen Tso if serv != 0 && servlen != 0 { p1 = bp + 78 port = Int32FromUint16(Xntohs(tls, (*Tsockaddr_in)(unsafe.Pointer(sa)).Fsin_port)) - (*(*[256]int8)(unsafe.Pointer(bp + 78)))[0] = 0 + (**(**[256]int8)(__ccgo_up(bp + 78)))[0] = 0 if !(flags&Int32FromInt32(NI_NUMERICSERV) != 0) { _reverse_services(tls, bp+78, port, flags&int32(NI_DGRAM)) } - if !(*(*int8)(unsafe.Pointer(p1)) != 0) { + if !(**(**int8)(__ccgo_up(p1)) != 0) { p1 = _itoa(tls, bp+334, Uint32FromInt32(port)) } if _strlen(tls, p1) >= uint64(servlen) { @@ -120784,11 +120784,11 @@ func Xgetservbyname_r(tls *TLS, name uintptr, prots uintptr, se uintptr, buf uin var _ /* end at bp+8 */ uintptr var _ /* servs at bp+0 */ [2]Tservice _, _, _, _ = align, cnt, proto, v1 - *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) + **(**uintptr)(__ccgo_up(res)) = uintptr(0) /* Don't treat numeric port number strings as service records. */ - *(*uintptr)(unsafe.Pointer(bp + 8)) = __ccgo_ts + **(**uintptr)(__ccgo_up(bp + 8)) = __ccgo_ts Xstrtoul(tls, name, bp+8, int32(10)) - if !(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) != 0) { + if !(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) != 0) { return int32(ENOENT) } /* Align buffer */ @@ -120823,16 +120823,16 @@ func Xgetservbyname_r(tls *TLS, name uintptr, prots uintptr, se uintptr, buf uin } (*Tservent)(unsafe.Pointer(se)).Fs_name = name (*Tservent)(unsafe.Pointer(se)).Fs_aliases = buf - *(*uintptr)(unsafe.Pointer((*Tservent)(unsafe.Pointer(se)).Fs_aliases)) = (*Tservent)(unsafe.Pointer(se)).Fs_name - *(*uintptr)(unsafe.Pointer((*Tservent)(unsafe.Pointer(se)).Fs_aliases + 1*8)) = uintptr(0) - (*Tservent)(unsafe.Pointer(se)).Fs_port = Int32FromUint16(Xhtons(tls, (*(*[2]Tservice)(unsafe.Pointer(bp)))[0].Fport)) - if Int32FromUint8((*(*[2]Tservice)(unsafe.Pointer(bp)))[0].Fproto) == int32(IPPROTO_TCP) { + **(**uintptr)(__ccgo_up((*Tservent)(unsafe.Pointer(se)).Fs_aliases)) = (*Tservent)(unsafe.Pointer(se)).Fs_name + **(**uintptr)(__ccgo_up((*Tservent)(unsafe.Pointer(se)).Fs_aliases + 1*8)) = uintptr(0) + (*Tservent)(unsafe.Pointer(se)).Fs_port = Int32FromUint16(Xhtons(tls, (**(**[2]Tservice)(__ccgo_up(bp)))[0].Fport)) + if Int32FromUint8((**(**[2]Tservice)(__ccgo_up(bp)))[0].Fproto) == int32(IPPROTO_TCP) { v1 = __ccgo_ts + 1054 } else { v1 = __ccgo_ts + 1058 } (*Tservent)(unsafe.Pointer(se)).Fs_proto = v1 - *(*uintptr)(unsafe.Pointer(res)) = se + **(**uintptr)(__ccgo_up(res)) = se return 0 } @@ -120912,7 +120912,7 @@ _9: if true { break } - if uint64(*(*Tsocklen_t)(unsafe.Pointer(optlen))) < uint64(16) { + if uint64(**(**Tsocklen_t)(__ccgo_up(optlen))) < uint64(16) { return int32(X__syscall_ret(tls, Uint64FromInt32(-Int32FromInt32(EINVAL)))) } if optname == int32(SO_RCVTIMEO) { @@ -120949,9 +120949,9 @@ _9: break } tv = optval - (*Ttimeval)(unsafe.Pointer(tv)).Ftv_sec = (*(*[2]int64)(unsafe.Pointer(bp + 8)))[0] - (*Ttimeval)(unsafe.Pointer(tv)).Ftv_usec = (*(*[2]int64)(unsafe.Pointer(bp + 8)))[int32(1)] - *(*Tsocklen_t)(unsafe.Pointer(optlen)) = uint32(16) + (*Ttimeval)(unsafe.Pointer(tv)).Ftv_sec = (**(**[2]int64)(__ccgo_up(bp + 8)))[0] + (*Ttimeval)(unsafe.Pointer(tv)).Ftv_usec = (**(**[2]int64)(__ccgo_up(bp + 8)))[int32(1)] + **(**Tsocklen_t)(__ccgo_up(optlen)) = uint32(16) case int32(SO_TIMESTAMP): fallthrough case int32(SO_TIMESTAMPNS): @@ -121021,7 +121021,7 @@ func Xherror(tls *TLS, msg uintptr) { } else { v2 = __ccgo_ts } - Xfprintf(tls, uintptr(unsafe.Pointer(&X__stderr_FILE)), __ccgo_ts+1062, VaList(bp+8, v1, v2, Xhstrerror(tls, *(*int32)(unsafe.Pointer(X__h_errno_location(tls)))))) + Xfprintf(tls, uintptr(unsafe.Pointer(&X__stderr_FILE)), __ccgo_ts+1062, VaList(bp+8, v1, v2, Xhstrerror(tls, **(**int32)(__ccgo_up(X__h_errno_location(tls)))))) } var _msgs1 = [84]int8{'H', 'o', 's', 't', ' ', 'n', 'o', 't', ' ', 'f', 'o', 'u', 'n', 'd', 0, 'T', 'r', 'y', ' ', 'a', 'g', 'a', 'i', 'n', 0, 'N', 'o', 'n', '-', 'r', 'e', 'c', 'o', 'v', 'e', 'r', 'a', 'b', 'l', 'e', ' ', 'e', 'r', 'r', 'o', 'r', 0, 'A', 'd', 'd', 'r', 'e', 's', 's', ' ', 'n', 'o', 't', ' ', 'a', 'v', 'a', 'i', 'l', 'a', 'b', 'l', 'e', 0, 0, 'U', 'n', 'k', 'n', 'o', 'w', 'n', ' ', 'e', 'r', 'r', 'o', 'r'} @@ -121036,11 +121036,11 @@ func Xhstrerror(tls *TLS, ecode int32) (r uintptr) { s = uintptr(unsafe.Pointer(&_msgs1)) ecode = ecode - 1 for { - if !(ecode != 0 && *(*int8)(unsafe.Pointer(s)) != 0) { + if !(ecode != 0 && **(**int8)(__ccgo_up(s)) != 0) { break } for { - if !(*(*int8)(unsafe.Pointer(s)) != 0) { + if !(**(**int8)(__ccgo_up(s)) != 0) { break } goto _2 @@ -121054,7 +121054,7 @@ func Xhstrerror(tls *TLS, ecode int32) (r uintptr) { ecode = ecode - 1 s = s + 1 } - if !(*(*int8)(unsafe.Pointer(s)) != 0) { + if !(**(**int8)(__ccgo_up(s)) != 0) { s = s + 1 } return X__lctrans_cur(tls, s) @@ -121142,8 +121142,8 @@ func Xif_indextoname(tls *TLS, index uint32, name uintptr) (r1 uintptr) { r = Xioctl(tls, fd, int32(SIOCGIFNAME), VaList(bp+48, bp)) X__syscall1(tls, int64(SYS_close), int64(fd)) if r < 0 { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENODEV) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENXIO) + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENODEV) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENXIO) } return uintptr(0) } @@ -121196,7 +121196,7 @@ func _netlink_msg_to_nameindex(tls *TLS, pctx uintptr, h uintptr) (r int32) { } /* suppress duplicates */ bucket = index % int32(IFADDRS_HASH_SIZE) - i = *(*uint32)(unsafe.Pointer(ctx + 24 + uintptr(bucket)*4)) + i = **(**uint32)(__ccgo_up(ctx + 24 + uintptr(bucket)*4)) for i != 0 { map1 = (*Tifnameindexctx)(unsafe.Pointer(ctx)).Flist + uintptr(i-uint32(1))*28 if (*Tifnamemap)(unsafe.Pointer(map1)).Findex == Uint32FromInt32(index) && Int32FromUint8((*Tifnamemap)(unsafe.Pointer(map1)).Fnamelen) == namelen && Xmemcmp(tls, map1+9, rta+UintptrFromInt64(4), Uint64FromInt32(namelen)) == 0 { @@ -121225,10 +121225,10 @@ func _netlink_msg_to_nameindex(tls *TLS, pctx uintptr, h uintptr) (r int32) { (*Tifnamemap)(unsafe.Pointer(map1)).Findex = Uint32FromInt32(index) (*Tifnamemap)(unsafe.Pointer(map1)).Fnamelen = Uint8FromInt32(namelen) Xmemcpy(tls, map1+9, rta+UintptrFromInt64(4), Uint64FromInt32(namelen)) - *(*uint32)(unsafe.Pointer(ctx + 8)) += Uint32FromInt32(namelen + int32(1)) + **(**uint32)(__ccgo_up(ctx + 8)) += Uint32FromInt32(namelen + int32(1)) (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum = (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum + 1 - (*Tifnamemap)(unsafe.Pointer(map1)).Fhash_next = *(*uint32)(unsafe.Pointer(ctx + 24 + uintptr(bucket)*4)) - *(*uint32)(unsafe.Pointer(ctx + 24 + uintptr(bucket)*4)) = (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum + (*Tifnamemap)(unsafe.Pointer(map1)).Fhash_next = **(**uint32)(__ccgo_up(ctx + 24 + uintptr(bucket)*4)) + **(**uint32)(__ccgo_up(ctx + 24 + uintptr(bucket)*4)) = (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum return 0 goto _1 _1: @@ -121275,7 +121275,7 @@ func Xif_nameindex(tls *TLS) (r uintptr) { p = p + uintptr((*Tifnamemap)(unsafe.Pointer(s)).Fnamelen) v2 = p p = p + 1 - *(*int8)(unsafe.Pointer(v2)) = 0 + **(**int8)(__ccgo_up(v2)) = 0 goto _1 _1: ; @@ -121288,9 +121288,9 @@ func Xif_nameindex(tls *TLS) (r uintptr) { goto err err: ; - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 280)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 280)), uintptr(0)) Xfree(tls, (*Tifnameindexctx)(unsafe.Pointer(ctx)).Flist) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOBUFS) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOBUFS) return ifs } @@ -121331,7 +121331,7 @@ func Xinet_addr(tls *TLS, p uintptr) (r Tin_addr_t) { if !(X__inet_aton(tls, p, bp) != 0) { return Uint32FromInt32(-Int32FromInt32(1)) } - return (*(*Tin_addr)(unsafe.Pointer(bp))).Fs_addr + return (**(**Tin_addr)(__ccgo_up(bp))).Fs_addr } func X__inet_aton(tls *TLS, s0 uintptr, dest uintptr) (r int32) { @@ -121348,20 +121348,20 @@ func X__inet_aton(tls *TLS, s0 uintptr, dest uintptr) (r int32) { _, _, _ = d, i, s s = s0 d = dest - *(*[4]uint64)(unsafe.Pointer(bp)) = [4]uint64{} + **(**[4]uint64)(__ccgo_up(bp)) = [4]uint64{} i = 0 for { if !(i < int32(4)) { break } - (*(*[4]uint64)(unsafe.Pointer(bp)))[i] = Xstrtoul(tls, s, bp+32, 0) - if *(*uintptr)(unsafe.Pointer(bp + 32)) == s || *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)))) != 0 && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32))))) != int32('.') || !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + (**(**[4]uint64)(__ccgo_up(bp)))[i] = Xstrtoul(tls, s, bp+32, 0) + if **(**uintptr)(__ccgo_up(bp + 32)) == s || **(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 32)))) != 0 && int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 32))))) != int32('.') || !(BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return 0 } - if !(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)))) != 0) { + if !(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 32)))) != 0) { break } - s = *(*uintptr)(unsafe.Pointer(bp + 32)) + uintptr(1) + s = **(**uintptr)(__ccgo_up(bp + 32)) + uintptr(1) goto _1 _1: ; @@ -121372,26 +121372,26 @@ func X__inet_aton(tls *TLS, s0 uintptr, dest uintptr) (r int32) { } switch i { case 0: - (*(*[4]uint64)(unsafe.Pointer(bp)))[int32(1)] = (*(*[4]uint64)(unsafe.Pointer(bp)))[0] & uint64(0xffffff) - *(*uint64)(unsafe.Pointer(bp)) >>= uint64(24) + (**(**[4]uint64)(__ccgo_up(bp)))[int32(1)] = (**(**[4]uint64)(__ccgo_up(bp)))[0] & uint64(0xffffff) + **(**uint64)(__ccgo_up(bp)) >>= uint64(24) fallthrough case int32(1): - (*(*[4]uint64)(unsafe.Pointer(bp)))[int32(2)] = (*(*[4]uint64)(unsafe.Pointer(bp)))[int32(1)] & uint64(0xffff) - *(*uint64)(unsafe.Pointer(bp + 1*8)) >>= uint64(16) + (**(**[4]uint64)(__ccgo_up(bp)))[int32(2)] = (**(**[4]uint64)(__ccgo_up(bp)))[int32(1)] & uint64(0xffff) + **(**uint64)(__ccgo_up(bp + 1*8)) >>= uint64(16) fallthrough case int32(2): - (*(*[4]uint64)(unsafe.Pointer(bp)))[int32(3)] = (*(*[4]uint64)(unsafe.Pointer(bp)))[int32(2)] & uint64(0xff) - *(*uint64)(unsafe.Pointer(bp + 2*8)) >>= uint64(8) + (**(**[4]uint64)(__ccgo_up(bp)))[int32(3)] = (**(**[4]uint64)(__ccgo_up(bp)))[int32(2)] & uint64(0xff) + **(**uint64)(__ccgo_up(bp + 2*8)) >>= uint64(8) } i = 0 for { if !(i < int32(4)) { break } - if (*(*[4]uint64)(unsafe.Pointer(bp)))[i] > uint64(255) { + if (**(**[4]uint64)(__ccgo_up(bp)))[i] > uint64(255) { return 0 } - *(*uint8)(unsafe.Pointer(d + uintptr(i))) = uint8((*(*[4]uint64)(unsafe.Pointer(bp)))[i]) + **(**uint8)(__ccgo_up(d + uintptr(i))) = uint8((**(**[4]uint64)(__ccgo_up(bp)))[i]) goto _2 _2: ; @@ -121480,7 +121480,7 @@ func Xinet_ntoa(tls *TLS, _in Tin_addr) (r uintptr) { var a uintptr _ = a a = bp - Xsnprintf(tls, uintptr(unsafe.Pointer(&_buf4)), uint64(16), __ccgo_ts+1070, VaList(bp+16, Int32FromUint8(*(*uint8)(unsafe.Pointer(a))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 1))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 2))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 3))))) + Xsnprintf(tls, uintptr(unsafe.Pointer(&_buf4)), uint64(16), __ccgo_ts+1070, VaList(bp+16, Int32FromUint8(**(**uint8)(__ccgo_up(a))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 1))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 2))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 3))))) return uintptr(unsafe.Pointer(&_buf4)) } @@ -121501,14 +121501,14 @@ func Xinet_ntop(tls *TLS, af int32, a0 uintptr, s uintptr, l Tsocklen_t) (r uint a = a0 switch af { case int32(PF_INET): - if Uint32FromInt32(Xsnprintf(tls, s, uint64(l), __ccgo_ts+1070, VaList(bp+112, Int32FromUint8(*(*uint8)(unsafe.Pointer(a))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 1))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 2))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 3)))))) < l { + if Uint32FromInt32(Xsnprintf(tls, s, uint64(l), __ccgo_ts+1070, VaList(bp+112, Int32FromUint8(**(**uint8)(__ccgo_up(a))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 1))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 2))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 3)))))) < l { return s } case int32(PF_INET6): if Xmemcmp(tls, a, __ccgo_ts+1017, uint64(12)) != 0 { - Xsnprintf(tls, bp, uint64(100), __ccgo_ts+1082, VaList(bp+112, int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 1))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 2)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 3))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 4)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 5))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 6)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 7))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 8)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 9))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 10)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 11))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 12)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 13))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 14)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 15))))) + Xsnprintf(tls, bp, uint64(100), __ccgo_ts+1082, VaList(bp+112, int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 1))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 2)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 3))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 4)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 5))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 6)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 7))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 8)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 9))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 10)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 11))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 12)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 13))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 14)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 15))))) } else { - Xsnprintf(tls, bp, uint64(100), __ccgo_ts+1106, VaList(bp+112, int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 1))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 2)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 3))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 4)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 5))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 6)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 7))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 8)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 9))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 10)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 11))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 12))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 13))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 14))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 15))))) + Xsnprintf(tls, bp, uint64(100), __ccgo_ts+1106, VaList(bp+112, int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 1))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 2)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 3))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 4)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 5))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 6)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 7))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 8)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 9))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 10)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 11))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 12))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 13))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 14))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 15))))) } /* Replace longest /(^0|:)[:0]{2,}/ with "::" */ v2 = Int32FromInt32(0) @@ -121516,10 +121516,10 @@ func Xinet_ntop(tls *TLS, af int32, a0 uintptr, s uintptr, l Tsocklen_t) (r uint i = v2 max = Int32FromInt32(2) for { - if !((*(*[100]int8)(unsafe.Pointer(bp)))[i] != 0) { + if !((**(**[100]int8)(__ccgo_up(bp)))[i] != 0) { break } - if i != 0 && int32((*(*[100]int8)(unsafe.Pointer(bp)))[i]) != int32(':') { + if i != 0 && int32((**(**[100]int8)(__ccgo_up(bp)))[i]) != int32(':') { goto _1 } j = Int32FromUint64(Xstrspn(tls, bp+uintptr(i), __ccgo_ts+1136)) @@ -121534,8 +121534,8 @@ func Xinet_ntop(tls *TLS, af int32, a0 uintptr, s uintptr, l Tsocklen_t) (r uint } if max > int32(3) { v3 = Int8FromUint8(':') - (*(*[100]int8)(unsafe.Pointer(bp)))[best+int32(1)] = v3 - (*(*[100]int8)(unsafe.Pointer(bp)))[best] = v3 + (**(**[100]int8)(__ccgo_up(bp)))[best+int32(1)] = v3 + (**(**[100]int8)(__ccgo_up(bp)))[best] = v3 Xmemmove(tls, bp+uintptr(best)+uintptr(2), bp+uintptr(best)+uintptr(max), Uint64FromInt32(i-best-max+int32(1))) } if _strlen(tls, bp) < uint64(l) { @@ -121543,10 +121543,10 @@ func Xinet_ntop(tls *TLS, af int32, a0 uintptr, s uintptr, l Tsocklen_t) (r uint return s } default: - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EAFNOSUPPORT) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EAFNOSUPPORT) return uintptr(0) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOSPC) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOSPC) return uintptr(0) } @@ -121586,23 +121586,23 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { j = v3 v = v3 for { - if !(j < int32(3) && BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s + uintptr(j))))-uint32('0') < uint32(10)) != 0) { + if !(j < int32(3) && BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(s + uintptr(j))))-uint32('0') < uint32(10)) != 0) { break } - v = int32(10)*v + int32(*(*int8)(unsafe.Pointer(s + uintptr(j)))) - int32('0') + v = int32(10)*v + int32(**(**int8)(__ccgo_up(s + uintptr(j)))) - int32('0') goto _2 _2: ; j = j + 1 } - if j == 0 || j > int32(1) && int32(*(*int8)(unsafe.Pointer(s))) == int32('0') || v > int32(255) { + if j == 0 || j > int32(1) && int32(**(**int8)(__ccgo_up(s))) == int32('0') || v > int32(255) { return 0 } - *(*uint8)(unsafe.Pointer(a + uintptr(i))) = Uint8FromInt32(v) - if int32(*(*int8)(unsafe.Pointer(s + uintptr(j)))) == 0 && i == int32(3) { + **(**uint8)(__ccgo_up(a + uintptr(i))) = Uint8FromInt32(v) + if int32(**(**int8)(__ccgo_up(s + uintptr(j)))) == 0 && i == int32(3) { return int32(1) } - if int32(*(*int8)(unsafe.Pointer(s + uintptr(j)))) != int32('.') { + if int32(**(**int8)(__ccgo_up(s + uintptr(j)))) != int32('.') { return 0 } s = s + uintptr(j+int32(1)) @@ -121614,25 +121614,25 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { return 0 } else { if af != int32(PF_INET6) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EAFNOSUPPORT) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EAFNOSUPPORT) return -int32(1) } } - if v5 = int32(*(*int8)(unsafe.Pointer(s))) == int32(':'); v5 { + if v5 = int32(**(**int8)(__ccgo_up(s))) == int32(':'); v5 { s = s + 1 v4 = s } - if v5 && int32(*(*int8)(unsafe.Pointer(v4))) != int32(':') { + if v5 && int32(**(**int8)(__ccgo_up(v4))) != int32(':') { return 0 } i = 0 for { - if int32(*(*int8)(unsafe.Pointer(s))) == int32(':') && brk < 0 { + if int32(**(**int8)(__ccgo_up(s))) == int32(':') && brk < 0 { brk = i - (*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[i&int32(7)] = uint16(0) + (**(**[8]Tuint16_t)(__ccgo_up(bp)))[i&int32(7)] = uint16(0) s = s + 1 v4 = s - if !(*(*int8)(unsafe.Pointer(v4)) != 0) { + if !(**(**int8)(__ccgo_up(v4)) != 0) { break } if i == int32(7) { @@ -121645,7 +121645,7 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { v = v3 for { if v5 = j < int32(4); v5 { - v9 = _hexval(tls, Uint32FromInt8(*(*int8)(unsafe.Pointer(s + uintptr(j))))) + v9 = _hexval(tls, Uint32FromInt8(**(**int8)(__ccgo_up(s + uintptr(j))))) d = v9 } if !(v5 && v9 >= 0) { @@ -121660,20 +121660,20 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { if j == 0 { return 0 } - (*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[i&int32(7)] = Uint16FromInt32(v) - if !(*(*int8)(unsafe.Pointer(s + uintptr(j))) != 0) && (brk >= 0 || i == int32(7)) { + (**(**[8]Tuint16_t)(__ccgo_up(bp)))[i&int32(7)] = Uint16FromInt32(v) + if !(**(**int8)(__ccgo_up(s + uintptr(j))) != 0) && (brk >= 0 || i == int32(7)) { break } if i == int32(7) { return 0 } - if int32(*(*int8)(unsafe.Pointer(s + uintptr(j)))) != int32(':') { - if int32(*(*int8)(unsafe.Pointer(s + uintptr(j)))) != int32('.') || i < int32(6) && brk < 0 { + if int32(**(**int8)(__ccgo_up(s + uintptr(j)))) != int32(':') { + if int32(**(**int8)(__ccgo_up(s + uintptr(j)))) != int32('.') || i < int32(6) && brk < 0 { return 0 } need_v4 = int32(1) i = i + 1 - (*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[i&int32(7)] = uint16(0) + (**(**[8]Tuint16_t)(__ccgo_up(bp)))[i&int32(7)] = uint16(0) break } s = s + uintptr(j+int32(1)) @@ -121689,7 +121689,7 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { if !(j < int32(7)-i) { break } - (*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[brk+j] = uint16(0) + (**(**[8]Tuint16_t)(__ccgo_up(bp)))[brk+j] = uint16(0) goto _12 _12: ; @@ -121703,10 +121703,10 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { } v4 = a a = a + 1 - *(*uint8)(unsafe.Pointer(v4)) = Uint8FromInt32(Int32FromUint16((*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[j]) >> int32(8)) + **(**uint8)(__ccgo_up(v4)) = Uint8FromInt32(Int32FromUint16((**(**[8]Tuint16_t)(__ccgo_up(bp)))[j]) >> int32(8)) v4 = a a = a + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8((*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[j]) + **(**uint8)(__ccgo_up(v4)) = uint8((**(**[8]Tuint16_t)(__ccgo_up(bp)))[j]) goto _13 _13: ; @@ -121769,15 +121769,15 @@ func X__lookup_ipliteral(tls *TLS, buf uintptr, name uintptr, family int32) (r i return -int32(5) } Xmemcpy(tls, buf+8, bp, uint64(4)) - (*(*Taddress)(unsafe.Pointer(buf))).Ffamily = int32(PF_INET) - (*(*Taddress)(unsafe.Pointer(buf))).Fscopeid = uint32(0) + (**(**Taddress)(__ccgo_up(buf))).Ffamily = int32(PF_INET) + (**(**Taddress)(__ccgo_up(buf))).Fscopeid = uint32(0) return int32(1) } p = Xstrchr(tls, name, int32('%')) scopeid = uint64(0) if p != 0 && int64(p)-int64(name) < int64(64) { Xmemcpy(tls, bp+20, name, Uint64FromInt64(int64(p)-int64(name))) - (*(*[64]int8)(unsafe.Pointer(bp + 20)))[int64(p)-int64(name)] = 0 + (**(**[64]int8)(__ccgo_up(bp + 20)))[int64(p)-int64(name)] = 0 name = bp + 20 } if Xinet_pton(tls, int32(PF_INET6), name, bp+4) <= 0 { @@ -121787,17 +121787,17 @@ func X__lookup_ipliteral(tls *TLS, buf uintptr, name uintptr, family int32) (r i return -int32(5) } Xmemcpy(tls, buf+8, bp+4, uint64(16)) - (*(*Taddress)(unsafe.Pointer(buf))).Ffamily = int32(PF_INET6) + (**(**Taddress)(__ccgo_up(buf))).Ffamily = int32(PF_INET6) if p != 0 { p = p + 1 v1 = p - if BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(v1)))-uint32('0') < uint32(10)) != 0 { + if BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(v1)))-uint32('0') < uint32(10)) != 0 { scopeid = Xstrtoull(tls, p, bp+88, int32(10)) } else { - *(*uintptr)(unsafe.Pointer(bp + 88)) = p - uintptr(1) + **(**uintptr)(__ccgo_up(bp + 88)) = p - uintptr(1) } - if *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 88)))) != 0 { - if !(Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(bp + 4))) == int32(0xfe) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(bp + 4 + 1)))&int32(0xc0) == int32(0x80)) && !(Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(bp + 4))) == int32(0xff) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(bp + 4 + 1)))&int32(0xf) == int32(0x2)) { + if **(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 88)))) != 0 { + if !(Int32FromUint8(**(**Tuint8_t)(__ccgo_up(bp + 4))) == int32(0xfe) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(bp + 4 + 1)))&int32(0xc0) == int32(0x80)) && !(Int32FromUint8(**(**Tuint8_t)(__ccgo_up(bp + 4))) == int32(0xff) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(bp + 4 + 1)))&int32(0xf) == int32(0x2)) { return -int32(2) } scopeid = uint64(Xif_nametoindex(tls, p)) @@ -121809,7 +121809,7 @@ func X__lookup_ipliteral(tls *TLS, buf uintptr, name uintptr, family int32) (r i return -int32(2) } } - (*(*Taddress)(unsafe.Pointer(buf))).Fscopeid = uint32(scopeid) + (**(**Taddress)(__ccgo_up(buf))).Fscopeid = uint32(scopeid) return int32(1) } @@ -121833,7 +121833,7 @@ func _is_valid_hostname(tls *TLS, host uintptr) (r int32) { } s = host for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) >= int32(0x80) || Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('.') || Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('-') || Xisalnum(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))) != 0) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(s))) >= int32(0x80) || Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('.') || Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('-') || Xisalnum(tls, Int32FromUint8(**(**uint8)(__ccgo_up(s)))) != 0) { break } goto _1 @@ -121841,7 +121841,7 @@ func _is_valid_hostname(tls *TLS, host uintptr) (r int32) { ; s = s + 1 } - return BoolInt32(!(*(*uint8)(unsafe.Pointer(s)) != 0)) + return BoolInt32(!(**(**uint8)(__ccgo_up(s)) != 0)) } func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags int32) (r int32) { @@ -121855,14 +121855,14 @@ func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags in if family != int32(PF_INET6) { v1 = cnt cnt = cnt + 1 - *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ + **(**Taddress)(__ccgo_up(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET), } } if family != int32(PF_INET) { v1 = cnt cnt = cnt + 1 - *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ + **(**Taddress)(__ccgo_up(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET6), } } @@ -121870,7 +121870,7 @@ func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags in if family != int32(PF_INET6) { v1 = cnt cnt = cnt + 1 - *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ + **(**Taddress)(__ccgo_up(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET), Faddr: [16]Tuint8_t{ 0: uint8(127), @@ -121881,7 +121881,7 @@ func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags in if family != int32(PF_INET) { v1 = cnt cnt = cnt + 1 - *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ + **(**Taddress)(__ccgo_up(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET6), Faddr: [16]Tuint8_t{ 15: uint8(1), @@ -121913,7 +121913,7 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family have_canon = 0 f = X__fopen_rb_ca(tls, __ccgo_ts+1006, bp+1544, bp+512, uint64(1032)) if !(f != 0) { - switch *(*int32)(unsafe.Pointer(X__errno_location(tls))) { + switch **(**int32)(__ccgo_up(X__errno_location(tls))) { case int32(ENOENT): fallthrough case int32(ENOTDIR): @@ -121930,21 +121930,21 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family if v1 != 0 { v2 = p p = p + 1 - *(*int8)(unsafe.Pointer(v2)) = int8('\n') - *(*int8)(unsafe.Pointer(p)) = Int8FromInt32(0) + **(**int8)(__ccgo_up(v2)) = int8('\n') + **(**int8)(__ccgo_up(p)) = Int8FromInt32(0) } p = bp + uintptr(1) for { v1 = Xstrstr(tls, p, name) p = v1 if v12 = v1 != 0; v12 { - v5 = int32(*(*int8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) + v5 = int32(**(**int8)(__ccgo_up(p + uintptr(-Int32FromInt32(1))))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _7 _7: ; if v11 = !(v6 != 0); !v11 { - v8 = int32(*(*int8)(unsafe.Pointer(p + uintptr(l)))) + v8 = int32(**(**int8)(__ccgo_up(p + uintptr(l)))) v9 = BoolInt32(v8 == int32(' ') || Uint32FromInt32(v8)-uint32('\t') < uint32(5)) goto _10 _10: @@ -121964,8 +121964,8 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family /* Isolate IP address to parse */ p = bp for { - if v11 = *(*int8)(unsafe.Pointer(p)) != 0; v11 { - v5 = int32(*(*int8)(unsafe.Pointer(p))) + if v11 = **(**int8)(__ccgo_up(p)) != 0; v11 { + v5 = int32(**(**int8)(__ccgo_up(p))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _16 _16: @@ -121980,7 +121980,7 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family } v1 = p p = p + 1 - *(*int8)(unsafe.Pointer(v1)) = 0 + **(**int8)(__ccgo_up(v1)) = 0 switch _name_from_numeric(tls, buf+uintptr(cnt)*28, bp, family) { case int32(1): cnt = cnt + 1 @@ -121995,8 +121995,8 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family } /* Extract first name as canonical name */ for { - if v11 = *(*int8)(unsafe.Pointer(p)) != 0; v11 { - v5 = int32(*(*int8)(unsafe.Pointer(p))) + if v11 = **(**int8)(__ccgo_up(p)) != 0; v11 { + v5 = int32(**(**int8)(__ccgo_up(p))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _22 _22: @@ -122011,8 +122011,8 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family } z = p for { - if v11 = *(*int8)(unsafe.Pointer(z)) != 0; v11 { - v5 = int32(*(*int8)(unsafe.Pointer(z))) + if v11 = **(**int8)(__ccgo_up(z)) != 0; v11 { + v5 = int32(**(**int8)(__ccgo_up(z))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _27 _27: @@ -122025,7 +122025,7 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family ; z = z + 1 } - *(*int8)(unsafe.Pointer(z)) = 0 + **(**int8)(__ccgo_up(z)) = 0 if _is_valid_hostname(tls, p) != 0 { have_canon = int32(1) Xmemcpy(tls, canon, p, Uint64FromInt64(int64(z)-int64(p)+int64(1))) @@ -122080,8 +122080,8 @@ func _dns_parse_callback1(tls *TLS, c uintptr, rr int32, data uintptr, len1 int3 family = int32(PF_INET6) break } - (*(*Taddress)(unsafe.Pointer((*Tdpc_ctx)(unsafe.Pointer(ctx)).Faddrs + uintptr((*Tdpc_ctx)(unsafe.Pointer(ctx)).Fcnt)*28))).Ffamily = family - (*(*Taddress)(unsafe.Pointer((*Tdpc_ctx)(unsafe.Pointer(ctx)).Faddrs + uintptr((*Tdpc_ctx)(unsafe.Pointer(ctx)).Fcnt)*28))).Fscopeid = uint32(0) + (**(**Taddress)(__ccgo_up((*Tdpc_ctx)(unsafe.Pointer(ctx)).Faddrs + uintptr((*Tdpc_ctx)(unsafe.Pointer(ctx)).Fcnt)*28))).Ffamily = family + (**(**Taddress)(__ccgo_up((*Tdpc_ctx)(unsafe.Pointer(ctx)).Faddrs + uintptr((*Tdpc_ctx)(unsafe.Pointer(ctx)).Fcnt)*28))).Fscopeid = uint32(0) v2 = ctx + 16 v1 = *(*int32)(unsafe.Pointer(v2)) *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) + 1 @@ -122102,16 +122102,16 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i var _ /* qlens at bp+10192 */ [2]int32 var _ /* qp at bp+10160 */ [2]uintptr _, _, _ = i, nq, qtypes - *(*[2]uintptr)(unsafe.Pointer(bp + 10160)) = [2]uintptr{ + **(**[2]uintptr)(__ccgo_up(bp + 10160)) = [2]uintptr{ 0: bp, 1: bp + 1*280, } - *(*[2]uintptr)(unsafe.Pointer(bp + 10176)) = [2]uintptr{ + **(**[2]uintptr)(__ccgo_up(bp + 10176)) = [2]uintptr{ 0: bp + 560, 1: bp + 560 + 1*4800, } nq = 0 - *(*Tdpc_ctx)(unsafe.Pointer(bp + 10208)) = Tdpc_ctx{ + **(**Tdpc_ctx)(__ccgo_up(bp + 10208)) = Tdpc_ctx{ Faddrs: buf, Fcanon: canon, } @@ -122121,15 +122121,15 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i break } if family != _afrr[i].Faf { - (*(*[2]int32)(unsafe.Pointer(bp + 10192)))[nq] = X__res_mkquery(tls, 0, name, int32(1), _afrr[i].Frr, uintptr(0), 0, uintptr(0), bp+uintptr(nq)*280, int32(280)) - if (*(*[2]int32)(unsafe.Pointer(bp + 10192)))[nq] == -int32(1) { + (**(**[2]int32)(__ccgo_up(bp + 10192)))[nq] = X__res_mkquery(tls, 0, name, int32(1), _afrr[i].Frr, uintptr(0), 0, uintptr(0), bp+uintptr(nq)*280, int32(280)) + if (**(**[2]int32)(__ccgo_up(bp + 10192)))[nq] == -int32(1) { return 0 } qtypes[nq] = _afrr[i].Frr - *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280 + 3)) = uint8(0) /* don't need AD flag */ + **(**uint8)(__ccgo_up(bp + uintptr(nq)*280 + 3)) = uint8(0) /* don't need AD flag */ /* Ensure query IDs are distinct. */ - if nq != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) { - *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280)) = *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280)) + 1 + if nq != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(bp + uintptr(nq)*280))) == Int32FromUint8(**(**uint8)(__ccgo_up(bp))) { + **(**uint8)(__ccgo_up(bp + uintptr(nq)*280)) = **(**uint8)(__ccgo_up(bp + uintptr(nq)*280)) + 1 } nq = nq + 1 } @@ -122146,13 +122146,13 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if !(i < nq) { break } - if (*(*[2]int32)(unsafe.Pointer(bp + 10200)))[i] < int32(4) || Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + 560 + uintptr(i)*4800 + 3)))&int32(15) == int32(2) { + if (**(**[2]int32)(__ccgo_up(bp + 10200)))[i] < int32(4) || Int32FromUint8(**(**uint8)(__ccgo_up(bp + 560 + uintptr(i)*4800 + 3)))&int32(15) == int32(2) { return -int32(3) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + 560 + uintptr(i)*4800 + 3)))&int32(15) == int32(3) { + if Int32FromUint8(**(**uint8)(__ccgo_up(bp + 560 + uintptr(i)*4800 + 3)))&int32(15) == int32(3) { return 0 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + 560 + uintptr(i)*4800 + 3)))&int32(15) != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(bp + 560 + uintptr(i)*4800 + 3)))&int32(15) != 0 { return -int32(4) } goto _2 @@ -122165,18 +122165,18 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if !(i >= 0) { break } - (*(*Tdpc_ctx)(unsafe.Pointer(bp + 10208))).Frrtype = qtypes[i] - if Uint64FromInt32((*(*[2]int32)(unsafe.Pointer(bp + 10200)))[i]) > uint64(4800) { - (*(*[2]int32)(unsafe.Pointer(bp + 10200)))[i] = int32(4800) + (**(**Tdpc_ctx)(__ccgo_up(bp + 10208))).Frrtype = qtypes[i] + if Uint64FromInt32((**(**[2]int32)(__ccgo_up(bp + 10200)))[i]) > uint64(4800) { + (**(**[2]int32)(__ccgo_up(bp + 10200)))[i] = int32(4800) } - X__dns_parse(tls, bp+560+uintptr(i)*4800, (*(*[2]int32)(unsafe.Pointer(bp + 10200)))[i], __ccgo_fp(_dns_parse_callback1), bp+10208) + X__dns_parse(tls, bp+560+uintptr(i)*4800, (**(**[2]int32)(__ccgo_up(bp + 10200)))[i], __ccgo_fp(_dns_parse_callback1), bp+10208) goto _3 _3: ; i = i - 1 } - if (*(*Tdpc_ctx)(unsafe.Pointer(bp + 10208))).Fcnt != 0 { - return (*(*Tdpc_ctx)(unsafe.Pointer(bp + 10208))).Fcnt + if (**(**Tdpc_ctx)(__ccgo_up(bp + 10208))).Fcnt != 0 { + return (**(**Tdpc_ctx)(__ccgo_up(bp + 10208))).Fcnt } return -int32(5) } @@ -122214,10 +122214,10 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f l = v2 dots = v2 for { - if !(*(*int8)(unsafe.Pointer(name + uintptr(l))) != 0) { + if !(**(**int8)(__ccgo_up(name + uintptr(l))) != 0) { break } - if int32(*(*int8)(unsafe.Pointer(name + uintptr(l)))) == int32('.') { + if int32(**(**int8)(__ccgo_up(name + uintptr(l)))) == int32('.') { dots = dots + 1 } goto _1 @@ -122225,14 +122225,14 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f ; l = l + 1 } - if dots >= uint64((*(*Tresolvconf)(unsafe.Pointer(bp + 256))).Fndots) || int32(*(*int8)(unsafe.Pointer(name + uintptr(l-uint64(1))))) == int32('.') { - *(*int8)(unsafe.Pointer(bp)) = 0 + if dots >= uint64((**(**Tresolvconf)(__ccgo_up(bp + 256))).Fndots) || int32(**(**int8)(__ccgo_up(name + uintptr(l-uint64(1))))) == int32('.') { + **(**int8)(__ccgo_up(bp)) = 0 } /* Strip final dot for canon, fail if multiple trailing dots. */ - if int32(*(*int8)(unsafe.Pointer(name + uintptr(l-uint64(1))))) == int32('.') { + if int32(**(**int8)(__ccgo_up(name + uintptr(l-uint64(1))))) == int32('.') { l = l - 1 } - if !(l != 0) || int32(*(*int8)(unsafe.Pointer(name + uintptr(l-uint64(1))))) == int32('.') { + if !(l != 0) || int32(**(**int8)(__ccgo_up(name + uintptr(l-uint64(1))))) == int32('.') { return -int32(2) } /* This can never happen; the caller already checked length. */ @@ -122244,14 +122244,14 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f * name is not a CNAME record) and serves as a buffer for passing * the full requested name to name_from_dns. */ Xmemcpy(tls, canon, name, l) - *(*int8)(unsafe.Pointer(canon + uintptr(l))) = int8('.') + **(**int8)(__ccgo_up(canon + uintptr(l))) = int8('.') p = bp for { - if !(*(*int8)(unsafe.Pointer(p)) != 0) { + if !(**(**int8)(__ccgo_up(p)) != 0) { break } for { - v5 = int32(*(*int8)(unsafe.Pointer(p))) + v5 = int32(**(**int8)(__ccgo_up(p))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _7 _7: @@ -122265,8 +122265,8 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f } z = p for { - if v12 = *(*int8)(unsafe.Pointer(z)) != 0; v12 { - v5 = int32(*(*int8)(unsafe.Pointer(z))) + if v12 = **(**int8)(__ccgo_up(z)) != 0; v12 { + v5 = int32(**(**int8)(__ccgo_up(z))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _11 _11: @@ -122284,7 +122284,7 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f } if Uint64FromInt64(int64(z)-int64(p)) < uint64(256)-l-uint64(1) { Xmemcpy(tls, canon+uintptr(l)+uintptr(1), p, Uint64FromInt64(int64(z)-int64(p))) - *(*int8)(unsafe.Pointer(canon + uintptr(Uint64FromInt64(int64(z)-int64(p)+int64(1))+l))) = 0 + **(**int8)(__ccgo_up(canon + uintptr(Uint64FromInt64(int64(z)-int64(p)+int64(1))+l))) = 0 cnt = _name_from_dns(tls, buf, canon, canon, family, bp+256) if cnt != 0 { return cnt @@ -122295,7 +122295,7 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f ; p = z } - *(*int8)(unsafe.Pointer(canon + uintptr(l))) = 0 + **(**int8)(__ccgo_up(canon + uintptr(l))) = 0 return _name_from_dns(tls, buf, canon, name, family, bp+256) } @@ -122356,7 +122356,7 @@ func _policyof(tls *TLS, a uintptr) (r uintptr) { if Xmemcmp(tls, a, uintptr(unsafe.Pointer(&_defpolicy))+uintptr(i)*20, uint64(_defpolicy[i].Flen1)) != 0 { goto _1 } - if Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + uintptr(_defpolicy[i].Flen1))))&Int32FromUint8(_defpolicy[i].Fmask) != Int32FromUint8(*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_defpolicy)) + uintptr(i)*20 + uintptr(_defpolicy[i].Flen1)))) { + if Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + uintptr(_defpolicy[i].Flen1))))&Int32FromUint8(_defpolicy[i].Fmask) != Int32FromUint8(**(**uint8)(__ccgo_up(uintptr(unsafe.Pointer(&_defpolicy)) + uintptr(i)*20 + uintptr(_defpolicy[i].Flen1)))) { goto _1 } return uintptr(unsafe.Pointer(&_defpolicy)) + uintptr(i)*20 @@ -122373,16 +122373,16 @@ func _labelof(tls *TLS, a uintptr) (r int32) { } func _scopeof(tls *TLS, a uintptr) (r int32) { - if Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a))) == int32(0xff) { - return Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 1))) & int32(15) + if Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a))) == int32(0xff) { + return Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 1))) & int32(15) } - if Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a))) == int32(0xfe) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 1)))&int32(0xc0) == int32(0x80) { + if Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a))) == int32(0xfe) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 1)))&int32(0xc0) == int32(0x80) { return int32(2) } - if *(*Tuint32_t)(unsafe.Pointer(a)) == uint32(0) && *(*Tuint32_t)(unsafe.Pointer(a + 1*4)) == uint32(0) && *(*Tuint32_t)(unsafe.Pointer(a + 2*4)) == uint32(0) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 12))) == 0 && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 13))) == 0 && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 14))) == 0 && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 15))) == int32(1) { + if **(**Tuint32_t)(__ccgo_up(a)) == uint32(0) && **(**Tuint32_t)(__ccgo_up(a + 1*4)) == uint32(0) && **(**Tuint32_t)(__ccgo_up(a + 2*4)) == uint32(0) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 12))) == 0 && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 13))) == 0 && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 14))) == 0 && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 15))) == int32(1) { return int32(2) } - if Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a))) == int32(0xfe) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 1)))&int32(0xc0) == int32(0xc0) { + if Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a))) == int32(0xfe) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 1)))&int32(0xc0) == int32(0xc0) { return int32(5) } return int32(14) @@ -122393,7 +122393,7 @@ func _prefixmatch(tls *TLS, s uintptr, d uintptr) (r int32) { _ = i i = uint32(0) for { - if !(i < uint32(128) && !((Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(s + uintptr(i/uint32(8)))))^Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(d + uintptr(i/uint32(8))))))&(Int32FromInt32(128)>>(i%Uint32FromInt32(8))) != 0)) { + if !(i < uint32(128) && !((Int32FromUint8(**(**Tuint8_t)(__ccgo_up(s + uintptr(i/uint32(8)))))^Int32FromUint8(**(**Tuint8_t)(__ccgo_up(d + uintptr(i/uint32(8))))))&(Int32FromInt32(128)>>(i%Uint32FromInt32(8))) != 0)) { break } goto _1 @@ -122431,7 +122431,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i var _ /* salen at bp+92 */ Tsocklen_t _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cnt, da, dalen, dlabel, dpolicy, dprec, dscope, family1, fd, i, j, key, l, prefixlen, sa, v1 cnt = 0 - *(*int8)(unsafe.Pointer(canon)) = 0 + **(**int8)(__ccgo_up(canon)) = 0 if name != 0 { /* reject empty name and check len so it fits into temp bufs */ l = Xstrnlen(tls, name, uint64(255)) @@ -122475,7 +122475,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i /* If any v6 results exist, remove v4 results. */ i = 0 for { - if !(i < cnt && (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily != int32(PF_INET6)) { + if !(i < cnt && (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Ffamily != int32(PF_INET6)) { break } goto _2 @@ -122489,10 +122489,10 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if !(i < cnt) { break } - if (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily == int32(PF_INET6) { + if (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Ffamily == int32(PF_INET6) { v1 = j j = j + 1 - *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = *(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28)) + **(**Taddress)(__ccgo_up(buf + uintptr(v1)*28)) = **(**Taddress)(__ccgo_up(buf + uintptr(i)*28)) } goto _3 _3: @@ -122510,12 +122510,12 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if !(i < cnt) { break } - if (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily != int32(PF_INET) { + if (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Ffamily != int32(PF_INET) { goto _6 } Xmemcpy(tls, buf+uintptr(i)*28+8+uintptr(12), buf+uintptr(i)*28+8, uint64(4)) Xmemcpy(tls, buf+uintptr(i)*28+8, __ccgo_ts+1017, uint64(12)) - (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily = int32(PF_INET6) + (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Ffamily = int32(PF_INET6) goto _6 _6: ; @@ -122532,7 +122532,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if !(i < cnt) { break } - if (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily != int32(PF_INET) { + if (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Ffamily != int32(PF_INET) { break } goto _7 @@ -122554,16 +122554,16 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if !(i < cnt) { break } - family1 = (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily + family1 = (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Ffamily key = 0 - *(*Tsockaddr_in6)(unsafe.Pointer(bp + 4)) = Tsockaddr_in6{} - *(*Tsockaddr_in6)(unsafe.Pointer(bp + 32)) = Tsockaddr_in6{ + **(**Tsockaddr_in6)(__ccgo_up(bp + 4)) = Tsockaddr_in6{} + **(**Tsockaddr_in6)(__ccgo_up(bp + 32)) = Tsockaddr_in6{ Fsin6_family: uint16(PF_INET6), Fsin6_port: uint16(65535), - Fsin6_scope_id: (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Fscopeid, + Fsin6_scope_id: (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Fscopeid, } - *(*Tsockaddr_in)(unsafe.Pointer(bp + 60)) = Tsockaddr_in{} - *(*Tsockaddr_in)(unsafe.Pointer(bp + 76)) = Tsockaddr_in{ + **(**Tsockaddr_in)(__ccgo_up(bp + 60)) = Tsockaddr_in{} + **(**Tsockaddr_in)(__ccgo_up(bp + 76)) = Tsockaddr_in{ Fsin_family: uint16(PF_INET), Fsin_port: uint16(65535), } @@ -122572,7 +122572,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i da = bp + 32 dalen = uint32(28) sa = bp + 4 - *(*Tsocklen_t)(unsafe.Pointer(bp + 92)) = uint32(28) + **(**Tsocklen_t)(__ccgo_up(bp + 92)) = uint32(28) } else { Xmemcpy(tls, bp+4+8, __ccgo_ts+1017, uint64(12)) Xmemcpy(tls, bp+32+8+uintptr(12), buf+uintptr(i)*28+8, uint64(4)) @@ -122582,7 +122582,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i da = bp + 76 dalen = uint32(16) sa = bp + 60 - *(*Tsocklen_t)(unsafe.Pointer(bp + 92)) = uint32(16) + **(**Tsocklen_t)(__ccgo_up(bp + 92)) = uint32(16) } dpolicy = _policyof(tls, bp+32+8) dscope = _scopeof(tls, bp+32+8) @@ -122612,14 +122612,14 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i key = key | (int32(15)-dscope)< uint64(65535) { return -int32(8) } if proto != int32(IPPROTO_UDP) { - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fport = uint16(port) - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_STREAM) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fport = uint16(port) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_STREAM) v1 = cnt cnt = cnt + 1 - (*(*Tservice)(unsafe.Pointer(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_TCP) + (**(**Tservice)(__ccgo_up(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_TCP) } if proto != int32(IPPROTO_TCP) { - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fport = uint16(port) - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_DGRAM) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fport = uint16(port) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_DGRAM) v1 = cnt cnt = cnt + 1 - (*(*Tservice)(unsafe.Pointer(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_UDP) + (**(**Tservice)(__ccgo_up(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_UDP) } return cnt } @@ -122705,7 +122705,7 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i l = _strlen(tls, name) f = X__fopen_rb_ca(tls, __ccgo_ts+1030, bp+1168, bp+136, uint64(1032)) if !(f != 0) { - switch *(*int32)(unsafe.Pointer(X__errno_location(tls))) { + switch **(**int32)(__ccgo_up(X__errno_location(tls))) { case int32(ENOENT): fallthrough case int32(ENOTDIR): @@ -122722,8 +122722,8 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i if v3 != 0 { v4 = p p = p + 1 - *(*int8)(unsafe.Pointer(v4)) = int8('\n') - *(*int8)(unsafe.Pointer(p)) = Int8FromInt32(0) + **(**int8)(__ccgo_up(v4)) = int8('\n') + **(**int8)(__ccgo_up(p)) = Int8FromInt32(0) } /* Find service name */ p = bp @@ -122734,7 +122734,7 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i break } if v10 = p > bp; v10 { - v1 = int32(*(*int8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) + v1 = int32(**(**int8)(__ccgo_up(p + uintptr(-Int32FromInt32(1))))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _9 _9: @@ -122742,8 +122742,8 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i if v10 && !(v2 != 0) { goto _5 } - if v10 = *(*int8)(unsafe.Pointer(p + uintptr(l))) != 0; v10 { - v1 = int32(*(*int8)(unsafe.Pointer(p + uintptr(l)))) + if v10 = **(**int8)(__ccgo_up(p + uintptr(l))) != 0; v10 { + v1 = int32(**(**int8)(__ccgo_up(p + uintptr(l)))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _13 _13: @@ -122763,8 +122763,8 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i /* Skip past canonical name at beginning of line */ p = bp for { - if v10 = *(*int8)(unsafe.Pointer(p)) != 0; v10 { - v1 = int32(*(*int8)(unsafe.Pointer(p))) + if v10 = **(**int8)(__ccgo_up(p)) != 0; v10 { + v1 = int32(**(**int8)(__ccgo_up(p))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _18 _18: @@ -122778,28 +122778,28 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i p = p + 1 } port = Xstrtoul(tls, p, bp+128, int32(10)) - if port > uint64(65535) || *(*uintptr)(unsafe.Pointer(bp + 128)) == p { + if port > uint64(65535) || **(**uintptr)(__ccgo_up(bp + 128)) == p { continue } - if !(Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(bp + 128)), __ccgo_ts+1044, uint64(4)) != 0) { + if !(Xstrncmp(tls, **(**uintptr)(__ccgo_up(bp + 128)), __ccgo_ts+1044, uint64(4)) != 0) { if proto == int32(IPPROTO_TCP) { continue } - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fport = uint16(port) - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_DGRAM) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fport = uint16(port) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_DGRAM) v1 = cnt cnt = cnt + 1 - (*(*Tservice)(unsafe.Pointer(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_UDP) + (**(**Tservice)(__ccgo_up(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_UDP) } - if !(Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(bp + 128)), __ccgo_ts+1049, uint64(4)) != 0) { + if !(Xstrncmp(tls, **(**uintptr)(__ccgo_up(bp + 128)), __ccgo_ts+1049, uint64(4)) != 0) { if proto == int32(IPPROTO_UDP) { continue } - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fport = uint16(port) - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_STREAM) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fport = uint16(port) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_STREAM) v1 = cnt cnt = cnt + 1 - (*(*Tservice)(unsafe.Pointer(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_TCP) + (**(**Tservice)(__ccgo_up(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_TCP) } } X__fclose_ca(tls, f) @@ -122829,58 +122829,58 @@ func ___netlink_enumerate(tls *TLS, fd int32, seq uint32, type1 int32, af int32, (*(*struct { Fnlh Tnlmsghdr Fg Trtgenmsg - })(unsafe.Pointer(&*(*struct { + })(unsafe.Pointer(&**(**struct { Freq [0]struct { Fnlh Tnlmsghdr Fg Trtgenmsg } Freply [0]Tnlmsghdr Fbuf [8192]Tuint8_t - })(unsafe.Pointer(bp))))).Fnlh.Fnlmsg_len = uint32(20) + })(__ccgo_up(bp))))).Fnlh.Fnlmsg_len = uint32(20) (*(*struct { Fnlh Tnlmsghdr Fg Trtgenmsg - })(unsafe.Pointer(&*(*struct { + })(unsafe.Pointer(&**(**struct { Freq [0]struct { Fnlh Tnlmsghdr Fg Trtgenmsg } Freply [0]Tnlmsghdr Fbuf [8192]Tuint8_t - })(unsafe.Pointer(bp))))).Fnlh.Fnlmsg_type = Uint16FromInt32(type1) + })(__ccgo_up(bp))))).Fnlh.Fnlmsg_type = Uint16FromInt32(type1) (*(*struct { Fnlh Tnlmsghdr Fg Trtgenmsg - })(unsafe.Pointer(&*(*struct { + })(unsafe.Pointer(&**(**struct { Freq [0]struct { Fnlh Tnlmsghdr Fg Trtgenmsg } Freply [0]Tnlmsghdr Fbuf [8192]Tuint8_t - })(unsafe.Pointer(bp))))).Fnlh.Fnlmsg_flags = Uint16FromInt32(Int32FromInt32(NLM_F_ROOT) | Int32FromInt32(NLM_F_MATCH) | Int32FromInt32(NLM_F_REQUEST)) + })(__ccgo_up(bp))))).Fnlh.Fnlmsg_flags = Uint16FromInt32(Int32FromInt32(NLM_F_ROOT) | Int32FromInt32(NLM_F_MATCH) | Int32FromInt32(NLM_F_REQUEST)) (*(*struct { Fnlh Tnlmsghdr Fg Trtgenmsg - })(unsafe.Pointer(&*(*struct { + })(unsafe.Pointer(&**(**struct { Freq [0]struct { Fnlh Tnlmsghdr Fg Trtgenmsg } Freply [0]Tnlmsghdr Fbuf [8192]Tuint8_t - })(unsafe.Pointer(bp))))).Fnlh.Fnlmsg_seq = seq + })(__ccgo_up(bp))))).Fnlh.Fnlmsg_seq = seq (*(*struct { Fnlh Tnlmsghdr Fg Trtgenmsg - })(unsafe.Pointer(&*(*struct { + })(unsafe.Pointer(&**(**struct { Freq [0]struct { Fnlh Tnlmsghdr Fg Trtgenmsg } Freply [0]Tnlmsghdr Fbuf [8192]Tuint8_t - })(unsafe.Pointer(bp))))).Fg.Frtgen_family = Uint8FromInt32(af) + })(__ccgo_up(bp))))).Fg.Frtgen_family = Uint8FromInt32(af) r = int32(Xsend(tls, fd, bp, uint64(20), 0)) if r < 0 { return r @@ -122956,7 +122956,7 @@ func Xns_get16(tls *TLS, cp uintptr) (r uint32) { trc("tls=%v cp=%v, (%v:)", tls, cp, origin(2)) defer func() { trc("-> %v", r) }() } - return Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(cp)))< %v", r) }() } - return uint64(uint32(*(*uint8)(unsafe.Pointer(cp)))<> int32(8)) + **(**uint8)(__ccgo_up(v1)) = uint8(s >> int32(8)) v1 = cp cp = cp + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(s) + **(**uint8)(__ccgo_up(v1)) = uint8(s) } func Xns_put32(tls *TLS, l uint64, cp uintptr) { @@ -122989,16 +122989,16 @@ func Xns_put32(tls *TLS, l uint64, cp uintptr) { _ = v1 v1 = cp cp = cp + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(l >> int32(24)) + **(**uint8)(__ccgo_up(v1)) = uint8(l >> int32(24)) v1 = cp cp = cp + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(l >> int32(16)) + **(**uint8)(__ccgo_up(v1)) = uint8(l >> int32(16)) v1 = cp cp = cp + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(l >> int32(8)) + **(**uint8)(__ccgo_up(v1)) = uint8(l >> int32(8)) v1 = cp cp = cp + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(l) + **(**uint8)(__ccgo_up(v1)) = uint8(l) } func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int32) { @@ -123023,7 +123023,7 @@ func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int3 break } msg = msg + uintptr(2) - *(*Tuint16_t)(unsafe.Pointer(handle + 20 + uintptr(i)*2)) = uint16(Xns_get16(tls, msg-uintptr(2))) + **(**Tuint16_t)(__ccgo_up(handle + 20 + uintptr(i)*2)) = uint16(Xns_get16(tls, msg-uintptr(2))) goto _1 _1: ; @@ -123034,15 +123034,15 @@ func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int3 if !(i < int32(_ns_s_max)) { break } - if *(*Tuint16_t)(unsafe.Pointer(handle + 20 + uintptr(i)*2)) != 0 { - *(*uintptr)(unsafe.Pointer(handle + 32 + uintptr(i)*8)) = msg - r = Xns_skiprr(tls, msg, (*Tns_msg)(unsafe.Pointer(handle)).F_eom, i, Int32FromUint16(*(*Tuint16_t)(unsafe.Pointer(handle + 20 + uintptr(i)*2)))) + if **(**Tuint16_t)(__ccgo_up(handle + 20 + uintptr(i)*2)) != 0 { + **(**uintptr)(__ccgo_up(handle + 32 + uintptr(i)*8)) = msg + r = Xns_skiprr(tls, msg, (*Tns_msg)(unsafe.Pointer(handle)).F_eom, i, Int32FromUint16(**(**Tuint16_t)(__ccgo_up(handle + 20 + uintptr(i)*2)))) if r < 0 { return -int32(1) } msg = msg + uintptr(r) } else { - *(*uintptr)(unsafe.Pointer(handle + 32 + uintptr(i)*8)) = UintptrFromInt32(0) + **(**uintptr)(__ccgo_up(handle + 32 + uintptr(i)*8)) = UintptrFromInt32(0) } goto _2 _2: @@ -123059,7 +123059,7 @@ func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int3 goto bad bad: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EMSGSIZE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EMSGSIZE) return -int32(1) } @@ -123103,7 +123103,7 @@ func Xns_skiprr(tls *TLS, ptr uintptr, eom uintptr, section Tns_sect, count int3 goto bad bad: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EMSGSIZE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EMSGSIZE) return -int32(1) } @@ -123121,31 +123121,31 @@ func Xns_parserr(tls *TLS, handle uintptr, section Tns_sect, rrnum int32, rr uin if section != (*Tns_msg)(unsafe.Pointer(handle)).F_sect { (*Tns_msg)(unsafe.Pointer(handle)).F_sect = section (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum = 0 - (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr = *(*uintptr)(unsafe.Pointer(handle + 32 + uintptr(section)*8)) + (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr = **(**uintptr)(__ccgo_up(handle + 32 + uintptr(section)*8)) } if rrnum == -int32(1) { rrnum = (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum } - if rrnum < 0 || rrnum >= Int32FromUint16(*(*Tuint16_t)(unsafe.Pointer(handle + 20 + uintptr(section)*2))) { + if rrnum < 0 || rrnum >= Int32FromUint16(**(**Tuint16_t)(__ccgo_up(handle + 20 + uintptr(section)*2))) { goto bad } if rrnum < (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum { (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum = 0 - (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr = *(*uintptr)(unsafe.Pointer(handle + 32 + uintptr(section)*8)) + (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr = **(**uintptr)(__ccgo_up(handle + 32 + uintptr(section)*8)) } if rrnum > (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum { r = Xns_skiprr(tls, (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr, (*Tns_msg)(unsafe.Pointer(handle)).F_eom, section, rrnum-(*Tns_msg)(unsafe.Pointer(handle)).F_rrnum) if r < 0 { return -int32(1) } - *(*uintptr)(unsafe.Pointer(handle + 72)) += uintptr(r) + **(**uintptr)(__ccgo_up(handle + 72)) += uintptr(r) (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum = rrnum } r = Xns_name_uncompress(tls, (*Tns_msg)(unsafe.Pointer(handle)).F_msg, (*Tns_msg)(unsafe.Pointer(handle)).F_eom, (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr, rr, uint64(NS_MAXDNAME)) if r < 0 { return -int32(1) } - *(*uintptr)(unsafe.Pointer(handle + 72)) += uintptr(r) + **(**uintptr)(__ccgo_up(handle + 72)) += uintptr(r) if int64(Int32FromInt32(2)*Int32FromInt32(NS_INT16SZ)) > int64((*Tns_msg)(unsafe.Pointer(handle)).F_eom)-int64((*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr) { goto size } @@ -123169,14 +123169,14 @@ func Xns_parserr(tls *TLS, handle uintptr, section Tns_sect, rrnum int32, rr uin goto size } (*Tns_rr)(unsafe.Pointer(rr)).Frdata = (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr - *(*uintptr)(unsafe.Pointer(handle + 72)) += uintptr((*Tns_rr)(unsafe.Pointer(rr)).Frdlength) + **(**uintptr)(__ccgo_up(handle + 72)) += uintptr((*Tns_rr)(unsafe.Pointer(rr)).Frdlength) } else { (*Tns_rr)(unsafe.Pointer(rr)).Fttl = uint32(0) (*Tns_rr)(unsafe.Pointer(rr)).Frdlength = uint16(0) (*Tns_rr)(unsafe.Pointer(rr)).Frdata = UintptrFromInt32(0) } (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum = (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum + 1 - if (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum > Int32FromUint16(*(*Tuint16_t)(unsafe.Pointer(handle + 20 + uintptr(section)*2))) { + if (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum > Int32FromUint16(**(**Tuint16_t)(__ccgo_up(handle + 20 + uintptr(section)*2))) { (*Tns_msg)(unsafe.Pointer(handle)).F_sect = section + int32(1) if (*Tns_msg)(unsafe.Pointer(handle)).F_sect == int32(_ns_s_max) { (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum = -int32(1) @@ -123189,12 +123189,12 @@ func Xns_parserr(tls *TLS, handle uintptr, section Tns_sect, rrnum int32, rr uin goto bad bad: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENODEV) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENODEV) return -int32(1) goto size size: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EMSGSIZE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EMSGSIZE) return -int32(1) } @@ -123207,7 +123207,7 @@ func Xns_name_uncompress(tls *TLS, msg uintptr, eom uintptr, src uintptr, dst ui _ = r r = Xdn_expand(tls, msg, eom, src, dst, Int32FromUint64(dstsiz)) if r < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EMSGSIZE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EMSGSIZE) } return r } @@ -123452,9 +123452,9 @@ func X__convert_scm_timestamps(tls *TLS, msg uintptr, csize Tsocklen_t) { common: ; Xmemcpy(tls, bp, cmsg+UintptrFromInt32(1)*16, uint64(8)) - (*(*[2]int64)(unsafe.Pointer(bp + 8)))[0] = *(*int64)(unsafe.Pointer(bp)) + (**(**[2]int64)(__ccgo_up(bp + 8)))[0] = int64(**(**int64)(__ccgo_up(bp))) Xmemcpy(tls, bp, cmsg+UintptrFromInt32(1)*16+uintptr(8), uint64(8)) - (*(*[2]int64)(unsafe.Pointer(bp + 8)))[int32(1)] = *(*int64)(unsafe.Pointer(bp)) + (**(**[2]int64)(__ccgo_up(bp + 8)))[int32(1)] = int64(**(**int64)(__ccgo_up(bp))) goto _5 _5: } @@ -123473,7 +123473,7 @@ func X__convert_scm_timestamps(tls *TLS, msg uintptr, csize Tsocklen_t) { return } if (Uint64FromInt64(16)+Uint64FromInt64(8)-Uint64FromInt32(1)) & ^(Uint64FromInt64(8)-Uint64FromInt32(1)) + (Uint64FromInt64(16)+Uint64FromInt64(8)-Uint64FromInt32(1)) & ^(Uint64FromInt64(8)-Uint64FromInt32(1)) > uint64(csize-(*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_controllen) { - *(*int32)(unsafe.Pointer(msg + 48)) |= int32(MSG_CTRUNC) + **(**int32)(__ccgo_up(msg + 48)) |= int32(MSG_CTRUNC) return } v2 = msg + 40 @@ -123508,10 +123508,10 @@ func Xrecvmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r2 Tssize_t) { orig_controllen = (*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_controllen orig = msg if msg != 0 { - *(*Tmsghdr)(unsafe.Pointer(bp)) = *(*Tmsghdr)(unsafe.Pointer(msg)) + **(**Tmsghdr)(__ccgo_up(bp)) = **(**Tmsghdr)(__ccgo_up(msg)) v1 = Int32FromInt32(0) - (*(*Tmsghdr)(unsafe.Pointer(bp))).F__pad2 = v1 - (*(*Tmsghdr)(unsafe.Pointer(bp))).F__pad1 = v1 + (**(**Tmsghdr)(__ccgo_up(bp))).F__pad2 = v1 + (**(**Tmsghdr)(__ccgo_up(bp))).F__pad1 = v1 msg = bp } v1 = int32(SYS_recvmsg) @@ -123539,7 +123539,7 @@ _10: X__convert_scm_timestamps(tls, msg, orig_controllen) } if orig != 0 { - *(*Tmsghdr)(unsafe.Pointer(orig)) = *(*Tmsghdr)(unsafe.Pointer(bp)) + **(**Tmsghdr)(__ccgo_up(orig)) = **(**Tmsghdr)(__ccgo_up(bp)) } return r1 } @@ -123565,10 +123565,10 @@ func X__res_mkquery(tls *TLS, op int32, dname uintptr, class int32, type1 int32, var _ /* ts at bp+280 */ Ttimespec _, _, _, _, _ = i, id, j, l, n l = Xstrnlen(tls, dname, uint64(255)) - if l != 0 && int32(*(*int8)(unsafe.Pointer(dname + uintptr(l-uint64(1))))) == int32('.') { + if l != 0 && int32(**(**int8)(__ccgo_up(dname + uintptr(l-uint64(1))))) == int32('.') { l = l - 1 } - if l != 0 && int32(*(*int8)(unsafe.Pointer(dname + uintptr(l-uint64(1))))) == int32('.') { + if l != 0 && int32(**(**int8)(__ccgo_up(dname + uintptr(l-uint64(1))))) == int32('.') { return -int32(1) } n = Int32FromUint64(uint64(17) + l + BoolUint64(!!(l != 0))) @@ -123577,18 +123577,18 @@ func X__res_mkquery(tls *TLS, op int32, dname uintptr, class int32, type1 int32, } /* Construct query template - ID will be filled later */ Xmemset(tls, bp, 0, Uint64FromInt32(n)) - (*(*[280]uint8)(unsafe.Pointer(bp)))[int32(2)] = Uint8FromInt32(op*int32(8) + int32(1)) - (*(*[280]uint8)(unsafe.Pointer(bp)))[int32(3)] = uint8(32) /* AD */ - (*(*[280]uint8)(unsafe.Pointer(bp)))[int32(5)] = uint8(1) + (**(**[280]uint8)(__ccgo_up(bp)))[int32(2)] = Uint8FromInt32(op*int32(8) + int32(1)) + (**(**[280]uint8)(__ccgo_up(bp)))[int32(3)] = uint8(32) /* AD */ + (**(**[280]uint8)(__ccgo_up(bp)))[int32(5)] = uint8(1) Xmemcpy(tls, bp+uintptr(13), dname, l) i = int32(13) for { - if !((*(*[280]uint8)(unsafe.Pointer(bp)))[i] != 0) { + if !((**(**[280]uint8)(__ccgo_up(bp)))[i] != 0) { break } j = i for { - if !((*(*[280]uint8)(unsafe.Pointer(bp)))[j] != 0 && Int32FromUint8((*(*[280]uint8)(unsafe.Pointer(bp)))[j]) != int32('.')) { + if !((**(**[280]uint8)(__ccgo_up(bp)))[j] != 0 && Int32FromUint8((**(**[280]uint8)(__ccgo_up(bp)))[j]) != int32('.')) { break } goto _2 @@ -123599,19 +123599,19 @@ func X__res_mkquery(tls *TLS, op int32, dname uintptr, class int32, type1 int32, if Uint32FromInt32(j-i)-uint32(1) > uint32(62) { return -int32(1) } - (*(*[280]uint8)(unsafe.Pointer(bp)))[i-int32(1)] = Uint8FromInt32(j - i) + (**(**[280]uint8)(__ccgo_up(bp)))[i-int32(1)] = Uint8FromInt32(j - i) goto _1 _1: ; i = j + int32(1) } - (*(*[280]uint8)(unsafe.Pointer(bp)))[i+int32(1)] = Uint8FromInt32(type1) - (*(*[280]uint8)(unsafe.Pointer(bp)))[i+int32(3)] = Uint8FromInt32(class) + (**(**[280]uint8)(__ccgo_up(bp)))[i+int32(1)] = Uint8FromInt32(type1) + (**(**[280]uint8)(__ccgo_up(bp)))[i+int32(3)] = Uint8FromInt32(class) /* Make a reasonably unpredictable id */ Xclock_gettime(tls, CLOCK_REALTIME, bp+280) - id = Int32FromUint64((Uint64FromInt64((*(*Ttimespec)(unsafe.Pointer(bp + 280))).Ftv_nsec) + Uint64FromInt64((*(*Ttimespec)(unsafe.Pointer(bp + 280))).Ftv_nsec)/uint64(65536)) & uint64(0xffff)) - (*(*[280]uint8)(unsafe.Pointer(bp)))[0] = Uint8FromInt32(id / int32(256)) - (*(*[280]uint8)(unsafe.Pointer(bp)))[int32(1)] = Uint8FromInt32(id) + id = Int32FromUint64((Uint64FromInt64((**(**Ttimespec)(__ccgo_up(bp + 280))).Ftv_nsec) + Uint64FromInt64((**(**Ttimespec)(__ccgo_up(bp + 280))).Ftv_nsec)/uint64(65536)) & uint64(0xffff)) + (**(**[280]uint8)(__ccgo_up(bp)))[0] = Uint8FromInt32(id / int32(256)) + (**(**[280]uint8)(__ccgo_up(bp)))[int32(1)] = Uint8FromInt32(id) Xmemcpy(tls, buf, bp, Uint64FromInt32(n)) return n } @@ -123728,11 +123728,11 @@ func _cleanup(tls *TLS, p uintptr) { pfd = p i = 0 for { - if !((*(*Tpollfd)(unsafe.Pointer(pfd + uintptr(i)*8))).Ffd >= -int32(1)) { + if !((**(**Tpollfd)(__ccgo_up(pfd + uintptr(i)*8))).Ffd >= -int32(1)) { break } - if (*(*Tpollfd)(unsafe.Pointer(pfd + uintptr(i)*8))).Ffd >= 0 { - X__syscall1(tls, int64(SYS_close), int64((*(*Tpollfd)(unsafe.Pointer(pfd + uintptr(i)*8))).Ffd)) + if (**(**Tpollfd)(__ccgo_up(pfd + uintptr(i)*8))).Ffd >= 0 { + X__syscall1(tls, int64(SYS_close), int64((**(**Tpollfd)(__ccgo_up(pfd + uintptr(i)*8))).Ffd)) } goto _1 _1: @@ -123745,10 +123745,10 @@ func _mtime(tls *TLS) (r uint64) { bp := tls.Alloc(16) defer tls.Free(16) var _ /* ts at bp+0 */ Ttimespec - if Xclock_gettime(tls, int32(CLOCK_MONOTONIC), bp) < 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENOSYS) { + if Xclock_gettime(tls, int32(CLOCK_MONOTONIC), bp) < 0 && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENOSYS) { Xclock_gettime(tls, CLOCK_REALTIME, bp) } - return Uint64FromInt64((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec)*uint64(1000) + Uint64FromInt64((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_nsec/int64(1000000)) + return Uint64FromInt64((**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec)*uint64(1000) + Uint64FromInt64((**(**Ttimespec)(__ccgo_up(bp))).Ftv_nsec/int64(1000000)) } func _start_tcp(tls *TLS, pfd uintptr, family int32, sa uintptr, sl Tsocklen_t, q uintptr, ql int32) (r1 int32) { @@ -123771,7 +123771,7 @@ func _start_tcp(tls *TLS, pfd uintptr, family int32, sa uintptr, sl Tsocklen_t, Fiov_len: Uint64FromInt32(ql), }, } - *(*Tmsghdr)(unsafe.Pointer(bp + 40)) = Tmsghdr{ + **(**Tmsghdr)(__ccgo_up(bp + 40)) = Tmsghdr{ Fmsg_name: sa, Fmsg_namelen: sl, Fmsg_iov: bp, @@ -123789,12 +123789,12 @@ func _start_tcp(tls *TLS, pfd uintptr, family int32, sa uintptr, sl Tsocklen_t, if r >= 0 { return r } - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EINPROGRESS) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EINPROGRESS) { return 0 } } r = Xconnect(tls, fd, sa, sl) - if !(r != 0) || *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EINPROGRESS) { + if !(r != 0) || **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EINPROGRESS) { return 0 } Xclose(tls, fd) @@ -123813,7 +123813,7 @@ func _step_mh(tls *TLS, mh uintptr, n Tsize_t) { return } (*Tiovec)(unsafe.Pointer((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov)).Fiov_base = (*Tiovec)(unsafe.Pointer((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov)).Fiov_base + uintptr(n) - *(*Tsize_t)(unsafe.Pointer((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov + 8)) -= n + **(**Tsize_t)(__ccgo_up((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov + 8)) -= n } /* Internal contract for __res_msend[_rc]: asize must be >=512, nqueries @@ -123865,11 +123865,11 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a F__ccgo_pad2 [12]byte }{} *(*uint16)(unsafe.Pointer(bp + 88)) = uint16(0) - *(*[3]struct { + **(**[3]struct { Fsin6 [0]Tsockaddr_in6 Fsin Tsockaddr_in F__ccgo_pad2 [12]byte - })(unsafe.Pointer(bp + 116)) = [3]struct { + })(__ccgo_up(bp + 116)) = [3]struct { Fsin6 [0]Tsockaddr_in6 Fsin Tsockaddr_in F__ccgo_pad2 [12]byte @@ -123896,16 +123896,16 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a iplit = conf + uintptr(nns)*28 if (*Taddress)(unsafe.Pointer(iplit)).Ffamily == int32(PF_INET) { Xmemcpy(tls, bp+116+uintptr(nns)*28+4, iplit+8, uint64(4)) - (*(*[3]struct { + (**(**[3]struct { Fsin6 [0]Tsockaddr_in6 Fsin Tsockaddr_in F__ccgo_pad2 [12]byte - })(unsafe.Pointer(bp + 116)))[nns].Fsin.Fsin_port = Xhtons(tls, uint16(53)) - (*(*[3]struct { + })(__ccgo_up(bp + 116)))[nns].Fsin.Fsin_port = Xhtons(tls, uint16(53)) + (**(**[3]struct { Fsin6 [0]Tsockaddr_in6 Fsin Tsockaddr_in F__ccgo_pad2 [12]byte - })(unsafe.Pointer(bp + 116)))[nns].Fsin.Fsin_family = uint16(PF_INET) + })(__ccgo_up(bp + 116)))[nns].Fsin.Fsin_family = uint16(PF_INET) } else { sl = uint32(28) Xmemcpy(tls, bp+116+uintptr(nns)*28+8, iplit+8, uint64(16)) @@ -123923,10 +123923,10 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a /* Get local address and open/bind a socket */ fd = Xsocket(tls, family, Int32FromInt32(SOCK_DGRAM)|Int32FromInt32(SOCK_CLOEXEC)|Int32FromInt32(SOCK_NONBLOCK), 0) /* Handle case where system lacks IPv6 support */ - if fd < 0 && family == int32(PF_INET6) && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EAFNOSUPPORT) { + if fd < 0 && family == int32(PF_INET6) && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EAFNOSUPPORT) { i = 0 for { - if !(i < nns && (*(*Taddress)(unsafe.Pointer(conf + uintptr(nns)*28))).Ffamily == int32(PF_INET6)) { + if !(i < nns && (**(**Taddress)(__ccgo_up(conf + uintptr(nns)*28))).Ffamily == int32(PF_INET6)) { break } goto _7 @@ -123935,7 +123935,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a i = i + 1 } if i == nns { - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 200)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 200)), uintptr(0)) return -int32(1) } fd = Xsocket(tls, int32(PF_INET), Int32FromInt32(SOCK_DGRAM)|Int32FromInt32(SOCK_CLOEXEC)|Int32FromInt32(SOCK_NONBLOCK), 0) @@ -123951,11 +123951,11 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a if !(i < nns) { break } - if Int32FromUint16((*(*[3]struct { + if Int32FromUint16((**(**[3]struct { Fsin6 [0]Tsockaddr_in6 Fsin Tsockaddr_in F__ccgo_pad2 [12]byte - })(unsafe.Pointer(bp + 116)))[i].Fsin.Fsin_family) != int32(PF_INET) { + })(__ccgo_up(bp + 116)))[i].Fsin.Fsin_family) != int32(PF_INET) { goto _8 } Xmemcpy(tls, bp+116+uintptr(i)*28+8+uintptr(12), bp+116+uintptr(i)*28+4, uint64(4)) @@ -123969,16 +123969,16 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a i = i + 1 } } - (*(*struct { + (**(**struct { Fsin6 [0]Tsockaddr_in6 Fsin Tsockaddr_in F__ccgo_pad2 [12]byte - })(unsafe.Pointer(bp + 88))).Fsin.Fsin_family = Uint16FromInt32(family) + })(__ccgo_up(bp + 88))).Fsin.Fsin_family = Uint16FromInt32(family) if fd < 0 || Xbind(tls, fd, bp+88, sl) < 0 { if fd >= 0 { Xclose(tls, fd) } - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 200)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 200)), uintptr(0)) return -int32(1) } /* Past this point, there are no errors. Each individual query will @@ -123999,7 +123999,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), nqueries*8))).Fevents = int16(POLLIN) (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), (nqueries+int32(1))*8))).Ffd = -int32(2) __pthread_cleanup_push(tls, bp+208, __ccgo_fp(_cleanup), pfd) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 200)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 200)), uintptr(0)) Xmemset(tls, alens, 0, uint64(4)*Uint64FromInt32(nqueries)) retry_interval = timeout / attempts next = 0 @@ -124015,7 +124015,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a * have an accepted answer. */ i = 0 for { - if !(i < nqueries && *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) > 0) { + if !(i < nqueries && **(**int32)(__ccgo_up(alens + uintptr(i)*4)) > 0) { break } goto _12 @@ -124033,13 +124033,13 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a if !(i < nqueries) { break } - if !(*(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) != 0) { + if !(**(**int32)(__ccgo_up(alens + uintptr(i)*4)) != 0) { j = 0 for { if !(j < nns) { break } - Xsendto(tls, fd, *(*uintptr)(unsafe.Pointer(queries + uintptr(i)*8)), Uint64FromInt32(*(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))), int32(MSG_NOSIGNAL), bp+116+uintptr(j)*28, sl) + Xsendto(tls, fd, **(**uintptr)(__ccgo_up(queries + uintptr(i)*8)), Uint64FromInt32(**(**int32)(__ccgo_up(qlens + uintptr(i)*4))), int32(MSG_NOSIGNAL), bp+116+uintptr(j)*28, sl) goto _14 _14: ; @@ -124061,11 +124061,11 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a for next < nqueries { *(*[1]Tiovec)(unsafe.Pointer(bp + 8)) = [1]Tiovec{ 0: { - Fiov_base: *(*uintptr)(unsafe.Pointer(answers + uintptr(next)*8)), + Fiov_base: **(**uintptr)(__ccgo_up(answers + uintptr(next)*8)), Fiov_len: Uint64FromInt32(asize), }, } - *(*Tmsghdr)(unsafe.Pointer(bp + 232)) = Tmsghdr{ + **(**Tmsghdr)(__ccgo_up(bp + 232)) = Tmsghdr{ Fmsg_name: bp + 88, Fmsg_namelen: sl, Fmsg_iov: bp + 8, @@ -124096,7 +124096,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a /* Find which query this answer goes with, if any */ i = next for { - if !(i < nqueries && (Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(answers + uintptr(next)*8))))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(queries + uintptr(i)*8))))) || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(answers + uintptr(next)*8)) + 1))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(queries + uintptr(i)*8)) + 1))))) { + if !(i < nqueries && (Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(answers + uintptr(next)*8))))) != Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(queries + uintptr(i)*8))))) || Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(answers + uintptr(next)*8)) + 1))) != Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(queries + uintptr(i)*8)) + 1))))) { break } goto _16 @@ -124107,13 +124107,13 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a if i == nqueries { continue } - if *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) != 0 { + if **(**int32)(__ccgo_up(alens + uintptr(i)*4)) != 0 { continue } /* Only accept positive or negative responses; * retry immediately on server failure, and ignore * all other codes such as refusal. */ - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(answers + uintptr(next)*8)) + 3))) & Int32FromInt32(15) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(answers + uintptr(next)*8)) + 3))) & Int32FromInt32(15) { case 0: fallthrough case int32(3): @@ -124123,7 +124123,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a servfail_retry = servfail_retry - 1 } if v18 && v6 != 0 { - Xsendto(tls, fd, *(*uintptr)(unsafe.Pointer(queries + uintptr(i)*8)), Uint64FromInt32(*(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))), int32(MSG_NOSIGNAL), bp+116+uintptr(j)*28, sl) + Xsendto(tls, fd, **(**uintptr)(__ccgo_up(queries + uintptr(i)*8)), Uint64FromInt32(**(**int32)(__ccgo_up(qlens + uintptr(i)*4))), int32(MSG_NOSIGNAL), bp+116+uintptr(j)*28, sl) } fallthrough default: @@ -124131,10 +124131,10 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a } /* Store answer in the right slot, or update next * available temp slot if it's already in place. */ - *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) = rlen + **(**int32)(__ccgo_up(alens + uintptr(i)*4)) = rlen if i == next { for { - if !(next < nqueries && *(*int32)(unsafe.Pointer(alens + uintptr(next)*4)) != 0) { + if !(next < nqueries && **(**int32)(__ccgo_up(alens + uintptr(next)*4)) != 0) { break } goto _19 @@ -124143,18 +124143,18 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a next = next + 1 } } else { - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(answers + uintptr(i)*8)), *(*uintptr)(unsafe.Pointer(answers + uintptr(next)*8)), Uint64FromInt32(rlen)) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(answers + uintptr(i)*8)), **(**uintptr)(__ccgo_up(answers + uintptr(next)*8)), Uint64FromInt32(rlen)) } /* Ignore further UDP if all slots full or TCP-mode */ if next == nqueries { (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), nqueries*8))).Fevents = 0 } /* If answer is truncated (TC bit), fallback to TCP */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(answers + uintptr(i)*8)) + 2)))&int32(2) != 0 || (*(*Tmsghdr)(unsafe.Pointer(bp + 232))).Fmsg_flags&int32(MSG_TRUNC) != 0 { - *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) = -int32(1) + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(answers + uintptr(i)*8)) + 2)))&int32(2) != 0 || (**(**Tmsghdr)(__ccgo_up(bp + 232))).Fmsg_flags&int32(MSG_TRUNC) != 0 { + **(**int32)(__ccgo_up(alens + uintptr(i)*4)) = -int32(1) _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), uintptr(0)) - r = _start_tcp(tls, pfd+uintptr(i)*8, family, bp+116+uintptr(j)*28, sl, *(*uintptr)(unsafe.Pointer(queries + uintptr(i)*8)), *(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 200)), uintptr(0)) + r = _start_tcp(tls, pfd+uintptr(i)*8, family, bp+116+uintptr(j)*28, sl, **(**uintptr)(__ccgo_up(queries + uintptr(i)*8)), **(**int32)(__ccgo_up(qlens + uintptr(i)*4))) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 200)), uintptr(0)) if r >= 0 { *(*int32)(unsafe.Add(unsafe.Pointer(qpos), i*4)) = r *(*int32)(unsafe.Add(unsafe.Pointer(apos), i*4)) = 0 @@ -124169,8 +124169,8 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a } if int32((*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), i*8))).Frevents)&int32(POLLOUT) != 0 { *(*[2]Tuint8_t)(unsafe.Pointer(bp + 52)) = [2]Tuint8_t{ - 0: Uint8FromInt32(*(*int32)(unsafe.Pointer(qlens + uintptr(i)*4)) >> int32(8)), - 1: Uint8FromInt32(*(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))), + 0: Uint8FromInt32(**(**int32)(__ccgo_up(qlens + uintptr(i)*4)) >> int32(8)), + 1: Uint8FromInt32(**(**int32)(__ccgo_up(qlens + uintptr(i)*4))), } *(*[2]Tiovec)(unsafe.Pointer(bp + 24)) = [2]Tiovec{ 0: { @@ -124178,11 +124178,11 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a Fiov_len: uint64(2), }, 1: { - Fiov_base: *(*uintptr)(unsafe.Pointer(queries + uintptr(i)*8)), - Fiov_len: Uint64FromInt32(*(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))), + Fiov_base: **(**uintptr)(__ccgo_up(queries + uintptr(i)*8)), + Fiov_len: Uint64FromInt32(**(**int32)(__ccgo_up(qlens + uintptr(i)*4))), }, } - *(*Tmsghdr)(unsafe.Pointer(bp + 288)) = Tmsghdr{ + **(**Tmsghdr)(__ccgo_up(bp + 288)) = Tmsghdr{ Fmsg_iov: bp + 24, Fmsg_iovlen: int32(2), } @@ -124191,8 +124191,8 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a if r < 0 { goto out } - *(*int32)(unsafe.Pointer(qpos + uintptr(i)*4)) += r - if *(*int32)(unsafe.Add(unsafe.Pointer(qpos), i*4)) == *(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))+int32(2) { + **(**int32)(__ccgo_up(qpos + uintptr(i)*4)) += r + if *(*int32)(unsafe.Add(unsafe.Pointer(qpos), i*4)) == **(**int32)(__ccgo_up(qlens + uintptr(i)*4))+int32(2) { (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), i*8))).Fevents = int16(POLLIN) } } @@ -124213,11 +124213,11 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a Fiov_len: uint64(2), }, 1: { - Fiov_base: *(*uintptr)(unsafe.Pointer(answers + uintptr(i)*8)), + Fiov_base: **(**uintptr)(__ccgo_up(answers + uintptr(i)*8)), Fiov_len: Uint64FromInt32(asize), }, } - *(*Tmsghdr)(unsafe.Pointer(bp + 344)) = Tmsghdr{ + **(**Tmsghdr)(__ccgo_up(bp + 344)) = Tmsghdr{ Fmsg_iov: bp + 56, Fmsg_iovlen: int32(2), } @@ -124226,25 +124226,25 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a if r <= 0 { goto out } - *(*int32)(unsafe.Pointer(apos + uintptr(i)*4)) += r + **(**int32)(__ccgo_up(apos + uintptr(i)*4)) += r if *(*int32)(unsafe.Add(unsafe.Pointer(apos), i*4)) < int32(2) { goto _21 } - alen = Int32FromUint8(*(*uint8)(unsafe.Pointer(alen_buf + uintptr(i)*2)))*int32(256) + Int32FromUint8(*(*uint8)(unsafe.Pointer(alen_buf + uintptr(i)*2 + 1))) + alen = Int32FromUint8(**(**uint8)(__ccgo_up(alen_buf + uintptr(i)*2)))*int32(256) + Int32FromUint8(**(**uint8)(__ccgo_up(alen_buf + uintptr(i)*2 + 1))) if alen < int32(13) { goto out } if *(*int32)(unsafe.Add(unsafe.Pointer(apos), i*4)) < alen+int32(2) && *(*int32)(unsafe.Add(unsafe.Pointer(apos), i*4)) < asize+int32(2) { goto _21 } - rcode = Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(answers + uintptr(i)*8)) + 3))) & int32(15) + rcode = Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(answers + uintptr(i)*8)) + 3))) & int32(15) if rcode != 0 && rcode != int32(3) { goto out } /* Storing the length here commits the accepted answer. * Immediately close TCP socket so as not to consume * resources we no longer need. */ - *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) = alen + **(**int32)(__ccgo_up(alens + uintptr(i)*4)) = alen X__syscall1(tls, int64(SYS_close), int64((*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), i*8))).Ffd)) (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), i*8))).Ffd = -int32(1) } @@ -124268,8 +124268,8 @@ out: if !(i < nqueries) { break } - if *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) < 0 { - *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) = 0 + if **(**int32)(__ccgo_up(alens + uintptr(i)*4)) < 0 { + **(**int32)(__ccgo_up(alens + uintptr(i)*4)) = 0 } goto _22 _22: @@ -124307,23 +124307,23 @@ func X__res_send(tls *TLS, _msg uintptr, _msglen int32, _answer uintptr, _anslen var r, v1 int32 var _ /* buf at bp+28 */ [512]uint8 _, _ = r, v1 - if *(*int32)(unsafe.Pointer(bp + 24)) < int32(512) { - r = X__res_send(tls, *(*uintptr)(unsafe.Pointer(bp)), *(*int32)(unsafe.Pointer(bp + 8)), bp+28, int32(512)) + if **(**int32)(__ccgo_up(bp + 24)) < int32(512) { + r = X__res_send(tls, **(**uintptr)(__ccgo_up(bp)), **(**int32)(__ccgo_up(bp + 8)), bp+28, int32(512)) if r >= 0 { - if r < *(*int32)(unsafe.Pointer(bp + 24)) { + if r < **(**int32)(__ccgo_up(bp + 24)) { v1 = r } else { - v1 = *(*int32)(unsafe.Pointer(bp + 24)) + v1 = **(**int32)(__ccgo_up(bp + 24)) } - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(bp + 16)), bp+28, Uint64FromInt32(v1)) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(bp + 16)), bp+28, Uint64FromInt32(v1)) } return r } - r = X__res_msend(tls, int32(1), bp, bp+8, bp+16, bp+24, *(*int32)(unsafe.Pointer(bp + 24))) - if r < 0 || !(*(*int32)(unsafe.Pointer(bp + 24)) != 0) { + r = X__res_msend(tls, int32(1), bp, bp+8, bp+16, bp+24, **(**int32)(__ccgo_up(bp + 24))) + if r < 0 || !(**(**int32)(__ccgo_up(bp + 24)) != 0) { v1 = -int32(1) } else { - v1 = *(*int32)(unsafe.Pointer(bp + 24)) + v1 = **(**int32)(__ccgo_up(bp + 24)) } return v1 } @@ -124370,11 +124370,11 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ (*Tresolvconf)(unsafe.Pointer(conf)).Ftimeout = uint32(5) (*Tresolvconf)(unsafe.Pointer(conf)).Fattempts = uint32(2) if search != 0 { - *(*int8)(unsafe.Pointer(search)) = 0 + **(**int8)(__ccgo_up(search)) = 0 } f = X__fopen_rb_ca(tls, __ccgo_ts+1139, bp+512, bp+256, uint64(256)) if !(f != 0) { - switch *(*int32)(unsafe.Pointer(X__errno_location(tls))) { + switch **(**int32)(__ccgo_up(X__errno_location(tls))) { case int32(ENOENT): fallthrough case int32(ENOTDIR): @@ -124393,17 +124393,17 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ continue } if v4 = !(Xstrncmp(tls, bp, __ccgo_ts+1156, uint64(7)) != 0); v4 { - v1 = int32((*(*[256]int8)(unsafe.Pointer(bp)))[int32(7)]) + v1 = int32((**(**[256]int8)(__ccgo_up(bp)))[int32(7)]) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _3 _3: } if v4 && v2 != 0 { p = Xstrstr(tls, bp, __ccgo_ts+1164) - if p != 0 && BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(p + 6)))-uint32('0') < uint32(10)) != 0 { + if p != 0 && BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(p + 6)))-uint32('0') < uint32(10)) != 0 { p = p + uintptr(6) x = Xstrtoul(tls, p, bp+744, int32(10)) - if *(*uintptr)(unsafe.Pointer(bp + 744)) != p { + if **(**uintptr)(__ccgo_up(bp + 744)) != p { if x > uint64(15) { v5 = uint64(15) } else { @@ -124413,10 +124413,10 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ } } p = Xstrstr(tls, bp, __ccgo_ts+1171) - if p != 0 && BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(p + 9)))-uint32('0') < uint32(10)) != 0 { + if p != 0 && BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(p + 9)))-uint32('0') < uint32(10)) != 0 { p = p + uintptr(9) x1 = Xstrtoul(tls, p, bp+744, int32(10)) - if *(*uintptr)(unsafe.Pointer(bp + 744)) != p { + if **(**uintptr)(__ccgo_up(bp + 744)) != p { if x1 > uint64(10) { v5 = uint64(10) } else { @@ -124426,10 +124426,10 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ } } p = Xstrstr(tls, bp, __ccgo_ts+1181) - if p != 0 && (BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(p + 8)))-uint32('0') < uint32(10)) != 0 || int32(*(*int8)(unsafe.Pointer(p + 8))) == int32('.')) { + if p != 0 && (BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(p + 8)))-uint32('0') < uint32(10)) != 0 || int32(**(**int8)(__ccgo_up(p + 8))) == int32('.')) { p = p + uintptr(8) x2 = Xstrtoul(tls, p, bp+744, int32(10)) - if *(*uintptr)(unsafe.Pointer(bp + 744)) != p { + if **(**uintptr)(__ccgo_up(bp + 744)) != p { if x2 > uint64(60) { v5 = uint64(60) } else { @@ -124441,7 +124441,7 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ continue } if v4 = !(Xstrncmp(tls, bp, __ccgo_ts+1190, uint64(10)) != 0); v4 { - v1 = int32((*(*[256]int8)(unsafe.Pointer(bp)))[int32(10)]) + v1 = int32((**(**[256]int8)(__ccgo_up(bp)))[int32(10)]) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _10 _10: @@ -124452,7 +124452,7 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ } p = bp + uintptr(11) for { - v1 = int32(*(*int8)(unsafe.Pointer(p))) + v1 = int32(**(**int8)(__ccgo_up(p))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _15 _15: @@ -124464,10 +124464,10 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ ; p = p + 1 } - *(*uintptr)(unsafe.Pointer(bp + 744)) = p + **(**uintptr)(__ccgo_up(bp + 744)) = p for { - if v4 = *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 744)))) != 0; v4 { - v1 = int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 744))))) + if v4 = **(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 744)))) != 0; v4 { + v1 = int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 744))))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _19 _19: @@ -124478,9 +124478,9 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ goto _16 _16: ; - *(*uintptr)(unsafe.Pointer(bp + 744)) = *(*uintptr)(unsafe.Pointer(bp + 744)) + 1 + **(**uintptr)(__ccgo_up(bp + 744)) = **(**uintptr)(__ccgo_up(bp + 744)) + 1 } - *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 744)))) = 0 + **(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 744)))) = 0 if X__lookup_ipliteral(tls, conf+uintptr(nns)*28, p, PF_UNSPEC) > 0 { nns = nns + 1 } @@ -124490,7 +124490,7 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ continue } if v4 = Xstrncmp(tls, bp, __ccgo_ts+1201, uint64(6)) != 0 && Xstrncmp(tls, bp, __ccgo_ts+1208, uint64(6)) != 0; !v4 { - v1 = int32((*(*[256]int8)(unsafe.Pointer(bp)))[int32(6)]) + v1 = int32((**(**[256]int8)(__ccgo_up(bp)))[int32(6)]) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _23 _23: @@ -124500,7 +124500,7 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ } p = bp + uintptr(7) for { - v1 = int32(*(*int8)(unsafe.Pointer(p))) + v1 = int32(**(**int8)(__ccgo_up(p))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _28 _28: @@ -124566,7 +124566,7 @@ func Xsendmmsg(tls *TLS, fd int32, msgvec uintptr, vlen uint32, flags uint32) (r if r < 0 { goto error } - (*(*Tmmsghdr)(unsafe.Pointer(msgvec + uintptr(i)*64))).Fmsg_len = Uint32FromInt64(r) + (**(**Tmmsghdr)(__ccgo_up(msgvec + uintptr(i)*64))).Fmsg_len = Uint32FromInt64(r) goto _1 _1: ; @@ -124599,18 +124599,18 @@ func Xsendmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r1 Tssize_t) { var _ /* h at bp+0 */ Tmsghdr _, _, _, _, _, _, _, _, _, _, _ = c1, r, v1, v10, v11, v12, v3, v6, v7, v8, v9 if msg != 0 { - *(*Tmsghdr)(unsafe.Pointer(bp)) = *(*Tmsghdr)(unsafe.Pointer(msg)) + **(**Tmsghdr)(__ccgo_up(bp)) = **(**Tmsghdr)(__ccgo_up(msg)) v1 = Int32FromInt32(0) - (*(*Tmsghdr)(unsafe.Pointer(bp))).F__pad2 = v1 - (*(*Tmsghdr)(unsafe.Pointer(bp))).F__pad1 = v1 + (**(**Tmsghdr)(__ccgo_up(bp))).F__pad2 = v1 + (**(**Tmsghdr)(__ccgo_up(bp))).F__pad1 = v1 msg = bp - if (*(*Tmsghdr)(unsafe.Pointer(bp))).Fmsg_controllen != 0 { - if uint64((*(*Tmsghdr)(unsafe.Pointer(bp))).Fmsg_controllen) > uint64(1056) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + if (**(**Tmsghdr)(__ccgo_up(bp))).Fmsg_controllen != 0 { + if uint64((**(**Tmsghdr)(__ccgo_up(bp))).Fmsg_controllen) > uint64(1056) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return int64(-int32(1)) } - Xmemcpy(tls, bp+56, (*(*Tmsghdr)(unsafe.Pointer(bp))).Fmsg_control, uint64((*(*Tmsghdr)(unsafe.Pointer(bp))).Fmsg_controllen)) - (*(*Tmsghdr)(unsafe.Pointer(bp))).Fmsg_control = bp + 56 + Xmemcpy(tls, bp+56, (**(**Tmsghdr)(__ccgo_up(bp))).Fmsg_control, uint64((**(**Tmsghdr)(__ccgo_up(bp))).Fmsg_controllen)) + (**(**Tmsghdr)(__ccgo_up(bp))).Fmsg_control = bp + 56 if uint64((*Tmsghdr)(unsafe.Pointer(bp)).Fmsg_controllen) >= uint64(16) { v3 = (*Tmsghdr)(unsafe.Pointer(bp)).Fmsg_control } else { @@ -124883,7 +124883,7 @@ func Xsockatmark(tls *TLS, s int32) (r int32) { if Xioctl(tls, s, int32(SIOCATMARK), VaList(bp+16, bp)) < 0 { return -int32(1) } - return *(*int32)(unsafe.Pointer(bp)) + return **(**int32)(__ccgo_up(bp)) } func Xsocket(tls *TLS, domain int32, type1 int32, protocol int32) (r1 int32) { @@ -124981,7 +124981,7 @@ func Xsocketpair(tls *TLS, domain int32, type1 int32, protocol int32, fd uintptr goto _9 _9: r1 = int32(X__syscall_ret(tls, Uint64FromInt64(v8))) - if r1 < 0 && (*(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EINVAL) || *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EPROTONOSUPPORT)) && type1&(Int32FromInt32(SOCK_CLOEXEC)|Int32FromInt32(SOCK_NONBLOCK)) != 0 { + if r1 < 0 && (**(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EINVAL) || **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EPROTONOSUPPORT)) && type1&(Int32FromInt32(SOCK_CLOEXEC)|Int32FromInt32(SOCK_NONBLOCK)) != 0 { v10 = int32(SYS_socketpair) _ = int32(__SC_socketpair) v11 = int64(domain) @@ -125007,12 +125007,12 @@ _9: return r1 } if type1&int32(SOCK_CLOEXEC) != 0 { - X__syscall3(tls, int64(__NR3264_fcntl), int64(*(*int32)(unsafe.Pointer(fd))), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) - X__syscall3(tls, int64(__NR3264_fcntl), int64(*(*int32)(unsafe.Pointer(fd + 1*4))), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) + X__syscall3(tls, int64(__NR3264_fcntl), int64(**(**int32)(__ccgo_up(fd))), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) + X__syscall3(tls, int64(__NR3264_fcntl), int64(**(**int32)(__ccgo_up(fd + 1*4))), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) } if type1&int32(SOCK_NONBLOCK) != 0 { - X__syscall3(tls, int64(__NR3264_fcntl), int64(*(*int32)(unsafe.Pointer(fd))), int64(Int32FromInt32(F_SETFL)), int64(Int32FromInt32(O_NONBLOCK))) - X__syscall3(tls, int64(__NR3264_fcntl), int64(*(*int32)(unsafe.Pointer(fd + 1*4))), int64(Int32FromInt32(F_SETFL)), int64(Int32FromInt32(O_NONBLOCK))) + X__syscall3(tls, int64(__NR3264_fcntl), int64(**(**int32)(__ccgo_up(fd))), int64(Int32FromInt32(F_SETFL)), int64(Int32FromInt32(O_NONBLOCK))) + X__syscall3(tls, int64(__NR3264_fcntl), int64(**(**int32)(__ccgo_up(fd + 1*4))), int64(Int32FromInt32(F_SETFL)), int64(Int32FromInt32(O_NONBLOCK))) } } return r1 @@ -125049,10 +125049,10 @@ func Xfgetgrent(tls *TLS, f uintptr) (r uintptr) { var _ /* nmem at bp+16 */ Tsize_t var _ /* res at bp+0 */ uintptr var _ /* size at bp+8 */ Tsize_t - *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint64(0) - *(*Tsize_t)(unsafe.Pointer(bp + 16)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp + 8)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp + 16)) = uint64(0) X__getgrent_a(tls, f, uintptr(unsafe.Pointer(&_gr)), uintptr(unsafe.Pointer(&_line1)), bp+8, uintptr(unsafe.Pointer(&_mem)), bp+16, bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } var _line1 uintptr @@ -125070,9 +125070,9 @@ func Xfgetpwent(tls *TLS, f uintptr) (r uintptr) { defer tls.Free(16) var _ /* res at bp+8 */ uintptr var _ /* size at bp+0 */ Tsize_t - *(*Tsize_t)(unsafe.Pointer(bp)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp)) = uint64(0) X__getpwent_a(tls, f, uintptr(unsafe.Pointer(&_pw)), uintptr(unsafe.Pointer(&_line2)), bp, bp+8) - return *(*uintptr)(unsafe.Pointer(bp + 8)) + return **(**uintptr)(__ccgo_up(bp + 8)) } var _line2 uintptr @@ -125118,11 +125118,11 @@ func _itoa1(tls *TLS, p uintptr, x Tuint32_t) (r uintptr) { p = p + uintptr(11) p = p - 1 v1 = p - *(*int8)(unsafe.Pointer(v1)) = 0 + **(**int8)(__ccgo_up(v1)) = 0 for cond := true; cond; cond = x != 0 { p = p - 1 v1 = p - *(*int8)(unsafe.Pointer(v1)) = Int8FromUint32(uint32('0') + x%uint32(10)) + **(**int8)(__ccgo_up(v1)) = Int8FromUint32(uint32('0') + x%uint32(10)) x = x / uint32(10) } return p @@ -125147,36 +125147,36 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz var _ /* swap at bp+40 */ int32 _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, grlist_len, i, key, len1, ptr, req, rv, tmp, tmp1, v1, v10, v5, v6 rv = 0 - *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) + **(**uintptr)(__ccgo_up(res)) = uintptr(0) _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp) f = Xfopen(tls, __ccgo_ts+1225, __ccgo_ts+315) if !(f != 0) { - rv = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + rv = **(**int32)(__ccgo_up(X__errno_location(tls))) goto done } for { v1 = X__getgrent_a(tls, f, gr, buf, size, mem, nmem, res) rv = v1 - if !(!(v1 != 0) && *(*uintptr)(unsafe.Pointer(res)) != 0) { + if !(!(v1 != 0) && **(**uintptr)(__ccgo_up(res)) != 0) { break } - if name != 0 && !(Xstrcmp(tls, name, (*Tgroup)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(res)))).Fgr_name) != 0) || !(name != 0) && (*Tgroup)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(res)))).Fgr_gid == gid { + if name != 0 && !(Xstrcmp(tls, name, (*Tgroup)(unsafe.Pointer(**(**uintptr)(__ccgo_up(res)))).Fgr_name) != 0) || !(name != 0) && (*Tgroup)(unsafe.Pointer(**(**uintptr)(__ccgo_up(res)))).Fgr_gid == gid { break } } Xfclose(tls, f) - if !(*(*uintptr)(unsafe.Pointer(res)) != 0) && (rv == 0 || rv == int32(ENOENT) || rv == int32(ENOTDIR)) { + if !(**(**uintptr)(__ccgo_up(res)) != 0) && (rv == 0 || rv == int32(ENOENT) || rv == int32(ENOTDIR)) { if name != 0 { v1 = int32(GETGRBYNAME) } else { v1 = int32(GETGRBYGID) } req = v1 - *(*[6]Tint32_t)(unsafe.Pointer(bp + 4)) = [6]Tint32_t{} + **(**[6]Tint32_t)(__ccgo_up(bp + 4)) = [6]Tint32_t{} len1 = uint64(0) grlist_len = uint64(0) - *(*[11]int8)(unsafe.Pointer(bp + 28)) = [11]int8{} - *(*int32)(unsafe.Pointer(bp + 40)) = 0 + **(**[11]int8)(__ccgo_up(bp + 28)) = [11]int8{} + **(**int32)(__ccgo_up(bp + 40)) = 0 if name != 0 { key = name } else { @@ -125188,116 +125188,116 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz } f = X__nscd_query(tls, req, key, bp+4, uint64(24), bp+40) if !(f != 0) { - rv = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + rv = **(**int32)(__ccgo_up(X__errno_location(tls))) goto done } - if !((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRFOUND)] != 0) { + if !((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRFOUND)] != 0) { rv = 0 goto cleanup_f } - if !((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRNAMELEN)] != 0) || !((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRPASSWDLEN)] != 0) { + if !((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRNAMELEN)] != 0) || !((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRPASSWDLEN)] != 0) { rv = int32(EIO) goto cleanup_f } - if Uint64FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRNAMELEN)]) > uint64(0xffffffffffffffff)-Uint64FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRPASSWDLEN)]) { + if Uint64FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRNAMELEN)]) > uint64(0xffffffffffffffff)-Uint64FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRPASSWDLEN)]) { rv = int32(ENOMEM) goto cleanup_f } - len1 = Uint64FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRNAMELEN)] + (*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRPASSWDLEN)]) + len1 = Uint64FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRNAMELEN)] + (**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRPASSWDLEN)]) i = 0 for { - if !(i < (*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)]) { + if !(i < (**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)]) { break } if Xfread(tls, bp+44, uint64(4), uint64(1), f) < uint64(1) { if Xferror(tls, f) != 0 { - v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = **(**int32)(__ccgo_up(X__errno_location(tls))) } else { v1 = int32(EIO) } rv = v1 goto cleanup_f } - if *(*int32)(unsafe.Pointer(bp + 40)) != 0 { - v5 = *(*Tuint32_t)(unsafe.Pointer(bp + 44)) + if **(**int32)(__ccgo_up(bp + 40)) != 0 { + v5 = **(**Tuint32_t)(__ccgo_up(bp + 44)) v6 = v5>>int32(24) | v5>>int32(8)&uint32(0xff00) | v5< uint64(0xffffffffffffffff)-grlist_len || uint64(*(*Tuint32_t)(unsafe.Pointer(bp + 44))) > uint64(0xffffffffffffffff)-len1 { + if uint64(**(**Tuint32_t)(__ccgo_up(bp + 44))) > uint64(0xffffffffffffffff)-grlist_len || uint64(**(**Tuint32_t)(__ccgo_up(bp + 44))) > uint64(0xffffffffffffffff)-len1 { rv = int32(ENOMEM) goto cleanup_f } - len1 = len1 + uint64(*(*Tuint32_t)(unsafe.Pointer(bp + 44))) - grlist_len = grlist_len + uint64(*(*Tuint32_t)(unsafe.Pointer(bp + 44))) + len1 = len1 + uint64(**(**Tuint32_t)(__ccgo_up(bp + 44))) + grlist_len = grlist_len + uint64(**(**Tuint32_t)(__ccgo_up(bp + 44))) goto _3 _3: ; i = i + 1 } - if len1 > *(*Tsize_t)(unsafe.Pointer(size)) || !(*(*uintptr)(unsafe.Pointer(buf)) != 0) { - tmp = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(buf)), len1) + if len1 > **(**Tsize_t)(__ccgo_up(size)) || !(**(**uintptr)(__ccgo_up(buf)) != 0) { + tmp = Xrealloc(tls, **(**uintptr)(__ccgo_up(buf)), len1) if !(tmp != 0) { - rv = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + rv = **(**int32)(__ccgo_up(X__errno_location(tls))) goto cleanup_f } - *(*uintptr)(unsafe.Pointer(buf)) = tmp - *(*Tsize_t)(unsafe.Pointer(size)) = len1 + **(**uintptr)(__ccgo_up(buf)) = tmp + **(**Tsize_t)(__ccgo_up(size)) = len1 } - if !(Xfread(tls, *(*uintptr)(unsafe.Pointer(buf)), len1, uint64(1), f) != 0) { + if !(Xfread(tls, **(**uintptr)(__ccgo_up(buf)), len1, uint64(1), f) != 0) { if Xferror(tls, f) != 0 { - v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = **(**int32)(__ccgo_up(X__errno_location(tls))) } else { v1 = int32(EIO) } rv = v1 goto cleanup_f } - if Uint64FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)]+int32(1)) > *(*Tsize_t)(unsafe.Pointer(nmem)) { - if Uint64FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)]+int32(1)) > Uint64FromUint64(0xffffffffffffffff)/Uint64FromInt64(8) { + if Uint64FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)]+int32(1)) > **(**Tsize_t)(__ccgo_up(nmem)) { + if Uint64FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)]+int32(1)) > Uint64FromUint64(0xffffffffffffffff)/Uint64FromInt64(8) { rv = int32(ENOMEM) goto cleanup_f } - tmp1 = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(mem)), Uint64FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)]+Int32FromInt32(1))*uint64(8)) + tmp1 = Xrealloc(tls, **(**uintptr)(__ccgo_up(mem)), Uint64FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)]+Int32FromInt32(1))*uint64(8)) if !(tmp1 != 0) { - rv = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + rv = **(**int32)(__ccgo_up(X__errno_location(tls))) goto cleanup_f } - *(*uintptr)(unsafe.Pointer(mem)) = tmp1 - *(*Tsize_t)(unsafe.Pointer(nmem)) = Uint64FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)] + int32(1)) + **(**uintptr)(__ccgo_up(mem)) = tmp1 + **(**Tsize_t)(__ccgo_up(nmem)) = Uint64FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)] + int32(1)) } - if (*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)] != 0 { - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)))) = *(*uintptr)(unsafe.Pointer(buf)) + uintptr((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRNAMELEN)]) + uintptr((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRPASSWDLEN)]) - ptr = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)))) + if (**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)] != 0 { + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)))) = **(**uintptr)(__ccgo_up(buf)) + uintptr((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRNAMELEN)]) + uintptr((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRPASSWDLEN)]) + ptr = **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)))) i = Int32FromInt32(0) for { - if !(ptr != *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem))))+uintptr(grlist_len)) { + if !(ptr != **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem))))+uintptr(grlist_len)) { break } - if !(*(*int8)(unsafe.Pointer(ptr)) != 0) { + if !(**(**int8)(__ccgo_up(ptr)) != 0) { i = i + 1 v10 = i - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v10)*8)) = ptr + uintptr(1) + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)) + uintptr(v10)*8)) = ptr + uintptr(1) } goto _9 _9: ; ptr = ptr + 1 } - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(i)*8)) = uintptr(0) - if i != (*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)] { + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)) + uintptr(i)*8)) = uintptr(0) + if i != (**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)] { rv = int32(EIO) goto cleanup_f } } else { - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)))) = uintptr(0) + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)))) = uintptr(0) } - (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = *(*uintptr)(unsafe.Pointer(buf)) - (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = (*Tgroup)(unsafe.Pointer(gr)).Fgr_name + uintptr((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRNAMELEN)]) - (*Tgroup)(unsafe.Pointer(gr)).Fgr_gid = Uint32FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRGID)]) - (*Tgroup)(unsafe.Pointer(gr)).Fgr_mem = *(*uintptr)(unsafe.Pointer(mem)) - if *(*int8)(unsafe.Pointer((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd + uintptr(-Int32FromInt32(1)))) != 0 || *(*int8)(unsafe.Pointer((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd + uintptr((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRPASSWDLEN)]-int32(1)))) != 0 { + (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = **(**uintptr)(__ccgo_up(buf)) + (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = (*Tgroup)(unsafe.Pointer(gr)).Fgr_name + uintptr((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRNAMELEN)]) + (*Tgroup)(unsafe.Pointer(gr)).Fgr_gid = Uint32FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRGID)]) + (*Tgroup)(unsafe.Pointer(gr)).Fgr_mem = **(**uintptr)(__ccgo_up(mem)) + if **(**int8)(__ccgo_up((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd + uintptr(-Int32FromInt32(1)))) != 0 || **(**int8)(__ccgo_up((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd + uintptr((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRPASSWDLEN)]-int32(1)))) != 0 { rv = int32(EIO) goto cleanup_f } @@ -125305,7 +125305,7 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz rv = int32(EIO) goto cleanup_f } - *(*uintptr)(unsafe.Pointer(res)) = gr + **(**uintptr)(__ccgo_up(res)) = gr goto cleanup_f cleanup_f: ; @@ -125315,9 +125315,9 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz goto done done: ; - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) if rv != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = rv + **(**int32)(__ccgo_up(X__errno_location(tls))) = rv } return rv } @@ -125333,42 +125333,42 @@ func _getgr_r(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, size var _ /* mem at bp+16 */ uintptr var _ /* nmem at bp+24 */ Tsize_t _, _ = i, rv - *(*uintptr)(unsafe.Pointer(bp)) = uintptr(0) - *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint64(0) - *(*uintptr)(unsafe.Pointer(bp + 16)) = uintptr(0) - *(*Tsize_t)(unsafe.Pointer(bp + 24)) = uint64(0) + **(**uintptr)(__ccgo_up(bp)) = uintptr(0) + **(**Tsize_t)(__ccgo_up(bp + 8)) = uint64(0) + **(**uintptr)(__ccgo_up(bp + 16)) = uintptr(0) + **(**Tsize_t)(__ccgo_up(bp + 24)) = uint64(0) rv = 0 _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp+32) rv = X__getgr_a(tls, name, gid, gr, bp, bp+8, bp+16, bp+24, res) - if *(*uintptr)(unsafe.Pointer(res)) != 0 && size < *(*Tsize_t)(unsafe.Pointer(bp + 8))+(*(*Tsize_t)(unsafe.Pointer(bp + 24))+uint64(1))*uint64(8)+uint64(32) { - *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) + if **(**uintptr)(__ccgo_up(res)) != 0 && size < **(**Tsize_t)(__ccgo_up(bp + 8))+(**(**Tsize_t)(__ccgo_up(bp + 24))+uint64(1))*uint64(8)+uint64(32) { + **(**uintptr)(__ccgo_up(res)) = uintptr(0) rv = int32(ERANGE) } - if *(*uintptr)(unsafe.Pointer(res)) != 0 { + if **(**uintptr)(__ccgo_up(res)) != 0 { buf = buf + uintptr((uint64(16)-uint64(buf))%uint64(16)) (*Tgroup)(unsafe.Pointer(gr)).Fgr_mem = buf - buf = buf + uintptr((*(*Tsize_t)(unsafe.Pointer(bp + 24))+uint64(1))*uint64(8)) - Xmemcpy(tls, buf, *(*uintptr)(unsafe.Pointer(bp)), *(*Tsize_t)(unsafe.Pointer(bp + 8))) - (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = uintptr(int64((*Tgroup)(unsafe.Pointer(gr)).Fgr_name)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf - (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = uintptr(int64((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf + buf = buf + uintptr((**(**Tsize_t)(__ccgo_up(bp + 24))+uint64(1))*uint64(8)) + Xmemcpy(tls, buf, **(**uintptr)(__ccgo_up(bp)), **(**Tsize_t)(__ccgo_up(bp + 8))) + (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = uintptr(int64((*Tgroup)(unsafe.Pointer(gr)).Fgr_name)-int64(**(**uintptr)(__ccgo_up(bp)))) + buf + (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = uintptr(int64((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd)-int64(**(**uintptr)(__ccgo_up(bp)))) + buf i = uint64(0) for { - if !(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + uintptr(i)*8)) != 0) { + if !(**(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 16)) + uintptr(i)*8)) != 0) { break } - *(*uintptr)(unsafe.Pointer((*Tgroup)(unsafe.Pointer(gr)).Fgr_mem + uintptr(i)*8)) = uintptr(int64(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + uintptr(i)*8)))-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf + **(**uintptr)(__ccgo_up((*Tgroup)(unsafe.Pointer(gr)).Fgr_mem + uintptr(i)*8)) = uintptr(int64(**(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 16)) + uintptr(i)*8)))-int64(**(**uintptr)(__ccgo_up(bp)))) + buf goto _1 _1: ; i = i + 1 } - *(*uintptr)(unsafe.Pointer((*Tgroup)(unsafe.Pointer(gr)).Fgr_mem + uintptr(i)*8)) = uintptr(0) + **(**uintptr)(__ccgo_up((*Tgroup)(unsafe.Pointer(gr)).Fgr_mem + uintptr(i)*8)) = uintptr(0) } - Xfree(tls, *(*uintptr)(unsafe.Pointer(bp + 16))) - Xfree(tls, *(*uintptr)(unsafe.Pointer(bp))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 32)), uintptr(0)) + Xfree(tls, **(**uintptr)(__ccgo_up(bp + 16))) + Xfree(tls, **(**uintptr)(__ccgo_up(bp))) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 32)), uintptr(0)) if rv != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = rv + **(**int32)(__ccgo_up(X__errno_location(tls))) = rv } return rv } @@ -125414,8 +125414,8 @@ func Xgetgrent(tls *TLS) (r uintptr) { var _ /* nmem at bp+16 */ Tsize_t var _ /* res at bp+0 */ uintptr var _ /* size at bp+8 */ Tsize_t - *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint64(0) - *(*Tsize_t)(unsafe.Pointer(bp + 16)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp + 8)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp + 16)) = uint64(0) if !(_f1 != 0) { _f1 = Xfopen(tls, __ccgo_ts+1225, __ccgo_ts+315) } @@ -125423,7 +125423,7 @@ func Xgetgrent(tls *TLS) (r uintptr) { return uintptr(0) } X__getgrent_a(tls, _f1, uintptr(unsafe.Pointer(&_gr1)), uintptr(unsafe.Pointer(&_line3)), bp+8, uintptr(unsafe.Pointer(&_mem1)), bp+16, bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func Xgetgrgid(tls *TLS, gid Tgid_t) (r uintptr) { @@ -125436,10 +125436,10 @@ func Xgetgrgid(tls *TLS, gid Tgid_t) (r uintptr) { var _ /* nmem at bp+16 */ Tsize_t var _ /* res at bp+0 */ uintptr var _ /* size at bp+8 */ Tsize_t - *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint64(0) - *(*Tsize_t)(unsafe.Pointer(bp + 16)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp + 8)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp + 16)) = uint64(0) X__getgr_a(tls, uintptr(0), gid, uintptr(unsafe.Pointer(&_gr1)), uintptr(unsafe.Pointer(&_line3)), bp+8, uintptr(unsafe.Pointer(&_mem1)), bp+16, bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func Xgetgrnam(tls *TLS, name uintptr) (r uintptr) { @@ -125452,10 +125452,10 @@ func Xgetgrnam(tls *TLS, name uintptr) (r uintptr) { var _ /* nmem at bp+16 */ Tsize_t var _ /* res at bp+0 */ uintptr var _ /* size at bp+8 */ Tsize_t - *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint64(0) - *(*Tsize_t)(unsafe.Pointer(bp + 16)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp + 8)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp + 16)) = uint64(0) X__getgr_a(tls, name, uint32(0), uintptr(unsafe.Pointer(&_gr1)), uintptr(unsafe.Pointer(&_line3)), bp+8, uintptr(unsafe.Pointer(&_mem1)), bp+16, bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func Xendgrent(tls *TLS) { @@ -125470,14 +125470,14 @@ func _atou(tls *TLS, s uintptr) (r uint32) { _ = x x = uint32(0) for { - if !(Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-int32('0')) < uint32(10)) { + if !(Uint32FromInt32(int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-int32('0')) < uint32(10)) { break } - x = uint32(10)*x + Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-Int32FromUint8('0')) + x = uint32(10)*x + Uint32FromInt32(int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-Int32FromUint8('0')) goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s)) = *(*uintptr)(unsafe.Pointer(s)) + 1 + **(**uintptr)(__ccgo_up(s)) = **(**uintptr)(__ccgo_up(s)) + 1 } return x } @@ -125503,107 +125503,107 @@ func X__getgrent_a(tls *TLS, f uintptr, gr uintptr, line uintptr, size uintptr, l = v2 if v2 < 0 { if Xferror(tls, f) != 0 { - v3 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v3 = **(**int32)(__ccgo_up(X__errno_location(tls))) } else { v3 = 0 } rv = v3 - Xfree(tls, *(*uintptr)(unsafe.Pointer(line))) - *(*uintptr)(unsafe.Pointer(line)) = uintptr(0) + Xfree(tls, **(**uintptr)(__ccgo_up(line))) + **(**uintptr)(__ccgo_up(line)) = uintptr(0) gr = uintptr(0) goto end } - *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(line)) + uintptr(l-int64(1)))) = 0 - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(line)) - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(line)) + uintptr(l-int64(1)))) = 0 + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(line)) + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = v4 - v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v4 + v4 = Xstrchr(tls, **(**uintptr)(__ccgo_up(bp)), int32(':')) + **(**uintptr)(__ccgo_up(bp)) = v4 if !(v4 != 0) { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*int8)(unsafe.Pointer(v4)) = 0 - (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = *(*uintptr)(unsafe.Pointer(bp)) - v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v4 + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**int8)(__ccgo_up(v4)) = 0 + (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = **(**uintptr)(__ccgo_up(bp)) + v4 = Xstrchr(tls, **(**uintptr)(__ccgo_up(bp)), int32(':')) + **(**uintptr)(__ccgo_up(bp)) = v4 if !(v4 != 0) { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*int8)(unsafe.Pointer(v4)) = 0 + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**int8)(__ccgo_up(v4)) = 0 (*Tgroup)(unsafe.Pointer(gr)).Fgr_gid = _atou(tls, bp) - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32(':') { + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) != int32(':') { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*int8)(unsafe.Pointer(v4)) = 0 - mems = *(*uintptr)(unsafe.Pointer(bp)) + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**int8)(__ccgo_up(v4)) = 0 + mems = **(**uintptr)(__ccgo_up(bp)) break goto _1 _1: } - *(*Tsize_t)(unsafe.Pointer(nmem)) = BoolUint64(!!(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) != 0)) + **(**Tsize_t)(__ccgo_up(nmem)) = BoolUint64(!!(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))) != 0)) for { - if !(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) != 0) { + if !(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))) != 0) { break } - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32(',') { - *(*Tsize_t)(unsafe.Pointer(nmem)) = *(*Tsize_t)(unsafe.Pointer(nmem)) + 1 + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) == int32(',') { + **(**Tsize_t)(__ccgo_up(nmem)) = **(**Tsize_t)(__ccgo_up(nmem)) + 1 } goto _10 _10: ; - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - } - Xfree(tls, *(*uintptr)(unsafe.Pointer(mem))) - *(*uintptr)(unsafe.Pointer(mem)) = Xcalloc(tls, uint64(8), *(*Tsize_t)(unsafe.Pointer(nmem))+uint64(1)) - if !(*(*uintptr)(unsafe.Pointer(mem)) != 0) { - rv = *(*int32)(unsafe.Pointer(X__errno_location(tls))) - Xfree(tls, *(*uintptr)(unsafe.Pointer(line))) - *(*uintptr)(unsafe.Pointer(line)) = uintptr(0) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + } + Xfree(tls, **(**uintptr)(__ccgo_up(mem))) + **(**uintptr)(__ccgo_up(mem)) = Xcalloc(tls, uint64(8), **(**Tsize_t)(__ccgo_up(nmem))+uint64(1)) + if !(**(**uintptr)(__ccgo_up(mem)) != 0) { + rv = **(**int32)(__ccgo_up(X__errno_location(tls))) + Xfree(tls, **(**uintptr)(__ccgo_up(line))) + **(**uintptr)(__ccgo_up(line)) = uintptr(0) gr = uintptr(0) goto end } - if *(*int8)(unsafe.Pointer(mems)) != 0 { - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)))) = mems - *(*uintptr)(unsafe.Pointer(bp)) = mems + if **(**int8)(__ccgo_up(mems)) != 0 { + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)))) = mems + **(**uintptr)(__ccgo_up(bp)) = mems i = Uint64FromInt32(0) for { - if !(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) != 0) { + if !(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))) != 0) { break } - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32(',') { - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*int8)(unsafe.Pointer(v4)) = 0 + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) == int32(',') { + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**int8)(__ccgo_up(v4)) = 0 i = i + 1 v13 = i - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v13)*8)) = *(*uintptr)(unsafe.Pointer(bp)) + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)) + uintptr(v13)*8)) = **(**uintptr)(__ccgo_up(bp)) } goto _11 _11: ; - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 } i = i + 1 v13 = i - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v13)*8)) = uintptr(0) + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)) + uintptr(v13)*8)) = uintptr(0) } else { - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)))) = uintptr(0) + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)))) = uintptr(0) } - (*Tgroup)(unsafe.Pointer(gr)).Fgr_mem = *(*uintptr)(unsafe.Pointer(mem)) + (*Tgroup)(unsafe.Pointer(gr)).Fgr_mem = **(**uintptr)(__ccgo_up(mem)) goto end end: ; - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 8)), uintptr(0)) - *(*uintptr)(unsafe.Pointer(res)) = gr + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 8)), uintptr(0)) + **(**uintptr)(__ccgo_up(res)) = gr if rv != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = rv + **(**int32)(__ccgo_up(X__errno_location(tls))) = rv } return rv } @@ -125632,44 +125632,44 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, i, n, nbytes, nlim, nscdbuf, ret, rv, v1, v14, v3, v4, v6, v9 ret = -int32(1) n = int64(1) - *(*int32)(unsafe.Pointer(bp + 40)) = 0 + **(**int32)(__ccgo_up(bp + 40)) = 0 nscdbuf = uintptr(0) - *(*uintptr)(unsafe.Pointer(bp + 56)) = uintptr(0) - *(*uintptr)(unsafe.Pointer(bp + 64)) = uintptr(0) - *(*Tsize_t)(unsafe.Pointer(bp + 72)) = uint64(0) - nlim = *(*int32)(unsafe.Pointer(ngroups)) + **(**uintptr)(__ccgo_up(bp + 56)) = uintptr(0) + **(**uintptr)(__ccgo_up(bp + 64)) = uintptr(0) + **(**Tsize_t)(__ccgo_up(bp + 72)) = uint64(0) + nlim = **(**int32)(__ccgo_up(ngroups)) if nlim >= int32(1) { v1 = groups groups += 4 - *(*Tgid_t)(unsafe.Pointer(v1)) = gid + **(**Tgid_t)(__ccgo_up(v1)) = gid } f = X__nscd_query(tls, int32(GETINITGR), user, bp+44, uint64(12), bp+40) if !(f != 0) { goto cleanup } - if (*(*[3]Tint32_t)(unsafe.Pointer(bp + 44)))[int32(INITGRFOUND)] != 0 { - nscdbuf = Xcalloc(tls, Uint64FromInt32((*(*[3]Tint32_t)(unsafe.Pointer(bp + 44)))[int32(INITGRNGRPS)]), uint64(4)) + if (**(**[3]Tint32_t)(__ccgo_up(bp + 44)))[int32(INITGRFOUND)] != 0 { + nscdbuf = Xcalloc(tls, Uint64FromInt32((**(**[3]Tint32_t)(__ccgo_up(bp + 44)))[int32(INITGRNGRPS)]), uint64(4)) if !(nscdbuf != 0) { goto cleanup } - nbytes = uint64(4) * Uint64FromInt32((*(*[3]Tint32_t)(unsafe.Pointer(bp + 44)))[int32(INITGRNGRPS)]) + nbytes = uint64(4) * Uint64FromInt32((**(**[3]Tint32_t)(__ccgo_up(bp + 44)))[int32(INITGRNGRPS)]) if nbytes != 0 && !(Xfread(tls, nscdbuf, nbytes, uint64(1), f) != 0) { if !(Xferror(tls, f) != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EIO) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EIO) } goto cleanup } - if *(*int32)(unsafe.Pointer(bp + 40)) != 0 { + if **(**int32)(__ccgo_up(bp + 40)) != 0 { i = 0 for { - if !(i < int64((*(*[3]Tint32_t)(unsafe.Pointer(bp + 44)))[int32(INITGRNGRPS)])) { + if !(i < int64((**(**[3]Tint32_t)(__ccgo_up(bp + 44)))[int32(INITGRNGRPS)])) { break } - v3 = *(*Tuint32_t)(unsafe.Pointer(nscdbuf + uintptr(i)*4)) + v3 = **(**Tuint32_t)(__ccgo_up(nscdbuf + uintptr(i)*4)) v4 = v3>>int32(24) | v3>>int32(8)&uint32(0xff00) | v3<= Uint64FromUint64(0xffffffffffffffff)/Uint64FromInt32(8) { + if Uint64FromInt32((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWNAMELEN)]|(**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWPASSWDLEN)]|(**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWGECOSLEN)]|(**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWDIRLEN)]|(**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWSHELLLEN)]) >= Uint64FromUint64(0xffffffffffffffff)/Uint64FromInt32(8) { rv = int32(ENOMEM) goto cleanup_f } - len1 = Uint64FromInt32((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWNAMELEN)] + (*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWPASSWDLEN)] + (*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWGECOSLEN)] + (*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWDIRLEN)] + (*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWSHELLLEN)]) - if len1 > *(*Tsize_t)(unsafe.Pointer(size)) || !(*(*uintptr)(unsafe.Pointer(buf)) != 0) { - tmp = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(buf)), len1) + len1 = Uint64FromInt32((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWNAMELEN)] + (**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWPASSWDLEN)] + (**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWGECOSLEN)] + (**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWDIRLEN)] + (**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWSHELLLEN)]) + if len1 > **(**Tsize_t)(__ccgo_up(size)) || !(**(**uintptr)(__ccgo_up(buf)) != 0) { + tmp = Xrealloc(tls, **(**uintptr)(__ccgo_up(buf)), len1) if !(tmp != 0) { - rv = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + rv = **(**int32)(__ccgo_up(X__errno_location(tls))) goto cleanup_f } - *(*uintptr)(unsafe.Pointer(buf)) = tmp - *(*Tsize_t)(unsafe.Pointer(size)) = len1 + **(**uintptr)(__ccgo_up(buf)) = tmp + **(**Tsize_t)(__ccgo_up(size)) = len1 } - if !(Xfread(tls, *(*uintptr)(unsafe.Pointer(buf)), len1, uint64(1), f) != 0) { + if !(Xfread(tls, **(**uintptr)(__ccgo_up(buf)), len1, uint64(1), f) != 0) { if Xferror(tls, f) != 0 { - v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = **(**int32)(__ccgo_up(X__errno_location(tls))) } else { v1 = int32(EIO) } rv = v1 goto cleanup_f } - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = *(*uintptr)(unsafe.Pointer(buf)) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name + uintptr((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWNAMELEN)]) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd + uintptr((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWPASSWDLEN)]) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos + uintptr((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWGECOSLEN)]) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir + uintptr((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWDIRLEN)]) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_uid = Uint32FromInt32((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWUID)]) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gid = Uint32FromInt32((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWGID)]) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = **(**uintptr)(__ccgo_up(buf)) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name + uintptr((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWNAMELEN)]) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd + uintptr((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWPASSWDLEN)]) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos + uintptr((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWGECOSLEN)]) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir + uintptr((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWDIRLEN)]) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_uid = Uint32FromInt32((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWUID)]) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gid = Uint32FromInt32((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWGID)]) /* Don't assume that nscd made sure to null terminate strings. * It's supposed to, but malicious nscd should be ignored * rather than causing a crash. */ - if *(*int8)(unsafe.Pointer((*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd + uintptr(-Int32FromInt32(1)))) != 0 || *(*int8)(unsafe.Pointer((*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos + uintptr(-Int32FromInt32(1)))) != 0 || *(*int8)(unsafe.Pointer((*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir + uintptr(-Int32FromInt32(1)))) != 0 || *(*int8)(unsafe.Pointer((*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell + uintptr((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWSHELLLEN)]-int32(1)))) != 0 { + if **(**int8)(__ccgo_up((*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd + uintptr(-Int32FromInt32(1)))) != 0 || **(**int8)(__ccgo_up((*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos + uintptr(-Int32FromInt32(1)))) != 0 || **(**int8)(__ccgo_up((*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir + uintptr(-Int32FromInt32(1)))) != 0 || **(**int8)(__ccgo_up((*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell + uintptr((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWSHELLLEN)]-int32(1)))) != 0 { rv = int32(EIO) goto cleanup_f } @@ -125905,7 +125905,7 @@ func X__getpw_a(tls *TLS, name uintptr, uid Tuid_t, pw uintptr, buf uintptr, siz rv = int32(EIO) goto cleanup_f } - *(*uintptr)(unsafe.Pointer(res)) = pw + **(**uintptr)(__ccgo_up(res)) = pw goto cleanup_f cleanup_f: ; @@ -125915,9 +125915,9 @@ func X__getpw_a(tls *TLS, name uintptr, uid Tuid_t, pw uintptr, buf uintptr, siz goto done done: ; - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 4)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 4)), uintptr(0)) if rv != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = rv + **(**int32)(__ccgo_up(X__errno_location(tls))) = rv } return rv } @@ -125930,27 +125930,27 @@ func _getpw_r(tls *TLS, name uintptr, uid Tuid_t, pw uintptr, buf uintptr, size var _ /* len at bp+8 */ Tsize_t var _ /* line at bp+0 */ uintptr _ = rv - *(*uintptr)(unsafe.Pointer(bp)) = uintptr(0) - *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint64(0) + **(**uintptr)(__ccgo_up(bp)) = uintptr(0) + **(**Tsize_t)(__ccgo_up(bp + 8)) = uint64(0) rv = 0 _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp+16) rv = X__getpw_a(tls, name, uid, pw, bp, bp+8, res) - if *(*uintptr)(unsafe.Pointer(res)) != 0 && size < *(*Tsize_t)(unsafe.Pointer(bp + 8)) { - *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) + if **(**uintptr)(__ccgo_up(res)) != 0 && size < **(**Tsize_t)(__ccgo_up(bp + 8)) { + **(**uintptr)(__ccgo_up(res)) = uintptr(0) rv = int32(ERANGE) } - if *(*uintptr)(unsafe.Pointer(res)) != 0 { - Xmemcpy(tls, buf, *(*uintptr)(unsafe.Pointer(bp)), *(*Tsize_t)(unsafe.Pointer(bp + 8))) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_name)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf + if **(**uintptr)(__ccgo_up(res)) != 0 { + Xmemcpy(tls, buf, **(**uintptr)(__ccgo_up(bp)), **(**Tsize_t)(__ccgo_up(bp + 8))) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_name)-int64(**(**uintptr)(__ccgo_up(bp)))) + buf + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd)-int64(**(**uintptr)(__ccgo_up(bp)))) + buf + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos)-int64(**(**uintptr)(__ccgo_up(bp)))) + buf + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir)-int64(**(**uintptr)(__ccgo_up(bp)))) + buf + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell)-int64(**(**uintptr)(__ccgo_up(bp)))) + buf } - Xfree(tls, *(*uintptr)(unsafe.Pointer(bp))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 16)), uintptr(0)) + Xfree(tls, **(**uintptr)(__ccgo_up(bp))) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 16)), uintptr(0)) if rv != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = rv + **(**int32)(__ccgo_up(X__errno_location(tls))) = rv } return rv } @@ -126001,7 +126001,7 @@ func Xgetpwent(tls *TLS) (r uintptr) { return uintptr(0) } X__getpwent_a(tls, _f2, uintptr(unsafe.Pointer(&_pw1)), uintptr(unsafe.Pointer(&_line4)), uintptr(unsafe.Pointer(&_size)), bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func Xgetpwuid(tls *TLS, uid Tuid_t) (r uintptr) { @@ -126013,7 +126013,7 @@ func Xgetpwuid(tls *TLS, uid Tuid_t) (r uintptr) { defer tls.Free(16) var _ /* res at bp+0 */ uintptr X__getpw_a(tls, uintptr(0), uid, uintptr(unsafe.Pointer(&_pw1)), uintptr(unsafe.Pointer(&_line4)), uintptr(unsafe.Pointer(&_size)), bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func Xgetpwnam(tls *TLS, name uintptr) (r uintptr) { @@ -126025,7 +126025,7 @@ func Xgetpwnam(tls *TLS, name uintptr) (r uintptr) { defer tls.Free(16) var _ /* res at bp+0 */ uintptr X__getpw_a(tls, name, uint32(0), uintptr(unsafe.Pointer(&_pw1)), uintptr(unsafe.Pointer(&_line4)), uintptr(unsafe.Pointer(&_size)), bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func Xendpwent(tls *TLS) { @@ -126040,14 +126040,14 @@ func _atou1(tls *TLS, s uintptr) (r uint32) { _ = x x = uint32(0) for { - if !(Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-int32('0')) < uint32(10)) { + if !(Uint32FromInt32(int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-int32('0')) < uint32(10)) { break } - x = uint32(10)*x + Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-Int32FromUint8('0')) + x = uint32(10)*x + Uint32FromInt32(int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-Int32FromUint8('0')) goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s)) = *(*uintptr)(unsafe.Pointer(s)) + 1 + **(**uintptr)(__ccgo_up(s)) = **(**uintptr)(__ccgo_up(s)) + 1 } return x } @@ -126072,79 +126072,79 @@ func X__getpwent_a(tls *TLS, f uintptr, pw uintptr, line uintptr, size uintptr, l = v2 if v2 < 0 { if Xferror(tls, f) != 0 { - v3 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v3 = **(**int32)(__ccgo_up(X__errno_location(tls))) } else { v3 = 0 } rv = v3 - Xfree(tls, *(*uintptr)(unsafe.Pointer(line))) - *(*uintptr)(unsafe.Pointer(line)) = uintptr(0) + Xfree(tls, **(**uintptr)(__ccgo_up(line))) + **(**uintptr)(__ccgo_up(line)) = uintptr(0) pw = uintptr(0) break } - *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(line)) + uintptr(l-int64(1)))) = 0 - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(line)) - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(line)) + uintptr(l-int64(1)))) = 0 + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(line)) + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = v4 - v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v4 + v4 = Xstrchr(tls, **(**uintptr)(__ccgo_up(bp)), int32(':')) + **(**uintptr)(__ccgo_up(bp)) = v4 if !(v4 != 0) { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*int8)(unsafe.Pointer(v4)) = 0 - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = *(*uintptr)(unsafe.Pointer(bp)) - v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v4 + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**int8)(__ccgo_up(v4)) = 0 + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = **(**uintptr)(__ccgo_up(bp)) + v4 = Xstrchr(tls, **(**uintptr)(__ccgo_up(bp)), int32(':')) + **(**uintptr)(__ccgo_up(bp)) = v4 if !(v4 != 0) { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*int8)(unsafe.Pointer(v4)) = 0 + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**int8)(__ccgo_up(v4)) = 0 (*Tpasswd)(unsafe.Pointer(pw)).Fpw_uid = _atou1(tls, bp) - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32(':') { + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) != int32(':') { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*int8)(unsafe.Pointer(v4)) = 0 + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**int8)(__ccgo_up(v4)) = 0 (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gid = _atou1(tls, bp) - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32(':') { + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) != int32(':') { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*int8)(unsafe.Pointer(v4)) = 0 - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = *(*uintptr)(unsafe.Pointer(bp)) - v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v4 + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**int8)(__ccgo_up(v4)) = 0 + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = **(**uintptr)(__ccgo_up(bp)) + v4 = Xstrchr(tls, **(**uintptr)(__ccgo_up(bp)), int32(':')) + **(**uintptr)(__ccgo_up(bp)) = v4 if !(v4 != 0) { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*int8)(unsafe.Pointer(v4)) = 0 - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = *(*uintptr)(unsafe.Pointer(bp)) - v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v4 + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**int8)(__ccgo_up(v4)) = 0 + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = **(**uintptr)(__ccgo_up(bp)) + v4 = Xstrchr(tls, **(**uintptr)(__ccgo_up(bp)), int32(':')) + **(**uintptr)(__ccgo_up(bp)) = v4 if !(v4 != 0) { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*int8)(unsafe.Pointer(v4)) = 0 - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = *(*uintptr)(unsafe.Pointer(bp)) + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**int8)(__ccgo_up(v4)) = 0 + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = **(**uintptr)(__ccgo_up(bp)) break goto _1 _1: } - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 8)), uintptr(0)) - *(*uintptr)(unsafe.Pointer(res)) = pw + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 8)), uintptr(0)) + **(**uintptr)(__ccgo_up(res)) = pw if rv != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = rv + **(**int32)(__ccgo_up(X__errno_location(tls))) = rv } return rv } @@ -126208,7 +126208,7 @@ func X__nscd_query(tls *TLS, req Tint32_t, key uintptr, buf uintptr, len1 Tsize_ var _ /* req_buf at bp+32 */ [3]Tint32_t _, _, _, _, _, _, _ = errno_save, f, fd, i, v1, v3, v4 f = uintptr(0) - *(*[3]Tint32_t)(unsafe.Pointer(bp + 32)) = [3]Tint32_t{ + **(**[3]Tint32_t)(__ccgo_up(bp + 32)) = [3]Tint32_t{ 0: int32(NSCDVERSION), 1: req, 2: Int32FromUint64(Xstrnlen(tls, key, uint64(LOGIN_NAME_MAX)) + uint64(1)), @@ -126223,23 +126223,23 @@ func X__nscd_query(tls *TLS, req Tint32_t, key uintptr, buf uintptr, len1 Tsize_ Fiov_len: _strlen(tls, key) + uint64(1), }, } - *(*Tmsghdr)(unsafe.Pointer(bp + 48)) = Tmsghdr{ + **(**Tmsghdr)(__ccgo_up(bp + 48)) = Tmsghdr{ Fmsg_iov: bp, Fmsg_iovlen: int32(2), } - errno_save = *(*int32)(unsafe.Pointer(X__errno_location(tls))) - *(*int32)(unsafe.Pointer(swap)) = 0 + errno_save = **(**int32)(__ccgo_up(X__errno_location(tls))) + **(**int32)(__ccgo_up(swap)) = 0 goto retry retry: ; Xmemset(tls, buf, 0, len1) - *(*Tint32_t)(unsafe.Pointer(buf)) = int32(NSCDVERSION) + **(**Tint32_t)(__ccgo_up(buf)) = int32(NSCDVERSION) fd = Xsocket(tls, int32(PF_LOCAL), Int32FromInt32(SOCK_STREAM)|Int32FromInt32(SOCK_CLOEXEC), 0) if fd < 0 { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EAFNOSUPPORT) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EAFNOSUPPORT) { f = Xfopen(tls, __ccgo_ts+1248, __ccgo_ts+1258) if f != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = errno_save + **(**int32)(__ccgo_up(X__errno_location(tls))) = errno_save } return f } @@ -126251,7 +126251,7 @@ retry: Xclose(tls, fd) return uintptr(0) } - if (*(*[3]Tint32_t)(unsafe.Pointer(bp + 32)))[int32(2)] > int32(LOGIN_NAME_MAX) { + if (**(**[3]Tint32_t)(__ccgo_up(bp + 32)))[int32(2)] > int32(LOGIN_NAME_MAX) { return f } if Xconnect(tls, fd, uintptr(unsafe.Pointer(&_addr)), uint32(24)) < 0 { @@ -126259,8 +126259,8 @@ retry: * result and the caller is responsible for calling * fclose on the (unconnected) socket. The value of * errno must be left unchanged in this case. */ - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EACCES) || *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ECONNREFUSED) || *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENOENT) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = errno_save + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EACCES) || **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ECONNREFUSED) || **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENOENT) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = errno_save return f } goto error @@ -126277,41 +126277,41 @@ retry: if Xferror(tls, f) != 0 { goto error } - if !(*(*int32)(unsafe.Pointer(swap)) != 0) { + if !(**(**int32)(__ccgo_up(swap)) != 0) { Xfclose(tls, f) i = uint64(0) for { if !(i < Uint64FromInt64(12)/Uint64FromInt64(4)) { break } - v3 = Uint32FromInt32((*(*[3]Tint32_t)(unsafe.Pointer(bp + 32)))[i]) + v3 = Uint32FromInt32((**(**[3]Tint32_t)(__ccgo_up(bp + 32)))[i]) v4 = v3>>int32(24) | v3>>int32(8)&uint32(0xff00) | v3<>int32(24) | v3>>int32(8)&uint32(0xff00) | v3<> int32(16)) - *(*uint16)(unsafe.Pointer(xi + 2*2)) = uint16(x >> int32(32)) + x = uint64(uint32(**(**uint16)(__ccgo_up(xi)))|(uint32(**(**uint16)(__ccgo_up(xi + 1*2)))+0)<> int32(16)) + **(**uint16)(__ccgo_up(xi + 2*2)) = uint16(x >> int32(32)) return x & uint64(0xffffffffffff) } @@ -126621,8 +126621,8 @@ func Xrand_r(tls *TLS, seed uintptr) (r int32) { } var v1 uint32 _ = v1 - v1 = *(*uint32)(unsafe.Pointer(seed))*Uint32FromInt32(1103515245) + Uint32FromInt32(12345) - *(*uint32)(unsafe.Pointer(seed)) = v1 + v1 = **(**uint32)(__ccgo_up(seed))*Uint32FromInt32(1103515245) + Uint32FromInt32(12345) + **(**uint32)(__ccgo_up(seed)) = v1 return Int32FromUint32(_temper(tls, v1) / uint32(2)) } @@ -126681,15 +126681,15 @@ func _lcg64(tls *TLS, x Tuint64_t) (r Tuint64_t) { } func _savestate(tls *TLS) (r uintptr) { - *(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(-Int32FromInt32(1))*4)) = Uint32FromInt32(_n<> int32(16)) - _i = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(-Int32FromInt32(1))*4)) >> Int32FromInt32(8) & uint32(0xff)) - _j = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(-Int32FromInt32(1))*4)) & uint32(0xff)) + _n = Int32FromUint32(**(**Tuint32_t)(__ccgo_up(_x1 + uintptr(-Int32FromInt32(1))*4)) >> int32(16)) + _i = Int32FromUint32(**(**Tuint32_t)(__ccgo_up(_x1 + uintptr(-Int32FromInt32(1))*4)) >> Int32FromInt32(8) & uint32(0xff)) + _j = Int32FromUint32(**(**Tuint32_t)(__ccgo_up(_x1 + uintptr(-Int32FromInt32(1))*4)) & uint32(0xff)) } func ___srandom(tls *TLS, seed uint32) { @@ -126698,7 +126698,7 @@ func ___srandom(tls *TLS, seed uint32) { _, _, _ = k, s, v1 s = uint64(seed) if _n == 0 { - *(*Tuint32_t)(unsafe.Pointer(_x1)) = uint32(s) + **(**Tuint32_t)(__ccgo_up(_x1)) = uint32(s) return } if _n == int32(31) || _n == int32(7) { @@ -126714,14 +126714,14 @@ func ___srandom(tls *TLS, seed uint32) { break } s = _lcg64(tls, s) - *(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(k)*4)) = uint32(s >> int32(32)) + **(**Tuint32_t)(__ccgo_up(_x1 + uintptr(k)*4)) = uint32(s >> int32(32)) goto _2 _2: ; k = k + 1 } /* make sure x contains at least one odd number */ - *(*Tuint32_t)(unsafe.Pointer(_x1)) |= uint32(1) + **(**Tuint32_t)(__ccgo_up(_x1)) |= uint32(1) } func Xsrandom(tls *TLS, seed uint32) { @@ -126794,13 +126794,13 @@ func Xrandom(tls *TLS) (r int64) { _, _, _ = k, v1, v2 ___lock(tls, uintptr(unsafe.Pointer(&_lock3))) if _n == 0 { - v1 = _lcg31(tls, *(*Tuint32_t)(unsafe.Pointer(_x1))) - *(*Tuint32_t)(unsafe.Pointer(_x1)) = v1 + v1 = _lcg31(tls, **(**Tuint32_t)(__ccgo_up(_x1))) + **(**Tuint32_t)(__ccgo_up(_x1)) = v1 k = Int64FromUint32(v1) goto end } - *(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(_i)*4)) += *(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(_j)*4)) - k = Int64FromUint32(*(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(_i)*4)) >> int32(1)) + **(**Tuint32_t)(__ccgo_up(_x1 + uintptr(_i)*4)) += **(**Tuint32_t)(__ccgo_up(_x1 + uintptr(_j)*4)) + k = Int64FromUint32(**(**Tuint32_t)(__ccgo_up(_x1 + uintptr(_i)*4)) >> int32(1)) _i = _i + 1 v2 = _i if v2 == _n { @@ -127006,8 +127006,8 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { defer func() { Xrealloc(tls, b, 0) }() path = Xgetenv(tls, __ccgo_ts+1351) seen_eacces = 0 - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOENT) - if !(*(*int8)(unsafe.Pointer(file)) != 0) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOENT) + if !(**(**int8)(__ccgo_up(file)) != 0) { return -int32(1) } if Xstrchr(tls, file, int32('/')) != 0 { @@ -127018,7 +127018,7 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { } k = Xstrnlen(tls, file, Uint64FromInt32(Int32FromInt32(NAME_MAX)+Int32FromInt32(1))) if k > uint64(NAME_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENAMETOOLONG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENAMETOOLONG) return -int32(1) } l = Xstrnlen(tls, path, Uint64FromInt32(Int32FromInt32(PATH_MAX)-Int32FromInt32(1))) + uint64(1) @@ -127030,7 +127030,7 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { if Uint64FromInt64(int64(z)-int64(p)) >= l { v3 = z z = z + 1 - if !(*(*int8)(unsafe.Pointer(v3)) != 0) { + if !(**(**int8)(__ccgo_up(v3)) != 0) { break } goto _1 @@ -127039,7 +127039,7 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { *(*int8)(unsafe.Add(unsafe.Pointer(b), int64(z)-int64(p))) = int8('/') Xmemcpy(tls, b+uintptr(int64(z)-int64(p))+BoolUintptr(z > p), file, k+uint64(1)) Xexecve(tls, b, argv, envp) - switch *(*int32)(unsafe.Pointer(X__errno_location(tls))) { + switch **(**int32)(__ccgo_up(X__errno_location(tls))) { case int32(EACCES): seen_eacces = int32(1) fallthrough @@ -127051,7 +127051,7 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { } v3 = z z = z + 1 - if !(*(*int8)(unsafe.Pointer(v3)) != 0) { + if !(**(**int8)(__ccgo_up(v3)) != 0) { break } goto _1 @@ -127060,7 +127060,7 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { p = z } if seen_eacces != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EACCES) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EACCES) } return -int32(1) } @@ -127097,8 +127097,8 @@ func Xfexecve(tls *TLS, fd int32, argv uintptr, envp uintptr) (r1 int32) { } X__procfdname(tls, bp, Uint32FromInt32(fd)) Xexecve(tls, bp, argv, envp) - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENOENT) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EBADF) + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENOENT) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EBADF) } return -int32(1) } @@ -127335,7 +127335,7 @@ func Xposix_spawnattr_getflags(tls *TLS, attr uintptr, flags uintptr) (r int32) trc("tls=%v attr=%v flags=%v, (%v:)", tls, attr, flags, origin(2)) defer func() { trc("-> %v", r) }() } - *(*int16)(unsafe.Pointer(flags)) = int16((*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__flags) + **(**int16)(__ccgo_up(flags)) = int16((*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__flags) return 0 } @@ -127344,7 +127344,7 @@ func Xposix_spawnattr_getpgroup(tls *TLS, attr uintptr, pgrp uintptr) (r int32) trc("tls=%v attr=%v pgrp=%v, (%v:)", tls, attr, pgrp, origin(2)) defer func() { trc("-> %v", r) }() } - *(*Tpid_t)(unsafe.Pointer(pgrp)) = (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__pgrp + **(**Tpid_t)(__ccgo_up(pgrp)) = (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__pgrp return 0 } @@ -127353,7 +127353,7 @@ func Xposix_spawnattr_getsigdefault(tls *TLS, attr uintptr, def uintptr) (r int3 trc("tls=%v attr=%v def=%v, (%v:)", tls, attr, def, origin(2)) defer func() { trc("-> %v", r) }() } - *(*Tsigset_t)(unsafe.Pointer(def)) = (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__def + **(**Tsigset_t)(__ccgo_up(def)) = (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__def return 0 } @@ -127362,7 +127362,7 @@ func Xposix_spawnattr_getsigmask(tls *TLS, attr uintptr, mask uintptr) (r int32) trc("tls=%v attr=%v mask=%v, (%v:)", tls, attr, mask, origin(2)) defer func() { trc("-> %v", r) }() } - *(*Tsigset_t)(unsafe.Pointer(mask)) = (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__mask + **(**Tsigset_t)(__ccgo_up(mask)) = (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__mask return 0 } @@ -127371,7 +127371,7 @@ func Xposix_spawnattr_init(tls *TLS, attr uintptr) (r int32) { trc("tls=%v attr=%v, (%v:)", tls, attr, origin(2)) defer func() { trc("-> %v", r) }() } - *(*Tposix_spawnattr_t)(unsafe.Pointer(attr)) = Tposix_spawnattr_t{} + **(**Tposix_spawnattr_t)(__ccgo_up(attr)) = Tposix_spawnattr_t{} return 0 } @@ -127436,7 +127436,7 @@ func Xposix_spawnattr_setsigdefault(tls *TLS, attr uintptr, def uintptr) (r int3 trc("tls=%v attr=%v def=%v, (%v:)", tls, attr, def, origin(2)) defer func() { trc("-> %v", r) }() } - (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__def = *(*Tsigset_t)(unsafe.Pointer(def)) + (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__def = **(**Tsigset_t)(__ccgo_up(def)) return 0 } @@ -127445,7 +127445,7 @@ func Xposix_spawnattr_setsigmask(tls *TLS, attr uintptr, mask uintptr) (r int32) trc("tls=%v attr=%v mask=%v, (%v:)", tls, attr, mask, origin(2)) defer func() { trc("-> %v", r) }() } - (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__mask = *(*Tsigset_t)(unsafe.Pointer(mask)) + (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__mask = **(**Tsigset_t)(__ccgo_up(mask)) return 0 } @@ -127503,20 +127503,20 @@ func _str_next(tls *TLS, str uintptr, n Tsize_t, step uintptr) (r int32) { var _ /* wc at bp+0 */ Twchar_t _ = k if !(n != 0) { - *(*Tsize_t)(unsafe.Pointer(step)) = uint64(0) + **(**Tsize_t)(__ccgo_up(step)) = uint64(0) return 0 } - if Uint32FromInt8(*(*int8)(unsafe.Pointer(str))) >= uint32(128) { + if Uint32FromInt8(**(**int8)(__ccgo_up(str))) >= uint32(128) { k = Xmbtowc(tls, bp, str, n) if k < 0 { - *(*Tsize_t)(unsafe.Pointer(step)) = uint64(1) + **(**Tsize_t)(__ccgo_up(step)) = uint64(1) return -int32(1) } - *(*Tsize_t)(unsafe.Pointer(step)) = Uint64FromInt32(k) - return *(*Twchar_t)(unsafe.Pointer(bp)) + **(**Tsize_t)(__ccgo_up(step)) = Uint64FromInt32(k) + return **(**Twchar_t)(__ccgo_up(bp)) } - *(*Tsize_t)(unsafe.Pointer(step)) = uint64(1) - return int32(*(*int8)(unsafe.Pointer(str))) + **(**Tsize_t)(__ccgo_up(step)) = uint64(1) + return int32(**(**int8)(__ccgo_up(str))) } func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r int32) { @@ -127527,43 +127527,43 @@ func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r i var _ /* wc at bp+0 */ Twchar_t _, _, _, _ = esc, k, k1, z esc = 0 - if !(m != 0) || !(*(*int8)(unsafe.Pointer(pat)) != 0) { - *(*Tsize_t)(unsafe.Pointer(step)) = uint64(0) + if !(m != 0) || !(**(**int8)(__ccgo_up(pat)) != 0) { + **(**Tsize_t)(__ccgo_up(step)) = uint64(0) return END } - *(*Tsize_t)(unsafe.Pointer(step)) = uint64(1) - if int32(*(*int8)(unsafe.Pointer(pat))) == int32('\\') && *(*int8)(unsafe.Pointer(pat + 1)) != 0 && !(flags&Int32FromInt32(FNM_NOESCAPE) != 0) { - *(*Tsize_t)(unsafe.Pointer(step)) = uint64(2) + **(**Tsize_t)(__ccgo_up(step)) = uint64(1) + if int32(**(**int8)(__ccgo_up(pat))) == int32('\\') && **(**int8)(__ccgo_up(pat + 1)) != 0 && !(flags&Int32FromInt32(FNM_NOESCAPE) != 0) { + **(**Tsize_t)(__ccgo_up(step)) = uint64(2) pat = pat + 1 esc = int32(1) goto escaped } - if int32(*(*int8)(unsafe.Pointer(pat))) == int32('[') { + if int32(**(**int8)(__ccgo_up(pat))) == int32('[') { k = uint64(1) if k < m { - if int32(*(*int8)(unsafe.Pointer(pat + uintptr(k)))) == int32('^') || int32(*(*int8)(unsafe.Pointer(pat + uintptr(k)))) == int32('!') { + if int32(**(**int8)(__ccgo_up(pat + uintptr(k)))) == int32('^') || int32(**(**int8)(__ccgo_up(pat + uintptr(k)))) == int32('!') { k = k + 1 } } if k < m { - if int32(*(*int8)(unsafe.Pointer(pat + uintptr(k)))) == int32(']') { + if int32(**(**int8)(__ccgo_up(pat + uintptr(k)))) == int32(']') { k = k + 1 } } for { - if !(k < m && *(*int8)(unsafe.Pointer(pat + uintptr(k))) != 0 && int32(*(*int8)(unsafe.Pointer(pat + uintptr(k)))) != int32(']')) { + if !(k < m && **(**int8)(__ccgo_up(pat + uintptr(k))) != 0 && int32(**(**int8)(__ccgo_up(pat + uintptr(k)))) != int32(']')) { break } - if k+uint64(1) < m && *(*int8)(unsafe.Pointer(pat + uintptr(k+uint64(1)))) != 0 && int32(*(*int8)(unsafe.Pointer(pat + uintptr(k)))) == int32('[') && (int32(*(*int8)(unsafe.Pointer(pat + uintptr(k+uint64(1))))) == int32(':') || int32(*(*int8)(unsafe.Pointer(pat + uintptr(k+uint64(1))))) == int32('.') || int32(*(*int8)(unsafe.Pointer(pat + uintptr(k+uint64(1))))) == int32('=')) { - z = int32(*(*int8)(unsafe.Pointer(pat + uintptr(k+uint64(1))))) + if k+uint64(1) < m && **(**int8)(__ccgo_up(pat + uintptr(k+uint64(1)))) != 0 && int32(**(**int8)(__ccgo_up(pat + uintptr(k)))) == int32('[') && (int32(**(**int8)(__ccgo_up(pat + uintptr(k+uint64(1))))) == int32(':') || int32(**(**int8)(__ccgo_up(pat + uintptr(k+uint64(1))))) == int32('.') || int32(**(**int8)(__ccgo_up(pat + uintptr(k+uint64(1))))) == int32('=')) { + z = int32(**(**int8)(__ccgo_up(pat + uintptr(k+uint64(1))))) k = k + uint64(2) - if k < m && *(*int8)(unsafe.Pointer(pat + uintptr(k))) != 0 { + if k < m && **(**int8)(__ccgo_up(pat + uintptr(k))) != 0 { k = k + 1 } - for k < m && *(*int8)(unsafe.Pointer(pat + uintptr(k))) != 0 && (int32(*(*int8)(unsafe.Pointer(pat + uintptr(k-uint64(1))))) != z || int32(*(*int8)(unsafe.Pointer(pat + uintptr(k)))) != int32(']')) { + for k < m && **(**int8)(__ccgo_up(pat + uintptr(k))) != 0 && (int32(**(**int8)(__ccgo_up(pat + uintptr(k-uint64(1))))) != z || int32(**(**int8)(__ccgo_up(pat + uintptr(k)))) != int32(']')) { k = k + 1 } - if k == m || !(*(*int8)(unsafe.Pointer(pat + uintptr(k))) != 0) { + if k == m || !(**(**int8)(__ccgo_up(pat + uintptr(k))) != 0) { break } } @@ -127572,32 +127572,32 @@ func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r i ; k = k + 1 } - if k == m || !(*(*int8)(unsafe.Pointer(pat + uintptr(k))) != 0) { - *(*Tsize_t)(unsafe.Pointer(step)) = uint64(1) + if k == m || !(**(**int8)(__ccgo_up(pat + uintptr(k))) != 0) { + **(**Tsize_t)(__ccgo_up(step)) = uint64(1) return int32('[') } - *(*Tsize_t)(unsafe.Pointer(step)) = k + uint64(1) + **(**Tsize_t)(__ccgo_up(step)) = k + uint64(1) return -int32(3) } - if int32(*(*int8)(unsafe.Pointer(pat))) == int32('*') { + if int32(**(**int8)(__ccgo_up(pat))) == int32('*') { return -int32(5) } - if int32(*(*int8)(unsafe.Pointer(pat))) == int32('?') { + if int32(**(**int8)(__ccgo_up(pat))) == int32('?') { return -int32(4) } goto escaped escaped: ; - if Uint32FromInt8(*(*int8)(unsafe.Pointer(pat))) >= uint32(128) { + if Uint32FromInt8(**(**int8)(__ccgo_up(pat))) >= uint32(128) { k1 = Xmbtowc(tls, bp, pat, m) if k1 < 0 { - *(*Tsize_t)(unsafe.Pointer(step)) = uint64(0) + **(**Tsize_t)(__ccgo_up(step)) = uint64(0) return -int32(2) } - *(*Tsize_t)(unsafe.Pointer(step)) = Uint64FromInt32(k1 + esc) - return *(*Twchar_t)(unsafe.Pointer(bp)) + **(**Tsize_t)(__ccgo_up(step)) = Uint64FromInt32(k1 + esc) + return **(**Twchar_t)(__ccgo_up(bp)) } - return int32(*(*int8)(unsafe.Pointer(pat))) + return int32(**(**int8)(__ccgo_up(pat))) } func _casefold(tls *TLS, k int32) (r int32) { @@ -127624,59 +127624,59 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { _, _, _, _, _ = inv, l, l1, p0, z inv = 0 p = p + 1 - if int32(*(*int8)(unsafe.Pointer(p))) == int32('^') || int32(*(*int8)(unsafe.Pointer(p))) == int32('!') { + if int32(**(**int8)(__ccgo_up(p))) == int32('^') || int32(**(**int8)(__ccgo_up(p))) == int32('!') { inv = int32(1) p = p + 1 } - if int32(*(*int8)(unsafe.Pointer(p))) == int32(']') { + if int32(**(**int8)(__ccgo_up(p))) == int32(']') { if k == int32(']') { return BoolInt32(!(inv != 0)) } p = p + 1 } else { - if int32(*(*int8)(unsafe.Pointer(p))) == int32('-') { + if int32(**(**int8)(__ccgo_up(p))) == int32('-') { if k == int32('-') { return BoolInt32(!(inv != 0)) } p = p + 1 } } - *(*Twchar_t)(unsafe.Pointer(bp)) = int32(*(*int8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) + **(**Twchar_t)(__ccgo_up(bp)) = int32(**(**int8)(__ccgo_up(p + uintptr(-Int32FromInt32(1))))) for { - if !(int32(*(*int8)(unsafe.Pointer(p))) != int32(']')) { + if !(int32(**(**int8)(__ccgo_up(p))) != int32(']')) { break } - if int32(*(*int8)(unsafe.Pointer(p))) == int32('-') && int32(*(*int8)(unsafe.Pointer(p + 1))) != int32(']') { + if int32(**(**int8)(__ccgo_up(p))) == int32('-') && int32(**(**int8)(__ccgo_up(p + 1))) != int32(']') { l = Xmbtowc(tls, bp+4, p+uintptr(1), uint64(4)) if l < 0 { return 0 } - if *(*Twchar_t)(unsafe.Pointer(bp)) <= *(*Twchar_t)(unsafe.Pointer(bp + 4)) { - if Uint32FromInt32(k)-Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))) <= Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp + 4))-*(*Twchar_t)(unsafe.Pointer(bp))) || Uint32FromInt32(kfold)-Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))) <= Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp + 4))-*(*Twchar_t)(unsafe.Pointer(bp))) { + if **(**Twchar_t)(__ccgo_up(bp)) <= **(**Twchar_t)(__ccgo_up(bp + 4)) { + if Uint32FromInt32(k)-Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))) <= Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp + 4))-**(**Twchar_t)(__ccgo_up(bp))) || Uint32FromInt32(kfold)-Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))) <= Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp + 4))-**(**Twchar_t)(__ccgo_up(bp))) { return BoolInt32(!(inv != 0)) } } p = p + uintptr(l-int32(1)) goto _1 } - if int32(*(*int8)(unsafe.Pointer(p))) == int32('[') && (int32(*(*int8)(unsafe.Pointer(p + 1))) == int32(':') || int32(*(*int8)(unsafe.Pointer(p + 1))) == int32('.') || int32(*(*int8)(unsafe.Pointer(p + 1))) == int32('=')) { + if int32(**(**int8)(__ccgo_up(p))) == int32('[') && (int32(**(**int8)(__ccgo_up(p + 1))) == int32(':') || int32(**(**int8)(__ccgo_up(p + 1))) == int32('.') || int32(**(**int8)(__ccgo_up(p + 1))) == int32('=')) { p0 = p + uintptr(2) - z = int32(*(*int8)(unsafe.Pointer(p + 1))) + z = int32(**(**int8)(__ccgo_up(p + 1))) p = p + uintptr(3) - for int32(*(*int8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) != z || int32(*(*int8)(unsafe.Pointer(p))) != int32(']') { + for int32(**(**int8)(__ccgo_up(p + uintptr(-Int32FromInt32(1))))) != z || int32(**(**int8)(__ccgo_up(p))) != int32(']') { p = p + 1 } if z == int32(':') && int64(p-uintptr(1))-int64(p0) < int64(16) { Xmemcpy(tls, bp+8, p0, Uint64FromInt64(int64(p-uintptr(1))-int64(p0))) - (*(*[16]int8)(unsafe.Pointer(bp + 8)))[int64(p-uintptr(1))-int64(p0)] = 0 + (**(**[16]int8)(__ccgo_up(bp + 8)))[int64(p-uintptr(1))-int64(p0)] = 0 if Xiswctype(tls, Uint32FromInt32(k), Xwctype(tls, bp+8)) != 0 || Xiswctype(tls, Uint32FromInt32(kfold), Xwctype(tls, bp+8)) != 0 { return BoolInt32(!(inv != 0)) } } goto _1 } - if Uint32FromInt8(*(*int8)(unsafe.Pointer(p))) < uint32(128) { - *(*Twchar_t)(unsafe.Pointer(bp)) = Int32FromUint8(Uint8FromInt8(*(*int8)(unsafe.Pointer(p)))) + if Uint32FromInt8(**(**int8)(__ccgo_up(p))) < uint32(128) { + **(**Twchar_t)(__ccgo_up(bp)) = Int32FromUint8(Uint8FromInt8(**(**int8)(__ccgo_up(p)))) } else { l1 = Xmbtowc(tls, bp, p, uint64(4)) if l1 < 0 { @@ -127684,7 +127684,7 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { } p = p + uintptr(l1-int32(1)) } - if *(*Twchar_t)(unsafe.Pointer(bp)) == k || *(*Twchar_t)(unsafe.Pointer(bp)) == kfold { + if **(**Twchar_t)(__ccgo_up(bp)) == k || **(**Twchar_t)(__ccgo_up(bp)) == kfold { return BoolInt32(!(inv != 0)) } goto _1 @@ -127707,7 +127707,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, endpat, endstr, k, kfold, p, ptail, s, stail, tailcnt, v2, v6, v9 tailcnt = uint64(0) if flags&int32(FNM_PERIOD) != 0 { - if int32(*(*int8)(unsafe.Pointer(str))) == int32('.') && int32(*(*int8)(unsafe.Pointer(pat))) != int32('.') { + if int32(**(**int8)(__ccgo_up(str))) == int32('.') && int32(**(**int8)(__ccgo_up(pat))) != int32('.') { return int32(FNM_NOMATCH) } } @@ -127730,8 +127730,8 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, } return v2 } - str = str + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) - n = n - *(*Tsize_t)(unsafe.Pointer(bp + 8)) + str = str + uintptr(**(**Tsize_t)(__ccgo_up(bp + 8))) + n = n - **(**Tsize_t)(__ccgo_up(bp + 8)) if flags&int32(FNM_CASEFOLD) != 0 { v2 = _casefold(tls, k) } else { @@ -127747,8 +127747,8 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, return int32(FNM_NOMATCH) } } - pat = pat + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) - m = m - *(*Tsize_t)(unsafe.Pointer(bp)) + pat = pat + uintptr(**(**Tsize_t)(__ccgo_up(bp))) + m = m - **(**Tsize_t)(__ccgo_up(bp)) goto _1 } break @@ -127779,7 +127779,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, goto _5 _5: ; - p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(**(**Tsize_t)(__ccgo_up(bp))) } /* Past this point we need not check for UNMATCHABLE in pat, * because all of pat has already been parsed once. */ @@ -127797,8 +127797,8 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, if !(s > str && tailcnt != 0) { break } - if v9 = Uint32FromInt8(*(*int8)(unsafe.Pointer(s + uintptr(-Int32FromInt32(1))))) < uint32(128); !v9 { - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if v9 = Uint32FromInt8(**(**int8)(__ccgo_up(s + uintptr(-Int32FromInt32(1))))) < uint32(128); !v9 { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v2 = int32(4) } else { v2 = int32(1) @@ -127810,7 +127810,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, for { s = s - 1 v6 = s - if !(uint32(Uint8FromInt8(*(*int8)(unsafe.Pointer(v6))))-uint32(0x80) < uint32(0x40) && s > str) { + if !(uint32(Uint8FromInt8(**(**int8)(__ccgo_up(v6))))-uint32(0x80) < uint32(0x40) && s > str) { break } } @@ -127828,7 +127828,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, p = ptail for { c = _pat_next(tls, p, Uint64FromInt64(int64(endpat)-int64(p)), bp, flags) - p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(**(**Tsize_t)(__ccgo_up(bp))) v2 = _str_next(tls, s, Uint64FromInt64(int64(endstr)-int64(s)), bp+8) k = v2 if v2 <= 0 { @@ -127837,7 +127837,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, } break } - s = s + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) + s = s + uintptr(**(**Tsize_t)(__ccgo_up(bp + 8))) if flags&int32(FNM_CASEFOLD) != 0 { v2 = _casefold(tls, k) } else { @@ -127845,7 +127845,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, } kfold = v2 if c == -int32(3) { - if !(_match_bracket(tls, p-uintptr(*(*Tsize_t)(unsafe.Pointer(bp))), k, kfold) != 0) { + if !(_match_bracket(tls, p-uintptr(**(**Tsize_t)(__ccgo_up(bp))), k, kfold) != 0) { return int32(FNM_NOMATCH) } } else { @@ -127865,7 +127865,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, s = str for { c = _pat_next(tls, p, Uint64FromInt64(int64(endpat)-int64(p)), bp, flags) - p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(**(**Tsize_t)(__ccgo_up(bp))) /* Encountering * completes/commits a component */ if c == -int32(5) { pat = p @@ -127883,7 +127883,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, } kfold = v2 if c == -int32(3) { - if !(_match_bracket(tls, p-uintptr(*(*Tsize_t)(unsafe.Pointer(bp))), k, kfold) != 0) { + if !(_match_bracket(tls, p-uintptr(**(**Tsize_t)(__ccgo_up(bp))), k, kfold) != 0) { break } } else { @@ -127891,7 +127891,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, break } } - s = s + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) + s = s + uintptr(**(**Tsize_t)(__ccgo_up(bp + 8))) goto _14 _14: } @@ -127902,7 +127902,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, * char, or past all invalid bytes otherwise. */ k = _str_next(tls, str, Uint64FromInt64(int64(endstr)-int64(str)), bp+8) if k > 0 { - str = str + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) + str = str + uintptr(**(**Tsize_t)(__ccgo_up(bp + 8))) } else { str = str + 1 for { @@ -127934,7 +127934,7 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { for { s = str for { - if !(*(*int8)(unsafe.Pointer(s)) != 0 && int32(*(*int8)(unsafe.Pointer(s))) != int32('/')) { + if !(**(**int8)(__ccgo_up(s)) != 0 && int32(**(**int8)(__ccgo_up(s))) != int32('/')) { break } goto _2 @@ -127952,9 +127952,9 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { goto _3 _3: ; - p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(**(**Tsize_t)(__ccgo_up(bp))) } - if c != int32(*(*int8)(unsafe.Pointer(s))) && (!(*(*int8)(unsafe.Pointer(s)) != 0) || !(flags&Int32FromInt32(FNM_LEADING_DIR) != 0)) { + if c != int32(**(**int8)(__ccgo_up(s))) && (!(**(**int8)(__ccgo_up(s)) != 0) || !(flags&Int32FromInt32(FNM_LEADING_DIR) != 0)) { return int32(FNM_NOMATCH) } if _fnmatch_internal(tls, pat, Uint64FromInt64(int64(p)-int64(pat)), str, Uint64FromInt64(int64(s)-int64(str)), flags) != 0 { @@ -127964,7 +127964,7 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { return 0 } str = s + uintptr(1) - pat = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + pat = p + uintptr(**(**Tsize_t)(__ccgo_up(bp))) goto _1 _1: } @@ -127972,10 +127972,10 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { if flags&int32(FNM_LEADING_DIR) != 0 { s = str for { - if !(*(*int8)(unsafe.Pointer(s)) != 0) { + if !(**(**int8)(__ccgo_up(s)) != 0) { break } - if int32(*(*int8)(unsafe.Pointer(s))) != int32('/') { + if int32(**(**int8)(__ccgo_up(s))) != int32('/') { goto _5 } if !(_fnmatch_internal(tls, pat, Uint64FromInt32(-Int32FromInt32(1)), str, Uint64FromInt64(int64(s)-int64(str)), flags) != 0) { @@ -128025,14 +128025,14 @@ func _append(tls *TLS, tail uintptr, name uintptr, len1 Tsize_t, mark int32) (r if !(new1 != 0) { return -int32(1) } - (*Tmatch)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tail)))).Fnext = new1 + (*Tmatch)(unsafe.Pointer(**(**uintptr)(__ccgo_up(tail)))).Fnext = new1 (*Tmatch)(unsafe.Pointer(new1)).Fnext = UintptrFromInt32(0) Xmemcpy(tls, new1+8, name, len1+uint64(1)) - if mark != 0 && len1 != 0 && int32(*(*int8)(unsafe.Pointer(name + uintptr(len1-uint64(1))))) != int32('/') { + if mark != 0 && len1 != 0 && int32(**(**int8)(__ccgo_up(name + uintptr(len1-uint64(1))))) != int32('/') { *(*int8)(unsafe.Pointer(new1 + 8 + uintptr(len1))) = int8('/') *(*int8)(unsafe.Pointer(new1 + 8 + uintptr(len1+uint64(1)))) = 0 } - *(*uintptr)(unsafe.Pointer(tail)) = new1 + **(**uintptr)(__ccgo_up(tail)) = new1 return 0 } @@ -128052,15 +128052,15 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag } /* Special-case the remaining pattern being all slashes, in * which case we can use caller-passed type if it's a dir. */ - if *(*int8)(unsafe.Pointer(pat)) != 0 && type1 != int32(DT_DIR) { + if **(**int8)(__ccgo_up(pat)) != 0 && type1 != int32(DT_DIR) { type1 = 0 } - for pos+uint64(1) < uint64(PATH_MAX) && int32(*(*int8)(unsafe.Pointer(pat))) == int32('/') { + for pos+uint64(1) < uint64(PATH_MAX) && int32(**(**int8)(__ccgo_up(pat))) == int32('/') { v1 = pos pos = pos + 1 v2 = pat pat = pat + 1 - *(*int8)(unsafe.Pointer(buf + uintptr(v1))) = *(*int8)(unsafe.Pointer(v2)) + **(**int8)(__ccgo_up(buf + uintptr(v1))) = **(**int8)(__ccgo_up(v2)) } /* Consume maximal [escaped-]literal prefix of pattern, copying * and un-escaping it to the running buffer as we go. */ @@ -128069,10 +128069,10 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag in_bracket = 0 overflow = 0 for { - if !(int32(*(*int8)(unsafe.Pointer(pat + uintptr(i)))) != int32('*') && int32(*(*int8)(unsafe.Pointer(pat + uintptr(i)))) != int32('?') && (!(in_bracket != 0) || int32(*(*int8)(unsafe.Pointer(pat + uintptr(i)))) != int32(']'))) { + if !(int32(**(**int8)(__ccgo_up(pat + uintptr(i)))) != int32('*') && int32(**(**int8)(__ccgo_up(pat + uintptr(i)))) != int32('?') && (!(in_bracket != 0) || int32(**(**int8)(__ccgo_up(pat + uintptr(i)))) != int32(']'))) { break } - if !(*(*int8)(unsafe.Pointer(pat + uintptr(i))) != 0) { + if !(**(**int8)(__ccgo_up(pat + uintptr(i))) != 0) { if overflow != 0 { return 0 } @@ -128083,25 +128083,25 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag i = v4 break } else { - if int32(*(*int8)(unsafe.Pointer(pat + uintptr(i)))) == int32('[') { + if int32(**(**int8)(__ccgo_up(pat + uintptr(i)))) == int32('[') { in_bracket = int32(1) } else { - if int32(*(*int8)(unsafe.Pointer(pat + uintptr(i)))) == int32('\\') && !(flags&Int32FromInt32(GLOB_NOESCAPE) != 0) { + if int32(**(**int8)(__ccgo_up(pat + uintptr(i)))) == int32('\\') && !(flags&Int32FromInt32(GLOB_NOESCAPE) != 0) { /* Backslashes inside a bracket are (at least by * our interpretation) non-special, so if next * char is ']' we have a complete expression. */ - if in_bracket != 0 && int32(*(*int8)(unsafe.Pointer(pat + uintptr(i+int64(1))))) == int32(']') { + if in_bracket != 0 && int32(**(**int8)(__ccgo_up(pat + uintptr(i+int64(1))))) == int32(']') { break } /* Unpaired final backslash never matches. */ - if !(*(*int8)(unsafe.Pointer(pat + uintptr(i+int64(1)))) != 0) { + if !(**(**int8)(__ccgo_up(pat + uintptr(i+int64(1)))) != 0) { return 0 } i = i + 1 } } } - if int32(*(*int8)(unsafe.Pointer(pat + uintptr(i)))) == int32('/') { + if int32(**(**int8)(__ccgo_up(pat + uintptr(i)))) == int32('/') { if overflow != 0 { return 0 } @@ -128119,7 +128119,7 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag if pos+Uint64FromInt64(j+Int64FromInt32(1)) < uint64(PATH_MAX) { v4 = j j = j + 1 - *(*int8)(unsafe.Pointer(buf + uintptr(pos+Uint64FromInt64(v4)))) = *(*int8)(unsafe.Pointer(pat + uintptr(i))) + **(**int8)(__ccgo_up(buf + uintptr(pos+Uint64FromInt64(v4)))) = **(**int8)(__ccgo_up(pat + uintptr(i))) } else { if in_bracket != 0 { overflow = int32(1) @@ -128135,17 +128135,17 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag ; i = i + 1 } - *(*int8)(unsafe.Pointer(buf + uintptr(pos))) = 0 - if !(*(*int8)(unsafe.Pointer(pat)) != 0) { + **(**int8)(__ccgo_up(buf + uintptr(pos))) = 0 + if !(**(**int8)(__ccgo_up(pat)) != 0) { if flags&int32(GLOB_MARK) != 0 && (!(type1 != 0) || type1 == int32(DT_LNK)) && !(Xstat(tls, buf, bp) != 0) { - if (*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFDIR) { + if (**(**Tstat)(__ccgo_up(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFDIR) { type1 = int32(DT_DIR) } else { type1 = int32(DT_REG) } } if !(type1 != 0) && Xlstat(tls, buf, bp) != 0 { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(ENOENT) && ((*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(ENOENT) && ((*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, **(**int32)(__ccgo_up(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0) { return int32(GLOB_ABORTED) } return 0 @@ -128162,7 +128162,7 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag if p2 != 0 && !(flags&Int32FromInt32(GLOB_NOESCAPE) != 0) { p = p2 for { - if !(p > pat && int32(*(*int8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) == int32('\\')) { + if !(p > pat && int32(**(**int8)(__ccgo_up(p + uintptr(-Int32FromInt32(1))))) == int32('\\')) { break } goto _6 @@ -128182,14 +128182,14 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag } dir = Xopendir(tls, v2) if !(dir != 0) { - if (*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0 { + if (*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, **(**int32)(__ccgo_up(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0 { return int32(GLOB_ABORTED) } return 0 } - old_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + old_errno = **(**int32)(__ccgo_up(X__errno_location(tls))) for { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = 0 + **(**int32)(__ccgo_up(X__errno_location(tls))) = 0 v2 = Xreaddir(tls, dir) de = v2 if !(v2 != 0) { @@ -128204,7 +128204,7 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag continue } if p2 != 0 { - *(*int8)(unsafe.Pointer(p2)) = 0 + **(**int8)(__ccgo_up(p2)) = 0 } if flags&int32(GLOB_NOESCAPE) != 0 { v9 = int32(FNM_NOESCAPE) @@ -128222,12 +128222,12 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag } /* With GLOB_PERIOD, don't allow matching . or .. unless * fnmatch would match them with FNM_PERIOD rules in effect. */ - if p2 != 0 && flags&int32(GLOB_PERIOD) != 0 && int32(*(*int8)(unsafe.Pointer(de + 19))) == int32('.') && (!(*(*int8)(unsafe.Pointer(de + 19 + 1)) != 0) || int32(*(*int8)(unsafe.Pointer(de + 19 + 1))) == int32('.') && !(*(*int8)(unsafe.Pointer(de + 19 + 2)) != 0)) && Xfnmatch(tls, pat, de+19, fnm_flags|int32(FNM_PERIOD)) != 0 { + if p2 != 0 && flags&int32(GLOB_PERIOD) != 0 && int32(**(**int8)(__ccgo_up(de + 19))) == int32('.') && (!(**(**int8)(__ccgo_up(de + 19 + 1)) != 0) || int32(**(**int8)(__ccgo_up(de + 19 + 1))) == int32('.') && !(**(**int8)(__ccgo_up(de + 19 + 2)) != 0)) && Xfnmatch(tls, pat, de+19, fnm_flags|int32(FNM_PERIOD)) != 0 { continue } Xmemcpy(tls, buf+uintptr(pos), de+19, l+uint64(1)) if p2 != 0 { - *(*int8)(unsafe.Pointer(p2)) = saved_sep + **(**int8)(__ccgo_up(p2)) = saved_sep } if p2 != 0 { v2 = p2 @@ -128240,15 +128240,15 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag return r } } - readerr = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + readerr = **(**int32)(__ccgo_up(X__errno_location(tls))) if p2 != 0 { - *(*int8)(unsafe.Pointer(p2)) = saved_sep + **(**int8)(__ccgo_up(p2)) = saved_sep } Xclosedir(tls, dir) - if readerr != 0 && ((*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0) { + if readerr != 0 && ((*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, **(**int32)(__ccgo_up(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0) { return int32(GLOB_ABORTED) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = old_errno + **(**int32)(__ccgo_up(X__errno_location(tls))) = old_errno return 0 } @@ -128274,7 +128274,7 @@ func _freelist(tls *TLS, head uintptr) { } func _sort(tls *TLS, a uintptr, b uintptr) (r int32) { - return Xstrcmp(tls, *(*uintptr)(unsafe.Pointer(a)), *(*uintptr)(unsafe.Pointer(b))) + return Xstrcmp(tls, **(**uintptr)(__ccgo_up(a)), **(**uintptr)(__ccgo_up(b))) } func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { @@ -128287,25 +128287,25 @@ func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { var _ /* pw at bp+0 */ Tpasswd var _ /* res at bp+48 */ uintptr _, _, _, _, _, _, _, _, _ = delim, home, i, name_end, p, v1, v10, v2, v4 - p = *(*uintptr)(unsafe.Pointer(pat)) + uintptr(1) + p = **(**uintptr)(__ccgo_up(pat)) + uintptr(1) i = uint64(0) name_end = X__strchrnul(tls, p, int32('/')) - v1 = *(*int8)(unsafe.Pointer(name_end)) + v1 = **(**int8)(__ccgo_up(name_end)) delim = v1 if v1 != 0 { v2 = name_end name_end = name_end + 1 - *(*int8)(unsafe.Pointer(v2)) = 0 + **(**int8)(__ccgo_up(v2)) = 0 } - *(*uintptr)(unsafe.Pointer(pat)) = name_end - if *(*int8)(unsafe.Pointer(p)) != 0 { + **(**uintptr)(__ccgo_up(pat)) = name_end + if **(**int8)(__ccgo_up(p)) != 0 { v2 = UintptrFromInt32(0) } else { v2 = Xgetenv(tls, __ccgo_ts+1385) } home = v2 if !(home != 0) { - if *(*int8)(unsafe.Pointer(p)) != 0 { + if **(**int8)(__ccgo_up(p)) != 0 { v4 = Xgetpwnam_r(tls, p, bp, buf, uint64(PATH_MAX), bp+48) } else { v4 = Xgetpwuid_r(tls, Xgetuid(tls), bp, buf, uint64(PATH_MAX), bp+48) @@ -128324,7 +128324,7 @@ func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { return int32(GLOB_NOSPACE) _7: ; - if !!(*(*uintptr)(unsafe.Pointer(bp + 48)) != 0) { + if !!(**(**uintptr)(__ccgo_up(bp + 48)) != 0) { goto _9 } _6: @@ -128334,26 +128334,26 @@ func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { ; _8: ; - home = (*(*Tpasswd)(unsafe.Pointer(bp))).Fpw_dir + home = (**(**Tpasswd)(__ccgo_up(bp))).Fpw_dir } - for i < Uint64FromInt32(Int32FromInt32(PATH_MAX)-Int32FromInt32(2)) && *(*int8)(unsafe.Pointer(home)) != 0 { + for i < Uint64FromInt32(Int32FromInt32(PATH_MAX)-Int32FromInt32(2)) && **(**int8)(__ccgo_up(home)) != 0 { v10 = i i = i + 1 v2 = home home = home + 1 - *(*int8)(unsafe.Pointer(buf + uintptr(v10))) = *(*int8)(unsafe.Pointer(v2)) + **(**int8)(__ccgo_up(buf + uintptr(v10))) = **(**int8)(__ccgo_up(v2)) } - if *(*int8)(unsafe.Pointer(home)) != 0 { + if **(**int8)(__ccgo_up(home)) != 0 { return int32(GLOB_NOMATCH) } v1 = delim - *(*int8)(unsafe.Pointer(buf + uintptr(i))) = v1 + **(**int8)(__ccgo_up(buf + uintptr(i))) = v1 if v1 != 0 { i = i + 1 v10 = i - *(*int8)(unsafe.Pointer(buf + uintptr(v10))) = 0 + **(**int8)(__ccgo_up(buf + uintptr(v10))) = 0 } - *(*Tsize_t)(unsafe.Pointer(pos)) = i + **(**Tsize_t)(__ccgo_up(pos)) = i return 0 } @@ -128376,10 +128376,10 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint var _ /* s at bp+4120 */ uintptr var _ /* tail at bp+8 */ uintptr _, _, _, _, _, _, _ = cnt, error1, i, offs, p, pathv, v1 - *(*Tmatch)(unsafe.Pointer(bp)) = struct { + **(**Tmatch)(__ccgo_up(bp)) = struct { Fnext uintptr }{} - *(*uintptr)(unsafe.Pointer(bp + 8)) = bp + **(**uintptr)(__ccgo_up(bp + 8)) = bp if flags&int32(GLOB_DOOFFS) != 0 { v1 = (*Tglob_t)(unsafe.Pointer(g)).Fgl_offs } else { @@ -128395,19 +128395,19 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathc = uint64(0) (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv = UintptrFromInt32(0) } - if *(*int8)(unsafe.Pointer(pat)) != 0 { + if **(**int8)(__ccgo_up(pat)) != 0 { p = Xstrdup(tls, pat) if !(p != 0) { return int32(GLOB_NOSPACE) } - (*(*[4096]int8)(unsafe.Pointer(bp + 16)))[0] = 0 - *(*Tsize_t)(unsafe.Pointer(bp + 4112)) = uint64(0) - *(*uintptr)(unsafe.Pointer(bp + 4120)) = p - if flags&(Int32FromInt32(GLOB_TILDE)|Int32FromInt32(GLOB_TILDE_CHECK)) != 0 && int32(*(*int8)(unsafe.Pointer(p))) == int32('~') { + (**(**[4096]int8)(__ccgo_up(bp + 16)))[0] = 0 + **(**Tsize_t)(__ccgo_up(bp + 4112)) = uint64(0) + **(**uintptr)(__ccgo_up(bp + 4120)) = p + if flags&(Int32FromInt32(GLOB_TILDE)|Int32FromInt32(GLOB_TILDE_CHECK)) != 0 && int32(**(**int8)(__ccgo_up(p))) == int32('~') { error1 = _expand_tilde(tls, bp+4120, bp+16, bp+4112) } if !(error1 != 0) { - error1 = _do_glob(tls, bp+16, *(*Tsize_t)(unsafe.Pointer(bp + 4112)), 0, *(*uintptr)(unsafe.Pointer(bp + 4120)), flags, __ccgo_fp_errfunc, bp+8) + error1 = _do_glob(tls, bp+16, **(**Tsize_t)(__ccgo_up(bp + 4112)), 0, **(**uintptr)(__ccgo_up(bp + 4120)), flags, __ccgo_fp_errfunc, bp+8) } Xfree(tls, p) } @@ -128416,20 +128416,20 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint return error1 } cnt = uint64(0) - *(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*Tmatch)(unsafe.Pointer(bp))).Fnext + **(**uintptr)(__ccgo_up(bp + 8)) = (**(**Tmatch)(__ccgo_up(bp))).Fnext for { - if !(*(*uintptr)(unsafe.Pointer(bp + 8)) != 0) { + if !(**(**uintptr)(__ccgo_up(bp + 8)) != 0) { break } goto _2 _2: ; - *(*uintptr)(unsafe.Pointer(bp + 8)) = (*Tmatch)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fnext + **(**uintptr)(__ccgo_up(bp + 8)) = (*Tmatch)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp + 8)))).Fnext cnt = cnt + 1 } if !(cnt != 0) { if flags&int32(GLOB_NOCHECK) != 0 { - *(*uintptr)(unsafe.Pointer(bp + 8)) = bp + **(**uintptr)(__ccgo_up(bp + 8)) = bp if _append(tls, bp+8, pat, _strlen(tls, pat), 0) != 0 { return int32(GLOB_NOSPACE) } @@ -128459,7 +128459,7 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint if !(i < offs) { break } - *(*uintptr)(unsafe.Pointer((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(i)*8)) = UintptrFromInt32(0) + **(**uintptr)(__ccgo_up((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(i)*8)) = UintptrFromInt32(0) goto _3 _3: ; @@ -128467,20 +128467,20 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint } } i = uint64(0) - *(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*Tmatch)(unsafe.Pointer(bp))).Fnext + **(**uintptr)(__ccgo_up(bp + 8)) = (**(**Tmatch)(__ccgo_up(bp))).Fnext for { if !(i < cnt) { break } - *(*uintptr)(unsafe.Pointer((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(offs+i)*8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + **(**uintptr)(__ccgo_up((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(offs+i)*8)) = **(**uintptr)(__ccgo_up(bp + 8)) + 8 goto _4 _4: ; - *(*uintptr)(unsafe.Pointer(bp + 8)) = (*Tmatch)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fnext + **(**uintptr)(__ccgo_up(bp + 8)) = (*Tmatch)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp + 8)))).Fnext i = i + 1 } - *(*uintptr)(unsafe.Pointer((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(offs+i)*8)) = UintptrFromInt32(0) - *(*Tsize_t)(unsafe.Pointer(g)) += cnt + **(**uintptr)(__ccgo_up((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(offs+i)*8)) = UintptrFromInt32(0) + **(**Tsize_t)(__ccgo_up(g)) += cnt if !(flags&Int32FromInt32(GLOB_NOSORT) != 0) { Xqsort(tls, (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv+uintptr(offs)*8, cnt, uint64(8), __ccgo_fp(_sort)) } @@ -128498,7 +128498,7 @@ func Xglobfree(tls *TLS, g uintptr) { if !(i < (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathc) { break } - Xfree(tls, *(*uintptr)(unsafe.Pointer((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr((*Tglob_t)(unsafe.Pointer(g)).Fgl_offs+i)*8))-uintptr(uint64(UintptrFromInt32(0)+8))) + Xfree(tls, **(**uintptr)(__ccgo_up((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr((*Tglob_t)(unsafe.Pointer(g)).Fgl_offs+i)*8))-uintptr(uint64(UintptrFromInt32(0)+8))) goto _1 _1: ; @@ -128897,7 +128897,7 @@ func _tre_stack_push(tls *TLS, s uintptr, value Ttre_stack_item) (r Treg_errcode var new_size int32 _, _ = new_buffer, new_size if (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr < (*Ttre_stack_t)(unsafe.Pointer(s)).Fsize { - *(*Ttre_stack_item)(unsafe.Pointer((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr((*Ttre_stack_t)(unsafe.Pointer(s)).Fptr)*8)) = value + **(**Ttre_stack_item)(__ccgo_up((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr((*Ttre_stack_t)(unsafe.Pointer(s)).Fptr)*8)) = value (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr = (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr + 1 } else { if (*Ttre_stack_t)(unsafe.Pointer(s)).Fsize >= (*Ttre_stack_t)(unsafe.Pointer(s)).Fmax_size { @@ -128931,7 +128931,7 @@ func _tre_stack_push_voidptr(tls *TLS, s uintptr, value uintptr) (r Treg_errcode defer tls.Free(16) var _ /* item at bp+0 */ Ttre_stack_item *(*uintptr)(unsafe.Pointer(bp)) = value - return _tre_stack_push(tls, s, *(*Ttre_stack_item)(unsafe.Pointer(bp))) + return _tre_stack_push(tls, s, **(**Ttre_stack_item)(__ccgo_up(bp))) } func _tre_stack_pop_int(tls *TLS, s uintptr) (r int32) { @@ -128941,7 +128941,7 @@ func _tre_stack_pop_int(tls *TLS, s uintptr) (r int32) { v2 = s + 12 *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) - 1 v1 = *(*int32)(unsafe.Pointer(v2)) - return *(*int32)(unsafe.Pointer(&*(*Ttre_stack_item)(unsafe.Pointer((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr(v1)*8)))) + return *(*int32)(unsafe.Pointer(&**(**Ttre_stack_item)(__ccgo_up((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr(v1)*8)))) } func _tre_stack_pop_voidptr(tls *TLS, s uintptr) (r uintptr) { @@ -129041,7 +129041,7 @@ func _tre_expand_macro(tls *TLS, s uintptr) (r uintptr) { _ = i i = 0 for { - if !(_tre_macros[i].Fc != 0 && int32(_tre_macros[i].Fc) != int32(*(*int8)(unsafe.Pointer(s)))) { + if !(_tre_macros[i].Fc != 0 && int32(_tre_macros[i].Fc) != int32(**(**int8)(__ccgo_up(s)))) { break } goto _1 @@ -129058,7 +129058,7 @@ func _tre_compare_lit(tls *TLS, a uintptr, b uintptr) (r int32) { la = a lb = b /* assumes the range of valid code_min is < INT_MAX */ - return int32((*Ttre_literal_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(la)))).Fcode_min - (*Ttre_literal_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(lb)))).Fcode_min) + return int32((*Ttre_literal_t)(unsafe.Pointer(**(**uintptr)(__ccgo_up(la)))).Fcode_min - (*Ttre_literal_t)(unsafe.Pointer(**(**uintptr)(__ccgo_up(lb)))).Fcode_min) } type Tliterals = struct { @@ -129076,7 +129076,7 @@ func _tre_new_lit(tls *TLS, p uintptr) (r uintptr) { if (*Tliterals)(unsafe.Pointer(p)).Fcap1 >= Int32FromInt32(1)< max { @@ -129268,7 +129268,7 @@ func _parse_bracket_terms(tls *TLS, ctx uintptr, s uintptr, ls uintptr, neg uint v6 = neg + 4 v2 = *(*int32)(unsafe.Pointer(v6)) *(*int32)(unsafe.Pointer(v6)) = *(*int32)(unsafe.Pointer(v6)) + 1 - *(*Ttre_ctype_t)(unsafe.Pointer(neg + 8 + uintptr(v2)*8)) = class + **(**Ttre_ctype_t)(__ccgo_up(neg + 8 + uintptr(v2)*8)) = class } else { lit = _tre_new_lit(tls, ls) if !(lit != 0) { @@ -129308,23 +129308,23 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { _, _, _, _, _, _, _, _, _, _, _ = err, i, lit, max, min, n, nc, negmax, negmin, node, v1 node = uintptr(0) nc = uintptr(0) - (*(*Tliterals)(unsafe.Pointer(bp))).Fmem = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem - (*(*Tliterals)(unsafe.Pointer(bp))).Flen1 = 0 - (*(*Tliterals)(unsafe.Pointer(bp))).Fcap1 = int32(32) - (*(*Tliterals)(unsafe.Pointer(bp))).Fa = Xmalloc(tls, Uint64FromInt32((*(*Tliterals)(unsafe.Pointer(bp))).Fcap1)*uint64(8)) - if !((*(*Tliterals)(unsafe.Pointer(bp))).Fa != 0) { + (**(**Tliterals)(__ccgo_up(bp))).Fmem = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem + (**(**Tliterals)(__ccgo_up(bp))).Flen1 = 0 + (**(**Tliterals)(__ccgo_up(bp))).Fcap1 = int32(32) + (**(**Tliterals)(__ccgo_up(bp))).Fa = Xmalloc(tls, Uint64FromInt32((**(**Tliterals)(__ccgo_up(bp))).Fcap1)*uint64(8)) + if !((**(**Tliterals)(__ccgo_up(bp))).Fa != 0) { return int32(REG_ESPACE) } - (*(*Tneg)(unsafe.Pointer(bp + 24))).Flen1 = 0 - (*(*Tneg)(unsafe.Pointer(bp + 24))).Fnegate = BoolInt32(int32(*(*int8)(unsafe.Pointer(s))) == int32('^')) - if (*(*Tneg)(unsafe.Pointer(bp + 24))).Fnegate != 0 { + (**(**Tneg)(__ccgo_up(bp + 24))).Flen1 = 0 + (**(**Tneg)(__ccgo_up(bp + 24))).Fnegate = BoolInt32(int32(**(**int8)(__ccgo_up(s))) == int32('^')) + if (**(**Tneg)(__ccgo_up(bp + 24))).Fnegate != 0 { s = s + 1 } err = _parse_bracket_terms(tls, ctx, s, bp, bp+24) if err != REG_OK { goto parse_bracket_done } - if (*(*Tneg)(unsafe.Pointer(bp + 24))).Fnegate != 0 { + if (**(**Tneg)(__ccgo_up(bp + 24))).Fnegate != 0 { /* * With REG_NEWLINE, POSIX requires that newlines are not matched by * any form of a non-matching list. @@ -129340,7 +129340,7 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition = -int32(1) } /* Sort the array if we need to negate it. */ - Xqsort(tls, (*(*Tliterals)(unsafe.Pointer(bp))).Fa, Uint64FromInt32((*(*Tliterals)(unsafe.Pointer(bp))).Flen1), uint64(8), __ccgo_fp(_tre_compare_lit)) + Xqsort(tls, (**(**Tliterals)(__ccgo_up(bp))).Fa, Uint64FromInt32((**(**Tliterals)(__ccgo_up(bp))).Flen1), uint64(8), __ccgo_fp(_tre_compare_lit)) /* extra lit for the last negated range */ lit = _tre_new_lit(tls, bp) if !(lit != 0) { @@ -129351,14 +129351,14 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max = int64(Int32FromInt32(TRE_CHAR_MAX) + Int32FromInt32(1)) (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition = -int32(1) /* negated classes */ - if (*(*Tneg)(unsafe.Pointer(bp + 24))).Flen1 != 0 { - nc = X__tre_mem_alloc_impl(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, 0, UintptrFromInt32(0), 0, Uint64FromInt32((*(*Tneg)(unsafe.Pointer(bp + 24))).Flen1+Int32FromInt32(1))*uint64(8)) + if (**(**Tneg)(__ccgo_up(bp + 24))).Flen1 != 0 { + nc = X__tre_mem_alloc_impl(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, 0, UintptrFromInt32(0), 0, Uint64FromInt32((**(**Tneg)(__ccgo_up(bp + 24))).Flen1+Int32FromInt32(1))*uint64(8)) if !(nc != 0) { err = int32(REG_ESPACE) goto parse_bracket_done } - Xmemcpy(tls, nc, bp+24+8, Uint64FromInt32((*(*Tneg)(unsafe.Pointer(bp + 24))).Flen1)*uint64(8)) - *(*Ttre_ctype_t)(unsafe.Pointer(nc + uintptr((*(*Tneg)(unsafe.Pointer(bp + 24))).Flen1)*8)) = uint64(0) + Xmemcpy(tls, nc, bp+24+8, Uint64FromInt32((**(**Tneg)(__ccgo_up(bp + 24))).Flen1)*uint64(8)) + **(**Ttre_ctype_t)(__ccgo_up(nc + uintptr((**(**Tneg)(__ccgo_up(bp + 24))).Flen1)*8)) = uint64(0) } } /* Build a union of the items in the array, negated if necessary. */ @@ -129367,13 +129367,13 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { negmax = v1 i = 0 for { - if !(i < (*(*Tliterals)(unsafe.Pointer(bp))).Flen1) { + if !(i < (**(**Tliterals)(__ccgo_up(bp))).Flen1) { break } - lit = *(*uintptr)(unsafe.Pointer((*(*Tliterals)(unsafe.Pointer(bp))).Fa + uintptr(i)*8)) + lit = **(**uintptr)(__ccgo_up((**(**Tliterals)(__ccgo_up(bp))).Fa + uintptr(i)*8)) min = int32((*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min) max = int32((*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max) - if (*(*Tneg)(unsafe.Pointer(bp + 24))).Fnegate != 0 { + if (**(**Tneg)(__ccgo_up(bp + 24))).Fnegate != 0 { if min <= negmin { /* Overlap. */ if max+int32(1) >= negmin { @@ -129405,22 +129405,22 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { goto parse_bracket_done parse_bracket_done: ; - Xfree(tls, (*(*Tliterals)(unsafe.Pointer(bp))).Fa) + Xfree(tls, (**(**Tliterals)(__ccgo_up(bp))).Fa) (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition + 1 (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = node return err } func _parse_dup_count(tls *TLS, s uintptr, n uintptr) (r uintptr) { - *(*int32)(unsafe.Pointer(n)) = -int32(1) - if !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + **(**int32)(__ccgo_up(n)) = -int32(1) + if !(BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return s } - *(*int32)(unsafe.Pointer(n)) = 0 + **(**int32)(__ccgo_up(n)) = 0 for { - *(*int32)(unsafe.Pointer(n)) = int32(10)**(*int32)(unsafe.Pointer(n)) + (int32(*(*int8)(unsafe.Pointer(s))) - int32('0')) + **(**int32)(__ccgo_up(n)) = int32(10)***(**int32)(__ccgo_up(n)) + (int32(**(**int8)(__ccgo_up(s))) - int32('0')) s = s + 1 - if !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) || *(*int32)(unsafe.Pointer(n)) > int32(RE_DUP_MAX) { + if !(BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) || **(**int32)(__ccgo_up(n)) > int32(RE_DUP_MAX) { break } goto _1 @@ -129438,26 +129438,26 @@ func _parse_dup(tls *TLS, s uintptr, ere int32, pmin uintptr, pmax uintptr) (r u var _ /* min at bp+0 */ int32 _, _, _, _, _ = v1, v2, v3, v4, v5 s = _parse_dup_count(tls, s, bp) - if int32(*(*int8)(unsafe.Pointer(s))) == int32(',') { + if int32(**(**int8)(__ccgo_up(s))) == int32(',') { s = _parse_dup_count(tls, s+uintptr(1), bp+4) } else { - *(*int32)(unsafe.Pointer(bp + 4)) = *(*int32)(unsafe.Pointer(bp)) + **(**int32)(__ccgo_up(bp + 4)) = **(**int32)(__ccgo_up(bp)) } - if v3 = *(*int32)(unsafe.Pointer(bp + 4)) < *(*int32)(unsafe.Pointer(bp)) && *(*int32)(unsafe.Pointer(bp + 4)) >= 0 || *(*int32)(unsafe.Pointer(bp + 4)) > int32(RE_DUP_MAX) || *(*int32)(unsafe.Pointer(bp)) > int32(RE_DUP_MAX) || *(*int32)(unsafe.Pointer(bp)) < 0; !v3 { + if v3 = **(**int32)(__ccgo_up(bp + 4)) < **(**int32)(__ccgo_up(bp)) && **(**int32)(__ccgo_up(bp + 4)) >= 0 || **(**int32)(__ccgo_up(bp + 4)) > int32(RE_DUP_MAX) || **(**int32)(__ccgo_up(bp)) > int32(RE_DUP_MAX) || **(**int32)(__ccgo_up(bp)) < 0; !v3 { if v2 = !(ere != 0); v2 { v1 = s s = s + 1 } } - if v5 = v3 || v2 && int32(*(*int8)(unsafe.Pointer(v1))) != int32('\\'); !v5 { + if v5 = v3 || v2 && int32(**(**int8)(__ccgo_up(v1))) != int32('\\'); !v5 { v4 = s s = s + 1 } - if v5 || int32(*(*int8)(unsafe.Pointer(v4))) != int32('}') { + if v5 || int32(**(**int8)(__ccgo_up(v4))) != int32('}') { return uintptr(0) } - *(*int32)(unsafe.Pointer(pmin)) = *(*int32)(unsafe.Pointer(bp)) - *(*int32)(unsafe.Pointer(pmax)) = *(*int32)(unsafe.Pointer(bp + 4)) + **(**int32)(__ccgo_up(pmin)) = **(**int32)(__ccgo_up(bp)) + **(**int32)(__ccgo_up(pmax)) = **(**int32)(__ccgo_up(bp + 4)) return s } @@ -129520,7 +129520,7 @@ func _parse_atom(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { var _ /* wc at bp+0 */ Twchar_t _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, ere, err, i, len1, node, p, tmp1, tmp11, tmp2, tmp21, v, val, v14, v16 ere = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fcflags & int32(REG_EXTENDED) - switch int32(*(*int8)(unsafe.Pointer(s))) { + switch int32(**(**int8)(__ccgo_up(s))) { case int32('['): goto _1 case int32('\\'): @@ -129562,7 +129562,7 @@ _2: /* extensions: \b, \B, \<, \>, \xHH \x{HHHH} */ s = s + 1 v14 = s - switch int32(*(*int8)(unsafe.Pointer(v14))) { + switch int32(**(**int8)(__ccgo_up(v14))) { case 0: return int32(REG_EESCAPE) case int32('b'): @@ -129577,7 +129577,7 @@ _2: s = s + 1 v = 0 len1 = int32(2) - if int32(*(*int8)(unsafe.Pointer(s))) == int32('{') { + if int32(**(**int8)(__ccgo_up(s))) == int32('{') { len1 = int32(8) s = s + 1 } @@ -129586,7 +129586,7 @@ _2: if !(i < len1 && v < int32(0x110000)) { break } - c = _hexval1(tls, Uint32FromInt8(*(*int8)(unsafe.Pointer(s + uintptr(i))))) + c = _hexval1(tls, Uint32FromInt8(**(**int8)(__ccgo_up(s + uintptr(i))))) if c < 0 { break } @@ -129598,7 +129598,7 @@ _2: } s = s + uintptr(i) if len1 == int32(8) { - if int32(*(*int8)(unsafe.Pointer(s))) != int32('}') { + if int32(**(**int8)(__ccgo_up(s))) != int32('}') { return int32(REG_EBRACE) } s = s + 1 @@ -129629,9 +129629,9 @@ _2: /* fallthrough */ fallthrough default: - if !(ere != 0) && Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-uint32('1') < uint32(9) { + if !(ere != 0) && Uint32FromInt8(**(**int8)(__ccgo_up(s)))-uint32('1') < uint32(9) { /* back reference */ - val = int32(*(*int8)(unsafe.Pointer(s))) - int32('0') + val = int32(**(**int8)(__ccgo_up(s))) - int32('0') v14 = ctx + 44 v16 = *(*int32)(unsafe.Pointer(v14)) *(*int32)(unsafe.Pointer(v14)) = *(*int32)(unsafe.Pointer(v14)) + 1 @@ -129686,7 +129686,7 @@ _4: _5: ; /* '$' is special everywhere in EREs, and at the end of a BRE subexpression. */ - if !(ere != 0) && *(*int8)(unsafe.Pointer(s + 1)) != 0 && (int32(*(*int8)(unsafe.Pointer(s + 1))) != int32('\\') || int32(*(*int8)(unsafe.Pointer(s + 2))) != int32(')') && int32(*(*int8)(unsafe.Pointer(s + 2))) != int32('|')) { + if !(ere != 0) && **(**int8)(__ccgo_up(s + 1)) != 0 && (int32(**(**int8)(__ccgo_up(s + 1))) != int32('\\') || int32(**(**int8)(__ccgo_up(s + 2))) != int32(')') && int32(**(**int8)(__ccgo_up(s + 2))) != int32('|')) { goto parse_literal } node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(2), int32(ASSERT_AT_EOL), -int32(1)) @@ -129722,17 +129722,17 @@ parse_literal: if len1 < 0 { return int32(REG_BADPAT) } - if (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fcflags&int32(REG_ICASE) != 0 && (Xiswupper(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp)))) != 0 || Xiswlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp)))) != 0) { + if (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fcflags&int32(REG_ICASE) != 0 && (Xiswupper(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp)))) != 0 || Xiswlower(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp)))) != 0) { /* multiple opposite case characters are not supported */ - tmp11 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint32(Xtowupper(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))))), Int32FromUint32(Xtowupper(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))))), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) - tmp21 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint32(Xtowlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))))), Int32FromUint32(Xtowlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))))), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) + tmp11 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint32(Xtowupper(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))))), Int32FromUint32(Xtowupper(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))))), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) + tmp21 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint32(Xtowlower(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))))), Int32FromUint32(Xtowlower(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))))), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) if tmp11 != 0 && tmp21 != 0 { node = _tre_ast_new_union(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, tmp11, tmp21) } else { node = uintptr(0) } } else { - node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, *(*Twchar_t)(unsafe.Pointer(bp)), *(*Twchar_t)(unsafe.Pointer(bp)), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) + node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, **(**Twchar_t)(__ccgo_up(bp)), **(**Twchar_t)(__ccgo_up(bp)), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) } (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition + 1 s = s + uintptr(len1) @@ -129774,7 +129774,7 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { return err } for { - if !(ere != 0) && int32(*(*int8)(unsafe.Pointer(s))) == int32('\\') && int32(*(*int8)(unsafe.Pointer(s + 1))) == int32('(') || ere != 0 && int32(*(*int8)(unsafe.Pointer(s))) == int32('(') { + if !(ere != 0) && int32(**(**int8)(__ccgo_up(s))) == int32('\\') && int32(**(**int8)(__ccgo_up(s + 1))) == int32('(') || ere != 0 && int32(**(**int8)(__ccgo_up(s))) == int32('(') { v1 = _tre_stack_push_voidptr(tls, stack, nunion) err = v1 if v1 != REG_OK { @@ -129803,7 +129803,7 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart = s goto _3 } - if !(ere != 0) && int32(*(*int8)(unsafe.Pointer(s))) == int32('\\') && int32(*(*int8)(unsafe.Pointer(s + 1))) == int32(')') || ere != 0 && int32(*(*int8)(unsafe.Pointer(s))) == int32(')') && depth != 0 { + if !(ere != 0) && int32(**(**int8)(__ccgo_up(s))) == int32('\\') && int32(**(**int8)(__ccgo_up(s + 1))) == int32(')') || ere != 0 && int32(**(**int8)(__ccgo_up(s))) == int32(')') && depth != 0 { (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(1), -int32(1), -int32(1)) if !((*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn != 0) { return int32(REG_ESPACE) @@ -129819,52 +129819,52 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { parse_iter: ; for { - if int32(*(*int8)(unsafe.Pointer(s))) != int32('\\') && int32(*(*int8)(unsafe.Pointer(s))) != int32('*') { + if int32(**(**int8)(__ccgo_up(s))) != int32('\\') && int32(**(**int8)(__ccgo_up(s))) != int32('*') { if !(ere != 0) { break } - if int32(*(*int8)(unsafe.Pointer(s))) != int32('+') && int32(*(*int8)(unsafe.Pointer(s))) != int32('?') && int32(*(*int8)(unsafe.Pointer(s))) != int32('{') { + if int32(**(**int8)(__ccgo_up(s))) != int32('+') && int32(**(**int8)(__ccgo_up(s))) != int32('?') && int32(**(**int8)(__ccgo_up(s))) != int32('{') { break } } - if int32(*(*int8)(unsafe.Pointer(s))) == int32('\\') && ere != 0 { + if int32(**(**int8)(__ccgo_up(s))) == int32('\\') && ere != 0 { break } /* extension: treat \+, \? as repetitions in BRE */ - if int32(*(*int8)(unsafe.Pointer(s))) == int32('\\') && int32(*(*int8)(unsafe.Pointer(s + 1))) != int32('+') && int32(*(*int8)(unsafe.Pointer(s + 1))) != int32('?') && int32(*(*int8)(unsafe.Pointer(s + 1))) != int32('{') { + if int32(**(**int8)(__ccgo_up(s))) == int32('\\') && int32(**(**int8)(__ccgo_up(s + 1))) != int32('+') && int32(**(**int8)(__ccgo_up(s + 1))) != int32('?') && int32(**(**int8)(__ccgo_up(s + 1))) != int32('{') { break } - if int32(*(*int8)(unsafe.Pointer(s))) == int32('\\') { + if int32(**(**int8)(__ccgo_up(s))) == int32('\\') { s = s + 1 } /* handle ^* at the start of a BRE. */ - if !(ere != 0) && s == (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart+uintptr(1) && int32(*(*int8)(unsafe.Pointer(s + uintptr(-Int32FromInt32(1))))) == int32('^') { + if !(ere != 0) && s == (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart+uintptr(1) && int32(**(**int8)(__ccgo_up(s + uintptr(-Int32FromInt32(1))))) == int32('^') { break } /* extension: multiple consecutive *+?{,} is unspecified, but (a+)+ has to be supported so accepting a++ makes sense, note however that the RE_DUP_MAX limit can be circumvented: (a{255}){255} uses a lot of memory.. */ - if int32(*(*int8)(unsafe.Pointer(s))) == int32('{') { + if int32(**(**int8)(__ccgo_up(s))) == int32('{') { s = _parse_dup(tls, s+uintptr(1), ere, bp, bp+4) if !(s != 0) { return int32(REG_BADBR) } } else { - *(*int32)(unsafe.Pointer(bp)) = 0 - *(*int32)(unsafe.Pointer(bp + 4)) = -int32(1) - if int32(*(*int8)(unsafe.Pointer(s))) == int32('+') { - *(*int32)(unsafe.Pointer(bp)) = int32(1) + **(**int32)(__ccgo_up(bp)) = 0 + **(**int32)(__ccgo_up(bp + 4)) = -int32(1) + if int32(**(**int8)(__ccgo_up(s))) == int32('+') { + **(**int32)(__ccgo_up(bp)) = int32(1) } - if int32(*(*int8)(unsafe.Pointer(s))) == int32('?') { - *(*int32)(unsafe.Pointer(bp + 4)) = int32(1) + if int32(**(**int8)(__ccgo_up(s))) == int32('?') { + **(**int32)(__ccgo_up(bp + 4)) = int32(1) } s = s + 1 } - if *(*int32)(unsafe.Pointer(bp + 4)) == 0 { + if **(**int32)(__ccgo_up(bp + 4)) == 0 { (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(1), -int32(1), -int32(1)) } else { - (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = _tre_ast_new_iter(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn, *(*int32)(unsafe.Pointer(bp)), *(*int32)(unsafe.Pointer(bp + 4)), 0) + (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = _tre_ast_new_iter(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn, **(**int32)(__ccgo_up(bp)), **(**int32)(__ccgo_up(bp + 4)), 0) } if !((*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn != 0) { return int32(REG_ESPACE) @@ -129873,13 +129873,13 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { _9: } nbranch = _tre_ast_new_catenation(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, nbranch, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn) - if ere != 0 && int32(*(*int8)(unsafe.Pointer(s))) == int32('|') || ere != 0 && int32(*(*int8)(unsafe.Pointer(s))) == int32(')') && depth != 0 || !(ere != 0) && int32(*(*int8)(unsafe.Pointer(s))) == int32('\\') && int32(*(*int8)(unsafe.Pointer(s + 1))) == int32(')') || !(ere != 0) && int32(*(*int8)(unsafe.Pointer(s))) == int32('\\') && int32(*(*int8)(unsafe.Pointer(s + 1))) == int32('|') || !(*(*int8)(unsafe.Pointer(s)) != 0) { + if ere != 0 && int32(**(**int8)(__ccgo_up(s))) == int32('|') || ere != 0 && int32(**(**int8)(__ccgo_up(s))) == int32(')') && depth != 0 || !(ere != 0) && int32(**(**int8)(__ccgo_up(s))) == int32('\\') && int32(**(**int8)(__ccgo_up(s + 1))) == int32(')') || !(ere != 0) && int32(**(**int8)(__ccgo_up(s))) == int32('\\') && int32(**(**int8)(__ccgo_up(s + 1))) == int32('|') || !(**(**int8)(__ccgo_up(s)) != 0) { /* extension: empty branch is unspecified (), (|a), (a|) here they are not rejected but match on empty string */ - c = int32(*(*int8)(unsafe.Pointer(s))) + c = int32(**(**int8)(__ccgo_up(s))) nunion = _tre_ast_new_union(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, nunion, nbranch) nbranch = uintptr(0) - if c == int32('\\') && int32(*(*int8)(unsafe.Pointer(s + 1))) == int32('|') { + if c == int32('\\') && int32(**(**int8)(__ccgo_up(s + 1))) == int32('|') { s = s + uintptr(2) (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart = s } else { @@ -130025,22 +130025,22 @@ func _tre_purge_regset(tls *TLS, regset uintptr, tnfa uintptr, tag int32) { _, _, _ = i, id, start i = 0 for { - if !(*(*int32)(unsafe.Pointer(regset + uintptr(i)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(regset + uintptr(i)*4)) >= 0) { break } - id = *(*int32)(unsafe.Pointer(regset + uintptr(i)*4)) / int32(2) - start = BoolInt32(!(*(*int32)(unsafe.Pointer(regset + uintptr(i)*4))%Int32FromInt32(2) != 0)) + id = **(**int32)(__ccgo_up(regset + uintptr(i)*4)) / int32(2) + start = BoolInt32(!(**(**int32)(__ccgo_up(regset + uintptr(i)*4))%Int32FromInt32(2) != 0)) if start != 0 { - (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id)*16))).Fso_tag = tag + (**(**Ttre_submatch_data_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id)*16))).Fso_tag = tag } else { - (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id)*16))).Feo_tag = tag + (**(**Ttre_submatch_data_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id)*16))).Feo_tag = tag } goto _1 _1: ; i = i + 1 } - *(*int32)(unsafe.Pointer(regset)) = -int32(1) + **(**int32)(__ccgo_up(regset)) = -int32(1) } // C documentation @@ -130069,20 +130069,20 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u direction = int32(_TRE_TAG_MINIMIZE) if !(first_pass != 0) { (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fend_tag = 0 - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags)) = -int32(1) + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags)) = -int32(1) } regset = Xmalloc(tls, uint64(4)*uint64(((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches+Uint32FromInt32(1))*Uint32FromInt32(2))) if regset == UintptrFromInt32(0) { return int32(REG_ESPACE) } - *(*int32)(unsafe.Pointer(regset)) = -int32(1) + **(**int32)(__ccgo_up(regset)) = -int32(1) orig_regset = regset parents = Xmalloc(tls, uint64(4)*uint64((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches+Uint32FromInt32(1))) if parents == UintptrFromInt32(0) { Xfree(tls, regset) return int32(REG_ESPACE) } - *(*int32)(unsafe.Pointer(parents)) = -int32(1) + **(**int32)(__ccgo_up(parents)) = -int32(1) saved_states = Xmalloc(tls, uint64(8)*uint64((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches+Uint32FromInt32(1))) if saved_states == UintptrFromInt32(0) { Xfree(tls, regset) @@ -130094,7 +130094,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u if !(i <= (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches) { break } - (*(*Ttre_tag_states_t)(unsafe.Pointer(saved_states + uintptr(i)*8))).Ftag = -int32(1) + (**(**Ttre_tag_states_t)(__ccgo_up(saved_states + uintptr(i)*8))).Ftag = -int32(1) goto _1 _1: ; @@ -130133,7 +130133,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u /* Add end of this submatch to regset. */ i1 = 0 for { - if !(*(*int32)(unsafe.Pointer(regset + uintptr(i1)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(regset + uintptr(i1)*4)) >= 0) { break } goto _11 @@ -130141,12 +130141,12 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i1 = i1 + 1 } - *(*int32)(unsafe.Pointer(regset + uintptr(i1)*4)) = id*int32(2) + int32(1) - *(*int32)(unsafe.Pointer(regset + uintptr(i1+int32(1))*4)) = -int32(1) + **(**int32)(__ccgo_up(regset + uintptr(i1)*4)) = id*int32(2) + int32(1) + **(**int32)(__ccgo_up(regset + uintptr(i1+int32(1))*4)) = -int32(1) /* Pop this submatch from the parents stack. */ i1 = 0 for { - if !(*(*int32)(unsafe.Pointer(parents + uintptr(i1)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(parents + uintptr(i1)*4)) >= 0) { break } goto _12 @@ -130154,7 +130154,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i1 = i1 + 1 } - *(*int32)(unsafe.Pointer(parents + uintptr(i1-int32(1))*4)) = -int32(1) + **(**int32)(__ccgo_up(parents + uintptr(i1-int32(1))*4)) = -int32(1) goto _10 _3: ; @@ -130164,7 +130164,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u /* Add start of this submatch to regset. */ i2 = 0 for { - if !(*(*int32)(unsafe.Pointer(regset + uintptr(i2)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(regset + uintptr(i2)*4)) >= 0) { break } goto _13 @@ -130172,12 +130172,12 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i2 = i2 + 1 } - *(*int32)(unsafe.Pointer(regset + uintptr(i2)*4)) = id1 * int32(2) - *(*int32)(unsafe.Pointer(regset + uintptr(i2+int32(1))*4)) = -int32(1) + **(**int32)(__ccgo_up(regset + uintptr(i2)*4)) = id1 * int32(2) + **(**int32)(__ccgo_up(regset + uintptr(i2+int32(1))*4)) = -int32(1) if !(first_pass != 0) { i2 = 0 for { - if !(*(*int32)(unsafe.Pointer(parents + uintptr(i2)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(parents + uintptr(i2)*4)) >= 0) { break } goto _14 @@ -130185,26 +130185,26 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i2 = i2 + 1 } - (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id1)*16))).Fparents = UintptrFromInt32(0) + (**(**Ttre_submatch_data_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id1)*16))).Fparents = UintptrFromInt32(0) if i2 > 0 { p = Xmalloc(tls, uint64(4)*Uint64FromInt32(i2+Int32FromInt32(1))) if p == UintptrFromInt32(0) { status = int32(REG_ESPACE) goto _10 } - (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id1)*16))).Fparents = p + (**(**Ttre_submatch_data_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id1)*16))).Fparents = p i2 = 0 for { - if !(*(*int32)(unsafe.Pointer(parents + uintptr(i2)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(parents + uintptr(i2)*4)) >= 0) { break } - *(*int32)(unsafe.Pointer(p + uintptr(i2)*4)) = *(*int32)(unsafe.Pointer(parents + uintptr(i2)*4)) + **(**int32)(__ccgo_up(p + uintptr(i2)*4)) = **(**int32)(__ccgo_up(parents + uintptr(i2)*4)) goto _15 _15: ; i2 = i2 + 1 } - *(*int32)(unsafe.Pointer(p + uintptr(i2)*4)) = -int32(1) + **(**int32)(__ccgo_up(p + uintptr(i2)*4)) = -int32(1) } } /* Add end of this submatch to regset after processing this @@ -130222,16 +130222,16 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u case int32(_LITERAL): lit = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj if !((*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min < Int64FromInt32(0)) || (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min == int64(-int32(4)) { - if *(*int32)(unsafe.Pointer(regset)) >= 0 { + if **(**int32)(__ccgo_up(regset)) >= 0 { /* Regset is not empty, so add a tag before the literal or backref. */ if !(first_pass != 0) { status = _tre_add_tag_left(tls, mem, node, tag) - *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = direction + **(**Ttre_tag_direction_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = direction if minimal_tag >= 0 { i3 = 0 for { - if !(*(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3)*4)) >= 0) { break } goto _16 @@ -130239,9 +130239,9 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i3 = i3 + 1 } - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3)*4)) = tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3+int32(1))*4)) = minimal_tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3+int32(2))*4)) = -int32(1) + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3)*4)) = tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3+int32(1))*4)) = minimal_tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) num_minimals = num_minimals + 1 } @@ -130249,7 +130249,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u } else { (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fnum_tags = int32(1) } - *(*int32)(unsafe.Pointer(regset)) = -int32(1) + **(**int32)(__ccgo_up(regset)) = -int32(1) tag = next_tag num_tags = num_tags + 1 next_tag = next_tag + 1 @@ -130309,7 +130309,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u case int32(_ITERATION): iter = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj if first_pass != 0 { - status = _tre_stack_push_int(tls, stack, BoolInt32(*(*int32)(unsafe.Pointer(regset)) >= 0 || int32(uint32(*(*uint8)(unsafe.Pointer(iter + 16))&0x1>>0)) != 0)) + status = _tre_stack_push_int(tls, stack, BoolInt32(**(**int32)(__ccgo_up(regset)) >= 0 || int32(uint32(*(*uint8)(unsafe.Pointer(iter + 16))&0x1>>0)) != 0)) if status != REG_OK { break } @@ -130340,18 +130340,18 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u break } /* Regset is not empty, so add a tag here. */ - if *(*int32)(unsafe.Pointer(regset)) >= 0 || int32(uint32(*(*uint8)(unsafe.Pointer(iter + 16))&0x1>>0)) != 0 { + if **(**int32)(__ccgo_up(regset)) >= 0 || int32(uint32(*(*uint8)(unsafe.Pointer(iter + 16))&0x1>>0)) != 0 { if !(first_pass != 0) { status = _tre_add_tag_left(tls, mem, node, tag) if int32(uint32(*(*uint8)(unsafe.Pointer(iter + 16))&0x1>>0)) != 0 { - *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = int32(_TRE_TAG_MAXIMIZE) + **(**Ttre_tag_direction_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = int32(_TRE_TAG_MAXIMIZE) } else { - *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = direction + **(**Ttre_tag_direction_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = direction } if minimal_tag >= 0 { i4 = 0 for { - if !(*(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4)*4)) >= 0) { break } goto _17 @@ -130359,15 +130359,15 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i4 = i4 + 1 } - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4)*4)) = tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4+int32(1))*4)) = minimal_tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4+int32(2))*4)) = -int32(1) + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4)*4)) = tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4+int32(1))*4)) = minimal_tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) num_minimals = num_minimals + 1 } _tre_purge_regset(tls, regset, tnfa, tag) } - *(*int32)(unsafe.Pointer(regset)) = -int32(1) + **(**int32)(__ccgo_up(regset)) = -int32(1) tag = next_tag num_tags = num_tags + 1 next_tag = next_tag + 1 @@ -130377,7 +130377,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u uni = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj left1 = (*Ttre_union_t)(unsafe.Pointer(uni)).Fleft right1 = (*Ttre_union_t)(unsafe.Pointer(uni)).Fright - if *(*int32)(unsafe.Pointer(regset)) >= 0 { + if **(**int32)(__ccgo_up(regset)) >= 0 { left_tag = next_tag right_tag = next_tag + int32(1) } else { @@ -130397,7 +130397,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u if status != REG_OK { break } - status = _tre_stack_push_int(tls, stack, BoolInt32(*(*int32)(unsafe.Pointer(regset)) >= 0)) + status = _tre_stack_push_int(tls, stack, BoolInt32(**(**int32)(__ccgo_up(regset)) >= 0)) if status != REG_OK { break } @@ -130441,14 +130441,14 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u break } /* Regset is not empty, so add a tag here. */ - if *(*int32)(unsafe.Pointer(regset)) >= 0 { + if **(**int32)(__ccgo_up(regset)) >= 0 { if !(first_pass != 0) { status = _tre_add_tag_left(tls, mem, node, tag) - *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = direction + **(**Ttre_tag_direction_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = direction if minimal_tag >= 0 { i5 = 0 for { - if !(*(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5)*4)) >= 0) { break } goto _18 @@ -130456,15 +130456,15 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i5 = i5 + 1 } - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5)*4)) = tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5+int32(1))*4)) = minimal_tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5+int32(2))*4)) = -int32(1) + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5)*4)) = tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5+int32(1))*4)) = minimal_tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) num_minimals = num_minimals + 1 } _tre_purge_regset(tls, regset, tnfa, tag) } - *(*int32)(unsafe.Pointer(regset)) = -int32(1) + **(**int32)(__ccgo_up(regset)) = -int32(1) tag = next_tag num_tags = num_tags + 1 next_tag = next_tag + 1 @@ -130481,7 +130481,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u /* Push this submatch on the parents stack. */ i6 = 0 for { - if !(*(*int32)(unsafe.Pointer(parents + uintptr(i6)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(parents + uintptr(i6)*4)) >= 0) { break } goto _19 @@ -130489,8 +130489,8 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i6 = i6 + 1 } - *(*int32)(unsafe.Pointer(parents + uintptr(i6)*4)) = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fsubmatch_id - *(*int32)(unsafe.Pointer(parents + uintptr(i6+int32(1))*4)) = -int32(1) + **(**int32)(__ccgo_up(parents + uintptr(i6)*4)) = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fsubmatch_id + **(**int32)(__ccgo_up(parents + uintptr(i6+int32(1))*4)) = -int32(1) } goto _10 /* end case: ADDTAGS_RECURSE */ _4: @@ -130538,7 +130538,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u will be restored at ADDTAGS_AFTER_UNION_RIGHT below. */ _21: ; - if !(*(*int32)(unsafe.Pointer(regset)) >= 0) { + if !(**(**int32)(__ccgo_up(regset)) >= 0) { goto _20 } regset += 4 @@ -130575,11 +130575,11 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u if (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fnum_submatches > 0 { if !(first_pass != 0) { status = _tre_add_tag_right(tls, mem, left2, tag_left) - *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag_left)*4)) = int32(_TRE_TAG_MAXIMIZE) + **(**Ttre_tag_direction_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag_left)*4)) = int32(_TRE_TAG_MAXIMIZE) if status == REG_OK { status = _tre_add_tag_right(tls, mem, right2, tag_right) } - *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag_right)*4)) = int32(_TRE_TAG_MAXIMIZE) + **(**Ttre_tag_direction_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag_right)*4)) = int32(_TRE_TAG_MAXIMIZE) } num_tags = num_tags + int32(2) } @@ -130597,7 +130597,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u if !(first_pass != 0) && minimal_tag >= 0 { i7 = 0 for { - if !(*(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7)*4)) >= 0) { break } goto _23 @@ -130605,9 +130605,9 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i7 = i7 + 1 } - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7)*4)) = tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7+int32(1))*4)) = minimal_tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7+int32(2))*4)) = -int32(1) + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7)*4)) = tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7+int32(1))*4)) = minimal_tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) num_minimals = num_minimals + 1 } @@ -130664,7 +130664,7 @@ func _tre_copy_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, flags i /* XXX - e.g. [ab] has only one position but two nodes, so we are creating holes in the state space here. Not fatal, just wastes memory. */ - pos = pos + *(*int32)(unsafe.Pointer(pos_add)) + pos = pos + **(**int32)(__ccgo_up(pos_add)) num_copied = num_copied + 1 } else { if (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min == int64(-int32(3)) && flags&int32(COPY_REMOVE_TAGS) != 0 { @@ -130676,30 +130676,30 @@ func _tre_copy_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, flags i } else { if (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min == int64(-int32(3)) && flags&int32(COPY_MAXIMIZE_FIRST_TAG) != 0 && first_tag != 0 { /* Maximize the first tag. */ - *(*Ttre_tag_direction_t)(unsafe.Pointer(tag_directions + uintptr(max)*4)) = int32(_TRE_TAG_MAXIMIZE) + **(**Ttre_tag_direction_t)(__ccgo_up(tag_directions + uintptr(max)*4)) = int32(_TRE_TAG_MAXIMIZE) first_tag = 0 } } } - *(*uintptr)(unsafe.Pointer(result)) = _tre_ast_new_literal(tls, mem, min, max, pos) - if *(*uintptr)(unsafe.Pointer(result)) == UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(result)) = _tre_ast_new_literal(tls, mem, min, max, pos) + if **(**uintptr)(__ccgo_up(result)) == UintptrFromInt32(0) { status = int32(REG_ESPACE) } else { - p = (*Ttre_ast_node_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(result)))).Fobj + p = (*Ttre_ast_node_t)(unsafe.Pointer(**(**uintptr)(__ccgo_up(result)))).Fobj (*Ttre_literal_t)(unsafe.Pointer(p)).Fclass = (*Ttre_literal_t)(unsafe.Pointer(lit)).Fclass (*Ttre_literal_t)(unsafe.Pointer(p)).Fneg_classes = (*Ttre_literal_t)(unsafe.Pointer(lit)).Fneg_classes } - if pos > *(*int32)(unsafe.Pointer(max_pos)) { - *(*int32)(unsafe.Pointer(max_pos)) = pos + if pos > **(**int32)(__ccgo_up(max_pos)) { + **(**int32)(__ccgo_up(max_pos)) = pos } case int32(_UNION): uni = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj - *(*uintptr)(unsafe.Pointer(result)) = _tre_ast_new_union(tls, mem, (*Ttre_union_t)(unsafe.Pointer(uni)).Fleft, (*Ttre_union_t)(unsafe.Pointer(uni)).Fright) - if *(*uintptr)(unsafe.Pointer(result)) == UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(result)) = _tre_ast_new_union(tls, mem, (*Ttre_union_t)(unsafe.Pointer(uni)).Fleft, (*Ttre_union_t)(unsafe.Pointer(uni)).Fright) + if **(**uintptr)(__ccgo_up(result)) == UintptrFromInt32(0) { status = int32(REG_ESPACE) break } - tmp = (*Ttre_ast_node_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(result)))).Fobj + tmp = (*Ttre_ast_node_t)(unsafe.Pointer(**(**uintptr)(__ccgo_up(result)))).Fobj result = tmp status = _tre_stack_push_voidptr(tls, stack, (*Ttre_union_t)(unsafe.Pointer(uni)).Fright) if status != REG_OK { @@ -130727,12 +130727,12 @@ func _tre_copy_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, flags i } case int32(_CATENATION): cat = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj - *(*uintptr)(unsafe.Pointer(result)) = _tre_ast_new_catenation(tls, mem, (*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft, (*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright) - if *(*uintptr)(unsafe.Pointer(result)) == UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(result)) = _tre_ast_new_catenation(tls, mem, (*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft, (*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright) + if **(**uintptr)(__ccgo_up(result)) == UintptrFromInt32(0) { status = int32(REG_ESPACE) break } - tmp1 = (*Ttre_ast_node_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(result)))).Fobj + tmp1 = (*Ttre_ast_node_t)(unsafe.Pointer(**(**uintptr)(__ccgo_up(result)))).Fobj (*Ttre_catenation_t)(unsafe.Pointer(tmp1)).Fleft = UintptrFromInt32(0) (*Ttre_catenation_t)(unsafe.Pointer(tmp1)).Fright = UintptrFromInt32(0) result = tmp1 @@ -130770,12 +130770,12 @@ func _tre_copy_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, flags i if status != REG_OK { break } - *(*uintptr)(unsafe.Pointer(result)) = _tre_ast_new_iter(tls, mem, (*Ttre_iteration_t)(unsafe.Pointer(iter)).Farg, (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmin, (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmax, int32(uint32(*(*uint8)(unsafe.Pointer(iter + 16))&0x1>>0))) - if *(*uintptr)(unsafe.Pointer(result)) == UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(result)) = _tre_ast_new_iter(tls, mem, (*Ttre_iteration_t)(unsafe.Pointer(iter)).Farg, (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmin, (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmax, int32(uint32(*(*uint8)(unsafe.Pointer(iter + 16))&0x1>>0))) + if **(**uintptr)(__ccgo_up(result)) == UintptrFromInt32(0) { status = int32(REG_ESPACE) break } - iter = (*Ttre_ast_node_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(result)))).Fobj + iter = (*Ttre_ast_node_t)(unsafe.Pointer(**(**uintptr)(__ccgo_up(result)))).Fobj result = iter default: break @@ -130783,7 +130783,7 @@ func _tre_copy_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, flags i break } } - *(*int32)(unsafe.Pointer(pos_add)) += num_copied + **(**int32)(__ccgo_up(pos_add)) += num_copied return status } @@ -130811,9 +130811,9 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _status, _status1, bottom, cat, flags, iter, iter1, iter_depth, j, lit, node, pos_add_last, pos_add_save, pos_add_total, seq1, status, symbol, tmp, uni, v2 status = REG_OK bottom = _tre_stack_num_objects(tls, stack) - *(*int32)(unsafe.Pointer(bp)) = 0 + **(**int32)(__ccgo_up(bp)) = 0 pos_add_total = 0 - *(*int32)(unsafe.Pointer(bp + 4)) = 0 + **(**int32)(__ccgo_up(bp + 4)) = 0 iter_depth = 0 _status = _tre_stack_push_voidptr(tls, stack, ast) if _status != REG_OK { @@ -130835,9 +130835,9 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit case int32(_LITERAL): lit = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj if !((*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min < Int64FromInt32(0)) || (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min == int64(-int32(4)) { - *(*int32)(unsafe.Pointer(lit + 16)) += *(*int32)(unsafe.Pointer(bp)) - if (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition > *(*int32)(unsafe.Pointer(bp + 4)) { - *(*int32)(unsafe.Pointer(bp + 4)) = (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition + **(**int32)(__ccgo_up(lit + 16)) += **(**int32)(__ccgo_up(bp)) + if (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition > **(**int32)(__ccgo_up(bp + 4)) { + **(**int32)(__ccgo_up(bp + 4)) = (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition } } case int32(_UNION): @@ -130878,7 +130878,7 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit } case int32(_ITERATION): iter = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj - status = _tre_stack_push_int(tls, stack, *(*int32)(unsafe.Pointer(bp))) + status = _tre_stack_push_int(tls, stack, **(**int32)(__ccgo_up(bp))) if status != REG_OK { break } @@ -130902,7 +130902,7 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit then don't increase the `pos' fields of the nodes now, it will get done when expanding. */ if (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmin > int32(1) || (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmax > int32(1) { - *(*int32)(unsafe.Pointer(bp)) = 0 + **(**int32)(__ccgo_up(bp)) = 0 } iter_depth = iter_depth + 1 default: @@ -130910,12 +130910,12 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit } case int32(_EXPAND_AFTER_ITER): iter1 = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj - *(*int32)(unsafe.Pointer(bp)) = _tre_stack_pop_int(tls, stack) - pos_add_last = *(*int32)(unsafe.Pointer(bp)) + **(**int32)(__ccgo_up(bp)) = _tre_stack_pop_int(tls, stack) + pos_add_last = **(**int32)(__ccgo_up(bp)) if (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Fmin > int32(1) || (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Fmax > int32(1) { seq1 = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(bp + 8)) = UintptrFromInt32(0) - pos_add_save = *(*int32)(unsafe.Pointer(bp)) + **(**uintptr)(__ccgo_up(bp + 8)) = UintptrFromInt32(0) + pos_add_save = **(**int32)(__ccgo_up(bp)) /* Create a catenated sequence of copies of the node. */ j = 0 for { @@ -130929,15 +130929,15 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit } /* Remove tags from all but the last copy. */ flags = v2 - pos_add_save = *(*int32)(unsafe.Pointer(bp)) + pos_add_save = **(**int32)(__ccgo_up(bp)) status = _tre_copy_ast(tls, mem, stack, (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Farg, flags, bp, tag_directions, bp+16, bp+4) if status != REG_OK { return status } if seq1 != UintptrFromInt32(0) { - seq1 = _tre_ast_new_catenation(tls, mem, seq1, *(*uintptr)(unsafe.Pointer(bp + 16))) + seq1 = _tre_ast_new_catenation(tls, mem, seq1, **(**uintptr)(__ccgo_up(bp + 16))) } else { - seq1 = *(*uintptr)(unsafe.Pointer(bp + 16)) + seq1 = **(**uintptr)(__ccgo_up(bp + 16)) } if seq1 == UintptrFromInt32(0) { return int32(REG_ESPACE) @@ -130949,13 +130949,13 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit } if (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Fmax == -int32(1) { /* No upper limit. */ - pos_add_save = *(*int32)(unsafe.Pointer(bp)) + pos_add_save = **(**int32)(__ccgo_up(bp)) status = _tre_copy_ast(tls, mem, stack, (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Farg, 0, bp, UintptrFromInt32(0), bp+8, bp+4) if status != REG_OK { return status } - *(*uintptr)(unsafe.Pointer(bp + 8)) = _tre_ast_new_iter(tls, mem, *(*uintptr)(unsafe.Pointer(bp + 8)), 0, -int32(1), 0) - if *(*uintptr)(unsafe.Pointer(bp + 8)) == UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(bp + 8)) = _tre_ast_new_iter(tls, mem, **(**uintptr)(__ccgo_up(bp + 8)), 0, -int32(1), 0) + if **(**uintptr)(__ccgo_up(bp + 8)) == UintptrFromInt32(0) { return int32(REG_ESPACE) } } else { @@ -130964,25 +130964,25 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit if !(j < (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Fmax) { break } - pos_add_save = *(*int32)(unsafe.Pointer(bp)) + pos_add_save = **(**int32)(__ccgo_up(bp)) status = _tre_copy_ast(tls, mem, stack, (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Farg, 0, bp, UintptrFromInt32(0), bp+24, bp+4) if status != REG_OK { return status } - if *(*uintptr)(unsafe.Pointer(bp + 8)) != UintptrFromInt32(0) { - *(*uintptr)(unsafe.Pointer(bp + 8)) = _tre_ast_new_catenation(tls, mem, *(*uintptr)(unsafe.Pointer(bp + 24)), *(*uintptr)(unsafe.Pointer(bp + 8))) + if **(**uintptr)(__ccgo_up(bp + 8)) != UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(bp + 8)) = _tre_ast_new_catenation(tls, mem, **(**uintptr)(__ccgo_up(bp + 24)), **(**uintptr)(__ccgo_up(bp + 8))) } else { - *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 24)) + **(**uintptr)(__ccgo_up(bp + 8)) = **(**uintptr)(__ccgo_up(bp + 24)) } - if *(*uintptr)(unsafe.Pointer(bp + 8)) == UintptrFromInt32(0) { + if **(**uintptr)(__ccgo_up(bp + 8)) == UintptrFromInt32(0) { return int32(REG_ESPACE) } tmp = _tre_ast_new_literal(tls, mem, -int32(1), -int32(1), -int32(1)) if tmp == UintptrFromInt32(0) { return int32(REG_ESPACE) } - *(*uintptr)(unsafe.Pointer(bp + 8)) = _tre_ast_new_union(tls, mem, tmp, *(*uintptr)(unsafe.Pointer(bp + 8))) - if *(*uintptr)(unsafe.Pointer(bp + 8)) == UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(bp + 8)) = _tre_ast_new_union(tls, mem, tmp, **(**uintptr)(__ccgo_up(bp + 8))) + if **(**uintptr)(__ccgo_up(bp + 8)) == UintptrFromInt32(0) { return int32(REG_ESPACE) } goto _3 @@ -130991,12 +130991,12 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit j = j + 1 } } - *(*int32)(unsafe.Pointer(bp)) = pos_add_save + **(**int32)(__ccgo_up(bp)) = pos_add_save if seq1 == UintptrFromInt32(0) { - seq1 = *(*uintptr)(unsafe.Pointer(bp + 8)) + seq1 = **(**uintptr)(__ccgo_up(bp + 8)) } else { - if *(*uintptr)(unsafe.Pointer(bp + 8)) != UintptrFromInt32(0) { - seq1 = _tre_ast_new_catenation(tls, mem, seq1, *(*uintptr)(unsafe.Pointer(bp + 8))) + if **(**uintptr)(__ccgo_up(bp + 8)) != UintptrFromInt32(0) { + seq1 = _tre_ast_new_catenation(tls, mem, seq1, **(**uintptr)(__ccgo_up(bp + 8))) } } if seq1 == UintptrFromInt32(0) { @@ -131006,21 +131006,21 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit (*Ttre_ast_node_t)(unsafe.Pointer(node)).Ftype1 = (*Ttre_ast_node_t)(unsafe.Pointer(seq1)).Ftype1 } iter_depth = iter_depth - 1 - pos_add_total = pos_add_total + (*(*int32)(unsafe.Pointer(bp)) - pos_add_last) + pos_add_total = pos_add_total + (**(**int32)(__ccgo_up(bp)) - pos_add_last) if iter_depth == 0 { - *(*int32)(unsafe.Pointer(bp)) = pos_add_total + **(**int32)(__ccgo_up(bp)) = pos_add_total } default: break } } - *(*int32)(unsafe.Pointer(position)) += pos_add_total + **(**int32)(__ccgo_up(position)) += pos_add_total /* `max_pos' should never be larger than `*position' if the above code works, but just an extra safeguard let's make sure `*position' is set large enough so enough memory will be allocated for the transition table. */ - if *(*int32)(unsafe.Pointer(bp + 4)) > *(*int32)(unsafe.Pointer(position)) { - *(*int32)(unsafe.Pointer(position)) = *(*int32)(unsafe.Pointer(bp + 4)) + if **(**int32)(__ccgo_up(bp + 4)) > **(**int32)(__ccgo_up(position)) { + **(**int32)(__ccgo_up(position)) = **(**int32)(__ccgo_up(bp + 4)) } return status } @@ -131032,9 +131032,9 @@ func _tre_set_empty(tls *TLS, mem Ttre_mem_t) (r uintptr) { if new_set == UintptrFromInt32(0) { return UintptrFromInt32(0) } - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fposition = -int32(1) - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fcode_min = -int32(1) - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fcode_max = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fposition = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fcode_min = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fcode_max = -int32(1) return new_set } @@ -131045,15 +131045,15 @@ func _tre_set_one(tls *TLS, mem Ttre_mem_t, position int32, code_min int32, code if new_set == UintptrFromInt32(0) { return UintptrFromInt32(0) } - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fposition = position - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fcode_min = code_min - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fcode_max = code_max - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fclass = class - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fneg_classes = neg_classes - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fbackref = backref - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + 1*56))).Fposition = -int32(1) - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + 1*56))).Fcode_min = -int32(1) - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + 1*56))).Fcode_max = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fposition = position + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fcode_min = code_min + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fcode_max = code_max + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fclass = class + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fneg_classes = neg_classes + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fbackref = backref + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + 1*56))).Fposition = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + 1*56))).Fcode_min = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + 1*56))).Fcode_max = -int32(1) return new_set } @@ -131063,7 +131063,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u _, _, _, _, _, _, _ = i, j, new_set, new_tags, num_tags, s1, s2 num_tags = 0 for { - if !(tags != UintptrFromInt32(0) && *(*int32)(unsafe.Pointer(tags + uintptr(num_tags)*4)) >= 0) { + if !(tags != UintptrFromInt32(0) && **(**int32)(__ccgo_up(tags + uintptr(num_tags)*4)) >= 0) { break } goto _1 @@ -131073,7 +131073,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u } s1 = 0 for { - if !((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fposition >= 0) { + if !((**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fposition >= 0) { break } goto _2 @@ -131083,7 +131083,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u } s2 = 0 for { - if !((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fposition >= 0) { + if !((**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fposition >= 0) { break } goto _3 @@ -131097,22 +131097,22 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u } s1 = 0 for { - if !((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fposition >= 0) { + if !((**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fposition >= 0) { break } - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Fposition = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fposition - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Fcode_min = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fcode_min - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Fcode_max = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fcode_max - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Fassertions = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fassertions | assertions - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Fclass = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fclass - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Fneg_classes = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fneg_classes - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Fbackref = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fbackref - if (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Ftags == UintptrFromInt32(0) && tags == UintptrFromInt32(0) { - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Ftags = UintptrFromInt32(0) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Fposition = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fposition + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Fcode_min = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fcode_min + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Fcode_max = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fcode_max + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Fassertions = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fassertions | assertions + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Fclass = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fclass + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Fneg_classes = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fneg_classes + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Fbackref = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fbackref + if (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Ftags == UintptrFromInt32(0) && tags == UintptrFromInt32(0) { + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Ftags = UintptrFromInt32(0) } else { i = 0 for { - if !((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Ftags != UintptrFromInt32(0) && *(*int32)(unsafe.Pointer((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Ftags + uintptr(i)*4)) >= 0) { + if !((**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Ftags != UintptrFromInt32(0) && **(**int32)(__ccgo_up((**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Ftags + uintptr(i)*4)) >= 0) { break } goto _5 @@ -131129,7 +131129,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u if !(j < i) { break } - *(*int32)(unsafe.Pointer(new_tags + uintptr(j)*4)) = *(*int32)(unsafe.Pointer((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Ftags + uintptr(j)*4)) + **(**int32)(__ccgo_up(new_tags + uintptr(j)*4)) = **(**int32)(__ccgo_up((**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Ftags + uintptr(j)*4)) goto _6 _6: ; @@ -131140,14 +131140,14 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u if !(i < num_tags) { break } - *(*int32)(unsafe.Pointer(new_tags + uintptr(j+i)*4)) = *(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) + **(**int32)(__ccgo_up(new_tags + uintptr(j+i)*4)) = **(**int32)(__ccgo_up(tags + uintptr(i)*4)) goto _7 _7: ; i = i + 1 } - *(*int32)(unsafe.Pointer(new_tags + uintptr(j+i)*4)) = -int32(1) - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Ftags = new_tags + **(**int32)(__ccgo_up(new_tags + uintptr(j+i)*4)) = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Ftags = new_tags } goto _4 _4: @@ -131156,23 +131156,23 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u } s2 = 0 for { - if !((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fposition >= 0) { + if !((**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fposition >= 0) { break } - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fposition = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fposition - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fcode_min = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fcode_min - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fcode_max = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fcode_max + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Fposition = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fposition + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Fcode_min = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fcode_min + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Fcode_max = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fcode_max /* XXX - why not | assertions here as well? */ - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fassertions = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fassertions - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fclass = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fclass - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fneg_classes = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fneg_classes - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fbackref = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fbackref - if (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Ftags == UintptrFromInt32(0) { - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Ftags = UintptrFromInt32(0) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Fassertions = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fassertions + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Fclass = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fclass + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Fneg_classes = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fneg_classes + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Fbackref = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fbackref + if (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Ftags == UintptrFromInt32(0) { + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Ftags = UintptrFromInt32(0) } else { i = 0 for { - if !(*(*int32)(unsafe.Pointer((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Ftags + uintptr(i)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Ftags + uintptr(i)*4)) >= 0) { break } goto _9 @@ -131189,21 +131189,21 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u if !(j < i) { break } - *(*int32)(unsafe.Pointer(new_tags + uintptr(j)*4)) = *(*int32)(unsafe.Pointer((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Ftags + uintptr(j)*4)) + **(**int32)(__ccgo_up(new_tags + uintptr(j)*4)) = **(**int32)(__ccgo_up((**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Ftags + uintptr(j)*4)) goto _10 _10: ; j = j + 1 } - *(*int32)(unsafe.Pointer(new_tags + uintptr(j)*4)) = -int32(1) - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Ftags = new_tags + **(**int32)(__ccgo_up(new_tags + uintptr(j)*4)) = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Ftags = new_tags } goto _8 _8: ; s2 = s2 + 1 } - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fposition = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Fposition = -int32(1) return new_set } @@ -131221,7 +131221,7 @@ func _tre_match_empty(tls *TLS, stack uintptr, node uintptr, tags uintptr, asser bottom = _tre_stack_num_objects(tls, stack) status = REG_OK if num_tags_seen != 0 { - *(*int32)(unsafe.Pointer(num_tags_seen)) = 0 + **(**int32)(__ccgo_up(num_tags_seen)) = 0 } status = _tre_stack_push_voidptr(tls, stack, node) /* Walk through the tree recursively. */ @@ -131237,10 +131237,10 @@ func _tre_match_empty(tls *TLS, stack uintptr, node uintptr, tags uintptr, asser /* Add the tag to `tags'. */ i = 0 for { - if !(*(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(tags + uintptr(i)*4)) >= 0) { break } - if int64(*(*int32)(unsafe.Pointer(tags + uintptr(i)*4))) == (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max { + if int64(**(**int32)(__ccgo_up(tags + uintptr(i)*4))) == (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max { break } goto _1 @@ -131248,13 +131248,13 @@ func _tre_match_empty(tls *TLS, stack uintptr, node uintptr, tags uintptr, asser ; i = i + 1 } - if *(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) < 0 { - *(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) = int32((*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max) - *(*int32)(unsafe.Pointer(tags + uintptr(i+int32(1))*4)) = -int32(1) + if **(**int32)(__ccgo_up(tags + uintptr(i)*4)) < 0 { + **(**int32)(__ccgo_up(tags + uintptr(i)*4)) = int32((*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max) + **(**int32)(__ccgo_up(tags + uintptr(i+int32(1))*4)) = -int32(1) } } if num_tags_seen != 0 { - *(*int32)(unsafe.Pointer(num_tags_seen)) = *(*int32)(unsafe.Pointer(num_tags_seen)) + 1 + **(**int32)(__ccgo_up(num_tags_seen)) = **(**int32)(__ccgo_up(num_tags_seen)) + 1 } } case int64(-int32(2)): @@ -131498,12 +131498,12 @@ func _tre_compute_nfl(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr) (r return status } /* Allocate arrays for the tags and parameters. */ - tags = Xmalloc(tls, uint64(4)*Uint64FromInt32(*(*int32)(unsafe.Pointer(bp))+Int32FromInt32(1))) + tags = Xmalloc(tls, uint64(4)*Uint64FromInt32(**(**int32)(__ccgo_up(bp))+Int32FromInt32(1))) if !(tags != 0) { return int32(REG_ESPACE) } - *(*int32)(unsafe.Pointer(tags)) = -int32(1) - *(*int32)(unsafe.Pointer(bp + 4)) = 0 + **(**int32)(__ccgo_up(tags)) = -int32(1) + **(**int32)(__ccgo_up(bp + 4)) = 0 /* Second pass with tre_mach_empty() to get the list of tags and parameters. */ status = _tre_match_empty(tls, stack, (*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft, tags, bp+4, UintptrFromInt32(0)) @@ -131511,7 +131511,7 @@ func _tre_compute_nfl(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr) (r Xfree(tls, tags) return status } - (*Ttre_ast_node_t)(unsafe.Pointer(node)).Ffirstpos = _tre_set_union(tls, mem, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright)).Ffirstpos, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft)).Ffirstpos, tags, *(*int32)(unsafe.Pointer(bp + 4))) + (*Ttre_ast_node_t)(unsafe.Pointer(node)).Ffirstpos = _tre_set_union(tls, mem, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright)).Ffirstpos, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft)).Ffirstpos, tags, **(**int32)(__ccgo_up(bp + 4))) Xfree(tls, tags) if !((*Ttre_ast_node_t)(unsafe.Pointer(node)).Ffirstpos != 0) { return int32(REG_ESPACE) @@ -131529,12 +131529,12 @@ func _tre_compute_nfl(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr) (r return status } /* Allocate arrays for the tags and parameters. */ - tags = Xmalloc(tls, uint64(4)*Uint64FromInt32(*(*int32)(unsafe.Pointer(bp))+Int32FromInt32(1))) + tags = Xmalloc(tls, uint64(4)*Uint64FromInt32(**(**int32)(__ccgo_up(bp))+Int32FromInt32(1))) if !(tags != 0) { return int32(REG_ESPACE) } - *(*int32)(unsafe.Pointer(tags)) = -int32(1) - *(*int32)(unsafe.Pointer(bp + 4)) = 0 + **(**int32)(__ccgo_up(tags)) = -int32(1) + **(**int32)(__ccgo_up(bp + 4)) = 0 /* Second pass with tre_mach_empty() to get the list of tags and parameters. */ status = _tre_match_empty(tls, stack, (*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright, tags, bp+4, UintptrFromInt32(0)) @@ -131542,7 +131542,7 @@ func _tre_compute_nfl(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr) (r Xfree(tls, tags) return status } - (*Ttre_ast_node_t)(unsafe.Pointer(node)).Flastpos = _tre_set_union(tls, mem, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft)).Flastpos, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright)).Flastpos, tags, *(*int32)(unsafe.Pointer(bp + 4))) + (*Ttre_ast_node_t)(unsafe.Pointer(node)).Flastpos = _tre_set_union(tls, mem, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft)).Flastpos, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright)).Flastpos, tags, **(**int32)(__ccgo_up(bp + 4))) Xfree(tls, tags) if !((*Ttre_ast_node_t)(unsafe.Pointer(node)).Flastpos != 0) { return int32(REG_ESPACE) @@ -131578,7 +131578,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun prev_p2_pos = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fposition /* Set `trans' to point to the next unused transition from position `p1->position'. */ - trans = transitions + uintptr(*(*int32)(unsafe.Pointer(offs + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)))*56 + trans = transitions + uintptr(**(**int32)(__ccgo_up(offs + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)))*56 for (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fstate != UintptrFromInt32(0) { trans += 56 } @@ -131589,7 +131589,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun the transition from `p1' to `p2'. */ (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fcode_min = Uint32FromInt32((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fcode_min) (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fcode_max = Uint32FromInt32((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fcode_max) - (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fstate = transitions + uintptr(*(*int32)(unsafe.Pointer(offs + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fposition)*4)))*56 + (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fstate = transitions + uintptr(**(**int32)(__ccgo_up(offs + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fposition)*4)))*56 (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fstate_id = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fposition if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fclass != 0 { v1 = int32(ASSERT_CHAR_CLASS) @@ -131604,14 +131604,14 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fassertions = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fassertions | (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fassertions | v1 | v2 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fbackref >= 0 { *(*int32)(unsafe.Pointer(&(*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fu)) = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fbackref - *(*int32)(unsafe.Pointer(trans + 32)) |= int32(ASSERT_BACKREF) + **(**int32)(__ccgo_up(trans + 32)) |= int32(ASSERT_BACKREF) } else { *(*Ttre_ctype_t)(unsafe.Pointer(trans + 40)) = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fclass } if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes != UintptrFromInt32(0) { i = 0 for { - if !(*(*Ttre_ctype_t)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes + uintptr(i)*8)) != Uint64FromInt32(0)) { + if !(**(**Ttre_ctype_t)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes + uintptr(i)*8)) != Uint64FromInt32(0)) { break } goto _3 @@ -131625,29 +131625,29 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun } i = 0 for { - if !(*(*Ttre_ctype_t)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes + uintptr(i)*8)) != Uint64FromInt32(0)) { + if !(**(**Ttre_ctype_t)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes + uintptr(i)*8)) != Uint64FromInt32(0)) { break } - *(*Ttre_ctype_t)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes + uintptr(i)*8)) = *(*Ttre_ctype_t)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes + uintptr(i)*8)) + **(**Ttre_ctype_t)(__ccgo_up((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes + uintptr(i)*8)) = **(**Ttre_ctype_t)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes + uintptr(i)*8)) goto _4 _4: ; i = i + 1 } - *(*Ttre_ctype_t)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes + uintptr(i)*8)) = Uint64FromInt32(0) + **(**Ttre_ctype_t)(__ccgo_up((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes + uintptr(i)*8)) = Uint64FromInt32(0) } else { (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes = UintptrFromInt32(0) } /* Find out how many tags this transition has. */ i = 0 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags != UintptrFromInt32(0) { - for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) >= 0 { + for **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) >= 0 { i = i + 1 } } j = 0 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags != UintptrFromInt32(0) { - for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) >= 0 { + for **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) >= 0 { j = j + 1 } } @@ -131664,15 +131664,15 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun } i = 0 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags != UintptrFromInt32(0) { - for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) >= 0 { - *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(i)*4)) = *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) + for **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) >= 0 { + **(**int32)(__ccgo_up((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(i)*4)) = **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) i = i + 1 } } l = i j = 0 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags != UintptrFromInt32(0) { - for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) >= 0 { + for **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) >= 0 { /* Don't add duplicates. */ dup = 0 k = 0 @@ -131680,7 +131680,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun if !(k < i) { break } - if *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(k)*4)) == *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) { + if **(**int32)(__ccgo_up((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(k)*4)) == **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) { dup = int32(1) break } @@ -131692,12 +131692,12 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun if !(dup != 0) { v1 = l l = l + 1 - *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(v1)*4)) = *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) + **(**int32)(__ccgo_up((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(v1)*4)) = **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) } j = j + 1 } } - *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(l)*4)) = -int32(1) + **(**int32)(__ccgo_up((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(l)*4)) = -int32(1) } p2 += 56 } @@ -131709,7 +131709,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun for (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition >= 0 { p2 = orig_p2 for (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fposition >= 0 { - *(*int32)(unsafe.Pointer(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)) = *(*int32)(unsafe.Pointer(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)) + 1 + **(**int32)(__ccgo_up(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)) = **(**int32)(__ccgo_up(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)) + 1 p2 += 56 } p1 += 56 @@ -131800,11 +131800,11 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { } /* Parse the regexp. */ Xmemset(tls, bp, 0, uint64(56)) - (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fmem = mem - (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fstack = stack - (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fstart = regex - (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fcflags = cflags - (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fmax_backref = -int32(1) + (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fmem = mem + (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fstack = stack + (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fstart = regex + (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fcflags = cflags + (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fmax_backref = -int32(1) errcode = _tre_parse(tls, bp) if errcode != REG_OK { errcode = errcode @@ -131812,10 +131812,10 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { goto error_exit } } - (*Tregex_t)(unsafe.Pointer(preg)).Fre_nsub = Uint64FromInt32((*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fsubmatch_id - int32(1)) - tree = (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fn + (*Tregex_t)(unsafe.Pointer(preg)).Fre_nsub = Uint64FromInt32((**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fsubmatch_id - int32(1)) + tree = (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fn /* Referring to nonexistent subexpressions is illegal. */ - if (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fmax_backref > Int32FromUint64((*Tregex_t)(unsafe.Pointer(preg)).Fre_nsub) { + if (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fmax_backref > Int32FromUint64((*Tregex_t)(unsafe.Pointer(preg)).Fre_nsub) { errcode = int32(REG_ESUBREG) if int32(1) != 0 { goto error_exit @@ -131829,9 +131829,9 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { goto error_exit } } - (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fhave_backrefs = BoolInt32((*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fmax_backref >= 0) + (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fhave_backrefs = BoolInt32((**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fmax_backref >= 0) (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fhave_approx = 0 - (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches = Uint32FromInt32((*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fsubmatch_id) + (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches = Uint32FromInt32((**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fsubmatch_id) /* Set up tags for submatch addressing. If REG_NOSUB is set and the regexp does not have back references, this can be skipped. */ if (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fhave_backrefs != 0 || !(cflags&Int32FromInt32(REG_NOSUB) != 0) { @@ -131861,7 +131861,7 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { goto error_exit } } - submatch_data = Xcalloc(tls, uint64(Uint32FromInt32((*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fsubmatch_id)), uint64(16)) + submatch_data = Xcalloc(tls, uint64(Uint32FromInt32((**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fsubmatch_id)), uint64(16)) if submatch_data == UintptrFromInt32(0) { errcode = int32(REG_ESPACE) if int32(1) != 0 { @@ -131914,14 +131914,14 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { goto error_exit } } - counts = Xmalloc(tls, uint64(4)*Uint64FromInt32((*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fposition)) + counts = Xmalloc(tls, uint64(4)*Uint64FromInt32((**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fposition)) if counts == UintptrFromInt32(0) { errcode = int32(REG_ESPACE) if int32(1) != 0 { goto error_exit } } - offs = Xmalloc(tls, uint64(4)*Uint64FromInt32((*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fposition)) + offs = Xmalloc(tls, uint64(4)*Uint64FromInt32((**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fposition)) if offs == UintptrFromInt32(0) { errcode = int32(REG_ESPACE) if int32(1) != 0 { @@ -131930,10 +131930,10 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { } i = 0 for { - if !(i < (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fposition) { + if !(i < (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fposition) { break } - *(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) = 0 + **(**int32)(__ccgo_up(counts + uintptr(i)*4)) = 0 goto _3 _3: ; @@ -131943,12 +131943,12 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { add = 0 i = 0 for { - if !(i < (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fposition) { + if !(i < (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fposition) { break } - *(*int32)(unsafe.Pointer(offs + uintptr(i)*4)) = add - add = add + (*(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) + int32(1)) - *(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) = 0 + **(**int32)(__ccgo_up(offs + uintptr(i)*4)) = add + add = add + (**(**int32)(__ccgo_up(counts + uintptr(i)*4)) + int32(1)) + **(**int32)(__ccgo_up(counts + uintptr(i)*4)) = 0 goto _4 _4: ; @@ -131991,15 +131991,15 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { if !((*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fposition >= 0) { break } - (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Fstate = transitions + uintptr(*(*int32)(unsafe.Pointer(offs + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fposition)*4)))*56 - (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Fstate_id = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fposition - (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Ftags = UintptrFromInt32(0) + (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*56))).Fstate = transitions + uintptr(**(**int32)(__ccgo_up(offs + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fposition)*4)))*56 + (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*56))).Fstate_id = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fposition + (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*56))).Ftags = UintptrFromInt32(0) /* Copy the arrays p->tags, and p->params, they are allocated from a tre_mem object. */ if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Ftags != 0 { j = 0 for { - if !(*(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Ftags + uintptr(j)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Ftags + uintptr(j)*4)) >= 0) { break } goto _6 @@ -132007,26 +132007,26 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { ; j = j + 1 } - (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Ftags = Xmalloc(tls, uint64(4)*Uint64FromInt32(j+Int32FromInt32(1))) - if !((*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Ftags != 0) { + (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*56))).Ftags = Xmalloc(tls, uint64(4)*Uint64FromInt32(j+Int32FromInt32(1))) + if !((**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*56))).Ftags != 0) { errcode = int32(REG_ESPACE) if int32(1) != 0 { goto error_exit } } - Xmemcpy(tls, (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Ftags, (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Ftags, uint64(4)*Uint64FromInt32(j+Int32FromInt32(1))) + Xmemcpy(tls, (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*56))).Ftags, (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Ftags, uint64(4)*Uint64FromInt32(j+Int32FromInt32(1))) } - (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Fassertions = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fassertions + (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*56))).Fassertions = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fassertions i = i + 1 goto _5 _5: ; p += 56 } - (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Fstate = UintptrFromInt32(0) + (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*56))).Fstate = UintptrFromInt32(0) (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_transitions = Uint32FromInt32(add) - (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ffinal = transitions + uintptr(*(*int32)(unsafe.Pointer(offs + uintptr((*(*Ttre_pos_and_tags_t)(unsafe.Pointer((*Ttre_ast_node_t)(unsafe.Pointer(tree)).Flastpos))).Fposition)*4)))*56 - (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_states = (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fposition + (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ffinal = transitions + uintptr(**(**int32)(__ccgo_up(offs + uintptr((**(**Ttre_pos_and_tags_t)(__ccgo_up((*Ttre_ast_node_t)(unsafe.Pointer(tree)).Flastpos))).Fposition)*4)))*56 + (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_states = (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fposition (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags = cflags X__tre_mem_destroy(tls, mem) _tre_stack_destroy(tls, stack) @@ -132069,12 +132069,12 @@ func Xregfree(tls *TLS, preg uintptr) { if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_transitions) { break } - if (*(*Ttre_tnfa_transition_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Fstate != 0 { - if (*(*Ttre_tnfa_transition_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Ftags != 0 { - Xfree(tls, (*(*Ttre_tnfa_transition_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Ftags) + if (**(**Ttre_tnfa_transition_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Fstate != 0 { + if (**(**Ttre_tnfa_transition_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Ftags != 0 { + Xfree(tls, (**(**Ttre_tnfa_transition_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Ftags) } - if (*(*Ttre_tnfa_transition_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Fneg_classes != 0 { - Xfree(tls, (*(*Ttre_tnfa_transition_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Fneg_classes) + if (**(**Ttre_tnfa_transition_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Fneg_classes != 0 { + Xfree(tls, (**(**Ttre_tnfa_transition_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Fneg_classes) } } goto _1 @@ -132107,8 +132107,8 @@ func Xregfree(tls *TLS, preg uintptr) { if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches) { break } - if (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(i)*16))).Fparents != 0 { - Xfree(tls, (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(i)*16))).Fparents) + if (**(**Ttre_submatch_data_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(i)*16))).Fparents != 0 { + Xfree(tls, (**(**Ttre_submatch_data_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(i)*16))).Fparents) } goto _3 _3: @@ -132148,7 +132148,7 @@ func Xregerror(tls *TLS, e int32, preg uintptr, buf uintptr, size Tsize_t) (r Ts _ = s s = uintptr(unsafe.Pointer(&_messages)) for { - if !(e != 0 && *(*int8)(unsafe.Pointer(s)) != 0) { + if !(e != 0 && **(**int8)(__ccgo_up(s)) != 0) { break } goto _1 @@ -132157,7 +132157,7 @@ func Xregerror(tls *TLS, e int32, preg uintptr, buf uintptr, size Tsize_t) (r Ts e = e - 1 s = s + uintptr(_strlen(tls, s)+uint64(1)) } - if !(*(*int8)(unsafe.Pointer(s)) != 0) { + if !(**(**int8)(__ccgo_up(s)) != 0) { s = s + 1 } s = X__lctrans_cur(tls, s) @@ -132183,18 +132183,18 @@ func _tre_tag_order(tls *TLS, num_tags int32, tag_directions uintptr, t1 uintptr if !(i < num_tags) { break } - if *(*Ttre_tag_direction_t)(unsafe.Pointer(tag_directions + uintptr(i)*4)) == int32(_TRE_TAG_MINIMIZE) { - if *(*Tregoff_t)(unsafe.Pointer(t1 + uintptr(i)*8)) < *(*Tregoff_t)(unsafe.Pointer(t2 + uintptr(i)*8)) { + if **(**Ttre_tag_direction_t)(__ccgo_up(tag_directions + uintptr(i)*4)) == int32(_TRE_TAG_MINIMIZE) { + if **(**Tregoff_t)(__ccgo_up(t1 + uintptr(i)*8)) < **(**Tregoff_t)(__ccgo_up(t2 + uintptr(i)*8)) { return int32(1) } - if *(*Tregoff_t)(unsafe.Pointer(t1 + uintptr(i)*8)) > *(*Tregoff_t)(unsafe.Pointer(t2 + uintptr(i)*8)) { + if **(**Tregoff_t)(__ccgo_up(t1 + uintptr(i)*8)) > **(**Tregoff_t)(__ccgo_up(t2 + uintptr(i)*8)) { return 0 } } else { - if *(*Tregoff_t)(unsafe.Pointer(t1 + uintptr(i)*8)) > *(*Tregoff_t)(unsafe.Pointer(t2 + uintptr(i)*8)) { + if **(**Tregoff_t)(__ccgo_up(t1 + uintptr(i)*8)) > **(**Tregoff_t)(__ccgo_up(t2 + uintptr(i)*8)) { return int32(1) } - if *(*Tregoff_t)(unsafe.Pointer(t1 + uintptr(i)*8)) < *(*Tregoff_t)(unsafe.Pointer(t2 + uintptr(i)*8)) { + if **(**Tregoff_t)(__ccgo_up(t1 + uintptr(i)*8)) < **(**Tregoff_t)(__ccgo_up(t2 + uintptr(i)*8)) { return 0 } } @@ -132208,8 +132208,8 @@ func _tre_tag_order(tls *TLS, num_tags int32, tag_directions uintptr, t1 uintptr } func _tre_neg_char_classes_match(tls *TLS, classes uintptr, wc Ttre_cint_t, icase int32) (r int32) { - for *(*Ttre_ctype_t)(unsafe.Pointer(classes)) != Uint64FromInt32(0) { - if !(icase != 0) && Xiswctype(tls, wc, *(*Ttre_ctype_t)(unsafe.Pointer(classes))) != 0 || icase != 0 && (Xiswctype(tls, Xtowupper(tls, wc), *(*Ttre_ctype_t)(unsafe.Pointer(classes))) != 0 || Xiswctype(tls, Xtowlower(tls, wc), *(*Ttre_ctype_t)(unsafe.Pointer(classes))) != 0) { + for **(**Ttre_ctype_t)(__ccgo_up(classes)) != Uint64FromInt32(0) { + if !(icase != 0) && Xiswctype(tls, wc, **(**Ttre_ctype_t)(__ccgo_up(classes))) != 0 || icase != 0 && (Xiswctype(tls, Xtowupper(tls, wc), **(**Ttre_ctype_t)(__ccgo_up(classes))) != 0 || Xiswctype(tls, Xtowlower(tls, wc), **(**Ttre_ctype_t)(__ccgo_up(classes))) != 0) { return int32(1) } else { classes += 8 @@ -132262,7 +132262,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = buf, end, i, match_eo, new_match, num_tags, pbytes, pos, pos_add_next, prev_c, rbytes, reach, reach_i, reach_next, reach_next_i, reach_pos, reg_newline, reg_notbol, reg_noteol, ret, skip, start, str_byte, tag_i, tbytes, tmp_buf, tmp_iptr, tmp_tags, total_bytes, trans_i, xbytes, v1, v18, v7 /* State variables required by GET_NEXT_WCHAR. */ prev_c = 0 - *(*Ttre_char_t)(unsafe.Pointer(bp)) = 0 + **(**Ttre_char_t)(__ccgo_up(bp)) = 0 str_byte = string1 pos = int64(-int32(1)) pos_add_next = int64(1) @@ -132342,9 +132342,9 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_states) { break } - (*(*Ttre_tnfa_reach_t)(unsafe.Pointer(reach + uintptr(i)*16))).Ftags = tmp_buf + (**(**Ttre_tnfa_reach_t)(__ccgo_up(reach + uintptr(i)*16))).Ftags = tmp_buf tmp_buf = tmp_buf + uintptr(xbytes) - (*(*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next + uintptr(i)*16))).Ftags = tmp_buf + (**(**Ttre_tnfa_reach_t)(__ccgo_up(reach_next + uintptr(i)*16))).Ftags = tmp_buf tmp_buf = tmp_buf + uintptr(xbytes) goto _5 _5: @@ -132356,13 +132356,13 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_states) { break } - (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr(i)*16))).Fpos = int64(-int32(1)) + (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr(i)*16))).Fpos = int64(-int32(1)) goto _6 _6: ; i = i + 1 } - prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + prev_c = **(**Ttre_char_t)(__ccgo_up(bp)) pos = pos + pos_add_next v7 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) pos_add_next = v7 @@ -132382,8 +132382,8 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if match_eo < 0 { trans_i = (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Finitial for (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate != UintptrFromInt32(0) { - if (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos < pos { - if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\000') || reg_noteol != 0) && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0 || !(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) || (*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && *(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\000') && BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) == BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || *(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('\000') || BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) != BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0))) { + if (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos < pos { + if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (**(**Ttre_char_t)(__ccgo_up(bp)) != int32('\000') || reg_noteol != 0) && (**(**Ttre_char_t)(__ccgo_up(bp)) != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0 || !(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) || (**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && **(**Ttre_char_t)(__ccgo_up(bp)) != int32('\000') && BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) == BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || **(**Ttre_char_t)(__ccgo_up(bp)) == int32('\000') || BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) != BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0))) { trans_i += 56 continue } @@ -132393,7 +132393,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < num_tags) { break } - *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(i)*8)) = int64(-int32(1)) + **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(i)*8)) = int64(-int32(1)) goto _8 _8: ; @@ -132401,9 +132401,9 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags } tag_i = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags if tag_i != 0 { - for *(*int32)(unsafe.Pointer(tag_i)) >= 0 { - if *(*int32)(unsafe.Pointer(tag_i)) < num_tags { - *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(*(*int32)(unsafe.Pointer(tag_i)))*8)) = pos + for **(**int32)(__ccgo_up(tag_i)) >= 0 { + if **(**int32)(__ccgo_up(tag_i)) < num_tags { + **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(**(**int32)(__ccgo_up(tag_i)))*8)) = pos } tag_i += 4 } @@ -132416,15 +132416,15 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < num_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(i)*8)) = *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(i)*8)) + **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(i)*8)) = **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(i)*8)) goto _9 _9: ; i = i + 1 } } - (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos = pos - (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags = reach_next_i + 8 + (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos = pos + (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags = reach_next_i + 8 reach_next_i += 16 } trans_i += 56 @@ -132437,10 +132437,10 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags } } /* Check for end of string. */ - if !(*(*Ttre_char_t)(unsafe.Pointer(bp)) != 0) { + if !(**(**Ttre_char_t)(__ccgo_up(bp)) != 0) { break } - prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + prev_c = **(**Ttre_char_t)(__ccgo_up(bp)) pos = pos + pos_add_next v7 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) pos_add_next = v7 @@ -132470,16 +132470,16 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags skip = 0 i = 0 for { - if !(*(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i)*4)) >= 0) { break } - end = *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i)*4)) - start = *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i+int32(1))*4)) + end = **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i)*4)) + start = **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i+int32(1))*4)) if end >= num_tags { skip = int32(1) break } else { - if *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Ftags + uintptr(start)*8)) == *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(start)*8)) && *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Ftags + uintptr(end)*8)) < *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(end)*8)) { + if **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Ftags + uintptr(start)*8)) == **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(start)*8)) && **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Ftags + uintptr(end)*8)) < **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(end)*8)) { skip = int32(1) break } @@ -132523,7 +132523,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags } /* Does this transition match the input symbol? */ if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fcode_min <= Uint32FromInt32(prev_c) && (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fcode_max >= Uint32FromInt32(prev_c) { - if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\000') || reg_noteol != 0) && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0 || !(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) || (*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && *(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\000') && BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) == BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || *(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('\000') || BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) != BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && !((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&Int32FromInt32(REG_ICASE) != 0) && !(Xiswctype(tls, Uint32FromInt32(prev_c), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE) != 0 && !(Xiswctype(tls, Xtowlower(tls, Uint32FromInt32(prev_c)), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) && !(Xiswctype(tls, Xtowupper(tls, Uint32FromInt32(prev_c)), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS_NEG) != 0 && _tre_neg_char_classes_match(tls, (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fneg_classes, Uint32FromInt32(prev_c), (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE)) != 0)) { + if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (**(**Ttre_char_t)(__ccgo_up(bp)) != int32('\000') || reg_noteol != 0) && (**(**Ttre_char_t)(__ccgo_up(bp)) != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0 || !(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) || (**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && **(**Ttre_char_t)(__ccgo_up(bp)) != int32('\000') && BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) == BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || **(**Ttre_char_t)(__ccgo_up(bp)) == int32('\000') || BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) != BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && !((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&Int32FromInt32(REG_ICASE) != 0) && !(Xiswctype(tls, Uint32FromInt32(prev_c), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE) != 0 && !(Xiswctype(tls, Xtowlower(tls, Uint32FromInt32(prev_c)), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) && !(Xiswctype(tls, Xtowupper(tls, Uint32FromInt32(prev_c)), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS_NEG) != 0 && _tre_neg_char_classes_match(tls, (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fneg_classes, Uint32FromInt32(prev_c), (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE)) != 0)) { goto _14 } /* Compute the tags after this transition. */ @@ -132532,7 +132532,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < num_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(tmp_tags + uintptr(i)*8)) = *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Ftags + uintptr(i)*8)) + **(**Tregoff_t)(__ccgo_up(tmp_tags + uintptr(i)*8)) = **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Ftags + uintptr(i)*8)) goto _15 _15: ; @@ -132540,22 +132540,22 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags } tag_i = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags if tag_i != UintptrFromInt32(0) { - for *(*int32)(unsafe.Pointer(tag_i)) >= 0 { - if *(*int32)(unsafe.Pointer(tag_i)) < num_tags { - *(*Tregoff_t)(unsafe.Pointer(tmp_tags + uintptr(*(*int32)(unsafe.Pointer(tag_i)))*8)) = pos + for **(**int32)(__ccgo_up(tag_i)) >= 0 { + if **(**int32)(__ccgo_up(tag_i)) < num_tags { + **(**Tregoff_t)(__ccgo_up(tmp_tags + uintptr(**(**int32)(__ccgo_up(tag_i)))*8)) = pos } tag_i += 4 } } - if (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos < pos { + if (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos < pos { /* Found an unvisited node. */ (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Fstate = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate tmp_iptr = (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags = tmp_tags tmp_tags = tmp_iptr - (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos = pos - (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags = reach_next_i + 8 - if (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Fstate == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ffinal && (match_eo == int64(-int32(1)) || num_tags > 0 && *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags)) <= *(*Tregoff_t)(unsafe.Pointer(match_tags))) { + (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos = pos + (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags = reach_next_i + 8 + if (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Fstate == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ffinal && (match_eo == int64(-int32(1)) || num_tags > 0 && **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags)) <= **(**Tregoff_t)(__ccgo_up(match_tags))) { match_eo = pos new_match = int32(1) i = 0 @@ -132563,7 +132563,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < num_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(i)*8)) = *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(i)*8)) + **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(i)*8)) = **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(i)*8)) goto _16 _16: ; @@ -132575,10 +132575,10 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags /* Another path has also reached this state. We choose the winner by examining the tag values for both paths. */ - if _tre_tag_order(tls, num_tags, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions, tmp_tags, *(*uintptr)(unsafe.Pointer((*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags))) != 0 { + if _tre_tag_order(tls, num_tags, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions, tmp_tags, **(**uintptr)(__ccgo_up((**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags))) != 0 { /* The new path wins. */ - tmp_iptr = *(*uintptr)(unsafe.Pointer((*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags)) - *(*uintptr)(unsafe.Pointer((*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags)) = tmp_tags + tmp_iptr = **(**uintptr)(__ccgo_up((**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags)) + **(**uintptr)(__ccgo_up((**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags)) = tmp_tags if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ffinal { match_eo = pos new_match = int32(1) @@ -132587,7 +132587,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < num_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(i)*8)) = *(*Tregoff_t)(unsafe.Pointer(tmp_tags + uintptr(i)*8)) + **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(i)*8)) = **(**Tregoff_t)(__ccgo_up(tmp_tags + uintptr(i)*8)) goto _17 _17: ; @@ -132610,7 +132610,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags } (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Fstate = UintptrFromInt32(0) } - *(*Tregoff_t)(unsafe.Pointer(match_end_ofs)) = match_eo + **(**Tregoff_t)(__ccgo_up(match_end_ofs)) = match_eo if match_eo >= 0 { v18 = REG_OK } else { @@ -132681,7 +132681,7 @@ func _tre_tnfa_run_backtrack(tls *TLS, tnfa uintptr, string1 uintptr, match_tags _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bt, bt_len, empty_br_match, eo, i, i1, i2, i3, i4, match_eo, mem, next_c_start, next_state, next_tags, pmatch, pos, pos_add_next, pos_start, prev_c, reg_newline, reg_notbol, reg_noteol, result, ret, s, s1, so, stack, state, states_seen, str_byte, str_byte_start, tags, tmp, tmp1, trans_i, v20, v3, v6 /* State variables required by GET_NEXT_WCHAR. */ prev_c = 0 - *(*Ttre_char_t)(unsafe.Pointer(bp)) = 0 + **(**Ttre_char_t)(__ccgo_up(bp)) = 0 str_byte = string1 pos = 0 pos_add_next = int64(1) @@ -132735,9 +132735,9 @@ retry: if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(i)*8)) = int64(-int32(1)) + **(**Tregoff_t)(__ccgo_up(tags + uintptr(i)*8)) = int64(-int32(1)) if match_tags != 0 { - *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(i)*8)) = int64(-int32(1)) + **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(i)*8)) = int64(-int32(1)) } goto _1 _1: @@ -132749,7 +132749,7 @@ retry: if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_states) { break } - *(*int32)(unsafe.Pointer(states_seen + uintptr(i)*4)) = 0 + **(**int32)(__ccgo_up(states_seen + uintptr(i)*4)) = 0 goto _2 _2: ; @@ -132757,7 +132757,7 @@ retry: } state = UintptrFromInt32(0) pos = pos_start - prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + prev_c = **(**Ttre_char_t)(__ccgo_up(bp)) pos = pos + pos_add_next v3 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) pos_add_next = v3 @@ -132771,7 +132771,7 @@ retry: } str_byte = str_byte + uintptr(pos_add_next) pos_start = pos - next_c_start = *(*Ttre_char_t)(unsafe.Pointer(bp)) + next_c_start = **(**Ttre_char_t)(__ccgo_up(bp)) str_byte_start = str_byte /* Handle initial states. */ next_tags = UintptrFromInt32(0) @@ -132780,7 +132780,7 @@ retry: if !((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate != 0) { break } - if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\000') || reg_noteol != 0) && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0 || !(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) || (*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && *(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\000') && BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) == BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || *(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('\000') || BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) != BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0))) { + if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (**(**Ttre_char_t)(__ccgo_up(bp)) != int32('\000') || reg_noteol != 0) && (**(**Ttre_char_t)(__ccgo_up(bp)) != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0 || !(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) || (**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && **(**Ttre_char_t)(__ccgo_up(bp)) != int32('\000') && BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) == BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || **(**Ttre_char_t)(__ccgo_up(bp)) == int32('\000') || BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) != BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0))) { goto _4 } if state == UintptrFromInt32(0) { @@ -132829,13 +132829,13 @@ retry: (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstr_byte = str_byte (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate_id = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id - (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fnext_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fnext_c = **(**Ttre_char_t)(__ccgo_up(bp)) i1 = 0 for { if !(i1 < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_tags) { break } - *(*Tregoff_t)(unsafe.Pointer((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(i1)*8)) = *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(i1)*8)) + **(**Tregoff_t)(__ccgo_up((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(i1)*8)) = **(**Tregoff_t)(__ccgo_up(tags + uintptr(i1)*8)) goto _5 _5: ; @@ -132843,10 +132843,10 @@ retry: } tmp = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags if tmp != 0 { - for *(*int32)(unsafe.Pointer(tmp)) >= 0 { + for **(**int32)(__ccgo_up(tmp)) >= 0 { v6 = tmp tmp += 4 - *(*Tregoff_t)(unsafe.Pointer((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(*(*int32)(unsafe.Pointer(v6)))*8)) = pos + **(**Tregoff_t)(__ccgo_up((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(**(**int32)(__ccgo_up(v6)))*8)) = pos } } } @@ -132857,10 +132857,10 @@ retry: } if next_tags != 0 { for { - if !(*(*int32)(unsafe.Pointer(next_tags)) >= 0) { + if !(**(**int32)(__ccgo_up(next_tags)) >= 0) { break } - *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(*(*int32)(unsafe.Pointer(next_tags)))*8)) = pos + **(**Tregoff_t)(__ccgo_up(tags + uintptr(**(**int32)(__ccgo_up(next_tags)))*8)) = pos goto _7 _7: ; @@ -132885,7 +132885,7 @@ _9: if !(i2 < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(i2)*8)) = *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(i2)*8)) + **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(i2)*8)) = **(**Tregoff_t)(__ccgo_up(tags + uintptr(i2)*8)) goto _10 _10: ; @@ -132905,8 +132905,8 @@ _9: /* Get the substring we need to match against. Remember to turn off REG_NOSUB temporarily. */ _tre_fill_pmatch(tls, Uint64FromInt32(bt+int32(1)), pmatch, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags & ^Int32FromInt32(REG_NOSUB), tnfa, tags, pos) - so = (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(bt)*16))).Frm_so - eo = (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(bt)*16))).Frm_eo + so = (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(bt)*16))).Frm_so + eo = (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(bt)*16))).Frm_eo bt_len = eo - so result = Xstrncmp(tls, string1+uintptr(so), str_byte-uintptr(1), Uint64FromInt64(bt_len)) if result == 0 { @@ -132914,15 +132914,15 @@ _9: if bt_len == 0 { empty_br_match = int32(1) } - if empty_br_match != 0 && *(*int32)(unsafe.Pointer(states_seen + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*4)) != 0 { + if empty_br_match != 0 && **(**int32)(__ccgo_up(states_seen + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*4)) != 0 { goto backtrack } - *(*int32)(unsafe.Pointer(states_seen + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*4)) = empty_br_match + **(**int32)(__ccgo_up(states_seen + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*4)) = empty_br_match /* Advance in input string and resync `prev_c', `next_c' and pos. */ str_byte = str_byte + uintptr(bt_len-int64(1)) pos = pos + (bt_len - int64(1)) - prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + prev_c = **(**Ttre_char_t)(__ccgo_up(bp)) pos = pos + pos_add_next v3 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) pos_add_next = v3 @@ -132940,11 +132940,11 @@ _9: } } else { /* Check for end of string. */ - if *(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('\000') { + if **(**Ttre_char_t)(__ccgo_up(bp)) == int32('\000') { goto backtrack } /* Read the next character. */ - prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + prev_c = **(**Ttre_char_t)(__ccgo_up(bp)) pos = pos + pos_add_next v3 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) pos_add_next = v3 @@ -132965,7 +132965,7 @@ _9: break } if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fcode_min <= Uint32FromInt32(prev_c) && (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fcode_max >= Uint32FromInt32(prev_c) { - if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\000') || reg_noteol != 0) && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0 || !(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) || (*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && *(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\000') && BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) == BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || *(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('\000') || BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) != BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && !((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&Int32FromInt32(REG_ICASE) != 0) && !(Xiswctype(tls, Uint32FromInt32(prev_c), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE) != 0 && !(Xiswctype(tls, Xtowlower(tls, Uint32FromInt32(prev_c)), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) && !(Xiswctype(tls, Xtowupper(tls, Uint32FromInt32(prev_c)), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS_NEG) != 0 && _tre_neg_char_classes_match(tls, (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fneg_classes, Uint32FromInt32(prev_c), (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE)) != 0)) { + if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (**(**Ttre_char_t)(__ccgo_up(bp)) != int32('\000') || reg_noteol != 0) && (**(**Ttre_char_t)(__ccgo_up(bp)) != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0 || !(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) || (**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && **(**Ttre_char_t)(__ccgo_up(bp)) != int32('\000') && BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) == BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || **(**Ttre_char_t)(__ccgo_up(bp)) == int32('\000') || BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) != BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && !((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&Int32FromInt32(REG_ICASE) != 0) && !(Xiswctype(tls, Uint32FromInt32(prev_c), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE) != 0 && !(Xiswctype(tls, Xtowlower(tls, Uint32FromInt32(prev_c)), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) && !(Xiswctype(tls, Xtowupper(tls, Uint32FromInt32(prev_c)), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS_NEG) != 0 && _tre_neg_char_classes_match(tls, (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fneg_classes, Uint32FromInt32(prev_c), (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE)) != 0)) { goto _13 } if next_state == UintptrFromInt32(0) { @@ -133017,13 +133017,13 @@ _9: (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstr_byte = str_byte (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate_id = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id - (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fnext_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fnext_c = **(**Ttre_char_t)(__ccgo_up(bp)) i3 = 0 for { if !(i3 < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_tags) { break } - *(*Tregoff_t)(unsafe.Pointer((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(i3)*8)) = *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(i3)*8)) + **(**Tregoff_t)(__ccgo_up((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(i3)*8)) = **(**Tregoff_t)(__ccgo_up(tags + uintptr(i3)*8)) goto _14 _14: ; @@ -133031,10 +133031,10 @@ _9: } tmp1 = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags for { - if !(tmp1 != 0 && *(*int32)(unsafe.Pointer(tmp1)) >= 0) { + if !(tmp1 != 0 && **(**int32)(__ccgo_up(tmp1)) >= 0) { break } - *(*Tregoff_t)(unsafe.Pointer((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(*(*int32)(unsafe.Pointer(tmp1)))*8)) = pos + **(**Tregoff_t)(__ccgo_up((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(**(**int32)(__ccgo_up(tmp1)))*8)) = pos goto _15 _15: ; @@ -133054,10 +133054,10 @@ _9: state = next_state /* Update the tag values. */ if next_tags != 0 { - for *(*int32)(unsafe.Pointer(next_tags)) >= 0 { + for **(**int32)(__ccgo_up(next_tags)) >= 0 { v6 = next_tags next_tags += 4 - *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(*(*int32)(unsafe.Pointer(v6)))*8)) = pos + **(**Tregoff_t)(__ccgo_up(tags + uintptr(**(**int32)(__ccgo_up(v6)))*8)) = pos } } goto _17 @@ -133069,18 +133069,18 @@ backtrack: /* A matching transition was not found. Try to backtrack. */ if (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fprev != 0 { if (*Ttre_tnfa_transition_t)(unsafe.Pointer((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate)).Fassertions&int32(ASSERT_BACKREF) != 0 { - *(*int32)(unsafe.Pointer(states_seen + uintptr((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate_id)*4)) = 0 + **(**int32)(__ccgo_up(states_seen + uintptr((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate_id)*4)) = 0 } pos = (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fpos str_byte = (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstr_byte state = (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate - *(*Ttre_char_t)(unsafe.Pointer(bp)) = (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fnext_c + **(**Ttre_char_t)(__ccgo_up(bp)) = (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fnext_c i4 = 0 for { if !(i4 < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(i4)*8)) = *(*Tregoff_t)(unsafe.Pointer((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(i4)*8)) + **(**Tregoff_t)(__ccgo_up(tags + uintptr(i4)*8)) = **(**Tregoff_t)(__ccgo_up((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(i4)*8)) goto _19 _19: ; @@ -133091,10 +133091,10 @@ backtrack: if match_eo < 0 { /* Try starting from a later position in the input string. */ /* Check for end of string. */ - if *(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('\000') { + if **(**Ttre_char_t)(__ccgo_up(bp)) == int32('\000') { goto _8 } - *(*Ttre_char_t)(unsafe.Pointer(bp)) = next_c_start + **(**Ttre_char_t)(__ccgo_up(bp)) = next_c_start str_byte = str_byte_start goto retry } else { @@ -133112,7 +133112,7 @@ _8: v20 = int32(REG_NOMATCH) } ret = v20 - *(*Tregoff_t)(unsafe.Pointer(match_end_ofs)) = match_eo + **(**Tregoff_t)(__ccgo_up(match_end_ofs)) = match_eo goto error_exit error_exit: ; @@ -133147,22 +133147,22 @@ func _tre_fill_pmatch(tls *TLS, nmatch Tsize_t, pmatch uintptr, cflags int32, tn /* Construct submatch offsets from the tags. */ submatch_data = (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data for i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches && uint64(i) < nmatch { - if (*(*Ttre_submatch_data_t)(unsafe.Pointer(submatch_data + uintptr(i)*16))).Fso_tag == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fend_tag { - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = match_eo + if (**(**Ttre_submatch_data_t)(__ccgo_up(submatch_data + uintptr(i)*16))).Fso_tag == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fend_tag { + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_so = match_eo } else { - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = *(*Tregoff_t)(unsafe.Pointer(tags + uintptr((*(*Ttre_submatch_data_t)(unsafe.Pointer(submatch_data + uintptr(i)*16))).Fso_tag)*8)) + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_so = **(**Tregoff_t)(__ccgo_up(tags + uintptr((**(**Ttre_submatch_data_t)(__ccgo_up(submatch_data + uintptr(i)*16))).Fso_tag)*8)) } - if (*(*Ttre_submatch_data_t)(unsafe.Pointer(submatch_data + uintptr(i)*16))).Feo_tag == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fend_tag { - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = match_eo + if (**(**Ttre_submatch_data_t)(__ccgo_up(submatch_data + uintptr(i)*16))).Feo_tag == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fend_tag { + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_eo = match_eo } else { - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = *(*Tregoff_t)(unsafe.Pointer(tags + uintptr((*(*Ttre_submatch_data_t)(unsafe.Pointer(submatch_data + uintptr(i)*16))).Feo_tag)*8)) + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_eo = **(**Tregoff_t)(__ccgo_up(tags + uintptr((**(**Ttre_submatch_data_t)(__ccgo_up(submatch_data + uintptr(i)*16))).Feo_tag)*8)) } /* If either of the endpoints were not used, this submatch was not part of the match. */ - if (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so == int64(-int32(1)) || (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo == int64(-int32(1)) { + if (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_so == int64(-int32(1)) || (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_eo == int64(-int32(1)) { v1 = int64(-Int32FromInt32(1)) - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = v1 - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = v1 + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_eo = v1 + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_so = v1 } i = i + 1 } @@ -133170,19 +133170,19 @@ func _tre_fill_pmatch(tls *TLS, nmatch Tsize_t, pmatch uintptr, cflags int32, tn submatches. */ i = uint32(0) for i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches && uint64(i) < nmatch { - if (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo == int64(-int32(1)) { + if (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_eo == int64(-int32(1)) { } - parents = (*(*Ttre_submatch_data_t)(unsafe.Pointer(submatch_data + uintptr(i)*16))).Fparents + parents = (**(**Ttre_submatch_data_t)(__ccgo_up(submatch_data + uintptr(i)*16))).Fparents if parents != UintptrFromInt32(0) { j = uint32(0) for { - if !(*(*int32)(unsafe.Pointer(parents + uintptr(j)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(parents + uintptr(j)*4)) >= 0) { break } - if (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so < (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(*(*int32)(unsafe.Pointer(parents + uintptr(j)*4)))*16))).Frm_so || (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo > (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(*(*int32)(unsafe.Pointer(parents + uintptr(j)*4)))*16))).Frm_eo { + if (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_so < (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(**(**int32)(__ccgo_up(parents + uintptr(j)*4)))*16))).Frm_so || (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_eo > (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(**(**int32)(__ccgo_up(parents + uintptr(j)*4)))*16))).Frm_eo { v1 = int64(-Int32FromInt32(1)) - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = v1 - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = v1 + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_eo = v1 + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_so = v1 } goto _2 _2: @@ -133194,8 +133194,8 @@ func _tre_fill_pmatch(tls *TLS, nmatch Tsize_t, pmatch uintptr, cflags int32, tn } } for uint64(i) < nmatch { - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = int64(-int32(1)) - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = int64(-int32(1)) + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_so = int64(-int32(1)) + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_eo = int64(-int32(1)) i = i + 1 } } @@ -133236,7 +133236,7 @@ func Xregexec(tls *TLS, preg uintptr, string1 uintptr, nmatch Tsize_t, pmatch ui } if status == REG_OK { /* A match was found, so fill the submatch registers. */ - _tre_fill_pmatch(tls, nmatch, pmatch, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags, tnfa, tags, *(*Tregoff_t)(unsafe.Pointer(bp))) + _tre_fill_pmatch(tls, nmatch, pmatch, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags, tnfa, tags, **(**Tregoff_t)(__ccgo_up(bp))) } if tags != 0 { Xfree(tls, tags) @@ -133354,8 +133354,8 @@ func X__tre_mem_alloc_impl(tls *TLS, mem Ttre_mem_t, provided int32, provided_bl size = size + v1 /* Allocate from current block. */ ptr = (*Ttre_mem_struct)(unsafe.Pointer(mem)).Fptr - *(*uintptr)(unsafe.Pointer(mem + 16)) += uintptr(size) - *(*Tsize_t)(unsafe.Pointer(mem + 24)) -= size + **(**uintptr)(__ccgo_up(mem + 16)) += uintptr(size) + **(**Tsize_t)(__ccgo_up(mem + 24)) -= size /* Set to zero if needed. */ if zero != 0 { Xmemset(tls, ptr, 0, size) @@ -133420,10 +133420,10 @@ func _keyhash(tls *TLS, k uintptr) (r Tsize_t) { _, _, _ = h, p, v1 p = k h = uint64(0) - for *(*uint8)(unsafe.Pointer(p)) != 0 { + for **(**uint8)(__ccgo_up(p)) != 0 { v1 = p p = p + 1 - h = uint64(31)*h + uint64(*(*uint8)(unsafe.Pointer(v1))) + h = uint64(31)*h + uint64(**(**uint8)(__ccgo_up(v1))) } return h } @@ -133476,7 +133476,7 @@ func _resize(tls *TLS, nel Tsize_t, htab uintptr) (r int32) { j = j + 1 i = i + v4 } - *(*TENTRY)(unsafe.Pointer(newe)) = *(*TENTRY)(unsafe.Pointer(e)) + **(**TENTRY)(__ccgo_up(newe)) = **(**TENTRY)(__ccgo_up(e)) } goto _2 _2: @@ -133532,7 +133532,7 @@ func Xhsearch(tls *TLS, item TENTRY, action TACTION) (r uintptr) { defer tls.Free(16) var _ /* e at bp+0 */ uintptr ___hsearch_r(tls, item, action, bp, uintptr(unsafe.Pointer(&_htab))) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func ___hcreate_r(tls *TLS, nel Tsize_t, htab uintptr) (r1 int32) { @@ -133565,14 +133565,14 @@ func ___hsearch_r(tls *TLS, item TENTRY, action TACTION, retval uintptr, htab ui hash = _keyhash(tls, item.Fkey) e = _lookup(tls, item.Fkey, hash, htab) if (*TENTRY)(unsafe.Pointer(e)).Fkey != 0 { - *(*uintptr)(unsafe.Pointer(retval)) = e + **(**uintptr)(__ccgo_up(retval)) = e return int32(1) } if action == int32(_FIND) { - *(*uintptr)(unsafe.Pointer(retval)) = uintptr(0) + **(**uintptr)(__ccgo_up(retval)) = uintptr(0) return 0 } - *(*TENTRY)(unsafe.Pointer(e)) = item + **(**TENTRY)(__ccgo_up(e)) = item v2 = (*Thsearch_data)(unsafe.Pointer(htab)).F__tab + 16 *(*Tsize_t)(unsafe.Pointer(v2)) = *(*Tsize_t)(unsafe.Pointer(v2)) + 1 v1 = *(*Tsize_t)(unsafe.Pointer(v2)) @@ -133580,12 +133580,12 @@ func ___hsearch_r(tls *TLS, item TENTRY, action TACTION, retval uintptr, htab ui if !(_resize(tls, uint64(2)*(*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused, htab) != 0) { (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused = (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused - 1 (*TENTRY)(unsafe.Pointer(e)).Fkey = uintptr(0) - *(*uintptr)(unsafe.Pointer(retval)) = uintptr(0) + **(**uintptr)(__ccgo_up(retval)) = uintptr(0) return 0 } e = _lookup(tls, item.Fkey, hash, htab) } - *(*uintptr)(unsafe.Pointer(retval)) = e + **(**uintptr)(__ccgo_up(retval)) = e return int32(1) } @@ -133645,7 +133645,7 @@ func Xlsearch(tls *TLS, key uintptr, base uintptr, nelp uintptr, width Tsize_t, defer func() {}() v1 = width p = base - n = *(*Tsize_t)(unsafe.Pointer(nelp)) + n = **(**Tsize_t)(__ccgo_up(nelp)) i = uint64(0) for { if !(i < n) { @@ -133659,7 +133659,7 @@ func Xlsearch(tls *TLS, key uintptr, base uintptr, nelp uintptr, width Tsize_t, ; i = i + 1 } - *(*Tsize_t)(unsafe.Pointer(nelp)) = n + uint64(1) + **(**Tsize_t)(__ccgo_up(nelp)) = n + uint64(1) return Xmemcpy(tls, p+uintptr(n)*uintptr(v1), key, width) } @@ -133677,7 +133677,7 @@ func Xlfind(tls *TLS, key uintptr, base uintptr, nelp uintptr, width Tsize_t, __ defer func() {}() v1 = width p = base - n = *(*Tsize_t)(unsafe.Pointer(nelp)) + n = **(**Tsize_t)(__ccgo_up(nelp)) i = uint64(0) for { if !(i < n) { @@ -133716,7 +133716,7 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui if !(rootp != 0) { return uintptr(0) } - n = *(*uintptr)(unsafe.Pointer(rootp)) + n = **(**uintptr)(__ccgo_up(rootp)) i = 0 /* *a[0] is an arbitrary non-null pointer that is returned when the root node is deleted. */ @@ -133737,34 +133737,34 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui v1 = i i = i + 1 a[v1] = n + 8 + BoolUintptr(c > 0)*8 - n = *(*uintptr)(unsafe.Pointer(n + 8 + BoolUintptr(c > 0)*8)) + n = **(**uintptr)(__ccgo_up(n + 8 + BoolUintptr(c > 0)*8)) goto _3 _3: } - parent = *(*uintptr)(unsafe.Pointer(a[i-int32(2)])) - if *(*uintptr)(unsafe.Pointer(n + 8)) != 0 { + parent = **(**uintptr)(__ccgo_up(a[i-int32(2)])) + if **(**uintptr)(__ccgo_up(n + 8)) != 0 { /* free the preceding node instead of the deleted one. */ deleted = n v1 = i i = i + 1 a[v1] = n + 8 - n = *(*uintptr)(unsafe.Pointer(n + 8)) - for *(*uintptr)(unsafe.Pointer(n + 8 + 1*8)) != 0 { + n = **(**uintptr)(__ccgo_up(n + 8)) + for **(**uintptr)(__ccgo_up(n + 8 + 1*8)) != 0 { v1 = i i = i + 1 a[v1] = n + 8 + 1*8 - n = *(*uintptr)(unsafe.Pointer(n + 8 + 1*8)) + n = **(**uintptr)(__ccgo_up(n + 8 + 1*8)) } (*Tnode1)(unsafe.Pointer(deleted)).Fkey = (*Tnode1)(unsafe.Pointer(n)).Fkey - child = *(*uintptr)(unsafe.Pointer(n + 8)) + child = **(**uintptr)(__ccgo_up(n + 8)) } else { - child = *(*uintptr)(unsafe.Pointer(n + 8 + 1*8)) + child = **(**uintptr)(__ccgo_up(n + 8 + 1*8)) } /* freed node has at most one child, move it up and rebalance. */ Xfree(tls, n) i = i - 1 v1 = i - *(*uintptr)(unsafe.Pointer(a[v1])) = child + **(**uintptr)(__ccgo_up(a[v1])) = child for { i = i - 1 v1 = i @@ -133787,8 +133787,8 @@ func Xtdestroy(tls *TLS, root uintptr, __ccgo_fp_freekey uintptr) { if r == uintptr(0) { return } - Xtdestroy(tls, *(*uintptr)(unsafe.Pointer(r + 8)), __ccgo_fp_freekey) - Xtdestroy(tls, *(*uintptr)(unsafe.Pointer(r + 8 + 1*8)), __ccgo_fp_freekey) + Xtdestroy(tls, **(**uintptr)(__ccgo_up(r + 8)), __ccgo_fp_freekey) + Xtdestroy(tls, **(**uintptr)(__ccgo_up(r + 8 + 1*8)), __ccgo_fp_freekey) if __ccgo_fp_freekey != 0 { (*(*func(*TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_freekey})))(tls, (*Tnode1)(unsafe.Pointer(r)).Fkey) } @@ -133808,7 +133808,7 @@ func Xtfind(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r uint if !(rootp != 0) { return uintptr(0) } - n = *(*uintptr)(unsafe.Pointer(rootp)) + n = **(**uintptr)(__ccgo_up(rootp)) for { if !(n != 0) { break @@ -133817,7 +133817,7 @@ func Xtfind(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r uint if !(c != 0) { break } - n = *(*uintptr)(unsafe.Pointer(n + 8 + BoolUintptr(c > 0)*8)) + n = **(**uintptr)(__ccgo_up(n + 8 + BoolUintptr(c > 0)*8)) goto _1 _1: } @@ -133839,11 +133839,11 @@ func _rot(tls *TLS, p uintptr, x uintptr, dir int32) (r int32) { var hx, hz int32 var y, z uintptr _, _, _, _ = hx, hz, y, z - y = *(*uintptr)(unsafe.Pointer(x + 8 + uintptr(dir)*8)) - z = *(*uintptr)(unsafe.Pointer(y + 8 + BoolUintptr(!(dir != 0))*8)) + y = **(**uintptr)(__ccgo_up(x + 8 + uintptr(dir)*8)) + z = **(**uintptr)(__ccgo_up(y + 8 + BoolUintptr(!(dir != 0))*8)) hx = (*Tnode1)(unsafe.Pointer(x)).Fh hz = _height(tls, z) - if hz > _height(tls, *(*uintptr)(unsafe.Pointer(y + 8 + uintptr(dir)*8))) { + if hz > _height(tls, **(**uintptr)(__ccgo_up(y + 8 + uintptr(dir)*8))) { /* * x * / \ dir z @@ -133851,10 +133851,10 @@ func _rot(tls *TLS, p uintptr, x uintptr, dir int32) (r int32) { * z D /| | * / \ A B C D * B C */ - *(*uintptr)(unsafe.Pointer(x + 8 + uintptr(dir)*8)) = *(*uintptr)(unsafe.Pointer(z + 8 + BoolUintptr(!(dir != 0))*8)) - *(*uintptr)(unsafe.Pointer(y + 8 + BoolUintptr(!(dir != 0))*8)) = *(*uintptr)(unsafe.Pointer(z + 8 + uintptr(dir)*8)) - *(*uintptr)(unsafe.Pointer(z + 8 + BoolUintptr(!(dir != 0))*8)) = x - *(*uintptr)(unsafe.Pointer(z + 8 + uintptr(dir)*8)) = y + **(**uintptr)(__ccgo_up(x + 8 + uintptr(dir)*8)) = **(**uintptr)(__ccgo_up(z + 8 + BoolUintptr(!(dir != 0))*8)) + **(**uintptr)(__ccgo_up(y + 8 + BoolUintptr(!(dir != 0))*8)) = **(**uintptr)(__ccgo_up(z + 8 + uintptr(dir)*8)) + **(**uintptr)(__ccgo_up(z + 8 + BoolUintptr(!(dir != 0))*8)) = x + **(**uintptr)(__ccgo_up(z + 8 + uintptr(dir)*8)) = y (*Tnode1)(unsafe.Pointer(x)).Fh = hz (*Tnode1)(unsafe.Pointer(y)).Fh = hz (*Tnode1)(unsafe.Pointer(z)).Fh = hz + int32(1) @@ -133864,13 +133864,13 @@ func _rot(tls *TLS, p uintptr, x uintptr, dir int32) (r int32) { * / \ / * A y --> x D * / \ / * z D A z */ - *(*uintptr)(unsafe.Pointer(x + 8 + uintptr(dir)*8)) = z - *(*uintptr)(unsafe.Pointer(y + 8 + BoolUintptr(!(dir != 0))*8)) = x + **(**uintptr)(__ccgo_up(x + 8 + uintptr(dir)*8)) = z + **(**uintptr)(__ccgo_up(y + 8 + BoolUintptr(!(dir != 0))*8)) = x (*Tnode1)(unsafe.Pointer(x)).Fh = hz + int32(1) (*Tnode1)(unsafe.Pointer(y)).Fh = hz + int32(2) z = y } - *(*uintptr)(unsafe.Pointer(p)) = z + **(**uintptr)(__ccgo_up(p)) = z return (*Tnode1)(unsafe.Pointer(z)).Fh - hx } @@ -133885,9 +133885,9 @@ func X__tsearch_balance(tls *TLS, p uintptr) (r int32) { var h0, h1, old, v1 int32 var n uintptr _, _, _, _, _ = h0, h1, n, old, v1 - n = *(*uintptr)(unsafe.Pointer(p)) - h0 = _height(tls, *(*uintptr)(unsafe.Pointer(n + 8))) - h1 = _height(tls, *(*uintptr)(unsafe.Pointer(n + 8 + 1*8))) + n = **(**uintptr)(__ccgo_up(p)) + h0 = _height(tls, **(**uintptr)(__ccgo_up(n + 8))) + h1 = _height(tls, **(**uintptr)(__ccgo_up(n + 8 + 1*8))) if Uint32FromInt32(h0-h1)+uint32(1) < uint32(3) { old = (*Tnode1)(unsafe.Pointer(n)).Fh if h0 < h1 { @@ -133916,7 +133916,7 @@ func Xtsearch(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r1 u if !(rootp != 0) { return uintptr(0) } - n = *(*uintptr)(unsafe.Pointer(rootp)) + n = **(**uintptr)(__ccgo_up(rootp)) i = 0 v1 = i i = i + 1 @@ -133932,7 +133932,7 @@ func Xtsearch(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r1 u v1 = i i = i + 1 a[v1] = n + 8 + BoolUintptr(c > 0)*8 - n = *(*uintptr)(unsafe.Pointer(n + 8 + BoolUintptr(c > 0)*8)) + n = **(**uintptr)(__ccgo_up(n + 8 + BoolUintptr(c > 0)*8)) goto _2 _2: } @@ -133942,13 +133942,13 @@ func Xtsearch(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r1 u } (*Tnode1)(unsafe.Pointer(r)).Fkey = key v4 = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(r + 8 + 1*8)) = v4 - *(*uintptr)(unsafe.Pointer(r + 8)) = v4 + **(**uintptr)(__ccgo_up(r + 8 + 1*8)) = v4 + **(**uintptr)(__ccgo_up(r + 8)) = v4 (*Tnode1)(unsafe.Pointer(r)).Fh = int32(1) /* insert new node, rebalance ancestors. */ i = i - 1 v1 = i - *(*uintptr)(unsafe.Pointer(a[v1])) = r + **(**uintptr)(__ccgo_up(a[v1])) = r for { if v7 = i != 0; v7 { i = i - 1 @@ -133969,9 +133969,9 @@ func _walk(tls *TLS, r uintptr, __ccgo_fp_action uintptr, d int32) { (*(*func(*TLS, uintptr, TVISIT, int32))(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_action})))(tls, r, int32(_leaf), d) } else { (*(*func(*TLS, uintptr, TVISIT, int32))(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_action})))(tls, r, int32(_preorder), d) - _walk(tls, *(*uintptr)(unsafe.Pointer(r + 8)), __ccgo_fp_action, d+int32(1)) + _walk(tls, **(**uintptr)(__ccgo_up(r + 8)), __ccgo_fp_action, d+int32(1)) (*(*func(*TLS, uintptr, TVISIT, int32))(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_action})))(tls, r, int32(_postorder), d) - _walk(tls, *(*uintptr)(unsafe.Pointer(r + 8 + 1*8)), __ccgo_fp_action, d+int32(1)) + _walk(tls, **(**uintptr)(__ccgo_up(r + 8 + 1*8)), __ccgo_fp_action, d+int32(1)) (*(*func(*TLS, uintptr, TVISIT, int32))(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_action})))(tls, r, int32(_endorder), d) } } @@ -134053,7 +134053,7 @@ func Xpselect(tls *TLS, n int32, rfds uintptr, wfds uintptr, efds uintptr, ts ui var v3 uintptr var _ /* data at bp+16 */ [2]Tsyscall_arg_t _, _, _, _, _ = ns, s, v1, v2, v3 - *(*[2]Tsyscall_arg_t)(unsafe.Pointer(bp + 16)) = [2]Tsyscall_arg_t{ + **(**[2]Tsyscall_arg_t)(__ccgo_up(bp + 16)) = [2]Tsyscall_arg_t{ 0: Int64FromUint64(uint64(mask)), 1: int64(Int32FromInt32(_NSIG) / Int32FromInt32(8)), } @@ -134175,10 +134175,10 @@ func Xgetitimer(tls *TLS, which int32, old uintptr) (r1 int32) { if uint64(8) > uint64(8) { r = int32(X__syscall2(tls, int64(SYS_getitimer), int64(which), int64(bp))) if !(r != 0) { - (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_sec = (*(*[4]int64)(unsafe.Pointer(bp)))[0] - (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_usec = (*(*[4]int64)(unsafe.Pointer(bp)))[int32(1)] - (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_sec = (*(*[4]int64)(unsafe.Pointer(bp)))[int32(2)] - (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_usec = (*(*[4]int64)(unsafe.Pointer(bp)))[int32(3)] + (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_sec = (**(**[4]int64)(__ccgo_up(bp)))[0] + (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_usec = (**(**[4]int64)(__ccgo_up(bp)))[int32(1)] + (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_sec = (**(**[4]int64)(__ccgo_up(bp)))[int32(2)] + (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_usec = (**(**[4]int64)(__ccgo_up(bp)))[int32(3)] } return int32(X__syscall_ret(tls, Uint64FromInt32(r))) } @@ -134199,7 +134199,7 @@ func Xkillpg(tls *TLS, pgid Tpid_t, sig int32) (r int32) { defer func() { trc("-> %v", r) }() } if pgid < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } return Xkill(tls, -pgid, sig) @@ -134235,7 +134235,7 @@ func Xpsignal(tls *TLS, sig int32, msg uintptr) { * not permitted to do so. */ old_locale = (*TFILE)(unsafe.Pointer(f)).Flocale old_mode = (*TFILE)(unsafe.Pointer(f)).Fmode - old_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + old_errno = **(**int32)(__ccgo_up(X__errno_location(tls))) if msg != 0 { v2 = msg } else { @@ -134247,7 +134247,7 @@ func Xpsignal(tls *TLS, sig int32, msg uintptr) { v3 = __ccgo_ts } if Xfprintf(tls, f, __ccgo_ts+1062, VaList(bp+8, v2, v3, s)) >= 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = old_errno + **(**int32)(__ccgo_up(X__errno_location(tls))) = old_errno } (*TFILE)(unsafe.Pointer(f)).Fmode = old_mode (*TFILE)(unsafe.Pointer(f)).Flocale = old_locale @@ -134314,10 +134314,10 @@ func Xsetitimer(tls *TLS, which int32, new1 uintptr, old uintptr) (r1 int32) { } r = int32(X__syscall3(tls, int64(SYS_setitimer), int64(which), int64(bp), int64(bp+32))) if !(r != 0) && old != 0 { - (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_sec = (*(*[4]int64)(unsafe.Pointer(bp + 32)))[0] - (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_usec = (*(*[4]int64)(unsafe.Pointer(bp + 32)))[int32(1)] - (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_sec = (*(*[4]int64)(unsafe.Pointer(bp + 32)))[int32(2)] - (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_usec = (*(*[4]int64)(unsafe.Pointer(bp + 32)))[int32(3)] + (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_sec = (**(**[4]int64)(__ccgo_up(bp + 32)))[0] + (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_usec = (**(**[4]int64)(__ccgo_up(bp + 32)))[int32(1)] + (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_sec = (**(**[4]int64)(__ccgo_up(bp + 32)))[int32(2)] + (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_usec = (**(**[4]int64)(__ccgo_up(bp + 32)))[int32(3)] } return int32(X__syscall_ret(tls, Uint64FromInt32(r))) } @@ -134409,7 +134409,7 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old1 uintptr) (r2 int32) Fv Tuint64_t }{} *(*uint64)(unsafe.Pointer(bp + 8)) = Uint64FromInt64(v2) - if *(*Tuint32_t)(unsafe.Pointer(bp + 8)) != 0 { + if **(**Tuint32_t)(__ccgo_up(bp + 8)) != 0 { v11 = v10 // __asm__ __volatile__ ("dbar 0" : : : "memory"); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 49, __ccgo_ts+1477) @@ -134447,7 +134447,7 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old1 uintptr) (r2 int32) goto _17 _17: } - if *(*Tuint32_t)(unsafe.Pointer(bp + 8 + 1*4)) != 0 { + if **(**Tuint32_t)(__ccgo_up(bp + 8 + 1*4)) != 0 { v18 = v10 + uintptr(1)*4 // __asm__ __volatile__ ("dbar 0" : : : "memory"); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 49, __ccgo_ts+1477) @@ -134509,8 +134509,8 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old1 uintptr) (r2 int32) X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 49, __ccgo_ts+1477) } } - (*(*Tk_sigaction)(unsafe.Pointer(bp + 16))).Fhandler = *(*uintptr)(unsafe.Pointer(sa)) - (*(*Tk_sigaction)(unsafe.Pointer(bp + 16))).Fflags = Uint64FromInt32((*Tsigaction)(unsafe.Pointer(sa)).Fsa_flags) + (**(**Tk_sigaction)(__ccgo_up(bp + 16))).Fhandler = *(*uintptr)(unsafe.Pointer(sa)) + (**(**Tk_sigaction)(__ccgo_up(bp + 16))).Fflags = Uint64FromInt32((*Tsigaction)(unsafe.Pointer(sa)).Fsa_flags) Xmemcpy(tls, bp+16+16, sa+8, Uint64FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))) } if sa != 0 { @@ -134525,8 +134525,8 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old1 uintptr) (r2 int32) } r1 = int32(X__syscall4(tls, int64(SYS_rt_sigaction), int64(sig), int64(v1), int64(v3), int64(Int32FromInt32(_NSIG)/Int32FromInt32(8)))) if old1 != 0 && !(r1 != 0) { - *(*uintptr)(unsafe.Pointer(old1)) = (*(*Tk_sigaction)(unsafe.Pointer(bp + 48))).Fhandler - (*Tsigaction)(unsafe.Pointer(old1)).Fsa_flags = Int32FromUint64((*(*Tk_sigaction)(unsafe.Pointer(bp + 48))).Fflags) + *(*uintptr)(unsafe.Pointer(old1)) = (**(**Tk_sigaction)(__ccgo_up(bp + 48))).Fhandler + (*Tsigaction)(unsafe.Pointer(old1)).Fsa_flags = Int32FromUint64((**(**Tk_sigaction)(__ccgo_up(bp + 48))).Fflags) Xmemcpy(tls, old1+8, bp+48+16, Uint64FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))) } return int32(X__syscall_ret(tls, Uint64FromInt32(r1))) @@ -134543,7 +134543,7 @@ func X__sigaction(tls *TLS, sig int32, sa uintptr, old uintptr) (r1 int32) { var _ /* set at bp+0 */ [1]uint64 _ = r if Uint32FromInt32(sig)-uint32(32) < uint32(3) || Uint32FromInt32(sig)-uint32(1) >= Uint32FromInt32(Int32FromInt32(_NSIG)-Int32FromInt32(1)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } /* Doing anything with the disposition of SIGABRT requires a lock, @@ -134578,10 +134578,10 @@ func Xsigaddset(tls *TLS, set uintptr, sig int32) (r int32) { _ = s s = Uint32FromInt32(sig - int32(1)) if s >= Uint32FromInt32(Int32FromInt32(_NSIG)-Int32FromInt32(1)) || Uint32FromInt32(sig)-uint32(32) < uint32(3) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } - *(*uint64)(unsafe.Pointer(set + uintptr(uint64(s/uint32(8))/uint64(8))*8)) |= uint64(1) << (uint64(s) & (Uint64FromInt32(8)*Uint64FromInt64(8) - Uint64FromInt32(1))) + **(**uint64)(__ccgo_up(set + uintptr(uint64(s/uint32(8))/uint64(8))*8)) |= uint64(1) << (uint64(s) & (Uint64FromInt32(8)*Uint64FromInt64(8) - Uint64FromInt32(1))) return 0 } @@ -134592,11 +134592,11 @@ func Xsigaltstack(tls *TLS, ss uintptr, old uintptr) (r int32) { } if ss != 0 { if !((*Tstack_t)(unsafe.Pointer(ss)).Fss_flags&Int32FromInt32(SS_DISABLE) != 0) && (*Tstack_t)(unsafe.Pointer(ss)).Fss_size < uint64(MINSIGSTKSZ) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return -int32(1) } if (*Tstack_t)(unsafe.Pointer(ss)).Fss_flags&int32(SS_ONSTACK) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } } @@ -134621,7 +134621,7 @@ func Xsigandset(tls *TLS, dest uintptr, left uintptr, right uintptr) (r1 int32) if !(i < Uint64FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))/Uint64FromInt64(8)) { break } - *(*uint64)(unsafe.Pointer(d + uintptr(i)*8)) = *(*uint64)(unsafe.Pointer(l + uintptr(i)*8)) & *(*uint64)(unsafe.Pointer(r + uintptr(i)*8)) + **(**uint64)(__ccgo_up(d + uintptr(i)*8)) = **(**uint64)(__ccgo_up(l + uintptr(i)*8)) & **(**uint64)(__ccgo_up(r + uintptr(i)*8)) goto _1 _1: ; @@ -134639,10 +134639,10 @@ func Xsigdelset(tls *TLS, set uintptr, sig int32) (r int32) { _ = s s = Uint32FromInt32(sig - int32(1)) if s >= Uint32FromInt32(Int32FromInt32(_NSIG)-Int32FromInt32(1)) || Uint32FromInt32(sig)-uint32(32) < uint32(3) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } - *(*uint64)(unsafe.Pointer(set + uintptr(uint64(s/uint32(8))/uint64(8))*8)) &= ^(Uint64FromUint64(1) << (uint64(s) & (Uint64FromInt32(8)*Uint64FromInt64(8) - Uint64FromInt32(1)))) + **(**uint64)(__ccgo_up(set + uintptr(uint64(s/uint32(8))/uint64(8))*8)) &= ^(Uint64FromUint64(1) << (uint64(s) & (Uint64FromInt32(8)*Uint64FromInt64(8) - Uint64FromInt32(1)))) return 0 } @@ -134651,13 +134651,13 @@ func Xsigemptyset(tls *TLS, set uintptr) (r int32) { trc("tls=%v set=%v, (%v:)", tls, set, origin(2)) defer func() { trc("-> %v", r) }() } - *(*uint64)(unsafe.Pointer(set)) = uint64(0) + **(**uint64)(__ccgo_up(set)) = uint64(0) if Bool(uint64(8) == uint64(4)) || Bool(int32(_NSIG) > int32(65)) { - *(*uint64)(unsafe.Pointer(set + 1*8)) = uint64(0) + **(**uint64)(__ccgo_up(set + 1*8)) = uint64(0) } if Bool(uint64(8) == uint64(4)) && Bool(int32(_NSIG) > int32(65)) { - *(*uint64)(unsafe.Pointer(set + 2*8)) = uint64(0) - *(*uint64)(unsafe.Pointer(set + 3*8)) = uint64(0) + **(**uint64)(__ccgo_up(set + 2*8)) = uint64(0) + **(**uint64)(__ccgo_up(set + 3*8)) = uint64(0) } return 0 } @@ -134676,9 +134676,9 @@ func Xsigfillset(tls *TLS, set uintptr) (r int32) { trc("tls=%v set=%v, (%v:)", tls, set, origin(2)) defer func() { trc("-> %v", r) }() } - *(*uint64)(unsafe.Pointer(set)) = uint64(0xfffffffc7fffffff) + **(**uint64)(__ccgo_up(set)) = uint64(0xfffffffc7fffffff) if int32(_NSIG) > int32(65) { - *(*uint64)(unsafe.Pointer(set + 1*8)) = uint64(0xffffffffffffffff) + **(**uint64)(__ccgo_up(set + 1*8)) = uint64(0xffffffffffffffff) } return 0 } @@ -134695,7 +134695,7 @@ func Xsigisemptyset(tls *TLS, set uintptr) (r int32) { if !(i < Uint64FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))/Uint64FromInt64(8)) { break } - if *(*uint64)(unsafe.Pointer(set + uintptr(i)*8)) != 0 { + if **(**uint64)(__ccgo_up(set + uintptr(i)*8)) != 0 { return 0 } goto _1 @@ -134717,7 +134717,7 @@ func Xsigismember(tls *TLS, set uintptr, sig int32) (r int32) { if s >= Uint32FromInt32(Int32FromInt32(_NSIG)-Int32FromInt32(1)) { return 0 } - return BoolInt32(!!(*(*uint64)(unsafe.Pointer(set + uintptr(uint64(s/uint32(8))/uint64(8))*8))&(Uint64FromUint64(1)<<(uint64(s)&(Uint64FromInt32(8)*Uint64FromInt64(8)-Uint64FromInt32(1)))) != 0)) + return BoolInt32(!!(**(**uint64)(__ccgo_up(set + uintptr(uint64(s/uint32(8))/uint64(8))*8))&(Uint64FromUint64(1)<<(uint64(s)&(Uint64FromInt32(8)*Uint64FromInt64(8)-Uint64FromInt32(1)))) != 0)) } func Xsigorset(tls *TLS, dest uintptr, left uintptr, right uintptr) (r1 int32) { @@ -134736,7 +134736,7 @@ func Xsigorset(tls *TLS, dest uintptr, left uintptr, right uintptr) (r1 int32) { if !(i < Uint64FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))/Uint64FromInt64(8)) { break } - *(*uint64)(unsafe.Pointer(d + uintptr(i)*8)) = *(*uint64)(unsafe.Pointer(l + uintptr(i)*8)) | *(*uint64)(unsafe.Pointer(r + uintptr(i)*8)) + **(**uint64)(__ccgo_up(d + uintptr(i)*8)) = **(**uint64)(__ccgo_up(l + uintptr(i)*8)) | **(**uint64)(__ccgo_up(r + uintptr(i)*8)) goto _1 _1: ; @@ -134764,7 +134764,7 @@ func Xsigprocmask(tls *TLS, how int32, set uintptr, old uintptr) (r1 int32) { if !(r != 0) { return r } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = r + **(**int32)(__ccgo_up(X__errno_location(tls))) = r return -int32(1) } @@ -134780,8 +134780,8 @@ func Xsigqueue(tls *TLS, pid Tpid_t, sig int32, value Tsigval) (r1 int32) { var _ /* si at bp+0 */ Tsiginfo_t _ = r Xmemset(tls, bp, 0, uint64(128)) - (*(*Tsiginfo_t)(unsafe.Pointer(bp))).Fsi_signo = sig - (*(*Tsiginfo_t)(unsafe.Pointer(bp))).Fsi_code = -int32(1) + (**(**Tsiginfo_t)(__ccgo_up(bp))).Fsi_signo = sig + (**(**Tsiginfo_t)(__ccgo_up(bp))).Fsi_code = -int32(1) *(*Tsigval)(unsafe.Pointer(bp + 16 + 8)) = value *(*Tuid_t)(unsafe.Pointer(bp + 16 + 4)) = Xgetuid(tls) X__block_app_sigs(tls, bp+128) @@ -134877,7 +134877,7 @@ func Xsigwait(tls *TLS, mask uintptr, sig uintptr) (r int32) { if Xsigtimedwait(tls, mask, bp, uintptr(0)) < 0 { return -int32(1) } - *(*int32)(unsafe.Pointer(sig)) = (*(*Tsiginfo_t)(unsafe.Pointer(bp))).Fsi_signo + **(**int32)(__ccgo_up(sig)) = (**(**Tsiginfo_t)(__ccgo_up(bp))).Fsi_signo return 0 } @@ -134926,7 +134926,7 @@ func X__xmknod(tls *TLS, ver int32, path uintptr, mode Tmode_t, dev uintptr) (r trc("tls=%v ver=%v path=%v mode=%v dev=%v, (%v:)", tls, ver, path, mode, dev, origin(2)) defer func() { trc("-> %v", r) }() } - return Xmknod(tls, path, mode, *(*Tdev_t)(unsafe.Pointer(dev))) + return Xmknod(tls, path, mode, **(**Tdev_t)(__ccgo_up(dev))) } func X__xmknodat(tls *TLS, ver int32, fd int32, path uintptr, mode Tmode_t, dev uintptr) (r int32) { @@ -134934,7 +134934,7 @@ func X__xmknodat(tls *TLS, ver int32, fd int32, path uintptr, mode Tmode_t, dev trc("tls=%v ver=%v fd=%v path=%v mode=%v dev=%v, (%v:)", tls, ver, fd, path, mode, dev, origin(2)) defer func() { trc("-> %v", r) }() } - return Xmknodat(tls, fd, path, mode, *(*Tdev_t)(unsafe.Pointer(dev))) + return Xmknodat(tls, fd, path, mode, **(**Tdev_t)(__ccgo_up(dev))) } func Xchmod(tls *TLS, path uintptr, mode Tmode_t) (r int32) { @@ -134987,7 +134987,7 @@ func Xfchmodat(tls *TLS, fd int32, path uintptr, mode Tmode_t, flag int32) (r in if Xfstatat(tls, fd, path, bp, flag) != 0 { return -int32(1) } - if (*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { + if (**(**Tstat)(__ccgo_up(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { return int32(X__syscall_ret(tls, Uint64FromInt32(-Int32FromInt32(EOPNOTSUPP)))) } v1 = int32(X__syscall3(tls, int64(SYS_openat), int64(fd), int64(path), int64(Int32FromInt32(O_RDONLY)|Int32FromInt32(O_PATH)|Int32FromInt32(O_NOFOLLOW)|Int32FromInt32(O_NOCTTY)|Int32FromInt32(O_CLOEXEC)))) @@ -135001,7 +135001,7 @@ func Xfchmodat(tls *TLS, fd int32, path uintptr, mode Tmode_t, flag int32) (r in X__procfdname(tls, bp+128, Uint32FromInt32(fd2)) ret = Xstat(tls, bp+128, bp) if !(ret != 0) { - if (*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { + if (**(**Tstat)(__ccgo_up(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { ret = int32(X__syscall_ret(tls, Uint64FromInt32(-Int32FromInt32(EOPNOTSUPP)))) } else { ret = int32(X__syscall_ret(tls, Uint64FromInt64(X__syscall3(tls, int64(SYS_fchmodat), int64(-Int32FromInt32(100)), int64(bp+128), Int64FromUint32(mode))))) @@ -135081,28 +135081,28 @@ func _fstatat_statx(tls *TLS, fd int32, path uintptr, st uintptr, flag int32) (r if ret != 0 { return ret } - *(*Tstat)(unsafe.Pointer(st)) = Tstat{ - Fst_dev: uint64(uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_dev_major)&Uint64FromUint64(0xfffff000)<= uint64(1000000) { + if Uint64FromInt64((**(**Ttimeval)(__ccgo_up(times + uintptr(i)*16))).Ftv_usec) >= uint64(1000000) { return int32(X__syscall_ret(tls, Uint64FromInt32(-Int32FromInt32(EINVAL)))) } - (*(*[2]Ttimespec)(unsafe.Pointer(bp)))[i].Ftv_sec = (*(*Ttimeval)(unsafe.Pointer(times + uintptr(i)*16))).Ftv_sec - (*(*[2]Ttimespec)(unsafe.Pointer(bp)))[i].Ftv_nsec = (*(*Ttimeval)(unsafe.Pointer(times + uintptr(i)*16))).Ftv_usec * int64(1000) + (**(**[2]Ttimespec)(__ccgo_up(bp)))[i].Ftv_sec = (**(**Ttimeval)(__ccgo_up(times + uintptr(i)*16))).Ftv_sec + (**(**[2]Ttimespec)(__ccgo_up(bp)))[i].Ftv_nsec = (**(**Ttimeval)(__ccgo_up(times + uintptr(i)*16))).Ftv_usec * int64(1000) goto _1 _1: ; @@ -135252,7 +135252,7 @@ func Xstat(tls *TLS, path uintptr, buf uintptr) (r int32) { } func ___statfs(tls *TLS, path uintptr, buf uintptr) (r int32) { - *(*Tstatfs)(unsafe.Pointer(buf)) = Tstatfs{} + **(**Tstatfs)(__ccgo_up(buf)) = Tstatfs{} return int32(X__syscall_ret(tls, Uint64FromInt64(X__syscall2(tls, int64(__NR3264_statfs), int64(path), int64(buf))))) } @@ -135261,14 +135261,14 @@ func Xfstatfs(tls *TLS, fd int32, buf uintptr) (r int32) { trc("tls=%v fd=%v buf=%v, (%v:)", tls, fd, buf, origin(2)) defer func() { trc("-> %v", r) }() } - *(*Tstatfs)(unsafe.Pointer(buf)) = Tstatfs{} + **(**Tstatfs)(__ccgo_up(buf)) = Tstatfs{} return int32(X__syscall_ret(tls, Uint64FromInt64(X__syscall2(tls, int64(__NR3264_fstatfs), int64(fd), int64(buf))))) } func _fixup(tls *TLS, out uintptr, in uintptr) { var v1 uint64 _ = v1 - *(*Tstatvfs)(unsafe.Pointer(out)) = Tstatvfs{} + **(**Tstatvfs)(__ccgo_up(out)) = Tstatvfs{} (*Tstatvfs)(unsafe.Pointer(out)).Ff_bsize = (*Tstatfs)(unsafe.Pointer(in)).Ff_bsize if (*Tstatfs)(unsafe.Pointer(in)).Ff_frsize != 0 { v1 = (*Tstatfs)(unsafe.Pointer(in)).Ff_frsize @@ -135282,7 +135282,7 @@ func _fixup(tls *TLS, out uintptr, in uintptr) { (*Tstatvfs)(unsafe.Pointer(out)).Ff_files = (*Tstatfs)(unsafe.Pointer(in)).Ff_files (*Tstatvfs)(unsafe.Pointer(out)).Ff_ffree = (*Tstatfs)(unsafe.Pointer(in)).Ff_ffree (*Tstatvfs)(unsafe.Pointer(out)).Ff_favail = (*Tstatfs)(unsafe.Pointer(in)).Ff_ffree - (*Tstatvfs)(unsafe.Pointer(out)).Ff_fsid = Uint64FromInt32(*(*int32)(unsafe.Pointer(in + 56))) + (*Tstatvfs)(unsafe.Pointer(out)).Ff_fsid = Uint64FromInt32(**(**int32)(__ccgo_up(in + 56))) (*Tstatvfs)(unsafe.Pointer(out)).Ff_flag = (*Tstatfs)(unsafe.Pointer(in)).Ff_flags (*Tstatvfs)(unsafe.Pointer(out)).Ff_namemax = (*Tstatfs)(unsafe.Pointer(in)).Ff_namelen (*Tstatvfs)(unsafe.Pointer(out)).Ff_type = uint32((*Tstatfs)(unsafe.Pointer(in)).Ff_type) @@ -135333,7 +135333,7 @@ func Xutimensat(tls *TLS, fd int32, path uintptr, times uintptr, flags int32) (r } var r int32 _ = r - if times != 0 && (*(*Ttimespec)(unsafe.Pointer(times))).Ftv_nsec == int64(UTIME_NOW) && (*(*Ttimespec)(unsafe.Pointer(times + 1*16))).Ftv_nsec == int64(UTIME_NOW) { + if times != 0 && (**(**Ttimespec)(__ccgo_up(times))).Ftv_nsec == int64(UTIME_NOW) && (**(**Ttimespec)(__ccgo_up(times + 1*16))).Ftv_nsec == int64(UTIME_NOW) { times = uintptr(0) } r = int32(X__syscall4(tls, int64(SYS_utimensat), int64(fd), int64(path), int64(times), int64(flags))) @@ -135360,8 +135360,8 @@ func X__fdopen(tls *TLS, fd int32, mode uintptr) (r uintptr) { var _ /* wsz at bp+0 */ Twinsize _, _, _, _ = f, flags, v1, v2 /* Check for valid initial mode character */ - if !(Xstrchr(tls, __ccgo_ts+1494, int32(*(*int8)(unsafe.Pointer(mode)))) != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if !(Xstrchr(tls, __ccgo_ts+1494, int32(**(**int8)(__ccgo_up(mode)))) != 0) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } /* Allocate FILE+buffer or fail */ @@ -135374,7 +135374,7 @@ func X__fdopen(tls *TLS, fd int32, mode uintptr) (r uintptr) { Xmemset(tls, f, 0, uint64(232)) /* Impose mode restrictions */ if !(Xstrchr(tls, mode, int32('+')) != 0) { - if int32(*(*int8)(unsafe.Pointer(mode))) == int32('r') { + if int32(**(**int8)(__ccgo_up(mode))) == int32('r') { v2 = int32(F_NOWR) } else { v2 = int32(F_NORD) @@ -135386,12 +135386,12 @@ func X__fdopen(tls *TLS, fd int32, mode uintptr) (r uintptr) { X__syscall3(tls, int64(__NR3264_fcntl), int64(fd), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) } /* Set append mode on fd if opened for append */ - if int32(*(*int8)(unsafe.Pointer(mode))) == int32('a') { + if int32(**(**int8)(__ccgo_up(mode))) == int32('a') { flags = int32(X__syscall2(tls, int64(__NR3264_fcntl), int64(fd), int64(Int32FromInt32(F_GETFL)))) if !(flags&Int32FromInt32(O_APPEND) != 0) { X__syscall3(tls, int64(__NR3264_fcntl), int64(fd), int64(Int32FromInt32(F_SETFL)), int64(flags|Int32FromInt32(O_APPEND))) } - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_APP) + **(**uint32)(__ccgo_up(f)) |= uint32(F_APP) } (*TFILE)(unsafe.Pointer(f)).Ffd = fd (*TFILE)(unsafe.Pointer(f)).Fbuf = f + uintptr(232) + uintptr(UNGET) @@ -135431,7 +135431,7 @@ func X__fmodeflags(tls *TLS, mode uintptr) (r int32) { if Xstrchr(tls, mode, int32('+')) != 0 { flags = int32(O_RDWR) } else { - if int32(*(*int8)(unsafe.Pointer(mode))) == int32('r') { + if int32(**(**int8)(__ccgo_up(mode))) == int32('r') { flags = O_RDONLY } else { flags = int32(O_WRONLY) @@ -135443,13 +135443,13 @@ func X__fmodeflags(tls *TLS, mode uintptr) (r int32) { if Xstrchr(tls, mode, int32('e')) != 0 { flags = flags | int32(O_CLOEXEC) } - if int32(*(*int8)(unsafe.Pointer(mode))) != int32('r') { + if int32(**(**int8)(__ccgo_up(mode))) != int32('r') { flags = flags | int32(O_CREAT) } - if int32(*(*int8)(unsafe.Pointer(mode))) == int32('w') { + if int32(**(**int8)(__ccgo_up(mode))) == int32('w') { flags = flags | int32(O_TRUNC) } - if int32(*(*int8)(unsafe.Pointer(mode))) == int32('a') { + if int32(**(**int8)(__ccgo_up(mode))) == int32('a') { flags = flags | int32(O_APPEND) } return flags @@ -135487,22 +135487,22 @@ func X__overflow(tls *TLS, f uintptr, _c int32) (r int32) { var v2, v3 uintptr var _ /* c at bp+0 */ uint8 _, _, _ = v1, v2, v3 - *(*uint8)(unsafe.Pointer(bp)) = Uint8FromInt32(_c) + **(**uint8)(__ccgo_up(bp)) = Uint8FromInt32(_c) if !((*TFILE)(unsafe.Pointer(f)).Fwend != 0) && X__towrite(tls, f) != 0 { return -int32(1) } - if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwend && Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) != (*TFILE)(unsafe.Pointer(f)).Flbf { - v1 = *(*uint8)(unsafe.Pointer(bp)) + if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwend && Int32FromUint8(**(**uint8)(__ccgo_up(bp))) != (*TFILE)(unsafe.Pointer(f)).Flbf { + v1 = **(**uint8)(__ccgo_up(bp)) v3 = f + 40 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - *(*uint8)(unsafe.Pointer(v2)) = v1 + **(**uint8)(__ccgo_up(v2)) = v1 return Int32FromUint8(v1) } if (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fwrite})))(tls, f, bp, uint64(1)) != uint64(1) { return -int32(1) } - return Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) + return Int32FromUint8(**(**uint8)(__ccgo_up(bp))) } func _dummy9(tls *TLS, fd int32) (r int32) { @@ -135540,7 +135540,7 @@ func X__stdio_exit(tls *TLS) { } var f uintptr _ = f - f = *(*uintptr)(unsafe.Pointer(X__ofl_lock(tls))) + f = **(**uintptr)(__ccgo_up(X__ofl_lock(tls))) for { if !(f != 0) { break @@ -135576,7 +135576,7 @@ func X__stdio_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { var v3, v4 uintptr var _ /* iov at bp+0 */ [2]Tiovec _, _, _, _, _ = cnt, v1, v2, v3, v4 - *(*[2]Tiovec)(unsafe.Pointer(bp)) = [2]Tiovec{ + **(**[2]Tiovec)(__ccgo_up(bp)) = [2]Tiovec{ 0: { Fiov_base: buf, Fiov_len: len1 - BoolUint64(!!((*TFILE)(unsafe.Pointer(f)).Fbuf_size != 0)), @@ -135586,10 +135586,10 @@ func X__stdio_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { Fiov_len: (*TFILE)(unsafe.Pointer(f)).Fbuf_size, }, } - if (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len != 0 { + if (**(**[2]Tiovec)(__ccgo_up(bp)))[0].Fiov_len != 0 { v1 = X__syscall_ret(tls, Uint64FromInt64(X__syscall3(tls, int64(SYS_readv), int64((*TFILE)(unsafe.Pointer(f)).Ffd), int64(bp), int64(Int32FromInt32(2))))) } else { - v1 = X__syscall_ret(tls, Uint64FromInt64(X__syscall3(tls, int64(SYS_read), int64((*TFILE)(unsafe.Pointer(f)).Ffd), int64((*(*[2]Tiovec)(unsafe.Pointer(bp)))[int32(1)].Fiov_base), Int64FromUint64((*(*[2]Tiovec)(unsafe.Pointer(bp)))[int32(1)].Fiov_len)))) + v1 = X__syscall_ret(tls, Uint64FromInt64(X__syscall3(tls, int64(SYS_read), int64((*TFILE)(unsafe.Pointer(f)).Ffd), int64((**(**[2]Tiovec)(__ccgo_up(bp)))[int32(1)].Fiov_base), Int64FromUint64((**(**[2]Tiovec)(__ccgo_up(bp)))[int32(1)].Fiov_len)))) } cnt = v1 if cnt <= 0 { @@ -135598,20 +135598,20 @@ func X__stdio_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { } else { v2 = int32(F_EOF) } - *(*uint32)(unsafe.Pointer(f)) |= Uint32FromInt32(v2) + **(**uint32)(__ccgo_up(f)) |= Uint32FromInt32(v2) return uint64(0) } - if Uint64FromInt64(cnt) <= (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len { + if Uint64FromInt64(cnt) <= (**(**[2]Tiovec)(__ccgo_up(bp)))[0].Fiov_len { return Uint64FromInt64(cnt) } - cnt = Int64FromUint64(uint64(cnt) - (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len) + cnt = Int64FromUint64(uint64(cnt) - (**(**[2]Tiovec)(__ccgo_up(bp)))[0].Fiov_len) (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(cnt) if (*TFILE)(unsafe.Pointer(f)).Fbuf_size != 0 { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(buf + uintptr(len1-uint64(1)))) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(buf + uintptr(len1-uint64(1)))) = **(**uint8)(__ccgo_up(v3)) } return len1 } @@ -135638,7 +135638,7 @@ func X__stdio_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) var v5 uint64 var _ /* iovs at bp+0 */ [2]Tiovec _, _, _, _, _, _, _ = cnt, iov, iovcnt, rem, v2, v3, v5 - *(*[2]Tiovec)(unsafe.Pointer(bp)) = [2]Tiovec{ + **(**[2]Tiovec)(__ccgo_up(bp)) = [2]Tiovec{ 0: { Fiov_base: (*TFILE)(unsafe.Pointer(f)).Fwbase, Fiov_len: Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Fwpos) - int64((*TFILE)(unsafe.Pointer(f)).Fwbase)), @@ -135649,7 +135649,7 @@ func X__stdio_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) }, } iov = bp - rem = (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len + (*(*Tiovec)(unsafe.Pointer(iov + 1*16))).Fiov_len + rem = (**(**Tiovec)(__ccgo_up(iov))).Fiov_len + (**(**Tiovec)(__ccgo_up(iov + 1*16))).Fiov_len iovcnt = int32(2) for { cnt = X__syscall_ret(tls, Uint64FromInt64(X__syscall3(tls, int64(SYS_writev), int64((*TFILE)(unsafe.Pointer(f)).Ffd), int64(iov), int64(iovcnt)))) @@ -135666,22 +135666,22 @@ func X__stdio_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) v2 = v3 (*TFILE)(unsafe.Pointer(f)).Fwbase = v2 (*TFILE)(unsafe.Pointer(f)).Fwpos = v2 - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) if iovcnt == int32(2) { v5 = uint64(0) } else { - v5 = len1 - (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len + v5 = len1 - (**(**Tiovec)(__ccgo_up(iov))).Fiov_len } return v5 } rem = rem - Uint64FromInt64(cnt) - if Uint64FromInt64(cnt) > (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len { - cnt = Int64FromUint64(uint64(cnt) - (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len) + if Uint64FromInt64(cnt) > (**(**Tiovec)(__ccgo_up(iov))).Fiov_len { + cnt = Int64FromUint64(uint64(cnt) - (**(**Tiovec)(__ccgo_up(iov))).Fiov_len) iov += 16 iovcnt = iovcnt - 1 } - (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_base = (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_base + uintptr(cnt) - (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len -= Uint64FromInt64(cnt) + (**(**Tiovec)(__ccgo_up(iov))).Fiov_base = (**(**Tiovec)(__ccgo_up(iov))).Fiov_base + uintptr(cnt) + (**(**Tiovec)(__ccgo_up(iov))).Fiov_len -= Uint64FromInt64(cnt) goto _1 _1: } @@ -135711,7 +135711,7 @@ func X__toread(tls *TLS, f uintptr) (r int32) { var v1, v2 uintptr var v4 int32 _, _, _ = v1, v2, v4 - *(*int32)(unsafe.Pointer(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) + **(**int32)(__ccgo_up(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwbase { (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fwrite})))(tls, f, uintptr(0), uint64(0)) } @@ -135721,7 +135721,7 @@ func X__toread(tls *TLS, f uintptr) (r int32) { (*TFILE)(unsafe.Pointer(f)).Fwbase = v1 (*TFILE)(unsafe.Pointer(f)).Fwpos = v1 if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_NORD) != 0 { - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) return -int32(1) } v1 = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr((*TFILE)(unsafe.Pointer(f)).Fbuf_size) @@ -135749,9 +135749,9 @@ func X__towrite(tls *TLS, f uintptr) (r int32) { } var v1 uintptr _ = v1 - *(*int32)(unsafe.Pointer(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) + **(**int32)(__ccgo_up(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_NOWR) != 0 { - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) return -int32(1) } /* Clear read buffer (easier than summoning nasal demons) */ @@ -135785,7 +135785,7 @@ func X__uflow(tls *TLS, f uintptr) (r int32) { defer tls.Free(16) var _ /* c at bp+0 */ uint8 if !(X__toread(tls, f) != 0) && (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fread})))(tls, f, bp, uint64(1)) == uint64(1) { - return Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) + return Int32FromUint8(**(**uint8)(__ccgo_up(bp))) } return -int32(1) } @@ -135816,7 +135816,7 @@ func Xclearerr(tls *TLS, f uintptr) { v1 = 0 } __need_unlock = v1 - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^(Int32FromInt32(F_EOF) | Int32FromInt32(F_ERR))) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^(Int32FromInt32(F_EOF) | Int32FromInt32(F_ERR))) if __need_unlock != 0 { ___unlockfile(tls, f) } @@ -135977,7 +135977,7 @@ func X__freadptr(tls *TLS, f uintptr, sizep uintptr) (r uintptr) { if (*TFILE)(unsafe.Pointer(f)).Frpos == (*TFILE)(unsafe.Pointer(f)).Frend { return uintptr(0) } - *(*Tsize_t)(unsafe.Pointer(sizep)) = Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Frend) - int64((*TFILE)(unsafe.Pointer(f)).Frpos)) + **(**Tsize_t)(__ccgo_up(sizep)) = Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Frend) - int64((*TFILE)(unsafe.Pointer(f)).Frpos)) return (*TFILE)(unsafe.Pointer(f)).Frpos } @@ -135985,14 +135985,14 @@ func X__freadptrinc(tls *TLS, f uintptr, inc Tsize_t) { if __ccgo_strace { trc("tls=%v f=%v inc=%v, (%v:)", tls, f, inc, origin(2)) } - *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(inc) + **(**uintptr)(__ccgo_up(f + 8)) += uintptr(inc) } func X__fseterr(tls *TLS, f uintptr) { if __ccgo_strace { trc("tls=%v f=%v, (%v:)", tls, f, origin(2)) } - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) } func _dummy10(tls *TLS, f uintptr) { @@ -136035,8 +136035,8 @@ func Xfclose(tls *TLS, f uintptr) (r1 int32) { if (*TFILE)(unsafe.Pointer(f)).Fnext != 0 { (*TFILE)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Fnext)).Fprev = (*TFILE)(unsafe.Pointer(f)).Fprev } - if *(*uintptr)(unsafe.Pointer(head)) == f { - *(*uintptr)(unsafe.Pointer(head)) = (*TFILE)(unsafe.Pointer(f)).Fnext + if **(**uintptr)(__ccgo_up(head)) == f { + **(**uintptr)(__ccgo_up(head)) = (*TFILE)(unsafe.Pointer(f)).Fnext } X__ofl_unlock(tls) Xfree(tls, (*TFILE)(unsafe.Pointer(f)).Fgetln_buf) @@ -136137,7 +136137,7 @@ func Xfflush(tls *TLS, f uintptr) (r1 int32) { if AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stderr_used))) != 0 { r = r | Xfflush(tls, AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stderr_used)))) } - f = *(*uintptr)(unsafe.Pointer(X__ofl_lock(tls))) + f = **(**uintptr)(__ccgo_up(X__ofl_lock(tls))) for { if !(f != 0) { break @@ -136254,7 +136254,7 @@ _9: v11 = f + 8 v1 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v1))) } else { v2 = X__uflow(tls, f) } @@ -136325,7 +136325,7 @@ func Xfgetc(tls *TLS, f1 uintptr) (r int32) { v6 = v1 + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(v5))) } else { v4 = X__uflow(tls, v1) } @@ -136361,7 +136361,7 @@ func Xfgetln(tls *TLS, f uintptr, plen uintptr) (r uintptr) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__uflow(tls, f) } @@ -136374,14 +136374,14 @@ func Xfgetln(tls *TLS, f uintptr, plen uintptr) (r uintptr) { ret = (*TFILE)(unsafe.Pointer(f)).Frpos z = z + 1 v3 = z - *(*Tsize_t)(unsafe.Pointer(plen)) = Uint64FromInt64(int64(v3) - int64(ret)) + **(**Tsize_t)(__ccgo_up(plen)) = Uint64FromInt64(int64(v3) - int64(ret)) (*TFILE)(unsafe.Pointer(f)).Frpos = z } else { *(*[1]Tsize_t)(unsafe.Pointer(bp)) = [1]Tsize_t{} v8 = Xgetline(tls, f+168, bp, f) l = v8 if v8 > 0 { - *(*Tsize_t)(unsafe.Pointer(plen)) = Uint64FromInt64(l) + **(**Tsize_t)(__ccgo_up(plen)) = Uint64FromInt64(l) ret = (*TFILE)(unsafe.Pointer(f)).Fgetln_buf } } @@ -136402,7 +136402,7 @@ func Xfgetpos(tls *TLS, f uintptr, pos uintptr) (r int32) { if off < 0 { return -int32(1) } - *(*int64)(unsafe.Pointer(pos)) = off + **(**int64)(__ccgo_up(pos)) = off return 0 } @@ -136426,14 +136426,14 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { } __need_unlock = v1 if n <= int32(1) { - *(*int32)(unsafe.Pointer(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) + **(**int32)(__ccgo_up(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) if __need_unlock != 0 { ___unlockfile(tls, f) } if n < int32(1) { return uintptr(0) } - *(*int8)(unsafe.Pointer(s)) = 0 + **(**int8)(__ccgo_up(s)) = 0 return s } n = n - 1 @@ -136453,7 +136453,7 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { } k = v3 Xmemcpy(tls, p, (*TFILE)(unsafe.Pointer(f)).Frpos, k) - *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(k) + **(**uintptr)(__ccgo_up(f + 8)) += uintptr(k) p = p + uintptr(k) n = Int32FromUint64(uint64(n) - k) if z != 0 || !(n != 0) { @@ -136464,7 +136464,7 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { v7 = f + 8 v6 = *(*uintptr)(unsafe.Pointer(v7)) *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) + 1 - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(v6))) } else { v4 = X__uflow(tls, f) } @@ -136480,13 +136480,13 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { v8 = int8(c) v6 = p p = p + 1 - *(*int8)(unsafe.Pointer(v6)) = v8 + **(**int8)(__ccgo_up(v6)) = v8 if int32(v8) == int32('\n') { break } } if s != 0 { - *(*int8)(unsafe.Pointer(p)) = 0 + **(**int8)(__ccgo_up(p)) = 0 } if __need_unlock != 0 { ___unlockfile(tls, f) @@ -136516,43 +136516,43 @@ func ___fgetwc_unlocked_internal(tls *TLS, f uintptr) (r Twint_t) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { l = Uint64FromInt32(Xmbtowc(tls, bp, (*TFILE)(unsafe.Pointer(f)).Frpos, Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Frend)-int64((*TFILE)(unsafe.Pointer(f)).Frpos)))) if l+uint64(1) >= uint64(1) { - *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(l + BoolUint64(!(l != 0))) /* l==0 means 1 byte, null */ - return Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))) + **(**uintptr)(__ccgo_up(f + 8)) += uintptr(l + BoolUint64(!(l != 0))) /* l==0 means 1 byte, null */ + return Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))) } } /* Convert character byte-by-byte */ - *(*Tmbstate_t)(unsafe.Pointer(bp + 8)) = Tmbstate_t{} + **(**Tmbstate_t)(__ccgo_up(bp + 8)) = Tmbstate_t{} first = int32(1) for cond := true; cond; cond = l == Uint64FromInt32(-Int32FromInt32(2)) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__uflow(tls, f) } v1 = v2 c = v1 - *(*uint8)(unsafe.Pointer(bp + 16)) = Uint8FromInt32(v1) + **(**uint8)(__ccgo_up(bp + 16)) = Uint8FromInt32(v1) if c < 0 { if !(first != 0) { - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EILSEQ) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EILSEQ) } return uint32(0xffffffff) } l = Xmbrtowc(tls, bp, bp+16, uint64(1), bp+8) if l == Uint64FromInt32(-Int32FromInt32(1)) { if !(first != 0) { - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) - Xungetc(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + 16))), f) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) + Xungetc(tls, Int32FromUint8(**(**uint8)(__ccgo_up(bp + 16))), f) } return uint32(0xffffffff) } first = 0 } - return Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))) + return Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))) } func X__fgetwc_unlocked(tls *TLS, f uintptr) (r Twint_t) { @@ -136565,13 +136565,13 @@ func X__fgetwc_unlocked(tls *TLS, f uintptr) (r Twint_t) { var wc Twchar_t _, _, _ = loc, ploc, wc ploc = uintptr(___get_tp(tls)) + 152 - loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) + loc = **(**Tlocale_t)(__ccgo_up(ploc)) if (*TFILE)(unsafe.Pointer(f)).Fmode <= 0 { Xfwide(tls, f, int32(1)) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale + **(**Tlocale_t)(__ccgo_up(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale wc = Int32FromUint32(___fgetwc_unlocked_internal(tls, f)) - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return Uint32FromInt32(wc) } @@ -136643,7 +136643,7 @@ func Xfgetws(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { } v4 = p p += 4 - *(*Twchar_t)(unsafe.Pointer(v4)) = Int32FromUint32(c) + **(**Twchar_t)(__ccgo_up(v4)) = Int32FromUint32(c) if c == uint32('\n') { break } @@ -136652,7 +136652,7 @@ func Xfgetws(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { ; n = n - 1 } - *(*Twchar_t)(unsafe.Pointer(p)) = 0 + **(**Twchar_t)(__ccgo_up(p)) = 0 if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_ERR) != 0 { p = s } @@ -136693,7 +136693,7 @@ func Xfileno(tls *TLS, f uintptr) (r int32) { ___unlockfile(tls, f) } if fd < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EBADF) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EBADF) return -int32(1) } return fd @@ -136746,7 +136746,7 @@ func _mseek(tls *TLS, f uintptr, off Toff_t, whence int32) (r Toff_t) { goto fail fail: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) _1: ; @@ -136754,7 +136754,7 @@ _1: 1: (*Tcookie)(unsafe.Pointer(c)).Fpos, 2: (*Tcookie)(unsafe.Pointer(c)).Flen1, } - base = Int64FromUint64(*(*Tsize_t)(unsafe.Pointer(bp + uintptr(whence)*8))) + base = Int64FromUint64(**(**Tsize_t)(__ccgo_up(bp + uintptr(whence)*8))) if off < -base || off > Int64FromUint64((*Tcookie)(unsafe.Pointer(c)).Fsize)-base { goto fail } @@ -136774,10 +136774,10 @@ func _mread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { } if len1 > rem { len1 = rem - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_EOF) + **(**uint32)(__ccgo_up(f)) |= uint32(F_EOF) } Xmemcpy(tls, buf, (*Tcookie)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie)(unsafe.Pointer(c)).Fpos), len1) - *(*Tsize_t)(unsafe.Pointer(c)) += len1 + **(**Tsize_t)(__ccgo_up(c)) += len1 rem = rem - len1 if rem > (*TFILE)(unsafe.Pointer(f)).Fbuf_size { rem = (*TFILE)(unsafe.Pointer(f)).Fbuf_size @@ -136785,7 +136785,7 @@ func _mread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(rem) Xmemcpy(tls, (*TFILE)(unsafe.Pointer(f)).Frpos, (*Tcookie)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie)(unsafe.Pointer(c)).Fpos), rem) - *(*Tsize_t)(unsafe.Pointer(c)) += rem + **(**Tsize_t)(__ccgo_up(c)) += rem return len1 } @@ -136809,14 +136809,14 @@ func _mwrite(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { len1 = rem } Xmemcpy(tls, (*Tcookie)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie)(unsafe.Pointer(c)).Fpos), buf, len1) - *(*Tsize_t)(unsafe.Pointer(c)) += len1 + **(**Tsize_t)(__ccgo_up(c)) += len1 if (*Tcookie)(unsafe.Pointer(c)).Fpos > (*Tcookie)(unsafe.Pointer(c)).Flen1 { (*Tcookie)(unsafe.Pointer(c)).Flen1 = (*Tcookie)(unsafe.Pointer(c)).Fpos if (*Tcookie)(unsafe.Pointer(c)).Flen1 < (*Tcookie)(unsafe.Pointer(c)).Fsize { - *(*uint8)(unsafe.Pointer((*Tcookie)(unsafe.Pointer(c)).Fbuf + uintptr((*Tcookie)(unsafe.Pointer(c)).Flen1))) = uint8(0) + **(**uint8)(__ccgo_up((*Tcookie)(unsafe.Pointer(c)).Fbuf + uintptr((*Tcookie)(unsafe.Pointer(c)).Flen1))) = uint8(0) } else { if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_NORD) != 0 && (*Tcookie)(unsafe.Pointer(c)).Fsize != 0 { - *(*uint8)(unsafe.Pointer((*Tcookie)(unsafe.Pointer(c)).Fbuf + uintptr((*Tcookie)(unsafe.Pointer(c)).Fsize-uint64(1)))) = uint8(0) + **(**uint8)(__ccgo_up((*Tcookie)(unsafe.Pointer(c)).Fbuf + uintptr((*Tcookie)(unsafe.Pointer(c)).Fsize-uint64(1)))) = uint8(0) } } } @@ -136838,12 +136838,12 @@ func Xfmemopen(tls *TLS, buf uintptr, size Tsize_t, mode uintptr) (r uintptr) { var v3 Tsize_t _, _, _, _, _ = f, plus, v1, v2, v3 plus = BoolInt32(!!(Xstrchr(tls, mode, int32('+')) != 0)) - if !(Xstrchr(tls, __ccgo_ts+1494, int32(*(*int8)(unsafe.Pointer(mode)))) != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if !(Xstrchr(tls, __ccgo_ts+1494, int32(**(**int8)(__ccgo_up(mode)))) != 0) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } if !(buf != 0) && size > Uint64FromInt64(Int64FromInt64(INT64_MAX)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return uintptr(0) } if buf != 0 { @@ -136867,25 +136867,25 @@ func Xfmemopen(tls *TLS, buf uintptr, size Tsize_t, mode uintptr) (r uintptr) { } (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fbuf = buf (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fsize = size - (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fmode = int32(*(*int8)(unsafe.Pointer(mode))) + (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fmode = int32(**(**int8)(__ccgo_up(mode))) if !(plus != 0) { - if int32(*(*int8)(unsafe.Pointer(mode))) == int32('r') { + if int32(**(**int8)(__ccgo_up(mode))) == int32('r') { v2 = int32(F_NOWR) } else { v2 = int32(F_NORD) } (*Tmem_FILE)(unsafe.Pointer(f)).Ff.Fflags = Uint32FromInt32(v2) } - if int32(*(*int8)(unsafe.Pointer(mode))) == int32('r') { + if int32(**(**int8)(__ccgo_up(mode))) == int32('r') { (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Flen1 = size } else { - if int32(*(*int8)(unsafe.Pointer(mode))) == int32('a') { + if int32(**(**int8)(__ccgo_up(mode))) == int32('a') { v3 = Xstrnlen(tls, buf, size) (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fpos = v3 (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Flen1 = v3 } else { if plus != 0 { - *(*uint8)(unsafe.Pointer((*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fbuf)) = uint8(0) + **(**uint8)(__ccgo_up((*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fbuf)) = uint8(0) } } } @@ -136908,8 +136908,8 @@ func Xfopen(tls *TLS, filename uintptr, mode uintptr) (r uintptr) { var fd, flags int32 _, _, _ = f, fd, flags /* Check for valid initial mode character */ - if !(Xstrchr(tls, __ccgo_ts+1494, int32(*(*int8)(unsafe.Pointer(mode)))) != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if !(Xstrchr(tls, __ccgo_ts+1494, int32(**(**int8)(__ccgo_up(mode)))) != 0) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } /* Compute the flags to pass to open() */ @@ -136976,7 +136976,7 @@ func _cookieread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - *(*uint8)(unsafe.Pointer(buf + uintptr(v1))) = *(*uint8)(unsafe.Pointer(v2)) + **(**uint8)(__ccgo_up(buf + uintptr(v1))) = **(**uint8)(__ccgo_up(v2)) return readlen goto bail bail: @@ -136986,7 +136986,7 @@ bail: } else { v4 = int32(F_ERR) } - *(*uint32)(unsafe.Pointer(f)) |= Uint32FromInt32(v4) + **(**uint32)(__ccgo_up(f)) |= Uint32FromInt32(v4) v2 = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = v2 (*TFILE)(unsafe.Pointer(f)).Frpos = v2 @@ -137016,7 +137016,7 @@ func _cookiewrite(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { v1 = v2 (*TFILE)(unsafe.Pointer(f)).Fwbase = v1 (*TFILE)(unsafe.Pointer(f)).Fwpos = v1 - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) return uint64(0) } return Uint64FromInt64(ret) @@ -137031,18 +137031,18 @@ func _cookieseek(tls *TLS, f uintptr, _off Toff_t, whence int32) (r Toff_t) { _, _ = fc, res fc = (*TFILE)(unsafe.Pointer(f)).Fcookie if Uint32FromInt32(whence) > uint32(2) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) } if !((*Tfcookie)(unsafe.Pointer(fc)).Fiofuncs.Fseek != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOPNOTSUPP) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOPNOTSUPP) return int64(-int32(1)) } res = (*(*func(*TLS, uintptr, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{(*Tfcookie)(unsafe.Pointer(fc)).Fiofuncs.Fseek})))(tls, (*Tfcookie)(unsafe.Pointer(fc)).Fcookie, bp, whence) if res < 0 { return int64(res) } - return *(*Toff_t)(unsafe.Pointer(bp)) + return **(**Toff_t)(__ccgo_up(bp)) } func _cookieclose(tls *TLS, f uintptr) (r int32) { @@ -137064,8 +137064,8 @@ func Xfopencookie(tls *TLS, cookie uintptr, mode uintptr, iofuncs Tcookie_io_fun var v2 int32 _, _, _ = f, v1, v2 /* Check for valid initial mode character */ - if !(Xstrchr(tls, __ccgo_ts+1494, int32(*(*int8)(unsafe.Pointer(mode)))) != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if !(Xstrchr(tls, __ccgo_ts+1494, int32(**(**int8)(__ccgo_up(mode)))) != 0) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } /* Allocate FILE+fcookie+buffer or fail */ @@ -137078,7 +137078,7 @@ func Xfopencookie(tls *TLS, cookie uintptr, mode uintptr, iofuncs Tcookie_io_fun Xmemset(tls, f, 0, uint64(232)) /* Impose mode restrictions */ if !(Xstrchr(tls, mode, int32('+')) != 0) { - if int32(*(*int8)(unsafe.Pointer(mode))) == int32('r') { + if int32(**(**int8)(__ccgo_up(mode))) == int32('r') { v2 = int32(F_NOWR) } else { v2 = int32(F_NORD) @@ -137167,7 +137167,7 @@ _9: v12 = f + 40 v1 = *(*uintptr)(unsafe.Pointer(v12)) *(*uintptr)(unsafe.Pointer(v12)) = *(*uintptr)(unsafe.Pointer(v12)) + 1 - *(*uint8)(unsafe.Pointer(v1)) = v11 + **(**uint8)(__ccgo_up(v1)) = v11 v2 = Int32FromUint8(v11) } else { v2 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) @@ -137242,7 +137242,7 @@ func Xfputc(tls *TLS, c1 int32, f1 uintptr) (r int32) { v8 = v2 + 40 v7 = *(*uintptr)(unsafe.Pointer(v8)) *(*uintptr)(unsafe.Pointer(v8)) = *(*uintptr)(unsafe.Pointer(v8)) + 1 - *(*uint8)(unsafe.Pointer(v7)) = v6 + **(**uint8)(__ccgo_up(v7)) = v6 v5 = Int32FromUint8(v6) } else { v5 = X__overflow(tls, v2, Int32FromUint8(Uint8FromInt32(v1))) @@ -137289,18 +137289,18 @@ func X__fputwc_unlocked(tls *TLS, c Twchar_t, f uintptr) (r Twint_t) { var _ /* mbc at bp+0 */ [4]int8 _, _, _, _, _, _, _ = l, loc, ploc, v1, v2, v3, v4 ploc = uintptr(___get_tp(tls)) + 152 - loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) + loc = **(**Tlocale_t)(__ccgo_up(ploc)) if (*TFILE)(unsafe.Pointer(f)).Fmode <= 0 { Xfwide(tls, f, int32(1)) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale + **(**Tlocale_t)(__ccgo_up(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale if BoolInt32(Uint32FromInt32(c) < uint32(128)) != 0 { if Int32FromUint8(Uint8FromInt32(c)) != (*TFILE)(unsafe.Pointer(f)).Flbf && (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwend { v2 = Uint8FromInt32(c) v4 = f + 40 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(v3)) = v2 + **(**uint8)(__ccgo_up(v3)) = v2 v1 = Int32FromUint8(v2) } else { v1 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) @@ -137312,7 +137312,7 @@ func X__fputwc_unlocked(tls *TLS, c Twchar_t, f uintptr) (r Twint_t) { if l < 0 { c = Int32FromUint32(0xffffffff) } else { - *(*uintptr)(unsafe.Pointer(f + 40)) += uintptr(l) + **(**uintptr)(__ccgo_up(f + 40)) += uintptr(l) } } else { l = Xwctomb(tls, bp, c) @@ -137322,9 +137322,9 @@ func X__fputwc_unlocked(tls *TLS, c Twchar_t, f uintptr) (r Twint_t) { } } if Uint32FromInt32(c) == uint32(0xffffffff) { - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return Uint32FromInt32(c) } @@ -137381,7 +137381,7 @@ func Xfputws(tls *TLS, _ws uintptr, f uintptr) (r int32) { _, _, _, _, _, _, _ = __need_unlock, l, loc, ploc, v1, v2, v3 l = uint64(0) ploc = uintptr(___get_tp(tls)) + 152 - loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) + loc = **(**Tlocale_t)(__ccgo_up(ploc)) if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) } else { @@ -137389,9 +137389,9 @@ func Xfputws(tls *TLS, _ws uintptr, f uintptr) (r int32) { } __need_unlock = v1 Xfwide(tls, f, int32(1)) - *(*Tlocale_t)(unsafe.Pointer(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale + **(**Tlocale_t)(__ccgo_up(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale for { - if v3 = *(*uintptr)(unsafe.Pointer(bp)) != 0; v3 { + if v3 = **(**uintptr)(__ccgo_up(bp)) != 0; v3 { v2 = Xwcsrtombs(tls, bp+8, bp, uint64(1024), uintptr(0)) l = v2 } @@ -137402,14 +137402,14 @@ func Xfputws(tls *TLS, _ws uintptr, f uintptr) (r int32) { if __need_unlock != 0 { ___unlockfile(tls, f) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return -int32(1) } } if __need_unlock != 0 { ___unlockfile(tls, f) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return Int32FromUint64(l) /* 0 or -1 */ } @@ -137443,7 +137443,7 @@ func Xfread(tls *TLS, destv uintptr, size Tsize_t, nmemb Tsize_t, f uintptr) (r v1 = 0 } __need_unlock = v1 - *(*int32)(unsafe.Pointer(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) + **(**int32)(__ccgo_up(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { /* First exhaust the buffer. */ if Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Frend)-int64((*TFILE)(unsafe.Pointer(f)).Frpos)) < l { @@ -137453,7 +137453,7 @@ func Xfread(tls *TLS, destv uintptr, size Tsize_t, nmemb Tsize_t, f uintptr) (r } k = v2 Xmemcpy(tls, dest, (*TFILE)(unsafe.Pointer(f)).Frpos, k) - *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(k) + **(**uintptr)(__ccgo_up(f + 8)) += uintptr(k) dest = dest + uintptr(k) l = l - k } @@ -137593,7 +137593,7 @@ func X__fseeko_unlocked(tls *TLS, f uintptr, off Toff_t, whence int32) (r int32) _, _ = v1, v2 /* Fail immediately for invalid whence argument. */ if whence != int32(1) && whence != 0 && whence != int32(2) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } /* Adjust relative offset for unread data in buffer, if any. */ @@ -137621,7 +137621,7 @@ func X__fseeko_unlocked(tls *TLS, f uintptr, off Toff_t, whence int32) (r int32) v1 = UintptrFromInt32(0) (*TFILE)(unsafe.Pointer(f)).Frend = v1 (*TFILE)(unsafe.Pointer(f)).Frpos = v1 - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) return 0 } @@ -137666,7 +137666,7 @@ func Xfsetpos(tls *TLS, f uintptr, pos uintptr) (r int32) { trc("tls=%v f=%v pos=%v, (%v:)", tls, f, pos, origin(2)) defer func() { trc("-> %v", r) }() } - return X__fseeko(tls, f, *(*int64)(unsafe.Pointer(pos)), 0) + return X__fseeko(tls, f, int64(**(**int64)(__ccgo_up(pos))), 0) } /* Support signed or unsigned plain-char */ @@ -137736,7 +137736,7 @@ func Xftell(tls *TLS, f uintptr) (r int64) { _ = pos pos = X__ftello(tls, f) if pos > int64(0x7fffffffffffffff) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return int64(-int32(1)) } return pos @@ -137902,7 +137902,7 @@ func Xfwide(tls *TLS, f uintptr, mode int32) (r int32) { __need_unlock = v1 if mode != 0 { if !((*TFILE)(unsafe.Pointer(f)).Flocale != 0) { - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v3 = int32(4) } else { v3 = int32(1) @@ -137962,7 +137962,7 @@ func X__fwritex(tls *TLS, s uintptr, l Tsize_t, f uintptr) (r Tsize_t) { /* Match /^(.*\n|)/ */ i = l for { - if !(i != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(i-uint64(1))))) != int32('\n')) { + if !(i != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(i-uint64(1))))) != int32('\n')) { break } goto _1 @@ -137980,7 +137980,7 @@ func X__fwritex(tls *TLS, s uintptr, l Tsize_t, f uintptr) (r Tsize_t) { } } Xmemcpy(tls, (*TFILE)(unsafe.Pointer(f)).Fwpos, s, l) - *(*uintptr)(unsafe.Pointer(f + 40)) += uintptr(l) + **(**uintptr)(__ccgo_up(f + 40)) += uintptr(l) return l + i } @@ -138094,7 +138094,7 @@ _9: v11 = f + 8 v1 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v1))) } else { v2 = X__uflow(tls, f) } @@ -138165,7 +138165,7 @@ func Xgetc(tls *TLS, f1 uintptr) (r int32) { v6 = v1 + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(v5))) } else { v4 = X__uflow(tls, v1) } @@ -138198,7 +138198,7 @@ func Xgetc_unlocked(tls *TLS, f uintptr) (r int32) { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__uflow(tls, f) } @@ -138270,7 +138270,7 @@ _9: v11 = f + 8 v1 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v1))) } else { v2 = X__uflow(tls, f) } @@ -138341,7 +138341,7 @@ func Xgetchar(tls *TLS) (r int32) { v6 = v1 + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(v5))) } else { v4 = X__uflow(tls, v1) } @@ -138366,7 +138366,7 @@ func Xgetchar_unlocked(tls *TLS) (r int32) { v3 = uintptr(unsafe.Pointer(&X__stdin_FILE)) + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__uflow(tls, uintptr(unsafe.Pointer(&X__stdin_FILE))) } @@ -138392,16 +138392,16 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize } __need_unlock = v1 if !(n != 0) || !(s != 0) { - *(*int32)(unsafe.Pointer(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**int32)(__ccgo_up(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) if __need_unlock != 0 { ___unlockfile(tls, f) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) } - if !(*(*uintptr)(unsafe.Pointer(s)) != 0) { - *(*Tsize_t)(unsafe.Pointer(n)) = uint64(0) + if !(**(**uintptr)(__ccgo_up(s)) != 0) { + **(**Tsize_t)(__ccgo_up(n)) = uint64(0) } for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { @@ -138416,36 +138416,36 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize z = uintptr(0) k = uint64(0) } - if i+k >= *(*Tsize_t)(unsafe.Pointer(n)) { + if i+k >= **(**Tsize_t)(__ccgo_up(n)) { m = i + k + uint64(2) if !(z != 0) && m < Uint64FromUint64(0xffffffffffffffff)/Uint64FromInt32(4) { m = m + m/uint64(2) } - tmp = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(s)), m) + tmp = Xrealloc(tls, **(**uintptr)(__ccgo_up(s)), m) if !(tmp != 0) { m = i + k + uint64(2) - tmp = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(s)), m) + tmp = Xrealloc(tls, **(**uintptr)(__ccgo_up(s)), m) if !(tmp != 0) { /* Copy as much as fits and ensure no * pushback remains in the FILE buf. */ - k = *(*Tsize_t)(unsafe.Pointer(n)) - i - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(s))+uintptr(i), (*TFILE)(unsafe.Pointer(f)).Frpos, k) - *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(k) - *(*int32)(unsafe.Pointer(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + k = **(**Tsize_t)(__ccgo_up(n)) - i + Xmemcpy(tls, **(**uintptr)(__ccgo_up(s))+uintptr(i), (*TFILE)(unsafe.Pointer(f)).Frpos, k) + **(**uintptr)(__ccgo_up(f + 8)) += uintptr(k) + **(**int32)(__ccgo_up(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) if __need_unlock != 0 { ___unlockfile(tls, f) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return int64(-int32(1)) } } - *(*uintptr)(unsafe.Pointer(s)) = tmp - *(*Tsize_t)(unsafe.Pointer(n)) = m + **(**uintptr)(__ccgo_up(s)) = tmp + **(**Tsize_t)(__ccgo_up(n)) = m } if k != 0 { - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(s))+uintptr(i), (*TFILE)(unsafe.Pointer(f)).Frpos, k) - *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(k) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(s))+uintptr(i), (*TFILE)(unsafe.Pointer(f)).Frpos, k) + **(**uintptr)(__ccgo_up(f + 8)) += uintptr(k) i = i + k } if z != 0 { @@ -138455,7 +138455,7 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize v7 = f + 8 v6 = *(*uintptr)(unsafe.Pointer(v7)) *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) + 1 - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(v6))) } else { v4 = X__uflow(tls, f) } @@ -138472,16 +138472,16 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize } /* If the byte read by getc won't fit without growing the * output buffer, push it back for next iteration. */ - if i+uint64(1) >= *(*Tsize_t)(unsafe.Pointer(n)) { + if i+uint64(1) >= **(**Tsize_t)(__ccgo_up(n)) { v7 = f + 8 *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) - 1 v6 = *(*uintptr)(unsafe.Pointer(v7)) - *(*uint8)(unsafe.Pointer(v6)) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(v6)) = Uint8FromInt32(c) } else { v10 = int8(c) v11 = i i = i + 1 - *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)) + uintptr(v11))) = v10 + **(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)) + uintptr(v11))) = v10 if int32(v10) == delim { break } @@ -138489,7 +138489,7 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize goto _2 _2: } - *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)) + uintptr(i))) = 0 + **(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)) + uintptr(i))) = 0 if __need_unlock != 0 { ___unlockfile(tls, f) } @@ -138533,7 +138533,7 @@ func Xgets(tls *TLS, s uintptr) (r uintptr) { v5 = uintptr(unsafe.Pointer(&X__stdin_FILE)) + 8 v4 = *(*uintptr)(unsafe.Pointer(v5)) *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v4))) } else { v3 = X__uflow(tls, uintptr(unsafe.Pointer(&X__stdin_FILE))) } @@ -138544,9 +138544,9 @@ func Xgets(tls *TLS, s uintptr) (r uintptr) { } v6 = i i = i + 1 - *(*int8)(unsafe.Pointer(s + uintptr(v6))) = int8(c) + **(**int8)(__ccgo_up(s + uintptr(v6))) = int8(c) } - *(*int8)(unsafe.Pointer(s + uintptr(i))) = 0 + **(**int8)(__ccgo_up(s + uintptr(i))) = 0 if c != int32('\n') && (!((*TFILE)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stdin_FILE)))).Fflags&Uint32FromInt32(F_EOF) != 0) || !(i != 0)) { s = uintptr(0) } @@ -138567,7 +138567,7 @@ func Xgetw(tls *TLS, f uintptr) (r int32) { var _ /* x at bp+0 */ int32 _ = v1 if Xfread(tls, bp, uint64(4), uint64(1), f) != 0 { - v1 = *(*int32)(unsafe.Pointer(bp)) + v1 = **(**int32)(__ccgo_up(bp)) } else { v1 = -int32(1) } @@ -138625,11 +138625,11 @@ func X__ofl_add(tls *TLS, f uintptr) (r uintptr) { var head uintptr _ = head head = X__ofl_lock(tls) - (*TFILE)(unsafe.Pointer(f)).Fnext = *(*uintptr)(unsafe.Pointer(head)) - if *(*uintptr)(unsafe.Pointer(head)) != 0 { - (*TFILE)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(head)))).Fprev = f + (*TFILE)(unsafe.Pointer(f)).Fnext = **(**uintptr)(__ccgo_up(head)) + if **(**uintptr)(__ccgo_up(head)) != 0 { + (*TFILE)(unsafe.Pointer(**(**uintptr)(__ccgo_up(head)))).Fprev = f } - *(*uintptr)(unsafe.Pointer(head)) = f + **(**uintptr)(__ccgo_up(head)) = f X__ofl_unlock(tls) return f } @@ -138663,7 +138663,7 @@ func _ms_seek(tls *TLS, f uintptr, off Toff_t, whence int32) (r Toff_t) { goto fail fail: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) _1: ; @@ -138671,7 +138671,7 @@ _1: 1: (*Tcookie1)(unsafe.Pointer(c)).Fpos, 2: (*Tcookie1)(unsafe.Pointer(c)).Flen1, } - base = Int64FromUint64(*(*Tsize_t)(unsafe.Pointer(bp + uintptr(whence)*8))) + base = Int64FromUint64(**(**Tsize_t)(__ccgo_up(bp + uintptr(whence)*8))) if off < -base || off > int64(0x7fffffffffffffff)-base { goto fail } @@ -138700,16 +138700,16 @@ func _ms_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { } v1 = newbuf (*Tcookie1)(unsafe.Pointer(c)).Fbuf = v1 - *(*uintptr)(unsafe.Pointer((*Tcookie1)(unsafe.Pointer(c)).Fbufp)) = v1 + **(**uintptr)(__ccgo_up((*Tcookie1)(unsafe.Pointer(c)).Fbufp)) = v1 Xmemset(tls, (*Tcookie1)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie1)(unsafe.Pointer(c)).Fspace), 0, len2-(*Tcookie1)(unsafe.Pointer(c)).Fspace) (*Tcookie1)(unsafe.Pointer(c)).Fspace = len2 } Xmemcpy(tls, (*Tcookie1)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie1)(unsafe.Pointer(c)).Fpos), buf, len1) - *(*Tsize_t)(unsafe.Pointer(c + 16)) += len1 + **(**Tsize_t)(__ccgo_up(c + 16)) += len1 if (*Tcookie1)(unsafe.Pointer(c)).Fpos >= (*Tcookie1)(unsafe.Pointer(c)).Flen1 { (*Tcookie1)(unsafe.Pointer(c)).Flen1 = (*Tcookie1)(unsafe.Pointer(c)).Fpos } - *(*Tsize_t)(unsafe.Pointer((*Tcookie1)(unsafe.Pointer(c)).Fsizep)) = (*Tcookie1)(unsafe.Pointer(c)).Fpos + **(**Tsize_t)(__ccgo_up((*Tcookie1)(unsafe.Pointer(c)).Fsizep)) = (*Tcookie1)(unsafe.Pointer(c)).Fpos return len1 } @@ -138742,16 +138742,16 @@ func Xopen_memstream(tls *TLS, bufp uintptr, sizep uintptr) (r uintptr) { (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fbufp = bufp (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fsizep = sizep v5 = Uint64FromInt32(0) - *(*Tsize_t)(unsafe.Pointer(sizep)) = v5 + **(**Tsize_t)(__ccgo_up(sizep)) = v5 v4 = v5 (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fspace = v4 v3 = v4 (*Tms_FILE)(unsafe.Pointer(f)).Fc.Flen1 = v3 (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fpos = v3 v1 = buf - *(*uintptr)(unsafe.Pointer(bufp)) = v1 + **(**uintptr)(__ccgo_up(bufp)) = v1 (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fbuf = v1 - *(*int8)(unsafe.Pointer(buf)) = 0 + **(**int8)(__ccgo_up(buf)) = 0 (*Tms_FILE)(unsafe.Pointer(f)).Ff.Fflags = uint32(F_NORD) (*Tms_FILE)(unsafe.Pointer(f)).Ff.Ffd = -int32(1) (*Tms_FILE)(unsafe.Pointer(f)).Ff.Fbuf = f + 280 @@ -138797,7 +138797,7 @@ func _wms_seek(tls *TLS, f uintptr, off Toff_t, whence int32) (r Toff_t) { goto fail fail: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) _1: ; @@ -138805,7 +138805,7 @@ _1: 1: (*Tcookie2)(unsafe.Pointer(c)).Fpos, 2: (*Tcookie2)(unsafe.Pointer(c)).Flen1, } - base = Int64FromUint64(*(*Tsize_t)(unsafe.Pointer(bp + uintptr(whence)*8))) + base = Int64FromUint64(**(**Tsize_t)(__ccgo_up(bp + uintptr(whence)*8))) if off < -base || off > Int64FromInt64(0x7fffffffffffffff)/Int64FromInt32(4)-base { goto fail } @@ -138841,7 +138841,7 @@ func _wms_write(tls *TLS, f uintptr, _buf uintptr, len1 Tsize_t) (r Tsize_t) { } v1 = newbuf (*Tcookie2)(unsafe.Pointer(c)).Fbuf = v1 - *(*uintptr)(unsafe.Pointer((*Tcookie2)(unsafe.Pointer(c)).Fbufp)) = v1 + **(**uintptr)(__ccgo_up((*Tcookie2)(unsafe.Pointer(c)).Fbufp)) = v1 Xmemset(tls, (*Tcookie2)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie2)(unsafe.Pointer(c)).Fspace)*4, 0, uint64(4)*(len2-(*Tcookie2)(unsafe.Pointer(c)).Fspace)) (*Tcookie2)(unsafe.Pointer(c)).Fspace = len2 } @@ -138849,11 +138849,11 @@ func _wms_write(tls *TLS, f uintptr, _buf uintptr, len1 Tsize_t) (r Tsize_t) { if len2 == Uint64FromInt32(-Int32FromInt32(1)) { return uint64(0) } - *(*Tsize_t)(unsafe.Pointer(c + 16)) += len2 + **(**Tsize_t)(__ccgo_up(c + 16)) += len2 if (*Tcookie2)(unsafe.Pointer(c)).Fpos >= (*Tcookie2)(unsafe.Pointer(c)).Flen1 { (*Tcookie2)(unsafe.Pointer(c)).Flen1 = (*Tcookie2)(unsafe.Pointer(c)).Fpos } - *(*Tsize_t)(unsafe.Pointer((*Tcookie2)(unsafe.Pointer(c)).Fsizep)) = (*Tcookie2)(unsafe.Pointer(c)).Fpos + **(**Tsize_t)(__ccgo_up((*Tcookie2)(unsafe.Pointer(c)).Fsizep)) = (*Tcookie2)(unsafe.Pointer(c)).Fpos return len1 } @@ -138886,16 +138886,16 @@ func Xopen_wmemstream(tls *TLS, bufp uintptr, sizep uintptr) (r uintptr) { (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fbufp = bufp (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fsizep = sizep v5 = Uint64FromInt32(0) - *(*Tsize_t)(unsafe.Pointer(sizep)) = v5 + **(**Tsize_t)(__ccgo_up(sizep)) = v5 v4 = v5 (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fspace = v4 v3 = v4 (*Twms_FILE)(unsafe.Pointer(f)).Fc.Flen1 = v3 (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fpos = v3 v1 = buf - *(*uintptr)(unsafe.Pointer(bufp)) = v1 + **(**uintptr)(__ccgo_up(bufp)) = v1 (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fbuf = v1 - *(*Twchar_t)(unsafe.Pointer(buf)) = 0 + **(**Twchar_t)(__ccgo_up(buf)) = 0 (*Twms_FILE)(unsafe.Pointer(f)).Ff.Fflags = uint32(F_NORD) (*Twms_FILE)(unsafe.Pointer(f)).Ff.Ffd = -int32(1) (*Twms_FILE)(unsafe.Pointer(f)).Ff.Fbuf = f + 288 @@ -138934,7 +138934,7 @@ func Xpclose(tls *TLS, f uintptr) (r1 int32) { if r < 0 { return int32(X__syscall_ret(tls, Uint64FromInt32(r))) } - return *(*int32)(unsafe.Pointer(bp)) + return **(**int32)(__ccgo_up(bp)) } func Xperror(tls *TLS, msg uintptr) { @@ -138945,7 +138945,7 @@ func Xperror(tls *TLS, msg uintptr) { var errstr, f, old_locale uintptr _, _, _, _, _, _ = __need_unlock, errstr, f, old_locale, old_mode, v1 f = uintptr(unsafe.Pointer(&X__stderr_FILE)) - errstr = Xstrerror(tls, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) + errstr = Xstrerror(tls, **(**int32)(__ccgo_up(X__errno_location(tls)))) if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) } else { @@ -138956,7 +138956,7 @@ func Xperror(tls *TLS, msg uintptr) { * permitted to change them. */ old_locale = (*TFILE)(unsafe.Pointer(f)).Flocale old_mode = (*TFILE)(unsafe.Pointer(f)).Fmode - if msg != 0 && *(*int8)(unsafe.Pointer(msg)) != 0 { + if msg != 0 && **(**int8)(__ccgo_up(msg)) != 0 { Xfwrite(tls, msg, _strlen(tls, msg), uint64(1), f) Xfputc(tls, int32(':'), f) Xfputc(tls, int32(' '), f) @@ -139035,7 +139035,7 @@ _9: v12 = f + 40 v1 = *(*uintptr)(unsafe.Pointer(v12)) *(*uintptr)(unsafe.Pointer(v12)) = *(*uintptr)(unsafe.Pointer(v12)) + 1 - *(*uint8)(unsafe.Pointer(v1)) = v11 + **(**uint8)(__ccgo_up(v1)) = v11 v2 = Int32FromUint8(v11) } else { v2 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) @@ -139110,7 +139110,7 @@ func Xputc(tls *TLS, c1 int32, f1 uintptr) (r int32) { v8 = v2 + 40 v7 = *(*uintptr)(unsafe.Pointer(v8)) *(*uintptr)(unsafe.Pointer(v8)) = *(*uintptr)(unsafe.Pointer(v8)) + 1 - *(*uint8)(unsafe.Pointer(v7)) = v6 + **(**uint8)(__ccgo_up(v7)) = v6 v5 = Int32FromUint8(v6) } else { v5 = X__overflow(tls, v2, Int32FromUint8(Uint8FromInt32(v1))) @@ -139146,7 +139146,7 @@ func Xputc_unlocked(tls *TLS, c int32, f uintptr) (r int32) { v4 = f + 40 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(v3)) = v2 + **(**uint8)(__ccgo_up(v3)) = v2 v1 = Int32FromUint8(v2) } else { v1 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) @@ -139221,7 +139221,7 @@ _9: v12 = f + 40 v1 = *(*uintptr)(unsafe.Pointer(v12)) *(*uintptr)(unsafe.Pointer(v12)) = *(*uintptr)(unsafe.Pointer(v12)) + 1 - *(*uint8)(unsafe.Pointer(v1)) = v11 + **(**uint8)(__ccgo_up(v1)) = v11 v2 = Int32FromUint8(v11) } else { v2 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) @@ -139296,7 +139296,7 @@ func Xputchar(tls *TLS, c1 int32) (r int32) { v8 = v2 + 40 v7 = *(*uintptr)(unsafe.Pointer(v8)) *(*uintptr)(unsafe.Pointer(v8)) = *(*uintptr)(unsafe.Pointer(v8)) + 1 - *(*uint8)(unsafe.Pointer(v7)) = v6 + **(**uint8)(__ccgo_up(v7)) = v6 v5 = Int32FromUint8(v6) } else { v5 = X__overflow(tls, v2, Int32FromUint8(Uint8FromInt32(v1))) @@ -139324,7 +139324,7 @@ func Xputchar_unlocked(tls *TLS, c int32) (r int32) { v4 = uintptr(unsafe.Pointer(&X__stdout_FILE)) + 40 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(v3)) = v2 + **(**uint8)(__ccgo_up(v3)) = v2 v1 = Int32FromUint8(v2) } else { v1 = X__overflow(tls, uintptr(unsafe.Pointer(&X__stdout_FILE)), Int32FromUint8(Uint8FromInt32(c))) @@ -139354,7 +139354,7 @@ func Xputs(tls *TLS, s uintptr) (r1 int32) { v5 = uintptr(unsafe.Pointer(&X__stdout_FILE)) + 40 v4 = *(*uintptr)(unsafe.Pointer(v5)) *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = v3 + **(**uint8)(__ccgo_up(v4)) = v3 v2 = Int32FromUint8(v3) } else { v2 = X__overflow(tls, uintptr(unsafe.Pointer(&X__stdout_FILE)), Int32FromUint8(Uint8FromInt32(Int32FromUint8('\n')))) @@ -139437,7 +139437,7 @@ func Xrewind(tls *TLS, f uintptr) { } __need_unlock = v1 X__fseeko_unlocked(tls, f, 0, 0) - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_ERR)) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^Int32FromInt32(F_ERR)) if __need_unlock != 0 { ___unlockfile(tls, f) } @@ -139527,7 +139527,7 @@ func Xsetvbuf(tls *TLS, f uintptr, buf uintptr, type1 int32, size Tsize_t) (r in return -int32(1) } } - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_SVB) + **(**uint32)(__ccgo_up(f)) |= uint32(F_SVB) return 0 } @@ -139667,14 +139667,14 @@ func Xtempnam(tls *TLS, dir uintptr, pfx uintptr) (r1 uintptr) { pl = _strlen(tls, pfx) l = dl + uint64(1) + pl + uint64(1) + uint64(6) if l >= uint64(PATH_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENAMETOOLONG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENAMETOOLONG) return uintptr(0) } Xmemcpy(tls, bp+1, dir, dl) - (*(*[4096]int8)(unsafe.Pointer(bp + 1)))[dl] = int8('/') + (**(**[4096]int8)(__ccgo_up(bp + 1)))[dl] = int8('/') Xmemcpy(tls, bp+1+uintptr(dl)+uintptr(1), pfx, pl) - (*(*[4096]int8)(unsafe.Pointer(bp + 1)))[dl+uint64(1)+pl] = int8('_') - (*(*[4096]int8)(unsafe.Pointer(bp + 1)))[l] = 0 + (**(**[4096]int8)(__ccgo_up(bp + 1)))[dl+uint64(1)+pl] = int8('_') + (**(**[4096]int8)(__ccgo_up(bp + 1)))[l] = 0 try = 0 for { if !(try < int32(MAXTRIES)) { @@ -139705,7 +139705,7 @@ func Xtmpfile(tls *TLS) (r uintptr) { var fd, try int32 var _ /* s at bp+0 */ [20]int8 _, _, _ = f, fd, try - *(*[20]int8)(unsafe.Pointer(bp)) = [20]int8{'/', 't', 'm', 'p', '/', 't', 'm', 'p', 'f', 'i', 'l', 'e', '_', 'X', 'X', 'X', 'X', 'X', 'X'} + **(**[20]int8)(__ccgo_up(bp)) = [20]int8{'/', 't', 'm', 'p', '/', 't', 'm', 'p', 'f', 'i', 'l', 'e', '_', 'X', 'X', 'X', 'X', 'X', 'X'} try = 0 for { if !(try < int32(MAXTRIES)) { @@ -139740,7 +139740,7 @@ func Xtmpnam(tls *TLS, buf uintptr) (r1 uintptr) { var v2 uintptr var _ /* s at bp+1 */ [19]int8 _, _, _ = r, try, v2 - *(*[19]int8)(unsafe.Pointer(bp + 1)) = [19]int8{'/', 't', 'm', 'p', '/', 't', 'm', 'p', 'n', 'a', 'm', '_', 'X', 'X', 'X', 'X', 'X', 'X'} + **(**[19]int8)(__ccgo_up(bp + 1)) = [19]int8{'/', 't', 'm', 'p', '/', 't', 'm', 'p', 'n', 'a', 'm', '_', 'X', 'X', 'X', 'X', 'X', 'X'} try = 0 for { if !(try < int32(MAXTRIES)) { @@ -139796,8 +139796,8 @@ func Xungetc(tls *TLS, c int32, f uintptr) (r int32) { v3 = f + 8 *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) - 1 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(c) - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) + **(**uint8)(__ccgo_up(v2)) = Uint8FromInt32(c) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) if __need_unlock != 0 { ___unlockfile(tls, f) } @@ -139818,7 +139818,7 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { var _ /* mbc at bp+0 */ [4]uint8 _, _, _, _, _, _, _, _ = __need_unlock, l, loc, ploc, v1, v3, v4, v5 ploc = uintptr(___get_tp(tls)) + 152 - loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) + loc = **(**Tlocale_t)(__ccgo_up(ploc)) if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) } else { @@ -139828,7 +139828,7 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { if (*TFILE)(unsafe.Pointer(f)).Fmode <= 0 { Xfwide(tls, f, int32(1)) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale + **(**Tlocale_t)(__ccgo_up(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale if !((*TFILE)(unsafe.Pointer(f)).Frpos != 0) { X__toread(tls, f) } @@ -139840,24 +139840,24 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { if __need_unlock != 0 { ___unlockfile(tls, f) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return uint32(0xffffffff) } if BoolInt32(c < uint32(128)) != 0 { v5 = f + 8 *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) - 1 v4 = *(*uintptr)(unsafe.Pointer(v5)) - *(*uint8)(unsafe.Pointer(v4)) = uint8(c) + **(**uint8)(__ccgo_up(v4)) = uint8(c) } else { v4 = f + 8 *(*uintptr)(unsafe.Pointer(v4)) -= uintptr(l) Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(v4)), bp, Uint64FromInt32(l)) } - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) if __need_unlock != 0 { ___unlockfile(tls, f) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return c } @@ -139876,12 +139876,12 @@ func Xvasprintf(tls *TLS, s uintptr, fmt uintptr, ap Tva_list) (r int32) { _ = ap2 if v2 = l < 0; !v2 { v1 = Xmalloc(tls, uint64(Uint32FromInt32(l)+uint32(1))) - *(*uintptr)(unsafe.Pointer(s)) = v1 + **(**uintptr)(__ccgo_up(s)) = v1 } if v2 || !(v1 != 0) { return -int32(1) } - return Xvsnprintf(tls, *(*uintptr)(unsafe.Pointer(s)), uint64(Uint32FromInt32(l)+uint32(1)), fmt, ap) + return Xvsnprintf(tls, **(**uintptr)(__ccgo_up(s)), uint64(Uint32FromInt32(l)+uint32(1)), fmt, ap) } func Xvdprintf(tls *TLS, fd int32, fmt uintptr, ap Tva_list) (r int32) { @@ -139892,7 +139892,7 @@ func Xvdprintf(tls *TLS, fd int32, fmt uintptr, ap Tva_list) (r int32) { bp := tls.Alloc(240) defer tls.Free(240) var _ /* f at bp+0 */ TFILE - *(*TFILE)(unsafe.Pointer(bp)) = TFILE{ + **(**TFILE)(__ccgo_up(bp)) = TFILE{ Fwrite: __ccgo_fp(X__stdio_write), Fbuf: fmt, Ffd: fd, @@ -140059,41 +140059,41 @@ type Targ = struct { func _pop_arg(tls *TLS, arg uintptr, type1 int32, ap uintptr) { switch type1 { case int32(_PTR): - *(*uintptr)(unsafe.Pointer(arg)) = VaUintptr(&*(*Tva_list)(unsafe.Pointer(ap))) + *(*uintptr)(unsafe.Pointer(arg)) = VaUintptr(&**(**Tva_list)(__ccgo_up(ap))) case int32(_INT): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_UINT): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint32(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint32(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_LONG): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_ULONG): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&**(**Tva_list)(__ccgo_up(ap))) case int32(_ULLONG): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_SHORT): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt16(int16(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt16(int16(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_USHORT): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint16FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint16FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_CHAR): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt8(int8(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt8(int8(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_UCHAR): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint8FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint8FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_LLONG): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_SIZET): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&**(**Tva_list)(__ccgo_up(ap))) case int32(_IMAX): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_UMAX): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&**(**Tva_list)(__ccgo_up(ap))) case int32(_PDIFF): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_UIPTR): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUintptr(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUintptr(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_DBL): - *(*float64)(unsafe.Pointer(arg)) = float64(VaFloat64(&*(*Tva_list)(unsafe.Pointer(ap)))) + *(*float64)(unsafe.Pointer(arg)) = float64(VaFloat64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_LDBL): - *(*float64)(unsafe.Pointer(arg)) = VaFloat64(&*(*Tva_list)(unsafe.Pointer(ap))) + *(*float64)(unsafe.Pointer(arg)) = VaFloat64(&**(**Tva_list)(__ccgo_up(ap))) } } @@ -140143,7 +140143,7 @@ func _fmt_x(tls *TLS, x Tuintmax_t, s uintptr, lower int32) (r uintptr) { } s = s - 1 v2 = s - *(*int8)(unsafe.Pointer(v2)) = int8(int32(_xdigits1[x&uint64(15)]) | lower) + **(**int8)(__ccgo_up(v2)) = int8(int32(_xdigits1[x&uint64(15)]) | lower) goto _1 _1: ; @@ -140161,7 +140161,7 @@ func _fmt_o(tls *TLS, x Tuintmax_t, s uintptr) (r uintptr) { } s = s - 1 v2 = s - *(*int8)(unsafe.Pointer(v2)) = Int8FromUint64(uint64('0') + x&uint64(7)) + **(**int8)(__ccgo_up(v2)) = Int8FromUint64(uint64('0') + x&uint64(7)) goto _1 _1: ; @@ -140180,7 +140180,7 @@ func _fmt_u(tls *TLS, x Tuintmax_t, s uintptr) (r uintptr) { } s = s - 1 v2 = s - *(*int8)(unsafe.Pointer(v2)) = Int8FromUint64(uint64('0') + x%uint64(10)) + **(**int8)(__ccgo_up(v2)) = Int8FromUint64(uint64('0') + x%uint64(10)) goto _1 _1: ; @@ -140193,7 +140193,7 @@ func _fmt_u(tls *TLS, x Tuintmax_t, s uintptr) (r uintptr) { } s = s - 1 v2 = s - *(*int8)(unsafe.Pointer(v2)) = Int8FromUint64(uint64('0') + y%uint64(10)) + **(**int8)(__ccgo_up(v2)) = Int8FromUint64(uint64('0') + y%uint64(10)) goto _3 _3: ; @@ -140228,7 +140228,7 @@ func _fmt_fp(tls *TLS, f uintptr, y float64, w int32, p int32, fl int32, t int32 var _ /* e2 at bp+512 */ int32 var _ /* ebuf0 at bp+538 */ [12]int8 _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, b, carry, carry1, d, e, ebuf, estr, i, j, l, need, pl, prefix, r, re, rm, round, round1, s, s1, s2, s3, s4, sh, sh1, small, x, x1, x2, z, v1, v36, v37, v38, v5, v6, v7 - *(*int32)(unsafe.Pointer(bp + 512)) = 0 + **(**int32)(__ccgo_up(bp + 512)) = 0 prefix = __ccgo_ts + 1576 ebuf = bp + 538 + uintptr(Uint64FromInt32(3)*Uint64FromInt64(4)) pl = int32(1) @@ -140282,7 +140282,7 @@ _4: } y = float64(Xfrexpl(tls, y, bp+512) * Float64FromInt32(2)) if y != 0 { - *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) - 1 + **(**int32)(__ccgo_up(bp + 512)) = **(**int32)(__ccgo_up(bp + 512)) - 1 } if t|int32(32) == int32('a') { round = Float64FromFloat64(8) @@ -140305,7 +140305,7 @@ _4: } round = round * Float64FromInt32(16) } - if int32(*(*int8)(unsafe.Pointer(prefix))) == int32('-') { + if int32(**(**int8)(__ccgo_up(prefix))) == int32('-') { y = -y y = y - round y = y + round @@ -140315,39 +140315,39 @@ _4: y = y - round } } - if *(*int32)(unsafe.Pointer(bp + 512)) < 0 { - v7 = -*(*int32)(unsafe.Pointer(bp + 512)) + if **(**int32)(__ccgo_up(bp + 512)) < 0 { + v7 = -**(**int32)(__ccgo_up(bp + 512)) } else { - v7 = *(*int32)(unsafe.Pointer(bp + 512)) + v7 = **(**int32)(__ccgo_up(bp + 512)) } estr = _fmt_u(tls, Uint64FromInt32(v7), ebuf) if estr == ebuf { estr = estr - 1 v5 = estr - *(*int8)(unsafe.Pointer(v5)) = int8('0') + **(**int8)(__ccgo_up(v5)) = int8('0') } estr = estr - 1 v5 = estr - if *(*int32)(unsafe.Pointer(bp + 512)) < 0 { + if **(**int32)(__ccgo_up(bp + 512)) < 0 { v7 = int32('-') } else { v7 = int32('+') } - *(*int8)(unsafe.Pointer(v5)) = int8(v7) + **(**int8)(__ccgo_up(v5)) = int8(v7) estr = estr - 1 v5 = estr - *(*int8)(unsafe.Pointer(v5)) = int8(t + (Int32FromUint8('p') - Int32FromUint8('a'))) + **(**int8)(__ccgo_up(v5)) = int8(t + (Int32FromUint8('p') - Int32FromUint8('a'))) s = bp + 516 for cond := true; cond; cond = y != 0 { x = int32(y) v5 = s s = s + 1 - *(*int8)(unsafe.Pointer(v5)) = int8(int32(_xdigits1[x]) | t&int32(32)) + **(**int8)(__ccgo_up(v5)) = int8(int32(_xdigits1[x]) | t&int32(32)) y = float64(Float64FromInt32(16) * (y - float64(x))) if int64(s)-t__predefined_ptrdiff_t(bp+516) == int64(1) && (y != 0 || p > 0 || Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0) { v5 = s s = s + 1 - *(*int8)(unsafe.Pointer(v5)) = int8('.') + **(**int8)(__ccgo_up(v5)) = int8('.') } } if int64(p) > int64(Int32FromInt32(INT_MAX)-Int32FromInt32(2))-(int64(ebuf)-int64(estr))-int64(pl) { @@ -140377,9 +140377,9 @@ _4: } if y != 0 { y = y * Float64FromFloat64(2.68435456e+08) - *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) - int32(28) + **(**int32)(__ccgo_up(bp + 512)) = **(**int32)(__ccgo_up(bp + 512)) - int32(28) } - if *(*int32)(unsafe.Pointer(bp + 512)) < 0 { + if **(**int32)(__ccgo_up(bp + 512)) < 0 { v6 = bp + 8 z = v6 v5 = v6 @@ -140393,17 +140393,17 @@ _4: a = v5 } for cond := true; cond; cond = y != 0 { - *(*Tuint32_t)(unsafe.Pointer(z)) = uint32(y) + **(**Tuint32_t)(__ccgo_up(z)) = uint32(y) v5 = z z += 4 - y = float64(Float64FromInt32(1000000000) * (y - float64(*(*Tuint32_t)(unsafe.Pointer(v5))))) + y = float64(Float64FromInt32(1000000000) * (y - float64(**(**Tuint32_t)(__ccgo_up(v5))))) } - for *(*int32)(unsafe.Pointer(bp + 512)) > 0 { + for **(**int32)(__ccgo_up(bp + 512)) > 0 { carry = uint32(0) - if int32(29) < *(*int32)(unsafe.Pointer(bp + 512)) { + if int32(29) < **(**int32)(__ccgo_up(bp + 512)) { v7 = int32(29) } else { - v7 = *(*int32)(unsafe.Pointer(bp + 512)) + v7 = **(**int32)(__ccgo_up(bp + 512)) } sh = v7 d = z - uintptr(1)*4 @@ -140411,8 +140411,8 @@ _4: if !(d >= a) { break } - x1 = uint64(*(*Tuint32_t)(unsafe.Pointer(d)))< a && !(*(*Tuint32_t)(unsafe.Pointer(z + uintptr(-Int32FromInt32(1))*4)) != 0) { + for z > a && !(**(**Tuint32_t)(__ccgo_up(z + uintptr(-Int32FromInt32(1))*4)) != 0) { z -= 4 } - *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) - sh + **(**int32)(__ccgo_up(bp + 512)) = **(**int32)(__ccgo_up(bp + 512)) - sh } - for *(*int32)(unsafe.Pointer(bp + 512)) < 0 { + for **(**int32)(__ccgo_up(bp + 512)) < 0 { carry1 = uint32(0) - if int32(9) < -*(*int32)(unsafe.Pointer(bp + 512)) { + if int32(9) < -**(**int32)(__ccgo_up(bp + 512)) { v7 = int32(9) } else { - v7 = -*(*int32)(unsafe.Pointer(bp + 512)) + v7 = -**(**int32)(__ccgo_up(bp + 512)) } sh1 = v7 need = Int32FromUint32(uint32(1) + (Uint32FromInt32(p)+Uint32FromInt32(LDBL_MANT_DIG)/Uint32FromUint32(3)+uint32(8))/uint32(9)) @@ -140443,21 +140443,21 @@ _4: if !(d < z) { break } - rm = *(*Tuint32_t)(unsafe.Pointer(d)) & Uint32FromInt32(int32(1)<>sh1 + carry1 + rm = **(**Tuint32_t)(__ccgo_up(d)) & Uint32FromInt32(int32(1)<>sh1 + carry1 carry1 = Uint32FromInt32(Int32FromInt32(1000000000)>>sh1) * rm goto _26 _26: ; d += 4 } - if !(*(*Tuint32_t)(unsafe.Pointer(a)) != 0) { + if !(**(**Tuint32_t)(__ccgo_up(a)) != 0) { a += 4 } if carry1 != 0 { v5 = z z += 4 - *(*Tuint32_t)(unsafe.Pointer(v5)) = carry1 + **(**Tuint32_t)(__ccgo_up(v5)) = carry1 } /* Avoid (slow!) computation past requested precision */ if t|int32(32) == int32('f') { @@ -140469,13 +140469,13 @@ _4: if (int64(z)-int64(b))/4 > int64(need) { z = b + uintptr(need)*4 } - *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) + sh1 + **(**int32)(__ccgo_up(bp + 512)) = **(**int32)(__ccgo_up(bp + 512)) + sh1 } if a < z { i = int32(10) e = int32(Int64FromInt32(9) * ((int64(r) - int64(a)) / 4)) for { - if !(*(*Tuint32_t)(unsafe.Pointer(a)) >= Uint32FromInt32(i)) { + if !(**(**Tuint32_t)(__ccgo_up(a)) >= Uint32FromInt32(i)) { break } goto _29 @@ -140506,11 +140506,11 @@ _4: i = i * int32(10) j = j + 1 } - x2 = *(*Tuint32_t)(unsafe.Pointer(d)) % Uint32FromInt32(i) + x2 = **(**Tuint32_t)(__ccgo_up(d)) % Uint32FromInt32(i) /* Are there any significant digits past j? */ if x2 != 0 || d+uintptr(1)*4 != z { round1 = Float64FromInt32(2) / Float64FromFloat64(2.22044604925031308085e-16) - if *(*Tuint32_t)(unsafe.Pointer(d))/Uint32FromInt32(i)&uint32(1) != 0 || i == int32(1000000000) && d > a && *(*Tuint32_t)(unsafe.Pointer(d + uintptr(-Int32FromInt32(1))*4))&uint32(1) != 0 { + if **(**Tuint32_t)(__ccgo_up(d))/Uint32FromInt32(i)&uint32(1) != 0 || i == int32(1000000000) && d > a && **(**Tuint32_t)(__ccgo_up(d + uintptr(-Int32FromInt32(1))*4))&uint32(1) != 0 { round1 = round1 + Float64FromInt32(2) } if x2 < Uint32FromInt32(i/int32(2)) { @@ -140522,29 +140522,29 @@ _4: small = Float64FromFloat64(1.5) } } - if pl != 0 && int32(*(*int8)(unsafe.Pointer(prefix))) == int32('-') { + if pl != 0 && int32(**(**int8)(__ccgo_up(prefix))) == int32('-') { round1 = round1 * float64(-Int32FromInt32(1)) small = small * float64(-Int32FromInt32(1)) } - *(*Tuint32_t)(unsafe.Pointer(d)) -= x2 + **(**Tuint32_t)(__ccgo_up(d)) -= x2 /* Decide whether to round by probing round+small */ if round1+small != round1 { - *(*Tuint32_t)(unsafe.Pointer(d)) = *(*Tuint32_t)(unsafe.Pointer(d)) + Uint32FromInt32(i) - for *(*Tuint32_t)(unsafe.Pointer(d)) > uint32(999999999) { + **(**Tuint32_t)(__ccgo_up(d)) = **(**Tuint32_t)(__ccgo_up(d)) + Uint32FromInt32(i) + for **(**Tuint32_t)(__ccgo_up(d)) > uint32(999999999) { v5 = d d -= 4 - *(*Tuint32_t)(unsafe.Pointer(v5)) = uint32(0) + **(**Tuint32_t)(__ccgo_up(v5)) = uint32(0) if d < a { a -= 4 v5 = a - *(*Tuint32_t)(unsafe.Pointer(v5)) = uint32(0) + **(**Tuint32_t)(__ccgo_up(v5)) = uint32(0) } - *(*Tuint32_t)(unsafe.Pointer(d)) = *(*Tuint32_t)(unsafe.Pointer(d)) + 1 + **(**Tuint32_t)(__ccgo_up(d)) = **(**Tuint32_t)(__ccgo_up(d)) + 1 } i = int32(10) e = int32(Int64FromInt32(9) * ((int64(r) - int64(a)) / 4)) for { - if !(*(*Tuint32_t)(unsafe.Pointer(a)) >= Uint32FromInt32(i)) { + if !(**(**Tuint32_t)(__ccgo_up(a)) >= Uint32FromInt32(i)) { break } goto _33 @@ -140560,7 +140560,7 @@ _4: } } for { - if !(z > a && !(*(*Tuint32_t)(unsafe.Pointer(z + uintptr(-Int32FromInt32(1))*4)) != 0)) { + if !(z > a && !(**(**Tuint32_t)(__ccgo_up(z + uintptr(-Int32FromInt32(1))*4)) != 0)) { break } goto _34 @@ -140581,11 +140581,11 @@ _4: } if !(Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0) { /* Count trailing zeros in last place */ - if z > a && *(*Tuint32_t)(unsafe.Pointer(z + uintptr(-Int32FromInt32(1))*4)) != 0 { + if z > a && **(**Tuint32_t)(__ccgo_up(z + uintptr(-Int32FromInt32(1))*4)) != 0 { i = int32(10) j = Int32FromInt32(0) for { - if !(*(*Tuint32_t)(unsafe.Pointer(z + uintptr(-Int32FromInt32(1))*4))%Uint32FromInt32(i) == uint32(0)) { + if !(**(**Tuint32_t)(__ccgo_up(z + uintptr(-Int32FromInt32(1))*4))%Uint32FromInt32(i) == uint32(0)) { break } goto _35 @@ -140655,7 +140655,7 @@ _4: for int64(ebuf)-int64(estr) < int64(2) { estr = estr - 1 v5 = estr - *(*int8)(unsafe.Pointer(v5)) = int8('0') + **(**int8)(__ccgo_up(v5)) = int8('0') } estr = estr - 1 v5 = estr @@ -140664,10 +140664,10 @@ _4: } else { v7 = int32('+') } - *(*int8)(unsafe.Pointer(v5)) = int8(v7) + **(**int8)(__ccgo_up(v5)) = int8(v7) estr = estr - 1 v5 = estr - *(*int8)(unsafe.Pointer(v5)) = int8(t) + **(**int8)(__ccgo_up(v5)) = int8(t) if int64(ebuf)-int64(estr) > int64(int32(INT_MAX)-l) { return -int32(1) } @@ -140688,18 +140688,18 @@ _4: if !(d <= r) { break } - s2 = _fmt_u(tls, uint64(*(*Tuint32_t)(unsafe.Pointer(d))), bp+516+uintptr(9)) + s2 = _fmt_u(tls, uint64(**(**Tuint32_t)(__ccgo_up(d))), bp+516+uintptr(9)) if d != a { for s2 > bp+516 { s2 = s2 - 1 v5 = s2 - *(*int8)(unsafe.Pointer(v5)) = int8('0') + **(**int8)(__ccgo_up(v5)) = int8('0') } } else { if s2 == bp+516+uintptr(9) { s2 = s2 - 1 v5 = s2 - *(*int8)(unsafe.Pointer(v5)) = int8('0') + **(**int8)(__ccgo_up(v5)) = int8('0') } } _out(tls, f, s2, Uint64FromInt64(int64(bp+516+uintptr(9))-int64(s2))) @@ -140715,11 +140715,11 @@ _4: if !(d < z && p > 0) { break } - s3 = _fmt_u(tls, uint64(*(*Tuint32_t)(unsafe.Pointer(d))), bp+516+uintptr(9)) + s3 = _fmt_u(tls, uint64(**(**Tuint32_t)(__ccgo_up(d))), bp+516+uintptr(9)) for s3 > bp+516 { s3 = s3 - 1 v5 = s3 - *(*int8)(unsafe.Pointer(v5)) = int8('0') + **(**int8)(__ccgo_up(v5)) = int8('0') } if int32(9) < p { v7 = int32(9) @@ -140743,17 +140743,17 @@ _4: if !(d < z && p >= 0) { break } - s4 = _fmt_u(tls, uint64(*(*Tuint32_t)(unsafe.Pointer(d))), bp+516+uintptr(9)) + s4 = _fmt_u(tls, uint64(**(**Tuint32_t)(__ccgo_up(d))), bp+516+uintptr(9)) if s4 == bp+516+uintptr(9) { s4 = s4 - 1 v5 = s4 - *(*int8)(unsafe.Pointer(v5)) = int8('0') + **(**int8)(__ccgo_up(v5)) = int8('0') } if d != a { for s4 > bp+516 { s4 = s4 - 1 v5 = s4 - *(*int8)(unsafe.Pointer(v5)) = int8('0') + **(**int8)(__ccgo_up(v5)) = int8('0') } } else { v5 = s4 @@ -140792,18 +140792,18 @@ func _getint(tls *TLS, s uintptr) (r int32) { _ = i i = 0 for { - if !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-uint32('0') < uint32(10)) != 0) { break } - if Uint32FromInt32(i) > Uint32FromInt32(INT_MAX)/Uint32FromUint32(10) || int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-int32('0') > int32(INT_MAX)-int32(10)*i { + if Uint32FromInt32(i) > Uint32FromInt32(INT_MAX)/Uint32FromUint32(10) || int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-int32('0') > int32(INT_MAX)-int32(10)*i { i = -int32(1) } else { - i = int32(10)*i + (int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s))))) - int32('0')) + i = int32(10)*i + (int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(s))))) - int32('0')) } goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s)) = *(*uintptr)(unsafe.Pointer(s)) + 1 + **(**uintptr)(__ccgo_up(s)) = **(**uintptr)(__ccgo_up(s)) + 1 } return i } @@ -140824,7 +140824,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, var _ /* s at bp+0 */ uintptr var _ /* wc at bp+40 */ [2]Twchar_t _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argpos, cnt, fl, i, l, l10n, p, pl, prefix, ps, st, t, w, ws, xp, z, v31, v34, v45, v5, v6, v8 - *(*uintptr)(unsafe.Pointer(bp)) = fmt + **(**uintptr)(__ccgo_up(bp)) = fmt l10n = uint32(0) cnt = 0 l = 0 @@ -140837,30 +140837,30 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } /* Update output count, end loop when fmt is exhausted */ cnt = cnt + l - if !(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) != 0) { + if !(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))) != 0) { break } /* Handle literal text and %% format specifiers */ - a = *(*uintptr)(unsafe.Pointer(bp)) + a = **(**uintptr)(__ccgo_up(bp)) for { - if !(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) != 0 && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32('%')) { + if !(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))) != 0 && int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) != int32('%')) { break } goto _2 _2: ; - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 } - z = *(*uintptr)(unsafe.Pointer(bp)) + z = **(**uintptr)(__ccgo_up(bp)) for { - if !(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('%') && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1))) == int32('%')) { + if !(int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) == int32('%') && int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1))) == int32('%')) { break } goto _3 _3: ; z = z + 1 - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(2) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + uintptr(2) } if int64(z)-int64(a) > int64(int32(INT_MAX)-cnt) { goto overflow @@ -140872,46 +140872,46 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if l != 0 { goto _1 } - if BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))-uint32('0') < uint32(10)) != 0 && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2))) == int32('$') { + if BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1)))-uint32('0') < uint32(10)) != 0 && int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 2))) == int32('$') { l10n = uint32(1) - argpos = int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1))) - int32('0') - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(3) + argpos = int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1))) - int32('0') + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + uintptr(3) } else { argpos = -int32(1) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 } /* Read modifier flags */ fl = uint32(0) for { - if !(Uint32FromInt8(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-uint32(' ') < uint32(32) && (Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('0')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('\'')-Int32FromUint8(' ')))&(uint32(1)<<(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-int32(' '))) != 0) { + if !(Uint32FromInt8(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))))-uint32(' ') < uint32(32) && (Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('0')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('\'')-Int32FromUint8(' ')))&(uint32(1)<<(int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))))-int32(' '))) != 0) { break } - fl = fl | uint32(1)<<(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-int32(' ')) + fl = fl | uint32(1)<<(int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))))-int32(' ')) goto _4 _4: ; - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 } /* Read field width */ - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('*') { - if BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))-uint32('0') < uint32(10)) != 0 && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2))) == int32('$') { + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) == int32('*') { + if BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1)))-uint32('0') < uint32(10)) != 0 && int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 2))) == int32('$') { l10n = uint32(1) if !(f != 0) { - *(*int32)(unsafe.Pointer(nl_type + uintptr(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))-int32('0'))*4)) = int32(_INT) + **(**int32)(__ccgo_up(nl_type + uintptr(int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1)))-int32('0'))*4)) = int32(_INT) w = Int32FromInt32(0) } else { - w = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))-int32('0'))*8))) + w = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1)))-int32('0'))*8))) } - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(3) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + uintptr(3) } else { if !(l10n != 0) { if f != 0 { - v5 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) + v5 = VaInt32(&**(**Tva_list)(__ccgo_up(ap))) } else { v5 = 0 } w = v5 - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 } else { goto inval } @@ -140928,32 +140928,32 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } } /* Read precision */ - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('.') && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1))) == int32('*') { - if BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2)))-uint32('0') < uint32(10)) != 0 && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 3))) == int32('$') { + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) == int32('.') && int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1))) == int32('*') { + if BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 2)))-uint32('0') < uint32(10)) != 0 && int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 3))) == int32('$') { if !(f != 0) { - *(*int32)(unsafe.Pointer(nl_type + uintptr(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2)))-int32('0'))*4)) = int32(_INT) + **(**int32)(__ccgo_up(nl_type + uintptr(int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 2)))-int32('0'))*4)) = int32(_INT) p = Int32FromInt32(0) } else { - p = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2)))-int32('0'))*8))) + p = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 2)))-int32('0'))*8))) } - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(4) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + uintptr(4) } else { if !(l10n != 0) { if f != 0 { - v5 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) + v5 = VaInt32(&**(**Tva_list)(__ccgo_up(ap))) } else { v5 = 0 } p = v5 - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(2) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + uintptr(2) } else { goto inval } } xp = BoolInt32(p >= 0) } else { - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('.') { - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) == int32('.') { + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 p = _getint(tls, bp) xp = int32(1) } else { @@ -140964,13 +140964,13 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, /* Format specifier state machine */ st = uint32(0) for cond := true; cond; cond = st-uint32(1) < uint32(_STOP) { - if Uint32FromInt8(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-uint32('A') > Uint32FromInt32(Int32FromUint8('z')-Int32FromUint8('A')) { + if Uint32FromInt8(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))))-uint32('A') > Uint32FromInt32(Int32FromUint8('z')-Int32FromUint8('A')) { goto inval } ps = st - v8 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - st = uint32(*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_states)) + uintptr(st)*58 + uintptr(int32(*(*int8)(unsafe.Pointer(v8)))-int32('A'))))) + v8 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + st = uint32(**(**uint8)(__ccgo_up(uintptr(unsafe.Pointer(&_states)) + uintptr(st)*58 + uintptr(int32(**(**int8)(__ccgo_up(v8)))-int32('A'))))) } if !(st != 0) { goto inval @@ -140983,9 +140983,9 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } else { if argpos >= 0 { if !(f != 0) { - *(*int32)(unsafe.Pointer(nl_type + uintptr(argpos)*4)) = Int32FromUint32(st) + **(**int32)(__ccgo_up(nl_type + uintptr(argpos)*4)) = Int32FromUint32(st) } else { - *(*Targ)(unsafe.Pointer(bp + 8)) = *(*Targ)(unsafe.Pointer(nl_arg + uintptr(argpos)*8)) + **(**Targ)(__ccgo_up(bp + 8)) = **(**Targ)(__ccgo_up(nl_arg + uintptr(argpos)*8)) } } else { if f != 0 { @@ -141005,7 +141005,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, z = bp + 16 + uintptr(24) prefix = __ccgo_ts + 1607 pl = 0 - t = int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + uintptr(-Int32FromInt32(1))))) + t = int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + uintptr(-Int32FromInt32(1))))) /* Transform ls,lc -> S,C */ if ps != 0 && t&int32(15) == int32(3) { t = t & ^Int32FromInt32(32) @@ -141063,19 +141063,19 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, ; switch ps { case uint32(_BARE): - *(*int32)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) = cnt + **(**int32)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 8)))) = cnt case uint32(_LPRE): - *(*int64)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) = int64(cnt) + **(**int64)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 8)))) = int64(cnt) case uint32(_LLPRE): - *(*int64)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) = int64(cnt) + **(**int64)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 8)))) = int64(cnt) case uint32(_HPRE): - *(*uint16)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) = Uint16FromInt32(cnt) + **(**uint16)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 8)))) = Uint16FromInt32(cnt) case uint32(_HHPRE): - *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) = Uint8FromInt32(cnt) + **(**uint8)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 8)))) = Uint8FromInt32(cnt) case uint32(_ZTPRE): - *(*Tsize_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) = Uint64FromInt32(cnt) + **(**Tsize_t)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 8)))) = Uint64FromInt32(cnt) case uint32(_JPRE): - *(*Tuintmax_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) = Uint64FromInt32(cnt) + **(**Tuintmax_t)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 8)))) = Uint64FromInt32(cnt) break } goto _1 @@ -141161,7 +141161,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, p = v5 v8 = z - uintptr(v5) a = v8 - *(*int8)(unsafe.Pointer(v8)) = Int8FromUint64(*(*Tuintmax_t)(unsafe.Pointer(bp + 8))) + **(**int8)(__ccgo_up(v8)) = Int8FromUint64(*(*Tuintmax_t)(unsafe.Pointer(bp + 8))) fl = fl & ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) goto _30 _19: @@ -141169,7 +141169,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if !(int32(1) != 0) { goto _37 } - a = Xstrerror(tls, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) + a = Xstrerror(tls, **(**int32)(__ccgo_up(X__errno_location(tls)))) goto _38 _37: ; @@ -141189,7 +141189,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, v5 = p } z = a + uintptr(Xstrnlen(tls, a, Uint64FromInt32(v5))) - if p < 0 && *(*int8)(unsafe.Pointer(z)) != 0 { + if p < 0 && **(**int8)(__ccgo_up(z)) != 0 { goto overflow } p = int32(int64(z) - int64(a)) @@ -141200,8 +141200,8 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if !(*(*Tuintmax_t)(unsafe.Pointer(bp + 8)) != 0) { goto narrow_c } - (*(*[2]Twchar_t)(unsafe.Pointer(bp + 40)))[0] = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(bp + 8))) - (*(*[2]Twchar_t)(unsafe.Pointer(bp + 40)))[int32(1)] = 0 + (**(**[2]Twchar_t)(__ccgo_up(bp + 40)))[0] = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(bp + 8))) + (**(**[2]Twchar_t)(__ccgo_up(bp + 40)))[int32(1)] = 0 *(*uintptr)(unsafe.Pointer(bp + 8)) = bp + 40 p = -int32(1) _21: @@ -141211,10 +141211,10 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, l = v5 i = Uint64FromInt32(v5) for { - if v45 = i < Uint64FromInt32(p) && *(*Twchar_t)(unsafe.Pointer(ws)) != 0; v45 { + if v45 = i < Uint64FromInt32(p) && **(**Twchar_t)(__ccgo_up(ws)) != 0; v45 { v8 = ws ws += 4 - v6 = Xwctomb(tls, bp+48, *(*Twchar_t)(unsafe.Pointer(v8))) + v6 = Xwctomb(tls, bp+48, **(**Twchar_t)(__ccgo_up(v8))) l = v6 } if !(v45 && v6 >= 0 && Uint64FromInt32(l) <= Uint64FromInt32(p)-i) { @@ -141236,10 +141236,10 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, ws = *(*uintptr)(unsafe.Pointer(bp + 8)) i = uint64(0) for { - if v45 = i < uint64(0+Uint32FromInt32(p)) && *(*Twchar_t)(unsafe.Pointer(ws)) != 0; v45 { + if v45 = i < uint64(0+Uint32FromInt32(p)) && **(**Twchar_t)(__ccgo_up(ws)) != 0; v45 { v8 = ws ws += 4 - v5 = Xwctomb(tls, bp+48, *(*Twchar_t)(unsafe.Pointer(v8))) + v5 = Xwctomb(tls, bp+48, **(**Twchar_t)(__ccgo_up(v8))) l = v5 } if !(v45 && i+Uint64FromInt32(v5) <= Uint64FromInt32(p)) { @@ -141315,17 +141315,17 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } i = uint64(1) for { - if !(i <= uint64(NL_ARGMAX) && *(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)) != 0) { + if !(i <= uint64(NL_ARGMAX) && **(**int32)(__ccgo_up(nl_type + uintptr(i)*4)) != 0) { break } - _pop_arg(tls, nl_arg+uintptr(i)*8, *(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)), ap) + _pop_arg(tls, nl_arg+uintptr(i)*8, **(**int32)(__ccgo_up(nl_type + uintptr(i)*4)), ap) goto _51 _51: ; i = i + 1 } for { - if !(i <= uint64(NL_ARGMAX) && !(*(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)) != 0)) { + if !(i <= uint64(NL_ARGMAX) && !(**(**int32)(__ccgo_up(nl_type + uintptr(i)*4)) != 0)) { break } goto _52 @@ -141340,12 +141340,12 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto inval inval: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) goto overflow overflow: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return -int32(1) } @@ -141363,12 +141363,12 @@ func Xvfprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { var _ /* nl_arg at bp+48 */ [10]Targ var _ /* nl_type at bp+8 */ [10]int32 _, _, _, _, _, _, _ = __need_unlock, olderr, ret, saved_buf, v1, v2, v3 - *(*[10]int32)(unsafe.Pointer(bp + 8)) = [10]int32{} + **(**[10]int32)(__ccgo_up(bp + 8)) = [10]int32{} saved_buf = uintptr(0) /* the copy allows passing va_list* even if va_list is an array */ - *(*Tva_list)(unsafe.Pointer(bp)) = ap + **(**Tva_list)(__ccgo_up(bp)) = ap if _printf_core(tls, uintptr(0), fmt, bp, bp+48, bp+8) < 0 { - _ = *(*Tva_list)(unsafe.Pointer(bp)) + _ = **(**Tva_list)(__ccgo_up(bp)) return -int32(1) } if AtomicLoadPInt32(f+140) >= 0 { @@ -141378,7 +141378,7 @@ func Xvfprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } __need_unlock = v1 olderr = Int32FromUint32((*TFILE)(unsafe.Pointer(f)).Fflags & uint32(F_ERR)) - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_ERR)) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^Int32FromInt32(F_ERR)) if !((*TFILE)(unsafe.Pointer(f)).Fbuf_size != 0) { saved_buf = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Fbuf = bp + 128 @@ -141410,11 +141410,11 @@ func Xvfprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_ERR) != 0 { ret = -int32(1) } - *(*uint32)(unsafe.Pointer(f)) |= Uint32FromInt32(olderr) + **(**uint32)(__ccgo_up(f)) |= Uint32FromInt32(olderr) if __need_unlock != 0 { ___unlockfile(tls, f) } - _ = *(*Tva_list)(unsafe.Pointer(bp)) + _ = **(**Tva_list)(__ccgo_up(bp)) return ret } @@ -141431,15 +141431,15 @@ func _store_int(tls *TLS, dest uintptr, size int32, i uint64) { } switch size { case -int32(2): - *(*int8)(unsafe.Pointer(dest)) = Int8FromUint64(i) + **(**int8)(__ccgo_up(dest)) = Int8FromUint64(i) case -int32(1): - *(*int16)(unsafe.Pointer(dest)) = Int16FromUint64(i) + **(**int16)(__ccgo_up(dest)) = Int16FromUint64(i) case SIZE_def: - *(*int32)(unsafe.Pointer(dest)) = Int32FromUint64(i) + **(**int32)(__ccgo_up(dest)) = Int32FromUint64(i) case int32(SIZE_l): - *(*int64)(unsafe.Pointer(dest)) = Int64FromUint64(i) + **(**int64)(__ccgo_up(dest)) = Int64FromUint64(i) case int32(SIZE_ll): - *(*int64)(unsafe.Pointer(dest)) = Int64FromUint64(i) + **(**int64)(__ccgo_up(dest)) = Int64FromUint64(i) break } } @@ -141502,17 +141502,17 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } p = fmt for { - if !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if !(**(**uint8)(__ccgo_up(p)) != 0) { break } alloc = 0 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v3 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _5 _5: if v3 != 0 { for { - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) v6 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _8 _8: @@ -141527,7 +141527,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v1 = X__shgetc(tls, f) } @@ -141545,16 +141545,16 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { pos = pos + ((*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf))) goto _2 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32('%') || Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('%') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) != int32('%') || Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) == int32('%') { X__shlim(tls, f, int64(Int32FromInt32(0))) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('%') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('%') { p = p + 1 for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v3 = X__shgetc(tls, f) } @@ -141573,13 +141573,13 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v1 = X__shgetc(tls, f) } c = v1 } - if c != Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) { + if c != Int32FromUint8(**(**uint8)(__ccgo_up(p))) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } @@ -141592,12 +141592,12 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { goto _2 } p = p + 1 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('*') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('*') { dest = uintptr(0) p = p + 1 } else { - if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('$') { - dest = _arg_n(tls, ap, Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))-int32('0'))) + if BoolInt32(uint32(**(**uint8)(__ccgo_up(p)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) == int32('$') { + dest = _arg_n(tls, ap, Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(p)))-int32('0'))) p = p + uintptr(2) } else { dest = VaUintptr(&ap) @@ -141605,16 +141605,16 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } width = 0 for { - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p)))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(p)))-uint32('0') < uint32(10)) != 0) { break } - width = int32(10)*width + Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - int32('0') + width = int32(10)*width + Int32FromUint8(**(**uint8)(__ccgo_up(p))) - int32('0') goto _25 _25: ; p = p + 1 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('m') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('m') { wcs = uintptr(0) s = uintptr(0) alloc = BoolInt32(!!(dest != 0)) @@ -141625,16 +141625,16 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { size = SIZE_def v10 = p p = p + 1 - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(v10))) { case int32('h'): - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('h') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('h') { p = p + 1 size = -Int32FromInt32(2) } else { size = -int32(1) } case int32('l'): - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('l') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('l') { p = p + 1 size = Int32FromInt32(SIZE_ll) } else { @@ -141693,7 +141693,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { default: goto fmt_fail } - t = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + t = Int32FromUint8(**(**uint8)(__ccgo_up(p))) /* C or S */ if t&int32(0x2f) == int32(3) { t = t | int32(32) @@ -141717,7 +141717,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v1 = X__shgetc(tls, f) } @@ -141739,7 +141739,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v1 = X__shgetc(tls, f) } @@ -141796,58 +141796,58 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { ; if t == int32('c') || t == int32('s') { Xmemset(tls, bp+16, -int32(1), uint64(257)) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[0] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[0] = uint8(0) if t == int32('s') { - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\t')] = uint8(0) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\n')] = uint8(0) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\v')] = uint8(0) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\f')] = uint8(0) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\r')] = uint8(0) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8(' ')] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\t')] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\n')] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\v')] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\f')] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\r')] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8(' ')] = uint8(0) } } else { p = p + 1 v10 = p - if Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) == int32('^') { + if Int32FromUint8(**(**uint8)(__ccgo_up(v10))) == int32('^') { p = p + 1 invert = Int32FromInt32(1) } else { invert = 0 } Xmemset(tls, bp+16, invert, uint64(257)) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[0] = uint8(0) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') { + (**(**[257]uint8)(__ccgo_up(bp + 16)))[0] = uint8(0) + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('-') { p = p + 1 - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('-')] = Uint8FromInt32(Int32FromInt32(1) - invert) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('-')] = Uint8FromInt32(Int32FromInt32(1) - invert) } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32(']') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32(']') { p = p + 1 - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8(']')] = Uint8FromInt32(Int32FromInt32(1) - invert) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8(']')] = Uint8FromInt32(Int32FromInt32(1) - invert) } } for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32(']')) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(p))) != int32(']')) { break } - if !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if !(**(**uint8)(__ccgo_up(p)) != 0) { goto fmt_fail } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') && *(*uint8)(unsafe.Pointer(p + 1)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) != int32(']') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('-') && **(**uint8)(__ccgo_up(p + 1)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) != int32(']') { v10 = p p = p + 1 - c = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10 + uintptr(-Int32FromInt32(1))))) + c = Int32FromUint8(**(**uint8)(__ccgo_up(v10 + uintptr(-Int32FromInt32(1))))) for { - if !(c < Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))) { + if !(c < Int32FromUint8(**(**uint8)(__ccgo_up(p)))) { break } - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[int32(1)+c] = Uint8FromInt32(int32(1) - invert) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[int32(1)+c] = Uint8FromInt32(int32(1) - invert) goto _57 _57: ; c = c + 1 } } - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[int32(1)+Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))] = Uint8FromInt32(int32(1) - invert) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[int32(1)+Int32FromUint8(**(**uint8)(__ccgo_up(p)))] = Uint8FromInt32(int32(1) - invert) goto _56 _56: ; @@ -141872,19 +141872,19 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } else { wcs = dest } - *(*Tmbstate_t)(unsafe.Pointer(bp + 8)) = Tmbstate_t{} + **(**Tmbstate_t)(__ccgo_up(bp + 8)) = Tmbstate_t{} for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v3 = X__shgetc(tls, f) } v1 = v3 c = v1 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { + if !((**(**[257]uint8)(__ccgo_up(bp + 16)))[v1+int32(1)] != 0) { break } *(*int8)(unsafe.Pointer(bp)) = int8(c) @@ -141897,7 +141897,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if wcs != 0 { v64 = i i = i + 1 - *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(v64)*4)) = *(*Twchar_t)(unsafe.Pointer(bp + 276)) + **(**Twchar_t)(__ccgo_up(wcs + uintptr(v64)*4)) = **(**Twchar_t)(__ccgo_up(bp + 276)) } if alloc != 0 && i == k { k = k + (k + uint64(1)) @@ -141922,18 +141922,18 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v3 = X__shgetc(tls, f) } v1 = v3 c = v1 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { + if !((**(**[257]uint8)(__ccgo_up(bp + 16)))[v1+int32(1)] != 0) { break } v64 = i i = i + 1 - *(*int8)(unsafe.Pointer(s + uintptr(v64))) = int8(c) + **(**int8)(__ccgo_up(s + uintptr(v64))) = int8(c) if i == k { k = k + (k + uint64(1)) tmp1 = Xrealloc(tls, s, k) @@ -141952,18 +141952,18 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v17 = f + 8 v11 = *(*uintptr)(unsafe.Pointer(v17)) *(*uintptr)(unsafe.Pointer(v17)) = *(*uintptr)(unsafe.Pointer(v17)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v11))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v11))) } else { v3 = X__shgetc(tls, f) } v1 = v3 c = v1 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { + if !((**(**[257]uint8)(__ccgo_up(bp + 16)))[v1+int32(1)] != 0) { break } v64 = i i = i + 1 - *(*int8)(unsafe.Pointer(s + uintptr(v64))) = int8(c) + **(**int8)(__ccgo_up(s + uintptr(v64))) = int8(c) } } else { for { @@ -141971,13 +141971,13 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v3 = X__shgetc(tls, f) } v1 = v3 c = v1 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { + if !((**(**[257]uint8)(__ccgo_up(bp + 16)))[v1+int32(1)] != 0) { break } } @@ -141995,17 +141995,17 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } if alloc != 0 { if size == int32(SIZE_l) { - *(*uintptr)(unsafe.Pointer(dest)) = wcs + **(**uintptr)(__ccgo_up(dest)) = wcs } else { - *(*uintptr)(unsafe.Pointer(dest)) = s + **(**uintptr)(__ccgo_up(dest)) = s } } if t != int32('c') { if wcs != 0 { - *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) = 0 + **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) = 0 } if s != 0 { - *(*int8)(unsafe.Pointer(s + uintptr(i))) = 0 + **(**int8)(__ccgo_up(s + uintptr(i))) = 0 } } goto _54 @@ -142038,7 +142038,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { goto match_fail } if t == int32('p') && dest != 0 { - *(*uintptr)(unsafe.Pointer(dest)) = uintptr(x) + **(**uintptr)(__ccgo_up(dest)) = uintptr(x) } else { _store_int(tls, dest, size, x) } @@ -142066,11 +142066,11 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if dest != 0 { switch size { case SIZE_def: - *(*float32)(unsafe.Pointer(dest)) = float32(y) + **(**float32)(__ccgo_up(dest)) = float32(y) case int32(SIZE_l): - *(*float64)(unsafe.Pointer(dest)) = y + **(**float64)(__ccgo_up(dest)) = y case int32(SIZE_L): - *(*float64)(unsafe.Pointer(dest)) = y + **(**float64)(__ccgo_up(dest)) = y break } } @@ -142236,41 +142236,41 @@ var _states1 = [8][58]uint8{ func _pop_arg1(tls *TLS, arg uintptr, type1 int32, ap uintptr) { switch type1 { case int32(_PTR): - *(*uintptr)(unsafe.Pointer(arg)) = VaUintptr(&*(*Tva_list)(unsafe.Pointer(ap))) + *(*uintptr)(unsafe.Pointer(arg)) = VaUintptr(&**(**Tva_list)(__ccgo_up(ap))) case int32(_INT): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_UINT): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint32(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint32(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_LONG): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_ULONG): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&**(**Tva_list)(__ccgo_up(ap))) case int32(_ULLONG): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_SHORT): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt16(int16(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt16(int16(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_USHORT): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint16FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint16FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_CHAR): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt8(int8(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt8(int8(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_UCHAR): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint8FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint8FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_LLONG): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_SIZET): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&**(**Tva_list)(__ccgo_up(ap))) case int32(_IMAX): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_UMAX): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&**(**Tva_list)(__ccgo_up(ap))) case int32(_PDIFF): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_UIPTR): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUintptr(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUintptr(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_DBL): - *(*float64)(unsafe.Pointer(arg)) = float64(VaFloat64(&*(*Tva_list)(unsafe.Pointer(ap)))) + *(*float64)(unsafe.Pointer(arg)) = float64(VaFloat64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_LDBL): - *(*float64)(unsafe.Pointer(arg)) = VaFloat64(&*(*Tva_list)(unsafe.Pointer(ap))) + *(*float64)(unsafe.Pointer(arg)) = VaFloat64(&**(**Tva_list)(__ccgo_up(ap))) } } @@ -142286,7 +142286,7 @@ func _out1(tls *TLS, f uintptr, s uintptr, l Tsize_t) { } v2 = s s += 4 - Xfputwc(tls, *(*Twchar_t)(unsafe.Pointer(v2)), f) + Xfputwc(tls, **(**Twchar_t)(__ccgo_up(v2)), f) } } @@ -142304,18 +142304,18 @@ func _getint1(tls *TLS, s uintptr) (r int32) { _ = i i = 0 for { - if !(BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-uint32('0') < uint32(10)) != 0) { break } - if Uint32FromInt32(i) > Uint32FromInt32(INT_MAX)/Uint32FromUint32(10) || *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s))))-int32('0') > int32(INT_MAX)-int32(10)*i { + if Uint32FromInt32(i) > Uint32FromInt32(INT_MAX)/Uint32FromUint32(10) || **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(s))))-int32('0') > int32(INT_MAX)-int32(10)*i { i = -int32(1) } else { - i = int32(10)*i + (*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))) - int32('0')) + i = int32(10)*i + (**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))) - int32('0')) } goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s)) += 4 + **(**uintptr)(__ccgo_up(s)) += 4 } return i } @@ -142346,7 +142346,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, var _ /* s at bp+8 */ uintptr var _ /* wc at bp+40 */ Twchar_t _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argpos, bs, cnt, fl, i, l, l10n, p, ps, st, t, w, xp, z, v15, v5, v6, v7, v8, v9 - *(*uintptr)(unsafe.Pointer(bp + 8)) = fmt + **(**uintptr)(__ccgo_up(bp + 8)) = fmt l10n = uint32(0) cnt = 0 l = 0 @@ -142359,30 +142359,30 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } /* Update output count, end loop when fmt is exhausted */ cnt = cnt + l - if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) != 0) { + if !(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) != 0) { break } /* Handle literal text and %% format specifiers */ - a = *(*uintptr)(unsafe.Pointer(bp + 8)) + a = **(**uintptr)(__ccgo_up(bp + 8)) for { - if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) != 0 && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) != int32('%')) { + if !(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) != 0 && **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) != int32('%')) { break } goto _2 _2: ; - *(*uintptr)(unsafe.Pointer(bp + 8)) += 4 + **(**uintptr)(__ccgo_up(bp + 8)) += 4 } - z = *(*uintptr)(unsafe.Pointer(bp + 8)) + z = **(**uintptr)(__ccgo_up(bp + 8)) for { - if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) == int32('%') && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4)) == int32('%')) { + if !(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) == int32('%') && **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 1*4)) == int32('%')) { break } goto _3 _3: ; z += 4 - *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(2)*4 + **(**uintptr)(__ccgo_up(bp + 8)) = **(**uintptr)(__ccgo_up(bp + 8)) + uintptr(2)*4 } if (int64(z)-int64(a))/4 > int64(int32(INT_MAX)-cnt) { goto overflow @@ -142394,42 +142394,42 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if l != 0 { goto _1 } - if BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4)))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4)) == int32('$') { + if BoolInt32(Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 1*4)))-uint32('0') < uint32(10)) != 0 && **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 2*4)) == int32('$') { l10n = uint32(1) - argpos = *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4)) - int32('0') - *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(3)*4 + argpos = **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 1*4)) - int32('0') + **(**uintptr)(__ccgo_up(bp + 8)) = **(**uintptr)(__ccgo_up(bp + 8)) + uintptr(3)*4 } else { argpos = -int32(1) - *(*uintptr)(unsafe.Pointer(bp + 8)) += 4 + **(**uintptr)(__ccgo_up(bp + 8)) += 4 } /* Read modifier flags */ fl = uint32(0) for { - if !(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))))-uint32(' ') < uint32(32) && (Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('0')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('\'')-Int32FromUint8(' ')))&(uint32(1)<<(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8))))-int32(' '))) != 0) { + if !(Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))))-uint32(' ') < uint32(32) && (Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('0')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('\'')-Int32FromUint8(' ')))&(uint32(1)<<(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8))))-int32(' '))) != 0) { break } - fl = fl | uint32(1)<<(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8))))-int32(' ')) + fl = fl | uint32(1)<<(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8))))-int32(' ')) goto _4 _4: ; - *(*uintptr)(unsafe.Pointer(bp + 8)) += 4 + **(**uintptr)(__ccgo_up(bp + 8)) += 4 } /* Read field width */ - if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) == int32('*') { - if BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4)))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4)) == int32('$') { + if **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) == int32('*') { + if BoolInt32(Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 1*4)))-uint32('0') < uint32(10)) != 0 && **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 2*4)) == int32('$') { l10n = uint32(1) - *(*int32)(unsafe.Pointer(nl_type + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4))-int32('0'))*4)) = int32(_INT) - w = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4))-int32('0'))*8))) - *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(3)*4 + **(**int32)(__ccgo_up(nl_type + uintptr(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 1*4))-int32('0'))*4)) = int32(_INT) + w = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 1*4))-int32('0'))*8))) + **(**uintptr)(__ccgo_up(bp + 8)) = **(**uintptr)(__ccgo_up(bp + 8)) + uintptr(3)*4 } else { if !(l10n != 0) { if f != 0 { - v5 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) + v5 = VaInt32(&**(**Tva_list)(__ccgo_up(ap))) } else { v5 = 0 } w = v5 - *(*uintptr)(unsafe.Pointer(bp + 8)) += 4 + **(**uintptr)(__ccgo_up(bp + 8)) += 4 } else { goto inval } @@ -142446,28 +142446,28 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } } /* Read precision */ - if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) == int32('.') && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4)) == int32('*') { - if BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4)))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 3*4)) == int32('$') { - *(*int32)(unsafe.Pointer(nl_type + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4))-int32('0'))*4)) = int32(_INT) - p = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4))-int32('0'))*8))) - *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(4)*4 + if **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) == int32('.') && **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 1*4)) == int32('*') { + if BoolInt32(Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 2*4)))-uint32('0') < uint32(10)) != 0 && **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 3*4)) == int32('$') { + **(**int32)(__ccgo_up(nl_type + uintptr(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 2*4))-int32('0'))*4)) = int32(_INT) + p = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 2*4))-int32('0'))*8))) + **(**uintptr)(__ccgo_up(bp + 8)) = **(**uintptr)(__ccgo_up(bp + 8)) + uintptr(4)*4 } else { if !(l10n != 0) { if f != 0 { - v5 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) + v5 = VaInt32(&**(**Tva_list)(__ccgo_up(ap))) } else { v5 = 0 } p = v5 - *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(2)*4 + **(**uintptr)(__ccgo_up(bp + 8)) = **(**uintptr)(__ccgo_up(bp + 8)) + uintptr(2)*4 } else { goto inval } } xp = BoolInt32(p >= 0) } else { - if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) == int32('.') { - *(*uintptr)(unsafe.Pointer(bp + 8)) += 4 + if **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) == int32('.') { + **(**uintptr)(__ccgo_up(bp + 8)) += 4 p = _getint1(tls, bp+8) xp = int32(1) } else { @@ -142478,13 +142478,13 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, /* Format specifier state machine */ st = uint32(0) for cond := true; cond; cond = st-uint32(1) < uint32(_STOP) { - if Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))))-uint32('A') > Uint32FromInt32(Int32FromUint8('z')-Int32FromUint8('A')) { + if Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))))-uint32('A') > Uint32FromInt32(Int32FromUint8('z')-Int32FromUint8('A')) { goto inval } ps = st - v8 = *(*uintptr)(unsafe.Pointer(bp + 8)) - *(*uintptr)(unsafe.Pointer(bp + 8)) += 4 - st = uint32(*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_states1)) + uintptr(st)*58 + uintptr(*(*Twchar_t)(unsafe.Pointer(v8))-int32('A'))))) + v8 = **(**uintptr)(__ccgo_up(bp + 8)) + **(**uintptr)(__ccgo_up(bp + 8)) += 4 + st = uint32(**(**uint8)(__ccgo_up(uintptr(unsafe.Pointer(&_states1)) + uintptr(st)*58 + uintptr(**(**Twchar_t)(__ccgo_up(v8))-int32('A'))))) } if !(st != 0) { goto inval @@ -142496,8 +142496,8 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } } else { if argpos >= 0 { - *(*int32)(unsafe.Pointer(nl_type + uintptr(argpos)*4)) = Int32FromUint32(st) - *(*Targ)(unsafe.Pointer(bp + 16)) = *(*Targ)(unsafe.Pointer(nl_arg + uintptr(argpos)*8)) + **(**int32)(__ccgo_up(nl_type + uintptr(argpos)*4)) = Int32FromUint32(st) + **(**Targ)(__ccgo_up(bp + 16)) = **(**Targ)(__ccgo_up(nl_arg + uintptr(argpos)*8)) } else { if f != 0 { _pop_arg1(tls, bp+16, Int32FromUint32(st), ap) @@ -142513,7 +142513,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_ERR) != 0 { return -int32(1) } - t = *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(-Int32FromInt32(1))*4)) + t = **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + uintptr(-Int32FromInt32(1))*4)) if ps != 0 && t&int32(15) == int32(3) { t = t & ^Int32FromInt32(32) } @@ -142521,19 +142521,19 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, case int32('n'): switch ps { case uint32(_BARE): - *(*int32)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))) = cnt + **(**int32)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 16)))) = cnt case uint32(_LPRE): - *(*int64)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))) = int64(cnt) + **(**int64)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 16)))) = int64(cnt) case uint32(_LLPRE): - *(*int64)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))) = int64(cnt) + **(**int64)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 16)))) = int64(cnt) case uint32(_HPRE): - *(*uint16)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))) = Uint16FromInt32(cnt) + **(**uint16)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 16)))) = Uint16FromInt32(cnt) case uint32(_HHPRE): - *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))) = Uint8FromInt32(cnt) + **(**uint8)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 16)))) = Uint8FromInt32(cnt) case uint32(_ZTPRE): - *(*Tsize_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))) = Uint64FromInt32(cnt) + **(**Tsize_t)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 16)))) = Uint64FromInt32(cnt) case uint32(_JPRE): - *(*Tuintmax_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))) = Uint64FromInt32(cnt) + **(**Tuintmax_t)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 16)))) = Uint64FromInt32(cnt) break } goto _1 @@ -142562,7 +142562,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, v5 = p } z = a + uintptr(Xwcsnlen(tls, a, Uint64FromInt32(v5)))*4 - if p < 0 && *(*Twchar_t)(unsafe.Pointer(z)) != 0 { + if p < 0 && **(**Twchar_t)(__ccgo_up(z)) != 0 { goto overflow } p = int32((int64(z) - int64(a)) / 4) @@ -142575,7 +142575,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, l = w goto _1 case int32('m'): - *(*uintptr)(unsafe.Pointer(bp + 16)) = Xstrerror(tls, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) + *(*uintptr)(unsafe.Pointer(bp + 16)) = Xstrerror(tls, **(**int32)(__ccgo_up(X__errno_location(tls)))) fallthrough case int32('s'): if !(*(*uintptr)(unsafe.Pointer(bp + 16)) != 0) { @@ -142607,7 +142607,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if i < 0 { return -int32(1) } - if p < 0 && *(*int8)(unsafe.Pointer(bs)) != 0 { + if p < 0 && **(**int8)(__ccgo_up(bs)) != 0 { goto overflow } p = l @@ -142668,17 +142668,17 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } i = int32(1) for { - if !(i <= int32(NL_ARGMAX) && *(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)) != 0) { + if !(i <= int32(NL_ARGMAX) && **(**int32)(__ccgo_up(nl_type + uintptr(i)*4)) != 0) { break } - _pop_arg1(tls, nl_arg+uintptr(i)*8, *(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)), ap) + _pop_arg1(tls, nl_arg+uintptr(i)*8, **(**int32)(__ccgo_up(nl_type + uintptr(i)*4)), ap) goto _17 _17: ; i = i + 1 } for { - if !(i <= int32(NL_ARGMAX) && !(*(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)) != 0)) { + if !(i <= int32(NL_ARGMAX) && !(**(**int32)(__ccgo_up(nl_type + uintptr(i)*4)) != 0)) { break } goto _18 @@ -142693,12 +142693,12 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto inval inval: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) goto overflow overflow: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return -int32(1) } @@ -142714,11 +142714,11 @@ func Xvfwprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { var _ /* nl_arg at bp+48 */ [10]Targ var _ /* nl_type at bp+8 */ [10]int32 _, _, _, _ = __need_unlock, olderr, ret, v1 - *(*[10]int32)(unsafe.Pointer(bp + 8)) = [10]int32{} + **(**[10]int32)(__ccgo_up(bp + 8)) = [10]int32{} /* the copy allows passing va_list* even if va_list is an array */ - *(*Tva_list)(unsafe.Pointer(bp)) = ap + **(**Tva_list)(__ccgo_up(bp)) = ap if _wprintf_core(tls, uintptr(0), fmt, bp, bp+48, bp+8) < 0 { - _ = *(*Tva_list)(unsafe.Pointer(bp)) + _ = **(**Tva_list)(__ccgo_up(bp)) return -int32(1) } if AtomicLoadPInt32(f+140) >= 0 { @@ -142729,16 +142729,16 @@ func Xvfwprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { __need_unlock = v1 Xfwide(tls, f, int32(1)) olderr = Int32FromUint32((*TFILE)(unsafe.Pointer(f)).Fflags & uint32(F_ERR)) - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_ERR)) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^Int32FromInt32(F_ERR)) ret = _wprintf_core(tls, f, fmt, bp, bp+48, bp+8) if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_ERR) != 0 { ret = -int32(1) } - *(*uint32)(unsafe.Pointer(f)) |= Uint32FromInt32(olderr) + **(**uint32)(__ccgo_up(f)) |= Uint32FromInt32(olderr) if __need_unlock != 0 { ___unlockfile(tls, f) } - _ = *(*Tva_list)(unsafe.Pointer(bp)) + _ = **(**Tva_list)(__ccgo_up(bp)) return ret } @@ -142748,15 +142748,15 @@ func _store_int1(tls *TLS, dest uintptr, size int32, i uint64) { } switch size { case -int32(2): - *(*int8)(unsafe.Pointer(dest)) = Int8FromUint64(i) + **(**int8)(__ccgo_up(dest)) = Int8FromUint64(i) case -int32(1): - *(*int16)(unsafe.Pointer(dest)) = Int16FromUint64(i) + **(**int16)(__ccgo_up(dest)) = Int16FromUint64(i) case SIZE_def: - *(*int32)(unsafe.Pointer(dest)) = Int32FromUint64(i) + **(**int32)(__ccgo_up(dest)) = Int32FromUint64(i) case int32(SIZE_l): - *(*int64)(unsafe.Pointer(dest)) = Int64FromUint64(i) + **(**int64)(__ccgo_up(dest)) = Int64FromUint64(i) case int32(SIZE_ll): - *(*int64)(unsafe.Pointer(dest)) = Int64FromUint64(i) + **(**int64)(__ccgo_up(dest)) = Int64FromUint64(i) break } } @@ -142788,13 +142788,13 @@ func _in_set(tls *TLS, set uintptr, c int32) (r int32) { var p, v3 uintptr _, _, _ = j, p, v3 p = set - if *(*Twchar_t)(unsafe.Pointer(p)) == int32('-') { + if **(**Twchar_t)(__ccgo_up(p)) == int32('-') { if c == int32('-') { return int32(1) } p += 4 } else { - if *(*Twchar_t)(unsafe.Pointer(p)) == int32(']') { + if **(**Twchar_t)(__ccgo_up(p)) == int32(']') { if c == int32(']') { return int32(1) } @@ -142802,15 +142802,15 @@ func _in_set(tls *TLS, set uintptr, c int32) (r int32) { } } for { - if !(*(*Twchar_t)(unsafe.Pointer(p)) != 0 && *(*Twchar_t)(unsafe.Pointer(p)) != int32(']')) { + if !(**(**Twchar_t)(__ccgo_up(p)) != 0 && **(**Twchar_t)(__ccgo_up(p)) != int32(']')) { break } - if *(*Twchar_t)(unsafe.Pointer(p)) == int32('-') && *(*Twchar_t)(unsafe.Pointer(p + 1*4)) != 0 && *(*Twchar_t)(unsafe.Pointer(p + 1*4)) != int32(']') { + if **(**Twchar_t)(__ccgo_up(p)) == int32('-') && **(**Twchar_t)(__ccgo_up(p + 1*4)) != 0 && **(**Twchar_t)(__ccgo_up(p + 1*4)) != int32(']') { v3 = p p += 4 - j = *(*Twchar_t)(unsafe.Pointer(v3 + uintptr(-Int32FromInt32(1))*4)) + j = **(**Twchar_t)(__ccgo_up(v3 + uintptr(-Int32FromInt32(1))*4)) for { - if !(j < *(*Twchar_t)(unsafe.Pointer(p))) { + if !(j < **(**Twchar_t)(__ccgo_up(p))) { break } if c == j { @@ -142822,7 +142822,7 @@ func _in_set(tls *TLS, set uintptr, c int32) (r int32) { j = j + 1 } } - if c == *(*Twchar_t)(unsafe.Pointer(p)) { + if c == **(**Twchar_t)(__ccgo_up(p)) { return int32(1) } goto _1 @@ -142860,20 +142860,20 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { Xfwide(tls, f, int32(1)) p = fmt for { - if !(*(*Twchar_t)(unsafe.Pointer(p)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(p)) != 0) { break } alloc = 0 - if Xiswspace(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(p)))) != 0 { - for Xiswspace(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(p + 1*4)))) != 0 { + if Xiswspace(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(p)))) != 0 { + for Xiswspace(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(p + 1*4)))) != 0 { p += 4 } for { - if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { + if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(**(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) + v4 = uint32(**(**uint8)(__ccgo_up(v5))) } else { v4 = Xgetwc(tls, f) } @@ -142888,21 +142888,21 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v6 = f + 8 *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 v5 = *(*uintptr)(unsafe.Pointer(v6)) - _ = *(*uint8)(unsafe.Pointer(v5)) + _ = **(**uint8)(__ccgo_up(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } goto _2 } - if *(*Twchar_t)(unsafe.Pointer(p)) != int32('%') || *(*Twchar_t)(unsafe.Pointer(p + 1*4)) == int32('%') { - if *(*Twchar_t)(unsafe.Pointer(p)) == int32('%') { + if **(**Twchar_t)(__ccgo_up(p)) != int32('%') || **(**Twchar_t)(__ccgo_up(p + 1*4)) == int32('%') { + if **(**Twchar_t)(__ccgo_up(p)) == int32('%') { p += 4 for { - if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { + if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(**(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) + v4 = uint32(**(**uint8)(__ccgo_up(v5))) } else { v4 = Xgetwc(tls, f) } @@ -142914,22 +142914,22 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { pos = pos + 1 } } else { - if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { + if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(**(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) + v4 = uint32(**(**uint8)(__ccgo_up(v5))) } else { v4 = Xgetwc(tls, f) } c = Int32FromUint32(v4) } - if c != *(*Twchar_t)(unsafe.Pointer(p)) { + if c != **(**Twchar_t)(__ccgo_up(p)) { if (*TFILE)(unsafe.Pointer(f)).Frend != 0 && Uint32FromInt32(c) < uint32(128) { v6 = f + 8 *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 v5 = *(*uintptr)(unsafe.Pointer(v6)) - _ = *(*uint8)(unsafe.Pointer(v5)) + _ = **(**uint8)(__ccgo_up(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -142942,12 +142942,12 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { goto _2 } p += 4 - if *(*Twchar_t)(unsafe.Pointer(p)) == int32('*') { + if **(**Twchar_t)(__ccgo_up(p)) == int32('*') { dest = uintptr(0) p += 4 } else { - if BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(p)))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(p + 1*4)) == int32('$') { - dest = _arg_n1(tls, ap, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(p))-int32('0'))) + if BoolInt32(Uint32FromInt32(**(**Twchar_t)(__ccgo_up(p)))-uint32('0') < uint32(10)) != 0 && **(**Twchar_t)(__ccgo_up(p + 1*4)) == int32('$') { + dest = _arg_n1(tls, ap, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(p))-int32('0'))) p = p + uintptr(2)*4 } else { dest = VaUintptr(&ap) @@ -142955,16 +142955,16 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } width = 0 for { - if !(BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(p)))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(Uint32FromInt32(**(**Twchar_t)(__ccgo_up(p)))-uint32('0') < uint32(10)) != 0) { break } - width = int32(10)*width + *(*Twchar_t)(unsafe.Pointer(p)) - int32('0') + width = int32(10)*width + **(**Twchar_t)(__ccgo_up(p)) - int32('0') goto _18 _18: ; p += 4 } - if *(*Twchar_t)(unsafe.Pointer(p)) == int32('m') { + if **(**Twchar_t)(__ccgo_up(p)) == int32('m') { wcs = uintptr(0) s = uintptr(0) alloc = BoolInt32(!!(dest != 0)) @@ -142975,16 +142975,16 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { size = SIZE_def v5 = p p += 4 - switch *(*Twchar_t)(unsafe.Pointer(v5)) { + switch **(**Twchar_t)(__ccgo_up(v5)) { case int32('h'): - if *(*Twchar_t)(unsafe.Pointer(p)) == int32('h') { + if **(**Twchar_t)(__ccgo_up(p)) == int32('h') { p += 4 size = -Int32FromInt32(2) } else { size = -int32(1) } case int32('l'): - if *(*Twchar_t)(unsafe.Pointer(p)) == int32('l') { + if **(**Twchar_t)(__ccgo_up(p)) == int32('l') { p += 4 size = Int32FromInt32(SIZE_ll) } else { @@ -143043,7 +143043,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { default: goto fmt_fail } - t = *(*Twchar_t)(unsafe.Pointer(p)) + t = **(**Twchar_t)(__ccgo_up(p)) /* Transform S,C -> ls,lc */ if t&int32(0x2f) == int32(3) { size = int32(SIZE_l) @@ -143052,11 +143052,11 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if t != int32('n') { if t != int32('[') && t|int32(32) != int32('c') { for { - if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { + if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(**(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) + v4 = uint32(**(**uint8)(__ccgo_up(v5))) } else { v4 = Xgetwc(tls, f) } @@ -143068,11 +143068,11 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { pos = pos + 1 } } else { - if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { + if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(**(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) + v4 = uint32(**(**uint8)(__ccgo_up(v5))) } else { v4 = Xgetwc(tls, f) } @@ -143085,7 +143085,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v6 = f + 8 *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 v5 = *(*uintptr)(unsafe.Pointer(v6)) - _ = *(*uint8)(unsafe.Pointer(v5)) + _ = **(**uint8)(__ccgo_up(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -143113,18 +143113,18 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } else { p += 4 v5 = p - if *(*Twchar_t)(unsafe.Pointer(v5)) == int32('^') { + if **(**Twchar_t)(__ccgo_up(v5)) == int32('^') { p += 4 invert = Int32FromInt32(1) } else { invert = 0 } set = p - if *(*Twchar_t)(unsafe.Pointer(p)) == int32(']') { + if **(**Twchar_t)(__ccgo_up(p)) == int32(']') { p += 4 } - for *(*Twchar_t)(unsafe.Pointer(p)) != int32(']') { - if !(*(*Twchar_t)(unsafe.Pointer(p)) != 0) { + for **(**Twchar_t)(__ccgo_up(p)) != int32(']') { + if !(**(**Twchar_t)(__ccgo_up(p)) != 0) { goto fmt_fail } p += 4 @@ -143168,11 +143168,11 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } } for width != 0 { - if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { + if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(**(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) + v4 = uint32(**(**uint8)(__ccgo_up(v5))) } else { v4 = Xgetwc(tls, f) } @@ -143187,7 +143187,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if wcs != 0 { v37 = i i = i + 1 - *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(v37)*4)) = c + **(**Twchar_t)(__ccgo_up(wcs + uintptr(v37)*4)) = c if alloc != 0 && i == k { k = k + (k + uint64(1)) tmp1 = Xrealloc(tls, wcs, k*uint64(4)) @@ -143227,7 +143227,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v6 = f + 8 *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 v5 = *(*uintptr)(unsafe.Pointer(v6)) - _ = *(*uint8)(unsafe.Pointer(v5)) + _ = **(**uint8)(__ccgo_up(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -143237,17 +143237,17 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } if alloc != 0 { if size == int32(SIZE_l) { - *(*uintptr)(unsafe.Pointer(dest)) = wcs + **(**uintptr)(__ccgo_up(dest)) = wcs } else { - *(*uintptr)(unsafe.Pointer(dest)) = s + **(**uintptr)(__ccgo_up(dest)) = s } } if t != int32('c') { if wcs != 0 { - *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) = 0 + **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) = 0 } if s != 0 { - *(*int8)(unsafe.Pointer(s + uintptr(i))) = 0 + **(**int8)(__ccgo_up(s + uintptr(i))) = 0 } } case int32('d'): @@ -143283,7 +143283,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { width = 0 } Xsnprintf(tls, bp+8, uint64(22), __ccgo_ts+1660, VaList(bp+40, int32(1)+BoolInt32(!(dest != 0)), __ccgo_ts+1678, width, uintptr(unsafe.Pointer(&_size_pfx))+uintptr(size+int32(2))*3, t)) - *(*Toff_t)(unsafe.Pointer(bp)) = 0 + **(**Toff_t)(__ccgo_up(bp)) = 0 if dest != 0 { v5 = dest } else { @@ -143292,11 +143292,11 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if Xfscanf(tls, f, bp+8, VaList(bp+40, v5, bp)) == -int32(1) { goto input_fail } else { - if !(*(*Toff_t)(unsafe.Pointer(bp)) != 0) { + if !(**(**Toff_t)(__ccgo_up(bp)) != 0) { goto match_fail } } - pos = pos + *(*Toff_t)(unsafe.Pointer(bp)) + pos = pos + **(**Toff_t)(__ccgo_up(bp)) default: goto fmt_fail } @@ -143422,8 +143422,8 @@ func _sn_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { k = v1 if k != 0 { Xmemcpy(tls, (*Tcookie3)(unsafe.Pointer(c)).Fs, (*TFILE)(unsafe.Pointer(f)).Fwbase, k) - *(*uintptr)(unsafe.Pointer(c)) += uintptr(k) - *(*Tsize_t)(unsafe.Pointer(c + 8)) -= k + **(**uintptr)(__ccgo_up(c)) += uintptr(k) + **(**Tsize_t)(__ccgo_up(c + 8)) -= k } if (*Tcookie3)(unsafe.Pointer(c)).Fn < l { v1 = (*Tcookie3)(unsafe.Pointer(c)).Fn @@ -143433,10 +143433,10 @@ func _sn_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { k = v1 if k != 0 { Xmemcpy(tls, (*Tcookie3)(unsafe.Pointer(c)).Fs, s, k) - *(*uintptr)(unsafe.Pointer(c)) += uintptr(k) - *(*Tsize_t)(unsafe.Pointer(c + 8)) -= k + **(**uintptr)(__ccgo_up(c)) += uintptr(k) + **(**Tsize_t)(__ccgo_up(c + 8)) -= k } - *(*int8)(unsafe.Pointer((*Tcookie3)(unsafe.Pointer(c)).Fs)) = 0 + **(**int8)(__ccgo_up((*Tcookie3)(unsafe.Pointer(c)).Fs)) = 0 v3 = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Fwbase = v3 (*TFILE)(unsafe.Pointer(f)).Fwpos = v3 @@ -143468,18 +143468,18 @@ func Xvsnprintf(tls *TLS, s uintptr, n Tsize_t, fmt uintptr, ap Tva_list) (r int } else { v2 = uint64(0) } - *(*Tcookie3)(unsafe.Pointer(bp + 8)) = Tcookie3{ + **(**Tcookie3)(__ccgo_up(bp + 8)) = Tcookie3{ Fs: v1, Fn: v2, } - *(*TFILE)(unsafe.Pointer(bp + 24)) = TFILE{ + **(**TFILE)(__ccgo_up(bp + 24)) = TFILE{ Fwrite: __ccgo_fp(_sn_write), Fbuf: bp, Flock: -int32(1), Flbf: -int32(1), Fcookie: bp + 8, } - *(*int8)(unsafe.Pointer((*(*Tcookie3)(unsafe.Pointer(bp + 8))).Fs)) = 0 + **(**int8)(__ccgo_up((**(**Tcookie3)(__ccgo_up(bp + 8))).Fs)) = 0 return Xvfprintf(tls, bp+24, fmt, ap) } @@ -143528,7 +143528,7 @@ func Xvsscanf(tls *TLS, s uintptr, fmt uintptr, ap Tva_list) (r int32) { bp := tls.Alloc(240) defer tls.Free(240) var _ /* f at bp+0 */ TFILE - *(*TFILE)(unsafe.Pointer(bp)) = TFILE{ + **(**TFILE)(__ccgo_up(bp)) = TFILE{ Fread: __ccgo_fp(_string_read), Fbuf: s, Flock: -int32(1), @@ -143578,14 +143578,14 @@ func _sw_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { (*Tcookie4)(unsafe.Pointer(c)).Fl = (*Tcookie4)(unsafe.Pointer(c)).Fl - 1 (*Tcookie4)(unsafe.Pointer(c)).Fws += 4 } - *(*Twchar_t)(unsafe.Pointer((*Tcookie4)(unsafe.Pointer(c)).Fws)) = 0 + **(**Twchar_t)(__ccgo_up((*Tcookie4)(unsafe.Pointer(c)).Fws)) = 0 if i < 0 { v4 = UintptrFromInt32(0) (*TFILE)(unsafe.Pointer(f)).Fwend = v4 v3 = v4 (*TFILE)(unsafe.Pointer(f)).Fwbase = v3 (*TFILE)(unsafe.Pointer(f)).Fwpos = v3 - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) return Uint64FromInt32(i) } (*TFILE)(unsafe.Pointer(f)).Fwend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr((*TFILE)(unsafe.Pointer(f)).Fbuf_size) @@ -143607,11 +143607,11 @@ func Xvswprintf(tls *TLS, s uintptr, n Tsize_t, fmt uintptr, ap Tva_list) (r1 in var _ /* c at bp+256 */ Tcookie4 var _ /* f at bp+272 */ TFILE _, _ = r, v1 - *(*Tcookie4)(unsafe.Pointer(bp + 256)) = Tcookie4{ + **(**Tcookie4)(__ccgo_up(bp + 256)) = Tcookie4{ Fws: s, Fl: n - uint64(1), } - *(*TFILE)(unsafe.Pointer(bp + 272)) = TFILE{ + **(**TFILE)(__ccgo_up(bp + 272)) = TFILE{ Fwrite: __ccgo_fp(_sw_write), Fbuf: bp, Fbuf_size: uint64(256), @@ -143639,8 +143639,8 @@ func _wstring_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { var v1, v2 uintptr var _ /* src at bp+0 */ uintptr _, _, _ = k, v1, v2 - *(*uintptr)(unsafe.Pointer(bp)) = (*TFILE)(unsafe.Pointer(f)).Fcookie - if !(*(*uintptr)(unsafe.Pointer(bp)) != 0) { + **(**uintptr)(__ccgo_up(bp)) = (*TFILE)(unsafe.Pointer(f)).Fcookie + if !(**(**uintptr)(__ccgo_up(bp)) != 0) { return uint64(0) } k = Xwcsrtombs(tls, (*TFILE)(unsafe.Pointer(f)).Fbuf, bp, (*TFILE)(unsafe.Pointer(f)).Fbuf_size, uintptr(0)) @@ -143652,14 +143652,14 @@ func _wstring_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { } (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(k) - (*TFILE)(unsafe.Pointer(f)).Fcookie = *(*uintptr)(unsafe.Pointer(bp)) + (*TFILE)(unsafe.Pointer(f)).Fcookie = **(**uintptr)(__ccgo_up(bp)) if !(len1 != 0) || !(k != 0) { return uint64(0) } v2 = f + 8 v1 = *(*uintptr)(unsafe.Pointer(v2)) *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(v2)) + 1 - *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v1)) + **(**uint8)(__ccgo_up(buf)) = **(**uint8)(__ccgo_up(v1)) return uint64(1) } @@ -143672,7 +143672,7 @@ func Xvswscanf(tls *TLS, s uintptr, fmt uintptr, ap Tva_list) (r int32) { defer tls.Free(496) var _ /* buf at bp+0 */ [256]uint8 var _ /* f at bp+256 */ TFILE - *(*TFILE)(unsafe.Pointer(bp + 256)) = TFILE{ + **(**TFILE)(__ccgo_up(bp + 256)) = TFILE{ Fread: __ccgo_fp(_wstring_read), Fbuf: bp, Fbuf_size: uint64(256), @@ -143784,7 +143784,7 @@ func Xatoi(tls *TLS, s uintptr) (r int32) { n = 0 neg = 0 for { - v1 = int32(*(*int8)(unsafe.Pointer(s))) + v1 = int32(**(**int8)(__ccgo_up(s))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _3 _3: @@ -143793,7 +143793,7 @@ func Xatoi(tls *TLS, s uintptr) (r int32) { } s = s + 1 } - switch int32(*(*int8)(unsafe.Pointer(s))) { + switch int32(**(**int8)(__ccgo_up(s))) { case int32('-'): neg = int32(1) fallthrough @@ -143801,10 +143801,10 @@ func Xatoi(tls *TLS, s uintptr) (r int32) { s = s + 1 } /* Compute n as a negative number to avoid overflow on INT_MIN */ - for BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { + for BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(s)))-uint32('0') < uint32(10)) != 0 { v4 = s s = s + 1 - n = int32(10)*n - (int32(*(*int8)(unsafe.Pointer(v4))) - int32('0')) + n = int32(10)*n - (int32(**(**int8)(__ccgo_up(v4))) - int32('0')) } if neg != 0 { v1 = n @@ -143826,7 +143826,7 @@ func Xatol(tls *TLS, s uintptr) (r int64) { n = 0 neg = 0 for { - v1 = int32(*(*int8)(unsafe.Pointer(s))) + v1 = int32(**(**int8)(__ccgo_up(s))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _3 _3: @@ -143835,7 +143835,7 @@ func Xatol(tls *TLS, s uintptr) (r int64) { } s = s + 1 } - switch int32(*(*int8)(unsafe.Pointer(s))) { + switch int32(**(**int8)(__ccgo_up(s))) { case int32('-'): neg = int32(1) fallthrough @@ -143843,10 +143843,10 @@ func Xatol(tls *TLS, s uintptr) (r int64) { s = s + 1 } /* Compute n as a negative number to avoid overflow on LONG_MIN */ - for BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { + for BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(s)))-uint32('0') < uint32(10)) != 0 { v4 = s s = s + 1 - n = int64(10)*n - int64(int32(*(*int8)(unsafe.Pointer(v4)))-Int32FromUint8('0')) + n = int64(10)*n - int64(int32(**(**int8)(__ccgo_up(v4)))-Int32FromUint8('0')) } if neg != 0 { v5 = n @@ -143868,7 +143868,7 @@ func Xatoll(tls *TLS, s uintptr) (r int64) { n = 0 neg = 0 for { - v1 = int32(*(*int8)(unsafe.Pointer(s))) + v1 = int32(**(**int8)(__ccgo_up(s))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _3 _3: @@ -143877,7 +143877,7 @@ func Xatoll(tls *TLS, s uintptr) (r int64) { } s = s + 1 } - switch int32(*(*int8)(unsafe.Pointer(s))) { + switch int32(**(**int8)(__ccgo_up(s))) { case int32('-'): neg = int32(1) fallthrough @@ -143885,10 +143885,10 @@ func Xatoll(tls *TLS, s uintptr) (r int64) { s = s + 1 } /* Compute n as a negative number to avoid overflow on LLONG_MIN */ - for BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { + for BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(s)))-uint32('0') < uint32(10)) != 0 { v4 = s s = s + 1 - n = int64(10)*n - int64(int32(*(*int8)(unsafe.Pointer(v4)))-Int32FromUint8('0')) + n = int64(10)*n - int64(int32(**(**int8)(__ccgo_up(v4)))-Int32FromUint8('0')) } if neg != 0 { v5 = n @@ -143950,24 +143950,24 @@ func Xecvt(tls *TLS, x float64, n int32, dp uintptr, sign uintptr) (r uintptr) { n = int32(15) } Xsprintf(tls, bp, __ccgo_ts+1681, VaList(bp+40, n-int32(1), x)) - v1 = BoolInt32(int32((*(*[32]int8)(unsafe.Pointer(bp)))[0]) == Int32FromUint8('-')) - *(*int32)(unsafe.Pointer(sign)) = v1 + v1 = BoolInt32(int32((**(**[32]int8)(__ccgo_up(bp)))[0]) == Int32FromUint8('-')) + **(**int32)(__ccgo_up(sign)) = v1 i = v1 j = 0 for { - if !(int32((*(*[32]int8)(unsafe.Pointer(bp)))[i]) != int32('e')) { + if !(int32((**(**[32]int8)(__ccgo_up(bp)))[i]) != int32('e')) { break } - _buf8[j] = (*(*[32]int8)(unsafe.Pointer(bp)))[i] + _buf8[j] = (**(**[32]int8)(__ccgo_up(bp)))[i] goto _2 _2: ; v1 = i i = i + 1 - j = j + BoolInt32(int32((*(*[32]int8)(unsafe.Pointer(bp)))[v1]) != int32('.')) + j = j + BoolInt32(int32((**(**[32]int8)(__ccgo_up(bp)))[v1]) != int32('.')) } _buf8[j] = 0 - *(*int32)(unsafe.Pointer(dp)) = Xatoi(tls, bp+uintptr(i)+uintptr(1)) + int32(1) + **(**int32)(__ccgo_up(dp)) = Xatoi(tls, bp+uintptr(i)+uintptr(1)) + int32(1) return uintptr(unsafe.Pointer(&_buf8)) } @@ -143987,15 +143987,15 @@ func Xfcvt(tls *TLS, x float64, n int32, dp uintptr, sign uintptr) (r uintptr) { n = int32(1400) } Xsprintf(tls, bp, __ccgo_ts+1686, VaList(bp+1512, n, x)) - i = BoolInt32(int32((*(*[1500]int8)(unsafe.Pointer(bp)))[0]) == int32('-')) - if int32((*(*[1500]int8)(unsafe.Pointer(bp)))[i]) == int32('0') { + i = BoolInt32(int32((**(**[1500]int8)(__ccgo_up(bp)))[0]) == int32('-')) + if int32((**(**[1500]int8)(__ccgo_up(bp)))[i]) == int32('0') { lz = Int32FromUint64(Xstrspn(tls, bp+uintptr(i)+uintptr(2), __ccgo_ts+1654)) } else { lz = -Int32FromUint64(Xstrcspn(tls, bp+uintptr(i), __ccgo_ts+558)) } if n <= lz { - *(*int32)(unsafe.Pointer(sign)) = i - *(*int32)(unsafe.Pointer(dp)) = int32(1) + **(**int32)(__ccgo_up(sign)) = i + **(**int32)(__ccgo_up(dp)) = int32(1) if Uint32FromInt32(n) > uint32(14) { n = int32(14) } @@ -144100,13 +144100,13 @@ func _pntz(tls *TLS, p uintptr) (r1 int32) { var v1, v5 uint64 var v8 bool _, _, _, _, _, _, _ = r, v1, v2, v4, v5, v6, v8 - v1 = *(*Tsize_t)(unsafe.Pointer(p)) - uint64(1) + v1 = **(**Tsize_t)(__ccgo_up(p)) - uint64(1) v2 = _a_ctz_64(tls, v1) goto _3 _3: r = v2 if v8 = r != 0; !v8 { - v5 = *(*Tsize_t)(unsafe.Pointer(p + 1*8)) + v5 = **(**Tsize_t)(__ccgo_up(p + 1*8)) v6 = _a_ctz_64(tls, v5) goto _7 _7: @@ -144130,7 +144130,7 @@ func _cycle(tls *TLS, width Tsize_t, ar uintptr, n int32) { if n < int32(2) { return } - *(*uintptr)(unsafe.Pointer(ar + uintptr(n)*8)) = bp + **(**uintptr)(__ccgo_up(ar + uintptr(n)*8)) = bp for width != 0 { if uint64(256) < width { v1 = uint64(256) @@ -144138,14 +144138,14 @@ func _cycle(tls *TLS, width Tsize_t, ar uintptr, n int32) { v1 = width } l = v1 - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(ar + uintptr(n)*8)), *(*uintptr)(unsafe.Pointer(ar)), l) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(ar + uintptr(n)*8)), **(**uintptr)(__ccgo_up(ar)), l) i = 0 for { if !(i < n) { break } - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(ar + uintptr(i)*8)), *(*uintptr)(unsafe.Pointer(ar + uintptr(i+int32(1))*8)), l) - *(*uintptr)(unsafe.Pointer(ar + uintptr(i)*8)) += uintptr(l) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(ar + uintptr(i)*8)), **(**uintptr)(__ccgo_up(ar + uintptr(i+int32(1))*8)), l) + **(**uintptr)(__ccgo_up(ar + uintptr(i)*8)) += uintptr(l) goto _2 _2: ; @@ -144161,23 +144161,23 @@ func _cycle(tls *TLS, width Tsize_t, ar uintptr, n int32) { func _shl(tls *TLS, p uintptr, n int32) { if Uint64FromInt32(n) >= Uint64FromInt32(8)*Uint64FromInt64(8) { n = Int32FromUint64(uint64(n) - Uint64FromInt32(8)*Uint64FromInt64(8)) - *(*Tsize_t)(unsafe.Pointer(p + 1*8)) = *(*Tsize_t)(unsafe.Pointer(p)) - *(*Tsize_t)(unsafe.Pointer(p)) = uint64(0) + **(**Tsize_t)(__ccgo_up(p + 1*8)) = **(**Tsize_t)(__ccgo_up(p)) + **(**Tsize_t)(__ccgo_up(p)) = uint64(0) } - *(*Tsize_t)(unsafe.Pointer(p + 1*8)) <<= Uint64FromInt32(n) - *(*Tsize_t)(unsafe.Pointer(p + 1*8)) |= *(*Tsize_t)(unsafe.Pointer(p)) >> (Uint64FromInt64(8)*Uint64FromInt32(8) - Uint64FromInt32(n)) - *(*Tsize_t)(unsafe.Pointer(p)) <<= Uint64FromInt32(n) + **(**Tsize_t)(__ccgo_up(p + 1*8)) <<= Uint64FromInt32(n) + **(**Tsize_t)(__ccgo_up(p + 1*8)) |= **(**Tsize_t)(__ccgo_up(p)) >> (Uint64FromInt64(8)*Uint64FromInt32(8) - Uint64FromInt32(n)) + **(**Tsize_t)(__ccgo_up(p)) <<= Uint64FromInt32(n) } func _shr(tls *TLS, p uintptr, n int32) { if Uint64FromInt32(n) >= Uint64FromInt32(8)*Uint64FromInt64(8) { n = Int32FromUint64(uint64(n) - Uint64FromInt32(8)*Uint64FromInt64(8)) - *(*Tsize_t)(unsafe.Pointer(p)) = *(*Tsize_t)(unsafe.Pointer(p + 1*8)) - *(*Tsize_t)(unsafe.Pointer(p + 1*8)) = uint64(0) + **(**Tsize_t)(__ccgo_up(p)) = **(**Tsize_t)(__ccgo_up(p + 1*8)) + **(**Tsize_t)(__ccgo_up(p + 1*8)) = uint64(0) } - *(*Tsize_t)(unsafe.Pointer(p)) >>= Uint64FromInt32(n) - *(*Tsize_t)(unsafe.Pointer(p)) |= *(*Tsize_t)(unsafe.Pointer(p + 1*8)) << (Uint64FromInt64(8)*Uint64FromInt32(8) - Uint64FromInt32(n)) - *(*Tsize_t)(unsafe.Pointer(p + 1*8)) >>= Uint64FromInt32(n) + **(**Tsize_t)(__ccgo_up(p)) >>= Uint64FromInt32(n) + **(**Tsize_t)(__ccgo_up(p)) |= **(**Tsize_t)(__ccgo_up(p + 1*8)) << (Uint64FromInt64(8)*Uint64FromInt32(8) - Uint64FromInt32(n)) + **(**Tsize_t)(__ccgo_up(p + 1*8)) >>= Uint64FromInt32(n) } func _sift(tls *TLS, head uintptr, width Tsize_t, __ccgo_fp_cmp Tcmpfun, arg uintptr, pshift int32, lp uintptr) { @@ -144188,23 +144188,23 @@ func _sift(tls *TLS, head uintptr, width Tsize_t, __ccgo_fp_cmp Tcmpfun, arg uin var _ /* ar at bp+0 */ [113]uintptr _, _, _, _ = i, lf, rt, v1 i = int32(1) - (*(*[113]uintptr)(unsafe.Pointer(bp)))[0] = head + (**(**[113]uintptr)(__ccgo_up(bp)))[0] = head for pshift > int32(1) { rt = head - uintptr(width) - lf = head - uintptr(width) - uintptr(*(*Tsize_t)(unsafe.Pointer(lp + uintptr(pshift-int32(2))*8))) - if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, (*(*[113]uintptr)(unsafe.Pointer(bp)))[0], lf, arg) >= 0 && (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, (*(*[113]uintptr)(unsafe.Pointer(bp)))[0], rt, arg) >= 0 { + lf = head - uintptr(width) - uintptr(**(**Tsize_t)(__ccgo_up(lp + uintptr(pshift-int32(2))*8))) + if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, (**(**[113]uintptr)(__ccgo_up(bp)))[0], lf, arg) >= 0 && (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, (**(**[113]uintptr)(__ccgo_up(bp)))[0], rt, arg) >= 0 { break } if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, lf, rt, arg) >= 0 { v1 = i i = i + 1 - (*(*[113]uintptr)(unsafe.Pointer(bp)))[v1] = lf + (**(**[113]uintptr)(__ccgo_up(bp)))[v1] = lf head = lf pshift = pshift - int32(1) } else { v1 = i i = i + 1 - (*(*[113]uintptr)(unsafe.Pointer(bp)))[v1] = rt + (**(**[113]uintptr)(__ccgo_up(bp)))[v1] = rt head = rt pshift = pshift - int32(2) } @@ -144221,24 +144221,24 @@ func _trinkle(tls *TLS, head uintptr, width Tsize_t, __ccgo_fp_cmp Tcmpfun, arg var _ /* p at bp+0 */ [2]Tsize_t _, _, _, _, _, _ = i, lf, rt, stepson, trail, v1 i = int32(1) - (*(*[2]Tsize_t)(unsafe.Pointer(bp)))[0] = *(*Tsize_t)(unsafe.Pointer(pp)) - (*(*[2]Tsize_t)(unsafe.Pointer(bp)))[int32(1)] = *(*Tsize_t)(unsafe.Pointer(pp + 1*8)) - (*(*[113]uintptr)(unsafe.Pointer(bp + 16)))[0] = head - for (*(*[2]Tsize_t)(unsafe.Pointer(bp)))[0] != uint64(1) || (*(*[2]Tsize_t)(unsafe.Pointer(bp)))[int32(1)] != uint64(0) { - stepson = head - uintptr(*(*Tsize_t)(unsafe.Pointer(lp + uintptr(pshift)*8))) - if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, stepson, (*(*[113]uintptr)(unsafe.Pointer(bp + 16)))[0], arg) <= 0 { + (**(**[2]Tsize_t)(__ccgo_up(bp)))[0] = **(**Tsize_t)(__ccgo_up(pp)) + (**(**[2]Tsize_t)(__ccgo_up(bp)))[int32(1)] = **(**Tsize_t)(__ccgo_up(pp + 1*8)) + (**(**[113]uintptr)(__ccgo_up(bp + 16)))[0] = head + for (**(**[2]Tsize_t)(__ccgo_up(bp)))[0] != uint64(1) || (**(**[2]Tsize_t)(__ccgo_up(bp)))[int32(1)] != uint64(0) { + stepson = head - uintptr(**(**Tsize_t)(__ccgo_up(lp + uintptr(pshift)*8))) + if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, stepson, (**(**[113]uintptr)(__ccgo_up(bp + 16)))[0], arg) <= 0 { break } if !(trusty != 0) && pshift > int32(1) { rt = head - uintptr(width) - lf = head - uintptr(width) - uintptr(*(*Tsize_t)(unsafe.Pointer(lp + uintptr(pshift-int32(2))*8))) + lf = head - uintptr(width) - uintptr(**(**Tsize_t)(__ccgo_up(lp + uintptr(pshift-int32(2))*8))) if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, rt, stepson, arg) >= 0 || (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, lf, stepson, arg) >= 0 { break } } v1 = i i = i + 1 - (*(*[113]uintptr)(unsafe.Pointer(bp + 16)))[v1] = stepson + (**(**[113]uintptr)(__ccgo_up(bp + 16)))[v1] = stepson head = stepson trail = _pntz(tls, bp) _shr(tls, bp, trail) @@ -144266,7 +144266,7 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm var _ /* p at bp+768 */ [2]Tsize_t _, _, _, _, _, _, _, _ = head, high, i, pshift, size, trail, v2, v3 size = width * nel - *(*[2]Tsize_t)(unsafe.Pointer(bp + 768)) = [2]Tsize_t{ + **(**[2]Tsize_t)(__ccgo_up(bp + 768)) = [2]Tsize_t{ 0: uint64(1), } pshift = int32(1) @@ -144277,12 +144277,12 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm high = head + uintptr(size) - uintptr(width) /* Precompute Leonardo numbers, scaled by element width */ v2 = width - (*(*[96]Tsize_t)(unsafe.Pointer(bp)))[int32(1)] = v2 - (*(*[96]Tsize_t)(unsafe.Pointer(bp)))[0] = v2 + (**(**[96]Tsize_t)(__ccgo_up(bp)))[int32(1)] = v2 + (**(**[96]Tsize_t)(__ccgo_up(bp)))[0] = v2 i = Uint64FromInt32(2) for { - v3 = (*(*[96]Tsize_t)(unsafe.Pointer(bp)))[i-uint64(2)] + (*(*[96]Tsize_t)(unsafe.Pointer(bp)))[i-uint64(1)] + width - (*(*[96]Tsize_t)(unsafe.Pointer(bp)))[i] = v3 + v3 = (**(**[96]Tsize_t)(__ccgo_up(bp)))[i-uint64(2)] + (**(**[96]Tsize_t)(__ccgo_up(bp)))[i-uint64(1)] + width + (**(**[96]Tsize_t)(__ccgo_up(bp)))[i] = v3 if !(v3 < size) { break } @@ -144292,12 +144292,12 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm i = i + 1 } for head < high { - if (*(*[2]Tsize_t)(unsafe.Pointer(bp + 768)))[0]&uint64(3) == uint64(3) { + if (**(**[2]Tsize_t)(__ccgo_up(bp + 768)))[0]&uint64(3) == uint64(3) { _sift(tls, head, width, __ccgo_fp_cmp, arg, pshift, bp) _shr(tls, bp+768, int32(2)) pshift = pshift + int32(2) } else { - if (*(*[96]Tsize_t)(unsafe.Pointer(bp)))[pshift-int32(1)] >= Uint64FromInt64(int64(high)-int64(head)) { + if (**(**[96]Tsize_t)(__ccgo_up(bp)))[pshift-int32(1)] >= Uint64FromInt64(int64(high)-int64(head)) { _trinkle(tls, head, width, __ccgo_fp_cmp, arg, bp+768, pshift, 0, bp) } else { _sift(tls, head, width, __ccgo_fp_cmp, arg, pshift, bp) @@ -144310,11 +144310,11 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm pshift = int32(1) } } - *(*Tsize_t)(unsafe.Pointer(bp + 768)) |= uint64(1) + **(**Tsize_t)(__ccgo_up(bp + 768)) |= uint64(1) head = head + uintptr(width) } _trinkle(tls, head, width, __ccgo_fp_cmp, arg, bp+768, pshift, 0, bp) - for pshift != int32(1) || (*(*[2]Tsize_t)(unsafe.Pointer(bp + 768)))[0] != uint64(1) || (*(*[2]Tsize_t)(unsafe.Pointer(bp + 768)))[int32(1)] != uint64(0) { + for pshift != int32(1) || (**(**[2]Tsize_t)(__ccgo_up(bp + 768)))[0] != uint64(1) || (**(**[2]Tsize_t)(__ccgo_up(bp + 768)))[int32(1)] != uint64(0) { if pshift <= int32(1) { trail = _pntz(tls, bp+768) _shr(tls, bp+768, trail) @@ -144322,11 +144322,11 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm } else { _shl(tls, bp+768, int32(2)) pshift = pshift - int32(2) - *(*Tsize_t)(unsafe.Pointer(bp + 768)) ^= uint64(7) + **(**Tsize_t)(__ccgo_up(bp + 768)) ^= uint64(7) _shr(tls, bp+768, int32(1)) - _trinkle(tls, head-uintptr((*(*[96]Tsize_t)(unsafe.Pointer(bp)))[pshift])-uintptr(width), width, __ccgo_fp_cmp, arg, bp+768, pshift+int32(1), int32(1), bp) + _trinkle(tls, head-uintptr((**(**[96]Tsize_t)(__ccgo_up(bp)))[pshift])-uintptr(width), width, __ccgo_fp_cmp, arg, bp+768, pshift+int32(1), int32(1), bp) _shl(tls, bp+768, int32(1)) - *(*Tsize_t)(unsafe.Pointer(bp + 768)) |= uint64(1) + **(**Tsize_t)(__ccgo_up(bp + 768)) |= uint64(1) _trinkle(tls, head-uintptr(width), width, __ccgo_fp_cmp, arg, bp+768, pshift, int32(1), bp) } head = head - uintptr(width) @@ -144376,7 +144376,7 @@ func _strtox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { } else { v1 = s } - *(*uintptr)(unsafe.Pointer(p)) = v1 + **(**uintptr)(__ccgo_up(p)) = v1 } return y } @@ -144421,7 +144421,7 @@ func _strtox1(tls *TLS, s uintptr, p uintptr, base int32, lim uint64) (r uint64) y = X__intscan(tls, bp, Uint32FromInt32(base), int32(1), lim) if p != 0 { cnt = Uint64FromInt64((*TFILE)(unsafe.Pointer(bp)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(bp)).Frpos) - int64((*TFILE)(unsafe.Pointer(bp)).Fbuf))) - *(*uintptr)(unsafe.Pointer(p)) = s + uintptr(cnt) + **(**uintptr)(__ccgo_up(p)) = s + uintptr(cnt) } return y } @@ -144532,20 +144532,20 @@ func _do_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { var v2 int32 _, _, _, _, _ = i, wcs, v2, v3, v4 wcs = (*TFILE)(unsafe.Pointer(f)).Fcookie - if !(*(*Twchar_t)(unsafe.Pointer(wcs)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(wcs)) != 0) { wcs = __ccgo_ts + 1712 } i = uint64(0) for { - if !(i < (*TFILE)(unsafe.Pointer(f)).Fbuf_size && *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) != 0) { + if !(i < (*TFILE)(unsafe.Pointer(f)).Fbuf_size && **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) != 0) { break } - if *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) < int32(128) { - v2 = *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) + if **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) < int32(128) { + v2 = **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) } else { v2 = int32('@') } - *(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(i))) = Uint8FromInt32(v2) + **(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(i))) = Uint8FromInt32(v2) goto _1 _1: ; @@ -144558,7 +144558,7 @@ func _do_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(buf)) = **(**uint8)(__ccgo_up(v3)) return uint64(1) } return uint64(0) @@ -144574,20 +144574,20 @@ func _wcstox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { var _ /* f at bp+64 */ TFILE _, _, _, _, _ = cnt, t, y, v1, v2 t = s - *(*TFILE)(unsafe.Pointer(bp + 64)) = TFILE{} - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fflags = uint32(0) + **(**TFILE)(__ccgo_up(bp + 64)) = TFILE{} + (**(**TFILE)(__ccgo_up(bp + 64))).Fflags = uint32(0) v2 = bp + UintptrFromInt32(4) - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fbuf = v2 + (**(**TFILE)(__ccgo_up(bp + 64))).Fbuf = v2 v1 = v2 - (*(*TFILE)(unsafe.Pointer(bp + 64))).Frend = v1 - (*(*TFILE)(unsafe.Pointer(bp + 64))).Frpos = v1 - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fbuf_size = Uint64FromInt64(64) - Uint64FromInt32(4) + (**(**TFILE)(__ccgo_up(bp + 64))).Frend = v1 + (**(**TFILE)(__ccgo_up(bp + 64))).Frpos = v1 + (**(**TFILE)(__ccgo_up(bp + 64))).Fbuf_size = Uint64FromInt64(64) - Uint64FromInt32(4) AtomicStorePInt32(bp+64+140, -int32(1)) - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fread = __ccgo_fp(_do_read) - for Xiswspace(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(t)))) != 0 { + (**(**TFILE)(__ccgo_up(bp + 64))).Fread = __ccgo_fp(_do_read) + for Xiswspace(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(t)))) != 0 { t += 4 } - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fcookie = t + (**(**TFILE)(__ccgo_up(bp + 64))).Fcookie = t X__shlim(tls, bp+64, int64(Int32FromInt32(0))) y = X__floatscan(tls, bp+64, prec, int32(1)) if p != 0 { @@ -144597,7 +144597,7 @@ func _wcstox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { } else { v1 = s } - *(*uintptr)(unsafe.Pointer(p)) = v1 + **(**uintptr)(__ccgo_up(p)) = v1 } return y } @@ -144636,20 +144636,20 @@ func _do_read1(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { var v2 int32 _, _, _, _, _ = i, wcs, v2, v3, v4 wcs = (*TFILE)(unsafe.Pointer(f)).Fcookie - if !(*(*Twchar_t)(unsafe.Pointer(wcs)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(wcs)) != 0) { wcs = __ccgo_ts + 1712 } i = uint64(0) for { - if !(i < (*TFILE)(unsafe.Pointer(f)).Fbuf_size && *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) != 0) { + if !(i < (*TFILE)(unsafe.Pointer(f)).Fbuf_size && **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) != 0) { break } - if *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) < int32(128) { - v2 = *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) + if **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) < int32(128) { + v2 = **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) } else { v2 = int32('@') } - *(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(i))) = Uint8FromInt32(v2) + **(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(i))) = Uint8FromInt32(v2) goto _1 _1: ; @@ -144662,7 +144662,7 @@ func _do_read1(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(buf)) = **(**uint8)(__ccgo_up(v3)) return uint64(1) } return uint64(0) @@ -144678,20 +144678,20 @@ func _wcstox1(tls *TLS, s uintptr, p uintptr, base int32, lim uint64) (r uint64) var _ /* f at bp+64 */ TFILE _, _, _, _, _ = cnt, t, y, v1, v2 t = s - *(*TFILE)(unsafe.Pointer(bp + 64)) = TFILE{} - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fflags = uint32(0) + **(**TFILE)(__ccgo_up(bp + 64)) = TFILE{} + (**(**TFILE)(__ccgo_up(bp + 64))).Fflags = uint32(0) v2 = bp + UintptrFromInt32(4) - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fbuf = v2 + (**(**TFILE)(__ccgo_up(bp + 64))).Fbuf = v2 v1 = v2 - (*(*TFILE)(unsafe.Pointer(bp + 64))).Frend = v1 - (*(*TFILE)(unsafe.Pointer(bp + 64))).Frpos = v1 - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fbuf_size = Uint64FromInt64(64) - Uint64FromInt32(4) + (**(**TFILE)(__ccgo_up(bp + 64))).Frend = v1 + (**(**TFILE)(__ccgo_up(bp + 64))).Frpos = v1 + (**(**TFILE)(__ccgo_up(bp + 64))).Fbuf_size = Uint64FromInt64(64) - Uint64FromInt32(4) AtomicStorePInt32(bp+64+140, -int32(1)) - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fread = __ccgo_fp(_do_read1) - for Xiswspace(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(t)))) != 0 { + (**(**TFILE)(__ccgo_up(bp + 64))).Fread = __ccgo_fp(_do_read1) + for Xiswspace(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(t)))) != 0 { t += 4 } - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fcookie = t + (**(**TFILE)(__ccgo_up(bp + 64))).Fcookie = t X__shlim(tls, bp+64, int64(Int32FromInt32(0))) y = X__intscan(tls, bp+64, Uint32FromInt32(base), int32(1), lim) if p != 0 { @@ -144701,7 +144701,7 @@ func _wcstox1(tls *TLS, s uintptr, p uintptr, base int32, lim uint64) (r uint64) } else { v1 = s } - *(*uintptr)(unsafe.Pointer(p)) = v1 + **(**uintptr)(__ccgo_up(p)) = v1 } return y } @@ -144820,8 +144820,8 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt if uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) == uint64(d)&(Uint64FromInt64(8)-Uint64FromInt32(1)) { for { if v3 = uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) != 0 && n != 0; v3 { - v2 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v2 + v2 = **(**uint8)(__ccgo_up(s)) + **(**uint8)(__ccgo_up(d)) = v2 } if !(v3 && Int32FromUint8(v2) != c) { break @@ -144840,10 +144840,10 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt wd = d ws = s for { - if !(n >= uint64(8) && !((*(*uint64)(unsafe.Pointer(ws))^k-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^(*(*uint64)(unsafe.Pointer(ws))^k) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { + if !(n >= uint64(8) && !((**(**uint64)(__ccgo_up(ws))^k-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^(**(**uint64)(__ccgo_up(ws))^k) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { break } - *(*uint64)(unsafe.Pointer(wd)) = *(*uint64)(unsafe.Pointer(ws)) + **(**uint64)(__ccgo_up(wd)) = **(**uint64)(__ccgo_up(ws)) goto _4 _4: ; @@ -144856,8 +144856,8 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt } for { if v3 = n != 0; v3 { - v2 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v2 + v2 = **(**uint8)(__ccgo_up(s)) + **(**uint8)(__ccgo_up(d)) = v2 } if !(v3 && Int32FromUint8(v2) != c) { break @@ -144900,7 +144900,7 @@ func Xmemchr(tls *TLS, src uintptr, c int32, n Tsize_t) (r uintptr) { s = src c = Int32FromUint8(Uint8FromInt32(c)) for { - if !(uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) != 0 && n != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != c) { + if !(uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) != 0 && n != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != c) { break } goto _1 @@ -144909,11 +144909,11 @@ func Xmemchr(tls *TLS, src uintptr, c int32, n Tsize_t) (r uintptr) { s = s + 1 n = n - 1 } - if n != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != c { + if n != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != c { k = Uint64FromInt32(-Int32FromInt32(1)) / Uint64FromInt32(UCHAR_MAX) * Uint64FromInt32(c) w = s for { - if !(n >= Uint64FromInt64(8) && !((*(*uint64)(unsafe.Pointer(w))^k-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^(*(*uint64)(unsafe.Pointer(w))^k) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { + if !(n >= Uint64FromInt64(8) && !((**(**uint64)(__ccgo_up(w))^k-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^(**(**uint64)(__ccgo_up(w))^k) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { break } goto _2 @@ -144925,7 +144925,7 @@ func Xmemchr(tls *TLS, src uintptr, c int32, n Tsize_t) (r uintptr) { s = w } for { - if !(n != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != c) { + if !(n != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != c) { break } goto _3 @@ -144953,7 +144953,7 @@ func Xmemcmp(tls *TLS, vl uintptr, vr uintptr, n Tsize_t) (r1 int32) { l = vl r = vr for { - if !(n != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))) { + if !(n != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(l))) == Int32FromUint8(**(**uint8)(__ccgo_up(r)))) { break } goto _1 @@ -144964,7 +144964,7 @@ func Xmemcmp(tls *TLS, vl uintptr, vr uintptr, n Tsize_t) (r1 int32) { r = r + 1 } if n != 0 { - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(l))) - Int32FromUint8(**(**uint8)(__ccgo_up(r))) } else { v2 = 0 } @@ -144992,7 +144992,7 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) goto _1 _1: ; @@ -145003,10 +145003,10 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { if !(n >= uint64(16)) { break } - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(0))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(4))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(4))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(8))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(8))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(12))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(12))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(0))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(0))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(4))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(4))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(8))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(8))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(12))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(12))) goto _4 _4: ; @@ -145015,13 +145015,13 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { n = n - uint64(16) } if n&uint64(8) != 0 { - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(0))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(4))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(4))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(0))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(0))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(4))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(4))) d = d + uintptr(8) s = s + uintptr(8) } if n&uint64(4) != 0 { - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(0))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(0))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(0))) d = d + uintptr(4) s = s + uintptr(4) } @@ -145030,50 +145030,50 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) } if n&uint64(1) != 0 { - *(*uint8)(unsafe.Pointer(d)) = *(*uint8)(unsafe.Pointer(s)) + **(**uint8)(__ccgo_up(d)) = **(**uint8)(__ccgo_up(s)) } return dest } if n >= uint64(32) { switch uint64(d) % Uint64FromInt32(4) { case uint64(1): - w = *(*uint32)(unsafe.Pointer(s)) + w = **(**uint32)(__ccgo_up(s)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) n = n - uint64(3) for { if !(n >= uint64(17)) { break } - x = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(1))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = w>>Int32FromInt32(24) | x<>Int32FromInt32(24) | w<>Int32FromInt32(24) | x<>Int32FromInt32(24) | w<>Int32FromInt32(24) | x<>Int32FromInt32(24) | w<>Int32FromInt32(24) | x<>Int32FromInt32(24) | w<= uint64(18)) { break } - x = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(2))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = w>>Int32FromInt32(16) | x<>Int32FromInt32(16) | w<>Int32FromInt32(16) | x<>Int32FromInt32(16) | w<>Int32FromInt32(16) | x<>Int32FromInt32(16) | w<>Int32FromInt32(16) | x<>Int32FromInt32(16) | w<= uint64(19)) { break } - x = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(3))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = w>>Int32FromInt32(8) | x<>Int32FromInt32(8) | w<>Int32FromInt32(8) | x<>Int32FromInt32(8) | w<>Int32FromInt32(8) | x<>Int32FromInt32(8) | w<>Int32FromInt32(8) | x<>Int32FromInt32(8) | w< Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(ip+k)))) > Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(jp+k)))) { jp = jp + k k = uint64(1) p = jp - ip @@ -145475,7 +145475,7 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin p = v2 k = v2 for jp+k < l { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(ip+k)))) == Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(jp+k)))) { if k == p { jp = jp + p k = uint64(1) @@ -145483,7 +145483,7 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin k = k + 1 } } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) < Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(ip+k)))) < Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(jp+k)))) { jp = jp + k k = uint64(1) p = jp - ip @@ -145522,8 +145522,8 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin return uintptr(0) } /* Check last byte first; advance by shift on mismatch */ - if (*(*[4]Tsize_t)(unsafe.Pointer(bp)))[uint64(*(*uint8)(unsafe.Pointer(h + uintptr(l-uint64(1)))))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(*(*uint8)(unsafe.Pointer(h + uintptr(l-uint64(1)))))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0 { - k = l - shift[*(*uint8)(unsafe.Pointer(h + uintptr(l-uint64(1))))] + if (**(**[4]Tsize_t)(__ccgo_up(bp)))[uint64(**(**uint8)(__ccgo_up(h + uintptr(l-uint64(1)))))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(**(**uint8)(__ccgo_up(h + uintptr(l-uint64(1)))))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0 { + k = l - shift[**(**uint8)(__ccgo_up(h + uintptr(l-uint64(1))))] if k != 0 { if k < mem { k = mem @@ -145545,7 +145545,7 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin } k = v8 for { - if !(k < l && Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(h + uintptr(k))))) { + if !(k < l && Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(k)))) == Int32FromUint8(**(**uint8)(__ccgo_up(h + uintptr(k))))) { break } goto _10 @@ -145561,7 +145561,7 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin /* Compare left half */ k = ms + uint64(1) for { - if !(k > mem && Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(k-uint64(1))))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(h + uintptr(k-uint64(1)))))) { + if !(k > mem && Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(k-uint64(1))))) == Int32FromUint8(**(**uint8)(__ccgo_up(h + uintptr(k-uint64(1)))))) { break } goto _12 @@ -145598,7 +145598,7 @@ func Xmemmem(tls *TLS, h0 uintptr, k Tsize_t, n0 uintptr, l Tsize_t) (r uintptr) return uintptr(0) } /* Use faster algorithms for short needles */ - h = Xmemchr(tls, h0, Int32FromUint8(*(*uint8)(unsafe.Pointer(n))), k) + h = Xmemchr(tls, h0, Int32FromUint8(**(**uint8)(__ccgo_up(n))), k) if !(h != 0) || l == uint64(1) { return h } @@ -145650,13 +145650,13 @@ func Xmemmove(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { d = d + 1 v3 = s s = s + 1 - *(*int8)(unsafe.Pointer(v2)) = *(*int8)(unsafe.Pointer(v3)) + **(**int8)(__ccgo_up(v2)) = **(**int8)(__ccgo_up(v3)) } for { if !(n >= Uint64FromInt64(8)) { break } - *(*TWT)(unsafe.Pointer(d)) = *(*TWT)(unsafe.Pointer(s)) + **(**TWT)(__ccgo_up(d)) = **(**TWT)(__ccgo_up(s)) goto _4 _4: ; @@ -145673,7 +145673,7 @@ func Xmemmove(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { d = d + 1 v3 = s s = s + 1 - *(*int8)(unsafe.Pointer(v2)) = *(*int8)(unsafe.Pointer(v3)) + **(**int8)(__ccgo_up(v2)) = **(**int8)(__ccgo_up(v3)) goto _5 _5: ; @@ -145687,16 +145687,16 @@ func Xmemmove(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { if !(v1 != 0) { return dest } - *(*int8)(unsafe.Pointer(d + uintptr(n))) = *(*int8)(unsafe.Pointer(s + uintptr(n))) + **(**int8)(__ccgo_up(d + uintptr(n))) = **(**int8)(__ccgo_up(s + uintptr(n))) } for n >= Uint64FromInt64(8) { n = n - Uint64FromInt64(8) - *(*TWT)(unsafe.Pointer(d + uintptr(n))) = *(*TWT)(unsafe.Pointer(s + uintptr(n))) + **(**TWT)(__ccgo_up(d + uintptr(n))) = **(**TWT)(__ccgo_up(s + uintptr(n))) } } for n != 0 { n = n - 1 - *(*int8)(unsafe.Pointer(d + uintptr(n))) = *(*int8)(unsafe.Pointer(s + uintptr(n))) + **(**int8)(__ccgo_up(d + uintptr(n))) = **(**int8)(__ccgo_up(s + uintptr(n))) } } return dest @@ -145726,7 +145726,7 @@ func X__memrchr(tls *TLS, m uintptr, c int32, n Tsize_t) (r uintptr) { if !(v1 != 0) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(n)))) == c { + if Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(n)))) == c { return s + uintptr(n) } } @@ -145758,20 +145758,20 @@ func Xmemset(tls *TLS, dest uintptr, c int32, n Tsize_t) (r uintptr) { if !(n != 0) { return dest } - *(*uint8)(unsafe.Pointer(s)) = Uint8FromInt32(c) - *(*uint8)(unsafe.Pointer(s + uintptr(n-uint64(1)))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s)) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + uintptr(n-uint64(1)))) = Uint8FromInt32(c) if n <= uint64(2) { return dest } - *(*uint8)(unsafe.Pointer(s + 1)) = Uint8FromInt32(c) - *(*uint8)(unsafe.Pointer(s + 2)) = Uint8FromInt32(c) - *(*uint8)(unsafe.Pointer(s + uintptr(n-uint64(2)))) = Uint8FromInt32(c) - *(*uint8)(unsafe.Pointer(s + uintptr(n-uint64(3)))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + 1)) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + 2)) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + uintptr(n-uint64(2)))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + uintptr(n-uint64(3)))) = Uint8FromInt32(c) if n <= uint64(6) { return dest } - *(*uint8)(unsafe.Pointer(s + 3)) = Uint8FromInt32(c) - *(*uint8)(unsafe.Pointer(s + uintptr(n-uint64(4)))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + 3)) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + uintptr(n-uint64(4)))) = Uint8FromInt32(c) if n <= uint64(8) { return dest } @@ -145789,26 +145789,26 @@ func Xmemset(tls *TLS, dest uintptr, c int32, n Tsize_t) (r uintptr) { * As in the initial byte-based head/tail fill, each * conditional below ensures that the subsequent offsets * are valid (e.g. !(n<=24) implies n>=28). */ - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(0))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(4))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(0))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(4))) = c32 if n <= uint64(8) { return dest } - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(4))) = c32 - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(8))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(12))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(8))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(4))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(8))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(12))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(8))) = c32 if n <= uint64(24) { return dest } - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(12))) = c32 - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(16))) = c32 - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(20))) = c32 - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(24))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(28))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(24))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(20))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(16))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(12))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(16))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(20))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(24))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(28))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(24))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(20))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(16))) = c32 /* Align to a multiple of 8 so we can fill 64 bits at a time, * and avoid writing the same bytes twice as much as is * practical without introducing additional branching. */ @@ -145823,10 +145823,10 @@ func Xmemset(tls *TLS, dest uintptr, c int32, n Tsize_t) (r uintptr) { if !(n >= uint64(32)) { break } - *(*uint64)(unsafe.Pointer(s + UintptrFromInt32(0))) = c64 - *(*uint64)(unsafe.Pointer(s + UintptrFromInt32(8))) = c64 - *(*uint64)(unsafe.Pointer(s + UintptrFromInt32(16))) = c64 - *(*uint64)(unsafe.Pointer(s + UintptrFromInt32(24))) = c64 + **(**uint64)(__ccgo_up(s + UintptrFromInt32(0))) = c64 + **(**uint64)(__ccgo_up(s + UintptrFromInt32(8))) = c64 + **(**uint64)(__ccgo_up(s + UintptrFromInt32(16))) = c64 + **(**uint64)(__ccgo_up(s + UintptrFromInt32(24))) = c64 goto _1 _1: ; @@ -145868,8 +145868,8 @@ func X__stpcpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { if !(uint64(s)%Uint64FromInt64(8) != 0) { break } - v2 = *(*int8)(unsafe.Pointer(s)) - *(*int8)(unsafe.Pointer(d)) = v2 + v2 = **(**int8)(__ccgo_up(s)) + **(**int8)(__ccgo_up(d)) = v2 if !(v2 != 0) { return d } @@ -145882,7 +145882,7 @@ func X__stpcpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { wd = d ws = s for { - if !!((*(*uint64)(unsafe.Pointer(ws))-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^*(*uint64)(unsafe.Pointer(ws)) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0) { + if !!((**(**uint64)(__ccgo_up(ws))-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^**(**uint64)(__ccgo_up(ws)) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0) { break } goto _3 @@ -145892,14 +145892,14 @@ func X__stpcpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { wd += 8 v5 = ws ws += 8 - *(*uint64)(unsafe.Pointer(v4)) = *(*uint64)(unsafe.Pointer(v5)) + **(**uint64)(__ccgo_up(v4)) = **(**uint64)(__ccgo_up(v5)) } d = wd s = ws } for { - v2 = *(*int8)(unsafe.Pointer(s)) - *(*int8)(unsafe.Pointer(d)) = v2 + v2 = **(**int8)(__ccgo_up(s)) + **(**int8)(__ccgo_up(d)) = v2 if !(v2 != 0) { break } @@ -145952,8 +145952,8 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { if uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) == uint64(d)&(Uint64FromInt64(8)-Uint64FromInt32(1)) { for { if v3 = uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) != 0 && n != 0; v3 { - v2 = *(*int8)(unsafe.Pointer(s)) - *(*int8)(unsafe.Pointer(d)) = v2 + v2 = **(**int8)(__ccgo_up(s)) + **(**int8)(__ccgo_up(d)) = v2 } if !(v3 && v2 != 0) { break @@ -145965,16 +145965,16 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { s = s + 1 d = d + 1 } - if !(n != 0) || !(*(*int8)(unsafe.Pointer(s)) != 0) { + if !(n != 0) || !(**(**int8)(__ccgo_up(s)) != 0) { goto tail } wd = d ws = s for { - if !(n >= uint64(8) && !((*(*uint64)(unsafe.Pointer(ws))-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^*(*uint64)(unsafe.Pointer(ws)) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { + if !(n >= uint64(8) && !((**(**uint64)(__ccgo_up(ws))-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^**(**uint64)(__ccgo_up(ws)) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { break } - *(*uint64)(unsafe.Pointer(wd)) = *(*uint64)(unsafe.Pointer(ws)) + **(**uint64)(__ccgo_up(wd)) = **(**uint64)(__ccgo_up(ws)) goto _4 _4: ; @@ -145987,8 +145987,8 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { } for { if v3 = n != 0; v3 { - v2 = *(*int8)(unsafe.Pointer(s)) - *(*int8)(unsafe.Pointer(d)) = v2 + v2 = **(**int8)(__ccgo_up(s)) + **(**int8)(__ccgo_up(d)) = v2 } if !(v3 && v2 != 0) { break @@ -146034,7 +146034,7 @@ func Xstrcasecmp(tls *TLS, _l uintptr, _r uintptr) (r1 int32) { l = _l r = _r for { - if !(*(*uint8)(unsafe.Pointer(l)) != 0 && *(*uint8)(unsafe.Pointer(r)) != 0 && (Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) || Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(l)))) == Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))))) { + if !(**(**uint8)(__ccgo_up(l)) != 0 && **(**uint8)(__ccgo_up(r)) != 0 && (Int32FromUint8(**(**uint8)(__ccgo_up(l))) == Int32FromUint8(**(**uint8)(__ccgo_up(r))) || Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(l)))) == Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(r)))))) { break } goto _1 @@ -146043,7 +146043,7 @@ func Xstrcasecmp(tls *TLS, _l uintptr, _r uintptr) (r1 int32) { l = l + 1 r = r + 1 } - return Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(l)))) - Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))) + return Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(l)))) - Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(r)))) } func X__strcasecmp_l(tls *TLS, l uintptr, r uintptr, loc Tlocale_t) (r1 int32) { @@ -146071,7 +146071,7 @@ func Xstrcasestr(tls *TLS, h uintptr, n uintptr) (r uintptr) { _ = l l = _strlen(tls, n) for { - if !(*(*int8)(unsafe.Pointer(h)) != 0) { + if !(**(**int8)(__ccgo_up(h)) != 0) { break } if !(Xstrncasecmp(tls, h, n, l) != 0) { @@ -146102,7 +146102,7 @@ func Xstrchr(tls *TLS, s uintptr, c int32) (r1 uintptr) { var r, v1 uintptr _, _ = r, v1 r = X__strchrnul(tls, s, c) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) == Int32FromUint8(Uint8FromInt32(c)) { + if Int32FromUint8(**(**uint8)(__ccgo_up(r))) == Int32FromUint8(Uint8FromInt32(c)) { v1 = r } else { v1 = uintptr(0) @@ -146137,7 +146137,7 @@ func X__strchrnul(tls *TLS, s uintptr, c int32) (r uintptr) { if !(uint64(s)%Uint64FromInt64(8) != 0) { break } - if !(*(*int8)(unsafe.Pointer(s)) != 0) || Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == c { + if !(**(**int8)(__ccgo_up(s)) != 0) || Int32FromUint8(**(**uint8)(__ccgo_up(s))) == c { return s } goto _1 @@ -146148,7 +146148,7 @@ func X__strchrnul(tls *TLS, s uintptr, c int32) (r uintptr) { k = Uint64FromInt32(-Int32FromInt32(1)) / Uint64FromInt32(UCHAR_MAX) * Uint64FromInt32(c) w = s for { - if !(!((*(*uint64)(unsafe.Pointer(w))-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^*(*uint64)(unsafe.Pointer(w)) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0) && !((*(*uint64)(unsafe.Pointer(w))^k-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^(*(*uint64)(unsafe.Pointer(w))^k) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { + if !(!((**(**uint64)(__ccgo_up(w))-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^**(**uint64)(__ccgo_up(w)) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0) && !((**(**uint64)(__ccgo_up(w))^k-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^(**(**uint64)(__ccgo_up(w))^k) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { break } goto _2 @@ -146158,7 +146158,7 @@ func X__strchrnul(tls *TLS, s uintptr, c int32) (r uintptr) { } s = w for { - if !(*(*int8)(unsafe.Pointer(s)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != c) { + if !(**(**int8)(__ccgo_up(s)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != c) { break } goto _3 @@ -146192,7 +146192,7 @@ func Xstrcmp(tls *TLS, l uintptr, r uintptr) (r1 int32) { defer func() { trc("-> %v", r1) }() } for { - if !(int32(*(*int8)(unsafe.Pointer(l))) == int32(*(*int8)(unsafe.Pointer(r))) && *(*int8)(unsafe.Pointer(l)) != 0) { + if !(int32(**(**int8)(__ccgo_up(l))) == int32(**(**int8)(__ccgo_up(r))) && **(**int8)(__ccgo_up(l)) != 0) { break } goto _1 @@ -146201,7 +146201,7 @@ func Xstrcmp(tls *TLS, l uintptr, r uintptr) (r1 int32) { l = l + 1 r = r + 1 } - return Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) + return Int32FromUint8(**(**uint8)(__ccgo_up(l))) - Int32FromUint8(**(**uint8)(__ccgo_up(r))) } func Xstrcpy(tls *TLS, dest uintptr, src uintptr) (r uintptr) { @@ -146225,14 +146225,14 @@ func Xstrcspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { var _ /* byteset at bp+0 */ [4]Tsize_t _, _, _ = a, v2, v3 a = s - if !(*(*int8)(unsafe.Pointer(c)) != 0) || !(*(*int8)(unsafe.Pointer(c + 1)) != 0) { - return Uint64FromInt64(int64(X__strchrnul(tls, s, int32(*(*int8)(unsafe.Pointer(c))))) - int64(a)) + if !(**(**int8)(__ccgo_up(c)) != 0) || !(**(**int8)(__ccgo_up(c + 1)) != 0) { + return Uint64FromInt64(int64(X__strchrnul(tls, s, int32(**(**int8)(__ccgo_up(c))))) - int64(a)) } Xmemset(tls, bp, 0, uint64(32)) for { - if v3 = *(*int8)(unsafe.Pointer(c)) != 0; v3 { - v2 = bp + uintptr(uint64(*(*uint8)(unsafe.Pointer(c)))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 - *(*Tsize_t)(unsafe.Pointer(v2)) |= Uint64FromInt32(1) << (uint64(*(*uint8)(unsafe.Pointer(c))) % (Uint64FromInt32(8) * Uint64FromInt64(8))) + if v3 = **(**int8)(__ccgo_up(c)) != 0; v3 { + v2 = bp + uintptr(uint64(**(**uint8)(__ccgo_up(c)))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 + *(*Tsize_t)(unsafe.Pointer(v2)) |= Uint64FromInt32(1) << (uint64(**(**uint8)(__ccgo_up(c))) % (Uint64FromInt32(8) * Uint64FromInt64(8))) } if !(v3 && *(*Tsize_t)(unsafe.Pointer(v2)) != 0) { break @@ -146243,7 +146243,7 @@ func Xstrcspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { c = c + 1 } for { - if !(*(*int8)(unsafe.Pointer(s)) != 0 && !((*(*[4]Tsize_t)(unsafe.Pointer(bp)))[uint64(*(*uint8)(unsafe.Pointer(s)))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(*(*uint8)(unsafe.Pointer(s)))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0)) { + if !(**(**int8)(__ccgo_up(s)) != 0 && !((**(**[4]Tsize_t)(__ccgo_up(bp)))[uint64(**(**uint8)(__ccgo_up(s)))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(**(**uint8)(__ccgo_up(s)))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0)) { break } goto _4 @@ -146283,7 +146283,7 @@ func Xstrerror_r(tls *TLS, err int32, buf uintptr, buflen Tsize_t) (r int32) { if l >= buflen { if buflen != 0 { Xmemcpy(tls, buf, msg, buflen-uint64(1)) - *(*int8)(unsafe.Pointer(buf + uintptr(buflen-uint64(1)))) = 0 + **(**int8)(__ccgo_up(buf + uintptr(buflen-uint64(1)))) = 0 } return int32(ERANGE) } @@ -146343,8 +146343,8 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { if uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) == uint64(d)&(Uint64FromInt64(8)-Uint64FromInt32(1)) { for { if v4 = uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) != 0 && n != 0; v4 { - v3 = *(*int8)(unsafe.Pointer(s)) - *(*int8)(unsafe.Pointer(d)) = v3 + v3 = **(**int8)(__ccgo_up(s)) + **(**int8)(__ccgo_up(d)) = v3 } if !(v4 && v3 != 0) { break @@ -146356,14 +146356,14 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { s = s + 1 d = d + 1 } - if n != 0 && *(*int8)(unsafe.Pointer(s)) != 0 { + if n != 0 && **(**int8)(__ccgo_up(s)) != 0 { wd = d ws = s for { - if !(n >= uint64(8) && !((*(*uint64)(unsafe.Pointer(ws))-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^*(*uint64)(unsafe.Pointer(ws)) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { + if !(n >= uint64(8) && !((**(**uint64)(__ccgo_up(ws))-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^**(**uint64)(__ccgo_up(ws)) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { break } - *(*Tsize_t)(unsafe.Pointer(wd)) = *(*uint64)(unsafe.Pointer(ws)) + **(**Tsize_t)(__ccgo_up(wd)) = **(**uint64)(__ccgo_up(ws)) goto _5 _5: ; @@ -146377,8 +146377,8 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { } for { if v4 = n != 0; v4 { - v3 = *(*int8)(unsafe.Pointer(s)) - *(*int8)(unsafe.Pointer(d)) = v3 + v3 = **(**int8)(__ccgo_up(s)) + **(**int8)(__ccgo_up(d)) = v3 } if !(v4 && v3 != 0) { break @@ -146390,7 +146390,7 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { s = s + 1 d = d + 1 } - *(*int8)(unsafe.Pointer(d)) = 0 + **(**int8)(__ccgo_up(d)) = 0 goto finish finish: ; @@ -146416,7 +146416,7 @@ func Xstrncasecmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { return 0 } for { - if !(*(*uint8)(unsafe.Pointer(l)) != 0 && *(*uint8)(unsafe.Pointer(r)) != 0 && n != 0 && (Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) || Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(l)))) == Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))))) { + if !(**(**uint8)(__ccgo_up(l)) != 0 && **(**uint8)(__ccgo_up(r)) != 0 && n != 0 && (Int32FromUint8(**(**uint8)(__ccgo_up(l))) == Int32FromUint8(**(**uint8)(__ccgo_up(r))) || Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(l)))) == Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(r)))))) { break } goto _2 @@ -146426,7 +146426,7 @@ func Xstrncasecmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { r = r + 1 n = n - 1 } - return Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(l)))) - Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))) + return Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(l)))) - Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(r)))) } func X__strncasecmp_l(tls *TLS, l uintptr, r uintptr, n Tsize_t, loc Tlocale_t) (r1 int32) { @@ -146454,17 +146454,17 @@ func Xstrncat(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { _, _, _ = a, v1, v2 a = d d = d + uintptr(_strlen(tls, d)) - for n != 0 && *(*int8)(unsafe.Pointer(s)) != 0 { + for n != 0 && **(**int8)(__ccgo_up(s)) != 0 { n = n - 1 v1 = d d = d + 1 v2 = s s = s + 1 - *(*int8)(unsafe.Pointer(v1)) = *(*int8)(unsafe.Pointer(v2)) + **(**int8)(__ccgo_up(v1)) = **(**int8)(__ccgo_up(v2)) } v1 = d d = d + 1 - *(*int8)(unsafe.Pointer(v1)) = 0 + **(**int8)(__ccgo_up(v1)) = 0 return a } @@ -146484,7 +146484,7 @@ func Xstrncmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { return 0 } for { - if !(*(*uint8)(unsafe.Pointer(l)) != 0 && *(*uint8)(unsafe.Pointer(r)) != 0 && n != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))) { + if !(**(**uint8)(__ccgo_up(l)) != 0 && **(**uint8)(__ccgo_up(r)) != 0 && n != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(l))) == Int32FromUint8(**(**uint8)(__ccgo_up(r)))) { break } goto _2 @@ -146494,7 +146494,7 @@ func Xstrncmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { r = r + 1 n = n - 1 } - return Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) + return Int32FromUint8(**(**uint8)(__ccgo_up(l))) - Int32FromUint8(**(**uint8)(__ccgo_up(r))) } func Xstrncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { @@ -146520,7 +146520,7 @@ func Xstrndup(tls *TLS, s uintptr, n Tsize_t) (r uintptr) { return UintptrFromInt32(0) } Xmemcpy(tls, d, s, l) - *(*int8)(unsafe.Pointer(d + uintptr(l))) = 0 + **(**int8)(__ccgo_up(d + uintptr(l))) = 0 return d } @@ -146549,7 +146549,7 @@ func Xstrpbrk(tls *TLS, s uintptr, b uintptr) (r uintptr) { var v1 uintptr _ = v1 s = s + uintptr(Xstrcspn(tls, s, b)) - if *(*int8)(unsafe.Pointer(s)) != 0 { + if **(**int8)(__ccgo_up(s)) != 0 { v1 = s } else { v1 = uintptr(0) @@ -146572,19 +146572,19 @@ func Xstrsep(tls *TLS, str uintptr, sep uintptr) (r uintptr) { } var end, s, v1 uintptr _, _, _ = end, s, v1 - s = *(*uintptr)(unsafe.Pointer(str)) + s = **(**uintptr)(__ccgo_up(str)) if !(s != 0) { return UintptrFromInt32(0) } end = s + uintptr(Xstrcspn(tls, s, sep)) - if *(*int8)(unsafe.Pointer(end)) != 0 { + if **(**int8)(__ccgo_up(end)) != 0 { v1 = end end = end + 1 - *(*int8)(unsafe.Pointer(v1)) = 0 + **(**int8)(__ccgo_up(v1)) = 0 } else { end = uintptr(0) } - *(*uintptr)(unsafe.Pointer(str)) = end + **(**uintptr)(__ccgo_up(str)) = end return s } @@ -146610,7 +146610,7 @@ func Xstrsignal(tls *TLS, signum int32) (r uintptr) { break } for { - if !(*(*int8)(unsafe.Pointer(s)) != 0) { + if !(**(**int8)(__ccgo_up(s)) != 0) { break } goto _3 @@ -146638,13 +146638,13 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { var _ /* byteset at bp+0 */ [4]Tsize_t _, _, _ = a, v3, v4 a = s - *(*[4]Tsize_t)(unsafe.Pointer(bp)) = [4]Tsize_t{} - if !(*(*int8)(unsafe.Pointer(c)) != 0) { + **(**[4]Tsize_t)(__ccgo_up(bp)) = [4]Tsize_t{} + if !(**(**int8)(__ccgo_up(c)) != 0) { return uint64(0) } - if !(*(*int8)(unsafe.Pointer(c + 1)) != 0) { + if !(**(**int8)(__ccgo_up(c + 1)) != 0) { for { - if !(int32(*(*int8)(unsafe.Pointer(s))) == int32(*(*int8)(unsafe.Pointer(c)))) { + if !(int32(**(**int8)(__ccgo_up(s))) == int32(**(**int8)(__ccgo_up(c)))) { break } goto _1 @@ -146655,9 +146655,9 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { return Uint64FromInt64(int64(s) - int64(a)) } for { - if v4 = *(*int8)(unsafe.Pointer(c)) != 0; v4 { - v3 = bp + uintptr(uint64(*(*uint8)(unsafe.Pointer(c)))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 - *(*Tsize_t)(unsafe.Pointer(v3)) |= Uint64FromInt32(1) << (uint64(*(*uint8)(unsafe.Pointer(c))) % (Uint64FromInt32(8) * Uint64FromInt64(8))) + if v4 = **(**int8)(__ccgo_up(c)) != 0; v4 { + v3 = bp + uintptr(uint64(**(**uint8)(__ccgo_up(c)))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 + *(*Tsize_t)(unsafe.Pointer(v3)) |= Uint64FromInt32(1) << (uint64(**(**uint8)(__ccgo_up(c))) % (Uint64FromInt32(8) * Uint64FromInt64(8))) } if !(v4 && *(*Tsize_t)(unsafe.Pointer(v3)) != 0) { break @@ -146668,7 +146668,7 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { c = c + 1 } for { - if !(*(*int8)(unsafe.Pointer(s)) != 0 && (*(*[4]Tsize_t)(unsafe.Pointer(bp)))[uint64(*(*uint8)(unsafe.Pointer(s)))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(*(*uint8)(unsafe.Pointer(s)))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0) { + if !(**(**int8)(__ccgo_up(s)) != 0 && (**(**[4]Tsize_t)(__ccgo_up(bp)))[uint64(**(**uint8)(__ccgo_up(s)))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(**(**uint8)(__ccgo_up(s)))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0) { break } goto _5 @@ -146683,11 +146683,11 @@ func _twobyte_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { var hw, nw Tuint16_t var v2 uintptr _, _, _ = hw, nw, v2 - nw = Uint16FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(n)))< Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(ip+k)))) > Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(jp+k)))) { jp = jp + k k = uint64(1) p = jp - ip @@ -146821,7 +146821,7 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { p = v2 k = v2 for jp+k < l { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(ip+k)))) == Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(jp+k)))) { if k == p { jp = jp + p k = uint64(1) @@ -146829,7 +146829,7 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { k = k + 1 } } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) < Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(ip+k)))) < Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(jp+k)))) { jp = jp + k k = uint64(1) p = jp - ip @@ -146880,8 +146880,8 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { } } /* Check last byte first; advance by shift on mismatch */ - if (*(*[4]Tsize_t)(unsafe.Pointer(bp)))[uint64(*(*uint8)(unsafe.Pointer(h + uintptr(l-uint64(1)))))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(*(*uint8)(unsafe.Pointer(h + uintptr(l-uint64(1)))))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0 { - k = l - shift[*(*uint8)(unsafe.Pointer(h + uintptr(l-uint64(1))))] + if (**(**[4]Tsize_t)(__ccgo_up(bp)))[uint64(**(**uint8)(__ccgo_up(h + uintptr(l-uint64(1)))))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(**(**uint8)(__ccgo_up(h + uintptr(l-uint64(1)))))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0 { + k = l - shift[**(**uint8)(__ccgo_up(h + uintptr(l-uint64(1))))] if k != 0 { if k < mem { k = mem @@ -146903,7 +146903,7 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { } k = v8 for { - if !(*(*uint8)(unsafe.Pointer(n + uintptr(k))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(h + uintptr(k))))) { + if !(**(**uint8)(__ccgo_up(n + uintptr(k))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(k)))) == Int32FromUint8(**(**uint8)(__ccgo_up(h + uintptr(k))))) { break } goto _10 @@ -146911,7 +146911,7 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { ; k = k + 1 } - if *(*uint8)(unsafe.Pointer(n + uintptr(k))) != 0 { + if **(**uint8)(__ccgo_up(n + uintptr(k))) != 0 { h = h + uintptr(k-ms) mem = uint64(0) goto _9 @@ -146919,7 +146919,7 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { /* Compare left half */ k = ms + uint64(1) for { - if !(k > mem && Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(k-uint64(1))))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(h + uintptr(k-uint64(1)))))) { + if !(k > mem && Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(k-uint64(1))))) == Int32FromUint8(**(**uint8)(__ccgo_up(h + uintptr(k-uint64(1)))))) { break } goto _12 @@ -146944,30 +146944,30 @@ func Xstrstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { defer func() { trc("-> %v", r) }() } /* Return immediately on empty needle */ - if !(*(*int8)(unsafe.Pointer(n)) != 0) { + if !(**(**int8)(__ccgo_up(n)) != 0) { return h } /* Use faster algorithms for short needles */ - h = Xstrchr(tls, h, int32(*(*int8)(unsafe.Pointer(n)))) - if !(h != 0) || !(*(*int8)(unsafe.Pointer(n + 1)) != 0) { + h = Xstrchr(tls, h, int32(**(**int8)(__ccgo_up(n)))) + if !(h != 0) || !(**(**int8)(__ccgo_up(n + 1)) != 0) { return h } - if !(*(*int8)(unsafe.Pointer(h + 1)) != 0) { + if !(**(**int8)(__ccgo_up(h + 1)) != 0) { return uintptr(0) } - if !(*(*int8)(unsafe.Pointer(n + 2)) != 0) { + if !(**(**int8)(__ccgo_up(n + 2)) != 0) { return _twobyte_strstr(tls, h, n) } - if !(*(*int8)(unsafe.Pointer(h + 2)) != 0) { + if !(**(**int8)(__ccgo_up(h + 2)) != 0) { return uintptr(0) } - if !(*(*int8)(unsafe.Pointer(n + 3)) != 0) { + if !(**(**int8)(__ccgo_up(n + 3)) != 0) { return _threebyte_strstr(tls, h, n) } - if !(*(*int8)(unsafe.Pointer(h + 3)) != 0) { + if !(**(**int8)(__ccgo_up(h + 3)) != 0) { return uintptr(0) } - if !(*(*int8)(unsafe.Pointer(n + 4)) != 0) { + if !(**(**int8)(__ccgo_up(n + 4)) != 0) { return _fourbyte_strstr(tls, h, n) } return _twoway_strstr(tls, h, n) @@ -146989,16 +146989,16 @@ func Xstrtok(tls *TLS, s uintptr, sep uintptr) (r uintptr) { return UintptrFromInt32(0) } s = s + uintptr(Xstrspn(tls, s, sep)) - if !(*(*int8)(unsafe.Pointer(s)) != 0) { + if !(**(**int8)(__ccgo_up(s)) != 0) { v1 = UintptrFromInt32(0) _p2 = v1 return v1 } _p2 = s + uintptr(Xstrcspn(tls, s, sep)) - if *(*int8)(unsafe.Pointer(_p2)) != 0 { + if **(**int8)(__ccgo_up(_p2)) != 0 { v1 = _p2 _p2 = _p2 + 1 - *(*int8)(unsafe.Pointer(v1)) = 0 + **(**int8)(__ccgo_up(v1)) = 0 } else { _p2 = uintptr(0) } @@ -147016,26 +147016,26 @@ func Xstrtok_r(tls *TLS, s uintptr, sep uintptr, p uintptr) (r uintptr) { var v2 bool _, _, _ = v1, v2, v3 if v2 = !(s != 0); v2 { - v1 = *(*uintptr)(unsafe.Pointer(p)) + v1 = **(**uintptr)(__ccgo_up(p)) s = v1 } if v2 && !(v1 != 0) { return UintptrFromInt32(0) } s = s + uintptr(Xstrspn(tls, s, sep)) - if !(*(*int8)(unsafe.Pointer(s)) != 0) { + if !(**(**int8)(__ccgo_up(s)) != 0) { v1 = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(p)) = v1 + **(**uintptr)(__ccgo_up(p)) = v1 return v1 } - *(*uintptr)(unsafe.Pointer(p)) = s + uintptr(Xstrcspn(tls, s, sep)) - if *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)))) != 0 { + **(**uintptr)(__ccgo_up(p)) = s + uintptr(Xstrcspn(tls, s, sep)) + if **(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)))) != 0 { v3 = p v1 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - *(*int8)(unsafe.Pointer(v1)) = 0 + **(**int8)(__ccgo_up(v1)) = 0 } else { - *(*uintptr)(unsafe.Pointer(p)) = uintptr(0) + **(**uintptr)(__ccgo_up(p)) = uintptr(0) } return s } @@ -147058,10 +147058,10 @@ func Xstrverscmp(tls *TLS, l0 uintptr, r0 uintptr) (r1 int32) { i = v2 dp = v2 for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(l + uintptr(i)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(r + uintptr(i))))) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(l + uintptr(i)))) == Int32FromUint8(**(**uint8)(__ccgo_up(r + uintptr(i))))) { break } - c = Int32FromUint8(*(*uint8)(unsafe.Pointer(l + uintptr(i)))) + c = Int32FromUint8(**(**uint8)(__ccgo_up(l + uintptr(i)))) if !(c != 0) { return 0 } @@ -147078,15 +147078,15 @@ func Xstrverscmp(tls *TLS, l0 uintptr, r0 uintptr) (r1 int32) { ; i = i + 1 } - if Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(l + uintptr(dp))))-int32('1')) < uint32(9) && Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(r + uintptr(dp))))-int32('1')) < uint32(9) { + if Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(l + uintptr(dp))))-int32('1')) < uint32(9) && Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(r + uintptr(dp))))-int32('1')) < uint32(9) { /* If we're looking at non-degenerate digit sequences starting * with nonzero digits, longest digit string is greater. */ j = i for { - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(l + uintptr(j))))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(l + uintptr(j))))-uint32('0') < uint32(10)) != 0) { break } - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(r + uintptr(j))))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(r + uintptr(j))))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return int32(1) } goto _3 @@ -147094,17 +147094,17 @@ func Xstrverscmp(tls *TLS, l0 uintptr, r0 uintptr) (r1 int32) { ; j = j + 1 } - if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(r + uintptr(j))))-uint32('0') < uint32(10)) != 0 { + if BoolInt32(uint32(**(**uint8)(__ccgo_up(r + uintptr(j))))-uint32('0') < uint32(10)) != 0 { return -int32(1) } } else { - if z != 0 && dp < i && (BoolInt32(uint32(*(*uint8)(unsafe.Pointer(l + uintptr(i))))-uint32('0') < uint32(10)) != 0 || BoolInt32(uint32(*(*uint8)(unsafe.Pointer(r + uintptr(i))))-uint32('0') < uint32(10)) != 0) { + if z != 0 && dp < i && (BoolInt32(uint32(**(**uint8)(__ccgo_up(l + uintptr(i))))-uint32('0') < uint32(10)) != 0 || BoolInt32(uint32(**(**uint8)(__ccgo_up(r + uintptr(i))))-uint32('0') < uint32(10)) != 0) { /* Otherwise, if common prefix of digit sequence is * all zeros, digits order less than non-digits. */ - return Int32FromUint8(Uint8FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(l + uintptr(i))))-Int32FromUint8('0'))) - Int32FromUint8(Uint8FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(r + uintptr(i))))-Int32FromUint8('0'))) + return Int32FromUint8(Uint8FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(l + uintptr(i))))-Int32FromUint8('0'))) - Int32FromUint8(Uint8FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(r + uintptr(i))))-Int32FromUint8('0'))) } } - return Int32FromUint8(*(*uint8)(unsafe.Pointer(l + uintptr(i)))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r + uintptr(i)))) + return Int32FromUint8(**(**uint8)(__ccgo_up(l + uintptr(i)))) - Int32FromUint8(**(**uint8)(__ccgo_up(r + uintptr(i)))) } func Xswab(tls *TLS, _src uintptr, _dest uintptr, n Tssize_t) { @@ -147119,8 +147119,8 @@ func Xswab(tls *TLS, _src uintptr, _dest uintptr, n Tssize_t) { if !(n > int64(1)) { break } - *(*int8)(unsafe.Pointer(dest)) = *(*int8)(unsafe.Pointer(src + 1)) - *(*int8)(unsafe.Pointer(dest + 1)) = *(*int8)(unsafe.Pointer(src)) + **(**int8)(__ccgo_up(dest)) = **(**int8)(__ccgo_up(src + 1)) + **(**int8)(__ccgo_up(dest + 1)) = **(**int8)(__ccgo_up(src)) dest = dest + uintptr(2) src = src + uintptr(2) goto _1 @@ -147182,7 +147182,7 @@ func Xwcschr(tls *TLS, s uintptr, c Twchar_t) (r uintptr) { return s + uintptr(Xwcslen(tls, s))*4 } for { - if !(*(*Twchar_t)(unsafe.Pointer(s)) != 0 && *(*Twchar_t)(unsafe.Pointer(s)) != c) { + if !(**(**Twchar_t)(__ccgo_up(s)) != 0 && **(**Twchar_t)(__ccgo_up(s)) != c) { break } goto _1 @@ -147190,7 +147190,7 @@ func Xwcschr(tls *TLS, s uintptr, c Twchar_t) (r uintptr) { ; s += 4 } - if *(*Twchar_t)(unsafe.Pointer(s)) != 0 { + if **(**Twchar_t)(__ccgo_up(s)) != 0 { v2 = s } else { v2 = uintptr(0) @@ -147206,7 +147206,7 @@ func Xwcscmp(tls *TLS, l uintptr, r uintptr) (r1 int32) { var v2 int32 _ = v2 for { - if !(*(*Twchar_t)(unsafe.Pointer(l)) == *(*Twchar_t)(unsafe.Pointer(r)) && *(*Twchar_t)(unsafe.Pointer(l)) != 0 && *(*Twchar_t)(unsafe.Pointer(r)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(l)) == **(**Twchar_t)(__ccgo_up(r)) && **(**Twchar_t)(__ccgo_up(l)) != 0 && **(**Twchar_t)(__ccgo_up(r)) != 0) { break } goto _1 @@ -147215,10 +147215,10 @@ func Xwcscmp(tls *TLS, l uintptr, r uintptr) (r1 int32) { l += 4 r += 4 } - if *(*Twchar_t)(unsafe.Pointer(l)) < *(*Twchar_t)(unsafe.Pointer(r)) { + if **(**Twchar_t)(__ccgo_up(l)) < **(**Twchar_t)(__ccgo_up(r)) { v2 = -int32(1) } else { - v2 = BoolInt32(*(*Twchar_t)(unsafe.Pointer(l)) > *(*Twchar_t)(unsafe.Pointer(r))) + v2 = BoolInt32(**(**Twchar_t)(__ccgo_up(l)) > **(**Twchar_t)(__ccgo_up(r))) } return v2 } @@ -147235,10 +147235,10 @@ func Xwcscpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { for { v2 = s s += 4 - v1 = *(*Twchar_t)(unsafe.Pointer(v2)) + v1 = **(**Twchar_t)(__ccgo_up(v2)) v3 = d d += 4 - *(*Twchar_t)(unsafe.Pointer(v3)) = v1 + **(**Twchar_t)(__ccgo_up(v3)) = v1 if !(v1 != 0) { break } @@ -147254,13 +147254,13 @@ func Xwcscspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { var a, v2, v3 uintptr var v1 uint64 _, _, _, _ = a, v1, v2, v3 - if !(*(*Twchar_t)(unsafe.Pointer(c)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(c)) != 0) { return Xwcslen(tls, s) } - if !(*(*Twchar_t)(unsafe.Pointer(c + 1*4)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(c + 1*4)) != 0) { v3 = s a = v3 - v2 = Xwcschr(tls, v3, *(*Twchar_t)(unsafe.Pointer(c))) + v2 = Xwcschr(tls, v3, **(**Twchar_t)(__ccgo_up(c))) s = v2 if v2 != 0 { v1 = Uint64FromInt64((int64(s) - int64(a)) / 4) @@ -147271,7 +147271,7 @@ func Xwcscspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { } a = s for { - if !(*(*Twchar_t)(unsafe.Pointer(s)) != 0 && !(Xwcschr(tls, c, *(*Twchar_t)(unsafe.Pointer(s))) != 0)) { + if !(**(**Twchar_t)(__ccgo_up(s)) != 0 && !(Xwcschr(tls, c, **(**Twchar_t)(__ccgo_up(s))) != 0)) { break } goto _4 @@ -147307,7 +147307,7 @@ func Xwcslen(tls *TLS, s uintptr) (r Tsize_t) { _ = a a = s for { - if !(*(*Twchar_t)(unsafe.Pointer(s)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(s)) != 0) { break } goto _1 @@ -147331,7 +147331,7 @@ func Xwcsncasecmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { return 0 } for { - if !(*(*Twchar_t)(unsafe.Pointer(l)) != 0 && *(*Twchar_t)(unsafe.Pointer(r)) != 0 && n != 0 && (*(*Twchar_t)(unsafe.Pointer(l)) == *(*Twchar_t)(unsafe.Pointer(r)) || Xtowlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(l)))) == Xtowlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(r)))))) { + if !(**(**Twchar_t)(__ccgo_up(l)) != 0 && **(**Twchar_t)(__ccgo_up(r)) != 0 && n != 0 && (**(**Twchar_t)(__ccgo_up(l)) == **(**Twchar_t)(__ccgo_up(r)) || Xtowlower(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(l)))) == Xtowlower(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(r)))))) { break } goto _2 @@ -147341,7 +147341,7 @@ func Xwcsncasecmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { r += 4 n = n - 1 } - return Int32FromUint32(Xtowlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(l)))) - Xtowlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(r))))) + return Int32FromUint32(Xtowlower(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(l)))) - Xtowlower(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(r))))) } func Xwcsncasecmp_l(tls *TLS, l uintptr, r uintptr, n Tsize_t, locale Tlocale_t) (r1 int32) { @@ -147361,17 +147361,17 @@ func Xwcsncat(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { _, _, _ = a, v1, v2 a = d d = d + uintptr(Xwcslen(tls, d))*4 - for n != 0 && *(*Twchar_t)(unsafe.Pointer(s)) != 0 { + for n != 0 && **(**Twchar_t)(__ccgo_up(s)) != 0 { n = n - 1 v1 = d d += 4 v2 = s s += 4 - *(*Twchar_t)(unsafe.Pointer(v1)) = *(*Twchar_t)(unsafe.Pointer(v2)) + **(**Twchar_t)(__ccgo_up(v1)) = **(**Twchar_t)(__ccgo_up(v2)) } v1 = d d += 4 - *(*Twchar_t)(unsafe.Pointer(v1)) = 0 + **(**Twchar_t)(__ccgo_up(v1)) = 0 return a } @@ -147383,7 +147383,7 @@ func Xwcsncmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { var v2, v3 int32 _, _ = v2, v3 for { - if !(n != 0 && *(*Twchar_t)(unsafe.Pointer(l)) == *(*Twchar_t)(unsafe.Pointer(r)) && *(*Twchar_t)(unsafe.Pointer(l)) != 0 && *(*Twchar_t)(unsafe.Pointer(r)) != 0) { + if !(n != 0 && **(**Twchar_t)(__ccgo_up(l)) == **(**Twchar_t)(__ccgo_up(r)) && **(**Twchar_t)(__ccgo_up(l)) != 0 && **(**Twchar_t)(__ccgo_up(r)) != 0) { break } goto _1 @@ -147394,10 +147394,10 @@ func Xwcsncmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { r += 4 } if n != 0 { - if *(*Twchar_t)(unsafe.Pointer(l)) < *(*Twchar_t)(unsafe.Pointer(r)) { + if **(**Twchar_t)(__ccgo_up(l)) < **(**Twchar_t)(__ccgo_up(r)) { v3 = -int32(1) } else { - v3 = BoolInt32(*(*Twchar_t)(unsafe.Pointer(l)) > *(*Twchar_t)(unsafe.Pointer(r))) + v3 = BoolInt32(**(**Twchar_t)(__ccgo_up(l)) > **(**Twchar_t)(__ccgo_up(r))) } v2 = v3 } else { @@ -147414,13 +147414,13 @@ func Xwcsncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { var a, v1, v2 uintptr _, _, _ = a, v1, v2 a = d - for n != 0 && *(*Twchar_t)(unsafe.Pointer(s)) != 0 { + for n != 0 && **(**Twchar_t)(__ccgo_up(s)) != 0 { n = n - 1 v1 = d d += 4 v2 = s s += 4 - *(*Twchar_t)(unsafe.Pointer(v1)) = *(*Twchar_t)(unsafe.Pointer(v2)) + **(**Twchar_t)(__ccgo_up(v1)) = **(**Twchar_t)(__ccgo_up(v2)) } Xwmemset(tls, d, 0, n) return a @@ -147448,7 +147448,7 @@ func Xwcspbrk(tls *TLS, s uintptr, b uintptr) (r uintptr) { var v1 uintptr _ = v1 s = s + uintptr(Xwcscspn(tls, s, b))*4 - if *(*Twchar_t)(unsafe.Pointer(s)) != 0 { + if **(**Twchar_t)(__ccgo_up(s)) != 0 { v1 = s } else { v1 = UintptrFromInt32(0) @@ -147465,7 +147465,7 @@ func Xwcsrchr(tls *TLS, s uintptr, c Twchar_t) (r uintptr) { _, _ = p, v2 p = s + uintptr(Xwcslen(tls, s))*4 for { - if !(p >= s && *(*Twchar_t)(unsafe.Pointer(p)) != c) { + if !(p >= s && **(**Twchar_t)(__ccgo_up(p)) != c) { break } goto _1 @@ -147490,7 +147490,7 @@ func Xwcsspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { _ = a a = s for { - if !(*(*Twchar_t)(unsafe.Pointer(s)) != 0 && Xwcschr(tls, c, *(*Twchar_t)(unsafe.Pointer(s))) != 0) { + if !(**(**Twchar_t)(__ccgo_up(s)) != 0 && Xwcschr(tls, c, **(**Twchar_t)(__ccgo_up(s))) != 0) { break } goto _1 @@ -147509,7 +147509,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { /* Computing length of needle */ l = uint64(0) for { - if !(*(*Twchar_t)(unsafe.Pointer(n + uintptr(l)*4)) != 0 && *(*Twchar_t)(unsafe.Pointer(h + uintptr(l)*4)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(n + uintptr(l)*4)) != 0 && **(**Twchar_t)(__ccgo_up(h + uintptr(l)*4)) != 0) { break } goto _1 @@ -147517,7 +147517,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { ; l = l + 1 } - if *(*Twchar_t)(unsafe.Pointer(n + uintptr(l)*4)) != 0 { + if **(**Twchar_t)(__ccgo_up(n + uintptr(l)*4)) != 0 { return uintptr(0) } /* hit the end of h */ /* Compute maximal suffix */ @@ -147527,7 +147527,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { p = v2 k = v2 for jp+k < l { - if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) == *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { + if **(**Twchar_t)(__ccgo_up(n + uintptr(ip+k)*4)) == **(**Twchar_t)(__ccgo_up(n + uintptr(jp+k)*4)) { if k == p { jp = jp + p k = uint64(1) @@ -147535,7 +147535,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { k = k + 1 } } else { - if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) > *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { + if **(**Twchar_t)(__ccgo_up(n + uintptr(ip+k)*4)) > **(**Twchar_t)(__ccgo_up(n + uintptr(jp+k)*4)) { jp = jp + k k = uint64(1) p = jp - ip @@ -147558,7 +147558,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { p = v2 k = v2 for jp+k < l { - if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) == *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { + if **(**Twchar_t)(__ccgo_up(n + uintptr(ip+k)*4)) == **(**Twchar_t)(__ccgo_up(n + uintptr(jp+k)*4)) { if k == p { jp = jp + p k = uint64(1) @@ -147566,7 +147566,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { k = k + 1 } } else { - if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) < *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { + if **(**Twchar_t)(__ccgo_up(n + uintptr(ip+k)*4)) < **(**Twchar_t)(__ccgo_up(n + uintptr(jp+k)*4)) { jp = jp + k k = uint64(1) p = jp - ip @@ -147624,7 +147624,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { } k = v8 for { - if !(*(*Twchar_t)(unsafe.Pointer(n + uintptr(k)*4)) != 0 && *(*Twchar_t)(unsafe.Pointer(n + uintptr(k)*4)) == *(*Twchar_t)(unsafe.Pointer(h + uintptr(k)*4))) { + if !(**(**Twchar_t)(__ccgo_up(n + uintptr(k)*4)) != 0 && **(**Twchar_t)(__ccgo_up(n + uintptr(k)*4)) == **(**Twchar_t)(__ccgo_up(h + uintptr(k)*4))) { break } goto _10 @@ -147632,7 +147632,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { ; k = k + 1 } - if *(*Twchar_t)(unsafe.Pointer(n + uintptr(k)*4)) != 0 { + if **(**Twchar_t)(__ccgo_up(n + uintptr(k)*4)) != 0 { h = h + uintptr(k-ms)*4 mem = uint64(0) goto _9 @@ -147640,7 +147640,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { /* Compare left half */ k = ms + uint64(1) for { - if !(k > mem && *(*Twchar_t)(unsafe.Pointer(n + uintptr(k-uint64(1))*4)) == *(*Twchar_t)(unsafe.Pointer(h + uintptr(k-uint64(1))*4))) { + if !(k > mem && **(**Twchar_t)(__ccgo_up(n + uintptr(k-uint64(1))*4)) == **(**Twchar_t)(__ccgo_up(h + uintptr(k-uint64(1))*4))) { break } goto _12 @@ -147665,18 +147665,18 @@ func Xwcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { defer func() { trc("-> %v", r) }() } /* Return immediately on empty needle or haystack */ - if !(*(*Twchar_t)(unsafe.Pointer(n)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(n)) != 0) { return h } - if !(*(*Twchar_t)(unsafe.Pointer(h)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(h)) != 0) { return uintptr(0) } /* Use faster algorithms for short needles */ - h = Xwcschr(tls, h, *(*Twchar_t)(unsafe.Pointer(n))) - if !(h != 0) || !(*(*Twchar_t)(unsafe.Pointer(n + 1*4)) != 0) { + h = Xwcschr(tls, h, **(**Twchar_t)(__ccgo_up(n))) + if !(h != 0) || !(**(**Twchar_t)(__ccgo_up(n + 1*4)) != 0) { return h } - if !(*(*Twchar_t)(unsafe.Pointer(h + 1*4)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(h + 1*4)) != 0) { return uintptr(0) } return _twoway_wcsstr(tls, h, n) @@ -147691,26 +147691,26 @@ func Xwcstok(tls *TLS, s uintptr, sep uintptr, p uintptr) (r uintptr) { var v2 bool _, _, _ = v1, v2, v3 if v2 = !(s != 0); v2 { - v1 = *(*uintptr)(unsafe.Pointer(p)) + v1 = **(**uintptr)(__ccgo_up(p)) s = v1 } if v2 && !(v1 != 0) { return UintptrFromInt32(0) } s = s + uintptr(Xwcsspn(tls, s, sep))*4 - if !(*(*Twchar_t)(unsafe.Pointer(s)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(s)) != 0) { v1 = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(p)) = v1 + **(**uintptr)(__ccgo_up(p)) = v1 return v1 } - *(*uintptr)(unsafe.Pointer(p)) = s + uintptr(Xwcscspn(tls, s, sep))*4 - if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)))) != 0 { + **(**uintptr)(__ccgo_up(p)) = s + uintptr(Xwcscspn(tls, s, sep))*4 + if **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(p)))) != 0 { v3 = p v1 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) += 4 - *(*Twchar_t)(unsafe.Pointer(v1)) = 0 + **(**Twchar_t)(__ccgo_up(v1)) = 0 } else { - *(*uintptr)(unsafe.Pointer(p)) = uintptr(0) + **(**uintptr)(__ccgo_up(p)) = uintptr(0) } return s } @@ -147731,7 +147731,7 @@ func Xwmemchr(tls *TLS, s uintptr, c Twchar_t, n Tsize_t) (r uintptr) { var v2 uintptr _ = v2 for { - if !(n != 0 && *(*Twchar_t)(unsafe.Pointer(s)) != c) { + if !(n != 0 && **(**Twchar_t)(__ccgo_up(s)) != c) { break } goto _1 @@ -147756,7 +147756,7 @@ func Xwmemcmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { var v2, v3 int32 _, _ = v2, v3 for { - if !(n != 0 && *(*Twchar_t)(unsafe.Pointer(l)) == *(*Twchar_t)(unsafe.Pointer(r))) { + if !(n != 0 && **(**Twchar_t)(__ccgo_up(l)) == **(**Twchar_t)(__ccgo_up(r))) { break } goto _1 @@ -147767,10 +147767,10 @@ func Xwmemcmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { r += 4 } if n != 0 { - if *(*Twchar_t)(unsafe.Pointer(l)) < *(*Twchar_t)(unsafe.Pointer(r)) { + if **(**Twchar_t)(__ccgo_up(l)) < **(**Twchar_t)(__ccgo_up(r)) { v3 = -int32(1) } else { - v3 = BoolInt32(*(*Twchar_t)(unsafe.Pointer(l)) > *(*Twchar_t)(unsafe.Pointer(r))) + v3 = BoolInt32(**(**Twchar_t)(__ccgo_up(l)) > **(**Twchar_t)(__ccgo_up(r))) } v2 = v3 } else { @@ -147798,7 +147798,7 @@ func Xwmemcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { d += 4 v3 = s s += 4 - *(*Twchar_t)(unsafe.Pointer(v2)) = *(*Twchar_t)(unsafe.Pointer(v3)) + **(**Twchar_t)(__ccgo_up(v2)) = **(**Twchar_t)(__ccgo_up(v3)) } return a } @@ -147822,7 +147822,7 @@ func Xwmemmove(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { if !(v1 != 0) { break } - *(*Twchar_t)(unsafe.Pointer(d + uintptr(n)*4)) = *(*Twchar_t)(unsafe.Pointer(s + uintptr(n)*4)) + **(**Twchar_t)(__ccgo_up(d + uintptr(n)*4)) = **(**Twchar_t)(__ccgo_up(s + uintptr(n)*4)) } } else { for { @@ -147835,7 +147835,7 @@ func Xwmemmove(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { d += 4 v4 = s s += 4 - *(*Twchar_t)(unsafe.Pointer(v3)) = *(*Twchar_t)(unsafe.Pointer(v4)) + **(**Twchar_t)(__ccgo_up(v3)) = **(**Twchar_t)(__ccgo_up(v4)) } } return d0 @@ -147858,7 +147858,7 @@ func Xwmemset(tls *TLS, d uintptr, c Twchar_t, n Tsize_t) (r uintptr) { } v2 = d d += 4 - *(*Twchar_t)(unsafe.Pointer(v2)) = c + **(**Twchar_t)(__ccgo_up(v2)) = c } return ret } @@ -147874,7 +147874,7 @@ func Xmkdtemp(tls *TLS, template uintptr) (r uintptr) { l = _strlen(tls, template) retries = int32(100) if l < uint64(6) || Xmemcmp(tls, template+uintptr(l)-uintptr(6), __ccgo_ts+1720, uint64(6)) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } for { @@ -147887,7 +147887,7 @@ func Xmkdtemp(tls *TLS, template uintptr) (r uintptr) { ; retries = retries - 1 v1 = retries - if !(v1 != 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EEXIST)) { + if !(v1 != 0 && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EEXIST)) { break } } @@ -147915,7 +147915,7 @@ func X__mkostemps(tls *TLS, template uintptr, len1 int32, flags int32) (r int32) _, _, _, _ = fd, l, retries, v1 l = _strlen(tls, template) if l < uint64(6) || Uint64FromInt32(len1) > l-uint64(6) || Xmemcmp(tls, template+uintptr(l)-uintptr(len1)-uintptr(6), __ccgo_ts+1720, uint64(6)) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } flags = flags - flags&(Int32FromInt32(03)|Int32FromInt32(O_PATH)) @@ -147932,7 +147932,7 @@ func X__mkostemps(tls *TLS, template uintptr, len1 int32, flags int32) (r int32) ; retries = retries - 1 v1 = retries - if !(v1 != 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EEXIST)) { + if !(v1 != 0 && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EEXIST)) { break } } @@ -147978,15 +147978,15 @@ func Xmktemp(tls *TLS, template uintptr) (r uintptr) { l = _strlen(tls, template) retries = int32(100) if l < uint64(6) || Xmemcmp(tls, template+uintptr(l)-uintptr(6), __ccgo_ts+1720, uint64(6)) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) - *(*int8)(unsafe.Pointer(template)) = 0 + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) + **(**int8)(__ccgo_up(template)) = 0 return template } for { ___randname(tls, template+uintptr(l)-uintptr(6)) if Xstat(tls, template, bp) != 0 { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(ENOENT) { - *(*int8)(unsafe.Pointer(template)) = 0 + if **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(ENOENT) { + **(**int8)(__ccgo_up(template)) = 0 } return template } @@ -147999,8 +147999,8 @@ func Xmktemp(tls *TLS, template uintptr) (r uintptr) { break } } - *(*int8)(unsafe.Pointer(template)) = 0 - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EEXIST) + **(**int8)(__ccgo_up(template)) = 0 + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EEXIST) return template } @@ -148024,13 +148024,13 @@ func Xcfmakeraw(tls *TLS, t uintptr) { if __ccgo_strace { trc("tls=%v t=%v, (%v:)", tls, t, origin(2)) } - *(*Ttcflag_t)(unsafe.Pointer(t)) &= Uint32FromInt32(^(Int32FromInt32(IGNBRK) | Int32FromInt32(BRKINT) | Int32FromInt32(PARMRK) | Int32FromInt32(ISTRIP) | Int32FromInt32(INLCR) | Int32FromInt32(IGNCR) | Int32FromInt32(ICRNL) | Int32FromInt32(IXON))) - *(*Ttcflag_t)(unsafe.Pointer(t + 4)) &= Uint32FromInt32(^Int32FromInt32(OPOST)) - *(*Ttcflag_t)(unsafe.Pointer(t + 12)) &= Uint32FromInt32(^(Int32FromInt32(ECHO) | Int32FromInt32(ECHONL) | Int32FromInt32(ICANON) | Int32FromInt32(ISIG) | Int32FromInt32(IEXTEN))) - *(*Ttcflag_t)(unsafe.Pointer(t + 8)) &= Uint32FromInt32(^(Int32FromInt32(CSIZE) | Int32FromInt32(PARENB))) - *(*Ttcflag_t)(unsafe.Pointer(t + 8)) |= uint32(CS8) - *(*Tcc_t)(unsafe.Pointer(t + 17 + 6)) = uint8(1) - *(*Tcc_t)(unsafe.Pointer(t + 17 + 5)) = uint8(0) + **(**Ttcflag_t)(__ccgo_up(t)) &= Uint32FromInt32(^(Int32FromInt32(IGNBRK) | Int32FromInt32(BRKINT) | Int32FromInt32(PARMRK) | Int32FromInt32(ISTRIP) | Int32FromInt32(INLCR) | Int32FromInt32(IGNCR) | Int32FromInt32(ICRNL) | Int32FromInt32(IXON))) + **(**Ttcflag_t)(__ccgo_up(t + 4)) &= Uint32FromInt32(^Int32FromInt32(OPOST)) + **(**Ttcflag_t)(__ccgo_up(t + 12)) &= Uint32FromInt32(^(Int32FromInt32(ECHO) | Int32FromInt32(ECHONL) | Int32FromInt32(ICANON) | Int32FromInt32(ISIG) | Int32FromInt32(IEXTEN))) + **(**Ttcflag_t)(__ccgo_up(t + 8)) &= Uint32FromInt32(^(Int32FromInt32(CSIZE) | Int32FromInt32(PARENB))) + **(**Ttcflag_t)(__ccgo_up(t + 8)) |= uint32(CS8) + **(**Tcc_t)(__ccgo_up(t + 17 + 6)) = uint8(1) + **(**Tcc_t)(__ccgo_up(t + 17 + 5)) = uint8(0) } func Xcfsetospeed(tls *TLS, tio uintptr, speed Tspeed_t) (r int32) { @@ -148039,11 +148039,11 @@ func Xcfsetospeed(tls *TLS, tio uintptr, speed Tspeed_t) (r int32) { defer func() { trc("-> %v", r) }() } if speed&Uint32FromInt32(^Int32FromInt32(CBAUD)) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } - *(*Ttcflag_t)(unsafe.Pointer(tio + 8)) &= Uint32FromInt32(^Int32FromInt32(CBAUD)) - *(*Ttcflag_t)(unsafe.Pointer(tio + 8)) |= speed + **(**Ttcflag_t)(__ccgo_up(tio + 8)) &= Uint32FromInt32(^Int32FromInt32(CBAUD)) + **(**Ttcflag_t)(__ccgo_up(tio + 8)) |= speed return 0 } @@ -148122,7 +148122,7 @@ func Xtcgetsid(tls *TLS, fd int32) (r Tpid_t) { if Xioctl(tls, fd, int32(TIOCGSID), VaList(bp+16, bp)) < 0 { return -int32(1) } - return *(*int32)(unsafe.Pointer(bp)) + return **(**int32)(__ccgo_up(bp)) } func Xtcgetwinsize(tls *TLS, fd int32, wsz uintptr) (r int32) { @@ -148152,7 +148152,7 @@ func Xtcsetattr(tls *TLS, fd int32, act int32, tio uintptr) (r int32) { bp := tls.Alloc(16) defer tls.Free(16) if act < 0 || act > int32(2) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } return Xioctl(tls, fd, int32(TCSETS)+act, VaList(bp+8, tio)) @@ -148183,8 +148183,8 @@ func X__map_file(tls *TLS, pathname uintptr, size uintptr) (r uintptr) { return uintptr(0) } if !(X__fstat(tls, fd, bp) != 0) { - map1 = X__mmap(tls, uintptr(0), Uint64FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_size), int32(PROT_READ), int32(MAP_SHARED), fd, 0) - *(*Tsize_t)(unsafe.Pointer(size)) = Uint64FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_size) + map1 = X__mmap(tls, uintptr(0), Uint64FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_size), int32(PROT_READ), int32(MAP_SHARED), fd, 0) + **(**Tsize_t)(__ccgo_up(size)) = Uint64FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_size) } X__syscall1(tls, int64(SYS_close), int64(fd)) if map1 == uintptr(-Int32FromInt32(1)) { @@ -148356,7 +148356,7 @@ func X__tm_to_secs(tls *TLS, tm uintptr) (r int64) { year = year + int64(adj) } t = X__year_to_secs(tls, year, bp) - t = t + int64(X__month_to_secs(tls, month, *(*int32)(unsafe.Pointer(bp)))) + t = t + int64(X__month_to_secs(tls, month, **(**int32)(__ccgo_up(bp)))) t = t + int64(86400)*int64((*Ttm)(unsafe.Pointer(tm)).Ftm_mday-Int32FromInt32(1)) t = t + int64(3600)*int64((*Ttm)(unsafe.Pointer(tm)).Ftm_hour) t = t + int64(60)*int64((*Ttm)(unsafe.Pointer(tm)).Ftm_min) @@ -148390,14 +148390,14 @@ func _getint2(tls *TLS, p uintptr) (r int32) { _ = x x = uint32(0) for { - if !(Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)))))-int32('0')) < uint32(10)) { + if !(Uint32FromInt32(int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)))))-int32('0')) < uint32(10)) { break } - x = Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)))))-int32('0')) + uint32(10)*x + x = Uint32FromInt32(int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)))))-int32('0')) + uint32(10)*x goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 } return Int32FromUint32(x) } @@ -148406,20 +148406,20 @@ func _getoff(tls *TLS, p uintptr) (r int32) { var neg, off, v1 int32 _, _, _ = neg, off, v1 neg = 0 - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('-') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) == int32('-') { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 neg = int32(1) } else { - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('+') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) == int32('+') { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 } } off = int32(3600) * _getint2(tls, p) - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32(':') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) == int32(':') { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 off = off + int32(60)*_getint2(tls, p) - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32(':') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) == int32(':') { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 off = off + _getint2(tls, p) } } @@ -148434,61 +148434,61 @@ func _getoff(tls *TLS, p uintptr) (r int32) { func _getrule(tls *TLS, p uintptr, rule uintptr) { var r, v1 int32 _, _ = r, v1 - v1 = int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) - *(*int32)(unsafe.Pointer(rule)) = v1 + v1 = int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) + **(**int32)(__ccgo_up(rule)) = v1 r = v1 if r != int32('M') { if r == int32('J') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 } else { - *(*int32)(unsafe.Pointer(rule)) = 0 + **(**int32)(__ccgo_up(rule)) = 0 } - *(*int32)(unsafe.Pointer(rule + 1*4)) = _getint2(tls, p) + **(**int32)(__ccgo_up(rule + 1*4)) = _getint2(tls, p) } else { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 - *(*int32)(unsafe.Pointer(rule + 1*4)) = _getint2(tls, p) - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 - *(*int32)(unsafe.Pointer(rule + 2*4)) = _getint2(tls, p) - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 - *(*int32)(unsafe.Pointer(rule + 3*4)) = _getint2(tls, p) - } - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('/') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 - *(*int32)(unsafe.Pointer(rule + 4*4)) = _getoff(tls, p) + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 + **(**int32)(__ccgo_up(rule + 1*4)) = _getint2(tls, p) + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 + **(**int32)(__ccgo_up(rule + 2*4)) = _getint2(tls, p) + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 + **(**int32)(__ccgo_up(rule + 3*4)) = _getint2(tls, p) + } + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) == int32('/') { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 + **(**int32)(__ccgo_up(rule + 4*4)) = _getoff(tls, p) } else { - *(*int32)(unsafe.Pointer(rule + 4*4)) = int32(7200) + **(**int32)(__ccgo_up(rule + 4*4)) = int32(7200) } } func _getname(tls *TLS, d uintptr, p uintptr) { var i, v3 int32 _, _ = i, v3 - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('<') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) == int32('<') { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 i = 0 for { - if !(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))) != 0 && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i)))) != int32('>')) { + if !(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)) + uintptr(i))) != 0 && int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)) + uintptr(i)))) != int32('>')) { break } if i < int32(TZNAME_MAX) { - *(*int8)(unsafe.Pointer(d + uintptr(i))) = *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))) + **(**int8)(__ccgo_up(d + uintptr(i))) = **(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)) + uintptr(i))) } goto _1 _1: ; i = i + 1 } - if *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))) != 0 { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + if **(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)) + uintptr(i))) != 0 { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 } } else { i = 0 for { - if !(Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))))|int32(32)-int32('a')) < uint32(26)) { + if !(Uint32FromInt32(int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)) + uintptr(i))))|int32(32)-int32('a')) < uint32(26)) { break } if i < int32(TZNAME_MAX) { - *(*int8)(unsafe.Pointer(d + uintptr(i))) = *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))) + **(**int8)(__ccgo_up(d + uintptr(i))) = **(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)) + uintptr(i))) } goto _2 _2: @@ -148496,17 +148496,17 @@ func _getname(tls *TLS, d uintptr, p uintptr) { i = i + 1 } } - *(*uintptr)(unsafe.Pointer(p)) += uintptr(i) + **(**uintptr)(__ccgo_up(p)) += uintptr(i) if i < int32(TZNAME_MAX) { v3 = i } else { v3 = int32(TZNAME_MAX) } - *(*int8)(unsafe.Pointer(d + uintptr(v3))) = 0 + **(**int8)(__ccgo_up(d + uintptr(v3))) = 0 } func _zi_read32(tls *TLS, z uintptr) (r Tuint32_t) { - return uint32(*(*uint8)(unsafe.Pointer(z)))< Uint64FromInt32(Int32FromInt32(PATH_MAX)+Int32FromInt32(1)) { - *(*uintptr)(unsafe.Pointer(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) + **(**uintptr)(__ccgo_up(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) i = Uint64FromInt32(3) } if i >= _old_tz_size { @@ -148589,13 +148589,13 @@ func _do_tzset(tls *TLS) { _old_tz = Xmalloc(tls, _old_tz_size) } if _old_tz != 0 { - Xmemcpy(tls, _old_tz, *(*uintptr)(unsafe.Pointer(bp + 288)), i+uint64(1)) + Xmemcpy(tls, _old_tz, **(**uintptr)(__ccgo_up(bp + 288)), i+uint64(1)) } posix_form = 0 - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) != int32(':') { - *(*uintptr)(unsafe.Pointer(bp + 296)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) != int32(':') { + **(**uintptr)(__ccgo_up(bp + 296)) = **(**uintptr)(__ccgo_up(bp + 288)) _getname(tls, bp+308, bp+296) - if *(*uintptr)(unsafe.Pointer(bp + 296)) != *(*uintptr)(unsafe.Pointer(bp + 288)) && (int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 296))))) == int32('+') || int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 296))))) == int32('-') || BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 296)))))-uint32('0') < uint32(10)) != 0 || !(Xstrcmp(tls, bp+308, __ccgo_ts+1745) != 0) || !(Xstrcmp(tls, bp+308, __ccgo_ts+1749) != 0)) { + if **(**uintptr)(__ccgo_up(bp + 296)) != **(**uintptr)(__ccgo_up(bp + 288)) && (int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 296))))) == int32('+') || int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 296))))) == int32('-') || BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 296)))))-uint32('0') < uint32(10)) != 0 || !(Xstrcmp(tls, bp+308, __ccgo_ts+1745) != 0) || !(Xstrcmp(tls, bp+308, __ccgo_ts+1749) != 0)) { posix_form = int32(1) } } @@ -148603,21 +148603,21 @@ func _do_tzset(tls *TLS) { * pathame beginning with "."; in secure mode, only the * standard path will be searched. */ if !(posix_form != 0) { - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32(':') { - *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32(':') { + **(**uintptr)(__ccgo_up(bp + 288)) = **(**uintptr)(__ccgo_up(bp + 288)) + 1 } - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32('/') || int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32('.') { - if !(X__libc.Fsecure != 0) || !(Xstrcmp(tls, *(*uintptr)(unsafe.Pointer(bp + 288)), __ccgo_ts+1730) != 0) { - map1 = X__map_file(tls, *(*uintptr)(unsafe.Pointer(bp + 288)), uintptr(unsafe.Pointer(&_map_size))) + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32('/') || int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32('.') { + if !(X__libc.Fsecure != 0) || !(Xstrcmp(tls, **(**uintptr)(__ccgo_up(bp + 288)), __ccgo_ts+1730) != 0) { + map1 = X__map_file(tls, **(**uintptr)(__ccgo_up(bp + 288)), uintptr(unsafe.Pointer(&_map_size))) } } else { - l = _strlen(tls, *(*uintptr)(unsafe.Pointer(bp + 288))) - if l <= uint64(NAME_MAX) && !(Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp + 288)), int32('.')) != 0) { - Xmemcpy(tls, pathname, *(*uintptr)(unsafe.Pointer(bp + 288)), l+uint64(1)) - *(*int8)(unsafe.Pointer(pathname + uintptr(l))) = 0 + l = _strlen(tls, **(**uintptr)(__ccgo_up(bp + 288))) + if l <= uint64(NAME_MAX) && !(Xstrchr(tls, **(**uintptr)(__ccgo_up(bp + 288)), int32('.')) != 0) { + Xmemcpy(tls, pathname, **(**uintptr)(__ccgo_up(bp + 288)), l+uint64(1)) + **(**int8)(__ccgo_up(pathname + uintptr(l))) = 0 try = uintptr(unsafe.Pointer(&_search)) for { - if !(!(map1 != 0) && *(*int8)(unsafe.Pointer(try)) != 0) { + if !(!(map1 != 0) && **(**int8)(__ccgo_up(try)) != 0) { break } l = _strlen(tls, try) @@ -148631,18 +148631,18 @@ func _do_tzset(tls *TLS) { } } if !(map1 != 0) { - *(*uintptr)(unsafe.Pointer(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) + **(**uintptr)(__ccgo_up(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) } } if map1 != 0 && (_map_size < uint64(44) || Xmemcmp(tls, map1, __ccgo_ts+1753, uint64(4)) != 0) { X__munmap(tls, map1, _map_size) map1 = uintptr(0) - *(*uintptr)(unsafe.Pointer(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) + **(**uintptr)(__ccgo_up(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) } _zi = map1 if map1 != 0 { scale = int32(2) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(map1 + 4))) != int32('1') { + if Int32FromUint8(**(**uint8)(__ccgo_up(map1 + 4))) != int32('1') { *(*[6]uint8)(unsafe.Pointer(bp)) = [6]uint8{ 0: uint8(1), 1: uint8(1), @@ -148661,18 +148661,18 @@ func _do_tzset(tls *TLS) { _types = _index + uintptr(_zi_read32(tls, _trans-uintptr(12))) _abbrevs = _types + uintptr(uint32(6)*_zi_read32(tls, _trans-uintptr(8))) _abbrevs_end = _abbrevs + uintptr(_zi_read32(tls, _trans-uintptr(4))) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(_zi + uintptr(_map_size-uint64(1))))) == int32('\n') { - *(*uintptr)(unsafe.Pointer(bp + 288)) = _zi + uintptr(_map_size) - uintptr(2) + if Int32FromUint8(**(**uint8)(__ccgo_up(_zi + uintptr(_map_size-uint64(1))))) == int32('\n') { + **(**uintptr)(__ccgo_up(bp + 288)) = _zi + uintptr(_map_size) - uintptr(2) for { - if !(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) != int32('\n')) { + if !(int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) != int32('\n')) { break } goto _4 _4: ; - *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) - 1 + **(**uintptr)(__ccgo_up(bp + 288)) = **(**uintptr)(__ccgo_up(bp + 288)) - 1 } - *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 + **(**uintptr)(__ccgo_up(bp + 288)) = **(**uintptr)(__ccgo_up(bp + 288)) + 1 } else { v5 = UintptrFromInt32(0) Xtzname[int32(1)] = v5 @@ -148687,12 +148687,12 @@ func _do_tzset(tls *TLS) { if !(p1 < _abbrevs) { break } - if !(*(*uint8)(unsafe.Pointer(p1 + 4)) != 0) && !(Xtzname[0] != 0) { - Xtzname[0] = _abbrevs + uintptr(*(*uint8)(unsafe.Pointer(p1 + 5))) + if !(**(**uint8)(__ccgo_up(p1 + 4)) != 0) && !(Xtzname[0] != 0) { + Xtzname[0] = _abbrevs + uintptr(**(**uint8)(__ccgo_up(p1 + 5))) Xtimezone = Int64FromUint32(-_zi_read32(tls, p1)) } - if *(*uint8)(unsafe.Pointer(p1 + 4)) != 0 && !(Xtzname[int32(1)] != 0) { - Xtzname[int32(1)] = _abbrevs + uintptr(*(*uint8)(unsafe.Pointer(p1 + 5))) + if **(**uint8)(__ccgo_up(p1 + 4)) != 0 && !(Xtzname[int32(1)] != 0) { + Xtzname[int32(1)] = _abbrevs + uintptr(**(**uint8)(__ccgo_up(p1 + 5))) _dst_off = Int32FromUint32(-_zi_read32(tls, p1)) Xdaylight = int32(1) } @@ -148714,8 +148714,8 @@ func _do_tzset(tls *TLS) { return } } - if !(*(*uintptr)(unsafe.Pointer(bp + 288)) != 0) { - *(*uintptr)(unsafe.Pointer(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) + if !(**(**uintptr)(__ccgo_up(bp + 288)) != 0) { + **(**uintptr)(__ccgo_up(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) } _getname(tls, uintptr(unsafe.Pointer(&_std_name)), bp+288) Xtzname[0] = uintptr(unsafe.Pointer(&_std_name)) @@ -148724,7 +148724,7 @@ func _do_tzset(tls *TLS) { Xtzname[int32(1)] = uintptr(unsafe.Pointer(&_dst_name)) if _dst_name[0] != 0 { Xdaylight = int32(1) - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32('+') || int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32('-') || Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288)))))-int32('0')) < uint32(10) { + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32('+') || int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32('-') || Uint32FromInt32(int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288)))))-int32('0')) < uint32(10) { _dst_off = _getoff(tls, bp+288) } else { _dst_off = int32(Xtimezone - int64(3600)) @@ -148733,12 +148733,12 @@ func _do_tzset(tls *TLS) { Xdaylight = 0 _dst_off = int32(Xtimezone) } - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32(',') { - *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32(',') { + **(**uintptr)(__ccgo_up(bp + 288)) = **(**uintptr)(__ccgo_up(bp + 288)) + 1 _getrule(tls, bp+288, uintptr(unsafe.Pointer(&_r0))) } - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32(',') { - *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32(',') { + **(**uintptr)(__ccgo_up(bp + 288)) = **(**uintptr)(__ccgo_up(bp + 288)) + 1 _getrule(tls, bp+288, uintptr(unsafe.Pointer(&_r12))) } } @@ -148759,7 +148759,7 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { n = Uint64FromInt64((int64(_index) - int64(_trans)) >> scale) if !(n != 0) { if alt != 0 { - *(*Tsize_t)(unsafe.Pointer(alt)) = uint64(0) + **(**Tsize_t)(__ccgo_up(alt)) = uint64(0) } return uint64(0) } @@ -148773,7 +148773,7 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { x = Uint64FromInt32(Int32FromUint64(x)) } if local != 0 { - off = Int32FromUint32(_zi_read32(tls, _types+uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(m-uint64(1)))))))) + off = Int32FromUint32(_zi_read32(tls, _types+uintptr(int32(6)*Int32FromUint8(**(**uint8)(__ccgo_up(_index + uintptr(m-uint64(1)))))))) } if t-int64(off) < int64(Int64FromUint64(x)) { n = n / uint64(2) @@ -148802,7 +148802,7 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { if !(i != 0) { break } - if !(*(*uint8)(unsafe.Pointer(_types + uintptr(i-uint64(6)+uint64(4)))) != 0) { + if !(**(**uint8)(__ccgo_up(_types + uintptr(i-uint64(6)+uint64(4)))) != 0) { j = i - uint64(6) } goto _1 @@ -148817,24 +148817,24 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { * and the index-zero (after transition) type as the alt. */ if t-int64(off) < int64(Int64FromUint64(x)) { if alt != 0 { - *(*Tsize_t)(unsafe.Pointer(alt)) = uint64(*(*uint8)(unsafe.Pointer(_index))) + **(**Tsize_t)(__ccgo_up(alt)) = uint64(**(**uint8)(__ccgo_up(_index))) } return j / uint64(6) } } /* Try to find a neighboring opposite-DST-status rule. */ if alt != 0 { - if a != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(_types + uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(a-uint64(1)))))+int32(4))))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(_types + uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(a))))+int32(4))))) { - *(*Tsize_t)(unsafe.Pointer(alt)) = uint64(*(*uint8)(unsafe.Pointer(_index + uintptr(a-uint64(1))))) + if a != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(_types + uintptr(int32(6)*Int32FromUint8(**(**uint8)(__ccgo_up(_index + uintptr(a-uint64(1)))))+int32(4))))) != Int32FromUint8(**(**uint8)(__ccgo_up(_types + uintptr(int32(6)*Int32FromUint8(**(**uint8)(__ccgo_up(_index + uintptr(a))))+int32(4))))) { + **(**Tsize_t)(__ccgo_up(alt)) = uint64(**(**uint8)(__ccgo_up(_index + uintptr(a-uint64(1))))) } else { - if a+uint64(1) < n && Int32FromUint8(*(*uint8)(unsafe.Pointer(_types + uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(a+uint64(1)))))+int32(4))))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(_types + uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(a))))+int32(4))))) { - *(*Tsize_t)(unsafe.Pointer(alt)) = uint64(*(*uint8)(unsafe.Pointer(_index + uintptr(a+uint64(1))))) + if a+uint64(1) < n && Int32FromUint8(**(**uint8)(__ccgo_up(_types + uintptr(int32(6)*Int32FromUint8(**(**uint8)(__ccgo_up(_index + uintptr(a+uint64(1)))))+int32(4))))) != Int32FromUint8(**(**uint8)(__ccgo_up(_types + uintptr(int32(6)*Int32FromUint8(**(**uint8)(__ccgo_up(_index + uintptr(a))))+int32(4))))) { + **(**Tsize_t)(__ccgo_up(alt)) = uint64(**(**uint8)(__ccgo_up(_index + uintptr(a+uint64(1))))) } else { - *(*Tsize_t)(unsafe.Pointer(alt)) = uint64(*(*uint8)(unsafe.Pointer(_index + uintptr(a)))) + **(**Tsize_t)(__ccgo_up(alt)) = uint64(**(**uint8)(__ccgo_up(_index + uintptr(a)))) } } } - return uint64(*(*uint8)(unsafe.Pointer(_index + uintptr(a)))) + return uint64(**(**uint8)(__ccgo_up(_index + uintptr(a)))) } func _days_in_month1(tls *TLS, m int32, is_leap int32) (r int32) { @@ -148856,28 +148856,28 @@ func _rule_to_secs(tls *TLS, rule uintptr, year int32) (r int64) { var _ /* is_leap at bp+0 */ int32 _, _, _, _, _, _, _ = d, days, m, n, t, wday, x t = X__year_to_secs(tls, int64(year), bp) - if *(*int32)(unsafe.Pointer(rule)) != int32('M') { - x = *(*int32)(unsafe.Pointer(rule + 1*4)) - if *(*int32)(unsafe.Pointer(rule)) == int32('J') && (x < int32(60) || !(*(*int32)(unsafe.Pointer(bp)) != 0)) { + if **(**int32)(__ccgo_up(rule)) != int32('M') { + x = **(**int32)(__ccgo_up(rule + 1*4)) + if **(**int32)(__ccgo_up(rule)) == int32('J') && (x < int32(60) || !(**(**int32)(__ccgo_up(bp)) != 0)) { x = x - 1 } t = t + int64(int32(86400)*x) } else { - m = *(*int32)(unsafe.Pointer(rule + 1*4)) - n = *(*int32)(unsafe.Pointer(rule + 2*4)) - d = *(*int32)(unsafe.Pointer(rule + 3*4)) - t = t + int64(X__month_to_secs(tls, m-int32(1), *(*int32)(unsafe.Pointer(bp)))) + m = **(**int32)(__ccgo_up(rule + 1*4)) + n = **(**int32)(__ccgo_up(rule + 2*4)) + d = **(**int32)(__ccgo_up(rule + 3*4)) + t = t + int64(X__month_to_secs(tls, m-int32(1), **(**int32)(__ccgo_up(bp)))) wday = int32((t+int64(Int32FromInt32(4)*Int32FromInt32(86400)))%int64(Int32FromInt32(7)*Int32FromInt32(86400))) / int32(86400) days = d - wday if days < 0 { days = days + int32(7) } - if n == int32(5) && days+int32(28) >= _days_in_month1(tls, m, *(*int32)(unsafe.Pointer(bp))) { + if n == int32(5) && days+int32(28) >= _days_in_month1(tls, m, **(**int32)(__ccgo_up(bp))) { n = int32(4) } t = t + int64(int32(86400)*(days+int32(7)*(n-int32(1)))) } - t = t + int64(*(*int32)(unsafe.Pointer(rule + 4*4))) + t = t + int64(**(**int32)(__ccgo_up(rule + 4*4))) return t } @@ -148903,11 +148903,11 @@ func X__secs_to_zone(tls *TLS, t int64, local int32, isdst uintptr, offset uintp if _zi != 0 { i = _scan_trans(tls, t, local, bp) if i != Uint64FromInt32(-Int32FromInt32(1)) { - *(*int32)(unsafe.Pointer(isdst)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(_types + uintptr(uint64(6)*i+uint64(4))))) - *(*int64)(unsafe.Pointer(offset)) = int64(Int32FromUint32(_zi_read32(tls, _types+uintptr(uint64(6)*i)))) - *(*uintptr)(unsafe.Pointer(zonename)) = _abbrevs + uintptr(*(*uint8)(unsafe.Pointer(_types + uintptr(uint64(6)*i+uint64(5))))) + **(**int32)(__ccgo_up(isdst)) = Int32FromUint8(**(**uint8)(__ccgo_up(_types + uintptr(uint64(6)*i+uint64(4))))) + **(**int64)(__ccgo_up(offset)) = int64(Int32FromUint32(_zi_read32(tls, _types+uintptr(uint64(6)*i)))) + **(**uintptr)(__ccgo_up(zonename)) = _abbrevs + uintptr(**(**uint8)(__ccgo_up(_types + uintptr(uint64(6)*i+uint64(5))))) if oppoff != 0 { - *(*int64)(unsafe.Pointer(oppoff)) = int64(Int32FromUint32(_zi_read32(tls, _types+uintptr(uint64(6)**(*Tsize_t)(unsafe.Pointer(bp)))))) + **(**int64)(__ccgo_up(oppoff)) = int64(Int32FromUint32(_zi_read32(tls, _types+uintptr(uint64(6)***(**Tsize_t)(__ccgo_up(bp)))))) } ___unlock(tls, uintptr(unsafe.Pointer(&_lock4))) return @@ -148945,23 +148945,23 @@ func X__secs_to_zone(tls *TLS, t int64, local int32, isdst uintptr, offset uintp goto std std: ; - *(*int32)(unsafe.Pointer(isdst)) = 0 - *(*int64)(unsafe.Pointer(offset)) = -Xtimezone + **(**int32)(__ccgo_up(isdst)) = 0 + **(**int64)(__ccgo_up(offset)) = -Xtimezone if oppoff != 0 { - *(*int64)(unsafe.Pointer(oppoff)) = int64(-_dst_off) + **(**int64)(__ccgo_up(oppoff)) = int64(-_dst_off) } - *(*uintptr)(unsafe.Pointer(zonename)) = Xtzname[0] + **(**uintptr)(__ccgo_up(zonename)) = Xtzname[0] ___unlock(tls, uintptr(unsafe.Pointer(&_lock4))) return goto dst dst: ; - *(*int32)(unsafe.Pointer(isdst)) = int32(1) - *(*int64)(unsafe.Pointer(offset)) = int64(-_dst_off) + **(**int32)(__ccgo_up(isdst)) = int32(1) + **(**int64)(__ccgo_up(offset)) = int64(-_dst_off) if oppoff != 0 { - *(*int64)(unsafe.Pointer(oppoff)) = -Xtimezone + **(**int64)(__ccgo_up(oppoff)) = -Xtimezone } - *(*uintptr)(unsafe.Pointer(zonename)) = Xtzname[int32(1)] + **(**uintptr)(__ccgo_up(zonename)) = Xtzname[int32(1)] ___unlock(tls, uintptr(unsafe.Pointer(&_lock4))) } @@ -149004,11 +149004,11 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { if !((y-Int32FromInt32(68))&Int32FromInt32(3) != 0) { leaps = leaps - 1 if is_leap != 0 { - *(*int32)(unsafe.Pointer(is_leap)) = int32(1) + **(**int32)(__ccgo_up(is_leap)) = int32(1) } } else { if is_leap != 0 { - *(*int32)(unsafe.Pointer(is_leap)) = 0 + **(**int32)(__ccgo_up(is_leap)) = 0 } } return int64(int32(31536000)*(y-int32(70)) + int32(86400)*leaps) @@ -149023,7 +149023,7 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { rem = rem + int32(400) } if !(rem != 0) { - *(*int32)(unsafe.Pointer(is_leap)) = int32(1) + **(**int32)(__ccgo_up(is_leap)) = int32(1) centuries = 0 leaps1 = 0 } else { @@ -149044,15 +149044,15 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { } } if !(rem != 0) { - *(*int32)(unsafe.Pointer(is_leap)) = 0 + **(**int32)(__ccgo_up(is_leap)) = 0 leaps1 = 0 } else { leaps1 = Int32FromUint32(Uint32FromInt32(rem) / uint32(4)) rem = Int32FromUint32(uint32(rem) % Uint32FromUint32(4)) - *(*int32)(unsafe.Pointer(is_leap)) = BoolInt32(!(rem != 0)) + **(**int32)(__ccgo_up(is_leap)) = BoolInt32(!(rem != 0)) } } - leaps1 = leaps1 + (int32(97)*cycles + int32(24)*centuries - *(*int32)(unsafe.Pointer(is_leap))) + leaps1 = leaps1 + (int32(97)*cycles + int32(24)*centuries - **(**int32)(__ccgo_up(is_leap))) return (year-int64(100))*int64(31536000) + int64(leaps1)*int64(86400) + int64(946684800) + int64(86400) } @@ -149081,7 +149081,7 @@ func X__asctime_r(tls *TLS, tm uintptr, buf uintptr) (r uintptr) { * application developers that they may not be so lucky * on other implementations (e.g. stack smashing..). */ - *(*int8)(unsafe.Pointer(UintptrFromInt32(0))) = 0 + **(**int8)(__ccgo_up(UintptrFromInt32(0))) = 0 } return buf } @@ -149114,10 +149114,10 @@ func Xclock(tls *TLS) (r Tclock_t) { if X__clock_gettime(tls, int32(CLOCK_PROCESS_CPUTIME_ID), bp) != 0 { return int64(-int32(1)) } - if (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec > Int64FromInt64(0x7fffffffffffffff)/Int64FromInt32(1000000) || (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_nsec/int64(1000) > int64(0x7fffffffffffffff)-int64(1000000)*(*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec { + if (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec > Int64FromInt64(0x7fffffffffffffff)/Int64FromInt32(1000000) || (**(**Ttimespec)(__ccgo_up(bp))).Ftv_nsec/int64(1000) > int64(0x7fffffffffffffff)-int64(1000000)*(**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec { return int64(-int32(1)) } - return (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec*int64(1000000) + (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_nsec/int64(1000) + return (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec*int64(1000000) + (**(**Ttimespec)(__ccgo_up(bp))).Ftv_nsec/int64(1000) } func Xclock_getcpuclockid(tls *TLS, pid Tpid_t, clk uintptr) (r int32) { @@ -149139,7 +149139,7 @@ func Xclock_getcpuclockid(tls *TLS, pid Tpid_t, clk uintptr) (r int32) { if ret != 0 { return -ret } - *(*Tclockid_t)(unsafe.Pointer(clk)) = id + **(**Tclockid_t)(__ccgo_up(clk)) = id return 0 } @@ -149269,8 +149269,8 @@ func Xftime(tls *TLS, tp uintptr) (r int32) { var _ /* ts at bp+0 */ Ttimespec _ = v1 Xclock_gettime(tls, CLOCK_REALTIME, bp) - (*Ttimeb)(unsafe.Pointer(tp)).Ftime = (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec - (*Ttimeb)(unsafe.Pointer(tp)).Fmillitm = Uint16FromInt64((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_nsec / int64(1000000)) + (*Ttimeb)(unsafe.Pointer(tp)).Ftime = (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec + (*Ttimeb)(unsafe.Pointer(tp)).Fmillitm = Uint16FromInt64((**(**Ttimespec)(__ccgo_up(bp))).Ftv_nsec / int64(1000000)) v1 = Int16FromInt32(0) (*Ttimeb)(unsafe.Pointer(tp)).Fdstflag = v1 (*Ttimeb)(unsafe.Pointer(tp)).Ftimezone = v1 @@ -149298,7 +149298,7 @@ func Xgetdate(tls *TLS, s uintptr) (r uintptr) { } f = Xfopen(tls, datemsk, __ccgo_ts+315) if !(f != 0) { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENOMEM) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENOMEM) { Xgetdate_err = int32(6) } else { Xgetdate_err = int32(2) @@ -149307,7 +149307,7 @@ func Xgetdate(tls *TLS, s uintptr) (r uintptr) { } for Xfgets(tls, bp, int32(100), f) != 0 { p = Xstrptime(tls, s, bp, uintptr(unsafe.Pointer(&_tmbuf))) - if p != 0 && !(*(*int8)(unsafe.Pointer(p)) != 0) { + if p != 0 && !(**(**int8)(__ccgo_up(p)) != 0) { ret = uintptr(unsafe.Pointer(&_tmbuf)) goto out } @@ -149323,7 +149323,7 @@ out: if f != 0 { Xfclose(tls, f) } - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 100)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 100)), uintptr(0)) return ret } @@ -149341,8 +149341,8 @@ func Xgettimeofday(tls *TLS, tv uintptr, tz uintptr) (r int32) { return 0 } Xclock_gettime(tls, CLOCK_REALTIME, bp) - (*Ttimeval)(unsafe.Pointer(tv)).Ftv_sec = (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec - (*Ttimeval)(unsafe.Pointer(tv)).Ftv_usec = int64(int32((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_nsec) / int32(1000)) + (*Ttimeval)(unsafe.Pointer(tv)).Ftv_sec = (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec + (*Ttimeval)(unsafe.Pointer(tv)).Ftv_usec = int64(int32((**(**Ttimespec)(__ccgo_up(bp))).Ftv_nsec) / int32(1000)) return 0 } @@ -149361,8 +149361,8 @@ func X__gmtime_r(tls *TLS, t uintptr, tm uintptr) (r uintptr) { trc("tls=%v t=%v tm=%v, (%v:)", tls, t, tm, origin(2)) defer func() { trc("-> %v", r) }() } - if X__secs_to_tm(tls, *(*Ttime_t)(unsafe.Pointer(t)), tm) < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + if X__secs_to_tm(tls, int64(**(**Ttime_t)(__ccgo_up(t))), tm) < 0 { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return uintptr(0) } (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst = 0 @@ -149405,13 +149405,13 @@ func X__localtime_r(tls *TLS, t uintptr, tm uintptr) (r uintptr) { } /* Reject time_t values whose year would overflow int because * __secs_to_zone cannot safely handle them. */ - if *(*Ttime_t)(unsafe.Pointer(t)) < int64(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff))*Int64FromInt64(31622400) || *(*Ttime_t)(unsafe.Pointer(t)) > Int64FromInt32(INT_MAX)*Int64FromInt64(31622400) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + if int64(**(**Ttime_t)(__ccgo_up(t))) < int64(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff))*Int64FromInt64(31622400) || int64(**(**Ttime_t)(__ccgo_up(t))) > Int64FromInt32(INT_MAX)*Int64FromInt64(31622400) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return uintptr(0) } - X__secs_to_zone(tls, *(*Ttime_t)(unsafe.Pointer(t)), 0, tm+32, tm+40, uintptr(0), tm+48) - if X__secs_to_tm(tls, *(*Ttime_t)(unsafe.Pointer(t))+(*Ttm)(unsafe.Pointer(tm)).F__tm_gmtoff, tm) < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + X__secs_to_zone(tls, int64(**(**Ttime_t)(__ccgo_up(t))), 0, tm+32, tm+40, uintptr(0), tm+48) + if X__secs_to_tm(tls, int64(**(**Ttime_t)(__ccgo_up(t)))+(*Ttm)(unsafe.Pointer(tm)).F__tm_gmtoff, tm) < 0 { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return uintptr(0) } return tm @@ -149447,23 +149447,23 @@ func Xmktime(tls *TLS, tm uintptr) (r Ttime_t) { _ = t t = X__tm_to_secs(tls, tm) X__secs_to_zone(tls, t, int32(1), bp+32, bp+40, bp+56, bp+48) - if (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst >= 0 && (*(*Ttm)(unsafe.Pointer(bp))).Ftm_isdst != (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst { - t = t - (*(*int64)(unsafe.Pointer(bp + 56)) - (*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff) + if (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst >= 0 && (**(**Ttm)(__ccgo_up(bp))).Ftm_isdst != (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst { + t = t - int64(**(**int64)(__ccgo_up(bp + 56))-(**(**Ttm)(__ccgo_up(bp))).F__tm_gmtoff) } - t = t - (*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff + t = t - int64((**(**Ttm)(__ccgo_up(bp))).F__tm_gmtoff) if t != t { goto error } X__secs_to_zone(tls, t, 0, bp+32, bp+40, bp+56, bp+48) - if X__secs_to_tm(tls, t+(*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff, bp) < 0 { + if X__secs_to_tm(tls, t+int64((**(**Ttm)(__ccgo_up(bp))).F__tm_gmtoff), bp) < 0 { goto error } - *(*Ttm)(unsafe.Pointer(tm)) = *(*Ttm)(unsafe.Pointer(bp)) + **(**Ttm)(__ccgo_up(tm)) = **(**Ttm)(__ccgo_up(bp)) return t goto error error: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return int64(-int32(1)) } @@ -149624,7 +149624,7 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc val = int64((*Ttm)(unsafe.Pointer(tm)).Ftm_min) goto number case int32('n'): - *(*Tsize_t)(unsafe.Pointer(l)) = uint64(1) + **(**Tsize_t)(__ccgo_up(l)) = uint64(1) return __ccgo_ts + 301 case int32('p'): if (*Ttm)(unsafe.Pointer(tm)).Ftm_hour >= int32(12) { @@ -149643,20 +149643,20 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc item = v1 fmt = X__nl_langinfo_l(tls, item, loc) d = s - *(*Tsize_t)(unsafe.Pointer(l)) = uint64(0) + **(**Tsize_t)(__ccgo_up(l)) = uint64(0) for { - if !(*(*int8)(unsafe.Pointer(fmt)) != 0) { + if !(**(**int8)(__ccgo_up(fmt)) != 0) { break } v4 = d d = d + 1 v5 = fmt fmt = fmt + 1 - *(*int8)(unsafe.Pointer(v4)) = int8(Xtolower(tls, int32(*(*int8)(unsafe.Pointer(v5))))) + **(**int8)(__ccgo_up(v4)) = int8(Xtolower(tls, int32(**(**int8)(__ccgo_up(v5))))) goto _3 _3: ; - *(*Tsize_t)(unsafe.Pointer(l)) = *(*Tsize_t)(unsafe.Pointer(l)) + 1 + **(**Tsize_t)(__ccgo_up(l)) = **(**Tsize_t)(__ccgo_up(l)) + 1 } return s case int32('r'): @@ -149673,7 +149673,7 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc val = int64((*Ttm)(unsafe.Pointer(tm)).Ftm_sec) goto number case int32('t'): - *(*Tsize_t)(unsafe.Pointer(l)) = uint64(1) + **(**Tsize_t)(__ccgo_up(l)) = uint64(1) return __ccgo_ts + 1390 case int32('T'): fmt = __ccgo_ts + 1822 @@ -149715,27 +149715,27 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc case int32('Y'): val = int64((*Ttm)(unsafe.Pointer(tm)).Ftm_year) + int64(1900) if val >= int64(10000) { - *(*Tsize_t)(unsafe.Pointer(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1831, VaList(bp+8, val))) + **(**Tsize_t)(__ccgo_up(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1831, VaList(bp+8, val))) return s } width = int32(4) goto number case int32('z'): if (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst < 0 { - *(*Tsize_t)(unsafe.Pointer(l)) = uint64(0) + **(**Tsize_t)(__ccgo_up(l)) = uint64(0) return __ccgo_ts } - *(*Tsize_t)(unsafe.Pointer(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1837, VaList(bp+8, (*Ttm)(unsafe.Pointer(tm)).F__tm_gmtoff/int64(3600)*int64(100)+(*Ttm)(unsafe.Pointer(tm)).F__tm_gmtoff%int64(3600)/int64(60)))) + **(**Tsize_t)(__ccgo_up(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1837, VaList(bp+8, (*Ttm)(unsafe.Pointer(tm)).F__tm_gmtoff/int64(3600)*int64(100)+(*Ttm)(unsafe.Pointer(tm)).F__tm_gmtoff%int64(3600)/int64(60)))) return s case int32('Z'): if (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst < 0 { - *(*Tsize_t)(unsafe.Pointer(l)) = uint64(0) + **(**Tsize_t)(__ccgo_up(l)) = uint64(0) return __ccgo_ts } fmt = X__tm_to_tzname(tls, tm) goto string case int32('%'): - *(*Tsize_t)(unsafe.Pointer(l)) = uint64(1) + **(**Tsize_t)(__ccgo_up(l)) = uint64(1) return __ccgo_ts + 348 default: return uintptr(0) @@ -149750,13 +149750,13 @@ number: } switch v1 { case int32('-'): - *(*Tsize_t)(unsafe.Pointer(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1844, VaList(bp+8, val))) + **(**Tsize_t)(__ccgo_up(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1844, VaList(bp+8, val))) case int32('_'): - *(*Tsize_t)(unsafe.Pointer(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1849, VaList(bp+8, width, val))) + **(**Tsize_t)(__ccgo_up(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1849, VaList(bp+8, width, val))) case int32('0'): fallthrough default: - *(*Tsize_t)(unsafe.Pointer(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1855, VaList(bp+8, width, val))) + **(**Tsize_t)(__ccgo_up(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1855, VaList(bp+8, width, val))) break } return s @@ -149767,7 +149767,7 @@ nl_strcat: goto string string: ; - *(*Tsize_t)(unsafe.Pointer(l)) = _strlen(tls, fmt) + **(**Tsize_t)(__ccgo_up(l)) = _strlen(tls, fmt) return fmt goto nl_strftime nl_strftime: @@ -149776,8 +149776,8 @@ nl_strftime: goto recu_strftime recu_strftime: ; - *(*Tsize_t)(unsafe.Pointer(l)) = X__strftime_l(tls, s, uint64(100), fmt, tm, loc) - if !(*(*Tsize_t)(unsafe.Pointer(l)) != 0) { + **(**Tsize_t)(__ccgo_up(l)) = X__strftime_l(tls, s, uint64(100), fmt, tm, loc) + if !(**(**Tsize_t)(__ccgo_up(l)) != 0) { return uintptr(0) } return s @@ -149804,46 +149804,46 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl if !(l < n) { break } - if !(*(*int8)(unsafe.Pointer(f)) != 0) { - *(*int8)(unsafe.Pointer(s + uintptr(l))) = 0 + if !(**(**int8)(__ccgo_up(f)) != 0) { + **(**int8)(__ccgo_up(s + uintptr(l))) = 0 return l } - if int32(*(*int8)(unsafe.Pointer(f))) != int32('%') { + if int32(**(**int8)(__ccgo_up(f))) != int32('%') { v2 = l l = l + 1 - *(*int8)(unsafe.Pointer(s + uintptr(v2))) = *(*int8)(unsafe.Pointer(f)) + **(**int8)(__ccgo_up(s + uintptr(v2))) = **(**int8)(__ccgo_up(f)) goto _1 } f = f + 1 pad = 0 - if int32(*(*int8)(unsafe.Pointer(f))) == int32('-') || int32(*(*int8)(unsafe.Pointer(f))) == int32('_') || int32(*(*int8)(unsafe.Pointer(f))) == int32('0') { + if int32(**(**int8)(__ccgo_up(f))) == int32('-') || int32(**(**int8)(__ccgo_up(f))) == int32('_') || int32(**(**int8)(__ccgo_up(f))) == int32('0') { v3 = f f = f + 1 - pad = int32(*(*int8)(unsafe.Pointer(v3))) + pad = int32(**(**int8)(__ccgo_up(v3))) } - v4 = BoolInt32(int32(*(*int8)(unsafe.Pointer(f))) == Int32FromUint8('+')) + v4 = BoolInt32(int32(**(**int8)(__ccgo_up(f))) == Int32FromUint8('+')) plus = v4 if v4 != 0 { f = f + 1 } - if BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(f)))-uint32('0') < uint32(10)) != 0 { + if BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(f)))-uint32('0') < uint32(10)) != 0 { width = Xstrtoul(tls, f, bp+112, int32(10)) } else { width = uint64(0) - *(*uintptr)(unsafe.Pointer(bp + 112)) = f + **(**uintptr)(__ccgo_up(bp + 112)) = f } - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 112))))) == int32('C') || int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 112))))) == int32('F') || int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 112))))) == int32('G') || int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 112))))) == int32('Y') { - if !(width != 0) && *(*uintptr)(unsafe.Pointer(bp + 112)) != f { + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 112))))) == int32('C') || int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 112))))) == int32('F') || int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 112))))) == int32('G') || int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 112))))) == int32('Y') { + if !(width != 0) && **(**uintptr)(__ccgo_up(bp + 112)) != f { width = uint64(1) } } else { width = uint64(0) } - f = *(*uintptr)(unsafe.Pointer(bp + 112)) - if int32(*(*int8)(unsafe.Pointer(f))) == int32('E') || int32(*(*int8)(unsafe.Pointer(f))) == int32('O') { + f = **(**uintptr)(__ccgo_up(bp + 112)) + if int32(**(**int8)(__ccgo_up(f))) == int32('E') || int32(**(**int8)(__ccgo_up(f))) == int32('O') { f = f + 1 } - t = X__strftime_fmt_1(tls, bp+8, bp, int32(*(*int8)(unsafe.Pointer(f))), tm, loc, pad) + t = X__strftime_fmt_1(tls, bp+8, bp, int32(**(**int8)(__ccgo_up(f))), tm, loc, pad) if !(t != 0) { break } @@ -149851,26 +149851,26 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl /* Trim off any sign and leading zeros, then * count remaining digits to determine behavior * for the + flag. */ - if int32(*(*int8)(unsafe.Pointer(t))) == int32('+') || int32(*(*int8)(unsafe.Pointer(t))) == int32('-') { + if int32(**(**int8)(__ccgo_up(t))) == int32('+') || int32(**(**int8)(__ccgo_up(t))) == int32('-') { t = t + 1 - *(*Tsize_t)(unsafe.Pointer(bp)) = *(*Tsize_t)(unsafe.Pointer(bp)) - 1 + **(**Tsize_t)(__ccgo_up(bp)) = **(**Tsize_t)(__ccgo_up(bp)) - 1 } for { - if !(int32(*(*int8)(unsafe.Pointer(t))) == int32('0') && Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(t + 1)))-int32('0')) < uint32(10)) { + if !(int32(**(**int8)(__ccgo_up(t))) == int32('0') && Uint32FromInt32(int32(**(**int8)(__ccgo_up(t + 1)))-int32('0')) < uint32(10)) { break } goto _5 _5: ; t = t + 1 - *(*Tsize_t)(unsafe.Pointer(bp)) = *(*Tsize_t)(unsafe.Pointer(bp)) - 1 + **(**Tsize_t)(__ccgo_up(bp)) = **(**Tsize_t)(__ccgo_up(bp)) - 1 } - if width < *(*Tsize_t)(unsafe.Pointer(bp)) { - width = *(*Tsize_t)(unsafe.Pointer(bp)) + if width < **(**Tsize_t)(__ccgo_up(bp)) { + width = **(**Tsize_t)(__ccgo_up(bp)) } d = uint64(0) for { - if !(Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(t + uintptr(d))))-int32('0')) < uint32(10)) { + if !(Uint32FromInt32(int32(**(**int8)(__ccgo_up(t + uintptr(d))))-int32('0')) < uint32(10)) { break } goto _6 @@ -149881,41 +149881,41 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl if (*Ttm)(unsafe.Pointer(tm)).Ftm_year < -int32(1900) { v2 = l l = l + 1 - *(*int8)(unsafe.Pointer(s + uintptr(v2))) = int8('-') + **(**int8)(__ccgo_up(s + uintptr(v2))) = int8('-') width = width - 1 } else { if v9 = plus != 0; v9 { - if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 112))))) == int32('C') { + if int32(**(**int8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 112))))) == int32('C') { v4 = int32(3) } else { v4 = int32(5) } } - if v9 && d+(width-*(*Tsize_t)(unsafe.Pointer(bp))) >= Uint64FromInt32(v4) { + if v9 && d+(width-**(**Tsize_t)(__ccgo_up(bp))) >= Uint64FromInt32(v4) { v2 = l l = l + 1 - *(*int8)(unsafe.Pointer(s + uintptr(v2))) = int8('+') + **(**int8)(__ccgo_up(s + uintptr(v2))) = int8('+') width = width - 1 } } for { - if !(width > *(*Tsize_t)(unsafe.Pointer(bp)) && l < n) { + if !(width > **(**Tsize_t)(__ccgo_up(bp)) && l < n) { break } v2 = l l = l + 1 - *(*int8)(unsafe.Pointer(s + uintptr(v2))) = int8('0') + **(**int8)(__ccgo_up(s + uintptr(v2))) = int8('0') goto _11 _11: ; width = width - 1 } } - if *(*Tsize_t)(unsafe.Pointer(bp)) > n-l { - *(*Tsize_t)(unsafe.Pointer(bp)) = n - l + if **(**Tsize_t)(__ccgo_up(bp)) > n-l { + **(**Tsize_t)(__ccgo_up(bp)) = n - l } - Xmemcpy(tls, s+uintptr(l), t, *(*Tsize_t)(unsafe.Pointer(bp))) - l = l + *(*Tsize_t)(unsafe.Pointer(bp)) + Xmemcpy(tls, s+uintptr(l), t, **(**Tsize_t)(__ccgo_up(bp))) + l = l + **(**Tsize_t)(__ccgo_up(bp)) goto _1 _1: ; @@ -149925,7 +149925,7 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl if l == n { l = n - uint64(1) } - *(*int8)(unsafe.Pointer(s + uintptr(l))) = 0 + **(**int8)(__ccgo_up(s + uintptr(l))) = 0 } return uint64(0) } @@ -149963,18 +149963,18 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { var _ /* relyear at bp+8 */ int32 _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = adj, dest, ex, i, len1, min, neg, range1, w, want_century, v1, v2, v5, v6, v8, v9 want_century = 0 - *(*int32)(unsafe.Pointer(bp + 4)) = 0 - *(*int32)(unsafe.Pointer(bp + 8)) = 0 - for *(*int8)(unsafe.Pointer(f)) != 0 { - if int32(*(*int8)(unsafe.Pointer(f))) != int32('%') { - v1 = int32(*(*int8)(unsafe.Pointer(f))) + **(**int32)(__ccgo_up(bp + 4)) = 0 + **(**int32)(__ccgo_up(bp + 8)) = 0 + for **(**int8)(__ccgo_up(f)) != 0 { + if int32(**(**int8)(__ccgo_up(f))) != int32('%') { + v1 = int32(**(**int8)(__ccgo_up(f))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _3 _3: if v2 != 0 { for { - if v8 = *(*int8)(unsafe.Pointer(s)) != 0; v8 { - v5 = int32(*(*int8)(unsafe.Pointer(s))) + if v8 = **(**int8)(__ccgo_up(s)) != 0; v8 { + v5 = int32(**(**int8)(__ccgo_up(s))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _7 _7: @@ -149988,7 +149988,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { s = s + 1 } } else { - if int32(*(*int8)(unsafe.Pointer(s))) != int32(*(*int8)(unsafe.Pointer(f))) { + if int32(**(**int8)(__ccgo_up(s))) != int32(**(**int8)(__ccgo_up(f))) { return uintptr(0) } else { s = s + 1 @@ -149998,19 +149998,19 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { continue } f = f + 1 - if int32(*(*int8)(unsafe.Pointer(f))) == int32('+') { + if int32(**(**int8)(__ccgo_up(f))) == int32('+') { f = f + 1 } - if BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(f)))-uint32('0') < uint32(10)) != 0 { + if BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(f)))-uint32('0') < uint32(10)) != 0 { w = Int32FromUint64(Xstrtoul(tls, f, bp+16, int32(10))) - f = *(*uintptr)(unsafe.Pointer(bp + 16)) + f = **(**uintptr)(__ccgo_up(bp + 16)) } else { w = -int32(1) } adj = 0 v9 = f f = f + 1 - switch int32(*(*int8)(unsafe.Pointer(v9))) { + switch int32(**(**int8)(__ccgo_up(v9))) { case int32('A'): goto _10 case int32('a'): @@ -150161,8 +150161,8 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { ; _44: ; - if v8 = *(*int8)(unsafe.Pointer(s)) != 0; v8 { - v1 = int32(*(*int8)(unsafe.Pointer(s))) + if v8 = **(**int8)(__ccgo_up(s)) != 0; v8 { + v1 = int32(**(**int8)(__ccgo_up(s))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _47 _47: @@ -150184,15 +150184,15 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { ex = Xnl_langinfo(tls, int32(AM_STR)) len1 = _strlen(tls, ex) if !(Xstrncasecmp(tls, s, ex, len1) != 0) { - *(*int32)(unsafe.Pointer(tm + 8)) %= int32(12) + **(**int32)(__ccgo_up(tm + 8)) %= int32(12) s = s + uintptr(len1) goto _41 } ex = Xnl_langinfo(tls, int32(PM_STR)) len1 = _strlen(tls, ex) if !(Xstrncasecmp(tls, s, ex, len1) != 0) { - *(*int32)(unsafe.Pointer(tm + 8)) %= int32(12) - *(*int32)(unsafe.Pointer(tm + 8)) += int32(12) + **(**int32)(__ccgo_up(tm + 8)) %= int32(12) + **(**int32)(__ccgo_up(tm + 8)) += int32(12) s = s + uintptr(len1) goto _41 } @@ -150272,7 +150272,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { ; v9 = s s = s + 1 - if int32(*(*int8)(unsafe.Pointer(v9))) != int32('%') { + if int32(**(**int8)(__ccgo_up(v9))) != int32('%') { return uintptr(0) } goto _41 @@ -150282,27 +150282,27 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { goto numeric_range numeric_range: ; - if !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + if !(BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } - *(*int32)(unsafe.Pointer(dest)) = 0 + **(**int32)(__ccgo_up(dest)) = 0 i = int32(1) for { - if !(i <= min+range1 && BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0) { + if !(i <= min+range1 && BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(s)))-uint32('0') < uint32(10)) != 0) { break } v9 = s s = s + 1 - *(*int32)(unsafe.Pointer(dest)) = *(*int32)(unsafe.Pointer(dest))*int32(10) + int32(*(*int8)(unsafe.Pointer(v9))) - int32('0') + **(**int32)(__ccgo_up(dest)) = **(**int32)(__ccgo_up(dest))*int32(10) + int32(**(**int8)(__ccgo_up(v9))) - int32('0') goto _50 _50: ; i = i * int32(10) } - if Uint32FromInt32(*(*int32)(unsafe.Pointer(dest))-min) >= Uint32FromInt32(range1) { + if Uint32FromInt32(**(**int32)(__ccgo_up(dest))-min) >= Uint32FromInt32(range1) { return uintptr(0) } - *(*int32)(unsafe.Pointer(dest)) -= adj + **(**int32)(__ccgo_up(dest)) -= adj switch int64(dest) - int64(tm) { case Int64FromUint64(uint64(UintptrFromInt32(0) + 28)): } @@ -150311,36 +150311,36 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { numeric_digits: ; neg = 0 - if int32(*(*int8)(unsafe.Pointer(s))) == int32('+') { + if int32(**(**int8)(__ccgo_up(s))) == int32('+') { s = s + 1 } else { - if int32(*(*int8)(unsafe.Pointer(s))) == int32('-') { + if int32(**(**int8)(__ccgo_up(s))) == int32('-') { neg = int32(1) s = s + 1 } } - if !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + if !(BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } v1 = Int32FromInt32(0) i = v1 - *(*int32)(unsafe.Pointer(dest)) = v1 + **(**int32)(__ccgo_up(dest)) = v1 for { - if !(i < w && BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0) { + if !(i < w && BoolInt32(Uint32FromInt8(**(**int8)(__ccgo_up(s)))-uint32('0') < uint32(10)) != 0) { break } v9 = s s = s + 1 - *(*int32)(unsafe.Pointer(dest)) = *(*int32)(unsafe.Pointer(dest))*int32(10) + int32(*(*int8)(unsafe.Pointer(v9))) - int32('0') + **(**int32)(__ccgo_up(dest)) = **(**int32)(__ccgo_up(dest))*int32(10) + int32(**(**int8)(__ccgo_up(v9))) - int32('0') goto _52 _52: ; i = i + 1 } if neg != 0 { - *(*int32)(unsafe.Pointer(dest)) = -*(*int32)(unsafe.Pointer(dest)) + **(**int32)(__ccgo_up(dest)) = -**(**int32)(__ccgo_up(dest)) } - *(*int32)(unsafe.Pointer(dest)) -= adj + **(**int32)(__ccgo_up(dest)) -= adj goto update goto symbolic_range symbolic_range: @@ -150356,7 +150356,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { goto _55 } s = s + uintptr(len1) - *(*int32)(unsafe.Pointer(dest)) = i % range1 + **(**int32)(__ccgo_up(dest)) = i % range1 break goto _55 _55: @@ -150374,12 +150374,12 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { _41: } if want_century != 0 { - (*Ttm)(unsafe.Pointer(tm)).Ftm_year = *(*int32)(unsafe.Pointer(bp + 8)) + (*Ttm)(unsafe.Pointer(tm)).Ftm_year = **(**int32)(__ccgo_up(bp + 8)) if want_century&int32(2) != 0 { - *(*int32)(unsafe.Pointer(tm + 20)) += *(*int32)(unsafe.Pointer(bp + 4))*int32(100) - int32(1900) + **(**int32)(__ccgo_up(tm + 20)) += **(**int32)(__ccgo_up(bp + 4))*int32(100) - int32(1900) } else { if (*Ttm)(unsafe.Pointer(tm)).Ftm_year <= int32(68) { - *(*int32)(unsafe.Pointer(tm + 20)) += int32(100) + **(**int32)(__ccgo_up(tm + 20)) += int32(100) } } } @@ -150396,9 +150396,9 @@ func Xtime(tls *TLS, t uintptr) (r Ttime_t) { var _ /* ts at bp+0 */ Ttimespec X__clock_gettime(tls, CLOCK_REALTIME, bp) if t != 0 { - *(*Ttime_t)(unsafe.Pointer(t)) = (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec + **(**Ttime_t)(__ccgo_up(t)) = (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec } - return (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec + return (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec } func Xtimegm(tls *TLS, tm uintptr) (r Ttime_t) { @@ -150413,10 +150413,10 @@ func Xtimegm(tls *TLS, tm uintptr) (r Ttime_t) { _ = t t = X__tm_to_secs(tls, tm) if X__secs_to_tm(tls, t, bp) < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return int64(-int32(1)) } - *(*Ttm1)(unsafe.Pointer(tm)) = *(*Ttm1)(unsafe.Pointer(bp)) + **(**Ttm1)(__ccgo_up(tm)) = **(**Ttm1)(__ccgo_up(bp)) (*Ttm1)(unsafe.Pointer(tm)).Ftm_isdst = 0 (*Ttm1)(unsafe.Pointer(tm)).Ftm_gmtoff = 0 (*Ttm1)(unsafe.Pointer(tm)).Ftm_zone = uintptr(unsafe.Pointer(&X__utc)) @@ -150574,92 +150574,92 @@ func X__wcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl if !(l < n) { break } - if !(*(*Twchar_t)(unsafe.Pointer(f)) != 0) { - *(*Twchar_t)(unsafe.Pointer(s + uintptr(l)*4)) = 0 + if !(**(**Twchar_t)(__ccgo_up(f)) != 0) { + **(**Twchar_t)(__ccgo_up(s + uintptr(l)*4)) = 0 return l } - if *(*Twchar_t)(unsafe.Pointer(f)) != int32('%') { + if **(**Twchar_t)(__ccgo_up(f)) != int32('%') { v2 = l l = l + 1 - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = *(*Twchar_t)(unsafe.Pointer(f)) + **(**Twchar_t)(__ccgo_up(s + uintptr(v2)*4)) = **(**Twchar_t)(__ccgo_up(f)) goto _1 } f += 4 pad = 0 - if *(*Twchar_t)(unsafe.Pointer(f)) == int32('-') || *(*Twchar_t)(unsafe.Pointer(f)) == int32('_') || *(*Twchar_t)(unsafe.Pointer(f)) == int32('0') { + if **(**Twchar_t)(__ccgo_up(f)) == int32('-') || **(**Twchar_t)(__ccgo_up(f)) == int32('_') || **(**Twchar_t)(__ccgo_up(f)) == int32('0') { v3 = f f += 4 - pad = *(*Twchar_t)(unsafe.Pointer(v3)) + pad = **(**Twchar_t)(__ccgo_up(v3)) } - v4 = BoolInt32(*(*Twchar_t)(unsafe.Pointer(f)) == Int32FromUint8('+')) + v4 = BoolInt32(**(**Twchar_t)(__ccgo_up(f)) == Int32FromUint8('+')) plus = v4 if v4 != 0 { f += 4 } width = Xwcstoul(tls, f, bp+512, int32(10)) - if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 512)))) == int32('C') || *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 512)))) == int32('F') || *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 512)))) == int32('G') || *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 512)))) == int32('Y') { - if !(width != 0) && *(*uintptr)(unsafe.Pointer(bp + 512)) != f { + if **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 512)))) == int32('C') || **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 512)))) == int32('F') || **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 512)))) == int32('G') || **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 512)))) == int32('Y') { + if !(width != 0) && **(**uintptr)(__ccgo_up(bp + 512)) != f { width = uint64(1) } } else { width = uint64(0) } - f = *(*uintptr)(unsafe.Pointer(bp + 512)) - if *(*Twchar_t)(unsafe.Pointer(f)) == int32('E') || *(*Twchar_t)(unsafe.Pointer(f)) == int32('O') { + f = **(**uintptr)(__ccgo_up(bp + 512)) + if **(**Twchar_t)(__ccgo_up(f)) == int32('E') || **(**Twchar_t)(__ccgo_up(f)) == int32('O') { f += 4 } - t_mb = X__strftime_fmt_1(tls, bp+8, bp, *(*Twchar_t)(unsafe.Pointer(f)), tm, loc, pad) + t_mb = X__strftime_fmt_1(tls, bp+8, bp, **(**Twchar_t)(__ccgo_up(f)), tm, loc, pad) if !(t_mb != 0) { break } - *(*Tsize_t)(unsafe.Pointer(bp)) = Xmbstowcs(tls, bp+108, t_mb, Uint64FromInt64(400)/Uint64FromInt64(4)) - if *(*Tsize_t)(unsafe.Pointer(bp)) == Uint64FromInt32(-Int32FromInt32(1)) { + **(**Tsize_t)(__ccgo_up(bp)) = Xmbstowcs(tls, bp+108, t_mb, Uint64FromInt64(400)/Uint64FromInt64(4)) + if **(**Tsize_t)(__ccgo_up(bp)) == Uint64FromInt32(-Int32FromInt32(1)) { return uint64(0) } t = bp + 108 if width != 0 { for { - if !(*(*Twchar_t)(unsafe.Pointer(t)) == int32('+') || *(*Twchar_t)(unsafe.Pointer(t)) == int32('-') || *(*Twchar_t)(unsafe.Pointer(t)) == int32('0') && *(*Twchar_t)(unsafe.Pointer(t + 1*4)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(t)) == int32('+') || **(**Twchar_t)(__ccgo_up(t)) == int32('-') || **(**Twchar_t)(__ccgo_up(t)) == int32('0') && **(**Twchar_t)(__ccgo_up(t + 1*4)) != 0) { break } goto _5 _5: ; t += 4 - *(*Tsize_t)(unsafe.Pointer(bp)) = *(*Tsize_t)(unsafe.Pointer(bp)) - 1 + **(**Tsize_t)(__ccgo_up(bp)) = **(**Tsize_t)(__ccgo_up(bp)) - 1 } width = width - 1 if plus != 0 && (*Ttm)(unsafe.Pointer(tm)).Ftm_year >= Int32FromInt32(10000)-Int32FromInt32(1900) { v2 = l l = l + 1 - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = int32('+') + **(**Twchar_t)(__ccgo_up(s + uintptr(v2)*4)) = int32('+') } else { if (*Ttm)(unsafe.Pointer(tm)).Ftm_year < -int32(1900) { v2 = l l = l + 1 - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = int32('-') + **(**Twchar_t)(__ccgo_up(s + uintptr(v2)*4)) = int32('-') } else { width = width + 1 } } for { - if !(width > *(*Tsize_t)(unsafe.Pointer(bp)) && l < n) { + if !(width > **(**Tsize_t)(__ccgo_up(bp)) && l < n) { break } v2 = l l = l + 1 - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = int32('0') + **(**Twchar_t)(__ccgo_up(s + uintptr(v2)*4)) = int32('0') goto _8 _8: ; width = width - 1 } } - if *(*Tsize_t)(unsafe.Pointer(bp)) >= n-l { - *(*Tsize_t)(unsafe.Pointer(bp)) = n - l + if **(**Tsize_t)(__ccgo_up(bp)) >= n-l { + **(**Tsize_t)(__ccgo_up(bp)) = n - l } - Xwmemcpy(tls, s+uintptr(l)*4, t, *(*Tsize_t)(unsafe.Pointer(bp))) - l = l + *(*Tsize_t)(unsafe.Pointer(bp)) + Xwmemcpy(tls, s+uintptr(l)*4, t, **(**Tsize_t)(__ccgo_up(bp))) + l = l + **(**Tsize_t)(__ccgo_up(bp)) goto _1 _1: ; @@ -150669,7 +150669,7 @@ func X__wcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl if l == n { l = n - uint64(1) } - *(*Twchar_t)(unsafe.Pointer(s + uintptr(l)*4)) = 0 + **(**Twchar_t)(__ccgo_up(s + uintptr(l)*4)) = 0 } return uint64(0) } @@ -150722,14 +150722,14 @@ func Xalarm(tls *TLS, seconds uint32) (r uint32) { defer tls.Free(64) var _ /* it at bp+0 */ Titimerval var _ /* old at bp+32 */ Titimerval - *(*Titimerval)(unsafe.Pointer(bp)) = Titimerval{ + **(**Titimerval)(__ccgo_up(bp)) = Titimerval{ Fit_value: Ttimeval{ Ftv_sec: Int64FromUint32(seconds), }, } - *(*Titimerval)(unsafe.Pointer(bp + 32)) = Titimerval{} + **(**Titimerval)(__ccgo_up(bp + 32)) = Titimerval{} Xsetitimer(tls, ITIMER_REAL, bp, bp+32) - return Uint32FromInt64((*(*Titimerval)(unsafe.Pointer(bp + 32))).Fit_value.Ftv_sec + BoolInt64(!!((*(*Titimerval)(unsafe.Pointer(bp + 32))).Fit_value.Ftv_usec != 0))) + return Uint32FromInt64((**(**Titimerval)(__ccgo_up(bp + 32))).Fit_value.Ftv_sec + BoolInt64(!!((**(**Titimerval)(__ccgo_up(bp + 32))).Fit_value.Ftv_usec != 0))) } func Xchdir(tls *TLS, path uintptr) (r int32) { @@ -150856,7 +150856,7 @@ func _checker(tls *TLS, p uintptr) (r int32) { if X__syscall2(tls, int64(SYS_setregid), X__syscall0(tls, int64(SYS_getegid)), int64(-Int32FromInt32(1))) != 0 || X__syscall2(tls, int64(SYS_setreuid), X__syscall0(tls, int64(SYS_geteuid)), int64(-Int32FromInt32(1))) != 0 { X__syscall1(tls, int64(SYS_exit), int64(Int32FromInt32(1))) } - *(*int32)(unsafe.Pointer(bp)) = int32(X__syscall4(tls, int64(SYS_faccessat), int64((*Tctx1)(unsafe.Pointer(c)).Ffd), int64((*Tctx1)(unsafe.Pointer(c)).Ffilename), int64((*Tctx1)(unsafe.Pointer(c)).Famode), int64(Int32FromInt32(0)))) + **(**int32)(__ccgo_up(bp)) = int32(X__syscall4(tls, int64(SYS_faccessat), int64((*Tctx1)(unsafe.Pointer(c)).Ffd), int64((*Tctx1)(unsafe.Pointer(c)).Ffilename), int64((*Tctx1)(unsafe.Pointer(c)).Famode), int64(Int32FromInt32(0)))) X__syscall3(tls, int64(SYS_write), int64((*Tctx1)(unsafe.Pointer(c)).Fp), int64(bp), Int64FromUint64(Uint64FromInt64(4))) return 0 } @@ -150971,7 +150971,7 @@ func Xgetcwd(tls *TLS, buf uintptr, size Tsize_t) (r uintptr) { size = v1 } else { if !(size != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } } @@ -150979,8 +150979,8 @@ func Xgetcwd(tls *TLS, buf uintptr, size Tsize_t) (r uintptr) { if ret < 0 { return uintptr(0) } - if ret == 0 || int32(*(*int8)(unsafe.Pointer(buf))) != int32('/') { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOENT) + if ret == 0 || int32(**(**int8)(__ccgo_up(buf))) != int32('/') { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOENT) return uintptr(0) } if buf == tmp { @@ -151044,8 +151044,8 @@ func Xgethostname(tls *TLS, name uintptr, len1 Tsize_t) (r int32) { i = uint64(0) for { if v3 = i < len1; v3 { - v2 = *(*int8)(unsafe.Pointer(bp + 65 + uintptr(i))) - *(*int8)(unsafe.Pointer(name + uintptr(i))) = v2 + v2 = **(**int8)(__ccgo_up(bp + 65 + uintptr(i))) + **(**int8)(__ccgo_up(name + uintptr(i))) = v2 } if !(v3 && v2 != 0) { break @@ -151056,7 +151056,7 @@ func Xgethostname(tls *TLS, name uintptr, len1 Tsize_t) (r int32) { i = i + 1 } if i != 0 && i == len1 { - *(*int8)(unsafe.Pointer(name + uintptr(i-uint64(1)))) = 0 + **(**int8)(__ccgo_up(name + uintptr(i-uint64(1)))) = 0 } return 0 } @@ -151149,8 +151149,8 @@ func Xisatty(tls *TLS, fd int32) (r1 int32) { if r == uint64(0) { return int32(1) } - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(EBADF) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOTTY) + if **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(EBADF) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOTTY) } return 0 } @@ -151215,8 +151215,8 @@ func Xnice(tls *TLS, inc int32) (r int32) { prio = -int32(NZERO) } if Xsetpriority(tls, PRIO_PROCESS, uint32(0), prio) != 0 { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EACCES) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EPERM) + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EACCES) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EPERM) } return -int32(1) } else { @@ -151263,12 +151263,12 @@ func Xpipe2(tls *TLS, fd uintptr, flag int32) (r int32) { return ret } if flag&int32(O_CLOEXEC) != 0 { - X__syscall3(tls, int64(__NR3264_fcntl), int64(*(*int32)(unsafe.Pointer(fd))), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) - X__syscall3(tls, int64(__NR3264_fcntl), int64(*(*int32)(unsafe.Pointer(fd + 1*4))), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) + X__syscall3(tls, int64(__NR3264_fcntl), int64(**(**int32)(__ccgo_up(fd))), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) + X__syscall3(tls, int64(__NR3264_fcntl), int64(**(**int32)(__ccgo_up(fd + 1*4))), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) } if flag&int32(O_NONBLOCK) != 0 { - X__syscall3(tls, int64(__NR3264_fcntl), int64(*(*int32)(unsafe.Pointer(fd))), int64(Int32FromInt32(F_SETFL)), int64(Int32FromInt32(O_NONBLOCK))) - X__syscall3(tls, int64(__NR3264_fcntl), int64(*(*int32)(unsafe.Pointer(fd + 1*4))), int64(Int32FromInt32(F_SETFL)), int64(Int32FromInt32(O_NONBLOCK))) + X__syscall3(tls, int64(__NR3264_fcntl), int64(**(**int32)(__ccgo_up(fd))), int64(Int32FromInt32(F_SETFL)), int64(Int32FromInt32(O_NONBLOCK))) + X__syscall3(tls, int64(__NR3264_fcntl), int64(**(**int32)(__ccgo_up(fd + 1*4))), int64(Int32FromInt32(F_SETFL)), int64(Int32FromInt32(O_NONBLOCK))) } return 0 } @@ -151467,7 +151467,7 @@ func X__setxid(tls *TLS, nr int32, id int32, eid int32, sid int32) (r int32) { _ = v1 /* ret is initially nonzero so that failure of the first thread does not * trigger the safety kill above. */ - *(*Tctx2)(unsafe.Pointer(bp)) = Tctx2{ + **(**Tctx2)(__ccgo_up(bp)) = Tctx2{ Fid: id, Feid: eid, Fsid: sid, @@ -151475,10 +151475,10 @@ func X__setxid(tls *TLS, nr int32, id int32, eid int32, sid int32) (r int32) { Fret: int32(1), } ___synccall(tls, __ccgo_fp(_do_setxid), bp) - if (*(*Tctx2)(unsafe.Pointer(bp))).Fret > 0 { + if (**(**Tctx2)(__ccgo_up(bp))).Fret > 0 { v1 = -int32(EAGAIN) } else { - v1 = (*(*Tctx2)(unsafe.Pointer(bp))).Fret + v1 = (**(**Tctx2)(__ccgo_up(bp))).Fret } return int32(X__syscall_ret(tls, Uint64FromInt32(v1))) } @@ -151491,11 +151491,11 @@ func Xsleep(tls *TLS, seconds uint32) (r uint32) { bp := tls.Alloc(16) defer tls.Free(16) var _ /* tv at bp+0 */ Ttimespec - *(*Ttimespec)(unsafe.Pointer(bp)) = Ttimespec{ + **(**Ttimespec)(__ccgo_up(bp)) = Ttimespec{ Ftv_sec: Int64FromUint32(seconds), } if Xnanosleep(tls, bp, bp) != 0 { - return Uint32FromInt64((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec) + return Uint32FromInt64((**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec) } return uint32(0) } @@ -151534,7 +151534,7 @@ func Xtcgetpgrp(tls *TLS, fd int32) (r Tpid_t) { if Xioctl(tls, fd, int32(TIOCGPGRP), VaList(bp+16, bp)) < 0 { return -int32(1) } - return *(*int32)(unsafe.Pointer(bp)) + return **(**int32)(__ccgo_up(bp)) } func Xtcsetpgrp(tls *TLS, fd int32, pgrp Tpid_t) (r int32) { @@ -151545,7 +151545,7 @@ func Xtcsetpgrp(tls *TLS, fd int32, pgrp Tpid_t) (r int32) { bp := tls.Alloc(32) defer tls.Free(32) var _ /* pgrp_int at bp+0 */ int32 - *(*int32)(unsafe.Pointer(bp)) = pgrp + **(**int32)(__ccgo_up(bp)) = pgrp return Xioctl(tls, fd, int32(TIOCSPGRP), VaList(bp+16, bp)) } @@ -151576,7 +151576,7 @@ func Xttyname(tls *TLS, fd int32) (r uintptr) { v1 = Xttyname_r(tls, fd, uintptr(unsafe.Pointer(&_buf10)), uint64(32)) result = v1 if v1 != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = result + **(**int32)(__ccgo_up(X__errno_location(tls))) = result return UintptrFromInt32(0) } return uintptr(unsafe.Pointer(&_buf10)) @@ -151597,22 +151597,22 @@ func Xttyname_r(tls *TLS, fd int32, name uintptr, size Tsize_t) (r int32) { var _ /* st2 at bp+128 */ Tstat _ = l if !(Xisatty(tls, fd) != 0) { - return *(*int32)(unsafe.Pointer(X__errno_location(tls))) + return **(**int32)(__ccgo_up(X__errno_location(tls))) } X__procfdname(tls, bp+256, Uint32FromInt32(fd)) l = Xreadlink(tls, bp+256, name, size) if l < 0 { - return *(*int32)(unsafe.Pointer(X__errno_location(tls))) + return **(**int32)(__ccgo_up(X__errno_location(tls))) } else { if Uint64FromInt64(l) == size { return int32(ERANGE) } } - *(*int8)(unsafe.Pointer(name + uintptr(l))) = 0 + **(**int8)(__ccgo_up(name + uintptr(l))) = 0 if Xstat(tls, name, bp) != 0 || Xfstat(tls, fd, bp+128) != 0 { - return *(*int32)(unsafe.Pointer(X__errno_location(tls))) + return **(**int32)(__ccgo_up(X__errno_location(tls))) } - if (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev != (*(*Tstat)(unsafe.Pointer(bp + 128))).Fst_dev || (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino != (*(*Tstat)(unsafe.Pointer(bp + 128))).Fst_ino { + if (**(**Tstat)(__ccgo_up(bp))).Fst_dev != (**(**Tstat)(__ccgo_up(bp + 128))).Fst_dev || (**(**Tstat)(__ccgo_up(bp))).Fst_ino != (**(**Tstat)(__ccgo_up(bp + 128))).Fst_ino { return int32(ENODEV) } return 0 @@ -151627,7 +151627,7 @@ func Xualarm(tls *TLS, value uint32, interval uint32) (r uint32) { defer tls.Free(64) var _ /* it at bp+0 */ Titimerval var _ /* it_old at bp+32 */ Titimerval - *(*Titimerval)(unsafe.Pointer(bp)) = Titimerval{ + **(**Titimerval)(__ccgo_up(bp)) = Titimerval{ Fit_interval: Ttimeval{ Ftv_usec: Int64FromUint32(interval), }, @@ -151636,7 +151636,7 @@ func Xualarm(tls *TLS, value uint32, interval uint32) (r uint32) { }, } Xsetitimer(tls, ITIMER_REAL, bp, bp+32) - return Uint32FromInt64((*(*Titimerval)(unsafe.Pointer(bp + 32))).Fit_value.Ftv_sec*int64(1000000) + (*(*Titimerval)(unsafe.Pointer(bp + 32))).Fit_value.Ftv_usec) + return Uint32FromInt64((**(**Titimerval)(__ccgo_up(bp + 32))).Fit_value.Ftv_sec*int64(1000000) + (**(**Titimerval)(__ccgo_up(bp + 32))).Fit_value.Ftv_usec) } func Xunlink(tls *TLS, path uintptr) (r int32) { @@ -151663,7 +151663,7 @@ func Xusleep(tls *TLS, useconds uint32) (r int32) { bp := tls.Alloc(16) defer tls.Free(16) var _ /* tv at bp+0 */ Ttimespec - *(*Ttimespec)(unsafe.Pointer(bp)) = Ttimespec{ + **(**Ttimespec)(__ccgo_up(bp)) = Ttimespec{ Ftv_sec: Int64FromUint32(useconds / uint32(1000000)), Ftv_nsec: Int64FromUint32(useconds % uint32(1000000) * uint32(1000)), } @@ -151691,6 +151691,10 @@ func __ccgo_fp(f interface{}) uintptr { return (*iface)(unsafe.Pointer(&f))[1] } +func __ccgo_up(n uintptr) unsafe.Pointer { + return unsafe.Pointer(&n) +} + var X__abort_lock [1]int32 var X__at_quick_exit_lockptr = uintptr(unsafe.Pointer(&_lock)) diff --git a/vendor/modernc.org/libc/ccgo_linux_ppc64le.go b/vendor/modernc.org/libc/ccgo_linux_ppc64le.go index f5b3d69c84..87cd1552d4 100644 --- a/vendor/modernc.org/libc/ccgo_linux_ppc64le.go +++ b/vendor/modernc.org/libc/ccgo_linux_ppc64le.go @@ -613,7 +613,7 @@ func ___frexp_exp(tls *TLS, x float64, expt uintptr) (r float64) { */ exp_x = Xexp(tls, x-_kln2) hx = uint32(*(*Tuint64_t)(unsafe.Pointer(&exp_x)) >> int32(32)) - *(*int32)(unsafe.Pointer(expt)) = Int32FromUint32(hx>>Int32FromInt32(20) - Uint32FromInt32(Int32FromInt32(0x3ff)+Int32FromInt32(1023)) + _k) + **(**int32)(__ccgo_up(expt)) = Int32FromUint32(hx>>Int32FromInt32(20) - Uint32FromInt32(Int32FromInt32(0x3ff)+Int32FromInt32(1023)) + _k) v1 = uint64(hx&Uint32FromInt32(0xfffff)|Uint32FromInt32((Int32FromInt32(0x3ff)+Int32FromInt32(1023))<>Int32FromInt32(23) - Uint32FromInt32(Int32FromInt32(0x7f)+Int32FromInt32(127)) + _k1) + **(**int32)(__ccgo_up(expt)) = Int32FromUint32(hx>>Int32FromInt32(23) - Uint32FromInt32(Int32FromInt32(0x7f)+Int32FromInt32(127)) + _k1) v1 = hx&uint32(0x7fffff) | Uint32FromInt32((Int32FromInt32(0x7f)+Int32FromInt32(127))< uint32(35) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uint64(0) } } @@ -3344,7 +3344,7 @@ func Xfpathconf(tls *TLS, fd int32, name int32) (r int64) { defer func() { trc("-> %v", r) }() } if Uint64FromInt32(name) >= Uint64FromInt64(42)/Uint64FromInt64(2) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) } return int64(_values[name]) @@ -7610,7 +7610,7 @@ func Xsysconf(tls *TLS, name int32) (r int64) { var _ /* si at bp+144 */ Tsysinfo _, _, _, _, _, _, _ = cnt, i, mem, val, v1, v3, v5 if Uint64FromInt32(name) >= Uint64FromInt64(502)/Uint64FromInt64(2) || !(_values1[name] != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) } else { if int32(_values1[name]) >= -int32(1) { @@ -7618,13 +7618,13 @@ func Xsysconf(tls *TLS, name int32) (r int64) { } else { if int32(_values1[name]) < -int32(256) { Xgetrlimit(tls, int32(_values1[name])&int32(16383), bp) - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur == ^Uint64FromUint64(0) { + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur == ^Uint64FromUint64(0) { return int64(-int32(1)) } - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur > uint64(0x7fffffffffffffff) { + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur > uint64(0x7fffffffffffffff) { v1 = uint64(0x7fffffffffffffff) } else { - v1 = (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur + v1 = (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur } return Int64FromUint64(v1) } @@ -7646,7 +7646,7 @@ func Xsysconf(tls *TLS, name int32) (r int64) { case (-Int32FromInt32(256) | Int32FromInt32(6)) & Int32FromInt32(255): fallthrough case (-Int32FromInt32(256) | Int32FromInt32(7)) & Int32FromInt32(255): - *(*[128]uint8)(unsafe.Pointer(bp + 16)) = [128]uint8{ + **(**[128]uint8)(__ccgo_up(bp + 16)) = [128]uint8{ 0: uint8(1), } X__syscall3(tls, int64(SYS_sched_getaffinity), int64(Int32FromInt32(0)), Int64FromUint64(Uint64FromInt64(128)), int64(bp+16)) @@ -7658,14 +7658,14 @@ func Xsysconf(tls *TLS, name int32) (r int64) { break } for { - if !((*(*[128]uint8)(unsafe.Pointer(bp + 16)))[i] != 0) { + if !((**(**[128]uint8)(__ccgo_up(bp + 16)))[i] != 0) { break } goto _4 _4: ; v5 = bp + 16 + uintptr(i) - *(*uint8)(unsafe.Pointer(v5)) = uint8(int32(*(*uint8)(unsafe.Pointer(v5))) & (Int32FromUint8((*(*[128]uint8)(unsafe.Pointer(bp + 16)))[i]) - Int32FromInt32(1))) + *(*uint8)(unsafe.Pointer(v5)) = uint8(int32(*(*uint8)(unsafe.Pointer(v5))) & (Int32FromUint8((**(**[128]uint8)(__ccgo_up(bp + 16)))[i]) - Int32FromInt32(1))) cnt = cnt + 1 } goto _2 @@ -7678,15 +7678,15 @@ func Xsysconf(tls *TLS, name int32) (r int64) { fallthrough case (-Int32FromInt32(256) | Int32FromInt32(9)) & Int32FromInt32(255): X__lsysinfo(tls, bp+144) - if !((*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fmem_unit != 0) { - (*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fmem_unit = uint32(1) + if !((**(**Tsysinfo)(__ccgo_up(bp + 144))).Fmem_unit != 0) { + (**(**Tsysinfo)(__ccgo_up(bp + 144))).Fmem_unit = uint32(1) } if name == int32(_SC_PHYS_PAGES) { - mem = (*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Ftotalram + mem = uint64((**(**Tsysinfo)(__ccgo_up(bp + 144))).Ftotalram) } else { - mem = (*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Ffreeram + (*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fbufferram + mem = uint64((**(**Tsysinfo)(__ccgo_up(bp + 144))).Ffreeram + (**(**Tsysinfo)(__ccgo_up(bp + 144))).Fbufferram) } - mem = mem * uint64((*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fmem_unit) + mem = mem * uint64((**(**Tsysinfo)(__ccgo_up(bp + 144))).Fmem_unit) mem = mem / X__libc.Fpage_size if mem > uint64(0x7fffffffffffffff) { v1 = uint64(0x7fffffffffffffff) @@ -9086,7 +9086,7 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { for cond := true; cond; cond = dptr < end { v1 = sptr sptr = sptr + 1 - tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = uint32(**(**uint8)(__ccgo_up(v1))) tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) @@ -9098,7 +9098,7 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { c1 = tmp v1 = sptr sptr = sptr + 1 - tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = uint32(**(**uint8)(__ccgo_up(v1))) tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) @@ -9110,13 +9110,13 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { c2 = tmp v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(c1<>int32(4)) + **(**uint8)(__ccgo_up(v1)) = uint8(c1<>int32(4)) if dptr >= end { break } v1 = sptr sptr = sptr + 1 - tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = uint32(**(**uint8)(__ccgo_up(v1))) tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) @@ -9128,13 +9128,13 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { c3 = tmp v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(c2&uint32(0x0F)<>int32(2)) + **(**uint8)(__ccgo_up(v1)) = uint8(c2&uint32(0x0F)<>int32(2)) if dptr >= end { break } v1 = sptr sptr = sptr + 1 - tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = uint32(**(**uint8)(__ccgo_up(v1))) tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) @@ -9146,7 +9146,7 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { c4 = tmp v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(c3&uint32(0x03)<>int32(2)] + **(**uint8)(__ccgo_up(v1)) = _BF_itoa64[c1>>int32(2)] c1 = c1 & uint32(0x03) << int32(4) if sptr >= end { v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] + **(**uint8)(__ccgo_up(v1)) = _BF_itoa64[c1] break } v1 = sptr sptr = sptr + 1 - c2 = uint32(*(*uint8)(unsafe.Pointer(v1))) + c2 = uint32(**(**uint8)(__ccgo_up(v1))) c1 = c1 | c2>>int32(4) v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] + **(**uint8)(__ccgo_up(v1)) = _BF_itoa64[c1] c1 = c2 & uint32(0x0f) << int32(2) if sptr >= end { v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] + **(**uint8)(__ccgo_up(v1)) = _BF_itoa64[c1] break } v1 = sptr sptr = sptr + 1 - c2 = uint32(*(*uint8)(unsafe.Pointer(v1))) + c2 = uint32(**(**uint8)(__ccgo_up(v1))) c1 = c1 | c2>>int32(6) v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] + **(**uint8)(__ccgo_up(v1)) = _BF_itoa64[c1] v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c2&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _BF_itoa64[c2&uint32(0x3f)] } } @@ -9207,11 +9207,11 @@ func _BF_swap(tls *TLS, x uintptr, count int32) { v1 = int32(1) if *(*uint8)(unsafe.Pointer(&v1)) != 0 { for { - tmp = *(*TBF_word)(unsafe.Pointer(x)) + tmp = **(**TBF_word)(__ccgo_up(x)) tmp = tmp<>Int32FromInt32(16) v4 = x x += 4 - *(*TBF_word)(unsafe.Pointer(v4)) = tmp&uint32(0x00FF00FF)<>Int32FromInt32(8)&uint32(0x00FF00FF) + **(**TBF_word)(__ccgo_up(v4)) = tmp&uint32(0x00FF00FF)<>Int32FromInt32(8)&uint32(0x00FF00FF) goto _3 _3: ; @@ -9231,7 +9231,7 @@ func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, e _, _, _, _, _, _, _ = i, ptr, tmp1, tmp2, tmp3, tmp4, v2 ptr = start for cond := true; cond; cond = ptr < end { - L = L ^ *(*TBF_word)(unsafe.Pointer(ctx)) + L = L ^ **(**TBF_word)(__ccgo_up(ctx)) i = 0 for { if !(i < int32(16)) { @@ -9243,12 +9243,12 @@ func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, e tmp3 = L >> int32(16) tmp3 = tmp3 & uint32(0xFF) tmp4 = L >> int32(24) - tmp1 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 3*1024 + uintptr(tmp1)*4)) - tmp2 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 2*1024 + uintptr(tmp2)*4)) - tmp3 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 1*1024 + uintptr(tmp3)*4)) - tmp3 = tmp3 + *(*TBF_word)(unsafe.Pointer(ctx + 72 + uintptr(tmp4)*4)) + tmp1 = **(**TBF_word)(__ccgo_up(ctx + 72 + 3*1024 + uintptr(tmp1)*4)) + tmp2 = **(**TBF_word)(__ccgo_up(ctx + 72 + 2*1024 + uintptr(tmp2)*4)) + tmp3 = **(**TBF_word)(__ccgo_up(ctx + 72 + 1*1024 + uintptr(tmp3)*4)) + tmp3 = tmp3 + **(**TBF_word)(__ccgo_up(ctx + 72 + uintptr(tmp4)*4)) tmp3 = tmp3 ^ tmp2 - R = R ^ *(*TBF_word)(unsafe.Pointer(ctx + uintptr(i+int32(1))*4)) + R = R ^ **(**TBF_word)(__ccgo_up(ctx + uintptr(i+int32(1))*4)) tmp3 = tmp3 + tmp1 R = R ^ tmp3 tmp1 = R & uint32(0xFF) @@ -9257,12 +9257,12 @@ func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, e tmp3 = R >> int32(16) tmp3 = tmp3 & uint32(0xFF) tmp4 = R >> int32(24) - tmp1 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 3*1024 + uintptr(tmp1)*4)) - tmp2 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 2*1024 + uintptr(tmp2)*4)) - tmp3 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 1*1024 + uintptr(tmp3)*4)) - tmp3 = tmp3 + *(*TBF_word)(unsafe.Pointer(ctx + 72 + uintptr(tmp4)*4)) + tmp1 = **(**TBF_word)(__ccgo_up(ctx + 72 + 3*1024 + uintptr(tmp1)*4)) + tmp2 = **(**TBF_word)(__ccgo_up(ctx + 72 + 2*1024 + uintptr(tmp2)*4)) + tmp3 = **(**TBF_word)(__ccgo_up(ctx + 72 + 1*1024 + uintptr(tmp3)*4)) + tmp3 = tmp3 + **(**TBF_word)(__ccgo_up(ctx + 72 + uintptr(tmp4)*4)) tmp3 = tmp3 ^ tmp2 - L = L ^ *(*TBF_word)(unsafe.Pointer(ctx + uintptr(i+int32(1)+int32(1))*4)) + L = L ^ **(**TBF_word)(__ccgo_up(ctx + uintptr(i+int32(1)+int32(1))*4)) tmp3 = tmp3 + tmp1 L = L ^ tmp3 goto _1 @@ -9272,13 +9272,13 @@ func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, e } tmp4 = R R = L - L = tmp4 ^ *(*TBF_word)(unsafe.Pointer(ctx + uintptr(Int32FromInt32(BF_N)+Int32FromInt32(1))*4)) + L = tmp4 ^ **(**TBF_word)(__ccgo_up(ctx + uintptr(Int32FromInt32(BF_N)+Int32FromInt32(1))*4)) v2 = ptr ptr += 4 - *(*TBF_word)(unsafe.Pointer(v2)) = L + **(**TBF_word)(__ccgo_up(v2)) = L v2 = ptr ptr += 4 - *(*TBF_word)(unsafe.Pointer(v2)) = R + **(**TBF_word)(__ccgo_up(v2)) = R } return L } @@ -9338,17 +9338,17 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags break } v1 = Uint32FromInt32(0) - (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)] = v1 - (*(*[2]TBF_word)(unsafe.Pointer(bp)))[0] = v1 + (**(**[2]TBF_word)(__ccgo_up(bp)))[int32(1)] = v1 + (**(**[2]TBF_word)(__ccgo_up(bp)))[0] = v1 j = uint32(0) for { if !(j < uint32(4)) { break } - *(*TBF_word)(unsafe.Pointer(bp)) <<= uint32(8) - *(*TBF_word)(unsafe.Pointer(bp)) |= uint32(*(*uint8)(unsafe.Pointer(ptr))) /* correct */ - *(*TBF_word)(unsafe.Pointer(bp + 1*4)) <<= uint32(8) - *(*TBF_word)(unsafe.Pointer(bp + 1*4)) |= Uint32FromInt8(Int8FromUint8(*(*uint8)(unsafe.Pointer(ptr)))) /* bug */ + **(**TBF_word)(__ccgo_up(bp)) <<= uint32(8) + **(**TBF_word)(__ccgo_up(bp)) |= uint32(uint8(**(**uint8)(__ccgo_up(ptr)))) /* correct */ + **(**TBF_word)(__ccgo_up(bp + 1*4)) <<= uint32(8) + **(**TBF_word)(__ccgo_up(bp + 1*4)) |= Uint32FromInt8(Int8FromUint8(**(**uint8)(__ccgo_up(ptr)))) /* bug */ /* * Sign extension in the first char has no effect - nothing to overwrite yet, * and those extra 24 bits will be fully shifted out of the 32-bit word. For @@ -9356,9 +9356,9 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags * extension in tmp[1] occurs. Once this flag is set, it remains set. */ if j != 0 { - sign = sign | (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)]&uint32(0x80) + sign = sign | (**(**[2]TBF_word)(__ccgo_up(bp)))[int32(1)]&uint32(0x80) } - if !(*(*uint8)(unsafe.Pointer(ptr)) != 0) { + if !(**(**uint8)(__ccgo_up(ptr)) != 0) { ptr = key } else { ptr = ptr + 1 @@ -9368,9 +9368,9 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags ; j = j + 1 } - diff = diff | ((*(*[2]TBF_word)(unsafe.Pointer(bp)))[0] ^ (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)]) /* Non-zero on any differences */ - *(*TBF_word)(unsafe.Pointer(expanded + uintptr(i)*4)) = (*(*[2]TBF_word)(unsafe.Pointer(bp)))[bug] - *(*TBF_word)(unsafe.Pointer(initial + uintptr(i)*4)) = *(*TBF_word)(unsafe.Pointer(uintptr(unsafe.Pointer(&_BF_init_state)) + uintptr(i)*4)) ^ (*(*[2]TBF_word)(unsafe.Pointer(bp)))[bug] + diff = diff | ((**(**[2]TBF_word)(__ccgo_up(bp)))[0] ^ (**(**[2]TBF_word)(__ccgo_up(bp)))[int32(1)]) /* Non-zero on any differences */ + **(**TBF_word)(__ccgo_up(expanded + uintptr(i)*4)) = (**(**[2]TBF_word)(__ccgo_up(bp)))[bug] + **(**TBF_word)(__ccgo_up(initial + uintptr(i)*4)) = **(**TBF_word)(__ccgo_up(uintptr(unsafe.Pointer(&_BF_init_state)) + uintptr(i)*4)) ^ (**(**[2]TBF_word)(__ccgo_up(bp)))[bug] goto _2 _2: ; @@ -9401,7 +9401,7 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags * state that could be directly specified by a password to the buggy algorithm * (and to the fully correct one as well, but that's a side-effect). */ - *(*TBF_word)(unsafe.Pointer(initial)) ^= sign + **(**TBF_word)(__ccgo_up(initial)) ^= sign } var _flags_by_subtype = [26]uint8{ @@ -9428,28 +9428,28 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w } } _, _, _, _, _, _, _, _, _, _, _, _ = L, L1, R, count, done, i, ptr, tmp1, tmp2, tmp3, tmp4, v1 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(setting))) != int32('$') || Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 1))) != int32('2') || Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 2)))-int32('a')) > uint32(25) || !(_flags_by_subtype[Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 2)))-int32('a')] != 0) || Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 3))) != int32('$') || Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 4)))-int32('0')) > uint32(1) || Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 5)))-int32('0')) > uint32(9) || Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 6))) != int32('$') { + if Int32FromUint8(**(**uint8)(__ccgo_up(setting))) != int32('$') || Int32FromUint8(**(**uint8)(__ccgo_up(setting + 1))) != int32('2') || Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(setting + 2)))-int32('a')) > uint32(25) || !(_flags_by_subtype[Int32FromUint8(**(**uint8)(__ccgo_up(setting + 2)))-int32('a')] != 0) || Int32FromUint8(**(**uint8)(__ccgo_up(setting + 3))) != int32('$') || Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(setting + 4)))-int32('0')) > uint32(1) || Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(setting + 5)))-int32('0')) > uint32(9) || Int32FromUint8(**(**uint8)(__ccgo_up(setting + 6))) != int32('$') { return UintptrFromInt32(0) } - count = Uint32FromInt32(1) << ((Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 4)))-int32('0'))*int32(10) + (Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 5))) - int32('0'))) + count = Uint32FromInt32(1) << ((Int32FromUint8(**(**uint8)(__ccgo_up(setting + 4)))-int32('0'))*int32(10) + (Int32FromUint8(**(**uint8)(__ccgo_up(setting + 5))) - int32('0'))) if count < min || _BF_decode(tls, bp+4240, setting+7, int32(16)) != 0 { return UintptrFromInt32(0) } _BF_swap(tls, bp+4240, int32(4)) - _BF_set_key(tls, key, bp+4168, bp, _flags_by_subtype[Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 2)))-int32('a')]) + _BF_set_key(tls, key, bp+4168, bp, _flags_by_subtype[Int32FromUint8(**(**uint8)(__ccgo_up(setting + 2)))-int32('a')]) Xmemcpy(tls, bp+72, uintptr(unsafe.Pointer(&_BF_init_state))+72, uint64(4096)) L = uint32(0) R = uint32(0) ptr = bp for cond := true; cond; cond = int32(1) != 0 { - L = _BF_encrypt(tls, bp, L^*(*TBF_word)(unsafe.Pointer(bp + 4240)), R^*(*TBF_word)(unsafe.Pointer(bp + 4240 + 1*4)), ptr, ptr) - R = *(*TBF_word)(unsafe.Pointer(ptr + UintptrFromInt32(1)*4)) + L = _BF_encrypt(tls, bp, L^**(**TBF_word)(__ccgo_up(bp + 4240)), R^**(**TBF_word)(__ccgo_up(bp + 4240 + 1*4)), ptr, ptr) + R = **(**TBF_word)(__ccgo_up(ptr + UintptrFromInt32(1)*4)) ptr = ptr + uintptr(2)*4 if ptr >= bp+uintptr(Int32FromInt32(BF_N)+Int32FromInt32(2)+Int32FromInt32(4)*Int32FromInt32(0x100))*4 { break } - L = _BF_encrypt(tls, bp, L^*(*TBF_word)(unsafe.Pointer(bp + 4240 + 2*4)), R^*(*TBF_word)(unsafe.Pointer(bp + 4240 + 3*4)), ptr, ptr) - R = *(*TBF_word)(unsafe.Pointer(ptr + UintptrFromInt32(1)*4)) + L = _BF_encrypt(tls, bp, L^**(**TBF_word)(__ccgo_up(bp + 4240 + 2*4)), R^**(**TBF_word)(__ccgo_up(bp + 4240 + 3*4)), ptr, ptr) + R = **(**TBF_word)(__ccgo_up(ptr + UintptrFromInt32(1)*4)) ptr = ptr + uintptr(2)*4 } for { @@ -9458,8 +9458,8 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w if !(i < Int32FromInt32(BF_N)+Int32FromInt32(2)) { break } - *(*TBF_word)(unsafe.Pointer(bp + uintptr(i)*4)) ^= *(*TBF_word)(unsafe.Pointer(bp + 4168 + uintptr(i)*4)) - *(*TBF_word)(unsafe.Pointer(bp + uintptr(i+int32(1))*4)) ^= *(*TBF_word)(unsafe.Pointer(bp + 4168 + uintptr(i+int32(1))*4)) + **(**TBF_word)(__ccgo_up(bp + uintptr(i)*4)) ^= **(**TBF_word)(__ccgo_up(bp + 4168 + uintptr(i)*4)) + **(**TBF_word)(__ccgo_up(bp + uintptr(i+int32(1))*4)) ^= **(**TBF_word)(__ccgo_up(bp + 4168 + uintptr(i+int32(1))*4)) goto _3 _3: ; @@ -9472,26 +9472,26 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w break } done = int32(1) - tmp1 = *(*TBF_word)(unsafe.Pointer(bp + 4240)) - tmp2 = *(*TBF_word)(unsafe.Pointer(bp + 4240 + 1*4)) - tmp3 = *(*TBF_word)(unsafe.Pointer(bp + 4240 + 2*4)) - tmp4 = *(*TBF_word)(unsafe.Pointer(bp + 4240 + 3*4)) + tmp1 = **(**TBF_word)(__ccgo_up(bp + 4240)) + tmp2 = **(**TBF_word)(__ccgo_up(bp + 4240 + 1*4)) + tmp3 = **(**TBF_word)(__ccgo_up(bp + 4240 + 2*4)) + tmp4 = **(**TBF_word)(__ccgo_up(bp + 4240 + 3*4)) i = 0 for { if !(i < int32(BF_N)) { break } - *(*TBF_word)(unsafe.Pointer(bp + uintptr(i)*4)) ^= tmp1 - *(*TBF_word)(unsafe.Pointer(bp + uintptr(i+int32(1))*4)) ^= tmp2 - *(*TBF_word)(unsafe.Pointer(bp + uintptr(i+int32(2))*4)) ^= tmp3 - *(*TBF_word)(unsafe.Pointer(bp + uintptr(i+int32(3))*4)) ^= tmp4 + **(**TBF_word)(__ccgo_up(bp + uintptr(i)*4)) ^= tmp1 + **(**TBF_word)(__ccgo_up(bp + uintptr(i+int32(1))*4)) ^= tmp2 + **(**TBF_word)(__ccgo_up(bp + uintptr(i+int32(2))*4)) ^= tmp3 + **(**TBF_word)(__ccgo_up(bp + uintptr(i+int32(3))*4)) ^= tmp4 goto _4 _4: ; i = i + int32(4) } - *(*TBF_word)(unsafe.Pointer(bp + 16*4)) ^= tmp1 - *(*TBF_word)(unsafe.Pointer(bp + 17*4)) ^= tmp2 + **(**TBF_word)(__ccgo_up(bp + 16*4)) ^= tmp1 + **(**TBF_word)(__ccgo_up(bp + 17*4)) ^= tmp2 } goto _2 _2: @@ -9508,10 +9508,10 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w break } L1 = _BF_magic_w[i] - (*(*[2]TBF_word)(unsafe.Pointer(bp + 4264)))[int32(1)] = _BF_magic_w[i+int32(1)] + (**(**[2]TBF_word)(__ccgo_up(bp + 4264)))[int32(1)] = _BF_magic_w[i+int32(1)] count = uint32(64) for { - L1 = _BF_encrypt(tls, bp, L1, (*(*[2]TBF_word)(unsafe.Pointer(bp + 4264)))[int32(1)], bp+4264, bp+4264) + L1 = _BF_encrypt(tls, bp, L1, (**(**[2]TBF_word)(__ccgo_up(bp + 4264)))[int32(1)], bp+4264, bp+4264) goto _7 _7: ; @@ -9521,20 +9521,20 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w break } } - *(*TBF_word)(unsafe.Pointer(bp + 4240 + uintptr(i)*4)) = L1 - *(*TBF_word)(unsafe.Pointer(bp + 4240 + uintptr(i+int32(1))*4)) = (*(*[2]TBF_word)(unsafe.Pointer(bp + 4264)))[int32(1)] + **(**TBF_word)(__ccgo_up(bp + 4240 + uintptr(i)*4)) = L1 + **(**TBF_word)(__ccgo_up(bp + 4240 + uintptr(i+int32(1))*4)) = (**(**[2]TBF_word)(__ccgo_up(bp + 4264)))[int32(1)] goto _5 _5: ; i = i + int32(2) } Xmemcpy(tls, output, setting, Uint64FromInt32(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1))) - *(*uint8)(unsafe.Pointer(output + uintptr(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1)))) = _BF_itoa64[Int32FromUint8(_BF_atoi64[Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1)))))-int32(0x20)])&int32(0x30)] + **(**uint8)(__ccgo_up(output + uintptr(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1)))) = _BF_itoa64[Int32FromUint8(_BF_atoi64[Int32FromUint8(**(**uint8)(__ccgo_up(setting + uintptr(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1)))))-int32(0x20)])&int32(0x30)] /* This has to be bug-compatible with the original implementation, so * only encode 23 of the 24 bytes. :-) */ _BF_swap(tls, bp+4240, int32(6)) _BF_encode(tls, output+uintptr(Int32FromInt32(7)+Int32FromInt32(22)), bp+4240, int32(23)) - *(*uint8)(unsafe.Pointer(output + uintptr(Int32FromInt32(7)+Int32FromInt32(22)+Int32FromInt32(31)))) = uint8('\000') + **(**uint8)(__ccgo_up(output + uintptr(Int32FromInt32(7)+Int32FromInt32(22)+Int32FromInt32(31)))) = uint8('\000') return output } @@ -9593,19 +9593,19 @@ func X__crypt_blowfish(tls *TLS, key uintptr, setting uintptr, output uintptr) ( */ Xmemcpy(tls, bp, test_setting, uint64(30)) if retval != 0 { - flags = uint32(_flags_by_subtype[Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 2)))-int32('a')]) + flags = uint32(_flags_by_subtype[Int32FromUint8(**(**uint8)(__ccgo_up(setting + 2)))-int32('a')]) test_hash = uintptr(unsafe.Pointer(&_test_hashes)) + uintptr(flags&uint32(1))*34 - *(*uint8)(unsafe.Pointer(bp + 2)) = *(*uint8)(unsafe.Pointer(setting + 2)) + **(**uint8)(__ccgo_up(bp + 2)) = **(**uint8)(__ccgo_up(setting + 2)) } Xmemset(tls, bp+30, int32(0x55), uint64(63)) - *(*uint8)(unsafe.Pointer(bp + 30 + uintptr(Uint64FromInt64(63)-Uint64FromInt32(1)))) = uint8(0) + **(**uint8)(__ccgo_up(bp + 30 + uintptr(Uint64FromInt64(63)-Uint64FromInt32(1)))) = uint8(0) p = _BF_crypt(tls, test_key, bp, bp+30, uint32(1)) ok = BoolInt32(p == bp+30 && !(Xmemcmp(tls, p, bp, Uint64FromInt32(Int32FromInt32(7)+Int32FromInt32(22))) != 0) && !(Xmemcmp(tls, p+uintptr(Int32FromInt32(7)+Int32FromInt32(22)), test_hash, Uint64FromInt32(Int32FromInt32(31)+Int32FromInt32(1)+Int32FromInt32(1)+Int32FromInt32(1))) != 0)) k = __ccgo_ts + 58 - _BF_set_key(tls, k, bp+96, bp+168, uint8(2)) /* $2a$ */ - _BF_set_key(tls, k, bp+240, bp+312, uint8(4)) /* $2y$ */ - *(*TBF_word)(unsafe.Pointer(bp + 168)) ^= uint32(0x10000) /* undo the safety (for comparison) */ - ok = BoolInt32(ok != 0 && (*(*TBF_key)(unsafe.Pointer(bp + 168)))[0] == uint32(0xdb9c59bc) && (*(*TBF_key)(unsafe.Pointer(bp + 240)))[int32(17)] == uint32(0x33343500) && !(Xmemcmp(tls, bp+96, bp+240, uint64(72)) != 0) && !(Xmemcmp(tls, bp+168, bp+312, uint64(72)) != 0)) + _BF_set_key(tls, k, bp+96, bp+168, uint8(2)) /* $2a$ */ + _BF_set_key(tls, k, bp+240, bp+312, uint8(4)) /* $2y$ */ + **(**TBF_word)(__ccgo_up(bp + 168)) ^= uint32(0x10000) /* undo the safety (for comparison) */ + ok = BoolInt32(ok != 0 && (**(**TBF_key)(__ccgo_up(bp + 168)))[0] == uint32(0xdb9c59bc) && (**(**TBF_key)(__ccgo_up(bp + 240)))[int32(17)] == uint32(0x33343500) && !(Xmemcmp(tls, bp+96, bp+240, uint64(72)) != 0) && !(Xmemcmp(tls, bp+168, bp+312, uint64(72)) != 0)) if ok != 0 && retval != 0 { return retval } @@ -11455,8 +11455,8 @@ func X__des_setkey(tls *TLS, key uintptr, ekey uintptr) { var i, ibit, j, round, shifts uint32 var k0, k1, kl, kr, rawkey0, rawkey1, t0, t1, v1 Tuint32_t _, _, _, _, _, _, _, _, _, _, _, _, _, _ = i, ibit, j, k0, k1, kl, kr, rawkey0, rawkey1, round, shifts, t0, t1, v1 - rawkey0 = uint32(*(*uint8)(unsafe.Pointer(key + 3))) | uint32(*(*uint8)(unsafe.Pointer(key + 2)))<>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskl)) + uintptr(i+uint32(4))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4))) - k1 = k1 | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j)*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) + k0 = k0 | (**(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_key_perm_maskl)) + uintptr(i)*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_key_perm_maskl)) + uintptr(i+uint32(4))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4))) + k1 = k1 | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j)*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) ibit = ibit - uint32(4) - k1 = k1 | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j+uint32(1))*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(i+uint32(8))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4))) + k1 = k1 | (**(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j+uint32(1))*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(i+uint32(8))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4))) goto _2 _2: ; @@ -11501,19 +11501,19 @@ func X__des_setkey(tls *TLS, key uintptr, ekey uintptr) { if !(i < uint32(4)) { break } - kl = kl | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskl0)) + uintptr(i)*32 + uintptr(t0>>ibit&uint32(7))*4)) - kr = kr | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskr0)) + uintptr(i)*32 + uintptr(t1>>ibit&uint32(7))*4)) + kl = kl | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_comp_maskl0)) + uintptr(i)*32 + uintptr(t0>>ibit&uint32(7))*4)) + kr = kr | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_comp_maskr0)) + uintptr(i)*32 + uintptr(t1>>ibit&uint32(7))*4)) ibit = ibit - uint32(4) - kl = kl | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskl1)) + uintptr(i)*64 + uintptr(t0>>ibit&uint32(0xf))*4)) - kr = kr | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskr1)) + uintptr(i)*64 + uintptr(t1>>ibit&uint32(0xf))*4)) + kl = kl | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_comp_maskl1)) + uintptr(i)*64 + uintptr(t0>>ibit&uint32(0xf))*4)) + kr = kr | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_comp_maskr1)) + uintptr(i)*64 + uintptr(t1>>ibit&uint32(0xf))*4)) ibit = ibit - uint32(3) goto _5 _5: ; i = i + 1 } - *(*Tuint32_t)(unsafe.Pointer(ekey + uintptr(round)*4)) = kl - *(*Tuint32_t)(unsafe.Pointer(ekey + 64 + uintptr(round)*4)) = kr + **(**Tuint32_t)(__ccgo_up(ekey + uintptr(round)*4)) = kl + **(**Tuint32_t)(__ccgo_up(ekey + 64 + uintptr(round)*4)) = kr goto _3 _3: ; @@ -11547,8 +11547,8 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui if !(i < uint32(8)) { break } - l = l | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4))) - r = r | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4))) + l = l | (**(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4))) + r = r | (**(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4))) goto _2 _2: ; @@ -11586,15 +11586,15 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui f = (r48l ^ r48r) & saltbits v5 = kl kl += 4 - r48l = r48l ^ (f ^ *(*Tuint32_t)(unsafe.Pointer(v5))) + r48l = r48l ^ (f ^ **(**Tuint32_t)(__ccgo_up(v5))) v5 = kr kr += 4 - r48r = r48r ^ (f ^ *(*Tuint32_t)(unsafe.Pointer(v5))) + r48r = r48r ^ (f ^ **(**Tuint32_t)(__ccgo_up(v5))) /* * Do S-box lookups (which shrink it back to 32 bits) * and do the P-box permutation at the same time. */ - f = *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + uintptr(r48l>>int32(18))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 1*256 + uintptr(r48l>>Int32FromInt32(12)&uint32(0x3f))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 2*256 + uintptr(r48l>>Int32FromInt32(6)&uint32(0x3f))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 3*256 + uintptr(r48l&uint32(0x3f))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 4*256 + uintptr(r48r>>int32(18))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 5*256 + uintptr(r48r>>Int32FromInt32(12)&uint32(0x3f))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 6*256 + uintptr(r48r>>Int32FromInt32(6)&uint32(0x3f))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 7*256 + uintptr(r48r&uint32(0x3f))*4)) + f = **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + uintptr(r48l>>int32(18))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 1*256 + uintptr(r48l>>Int32FromInt32(12)&uint32(0x3f))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 2*256 + uintptr(r48l>>Int32FromInt32(6)&uint32(0x3f))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 3*256 + uintptr(r48l&uint32(0x3f))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 4*256 + uintptr(r48r>>int32(18))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 5*256 + uintptr(r48r>>Int32FromInt32(12)&uint32(0x3f))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 6*256 + uintptr(r48r>>Int32FromInt32(6)&uint32(0x3f))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 7*256 + uintptr(r48r&uint32(0x3f))*4)) /* * Now that we've permuted things, complete f(). */ @@ -11617,17 +11617,17 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui if !(i1 < uint32(4)) { break } - ro = ro | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4))) + ro = ro | (**(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4))) ibit1 = ibit1 - uint32(4) - lo = lo | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4))) + lo = lo | (**(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4))) goto _8 _8: ; i1 = i1 + 1 ibit1 = ibit1 - uint32(4) } - *(*Tuint32_t)(unsafe.Pointer(l_out)) = lo - *(*Tuint32_t)(unsafe.Pointer(r_out)) = ro + **(**Tuint32_t)(__ccgo_up(l_out)) = lo + **(**Tuint32_t)(__ccgo_up(r_out)) = ro } func _des_cipher(tls *TLS, in uintptr, out uintptr, count Tuint32_t, saltbits Tuint32_t, ekey uintptr) { @@ -11637,17 +11637,17 @@ func _des_cipher(tls *TLS, in uintptr, out uintptr, count Tuint32_t, saltbits Tu var _ /* l_out at bp+0 */ Tuint32_t var _ /* r_out at bp+4 */ Tuint32_t _, _ = rawl, rawr - rawl = uint32(*(*uint8)(unsafe.Pointer(in + 3))) | uint32(*(*uint8)(unsafe.Pointer(in + 2)))<> int32(24)) - *(*uint8)(unsafe.Pointer(out + 1)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp)) >> int32(16)) - *(*uint8)(unsafe.Pointer(out + 2)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp)) >> int32(8)) - *(*uint8)(unsafe.Pointer(out + 3)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp))) - *(*uint8)(unsafe.Pointer(out + 4)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp + 4)) >> int32(24)) - *(*uint8)(unsafe.Pointer(out + 5)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp + 4)) >> int32(16)) - *(*uint8)(unsafe.Pointer(out + 6)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp + 4)) >> int32(8)) - *(*uint8)(unsafe.Pointer(out + 7)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp + 4))) + **(**uint8)(__ccgo_up(out)) = uint8(**(**Tuint32_t)(__ccgo_up(bp)) >> int32(24)) + **(**uint8)(__ccgo_up(out + 1)) = uint8(**(**Tuint32_t)(__ccgo_up(bp)) >> int32(16)) + **(**uint8)(__ccgo_up(out + 2)) = uint8(**(**Tuint32_t)(__ccgo_up(bp)) >> int32(8)) + **(**uint8)(__ccgo_up(out + 3)) = uint8(**(**Tuint32_t)(__ccgo_up(bp))) + **(**uint8)(__ccgo_up(out + 4)) = uint8(**(**Tuint32_t)(__ccgo_up(bp + 4)) >> int32(24)) + **(**uint8)(__ccgo_up(out + 5)) = uint8(**(**Tuint32_t)(__ccgo_up(bp + 4)) >> int32(16)) + **(**uint8)(__ccgo_up(out + 6)) = uint8(**(**Tuint32_t)(__ccgo_up(bp + 4)) >> int32(8)) + **(**uint8)(__ccgo_up(out + 7)) = uint8(**(**Tuint32_t)(__ccgo_up(bp + 4))) } func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uintptr) (r uintptr) { @@ -11671,13 +11671,13 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin for q <= bp+128+uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) { v1 = q q = q + 1 - *(*uint8)(unsafe.Pointer(v1)) = Uint8FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(key))) << int32(1)) - if *(*uint8)(unsafe.Pointer(key)) != 0 { + **(**uint8)(__ccgo_up(v1)) = Uint8FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(key))) << int32(1)) + if **(**uint8)(__ccgo_up(key)) != 0 { key = key + 1 } } X__des_setkey(tls, bp+128, bp) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(setting))) == int32('_') { + if Int32FromUint8(**(**uint8)(__ccgo_up(setting))) == int32('_') { /* * "new"-style: * setting - underscore, 4 chars of count, 4 chars of salt @@ -11689,8 +11689,8 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin if !(i < uint32(5)) { break } - value = _ascii_to_bin(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(i))))) - if Int32FromUint8(_ascii64[value]) != Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(i)))) { + value = _ascii_to_bin(tls, Int32FromUint8(**(**uint8)(__ccgo_up(setting + uintptr(i))))) + if Int32FromUint8(_ascii64[value]) != Int32FromUint8(**(**uint8)(__ccgo_up(setting + uintptr(i)))) { return UintptrFromInt32(0) } count = count | value<<((i-uint32(1))*uint32(6)) @@ -11708,8 +11708,8 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin if !(i < uint32(9)) { break } - value1 = _ascii_to_bin(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(i))))) - if Int32FromUint8(_ascii64[value1]) != Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(i)))) { + value1 = _ascii_to_bin(tls, Int32FromUint8(**(**uint8)(__ccgo_up(setting + uintptr(i))))) + if Int32FromUint8(_ascii64[value1]) != Int32FromUint8(**(**uint8)(__ccgo_up(setting + uintptr(i)))) { return UintptrFromInt32(0) } salt = salt | value1<<((i-uint32(5))*uint32(6)) @@ -11718,7 +11718,7 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin ; i = i + 1 } - for *(*uint8)(unsafe.Pointer(key)) != 0 { + for **(**uint8)(__ccgo_up(key)) != 0 { /* * Encrypt the key with itself. */ @@ -11727,18 +11727,18 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin * And XOR with the next 8 characters of the key. */ q = bp + 128 - for q <= bp+128+uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) && *(*uint8)(unsafe.Pointer(key)) != 0 { + for q <= bp+128+uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) && **(**uint8)(__ccgo_up(key)) != 0 { v4 = q q = q + 1 v1 = v4 v5 = key key = key + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(int32(*(*uint8)(unsafe.Pointer(v1))) ^ Int32FromUint8(*(*uint8)(unsafe.Pointer(v5)))<> int32(8) + l = **(**Tuint32_t)(__ccgo_up(bp + 136)) >> int32(8) v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l&uint32(0x3f)] - l = *(*Tuint32_t)(unsafe.Pointer(bp + 136))<>Int32FromInt32(16)&uint32(0xffff) + **(**uint8)(__ccgo_up(v1)) = _ascii64[l&uint32(0x3f)] + l = **(**Tuint32_t)(__ccgo_up(bp + 136))<>Int32FromInt32(16)&uint32(0xffff) v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l&uint32(0x3f)] - l = *(*Tuint32_t)(unsafe.Pointer(bp + 140)) << int32(2) + **(**uint8)(__ccgo_up(v1)) = _ascii64[l&uint32(0x3f)] + l = **(**Tuint32_t)(__ccgo_up(bp + 140)) << int32(2) v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l&uint32(0x3f)] - *(*uint8)(unsafe.Pointer(p)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = _ascii64[l&uint32(0x3f)] + **(**uint8)(__ccgo_up(p)) = uint8(0) return output } @@ -11815,7 +11815,7 @@ func X__crypt_des(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uin test_key = __ccgo_ts + 72 test_setting = __ccgo_ts + 93 test_hash = __ccgo_ts + 103 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(setting))) != int32('_') { + if Int32FromUint8(**(**uint8)(__ccgo_up(setting))) != int32('_') { test_setting = __ccgo_ts + 124 test_hash = __ccgo_ts + 127 } @@ -11834,7 +11834,7 @@ func X__crypt_des(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uin if p != 0 && !(Xstrcmp(tls, p, test_hash) != 0) && retval != 0 { return retval } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(setting))) == int32('*') { + if Int32FromUint8(**(**uint8)(__ccgo_up(setting))) == int32('*') { v1 = __ccgo_ts + 141 } else { v1 = __ccgo_ts + 70 @@ -11935,80 +11935,80 @@ func _processblock(tls *TLS, s uintptr, buf uintptr) { if !(i < uint32(16)) { break } - (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] = uint32(*(*Tuint8_t)(unsafe.Pointer(buf + uintptr(uint32(4)*i)))) - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(i)*4)) |= uint32(*(*Tuint8_t)(unsafe.Pointer(buf + uintptr(uint32(4)*i+uint32(1))))) << int32(8) - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(i)*4)) |= uint32(*(*Tuint8_t)(unsafe.Pointer(buf + uintptr(uint32(4)*i+uint32(2))))) << int32(16) - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(i)*4)) |= uint32(*(*Tuint8_t)(unsafe.Pointer(buf + uintptr(uint32(4)*i+uint32(3))))) << int32(24) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[i] = uint32(**(**Tuint8_t)(__ccgo_up(buf + uintptr(uint32(4)*i)))) + **(**Tuint32_t)(__ccgo_up(bp + uintptr(i)*4)) |= uint32(**(**Tuint8_t)(__ccgo_up(buf + uintptr(uint32(4)*i+uint32(1))))) << int32(8) + **(**Tuint32_t)(__ccgo_up(bp + uintptr(i)*4)) |= uint32(**(**Tuint8_t)(__ccgo_up(buf + uintptr(uint32(4)*i+uint32(2))))) << int32(16) + **(**Tuint32_t)(__ccgo_up(bp + uintptr(i)*4)) |= uint32(**(**Tuint8_t)(__ccgo_up(buf + uintptr(uint32(4)*i+uint32(3))))) << int32(24) goto _1 _1: ; i = i + 1 } - a = *(*Tuint32_t)(unsafe.Pointer(s + 8)) - b = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) - c = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 2*4)) - d = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) + a = **(**Tuint32_t)(__ccgo_up(s + 8)) + b = **(**Tuint32_t)(__ccgo_up(s + 8 + 1*4)) + c = **(**Tuint32_t)(__ccgo_up(s + 8 + 2*4)) + d = **(**Tuint32_t)(__ccgo_up(s + 8 + 3*4)) i = uint32(0) for i < uint32(16) { - a = a + (d ^ b&(c^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) + a = a + (d ^ b&(c^d) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[i] + _tab[i]) a = _rol(tls, a, int32(7)) + b i = i + 1 - d = d + (c ^ a&(b^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) + d = d + (c ^ a&(b^c) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[i] + _tab[i]) d = _rol(tls, d, int32(12)) + a i = i + 1 - c = c + (b ^ d&(a^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) + c = c + (b ^ d&(a^b) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[i] + _tab[i]) c = _rol(tls, c, int32(17)) + d i = i + 1 - b = b + (a ^ c&(d^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) + b = b + (a ^ c&(d^a) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[i] + _tab[i]) b = _rol(tls, b, int32(22)) + c i = i + 1 } for i < uint32(32) { - a = a + (c ^ d&(c^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) + a = a + (c ^ d&(c^b) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) a = _rol(tls, a, int32(5)) + b i = i + 1 - d = d + (b ^ c&(b^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) + d = d + (b ^ c&(b^a) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) d = _rol(tls, d, int32(9)) + a i = i + 1 - c = c + (a ^ b&(a^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) + c = c + (a ^ b&(a^d) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) c = _rol(tls, c, int32(14)) + d i = i + 1 - b = b + (d ^ a&(d^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) + b = b + (d ^ a&(d^c) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) b = _rol(tls, b, int32(20)) + c i = i + 1 } for i < uint32(48) { - a = a + (b ^ c ^ d + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) + a = a + (b ^ c ^ d + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) a = _rol(tls, a, int32(4)) + b i = i + 1 - d = d + (a ^ b ^ c + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) + d = d + (a ^ b ^ c + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) d = _rol(tls, d, int32(11)) + a i = i + 1 - c = c + (d ^ a ^ b + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) + c = c + (d ^ a ^ b + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) c = _rol(tls, c, int32(16)) + d i = i + 1 - b = b + (c ^ d ^ a + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) + b = b + (c ^ d ^ a + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) b = _rol(tls, b, int32(23)) + c i = i + 1 } for i < uint32(64) { - a = a + (c ^ (b | ^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) + a = a + (c ^ (b | ^d) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) a = _rol(tls, a, int32(6)) + b i = i + 1 - d = d + (b ^ (a | ^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) + d = d + (b ^ (a | ^c) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) d = _rol(tls, d, int32(10)) + a i = i + 1 - c = c + (a ^ (d | ^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) + c = c + (a ^ (d | ^b) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) c = _rol(tls, c, int32(15)) + d i = i + 1 - b = b + (d ^ (c | ^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) + b = b + (d ^ (c | ^a) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) b = _rol(tls, b, int32(21)) + c i = i + 1 } - *(*Tuint32_t)(unsafe.Pointer(s + 8)) += a - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) += b - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 2*4)) += c - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) += d + **(**Tuint32_t)(__ccgo_up(s + 8)) += a + **(**Tuint32_t)(__ccgo_up(s + 8 + 1*4)) += b + **(**Tuint32_t)(__ccgo_up(s + 8 + 2*4)) += c + **(**Tuint32_t)(__ccgo_up(s + 8 + 3*4)) += d } func _pad(tls *TLS, s uintptr) { @@ -12017,31 +12017,31 @@ func _pad(tls *TLS, s uintptr) { r = uint32((*Tmd5)(unsafe.Pointer(s)).Flen1 % uint64(64)) v1 = r r = r + 1 - *(*Tuint8_t)(unsafe.Pointer(s + 24 + uintptr(v1))) = uint8(0x80) + **(**Tuint8_t)(__ccgo_up(s + 24 + uintptr(v1))) = uint8(0x80) if r > uint32(56) { Xmemset(tls, s+24+uintptr(r), 0, uint64(uint32(64)-r)) r = uint32(0) _processblock(tls, s, s+24) } Xmemset(tls, s+24+uintptr(r), 0, uint64(uint32(56)-r)) - *(*Tuint64_t)(unsafe.Pointer(s)) *= uint64(8) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 56)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 57)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(8)) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 58)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(16)) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 59)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(24)) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 60)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(32)) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 61)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(40)) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 62)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(48)) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 63)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(56)) + **(**Tuint64_t)(__ccgo_up(s)) *= uint64(8) + **(**Tuint8_t)(__ccgo_up(s + 24 + 56)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1) + **(**Tuint8_t)(__ccgo_up(s + 24 + 57)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(8)) + **(**Tuint8_t)(__ccgo_up(s + 24 + 58)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(16)) + **(**Tuint8_t)(__ccgo_up(s + 24 + 59)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(24)) + **(**Tuint8_t)(__ccgo_up(s + 24 + 60)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(32)) + **(**Tuint8_t)(__ccgo_up(s + 24 + 61)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(40)) + **(**Tuint8_t)(__ccgo_up(s + 24 + 62)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(48)) + **(**Tuint8_t)(__ccgo_up(s + 24 + 63)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(56)) _processblock(tls, s, s+24) } func _md5_init(tls *TLS, s uintptr) { (*Tmd5)(unsafe.Pointer(s)).Flen1 = uint64(0) - *(*Tuint32_t)(unsafe.Pointer(s + 8)) = uint32(0x67452301) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) = uint32(0xefcdab89) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 2*4)) = uint32(0x98badcfe) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) = uint32(0x10325476) + **(**Tuint32_t)(__ccgo_up(s + 8)) = uint32(0x67452301) + **(**Tuint32_t)(__ccgo_up(s + 8 + 1*4)) = uint32(0xefcdab89) + **(**Tuint32_t)(__ccgo_up(s + 8 + 2*4)) = uint32(0x98badcfe) + **(**Tuint32_t)(__ccgo_up(s + 8 + 3*4)) = uint32(0x10325476) } func _md5_sum(tls *TLS, s uintptr, md uintptr) { @@ -12053,10 +12053,10 @@ func _md5_sum(tls *TLS, s uintptr, md uintptr) { if !(i < int32(4)) { break } - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4))) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i+int32(1)))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4)) >> int32(8)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i+int32(2)))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4)) >> int32(16)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i+int32(3)))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4)) >> int32(24)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4))) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i+int32(1)))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4)) >> int32(8)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i+int32(2)))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4)) >> int32(16)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i+int32(3)))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4)) >> int32(24)) goto _1 _1: ; @@ -12070,7 +12070,7 @@ func _md5_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { _, _ = p, r p = m r = uint32((*Tmd5)(unsafe.Pointer(s)).Flen1 % uint64(64)) - *(*Tuint64_t)(unsafe.Pointer(s)) += len1 + **(**Tuint64_t)(__ccgo_up(s)) += len1 if r != 0 { if len1 < uint64(uint32(64)-r) { Xmemcpy(tls, s+24+uintptr(r), p, len1) @@ -12137,7 +12137,7 @@ func _to64(tls *TLS, s uintptr, u uint32, n int32) (r uintptr) { } v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = _b64[u%uint32(64)] + **(**uint8)(__ccgo_up(v2)) = _b64[u%uint32(64)] u = u / uint32(64) } return s @@ -12163,7 +12163,7 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt salt = setting + uintptr(3) i = uint32(0) for { - if !(i < uint32(SALT_MAX) && *(*uint8)(unsafe.Pointer(salt + uintptr(i))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(salt + uintptr(i)))) != int32('$')) { + if !(i < uint32(SALT_MAX) && **(**uint8)(__ccgo_up(salt + uintptr(i))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(salt + uintptr(i)))) != int32('$')) { break } goto _1 @@ -12194,7 +12194,7 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt i = uint32(uint64(i) - Uint64FromInt64(16)) } _md5_update(tls, bp, bp+88, uint64(i)) - (*(*[16]uint8)(unsafe.Pointer(bp + 88)))[0] = uint8(0) + (**(**[16]uint8)(__ccgo_up(bp + 88)))[0] = uint8(0) i = klen for { if !(i != 0) { @@ -12245,20 +12245,20 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt p = output + uintptr(3) + uintptr(slen) v5 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v5)) = uint8('$') + **(**uint8)(__ccgo_up(v5)) = uint8('$') i = uint32(0) for { if !(i < uint32(5)) { break } - p = _to64(tls, p, Uint32FromInt32(Int32FromUint8((*(*[16]uint8)(unsafe.Pointer(bp + 88)))[*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_perm)) + uintptr(i)*3))])<>Int32FromInt32(10) + (*(*[64]Tuint32_t)(unsafe.Pointer(bp)))[i-int32(7)] + (_ror(tls, (*(*[64]Tuint32_t)(unsafe.Pointer(bp)))[i-int32(15)], int32(7)) ^ _ror(tls, (*(*[64]Tuint32_t)(unsafe.Pointer(bp)))[i-int32(15)], int32(18)) ^ (*(*[64]Tuint32_t)(unsafe.Pointer(bp)))[i-int32(15)]>>Int32FromInt32(3)) + (*(*[64]Tuint32_t)(unsafe.Pointer(bp)))[i-int32(16)] + (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i] = _ror(tls, (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(2)], int32(17)) ^ _ror(tls, (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(2)], int32(19)) ^ (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(2)]>>Int32FromInt32(10) + (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(7)] + (_ror(tls, (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(15)], int32(7)) ^ _ror(tls, (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(15)], int32(18)) ^ (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(15)]>>Int32FromInt32(3)) + (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(16)] goto _2 _2: ; i = i + 1 } - a = *(*Tuint32_t)(unsafe.Pointer(s + 8)) - b = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) - c = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 2*4)) - d = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) - e = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 4*4)) - f = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 5*4)) - g = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 6*4)) - h = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 7*4)) + a = **(**Tuint32_t)(__ccgo_up(s + 8)) + b = **(**Tuint32_t)(__ccgo_up(s + 8 + 1*4)) + c = **(**Tuint32_t)(__ccgo_up(s + 8 + 2*4)) + d = **(**Tuint32_t)(__ccgo_up(s + 8 + 3*4)) + e = **(**Tuint32_t)(__ccgo_up(s + 8 + 4*4)) + f = **(**Tuint32_t)(__ccgo_up(s + 8 + 5*4)) + g = **(**Tuint32_t)(__ccgo_up(s + 8 + 6*4)) + h = **(**Tuint32_t)(__ccgo_up(s + 8 + 7*4)) i = 0 for { if !(i < int32(64)) { break } - t1 = h + (_ror(tls, e, int32(6)) ^ _ror(tls, e, int32(11)) ^ _ror(tls, e, int32(25))) + (g ^ e&(f^g)) + _K[i] + (*(*[64]Tuint32_t)(unsafe.Pointer(bp)))[i] + t1 = h + (_ror(tls, e, int32(6)) ^ _ror(tls, e, int32(11)) ^ _ror(tls, e, int32(25))) + (g ^ e&(f^g)) + _K[i] + (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i] t2 = _ror(tls, a, int32(2)) ^ _ror(tls, a, int32(13)) ^ _ror(tls, a, int32(22)) + (a&b | c&(a|b)) h = g g = f @@ -12495,14 +12495,14 @@ func _processblock1(tls *TLS, s uintptr, buf uintptr) { ; i = i + 1 } - *(*Tuint32_t)(unsafe.Pointer(s + 8)) += a - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) += b - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 2*4)) += c - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) += d - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 4*4)) += e - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 5*4)) += f - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 6*4)) += g - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 7*4)) += h + **(**Tuint32_t)(__ccgo_up(s + 8)) += a + **(**Tuint32_t)(__ccgo_up(s + 8 + 1*4)) += b + **(**Tuint32_t)(__ccgo_up(s + 8 + 2*4)) += c + **(**Tuint32_t)(__ccgo_up(s + 8 + 3*4)) += d + **(**Tuint32_t)(__ccgo_up(s + 8 + 4*4)) += e + **(**Tuint32_t)(__ccgo_up(s + 8 + 5*4)) += f + **(**Tuint32_t)(__ccgo_up(s + 8 + 6*4)) += g + **(**Tuint32_t)(__ccgo_up(s + 8 + 7*4)) += h } func _pad1(tls *TLS, s uintptr) { @@ -12511,35 +12511,35 @@ func _pad1(tls *TLS, s uintptr) { r = uint32((*Tsha256)(unsafe.Pointer(s)).Flen1 % uint64(64)) v1 = r r = r + 1 - *(*Tuint8_t)(unsafe.Pointer(s + 40 + uintptr(v1))) = uint8(0x80) + **(**Tuint8_t)(__ccgo_up(s + 40 + uintptr(v1))) = uint8(0x80) if r > uint32(56) { Xmemset(tls, s+40+uintptr(r), 0, uint64(uint32(64)-r)) r = uint32(0) _processblock1(tls, s, s+40) } Xmemset(tls, s+40+uintptr(r), 0, uint64(uint32(56)-r)) - *(*Tuint64_t)(unsafe.Pointer(s)) *= uint64(8) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 56)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(56)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 57)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(48)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 58)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(40)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 59)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(32)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 60)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(24)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 61)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(16)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 62)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(8)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 63)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1) + **(**Tuint64_t)(__ccgo_up(s)) *= uint64(8) + **(**Tuint8_t)(__ccgo_up(s + 40 + 56)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(56)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 57)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(48)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 58)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(40)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 59)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(32)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 60)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(24)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 61)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(16)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 62)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(8)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 63)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1) _processblock1(tls, s, s+40) } func _sha256_init(tls *TLS, s uintptr) { (*Tsha256)(unsafe.Pointer(s)).Flen1 = uint64(0) - *(*Tuint32_t)(unsafe.Pointer(s + 8)) = uint32(0x6a09e667) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) = uint32(0xbb67ae85) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 2*4)) = uint32(0x3c6ef372) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) = uint32(0xa54ff53a) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 4*4)) = uint32(0x510e527f) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 5*4)) = uint32(0x9b05688c) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 6*4)) = uint32(0x1f83d9ab) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 7*4)) = uint32(0x5be0cd19) + **(**Tuint32_t)(__ccgo_up(s + 8)) = uint32(0x6a09e667) + **(**Tuint32_t)(__ccgo_up(s + 8 + 1*4)) = uint32(0xbb67ae85) + **(**Tuint32_t)(__ccgo_up(s + 8 + 2*4)) = uint32(0x3c6ef372) + **(**Tuint32_t)(__ccgo_up(s + 8 + 3*4)) = uint32(0xa54ff53a) + **(**Tuint32_t)(__ccgo_up(s + 8 + 4*4)) = uint32(0x510e527f) + **(**Tuint32_t)(__ccgo_up(s + 8 + 5*4)) = uint32(0x9b05688c) + **(**Tuint32_t)(__ccgo_up(s + 8 + 6*4)) = uint32(0x1f83d9ab) + **(**Tuint32_t)(__ccgo_up(s + 8 + 7*4)) = uint32(0x5be0cd19) } func _sha256_sum(tls *TLS, s uintptr, md uintptr) { @@ -12551,10 +12551,10 @@ func _sha256_sum(tls *TLS, s uintptr, md uintptr) { if !(i < int32(8)) { break } - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4)) >> int32(24)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i+int32(1)))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4)) >> int32(16)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i+int32(2)))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4)) >> int32(8)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i+int32(3)))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4))) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4)) >> int32(24)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i+int32(1)))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4)) >> int32(16)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i+int32(2)))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4)) >> int32(8)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i+int32(3)))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4))) goto _1 _1: ; @@ -12568,7 +12568,7 @@ func _sha256_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { _, _ = p, r p = m r = uint32((*Tsha256)(unsafe.Pointer(s)).Flen1 % uint64(64)) - *(*Tuint64_t)(unsafe.Pointer(s)) += len1 + **(**Tuint64_t)(__ccgo_up(s)) += len1 if r != 0 { if len1 < uint64(uint32(64)-r) { Xmemcpy(tls, s+40+uintptr(r), p, len1) @@ -12607,7 +12607,7 @@ func _to641(tls *TLS, s uintptr, u uint32, n int32) (r uintptr) { } v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = _b641[u%uint32(64)] + **(**uint8)(__ccgo_up(v2)) = _b641[u%uint32(64)] u = u / uint32(64) } return s @@ -12650,7 +12650,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui var _ /* rounds at bp+200 */ [20]uint8 var _ /* smd at bp+168 */ [32]uint8 _, _, _, _, _, _, _ = i, klen, p, r, salt, slen, u - *(*[20]uint8)(unsafe.Pointer(bp + 200)) = [20]uint8{} + **(**[20]uint8)(__ccgo_up(bp + 200)) = [20]uint8{} /* reject large keys */ klen = uint32(Xstrnlen(tls, key, Uint64FromInt32(Int32FromInt32(KEY_MAX1)+Int32FromInt32(1)))) if klen > uint32(KEY_MAX1) { @@ -12676,14 +12676,14 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui * the host's value of ULONG_MAX. */ salt = salt + uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(salt)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(salt)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } u = Xstrtoul(tls, salt, bp+224, int32(10)) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 224))))) != int32('$') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 224))))) != int32('$') { return uintptr(0) } - salt = *(*uintptr)(unsafe.Pointer(bp + 224)) + uintptr(1) + salt = **(**uintptr)(__ccgo_up(bp + 224)) + uintptr(1) if u < uint64(ROUNDS_MIN) { r = uint32(ROUNDS_MIN) } else { @@ -12698,11 +12698,11 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui } i = uint32(0) for { - if !(i < uint32(SALT_MAX1) && *(*uint8)(unsafe.Pointer(salt + uintptr(i))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(salt + uintptr(i)))) != int32('$')) { + if !(i < uint32(SALT_MAX1) && **(**uint8)(__ccgo_up(salt + uintptr(i))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(salt + uintptr(i)))) != int32('$')) { break } /* reject characters that interfere with /etc/shadow parsing */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(salt + uintptr(i)))) == int32('\n') || Int32FromUint8(*(*uint8)(unsafe.Pointer(salt + uintptr(i)))) == int32(':') { + if Int32FromUint8(**(**uint8)(__ccgo_up(salt + uintptr(i)))) == int32('\n') || Int32FromUint8(**(**uint8)(__ccgo_up(salt + uintptr(i)))) == int32(':') { return uintptr(0) } goto _1 @@ -12756,7 +12756,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui _sha256_init(tls, bp) i = uint32(0) for { - if !(i < Uint32FromInt32(int32(16)+Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp + 104)))[0]))) { + if !(i < Uint32FromInt32(int32(16)+Int32FromUint8((**(**[32]uint8)(__ccgo_up(bp + 104)))[0]))) { break } _sha256_update(tls, bp, salt, uint64(slen)) @@ -12803,14 +12803,14 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui if !(i < uint32(10)) { break } - p = _to641(tls, p, Uint32FromInt32(Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp + 104)))[*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_perm1)) + uintptr(i)*3))])<>Int32FromInt32(6) + (*(*[80]Tuint64_t)(unsafe.Pointer(bp)))[i-int32(7)] + (_ror1(tls, (*(*[80]Tuint64_t)(unsafe.Pointer(bp)))[i-int32(15)], int32(1)) ^ _ror1(tls, (*(*[80]Tuint64_t)(unsafe.Pointer(bp)))[i-int32(15)], int32(8)) ^ (*(*[80]Tuint64_t)(unsafe.Pointer(bp)))[i-int32(15)]>>Int32FromInt32(7)) + (*(*[80]Tuint64_t)(unsafe.Pointer(bp)))[i-int32(16)] + (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i] = _ror1(tls, (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(2)], int32(19)) ^ _ror1(tls, (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(2)], int32(61)) ^ (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(2)]>>Int32FromInt32(6) + (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(7)] + (_ror1(tls, (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(15)], int32(1)) ^ _ror1(tls, (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(15)], int32(8)) ^ (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(15)]>>Int32FromInt32(7)) + (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(16)] goto _2 _2: ; i = i + 1 } - a = *(*Tuint64_t)(unsafe.Pointer(s + 8)) - b = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 1*8)) - c = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 2*8)) - d = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 3*8)) - e = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 4*8)) - f = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 5*8)) - g = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 6*8)) - h = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 7*8)) + a = **(**Tuint64_t)(__ccgo_up(s + 8)) + b = **(**Tuint64_t)(__ccgo_up(s + 8 + 1*8)) + c = **(**Tuint64_t)(__ccgo_up(s + 8 + 2*8)) + d = **(**Tuint64_t)(__ccgo_up(s + 8 + 3*8)) + e = **(**Tuint64_t)(__ccgo_up(s + 8 + 4*8)) + f = **(**Tuint64_t)(__ccgo_up(s + 8 + 5*8)) + g = **(**Tuint64_t)(__ccgo_up(s + 8 + 6*8)) + h = **(**Tuint64_t)(__ccgo_up(s + 8 + 7*8)) i = 0 for { if !(i < int32(80)) { break } - t1 = h + (_ror1(tls, e, int32(14)) ^ _ror1(tls, e, int32(18)) ^ _ror1(tls, e, int32(41))) + (g ^ e&(f^g)) + _K1[i] + (*(*[80]Tuint64_t)(unsafe.Pointer(bp)))[i] + t1 = h + (_ror1(tls, e, int32(14)) ^ _ror1(tls, e, int32(18)) ^ _ror1(tls, e, int32(41))) + (g ^ e&(f^g)) + _K1[i] + (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i] t2 = _ror1(tls, a, int32(28)) ^ _ror1(tls, a, int32(34)) ^ _ror1(tls, a, int32(39)) + (a&b | c&(a|b)) h = g g = f @@ -13050,14 +13050,14 @@ func _processblock2(tls *TLS, s uintptr, buf uintptr) { ; i = i + 1 } - *(*Tuint64_t)(unsafe.Pointer(s + 8)) += a - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 1*8)) += b - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 2*8)) += c - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 3*8)) += d - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 4*8)) += e - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 5*8)) += f - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 6*8)) += g - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 7*8)) += h + **(**Tuint64_t)(__ccgo_up(s + 8)) += a + **(**Tuint64_t)(__ccgo_up(s + 8 + 1*8)) += b + **(**Tuint64_t)(__ccgo_up(s + 8 + 2*8)) += c + **(**Tuint64_t)(__ccgo_up(s + 8 + 3*8)) += d + **(**Tuint64_t)(__ccgo_up(s + 8 + 4*8)) += e + **(**Tuint64_t)(__ccgo_up(s + 8 + 5*8)) += f + **(**Tuint64_t)(__ccgo_up(s + 8 + 6*8)) += g + **(**Tuint64_t)(__ccgo_up(s + 8 + 7*8)) += h } func _pad2(tls *TLS, s uintptr) { @@ -13066,35 +13066,35 @@ func _pad2(tls *TLS, s uintptr) { r = uint32((*Tsha512)(unsafe.Pointer(s)).Flen1 % uint64(128)) v1 = r r = r + 1 - *(*Tuint8_t)(unsafe.Pointer(s + 72 + uintptr(v1))) = uint8(0x80) + **(**Tuint8_t)(__ccgo_up(s + 72 + uintptr(v1))) = uint8(0x80) if r > uint32(112) { Xmemset(tls, s+72+uintptr(r), 0, uint64(uint32(128)-r)) r = uint32(0) _processblock2(tls, s, s+72) } Xmemset(tls, s+72+uintptr(r), 0, uint64(uint32(120)-r)) - *(*Tuint64_t)(unsafe.Pointer(s)) *= uint64(8) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 120)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(56)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 121)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(48)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 122)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(40)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 123)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(32)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 124)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(24)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 125)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(16)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 126)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(8)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 127)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1) + **(**Tuint64_t)(__ccgo_up(s)) *= uint64(8) + **(**Tuint8_t)(__ccgo_up(s + 72 + 120)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(56)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 121)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(48)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 122)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(40)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 123)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(32)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 124)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(24)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 125)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(16)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 126)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(8)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 127)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1) _processblock2(tls, s, s+72) } func _sha512_init(tls *TLS, s uintptr) { (*Tsha512)(unsafe.Pointer(s)).Flen1 = uint64(0) - *(*Tuint64_t)(unsafe.Pointer(s + 8)) = uint64(0x6a09e667f3bcc908) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 1*8)) = uint64(0xbb67ae8584caa73b) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 2*8)) = uint64(0x3c6ef372fe94f82b) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 3*8)) = uint64(0xa54ff53a5f1d36f1) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 4*8)) = uint64(0x510e527fade682d1) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 5*8)) = uint64(0x9b05688c2b3e6c1f) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 6*8)) = uint64(0x1f83d9abfb41bd6b) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 7*8)) = uint64(0x5be0cd19137e2179) + **(**Tuint64_t)(__ccgo_up(s + 8)) = uint64(0x6a09e667f3bcc908) + **(**Tuint64_t)(__ccgo_up(s + 8 + 1*8)) = uint64(0xbb67ae8584caa73b) + **(**Tuint64_t)(__ccgo_up(s + 8 + 2*8)) = uint64(0x3c6ef372fe94f82b) + **(**Tuint64_t)(__ccgo_up(s + 8 + 3*8)) = uint64(0xa54ff53a5f1d36f1) + **(**Tuint64_t)(__ccgo_up(s + 8 + 4*8)) = uint64(0x510e527fade682d1) + **(**Tuint64_t)(__ccgo_up(s + 8 + 5*8)) = uint64(0x9b05688c2b3e6c1f) + **(**Tuint64_t)(__ccgo_up(s + 8 + 6*8)) = uint64(0x1f83d9abfb41bd6b) + **(**Tuint64_t)(__ccgo_up(s + 8 + 7*8)) = uint64(0x5be0cd19137e2179) } func _sha512_sum(tls *TLS, s uintptr, md uintptr) { @@ -13106,14 +13106,14 @@ func _sha512_sum(tls *TLS, s uintptr, md uintptr) { if !(i < int32(8)) { break } - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(56)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(1)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(48)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(2)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(40)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(3)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(32)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(4)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(24)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(5)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(16)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(6)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(8)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(7)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8))) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(56)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(1)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(48)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(2)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(40)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(3)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(32)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(4)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(24)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(5)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(16)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(6)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(8)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(7)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8))) goto _1 _1: ; @@ -13127,7 +13127,7 @@ func _sha512_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { _, _ = p, r p = m r = uint32((*Tsha512)(unsafe.Pointer(s)).Flen1 % uint64(128)) - *(*Tuint64_t)(unsafe.Pointer(s)) += len1 + **(**Tuint64_t)(__ccgo_up(s)) += len1 if r != 0 { if len1 < uint64(uint32(128)-r) { Xmemcpy(tls, s+72+uintptr(r), p, len1) @@ -13166,7 +13166,7 @@ func _to642(tls *TLS, s uintptr, u uint32, n int32) (r uintptr) { } v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = _b642[u%uint32(64)] + **(**uint8)(__ccgo_up(v2)) = _b642[u%uint32(64)] u = u / uint32(64) } return s @@ -13209,11 +13209,11 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui var _ /* rounds at bp+392 */ [20]uint8 var _ /* smd at bp+328 */ [64]uint8 _, _, _, _, _, _, _ = i, klen, p, r, salt, slen, u - *(*[20]uint8)(unsafe.Pointer(bp + 392)) = [20]uint8{} + **(**[20]uint8)(__ccgo_up(bp + 392)) = [20]uint8{} /* reject large keys */ i = uint32(0) for { - if !(i <= uint32(KEY_MAX1) && *(*uint8)(unsafe.Pointer(key + uintptr(i))) != 0) { + if !(i <= uint32(KEY_MAX1) && **(**uint8)(__ccgo_up(key + uintptr(i))) != 0) { break } goto _1 @@ -13245,14 +13245,14 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui * the host's value of ULONG_MAX. */ salt = salt + uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(salt)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(salt)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } u = Xstrtoul(tls, salt, bp+416, int32(10)) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 416))))) != int32('$') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 416))))) != int32('$') { return uintptr(0) } - salt = *(*uintptr)(unsafe.Pointer(bp + 416)) + uintptr(1) + salt = **(**uintptr)(__ccgo_up(bp + 416)) + uintptr(1) if u < uint64(ROUNDS_MIN) { r = uint32(ROUNDS_MIN) } else { @@ -13267,11 +13267,11 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui } i = uint32(0) for { - if !(i < uint32(SALT_MAX1) && *(*uint8)(unsafe.Pointer(salt + uintptr(i))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(salt + uintptr(i)))) != int32('$')) { + if !(i < uint32(SALT_MAX1) && **(**uint8)(__ccgo_up(salt + uintptr(i))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(salt + uintptr(i)))) != int32('$')) { break } /* reject characters that interfere with /etc/shadow parsing */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(salt + uintptr(i)))) == int32('\n') || Int32FromUint8(*(*uint8)(unsafe.Pointer(salt + uintptr(i)))) == int32(':') { + if Int32FromUint8(**(**uint8)(__ccgo_up(salt + uintptr(i)))) == int32('\n') || Int32FromUint8(**(**uint8)(__ccgo_up(salt + uintptr(i)))) == int32(':') { return uintptr(0) } goto _2 @@ -13325,7 +13325,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui _sha512_init(tls, bp) i = uint32(0) for { - if !(i < Uint32FromInt32(int32(16)+Int32FromUint8((*(*[64]uint8)(unsafe.Pointer(bp + 200)))[0]))) { + if !(i < Uint32FromInt32(int32(16)+Int32FromUint8((**(**[64]uint8)(__ccgo_up(bp + 200)))[0]))) { break } _sha512_update(tls, bp, salt, uint64(slen)) @@ -13372,14 +13372,14 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui if !(i < uint32(21)) { break } - p = _to642(tls, p, Uint32FromInt32(Int32FromUint8((*(*[64]uint8)(unsafe.Pointer(bp + 200)))[*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_perm2)) + uintptr(i)*3))])<= 0) { break } v3 = bp + uintptr(i) - *(*uint8)(unsafe.Pointer(v3)) = uint8(uint32(*(*uint8)(unsafe.Pointer(v3))) | Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(key)))&Int32FromInt32(1))<= 0) { break } - *(*Tuint32_t)(unsafe.Pointer(bp + 128 + uintptr(i)*4)) |= Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))&Int32FromInt32(1)) << j + **(**Tuint32_t)(__ccgo_up(bp + 128 + uintptr(i)*4)) |= Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(p)))&Int32FromInt32(1)) << j goto _2 _2: ; @@ -13597,15 +13597,15 @@ func Xencrypt(tls *TLS, block uintptr, edflag int32) { if !(i < int32(16)) { break } - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(i)*4)) = *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&___encrypt_key)) + uintptr(int32(15)-i)*4)) - *(*Tuint32_t)(unsafe.Pointer(bp + 64 + uintptr(i)*4)) = *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&___encrypt_key)) + 64 + uintptr(int32(15)-i)*4)) + **(**Tuint32_t)(__ccgo_up(bp + uintptr(i)*4)) = **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&___encrypt_key)) + uintptr(int32(15)-i)*4)) + **(**Tuint32_t)(__ccgo_up(bp + 64 + uintptr(i)*4)) = **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&___encrypt_key)) + 64 + uintptr(int32(15)-i)*4)) goto _3 _3: ; i = i + 1 } } - X__do_des(tls, (*(*[2]Tuint32_t)(unsafe.Pointer(bp + 128)))[0], (*(*[2]Tuint32_t)(unsafe.Pointer(bp + 128)))[int32(1)], bp+128, bp+128+uintptr(1)*4, uint32(1), uint32(0), key) + X__do_des(tls, (**(**[2]Tuint32_t)(__ccgo_up(bp + 128)))[0], (**(**[2]Tuint32_t)(__ccgo_up(bp + 128)))[int32(1)], bp+128, bp+128+uintptr(1)*4, uint32(1), uint32(0), key) p = block i = 0 for { @@ -13619,7 +13619,7 @@ func Xencrypt(tls *TLS, block uintptr, edflag int32) { } v6 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v6)) = uint8((*(*[2]Tuint32_t)(unsafe.Pointer(bp + 128)))[i] >> j & uint32(1)) + **(**uint8)(__ccgo_up(v6)) = uint8((**(**[2]Tuint32_t)(__ccgo_up(bp + 128)))[i] >> j & uint32(1)) goto _5 _5: ; @@ -14092,7 +14092,7 @@ func X__ctype_get_mb_cur_max(tls *TLS) (r Tsize_t) { } var v1 int32 _ = v1 - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v1 = int32(4) } else { v1 = int32(1) @@ -17656,10 +17656,10 @@ func Xwctype(tls *TLS, s uintptr) (r Twctype_t) { i = int32(1) p = uintptr(unsafe.Pointer(&_names)) for { - if !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if !(**(**uint8)(__ccgo_up(p)) != 0) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) && !(Xstrcmp(tls, s, p) != 0) { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == Int32FromUint8(**(**uint8)(__ccgo_up(p))) && !(Xstrcmp(tls, s, p) != 0) { return Uint64FromInt32(i) } goto _1 @@ -22405,9 +22405,9 @@ func _casemap(tls *TLS, c uint32, dir int32) (r1 int32) { xn = Uint32FromInt32(rd & int32(0xff)) xb = Uint32FromInt32(rd) >> int32(8) for xn != 0 { - try = uint32(*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_exceptions)) + uintptr(xb+xn/uint32(2))*2))) + try = uint32(**(**uint8)(__ccgo_up(uintptr(unsafe.Pointer(&_exceptions)) + uintptr(xb+xn/uint32(2))*2))) if try == c { - r = _rules[*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_exceptions)) + uintptr(xb+xn/uint32(2))*2 + 1))] + r = _rules[**(**uint8)(__ccgo_up(uintptr(unsafe.Pointer(&_exceptions)) + uintptr(xb+xn/uint32(2))*2 + 1))] rt = Uint32FromInt32(r & int32(255)) rd = r >> int32(8) if rt < uint32(2) { @@ -22500,8 +22500,8 @@ func Xwcswidth(tls *TLS, wcs uintptr, n Tsize_t) (r int32) { for { v2 = n n = n - 1 - if v4 = v2 != 0 && *(*Twchar_t)(unsafe.Pointer(wcs)) != 0; v4 { - v3 = Xwcwidth(tls, *(*Twchar_t)(unsafe.Pointer(wcs))) + if v4 = v2 != 0 && **(**Twchar_t)(__ccgo_up(wcs)) != 0; v4 { + v3 = Xwcwidth(tls, **(**Twchar_t)(__ccgo_up(wcs))) k = v3 } if !(v4 && v3 >= 0) { @@ -24701,7 +24701,7 @@ func Xalphasort(tls *TLS, a uintptr, b uintptr) (r int32) { trc("tls=%v a=%v b=%v, (%v:)", tls, a, b, origin(2)) defer func() { trc("-> %v", r) }() } - return Xstrcoll(tls, *(*uintptr)(unsafe.Pointer(a))+19, *(*uintptr)(unsafe.Pointer(b))+19) + return Xstrcoll(tls, **(**uintptr)(__ccgo_up(a))+19, **(**uintptr)(__ccgo_up(b))+19) } type TDIR = struct { @@ -24868,11 +24868,11 @@ func Xfdopendir(tls *TLS, fd int32) (r uintptr) { return uintptr(0) } if Xfcntl(tls, fd, int32(F_GETFL), 0)&int32(O_PATH) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EBADF) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EBADF) return uintptr(0) } - if !((*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&Uint32FromInt32(S_IFMT) == Uint32FromInt32(S_IFDIR)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOTDIR) + if !((**(**Tstat)(__ccgo_up(bp))).Fst_mode&Uint32FromInt32(S_IFMT) == Uint32FromInt32(S_IFDIR)) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOTDIR) return uintptr(0) } v1 = Xcalloc(tls, uint64(1), uint64(2072)) @@ -25007,7 +25007,7 @@ func Xreaddir(tls *TLS, dir uintptr) (r uintptr) { len1 = int32(X__syscall3(tls, int64(SYS_getdents64), int64((*TDIR)(unsafe.Pointer(dir)).Ffd), int64(dir+24), Int64FromUint64(Uint64FromInt64(2048)))) if len1 <= 0 { if len1 < 0 && len1 != -int32(ENOENT) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = -len1 + **(**int32)(__ccgo_up(X__errno_location(tls))) = -len1 } return uintptr(0) } @@ -25015,7 +25015,7 @@ func Xreaddir(tls *TLS, dir uintptr) (r uintptr) { (*TDIR)(unsafe.Pointer(dir)).Fbuf_pos = 0 } de = dir + 24 + uintptr((*TDIR)(unsafe.Pointer(dir)).Fbuf_pos) - *(*int32)(unsafe.Pointer(dir + 12)) += Int32FromUint16((*Tdirent)(unsafe.Pointer(de)).Fd_reclen) + **(**int32)(__ccgo_up(dir + 12)) += Int32FromUint16((*Tdirent)(unsafe.Pointer(de)).Fd_reclen) (*TDIR)(unsafe.Pointer(dir)).Ftell = (*Tdirent)(unsafe.Pointer(de)).Fd_off return de } @@ -25028,24 +25028,24 @@ func Xreaddir_r(tls *TLS, dir uintptr, buf uintptr, result uintptr) (r int32) { var de uintptr var errno_save, ret, v1 int32 _, _, _, _ = de, errno_save, ret, v1 - errno_save = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + errno_save = **(**int32)(__ccgo_up(X__errno_location(tls))) ___lock(tls, dir+20) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = 0 + **(**int32)(__ccgo_up(X__errno_location(tls))) = 0 de = Xreaddir(tls, dir) - v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = **(**int32)(__ccgo_up(X__errno_location(tls))) ret = v1 if v1 != 0 { ___unlock(tls, dir+20) return ret } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = errno_save + **(**int32)(__ccgo_up(X__errno_location(tls))) = errno_save if de != 0 { Xmemcpy(tls, buf, de, uint64((*Tdirent)(unsafe.Pointer(de)).Fd_reclen)) } else { buf = UintptrFromInt32(0) } ___unlock(tls, dir+20) - *(*uintptr)(unsafe.Pointer(result)) = buf + **(**uintptr)(__ccgo_up(result)) = buf return 0 } @@ -25081,12 +25081,12 @@ func Xscandir(tls *TLS, path uintptr, res uintptr, __ccgo_fp_sel uintptr, __ccgo names = uintptr(0) cnt = uint64(0) len1 = uint64(0) - old_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + old_errno = **(**int32)(__ccgo_up(X__errno_location(tls))) if !(d != 0) { return -int32(1) } for { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = 0 + **(**int32)(__ccgo_up(X__errno_location(tls))) = 0 v1 = Xreaddir(tls, d) de = v1 if !(v1 != 0) { @@ -25106,16 +25106,16 @@ func Xscandir(tls *TLS, path uintptr, res uintptr, __ccgo_fp_sel uintptr, __ccgo } names = tmp } - *(*uintptr)(unsafe.Pointer(names + uintptr(cnt)*8)) = Xmalloc(tls, uint64((*Tdirent)(unsafe.Pointer(de)).Fd_reclen)) - if !(*(*uintptr)(unsafe.Pointer(names + uintptr(cnt)*8)) != 0) { + **(**uintptr)(__ccgo_up(names + uintptr(cnt)*8)) = Xmalloc(tls, uint64((*Tdirent)(unsafe.Pointer(de)).Fd_reclen)) + if !(**(**uintptr)(__ccgo_up(names + uintptr(cnt)*8)) != 0) { break } v2 = cnt cnt = cnt + 1 - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(names + uintptr(v2)*8)), de, uint64((*Tdirent)(unsafe.Pointer(de)).Fd_reclen)) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(names + uintptr(v2)*8)), de, uint64((*Tdirent)(unsafe.Pointer(de)).Fd_reclen)) } Xclosedir(tls, d) - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != 0 { + if **(**int32)(__ccgo_up(X__errno_location(tls))) != 0 { if names != 0 { for { v2 = cnt @@ -25123,17 +25123,17 @@ func Xscandir(tls *TLS, path uintptr, res uintptr, __ccgo_fp_sel uintptr, __ccgo if !(v2 > uint64(0)) { break } - Xfree(tls, *(*uintptr)(unsafe.Pointer(names + uintptr(cnt)*8))) + Xfree(tls, **(**uintptr)(__ccgo_up(names + uintptr(cnt)*8))) } } Xfree(tls, names) return -int32(1) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = old_errno + **(**int32)(__ccgo_up(X__errno_location(tls))) = old_errno if __ccgo_fp_cmp != 0 { Xqsort(tls, names, cnt, uint64(8), __ccgo_fp_cmp) } - *(*uintptr)(unsafe.Pointer(res)) = names + **(**uintptr)(__ccgo_up(res)) = names return Int32FromUint64(cnt) } @@ -25164,7 +25164,7 @@ func Xversionsort(tls *TLS, a uintptr, b uintptr) (r int32) { trc("tls=%v a=%v b=%v, (%v:)", tls, a, b, origin(2)) defer func() { trc("-> %v", r) }() } - return Xstrverscmp(tls, *(*uintptr)(unsafe.Pointer(a))+19, *(*uintptr)(unsafe.Pointer(b))+19) + return Xstrverscmp(tls, **(**uintptr)(__ccgo_up(a))+19, **(**uintptr)(__ccgo_up(b))+19) } func X__reset_tls(tls *TLS) { @@ -25176,7 +25176,7 @@ func X__reset_tls(tls *TLS) { var self Tpthread_t _, _, _, _, _ = i, mem, n, p, self self = uintptr(___get_tp(tls)) - n = *(*Tuintptr_t)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(self)).Fdtv)) + n = **(**Tuintptr_t)(__ccgo_up((*t__pthread)(unsafe.Pointer(self)).Fdtv)) if n != 0 { p = X__libc.Ftls_head i = Uint64FromInt32(1) @@ -25184,7 +25184,7 @@ func X__reset_tls(tls *TLS) { if !(i <= n) { break } - mem = uintptr(*(*Tuintptr_t)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(self)).Fdtv + uintptr(i)*8)) - Uint64FromInt32(DTP_OFFSET)) + mem = uintptr(**(**Tuintptr_t)(__ccgo_up((*t__pthread)(unsafe.Pointer(self)).Fdtv + uintptr(i)*8)) - Uint64FromInt32(DTP_OFFSET)) Xmemcpy(tls, mem, (*Ttls_module)(unsafe.Pointer(p)).Fimage, (*Ttls_module)(unsafe.Pointer(p)).Flen1) Xmemset(tls, mem+uintptr((*Ttls_module)(unsafe.Pointer(p)).Flen1), 0, (*Ttls_module)(unsafe.Pointer(p)).Fsize-(*Ttls_module)(unsafe.Pointer(p)).Flen1) goto _1 @@ -25210,7 +25210,7 @@ func X__init_ssp(tls *TLS, entropy uintptr) { * The NULL byte is on the second byte so that off-by-ones can * still be detected. Endianness is taken care of * automatically. */ - *(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stack_chk_guard)) + 1)) = uint8(0) + **(**uint8)(__ccgo_up(uintptr(unsafe.Pointer(&X__stack_chk_guard)) + 1)) = uint8(0) (*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Fcanary = X__stack_chk_guard } @@ -25246,10 +25246,10 @@ func Xclearenv(tls *TLS) (r int32) { e = Xenviron Xenviron = uintptr(0) if e != 0 { - for *(*uintptr)(unsafe.Pointer(e)) != 0 { + for **(**uintptr)(__ccgo_up(e)) != 0 { v1 = e e += 8 - X__env_rm_add(tls, *(*uintptr)(unsafe.Pointer(v1)), uintptr(0)) + X__env_rm_add(tls, **(**uintptr)(__ccgo_up(v1)), uintptr(0)) } } return 0 @@ -25264,14 +25264,14 @@ func Xgetenv(tls *TLS, name uintptr) (r uintptr) { var l Tsize_t _, _ = e, l l = Uint64FromInt64(int64(X__strchrnul(tls, name, int32('='))) - int64(name)) - if l != 0 && !(*(*uint8)(unsafe.Pointer(name + uintptr(l))) != 0) && Xenviron != 0 { + if l != 0 && !(**(**uint8)(__ccgo_up(name + uintptr(l))) != 0) && Xenviron != 0 { e = Xenviron for { - if !(*(*uintptr)(unsafe.Pointer(e)) != 0) { + if !(**(**uintptr)(__ccgo_up(e)) != 0) { break } - if !(Xstrncmp(tls, name, *(*uintptr)(unsafe.Pointer(e)), l) != 0) && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(e)) + uintptr(l)))) == int32('=') { - return *(*uintptr)(unsafe.Pointer(e)) + uintptr(l) + uintptr(1) + if !(Xstrncmp(tls, name, **(**uintptr)(__ccgo_up(e)), l) != 0) && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(e)) + uintptr(l)))) == int32('=') { + return **(**uintptr)(__ccgo_up(e)) + uintptr(l) + uintptr(1) } goto _1 _1: @@ -25297,12 +25297,12 @@ func X__putenv(tls *TLS, s uintptr, l Tsize_t, r uintptr) (r1 int32) { if Xenviron != 0 { e = Xenviron for { - if !(*(*uintptr)(unsafe.Pointer(e)) != 0) { + if !(**(**uintptr)(__ccgo_up(e)) != 0) { break } - if !(Xstrncmp(tls, s, *(*uintptr)(unsafe.Pointer(e)), l+uint64(1)) != 0) { - tmp = *(*uintptr)(unsafe.Pointer(e)) - *(*uintptr)(unsafe.Pointer(e)) = s + if !(Xstrncmp(tls, s, **(**uintptr)(__ccgo_up(e)), l+uint64(1)) != 0) { + tmp = **(**uintptr)(__ccgo_up(e)) + **(**uintptr)(__ccgo_up(e)) = s X__env_rm_add(tls, tmp, r) return 0 } @@ -25328,8 +25328,8 @@ func X__putenv(tls *TLS, s uintptr, l Tsize_t, r uintptr) (r1 int32) { } Xfree(tls, _oldenv) } - *(*uintptr)(unsafe.Pointer(newenv + uintptr(i)*8)) = s - *(*uintptr)(unsafe.Pointer(newenv + uintptr(i+uint64(1))*8)) = uintptr(0) + **(**uintptr)(__ccgo_up(newenv + uintptr(i)*8)) = s + **(**uintptr)(__ccgo_up(newenv + uintptr(i+uint64(1))*8)) = uintptr(0) v2 = newenv _oldenv = v2 Xenviron = v2 @@ -25354,7 +25354,7 @@ func Xputenv(tls *TLS, s uintptr) (r int32) { var l Tsize_t _ = l l = Uint64FromInt64(int64(X__strchrnul(tls, s, int32('='))) - int64(s)) - if !(l != 0) || !(*(*uint8)(unsafe.Pointer(s + uintptr(l))) != 0) { + if !(l != 0) || !(**(**uint8)(__ccgo_up(s + uintptr(l))) != 0) { return Xunsetenv(tls, s) } return X__putenv(tls, s, l, uintptr(0)) @@ -25399,13 +25399,13 @@ func X__env_rm_add(tls *TLS, old uintptr, new1 uintptr) { if !(i < _env_alloced_n) { break } - if *(*uintptr)(unsafe.Pointer(_env_alloced + uintptr(i)*8)) == old { - *(*uintptr)(unsafe.Pointer(_env_alloced + uintptr(i)*8)) = new1 + if **(**uintptr)(__ccgo_up(_env_alloced + uintptr(i)*8)) == old { + **(**uintptr)(__ccgo_up(_env_alloced + uintptr(i)*8)) = new1 Xfree(tls, old) return } else { - if !(*(*uintptr)(unsafe.Pointer(_env_alloced + uintptr(i)*8)) != 0) && new1 != 0 { - *(*uintptr)(unsafe.Pointer(_env_alloced + uintptr(i)*8)) = new1 + if !(**(**uintptr)(__ccgo_up(_env_alloced + uintptr(i)*8)) != 0) && new1 != 0 { + **(**uintptr)(__ccgo_up(_env_alloced + uintptr(i)*8)) = new1 new1 = uintptr(0) } } @@ -25425,7 +25425,7 @@ func X__env_rm_add(tls *TLS, old uintptr, new1 uintptr) { _env_alloced = v2 v3 = _env_alloced_n _env_alloced_n = _env_alloced_n + 1 - *(*uintptr)(unsafe.Pointer(v2 + uintptr(v3)*8)) = new1 + **(**uintptr)(__ccgo_up(v2 + uintptr(v3)*8)) = new1 } var _env_alloced uintptr @@ -25445,8 +25445,8 @@ func Xsetenv(tls *TLS, var1 uintptr, value uintptr, overwrite int32) (r int32) { v1 = Uint64FromInt64(int64(X__strchrnul(tls, var1, int32('='))) - int64(var1)) l1 = v1 } - if v2 || !(v1 != 0) || *(*uint8)(unsafe.Pointer(var1 + uintptr(l1))) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if v2 || !(v1 != 0) || **(**uint8)(__ccgo_up(var1 + uintptr(l1))) != 0 { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } if !(overwrite != 0) && Xgetenv(tls, var1) != 0 { @@ -25458,7 +25458,7 @@ func Xsetenv(tls *TLS, var1 uintptr, value uintptr, overwrite int32) (r int32) { return -int32(1) } Xmemcpy(tls, s, var1, l1) - *(*uint8)(unsafe.Pointer(s + uintptr(l1))) = uint8('=') + **(**uint8)(__ccgo_up(s + uintptr(l1))) = uint8('=') Xmemcpy(tls, s+uintptr(l1)+uintptr(1), value, l2+uint64(1)) return X__putenv(tls, s, l1, s) } @@ -25475,24 +25475,24 @@ func Xunsetenv(tls *TLS, name uintptr) (r int32) { var l Tsize_t _, _, _, _ = e, eo, l, v2 l = Uint64FromInt64(int64(X__strchrnul(tls, name, int32('='))) - int64(name)) - if !(l != 0) || *(*uint8)(unsafe.Pointer(name + uintptr(l))) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if !(l != 0) || **(**uint8)(__ccgo_up(name + uintptr(l))) != 0 { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } if Xenviron != 0 { e = Xenviron eo = e for { - if !(*(*uintptr)(unsafe.Pointer(e)) != 0) { + if !(**(**uintptr)(__ccgo_up(e)) != 0) { break } - if !(Xstrncmp(tls, name, *(*uintptr)(unsafe.Pointer(e)), l) != 0) && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(e)) + uintptr(l)))) == int32('=') { - X__env_rm_add(tls, *(*uintptr)(unsafe.Pointer(e)), uintptr(0)) + if !(Xstrncmp(tls, name, **(**uintptr)(__ccgo_up(e)), l) != 0) && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(e)) + uintptr(l)))) == int32('=') { + X__env_rm_add(tls, **(**uintptr)(__ccgo_up(e)), uintptr(0)) } else { if eo != e { v2 = eo eo += 8 - *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(e)) + **(**uintptr)(__ccgo_up(v2)) = **(**uintptr)(__ccgo_up(e)) } else { eo += 8 } @@ -25503,7 +25503,7 @@ func Xunsetenv(tls *TLS, name uintptr) (r int32) { e += 8 } if eo != e { - *(*uintptr)(unsafe.Pointer(eo)) = uintptr(0) + **(**uintptr)(__ccgo_up(eo)) = uintptr(0) } } return 0 @@ -25813,7 +25813,7 @@ func X__strerror_l(tls *TLS, e int32, loc Tlocale_t) (r uintptr) { e = 0 } s = uintptr(unsafe.Pointer(&_errmsgstr)) + uintptr(_errmsgidx[e]) - return X__lctrans(tls, s, *(*uintptr)(unsafe.Pointer(loc + 5*8))) + return X__lctrans(tls, s, **(**uintptr)(__ccgo_up(loc + 5*8))) } func Xstrerror(tls *TLS, e int32) (r uintptr) { @@ -25950,10 +25950,10 @@ func Xfcntl(tls *TLS, fd int32, cmd int32, va uintptr) (r int32) { if ret != 0 { return int32(X__syscall_ret(tls, Uint64FromInt32(ret))) } - if (*(*Tf_owner_ex)(unsafe.Pointer(bp))).Ftype1 == int32(F_OWNER_PGRP) { - v1 = -(*(*Tf_owner_ex)(unsafe.Pointer(bp))).Fpid + if (**(**Tf_owner_ex)(__ccgo_up(bp))).Ftype1 == int32(F_OWNER_PGRP) { + v1 = -(**(**Tf_owner_ex)(__ccgo_up(bp))).Fpid } else { - v1 = (*(*Tf_owner_ex)(unsafe.Pointer(bp))).Fpid + v1 = (**(**Tf_owner_ex)(__ccgo_up(bp))).Fpid } return v1 } @@ -26153,7 +26153,7 @@ func Xfegetenv(tls *TLS, envp uintptr) (r int32) { trc("tls=%v envp=%v, (%v:)", tls, envp, origin(2)) defer func() { trc("-> %v", r) }() } - *(*Tfenv_t)(unsafe.Pointer(envp)) = _get_fpscr_f(tls) + **(**Tfenv_t)(__ccgo_up(envp)) = _get_fpscr_f(tls) return 0 } @@ -26165,7 +26165,7 @@ func Xfesetenv(tls *TLS, envp uintptr) (r int32) { var v1 Tfenv_t _ = v1 if envp != uintptr(-Int32FromInt32(1)) { - v1 = *(*Tfenv_t)(unsafe.Pointer(envp)) + v1 = **(**Tfenv_t)(__ccgo_up(envp)) } else { v1 = Float64FromInt32(0) } @@ -26250,7 +26250,7 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26261,7 +26261,7 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26291,7 +26291,7 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26310,7 +26310,7 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26327,7 +26327,7 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26380,7 +26380,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__shgetc(tls, f) } @@ -26392,7 +26392,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__shgetc(tls, f) } @@ -26410,14 +26410,14 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__shgetc(tls, f) } c = v2 } } - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0] = uint32(0) + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[0] = uint32(0) for { if !(Uint32FromInt32(c-int32('0')) < uint32(10) || c == int32('.')) { break @@ -26435,9 +26435,9 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, lnz = int32(dc) } if j != 0 { - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k]*uint32(10) + Uint32FromInt32(c) - uint32('0') + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] = (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k]*uint32(10) + Uint32FromInt32(c) - uint32('0') } else { - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] = Uint32FromInt32(c - int32('0')) + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] = Uint32FromInt32(c - int32('0')) } j = j + 1 v2 = j @@ -26450,7 +26450,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, dc = dc + 1 if c != int32('0') { lnz = (Int32FromInt32(KMAX) - Int32FromInt32(4)) * Int32FromInt32(9) - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(Int32FromInt32(KMAX)-Int32FromInt32(4))*4)) |= uint32(1) + **(**Tuint32_t)(__ccgo_up(bp + uintptr(Int32FromInt32(KMAX)-Int32FromInt32(4))*4)) |= uint32(1) } } } @@ -26461,7 +26461,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__shgetc(tls, f) } @@ -26492,24 +26492,24 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, } } if !(gotdig != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) X__shlim(tls, f, int64(Int32FromInt32(0))) return Float64FromInt32(0) } /* Handle zero specially to avoid nasty special cases later */ - if !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0] != 0) { + if !((**(**[128]Tuint32_t)(__ccgo_up(bp)))[0] != 0) { return float64(float64(sign) * float64(0)) } /* Optimize small integers (w/no exponent) and over/under-flow */ - if lrp == dc && dc < int64(10) && (bits > int32(30) || (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0]>>bits == uint32(0)) { - return float64(float64(sign) * float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0])) + if lrp == dc && dc < int64(10) && (bits > int32(30) || (**(**[128]Tuint32_t)(__ccgo_up(bp)))[0]>>bits == uint32(0)) { + return float64(float64(sign) * float64((**(**[128]Tuint32_t)(__ccgo_up(bp)))[0])) } if lrp > int64(-emin/int32(2)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return float64(float64(float64(sign)*Float64FromFloat64(1.79769313486231570815e+308)) * Float64FromFloat64(1.79769313486231570815e+308)) } if lrp < int64(emin-Int32FromInt32(2)*Int32FromInt32(LDBL_MANT_DIG)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return float64(float64(float64(sign)*Float64FromFloat64(2.22507385850720138309e-308)) * Float64FromFloat64(2.22507385850720138309e-308)) } /* Align incomplete final B1B digit */ @@ -26518,7 +26518,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if !(j < int32(9)) { break } - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(k)*4)) *= uint32(10) + **(**Tuint32_t)(__ccgo_up(bp + uintptr(k)*4)) *= uint32(10) goto _17 _17: ; @@ -26534,19 +26534,19 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, /* Optimize small to mid-size integers (even in exp. notation) */ if lnz < int32(9) && lnz <= rp && rp < int32(18) { if rp == int32(9) { - return float64(float64(sign) * float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0])) + return float64(float64(sign) * float64((**(**[128]Tuint32_t)(__ccgo_up(bp)))[0])) } if rp < int32(9) { - return float64(float64(sign)*float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0])) / float64(_p10s[int32(8)-rp]) + return float64(float64(sign)*float64((**(**[128]Tuint32_t)(__ccgo_up(bp)))[0])) / float64(_p10s[int32(8)-rp]) } bitlim = bits - int32(3)*(rp-Int32FromInt32(9)) - if bitlim > int32(30) || (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0]>>bitlim == uint32(0) { - return float64(float64(float64(sign)*float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0])) * float64(_p10s[rp-int32(10)])) + if bitlim > int32(30) || (**(**[128]Tuint32_t)(__ccgo_up(bp)))[0]>>bitlim == uint32(0) { + return float64(float64(float64(sign)*float64((**(**[128]Tuint32_t)(__ccgo_up(bp)))[0])) * float64(_p10s[rp-int32(10)])) } } /* Drop trailing zeros */ for { - if !!((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[z-int32(1)] != 0) { + if !!((**(**[128]Tuint32_t)(__ccgo_up(bp)))[z-int32(1)] != 0) { break } goto _18 @@ -26569,10 +26569,10 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if !(k != z) { break } - tmp = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] % Uint32FromInt32(p10) - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k]/Uint32FromInt32(p10) + carry + tmp = (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] % Uint32FromInt32(p10) + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] = (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k]/Uint32FromInt32(p10) + carry carry = Uint32FromInt32(int32(1000000000)/p10) * tmp - if k == a && !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] != 0) { + if k == a && !((**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] != 0) { a = (a + int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) rp = rp - int32(9) } @@ -26584,25 +26584,25 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if carry != 0 { v2 = z z = z + 1 - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v2] = carry + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[v2] = carry } rp = rp + (int32(9) - rpm9) } /* Upscale until desired number of bits are left of radix point */ - for rp < Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) || rp == Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) && (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[a] < _th[0] { + for rp < Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) || rp == Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) && (**(**[128]Tuint32_t)(__ccgo_up(bp)))[a] < _th[0] { carry1 = uint32(0) e2 = e2 - int32(29) k = (z - int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) for { - tmp1 = uint64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k])< uint64(1000000000) { carry1 = uint32(tmp1 / uint64(1000000000)) - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] = uint32(tmp1 % uint64(1000000000)) + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] = uint32(tmp1 % uint64(1000000000)) } else { carry1 = uint32(0) - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] = uint32(tmp1) + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] = uint32(tmp1) } - if k == (z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) && k != a && !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] != 0) { + if k == (z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) && k != a && !((**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] != 0) { z = k } if k == a { @@ -26618,9 +26618,9 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, a = (a - int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) if a == z { z = (z - int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr((z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)))*4)) |= (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[z] + **(**Tuint32_t)(__ccgo_up(bp + uintptr((z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)))*4)) |= (**(**[128]Tuint32_t)(__ccgo_up(bp)))[z] } - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[a] = carry1 + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[a] = carry1 } } /* Downscale until exactly number of bits are left of radix point */ @@ -26633,11 +26633,11 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, break } k = (a + i) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) - if k == z || (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] < _th[i] { + if k == z || (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] < _th[i] { i = int32(LD_B1B_DIG) break } - if (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))] > _th[i] { + if (**(**[128]Tuint32_t)(__ccgo_up(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))] > _th[i] { break } goto _24 @@ -26658,10 +26658,10 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if !(k != z) { break } - tmp2 = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] & Uint32FromInt32(int32(1)<>sh + carry2 + tmp2 = (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] & Uint32FromInt32(int32(1)<>sh + carry2 carry2 = Uint32FromInt32(Int32FromInt32(1000000000)>>sh) * tmp2 - if k == a && !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] != 0) { + if k == a && !((**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] != 0) { a = (a + int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) i = i - 1 rp = rp - int32(9) @@ -26673,10 +26673,10 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, } if carry2 != 0 { if (z+int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) != a { - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[z] = carry2 + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[z] = carry2 z = (z + int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) } else { - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr((z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)))*4)) |= uint32(1) + **(**Tuint32_t)(__ccgo_up(bp + uintptr((z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)))*4)) |= uint32(1) } } goto _23 @@ -26693,9 +26693,9 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if (a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1)) == z { v6 = (z + Int32FromInt32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) z = v6 - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v6-int32(1)] = uint32(0) + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[v6-int32(1)] = uint32(0) } - y = float64(Float64FromFloat64(1e+09)*y) + float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))]) + y = float64(Float64FromFloat64(1e+09)*y) + float64((**(**[128]Tuint32_t)(__ccgo_up(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))]) goto _26 _26: ; @@ -26719,7 +26719,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, } /* Process tail of decimal input so it can affect rounding */ if (a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1)) != z { - t = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))] + t = (**(**[128]Tuint32_t)(__ccgo_up(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))] if t < uint32(500000000) && (t != 0 || (a+i+int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) != z) { frac = frac + float64(float64(0.25)*float64(sign)) } else { @@ -26750,7 +26750,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, e2 = e2 + 1 } if e2+int32(LDBL_MANT_DIG) > emax || denormal != 0 && frac != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) } } return Xscalbnl(tls, y, e2) @@ -26793,7 +26793,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26811,7 +26811,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26823,7 +26823,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26842,7 +26842,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26889,7 +26889,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26943,11 +26943,11 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 return float64(float64(sign) * float64(0)) } if e2 > int64(-emin) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return float64(float64(float64(sign)*Float64FromFloat64(1.79769313486231570815e+308)) * Float64FromFloat64(1.79769313486231570815e+308)) } if e2 < int64(emin-Int32FromInt32(2)*Int32FromInt32(LDBL_MANT_DIG)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return float64(float64(float64(sign)*Float64FromFloat64(2.22507385850720138309e-308)) * Float64FromFloat64(2.22507385850720138309e-308)) } for x < uint32(0x80000000) { @@ -26976,7 +26976,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 y = bias + float64(float64(sign)*float64(x)) + float64(float64(sign)*y) y = y - bias if !(y != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) } return Xscalbnl(tls, y, int32(e2)) } @@ -27009,7 +27009,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__shgetc(tls, f) } @@ -27029,7 +27029,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27037,7 +27037,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { } i = uint64(0) for { - if !(i < uint64(8) && c|int32(32) == Int32FromUint8(*(*uint8)(unsafe.Pointer(__ccgo_ts + 344 + uintptr(i))))) { + if !(i < uint64(8) && c|int32(32) == Int32FromUint8(**(**uint8)(__ccgo_up(__ccgo_ts + 344 + uintptr(i))))) { break } if i < uint64(7) { @@ -27045,7 +27045,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27081,7 +27081,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { if !(i != 0) { i = uint64(0) for { - if !(i < uint64(3) && c|int32(32) == Int32FromUint8(*(*uint8)(unsafe.Pointer(__ccgo_ts + 353 + uintptr(i))))) { + if !(i < uint64(3) && c|int32(32) == Int32FromUint8(**(**uint8)(__ccgo_up(__ccgo_ts + 353 + uintptr(i))))) { break } if i < uint64(2) { @@ -27089,7 +27089,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27106,7 +27106,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27122,7 +27122,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27137,7 +27137,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if !(pok != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) X__shlim(tls, f, int64(Int32FromInt32(0))) return Float64FromInt32(0) } @@ -27163,7 +27163,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) X__shlim(tls, f, int64(Int32FromInt32(0))) return Float64FromInt32(0) } @@ -27172,7 +27172,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27463,7 +27463,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint val = uintptr(unsafe.Pointer(&_table6)) + uintptr(1) neg = 0 if base > uint32(36) || base == uint32(1) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uint64(0) } for { @@ -27471,7 +27471,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__shgetc(tls, f) } @@ -27491,7 +27491,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27502,7 +27502,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27512,12 +27512,12 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } c = v1 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) >= int32(16) { + if Int32FromUint8(**(**uint8)(__ccgo_up(val + uintptr(c)))) >= int32(16) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } @@ -27540,12 +27540,12 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint if base == uint32(0) { base = uint32(10) } - if uint32(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) >= base { + if uint32(**(**uint8)(__ccgo_up(val + uintptr(c)))) >= base { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } X__shlim(tls, f, int64(Int32FromInt32(0))) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uint64(0) } } @@ -27563,7 +27563,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27582,7 +27582,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27593,13 +27593,13 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint } } else { if !(base&(base-Uint32FromInt32(1)) != 0) { - bs = Int32FromUint8(*(*uint8)(unsafe.Pointer(__ccgo_ts + 357 + uintptr(uint32(0x17)*base>>int32(5)&uint32(7))))) + bs = Int32FromUint8(**(**uint8)(__ccgo_up(__ccgo_ts + 357 + uintptr(uint32(0x17)*base>>int32(5)&uint32(7))))) x = uint32(0) for { - if !(uint32(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) < base && x <= Uint32FromUint32(0xffffffff)/Uint32FromInt32(32)) { + if !(uint32(**(**uint8)(__ccgo_up(val + uintptr(c)))) < base && x <= Uint32FromUint32(0xffffffff)/Uint32FromInt32(32)) { break } - x = x<>bs) { + if !(uint32(**(**uint8)(__ccgo_up(val + uintptr(c)))) < base && y <= (Uint64FromUint64(2)*Uint64FromInt64(0x7fffffffffffffff)+Uint64FromInt32(1))>>bs) { break } - y = y<= lim { if !(lim&Uint64FromInt32(1) != 0) && !(neg != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return lim - uint64(1) } else { if y > lim { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return lim } } @@ -27726,8 +27726,8 @@ func X__procfdname(tls *TLS, buf uintptr, fd uint32) { _, _, _, _ = i, j, v2, v5 i = uint32(0) for { - v2 = *(*uint8)(unsafe.Pointer(__ccgo_ts + 366 + uintptr(i))) - *(*uint8)(unsafe.Pointer(buf + uintptr(i))) = v2 + v2 = **(**uint8)(__ccgo_up(__ccgo_ts + 366 + uintptr(i))) + **(**uint8)(__ccgo_up(buf + uintptr(i))) = v2 if !(v2 != 0) { break } @@ -27737,8 +27737,8 @@ func X__procfdname(tls *TLS, buf uintptr, fd uint32) { i = i + 1 } if !(fd != 0) { - *(*uint8)(unsafe.Pointer(buf + uintptr(i))) = uint8('0') - *(*uint8)(unsafe.Pointer(buf + uintptr(i+uint32(1)))) = uint8(0) + **(**uint8)(__ccgo_up(buf + uintptr(i))) = uint8('0') + **(**uint8)(__ccgo_up(buf + uintptr(i+uint32(1)))) = uint8(0) return } j = fd @@ -27752,14 +27752,14 @@ func X__procfdname(tls *TLS, buf uintptr, fd uint32) { j = j / uint32(10) i = i + 1 } - *(*uint8)(unsafe.Pointer(buf + uintptr(i))) = uint8(0) + **(**uint8)(__ccgo_up(buf + uintptr(i))) = uint8(0) for { if !(fd != 0) { break } i = i - 1 v5 = i - *(*uint8)(unsafe.Pointer(buf + uintptr(v5))) = uint8(uint32('0') + fd%uint32(10)) + **(**uint8)(__ccgo_up(buf + uintptr(v5))) = uint8(uint32('0') + fd%uint32(10)) goto _4 _4: ; @@ -27814,7 +27814,7 @@ func X__shgetc(tls *TLS, f uintptr) (r int32) { } (*TFILE)(unsafe.Pointer(f)).Fshcnt = int64((*TFILE)(unsafe.Pointer(f)).Fbuf) - int64((*TFILE)(unsafe.Pointer(f)).Frpos) + cnt if (*TFILE)(unsafe.Pointer(f)).Frpos <= (*TFILE)(unsafe.Pointer(f)).Fbuf { - *(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos + uintptr(-Int32FromInt32(1)))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos + uintptr(-Int32FromInt32(1)))) = Uint8FromInt32(c) } return c } @@ -27825,7 +27825,7 @@ func X__syscall_ret(tls *TLS, r uint64) (r1 int64) { defer func() { trc("-> %v", r1) }() } if r > -Uint64FromUint64(4096) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = Int32FromUint64(-r) + **(**int32)(__ccgo_up(X__errno_location(tls))) = Int32FromUint64(-r) return int64(-int32(1)) } return Int64FromUint64(r) @@ -27901,7 +27901,7 @@ func Xftok(tls *TLS, path uintptr, id int32) (r Tkey_t) { if Xstat(tls, path, bp) < 0 { return -int32(1) } - return Int32FromUint64((*(*Tstat)(unsafe.Pointer(bp))).Fst_ino&Uint64FromInt32(0xffff) | (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev&Uint64FromInt32(0xff)< -Uint64FromInt32(SHMLBA) { v1 = uintptr(ret) } else { - v1 = *(*uintptr)(unsafe.Pointer(bp)) + v1 = **(**uintptr)(__ccgo_up(bp)) } return v1 } @@ -28276,20 +28276,20 @@ func Xcuserid(tls *TLS, buf uintptr) (r uintptr) { var _ /* pwb at bp+56 */ [256]int64 _ = len1 if buf != 0 { - *(*uint8)(unsafe.Pointer(buf)) = uint8(0) + **(**uint8)(__ccgo_up(buf)) = uint8(0) } Xgetpwuid_r(tls, Xgeteuid(tls), bp, bp+56, uint64(2048), bp+48) - if !(*(*uintptr)(unsafe.Pointer(bp + 48)) != 0) { + if !(**(**uintptr)(__ccgo_up(bp + 48)) != 0) { return buf } - len1 = Xstrnlen(tls, (*(*Tpasswd)(unsafe.Pointer(bp))).Fpw_name, uint64(L_cuserid)) + len1 = Xstrnlen(tls, (**(**Tpasswd)(__ccgo_up(bp))).Fpw_name, uint64(L_cuserid)) if len1 == uint64(L_cuserid) { return buf } if !(buf != 0) { buf = uintptr(unsafe.Pointer(&_usridbuf)) } - Xmemcpy(tls, buf, (*(*Tpasswd)(unsafe.Pointer(bp))).Fpw_name, len1+uint64(1)) + Xmemcpy(tls, buf, (**(**Tpasswd)(__ccgo_up(bp))).Fpw_name, len1+uint64(1)) return buf } @@ -28492,10 +28492,10 @@ func Xfutimes(tls *TLS, fd int32, tv uintptr) (r int32) { if !(tv != 0) { return Xfutimens(tls, fd, uintptr(0)) } - (*(*[2]Ttimespec)(unsafe.Pointer(bp)))[0].Ftv_sec = (*(*Ttimeval)(unsafe.Pointer(tv))).Ftv_sec - (*(*[2]Ttimespec)(unsafe.Pointer(bp)))[0].Ftv_nsec = (*(*Ttimeval)(unsafe.Pointer(tv))).Ftv_usec * int64(1000) - (*(*[2]Ttimespec)(unsafe.Pointer(bp)))[int32(1)].Ftv_sec = (*(*Ttimeval)(unsafe.Pointer(tv + 1*16))).Ftv_sec - (*(*[2]Ttimespec)(unsafe.Pointer(bp)))[int32(1)].Ftv_nsec = (*(*Ttimeval)(unsafe.Pointer(tv + 1*16))).Ftv_usec * int64(1000) + (**(**[2]Ttimespec)(__ccgo_up(bp)))[0].Ftv_sec = (**(**Ttimeval)(__ccgo_up(tv))).Ftv_sec + (**(**[2]Ttimespec)(__ccgo_up(bp)))[0].Ftv_nsec = (**(**Ttimeval)(__ccgo_up(tv))).Ftv_usec * int64(1000) + (**(**[2]Ttimespec)(__ccgo_up(bp)))[int32(1)].Ftv_sec = (**(**Ttimeval)(__ccgo_up(tv + 1*16))).Ftv_sec + (**(**[2]Ttimespec)(__ccgo_up(bp)))[int32(1)].Ftv_nsec = (**(**Ttimeval)(__ccgo_up(tv + 1*16))).Ftv_usec * int64(1000) return Xfutimens(tls, fd, bp) } @@ -28512,8 +28512,8 @@ func Xgetdtablesize(tls *TLS) (r int32) { var _ /* rl at bp+0 */ Trlimit _ = v1 Xgetrlimit(tls, int32(RLIMIT_NOFILE), bp) - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur < uint64(INT_MAX) { - v1 = (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur < uint64(INT_MAX) { + v1 = (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur } else { v1 = uint64(INT_MAX) } @@ -28547,7 +28547,7 @@ func Xgetloadavg(tls *TLS, a uintptr, n int32) (r int32) { if !(i < n) { break } - *(*float64)(unsafe.Pointer(a + uintptr(i)*8)) = float64(Float64FromFloat64(1) / float64(Int32FromInt32(1)< int64(1000) || (*Ttimeval)(unsafe.Pointer(in)).Ftv_usec > int64(1000000000) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } - (*(*Ttimex)(unsafe.Pointer(bp))).Foffset = (*Ttimeval)(unsafe.Pointer(in)).Ftv_sec*int64(1000000) + (*Ttimeval)(unsafe.Pointer(in)).Ftv_usec - (*(*Ttimex)(unsafe.Pointer(bp))).Fmodes = uint32(ADJ_OFFSET_SINGLESHOT) + (**(**Ttimex)(__ccgo_up(bp))).Foffset = (*Ttimeval)(unsafe.Pointer(in)).Ftv_sec*int64(1000000) + (*Ttimeval)(unsafe.Pointer(in)).Ftv_usec + (**(**Ttimex)(__ccgo_up(bp))).Fmodes = uint32(ADJ_OFFSET_SINGLESHOT) } if Xadjtimex(tls, bp) < 0 { return -int32(1) } if out != 0 { - (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec = (*(*Ttimex)(unsafe.Pointer(bp))).Foffset / int64(1000000) - v1 = (*(*Ttimex)(unsafe.Pointer(bp))).Foffset % Int64FromInt32(1000000) + (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec = (**(**Ttimex)(__ccgo_up(bp))).Foffset / int64(1000000) + v1 = (**(**Ttimex)(__ccgo_up(bp))).Foffset % Int64FromInt32(1000000) (*Ttimeval)(unsafe.Pointer(out)).Ftv_usec = v1 if v1 < 0 { (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec = (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec - 1 - *(*Tsuseconds_t)(unsafe.Pointer(out + 8)) += int64(1000000) + **(**Tsuseconds_t)(__ccgo_up(out + 8)) += int64(1000000) } } return 0 @@ -29365,7 +29365,7 @@ func Xclock_adjtime(tls *TLS, clock_id Tclockid_t, utx uintptr) (r1 int32) { _ = r r = -int32(ENOSYS) if uint64(8) > uint64(8) { - *(*Tktimex)(unsafe.Pointer(bp)) = Tktimex{ + **(**Tktimex)(__ccgo_up(bp)) = Tktimex{ Fmodes: (*Ttimex)(unsafe.Pointer(utx)).Fmodes, Foffset: (*Ttimex)(unsafe.Pointer(utx)).Foffset, Ffreq: (*Ttimex)(unsafe.Pointer(utx)).Ffreq, @@ -29394,27 +29394,27 @@ func Xclock_adjtime(tls *TLS, clock_id Tclockid_t, utx uintptr) (r1 int32) { r = int32(X__syscall2(tls, int64(SYS_clock_adjtime), int64(clock_id), int64(bp))) } if r >= 0 { - (*Ttimex)(unsafe.Pointer(utx)).Fmodes = (*(*Tktimex)(unsafe.Pointer(bp))).Fmodes - (*Ttimex)(unsafe.Pointer(utx)).Foffset = (*(*Tktimex)(unsafe.Pointer(bp))).Foffset - (*Ttimex)(unsafe.Pointer(utx)).Ffreq = (*(*Tktimex)(unsafe.Pointer(bp))).Ffreq - (*Ttimex)(unsafe.Pointer(utx)).Fmaxerror = (*(*Tktimex)(unsafe.Pointer(bp))).Fmaxerror - (*Ttimex)(unsafe.Pointer(utx)).Festerror = (*(*Tktimex)(unsafe.Pointer(bp))).Festerror - (*Ttimex)(unsafe.Pointer(utx)).Fstatus = (*(*Tktimex)(unsafe.Pointer(bp))).Fstatus - (*Ttimex)(unsafe.Pointer(utx)).Fconstant = (*(*Tktimex)(unsafe.Pointer(bp))).Fconstant - (*Ttimex)(unsafe.Pointer(utx)).Fprecision = (*(*Tktimex)(unsafe.Pointer(bp))).Fprecision - (*Ttimex)(unsafe.Pointer(utx)).Ftolerance = (*(*Tktimex)(unsafe.Pointer(bp))).Ftolerance - (*Ttimex)(unsafe.Pointer(utx)).Ftime.Ftv_sec = (*(*Tktimex)(unsafe.Pointer(bp))).Ftime_sec - (*Ttimex)(unsafe.Pointer(utx)).Ftime.Ftv_usec = (*(*Tktimex)(unsafe.Pointer(bp))).Ftime_usec - (*Ttimex)(unsafe.Pointer(utx)).Ftick = (*(*Tktimex)(unsafe.Pointer(bp))).Ftick - (*Ttimex)(unsafe.Pointer(utx)).Fppsfreq = (*(*Tktimex)(unsafe.Pointer(bp))).Fppsfreq - (*Ttimex)(unsafe.Pointer(utx)).Fjitter = (*(*Tktimex)(unsafe.Pointer(bp))).Fjitter - (*Ttimex)(unsafe.Pointer(utx)).Fshift = (*(*Tktimex)(unsafe.Pointer(bp))).Fshift - (*Ttimex)(unsafe.Pointer(utx)).Fstabil = (*(*Tktimex)(unsafe.Pointer(bp))).Fstabil - (*Ttimex)(unsafe.Pointer(utx)).Fjitcnt = (*(*Tktimex)(unsafe.Pointer(bp))).Fjitcnt - (*Ttimex)(unsafe.Pointer(utx)).Fcalcnt = (*(*Tktimex)(unsafe.Pointer(bp))).Fcalcnt - (*Ttimex)(unsafe.Pointer(utx)).Ferrcnt = (*(*Tktimex)(unsafe.Pointer(bp))).Ferrcnt - (*Ttimex)(unsafe.Pointer(utx)).Fstbcnt = (*(*Tktimex)(unsafe.Pointer(bp))).Fstbcnt - (*Ttimex)(unsafe.Pointer(utx)).Ftai = (*(*Tktimex)(unsafe.Pointer(bp))).Ftai + (*Ttimex)(unsafe.Pointer(utx)).Fmodes = (**(**Tktimex)(__ccgo_up(bp))).Fmodes + (*Ttimex)(unsafe.Pointer(utx)).Foffset = (**(**Tktimex)(__ccgo_up(bp))).Foffset + (*Ttimex)(unsafe.Pointer(utx)).Ffreq = (**(**Tktimex)(__ccgo_up(bp))).Ffreq + (*Ttimex)(unsafe.Pointer(utx)).Fmaxerror = (**(**Tktimex)(__ccgo_up(bp))).Fmaxerror + (*Ttimex)(unsafe.Pointer(utx)).Festerror = (**(**Tktimex)(__ccgo_up(bp))).Festerror + (*Ttimex)(unsafe.Pointer(utx)).Fstatus = (**(**Tktimex)(__ccgo_up(bp))).Fstatus + (*Ttimex)(unsafe.Pointer(utx)).Fconstant = (**(**Tktimex)(__ccgo_up(bp))).Fconstant + (*Ttimex)(unsafe.Pointer(utx)).Fprecision = (**(**Tktimex)(__ccgo_up(bp))).Fprecision + (*Ttimex)(unsafe.Pointer(utx)).Ftolerance = (**(**Tktimex)(__ccgo_up(bp))).Ftolerance + (*Ttimex)(unsafe.Pointer(utx)).Ftime.Ftv_sec = (**(**Tktimex)(__ccgo_up(bp))).Ftime_sec + (*Ttimex)(unsafe.Pointer(utx)).Ftime.Ftv_usec = (**(**Tktimex)(__ccgo_up(bp))).Ftime_usec + (*Ttimex)(unsafe.Pointer(utx)).Ftick = (**(**Tktimex)(__ccgo_up(bp))).Ftick + (*Ttimex)(unsafe.Pointer(utx)).Fppsfreq = (**(**Tktimex)(__ccgo_up(bp))).Fppsfreq + (*Ttimex)(unsafe.Pointer(utx)).Fjitter = (**(**Tktimex)(__ccgo_up(bp))).Fjitter + (*Ttimex)(unsafe.Pointer(utx)).Fshift = (**(**Tktimex)(__ccgo_up(bp))).Fshift + (*Ttimex)(unsafe.Pointer(utx)).Fstabil = (**(**Tktimex)(__ccgo_up(bp))).Fstabil + (*Ttimex)(unsafe.Pointer(utx)).Fjitcnt = (**(**Tktimex)(__ccgo_up(bp))).Fjitcnt + (*Ttimex)(unsafe.Pointer(utx)).Fcalcnt = (**(**Tktimex)(__ccgo_up(bp))).Fcalcnt + (*Ttimex)(unsafe.Pointer(utx)).Ferrcnt = (**(**Tktimex)(__ccgo_up(bp))).Ferrcnt + (*Ttimex)(unsafe.Pointer(utx)).Fstbcnt = (**(**Tktimex)(__ccgo_up(bp))).Fstbcnt + (*Ttimex)(unsafe.Pointer(utx)).Ftai = (**(**Tktimex)(__ccgo_up(bp))).Ftai } return int32(X__syscall_ret(tls, Uint64FromInt32(r))) } @@ -30486,12 +30486,12 @@ func Xprlimit(tls *TLS, pid Tpid_t, resource int32, new_limit uintptr, old_limit var _ /* tmp at bp+0 */ Trlimit _ = r if new_limit != 0 && Bool(^Uint64FromUint64(0) != ^Uint64FromUint64(0)) { - *(*Trlimit)(unsafe.Pointer(bp)) = *(*Trlimit)(unsafe.Pointer(new_limit)) - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur >= ^Uint64FromUint64(0) { - (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur = ^Uint64FromUint64(0) + **(**Trlimit)(__ccgo_up(bp)) = **(**Trlimit)(__ccgo_up(new_limit)) + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur >= ^Uint64FromUint64(0) { + (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur = ^Uint64FromUint64(0) } - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_max >= ^Uint64FromUint64(0) { - (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_max = ^Uint64FromUint64(0) + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_max >= ^Uint64FromUint64(0) { + (**(**Trlimit)(__ccgo_up(bp))).Frlim_max = ^Uint64FromUint64(0) } new_limit = bp } @@ -30700,7 +30700,7 @@ func Xptrace(tls *TLS, req int32, va uintptr) (r int64) { if ret < 0 || Uint32FromInt32(req)-uint32(1) >= uint32(3) { return ret } - return *(*int64)(unsafe.Pointer(bp)) + return **(**int64)(__ccgo_up(bp)) } func Xpwritev2(tls *TLS, fd int32, iov uintptr, count int32, ofs Toff_t, flags int32) (r Tssize_t) { @@ -31012,22 +31012,22 @@ func Xstatx(tls *TLS, dirfd int32, path uintptr, flags int32, mask uint32, stx u if ret != 0 { return ret } - (*Tstatx)(unsafe.Pointer(stx)).Fstx_dev_major = uint32((*(*Tstat)(unsafe.Pointer(bp))).Fst_dev>>Int32FromInt32(31)>>Int32FromInt32(1)&Uint64FromUint32(0xfffff000) | (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev>>Int32FromInt32(8)&Uint64FromInt32(0x00000fff)) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_dev_minor = uint32((*(*Tstat)(unsafe.Pointer(bp))).Fst_dev>>Int32FromInt32(12)&Uint64FromUint32(0xffffff00) | (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev&Uint64FromInt32(0x000000ff)) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_ino = (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino - (*Tstatx)(unsafe.Pointer(stx)).Fstx_mode = uint16((*(*Tstat)(unsafe.Pointer(bp))).Fst_mode) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_nlink = uint32((*(*Tstat)(unsafe.Pointer(bp))).Fst_nlink) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_uid = (*(*Tstat)(unsafe.Pointer(bp))).Fst_uid - (*Tstatx)(unsafe.Pointer(stx)).Fstx_gid = (*(*Tstat)(unsafe.Pointer(bp))).Fst_gid - (*Tstatx)(unsafe.Pointer(stx)).Fstx_size = Uint64FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_size) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_blksize = Uint32FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_blksize) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_blocks = Uint64FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_blocks) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_atime.Ftv_sec = (*(*Tstat)(unsafe.Pointer(bp))).Fst_atim.Ftv_sec - (*Tstatx)(unsafe.Pointer(stx)).Fstx_atime.Ftv_nsec = Uint32FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_atim.Ftv_nsec) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_mtime.Ftv_sec = (*(*Tstat)(unsafe.Pointer(bp))).Fst_mtim.Ftv_sec - (*Tstatx)(unsafe.Pointer(stx)).Fstx_mtime.Ftv_nsec = Uint32FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_mtim.Ftv_nsec) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_ctime.Ftv_sec = (*(*Tstat)(unsafe.Pointer(bp))).Fst_ctim.Ftv_sec - (*Tstatx)(unsafe.Pointer(stx)).Fstx_ctime.Ftv_nsec = Uint32FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_ctim.Ftv_nsec) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_dev_major = uint32((**(**Tstat)(__ccgo_up(bp))).Fst_dev>>Int32FromInt32(31)>>Int32FromInt32(1)&Uint64FromUint32(0xfffff000) | (**(**Tstat)(__ccgo_up(bp))).Fst_dev>>Int32FromInt32(8)&Uint64FromInt32(0x00000fff)) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_dev_minor = uint32((**(**Tstat)(__ccgo_up(bp))).Fst_dev>>Int32FromInt32(12)&Uint64FromUint32(0xffffff00) | (**(**Tstat)(__ccgo_up(bp))).Fst_dev&Uint64FromInt32(0x000000ff)) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_ino = (**(**Tstat)(__ccgo_up(bp))).Fst_ino + (*Tstatx)(unsafe.Pointer(stx)).Fstx_mode = uint16((**(**Tstat)(__ccgo_up(bp))).Fst_mode) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_nlink = uint32((**(**Tstat)(__ccgo_up(bp))).Fst_nlink) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_uid = (**(**Tstat)(__ccgo_up(bp))).Fst_uid + (*Tstatx)(unsafe.Pointer(stx)).Fstx_gid = (**(**Tstat)(__ccgo_up(bp))).Fst_gid + (*Tstatx)(unsafe.Pointer(stx)).Fstx_size = Uint64FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_size) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_blksize = Uint32FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_blksize) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_blocks = Uint64FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_blocks) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_atime.Ftv_sec = (**(**Tstat)(__ccgo_up(bp))).Fst_atim.Ftv_sec + (*Tstatx)(unsafe.Pointer(stx)).Fstx_atime.Ftv_nsec = Uint32FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_atim.Ftv_nsec) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_mtime.Ftv_sec = (**(**Tstat)(__ccgo_up(bp))).Fst_mtim.Ftv_sec + (*Tstatx)(unsafe.Pointer(stx)).Fstx_mtime.Ftv_nsec = Uint32FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_mtim.Ftv_nsec) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_ctime.Ftv_sec = (**(**Tstat)(__ccgo_up(bp))).Fst_ctim.Ftv_sec + (*Tstatx)(unsafe.Pointer(stx)).Fstx_ctime.Ftv_nsec = Uint32FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_ctim.Ftv_nsec) (*Tstatx)(unsafe.Pointer(stx)).Fstx_btime = Tstatx_timestamp{} (*Tstatx)(unsafe.Pointer(stx)).Fstx_mask = uint32(0x7ff) return 0 @@ -31041,8 +31041,8 @@ func Xstime(tls *TLS, t uintptr) (r int32) { bp := tls.Alloc(16) defer tls.Free(16) var _ /* tv at bp+0 */ Ttimeval - *(*Ttimeval)(unsafe.Pointer(bp)) = Ttimeval{ - Ftv_sec: *(*Ttime_t)(unsafe.Pointer(t)), + **(**Ttimeval)(__ccgo_up(bp)) = Ttimeval{ + Ftv_sec: **(**Ttime_t)(__ccgo_up(t)), } return Xsettimeofday(tls, bp, UintptrFromInt32(0)) } @@ -31251,12 +31251,12 @@ func Xwait4(tls *TLS, pid Tpid_t, status uintptr, options int32, ru uintptr) (r1 if r > 0 && ru != 0 && Bool(uint64(8) > uint64(8)) { Xmemcpy(tls, bp, dest, Uint64FromInt32(4)*Uint64FromInt64(8)) (*Trusage)(unsafe.Pointer(ru)).Fru_utime = Ttimeval{ - Ftv_sec: (*(*[4]int64)(unsafe.Pointer(bp)))[0], - Ftv_usec: (*(*[4]int64)(unsafe.Pointer(bp)))[int32(1)], + Ftv_sec: (**(**[4]int64)(__ccgo_up(bp)))[0], + Ftv_usec: (**(**[4]int64)(__ccgo_up(bp)))[int32(1)], } (*Trusage)(unsafe.Pointer(ru)).Fru_stime = Ttimeval{ - Ftv_sec: (*(*[4]int64)(unsafe.Pointer(bp)))[int32(2)], - Ftv_usec: (*(*[4]int64)(unsafe.Pointer(bp)))[int32(3)], + Ftv_sec: (**(**[4]int64)(__ccgo_up(bp)))[int32(2)], + Ftv_usec: (**(**[4]int64)(__ccgo_up(bp)))[int32(3)], } } return int32(X__syscall_ret(tls, Uint64FromInt32(r))) @@ -31379,7 +31379,7 @@ func X__lctrans_cur(tls *TLS, msg uintptr) (r uintptr) { trc("tls=%v msg=%v, (%v:)", tls, msg, origin(2)) defer func() { trc("-> %v", r) }() } - return X__lctrans_impl(tls, msg, *(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale + 5*8))) + return X__lctrans_impl(tls, msg, **(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale + 5*8))) } func _swapc(tls *TLS, x Tuint32_t, c int32) (r Tuint32_t) { @@ -31403,27 +31403,27 @@ func X__mo_lookup(tls *TLS, p uintptr, size Tsize_t, s uintptr) (r uintptr) { var sign, sw int32 _, _, _, _, _, _, _, _, _, _, _ = b, mo, n, o, ol, os, sign, sw, t, tl, ts mo = p - sw = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(mo)) - uint32(0x950412de)) + sw = Int32FromUint32(**(**Tuint32_t)(__ccgo_up(mo)) - uint32(0x950412de)) b = uint32(0) - n = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + 2*4)), sw) - o = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + 3*4)), sw) - t = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + 4*4)), sw) + n = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + 2*4)), sw) + o = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + 3*4)), sw) + t = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + 4*4)), sw) if uint64(n) >= size/uint64(4) || uint64(o) >= size-uint64(uint32(4)*n) || uint64(t) >= size-uint64(uint32(4)*n) || (o|t)%uint32(4) != 0 { return uintptr(0) } o = o / uint32(4) t = t / uint32(4) for { - ol = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + uintptr(o+uint32(2)*(b+n/uint32(2)))*4)), sw) - os = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + uintptr(o+uint32(2)*(b+n/uint32(2))+uint32(1))*4)), sw) - if uint64(os) >= size || uint64(ol) >= size-uint64(os) || *(*uint8)(unsafe.Pointer(p + uintptr(os+ol))) != 0 { + ol = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + uintptr(o+uint32(2)*(b+n/uint32(2)))*4)), sw) + os = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + uintptr(o+uint32(2)*(b+n/uint32(2))+uint32(1))*4)), sw) + if uint64(os) >= size || uint64(ol) >= size-uint64(os) || **(**uint8)(__ccgo_up(p + uintptr(os+ol))) != 0 { return uintptr(0) } sign = Xstrcmp(tls, s, p+uintptr(os)) if !(sign != 0) { - tl = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + uintptr(t+uint32(2)*(b+n/uint32(2)))*4)), sw) - ts = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + uintptr(t+uint32(2)*(b+n/uint32(2))+uint32(1))*4)), sw) - if uint64(ts) >= size || uint64(tl) >= size-uint64(ts) || *(*uint8)(unsafe.Pointer(p + uintptr(ts+tl))) != 0 { + tl = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + uintptr(t+uint32(2)*(b+n/uint32(2)))*4)), sw) + ts = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + uintptr(t+uint32(2)*(b+n/uint32(2))+uint32(1))*4)), sw) + if uint64(ts) >= size || uint64(tl) >= size-uint64(ts) || **(**uint8)(__ccgo_up(p + uintptr(ts+tl))) != 0 { return uintptr(0) } return p + uintptr(ts) @@ -31453,7 +31453,7 @@ func Xbind_textdomain_codeset(tls *TLS, domainname uintptr, codeset uintptr) (r defer func() { trc("-> %v", r) }() } if codeset != 0 && Xstrcasecmp(tls, codeset, __ccgo_ts+419) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) } return UintptrFromInt32(0) } @@ -31481,7 +31481,7 @@ func Xcatclose(tls *TLS, catd Tnl_catd) (r int32) { var v1, v2 Tuint32_t _, _, _ = map1, v1, v2 map1 = catd - v1 = *(*Tuint32_t)(unsafe.Pointer(map1 + UintptrFromInt32(8))) + v1 = **(**Tuint32_t)(__ccgo_up(map1 + UintptrFromInt32(8))) v2 = v1>>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v4>>int32(8)&uint32(0xff00) | v4<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v4>>int32(8)&uint32(0xff00) | v4<>int32(24) | v7>>int32(8)&uint32(0xff00) | v7<>int32(24) | v10>>int32(8)&uint32(0xff00) | v10<>int32(24) | v13>>int32(8)&uint32(0xff00) | v13<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v4>>int32(8)&uint32(0xff00) | v4<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v5>>int32(8)&uint32(0xff00) | v5< uint64(NAME_MAX) || dirlen >= uint64(PATH_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } ___lock(tls, uintptr(unsafe.Pointer(&_lock1))) @@ -31988,7 +31988,7 @@ func Xdcngettext(tls *TLS, domainname uintptr, msgid1 uintptr, msgid2 uintptr, n _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = alt_modlen, catlen, catname, csp, dirlen, dirname, domlen, l, lm, loc, loclen, locname, locp, map1, modlen, modname, name, np, old, old_cats, old_errno, p3, plural, q, r, r1, rem, rule, trans, v, v10, v11, v12, v17, v21, v29, v3, v5, v6, v8, v9 defer func() { Xrealloc(tls, name, 0) }() loc = (*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale - old_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + old_errno = **(**int32)(__ccgo_up(X__errno_location(tls))) /* match gnu gettext behaviour */ if !(msgid1 != 0) { goto notrans @@ -32019,14 +32019,14 @@ func Xdcngettext(tls *TLS, domainname uintptr, msgid1 uintptr, msgid2 uintptr, n if !(q != 0) { goto notrans } - lm = *(*uintptr)(unsafe.Pointer(loc + uintptr(category)*8)) + lm = **(**uintptr)(__ccgo_up(loc + uintptr(category)*8)) if !!(lm != 0) { goto _2 } goto notrans notrans: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = old_errno + **(**int32)(__ccgo_up(X__errno_location(tls))) = old_errno if n == uint64(1) { v3 = msgid1 } else { @@ -32099,21 +32099,21 @@ _2: } p3 = Xcalloc(tls, uint64(64), uint64(1)) if !(p3 != 0) { - X__munmap(tls, map1, *(*Tsize_t)(unsafe.Pointer(bp))) + X__munmap(tls, map1, **(**Tsize_t)(__ccgo_up(bp))) goto notrans } (*Tmsgcat)(unsafe.Pointer(p3)).Fcat = category (*Tmsgcat)(unsafe.Pointer(p3)).Fbinding = q (*Tmsgcat)(unsafe.Pointer(p3)).Flm = lm (*Tmsgcat)(unsafe.Pointer(p3)).Fmap1 = map1 - (*Tmsgcat)(unsafe.Pointer(p3)).Fmap_size = *(*Tsize_t)(unsafe.Pointer(bp)) + (*Tmsgcat)(unsafe.Pointer(p3)).Fmap_size = **(**Tsize_t)(__ccgo_up(bp)) rule = __ccgo_ts + 493 np = uint64(2) r1 = X__mo_lookup(tls, (*Tmsgcat)(unsafe.Pointer(p3)).Fmap1, (*Tmsgcat)(unsafe.Pointer(p3)).Fmap_size, __ccgo_ts) for r1 != 0 && Xstrncmp(tls, r1, __ccgo_ts+499, uint64(13)) != 0 { - *(*uintptr)(unsafe.Pointer(bp + 8)) = Xstrchr(tls, r1, int32('\n')) - if *(*uintptr)(unsafe.Pointer(bp + 8)) != 0 { - v3 = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(1) + **(**uintptr)(__ccgo_up(bp + 8)) = Xstrchr(tls, r1, int32('\n')) + if **(**uintptr)(__ccgo_up(bp + 8)) != 0 { + v3 = **(**uintptr)(__ccgo_up(bp + 8)) + uintptr(1) } else { v3 = uintptr(0) } @@ -32122,7 +32122,7 @@ _2: if r1 != 0 { r1 = r1 + uintptr(13) for { - v11 = Int32FromUint8(*(*uint8)(unsafe.Pointer(r1))) + v11 = Int32FromUint8(**(**uint8)(__ccgo_up(r1))) v12 = BoolInt32(v11 == int32(' ') || Uint32FromInt32(v11)-uint32('\t') < uint32(5)) goto _13 _13: @@ -32133,15 +32133,15 @@ _2: } if !(Xstrncmp(tls, r1, __ccgo_ts+513, uint64(9)) != 0) { np = Xstrtoul(tls, r1+uintptr(9), bp+8, int32(10)) - r1 = *(*uintptr)(unsafe.Pointer(bp + 8)) + r1 = **(**uintptr)(__ccgo_up(bp + 8)) } - for *(*uint8)(unsafe.Pointer(r1)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(r1))) != int32(';') { + for **(**uint8)(__ccgo_up(r1)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(r1))) != int32(';') { r1 = r1 + 1 } - if *(*uint8)(unsafe.Pointer(r1)) != 0 { + if **(**uint8)(__ccgo_up(r1)) != 0 { r1 = r1 + 1 for { - v11 = Int32FromUint8(*(*uint8)(unsafe.Pointer(r1))) + v11 = Int32FromUint8(**(**uint8)(__ccgo_up(r1))) v12 = BoolInt32(v11 == int32(' ') || Uint32FromInt32(v11)-uint32('\t') < uint32(5)) goto _16 _16: @@ -32228,7 +32228,7 @@ _2: trans = trans + uintptr(l+uint64(1)) } } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = old_errno + **(**int32)(__ccgo_up(X__errno_location(tls))) = old_errno return trans } @@ -32272,7 +32272,7 @@ func X__duplocale(tls *TLS, old Tlocale_t) (r Tlocale_t) { if old == uintptr(-Int32FromInt32(1)) { old = uintptr(unsafe.Pointer(&X__libc)) + 56 } - *(*t__locale_struct)(unsafe.Pointer(new1)) = *(*t__locale_struct)(unsafe.Pointer(old)) + **(**t__locale_struct)(__ccgo_up(new1)) = **(**t__locale_struct)(__ccgo_up(old)) return new1 } @@ -98446,13 +98446,13 @@ var _rev_jis = [6879]uint16{ func _fuzzycmp(tls *TLS, a uintptr, b uintptr) (r int32) { for { - if !(*(*uint8)(unsafe.Pointer(a)) != 0 && *(*uint8)(unsafe.Pointer(b)) != 0) { + if !(**(**uint8)(__ccgo_up(a)) != 0 && **(**uint8)(__ccgo_up(b)) != 0) { break } - for *(*uint8)(unsafe.Pointer(a)) != 0 && uint32(*(*uint8)(unsafe.Pointer(a)))|uint32(32)-uint32('a') > uint32(26) && Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(a)))-int32('0')) > uint32(10) { + for **(**uint8)(__ccgo_up(a)) != 0 && uint32(**(**uint8)(__ccgo_up(a)))|uint32(32)-uint32('a') > uint32(26) && Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(a)))-int32('0')) > uint32(10) { a = a + 1 } - if uint32(*(*uint8)(unsafe.Pointer(a)))|uint32(32) != uint32(*(*uint8)(unsafe.Pointer(b))) { + if uint32(**(**uint8)(__ccgo_up(a)))|uint32(32) != uint32(**(**uint8)(__ccgo_up(b))) { return int32(1) } goto _1 @@ -98461,23 +98461,23 @@ func _fuzzycmp(tls *TLS, a uintptr, b uintptr) (r int32) { a = a + 1 b = b + 1 } - return BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(a))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(b)))) + return BoolInt32(Int32FromUint8(**(**uint8)(__ccgo_up(a))) != Int32FromUint8(**(**uint8)(__ccgo_up(b)))) } func _find_charmap(tls *TLS, name uintptr) (r Tsize_t) { var s uintptr _ = s - if !(*(*uint8)(unsafe.Pointer(name)) != 0) { + if !(**(**uint8)(__ccgo_up(name)) != 0) { name = uintptr(unsafe.Pointer(&_charmaps)) } /* "utf8" */ s = uintptr(unsafe.Pointer(&_charmaps)) for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { break } if !(_fuzzycmp(tls, name, s) != 0) { for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { break } goto _2 @@ -98488,11 +98488,11 @@ func _find_charmap(tls *TLS, name uintptr) (r Tsize_t) { return Uint64FromInt64(int64(s+uintptr(1)) - t__predefined_ptrdiff_t(uintptr(unsafe.Pointer(&_charmaps)))) } s = s + uintptr(_strlen(tls, s)+uint64(1)) - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) > int32(0200) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { + if Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) > int32(0200) { s = s + uintptr(2) } else { - s = s + uintptr(uint32(2)+(uint32(64)-uint32(*(*uint8)(unsafe.Pointer(s + 1))))*uint32(5)) + s = s + uintptr(uint32(2)+(uint32(64)-uint32(**(**uint8)(__ccgo_up(s + 1))))*uint32(5)) } } goto _1 @@ -98535,7 +98535,7 @@ func Xiconv_open(tls *TLS, to uintptr, from uintptr) (r Ticonv_t) { f = v2 } if v3 || v2 == Uint64FromInt32(-Int32FromInt32(1)) || Int32FromUint8(_charmaps[t]) >= int32(0330) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(-Int32FromInt32(1)) } cd = _combine_to_from(tls, t, f) @@ -98560,26 +98560,26 @@ func Xiconv_open(tls *TLS, to uintptr, from uintptr) (r Ticonv_t) { func _get_16(tls *TLS, s uintptr, e int32) (r uint32) { e = e & int32(1) - return Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(e))))<> int32(8)) - *(*uint8)(unsafe.Pointer(s + uintptr(int32(1)-e))) = uint8(c) + **(**uint8)(__ccgo_up(s + uintptr(e))) = uint8(c >> int32(8)) + **(**uint8)(__ccgo_up(s + uintptr(int32(1)-e))) = uint8(c) } func _get_32(tls *TLS, s uintptr, e int32) (r uint32) { e = e & int32(3) - return (uint32(*(*uint8)(unsafe.Pointer(s + uintptr(e))))+0)<> int32(24)) - *(*uint8)(unsafe.Pointer(s + uintptr(e^int32(1)))) = uint8(c >> int32(16)) - *(*uint8)(unsafe.Pointer(s + uintptr(e^int32(2)))) = uint8(c >> int32(8)) - *(*uint8)(unsafe.Pointer(s + uintptr(e^int32(3)))) = uint8(c) + **(**uint8)(__ccgo_up(s + uintptr(e^0))) = uint8(c >> int32(24)) + **(**uint8)(__ccgo_up(s + uintptr(e^int32(1)))) = uint8(c >> int32(16)) + **(**uint8)(__ccgo_up(s + uintptr(e^int32(2)))) = uint8(c >> int32(8)) + **(**uint8)(__ccgo_up(s + uintptr(e^int32(3)))) = uint8(c) } /* Adapt as needed */ @@ -98587,11 +98587,11 @@ func _put_32(tls *TLS, s uintptr, c uint32, e int32) { func _legacy_map(tls *TLS, map1 uintptr, c uint32) (r uint32) { var x, v1 uint32 _, _ = x, v1 - if c < Uint32FromInt32(int32(4)*Int32FromUint8(*(*uint8)(unsafe.Pointer(map1 + uintptr(-Int32FromInt32(1)))))) { + if c < Uint32FromInt32(int32(4)*Int32FromUint8(**(**uint8)(__ccgo_up(map1 + uintptr(-Int32FromInt32(1)))))) { return c } - x = c - Uint32FromInt32(int32(4)*Int32FromUint8(*(*uint8)(unsafe.Pointer(map1 + uintptr(-Int32FromInt32(1)))))) - x = Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(map1 + uintptr(x*uint32(5)/uint32(4)))))>>(uint32(2)*x%uint32(8)) | Int32FromUint8(*(*uint8)(unsafe.Pointer(map1 + uintptr(x*uint32(5)/uint32(4)+uint32(1)))))<<(uint32(8)-uint32(2)*x%uint32(8))&int32(1023)) + x = c - Uint32FromInt32(int32(4)*Int32FromUint8(**(**uint8)(__ccgo_up(map1 + uintptr(-Int32FromInt32(1)))))) + x = Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(map1 + uintptr(x*uint32(5)/uint32(4)))))>>(uint32(2)*x%uint32(8)) | Int32FromUint8(**(**uint8)(__ccgo_up(map1 + uintptr(x*uint32(5)/uint32(4)+uint32(1)))))<<(uint32(8)-uint32(2)*x%uint32(8))&int32(1023)) if x < uint32(256) { v1 = x } else { @@ -98608,7 +98608,7 @@ func _uni_to_jis(tls *TLS, c uint32) (r uint32) { for { i = nel / uint32(2) j = uint32(_rev_jis[b+i]) - d = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(j/uint32(256))*188 + uintptr(j%uint32(256))*2))) + d = uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(j/uint32(256))*188 + uintptr(j%uint32(256))*2))) if d == c { return j + uint32(0x2121) } else { @@ -98661,20 +98661,20 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui from = uint32(_extract_from(tls, cd)) map1 = uintptr(unsafe.Pointer(&_charmaps)) + uintptr(from) + uintptr(1) tomap = uintptr(unsafe.Pointer(&_charmaps)) + uintptr(to) + uintptr(1) - *(*Tmbstate_t)(unsafe.Pointer(bp + 24)) = Tmbstate_t{} - type1 = *(*uint8)(unsafe.Pointer(map1 + uintptr(-Int32FromInt32(1)))) - totype = *(*uint8)(unsafe.Pointer(tomap + uintptr(-Int32FromInt32(1)))) + **(**Tmbstate_t)(__ccgo_up(bp + 24)) = Tmbstate_t{} + type1 = **(**uint8)(__ccgo_up(map1 + uintptr(-Int32FromInt32(1)))) + totype = **(**uint8)(__ccgo_up(tomap + uintptr(-Int32FromInt32(1)))) ploc = uintptr(___get_tp(tls)) + 152 - loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) - if !(in != 0) || !(*(*uintptr)(unsafe.Pointer(in)) != 0) || !(*(*Tsize_t)(unsafe.Pointer(inb)) != 0) { + loc = **(**Tlocale_t)(__ccgo_up(ploc)) + if !(in != 0) || !(**(**uintptr)(__ccgo_up(in)) != 0) || !(**(**Tsize_t)(__ccgo_up(inb)) != 0) { return uint64(0) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = uintptr(unsafe.Pointer(&X__c_dot_utf8_locale)) + **(**Tlocale_t)(__ccgo_up(ploc)) = uintptr(unsafe.Pointer(&X__c_dot_utf8_locale)) for { - if !(*(*Tsize_t)(unsafe.Pointer(inb)) != 0) { + if !(**(**Tsize_t)(__ccgo_up(inb)) != 0) { break } - c = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in))))) + c = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in))))) l = uint64(1) switch Int32FromUint8(type1) { case int32(UTF_8): @@ -98726,14 +98726,14 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if c < uint32(128) { goto _23 } - l = Xmbrtowc(tls, bp+32, *(*uintptr)(unsafe.Pointer(in)), *(*Tsize_t)(unsafe.Pointer(inb)), bp+24) + l = Xmbrtowc(tls, bp+32, **(**uintptr)(__ccgo_up(in)), **(**Tsize_t)(__ccgo_up(inb)), bp+24) if l == Uint64FromInt32(-Int32FromInt32(1)) { goto ilseq } if l == Uint64FromInt32(-Int32FromInt32(2)) { goto starved } - c = Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp + 32))) + c = Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp + 32))) goto _23 _3: ; @@ -98744,10 +98744,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui _4: ; l = uint64(4) - if *(*Tsize_t)(unsafe.Pointer(inb)) < l { + if **(**Tsize_t)(__ccgo_up(inb)) < l { goto starved } - c = Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in))))) + c = Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(in))))) if !(0 != 0) { goto _24 } @@ -98756,10 +98756,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui _5: ; l = uint64(4) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(4) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(4) { goto starved } - c = _get_32(tls, *(*uintptr)(unsafe.Pointer(in)), Int32FromUint8(type1)) + c = _get_32(tls, **(**uintptr)(__ccgo_up(in)), Int32FromUint8(type1)) _24: ; if c-uint32(0xd800) < uint32(0x800) || c >= uint32(0x110000) { @@ -98775,10 +98775,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui _7: ; l = uint64(2) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(2) { goto starved } - c = _get_16(tls, *(*uintptr)(unsafe.Pointer(in)), Int32FromUint8(type1)) + c = _get_16(tls, **(**uintptr)(__ccgo_up(in)), Int32FromUint8(type1)) if c-Uint32FromInt32(0xdc00) < uint32(0x400) { goto ilseq } @@ -98787,10 +98787,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto ilseq } l = uint64(4) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(4) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(4) { goto starved } - d = _get_16(tls, *(*uintptr)(unsafe.Pointer(in))+UintptrFromInt32(2), Int32FromUint8(type1)) + d = _get_16(tls, **(**uintptr)(__ccgo_up(in))+UintptrFromInt32(2), Int32FromUint8(type1)) if d-Uint32FromInt32(0xdc00) >= uint32(0x400) { goto ilseq } @@ -98803,10 +98803,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui ; l = uint64(0) if !((*Tstateful_cd)(unsafe.Pointer(scd)).Fstate != 0) { - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(2) { goto starved } - c = _get_16(tls, *(*uintptr)(unsafe.Pointer(in)), 0) + c = _get_16(tls, **(**uintptr)(__ccgo_up(in)), 0) if Int32FromUint8(type1) == int32(UCS2) { if c == uint32(0xfffe) { v26 = int32(UCS2LE) @@ -98833,10 +98833,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui ; l = uint64(0) if !((*Tstateful_cd)(unsafe.Pointer(scd)).Fstate != 0) { - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(4) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(4) { goto starved } - c = _get_32(tls, *(*uintptr)(unsafe.Pointer(in)), 0) + c = _get_32(tls, **(**uintptr)(__ccgo_up(in)), 0) if c == uint32(0xfffe0000) { v25 = int32(UTF_32LE) } else { @@ -98859,10 +98859,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _23 } l = uint64(2) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(2) { goto starved } - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(1)))) if c-uint32(129) <= Uint32FromInt32(Int32FromInt32(159)-Int32FromInt32(129)) { c = c - uint32(129) } else { @@ -98890,7 +98890,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if c >= uint32(84) { goto ilseq } - c = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(c)*188 + uintptr(d)*2))) + c = uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(c)*188 + uintptr(d)*2))) if !(c != 0) { goto ilseq } @@ -98901,10 +98901,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _23 } l = uint64(2) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(2) { goto starved } - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(1)))) if c == uint32(0x8e) { c = d if c-uint32(0xa1) > Uint32FromInt32(Int32FromInt32(0xdf)-Int32FromInt32(0xa1)) { @@ -98918,7 +98918,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if c >= uint32(84) || d >= uint32(94) { goto ilseq } - c = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(c)*188 + uintptr(d)*2))) + c = uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(c)*188 + uintptr(d)*2))) if !(c != 0) { goto ilseq } @@ -98930,11 +98930,11 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } if c == uint32('\033') { l = uint64(3) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(3) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(3) { goto starved } - c = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(2)))) + c = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(1)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(2)))) if c != uint32('(') && c != uint32('$') { goto ilseq } @@ -98969,16 +98969,16 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui fallthrough case uint32(3): l = uint64(2) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(2) { goto starved } - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(1)))) c = c - uint32(0x21) d = d - uint32(0x21) if c >= uint32(84) || d >= uint32(94) { goto ilseq } - c = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(c)*188 + uintptr(d)*2))) + c = uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(c)*188 + uintptr(d)*2))) if !(c != 0) { goto ilseq } @@ -99016,10 +99016,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto ilseq } l = uint64(2) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(2) { goto starved } - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(1)))) if d < uint32(0xa1) && Int32FromUint8(type1) == int32(GB2312) { goto ilseq } @@ -99028,16 +99028,16 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto ilseq } l = uint64(4) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(4) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(4) { goto starved } c = (uint32(10)*c + d - uint32('0')) * uint32(1260) - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(2)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(2)))) if d-uint32(0x81) > uint32(126) { goto ilseq } c = c + uint32(10)*(d-uint32(0x81)) - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(3)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(3)))) if d-uint32('0') > uint32(9) { goto ilseq } @@ -99059,7 +99059,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if !(j < int32(190)) { break } - if uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_gb18030)) + uintptr(i)*380 + uintptr(j)*2)))-d <= c-d { + if uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_gb18030)) + uintptr(i)*380 + uintptr(j)*2)))-d <= c-d { k = k + 1 } goto _31 @@ -99083,7 +99083,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if d > uint32(63) { d = d - 1 } - c = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_gb18030)) + uintptr(c)*380 + uintptr(d)*2))) + c = uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_gb18030)) + uintptr(c)*380 + uintptr(d)*2))) goto _23 _20: ; @@ -99091,10 +99091,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _23 } l = uint64(2) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(2) { goto starved } - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(1)))) if d-uint32(0x40) >= Uint32FromInt32(Int32FromInt32(0xff)-Int32FromInt32(0x40)) || d-uint32(0x7f) < Uint32FromInt32(Int32FromInt32(0xa1)-Int32FromInt32(0x7f)) { goto ilseq } @@ -99117,21 +99117,21 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui * range in the hkscs table then hard-coded * here. Ugly, yes. */ if c/uint32(256) == uint32(0xdc) { - *(*uintptr)(unsafe.Pointer(bp + 48)) = bp + 40 + **(**uintptr)(__ccgo_up(bp + 48)) = bp + 40 *(*uintptr)(unsafe.Pointer(bp)) = __ccgo_ts + 542 + uintptr(c%uint32(256)) *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint64(4) *(*Tsize_t)(unsafe.Pointer(bp + 16)) = uint64(8) tmpx = Xiconv(tls, _combine_to_from(tls, uint64(to), _find_charmap(tls, __ccgo_ts+559)), bp, bp+8, bp+48, bp+16) - tmplen = Uint64FromInt64(int64(*(*uintptr)(unsafe.Pointer(bp + 48))) - t__predefined_ptrdiff_t(bp+40)) - if tmplen > *(*Tsize_t)(unsafe.Pointer(outb)) { + tmplen = Uint64FromInt64(int64(**(**uintptr)(__ccgo_up(bp + 48))) - t__predefined_ptrdiff_t(bp+40)) + if tmplen > **(**Tsize_t)(__ccgo_up(outb)) { goto toobig } if tmpx != 0 { x = x + 1 } - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(out)), bp+40, tmplen) - *(*uintptr)(unsafe.Pointer(out)) += uintptr(tmplen) - *(*Tsize_t)(unsafe.Pointer(outb)) -= tmplen + Xmemcpy(tls, **(**uintptr)(__ccgo_up(out)), bp+40, tmplen) + **(**uintptr)(__ccgo_up(out)) += uintptr(tmplen) + **(**Tsize_t)(__ccgo_up(outb)) -= tmplen goto _1 } if !(c != 0) { @@ -99140,7 +99140,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _23 } c = c - uint32(0xa1) - c = Uint32FromInt32(Int32FromUint16(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_big5)) + uintptr(c)*314 + uintptr(d)*2))) | BoolInt32(c == uint32(0x27) && (d == uint32(0x3a) || d == uint32(0x3c) || d == uint32(0x42)))<= uint32(93) || d >= uint32(94) { @@ -99198,7 +99198,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if !(j1 < int32(94)) { break } - if uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ksc)) + uintptr(i1)*188 + uintptr(j1)*2)))-d <= c-d { + if uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_ksc)) + uintptr(i1)*188 + uintptr(j1)*2)))-d <= c-d { k = k + 1 } goto _34 @@ -99218,7 +99218,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } goto _23 } - c = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ksc)) + uintptr(c)*188 + uintptr(d)*2))) + c = uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_ksc)) + uintptr(c)*188 + uintptr(d)*2))) if !(c != 0) { goto ilseq } @@ -99271,26 +99271,26 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _51 _35: ; - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(4) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(4) { goto toobig } - *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(out)))) = Int32FromUint32(c) - *(*uintptr)(unsafe.Pointer(out)) += uintptr(4) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(4) + **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(out)))) = Int32FromUint32(c) + **(**uintptr)(__ccgo_up(out)) += uintptr(4) + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(4) goto _51 _36: ; - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(4) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(4) { k = Uint64FromInt32(Xwctomb(tls, bp+56, Int32FromUint32(c))) - if *(*Tsize_t)(unsafe.Pointer(outb)) < k { + if **(**Tsize_t)(__ccgo_up(outb)) < k { goto toobig } - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(out)), bp+56, k) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(out)), bp+56, k) } else { - k = Uint64FromInt32(Xwctomb(tls, *(*uintptr)(unsafe.Pointer(out)), Int32FromUint32(c))) + k = Uint64FromInt32(Xwctomb(tls, **(**uintptr)(__ccgo_up(out)), Int32FromUint32(c))) } - *(*uintptr)(unsafe.Pointer(out)) += uintptr(k) - *(*Tsize_t)(unsafe.Pointer(outb)) -= k + **(**uintptr)(__ccgo_up(out)) += uintptr(k) + **(**Tsize_t)(__ccgo_up(outb)) -= k goto _51 _37: ; @@ -99306,7 +99306,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui ; _38: ; - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(1) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(1) { goto toobig } if !(c < uint32(256) && c == _legacy_map(tls, tomap, c)) { @@ -99315,14 +99315,14 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto revout revout: ; - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(1) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(1) { goto toobig } v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8(c) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(1) + **(**uint8)(__ccgo_up(v54)) = uint8(c) + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(1) goto _51 _53: ; @@ -99364,7 +99364,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if !(c != 0) { goto subst } - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(2) { goto toobig } d = c % uint32(256) @@ -99377,7 +99377,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } else { v25 = int32(176) } - *(*uint8)(unsafe.Pointer(v54)) = uint8((c+uint32(1))/uint32(2) + Uint32FromInt32(v25)) + **(**uint8)(__ccgo_up(v54)) = uint8((c+uint32(1))/uint32(2) + Uint32FromInt32(v25)) v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 @@ -99386,8 +99386,8 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } else { v62 = d + uint32(126) } - *(*uint8)(unsafe.Pointer(v54)) = uint8(v62) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(2) + **(**uint8)(__ccgo_up(v54)) = uint8(v62) + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(2) goto _51 _40: ; @@ -99402,18 +99402,18 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if !(c != 0) { goto subst } - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(2) { goto toobig } v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8(c/uint32(256) + uint32(0x80)) + **(**uint8)(__ccgo_up(v54)) = uint8(c/uint32(256) + uint32(0x80)) v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8(c%uint32(256) + uint32(0x80)) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(2) + **(**uint8)(__ccgo_up(v54)) = uint8(c%uint32(256) + uint32(0x80)) + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(2) goto _51 _41: ; @@ -99421,102 +99421,102 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto revout } if c-uint32(0xff61) <= Uint32FromInt32(Int32FromInt32(0xdf)-Int32FromInt32(0xa1)) || c == uint32(0xa5) || c == uint32(0x203e) { - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(7) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(7) { goto toobig } v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('\033') + **(**uint8)(__ccgo_up(v54)) = uint8('\033') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('(') + **(**uint8)(__ccgo_up(v54)) = uint8('(') if c == uint32(0xa5) { v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('J') + **(**uint8)(__ccgo_up(v54)) = uint8('J') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('\\') + **(**uint8)(__ccgo_up(v54)) = uint8('\\') } else { if c == uint32(0x203e) { v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('J') + **(**uint8)(__ccgo_up(v54)) = uint8('J') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('~') + **(**uint8)(__ccgo_up(v54)) = uint8('~') } else { v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('I') + **(**uint8)(__ccgo_up(v54)) = uint8('I') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8(c - uint32(0xff61) + uint32(0x21)) + **(**uint8)(__ccgo_up(v54)) = uint8(c - uint32(0xff61) + uint32(0x21)) } } v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('\033') + **(**uint8)(__ccgo_up(v54)) = uint8('\033') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('(') + **(**uint8)(__ccgo_up(v54)) = uint8('(') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('B') - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(7) + **(**uint8)(__ccgo_up(v54)) = uint8('B') + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(7) goto _51 } c = _uni_to_jis(tls, c) if !(c != 0) { goto subst } - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(8) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(8) { goto toobig } v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('\033') + **(**uint8)(__ccgo_up(v54)) = uint8('\033') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('$') + **(**uint8)(__ccgo_up(v54)) = uint8('$') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('B') + **(**uint8)(__ccgo_up(v54)) = uint8('B') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8(c / uint32(256)) + **(**uint8)(__ccgo_up(v54)) = uint8(c / uint32(256)) v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8(c % uint32(256)) + **(**uint8)(__ccgo_up(v54)) = uint8(c % uint32(256)) v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('\033') + **(**uint8)(__ccgo_up(v54)) = uint8('\033') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('(') + **(**uint8)(__ccgo_up(v54)) = uint8('(') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('B') - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(8) + **(**uint8)(__ccgo_up(v54)) = uint8('B') + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(8) goto _51 _42: ; @@ -99535,22 +99535,22 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if c >= uint32(0x10000) { c = uint32(0xFFFD) } - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(2) { goto toobig } - _put_16(tls, *(*uintptr)(unsafe.Pointer(out)), c, Int32FromUint8(totype)) - *(*uintptr)(unsafe.Pointer(out)) += uintptr(2) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(2) + _put_16(tls, **(**uintptr)(__ccgo_up(out)), c, Int32FromUint8(totype)) + **(**uintptr)(__ccgo_up(out)) += uintptr(2) + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(2) goto _51 } - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(4) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(4) { goto toobig } c = c - uint32(0x10000) - _put_16(tls, *(*uintptr)(unsafe.Pointer(out)), c>>int32(10)|uint32(0xd800), Int32FromUint8(totype)) - _put_16(tls, *(*uintptr)(unsafe.Pointer(out))+UintptrFromInt32(2), c&uint32(0x3ff)|uint32(0xdc00), Int32FromUint8(totype)) - *(*uintptr)(unsafe.Pointer(out)) += uintptr(4) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(4) + _put_16(tls, **(**uintptr)(__ccgo_up(out)), c>>int32(10)|uint32(0xd800), Int32FromUint8(totype)) + _put_16(tls, **(**uintptr)(__ccgo_up(out))+UintptrFromInt32(2), c&uint32(0x3ff)|uint32(0xdc00), Int32FromUint8(totype)) + **(**uintptr)(__ccgo_up(out)) += uintptr(4) + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(4) goto _51 _48: ; @@ -99559,22 +99559,22 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui ; _49: ; - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(4) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(4) { goto toobig } - _put_32(tls, *(*uintptr)(unsafe.Pointer(out)), c, Int32FromUint8(totype)) - *(*uintptr)(unsafe.Pointer(out)) += uintptr(4) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(4) + _put_32(tls, **(**uintptr)(__ccgo_up(out)), c, Int32FromUint8(totype)) + **(**uintptr)(__ccgo_up(out)) += uintptr(4) + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(4) goto _51 _51: ; goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(in)) += uintptr(l) - *(*Tsize_t)(unsafe.Pointer(inb)) -= l + **(**uintptr)(__ccgo_up(in)) += uintptr(l) + **(**Tsize_t)(__ccgo_up(inb)) -= l } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return x goto ilseq ilseq: @@ -99596,8 +99596,8 @@ starved: goto end end: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = err - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**int32)(__ccgo_up(X__errno_location(tls))) = err + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return x } @@ -99628,7 +99628,7 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { cat = item >> int32(16) idx = item & int32(65535) if item == int32(CODESET) { - if *(*uintptr)(unsafe.Pointer(loc)) != 0 { + if **(**uintptr)(__ccgo_up(loc)) != 0 { v1 = __ccgo_ts + 419 } else { v1 = __ccgo_ts + 564 @@ -99637,8 +99637,8 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { } /* _NL_LOCALE_NAME extension */ if idx == int32(65535) && cat < int32(LC_ALL) { - if *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*8)) != 0 { - v1 = *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*8)) + 16 + if **(**uintptr)(__ccgo_up(loc + uintptr(cat)*8)) != 0 { + v1 = **(**uintptr)(__ccgo_up(loc + uintptr(cat)*8)) + 16 } else { v1 = __ccgo_ts + 570 } @@ -99673,7 +99673,7 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { break } for { - if !(*(*uint8)(unsafe.Pointer(str)) != 0) { + if !(**(**uint8)(__ccgo_up(str)) != 0) { break } goto _4 @@ -99687,8 +99687,8 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { idx = idx - 1 str = str + 1 } - if cat != int32(LC_NUMERIC) && *(*uint8)(unsafe.Pointer(str)) != 0 { - str = X__lctrans(tls, str, *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*8))) + if cat != int32(LC_NUMERIC) && **(**uint8)(__ccgo_up(str)) != 0 { + str = X__lctrans(tls, str, **(**uintptr)(__ccgo_up(loc + uintptr(cat)*8))) } return str } @@ -99761,18 +99761,18 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = builtin, l, map1, n, new1, p, path, z, v1, v2, v3, v4, v5, v6, v7 new1 = uintptr(0) path = uintptr(0) - if !(*(*uint8)(unsafe.Pointer(val)) != 0) { + if !(**(**uint8)(__ccgo_up(val)) != 0) { v1 = Xgetenv(tls, __ccgo_ts+572) val = v1 - if v3 = v1 != 0 && *(*uint8)(unsafe.Pointer(val)) != 0; !v3 { + if v3 = v1 != 0 && **(**uint8)(__ccgo_up(val)) != 0; !v3 { v2 = Xgetenv(tls, uintptr(unsafe.Pointer(&_envvars))+uintptr(cat)*12) val = v2 } - if v5 = v3 || v2 != 0 && *(*uint8)(unsafe.Pointer(val)) != 0; !v5 { + if v5 = v3 || v2 != 0 && **(**uint8)(__ccgo_up(val)) != 0; !v5 { v4 = Xgetenv(tls, __ccgo_ts+433) val = v4 } - if v7 = v5 || v4 != 0 && *(*uint8)(unsafe.Pointer(val)) != 0; !v7 { + if v7 = v5 || v4 != 0 && **(**uint8)(__ccgo_up(val)) != 0; !v7 { v6 = __ccgo_ts + 579 val = v6 } @@ -99781,7 +99781,7 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { /* Limit name length and forbid leading dot or any slashes. */ n = uint64(0) for { - if !(n < uint64(LOCALE_NAME_MAX) && *(*uint8)(unsafe.Pointer(val + uintptr(n))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(val + uintptr(n)))) != int32('/')) { + if !(n < uint64(LOCALE_NAME_MAX) && **(**uint8)(__ccgo_up(val + uintptr(n))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(val + uintptr(n)))) != int32('/')) { break } goto _8 @@ -99789,12 +99789,12 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { ; n = n + 1 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(val))) == int32('.') || *(*uint8)(unsafe.Pointer(val + uintptr(n))) != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(val))) == int32('.') || **(**uint8)(__ccgo_up(val + uintptr(n))) != 0 { val = __ccgo_ts + 579 } - builtin = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(val))) == int32('C') && !(*(*uint8)(unsafe.Pointer(val + 1)) != 0) || !(Xstrcmp(tls, val, __ccgo_ts+579) != 0) || !(Xstrcmp(tls, val, __ccgo_ts+587) != 0)) + builtin = BoolInt32(Int32FromUint8(**(**uint8)(__ccgo_up(val))) == int32('C') && !(**(**uint8)(__ccgo_up(val + 1)) != 0) || !(Xstrcmp(tls, val, __ccgo_ts+579) != 0) || !(Xstrcmp(tls, val, __ccgo_ts+587) != 0)) if builtin != 0 { - if cat == LC_CTYPE && Int32FromUint8(*(*uint8)(unsafe.Pointer(val + 1))) == int32('.') { + if cat == LC_CTYPE && Int32FromUint8(**(**uint8)(__ccgo_up(val + 1))) == int32('.') { return uintptr(unsafe.Pointer(&X__c_dot_utf8)) } return uintptr(0) @@ -99818,7 +99818,7 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { /* FIXME: add a default path? */ if path != 0 { for { - if !(*(*uint8)(unsafe.Pointer(path)) != 0) { + if !(**(**uint8)(__ccgo_up(path)) != 0) { break } z = X__strchrnul(tls, path, int32(':')) @@ -99827,20 +99827,20 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { goto _10 } Xmemcpy(tls, bp, path, l) - (*(*[256]uint8)(unsafe.Pointer(bp)))[l] = uint8('/') + (**(**[256]uint8)(__ccgo_up(bp)))[l] = uint8('/') Xmemcpy(tls, bp+uintptr(l)+uintptr(1), val, n) - (*(*[256]uint8)(unsafe.Pointer(bp)))[l+uint64(1)+n] = uint8(0) + (**(**[256]uint8)(__ccgo_up(bp)))[l+uint64(1)+n] = uint8(0) map1 = X__map_file(tls, bp, bp+256) if map1 != 0 { new1 = Xmalloc(tls, uint64(48)) if !(new1 != 0) { - X__munmap(tls, map1, *(*Tsize_t)(unsafe.Pointer(bp + 256))) + X__munmap(tls, map1, **(**Tsize_t)(__ccgo_up(bp + 256))) break } (*t__locale_map)(unsafe.Pointer(new1)).Fmap1 = map1 - (*t__locale_map)(unsafe.Pointer(new1)).Fmap_size = *(*Tsize_t)(unsafe.Pointer(bp + 256)) + (*t__locale_map)(unsafe.Pointer(new1)).Fmap_size = **(**Tsize_t)(__ccgo_up(bp + 256)) Xmemcpy(tls, new1+16, val, n) - *(*uint8)(unsafe.Pointer(new1 + 16 + uintptr(n))) = uint8(0) + **(**uint8)(__ccgo_up(new1 + 16 + uintptr(n))) = uint8(0) (*t__locale_map)(unsafe.Pointer(new1)).Fnext = AtomicLoadPUintptr(uintptr(unsafe.Pointer(&_loc_head))) AtomicStorePUintptr(uintptr(unsafe.Pointer(&_loc_head)), new1) break @@ -99848,7 +99848,7 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { goto _10 _10: ; - path = z + BoolUintptr(!!(*(*uint8)(unsafe.Pointer(z)) != 0)) + path = z + BoolUintptr(!!(**(**uint8)(__ccgo_up(z)) != 0)) } } /* If no locale definition was found, make a locale map @@ -99863,7 +99863,7 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { (*t__locale_map)(unsafe.Pointer(new1)).Fmap1 = X__c_dot_utf8.Fmap1 (*t__locale_map)(unsafe.Pointer(new1)).Fmap_size = X__c_dot_utf8.Fmap_size Xmemcpy(tls, new1+16, val, n) - *(*uint8)(unsafe.Pointer(new1 + 16 + uintptr(n))) = uint8(0) + **(**uint8)(__ccgo_up(new1 + 16 + uintptr(n))) = uint8(0) (*t__locale_map)(unsafe.Pointer(new1)).Fnext = AtomicLoadPUintptr(uintptr(unsafe.Pointer(&_loc_head))) AtomicStorePUintptr(uintptr(unsafe.Pointer(&_loc_head)), new1) } @@ -99947,7 +99947,7 @@ func _do_newlocale(tls *TLS, mask int32, name uintptr, loc Tlocale_t) (r Tlocale break } if !(mask&(Int32FromInt32(1)<,< are accepted with or without = */ - if i < int32(6) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) == Int32FromUint8(_opch2[i]) { + if i < int32(6) && Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) == Int32FromUint8(_opch2[i]) { (*Tst)(unsafe.Pointer(st)).Fop = i return s + uintptr(2) } @@ -100253,12 +100253,12 @@ func _evalexpr(tls *TLS, st uintptr, s uintptr, d int32) (r uintptr) { return __ccgo_ts } s = _evalbinop(tls, st, s, 0, d) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('?') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32('?') { return s } a = (*Tst)(unsafe.Pointer(st)).Fr s = _evalexpr(tls, st, s+uintptr(1), d) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32(':') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32(':') { return __ccgo_ts } b = (*Tst)(unsafe.Pointer(st)).Fr @@ -100282,10 +100282,10 @@ func X__pleval(tls *TLS, s uintptr, n uint64) (r uint64) { var v1 uint64 var _ /* st at bp+0 */ Tst _ = v1 - (*(*Tst)(unsafe.Pointer(bp))).Fn = n + (**(**Tst)(__ccgo_up(bp))).Fn = n s = _evalexpr(tls, bp, s, int32(100)) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32(';') { - v1 = (*(*Tst)(unsafe.Pointer(bp))).Fr + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32(';') { + v1 = (**(**Tst)(__ccgo_up(bp))).Fr } else { v1 = Uint64FromInt32(-Int32FromInt32(1)) } @@ -100318,7 +100318,7 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { * on the format, so it can easily be changed if needed. */ if cat == int32(LC_ALL) { if name != 0 { - *(*[24]uint8)(unsafe.Pointer(bp + 48)) = [24]uint8{'C', '.', 'U', 'T', 'F', '-', '8'} + **(**[24]uint8)(__ccgo_up(bp + 48)) = [24]uint8{'C', '.', 'U', 'T', 'F', '-', '8'} p = name i = 0 for { @@ -100328,8 +100328,8 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { z = X__strchrnul(tls, p, int32(';')) if int64(z)-int64(p) <= int64(LOCALE_NAME_MAX) { Xmemcpy(tls, bp+48, p, Uint64FromInt64(int64(z)-int64(p))) - (*(*[24]uint8)(unsafe.Pointer(bp + 48)))[int64(z)-int64(p)] = uint8(0) - if *(*uint8)(unsafe.Pointer(z)) != 0 { + (**(**[24]uint8)(__ccgo_up(bp + 48)))[int64(z)-int64(p)] = uint8(0) + if **(**uint8)(__ccgo_up(z)) != 0 { p = z + uintptr(1) } } @@ -100338,13 +100338,13 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { ___unlock(tls, uintptr(unsafe.Pointer(&X__locale_lock))) return uintptr(0) } - *(*uintptr)(unsafe.Pointer(bp + uintptr(i)*8)) = lm + **(**uintptr)(__ccgo_up(bp + uintptr(i)*8)) = lm goto _1 _1: ; i = i + 1 } - X__libc.Fglobal_locale = *(*t__locale_struct)(unsafe.Pointer(bp)) + X__libc.Fglobal_locale = **(**t__locale_struct)(__ccgo_up(bp)) } s = uintptr(unsafe.Pointer(&_buf1)) same = 0 @@ -100353,8 +100353,8 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { if !(i < int32(LC_ALL)) { break } - lm1 = *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 56 + uintptr(i)*8)) - if lm1 == *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 56)) { + lm1 = **(**uintptr)(__ccgo_up(uintptr(unsafe.Pointer(&X__libc)) + 56 + uintptr(i)*8)) + if lm1 == **(**uintptr)(__ccgo_up(uintptr(unsafe.Pointer(&X__libc)) + 56)) { same = same + 1 } if lm1 != 0 { @@ -100365,7 +100365,7 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { part1 = v3 l = _strlen(tls, part1) Xmemcpy(tls, s, part1, l) - *(*uint8)(unsafe.Pointer(s + uintptr(l))) = uint8(';') + **(**uint8)(__ccgo_up(s + uintptr(l))) = uint8(';') s = s + uintptr(l+uint64(1)) goto _2 _2: @@ -100374,7 +100374,7 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { } s = s - 1 v3 = s - *(*uint8)(unsafe.Pointer(v3)) = uint8(0) + **(**uint8)(__ccgo_up(v3)) = uint8(0) ___unlock(tls, uintptr(unsafe.Pointer(&X__locale_lock))) if same == int32(LC_ALL) { v3 = part1 @@ -100389,9 +100389,9 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { ___unlock(tls, uintptr(unsafe.Pointer(&X__locale_lock))) return uintptr(0) } - *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 56 + uintptr(cat)*8)) = lm + **(**uintptr)(__ccgo_up(uintptr(unsafe.Pointer(&X__libc)) + 56 + uintptr(cat)*8)) = lm } else { - lm = *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 56 + uintptr(cat)*8)) + lm = **(**uintptr)(__ccgo_up(uintptr(unsafe.Pointer(&X__libc)) + 56 + uintptr(cat)*8)) } if lm != 0 { v3 = lm + 16 @@ -100438,10 +100438,10 @@ func _vstrfmon_l(tls *TLS, s uintptr, n Tsize_t, loc Tlocale_t, fmt uintptr, ap s0 = s _3: ; - if !(n != 0 && *(*uint8)(unsafe.Pointer(fmt)) != 0) { + if !(n != 0 && **(**uint8)(__ccgo_up(fmt)) != 0) { goto _1 } - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) != int32('%')) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(fmt))) != int32('%')) { goto _4 } goto literal @@ -100451,13 +100451,13 @@ literal: s = s + 1 v6 = fmt fmt = fmt + 1 - *(*uint8)(unsafe.Pointer(v5)) = *(*uint8)(unsafe.Pointer(v6)) + **(**uint8)(__ccgo_up(v5)) = **(**uint8)(__ccgo_up(v6)) n = n - 1 goto _2 _4: ; fmt = fmt + 1 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) == int32('%') { + if Int32FromUint8(**(**uint8)(__ccgo_up(fmt))) == int32('%') { goto literal } fill = int32(' ') @@ -100466,11 +100466,11 @@ _4: nosym = 0 left = 0 for { - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(fmt))) { case int32('='): fmt = fmt + 1 v5 = fmt - fill = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + fill = Int32FromUint8(**(**uint8)(__ccgo_up(v5))) goto _7 case int32('^'): nogrp = int32(1) @@ -100495,10 +100495,10 @@ _4: } fw = 0 for { - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(fmt)))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(fmt)))-uint32('0') < uint32(10)) != 0) { break } - fw = int32(10)*fw + (Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) - int32('0')) + fw = int32(10)*fw + (Int32FromUint8(**(**uint8)(__ccgo_up(fmt))) - int32('0')) goto _9 _9: ; @@ -100506,28 +100506,28 @@ _4: } lp = 0 rp = int32(2) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) == int32('#') { + if Int32FromUint8(**(**uint8)(__ccgo_up(fmt))) == int32('#') { lp = 0 fmt = fmt + 1 for { - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(fmt)))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(fmt)))-uint32('0') < uint32(10)) != 0) { break } - lp = int32(10)*lp + (Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) - int32('0')) + lp = int32(10)*lp + (Int32FromUint8(**(**uint8)(__ccgo_up(fmt))) - int32('0')) goto _10 _10: ; fmt = fmt + 1 } } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) == int32('.') { + if Int32FromUint8(**(**uint8)(__ccgo_up(fmt))) == int32('.') { rp = 0 fmt = fmt + 1 for { - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(fmt)))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(fmt)))-uint32('0') < uint32(10)) != 0) { break } - rp = int32(10)*rp + (Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) - int32('0')) + rp = int32(10)*rp + (Int32FromUint8(**(**uint8)(__ccgo_up(fmt))) - int32('0')) goto _11 _11: ; @@ -100536,7 +100536,7 @@ _4: } v5 = fmt fmt = fmt + 1 - intl = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) == int32('i')) + intl = BoolInt32(Int32FromUint8(**(**uint8)(__ccgo_up(v5))) == int32('i')) w = lp + int32(1) + rp if !(left != 0) && fw > w { w = fw @@ -100544,7 +100544,7 @@ _4: x = VaFloat64(&ap) l = Uint64FromInt32(Xsnprintf(tls, s, n, __ccgo_ts+608, VaList(bp+8, w, rp, x))) if l >= n { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(E2BIG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(E2BIG) return int64(-int32(1)) } s = s + uintptr(l) @@ -100709,7 +100709,7 @@ func Xtextdomain(tls *TLS, domainname uintptr) (r uintptr) { } domlen = _strlen(tls, domainname) if domlen > uint64(NAME_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } if !(_current_domain != 0) { @@ -100819,7 +100819,7 @@ func X__wcsxfrm_l(tls *TLS, dest uintptr, src uintptr, n Tsize_t, loc Tlocale_t) } else { if n != 0 { Xwmemcpy(tls, dest, src, n-uint64(1)) - *(*Twchar_t)(unsafe.Pointer(dest + uintptr(n-uint64(1))*4)) = 0 + **(**Twchar_t)(__ccgo_up(dest + uintptr(n-uint64(1))*4)) = 0 } } return l @@ -100850,7 +100850,7 @@ func Xreallocarray(tls *TLS, ptr uintptr, m Tsize_t, n Tsize_t) (r uintptr) { defer func() { trc("-> %v", r) }() } if n != 0 && m > Uint64FromInt32(-Int32FromInt32(1))/n { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return uintptr(0) } return Xrealloc(tls, ptr, m*n) @@ -101243,25 +101243,25 @@ func X__rem_pio2(tls *TLS, x float64, y uintptr) (r1 int32) { if ix <= uint32(0x4002d97c) { /* |x| ~<= 3pi/4 */ if !(sign != 0) { z = x - _pio2_1 /* one round good to 85 bits */ - *(*float64)(unsafe.Pointer(y)) = z - _pio2_1t - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) - _pio2_1t + **(**float64)(__ccgo_up(y)) = z - _pio2_1t + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) - _pio2_1t return int32(1) } else { z = x + _pio2_1 - *(*float64)(unsafe.Pointer(y)) = z + _pio2_1t - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) + _pio2_1t + **(**float64)(__ccgo_up(y)) = z + _pio2_1t + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) + _pio2_1t return -int32(1) } } else { if !(sign != 0) { z = x - float64(Float64FromInt32(2)*_pio2_1) - *(*float64)(unsafe.Pointer(y)) = z - Tdouble_t(Float64FromInt32(2)*_pio2_1t) - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) - Tdouble_t(Float64FromInt32(2)*_pio2_1t) + **(**float64)(__ccgo_up(y)) = z - Tdouble_t(Float64FromInt32(2)*_pio2_1t) + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) - Tdouble_t(Float64FromInt32(2)*_pio2_1t) return int32(2) } else { z = x + float64(Float64FromInt32(2)*_pio2_1) - *(*float64)(unsafe.Pointer(y)) = z + Tdouble_t(Float64FromInt32(2)*_pio2_1t) - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) + Tdouble_t(Float64FromInt32(2)*_pio2_1t) + **(**float64)(__ccgo_up(y)) = z + Tdouble_t(Float64FromInt32(2)*_pio2_1t) + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) + Tdouble_t(Float64FromInt32(2)*_pio2_1t) return -int32(2) } } @@ -101273,13 +101273,13 @@ func X__rem_pio2(tls *TLS, x float64, y uintptr) (r1 int32) { } if !(sign != 0) { z = x - float64(Float64FromInt32(3)*_pio2_1) - *(*float64)(unsafe.Pointer(y)) = z - Tdouble_t(Float64FromInt32(3)*_pio2_1t) - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) - Tdouble_t(Float64FromInt32(3)*_pio2_1t) + **(**float64)(__ccgo_up(y)) = z - Tdouble_t(Float64FromInt32(3)*_pio2_1t) + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) - Tdouble_t(Float64FromInt32(3)*_pio2_1t) return int32(3) } else { z = x + float64(Float64FromInt32(3)*_pio2_1) - *(*float64)(unsafe.Pointer(y)) = z + Tdouble_t(Float64FromInt32(3)*_pio2_1t) - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) + Tdouble_t(Float64FromInt32(3)*_pio2_1t) + **(**float64)(__ccgo_up(y)) = z + Tdouble_t(Float64FromInt32(3)*_pio2_1t) + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) + Tdouble_t(Float64FromInt32(3)*_pio2_1t) return -int32(3) } } else { @@ -101288,13 +101288,13 @@ func X__rem_pio2(tls *TLS, x float64, y uintptr) (r1 int32) { } if !(sign != 0) { z = x - float64(Float64FromInt32(4)*_pio2_1) - *(*float64)(unsafe.Pointer(y)) = z - Tdouble_t(Float64FromInt32(4)*_pio2_1t) - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) - Tdouble_t(Float64FromInt32(4)*_pio2_1t) + **(**float64)(__ccgo_up(y)) = z - Tdouble_t(Float64FromInt32(4)*_pio2_1t) + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) - Tdouble_t(Float64FromInt32(4)*_pio2_1t) return int32(4) } else { z = x + float64(Float64FromInt32(4)*_pio2_1) - *(*float64)(unsafe.Pointer(y)) = z + Tdouble_t(Float64FromInt32(4)*_pio2_1t) - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) + Tdouble_t(Float64FromInt32(4)*_pio2_1t) + **(**float64)(__ccgo_up(y)) = z + Tdouble_t(Float64FromInt32(4)*_pio2_1t) + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) + Tdouble_t(Float64FromInt32(4)*_pio2_1t) return -int32(4) } } @@ -101324,8 +101324,8 @@ medium: w = Tdouble_t(fn * _pio2_1t) } } - *(*float64)(unsafe.Pointer(y)) = r - w - *(*float64)(unsafe.Pointer(bp)) = *(*float64)(unsafe.Pointer(y)) + **(**float64)(__ccgo_up(y)) = r - w + *(*float64)(unsafe.Pointer(bp)) = **(**float64)(__ccgo_up(y)) ey = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(52) & uint64(0x7ff)) ex = Int32FromUint32(ix >> int32(20)) if ex-ey > int32(16) { /* 2nd round, good to 118 bits */ @@ -101333,18 +101333,18 @@ medium: w = Tdouble_t(fn * _pio2_2) r = t - w w = Tdouble_t(fn*_pio2_2t) - (t - r - w) - *(*float64)(unsafe.Pointer(y)) = r - w - *(*float64)(unsafe.Pointer(bp)) = *(*float64)(unsafe.Pointer(y)) + **(**float64)(__ccgo_up(y)) = r - w + *(*float64)(unsafe.Pointer(bp)) = **(**float64)(__ccgo_up(y)) ey = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(52) & uint64(0x7ff)) if ex-ey > int32(49) { /* 3rd round, good to 151 bits, covers all cases */ t = r w = Tdouble_t(fn * _pio2_3) r = t - w w = Tdouble_t(fn*_pio2_3t) - (t - r - w) - *(*float64)(unsafe.Pointer(y)) = r - w + **(**float64)(__ccgo_up(y)) = r - w } } - *(*float64)(unsafe.Pointer(y + 1*8)) = r - *(*float64)(unsafe.Pointer(y)) - w + **(**float64)(__ccgo_up(y + 1*8)) = r - **(**float64)(__ccgo_up(y)) - w return n _1: ; @@ -101353,8 +101353,8 @@ _1: */ if ix >= uint32(0x7ff00000) { /* x is inf or NaN */ v2 = x - x - *(*float64)(unsafe.Pointer(y + 1*8)) = v2 - *(*float64)(unsafe.Pointer(y)) = v2 + **(**float64)(__ccgo_up(y + 1*8)) = v2 + **(**float64)(__ccgo_up(y)) = v2 return 0 } /* set z = scalbn(|x|,-ilogb(x)+23) */ @@ -101367,26 +101367,26 @@ _1: if !(i < int32(2)) { break } - (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i] = float64(int32(z)) - z = Tdouble_t((z - (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i]) * float64(1.6777216e+07)) + (**(**[3]float64)(__ccgo_up(bp + 8)))[i] = float64(int32(z)) + z = Tdouble_t((z - (**(**[3]float64)(__ccgo_up(bp + 8)))[i]) * float64(1.6777216e+07)) goto _3 _3: ; i = i + 1 } - (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i] = z + (**(**[3]float64)(__ccgo_up(bp + 8)))[i] = z /* skip zero terms, first term is non-zero */ - for (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i] == float64(0) { + for (**(**[3]float64)(__ccgo_up(bp + 8)))[i] == float64(0) { i = i - 1 } n = X__rem_pio2_large(tls, bp+8, bp+32, Int32FromUint32(ix>>Int32FromInt32(20))-(Int32FromInt32(0x3ff)+Int32FromInt32(23)), i+int32(1), int32(1)) if sign != 0 { - *(*float64)(unsafe.Pointer(y)) = -(*(*[2]float64)(unsafe.Pointer(bp + 32)))[0] - *(*float64)(unsafe.Pointer(y + 1*8)) = -(*(*[2]float64)(unsafe.Pointer(bp + 32)))[int32(1)] + **(**float64)(__ccgo_up(y)) = -(**(**[2]float64)(__ccgo_up(bp + 32)))[0] + **(**float64)(__ccgo_up(y + 1*8)) = -(**(**[2]float64)(__ccgo_up(bp + 32)))[int32(1)] return -n } - *(*float64)(unsafe.Pointer(y)) = (*(*[2]float64)(unsafe.Pointer(bp + 32)))[0] - *(*float64)(unsafe.Pointer(y + 1*8)) = (*(*[2]float64)(unsafe.Pointer(bp + 32)))[int32(1)] + **(**float64)(__ccgo_up(y)) = (**(**[2]float64)(__ccgo_up(bp + 32)))[0] + **(**float64)(__ccgo_up(y + 1*8)) = (**(**[2]float64)(__ccgo_up(bp + 32)))[int32(1)] return n } @@ -101548,7 +101548,7 @@ func X__rem_pio2_large(tls *TLS, x uintptr, y uintptr, e0 int32, nx int32, prec if !(j <= jx) { break } - fw = fw + float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8))*f[jx+i-j]) + fw = fw + float64(**(**float64)(__ccgo_up(x + uintptr(j)*8))*f[jx+i-j]) goto _4 _4: ; @@ -101573,7 +101573,7 @@ recompute: break } fw = float64(int32(float64(Float64FromFloat64(5.960464477539063e-08) * z))) - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] = int32(z - float64(Float64FromFloat64(1.6777216e+07)*fw)) + (**(**[20]Tint32_t)(__ccgo_up(bp)))[i] = int32(z - float64(Float64FromFloat64(1.6777216e+07)*fw)) z = q[j-int32(1)] + fw goto _5 _5: @@ -101588,13 +101588,13 @@ recompute: z = z - float64(n) ih = 0 if q0 > 0 { /* need iq[jz-1] to determine n */ - i = (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz-int32(1)] >> (int32(24) - q0) + i = (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz-int32(1)] >> (int32(24) - q0) n = n + i - *(*Tint32_t)(unsafe.Pointer(bp + uintptr(jz-int32(1))*4)) -= i << (int32(24) - q0) - ih = (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz-int32(1)] >> (int32(23) - q0) + **(**Tint32_t)(__ccgo_up(bp + uintptr(jz-int32(1))*4)) -= i << (int32(24) - q0) + ih = (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz-int32(1)] >> (int32(23) - q0) } else { if q0 == 0 { - ih = (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz-int32(1)] >> int32(23) + ih = (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz-int32(1)] >> int32(23) } else { if z >= float64(0.5) { ih = int32(2) @@ -101609,14 +101609,14 @@ recompute: if !(i < jz) { break } /* compute 1-q */ - j = (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] + j = (**(**[20]Tint32_t)(__ccgo_up(bp)))[i] if carry == 0 { if j != 0 { carry = int32(1) - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] = int32(0x1000000) - j + (**(**[20]Tint32_t)(__ccgo_up(bp)))[i] = int32(0x1000000) - j } } else { - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] = int32(0xffffff) - j + (**(**[20]Tint32_t)(__ccgo_up(bp)))[i] = int32(0xffffff) - j } goto _6 _6: @@ -101626,9 +101626,9 @@ recompute: if q0 > 0 { /* rare case: chance is 1 in 12 */ switch q0 { case int32(1): - *(*Tint32_t)(unsafe.Pointer(bp + uintptr(jz-int32(1))*4)) &= int32(0x7fffff) + **(**Tint32_t)(__ccgo_up(bp + uintptr(jz-int32(1))*4)) &= int32(0x7fffff) case int32(2): - *(*Tint32_t)(unsafe.Pointer(bp + uintptr(jz-int32(1))*4)) &= int32(0x3fffff) + **(**Tint32_t)(__ccgo_up(bp + uintptr(jz-int32(1))*4)) &= int32(0x3fffff) break } } @@ -101647,7 +101647,7 @@ recompute: if !(i >= jk) { break } - j = j | (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] + j = j | (**(**[20]Tint32_t)(__ccgo_up(bp)))[i] goto _7 _7: ; @@ -101656,7 +101656,7 @@ recompute: if j == 0 { /* need recomputation */ k = int32(1) for { - if !((*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jk-k] == 0) { + if !((**(**[20]Tint32_t)(__ccgo_up(bp)))[jk-k] == 0) { break } goto _8 @@ -101676,7 +101676,7 @@ recompute: if !(j <= jx) { break } - fw = fw + float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8))*f[jx+i-j]) + fw = fw + float64(**(**float64)(__ccgo_up(x + uintptr(j)*8))*f[jx+i-j]) goto _10 _10: ; @@ -101696,7 +101696,7 @@ recompute: if z == float64(0) { jz = jz - int32(1) q0 = q0 - int32(24) - for (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] == 0 { + for (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz] == 0 { jz = jz - 1 q0 = q0 - int32(24) } @@ -101704,12 +101704,12 @@ recompute: z = Xscalbn(tls, z, -q0) if z >= float64(1.6777216e+07) { fw = float64(int32(float64(Float64FromFloat64(5.960464477539063e-08) * z))) - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(z - float64(Float64FromFloat64(1.6777216e+07)*fw)) + (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz] = int32(z - float64(Float64FromFloat64(1.6777216e+07)*fw)) jz = jz + int32(1) q0 = q0 + int32(24) - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(fw) + (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz] = int32(fw) } else { - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(z) + (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz] = int32(z) } } /* convert integer "bit" chunk to floating-point value */ @@ -101719,7 +101719,7 @@ recompute: if !(i >= 0) { break } - q[i] = float64(fw * float64((*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i])) + q[i] = float64(fw * float64((**(**[20]Tint32_t)(__ccgo_up(bp)))[i])) fw = fw * float64(5.960464477539063e-08) goto _11 _11: @@ -101744,7 +101744,7 @@ recompute: ; k = k + 1 } - (*(*[20]float64)(unsafe.Pointer(bp + 80)))[jz-i] = fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[jz-i] = fw goto _12 _12: ; @@ -101770,7 +101770,7 @@ _14: if !(i >= 0) { break } - fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[i] goto _19 _19: ; @@ -101781,7 +101781,7 @@ _14: } else { v2 = -fw } - *(*float64)(unsafe.Pointer(y)) = v2 + **(**float64)(__ccgo_up(y)) = v2 goto _18 _16: ; @@ -101793,7 +101793,7 @@ _15: if !(i >= 0) { break } - fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[i] goto _21 _21: ; @@ -101806,14 +101806,14 @@ _15: } else { v2 = -fw } - *(*float64)(unsafe.Pointer(y)) = v2 - fw = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[0] - fw + **(**float64)(__ccgo_up(y)) = v2 + fw = (**(**[20]float64)(__ccgo_up(bp + 80)))[0] - fw i = int32(1) for { if !(i <= jz) { break } - fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[i] goto _23 _23: ; @@ -101824,7 +101824,7 @@ _15: } else { v2 = -fw } - *(*float64)(unsafe.Pointer(y + 1*8)) = v2 + **(**float64)(__ccgo_up(y + 1*8)) = v2 goto _18 _17: ; /* painful */ @@ -101834,9 +101834,9 @@ _27: if !(i > 0) { goto _25 } - fw = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i-int32(1)] + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] - *(*float64)(unsafe.Pointer(bp + 80 + uintptr(i)*8)) += (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i-int32(1)] - fw - (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i-int32(1)] = fw + fw = (**(**[20]float64)(__ccgo_up(bp + 80)))[i-int32(1)] + (**(**[20]float64)(__ccgo_up(bp + 80)))[i] + **(**float64)(__ccgo_up(bp + 80 + uintptr(i)*8)) += (**(**[20]float64)(__ccgo_up(bp + 80)))[i-int32(1)] - fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[i-int32(1)] = fw goto _26 _26: ; @@ -101850,9 +101850,9 @@ _25: if !(i > int32(1)) { break } - fw = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i-int32(1)] + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] - *(*float64)(unsafe.Pointer(bp + 80 + uintptr(i)*8)) += (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i-int32(1)] - fw - (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i-int32(1)] = fw + fw = (**(**[20]float64)(__ccgo_up(bp + 80)))[i-int32(1)] + (**(**[20]float64)(__ccgo_up(bp + 80)))[i] + **(**float64)(__ccgo_up(bp + 80 + uintptr(i)*8)) += (**(**[20]float64)(__ccgo_up(bp + 80)))[i-int32(1)] - fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[i-int32(1)] = fw goto _28 _28: ; @@ -101864,20 +101864,20 @@ _25: if !(i >= int32(2)) { break } - fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[i] goto _29 _29: ; i = i - 1 } if ih == 0 { - *(*float64)(unsafe.Pointer(y)) = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[0] - *(*float64)(unsafe.Pointer(y + 1*8)) = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[int32(1)] - *(*float64)(unsafe.Pointer(y + 2*8)) = fw + **(**float64)(__ccgo_up(y)) = (**(**[20]float64)(__ccgo_up(bp + 80)))[0] + **(**float64)(__ccgo_up(y + 1*8)) = (**(**[20]float64)(__ccgo_up(bp + 80)))[int32(1)] + **(**float64)(__ccgo_up(y + 2*8)) = fw } else { - *(*float64)(unsafe.Pointer(y)) = -(*(*[20]float64)(unsafe.Pointer(bp + 80)))[0] - *(*float64)(unsafe.Pointer(y + 1*8)) = -(*(*[20]float64)(unsafe.Pointer(bp + 80)))[int32(1)] - *(*float64)(unsafe.Pointer(y + 2*8)) = -fw + **(**float64)(__ccgo_up(y)) = -(**(**[20]float64)(__ccgo_up(bp + 80)))[0] + **(**float64)(__ccgo_up(y + 1*8)) = -(**(**[20]float64)(__ccgo_up(bp + 80)))[int32(1)] + **(**float64)(__ccgo_up(y + 2*8)) = -fw } _18: ; @@ -101931,36 +101931,36 @@ func X__rem_pio2f(tls *TLS, x float32, y uintptr) (r int32) { /* Use a specialized rint() to get fn. */ fn = Tdouble_t(float64(x)*_invpio21) + _toint1 - _toint1 n = int32(fn) - *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) + **(**float64)(__ccgo_up(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) /* Matters with directed rounding. */ - if *(*float64)(unsafe.Pointer(y)) < -_pio41 { + if **(**float64)(__ccgo_up(y)) < -_pio41 { n = n - 1 fn = fn - 1 - *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) + **(**float64)(__ccgo_up(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) } else { - if *(*float64)(unsafe.Pointer(y)) > _pio41 { + if **(**float64)(__ccgo_up(y)) > _pio41 { n = n + 1 fn = fn + 1 - *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) + **(**float64)(__ccgo_up(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) } } return n } if ix >= uint32(0x7f800000) { /* x is inf or NaN */ - *(*float64)(unsafe.Pointer(y)) = float64(x - x) + **(**float64)(__ccgo_up(y)) = float64(x - x) return 0 } /* scale x into [2^23, 2^24-1] */ sign = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(bp)) >> int32(31)) e0 = Int32FromUint32(ix>>Int32FromInt32(23) - Uint32FromInt32(Int32FromInt32(0x7f)+Int32FromInt32(23))) /* e0 = ilogb(|x|)-23, positive */ *(*Tuint32_t)(unsafe.Pointer(bp)) = ix - Uint32FromInt32(e0<>int32(52)&uint64(0x7ff) < Uint64FromInt32(Int32FromInt32(0x3ff)+Int32FromInt32(4)) { if !(y != 0) { - return _p10[int32(*(*float64)(unsafe.Pointer(bp)))+int32(15)] + return _p10[int32(**(**float64)(__ccgo_up(bp)))+int32(15)] } y = Xexp2(tls, float64(float64(3.321928094887362)*y)) - return float64(y * _p10[int32(*(*float64)(unsafe.Pointer(bp)))+int32(15)]) + return float64(y * _p10[int32(**(**float64)(__ccgo_up(bp)))+int32(15)]) } return Xpow(tls, float64(10), x) } @@ -104609,14 +104609,14 @@ func Xexp10f(tls *TLS, x float32) (r float32) { Fi [0]Tuint32_t Ff float32 }{} - *(*float32)(unsafe.Pointer(bp + 4)) = *(*float32)(unsafe.Pointer(bp)) + *(*float32)(unsafe.Pointer(bp + 4)) = **(**float32)(__ccgo_up(bp)) /* fabsf(n) < 8 without raising invalid on nan */ if *(*Tuint32_t)(unsafe.Pointer(bp + 4))>>int32(23)&uint32(0xff) < Uint32FromInt32(Int32FromInt32(0x7f)+Int32FromInt32(3)) { if !(y != 0) { - return _p101[int32(*(*float32)(unsafe.Pointer(bp)))+int32(7)] + return _p101[int32(**(**float32)(__ccgo_up(bp)))+int32(7)] } y = Xexp2f(tls, float32(Float32FromFloat32(3.321928094887362)*y)) - return float32(y * _p101[int32(*(*float32)(unsafe.Pointer(bp)))+int32(7)]) + return float32(y * _p101[int32(**(**float32)(__ccgo_up(bp)))+int32(7)]) } return float32(Xexp2(tls, float64(float64(3.321928094887362)*float64(x)))) } @@ -104780,16 +104780,16 @@ _5: /* 2^(k/N) ~= scale * (1 + tail). */ idx = uint64(2) * (ki % Uint64FromInt32(Int32FromInt32(1)<>Int32FromInt32(32) + BoolUint64(t1 > *(*Tuint64_t)(unsafe.Pointer(lo))) + **(**Tuint64_t)(__ccgo_up(lo)) = t1 + t2<>Int32FromInt32(32) + BoolUint64(t1 > **(**Tuint64_t)(__ccgo_up(lo))) } func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { @@ -105694,11 +105694,11 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { if d == 0 { } else { if d < int32(64) { - *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = *(*Tuint64_t)(unsafe.Pointer(bp))<<(int32(64)-d) | *(*Tuint64_t)(unsafe.Pointer(bp + 8))>>d | BoolUint64(!!(*(*Tuint64_t)(unsafe.Pointer(bp + 8))<<(Int32FromInt32(64)-d) != 0)) - *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp)) >> d + **(**Tuint64_t)(__ccgo_up(bp + 8)) = **(**Tuint64_t)(__ccgo_up(bp))<<(int32(64)-d) | **(**Tuint64_t)(__ccgo_up(bp + 8))>>d | BoolUint64(!!(**(**Tuint64_t)(__ccgo_up(bp + 8))<<(Int32FromInt32(64)-d) != 0)) + **(**Tuint64_t)(__ccgo_up(bp)) = **(**Tuint64_t)(__ccgo_up(bp)) >> d } else { - *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = uint64(1) - *(*Tuint64_t)(unsafe.Pointer(bp)) = uint64(0) + **(**Tuint64_t)(__ccgo_up(bp + 8)) = uint64(1) + **(**Tuint64_t)(__ccgo_up(bp)) = uint64(0) } } } @@ -105721,24 +105721,24 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { nonzero = int32(1) if samesign != 0 { /* r += z */ - *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) + zlo - *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp)) + (zhi + BoolUint64(*(*Tuint64_t)(unsafe.Pointer(bp + 8)) < zlo)) + **(**Tuint64_t)(__ccgo_up(bp + 8)) = **(**Tuint64_t)(__ccgo_up(bp + 8)) + zlo + **(**Tuint64_t)(__ccgo_up(bp)) = **(**Tuint64_t)(__ccgo_up(bp)) + (zhi + BoolUint64(**(**Tuint64_t)(__ccgo_up(bp + 8)) < zlo)) } else { /* r -= z */ - t = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) - *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) - zlo - *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp)) - zhi - BoolUint64(t < *(*Tuint64_t)(unsafe.Pointer(bp + 8))) - if *(*Tuint64_t)(unsafe.Pointer(bp))>>int32(63) != 0 { - *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = -*(*Tuint64_t)(unsafe.Pointer(bp + 8)) - *(*Tuint64_t)(unsafe.Pointer(bp)) = -*(*Tuint64_t)(unsafe.Pointer(bp)) - BoolUint64(!!(*(*Tuint64_t)(unsafe.Pointer(bp + 8)) != 0)) + t = **(**Tuint64_t)(__ccgo_up(bp + 8)) + **(**Tuint64_t)(__ccgo_up(bp + 8)) = **(**Tuint64_t)(__ccgo_up(bp + 8)) - zlo + **(**Tuint64_t)(__ccgo_up(bp)) = **(**Tuint64_t)(__ccgo_up(bp)) - zhi - BoolUint64(t < **(**Tuint64_t)(__ccgo_up(bp + 8))) + if **(**Tuint64_t)(__ccgo_up(bp))>>int32(63) != 0 { + **(**Tuint64_t)(__ccgo_up(bp + 8)) = -**(**Tuint64_t)(__ccgo_up(bp + 8)) + **(**Tuint64_t)(__ccgo_up(bp)) = -**(**Tuint64_t)(__ccgo_up(bp)) - BoolUint64(!!(**(**Tuint64_t)(__ccgo_up(bp + 8)) != 0)) sign = BoolInt32(!(sign != 0)) } - nonzero = BoolInt32(!!(*(*Tuint64_t)(unsafe.Pointer(bp)) != 0)) + nonzero = BoolInt32(!!(**(**Tuint64_t)(__ccgo_up(bp)) != 0)) } /* set rhi to top 63bit of the result (last bit is sticky) */ if nonzero != 0 { e = e + int32(64) - v1 = *(*Tuint64_t)(unsafe.Pointer(bp)) + v1 = **(**Tuint64_t)(__ccgo_up(bp)) // __asm__ ("cntlzd %0, %1" : "=r"(x) : "r"(x)); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 60, __ccgo_ts+614) v2 = Int32FromUint64(v1) @@ -105746,10 +105746,10 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { _3: d = v2 - int32(1) /* note: d > 0 */ - *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp))<>(int32(64)-d) | BoolUint64(!!(*(*Tuint64_t)(unsafe.Pointer(bp + 8))<>(int32(64)-d) | BoolUint64(!!(**(**Tuint64_t)(__ccgo_up(bp + 8))<>int32(1) | *(*Tuint64_t)(unsafe.Pointer(bp + 8))&uint64(1) + **(**Tuint64_t)(__ccgo_up(bp)) = **(**Tuint64_t)(__ccgo_up(bp + 8))>>int32(1) | **(**Tuint64_t)(__ccgo_up(bp + 8))&uint64(1) } else { - *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) << d + **(**Tuint64_t)(__ccgo_up(bp)) = **(**Tuint64_t)(__ccgo_up(bp + 8)) << d } } else { /* exact +-0 */ @@ -105768,7 +105768,7 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { } e = e - d /* convert to double */ - i = Int64FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp))) /* i is in [1<<62,(1<<63)-1] */ + i = Int64FromUint64(**(**Tuint64_t)(__ccgo_up(bp))) /* i is in [1<<62,(1<<63)-1] */ if sign != 0 { i = -i } @@ -105789,8 +105789,8 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { } /* one bit is lost when scaled, add another top bit to only round once at conversion if it is inexact */ - if *(*Tuint64_t)(unsafe.Pointer(bp))<>int32(1) | *(*Tuint64_t)(unsafe.Pointer(bp))&uint64(1) | Uint64FromUint64(1)<>int32(1)|**(**Tuint64_t)(__ccgo_up(bp))&uint64(1)) | Uint64FromUint64(1)<>d | BoolUint64(!!(*(*Tuint64_t)(unsafe.Pointer(bp))<<(Int32FromInt32(64)-d) != 0))) << d) + i = Int64FromUint64((**(**Tuint64_t)(__ccgo_up(bp))>>d | BoolUint64(!!(**(**Tuint64_t)(__ccgo_up(bp))<<(Int32FromInt32(64)-d) != 0))) << d) if sign != 0 { i = -i } @@ -106390,9 +106390,9 @@ func Xfrexp(tls *TLS, x float64, e uintptr) (r float64) { if !(ee != 0) { if x != 0 { x = Xfrexp(tls, float64(x*float64(1.8446744073709552e+19)), e) - *(*int32)(unsafe.Pointer(e)) -= int32(64) + **(**int32)(__ccgo_up(e)) -= int32(64) } else { - *(*int32)(unsafe.Pointer(e)) = 0 + **(**int32)(__ccgo_up(e)) = 0 } return x } else { @@ -106400,7 +106400,7 @@ func Xfrexp(tls *TLS, x float64, e uintptr) (r float64) { return x } } - *(*int32)(unsafe.Pointer(e)) = ee - int32(0x3fe) + **(**int32)(__ccgo_up(e)) = ee - int32(0x3fe) v1 = bp *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & Uint64FromUint64(0x800fffffffffffff)) v1 = bp @@ -106434,9 +106434,9 @@ func Xfrexpf(tls *TLS, x float32, e uintptr) (r float32) { if !(ee != 0) { if x != 0 { x = Xfrexpf(tls, float32(float64(x)*float64(1.8446744073709552e+19)), e) - *(*int32)(unsafe.Pointer(e)) -= int32(64) + **(**int32)(__ccgo_up(e)) -= int32(64) } else { - *(*int32)(unsafe.Pointer(e)) = 0 + **(**int32)(__ccgo_up(e)) = 0 } return x } else { @@ -106444,7 +106444,7 @@ func Xfrexpf(tls *TLS, x float32, e uintptr) (r float32) { return x } } - *(*int32)(unsafe.Pointer(e)) = ee - int32(0x7e) + **(**int32)(__ccgo_up(e)) = ee - int32(0x7e) v1 = bp *(*Tuint32_t)(unsafe.Pointer(v1)) = Tuint32_t(uint64(*(*Tuint32_t)(unsafe.Pointer(v1))) & Uint64FromUint64(0x807fffff)) v1 = bp @@ -106468,8 +106468,8 @@ func _sq(tls *TLS, hi uintptr, lo uintptr, x float64) { xc = Tdouble_t(x * (Float64FromFloat64(1.34217728e+08) + Float64FromInt32(1))) xh = x - xc + xc xl = x - xh - *(*Tdouble_t)(unsafe.Pointer(hi)) = Tdouble_t(x * x) - *(*Tdouble_t)(unsafe.Pointer(lo)) = Tdouble_t(xh*xh) - *(*Tdouble_t)(unsafe.Pointer(hi)) + Tdouble_t(Tdouble_t(Float64FromInt32(2)*xh)*xl) + Tdouble_t(xl*xl) + **(**Tdouble_t)(__ccgo_up(hi)) = Tdouble_t(x * x) + **(**Tdouble_t)(__ccgo_up(lo)) = Tdouble_t(xh*xh) - **(**Tdouble_t)(__ccgo_up(hi)) + Tdouble_t(Tdouble_t(Float64FromInt32(2)*xh)*xl) + Tdouble_t(xl*xl) } func Xhypot(tls *TLS, x float64, y float64) (r float64) { @@ -106521,21 +106521,21 @@ func Xhypot(tls *TLS, x float64, y float64) (r float64) { v1 = bp + 8 *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & (-Uint64FromUint64(1) >> Int32FromInt32(1))) if *(*Tuint64_t)(unsafe.Pointer(bp)) < *(*Tuint64_t)(unsafe.Pointer(bp + 8)) { - ut = *(*struct { + ut = **(**struct { Fi [0]Tuint64_t Ff float64 - })(unsafe.Pointer(bp)) - *(*struct { + })(__ccgo_up(bp)) + **(**struct { Fi [0]Tuint64_t Ff float64 - })(unsafe.Pointer(bp)) = *(*struct { + })(__ccgo_up(bp)) = **(**struct { Fi [0]Tuint64_t Ff float64 - })(unsafe.Pointer(bp + 8)) - *(*struct { + })(__ccgo_up(bp + 8)) + **(**struct { Fi [0]Tuint64_t Ff float64 - })(unsafe.Pointer(bp + 8)) = ut + })(__ccgo_up(bp + 8)) = ut } /* special cases */ ex = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(52)) @@ -106570,7 +106570,7 @@ func Xhypot(tls *TLS, x float64, y float64) (r float64) { } _sq(tls, bp+16, bp+24, x) _sq(tls, bp+32, bp+40, y) - return float64(z * Xsqrt(tls, *(*Tdouble_t)(unsafe.Pointer(bp + 40))+*(*Tdouble_t)(unsafe.Pointer(bp + 24))+*(*Tdouble_t)(unsafe.Pointer(bp + 32))+*(*Tdouble_t)(unsafe.Pointer(bp + 16)))) + return float64(z * Xsqrt(tls, **(**Tdouble_t)(__ccgo_up(bp + 40))+**(**Tdouble_t)(__ccgo_up(bp + 24))+**(**Tdouble_t)(__ccgo_up(bp + 32))+**(**Tdouble_t)(__ccgo_up(bp + 16)))) } func Xhypotf(tls *TLS, x float32, y float32) (r float32) { @@ -106613,21 +106613,21 @@ func Xhypotf(tls *TLS, x float32, y float32) (r float32) { *(*Tuint32_t)(unsafe.Pointer(bp)) &= -Uint32FromUint32(1) >> Int32FromInt32(1) *(*Tuint32_t)(unsafe.Pointer(bp + 4)) &= -Uint32FromUint32(1) >> Int32FromInt32(1) if *(*Tuint32_t)(unsafe.Pointer(bp)) < *(*Tuint32_t)(unsafe.Pointer(bp + 4)) { - ut = *(*struct { + ut = **(**struct { Fi [0]Tuint32_t Ff float32 - })(unsafe.Pointer(bp)) - *(*struct { + })(__ccgo_up(bp)) + **(**struct { Fi [0]Tuint32_t Ff float32 - })(unsafe.Pointer(bp)) = *(*struct { + })(__ccgo_up(bp)) = **(**struct { Fi [0]Tuint32_t Ff float32 - })(unsafe.Pointer(bp + 4)) - *(*struct { + })(__ccgo_up(bp + 4)) + **(**struct { Fi [0]Tuint32_t Ff float32 - })(unsafe.Pointer(bp + 4)) = ut + })(__ccgo_up(bp + 4)) = ut } x = *(*float32)(unsafe.Pointer(bp)) y = *(*float32)(unsafe.Pointer(bp + 4)) @@ -107055,8 +107055,8 @@ func _pzero(tls *TLS, x float64) (r1 float64) { } } z = float64(1) / float64(x*x) - r = *(*float64)(unsafe.Pointer(p)) + float64(z*(*(*float64)(unsafe.Pointer(p + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 4*8))+float64(z**(*float64)(unsafe.Pointer(p + 5*8))))))))))) - s = float64(1) + float64(z*(*(*float64)(unsafe.Pointer(q))+float64(z*(*(*float64)(unsafe.Pointer(q + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 3*8))+float64(z**(*float64)(unsafe.Pointer(q + 4*8))))))))))) + r = **(**float64)(__ccgo_up(p)) + float64(z*(**(**float64)(__ccgo_up(p + 1*8))+float64(z*(**(**float64)(__ccgo_up(p + 2*8))+float64(z*(**(**float64)(__ccgo_up(p + 3*8))+float64(z*(**(**float64)(__ccgo_up(p + 4*8))+float64(z***(**float64)(__ccgo_up(p + 5*8))))))))))) + s = float64(1) + float64(z*(**(**float64)(__ccgo_up(q))+float64(z*(**(**float64)(__ccgo_up(q + 1*8))+float64(z*(**(**float64)(__ccgo_up(q + 2*8))+float64(z*(**(**float64)(__ccgo_up(q + 3*8))+float64(z***(**float64)(__ccgo_up(q + 4*8))))))))))) return float64(1) + r/s } @@ -107163,8 +107163,8 @@ func _qzero(tls *TLS, x float64) (r1 float64) { } } z = float64(1) / float64(x*x) - r = *(*float64)(unsafe.Pointer(p)) + float64(z*(*(*float64)(unsafe.Pointer(p + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 4*8))+float64(z**(*float64)(unsafe.Pointer(p + 5*8))))))))))) - s = float64(1) + float64(z*(*(*float64)(unsafe.Pointer(q))+float64(z*(*(*float64)(unsafe.Pointer(q + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 4*8))+float64(z**(*float64)(unsafe.Pointer(q + 5*8))))))))))))) + r = **(**float64)(__ccgo_up(p)) + float64(z*(**(**float64)(__ccgo_up(p + 1*8))+float64(z*(**(**float64)(__ccgo_up(p + 2*8))+float64(z*(**(**float64)(__ccgo_up(p + 3*8))+float64(z*(**(**float64)(__ccgo_up(p + 4*8))+float64(z***(**float64)(__ccgo_up(p + 5*8))))))))))) + s = float64(1) + float64(z*(**(**float64)(__ccgo_up(q))+float64(z*(**(**float64)(__ccgo_up(q + 1*8))+float64(z*(**(**float64)(__ccgo_up(q + 2*8))+float64(z*(**(**float64)(__ccgo_up(q + 3*8))+float64(z*(**(**float64)(__ccgo_up(q + 4*8))+float64(z***(**float64)(__ccgo_up(q + 5*8))))))))))))) return (-Float64FromFloat64(0.125) + r/s) / x } @@ -107388,8 +107388,8 @@ func _pzerof(tls *TLS, x float32) (r1 float32) { } } z = Float32FromFloat32(1) / float32(x*x) - r = *(*float32)(unsafe.Pointer(p)) + float32(z*(*(*float32)(unsafe.Pointer(p + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 3*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 4*4))+float32(z**(*float32)(unsafe.Pointer(p + 5*4))))))))))) - s = Float32FromFloat32(1) + float32(z*(*(*float32)(unsafe.Pointer(q))+float32(z*(*(*float32)(unsafe.Pointer(q + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 3*4))+float32(z**(*float32)(unsafe.Pointer(q + 4*4))))))))))) + r = **(**float32)(__ccgo_up(p)) + float32(z*(**(**float32)(__ccgo_up(p + 1*4))+float32(z*(**(**float32)(__ccgo_up(p + 2*4))+float32(z*(**(**float32)(__ccgo_up(p + 3*4))+float32(z*(**(**float32)(__ccgo_up(p + 4*4))+float32(z***(**float32)(__ccgo_up(p + 5*4))))))))))) + s = Float32FromFloat32(1) + float32(z*(**(**float32)(__ccgo_up(q))+float32(z*(**(**float32)(__ccgo_up(q + 1*4))+float32(z*(**(**float32)(__ccgo_up(q + 2*4))+float32(z*(**(**float32)(__ccgo_up(q + 3*4))+float32(z***(**float32)(__ccgo_up(q + 4*4))))))))))) return Float32FromFloat32(1) + r/s } @@ -107496,8 +107496,8 @@ func _qzerof(tls *TLS, x float32) (r1 float32) { } } z = Float32FromFloat32(1) / float32(x*x) - r = *(*float32)(unsafe.Pointer(p)) + float32(z*(*(*float32)(unsafe.Pointer(p + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 3*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 4*4))+float32(z**(*float32)(unsafe.Pointer(p + 5*4))))))))))) - s = Float32FromFloat32(1) + float32(z*(*(*float32)(unsafe.Pointer(q))+float32(z*(*(*float32)(unsafe.Pointer(q + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 3*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 4*4))+float32(z**(*float32)(unsafe.Pointer(q + 5*4))))))))))))) + r = **(**float32)(__ccgo_up(p)) + float32(z*(**(**float32)(__ccgo_up(p + 1*4))+float32(z*(**(**float32)(__ccgo_up(p + 2*4))+float32(z*(**(**float32)(__ccgo_up(p + 3*4))+float32(z*(**(**float32)(__ccgo_up(p + 4*4))+float32(z***(**float32)(__ccgo_up(p + 5*4))))))))))) + s = Float32FromFloat32(1) + float32(z*(**(**float32)(__ccgo_up(q))+float32(z*(**(**float32)(__ccgo_up(q + 1*4))+float32(z*(**(**float32)(__ccgo_up(q + 2*4))+float32(z*(**(**float32)(__ccgo_up(q + 3*4))+float32(z*(**(**float32)(__ccgo_up(q + 4*4))+float32(z***(**float32)(__ccgo_up(q + 5*4))))))))))))) return (-Float32FromFloat32(0.125) + r/s) / x } @@ -107734,8 +107734,8 @@ func _pone(tls *TLS, x float64) (r1 float64) { } } z = float64(1) / float64(x*x) - r = *(*float64)(unsafe.Pointer(p)) + float64(z*(*(*float64)(unsafe.Pointer(p + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 4*8))+float64(z**(*float64)(unsafe.Pointer(p + 5*8))))))))))) - s = float64(1) + float64(z*(*(*float64)(unsafe.Pointer(q))+float64(z*(*(*float64)(unsafe.Pointer(q + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 3*8))+float64(z**(*float64)(unsafe.Pointer(q + 4*8))))))))))) + r = **(**float64)(__ccgo_up(p)) + float64(z*(**(**float64)(__ccgo_up(p + 1*8))+float64(z*(**(**float64)(__ccgo_up(p + 2*8))+float64(z*(**(**float64)(__ccgo_up(p + 3*8))+float64(z*(**(**float64)(__ccgo_up(p + 4*8))+float64(z***(**float64)(__ccgo_up(p + 5*8))))))))))) + s = float64(1) + float64(z*(**(**float64)(__ccgo_up(q))+float64(z*(**(**float64)(__ccgo_up(q + 1*8))+float64(z*(**(**float64)(__ccgo_up(q + 2*8))+float64(z*(**(**float64)(__ccgo_up(q + 3*8))+float64(z***(**float64)(__ccgo_up(q + 4*8))))))))))) return float64(1) + r/s } @@ -107841,8 +107841,8 @@ func _qone(tls *TLS, x float64) (r1 float64) { } } z = float64(1) / float64(x*x) - r = *(*float64)(unsafe.Pointer(p)) + float64(z*(*(*float64)(unsafe.Pointer(p + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 4*8))+float64(z**(*float64)(unsafe.Pointer(p + 5*8))))))))))) - s = float64(1) + float64(z*(*(*float64)(unsafe.Pointer(q))+float64(z*(*(*float64)(unsafe.Pointer(q + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 4*8))+float64(z**(*float64)(unsafe.Pointer(q + 5*8))))))))))))) + r = **(**float64)(__ccgo_up(p)) + float64(z*(**(**float64)(__ccgo_up(p + 1*8))+float64(z*(**(**float64)(__ccgo_up(p + 2*8))+float64(z*(**(**float64)(__ccgo_up(p + 3*8))+float64(z*(**(**float64)(__ccgo_up(p + 4*8))+float64(z***(**float64)(__ccgo_up(p + 5*8))))))))))) + s = float64(1) + float64(z*(**(**float64)(__ccgo_up(q))+float64(z*(**(**float64)(__ccgo_up(q + 1*8))+float64(z*(**(**float64)(__ccgo_up(q + 2*8))+float64(z*(**(**float64)(__ccgo_up(q + 3*8))+float64(z*(**(**float64)(__ccgo_up(q + 4*8))+float64(z***(**float64)(__ccgo_up(q + 5*8))))))))))))) return (float64(0.375) + r/s) / x } @@ -108065,8 +108065,8 @@ func _ponef(tls *TLS, x float32) (r1 float32) { } } z = Float32FromFloat32(1) / float32(x*x) - r = *(*float32)(unsafe.Pointer(p)) + float32(z*(*(*float32)(unsafe.Pointer(p + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 3*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 4*4))+float32(z**(*float32)(unsafe.Pointer(p + 5*4))))))))))) - s = Float32FromFloat32(1) + float32(z*(*(*float32)(unsafe.Pointer(q))+float32(z*(*(*float32)(unsafe.Pointer(q + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 3*4))+float32(z**(*float32)(unsafe.Pointer(q + 4*4))))))))))) + r = **(**float32)(__ccgo_up(p)) + float32(z*(**(**float32)(__ccgo_up(p + 1*4))+float32(z*(**(**float32)(__ccgo_up(p + 2*4))+float32(z*(**(**float32)(__ccgo_up(p + 3*4))+float32(z*(**(**float32)(__ccgo_up(p + 4*4))+float32(z***(**float32)(__ccgo_up(p + 5*4))))))))))) + s = Float32FromFloat32(1) + float32(z*(**(**float32)(__ccgo_up(q))+float32(z*(**(**float32)(__ccgo_up(q + 1*4))+float32(z*(**(**float32)(__ccgo_up(q + 2*4))+float32(z*(**(**float32)(__ccgo_up(q + 3*4))+float32(z***(**float32)(__ccgo_up(q + 4*4))))))))))) return Float32FromFloat32(1) + r/s } @@ -108172,8 +108172,8 @@ func _qonef(tls *TLS, x float32) (r1 float32) { } } z = Float32FromFloat32(1) / float32(x*x) - r = *(*float32)(unsafe.Pointer(p)) + float32(z*(*(*float32)(unsafe.Pointer(p + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 3*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 4*4))+float32(z**(*float32)(unsafe.Pointer(p + 5*4))))))))))) - s = Float32FromFloat32(1) + float32(z*(*(*float32)(unsafe.Pointer(q))+float32(z*(*(*float32)(unsafe.Pointer(q + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 3*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 4*4))+float32(z**(*float32)(unsafe.Pointer(q + 5*4))))))))))))) + r = **(**float32)(__ccgo_up(p)) + float32(z*(**(**float32)(__ccgo_up(p + 1*4))+float32(z*(**(**float32)(__ccgo_up(p + 2*4))+float32(z*(**(**float32)(__ccgo_up(p + 3*4))+float32(z*(**(**float32)(__ccgo_up(p + 4*4))+float32(z***(**float32)(__ccgo_up(p + 5*4))))))))))) + s = Float32FromFloat32(1) + float32(z*(**(**float32)(__ccgo_up(q))+float32(z*(**(**float32)(__ccgo_up(q + 1*4))+float32(z*(**(**float32)(__ccgo_up(q + 2*4))+float32(z*(**(**float32)(__ccgo_up(q + 3*4))+float32(z*(**(**float32)(__ccgo_up(q + 4*4))+float32(z***(**float32)(__ccgo_up(q + 5*4))))))))))))) return (Float32FromFloat32(0.375) + r/s) / x } @@ -108854,7 +108854,7 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { }{} *(*float64)(unsafe.Pointer(bp)) = x /* purge off +-inf, NaN, +-0, tiny and negative arguments */ - *(*int32)(unsafe.Pointer(signgamp)) = int32(1) + **(**int32)(__ccgo_up(signgamp)) = int32(1) sign = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(63)) ix = uint32(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(32) & uint64(0x7fffffff)) if ix >= uint32(0x7ff00000) { @@ -108863,7 +108863,7 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { if ix < Uint32FromInt32((Int32FromInt32(0x3ff)-Int32FromInt32(70))< float64(0) { - *(*int32)(unsafe.Pointer(signgamp)) = -int32(1) + **(**int32)(__ccgo_up(signgamp)) = -int32(1) } else { t = -t } @@ -109111,7 +109111,7 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { }{} *(*float32)(unsafe.Pointer(bp)) = x /* purge off +-inf, NaN, +-0, tiny and negative arguments */ - *(*int32)(unsafe.Pointer(signgamp)) = int32(1) + **(**int32)(__ccgo_up(signgamp)) = int32(1) sign = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(bp)) >> int32(31)) ix = *(*Tuint32_t)(unsafe.Pointer(bp)) & uint32(0x7fffffff) if ix >= uint32(0x7f800000) { @@ -109119,7 +109119,7 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { } if ix < uint32(0x35000000) { /* |x| < 2**-21, return -log(|x|) */ if sign != 0 { - *(*int32)(unsafe.Pointer(signgamp)) = -int32(1) + **(**int32)(__ccgo_up(signgamp)) = -int32(1) x = -x } return -Xlogf(tls, x) @@ -109131,7 +109131,7 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { return Float32FromFloat32(1) / (x - x) } if t > Float32FromFloat32(0) { - *(*int32)(unsafe.Pointer(signgamp)) = -int32(1) + **(**int32)(__ccgo_up(signgamp)) = -int32(1) } else { t = -t } @@ -109362,15 +109362,15 @@ func Xlog(tls *TLS, x1 float64) (r1 float64) { r = x1 - float64(1) r2 = Tdouble_t(r * r) r3 = Tdouble_t(r * r2) - y1 = Tdouble_t(r3 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 1*8)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 2*8))) + float64(r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 3*8))) + float64(r3*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 4*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 5*8)))+float64(r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 6*8)))+float64(r3*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 7*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 8*8)))+float64(r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 9*8)))+float64(r3**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 10*8))))))))) + y1 = Tdouble_t(r3 * (**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 1*8)) + float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 2*8))) + float64(r2***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 3*8))) + float64(r3*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 4*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 5*8)))+float64(r2***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 6*8)))+float64(r3*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 7*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 8*8)))+float64(r2***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 9*8)))+float64(r3***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 10*8))))))))) /* Worst-case error is around 0.507 ULP. */ w = Tdouble_t(r * float64(1.34217728e+08)) rhi = r + w - w rlo = r - rhi - w = Tdouble_t(Tdouble_t(rhi*rhi) * *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56))) /* B[0] == -0.5. */ + w = Tdouble_t(Tdouble_t(rhi*rhi) * **(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56))) /* B[0] == -0.5. */ hi = r + w lo = r - hi + w - lo = lo + Tdouble_t(float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56))*rlo)*(rhi+r)) + lo = lo + Tdouble_t(float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56))*rlo)*(rhi+r)) y1 = y1 + lo y1 = y1 + hi y = y1 @@ -109403,14 +109403,14 @@ func Xlog(tls *TLS, x1 float64) (r1 float64) { i = Int32FromUint64(tmp >> (Int32FromInt32(52) - Int32FromInt32(LOG_TABLE_BITS)) % Uint64FromInt32(Int32FromInt32(1)<> int32(52)) /* arithmetic shift */ iz = uint64(ix - tmp&(Uint64FromUint64(0xfff)< 0x1p-4: 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma). */ - y1 = lo + Tdouble_t(r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16))) + Tdouble_t(Tdouble_t(r*r2)*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 1*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 2*8)))+float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 3*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 4*8))))))) + hi + y1 = lo + Tdouble_t(r2***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 16))) + Tdouble_t(Tdouble_t(r*r2)*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 1*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 2*8)))+float64(r2*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 3*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 4*8))))))) + hi y = y1 v1 = y goto _11 @@ -109872,10 +109872,10 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { r2 = Tdouble_t(r * r) /* rounding error: 0x1p-62. */ r4 = Tdouble_t(r2 * r2) /* Worst-case error is less than 0.54 ULP (0.55 ULP without fma). */ - p = Tdouble_t(r2 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 1*8))))) + p = Tdouble_t(r2 * (**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64)) + float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 1*8))))) y1 = hi + p lo = lo + (hi - y1 + p) - lo = lo + Tdouble_t(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 2*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 3*8)))+float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 4*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 5*8)))))+float64(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 6*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 7*8)))+float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 8*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 9*8))))))))) + lo = lo + Tdouble_t(r4*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 2*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 3*8)))+float64(r2*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 4*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 5*8)))))+float64(r4*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 6*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 7*8)))+float64(r2*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 8*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 9*8))))))))) y1 = y1 + lo y = y1 v1 = y @@ -109907,14 +109907,14 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { i = Int32FromUint64(tmp >> (Int32FromInt32(52) - Int32FromInt32(LOG2_TABLE_BITS)) % Uint64FromInt32(Int32FromInt32(1)<> int32(52)) /* arithmetic shift */ iz = uint64(ix - tmp&(Uint64FromUint64(0xfff)< 0x1p-4: 0.547 ULP (0.550 ULP without fma). ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma). */ - p = *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 1*8))) + float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 2*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 3*8))))) + float64(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 4*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 5*8))))) + p = **(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 16)) + float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 1*8))) + float64(r2*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 2*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 3*8))))) + float64(r4*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 4*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 5*8))))) y1 = lo + Tdouble_t(r2*p) + hi y = y1 v1 = y @@ -110005,23 +110005,23 @@ func Xlog2f(tls *TLS, x1 float32) (r1 float32) { top = tmp & uint32(0xff800000) iz = ix - top k = Int32FromUint32(tmp) >> int32(23) /* arithmetic shift */ - invc = (*(*struct { + invc = (**(**struct { Finvc float64 Flogc float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + uintptr(i)*16))).Finvc - logc = (*(*struct { + })(__ccgo_up(uintptr(unsafe.Pointer(&X__log2f_data)) + uintptr(i)*16))).Finvc + logc = (**(**struct { Finvc float64 Flogc float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + uintptr(i)*16))).Flogc + })(__ccgo_up(uintptr(unsafe.Pointer(&X__log2f_data)) + uintptr(i)*16))).Flogc z = float64(*(*float32)(unsafe.Pointer(&iz))) /* log2(x) = log1p(z/c-1)/ln2 + log2(c) + k */ r = Tdouble_t(z*invc) - Float64FromInt32(1) y0 = logc + float64(k) /* Pipelined polynomial evaluation to approximate log1p(r)/ln2. */ r2 = Tdouble_t(r * r) - y1 = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 1*8))*r) + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 2*8)) - y1 = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256))*r2) + y1 - p = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 3*8))*r) + y0 + y1 = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 1*8))*r) + **(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 2*8)) + y1 = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2f_data)) + 256))*r2) + y1 + p = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 3*8))*r) + y0 y1 = Tdouble_t(y1*r2) + p y = float32(y1) v1 = y @@ -110194,22 +110194,22 @@ func Xlogf(tls *TLS, x1 float32) (r1 float32) { i = Int32FromUint32(tmp >> (Int32FromInt32(23) - Int32FromInt32(LOGF_TABLE_BITS)) % Uint32FromInt32(Int32FromInt32(1)<> int32(23) /* arithmetic shift */ iz = ix - tmp&uint32(0xff800000) - invc = (*(*struct { + invc = (**(**struct { Finvc float64 Flogc float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + uintptr(i)*16))).Finvc - logc = (*(*struct { + })(__ccgo_up(uintptr(unsafe.Pointer(&X__logf_data)) + uintptr(i)*16))).Finvc + logc = (**(**struct { Finvc float64 Flogc float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + uintptr(i)*16))).Flogc + })(__ccgo_up(uintptr(unsafe.Pointer(&X__logf_data)) + uintptr(i)*16))).Flogc z = float64(*(*float32)(unsafe.Pointer(&iz))) /* log(x) = log1p(z/c-1) + log(c) + k*Ln2 */ r = Tdouble_t(z*invc) - Float64FromInt32(1) y0 = logc + Tdouble_t(float64(k)*X__logf_data.Fln2) /* Pipelined polynomial evaluation to approximate log1p(r). */ r2 = Tdouble_t(r * r) - y1 = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + 264 + 1*8))*r) + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + 264 + 2*8)) - y1 = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + 264))*r2) + y1 + y1 = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__logf_data)) + 264 + 1*8))*r) + **(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__logf_data)) + 264 + 2*8)) + y1 = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__logf_data)) + 264))*r2) + y1 y1 = Tdouble_t(y1*r2) + (y0 + r) y = float32(y1) v1 = y @@ -110334,7 +110334,7 @@ func Xmodf(tls *TLS, x float64, iptr uintptr) (r float64) { e = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp))>>Int32FromInt32(52)&Uint64FromInt32(0x7ff)) - int32(0x3ff) /* no fractional part */ if e >= int32(52) { - *(*float64)(unsafe.Pointer(iptr)) = x + **(**float64)(__ccgo_up(iptr)) = x if e == int32(0x400) && *(*Tuint64_t)(unsafe.Pointer(bp))<> Int32FromInt32(12) >> e) if *(*Tuint64_t)(unsafe.Pointer(bp))&mask == uint64(0) { - *(*float64)(unsafe.Pointer(iptr)) = x + **(**float64)(__ccgo_up(iptr)) = x v1 = bp *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & (Uint64FromUint64(1) << Int32FromInt32(63))) return *(*float64)(unsafe.Pointer(bp)) } *(*Tuint64_t)(unsafe.Pointer(bp)) &= ^mask - *(*float64)(unsafe.Pointer(iptr)) = *(*float64)(unsafe.Pointer(bp)) + **(**float64)(__ccgo_up(iptr)) = *(*float64)(unsafe.Pointer(bp)) return x - *(*float64)(unsafe.Pointer(bp)) } @@ -110386,7 +110386,7 @@ func Xmodff(tls *TLS, x float32, iptr uintptr) (r float32) { e = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(bp))>>Int32FromInt32(23)&Uint32FromInt32(0xff)) - int32(0x7f) /* no fractional part */ if e >= int32(23) { - *(*float32)(unsafe.Pointer(iptr)) = x + **(**float32)(__ccgo_up(iptr)) = x if e == int32(0x80) && *(*Tuint32_t)(unsafe.Pointer(bp))<> e) if *(*Tuint32_t)(unsafe.Pointer(bp))&mask == uint32(0) { - *(*float32)(unsafe.Pointer(iptr)) = x + **(**float32)(__ccgo_up(iptr)) = x *(*Tuint32_t)(unsafe.Pointer(bp)) &= uint32(0x80000000) return *(*float32)(unsafe.Pointer(bp)) } *(*Tuint32_t)(unsafe.Pointer(bp)) &= ^mask - *(*float32)(unsafe.Pointer(iptr)) = *(*float32)(unsafe.Pointer(bp)) + **(**float32)(__ccgo_up(iptr)) = *(*float32)(unsafe.Pointer(bp)) return x - *(*float32)(unsafe.Pointer(bp)) } @@ -110421,7 +110421,7 @@ func Xmodfl(tls *TLS, x float64, iptr uintptr) (r1 float64) { var _ /* d at bp+0 */ float64 _ = r r = Xmodf(tls, x, bp) - *(*float64)(unsafe.Pointer(iptr)) = *(*float64)(unsafe.Pointer(bp)) + **(**float64)(__ccgo_up(iptr)) = float64(**(**float64)(__ccgo_up(bp))) return r } @@ -110823,24 +110823,24 @@ func _log_inline(tls *TLS, ix Tuint64_t, tail uintptr) (r1 Tdouble_t) { z = *(*float64)(unsafe.Pointer(&iz)) kd = float64(k) /* log(x) = k*Ln2 + log(c) + log1p(z/c-1). */ - invc = (*(*struct { + invc = (**(**struct { Finvc float64 Fpad float64 Flogc float64 Flogctail float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Finvc - logc = (*(*struct { + })(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Finvc + logc = (**(**struct { Finvc float64 Fpad float64 Flogc float64 Flogctail float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Flogc - logctail = (*(*struct { + })(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Flogc + logctail = (**(**struct { Finvc float64 Fpad float64 Flogc float64 Flogctail float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Flogctail + })(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Flogctail /* Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible. */ r = float64(X__builtin_fma(tls, z, invc, -Float64FromFloat64(1))) @@ -110849,7 +110849,7 @@ func _log_inline(tls *TLS, ix Tuint64_t, tail uintptr) (r1 Tdouble_t) { t2 = t1 + r lo1 = Tdouble_t(kd*X__pow_log_data.Fln2lo) + logctail lo2 = t1 - t2 + r - ar = Tdouble_t(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16)) * r) /* A[0] = -0.5. */ + ar = Tdouble_t(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16)) * r) /* A[0] = -0.5. */ ar2 = Tdouble_t(r * ar) ar3 = Tdouble_t(r * ar2) /* k*Ln2 + log(c) + r + A[0]*r*r. */ @@ -110857,10 +110857,10 @@ func _log_inline(tls *TLS, ix Tuint64_t, tail uintptr) (r1 Tdouble_t) { lo3 = float64(X__builtin_fma(tls, ar, r, -ar2)) lo4 = t2 - hi + ar2 /* p = log1p(r) - r - A[0]*r*r. */ - p = Tdouble_t(ar3 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 1*8)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 2*8))) + float64(ar2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 3*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 4*8)))+float64(ar2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 5*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 6*8))))))))) + p = Tdouble_t(ar3 * (**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 1*8)) + float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 2*8))) + float64(ar2*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 3*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 4*8)))+float64(ar2*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 5*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 6*8))))))))) lo = lo1 + lo2 + lo3 + lo4 + p y = hi + lo - *(*Tdouble_t)(unsafe.Pointer(tail)) = hi - y + lo + **(**Tdouble_t)(__ccgo_up(tail)) = hi - y + lo return y } @@ -110980,16 +110980,16 @@ _4: /* 2^(k/N) ~= scale * (1 + tail). */ idx = uint64(2) * (ki % Uint64FromInt32(Int32FromInt32(1)<> (Int32FromInt32(23) - Int32FromInt32(POWF_SCALE_BITS)) /* arithmetic shift */ - invc = (*(*struct { + invc = (**(**struct { Finvc float64 Flogc float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + uintptr(i)*16))).Finvc - logc = (*(*struct { + })(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + uintptr(i)*16))).Finvc + logc = (**(**struct { Finvc float64 Flogc float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + uintptr(i)*16))).Flogc + })(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + uintptr(i)*16))).Flogc z = float64(*(*float32)(unsafe.Pointer(&iz))) /* log2(x) = log1p(z/c-1)/ln2 + log2(c) + k */ r = Tdouble_t(z*invc) - Float64FromInt32(1) y0 = logc + float64(k) /* Pipelined polynomial evaluation to approximate log1p(r)/ln2. */ r2 = Tdouble_t(r * r) - y = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256))*r) + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 1*8)) - p = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 2*8))*r) + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 3*8)) + y = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256))*r) + **(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 1*8)) + p = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 2*8))*r) + **(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 3*8)) r4 = Tdouble_t(r2 * r2) - q = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 4*8))*r) + y0 + q = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 4*8))*r) + y0 q = Tdouble_t(p*r2) + q y = Tdouble_t(y*r4) + q return y @@ -111251,13 +111251,13 @@ _2: kd = kd - X__exp2f_data.Fshift_scaled /* k/N */ r = xd - kd /* exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1) */ - t = *(*Tuint64_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + uintptr(ki%Uint64FromInt32(Int32FromInt32(1)<> int32(63)) sy = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp + 16)) >> int32(63)) uxi = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) - *(*int32)(unsafe.Pointer(quo)) = 0 + **(**int32)(__ccgo_up(quo)) = 0 if v3 = *(*Tuint64_t)(unsafe.Pointer(bp + 16))<> int32(31)) sy = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(bp + 8)) >> int32(31)) uxi = *(*Tuint32_t)(unsafe.Pointer(bp + 4)) - *(*int32)(unsafe.Pointer(quo)) = 0 + **(**int32)(__ccgo_up(quo)) = 0 if v3 = *(*Tuint32_t)(unsafe.Pointer(bp + 8))<= uint32(0x7ff00000) { v1 = x3 - x3 - *(*float64)(unsafe.Pointer(cos)) = v1 - *(*float64)(unsafe.Pointer(sin)) = v1 + **(**float64)(__ccgo_up(cos)) = v1 + **(**float64)(__ccgo_up(sin)) = v1 return } /* argument reduction needed */ n = Uint32FromInt32(X__rem_pio2(tls, x3, bp)) - s = X__sin(tls, (*(*[2]float64)(unsafe.Pointer(bp)))[0], (*(*[2]float64)(unsafe.Pointer(bp)))[int32(1)], int32(1)) - c = X__cos(tls, (*(*[2]float64)(unsafe.Pointer(bp)))[0], (*(*[2]float64)(unsafe.Pointer(bp)))[int32(1)]) + s = X__sin(tls, (**(**[2]float64)(__ccgo_up(bp)))[0], (**(**[2]float64)(__ccgo_up(bp)))[int32(1)], int32(1)) + c = X__cos(tls, (**(**[2]float64)(__ccgo_up(bp)))[0], (**(**[2]float64)(__ccgo_up(bp)))[int32(1)]) switch n & Uint32FromInt32(3) { case uint32(0): - *(*float64)(unsafe.Pointer(sin)) = s - *(*float64)(unsafe.Pointer(cos)) = c + **(**float64)(__ccgo_up(sin)) = s + **(**float64)(__ccgo_up(cos)) = c case uint32(1): - *(*float64)(unsafe.Pointer(sin)) = c - *(*float64)(unsafe.Pointer(cos)) = -s + **(**float64)(__ccgo_up(sin)) = c + **(**float64)(__ccgo_up(cos)) = -s case uint32(2): - *(*float64)(unsafe.Pointer(sin)) = -s - *(*float64)(unsafe.Pointer(cos)) = -c + **(**float64)(__ccgo_up(sin)) = -s + **(**float64)(__ccgo_up(cos)) = -c case uint32(3): fallthrough default: - *(*float64)(unsafe.Pointer(sin)) = -c - *(*float64)(unsafe.Pointer(cos)) = s + **(**float64)(__ccgo_up(sin)) = -c + **(**float64)(__ccgo_up(cos)) = s break } } @@ -112498,23 +112498,23 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { y2 = float64(v1) } } - *(*float32)(unsafe.Pointer(sin)) = x3 - *(*float32)(unsafe.Pointer(cos)) = Float32FromFloat32(1) + **(**float32)(__ccgo_up(sin)) = x3 + **(**float32)(__ccgo_up(cos)) = Float32FromFloat32(1) return } - *(*float32)(unsafe.Pointer(sin)) = X__sindf(tls, float64(x3)) - *(*float32)(unsafe.Pointer(cos)) = X__cosdf(tls, float64(x3)) + **(**float32)(__ccgo_up(sin)) = X__sindf(tls, float64(x3)) + **(**float32)(__ccgo_up(cos)) = X__cosdf(tls, float64(x3)) return } /* |x| ~<= 5*pi/4 */ if ix <= uint32(0x407b53d1) { if ix <= uint32(0x4016cbe3) { /* |x| ~<= 3pi/4 */ if sign != 0 { - *(*float32)(unsafe.Pointer(sin)) = -X__cosdf(tls, float64(x3)+_s1pio2) - *(*float32)(unsafe.Pointer(cos)) = X__sindf(tls, float64(x3)+_s1pio2) + **(**float32)(__ccgo_up(sin)) = -X__cosdf(tls, float64(x3)+_s1pio2) + **(**float32)(__ccgo_up(cos)) = X__sindf(tls, float64(x3)+_s1pio2) } else { - *(*float32)(unsafe.Pointer(sin)) = X__cosdf(tls, _s1pio2-float64(x3)) - *(*float32)(unsafe.Pointer(cos)) = X__sindf(tls, _s1pio2-float64(x3)) + **(**float32)(__ccgo_up(sin)) = X__cosdf(tls, _s1pio2-float64(x3)) + **(**float32)(__ccgo_up(cos)) = X__sindf(tls, _s1pio2-float64(x3)) } return } @@ -112524,24 +112524,24 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { } else { v4 = float64(x3) - _s2pio2 } - *(*float32)(unsafe.Pointer(sin)) = -X__sindf(tls, v4) + **(**float32)(__ccgo_up(sin)) = -X__sindf(tls, v4) if sign != 0 { v4 = float64(x3) + _s2pio2 } else { v4 = float64(x3) - _s2pio2 } - *(*float32)(unsafe.Pointer(cos)) = -X__cosdf(tls, v4) + **(**float32)(__ccgo_up(cos)) = -X__cosdf(tls, v4) return } /* |x| ~<= 9*pi/4 */ if ix <= uint32(0x40e231d5) { if ix <= uint32(0x40afeddf) { /* |x| ~<= 7*pi/4 */ if sign != 0 { - *(*float32)(unsafe.Pointer(sin)) = X__cosdf(tls, float64(x3)+_s3pio2) - *(*float32)(unsafe.Pointer(cos)) = -X__sindf(tls, float64(x3)+_s3pio2) + **(**float32)(__ccgo_up(sin)) = X__cosdf(tls, float64(x3)+_s3pio2) + **(**float32)(__ccgo_up(cos)) = -X__sindf(tls, float64(x3)+_s3pio2) } else { - *(*float32)(unsafe.Pointer(sin)) = -X__cosdf(tls, float64(x3)-_s3pio2) - *(*float32)(unsafe.Pointer(cos)) = X__sindf(tls, float64(x3)-_s3pio2) + **(**float32)(__ccgo_up(sin)) = -X__cosdf(tls, float64(x3)-_s3pio2) + **(**float32)(__ccgo_up(cos)) = X__sindf(tls, float64(x3)-_s3pio2) } return } @@ -112550,41 +112550,41 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { } else { v4 = float64(x3) - _s4pio2 } - *(*float32)(unsafe.Pointer(sin)) = X__sindf(tls, v4) + **(**float32)(__ccgo_up(sin)) = X__sindf(tls, v4) if sign != 0 { v4 = float64(x3) + _s4pio2 } else { v4 = float64(x3) - _s4pio2 } - *(*float32)(unsafe.Pointer(cos)) = X__cosdf(tls, v4) + **(**float32)(__ccgo_up(cos)) = X__cosdf(tls, v4) return } /* sin(Inf or NaN) is NaN */ if ix >= uint32(0x7f800000) { v1 = x3 - x3 - *(*float32)(unsafe.Pointer(cos)) = v1 - *(*float32)(unsafe.Pointer(sin)) = v1 + **(**float32)(__ccgo_up(cos)) = v1 + **(**float32)(__ccgo_up(sin)) = v1 return } /* general argument reduction needed */ n = Uint32FromInt32(X__rem_pio2f(tls, x3, bp)) - s = X__sindf(tls, *(*float64)(unsafe.Pointer(bp))) - c = X__cosdf(tls, *(*float64)(unsafe.Pointer(bp))) + s = X__sindf(tls, **(**float64)(__ccgo_up(bp))) + c = X__cosdf(tls, **(**float64)(__ccgo_up(bp))) switch n & Uint32FromInt32(3) { case uint32(0): - *(*float32)(unsafe.Pointer(sin)) = s - *(*float32)(unsafe.Pointer(cos)) = c + **(**float32)(__ccgo_up(sin)) = s + **(**float32)(__ccgo_up(cos)) = c case uint32(1): - *(*float32)(unsafe.Pointer(sin)) = c - *(*float32)(unsafe.Pointer(cos)) = -s + **(**float32)(__ccgo_up(sin)) = c + **(**float32)(__ccgo_up(cos)) = -s case uint32(2): - *(*float32)(unsafe.Pointer(sin)) = -s - *(*float32)(unsafe.Pointer(cos)) = -c + **(**float32)(__ccgo_up(sin)) = -s + **(**float32)(__ccgo_up(cos)) = -c case uint32(3): fallthrough default: - *(*float32)(unsafe.Pointer(sin)) = -c - *(*float32)(unsafe.Pointer(cos)) = s + **(**float32)(__ccgo_up(sin)) = -c + **(**float32)(__ccgo_up(cos)) = s break } } @@ -112600,8 +112600,8 @@ func Xsincosl(tls *TLS, x float64, sin uintptr, cos uintptr) { var _ /* cosd at bp+8 */ float64 var _ /* sind at bp+0 */ float64 Xsincos(tls, x, bp, bp+8) - *(*float64)(unsafe.Pointer(sin)) = *(*float64)(unsafe.Pointer(bp)) - *(*float64)(unsafe.Pointer(cos)) = *(*float64)(unsafe.Pointer(bp + 8)) + **(**float64)(__ccgo_up(sin)) = float64(**(**float64)(__ccgo_up(bp))) + **(**float64)(__ccgo_up(cos)) = float64(**(**float64)(__ccgo_up(bp + 8))) } const M_PI_27 = 1.5707963267948966 @@ -112700,13 +112700,13 @@ func Xsinf(tls *TLS, x3 float32) (r float32) { n = X__rem_pio2f(tls, x3, bp) switch n & Int32FromInt32(3) { case 0: - return X__sindf(tls, *(*float64)(unsafe.Pointer(bp))) + return X__sindf(tls, **(**float64)(__ccgo_up(bp))) case int32(1): - return X__cosdf(tls, *(*float64)(unsafe.Pointer(bp))) + return X__cosdf(tls, **(**float64)(__ccgo_up(bp))) case int32(2): - return X__sindf(tls, -*(*float64)(unsafe.Pointer(bp))) + return X__sindf(tls, -**(**float64)(__ccgo_up(bp))) default: - return -X__cosdf(tls, *(*float64)(unsafe.Pointer(bp))) + return -X__cosdf(tls, **(**float64)(__ccgo_up(bp))) } return r } @@ -113152,7 +113152,7 @@ func Xtan(tls *TLS, x3 float64) (r float64) { } /* argument reduction */ n = Uint32FromInt32(X__rem_pio2(tls, x3, bp)) - return X__tan(tls, (*(*[2]float64)(unsafe.Pointer(bp)))[0], (*(*[2]float64)(unsafe.Pointer(bp)))[int32(1)], Int32FromUint32(n&uint32(1))) + return X__tan(tls, (**(**[2]float64)(__ccgo_up(bp)))[0], (**(**[2]float64)(__ccgo_up(bp)))[int32(1)], Int32FromUint32(n&uint32(1))) } const M_PI_29 = 1.5707963267948966 @@ -113253,7 +113253,7 @@ func Xtanf(tls *TLS, x3 float32) (r float32) { } /* argument reduction */ n = Uint32FromInt32(X__rem_pio2f(tls, x3, bp)) - return X__tandf(tls, *(*float64)(unsafe.Pointer(bp)), Int32FromUint32(n&uint32(1))) + return X__tandf(tls, **(**float64)(__ccgo_up(bp)), Int32FromUint32(n&uint32(1))) } const M_PI_210 = 0 @@ -113793,10 +113793,10 @@ func Xa64l(tls *TLS, s uintptr) (r int64) { x = uint32(0) e = 0 for { - if !(e < int32(36) && *(*uint8)(unsafe.Pointer(s)) != 0) { + if !(e < int32(36) && **(**uint8)(__ccgo_up(s)) != 0) { break } - d = Xstrchr(tls, uintptr(unsafe.Pointer(&_digits)), Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))) + d = Xstrchr(tls, uintptr(unsafe.Pointer(&_digits)), Int32FromUint8(**(**uint8)(__ccgo_up(s)))) if !(d != 0) { break } @@ -113824,14 +113824,14 @@ func Xl64a(tls *TLS, x0 int64) (r uintptr) { if !(x != 0) { break } - *(*uint8)(unsafe.Pointer(p)) = _digits[x&uint32(63)] + **(**uint8)(__ccgo_up(p)) = _digits[x&uint32(63)] goto _1 _1: ; p = p + 1 x = x >> uint32(6) } - *(*uint8)(unsafe.Pointer(p)) = uint8(0) + **(**uint8)(__ccgo_up(p)) = uint8(0) return uintptr(unsafe.Pointer(&_s)) } @@ -113844,22 +113844,22 @@ func Xbasename(tls *TLS, s uintptr) (r uintptr) { } var i Tsize_t _ = i - if !(s != 0) || !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(s != 0) || !(**(**uint8)(__ccgo_up(s)) != 0) { return __ccgo_ts + 606 } i = _strlen(tls, s) - uint64(1) for { - if !(i != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(i)))) == int32('/')) { + if !(i != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(i)))) == int32('/')) { break } - *(*uint8)(unsafe.Pointer(s + uintptr(i))) = uint8(0) + **(**uint8)(__ccgo_up(s + uintptr(i))) = uint8(0) goto _1 _1: ; i = i - 1 } for { - if !(i != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(i-uint64(1))))) != int32('/')) { + if !(i != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(i-uint64(1))))) != int32('/')) { break } goto _2 @@ -113885,12 +113885,12 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { } var i Tsize_t _ = i - if !(s != 0) || !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(s != 0) || !(**(**uint8)(__ccgo_up(s)) != 0) { return __ccgo_ts + 606 } i = _strlen(tls, s) - uint64(1) for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(i)))) == int32('/')) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(i)))) == int32('/')) { break } if !(i != 0) { @@ -113902,7 +113902,7 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { i = i - 1 } for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(i)))) != int32('/')) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(i)))) != int32('/')) { break } if !(i != 0) { @@ -113914,7 +113914,7 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { i = i - 1 } for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(i)))) == int32('/')) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(i)))) == int32('/')) { break } if !(i != 0) { @@ -113925,7 +113925,7 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { ; i = i - 1 } - *(*uint8)(unsafe.Pointer(s + uintptr(i+uint64(1)))) = uint8(0) + **(**uint8)(__ccgo_up(s + uintptr(i+uint64(1)))) = uint8(0) return s } @@ -114016,10 +114016,10 @@ func __strcolcmp(tls *TLS, lstr uintptr, bstr uintptr) (r int32) { var i Tsize_t _ = i i = uint64(0) - for *(*uint8)(unsafe.Pointer(lstr + uintptr(i))) != 0 && *(*uint8)(unsafe.Pointer(bstr + uintptr(i))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(bstr + uintptr(i)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(lstr + uintptr(i)))) { + for **(**uint8)(__ccgo_up(lstr + uintptr(i))) != 0 && **(**uint8)(__ccgo_up(bstr + uintptr(i))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(bstr + uintptr(i)))) == Int32FromUint8(**(**uint8)(__ccgo_up(lstr + uintptr(i)))) { i = i + 1 } - if *(*uint8)(unsafe.Pointer(lstr + uintptr(i))) != 0 || *(*uint8)(unsafe.Pointer(bstr + uintptr(i))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(bstr + uintptr(i)))) != int32(':') { + if **(**uint8)(__ccgo_up(lstr + uintptr(i))) != 0 || **(**uint8)(__ccgo_up(bstr + uintptr(i))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(bstr + uintptr(i)))) != int32(':') { return int32(1) } return 0 @@ -114117,7 +114117,7 @@ func Xfmtmsg(tls *TLS, classification int64, label uintptr, severity int32, text } } if classification&int64(MM_PRINT) != 0 { - for cmsg != 0 && *(*uint8)(unsafe.Pointer(cmsg)) != 0 { + for cmsg != 0 && **(**uint8)(__ccgo_up(cmsg)) != 0 { i = 0 for { if !(msgs[i] != 0) { @@ -114193,7 +114193,7 @@ func Xfmtmsg(tls *TLS, classification int64, label uintptr, severity int32, text if ret&(Int32FromInt32(MM_NOCON)|Int32FromInt32(MM_NOMSG)) == Int32FromInt32(MM_NOCON)|Int32FromInt32(MM_NOMSG) { ret = -int32(1) } - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) return ret } @@ -114209,7 +114209,7 @@ func Xget_current_dir_name(tls *TLS) (r uintptr) { var _ /* b at bp+144 */ Tstat _ = res res = Xgetenv(tls, __ccgo_ts+734) - if res != 0 && *(*uint8)(unsafe.Pointer(res)) != 0 && !(Xstat(tls, res, bp) != 0) && !(Xstat(tls, __ccgo_ts+606, bp+144) != 0) && (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev == (*(*Tstat)(unsafe.Pointer(bp + 144))).Fst_dev && (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino == (*(*Tstat)(unsafe.Pointer(bp + 144))).Fst_ino { + if res != 0 && **(**uint8)(__ccgo_up(res)) != 0 && !(Xstat(tls, res, bp) != 0) && !(Xstat(tls, __ccgo_ts+606, bp+144) != 0) && (**(**Tstat)(__ccgo_up(bp))).Fst_dev == (**(**Tstat)(__ccgo_up(bp + 144))).Fst_dev && (**(**Tstat)(__ccgo_up(bp))).Fst_ino == (**(**Tstat)(__ccgo_up(bp + 144))).Fst_ino { return Xstrdup(tls, res) } return Xgetcwd(tls, uintptr(0), uint64(0)) @@ -114227,18 +114227,18 @@ func X__getauxval(tls *TLS, item uint64) (r uint64) { return uint64(X__libc.Fsecure) } for { - if !(*(*Tsize_t)(unsafe.Pointer(auxv)) != 0) { + if !(**(**Tsize_t)(__ccgo_up(auxv)) != 0) { break } - if *(*Tsize_t)(unsafe.Pointer(auxv)) == item { - return *(*Tsize_t)(unsafe.Pointer(auxv + 1*8)) + if **(**Tsize_t)(__ccgo_up(auxv)) == item { + return **(**Tsize_t)(__ccgo_up(auxv + 1*8)) } goto _1 _1: ; auxv = auxv + uintptr(2)*8 } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOENT) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOENT) return uint64(0) } @@ -114269,7 +114269,7 @@ func Xgetdomainname(tls *TLS, name uintptr, len1 Tsize_t) (r int32) { var _ /* temp at bp+0 */ Tutsname Xuname(tls, bp) if !(len1 != 0) || _strlen(tls, bp+325) >= len1 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } Xstrcpy(tls, name, bp+325) @@ -114290,14 +114290,14 @@ func Xgetentropy(tls *TLS, buffer uintptr, len1 Tsize_t) (r int32) { ret = 0 pos = buffer if len1 > uint64(256) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EIO) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EIO) return -int32(1) } _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp) for len1 != 0 { ret = int32(Xgetrandom(tls, pos, len1, uint32(0))) if ret < 0 { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EINTR) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EINTR) { continue } else { break @@ -114307,7 +114307,7 @@ func Xgetentropy(tls *TLS, buffer uintptr, len1 Tsize_t) (r int32) { len1 = len1 - Uint64FromInt32(ret) ret = 0 } - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) return ret } @@ -114361,46 +114361,46 @@ func Xgetopt(tls *TLS, argc int32, argv uintptr, optstring uintptr) (r int32) { X__optpos = 0 Xoptind = int32(1) } - if Xoptind >= argc || !(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) != 0) { + if Xoptind >= argc || !(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) != 0) { return -int32(1) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))))) != int32('-') { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) == int32('-') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8))))) != int32('-') { + if Int32FromUint8(**(**uint8)(__ccgo_up(optstring))) == int32('-') { v1 = Xoptind Xoptind = Xoptind + 1 - Xoptarg = *(*uintptr)(unsafe.Pointer(argv + uintptr(v1)*8)) + Xoptarg = **(**uintptr)(__ccgo_up(argv + uintptr(v1)*8)) return int32(1) } return -int32(1) } - if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1)) != 0) { + if !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + 1)) != 0) { return -int32(1) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1))) == int32('-') && !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 2)) != 0) { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + 1))) == int32('-') && !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + 2)) != 0) { Xoptind = Xoptind + 1 return -Int32FromInt32(1) } if !(X__optpos != 0) { X__optpos = X__optpos + 1 } - v1 = Xmbtowc(tls, bp, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))+uintptr(X__optpos), uint64(MB_LEN_MAX)) + v1 = Xmbtowc(tls, bp, **(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8))+uintptr(X__optpos), uint64(MB_LEN_MAX)) k = v1 if v1 < 0 { k = int32(1) - *(*Twchar_t)(unsafe.Pointer(bp)) = int32(0xfffd) /* replacement char */ + **(**Twchar_t)(__ccgo_up(bp)) = int32(0xfffd) /* replacement char */ } - optchar = *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + uintptr(X__optpos) + optchar = **(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + uintptr(X__optpos) X__optpos = X__optpos + k - if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + uintptr(X__optpos))) != 0) { + if !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + uintptr(X__optpos))) != 0) { Xoptind = Xoptind + 1 X__optpos = 0 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) == int32('-') || Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) == int32('+') { + if Int32FromUint8(**(**uint8)(__ccgo_up(optstring))) == int32('-') || Int32FromUint8(**(**uint8)(__ccgo_up(optstring))) == int32('+') { optstring = optstring + 1 } i = 0 - *(*Twchar_t)(unsafe.Pointer(bp + 4)) = 0 - for cond := true; cond; cond = l != 0 && *(*Twchar_t)(unsafe.Pointer(bp + 4)) != *(*Twchar_t)(unsafe.Pointer(bp)) { + **(**Twchar_t)(__ccgo_up(bp + 4)) = 0 + for cond := true; cond; cond = l != 0 && **(**Twchar_t)(__ccgo_up(bp + 4)) != **(**Twchar_t)(__ccgo_up(bp)) { l = Xmbtowc(tls, bp+4, optstring+uintptr(i), uint64(MB_LEN_MAX)) if l > 0 { i = i + l @@ -114408,36 +114408,36 @@ func Xgetopt(tls *TLS, argc int32, argv uintptr, optstring uintptr) (r int32) { i = i + 1 } } - if *(*Twchar_t)(unsafe.Pointer(bp + 4)) != *(*Twchar_t)(unsafe.Pointer(bp)) || *(*Twchar_t)(unsafe.Pointer(bp)) == int32(':') { - Xoptopt = *(*Twchar_t)(unsafe.Pointer(bp)) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) != int32(':') && Xopterr != 0 { - X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), __ccgo_ts+738, optchar, Uint64FromInt32(k)) + if **(**Twchar_t)(__ccgo_up(bp + 4)) != **(**Twchar_t)(__ccgo_up(bp)) || **(**Twchar_t)(__ccgo_up(bp)) == int32(':') { + Xoptopt = **(**Twchar_t)(__ccgo_up(bp)) + if Int32FromUint8(**(**uint8)(__ccgo_up(optstring))) != int32(':') && Xopterr != 0 { + X__getopt_msg(tls, **(**uintptr)(__ccgo_up(argv)), __ccgo_ts+738, optchar, Uint64FromInt32(k)) } return int32('?') } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring + uintptr(i)))) == int32(':') { + if Int32FromUint8(**(**uint8)(__ccgo_up(optstring + uintptr(i)))) == int32(':') { Xoptarg = uintptr(0) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring + uintptr(i+int32(1))))) != int32(':') || X__optpos != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(optstring + uintptr(i+int32(1))))) != int32(':') || X__optpos != 0 { v1 = Xoptind Xoptind = Xoptind + 1 - Xoptarg = *(*uintptr)(unsafe.Pointer(argv + uintptr(v1)*8)) + Xoptarg = **(**uintptr)(__ccgo_up(argv + uintptr(v1)*8)) if X__optpos != 0 { Xoptarg = Xoptarg + uintptr(X__optpos) } X__optpos = 0 } if Xoptind > argc { - Xoptopt = *(*Twchar_t)(unsafe.Pointer(bp)) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) == int32(':') { + Xoptopt = **(**Twchar_t)(__ccgo_up(bp)) + if Int32FromUint8(**(**uint8)(__ccgo_up(optstring))) == int32(':') { return int32(':') } if Xopterr != 0 { - X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), __ccgo_ts+762, optchar, Uint64FromInt32(k)) + X__getopt_msg(tls, **(**uintptr)(__ccgo_up(argv)), __ccgo_ts+762, optchar, Uint64FromInt32(k)) } return int32('?') } } - return *(*Twchar_t)(unsafe.Pointer(bp)) + return **(**Twchar_t)(__ccgo_up(bp)) } func X__posix_getopt(tls *TLS, argc int32, argv uintptr, optstring uintptr) (r int32) { @@ -114464,19 +114464,19 @@ func _permute(tls *TLS, argv uintptr, dest int32, src int32) { var i int32 _, _, _ = av, i, tmp av = argv - tmp = *(*uintptr)(unsafe.Pointer(av + uintptr(src)*8)) + tmp = **(**uintptr)(__ccgo_up(av + uintptr(src)*8)) i = src for { if !(i > dest) { break } - *(*uintptr)(unsafe.Pointer(av + uintptr(i)*8)) = *(*uintptr)(unsafe.Pointer(av + uintptr(i-int32(1))*8)) + **(**uintptr)(__ccgo_up(av + uintptr(i)*8)) = **(**uintptr)(__ccgo_up(av + uintptr(i-int32(1))*8)) goto _1 _1: ; i = i - 1 } - *(*uintptr)(unsafe.Pointer(av + uintptr(dest)*8)) = tmp + **(**uintptr)(__ccgo_up(av + uintptr(dest)*8)) = tmp } func ___getopt_long(tls *TLS, argc int32, argv uintptr, optstring uintptr, longopts uintptr, idx uintptr, longonly int32) (r int32) { @@ -114487,17 +114487,17 @@ func ___getopt_long(tls *TLS, argc int32, argv uintptr, optstring uintptr, longo X__optpos = 0 Xoptind = int32(1) } - if Xoptind >= argc || !(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) != 0) { + if Xoptind >= argc || !(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) != 0) { return -int32(1) } skipped = Xoptind - if Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) != int32('+') && Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) != int32('-') { + if Int32FromUint8(**(**uint8)(__ccgo_up(optstring))) != int32('+') && Int32FromUint8(**(**uint8)(__ccgo_up(optstring))) != int32('-') { i = Xoptind for { - if i >= argc || !(*(*uintptr)(unsafe.Pointer(argv + uintptr(i)*8)) != 0) { + if i >= argc || !(**(**uintptr)(__ccgo_up(argv + uintptr(i)*8)) != 0) { return -int32(1) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(i)*8))))) == int32('-') && *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(i)*8)) + 1)) != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(i)*8))))) == int32('-') && **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(i)*8)) + 1)) != 0 { break } goto _1 @@ -114532,31 +114532,31 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, var cnt, colon, i, j, l, match, v2 int32 _, _, _, _, _, _, _, _, _, _, _, _ = arg, cnt, colon, i, j, l, match, name, opt, start, v2, v5 Xoptarg = uintptr(0) - if longopts != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))))) == int32('-') && (longonly != 0 && *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1))) != int32('-') || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1))) == int32('-') && *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 2)) != 0) { - colon = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring + BoolUintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) == int32('+') || Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) == int32('-'))))) == int32(':')) - start = *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + uintptr(1) + if longopts != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8))))) == int32('-') && (longonly != 0 && **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + 1)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + 1))) != int32('-') || Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + 1))) == int32('-') && **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + 2)) != 0) { + colon = BoolInt32(Int32FromUint8(**(**uint8)(__ccgo_up(optstring + BoolUintptr(Int32FromUint8(**(**uint8)(__ccgo_up(optstring))) == int32('+') || Int32FromUint8(**(**uint8)(__ccgo_up(optstring))) == int32('-'))))) == int32(':')) + start = **(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + uintptr(1) v2 = Int32FromInt32(0) i = v2 cnt = v2 for { - if !((*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname != 0) { + if !((**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fname != 0) { break } - name = (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname + name = (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fname opt = start - if Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) == int32('-') { + if Int32FromUint8(**(**uint8)(__ccgo_up(opt))) == int32('-') { opt = opt + 1 } - for *(*uint8)(unsafe.Pointer(opt)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) != int32('=') && Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) { + for **(**uint8)(__ccgo_up(opt)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(opt))) != int32('=') && Int32FromUint8(**(**uint8)(__ccgo_up(opt))) == Int32FromUint8(**(**uint8)(__ccgo_up(name))) { name = name + 1 opt = opt + 1 } - if *(*uint8)(unsafe.Pointer(opt)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) != int32('=') { + if **(**uint8)(__ccgo_up(opt)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(opt))) != int32('=') { goto _1 } arg = opt match = i - if !(*(*uint8)(unsafe.Pointer(name)) != 0) { + if !(**(**uint8)(__ccgo_up(name)) != 0) { cnt = int32(1) break } @@ -114570,12 +114570,12 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, l = int32(int64(arg) - int64(start)) i = 0 for { - if !(*(*uint8)(unsafe.Pointer(optstring + uintptr(i))) != 0) { + if !(**(**uint8)(__ccgo_up(optstring + uintptr(i))) != 0) { break } j = 0 for { - if !(j < l && Int32FromUint8(*(*uint8)(unsafe.Pointer(start + uintptr(j)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring + uintptr(i+j))))) { + if !(j < l && Int32FromUint8(**(**uint8)(__ccgo_up(start + uintptr(j)))) == Int32FromUint8(**(**uint8)(__ccgo_up(optstring + uintptr(i+j))))) { break } goto _4 @@ -114597,44 +114597,44 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, i = match opt = arg Xoptind = Xoptind + 1 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) == int32('=') { - if !((*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fhas_arg != 0) { - Xoptopt = (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fval + if Int32FromUint8(**(**uint8)(__ccgo_up(opt))) == int32('=') { + if !((**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fhas_arg != 0) { + Xoptopt = (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fval if colon != 0 || !(Xopterr != 0) { return int32('?') } - X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), __ccgo_ts+794, (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname, _strlen(tls, (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname)) + X__getopt_msg(tls, **(**uintptr)(__ccgo_up(argv)), __ccgo_ts+794, (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fname, _strlen(tls, (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fname)) return int32('?') } Xoptarg = opt + uintptr(1) } else { - if (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fhas_arg == int32(required_argument) { - v5 = *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + if (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fhas_arg == int32(required_argument) { + v5 = **(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) Xoptarg = v5 if !(v5 != 0) { - Xoptopt = (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fval + Xoptopt = (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fval if colon != 0 { return int32(':') } if !(Xopterr != 0) { return int32('?') } - X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), __ccgo_ts+762, (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname, _strlen(tls, (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname)) + X__getopt_msg(tls, **(**uintptr)(__ccgo_up(argv)), __ccgo_ts+762, (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fname, _strlen(tls, (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fname)) return int32('?') } Xoptind = Xoptind + 1 } } if idx != 0 { - *(*int32)(unsafe.Pointer(idx)) = i + **(**int32)(__ccgo_up(idx)) = i } - if (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fflag != 0 { - *(*int32)(unsafe.Pointer((*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fflag)) = (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fval + if (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fflag != 0 { + **(**int32)(__ccgo_up((**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fflag)) = (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fval return 0 } - return (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fval + return (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fval } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1))) == int32('-') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + 1))) == int32('-') { Xoptopt = 0 if !(colon != 0) && Xopterr != 0 { if cnt != 0 { @@ -114642,7 +114642,7 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, } else { v5 = __ccgo_ts + 738 } - X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), v5, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))+uintptr(2), _strlen(tls, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))+uintptr(2))) + X__getopt_msg(tls, **(**uintptr)(__ccgo_up(argv)), v5, **(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8))+uintptr(2), _strlen(tls, **(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8))+uintptr(2))) } Xoptind = Xoptind + 1 return int32('?') @@ -114717,22 +114717,22 @@ func Xgetrlimit(tls *TLS, resource int32, rlim uintptr) (r int32) { (*Trlimit)(unsafe.Pointer(rlim)).Frlim_max = ^Uint64FromUint64(0) } } - if !(ret != 0) || *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(ENOSYS) { + if !(ret != 0) || **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(ENOSYS) { return ret } if X__syscall_ret(tls, Uint64FromInt64(X__syscall2(tls, int64(SYS_ugetrlimit), int64(resource), int64(bp)))) < 0 { return -int32(1) } - if (*(*[2]uint64)(unsafe.Pointer(bp)))[0] == -Uint64FromUint64(1) { + if (**(**[2]uint64)(__ccgo_up(bp)))[0] == -Uint64FromUint64(1) { v1 = ^Uint64FromUint64(0) } else { - v1 = (*(*[2]uint64)(unsafe.Pointer(bp)))[0] + v1 = (**(**[2]uint64)(__ccgo_up(bp)))[0] } (*Trlimit)(unsafe.Pointer(rlim)).Frlim_cur = v1 - if (*(*[2]uint64)(unsafe.Pointer(bp)))[int32(1)] == -Uint64FromUint64(1) { + if (**(**[2]uint64)(__ccgo_up(bp)))[int32(1)] == -Uint64FromUint64(1) { v1 = ^Uint64FromUint64(0) } else { - v1 = (*(*[2]uint64)(unsafe.Pointer(bp)))[int32(1)] + v1 = (**(**[2]uint64)(__ccgo_up(bp)))[int32(1)] } (*Trlimit)(unsafe.Pointer(rlim)).Frlim_max = v1 if (*Trlimit)(unsafe.Pointer(rlim)).Frlim_cur >= ^Uint64FromUint64(0) { @@ -114760,12 +114760,12 @@ func Xgetrusage(tls *TLS, who int32, ru uintptr) (r1 int32) { if !(r != 0) && Bool(uint64(8) > uint64(8)) { Xmemcpy(tls, bp, dest, Uint64FromInt32(4)*Uint64FromInt64(8)) (*Trusage)(unsafe.Pointer(ru)).Fru_utime = Ttimeval{ - Ftv_sec: (*(*[4]int64)(unsafe.Pointer(bp)))[0], - Ftv_usec: (*(*[4]int64)(unsafe.Pointer(bp)))[int32(1)], + Ftv_sec: (**(**[4]int64)(__ccgo_up(bp)))[0], + Ftv_usec: (**(**[4]int64)(__ccgo_up(bp)))[int32(1)], } (*Trusage)(unsafe.Pointer(ru)).Fru_stime = Ttimeval{ - Ftv_sec: (*(*[4]int64)(unsafe.Pointer(bp)))[int32(2)], - Ftv_usec: (*(*[4]int64)(unsafe.Pointer(bp)))[int32(3)], + Ftv_sec: (**(**[4]int64)(__ccgo_up(bp)))[int32(2)], + Ftv_usec: (**(**[4]int64)(__ccgo_up(bp)))[int32(3)], } } return int32(X__syscall_ret(tls, Uint64FromInt32(r))) @@ -114780,30 +114780,30 @@ func Xgetsubopt(tls *TLS, opt uintptr, keys uintptr, val uintptr) (r int32) { var l Tsize_t var s, v1, v2 uintptr _, _, _, _, _ = i, l, s, v1, v2 - s = *(*uintptr)(unsafe.Pointer(opt)) - *(*uintptr)(unsafe.Pointer(val)) = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(opt)) = Xstrchr(tls, s, int32(',')) - if *(*uintptr)(unsafe.Pointer(opt)) != 0 { + s = **(**uintptr)(__ccgo_up(opt)) + **(**uintptr)(__ccgo_up(val)) = UintptrFromInt32(0) + **(**uintptr)(__ccgo_up(opt)) = Xstrchr(tls, s, int32(',')) + if **(**uintptr)(__ccgo_up(opt)) != 0 { v2 = opt v1 = *(*uintptr)(unsafe.Pointer(v2)) *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(v2)) + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) } else { - *(*uintptr)(unsafe.Pointer(opt)) = s + uintptr(_strlen(tls, s)) + **(**uintptr)(__ccgo_up(opt)) = s + uintptr(_strlen(tls, s)) } i = 0 for { - if !(*(*uintptr)(unsafe.Pointer(keys + uintptr(i)*8)) != 0) { + if !(**(**uintptr)(__ccgo_up(keys + uintptr(i)*8)) != 0) { break } - l = _strlen(tls, *(*uintptr)(unsafe.Pointer(keys + uintptr(i)*8))) - if Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(keys + uintptr(i)*8)), s, l) != 0 { + l = _strlen(tls, **(**uintptr)(__ccgo_up(keys + uintptr(i)*8))) + if Xstrncmp(tls, **(**uintptr)(__ccgo_up(keys + uintptr(i)*8)), s, l) != 0 { goto _3 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(l)))) == int32('=') { - *(*uintptr)(unsafe.Pointer(val)) = s + uintptr(l) + uintptr(1) + if Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(l)))) == int32('=') { + **(**uintptr)(__ccgo_up(val)) = s + uintptr(l) + uintptr(1) } else { - if *(*uint8)(unsafe.Pointer(s + uintptr(l))) != 0 { + if **(**uint8)(__ccgo_up(s + uintptr(l))) != 0 { goto _3 } } @@ -115092,7 +115092,7 @@ func _convert_ioctl_struct(tls *TLS, map1 uintptr, old uintptr, new1 uintptr, di if !(i < Int32FromUint8((*Tioctl_compat_map)(unsafe.Pointer(map1)).Fnoffs)) { break } - ts_offset = Int32FromUint8(*(*uint8)(unsafe.Pointer(map1 + 12 + uintptr(i)))) + ts_offset = Int32FromUint8(**(**uint8)(__ccgo_up(map1 + 12 + uintptr(i)))) len1 = ts_offset - old_offset if dir == int32(W) { Xmemcpy(tls, old+uintptr(old_offset), new1+uintptr(new_offset), Uint64FromInt32(len1)) @@ -115110,11 +115110,11 @@ func _convert_ioctl_struct(tls *TLS, map1 uintptr, old uintptr, new1 uintptr, di new_offset = new_offset + (align-int32(1))&-new_offset if dir == int32(W) { Xmemcpy(tls, bp, new1+uintptr(new_offset), uint64(8)) - *(*int64)(unsafe.Pointer(bp + 8)) = *(*int64)(unsafe.Pointer(bp)) + **(**int64)(__ccgo_up(bp + 8)) = int64(**(**int64)(__ccgo_up(bp))) Xmemcpy(tls, old+uintptr(old_offset), bp+8, uint64(8)) } else { Xmemcpy(tls, bp+8, old+uintptr(old_offset), uint64(8)) - *(*int64)(unsafe.Pointer(bp)) = *(*int64)(unsafe.Pointer(bp + 8)) + **(**int64)(__ccgo_up(bp)) = int64(**(**int64)(__ccgo_up(bp + 8))) Xmemcpy(tls, new1+uintptr(new_offset), bp, uint64(8)) } new_offset = Int32FromUint64(uint64(new_offset) + Uint64FromInt64(8)) @@ -115192,31 +115192,31 @@ func Xlockf(tls *TLS, fd int32, op int32, size Toff_t) (r int32) { bp := tls.Alloc(48) defer tls.Free(48) var _ /* l at bp+0 */ Tflock - *(*Tflock)(unsafe.Pointer(bp)) = Tflock{ + **(**Tflock)(__ccgo_up(bp)) = Tflock{ Fl_type: int16(F_WRLCK), Fl_whence: int16(1), Fl_len: size, } switch op { case int32(F_TEST): - (*(*Tflock)(unsafe.Pointer(bp))).Fl_type = F_RDLCK + (**(**Tflock)(__ccgo_up(bp))).Fl_type = F_RDLCK if Xfcntl(tls, fd, int32(F_GETLK), VaList(bp+40, bp)) < 0 { return -int32(1) } - if int32((*(*Tflock)(unsafe.Pointer(bp))).Fl_type) == int32(F_UNLCK) || (*(*Tflock)(unsafe.Pointer(bp))).Fl_pid == Xgetpid(tls) { + if int32((**(**Tflock)(__ccgo_up(bp))).Fl_type) == int32(F_UNLCK) || (**(**Tflock)(__ccgo_up(bp))).Fl_pid == Xgetpid(tls) { return 0 } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EACCES) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EACCES) return -int32(1) case F_ULOCK: - (*(*Tflock)(unsafe.Pointer(bp))).Fl_type = int16(F_UNLCK) + (**(**Tflock)(__ccgo_up(bp))).Fl_type = int16(F_UNLCK) fallthrough case int32(F_TLOCK): return Xfcntl(tls, fd, int32(F_SETLK), VaList(bp+40, bp)) case int32(F_LOCK): return Xfcntl(tls, fd, int32(F_SETLKW), VaList(bp+40, bp)) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } @@ -115318,23 +115318,23 @@ func _unescape_ent(tls *TLS, beg uintptr) (r uintptr) { _, _, _, _, _, _, _ = cval, dest, i, src, val, v1, v2 dest = beg src = beg - for *(*uint8)(unsafe.Pointer(src)) != 0 { + for **(**uint8)(__ccgo_up(src)) != 0 { cval = uint8(0) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) != int32('\\') { + if Int32FromUint8(**(**uint8)(__ccgo_up(src))) != int32('\\') { v1 = dest dest = dest + 1 v2 = src src = src + 1 - *(*uint8)(unsafe.Pointer(v1)) = *(*uint8)(unsafe.Pointer(v2)) + **(**uint8)(__ccgo_up(v1)) = **(**uint8)(__ccgo_up(v2)) continue } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 1))) == int32('\\') { + if Int32FromUint8(**(**uint8)(__ccgo_up(src + 1))) == int32('\\') { src = src + 1 v1 = dest dest = dest + 1 v2 = src src = src + 1 - *(*uint8)(unsafe.Pointer(v1)) = *(*uint8)(unsafe.Pointer(v2)) + **(**uint8)(__ccgo_up(v1)) = **(**uint8)(__ccgo_up(v2)) continue } val = src + uintptr(1) @@ -115343,11 +115343,11 @@ func _unescape_ent(tls *TLS, beg uintptr) (r uintptr) { if !(i < int32(3)) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(val))) >= int32('0') && Int32FromUint8(*(*uint8)(unsafe.Pointer(val))) <= int32('7') { + if Int32FromUint8(**(**uint8)(__ccgo_up(val))) >= int32('0') && Int32FromUint8(**(**uint8)(__ccgo_up(val))) <= int32('7') { cval = Uint8FromInt32(int32(cval) << Int32FromInt32(3)) v1 = val val = val + 1 - cval = Uint8FromInt32(int32(cval) + (Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) - Int32FromUint8('0'))) + cval = Uint8FromInt32(int32(cval) + (Int32FromUint8(**(**uint8)(__ccgo_up(v1))) - Int32FromUint8('0'))) } else { break } @@ -115359,17 +115359,17 @@ func _unescape_ent(tls *TLS, beg uintptr) (r uintptr) { if cval != 0 { v1 = dest dest = dest + 1 - *(*uint8)(unsafe.Pointer(v1)) = cval + **(**uint8)(__ccgo_up(v1)) = cval src = val } else { v1 = dest dest = dest + 1 v2 = src src = src + 1 - *(*uint8)(unsafe.Pointer(v1)) = *(*uint8)(unsafe.Pointer(v2)) + **(**uint8)(__ccgo_up(v1)) = **(**uint8)(__ccgo_up(v2)) } } - *(*uint8)(unsafe.Pointer(dest)) = uint8(0) + **(**uint8)(__ccgo_up(dest)) = uint8(0) return beg } @@ -115387,7 +115387,7 @@ func Xgetmntent_r(tls *TLS, f uintptr, mnt uintptr, linebuf uintptr, buflen int3 use_internal = BoolInt32(linebuf == uintptr(unsafe.Pointer(&_internal_buf))) (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_freq = 0 (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_passno = 0 - for cond := true; cond; cond = Int32FromUint8(*(*uint8)(unsafe.Pointer(linebuf + uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[0])))) == int32('#') || Uint64FromInt32((*(*[8]int32)(unsafe.Pointer(bp)))[int32(1)]) == len1 { + for cond := true; cond; cond = Int32FromUint8(**(**uint8)(__ccgo_up(linebuf + uintptr((**(**[8]int32)(__ccgo_up(bp)))[0])))) == int32('#') || Uint64FromInt32((**(**[8]int32)(__ccgo_up(bp)))[int32(1)]) == len1 { if use_internal != 0 { Xgetline(tls, uintptr(unsafe.Pointer(&_internal_buf)), uintptr(unsafe.Pointer(&_internal_bufsize)), f) linebuf = _internal_buf @@ -115399,7 +115399,7 @@ func Xgetmntent_r(tls *TLS, f uintptr, mnt uintptr, linebuf uintptr, buflen int3 } if !(Xstrchr(tls, linebuf, int32('\n')) != 0) { Xfscanf(tls, f, __ccgo_ts+855, 0) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return uintptr(0) } len1 = _strlen(tls, linebuf) @@ -115411,7 +115411,7 @@ func Xgetmntent_r(tls *TLS, f uintptr, mnt uintptr, linebuf uintptr, buflen int3 if !(i < Uint64FromInt64(32)/Uint64FromInt64(4)) { break } - (*(*[8]int32)(unsafe.Pointer(bp)))[i] = Int32FromUint64(len1) + (**(**[8]int32)(__ccgo_up(bp)))[i] = Int32FromUint64(len1) goto _1 _1: ; @@ -115419,14 +115419,14 @@ func Xgetmntent_r(tls *TLS, f uintptr, mnt uintptr, linebuf uintptr, buflen int3 } Xsscanf(tls, linebuf, __ccgo_ts+867, VaList(bp+40, bp, bp+uintptr(1)*4, bp+uintptr(2)*4, bp+uintptr(3)*4, bp+uintptr(4)*4, bp+uintptr(5)*4, bp+uintptr(6)*4, bp+uintptr(7)*4, mnt+32, mnt+36)) } - *(*uint8)(unsafe.Pointer(linebuf + uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(1)]))) = uint8(0) - *(*uint8)(unsafe.Pointer(linebuf + uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(3)]))) = uint8(0) - *(*uint8)(unsafe.Pointer(linebuf + uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(5)]))) = uint8(0) - *(*uint8)(unsafe.Pointer(linebuf + uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(7)]))) = uint8(0) - (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_fsname = _unescape_ent(tls, linebuf+uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[0])) - (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_dir = _unescape_ent(tls, linebuf+uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(2)])) - (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_type = _unescape_ent(tls, linebuf+uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(4)])) - (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_opts = _unescape_ent(tls, linebuf+uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(6)])) + **(**uint8)(__ccgo_up(linebuf + uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(1)]))) = uint8(0) + **(**uint8)(__ccgo_up(linebuf + uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(3)]))) = uint8(0) + **(**uint8)(__ccgo_up(linebuf + uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(5)]))) = uint8(0) + **(**uint8)(__ccgo_up(linebuf + uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(7)]))) = uint8(0) + (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_fsname = _unescape_ent(tls, linebuf+uintptr((**(**[8]int32)(__ccgo_up(bp)))[0])) + (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_dir = _unescape_ent(tls, linebuf+uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(2)])) + (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_type = _unescape_ent(tls, linebuf+uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(4)])) + (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_opts = _unescape_ent(tls, linebuf+uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(6)])) return mnt } @@ -115483,39 +115483,39 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag var _ /* st at bp+0 */ Tstat _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, de, dfd, err, j, k, l, r, type1, v1, v10, v2, v3, v8 l = _strlen(tls, path) - if l != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(path + uintptr(l-uint64(1))))) == int32('/') { + if l != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(path + uintptr(l-uint64(1))))) == int32('/') { v1 = l - uint64(1) } else { v1 = l } j = v1 v2 = Uint64FromInt32(0) - (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino = v2 - (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev = v2 + (**(**Tstat)(__ccgo_up(bp))).Fst_ino = v2 + (**(**Tstat)(__ccgo_up(bp))).Fst_dev = v2 if flags&int32(FTW_PHYS) != 0 { v3 = Xlstat(tls, path, bp) } else { v3 = BoolInt32(Xstat(tls, path, bp) < 0) } if v3 != 0 { - if !(flags&Int32FromInt32(FTW_PHYS) != 0) && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENOENT) && !(Xlstat(tls, path, bp) != 0) { + if !(flags&Int32FromInt32(FTW_PHYS) != 0) && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENOENT) && !(Xlstat(tls, path, bp) != 0) { type1 = int32(FTW_SLN) } else { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(EACCES) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(EACCES) { return -int32(1) } else { type1 = int32(FTW_NS) } } } else { - if (*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFDIR) { + if (**(**Tstat)(__ccgo_up(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFDIR) { if flags&int32(FTW_DEPTH) != 0 { type1 = int32(FTW_DP) } else { type1 = int32(FTW_D) } } else { - if (*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { + if (**(**Tstat)(__ccgo_up(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { if flags&int32(FTW_PHYS) != 0 { type1 = int32(FTW_SL) } else { @@ -115526,26 +115526,26 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag } } } - if flags&int32(FTW_MOUNT) != 0 && h != 0 && type1 != int32(FTW_NS) && (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev != (*Thistory)(unsafe.Pointer(h)).Fdev { + if flags&int32(FTW_MOUNT) != 0 && h != 0 && type1 != int32(FTW_NS) && (**(**Tstat)(__ccgo_up(bp))).Fst_dev != (*Thistory)(unsafe.Pointer(h)).Fdev { return 0 } - (*(*Thistory)(unsafe.Pointer(bp + 144))).Fchain = h - (*(*Thistory)(unsafe.Pointer(bp + 144))).Fdev = (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev - (*(*Thistory)(unsafe.Pointer(bp + 144))).Fino = (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino + (**(**Thistory)(__ccgo_up(bp + 144))).Fchain = h + (**(**Thistory)(__ccgo_up(bp + 144))).Fdev = (**(**Tstat)(__ccgo_up(bp))).Fst_dev + (**(**Thistory)(__ccgo_up(bp + 144))).Fino = (**(**Tstat)(__ccgo_up(bp))).Fst_ino if h != 0 { v3 = (*Thistory)(unsafe.Pointer(h)).Flevel + int32(1) } else { v3 = 0 } - (*(*Thistory)(unsafe.Pointer(bp + 144))).Flevel = v3 - (*(*Thistory)(unsafe.Pointer(bp + 144))).Fbase = Int32FromUint64(j + uint64(1)) - (*(*TFTW)(unsafe.Pointer(bp + 176))).Flevel = (*(*Thistory)(unsafe.Pointer(bp + 144))).Flevel + (**(**Thistory)(__ccgo_up(bp + 144))).Flevel = v3 + (**(**Thistory)(__ccgo_up(bp + 144))).Fbase = Int32FromUint64(j + uint64(1)) + (**(**TFTW)(__ccgo_up(bp + 176))).Flevel = (**(**Thistory)(__ccgo_up(bp + 144))).Flevel if h != 0 { - (*(*TFTW)(unsafe.Pointer(bp + 176))).Fbase = (*Thistory)(unsafe.Pointer(h)).Fbase + (**(**TFTW)(__ccgo_up(bp + 176))).Fbase = (*Thistory)(unsafe.Pointer(h)).Fbase } else { k = j for { - if !(k != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(path + uintptr(k)))) == int32('/')) { + if !(k != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(path + uintptr(k)))) == int32('/')) { break } goto _5 @@ -115554,7 +115554,7 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag k = k - 1 } for { - if !(k != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(path + uintptr(k-uint64(1))))) != int32('/')) { + if !(k != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(path + uintptr(k-uint64(1))))) != int32('/')) { break } goto _6 @@ -115562,11 +115562,11 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag ; k = k - 1 } - (*(*TFTW)(unsafe.Pointer(bp + 176))).Fbase = Int32FromUint64(k) + (**(**TFTW)(__ccgo_up(bp + 176))).Fbase = Int32FromUint64(k) } if type1 == int32(FTW_D) || type1 == int32(FTW_DP) { dfd = Xopen(tls, path, O_RDONLY, 0) - err = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + err = **(**int32)(__ccgo_up(X__errno_location(tls))) if dfd < 0 && err == int32(EACCES) { type1 = int32(FTW_DNR) } @@ -115585,7 +115585,7 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag if !(h != 0) { break } - if (*Thistory)(unsafe.Pointer(h)).Fdev == (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev && (*Thistory)(unsafe.Pointer(h)).Fino == (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino { + if (*Thistory)(unsafe.Pointer(h)).Fdev == (**(**Tstat)(__ccgo_up(bp))).Fst_dev && (*Thistory)(unsafe.Pointer(h)).Fino == (**(**Tstat)(__ccgo_up(bp))).Fst_ino { return 0 } goto _9 @@ -115595,7 +115595,7 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag } if (type1 == int32(FTW_D) || type1 == int32(FTW_DP)) && fd_limit != 0 { if dfd < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = err + **(**int32)(__ccgo_up(X__errno_location(tls))) = err return -int32(1) } d = Xfdopendir(tls, dfd) @@ -115606,15 +115606,15 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag if !(v10 != 0) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(de + 19))) == int32('.') && (!(*(*uint8)(unsafe.Pointer(de + 19 + 1)) != 0) || Int32FromUint8(*(*uint8)(unsafe.Pointer(de + 19 + 1))) == int32('.') && !(*(*uint8)(unsafe.Pointer(de + 19 + 2)) != 0)) { + if Int32FromUint8(**(**uint8)(__ccgo_up(de + 19))) == int32('.') && (!(**(**uint8)(__ccgo_up(de + 19 + 1)) != 0) || Int32FromUint8(**(**uint8)(__ccgo_up(de + 19 + 1))) == int32('.') && !(**(**uint8)(__ccgo_up(de + 19 + 2)) != 0)) { continue } if _strlen(tls, de+19) >= uint64(PATH_MAX)-l { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENAMETOOLONG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENAMETOOLONG) Xclosedir(tls, d) return -int32(1) } - *(*uint8)(unsafe.Pointer(path + uintptr(j))) = uint8('/') + **(**uint8)(__ccgo_up(path + uintptr(j))) = uint8('/') Xstrcpy(tls, path+uintptr(j)+uintptr(1), de+19) v3 = _do_nftw(tls, path, __ccgo_fp_fn, fd_limit-int32(1), flags, bp+144) r = v3 @@ -115629,7 +115629,7 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag return -int32(1) } } - *(*uint8)(unsafe.Pointer(path + uintptr(l))) = uint8(0) + **(**uint8)(__ccgo_up(path + uintptr(l))) = uint8(0) if v8 = flags&int32(FTW_DEPTH) != 0; v8 { v3 = (*(*func(*TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_fn})))(tls, path, bp, type1, bp+176) r = v3 @@ -115659,13 +115659,13 @@ func Xnftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flags i } l = _strlen(tls, path) if l > uint64(PATH_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENAMETOOLONG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENAMETOOLONG) return -int32(1) } Xmemcpy(tls, bp+4, path, l+uint64(1)) _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp) r = _do_nftw(tls, bp+4, __ccgo_fp_fn, fd_limit, flags, UintptrFromInt32(0)) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) return r } @@ -115683,7 +115683,7 @@ func Xopenpty(tls *TLS, pm uintptr, ps uintptr, name uintptr, tio uintptr, ws ui var _ /* cs at bp+4 */ int32 var _ /* n at bp+0 */ int32 _, _, _ = m, s, v1 - *(*int32)(unsafe.Pointer(bp)) = 0 + **(**int32)(__ccgo_up(bp)) = 0 m = Xopen(tls, __ccgo_ts+941, Int32FromInt32(O_RDWR)|Int32FromInt32(O_NOCTTY), 0) if m < 0 { return -int32(1) @@ -115695,7 +115695,7 @@ func Xopenpty(tls *TLS, pm uintptr, ps uintptr, name uintptr, tio uintptr, ws ui if !(name != 0) { name = bp + 8 } - Xsnprintf(tls, name, uint64(20), __ccgo_ts+951, VaList(bp+40, *(*int32)(unsafe.Pointer(bp)))) + Xsnprintf(tls, name, uint64(20), __ccgo_ts+951, VaList(bp+40, **(**int32)(__ccgo_up(bp)))) v1 = Xopen(tls, name, Int32FromInt32(O_RDWR)|Int32FromInt32(O_NOCTTY), 0) s = v1 if v1 < 0 { @@ -115707,15 +115707,15 @@ func Xopenpty(tls *TLS, pm uintptr, ps uintptr, name uintptr, tio uintptr, ws ui if ws != 0 { Xioctl(tls, s, Int32FromUint64(uint64(Uint32FromUint32(4)<= len1 { + if Uint64FromInt32(Xsnprintf(tls, buf, len1, __ccgo_ts+951, VaList(bp+16, **(**int32)(__ccgo_up(bp))))) >= len1 { return int32(ERANGE) } return 0 @@ -115806,7 +115806,7 @@ func _slash_len(tls *TLS, s uintptr) (r Tsize_t) { var s0 uintptr _ = s0 s0 = s - for Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('/') { + for Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('/') { s = s + 1 } return Uint64FromInt64(int64(s) - int64(s0)) @@ -115830,12 +115830,12 @@ func Xrealpath(tls *TLS, filename uintptr, resolved uintptr) (r uintptr) { nup = uint64(0) check_dir = 0 if !(filename != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } l = Xstrnlen(tls, filename, uint64(4097)) if !(l != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOENT) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOENT) return uintptr(0) } if l >= uint64(PATH_MAX) { @@ -115855,19 +115855,19 @@ _3: ; /* If stack starts with /, the whole component is / or // * and the output state must be reset. */ - if Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p]) == int32('/') { + if Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[p]) == int32('/') { check_dir = 0 nup = uint64(0) q = uint64(0) v4 = q q = q + 1 - (*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[v4] = uint8('/') + (**(**[4096]uint8)(__ccgo_up(bp + 4097)))[v4] = uint8('/') p = p + 1 /* Initial // is special. */ - if Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p]) == int32('/') && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p+uint64(1)]) != int32('/') { + if Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[p]) == int32('/') && Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[p+uint64(1)]) != int32('/') { v4 = q q = q + 1 - (*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[v4] = uint8('/') + (**(**[4096]uint8)(__ccgo_up(bp + 4097)))[v4] = uint8('/') } goto _2 } @@ -115879,30 +115879,30 @@ _3: goto _1 } /* Skip any . component but preserve check_dir status. */ - if l == uint64(1) && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p]) == int32('.') { + if l == uint64(1) && Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[p]) == int32('.') { p = p + l goto _2 } /* Copy next component onto output at least temporarily, to * call readlink, but wait to advance output position until * determining it's not a link. */ - if q != 0 && Int32FromUint8((*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[q-uint64(1)]) != int32('/') { + if q != 0 && Int32FromUint8((**(**[4096]uint8)(__ccgo_up(bp + 4097)))[q-uint64(1)]) != int32('/') { if !(p != 0) { goto toolong } p = p - 1 v4 = p - (*(*[4097]uint8)(unsafe.Pointer(bp)))[v4] = uint8('/') + (**(**[4097]uint8)(__ccgo_up(bp)))[v4] = uint8('/') l = l + 1 } if q+l >= uint64(PATH_MAX) { goto toolong } Xmemcpy(tls, bp+4097+uintptr(q), bp+uintptr(p), l) - (*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[q+l] = uint8(0) + (**(**[4096]uint8)(__ccgo_up(bp + 4097)))[q+l] = uint8(0) p = p + l up = 0 - if l0 == uint64(2) && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p-uint64(2)]) == int32('.') && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p-uint64(1)]) == int32('.') { + if l0 == uint64(2) && Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[p-uint64(2)]) == int32('.') && Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[p-uint64(1)]) == int32('.') { up = int32(1) /* Any non-.. path components we could cancel start * after nup repetitions of the 3-byte string "../"; @@ -115924,13 +115924,13 @@ _3: goto toolong } if !(k != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOENT) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOENT) return uintptr(0) } if !(k < 0) { goto _8 } - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(EINVAL) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(EINVAL) { return uintptr(0) } goto skip_readlink @@ -115938,10 +115938,10 @@ skip_readlink: ; check_dir = 0 if up != 0 { - for q != 0 && Int32FromUint8((*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[q-uint64(1)]) != int32('/') { + for q != 0 && Int32FromUint8((**(**[4096]uint8)(__ccgo_up(bp + 4097)))[q-uint64(1)]) != int32('/') { q = q - 1 } - if q > uint64(1) && (q > uint64(2) || Int32FromUint8((*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[0]) != int32('/')) { + if q > uint64(1) && (q > uint64(2) || Int32FromUint8((**(**[4096]uint8)(__ccgo_up(bp + 4097)))[0]) != int32('/')) { q = q - 1 } goto _2 @@ -115949,20 +115949,20 @@ skip_readlink: if l0 != 0 { q = q + l } - check_dir = Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p]) + check_dir = Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[p]) goto _2 _8: ; cnt = cnt + 1 v4 = cnt if v4 == uint64(SYMLOOP_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ELOOP) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ELOOP) return uintptr(0) } /* If link contents end in /, strip any slashes already on * stack to avoid /->// or //->/// or spurious toolong. */ - if Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[k-int64(1)]) == int32('/') { - for Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p]) == int32('/') { + if Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[k-int64(1)]) == int32('/') { + for Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[p]) == int32('/') { p = p + 1 } } @@ -115979,8 +115979,8 @@ _2: goto _1 _1: ; - (*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[q] = uint8(0) - if Int32FromUint8((*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[0]) != int32('/') { + (**(**[4096]uint8)(__ccgo_up(bp + 4097)))[q] = uint8(0) + if Int32FromUint8((**(**[4096]uint8)(__ccgo_up(bp + 4097)))[0]) != int32('/') { if !(Xgetcwd(tls, bp, uint64(4097)) != 0) { return uintptr(0) } @@ -115993,7 +115993,7 @@ _1: if !(v4 != 0) { break } - for l > uint64(1) && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[l-uint64(1)]) != int32('/') { + for l > uint64(1) && Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[l-uint64(1)]) != int32('/') { l = l - 1 } if l > uint64(1) { @@ -116004,10 +116004,10 @@ _1: p = p + 1 } } - if q-p != 0 && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[l-uint64(1)]) != int32('/') { + if q-p != 0 && Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[l-uint64(1)]) != int32('/') { v4 = l l = l + 1 - (*(*[4097]uint8)(unsafe.Pointer(bp)))[v4] = uint8('/') + (**(**[4097]uint8)(__ccgo_up(bp)))[v4] = uint8('/') } if l+(q-p)+uint64(1) >= uint64(PATH_MAX) { goto toolong @@ -116024,7 +116024,7 @@ _1: goto toolong toolong: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENAMETOOLONG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENAMETOOLONG) return uintptr(0) } @@ -116073,12 +116073,12 @@ func Xsetrlimit(tls *TLS, resource int32, rlim uintptr) (r int32) { var _ /* tmp at bp+0 */ Trlimit _, _, _ = ret, v1, v2 if ^Uint64FromUint64(0) != ^Uint64FromUint64(0) { - *(*Trlimit)(unsafe.Pointer(bp)) = *(*Trlimit)(unsafe.Pointer(rlim)) - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur >= ^Uint64FromUint64(0) { - (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur = ^Uint64FromUint64(0) + **(**Trlimit)(__ccgo_up(bp)) = **(**Trlimit)(__ccgo_up(rlim)) + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur >= ^Uint64FromUint64(0) { + (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur = ^Uint64FromUint64(0) } - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_max >= ^Uint64FromUint64(0) { - (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_max = ^Uint64FromUint64(0) + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_max >= ^Uint64FromUint64(0) { + (**(**Trlimit)(__ccgo_up(bp))).Frlim_max = ^Uint64FromUint64(0) } rlim = bp } @@ -116096,7 +116096,7 @@ func Xsetrlimit(tls *TLS, resource int32, rlim uintptr) (r int32) { } else { v2 = ^Uint64FromUint64(0) } - *(*Tctx)(unsafe.Pointer(bp + 16)) = Tctx{ + **(**Tctx)(__ccgo_up(bp + 16)) = Tctx{ Flim: [2]uint64{ 0: v1, 1: v2, @@ -116105,9 +116105,9 @@ func Xsetrlimit(tls *TLS, resource int32, rlim uintptr) (r int32) { Ferr: -int32(1), } ___synccall(tls, __ccgo_fp(_do_setrlimit), bp+16) - if (*(*Tctx)(unsafe.Pointer(bp + 16))).Ferr != 0 { - if (*(*Tctx)(unsafe.Pointer(bp + 16))).Ferr > 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = (*(*Tctx)(unsafe.Pointer(bp + 16))).Ferr + if (**(**Tctx)(__ccgo_up(bp + 16))).Ferr != 0 { + if (**(**Tctx)(__ccgo_up(bp + 16))).Ferr > 0 { + **(**int32)(__ccgo_up(X__errno_location(tls))) = (**(**Tctx)(__ccgo_up(bp + 16))).Ferr } return -int32(1) } @@ -116487,7 +116487,7 @@ func Xcloselog(tls *TLS) { Xclose(tls, _log_fd) _log_fd = -int32(1) ___unlock(tls, uintptr(unsafe.Pointer(&_lock2))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) } func ___openlog(tls *TLS) { @@ -116521,7 +116521,7 @@ func Xopenlog(tls *TLS, ident uintptr, opt int32, facility int32) { ___openlog(tls) } ___unlock(tls, uintptr(unsafe.Pointer(&_lock2))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) } func _is_lost_conn(tls *TLS, e int32) (r int32) { @@ -116538,14 +116538,14 @@ func __vsyslog(tls *TLS, priority int32, message uintptr, ap Tva_list) { var _ /* timebuf at bp+0 */ [16]uint8 var _ /* tm at bp+24 */ Ttm _, _, _, _, _, _ = errno_save, fd, l, l2, pid, v1 - errno_save = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + errno_save = **(**int32)(__ccgo_up(X__errno_location(tls))) if _log_fd < 0 { ___openlog(tls) } if !(priority&Int32FromInt32(LOG_FACMASK) != 0) { priority = priority | _log_facility } - *(*Ttime_t)(unsafe.Pointer(bp + 16)) = Xtime(tls, UintptrFromInt32(0)) + **(**Ttime_t)(__ccgo_up(bp + 16)) = Xtime(tls, UintptrFromInt32(0)) Xgmtime_r(tls, bp+16, bp+24) Xstrftime_l(tls, bp, uint64(16), __ccgo_ts+963, bp+24, uintptr(unsafe.Pointer(&X__c_locale))) if _log_opt&int32(LOG_PID) != 0 { @@ -116555,7 +116555,7 @@ func __vsyslog(tls *TLS, priority int32, message uintptr, ap Tva_list) { } pid = v1 l = Xsnprintf(tls, bp+80, uint64(1024), __ccgo_ts+972, VaList(bp+1120, priority, bp, bp+1104, uintptr(unsafe.Pointer(&_log_ident)), __ccgo_ts+994+BoolUintptr(!(pid != 0)), pid, __ccgo_ts+996+BoolUintptr(!(pid != 0)))) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = errno_save + **(**int32)(__ccgo_up(X__errno_location(tls))) = errno_save l2 = Xvsnprintf(tls, bp+80+uintptr(l), uint64(1024)-Uint64FromInt32(l), message, ap) if l2 >= 0 { if Uint64FromInt32(l2) >= uint64(1024)-Uint64FromInt32(l) { @@ -116563,20 +116563,20 @@ func __vsyslog(tls *TLS, priority int32, message uintptr, ap Tva_list) { } else { l = l + l2 } - if Int32FromUint8((*(*[1024]uint8)(unsafe.Pointer(bp + 80)))[l-int32(1)]) != int32('\n') { + if Int32FromUint8((**(**[1024]uint8)(__ccgo_up(bp + 80)))[l-int32(1)]) != int32('\n') { v1 = l l = l + 1 - (*(*[1024]uint8)(unsafe.Pointer(bp + 80)))[v1] = uint8('\n') + (**(**[1024]uint8)(__ccgo_up(bp + 80)))[v1] = uint8('\n') } - if Xsend(tls, _log_fd, bp+80, Uint64FromInt32(l), 0) < 0 && (!(_is_lost_conn(tls, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) != 0) || Xconnect(tls, _log_fd, uintptr(unsafe.Pointer(&_log_addr)), uint32(12)) < 0 || Xsend(tls, _log_fd, bp+80, Uint64FromInt32(l), 0) < 0) && _log_opt&int32(LOG_CONS) != 0 { + if Xsend(tls, _log_fd, bp+80, Uint64FromInt32(l), 0) < 0 && (!(_is_lost_conn(tls, **(**int32)(__ccgo_up(X__errno_location(tls)))) != 0) || Xconnect(tls, _log_fd, uintptr(unsafe.Pointer(&_log_addr)), uint32(12)) < 0 || Xsend(tls, _log_fd, bp+80, Uint64FromInt32(l), 0) < 0) && _log_opt&int32(LOG_CONS) != 0 { fd = Xopen(tls, __ccgo_ts+691, Int32FromInt32(O_WRONLY)|Int32FromInt32(O_NOCTTY)|Int32FromInt32(O_CLOEXEC), 0) if fd >= 0 { - Xdprintf(tls, fd, __ccgo_ts+998, VaList(bp+1120, l-*(*int32)(unsafe.Pointer(bp + 1104)), bp+80+uintptr(*(*int32)(unsafe.Pointer(bp + 1104))))) + Xdprintf(tls, fd, __ccgo_ts+998, VaList(bp+1120, l-**(**int32)(__ccgo_up(bp + 1104)), bp+80+uintptr(**(**int32)(__ccgo_up(bp + 1104))))) Xclose(tls, fd) } } if _log_opt&int32(LOG_PERROR) != 0 { - Xdprintf(tls, int32(2), __ccgo_ts+998, VaList(bp+1120, l-*(*int32)(unsafe.Pointer(bp + 1104)), bp+80+uintptr(*(*int32)(unsafe.Pointer(bp + 1104))))) + Xdprintf(tls, int32(2), __ccgo_ts+998, VaList(bp+1120, l-**(**int32)(__ccgo_up(bp + 1104)), bp+80+uintptr(**(**int32)(__ccgo_up(bp + 1104))))) } } } @@ -116592,7 +116592,7 @@ func ___vsyslog(tls *TLS, priority int32, message uintptr, ap Tva_list) { ___lock(tls, uintptr(unsafe.Pointer(&_lock2))) __vsyslog(tls, priority, message, ap) ___unlock(tls, uintptr(unsafe.Pointer(&_lock2))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) } func Xsyslog(tls *TLS, priority int32, message uintptr, va uintptr) { @@ -116677,11 +116677,11 @@ func X__mmap(tls *TLS, start uintptr, len1 Tsize_t, prot int32, flags int32, fd var ret int64 _ = ret if Uint64FromInt64(off)&(-Uint64FromUint64(0x2000)<<(Uint64FromInt32(8)*Uint64FromInt64(8)-Uint64FromInt32(1))|(Uint64FromUint64(4096)-Uint64FromInt32(1))) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(-Int32FromInt32(1)) } if len1 >= Uint64FromInt64(Int64FromInt64(INT64_MAX)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return uintptr(-Int32FromInt32(1)) } if flags&int32(MAP_FIXED) != 0 { @@ -116736,7 +116736,7 @@ func X__mremap(tls *TLS, old_addr uintptr, old_len Tsize_t, new_len Tsize_t, fla _, _ = ap, new_addr new_addr = uintptr(0) if new_len >= Uint64FromInt64(Int64FromInt64(INT64_MAX)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return uintptr(-Int32FromInt32(1)) } if flags&int32(MREMAP_FIXED) != 0 { @@ -116818,17 +116818,17 @@ func X__shm_mapname(tls *TLS, name uintptr, buf uintptr) (r uintptr) { } var p, v1 uintptr _, _ = p, v1 - for Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) == int32('/') { + for Int32FromUint8(**(**uint8)(__ccgo_up(name))) == int32('/') { name = name + 1 } v1 = X__strchrnul(tls, name, int32('/')) p = v1 - if *(*uint8)(unsafe.Pointer(v1)) != 0 || p == name || int64(p)-int64(name) <= int64(2) && Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) == int32('.') && Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) == int32('.') { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if **(**uint8)(__ccgo_up(v1)) != 0 || p == name || int64(p)-int64(name) <= int64(2) && Int32FromUint8(**(**uint8)(__ccgo_up(name))) == int32('.') && Int32FromUint8(**(**uint8)(__ccgo_up(p + uintptr(-Int32FromInt32(1))))) == int32('.') { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } if int64(p)-int64(name) > int64(NAME_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENAMETOOLONG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENAMETOOLONG) return uintptr(0) } Xmemcpy(tls, buf, __ccgo_ts+1003, uint64(9)) @@ -116855,7 +116855,7 @@ func Xshm_open(tls *TLS, name uintptr, flag int32, mode Tmode_t) (r int32) { } _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp) fd = Xopen(tls, name, flag|int32(O_NOFOLLOW)|int32(O_CLOEXEC)|int32(O_NONBLOCK), VaList(bp+280, mode)) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) return fd } @@ -116893,7 +116893,7 @@ func Xbtowc(tls *TLS, c int32) (r Twint_t) { if Uint32FromInt32(b) < uint32(128) { v1 = Uint32FromInt32(b) } else { - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v3 = int32(4) } else { v3 = int32(1) @@ -116925,22 +116925,22 @@ func Xc16rtomb(tls *TLS, s uintptr, c16 Tchar16_t, ps uintptr) (r Tsize_t) { } x = ps if !(s != 0) { - if *(*uint32)(unsafe.Pointer(x)) != 0 { + if **(**uint32)(__ccgo_up(x)) != 0 { goto ilseq } return uint64(1) } - if !(*(*uint32)(unsafe.Pointer(x)) != 0) && uint32(c16)-uint32(0xd800) < uint32(0x400) { - *(*uint32)(unsafe.Pointer(x)) = Uint32FromInt32((Int32FromUint16(c16) - int32(0xd7c0)) << int32(10)) + if !(**(**uint32)(__ccgo_up(x)) != 0) && uint32(c16)-uint32(0xd800) < uint32(0x400) { + **(**uint32)(__ccgo_up(x)) = Uint32FromInt32((Int32FromUint16(c16) - int32(0xd7c0)) << int32(10)) return uint64(0) } - if *(*uint32)(unsafe.Pointer(x)) != 0 { + if **(**uint32)(__ccgo_up(x)) != 0 { if uint32(c16)-uint32(0xdc00) >= uint32(0x400) { goto ilseq } else { - wc = Int32FromUint32(*(*uint32)(unsafe.Pointer(x)) + uint32(c16) - uint32(0xdc00)) + wc = Int32FromUint32(**(**uint32)(__ccgo_up(x)) + uint32(c16) - uint32(0xdc00)) } - *(*uint32)(unsafe.Pointer(x)) = uint32(0) + **(**uint32)(__ccgo_up(x)) = uint32(0) } else { wc = Int32FromUint16(c16) } @@ -116948,8 +116948,8 @@ func Xc16rtomb(tls *TLS, s uintptr, c16 Tchar16_t, ps uintptr) (r Tsize_t) { goto ilseq ilseq: ; - *(*uint32)(unsafe.Pointer(x)) = uint32(0) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EILSEQ) + **(**uint32)(__ccgo_up(x)) = uint32(0) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EILSEQ) return Uint64FromInt32(-Int32FromInt32(1)) } @@ -117008,21 +117008,21 @@ func Xmbrtoc16(tls *TLS, pc16 uintptr, s uintptr, n Tsize_t, ps uintptr) (r Tsiz } /* mbrtowc states for partial UTF-8 characters have the high bit set; * we use nonzero states without high bit for pending surrogates. */ - if Int32FromUint32(*(*uint32)(unsafe.Pointer(pending))) > 0 { + if Int32FromUint32(**(**uint32)(__ccgo_up(pending))) > 0 { if pc16 != 0 { - *(*Tchar16_t)(unsafe.Pointer(pc16)) = uint16(*(*uint32)(unsafe.Pointer(pending))) + **(**Tchar16_t)(__ccgo_up(pc16)) = uint16(**(**uint32)(__ccgo_up(pending))) } - *(*uint32)(unsafe.Pointer(pending)) = uint32(0) + **(**uint32)(__ccgo_up(pending)) = uint32(0) return Uint64FromInt32(-Int32FromInt32(3)) } ret = Xmbrtowc(tls, bp, s, n, ps) if ret <= uint64(4) { - if *(*Twchar_t)(unsafe.Pointer(bp)) >= int32(0x10000) { - *(*uint32)(unsafe.Pointer(pending)) = Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))&int32(0x3ff) + int32(0xdc00)) - *(*Twchar_t)(unsafe.Pointer(bp)) = int32(0xd7c0) + *(*Twchar_t)(unsafe.Pointer(bp))>>Int32FromInt32(10) + if **(**Twchar_t)(__ccgo_up(bp)) >= int32(0x10000) { + **(**uint32)(__ccgo_up(pending)) = Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))&int32(0x3ff) + int32(0xdc00)) + **(**Twchar_t)(__ccgo_up(bp)) = int32(0xd7c0) + **(**Twchar_t)(__ccgo_up(bp))>>Int32FromInt32(10) } if pc16 != 0 { - *(*Tchar16_t)(unsafe.Pointer(pc16)) = Uint16FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))) + **(**Tchar16_t)(__ccgo_up(pc16)) = Uint16FromInt32(**(**Twchar_t)(__ccgo_up(bp))) } } return ret @@ -117048,7 +117048,7 @@ func Xmbrtoc32(tls *TLS, pc32 uintptr, s uintptr, n Tsize_t, ps uintptr) (r Tsiz } ret = Xmbrtowc(tls, bp, s, n, ps) if ret <= uint64(4) && pc32 != 0 { - *(*Tchar32_t)(unsafe.Pointer(pc32)) = Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))) + **(**Tchar32_t)(__ccgo_up(pc32)) = Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))) } return ret } @@ -117074,7 +117074,7 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize if !(st != 0) { st = uintptr(unsafe.Pointer(&_internal_state3)) } - c = *(*uint32)(unsafe.Pointer(st)) + c = **(**uint32)(__ccgo_up(st)) if !(s != 0) { if c != 0 { goto ilseq @@ -117089,30 +117089,30 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize return Uint64FromInt32(-Int32FromInt32(2)) } if !(c != 0) { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) < int32(0x80) { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) - *(*Twchar_t)(unsafe.Pointer(wc)) = v1 + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) < int32(0x80) { + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(s))) + **(**Twchar_t)(__ccgo_up(wc)) = v1 return BoolUint64(!!(v1 != 0)) } - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v2 = int32(4) } else { v2 = int32(1) } if v2 == int32(1) { - *(*Twchar_t)(unsafe.Pointer(wc)) = Int32FromInt32(0xdfff) & int32(Int8FromUint8(*(*uint8)(unsafe.Pointer(s)))) + **(**Twchar_t)(__ccgo_up(wc)) = Int32FromInt32(0xdfff) & int32(Int8FromUint8(**(**uint8)(__ccgo_up(s)))) return Uint64FromInt32(1) } - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { goto ilseq } v3 = s s = s + 1 - c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v3)))-uint32(0xc2)] + c = X__fsmu8[uint32(**(**uint8)(__ccgo_up(v3)))-uint32(0xc2)] n = n - 1 } if n != 0 { - if (Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { + if (Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { goto ilseq } goto loop @@ -117120,27 +117120,27 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize ; v3 = s s = s + 1 - c = c<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { goto ilseq } goto loop } } - *(*uint32)(unsafe.Pointer(st)) = c + **(**uint32)(__ccgo_up(st)) = c return Uint64FromInt32(-Int32FromInt32(2)) goto ilseq ilseq: ; - *(*uint32)(unsafe.Pointer(st)) = uint32(0) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EILSEQ) + **(**uint32)(__ccgo_up(st)) = uint32(0) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EILSEQ) return Uint64FromInt32(-Int32FromInt32(1)) } @@ -117151,7 +117151,7 @@ func Xmbsinit(tls *TLS, st uintptr) (r int32) { trc("tls=%v st=%v, (%v:)", tls, st, origin(2)) defer func() { trc("-> %v", r) }() } - return BoolInt32(!(st != 0) || !(*(*uint32)(unsafe.Pointer(st)) != 0)) + return BoolInt32(!(st != 0) || !(**(**uint32)(__ccgo_up(st)) != 0)) } func Xmbsnrtowcs(tls *TLS, wcs uintptr, src uintptr, n Tsize_t, wn Tsize_t, st uintptr) (r Tsize_t) { @@ -117169,7 +117169,7 @@ func Xmbsnrtowcs(tls *TLS, wcs uintptr, src uintptr, n Tsize_t, wn Tsize_t, st u var _ /* wbuf at bp+0 */ [256]Twchar_t _, _, _, _, _, _, _, _ = cnt, l, n2, tmp_s, ws, v1, v2, v3 cnt = uint64(0) - *(*uintptr)(unsafe.Pointer(bp + 1024)) = *(*uintptr)(unsafe.Pointer(src)) + **(**uintptr)(__ccgo_up(bp + 1024)) = **(**uintptr)(__ccgo_up(src)) if !(wcs != 0) { ws = bp wn = Uint64FromInt64(1024) / Uint64FromInt64(4) @@ -117180,7 +117180,7 @@ func Xmbsnrtowcs(tls *TLS, wcs uintptr, src uintptr, n Tsize_t, wn Tsize_t, st u * that mbsrtowcs never reads more than n input bytes. thus * we can use mbsrtowcs as long as it's practical.. */ for { - if v2 = *(*uintptr)(unsafe.Pointer(bp + 1024)) != 0 && wn != 0; v2 { + if v2 = **(**uintptr)(__ccgo_up(bp + 1024)) != 0 && wn != 0; v2 { v1 = n / Uint64FromInt32(4) n2 = v1 } @@ -117190,7 +117190,7 @@ func Xmbsnrtowcs(tls *TLS, wcs uintptr, src uintptr, n Tsize_t, wn Tsize_t, st u if n2 >= wn { n2 = wn } - tmp_s = *(*uintptr)(unsafe.Pointer(bp + 1024)) + tmp_s = **(**uintptr)(__ccgo_up(bp + 1024)) l = Xmbsrtowcs(tls, ws, bp+1024, n2, st) if !(l+Uint64FromInt32(1) != 0) { cnt = l @@ -117201,31 +117201,31 @@ func Xmbsnrtowcs(tls *TLS, wcs uintptr, src uintptr, n Tsize_t, wn Tsize_t, st u ws = ws + uintptr(l)*4 wn = wn - l } - if *(*uintptr)(unsafe.Pointer(bp + 1024)) != 0 { - v3 = n - Uint64FromInt64(int64(*(*uintptr)(unsafe.Pointer(bp + 1024)))-int64(tmp_s)) + if **(**uintptr)(__ccgo_up(bp + 1024)) != 0 { + v3 = n - Uint64FromInt64(int64(**(**uintptr)(__ccgo_up(bp + 1024)))-int64(tmp_s)) } else { v3 = uint64(0) } n = v3 cnt = cnt + l } - if *(*uintptr)(unsafe.Pointer(bp + 1024)) != 0 { + if **(**uintptr)(__ccgo_up(bp + 1024)) != 0 { for wn != 0 && n != 0 { - l = Xmbrtowc(tls, ws, *(*uintptr)(unsafe.Pointer(bp + 1024)), n, st) + l = Xmbrtowc(tls, ws, **(**uintptr)(__ccgo_up(bp + 1024)), n, st) if l+uint64(2) <= uint64(2) { if !(l+Uint64FromInt32(1) != 0) { cnt = l break } if !(l != 0) { - *(*uintptr)(unsafe.Pointer(bp + 1024)) = uintptr(0) + **(**uintptr)(__ccgo_up(bp + 1024)) = uintptr(0) break } /* have to roll back partial character */ - *(*uint32)(unsafe.Pointer(st)) = uint32(0) + **(**uint32)(__ccgo_up(st)) = uint32(0) break } - *(*uintptr)(unsafe.Pointer(bp + 1024)) = *(*uintptr)(unsafe.Pointer(bp + 1024)) + uintptr(l) + **(**uintptr)(__ccgo_up(bp + 1024)) = **(**uintptr)(__ccgo_up(bp + 1024)) + uintptr(l) n = n - l /* safe - this loop runs fewer than sizeof(wbuf)/8 times */ ws += 4 @@ -117234,7 +117234,7 @@ func Xmbsnrtowcs(tls *TLS, wcs uintptr, src uintptr, n Tsize_t, wn Tsize_t, st u } } if wcs != 0 { - *(*uintptr)(unsafe.Pointer(src)) = *(*uintptr)(unsafe.Pointer(bp + 1024)) + **(**uintptr)(__ccgo_up(src)) = **(**uintptr)(__ccgo_up(bp + 1024)) } return cnt } @@ -117250,22 +117250,22 @@ func Xmbsrtowcs(tls *TLS, ws uintptr, src uintptr, wn Tsize_t, st uintptr) (r Ts var v2 bool var v3 int32 _, _, _, _, _, _, _, _ = c, s, wn0, v1, v2, v3, v5, v6 - s = *(*uintptr)(unsafe.Pointer(src)) + s = **(**uintptr)(__ccgo_up(src)) wn0 = wn c = uint32(0) if v2 = st != 0; v2 { - v1 = *(*uint32)(unsafe.Pointer(st)) + v1 = **(**uint32)(__ccgo_up(st)) c = v1 } if v2 && v1 != 0 { if ws != 0 { - *(*uint32)(unsafe.Pointer(st)) = uint32(0) + **(**uint32)(__ccgo_up(st)) = uint32(0) goto resume } else { goto resume0 } } - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v3 = int32(4) } else { v3 = int32(1) @@ -117276,24 +117276,24 @@ func Xmbsrtowcs(tls *TLS, ws uintptr, src uintptr, wn Tsize_t, st uintptr) (r Ts } for { if !(wn != 0) { - *(*uintptr)(unsafe.Pointer(src)) = s + **(**uintptr)(__ccgo_up(src)) = s return wn0 } - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { break } v5 = s s = s + 1 - c = uint32(*(*uint8)(unsafe.Pointer(v5))) + c = uint32(**(**uint8)(__ccgo_up(v5))) v5 = ws ws += 4 - *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromInt32(0xdfff) & int32(Int8FromUint32(c)) + **(**Twchar_t)(__ccgo_up(v5)) = Int32FromInt32(0xdfff) & int32(Int8FromUint32(c)) wn = wn - 1 goto _4 _4: } - *(*Twchar_t)(unsafe.Pointer(ws)) = 0 - *(*uintptr)(unsafe.Pointer(src)) = uintptr(0) + **(**Twchar_t)(__ccgo_up(ws)) = 0 + **(**uintptr)(__ccgo_up(src)) = uintptr(0) return wn0 - wn } if !!(ws != 0) { @@ -117301,39 +117301,39 @@ func Xmbsrtowcs(tls *TLS, ws uintptr, src uintptr, wn Tsize_t, st uintptr) (r Ts } _11: ; - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) && uint64(s)%uint64(4) == uint64(0) { - for !((*(*uint32)(unsafe.Pointer(s))|(*(*uint32)(unsafe.Pointer(s))-Uint32FromInt32(0x01010101)))&Uint32FromUint32(0x80808080) != 0) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(1) < uint32(0x7f) && uint64(s)%uint64(4) == uint64(0) { + for !((**(**uint32)(__ccgo_up(s))|(**(**uint32)(__ccgo_up(s))-Uint32FromInt32(0x01010101)))&Uint32FromUint32(0x80808080) != 0) { s = s + uintptr(4) wn = wn - uint64(4) } } - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(1) < uint32(0x7f) { s = s + 1 wn = wn - 1 goto _10 } - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { goto _9 } v5 = s s = s + 1 - c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v5)))-uint32(0xc2)] + c = X__fsmu8[uint32(**(**uint8)(__ccgo_up(v5)))-uint32(0xc2)] goto resume0 resume0: ; - if (Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { + if (Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { s = s - 1 goto _9 } s = s + 1 if c&(Uint32FromUint32(1)<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { s = s - uintptr(2) goto _9 } s = s + 1 if c&(Uint32FromUint32(1)<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { s = s - uintptr(3) goto _9 } @@ -117355,80 +117355,80 @@ _7: _15: ; if !(wn != 0) { - *(*uintptr)(unsafe.Pointer(src)) = s + **(**uintptr)(__ccgo_up(src)) = s return wn0 } - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) && uint64(s)%uint64(4) == uint64(0) { - for wn >= uint64(5) && !((*(*uint32)(unsafe.Pointer(s))|(*(*uint32)(unsafe.Pointer(s))-Uint32FromInt32(0x01010101)))&Uint32FromUint32(0x80808080) != 0) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(1) < uint32(0x7f) && uint64(s)%uint64(4) == uint64(0) { + for wn >= uint64(5) && !((**(**uint32)(__ccgo_up(s))|(**(**uint32)(__ccgo_up(s))-Uint32FromInt32(0x01010101)))&Uint32FromUint32(0x80808080) != 0) { v5 = ws ws += 4 v6 = s s = s + 1 - *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + **(**Twchar_t)(__ccgo_up(v5)) = Int32FromUint8(**(**uint8)(__ccgo_up(v6))) v5 = ws ws += 4 v6 = s s = s + 1 - *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + **(**Twchar_t)(__ccgo_up(v5)) = Int32FromUint8(**(**uint8)(__ccgo_up(v6))) v5 = ws ws += 4 v6 = s s = s + 1 - *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + **(**Twchar_t)(__ccgo_up(v5)) = Int32FromUint8(**(**uint8)(__ccgo_up(v6))) v5 = ws ws += 4 v6 = s s = s + 1 - *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + **(**Twchar_t)(__ccgo_up(v5)) = Int32FromUint8(**(**uint8)(__ccgo_up(v6))) wn = wn - uint64(4) } } - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(1) < uint32(0x7f) { v5 = ws ws += 4 v6 = s s = s + 1 - *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + **(**Twchar_t)(__ccgo_up(v5)) = Int32FromUint8(**(**uint8)(__ccgo_up(v6))) wn = wn - 1 goto _14 } - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { goto _13 } v5 = s s = s + 1 - c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v5)))-uint32(0xc2)] + c = X__fsmu8[uint32(**(**uint8)(__ccgo_up(v5)))-uint32(0xc2)] goto resume resume: ; - if (Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { + if (Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { s = s - 1 goto _13 } v5 = s s = s + 1 - c = c<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { s = s - uintptr(2) goto _13 } v5 = s s = s + 1 - c = c<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { s = s - uintptr(3) goto _13 } v5 = s s = s + 1 - c = c< Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { goto ilseq } v3 = s s = s + 1 - c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v3)))-uint32(0xc2)] + c = X__fsmu8[uint32(**(**uint8)(__ccgo_up(v3)))-uint32(0xc2)] /* Avoid excessive checks against n: If shifting the state n-1 * times does not clear the high bit, then the value of n is * insufficient to read a character */ if n < uint64(4) && c<<(uint64(6)*n-uint64(6))&(Uint32FromUint32(1)<>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { + if (Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { goto ilseq } v3 = s s = s + 1 - c = c<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { goto ilseq } v3 = s s = s + 1 - c = c<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { goto ilseq } v3 = s s = s + 1 - *(*Twchar_t)(unsafe.Pointer(wc)) = Int32FromUint32(c<>Int32FromInt32(6)) - *(*uint8)(unsafe.Pointer(s)) = Uint8FromInt32(int32(0x80) | wc&int32(0x3f)) + **(**uint8)(__ccgo_up(v2)) = Uint8FromInt32(int32(0xc0) | wc>>Int32FromInt32(6)) + **(**uint8)(__ccgo_up(s)) = Uint8FromInt32(int32(0x80) | wc&int32(0x3f)) return uint64(2) } else { if Uint32FromInt32(wc) < uint32(0xd800) || Uint32FromInt32(wc)-uint32(0xe000) < uint32(0x2000) { v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(int32(0xe0) | wc>>Int32FromInt32(12)) + **(**uint8)(__ccgo_up(v2)) = Uint8FromInt32(int32(0xe0) | wc>>Int32FromInt32(12)) v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(int32(0x80) | wc>>Int32FromInt32(6)&int32(0x3f)) - *(*uint8)(unsafe.Pointer(s)) = Uint8FromInt32(int32(0x80) | wc&int32(0x3f)) + **(**uint8)(__ccgo_up(v2)) = Uint8FromInt32(int32(0x80) | wc>>Int32FromInt32(6)&int32(0x3f)) + **(**uint8)(__ccgo_up(s)) = Uint8FromInt32(int32(0x80) | wc&int32(0x3f)) return uint64(3) } else { if Uint32FromInt32(wc)-uint32(0x10000) < uint32(0x100000) { v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(int32(0xf0) | wc>>Int32FromInt32(18)) + **(**uint8)(__ccgo_up(v2)) = Uint8FromInt32(int32(0xf0) | wc>>Int32FromInt32(18)) v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(int32(0x80) | wc>>Int32FromInt32(12)&int32(0x3f)) + **(**uint8)(__ccgo_up(v2)) = Uint8FromInt32(int32(0x80) | wc>>Int32FromInt32(12)&int32(0x3f)) v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(int32(0x80) | wc>>Int32FromInt32(6)&int32(0x3f)) - *(*uint8)(unsafe.Pointer(s)) = Uint8FromInt32(int32(0x80) | wc&int32(0x3f)) + **(**uint8)(__ccgo_up(v2)) = Uint8FromInt32(int32(0x80) | wc>>Int32FromInt32(6)&int32(0x3f)) + **(**uint8)(__ccgo_up(s)) = Uint8FromInt32(int32(0x80) | wc&int32(0x3f)) return uint64(4) } } } } } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EILSEQ) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EILSEQ) return Uint64FromInt32(-Int32FromInt32(1)) } @@ -117625,7 +117625,7 @@ func Xwcsnrtombs(tls *TLS, dst uintptr, wcs uintptr, wn Tsize_t, n Tsize_t, st u var ws, v1 uintptr var _ /* tmp at bp+0 */ [4]uint8 _, _, _, _ = cnt, l, ws, v1 - ws = *(*uintptr)(unsafe.Pointer(wcs)) + ws = **(**uintptr)(__ccgo_up(wcs)) cnt = uint64(0) if !(dst != 0) { n = uint64(0) @@ -117636,7 +117636,7 @@ func Xwcsnrtombs(tls *TLS, dst uintptr, wcs uintptr, wn Tsize_t, n Tsize_t, st u } else { v1 = dst } - l = Xwcrtomb(tls, v1, *(*Twchar_t)(unsafe.Pointer(ws)), uintptr(0)) + l = Xwcrtomb(tls, v1, **(**Twchar_t)(__ccgo_up(ws)), uintptr(0)) if l == Uint64FromInt32(-Int32FromInt32(1)) { cnt = Uint64FromInt32(-Int32FromInt32(1)) break @@ -117651,7 +117651,7 @@ func Xwcsnrtombs(tls *TLS, dst uintptr, wcs uintptr, wn Tsize_t, n Tsize_t, st u dst = dst + uintptr(l) n = n - l } - if !(*(*Twchar_t)(unsafe.Pointer(ws)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(ws)) != 0) { ws = uintptr(0) break } @@ -117660,7 +117660,7 @@ func Xwcsnrtombs(tls *TLS, dst uintptr, wcs uintptr, wn Tsize_t, n Tsize_t, st u cnt = cnt + l } if dst != 0 { - *(*uintptr)(unsafe.Pointer(wcs)) = ws + **(**uintptr)(__ccgo_up(wcs)) = ws } return cnt } @@ -117679,13 +117679,13 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize N = n if !(s != 0) { n = uint64(0) - ws2 = *(*uintptr)(unsafe.Pointer(ws)) + ws2 = **(**uintptr)(__ccgo_up(ws)) for { - if !(*(*Twchar_t)(unsafe.Pointer(ws2)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(ws2)) != 0) { break } - if Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(ws2))) >= uint32(0x80) { - l = Xwcrtomb(tls, bp, *(*Twchar_t)(unsafe.Pointer(ws2)), uintptr(0)) + if Uint32FromInt32(**(**Twchar_t)(__ccgo_up(ws2))) >= uint32(0x80) { + l = Xwcrtomb(tls, bp, **(**Twchar_t)(__ccgo_up(ws2)), uintptr(0)) if !(l+Uint64FromInt32(1) != 0) { return Uint64FromInt32(-Int32FromInt32(1)) } @@ -117701,13 +117701,13 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize return n } for n >= uint64(4) { - if Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))))-uint32(1) >= uint32(0x7f) { - if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))) != 0) { - *(*uint8)(unsafe.Pointer(s)) = uint8(0) - *(*uintptr)(unsafe.Pointer(ws)) = uintptr(0) + if Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))))-uint32(1) >= uint32(0x7f) { + if !(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))) != 0) { + **(**uint8)(__ccgo_up(s)) = uint8(0) + **(**uintptr)(__ccgo_up(ws)) = uintptr(0) return N - n } - l = Xwcrtomb(tls, s, *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))), uintptr(0)) + l = Xwcrtomb(tls, s, **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))), uintptr(0)) if !(l+Uint64FromInt32(1) != 0) { return Uint64FromInt32(-Int32FromInt32(1)) } @@ -117716,35 +117716,35 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize } else { v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) + **(**uint8)(__ccgo_up(v2)) = Uint8FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws))))) n = n - 1 } - *(*uintptr)(unsafe.Pointer(ws)) += 4 + **(**uintptr)(__ccgo_up(ws)) += 4 } for n != 0 { - if Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))))-uint32(1) >= uint32(0x7f) { - if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))) != 0) { - *(*uint8)(unsafe.Pointer(s)) = uint8(0) - *(*uintptr)(unsafe.Pointer(ws)) = uintptr(0) + if Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))))-uint32(1) >= uint32(0x7f) { + if !(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))) != 0) { + **(**uint8)(__ccgo_up(s)) = uint8(0) + **(**uintptr)(__ccgo_up(ws)) = uintptr(0) return N - n } - l = Xwcrtomb(tls, bp, *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))), uintptr(0)) + l = Xwcrtomb(tls, bp, **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))), uintptr(0)) if !(l+Uint64FromInt32(1) != 0) { return Uint64FromInt32(-Int32FromInt32(1)) } if l > n { return N - n } - Xwcrtomb(tls, s, *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))), uintptr(0)) + Xwcrtomb(tls, s, **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))), uintptr(0)) s = s + uintptr(l) n = n - l } else { v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) + **(**uint8)(__ccgo_up(v2)) = Uint8FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws))))) n = n - 1 } - *(*uintptr)(unsafe.Pointer(ws)) += 4 + **(**uintptr)(__ccgo_up(ws)) += 4 } return N } @@ -117770,7 +117770,7 @@ func Xwctob(tls *TLS, c Twint_t) (r int32) { if c < uint32(128) { return Int32FromUint32(c) } - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v1 = int32(4) } else { v1 = int32(1) @@ -117916,11 +117916,11 @@ func Xaccept4(tls *TLS, fd int32, addr uintptr, len1 uintptr, flg int32) (r1 int goto _11 _11: ret = int32(X__syscall_ret(tls, Uint64FromInt64(v10))) - if ret >= 0 || *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(ENOSYS) && *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(EINVAL) { + if ret >= 0 || **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(ENOSYS) && **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(EINVAL) { return ret } if flg & ^(Int32FromInt32(SOCK_CLOEXEC)|Int32FromInt32(SOCK_NONBLOCK)) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } ret = Xaccept(tls, fd, addr, len1) @@ -118940,13 +118940,13 @@ func _getoffs(tls *TLS, offs uintptr, base uintptr, s uintptr) (r int32) { _, _ = i, v2 i = 0 for { - for Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))&int32(0xc0) != 0 { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))&int32(0xc0) != int32(0xc0) { + for Int32FromUint8(**(**uint8)(__ccgo_up(s)))&int32(0xc0) != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(s)))&int32(0xc0) != int32(0xc0) { return 0 } - s = base + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))&Int32FromInt32(0x3f)<= int64(0x4000) { @@ -118954,8 +118954,8 @@ func _getoffs(tls *TLS, offs uintptr, base uintptr, s uintptr) (r int32) { } v2 = i i = i + 1 - *(*int16)(unsafe.Pointer(offs + uintptr(v2)*2)) = int16(int64(s) - int64(base)) - s = s + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))+int32(1)) + **(**int16)(__ccgo_up(offs + uintptr(v2)*2)) = int16(int64(s) - int64(base)) + s = s + uintptr(Int32FromUint8(**(**uint8)(__ccgo_up(s)))+int32(1)) goto _1 _1: } @@ -118973,7 +118973,7 @@ func _getlens(tls *TLS, lens uintptr, s uintptr, l int32) (r int32) { k = 0 for { for { - if !(j < l && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(j)))) != int32('.')) { + if !(j < l && Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(j)))) != int32('.')) { break } goto _2 @@ -118986,7 +118986,7 @@ func _getlens(tls *TLS, lens uintptr, s uintptr, l int32) (r int32) { } v3 = i i = i + 1 - *(*uint8)(unsafe.Pointer(lens + uintptr(v3))) = Uint8FromInt32(j - k) + **(**uint8)(__ccgo_up(lens + uintptr(v3))) = Uint8FromInt32(j - k) if j == l { return i } @@ -119016,15 +119016,15 @@ func _match(tls *TLS, offset uintptr, base uintptr, dn uintptr, end uintptr, len for { nlen = nlen - 1 v2 = nlen - l = Int32FromUint8(*(*uint8)(unsafe.Pointer(lens + uintptr(v2)))) + l = Int32FromUint8(**(**uint8)(__ccgo_up(lens + uintptr(v2)))) noff = noff - 1 v2 = noff - o = int32((*(*[128]int16)(unsafe.Pointer(bp)))[v2]) + o = int32((**(**[128]int16)(__ccgo_up(bp)))[v2]) end = end - uintptr(l) - if l != Int32FromUint8(*(*uint8)(unsafe.Pointer(base + uintptr(o)))) || Xmemcmp(tls, base+uintptr(o)+uintptr(1), end, Uint64FromInt32(l)) != 0 { + if l != Int32FromUint8(**(**uint8)(__ccgo_up(base + uintptr(o)))) || Xmemcmp(tls, base+uintptr(o)+uintptr(1), end, Uint64FromInt32(l)) != 0 { return m } - *(*int32)(unsafe.Pointer(offset)) = o + **(**int32)(__ccgo_up(offset)) = o m = m + l if nlen != 0 { m = m + 1 @@ -119055,14 +119055,14 @@ func Xdn_comp(tls *TLS, src uintptr, dst uintptr, space int32, dnptrs uintptr, l m = 0 bestlen = 0 l = Xstrnlen(tls, src, uint64(255)) - if l != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(src + uintptr(l-uint64(1))))) == int32('.') { + if l != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(src + uintptr(l-uint64(1))))) == int32('.') { l = l - 1 } if l > uint64(253) || space <= 0 { return -int32(1) } if !(l != 0) { - *(*uint8)(unsafe.Pointer(dst)) = uint8(0) + **(**uint8)(__ccgo_up(dst)) = uint8(0) return int32(1) } end = src + uintptr(l) @@ -119071,16 +119071,16 @@ func Xdn_comp(tls *TLS, src uintptr, dst uintptr, space int32, dnptrs uintptr, l return -int32(1) } p = dnptrs - if p != 0 && *(*uintptr)(unsafe.Pointer(p)) != 0 { + if p != 0 && **(**uintptr)(__ccgo_up(p)) != 0 { p += 8 for { - if !(*(*uintptr)(unsafe.Pointer(p)) != 0) { + if !(**(**uintptr)(__ccgo_up(p)) != 0) { break } - m = _match(tls, bp, *(*uintptr)(unsafe.Pointer(dnptrs)), *(*uintptr)(unsafe.Pointer(p)), end, bp+4, n) + m = _match(tls, bp, **(**uintptr)(__ccgo_up(dnptrs)), **(**uintptr)(__ccgo_up(p)), end, bp+4, n) if m > bestlen { bestlen = m - bestoff = *(*int32)(unsafe.Pointer(bp)) + bestoff = **(**int32)(__ccgo_up(bp)) if Uint64FromInt32(m) == l { break } @@ -119103,37 +119103,37 @@ func Xdn_comp(tls *TLS, src uintptr, dst uintptr, space int32, dnptrs uintptr, l if !(Uint64FromInt32(i) < l-Uint64FromInt32(bestlen)) { break } - *(*uint8)(unsafe.Pointer(dst + uintptr(i))) = (*(*[127]uint8)(unsafe.Pointer(bp + 4)))[j] + **(**uint8)(__ccgo_up(dst + uintptr(i))) = (**(**[127]uint8)(__ccgo_up(bp + 4)))[j] goto _2 _2: ; v3 = j j = j + 1 - i = i + (Int32FromUint8((*(*[127]uint8)(unsafe.Pointer(bp + 4)))[v3]) + int32(1)) + i = i + (Int32FromUint8((**(**[127]uint8)(__ccgo_up(bp + 4)))[v3]) + int32(1)) } /* add tail */ if bestlen != 0 { v3 = i i = i + 1 - *(*uint8)(unsafe.Pointer(dst + uintptr(v3))) = Uint8FromInt32(int32(0xc0) | bestoff>>int32(8)) + **(**uint8)(__ccgo_up(dst + uintptr(v3))) = Uint8FromInt32(int32(0xc0) | bestoff>>int32(8)) v3 = i i = i + 1 - *(*uint8)(unsafe.Pointer(dst + uintptr(v3))) = Uint8FromInt32(bestoff) + **(**uint8)(__ccgo_up(dst + uintptr(v3))) = Uint8FromInt32(bestoff) } else { v3 = i i = i + 1 - *(*uint8)(unsafe.Pointer(dst + uintptr(v3))) = uint8(0) + **(**uint8)(__ccgo_up(dst + uintptr(v3))) = uint8(0) } /* save dst pointer */ - if i > int32(2) && lastdnptr != 0 && dnptrs != 0 && *(*uintptr)(unsafe.Pointer(dnptrs)) != 0 { - for *(*uintptr)(unsafe.Pointer(p)) != 0 { + if i > int32(2) && lastdnptr != 0 && dnptrs != 0 && **(**uintptr)(__ccgo_up(dnptrs)) != 0 { + for **(**uintptr)(__ccgo_up(p)) != 0 { p += 8 } if p+uintptr(1)*8 < lastdnptr { v8 = p p += 8 - *(*uintptr)(unsafe.Pointer(v8)) = dst - *(*uintptr)(unsafe.Pointer(p)) = uintptr(0) + **(**uintptr)(__ccgo_up(v8)) = dst + **(**uintptr)(__ccgo_up(p)) = uintptr(0) } } return i @@ -119166,11 +119166,11 @@ func X__dn_expand(tls *TLS, base uintptr, end uintptr, src uintptr, dest uintptr break } /* loop invariants: p= int64(end)-int64(p) || int64(j) >= int64(dend)-int64(dest) { return -int32(1) } @@ -119201,10 +119201,10 @@ func X__dn_expand(tls *TLS, base uintptr, end uintptr, src uintptr, dest uintptr dest = dest + 1 v4 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v3)) = *(*uint8)(unsafe.Pointer(v4)) + **(**uint8)(__ccgo_up(v3)) = uint8(**(**uint8)(__ccgo_up(v4))) } } else { - *(*uint8)(unsafe.Pointer(dest)) = uint8(0) + **(**uint8)(__ccgo_up(dest)) = uint8(0) if len1 < 0 { len1 = int32(int64(p+uintptr(1)) - int64(src)) } @@ -119236,20 +119236,20 @@ func Xdn_skipname(tls *TLS, s uintptr, end uintptr) (r int32) { _ = p p = s for p < end { - if !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if !(**(**uint8)(__ccgo_up(p)) != 0) { return int32(int64(p) - int64(s) + int64(1)) } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) >= int32(192) { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) >= int32(192) { if p+uintptr(1) < end { return int32(int64(p) - int64(s) + int64(2)) } else { break } } else { - if int64(end)-int64(p) < int64(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))+int32(1)) { + if int64(end)-int64(p) < int64(Int32FromUint8(**(**uint8)(__ccgo_up(p)))+int32(1)) { break } else { - p = p + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))+int32(1)) + p = p + uintptr(Int32FromUint8(**(**uint8)(__ccgo_up(p)))+int32(1)) } } } @@ -119365,25 +119365,25 @@ func X__dns_parse(tls *TLS, r uintptr, rlen int32, __ccgo_fp_callback uintptr, c if rlen < int32(12) { return -int32(1) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 3)))&int32(15) != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(r + 3)))&int32(15) != 0 { return 0 } p = r + uintptr(12) - qdcount = Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 4)))*int32(256) + Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 5))) - ancount = Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 6)))*int32(256) + Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 7))) + qdcount = Int32FromUint8(**(**uint8)(__ccgo_up(r + 4)))*int32(256) + Int32FromUint8(**(**uint8)(__ccgo_up(r + 5))) + ancount = Int32FromUint8(**(**uint8)(__ccgo_up(r + 6)))*int32(256) + Int32FromUint8(**(**uint8)(__ccgo_up(r + 7))) for { v1 = qdcount qdcount = qdcount - 1 if !(v1 != 0) { break } - for int64(p)-int64(r) < int64(rlen) && uint32(*(*uint8)(unsafe.Pointer(p)))-uint32(1) < uint32(127) { + for int64(p)-int64(r) < int64(rlen) && uint32(**(**uint8)(__ccgo_up(p)))-uint32(1) < uint32(127) { p = p + 1 } if p > r+uintptr(rlen)-uintptr(6) { return -int32(1) } - p = p + uintptr(int32(5)+BoolInt32(!!(*(*uint8)(unsafe.Pointer(p)) != 0))) + p = p + uintptr(int32(5)+BoolInt32(!!(**(**uint8)(__ccgo_up(p)) != 0))) } for { v1 = ancount @@ -119391,18 +119391,18 @@ func X__dns_parse(tls *TLS, r uintptr, rlen int32, __ccgo_fp_callback uintptr, c if !(v1 != 0) { break } - for int64(p)-int64(r) < int64(rlen) && uint32(*(*uint8)(unsafe.Pointer(p)))-uint32(1) < uint32(127) { + for int64(p)-int64(r) < int64(rlen) && uint32(**(**uint8)(__ccgo_up(p)))-uint32(1) < uint32(127) { p = p + 1 } if p > r+uintptr(rlen)-uintptr(12) { return -int32(1) } - p = p + uintptr(int32(1)+BoolInt32(!!(*(*uint8)(unsafe.Pointer(p)) != 0))) - len1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 8)))*int32(256) + Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 9))) + p = p + uintptr(int32(1)+BoolInt32(!!(**(**uint8)(__ccgo_up(p)) != 0))) + len1 = Int32FromUint8(**(**uint8)(__ccgo_up(p + 8)))*int32(256) + Int32FromUint8(**(**uint8)(__ccgo_up(p + 9))) if int64(len1+int32(10)) > int64(r+uintptr(rlen))-int64(p) { return -int32(1) } - if (*(*func(*TLS, uintptr, int32, uintptr, int32, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_callback})))(tls, ctx, Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))), p+uintptr(10), len1, r, rlen) < 0 { + if (*(*func(*TLS, uintptr, int32, uintptr, int32, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_callback})))(tls, ctx, Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))), p+uintptr(10), len1, r, rlen) < 0 { return -int32(1) } p = p + uintptr(int32(10)+len1) @@ -119744,27 +119744,27 @@ func Xether_aton_r(tls *TLS, x uintptr, p_a uintptr) (r uintptr) { break } if ii != 0 { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(x))) != int32(':') { + if Int32FromUint8(**(**uint8)(__ccgo_up(x))) != int32(':') { return uintptr(0) } else { x = x + 1 } } n = Xstrtoul(tls, x, bp+8, int32(16)) - x = *(*uintptr)(unsafe.Pointer(bp + 8)) + x = **(**uintptr)(__ccgo_up(bp + 8)) if n > uint64(0xFF) { return uintptr(0) } /* bad byte */ - *(*Tuint8_t)(unsafe.Pointer(bp + uintptr(ii))) = uint8(n) + **(**Tuint8_t)(__ccgo_up(bp + uintptr(ii))) = uint8(n) goto _1 _1: ; ii = ii + 1 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(x))) != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(x))) != 0 { return uintptr(0) } /* bad format */ - *(*Tether_addr)(unsafe.Pointer(p_a)) = *(*Tether_addr)(unsafe.Pointer(bp)) + **(**Tether_addr)(__ccgo_up(p_a)) = **(**Tether_addr)(__ccgo_up(bp)) return p_a } @@ -119799,7 +119799,7 @@ func Xether_ntoa_r(tls *TLS, p_a uintptr, x uintptr) (r uintptr) { } else { v2 = __ccgo_ts + 1018 } - x = x + uintptr(Xsprintf(tls, x, v2, VaList(bp+8, Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(p_a + uintptr(ii))))))) + x = x + uintptr(Xsprintf(tls, x, v2, VaList(bp+8, Int32FromUint8(**(**Tuint8_t)(__ccgo_up(p_a + uintptr(ii))))))) goto _1 _1: ; @@ -119884,11 +119884,11 @@ func Xgai_strerror(tls *TLS, ecode int32) (r uintptr) { s = uintptr(unsafe.Pointer(&_msgs)) ecode = ecode + 1 for { - if !(ecode != 0 && *(*uint8)(unsafe.Pointer(s)) != 0) { + if !(ecode != 0 && **(**uint8)(__ccgo_up(s)) != 0) { break } for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { break } goto _2 @@ -119902,7 +119902,7 @@ func Xgai_strerror(tls *TLS, ecode int32) (r uintptr) { ecode = ecode + 1 s = s + 1 } - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { s = s + 1 } return X__lctrans_cur(tls, s) @@ -119978,15 +119978,15 @@ func Xgetaddrinfo(tls *TLS, host uintptr, serv uintptr, hint uintptr, res uintpt if s >= 0 { _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp+1608) r = Xconnect(tls, s, ta[i], tl[i]) - saved_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 1608)), uintptr(0)) + saved_errno = **(**int32)(__ccgo_up(X__errno_location(tls))) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 1608)), uintptr(0)) Xclose(tls, s) if !(r != 0) { goto _1 } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = saved_errno + **(**int32)(__ccgo_up(X__errno_location(tls))) = saved_errno } - switch *(*int32)(unsafe.Pointer(X__errno_location(tls))) { + switch **(**int32)(__ccgo_up(X__errno_location(tls))) { case int32(EADDRNOTAVAIL): fallthrough case int32(EAFNOSUPPORT): @@ -120044,32 +120044,32 @@ func Xgetaddrinfo(tls *TLS, host uintptr, serv uintptr, hint uintptr, res uintpt if !(j < nservs) { break } - (*(*Taibuf)(unsafe.Pointer(out + uintptr(k)*88))).Fslot = int16(k) - if (*(*[48]Taddress)(unsafe.Pointer(bp + 8)))[i].Ffamily == int32(PF_INET) { + (**(**Taibuf)(__ccgo_up(out + uintptr(k)*88))).Fslot = int16(k) + if (**(**[48]Taddress)(__ccgo_up(bp + 8)))[i].Ffamily == int32(PF_INET) { v5 = uint64(16) } else { v5 = uint64(28) } - (*(*Taibuf)(unsafe.Pointer(out + uintptr(k)*88))).Fai = Taddrinfo{ - Fai_family: (*(*[48]Taddress)(unsafe.Pointer(bp + 8)))[i].Ffamily, - Fai_socktype: Int32FromUint8((*(*[2]Tservice)(unsafe.Pointer(bp)))[j].Fsocktype), - Fai_protocol: Int32FromUint8((*(*[2]Tservice)(unsafe.Pointer(bp)))[j].Fproto), + (**(**Taibuf)(__ccgo_up(out + uintptr(k)*88))).Fai = Taddrinfo{ + Fai_family: (**(**[48]Taddress)(__ccgo_up(bp + 8)))[i].Ffamily, + Fai_socktype: Int32FromUint8((**(**[2]Tservice)(__ccgo_up(bp)))[j].Fsocktype), + Fai_protocol: Int32FromUint8((**(**[2]Tservice)(__ccgo_up(bp)))[j].Fproto), Fai_addrlen: uint32(v5), Fai_addr: out + uintptr(k)*88 + 48, Fai_canonname: outcanon, } if k != 0 { - (*(*Taibuf)(unsafe.Pointer(out + uintptr(k-int32(1))*88))).Fai.Fai_next = out + uintptr(k)*88 + (**(**Taibuf)(__ccgo_up(out + uintptr(k-int32(1))*88))).Fai.Fai_next = out + uintptr(k)*88 } - switch (*(*[48]Taddress)(unsafe.Pointer(bp + 8)))[i].Ffamily { + switch (**(**[48]Taddress)(__ccgo_up(bp + 8)))[i].Ffamily { case int32(PF_INET): *(*Tsa_family_t)(unsafe.Pointer(out + uintptr(k)*88 + 48)) = uint16(PF_INET) - *(*Tin_port_t)(unsafe.Pointer(out + uintptr(k)*88 + 48 + 2)) = Xhtons(tls, (*(*[2]Tservice)(unsafe.Pointer(bp)))[j].Fport) + *(*Tin_port_t)(unsafe.Pointer(out + uintptr(k)*88 + 48 + 2)) = Xhtons(tls, (**(**[2]Tservice)(__ccgo_up(bp)))[j].Fport) Xmemcpy(tls, out+uintptr(k)*88+48+4, bp+8+uintptr(i)*28+8, uint64(4)) case int32(PF_INET6): *(*Tsa_family_t)(unsafe.Pointer(out + uintptr(k)*88 + 48)) = uint16(PF_INET6) - *(*Tin_port_t)(unsafe.Pointer(out + uintptr(k)*88 + 48 + 2)) = Xhtons(tls, (*(*[2]Tservice)(unsafe.Pointer(bp)))[j].Fport) - *(*Tuint32_t)(unsafe.Pointer(out + uintptr(k)*88 + 48 + 24)) = (*(*[48]Taddress)(unsafe.Pointer(bp + 8)))[i].Fscopeid + *(*Tin_port_t)(unsafe.Pointer(out + uintptr(k)*88 + 48 + 2)) = Xhtons(tls, (**(**[2]Tservice)(__ccgo_up(bp)))[j].Fport) + *(*Tuint32_t)(unsafe.Pointer(out + uintptr(k)*88 + 48 + 24)) = (**(**[48]Taddress)(__ccgo_up(bp + 8)))[i].Fscopeid Xmemcpy(tls, out+uintptr(k)*88+48+8, bp+8+uintptr(i)*28+8, uint64(16)) break } @@ -120084,8 +120084,8 @@ func Xgetaddrinfo(tls *TLS, host uintptr, serv uintptr, hint uintptr, res uintpt ; i = i + 1 } - (*(*Taibuf)(unsafe.Pointer(out))).Fref = int16(nais) - *(*uintptr)(unsafe.Pointer(res)) = out + (**(**Taibuf)(__ccgo_up(out))).Fref = int16(nais) + **(**uintptr)(__ccgo_up(res)) = out return 0 } @@ -120216,12 +120216,12 @@ func Xgethostbyaddr(tls *TLS, a uintptr, l Tsocklen_t, af int32) (r uintptr) { size = size + (size + uint64(1)) _h = Xmalloc(tls, size) if !(_h != 0) { - *(*int32)(unsafe.Pointer(X__h_errno_location(tls))) = int32(NO_RECOVERY) + **(**int32)(__ccgo_up(X__h_errno_location(tls))) = int32(NO_RECOVERY) return uintptr(0) } err = Xgethostbyaddr_r(tls, a, l, af, _h, _h+UintptrFromInt32(1)*32, size-uint64(32), bp, X__h_errno_location(tls)) } - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } var _h uintptr @@ -120258,7 +120258,7 @@ func Xgethostbyaddr_r(tls *TLS, a uintptr, l Tsocklen_t, af int32, h uintptr, bu v1 = uint64(16) } sl = uint32(v1) - *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) + **(**uintptr)(__ccgo_up(res)) = uintptr(0) /* Load address argument into sockaddr structure */ if af == int32(PF_INET6) && l == uint32(16) { Xmemcpy(tls, bp+8, a, uint64(16)) @@ -120266,7 +120266,7 @@ func Xgethostbyaddr_r(tls *TLS, a uintptr, l Tsocklen_t, af int32, h uintptr, bu if af == int32(PF_INET) && l == uint32(4) { Xmemcpy(tls, bp+4, a, uint64(4)) } else { - *(*int32)(unsafe.Pointer(err)) = int32(NO_RECOVERY) + **(**int32)(__ccgo_up(err)) = int32(NO_RECOVERY) return int32(EINVAL) } } @@ -120284,33 +120284,33 @@ func Xgethostbyaddr_r(tls *TLS, a uintptr, l Tsocklen_t, af int32, h uintptr, bu buf = buf + uintptr(Uint64FromInt32(2)*Uint64FromInt64(8)) (*Thostent)(unsafe.Pointer(h)).Fh_aliases = buf buf = buf + uintptr(Uint64FromInt32(2)*Uint64FromInt64(8)) - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list)) = buf - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list)), a, uint64(l)) + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_addr_list)) = buf + Xmemcpy(tls, **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_addr_list)), a, uint64(l)) buf = buf + uintptr(l) - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + 1*8)) = uintptr(0) - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) = buf - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = uintptr(0) + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + 1*8)) = uintptr(0) + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) = buf + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = uintptr(0) switch Xgetnameinfo(tls, bp, sl, buf, uint32(buflen), uintptr(0), uint32(0), 0) { case -int32(3): - *(*int32)(unsafe.Pointer(err)) = int32(TRY_AGAIN) + **(**int32)(__ccgo_up(err)) = int32(TRY_AGAIN) return int32(EAGAIN) case -int32(12): return int32(ERANGE) default: fallthrough case -int32(4): - *(*int32)(unsafe.Pointer(err)) = int32(NO_RECOVERY) + **(**int32)(__ccgo_up(err)) = int32(NO_RECOVERY) return int32(EBADMSG) case -int32(11): - *(*int32)(unsafe.Pointer(err)) = int32(NO_RECOVERY) - return *(*int32)(unsafe.Pointer(X__errno_location(tls))) + **(**int32)(__ccgo_up(err)) = int32(NO_RECOVERY) + return **(**int32)(__ccgo_up(X__errno_location(tls))) case 0: break } (*Thostent)(unsafe.Pointer(h)).Fh_addrtype = af (*Thostent)(unsafe.Pointer(h)).Fh_length = Int32FromUint32(l) - (*Thostent)(unsafe.Pointer(h)).Fh_name = *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) - *(*uintptr)(unsafe.Pointer(res)) = h + (*Thostent)(unsafe.Pointer(h)).Fh_name = **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) + **(**uintptr)(__ccgo_up(res)) = h return 0 } @@ -120339,12 +120339,12 @@ func Xgethostbyname2(tls *TLS, name uintptr, af int32) (r uintptr) { size = size + (size + uint64(1)) _h1 = Xmalloc(tls, size) if !(_h1 != 0) { - *(*int32)(unsafe.Pointer(X__h_errno_location(tls))) = int32(NO_RECOVERY) + **(**int32)(__ccgo_up(X__h_errno_location(tls))) = int32(NO_RECOVERY) return uintptr(0) } err = Xgethostbyname2_r(tls, name, af, _h1, _h1+UintptrFromInt32(1)*32, size-uint64(32), bp, X__h_errno_location(tls)) } - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } var _h1 uintptr @@ -120362,27 +120362,27 @@ func Xgethostbyname2_r(tls *TLS, name uintptr, af int32, h uintptr, buf uintptr, var _ /* addrs at bp+0 */ [48]Taddress var _ /* canon at bp+1344 */ [256]uint8 _, _, _, _, _, _ = align, cnt, i, need, v1, v3 - *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) + **(**uintptr)(__ccgo_up(res)) = uintptr(0) cnt = X__lookup_name(tls, bp, bp+1344, name, af, int32(AI_CANONNAME)) if cnt < 0 { switch cnt { case -int32(2): - *(*int32)(unsafe.Pointer(err)) = int32(HOST_NOT_FOUND) + **(**int32)(__ccgo_up(err)) = int32(HOST_NOT_FOUND) return 0 case -int32(5): - *(*int32)(unsafe.Pointer(err)) = int32(NO_DATA) + **(**int32)(__ccgo_up(err)) = int32(NO_DATA) return 0 case -int32(3): - *(*int32)(unsafe.Pointer(err)) = int32(TRY_AGAIN) + **(**int32)(__ccgo_up(err)) = int32(TRY_AGAIN) return int32(EAGAIN) default: fallthrough case -int32(4): - *(*int32)(unsafe.Pointer(err)) = int32(NO_RECOVERY) + **(**int32)(__ccgo_up(err)) = int32(NO_RECOVERY) return int32(EBADMSG) case -int32(11): - *(*int32)(unsafe.Pointer(err)) = int32(NO_RECOVERY) - return *(*int32)(unsafe.Pointer(X__errno_location(tls))) + **(**int32)(__ccgo_up(err)) = int32(NO_RECOVERY) + return **(**int32)(__ccgo_up(X__errno_location(tls))) } } (*Thostent)(unsafe.Pointer(h)).Fh_addrtype = af @@ -120412,29 +120412,29 @@ func Xgethostbyname2_r(tls *TLS, name uintptr, af int32, h uintptr, buf uintptr, if !(i < cnt) { break } - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)) = buf + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)) = buf buf = buf + uintptr((*Thostent)(unsafe.Pointer(h)).Fh_length) - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)), bp+uintptr(i)*28+8, Uint64FromInt32((*Thostent)(unsafe.Pointer(h)).Fh_length)) + Xmemcpy(tls, **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)), bp+uintptr(i)*28+8, Uint64FromInt32((*Thostent)(unsafe.Pointer(h)).Fh_length)) goto _2 _2: ; i = i + 1 } - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)) = uintptr(0) + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)) = uintptr(0) v3 = buf - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) = v3 + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) = v3 (*Thostent)(unsafe.Pointer(h)).Fh_name = v3 Xstrcpy(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name, bp+1344) buf = buf + uintptr(_strlen(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name)+uint64(1)) if Xstrcmp(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name, name) != 0 { - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = buf - Xstrcpy(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)), name) - buf = buf + uintptr(_strlen(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)))+uint64(1)) + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = buf + Xstrcpy(tls, **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)), name) + buf = buf + uintptr(_strlen(tls, **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)))+uint64(1)) } else { - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = uintptr(0) + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = uintptr(0) } - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 2*8)) = uintptr(0) - *(*uintptr)(unsafe.Pointer(res)) = h + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 2*8)) = uintptr(0) + **(**uintptr)(__ccgo_up(res)) = h return 0 } @@ -120663,7 +120663,7 @@ func _copy_addr(tls *TLS, r uintptr, af int32, sa uintptr, addr uintptr, addrlen case int32(PF_INET6): dst = sa + 8 len1 = int32(16) - if Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(addr))) == int32(0xfe) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(addr + 1)))&int32(0xc0) == int32(0x80) || Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(addr))) == int32(0xff) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(addr + 1)))&int32(0xf) == int32(0x2) { + if Int32FromUint8(**(**Tuint8_t)(__ccgo_up(addr))) == int32(0xfe) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(addr + 1)))&int32(0xc0) == int32(0x80) || Int32FromUint8(**(**Tuint8_t)(__ccgo_up(addr))) == int32(0xff) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(addr + 1)))&int32(0xf) == int32(0x2) { (*(*Tsockaddr_in6)(unsafe.Pointer(sa))).Fsin6_scope_id = Uint32FromInt32(ifindex) } default: @@ -120674,7 +120674,7 @@ func _copy_addr(tls *TLS, r uintptr, af int32, sa uintptr, addr uintptr, addrlen } (*Tsockany)(unsafe.Pointer(sa)).Fsa.Fsa_family = Uint16FromInt32(af) Xmemcpy(tls, dst, addr, Uint64FromInt32(len1)) - *(*uintptr)(unsafe.Pointer(r)) = sa + **(**uintptr)(__ccgo_up(r)) = sa } func _gen_netmask(tls *TLS, r uintptr, af int32, sa uintptr, prefixlen int32) { @@ -120683,7 +120683,7 @@ func _gen_netmask(tls *TLS, r uintptr, af int32, sa uintptr, prefixlen int32) { var i, v1 int32 var _ /* addr at bp+0 */ [16]Tuint8_t _, _ = i, v1 - *(*[16]Tuint8_t)(unsafe.Pointer(bp)) = [16]Tuint8_t{} + **(**[16]Tuint8_t)(__ccgo_up(bp)) = [16]Tuint8_t{} if Uint64FromInt32(prefixlen) > Uint64FromInt32(8)*Uint64FromInt64(16) { prefixlen = Int32FromUint64(Uint64FromInt32(8) * Uint64FromInt64(16)) } @@ -120692,7 +120692,7 @@ func _gen_netmask(tls *TLS, r uintptr, af int32, sa uintptr, prefixlen int32) { if Uint64FromInt32(i) < uint64(16) { v1 = i i = i + 1 - (*(*[16]Tuint8_t)(unsafe.Pointer(bp)))[v1] = Uint8FromInt32(int32(0xff) << (int32(8) - prefixlen%int32(8))) + (**(**[16]Tuint8_t)(__ccgo_up(bp)))[v1] = Uint8FromInt32(int32(0xff) << (int32(8) - prefixlen%int32(8))) } _copy_addr(tls, r, af, sa, bp, uint64(16), 0) } @@ -120706,7 +120706,7 @@ func _copy_lladdr(tls *TLS, r uintptr, sa uintptr, addr uintptr, addrlen Tsize_t (*(*Tsockaddr_ll_hack)(unsafe.Pointer(sa))).Fsll_hatype = hatype (*(*Tsockaddr_ll_hack)(unsafe.Pointer(sa))).Fsll_halen = uint8(addrlen) Xmemcpy(tls, sa+12, addr, addrlen) - *(*uintptr)(unsafe.Pointer(r)) = sa + **(**uintptr)(__ccgo_up(r)) = sa } func _netlink_msg_to_ifaddr(tls *TLS, pctx uintptr, h uintptr) (r int32) { @@ -120735,7 +120735,7 @@ func _netlink_msg_to_ifaddr(tls *TLS, pctx uintptr, h uintptr) (r int32) { rta = rta + uintptr((Int32FromUint16((*Trtattr)(unsafe.Pointer(rta)).Frta_len)+Int32FromInt32(3)) & ^Int32FromInt32(3)) } } else { - ifs0 = *(*uintptr)(unsafe.Pointer(ctx + 16 + uintptr((*Tifaddrmsg)(unsafe.Pointer(ifa)).Fifa_index%uint32(IFADDRS_HASH_SIZE))*8)) + ifs0 = **(**uintptr)(__ccgo_up(ctx + 16 + uintptr((*Tifaddrmsg)(unsafe.Pointer(ifa)).Fifa_index%uint32(IFADDRS_HASH_SIZE))*8)) for { if !(ifs0 != 0) { break @@ -120786,8 +120786,8 @@ func _netlink_msg_to_ifaddr(tls *TLS, pctx uintptr, h uintptr) (r int32) { } if (*Tifaddrs_storage)(unsafe.Pointer(ifs)).Fifa.Fifa_name != 0 { bucket = (*Tifaddrs_storage)(unsafe.Pointer(ifs)).Findex % uint32(IFADDRS_HASH_SIZE) - (*Tifaddrs_storage)(unsafe.Pointer(ifs)).Fhash_next = *(*uintptr)(unsafe.Pointer(ctx + 16 + uintptr(bucket)*8)) - *(*uintptr)(unsafe.Pointer(ctx + 16 + uintptr(bucket)*8)) = ifs + (*Tifaddrs_storage)(unsafe.Pointer(ifs)).Fhash_next = **(**uintptr)(__ccgo_up(ctx + 16 + uintptr(bucket)*8)) + **(**uintptr)(__ccgo_up(ctx + 16 + uintptr(bucket)*8)) = ifs } } else { (*Tifaddrs_storage)(unsafe.Pointer(ifs)).Fifa.Fifa_name = (*Tifaddrs_storage)(unsafe.Pointer(ifs0)).Fifa.Fifa_name @@ -120862,7 +120862,7 @@ func Xgetifaddrs(tls *TLS, ifap uintptr) (r1 int32) { Xmemset(tls, ctx, 0, uint64(528)) r = X__rtnetlink_enumerate(tls, PF_UNSPEC, PF_UNSPEC, __ccgo_fp(_netlink_msg_to_ifaddr), ctx) if r == 0 { - *(*uintptr)(unsafe.Pointer(ifap)) = (*Tifaddrs_ctx)(unsafe.Pointer(ctx)).Ffirst + **(**uintptr)(__ccgo_up(ifap)) = (*Tifaddrs_ctx)(unsafe.Pointer(ctx)).Ffirst } else { Xfreeifaddrs(tls, (*Tifaddrs_ctx)(unsafe.Pointer(ctx)).Ffirst) } @@ -120877,11 +120877,11 @@ func _itoa(tls *TLS, p uintptr, x uint32) (r uintptr) { p = p + uintptr(Uint64FromInt32(3)*Uint64FromInt64(4)) p = p - 1 v1 = p - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) for cond := true; cond; cond = x != 0 { p = p - 1 v1 = p - *(*uint8)(unsafe.Pointer(v1)) = uint8(uint32('0') + x%uint32(10)) + **(**uint8)(__ccgo_up(v1)) = uint8(uint32('0') + x%uint32(10)) x = x / uint32(10) } return p @@ -120890,7 +120890,7 @@ func _itoa(tls *TLS, p uintptr, x uint32) (r uintptr) { func _mkptr4(tls *TLS, s uintptr, ip uintptr) { bp := tls.Alloc(48) defer tls.Free(48) - Xsprintf(tls, s, __ccgo_ts+1024, VaList(bp+8, Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + 3))), Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + 2))), Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + 1))), Int32FromUint8(*(*uint8)(unsafe.Pointer(ip))))) + Xsprintf(tls, s, __ccgo_ts+1024, VaList(bp+8, Int32FromUint8(**(**uint8)(__ccgo_up(ip + 3))), Int32FromUint8(**(**uint8)(__ccgo_up(ip + 2))), Int32FromUint8(**(**uint8)(__ccgo_up(ip + 1))), Int32FromUint8(**(**uint8)(__ccgo_up(ip))))) } func _mkptr6(tls *TLS, s uintptr, ip uintptr) { @@ -120904,16 +120904,16 @@ func _mkptr6(tls *TLS, s uintptr, ip uintptr) { } v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = _xdigits[Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + uintptr(i))))&int32(15)] + **(**uint8)(__ccgo_up(v2)) = _xdigits[Int32FromUint8(**(**uint8)(__ccgo_up(ip + uintptr(i))))&int32(15)] v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8('.') + **(**uint8)(__ccgo_up(v2)) = uint8('.') v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = _xdigits[Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + uintptr(i))))>>int32(4)] + **(**uint8)(__ccgo_up(v2)) = _xdigits[Int32FromUint8(**(**uint8)(__ccgo_up(ip + uintptr(i))))>>int32(4)] v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8('.') + **(**uint8)(__ccgo_up(v2)) = uint8('.') goto _1 _1: ; @@ -120951,13 +120951,13 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int if v1 != 0 { v2 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8('\n') - *(*uint8)(unsafe.Pointer(p)) = Uint8FromInt32(0) + **(**uint8)(__ccgo_up(v2)) = uint8('\n') + **(**uint8)(__ccgo_up(p)) = Uint8FromInt32(0) } p = bp for { - if v7 = *(*uint8)(unsafe.Pointer(p)) != 0; v7 { - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + if v7 = **(**uint8)(__ccgo_up(p)) != 0; v7 { + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v5 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _6 _6: @@ -120970,26 +120970,26 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int ; p = p + 1 } - if !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if !(**(**uint8)(__ccgo_up(p)) != 0) { continue } v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) if X__lookup_ipliteral(tls, bp+1560, bp, PF_UNSPEC) <= 0 { continue } - if (*(*Taddress)(unsafe.Pointer(bp + 1560))).Ffamily == int32(PF_INET) { + if (**(**Taddress)(__ccgo_up(bp + 1560))).Ffamily == int32(PF_INET) { Xmemcpy(tls, bp+1560+8+uintptr(12), bp+1560+8, uint64(4)) Xmemcpy(tls, bp+1560+8, __ccgo_ts+1069, uint64(12)) - (*(*Taddress)(unsafe.Pointer(bp + 1560))).Fscopeid = uint32(0) + (**(**Taddress)(__ccgo_up(bp + 1560))).Fscopeid = uint32(0) } - if Xmemcmp(tls, a, bp+1560+8, uint64(16)) != 0 || (*(*Taddress)(unsafe.Pointer(bp + 1560))).Fscopeid != scopeid { + if Xmemcmp(tls, a, bp+1560+8, uint64(16)) != 0 || (**(**Taddress)(__ccgo_up(bp + 1560))).Fscopeid != scopeid { continue } for { - if v7 = *(*uint8)(unsafe.Pointer(p)) != 0; v7 { - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + if v7 = **(**uint8)(__ccgo_up(p)) != 0; v7 { + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v5 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _12 _12: @@ -121004,8 +121004,8 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int } z = p for { - if v7 = *(*uint8)(unsafe.Pointer(z)) != 0; v7 { - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(z))) + if v7 = **(**uint8)(__ccgo_up(z)) != 0; v7 { + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(z))) v5 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _17 _17: @@ -121018,7 +121018,7 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int ; z = z + 1 } - *(*uint8)(unsafe.Pointer(z)) = uint8(0) + **(**uint8)(__ccgo_up(z)) = uint8(0) if int64(z)-int64(p) < int64(256) { Xmemcpy(tls, buf, p, Uint64FromInt64(int64(z)-int64(p)+int64(1))) break @@ -121049,13 +121049,13 @@ func _reverse_services(tls *TLS, buf uintptr, port int32, dgram int32) { if v1 != 0 { v2 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8('\n') - *(*uint8)(unsafe.Pointer(p)) = Uint8FromInt32(0) + **(**uint8)(__ccgo_up(v2)) = uint8('\n') + **(**uint8)(__ccgo_up(p)) = Uint8FromInt32(0) } p = bp for { - if v7 = *(*uint8)(unsafe.Pointer(p)) != 0; v7 { - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + if v7 = **(**uint8)(__ccgo_up(p)) != 0; v7 { + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v5 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _6 _6: @@ -121068,20 +121068,20 @@ func _reverse_services(tls *TLS, buf uintptr, port int32, dgram int32) { ; p = p + 1 } - if !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if !(**(**uint8)(__ccgo_up(p)) != 0) { continue } v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) svport = Xstrtoul(tls, p, bp+128, int32(10)) - if svport != Uint64FromInt32(port) || *(*uintptr)(unsafe.Pointer(bp + 128)) == p { + if svport != Uint64FromInt32(port) || **(**uintptr)(__ccgo_up(bp + 128)) == p { continue } - if dgram != 0 && Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(bp + 128)), __ccgo_ts+1096, uint64(4)) != 0 { + if dgram != 0 && Xstrncmp(tls, **(**uintptr)(__ccgo_up(bp + 128)), __ccgo_ts+1096, uint64(4)) != 0 { continue } - if !(dgram != 0) && Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(bp + 128)), __ccgo_ts+1101, uint64(4)) != 0 { + if !(dgram != 0) && Xstrncmp(tls, **(**uintptr)(__ccgo_up(bp + 128)), __ccgo_ts+1101, uint64(4)) != 0 { continue } if int64(p)-t__predefined_ptrdiff_t(bp) > int64(32) { @@ -121098,7 +121098,7 @@ func _dns_parse_callback(tls *TLS, c uintptr, rr int32, data uintptr, len1 int32 return 0 } if X__dn_expand(tls, packet, packet+uintptr(plen), data, c, int32(256)) <= 0 { - *(*uint8)(unsafe.Pointer(c)) = uint8(0) + **(**uint8)(__ccgo_up(c)) = uint8(0) } return 0 } @@ -121144,15 +121144,15 @@ func Xgetnameinfo(tls *TLS, sa uintptr, sl Tsocklen_t, node uintptr, nodelen Tso return -int32(6) } if node != 0 && nodelen != 0 { - (*(*[256]uint8)(unsafe.Pointer(bp + 78)))[0] = uint8(0) + (**(**[256]uint8)(__ccgo_up(bp + 78)))[0] = uint8(0) if !(flags&Int32FromInt32(NI_NUMERICHOST) != 0) { _reverse_hosts(tls, bp+78, a, scopeid, af) } - if !(*(*uint8)(unsafe.Pointer(bp + 78)) != 0) && !(flags&Int32FromInt32(NI_NUMERICHOST) != 0) { + if !(**(**uint8)(__ccgo_up(bp + 78)) != 0) && !(flags&Int32FromInt32(NI_NUMERICHOST) != 0) { qlen = X__res_mkquery(tls, 0, bp, int32(1), int32(RR_PTR), uintptr(0), 0, uintptr(0), bp+347, int32(96)) - (*(*[96]uint8)(unsafe.Pointer(bp + 347)))[int32(3)] = uint8(0) /* don't need AD flag */ + (**(**[96]uint8)(__ccgo_up(bp + 347)))[int32(3)] = uint8(0) /* don't need AD flag */ rlen = X__res_send(tls, bp+347, qlen, bp+443, int32(512)) - (*(*[256]uint8)(unsafe.Pointer(bp + 78)))[0] = uint8(0) + (**(**[256]uint8)(__ccgo_up(bp + 78)))[0] = uint8(0) if rlen > 0 { if Uint64FromInt32(rlen) > uint64(512) { rlen = int32(512) @@ -121160,14 +121160,14 @@ func Xgetnameinfo(tls *TLS, sa uintptr, sl Tsocklen_t, node uintptr, nodelen Tso X__dns_parse(tls, bp+443, rlen, __ccgo_fp(_dns_parse_callback), bp+78) } } - if !(*(*uint8)(unsafe.Pointer(bp + 78)) != 0) { + if !(**(**uint8)(__ccgo_up(bp + 78)) != 0) { if flags&int32(NI_NAMEREQD) != 0 { return -int32(2) } Xinet_ntop(tls, af, a, bp+78, uint32(256)) if scopeid != 0 { p = uintptr(0) - if !(flags&Int32FromInt32(NI_NUMERICSCOPE) != 0) && (Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a))) == int32(0xfe) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 1)))&int32(0xc0) == int32(0x80) || Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a))) == int32(0xff) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 1)))&int32(0xf) == int32(0x2)) { + if !(flags&Int32FromInt32(NI_NUMERICSCOPE) != 0) && (Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a))) == int32(0xfe) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 1)))&int32(0xc0) == int32(0x80) || Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a))) == int32(0xff) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 1)))&int32(0xf) == int32(0x2)) { p = Xif_indextoname(tls, scopeid, bp+955+uintptr(1)) } if !(p != 0) { @@ -121175,7 +121175,7 @@ func Xgetnameinfo(tls *TLS, sa uintptr, sl Tsocklen_t, node uintptr, nodelen Tso } p = p - 1 v1 = p - *(*uint8)(unsafe.Pointer(v1)) = uint8('%') + **(**uint8)(__ccgo_up(v1)) = uint8('%') Xstrcat(tls, bp+78, p) } } @@ -121187,11 +121187,11 @@ func Xgetnameinfo(tls *TLS, sa uintptr, sl Tsocklen_t, node uintptr, nodelen Tso if serv != 0 && servlen != 0 { p1 = bp + 78 port = Int32FromUint16(Xntohs(tls, (*Tsockaddr_in)(unsafe.Pointer(sa)).Fsin_port)) - (*(*[256]uint8)(unsafe.Pointer(bp + 78)))[0] = uint8(0) + (**(**[256]uint8)(__ccgo_up(bp + 78)))[0] = uint8(0) if !(flags&Int32FromInt32(NI_NUMERICSERV) != 0) { _reverse_services(tls, bp+78, port, flags&int32(NI_DGRAM)) } - if !(*(*uint8)(unsafe.Pointer(p1)) != 0) { + if !(**(**uint8)(__ccgo_up(p1)) != 0) { p1 = _itoa(tls, bp+334, Uint32FromInt32(port)) } if _strlen(tls, p1) >= uint64(servlen) { @@ -121290,11 +121290,11 @@ func Xgetservbyname_r(tls *TLS, name uintptr, prots uintptr, se uintptr, buf uin var _ /* end at bp+8 */ uintptr var _ /* servs at bp+0 */ [2]Tservice _, _, _, _ = align, cnt, proto, v1 - *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) + **(**uintptr)(__ccgo_up(res)) = uintptr(0) /* Don't treat numeric port number strings as service records. */ - *(*uintptr)(unsafe.Pointer(bp + 8)) = __ccgo_ts + **(**uintptr)(__ccgo_up(bp + 8)) = __ccgo_ts Xstrtoul(tls, name, bp+8, int32(10)) - if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) != 0) { + if !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) != 0) { return int32(ENOENT) } /* Align buffer */ @@ -121329,16 +121329,16 @@ func Xgetservbyname_r(tls *TLS, name uintptr, prots uintptr, se uintptr, buf uin } (*Tservent)(unsafe.Pointer(se)).Fs_name = name (*Tservent)(unsafe.Pointer(se)).Fs_aliases = buf - *(*uintptr)(unsafe.Pointer((*Tservent)(unsafe.Pointer(se)).Fs_aliases)) = (*Tservent)(unsafe.Pointer(se)).Fs_name - *(*uintptr)(unsafe.Pointer((*Tservent)(unsafe.Pointer(se)).Fs_aliases + 1*8)) = uintptr(0) - (*Tservent)(unsafe.Pointer(se)).Fs_port = Int32FromUint16(Xhtons(tls, (*(*[2]Tservice)(unsafe.Pointer(bp)))[0].Fport)) - if Int32FromUint8((*(*[2]Tservice)(unsafe.Pointer(bp)))[0].Fproto) == int32(IPPROTO_TCP) { + **(**uintptr)(__ccgo_up((*Tservent)(unsafe.Pointer(se)).Fs_aliases)) = (*Tservent)(unsafe.Pointer(se)).Fs_name + **(**uintptr)(__ccgo_up((*Tservent)(unsafe.Pointer(se)).Fs_aliases + 1*8)) = uintptr(0) + (*Tservent)(unsafe.Pointer(se)).Fs_port = Int32FromUint16(Xhtons(tls, (**(**[2]Tservice)(__ccgo_up(bp)))[0].Fport)) + if Int32FromUint8((**(**[2]Tservice)(__ccgo_up(bp)))[0].Fproto) == int32(IPPROTO_TCP) { v1 = __ccgo_ts + 1106 } else { v1 = __ccgo_ts + 1110 } (*Tservent)(unsafe.Pointer(se)).Fs_proto = v1 - *(*uintptr)(unsafe.Pointer(res)) = se + **(**uintptr)(__ccgo_up(res)) = se return 0 } @@ -121464,7 +121464,7 @@ _11: if false { break } - if uint64(*(*Tsocklen_t)(unsafe.Pointer(optlen))) < uint64(16) { + if uint64(**(**Tsocklen_t)(__ccgo_up(optlen))) < uint64(16) { return int32(X__syscall_ret(tls, Uint64FromInt32(-Int32FromInt32(EINVAL)))) } if optname == int32(SO_RCVTIMEO) { @@ -121523,9 +121523,9 @@ _11: break } tv = optval - (*Ttimeval)(unsafe.Pointer(tv)).Ftv_sec = (*(*[2]int64)(unsafe.Pointer(bp + 296)))[0] - (*Ttimeval)(unsafe.Pointer(tv)).Ftv_usec = (*(*[2]int64)(unsafe.Pointer(bp + 296)))[int32(1)] - *(*Tsocklen_t)(unsafe.Pointer(optlen)) = uint32(16) + (*Ttimeval)(unsafe.Pointer(tv)).Ftv_sec = (**(**[2]int64)(__ccgo_up(bp + 296)))[0] + (*Ttimeval)(unsafe.Pointer(tv)).Ftv_usec = (**(**[2]int64)(__ccgo_up(bp + 296)))[int32(1)] + **(**Tsocklen_t)(__ccgo_up(optlen)) = uint32(16) case int32(SO_TIMESTAMP): fallthrough case int32(SO_TIMESTAMPNS): @@ -121617,7 +121617,7 @@ func Xherror(tls *TLS, msg uintptr) { } else { v2 = __ccgo_ts } - Xfprintf(tls, uintptr(unsafe.Pointer(&X__stderr_FILE)), __ccgo_ts+1114, VaList(bp+8, v1, v2, Xhstrerror(tls, *(*int32)(unsafe.Pointer(X__h_errno_location(tls)))))) + Xfprintf(tls, uintptr(unsafe.Pointer(&X__stderr_FILE)), __ccgo_ts+1114, VaList(bp+8, v1, v2, Xhstrerror(tls, **(**int32)(__ccgo_up(X__h_errno_location(tls)))))) } var _msgs1 = [84]uint8{'H', 'o', 's', 't', ' ', 'n', 'o', 't', ' ', 'f', 'o', 'u', 'n', 'd', 0, 'T', 'r', 'y', ' ', 'a', 'g', 'a', 'i', 'n', 0, 'N', 'o', 'n', '-', 'r', 'e', 'c', 'o', 'v', 'e', 'r', 'a', 'b', 'l', 'e', ' ', 'e', 'r', 'r', 'o', 'r', 0, 'A', 'd', 'd', 'r', 'e', 's', 's', ' ', 'n', 'o', 't', ' ', 'a', 'v', 'a', 'i', 'l', 'a', 'b', 'l', 'e', 0, 0, 'U', 'n', 'k', 'n', 'o', 'w', 'n', ' ', 'e', 'r', 'r', 'o', 'r'} @@ -121632,11 +121632,11 @@ func Xhstrerror(tls *TLS, ecode int32) (r uintptr) { s = uintptr(unsafe.Pointer(&_msgs1)) ecode = ecode - 1 for { - if !(ecode != 0 && *(*uint8)(unsafe.Pointer(s)) != 0) { + if !(ecode != 0 && **(**uint8)(__ccgo_up(s)) != 0) { break } for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { break } goto _2 @@ -121650,7 +121650,7 @@ func Xhstrerror(tls *TLS, ecode int32) (r uintptr) { ecode = ecode - 1 s = s + 1 } - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { s = s + 1 } return X__lctrans_cur(tls, s) @@ -121738,8 +121738,8 @@ func Xif_indextoname(tls *TLS, index uint32, name uintptr) (r1 uintptr) { r = Xioctl(tls, fd, int32(SIOCGIFNAME), VaList(bp+48, bp)) X__syscall1(tls, int64(SYS_close), int64(fd)) if r < 0 { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENODEV) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENXIO) + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENODEV) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENXIO) } return uintptr(0) } @@ -121792,7 +121792,7 @@ func _netlink_msg_to_nameindex(tls *TLS, pctx uintptr, h uintptr) (r int32) { } /* suppress duplicates */ bucket = index % int32(IFADDRS_HASH_SIZE) - i = *(*uint32)(unsafe.Pointer(ctx + 24 + uintptr(bucket)*4)) + i = **(**uint32)(__ccgo_up(ctx + 24 + uintptr(bucket)*4)) for i != 0 { map1 = (*Tifnameindexctx)(unsafe.Pointer(ctx)).Flist + uintptr(i-uint32(1))*28 if (*Tifnamemap)(unsafe.Pointer(map1)).Findex == Uint32FromInt32(index) && Int32FromUint8((*Tifnamemap)(unsafe.Pointer(map1)).Fnamelen) == namelen && Xmemcmp(tls, map1+9, rta+UintptrFromInt64(4), Uint64FromInt32(namelen)) == 0 { @@ -121821,10 +121821,10 @@ func _netlink_msg_to_nameindex(tls *TLS, pctx uintptr, h uintptr) (r int32) { (*Tifnamemap)(unsafe.Pointer(map1)).Findex = Uint32FromInt32(index) (*Tifnamemap)(unsafe.Pointer(map1)).Fnamelen = Uint8FromInt32(namelen) Xmemcpy(tls, map1+9, rta+UintptrFromInt64(4), Uint64FromInt32(namelen)) - *(*uint32)(unsafe.Pointer(ctx + 8)) += Uint32FromInt32(namelen + int32(1)) + **(**uint32)(__ccgo_up(ctx + 8)) += Uint32FromInt32(namelen + int32(1)) (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum = (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum + 1 - (*Tifnamemap)(unsafe.Pointer(map1)).Fhash_next = *(*uint32)(unsafe.Pointer(ctx + 24 + uintptr(bucket)*4)) - *(*uint32)(unsafe.Pointer(ctx + 24 + uintptr(bucket)*4)) = (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum + (*Tifnamemap)(unsafe.Pointer(map1)).Fhash_next = **(**uint32)(__ccgo_up(ctx + 24 + uintptr(bucket)*4)) + **(**uint32)(__ccgo_up(ctx + 24 + uintptr(bucket)*4)) = (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum return 0 goto _1 _1: @@ -121871,7 +121871,7 @@ func Xif_nameindex(tls *TLS) (r uintptr) { p = p + uintptr((*Tifnamemap)(unsafe.Pointer(s)).Fnamelen) v2 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8(0) + **(**uint8)(__ccgo_up(v2)) = uint8(0) goto _1 _1: ; @@ -121884,9 +121884,9 @@ func Xif_nameindex(tls *TLS) (r uintptr) { goto err err: ; - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 280)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 280)), uintptr(0)) Xfree(tls, (*Tifnameindexctx)(unsafe.Pointer(ctx)).Flist) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOBUFS) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOBUFS) return ifs } @@ -121927,7 +121927,7 @@ func Xinet_addr(tls *TLS, p uintptr) (r Tin_addr_t) { if !(X__inet_aton(tls, p, bp) != 0) { return Uint32FromInt32(-Int32FromInt32(1)) } - return (*(*Tin_addr)(unsafe.Pointer(bp))).Fs_addr + return (**(**Tin_addr)(__ccgo_up(bp))).Fs_addr } func X__inet_aton(tls *TLS, s0 uintptr, dest uintptr) (r int32) { @@ -121944,20 +121944,20 @@ func X__inet_aton(tls *TLS, s0 uintptr, dest uintptr) (r int32) { _, _, _ = d, i, s s = s0 d = dest - *(*[4]uint64)(unsafe.Pointer(bp)) = [4]uint64{} + **(**[4]uint64)(__ccgo_up(bp)) = [4]uint64{} i = 0 for { if !(i < int32(4)) { break } - (*(*[4]uint64)(unsafe.Pointer(bp)))[i] = Xstrtoul(tls, s, bp+32, 0) - if *(*uintptr)(unsafe.Pointer(bp + 32)) == s || *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32))))) != int32('.') || !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + (**(**[4]uint64)(__ccgo_up(bp)))[i] = Xstrtoul(tls, s, bp+32, 0) + if **(**uintptr)(__ccgo_up(bp + 32)) == s || **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 32)))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 32))))) != int32('.') || !(BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return 0 } - if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)))) != 0) { + if !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 32)))) != 0) { break } - s = *(*uintptr)(unsafe.Pointer(bp + 32)) + uintptr(1) + s = **(**uintptr)(__ccgo_up(bp + 32)) + uintptr(1) goto _1 _1: ; @@ -121968,26 +121968,26 @@ func X__inet_aton(tls *TLS, s0 uintptr, dest uintptr) (r int32) { } switch i { case 0: - (*(*[4]uint64)(unsafe.Pointer(bp)))[int32(1)] = (*(*[4]uint64)(unsafe.Pointer(bp)))[0] & uint64(0xffffff) - *(*uint64)(unsafe.Pointer(bp)) >>= uint64(24) + (**(**[4]uint64)(__ccgo_up(bp)))[int32(1)] = (**(**[4]uint64)(__ccgo_up(bp)))[0] & uint64(0xffffff) + **(**uint64)(__ccgo_up(bp)) >>= uint64(24) fallthrough case int32(1): - (*(*[4]uint64)(unsafe.Pointer(bp)))[int32(2)] = (*(*[4]uint64)(unsafe.Pointer(bp)))[int32(1)] & uint64(0xffff) - *(*uint64)(unsafe.Pointer(bp + 1*8)) >>= uint64(16) + (**(**[4]uint64)(__ccgo_up(bp)))[int32(2)] = (**(**[4]uint64)(__ccgo_up(bp)))[int32(1)] & uint64(0xffff) + **(**uint64)(__ccgo_up(bp + 1*8)) >>= uint64(16) fallthrough case int32(2): - (*(*[4]uint64)(unsafe.Pointer(bp)))[int32(3)] = (*(*[4]uint64)(unsafe.Pointer(bp)))[int32(2)] & uint64(0xff) - *(*uint64)(unsafe.Pointer(bp + 2*8)) >>= uint64(8) + (**(**[4]uint64)(__ccgo_up(bp)))[int32(3)] = (**(**[4]uint64)(__ccgo_up(bp)))[int32(2)] & uint64(0xff) + **(**uint64)(__ccgo_up(bp + 2*8)) >>= uint64(8) } i = 0 for { if !(i < int32(4)) { break } - if (*(*[4]uint64)(unsafe.Pointer(bp)))[i] > uint64(255) { + if (**(**[4]uint64)(__ccgo_up(bp)))[i] > uint64(255) { return 0 } - *(*uint8)(unsafe.Pointer(d + uintptr(i))) = uint8((*(*[4]uint64)(unsafe.Pointer(bp)))[i]) + **(**uint8)(__ccgo_up(d + uintptr(i))) = uint8((**(**[4]uint64)(__ccgo_up(bp)))[i]) goto _2 _2: ; @@ -122076,7 +122076,7 @@ func Xinet_ntoa(tls *TLS, _in Tin_addr) (r uintptr) { var a uintptr _ = a a = bp - Xsnprintf(tls, uintptr(unsafe.Pointer(&_buf4)), uint64(16), __ccgo_ts+1122, VaList(bp+16, Int32FromUint8(*(*uint8)(unsafe.Pointer(a))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 1))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 2))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 3))))) + Xsnprintf(tls, uintptr(unsafe.Pointer(&_buf4)), uint64(16), __ccgo_ts+1122, VaList(bp+16, Int32FromUint8(**(**uint8)(__ccgo_up(a))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 1))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 2))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 3))))) return uintptr(unsafe.Pointer(&_buf4)) } @@ -122097,14 +122097,14 @@ func Xinet_ntop(tls *TLS, af int32, a0 uintptr, s uintptr, l Tsocklen_t) (r uint a = a0 switch af { case int32(PF_INET): - if Uint32FromInt32(Xsnprintf(tls, s, uint64(l), __ccgo_ts+1122, VaList(bp+112, Int32FromUint8(*(*uint8)(unsafe.Pointer(a))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 1))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 2))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 3)))))) < l { + if Uint32FromInt32(Xsnprintf(tls, s, uint64(l), __ccgo_ts+1122, VaList(bp+112, Int32FromUint8(**(**uint8)(__ccgo_up(a))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 1))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 2))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 3)))))) < l { return s } case int32(PF_INET6): if Xmemcmp(tls, a, __ccgo_ts+1069, uint64(12)) != 0 { - Xsnprintf(tls, bp, uint64(100), __ccgo_ts+1134, VaList(bp+112, int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 1))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 2)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 3))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 4)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 5))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 6)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 7))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 8)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 9))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 10)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 11))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 12)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 13))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 14)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 15))))) + Xsnprintf(tls, bp, uint64(100), __ccgo_ts+1134, VaList(bp+112, int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 1))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 2)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 3))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 4)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 5))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 6)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 7))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 8)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 9))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 10)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 11))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 12)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 13))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 14)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 15))))) } else { - Xsnprintf(tls, bp, uint64(100), __ccgo_ts+1158, VaList(bp+112, int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 1))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 2)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 3))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 4)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 5))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 6)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 7))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 8)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 9))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 10)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 11))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 12))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 13))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 14))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 15))))) + Xsnprintf(tls, bp, uint64(100), __ccgo_ts+1158, VaList(bp+112, int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 1))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 2)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 3))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 4)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 5))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 6)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 7))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 8)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 9))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 10)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 11))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 12))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 13))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 14))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 15))))) } /* Replace longest /(^0|:)[:0]{2,}/ with "::" */ v2 = Int32FromInt32(0) @@ -122112,10 +122112,10 @@ func Xinet_ntop(tls *TLS, af int32, a0 uintptr, s uintptr, l Tsocklen_t) (r uint i = v2 max = Int32FromInt32(2) for { - if !((*(*[100]uint8)(unsafe.Pointer(bp)))[i] != 0) { + if !((**(**[100]uint8)(__ccgo_up(bp)))[i] != 0) { break } - if i != 0 && Int32FromUint8((*(*[100]uint8)(unsafe.Pointer(bp)))[i]) != int32(':') { + if i != 0 && Int32FromUint8((**(**[100]uint8)(__ccgo_up(bp)))[i]) != int32(':') { goto _1 } j = Int32FromUint64(Xstrspn(tls, bp+uintptr(i), __ccgo_ts+1188)) @@ -122130,8 +122130,8 @@ func Xinet_ntop(tls *TLS, af int32, a0 uintptr, s uintptr, l Tsocklen_t) (r uint } if max > int32(3) { v3 = Uint8FromUint8(':') - (*(*[100]uint8)(unsafe.Pointer(bp)))[best+int32(1)] = v3 - (*(*[100]uint8)(unsafe.Pointer(bp)))[best] = v3 + (**(**[100]uint8)(__ccgo_up(bp)))[best+int32(1)] = v3 + (**(**[100]uint8)(__ccgo_up(bp)))[best] = v3 Xmemmove(tls, bp+uintptr(best)+uintptr(2), bp+uintptr(best)+uintptr(max), Uint64FromInt32(i-best-max+int32(1))) } if _strlen(tls, bp) < uint64(l) { @@ -122139,10 +122139,10 @@ func Xinet_ntop(tls *TLS, af int32, a0 uintptr, s uintptr, l Tsocklen_t) (r uint return s } default: - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EAFNOSUPPORT) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EAFNOSUPPORT) return uintptr(0) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOSPC) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOSPC) return uintptr(0) } @@ -122182,23 +122182,23 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { j = v3 v = v3 for { - if !(j < int32(3) && BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s + uintptr(j))))-uint32('0') < uint32(10)) != 0) { + if !(j < int32(3) && BoolInt32(uint32(**(**uint8)(__ccgo_up(s + uintptr(j))))-uint32('0') < uint32(10)) != 0) { break } - v = int32(10)*v + Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(j)))) - int32('0') + v = int32(10)*v + Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(j)))) - int32('0') goto _2 _2: ; j = j + 1 } - if j == 0 || j > int32(1) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('0') || v > int32(255) { + if j == 0 || j > int32(1) && Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('0') || v > int32(255) { return 0 } - *(*uint8)(unsafe.Pointer(a + uintptr(i))) = Uint8FromInt32(v) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(j)))) == 0 && i == int32(3) { + **(**uint8)(__ccgo_up(a + uintptr(i))) = Uint8FromInt32(v) + if Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(j)))) == 0 && i == int32(3) { return int32(1) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(j)))) != int32('.') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(j)))) != int32('.') { return 0 } s = s + uintptr(j+int32(1)) @@ -122210,25 +122210,25 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { return 0 } else { if af != int32(PF_INET6) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EAFNOSUPPORT) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EAFNOSUPPORT) return -int32(1) } } - if v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32(':'); v5 { + if v5 = Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32(':'); v5 { s = s + 1 v4 = s } - if v5 && Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) != int32(':') { + if v5 && Int32FromUint8(**(**uint8)(__ccgo_up(v4))) != int32(':') { return 0 } i = 0 for { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32(':') && brk < 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32(':') && brk < 0 { brk = i - (*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[i&int32(7)] = uint16(0) + (**(**[8]Tuint16_t)(__ccgo_up(bp)))[i&int32(7)] = uint16(0) s = s + 1 v4 = s - if !(*(*uint8)(unsafe.Pointer(v4)) != 0) { + if !(**(**uint8)(__ccgo_up(v4)) != 0) { break } if i == int32(7) { @@ -122241,7 +122241,7 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { v = v3 for { if v5 = j < int32(4); v5 { - v9 = _hexval(tls, uint32(*(*uint8)(unsafe.Pointer(s + uintptr(j))))) + v9 = _hexval(tls, uint32(**(**uint8)(__ccgo_up(s + uintptr(j))))) d = v9 } if !(v5 && v9 >= 0) { @@ -122256,20 +122256,20 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { if j == 0 { return 0 } - (*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[i&int32(7)] = Uint16FromInt32(v) - if !(*(*uint8)(unsafe.Pointer(s + uintptr(j))) != 0) && (brk >= 0 || i == int32(7)) { + (**(**[8]Tuint16_t)(__ccgo_up(bp)))[i&int32(7)] = Uint16FromInt32(v) + if !(**(**uint8)(__ccgo_up(s + uintptr(j))) != 0) && (brk >= 0 || i == int32(7)) { break } if i == int32(7) { return 0 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(j)))) != int32(':') { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(j)))) != int32('.') || i < int32(6) && brk < 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(j)))) != int32(':') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(j)))) != int32('.') || i < int32(6) && brk < 0 { return 0 } need_v4 = int32(1) i = i + 1 - (*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[i&int32(7)] = uint16(0) + (**(**[8]Tuint16_t)(__ccgo_up(bp)))[i&int32(7)] = uint16(0) break } s = s + uintptr(j+int32(1)) @@ -122285,7 +122285,7 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { if !(j < int32(7)-i) { break } - (*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[brk+j] = uint16(0) + (**(**[8]Tuint16_t)(__ccgo_up(bp)))[brk+j] = uint16(0) goto _12 _12: ; @@ -122299,10 +122299,10 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { } v4 = a a = a + 1 - *(*uint8)(unsafe.Pointer(v4)) = Uint8FromInt32(Int32FromUint16((*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[j]) >> int32(8)) + **(**uint8)(__ccgo_up(v4)) = Uint8FromInt32(Int32FromUint16((**(**[8]Tuint16_t)(__ccgo_up(bp)))[j]) >> int32(8)) v4 = a a = a + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8((*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[j]) + **(**uint8)(__ccgo_up(v4)) = uint8((**(**[8]Tuint16_t)(__ccgo_up(bp)))[j]) goto _13 _13: ; @@ -122389,15 +122389,15 @@ func X__lookup_ipliteral(tls *TLS, buf uintptr, name uintptr, family int32) (r i return -int32(5) } Xmemcpy(tls, buf+8, bp, uint64(4)) - (*(*Taddress)(unsafe.Pointer(buf))).Ffamily = int32(PF_INET) - (*(*Taddress)(unsafe.Pointer(buf))).Fscopeid = uint32(0) + (**(**Taddress)(__ccgo_up(buf))).Ffamily = int32(PF_INET) + (**(**Taddress)(__ccgo_up(buf))).Fscopeid = uint32(0) return int32(1) } p = Xstrchr(tls, name, int32('%')) scopeid = uint64(0) if p != 0 && int64(p)-int64(name) < int64(64) { Xmemcpy(tls, bp+20, name, Uint64FromInt64(int64(p)-int64(name))) - (*(*[64]uint8)(unsafe.Pointer(bp + 20)))[int64(p)-int64(name)] = uint8(0) + (**(**[64]uint8)(__ccgo_up(bp + 20)))[int64(p)-int64(name)] = uint8(0) name = bp + 20 } if Xinet_pton(tls, int32(PF_INET6), name, bp+4) <= 0 { @@ -122407,17 +122407,17 @@ func X__lookup_ipliteral(tls *TLS, buf uintptr, name uintptr, family int32) (r i return -int32(5) } Xmemcpy(tls, buf+8, bp+4, uint64(16)) - (*(*Taddress)(unsafe.Pointer(buf))).Ffamily = int32(PF_INET6) + (**(**Taddress)(__ccgo_up(buf))).Ffamily = int32(PF_INET6) if p != 0 { p = p + 1 v1 = p - if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(v1)))-uint32('0') < uint32(10)) != 0 { + if BoolInt32(uint32(**(**uint8)(__ccgo_up(v1)))-uint32('0') < uint32(10)) != 0 { scopeid = Xstrtoull(tls, p, bp+88, int32(10)) } else { - *(*uintptr)(unsafe.Pointer(bp + 88)) = p - uintptr(1) + **(**uintptr)(__ccgo_up(bp + 88)) = p - uintptr(1) } - if *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 88)))) != 0 { - if !(Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(bp + 4))) == int32(0xfe) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(bp + 4 + 1)))&int32(0xc0) == int32(0x80)) && !(Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(bp + 4))) == int32(0xff) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(bp + 4 + 1)))&int32(0xf) == int32(0x2)) { + if **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 88)))) != 0 { + if !(Int32FromUint8(**(**Tuint8_t)(__ccgo_up(bp + 4))) == int32(0xfe) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(bp + 4 + 1)))&int32(0xc0) == int32(0x80)) && !(Int32FromUint8(**(**Tuint8_t)(__ccgo_up(bp + 4))) == int32(0xff) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(bp + 4 + 1)))&int32(0xf) == int32(0x2)) { return -int32(2) } scopeid = uint64(Xif_nametoindex(tls, p)) @@ -122429,7 +122429,7 @@ func X__lookup_ipliteral(tls *TLS, buf uintptr, name uintptr, family int32) (r i return -int32(2) } } - (*(*Taddress)(unsafe.Pointer(buf))).Fscopeid = uint32(scopeid) + (**(**Taddress)(__ccgo_up(buf))).Fscopeid = uint32(scopeid) return int32(1) } @@ -122453,7 +122453,7 @@ func _is_valid_hostname(tls *TLS, host uintptr) (r int32) { } s = host for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) >= int32(0x80) || Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('.') || Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('-') || Xisalnum(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))) != 0) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(s))) >= int32(0x80) || Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('.') || Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('-') || Xisalnum(tls, Int32FromUint8(**(**uint8)(__ccgo_up(s)))) != 0) { break } goto _1 @@ -122461,7 +122461,7 @@ func _is_valid_hostname(tls *TLS, host uintptr) (r int32) { ; s = s + 1 } - return BoolInt32(!(*(*uint8)(unsafe.Pointer(s)) != 0)) + return BoolInt32(!(**(**uint8)(__ccgo_up(s)) != 0)) } func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags int32) (r int32) { @@ -122475,14 +122475,14 @@ func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags in if family != int32(PF_INET6) { v1 = cnt cnt = cnt + 1 - *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ + **(**Taddress)(__ccgo_up(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET), } } if family != int32(PF_INET) { v1 = cnt cnt = cnt + 1 - *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ + **(**Taddress)(__ccgo_up(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET6), } } @@ -122490,7 +122490,7 @@ func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags in if family != int32(PF_INET6) { v1 = cnt cnt = cnt + 1 - *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ + **(**Taddress)(__ccgo_up(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET), Faddr: [16]Tuint8_t{ 0: uint8(127), @@ -122501,7 +122501,7 @@ func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags in if family != int32(PF_INET) { v1 = cnt cnt = cnt + 1 - *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ + **(**Taddress)(__ccgo_up(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET6), Faddr: [16]Tuint8_t{ 15: uint8(1), @@ -122533,7 +122533,7 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family have_canon = 0 f = X__fopen_rb_ca(tls, __ccgo_ts+1058, bp+1544, bp+512, uint64(1032)) if !(f != 0) { - switch *(*int32)(unsafe.Pointer(X__errno_location(tls))) { + switch **(**int32)(__ccgo_up(X__errno_location(tls))) { case int32(ENOENT): fallthrough case int32(ENOTDIR): @@ -122550,21 +122550,21 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family if v1 != 0 { v2 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8('\n') - *(*uint8)(unsafe.Pointer(p)) = Uint8FromInt32(0) + **(**uint8)(__ccgo_up(v2)) = uint8('\n') + **(**uint8)(__ccgo_up(p)) = Uint8FromInt32(0) } p = bp + uintptr(1) for { v1 = Xstrstr(tls, p, name) p = v1 if v12 = v1 != 0; v12 { - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) + v5 = Int32FromUint8(**(**uint8)(__ccgo_up(p + uintptr(-Int32FromInt32(1))))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _7 _7: ; if v11 = !(v6 != 0); !v11 { - v8 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(l)))) + v8 = Int32FromUint8(**(**uint8)(__ccgo_up(p + uintptr(l)))) v9 = BoolInt32(v8 == int32(' ') || Uint32FromInt32(v8)-uint32('\t') < uint32(5)) goto _10 _10: @@ -122584,8 +122584,8 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family /* Isolate IP address to parse */ p = bp for { - if v11 = *(*uint8)(unsafe.Pointer(p)) != 0; v11 { - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + if v11 = **(**uint8)(__ccgo_up(p)) != 0; v11 { + v5 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _16 _16: @@ -122600,7 +122600,7 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family } v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) switch _name_from_numeric(tls, buf+uintptr(cnt)*28, bp, family) { case int32(1): cnt = cnt + 1 @@ -122615,8 +122615,8 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family } /* Extract first name as canonical name */ for { - if v11 = *(*uint8)(unsafe.Pointer(p)) != 0; v11 { - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + if v11 = **(**uint8)(__ccgo_up(p)) != 0; v11 { + v5 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _22 _22: @@ -122631,8 +122631,8 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family } z = p for { - if v11 = *(*uint8)(unsafe.Pointer(z)) != 0; v11 { - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(z))) + if v11 = **(**uint8)(__ccgo_up(z)) != 0; v11 { + v5 = Int32FromUint8(**(**uint8)(__ccgo_up(z))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _27 _27: @@ -122645,7 +122645,7 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family ; z = z + 1 } - *(*uint8)(unsafe.Pointer(z)) = uint8(0) + **(**uint8)(__ccgo_up(z)) = uint8(0) if _is_valid_hostname(tls, p) != 0 { have_canon = int32(1) Xmemcpy(tls, canon, p, Uint64FromInt64(int64(z)-int64(p)+int64(1))) @@ -122700,8 +122700,8 @@ func _dns_parse_callback1(tls *TLS, c uintptr, rr int32, data uintptr, len1 int3 family = int32(PF_INET6) break } - (*(*Taddress)(unsafe.Pointer((*Tdpc_ctx)(unsafe.Pointer(ctx)).Faddrs + uintptr((*Tdpc_ctx)(unsafe.Pointer(ctx)).Fcnt)*28))).Ffamily = family - (*(*Taddress)(unsafe.Pointer((*Tdpc_ctx)(unsafe.Pointer(ctx)).Faddrs + uintptr((*Tdpc_ctx)(unsafe.Pointer(ctx)).Fcnt)*28))).Fscopeid = uint32(0) + (**(**Taddress)(__ccgo_up((*Tdpc_ctx)(unsafe.Pointer(ctx)).Faddrs + uintptr((*Tdpc_ctx)(unsafe.Pointer(ctx)).Fcnt)*28))).Ffamily = family + (**(**Taddress)(__ccgo_up((*Tdpc_ctx)(unsafe.Pointer(ctx)).Faddrs + uintptr((*Tdpc_ctx)(unsafe.Pointer(ctx)).Fcnt)*28))).Fscopeid = uint32(0) v2 = ctx + 16 v1 = *(*int32)(unsafe.Pointer(v2)) *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) + 1 @@ -122722,16 +122722,16 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i var _ /* qlens at bp+10192 */ [2]int32 var _ /* qp at bp+10160 */ [2]uintptr _, _, _ = i, nq, qtypes - *(*[2]uintptr)(unsafe.Pointer(bp + 10160)) = [2]uintptr{ + **(**[2]uintptr)(__ccgo_up(bp + 10160)) = [2]uintptr{ 0: bp, 1: bp + 1*280, } - *(*[2]uintptr)(unsafe.Pointer(bp + 10176)) = [2]uintptr{ + **(**[2]uintptr)(__ccgo_up(bp + 10176)) = [2]uintptr{ 0: bp + 560, 1: bp + 560 + 1*4800, } nq = 0 - *(*Tdpc_ctx)(unsafe.Pointer(bp + 10208)) = Tdpc_ctx{ + **(**Tdpc_ctx)(__ccgo_up(bp + 10208)) = Tdpc_ctx{ Faddrs: buf, Fcanon: canon, } @@ -122741,15 +122741,15 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i break } if family != _afrr[i].Faf { - (*(*[2]int32)(unsafe.Pointer(bp + 10192)))[nq] = X__res_mkquery(tls, 0, name, int32(1), _afrr[i].Frr, uintptr(0), 0, uintptr(0), bp+uintptr(nq)*280, int32(280)) - if (*(*[2]int32)(unsafe.Pointer(bp + 10192)))[nq] == -int32(1) { + (**(**[2]int32)(__ccgo_up(bp + 10192)))[nq] = X__res_mkquery(tls, 0, name, int32(1), _afrr[i].Frr, uintptr(0), 0, uintptr(0), bp+uintptr(nq)*280, int32(280)) + if (**(**[2]int32)(__ccgo_up(bp + 10192)))[nq] == -int32(1) { return 0 } qtypes[nq] = _afrr[i].Frr - *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280 + 3)) = uint8(0) /* don't need AD flag */ + **(**uint8)(__ccgo_up(bp + uintptr(nq)*280 + 3)) = uint8(0) /* don't need AD flag */ /* Ensure query IDs are distinct. */ - if nq != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) { - *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280)) = *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280)) + 1 + if nq != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(bp + uintptr(nq)*280))) == Int32FromUint8(**(**uint8)(__ccgo_up(bp))) { + **(**uint8)(__ccgo_up(bp + uintptr(nq)*280)) = **(**uint8)(__ccgo_up(bp + uintptr(nq)*280)) + 1 } nq = nq + 1 } @@ -122766,13 +122766,13 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if !(i < nq) { break } - if (*(*[2]int32)(unsafe.Pointer(bp + 10200)))[i] < int32(4) || Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + 560 + uintptr(i)*4800 + 3)))&int32(15) == int32(2) { + if (**(**[2]int32)(__ccgo_up(bp + 10200)))[i] < int32(4) || Int32FromUint8(**(**uint8)(__ccgo_up(bp + 560 + uintptr(i)*4800 + 3)))&int32(15) == int32(2) { return -int32(3) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + 560 + uintptr(i)*4800 + 3)))&int32(15) == int32(3) { + if Int32FromUint8(**(**uint8)(__ccgo_up(bp + 560 + uintptr(i)*4800 + 3)))&int32(15) == int32(3) { return 0 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + 560 + uintptr(i)*4800 + 3)))&int32(15) != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(bp + 560 + uintptr(i)*4800 + 3)))&int32(15) != 0 { return -int32(4) } goto _2 @@ -122785,18 +122785,18 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if !(i >= 0) { break } - (*(*Tdpc_ctx)(unsafe.Pointer(bp + 10208))).Frrtype = qtypes[i] - if Uint64FromInt32((*(*[2]int32)(unsafe.Pointer(bp + 10200)))[i]) > uint64(4800) { - (*(*[2]int32)(unsafe.Pointer(bp + 10200)))[i] = int32(4800) + (**(**Tdpc_ctx)(__ccgo_up(bp + 10208))).Frrtype = qtypes[i] + if Uint64FromInt32((**(**[2]int32)(__ccgo_up(bp + 10200)))[i]) > uint64(4800) { + (**(**[2]int32)(__ccgo_up(bp + 10200)))[i] = int32(4800) } - X__dns_parse(tls, bp+560+uintptr(i)*4800, (*(*[2]int32)(unsafe.Pointer(bp + 10200)))[i], __ccgo_fp(_dns_parse_callback1), bp+10208) + X__dns_parse(tls, bp+560+uintptr(i)*4800, (**(**[2]int32)(__ccgo_up(bp + 10200)))[i], __ccgo_fp(_dns_parse_callback1), bp+10208) goto _3 _3: ; i = i - 1 } - if (*(*Tdpc_ctx)(unsafe.Pointer(bp + 10208))).Fcnt != 0 { - return (*(*Tdpc_ctx)(unsafe.Pointer(bp + 10208))).Fcnt + if (**(**Tdpc_ctx)(__ccgo_up(bp + 10208))).Fcnt != 0 { + return (**(**Tdpc_ctx)(__ccgo_up(bp + 10208))).Fcnt } return -int32(5) } @@ -122834,10 +122834,10 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f l = v2 dots = v2 for { - if !(*(*uint8)(unsafe.Pointer(name + uintptr(l))) != 0) { + if !(**(**uint8)(__ccgo_up(name + uintptr(l))) != 0) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(name + uintptr(l)))) == int32('.') { + if Int32FromUint8(**(**uint8)(__ccgo_up(name + uintptr(l)))) == int32('.') { dots = dots + 1 } goto _1 @@ -122845,14 +122845,14 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f ; l = l + 1 } - if dots >= uint64((*(*Tresolvconf)(unsafe.Pointer(bp + 256))).Fndots) || Int32FromUint8(*(*uint8)(unsafe.Pointer(name + uintptr(l-uint64(1))))) == int32('.') { - *(*uint8)(unsafe.Pointer(bp)) = uint8(0) + if dots >= uint64((**(**Tresolvconf)(__ccgo_up(bp + 256))).Fndots) || Int32FromUint8(**(**uint8)(__ccgo_up(name + uintptr(l-uint64(1))))) == int32('.') { + **(**uint8)(__ccgo_up(bp)) = uint8(0) } /* Strip final dot for canon, fail if multiple trailing dots. */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(name + uintptr(l-uint64(1))))) == int32('.') { + if Int32FromUint8(**(**uint8)(__ccgo_up(name + uintptr(l-uint64(1))))) == int32('.') { l = l - 1 } - if !(l != 0) || Int32FromUint8(*(*uint8)(unsafe.Pointer(name + uintptr(l-uint64(1))))) == int32('.') { + if !(l != 0) || Int32FromUint8(**(**uint8)(__ccgo_up(name + uintptr(l-uint64(1))))) == int32('.') { return -int32(2) } /* This can never happen; the caller already checked length. */ @@ -122864,14 +122864,14 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f * name is not a CNAME record) and serves as a buffer for passing * the full requested name to name_from_dns. */ Xmemcpy(tls, canon, name, l) - *(*uint8)(unsafe.Pointer(canon + uintptr(l))) = uint8('.') + **(**uint8)(__ccgo_up(canon + uintptr(l))) = uint8('.') p = bp for { - if !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if !(**(**uint8)(__ccgo_up(p)) != 0) { break } for { - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v5 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _7 _7: @@ -122885,8 +122885,8 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f } z = p for { - if v12 = *(*uint8)(unsafe.Pointer(z)) != 0; v12 { - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(z))) + if v12 = **(**uint8)(__ccgo_up(z)) != 0; v12 { + v5 = Int32FromUint8(**(**uint8)(__ccgo_up(z))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _11 _11: @@ -122904,7 +122904,7 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f } if Uint64FromInt64(int64(z)-int64(p)) < uint64(256)-l-uint64(1) { Xmemcpy(tls, canon+uintptr(l)+uintptr(1), p, Uint64FromInt64(int64(z)-int64(p))) - *(*uint8)(unsafe.Pointer(canon + uintptr(Uint64FromInt64(int64(z)-int64(p)+int64(1))+l))) = uint8(0) + **(**uint8)(__ccgo_up(canon + uintptr(Uint64FromInt64(int64(z)-int64(p)+int64(1))+l))) = uint8(0) cnt = _name_from_dns(tls, buf, canon, canon, family, bp+256) if cnt != 0 { return cnt @@ -122915,7 +122915,7 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f ; p = z } - *(*uint8)(unsafe.Pointer(canon + uintptr(l))) = uint8(0) + **(**uint8)(__ccgo_up(canon + uintptr(l))) = uint8(0) return _name_from_dns(tls, buf, canon, name, family, bp+256) } @@ -122976,7 +122976,7 @@ func _policyof(tls *TLS, a uintptr) (r uintptr) { if Xmemcmp(tls, a, uintptr(unsafe.Pointer(&_defpolicy))+uintptr(i)*20, uint64(_defpolicy[i].Flen1)) != 0 { goto _1 } - if Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + uintptr(_defpolicy[i].Flen1))))&Int32FromUint8(_defpolicy[i].Fmask) != Int32FromUint8(*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_defpolicy)) + uintptr(i)*20 + uintptr(_defpolicy[i].Flen1)))) { + if Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + uintptr(_defpolicy[i].Flen1))))&Int32FromUint8(_defpolicy[i].Fmask) != Int32FromUint8(**(**uint8)(__ccgo_up(uintptr(unsafe.Pointer(&_defpolicy)) + uintptr(i)*20 + uintptr(_defpolicy[i].Flen1)))) { goto _1 } return uintptr(unsafe.Pointer(&_defpolicy)) + uintptr(i)*20 @@ -122993,16 +122993,16 @@ func _labelof(tls *TLS, a uintptr) (r int32) { } func _scopeof(tls *TLS, a uintptr) (r int32) { - if Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a))) == int32(0xff) { - return Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 1))) & int32(15) + if Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a))) == int32(0xff) { + return Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 1))) & int32(15) } - if Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a))) == int32(0xfe) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 1)))&int32(0xc0) == int32(0x80) { + if Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a))) == int32(0xfe) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 1)))&int32(0xc0) == int32(0x80) { return int32(2) } - if *(*Tuint32_t)(unsafe.Pointer(a)) == uint32(0) && *(*Tuint32_t)(unsafe.Pointer(a + 1*4)) == uint32(0) && *(*Tuint32_t)(unsafe.Pointer(a + 2*4)) == uint32(0) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 12))) == 0 && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 13))) == 0 && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 14))) == 0 && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 15))) == int32(1) { + if **(**Tuint32_t)(__ccgo_up(a)) == uint32(0) && **(**Tuint32_t)(__ccgo_up(a + 1*4)) == uint32(0) && **(**Tuint32_t)(__ccgo_up(a + 2*4)) == uint32(0) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 12))) == 0 && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 13))) == 0 && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 14))) == 0 && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 15))) == int32(1) { return int32(2) } - if Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a))) == int32(0xfe) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 1)))&int32(0xc0) == int32(0xc0) { + if Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a))) == int32(0xfe) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 1)))&int32(0xc0) == int32(0xc0) { return int32(5) } return int32(14) @@ -123013,7 +123013,7 @@ func _prefixmatch(tls *TLS, s uintptr, d uintptr) (r int32) { _ = i i = uint32(0) for { - if !(i < uint32(128) && !((Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(s + uintptr(i/uint32(8)))))^Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(d + uintptr(i/uint32(8))))))&(Int32FromInt32(128)>>(i%Uint32FromInt32(8))) != 0)) { + if !(i < uint32(128) && !((Int32FromUint8(**(**Tuint8_t)(__ccgo_up(s + uintptr(i/uint32(8)))))^Int32FromUint8(**(**Tuint8_t)(__ccgo_up(d + uintptr(i/uint32(8))))))&(Int32FromInt32(128)>>(i%Uint32FromInt32(8))) != 0)) { break } goto _1 @@ -123051,7 +123051,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i var _ /* salen at bp+92 */ Tsocklen_t _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cnt, da, dalen, dlabel, dpolicy, dprec, dscope, family1, fd, i, j, key, l, prefixlen, sa, v1 cnt = 0 - *(*uint8)(unsafe.Pointer(canon)) = uint8(0) + **(**uint8)(__ccgo_up(canon)) = uint8(0) if name != 0 { /* reject empty name and check len so it fits into temp bufs */ l = Xstrnlen(tls, name, uint64(255)) @@ -123095,7 +123095,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i /* If any v6 results exist, remove v4 results. */ i = 0 for { - if !(i < cnt && (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily != int32(PF_INET6)) { + if !(i < cnt && (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Ffamily != int32(PF_INET6)) { break } goto _2 @@ -123109,10 +123109,10 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if !(i < cnt) { break } - if (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily == int32(PF_INET6) { + if (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Ffamily == int32(PF_INET6) { v1 = j j = j + 1 - *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = *(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28)) + **(**Taddress)(__ccgo_up(buf + uintptr(v1)*28)) = **(**Taddress)(__ccgo_up(buf + uintptr(i)*28)) } goto _3 _3: @@ -123130,12 +123130,12 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if !(i < cnt) { break } - if (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily != int32(PF_INET) { + if (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Ffamily != int32(PF_INET) { goto _6 } Xmemcpy(tls, buf+uintptr(i)*28+8+uintptr(12), buf+uintptr(i)*28+8, uint64(4)) Xmemcpy(tls, buf+uintptr(i)*28+8, __ccgo_ts+1069, uint64(12)) - (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily = int32(PF_INET6) + (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Ffamily = int32(PF_INET6) goto _6 _6: ; @@ -123152,7 +123152,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if !(i < cnt) { break } - if (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily != int32(PF_INET) { + if (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Ffamily != int32(PF_INET) { break } goto _7 @@ -123174,16 +123174,16 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if !(i < cnt) { break } - family1 = (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily + family1 = (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Ffamily key = 0 - *(*Tsockaddr_in6)(unsafe.Pointer(bp + 4)) = Tsockaddr_in6{} - *(*Tsockaddr_in6)(unsafe.Pointer(bp + 32)) = Tsockaddr_in6{ + **(**Tsockaddr_in6)(__ccgo_up(bp + 4)) = Tsockaddr_in6{} + **(**Tsockaddr_in6)(__ccgo_up(bp + 32)) = Tsockaddr_in6{ Fsin6_family: uint16(PF_INET6), Fsin6_port: uint16(65535), - Fsin6_scope_id: (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Fscopeid, + Fsin6_scope_id: (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Fscopeid, } - *(*Tsockaddr_in)(unsafe.Pointer(bp + 60)) = Tsockaddr_in{} - *(*Tsockaddr_in)(unsafe.Pointer(bp + 76)) = Tsockaddr_in{ + **(**Tsockaddr_in)(__ccgo_up(bp + 60)) = Tsockaddr_in{} + **(**Tsockaddr_in)(__ccgo_up(bp + 76)) = Tsockaddr_in{ Fsin_family: uint16(PF_INET), Fsin_port: uint16(65535), } @@ -123192,7 +123192,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i da = bp + 32 dalen = uint32(28) sa = bp + 4 - *(*Tsocklen_t)(unsafe.Pointer(bp + 92)) = uint32(28) + **(**Tsocklen_t)(__ccgo_up(bp + 92)) = uint32(28) } else { Xmemcpy(tls, bp+4+8, __ccgo_ts+1069, uint64(12)) Xmemcpy(tls, bp+32+8+uintptr(12), buf+uintptr(i)*28+8, uint64(4)) @@ -123202,7 +123202,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i da = bp + 76 dalen = uint32(16) sa = bp + 60 - *(*Tsocklen_t)(unsafe.Pointer(bp + 92)) = uint32(16) + **(**Tsocklen_t)(__ccgo_up(bp + 92)) = uint32(16) } dpolicy = _policyof(tls, bp+32+8) dscope = _scopeof(tls, bp+32+8) @@ -123232,14 +123232,14 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i key = key | (int32(15)-dscope)< uint64(65535) { return -int32(8) } if proto != int32(IPPROTO_UDP) { - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fport = uint16(port) - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_STREAM) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fport = uint16(port) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_STREAM) v1 = cnt cnt = cnt + 1 - (*(*Tservice)(unsafe.Pointer(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_TCP) + (**(**Tservice)(__ccgo_up(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_TCP) } if proto != int32(IPPROTO_TCP) { - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fport = uint16(port) - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_DGRAM) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fport = uint16(port) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_DGRAM) v1 = cnt cnt = cnt + 1 - (*(*Tservice)(unsafe.Pointer(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_UDP) + (**(**Tservice)(__ccgo_up(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_UDP) } return cnt } @@ -123325,7 +123325,7 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i l = _strlen(tls, name) f = X__fopen_rb_ca(tls, __ccgo_ts+1082, bp+1168, bp+136, uint64(1032)) if !(f != 0) { - switch *(*int32)(unsafe.Pointer(X__errno_location(tls))) { + switch **(**int32)(__ccgo_up(X__errno_location(tls))) { case int32(ENOENT): fallthrough case int32(ENOTDIR): @@ -123342,8 +123342,8 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i if v3 != 0 { v4 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8('\n') - *(*uint8)(unsafe.Pointer(p)) = Uint8FromInt32(0) + **(**uint8)(__ccgo_up(v4)) = uint8('\n') + **(**uint8)(__ccgo_up(p)) = Uint8FromInt32(0) } /* Find service name */ p = bp @@ -123354,7 +123354,7 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i break } if v10 = p > bp; v10 { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(p + uintptr(-Int32FromInt32(1))))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _9 _9: @@ -123362,8 +123362,8 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i if v10 && !(v2 != 0) { goto _5 } - if v10 = *(*uint8)(unsafe.Pointer(p + uintptr(l))) != 0; v10 { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(l)))) + if v10 = **(**uint8)(__ccgo_up(p + uintptr(l))) != 0; v10 { + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(p + uintptr(l)))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _13 _13: @@ -123383,8 +123383,8 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i /* Skip past canonical name at beginning of line */ p = bp for { - if v10 = *(*uint8)(unsafe.Pointer(p)) != 0; v10 { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + if v10 = **(**uint8)(__ccgo_up(p)) != 0; v10 { + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _18 _18: @@ -123398,28 +123398,28 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i p = p + 1 } port = Xstrtoul(tls, p, bp+128, int32(10)) - if port > uint64(65535) || *(*uintptr)(unsafe.Pointer(bp + 128)) == p { + if port > uint64(65535) || **(**uintptr)(__ccgo_up(bp + 128)) == p { continue } - if !(Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(bp + 128)), __ccgo_ts+1096, uint64(4)) != 0) { + if !(Xstrncmp(tls, **(**uintptr)(__ccgo_up(bp + 128)), __ccgo_ts+1096, uint64(4)) != 0) { if proto == int32(IPPROTO_TCP) { continue } - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fport = uint16(port) - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_DGRAM) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fport = uint16(port) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_DGRAM) v1 = cnt cnt = cnt + 1 - (*(*Tservice)(unsafe.Pointer(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_UDP) + (**(**Tservice)(__ccgo_up(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_UDP) } - if !(Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(bp + 128)), __ccgo_ts+1101, uint64(4)) != 0) { + if !(Xstrncmp(tls, **(**uintptr)(__ccgo_up(bp + 128)), __ccgo_ts+1101, uint64(4)) != 0) { if proto == int32(IPPROTO_UDP) { continue } - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fport = uint16(port) - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_STREAM) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fport = uint16(port) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_STREAM) v1 = cnt cnt = cnt + 1 - (*(*Tservice)(unsafe.Pointer(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_TCP) + (**(**Tservice)(__ccgo_up(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_TCP) } } X__fclose_ca(tls, f) @@ -123449,58 +123449,58 @@ func ___netlink_enumerate(tls *TLS, fd int32, seq uint32, type1 int32, af int32, (*(*struct { Fnlh Tnlmsghdr Fg Trtgenmsg - })(unsafe.Pointer(&*(*struct { + })(unsafe.Pointer(&**(**struct { Freq [0]struct { Fnlh Tnlmsghdr Fg Trtgenmsg } Freply [0]Tnlmsghdr Fbuf [8192]Tuint8_t - })(unsafe.Pointer(bp))))).Fnlh.Fnlmsg_len = uint32(20) + })(__ccgo_up(bp))))).Fnlh.Fnlmsg_len = uint32(20) (*(*struct { Fnlh Tnlmsghdr Fg Trtgenmsg - })(unsafe.Pointer(&*(*struct { + })(unsafe.Pointer(&**(**struct { Freq [0]struct { Fnlh Tnlmsghdr Fg Trtgenmsg } Freply [0]Tnlmsghdr Fbuf [8192]Tuint8_t - })(unsafe.Pointer(bp))))).Fnlh.Fnlmsg_type = Uint16FromInt32(type1) + })(__ccgo_up(bp))))).Fnlh.Fnlmsg_type = Uint16FromInt32(type1) (*(*struct { Fnlh Tnlmsghdr Fg Trtgenmsg - })(unsafe.Pointer(&*(*struct { + })(unsafe.Pointer(&**(**struct { Freq [0]struct { Fnlh Tnlmsghdr Fg Trtgenmsg } Freply [0]Tnlmsghdr Fbuf [8192]Tuint8_t - })(unsafe.Pointer(bp))))).Fnlh.Fnlmsg_flags = Uint16FromInt32(Int32FromInt32(NLM_F_ROOT) | Int32FromInt32(NLM_F_MATCH) | Int32FromInt32(NLM_F_REQUEST)) + })(__ccgo_up(bp))))).Fnlh.Fnlmsg_flags = Uint16FromInt32(Int32FromInt32(NLM_F_ROOT) | Int32FromInt32(NLM_F_MATCH) | Int32FromInt32(NLM_F_REQUEST)) (*(*struct { Fnlh Tnlmsghdr Fg Trtgenmsg - })(unsafe.Pointer(&*(*struct { + })(unsafe.Pointer(&**(**struct { Freq [0]struct { Fnlh Tnlmsghdr Fg Trtgenmsg } Freply [0]Tnlmsghdr Fbuf [8192]Tuint8_t - })(unsafe.Pointer(bp))))).Fnlh.Fnlmsg_seq = seq + })(__ccgo_up(bp))))).Fnlh.Fnlmsg_seq = seq (*(*struct { Fnlh Tnlmsghdr Fg Trtgenmsg - })(unsafe.Pointer(&*(*struct { + })(unsafe.Pointer(&**(**struct { Freq [0]struct { Fnlh Tnlmsghdr Fg Trtgenmsg } Freply [0]Tnlmsghdr Fbuf [8192]Tuint8_t - })(unsafe.Pointer(bp))))).Fg.Frtgen_family = Uint8FromInt32(af) + })(__ccgo_up(bp))))).Fg.Frtgen_family = Uint8FromInt32(af) r = int32(Xsend(tls, fd, bp, uint64(20), 0)) if r < 0 { return r @@ -123576,7 +123576,7 @@ func Xns_get16(tls *TLS, cp uintptr) (r uint32) { trc("tls=%v cp=%v, (%v:)", tls, cp, origin(2)) defer func() { trc("-> %v", r) }() } - return Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(cp)))< %v", r) }() } - return uint64(uint32(*(*uint8)(unsafe.Pointer(cp)))<> int32(8)) + **(**uint8)(__ccgo_up(v1)) = uint8(s >> int32(8)) v1 = cp cp = cp + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(s) + **(**uint8)(__ccgo_up(v1)) = uint8(s) } func Xns_put32(tls *TLS, l uint64, cp uintptr) { @@ -123609,16 +123609,16 @@ func Xns_put32(tls *TLS, l uint64, cp uintptr) { _ = v1 v1 = cp cp = cp + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(l >> int32(24)) + **(**uint8)(__ccgo_up(v1)) = uint8(l >> int32(24)) v1 = cp cp = cp + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(l >> int32(16)) + **(**uint8)(__ccgo_up(v1)) = uint8(l >> int32(16)) v1 = cp cp = cp + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(l >> int32(8)) + **(**uint8)(__ccgo_up(v1)) = uint8(l >> int32(8)) v1 = cp cp = cp + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(l) + **(**uint8)(__ccgo_up(v1)) = uint8(l) } func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int32) { @@ -123643,7 +123643,7 @@ func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int3 break } msg = msg + uintptr(2) - *(*Tuint16_t)(unsafe.Pointer(handle + 20 + uintptr(i)*2)) = uint16(Xns_get16(tls, msg-uintptr(2))) + **(**Tuint16_t)(__ccgo_up(handle + 20 + uintptr(i)*2)) = uint16(Xns_get16(tls, msg-uintptr(2))) goto _1 _1: ; @@ -123654,15 +123654,15 @@ func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int3 if !(i < int32(_ns_s_max)) { break } - if *(*Tuint16_t)(unsafe.Pointer(handle + 20 + uintptr(i)*2)) != 0 { - *(*uintptr)(unsafe.Pointer(handle + 32 + uintptr(i)*8)) = msg - r = Xns_skiprr(tls, msg, (*Tns_msg)(unsafe.Pointer(handle)).F_eom, i, Int32FromUint16(*(*Tuint16_t)(unsafe.Pointer(handle + 20 + uintptr(i)*2)))) + if **(**Tuint16_t)(__ccgo_up(handle + 20 + uintptr(i)*2)) != 0 { + **(**uintptr)(__ccgo_up(handle + 32 + uintptr(i)*8)) = msg + r = Xns_skiprr(tls, msg, (*Tns_msg)(unsafe.Pointer(handle)).F_eom, i, Int32FromUint16(**(**Tuint16_t)(__ccgo_up(handle + 20 + uintptr(i)*2)))) if r < 0 { return -int32(1) } msg = msg + uintptr(r) } else { - *(*uintptr)(unsafe.Pointer(handle + 32 + uintptr(i)*8)) = UintptrFromInt32(0) + **(**uintptr)(__ccgo_up(handle + 32 + uintptr(i)*8)) = UintptrFromInt32(0) } goto _2 _2: @@ -123679,7 +123679,7 @@ func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int3 goto bad bad: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EMSGSIZE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EMSGSIZE) return -int32(1) } @@ -123723,7 +123723,7 @@ func Xns_skiprr(tls *TLS, ptr uintptr, eom uintptr, section Tns_sect, count int3 goto bad bad: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EMSGSIZE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EMSGSIZE) return -int32(1) } @@ -123741,31 +123741,31 @@ func Xns_parserr(tls *TLS, handle uintptr, section Tns_sect, rrnum int32, rr uin if section != (*Tns_msg)(unsafe.Pointer(handle)).F_sect { (*Tns_msg)(unsafe.Pointer(handle)).F_sect = section (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum = 0 - (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr = *(*uintptr)(unsafe.Pointer(handle + 32 + uintptr(section)*8)) + (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr = **(**uintptr)(__ccgo_up(handle + 32 + uintptr(section)*8)) } if rrnum == -int32(1) { rrnum = (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum } - if rrnum < 0 || rrnum >= Int32FromUint16(*(*Tuint16_t)(unsafe.Pointer(handle + 20 + uintptr(section)*2))) { + if rrnum < 0 || rrnum >= Int32FromUint16(**(**Tuint16_t)(__ccgo_up(handle + 20 + uintptr(section)*2))) { goto bad } if rrnum < (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum { (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum = 0 - (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr = *(*uintptr)(unsafe.Pointer(handle + 32 + uintptr(section)*8)) + (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr = **(**uintptr)(__ccgo_up(handle + 32 + uintptr(section)*8)) } if rrnum > (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum { r = Xns_skiprr(tls, (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr, (*Tns_msg)(unsafe.Pointer(handle)).F_eom, section, rrnum-(*Tns_msg)(unsafe.Pointer(handle)).F_rrnum) if r < 0 { return -int32(1) } - *(*uintptr)(unsafe.Pointer(handle + 72)) += uintptr(r) + **(**uintptr)(__ccgo_up(handle + 72)) += uintptr(r) (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum = rrnum } r = Xns_name_uncompress(tls, (*Tns_msg)(unsafe.Pointer(handle)).F_msg, (*Tns_msg)(unsafe.Pointer(handle)).F_eom, (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr, rr, uint64(NS_MAXDNAME)) if r < 0 { return -int32(1) } - *(*uintptr)(unsafe.Pointer(handle + 72)) += uintptr(r) + **(**uintptr)(__ccgo_up(handle + 72)) += uintptr(r) if int64(Int32FromInt32(2)*Int32FromInt32(NS_INT16SZ)) > int64((*Tns_msg)(unsafe.Pointer(handle)).F_eom)-int64((*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr) { goto size } @@ -123789,14 +123789,14 @@ func Xns_parserr(tls *TLS, handle uintptr, section Tns_sect, rrnum int32, rr uin goto size } (*Tns_rr)(unsafe.Pointer(rr)).Frdata = (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr - *(*uintptr)(unsafe.Pointer(handle + 72)) += uintptr((*Tns_rr)(unsafe.Pointer(rr)).Frdlength) + **(**uintptr)(__ccgo_up(handle + 72)) += uintptr((*Tns_rr)(unsafe.Pointer(rr)).Frdlength) } else { (*Tns_rr)(unsafe.Pointer(rr)).Fttl = uint32(0) (*Tns_rr)(unsafe.Pointer(rr)).Frdlength = uint16(0) (*Tns_rr)(unsafe.Pointer(rr)).Frdata = UintptrFromInt32(0) } (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum = (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum + 1 - if (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum > Int32FromUint16(*(*Tuint16_t)(unsafe.Pointer(handle + 20 + uintptr(section)*2))) { + if (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum > Int32FromUint16(**(**Tuint16_t)(__ccgo_up(handle + 20 + uintptr(section)*2))) { (*Tns_msg)(unsafe.Pointer(handle)).F_sect = section + int32(1) if (*Tns_msg)(unsafe.Pointer(handle)).F_sect == int32(_ns_s_max) { (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum = -int32(1) @@ -123809,12 +123809,12 @@ func Xns_parserr(tls *TLS, handle uintptr, section Tns_sect, rrnum int32, rr uin goto bad bad: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENODEV) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENODEV) return -int32(1) goto size size: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EMSGSIZE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EMSGSIZE) return -int32(1) } @@ -123827,7 +123827,7 @@ func Xns_name_uncompress(tls *TLS, msg uintptr, eom uintptr, src uintptr, dst ui _ = r r = Xdn_expand(tls, msg, eom, src, dst, Int32FromUint64(dstsiz)) if r < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EMSGSIZE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EMSGSIZE) } return r } @@ -124096,9 +124096,9 @@ func X__convert_scm_timestamps(tls *TLS, msg uintptr, csize Tsocklen_t) { common: ; Xmemcpy(tls, bp, cmsg+UintptrFromInt32(1)*16, uint64(8)) - (*(*[2]int64)(unsafe.Pointer(bp + 8)))[0] = *(*int64)(unsafe.Pointer(bp)) + (**(**[2]int64)(__ccgo_up(bp + 8)))[0] = int64(**(**int64)(__ccgo_up(bp))) Xmemcpy(tls, bp, cmsg+UintptrFromInt32(1)*16+uintptr(8), uint64(8)) - (*(*[2]int64)(unsafe.Pointer(bp + 8)))[int32(1)] = *(*int64)(unsafe.Pointer(bp)) + (**(**[2]int64)(__ccgo_up(bp + 8)))[int32(1)] = int64(**(**int64)(__ccgo_up(bp))) goto _5 _5: } @@ -124117,7 +124117,7 @@ func X__convert_scm_timestamps(tls *TLS, msg uintptr, csize Tsocklen_t) { return } if (Uint64FromInt64(16)+Uint64FromInt64(8)-Uint64FromInt32(1)) & ^(Uint64FromInt64(8)-Uint64FromInt32(1)) + (Uint64FromInt64(16)+Uint64FromInt64(8)-Uint64FromInt32(1)) & ^(Uint64FromInt64(8)-Uint64FromInt32(1)) > uint64(csize-(*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_controllen) { - *(*int32)(unsafe.Pointer(msg + 48)) |= int32(MSG_CTRUNC) + **(**int32)(__ccgo_up(msg + 48)) |= int32(MSG_CTRUNC) return } v2 = msg + 40 @@ -124152,10 +124152,10 @@ func Xrecvmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r2 Tssize_t) { orig_controllen = (*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_controllen orig = msg if msg != 0 { - *(*Tmsghdr)(unsafe.Pointer(bp + 96)) = *(*Tmsghdr)(unsafe.Pointer(msg)) + **(**Tmsghdr)(__ccgo_up(bp + 96)) = **(**Tmsghdr)(__ccgo_up(msg)) v1 = Int32FromInt32(0) - (*(*Tmsghdr)(unsafe.Pointer(bp + 96))).F__pad2 = v1 - (*(*Tmsghdr)(unsafe.Pointer(bp + 96))).F__pad1 = v1 + (**(**Tmsghdr)(__ccgo_up(bp + 96))).F__pad2 = v1 + (**(**Tmsghdr)(__ccgo_up(bp + 96))).F__pad1 = v1 msg = bp + 96 } v1 = int32(SYS_recvmsg) @@ -124205,7 +124205,7 @@ _12: X__convert_scm_timestamps(tls, msg, orig_controllen) } if orig != 0 { - *(*Tmsghdr)(unsafe.Pointer(orig)) = *(*Tmsghdr)(unsafe.Pointer(bp + 96)) + **(**Tmsghdr)(__ccgo_up(orig)) = **(**Tmsghdr)(__ccgo_up(bp + 96)) } return r1 } @@ -124231,10 +124231,10 @@ func X__res_mkquery(tls *TLS, op int32, dname uintptr, class int32, type1 int32, var _ /* ts at bp+280 */ Ttimespec _, _, _, _, _ = i, id, j, l, n l = Xstrnlen(tls, dname, uint64(255)) - if l != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(dname + uintptr(l-uint64(1))))) == int32('.') { + if l != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(dname + uintptr(l-uint64(1))))) == int32('.') { l = l - 1 } - if l != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(dname + uintptr(l-uint64(1))))) == int32('.') { + if l != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(dname + uintptr(l-uint64(1))))) == int32('.') { return -int32(1) } n = Int32FromUint64(uint64(17) + l + BoolUint64(!!(l != 0))) @@ -124243,18 +124243,18 @@ func X__res_mkquery(tls *TLS, op int32, dname uintptr, class int32, type1 int32, } /* Construct query template - ID will be filled later */ Xmemset(tls, bp, 0, Uint64FromInt32(n)) - (*(*[280]uint8)(unsafe.Pointer(bp)))[int32(2)] = Uint8FromInt32(op*int32(8) + int32(1)) - (*(*[280]uint8)(unsafe.Pointer(bp)))[int32(3)] = uint8(32) /* AD */ - (*(*[280]uint8)(unsafe.Pointer(bp)))[int32(5)] = uint8(1) + (**(**[280]uint8)(__ccgo_up(bp)))[int32(2)] = Uint8FromInt32(op*int32(8) + int32(1)) + (**(**[280]uint8)(__ccgo_up(bp)))[int32(3)] = uint8(32) /* AD */ + (**(**[280]uint8)(__ccgo_up(bp)))[int32(5)] = uint8(1) Xmemcpy(tls, bp+uintptr(13), dname, l) i = int32(13) for { - if !((*(*[280]uint8)(unsafe.Pointer(bp)))[i] != 0) { + if !((**(**[280]uint8)(__ccgo_up(bp)))[i] != 0) { break } j = i for { - if !((*(*[280]uint8)(unsafe.Pointer(bp)))[j] != 0 && Int32FromUint8((*(*[280]uint8)(unsafe.Pointer(bp)))[j]) != int32('.')) { + if !((**(**[280]uint8)(__ccgo_up(bp)))[j] != 0 && Int32FromUint8((**(**[280]uint8)(__ccgo_up(bp)))[j]) != int32('.')) { break } goto _2 @@ -124265,19 +124265,19 @@ func X__res_mkquery(tls *TLS, op int32, dname uintptr, class int32, type1 int32, if Uint32FromInt32(j-i)-uint32(1) > uint32(62) { return -int32(1) } - (*(*[280]uint8)(unsafe.Pointer(bp)))[i-int32(1)] = Uint8FromInt32(j - i) + (**(**[280]uint8)(__ccgo_up(bp)))[i-int32(1)] = Uint8FromInt32(j - i) goto _1 _1: ; i = j + int32(1) } - (*(*[280]uint8)(unsafe.Pointer(bp)))[i+int32(1)] = Uint8FromInt32(type1) - (*(*[280]uint8)(unsafe.Pointer(bp)))[i+int32(3)] = Uint8FromInt32(class) + (**(**[280]uint8)(__ccgo_up(bp)))[i+int32(1)] = Uint8FromInt32(type1) + (**(**[280]uint8)(__ccgo_up(bp)))[i+int32(3)] = Uint8FromInt32(class) /* Make a reasonably unpredictable id */ Xclock_gettime(tls, CLOCK_REALTIME, bp+280) - id = Int32FromUint64((Uint64FromInt64((*(*Ttimespec)(unsafe.Pointer(bp + 280))).Ftv_nsec) + Uint64FromInt64((*(*Ttimespec)(unsafe.Pointer(bp + 280))).Ftv_nsec)/uint64(65536)) & uint64(0xffff)) - (*(*[280]uint8)(unsafe.Pointer(bp)))[0] = Uint8FromInt32(id / int32(256)) - (*(*[280]uint8)(unsafe.Pointer(bp)))[int32(1)] = Uint8FromInt32(id) + id = Int32FromUint64((Uint64FromInt64((**(**Ttimespec)(__ccgo_up(bp + 280))).Ftv_nsec) + Uint64FromInt64((**(**Ttimespec)(__ccgo_up(bp + 280))).Ftv_nsec)/uint64(65536)) & uint64(0xffff)) + (**(**[280]uint8)(__ccgo_up(bp)))[0] = Uint8FromInt32(id / int32(256)) + (**(**[280]uint8)(__ccgo_up(bp)))[int32(1)] = Uint8FromInt32(id) Xmemcpy(tls, buf, bp, Uint64FromInt32(n)) return n } @@ -124394,11 +124394,11 @@ func _cleanup(tls *TLS, p uintptr) { pfd = p i = 0 for { - if !((*(*Tpollfd)(unsafe.Pointer(pfd + uintptr(i)*8))).Ffd >= -int32(1)) { + if !((**(**Tpollfd)(__ccgo_up(pfd + uintptr(i)*8))).Ffd >= -int32(1)) { break } - if (*(*Tpollfd)(unsafe.Pointer(pfd + uintptr(i)*8))).Ffd >= 0 { - X__syscall1(tls, int64(SYS_close), int64((*(*Tpollfd)(unsafe.Pointer(pfd + uintptr(i)*8))).Ffd)) + if (**(**Tpollfd)(__ccgo_up(pfd + uintptr(i)*8))).Ffd >= 0 { + X__syscall1(tls, int64(SYS_close), int64((**(**Tpollfd)(__ccgo_up(pfd + uintptr(i)*8))).Ffd)) } goto _1 _1: @@ -124411,10 +124411,10 @@ func _mtime(tls *TLS) (r uint64) { bp := tls.Alloc(16) defer tls.Free(16) var _ /* ts at bp+0 */ Ttimespec - if Xclock_gettime(tls, int32(CLOCK_MONOTONIC), bp) < 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENOSYS) { + if Xclock_gettime(tls, int32(CLOCK_MONOTONIC), bp) < 0 && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENOSYS) { Xclock_gettime(tls, CLOCK_REALTIME, bp) } - return Uint64FromInt64((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec)*uint64(1000) + Uint64FromInt64((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_nsec/int64(1000000)) + return Uint64FromInt64((**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec)*uint64(1000) + Uint64FromInt64((**(**Ttimespec)(__ccgo_up(bp))).Ftv_nsec/int64(1000000)) } func _start_tcp(tls *TLS, pfd uintptr, family int32, sa uintptr, sl Tsocklen_t, q uintptr, ql int32) (r1 int32) { @@ -124437,7 +124437,7 @@ func _start_tcp(tls *TLS, pfd uintptr, family int32, sa uintptr, sl Tsocklen_t, Fiov_len: Uint64FromInt32(ql), }, } - *(*Tmsghdr)(unsafe.Pointer(bp + 40)) = Tmsghdr{ + **(**Tmsghdr)(__ccgo_up(bp + 40)) = Tmsghdr{ Fmsg_name: sa, Fmsg_namelen: sl, Fmsg_iov: bp, @@ -124455,12 +124455,12 @@ func _start_tcp(tls *TLS, pfd uintptr, family int32, sa uintptr, sl Tsocklen_t, if r >= 0 { return r } - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EINPROGRESS) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EINPROGRESS) { return 0 } } r = Xconnect(tls, fd, sa, sl) - if !(r != 0) || *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EINPROGRESS) { + if !(r != 0) || **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EINPROGRESS) { return 0 } Xclose(tls, fd) @@ -124479,7 +124479,7 @@ func _step_mh(tls *TLS, mh uintptr, n Tsize_t) { return } (*Tiovec)(unsafe.Pointer((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov)).Fiov_base = (*Tiovec)(unsafe.Pointer((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov)).Fiov_base + uintptr(n) - *(*Tsize_t)(unsafe.Pointer((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov + 8)) -= n + **(**Tsize_t)(__ccgo_up((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov + 8)) -= n } /* Internal contract for __res_msend[_rc]: asize must be >=512, nqueries @@ -124531,11 +124531,11 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a F__ccgo_pad2 [12]byte }{} *(*uint16)(unsafe.Pointer(bp + 88)) = uint16(0) - *(*[3]struct { + **(**[3]struct { Fsin6 [0]Tsockaddr_in6 Fsin Tsockaddr_in F__ccgo_pad2 [12]byte - })(unsafe.Pointer(bp + 116)) = [3]struct { + })(__ccgo_up(bp + 116)) = [3]struct { Fsin6 [0]Tsockaddr_in6 Fsin Tsockaddr_in F__ccgo_pad2 [12]byte @@ -124562,16 +124562,16 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a iplit = conf + uintptr(nns)*28 if (*Taddress)(unsafe.Pointer(iplit)).Ffamily == int32(PF_INET) { Xmemcpy(tls, bp+116+uintptr(nns)*28+4, iplit+8, uint64(4)) - (*(*[3]struct { + (**(**[3]struct { Fsin6 [0]Tsockaddr_in6 Fsin Tsockaddr_in F__ccgo_pad2 [12]byte - })(unsafe.Pointer(bp + 116)))[nns].Fsin.Fsin_port = Xhtons(tls, uint16(53)) - (*(*[3]struct { + })(__ccgo_up(bp + 116)))[nns].Fsin.Fsin_port = Xhtons(tls, uint16(53)) + (**(**[3]struct { Fsin6 [0]Tsockaddr_in6 Fsin Tsockaddr_in F__ccgo_pad2 [12]byte - })(unsafe.Pointer(bp + 116)))[nns].Fsin.Fsin_family = uint16(PF_INET) + })(__ccgo_up(bp + 116)))[nns].Fsin.Fsin_family = uint16(PF_INET) } else { sl = uint32(28) Xmemcpy(tls, bp+116+uintptr(nns)*28+8, iplit+8, uint64(16)) @@ -124589,10 +124589,10 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a /* Get local address and open/bind a socket */ fd = Xsocket(tls, family, Int32FromInt32(SOCK_DGRAM)|Int32FromInt32(SOCK_CLOEXEC)|Int32FromInt32(SOCK_NONBLOCK), 0) /* Handle case where system lacks IPv6 support */ - if fd < 0 && family == int32(PF_INET6) && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EAFNOSUPPORT) { + if fd < 0 && family == int32(PF_INET6) && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EAFNOSUPPORT) { i = 0 for { - if !(i < nns && (*(*Taddress)(unsafe.Pointer(conf + uintptr(nns)*28))).Ffamily == int32(PF_INET6)) { + if !(i < nns && (**(**Taddress)(__ccgo_up(conf + uintptr(nns)*28))).Ffamily == int32(PF_INET6)) { break } goto _7 @@ -124601,7 +124601,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a i = i + 1 } if i == nns { - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 200)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 200)), uintptr(0)) return -int32(1) } fd = Xsocket(tls, int32(PF_INET), Int32FromInt32(SOCK_DGRAM)|Int32FromInt32(SOCK_CLOEXEC)|Int32FromInt32(SOCK_NONBLOCK), 0) @@ -124617,11 +124617,11 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a if !(i < nns) { break } - if Int32FromUint16((*(*[3]struct { + if Int32FromUint16((**(**[3]struct { Fsin6 [0]Tsockaddr_in6 Fsin Tsockaddr_in F__ccgo_pad2 [12]byte - })(unsafe.Pointer(bp + 116)))[i].Fsin.Fsin_family) != int32(PF_INET) { + })(__ccgo_up(bp + 116)))[i].Fsin.Fsin_family) != int32(PF_INET) { goto _8 } Xmemcpy(tls, bp+116+uintptr(i)*28+8+uintptr(12), bp+116+uintptr(i)*28+4, uint64(4)) @@ -124635,16 +124635,16 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a i = i + 1 } } - (*(*struct { + (**(**struct { Fsin6 [0]Tsockaddr_in6 Fsin Tsockaddr_in F__ccgo_pad2 [12]byte - })(unsafe.Pointer(bp + 88))).Fsin.Fsin_family = Uint16FromInt32(family) + })(__ccgo_up(bp + 88))).Fsin.Fsin_family = Uint16FromInt32(family) if fd < 0 || Xbind(tls, fd, bp+88, sl) < 0 { if fd >= 0 { Xclose(tls, fd) } - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 200)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 200)), uintptr(0)) return -int32(1) } /* Past this point, there are no errors. Each individual query will @@ -124665,7 +124665,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), nqueries*8))).Fevents = int16(POLLIN) (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), (nqueries+int32(1))*8))).Ffd = -int32(2) __pthread_cleanup_push(tls, bp+208, __ccgo_fp(_cleanup), pfd) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 200)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 200)), uintptr(0)) Xmemset(tls, alens, 0, uint64(4)*Uint64FromInt32(nqueries)) retry_interval = timeout / attempts next = 0 @@ -124681,7 +124681,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a * have an accepted answer. */ i = 0 for { - if !(i < nqueries && *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) > 0) { + if !(i < nqueries && **(**int32)(__ccgo_up(alens + uintptr(i)*4)) > 0) { break } goto _12 @@ -124699,13 +124699,13 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a if !(i < nqueries) { break } - if !(*(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) != 0) { + if !(**(**int32)(__ccgo_up(alens + uintptr(i)*4)) != 0) { j = 0 for { if !(j < nns) { break } - Xsendto(tls, fd, *(*uintptr)(unsafe.Pointer(queries + uintptr(i)*8)), Uint64FromInt32(*(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))), int32(MSG_NOSIGNAL), bp+116+uintptr(j)*28, sl) + Xsendto(tls, fd, **(**uintptr)(__ccgo_up(queries + uintptr(i)*8)), Uint64FromInt32(**(**int32)(__ccgo_up(qlens + uintptr(i)*4))), int32(MSG_NOSIGNAL), bp+116+uintptr(j)*28, sl) goto _14 _14: ; @@ -124727,11 +124727,11 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a for next < nqueries { *(*[1]Tiovec)(unsafe.Pointer(bp + 8)) = [1]Tiovec{ 0: { - Fiov_base: *(*uintptr)(unsafe.Pointer(answers + uintptr(next)*8)), + Fiov_base: **(**uintptr)(__ccgo_up(answers + uintptr(next)*8)), Fiov_len: Uint64FromInt32(asize), }, } - *(*Tmsghdr)(unsafe.Pointer(bp + 232)) = Tmsghdr{ + **(**Tmsghdr)(__ccgo_up(bp + 232)) = Tmsghdr{ Fmsg_name: bp + 88, Fmsg_namelen: sl, Fmsg_iov: bp + 8, @@ -124762,7 +124762,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a /* Find which query this answer goes with, if any */ i = next for { - if !(i < nqueries && (Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(answers + uintptr(next)*8))))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(queries + uintptr(i)*8))))) || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(answers + uintptr(next)*8)) + 1))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(queries + uintptr(i)*8)) + 1))))) { + if !(i < nqueries && (Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(answers + uintptr(next)*8))))) != Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(queries + uintptr(i)*8))))) || Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(answers + uintptr(next)*8)) + 1))) != Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(queries + uintptr(i)*8)) + 1))))) { break } goto _16 @@ -124773,13 +124773,13 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a if i == nqueries { continue } - if *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) != 0 { + if **(**int32)(__ccgo_up(alens + uintptr(i)*4)) != 0 { continue } /* Only accept positive or negative responses; * retry immediately on server failure, and ignore * all other codes such as refusal. */ - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(answers + uintptr(next)*8)) + 3))) & Int32FromInt32(15) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(answers + uintptr(next)*8)) + 3))) & Int32FromInt32(15) { case 0: fallthrough case int32(3): @@ -124789,7 +124789,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a servfail_retry = servfail_retry - 1 } if v18 && v6 != 0 { - Xsendto(tls, fd, *(*uintptr)(unsafe.Pointer(queries + uintptr(i)*8)), Uint64FromInt32(*(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))), int32(MSG_NOSIGNAL), bp+116+uintptr(j)*28, sl) + Xsendto(tls, fd, **(**uintptr)(__ccgo_up(queries + uintptr(i)*8)), Uint64FromInt32(**(**int32)(__ccgo_up(qlens + uintptr(i)*4))), int32(MSG_NOSIGNAL), bp+116+uintptr(j)*28, sl) } fallthrough default: @@ -124797,10 +124797,10 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a } /* Store answer in the right slot, or update next * available temp slot if it's already in place. */ - *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) = rlen + **(**int32)(__ccgo_up(alens + uintptr(i)*4)) = rlen if i == next { for { - if !(next < nqueries && *(*int32)(unsafe.Pointer(alens + uintptr(next)*4)) != 0) { + if !(next < nqueries && **(**int32)(__ccgo_up(alens + uintptr(next)*4)) != 0) { break } goto _19 @@ -124809,18 +124809,18 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a next = next + 1 } } else { - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(answers + uintptr(i)*8)), *(*uintptr)(unsafe.Pointer(answers + uintptr(next)*8)), Uint64FromInt32(rlen)) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(answers + uintptr(i)*8)), **(**uintptr)(__ccgo_up(answers + uintptr(next)*8)), Uint64FromInt32(rlen)) } /* Ignore further UDP if all slots full or TCP-mode */ if next == nqueries { (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), nqueries*8))).Fevents = 0 } /* If answer is truncated (TC bit), fallback to TCP */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(answers + uintptr(i)*8)) + 2)))&int32(2) != 0 || (*(*Tmsghdr)(unsafe.Pointer(bp + 232))).Fmsg_flags&int32(MSG_TRUNC) != 0 { - *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) = -int32(1) + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(answers + uintptr(i)*8)) + 2)))&int32(2) != 0 || (**(**Tmsghdr)(__ccgo_up(bp + 232))).Fmsg_flags&int32(MSG_TRUNC) != 0 { + **(**int32)(__ccgo_up(alens + uintptr(i)*4)) = -int32(1) _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), uintptr(0)) - r = _start_tcp(tls, pfd+uintptr(i)*8, family, bp+116+uintptr(j)*28, sl, *(*uintptr)(unsafe.Pointer(queries + uintptr(i)*8)), *(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 200)), uintptr(0)) + r = _start_tcp(tls, pfd+uintptr(i)*8, family, bp+116+uintptr(j)*28, sl, **(**uintptr)(__ccgo_up(queries + uintptr(i)*8)), **(**int32)(__ccgo_up(qlens + uintptr(i)*4))) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 200)), uintptr(0)) if r >= 0 { *(*int32)(unsafe.Add(unsafe.Pointer(qpos), i*4)) = r *(*int32)(unsafe.Add(unsafe.Pointer(apos), i*4)) = 0 @@ -124835,8 +124835,8 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a } if int32((*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), i*8))).Frevents)&int32(POLLOUT) != 0 { *(*[2]Tuint8_t)(unsafe.Pointer(bp + 52)) = [2]Tuint8_t{ - 0: Uint8FromInt32(*(*int32)(unsafe.Pointer(qlens + uintptr(i)*4)) >> int32(8)), - 1: Uint8FromInt32(*(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))), + 0: Uint8FromInt32(**(**int32)(__ccgo_up(qlens + uintptr(i)*4)) >> int32(8)), + 1: Uint8FromInt32(**(**int32)(__ccgo_up(qlens + uintptr(i)*4))), } *(*[2]Tiovec)(unsafe.Pointer(bp + 24)) = [2]Tiovec{ 0: { @@ -124844,11 +124844,11 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a Fiov_len: uint64(2), }, 1: { - Fiov_base: *(*uintptr)(unsafe.Pointer(queries + uintptr(i)*8)), - Fiov_len: Uint64FromInt32(*(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))), + Fiov_base: **(**uintptr)(__ccgo_up(queries + uintptr(i)*8)), + Fiov_len: Uint64FromInt32(**(**int32)(__ccgo_up(qlens + uintptr(i)*4))), }, } - *(*Tmsghdr)(unsafe.Pointer(bp + 288)) = Tmsghdr{ + **(**Tmsghdr)(__ccgo_up(bp + 288)) = Tmsghdr{ Fmsg_iov: bp + 24, Fmsg_iovlen: int32(2), } @@ -124857,8 +124857,8 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a if r < 0 { goto out } - *(*int32)(unsafe.Pointer(qpos + uintptr(i)*4)) += r - if *(*int32)(unsafe.Add(unsafe.Pointer(qpos), i*4)) == *(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))+int32(2) { + **(**int32)(__ccgo_up(qpos + uintptr(i)*4)) += r + if *(*int32)(unsafe.Add(unsafe.Pointer(qpos), i*4)) == **(**int32)(__ccgo_up(qlens + uintptr(i)*4))+int32(2) { (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), i*8))).Fevents = int16(POLLIN) } } @@ -124879,11 +124879,11 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a Fiov_len: uint64(2), }, 1: { - Fiov_base: *(*uintptr)(unsafe.Pointer(answers + uintptr(i)*8)), + Fiov_base: **(**uintptr)(__ccgo_up(answers + uintptr(i)*8)), Fiov_len: Uint64FromInt32(asize), }, } - *(*Tmsghdr)(unsafe.Pointer(bp + 344)) = Tmsghdr{ + **(**Tmsghdr)(__ccgo_up(bp + 344)) = Tmsghdr{ Fmsg_iov: bp + 56, Fmsg_iovlen: int32(2), } @@ -124892,25 +124892,25 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a if r <= 0 { goto out } - *(*int32)(unsafe.Pointer(apos + uintptr(i)*4)) += r + **(**int32)(__ccgo_up(apos + uintptr(i)*4)) += r if *(*int32)(unsafe.Add(unsafe.Pointer(apos), i*4)) < int32(2) { goto _21 } - alen = Int32FromUint8(*(*uint8)(unsafe.Pointer(alen_buf + uintptr(i)*2)))*int32(256) + Int32FromUint8(*(*uint8)(unsafe.Pointer(alen_buf + uintptr(i)*2 + 1))) + alen = Int32FromUint8(**(**uint8)(__ccgo_up(alen_buf + uintptr(i)*2)))*int32(256) + Int32FromUint8(**(**uint8)(__ccgo_up(alen_buf + uintptr(i)*2 + 1))) if alen < int32(13) { goto out } if *(*int32)(unsafe.Add(unsafe.Pointer(apos), i*4)) < alen+int32(2) && *(*int32)(unsafe.Add(unsafe.Pointer(apos), i*4)) < asize+int32(2) { goto _21 } - rcode = Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(answers + uintptr(i)*8)) + 3))) & int32(15) + rcode = Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(answers + uintptr(i)*8)) + 3))) & int32(15) if rcode != 0 && rcode != int32(3) { goto out } /* Storing the length here commits the accepted answer. * Immediately close TCP socket so as not to consume * resources we no longer need. */ - *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) = alen + **(**int32)(__ccgo_up(alens + uintptr(i)*4)) = alen X__syscall1(tls, int64(SYS_close), int64((*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), i*8))).Ffd)) (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), i*8))).Ffd = -int32(1) } @@ -124934,8 +124934,8 @@ out: if !(i < nqueries) { break } - if *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) < 0 { - *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) = 0 + if **(**int32)(__ccgo_up(alens + uintptr(i)*4)) < 0 { + **(**int32)(__ccgo_up(alens + uintptr(i)*4)) = 0 } goto _22 _22: @@ -124973,23 +124973,23 @@ func X__res_send(tls *TLS, _msg uintptr, _msglen int32, _answer uintptr, _anslen var r, v1 int32 var _ /* buf at bp+28 */ [512]uint8 _, _ = r, v1 - if *(*int32)(unsafe.Pointer(bp + 24)) < int32(512) { - r = X__res_send(tls, *(*uintptr)(unsafe.Pointer(bp)), *(*int32)(unsafe.Pointer(bp + 8)), bp+28, int32(512)) + if **(**int32)(__ccgo_up(bp + 24)) < int32(512) { + r = X__res_send(tls, **(**uintptr)(__ccgo_up(bp)), **(**int32)(__ccgo_up(bp + 8)), bp+28, int32(512)) if r >= 0 { - if r < *(*int32)(unsafe.Pointer(bp + 24)) { + if r < **(**int32)(__ccgo_up(bp + 24)) { v1 = r } else { - v1 = *(*int32)(unsafe.Pointer(bp + 24)) + v1 = **(**int32)(__ccgo_up(bp + 24)) } - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(bp + 16)), bp+28, Uint64FromInt32(v1)) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(bp + 16)), bp+28, Uint64FromInt32(v1)) } return r } - r = X__res_msend(tls, int32(1), bp, bp+8, bp+16, bp+24, *(*int32)(unsafe.Pointer(bp + 24))) - if r < 0 || !(*(*int32)(unsafe.Pointer(bp + 24)) != 0) { + r = X__res_msend(tls, int32(1), bp, bp+8, bp+16, bp+24, **(**int32)(__ccgo_up(bp + 24))) + if r < 0 || !(**(**int32)(__ccgo_up(bp + 24)) != 0) { v1 = -int32(1) } else { - v1 = *(*int32)(unsafe.Pointer(bp + 24)) + v1 = **(**int32)(__ccgo_up(bp + 24)) } return v1 } @@ -125036,11 +125036,11 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ (*Tresolvconf)(unsafe.Pointer(conf)).Ftimeout = uint32(5) (*Tresolvconf)(unsafe.Pointer(conf)).Fattempts = uint32(2) if search != 0 { - *(*uint8)(unsafe.Pointer(search)) = uint8(0) + **(**uint8)(__ccgo_up(search)) = uint8(0) } f = X__fopen_rb_ca(tls, __ccgo_ts+1191, bp+512, bp+256, uint64(256)) if !(f != 0) { - switch *(*int32)(unsafe.Pointer(X__errno_location(tls))) { + switch **(**int32)(__ccgo_up(X__errno_location(tls))) { case int32(ENOENT): fallthrough case int32(ENOTDIR): @@ -125059,17 +125059,17 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ continue } if v4 = !(Xstrncmp(tls, bp, __ccgo_ts+1208, uint64(7)) != 0); v4 { - v1 = Int32FromUint8((*(*[256]uint8)(unsafe.Pointer(bp)))[int32(7)]) + v1 = Int32FromUint8((**(**[256]uint8)(__ccgo_up(bp)))[int32(7)]) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _3 _3: } if v4 && v2 != 0 { p = Xstrstr(tls, bp, __ccgo_ts+1216) - if p != 0 && BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p + 6)))-uint32('0') < uint32(10)) != 0 { + if p != 0 && BoolInt32(uint32(**(**uint8)(__ccgo_up(p + 6)))-uint32('0') < uint32(10)) != 0 { p = p + uintptr(6) x = Xstrtoul(tls, p, bp+744, int32(10)) - if *(*uintptr)(unsafe.Pointer(bp + 744)) != p { + if **(**uintptr)(__ccgo_up(bp + 744)) != p { if x > uint64(15) { v5 = uint64(15) } else { @@ -125079,10 +125079,10 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ } } p = Xstrstr(tls, bp, __ccgo_ts+1223) - if p != 0 && BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p + 9)))-uint32('0') < uint32(10)) != 0 { + if p != 0 && BoolInt32(uint32(**(**uint8)(__ccgo_up(p + 9)))-uint32('0') < uint32(10)) != 0 { p = p + uintptr(9) x1 = Xstrtoul(tls, p, bp+744, int32(10)) - if *(*uintptr)(unsafe.Pointer(bp + 744)) != p { + if **(**uintptr)(__ccgo_up(bp + 744)) != p { if x1 > uint64(10) { v5 = uint64(10) } else { @@ -125092,10 +125092,10 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ } } p = Xstrstr(tls, bp, __ccgo_ts+1233) - if p != 0 && (BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p + 8)))-uint32('0') < uint32(10)) != 0 || Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 8))) == int32('.')) { + if p != 0 && (BoolInt32(uint32(**(**uint8)(__ccgo_up(p + 8)))-uint32('0') < uint32(10)) != 0 || Int32FromUint8(**(**uint8)(__ccgo_up(p + 8))) == int32('.')) { p = p + uintptr(8) x2 = Xstrtoul(tls, p, bp+744, int32(10)) - if *(*uintptr)(unsafe.Pointer(bp + 744)) != p { + if **(**uintptr)(__ccgo_up(bp + 744)) != p { if x2 > uint64(60) { v5 = uint64(60) } else { @@ -125107,7 +125107,7 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ continue } if v4 = !(Xstrncmp(tls, bp, __ccgo_ts+1242, uint64(10)) != 0); v4 { - v1 = Int32FromUint8((*(*[256]uint8)(unsafe.Pointer(bp)))[int32(10)]) + v1 = Int32FromUint8((**(**[256]uint8)(__ccgo_up(bp)))[int32(10)]) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _10 _10: @@ -125118,7 +125118,7 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ } p = bp + uintptr(11) for { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _15 _15: @@ -125130,10 +125130,10 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ ; p = p + 1 } - *(*uintptr)(unsafe.Pointer(bp + 744)) = p + **(**uintptr)(__ccgo_up(bp + 744)) = p for { - if v4 = *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 744)))) != 0; v4 { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 744))))) + if v4 = **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 744)))) != 0; v4 { + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 744))))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _19 _19: @@ -125144,9 +125144,9 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ goto _16 _16: ; - *(*uintptr)(unsafe.Pointer(bp + 744)) = *(*uintptr)(unsafe.Pointer(bp + 744)) + 1 + **(**uintptr)(__ccgo_up(bp + 744)) = **(**uintptr)(__ccgo_up(bp + 744)) + 1 } - *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 744)))) = uint8(0) + **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 744)))) = uint8(0) if X__lookup_ipliteral(tls, conf+uintptr(nns)*28, p, PF_UNSPEC) > 0 { nns = nns + 1 } @@ -125156,7 +125156,7 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ continue } if v4 = Xstrncmp(tls, bp, __ccgo_ts+1253, uint64(6)) != 0 && Xstrncmp(tls, bp, __ccgo_ts+1260, uint64(6)) != 0; !v4 { - v1 = Int32FromUint8((*(*[256]uint8)(unsafe.Pointer(bp)))[int32(6)]) + v1 = Int32FromUint8((**(**[256]uint8)(__ccgo_up(bp)))[int32(6)]) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _23 _23: @@ -125166,7 +125166,7 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ } p = bp + uintptr(7) for { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _28 _28: @@ -125232,7 +125232,7 @@ func Xsendmmsg(tls *TLS, fd int32, msgvec uintptr, vlen uint32, flags uint32) (r if r < 0 { goto error } - (*(*Tmmsghdr)(unsafe.Pointer(msgvec + uintptr(i)*64))).Fmsg_len = Uint32FromInt64(r) + (**(**Tmmsghdr)(__ccgo_up(msgvec + uintptr(i)*64))).Fmsg_len = Uint32FromInt64(r) goto _1 _1: ; @@ -125265,18 +125265,18 @@ func Xsendmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r1 Tssize_t) { var _ /* h at bp+96 */ Tmsghdr _, _, _, _, _, _, _, _, _, _, _, _, _ = c1, r, v1, v10, v11, v12, v13, v14, v3, v5, v6, v8, v9 if msg != 0 { - *(*Tmsghdr)(unsafe.Pointer(bp + 96)) = *(*Tmsghdr)(unsafe.Pointer(msg)) + **(**Tmsghdr)(__ccgo_up(bp + 96)) = **(**Tmsghdr)(__ccgo_up(msg)) v1 = Int32FromInt32(0) - (*(*Tmsghdr)(unsafe.Pointer(bp + 96))).F__pad2 = v1 - (*(*Tmsghdr)(unsafe.Pointer(bp + 96))).F__pad1 = v1 + (**(**Tmsghdr)(__ccgo_up(bp + 96))).F__pad2 = v1 + (**(**Tmsghdr)(__ccgo_up(bp + 96))).F__pad1 = v1 msg = bp + 96 - if (*(*Tmsghdr)(unsafe.Pointer(bp + 96))).Fmsg_controllen != 0 { - if uint64((*(*Tmsghdr)(unsafe.Pointer(bp + 96))).Fmsg_controllen) > uint64(1056) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + if (**(**Tmsghdr)(__ccgo_up(bp + 96))).Fmsg_controllen != 0 { + if uint64((**(**Tmsghdr)(__ccgo_up(bp + 96))).Fmsg_controllen) > uint64(1056) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return int64(-int32(1)) } - Xmemcpy(tls, bp+152, (*(*Tmsghdr)(unsafe.Pointer(bp + 96))).Fmsg_control, uint64((*(*Tmsghdr)(unsafe.Pointer(bp + 96))).Fmsg_controllen)) - (*(*Tmsghdr)(unsafe.Pointer(bp + 96))).Fmsg_control = bp + 152 + Xmemcpy(tls, bp+152, (**(**Tmsghdr)(__ccgo_up(bp + 96))).Fmsg_control, uint64((**(**Tmsghdr)(__ccgo_up(bp + 96))).Fmsg_controllen)) + (**(**Tmsghdr)(__ccgo_up(bp + 96))).Fmsg_control = bp + 152 if uint64((*Tmsghdr)(unsafe.Pointer(bp+96)).Fmsg_controllen) >= uint64(16) { v3 = (*Tmsghdr)(unsafe.Pointer(bp + 96)).Fmsg_control } else { @@ -125685,7 +125685,7 @@ func Xsockatmark(tls *TLS, s int32) (r int32) { if Xioctl(tls, s, int32(SIOCATMARK), VaList(bp+16, bp)) < 0 { return -int32(1) } - return *(*int32)(unsafe.Pointer(bp)) + return **(**int32)(__ccgo_up(bp)) } func Xsocket(tls *TLS, domain int32, type1 int32, protocol int32) (r1 int32) { @@ -125853,7 +125853,7 @@ func Xsocketpair(tls *TLS, domain int32, type1 int32, protocol int32, fd uintptr goto _11 _11: r1 = int32(X__syscall_ret(tls, Uint64FromInt64(v10))) - if r1 < 0 && (*(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EINVAL) || *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EPROTONOSUPPORT)) && type1&(Int32FromInt32(SOCK_CLOEXEC)|Int32FromInt32(SOCK_NONBLOCK)) != 0 { + if r1 < 0 && (**(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EINVAL) || **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EPROTONOSUPPORT)) && type1&(Int32FromInt32(SOCK_CLOEXEC)|Int32FromInt32(SOCK_NONBLOCK)) != 0 { v12 = int32(SYS_socketpair) v13 = int32(__SC_socketpair) v14 = 0 @@ -125901,12 +125901,12 @@ _11: return r1 } if type1&int32(SOCK_CLOEXEC) != 0 { - X__syscall3(tls, int64(SYS_fcntl), int64(*(*int32)(unsafe.Pointer(fd))), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) - X__syscall3(tls, int64(SYS_fcntl), int64(*(*int32)(unsafe.Pointer(fd + 1*4))), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) + X__syscall3(tls, int64(SYS_fcntl), int64(**(**int32)(__ccgo_up(fd))), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) + X__syscall3(tls, int64(SYS_fcntl), int64(**(**int32)(__ccgo_up(fd + 1*4))), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) } if type1&int32(SOCK_NONBLOCK) != 0 { - X__syscall3(tls, int64(SYS_fcntl), int64(*(*int32)(unsafe.Pointer(fd))), int64(Int32FromInt32(F_SETFL)), int64(Int32FromInt32(O_NONBLOCK))) - X__syscall3(tls, int64(SYS_fcntl), int64(*(*int32)(unsafe.Pointer(fd + 1*4))), int64(Int32FromInt32(F_SETFL)), int64(Int32FromInt32(O_NONBLOCK))) + X__syscall3(tls, int64(SYS_fcntl), int64(**(**int32)(__ccgo_up(fd))), int64(Int32FromInt32(F_SETFL)), int64(Int32FromInt32(O_NONBLOCK))) + X__syscall3(tls, int64(SYS_fcntl), int64(**(**int32)(__ccgo_up(fd + 1*4))), int64(Int32FromInt32(F_SETFL)), int64(Int32FromInt32(O_NONBLOCK))) } } return r1 @@ -125943,10 +125943,10 @@ func Xfgetgrent(tls *TLS, f uintptr) (r uintptr) { var _ /* nmem at bp+16 */ Tsize_t var _ /* res at bp+0 */ uintptr var _ /* size at bp+8 */ Tsize_t - *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint64(0) - *(*Tsize_t)(unsafe.Pointer(bp + 16)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp + 8)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp + 16)) = uint64(0) X__getgrent_a(tls, f, uintptr(unsafe.Pointer(&_gr)), uintptr(unsafe.Pointer(&_line1)), bp+8, uintptr(unsafe.Pointer(&_mem)), bp+16, bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } var _line1 uintptr @@ -125964,9 +125964,9 @@ func Xfgetpwent(tls *TLS, f uintptr) (r uintptr) { defer tls.Free(16) var _ /* res at bp+8 */ uintptr var _ /* size at bp+0 */ Tsize_t - *(*Tsize_t)(unsafe.Pointer(bp)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp)) = uint64(0) X__getpwent_a(tls, f, uintptr(unsafe.Pointer(&_pw)), uintptr(unsafe.Pointer(&_line2)), bp, bp+8) - return *(*uintptr)(unsafe.Pointer(bp + 8)) + return **(**uintptr)(__ccgo_up(bp + 8)) } var _line2 uintptr @@ -126012,11 +126012,11 @@ func _itoa1(tls *TLS, p uintptr, x Tuint32_t) (r uintptr) { p = p + uintptr(11) p = p - 1 v1 = p - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) for cond := true; cond; cond = x != 0 { p = p - 1 v1 = p - *(*uint8)(unsafe.Pointer(v1)) = uint8(uint32('0') + x%uint32(10)) + **(**uint8)(__ccgo_up(v1)) = uint8(uint32('0') + x%uint32(10)) x = x / uint32(10) } return p @@ -126041,36 +126041,36 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz var _ /* swap at bp+40 */ int32 _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, grlist_len, i, key, len1, ptr, req, rv, tmp, tmp1, v1, v10, v5, v6 rv = 0 - *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) + **(**uintptr)(__ccgo_up(res)) = uintptr(0) _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp) f = Xfopen(tls, __ccgo_ts+1277, __ccgo_ts+412) if !(f != 0) { - rv = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + rv = **(**int32)(__ccgo_up(X__errno_location(tls))) goto done } for { v1 = X__getgrent_a(tls, f, gr, buf, size, mem, nmem, res) rv = v1 - if !(!(v1 != 0) && *(*uintptr)(unsafe.Pointer(res)) != 0) { + if !(!(v1 != 0) && **(**uintptr)(__ccgo_up(res)) != 0) { break } - if name != 0 && !(Xstrcmp(tls, name, (*Tgroup)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(res)))).Fgr_name) != 0) || !(name != 0) && (*Tgroup)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(res)))).Fgr_gid == gid { + if name != 0 && !(Xstrcmp(tls, name, (*Tgroup)(unsafe.Pointer(**(**uintptr)(__ccgo_up(res)))).Fgr_name) != 0) || !(name != 0) && (*Tgroup)(unsafe.Pointer(**(**uintptr)(__ccgo_up(res)))).Fgr_gid == gid { break } } Xfclose(tls, f) - if !(*(*uintptr)(unsafe.Pointer(res)) != 0) && (rv == 0 || rv == int32(ENOENT) || rv == int32(ENOTDIR)) { + if !(**(**uintptr)(__ccgo_up(res)) != 0) && (rv == 0 || rv == int32(ENOENT) || rv == int32(ENOTDIR)) { if name != 0 { v1 = int32(GETGRBYNAME) } else { v1 = int32(GETGRBYGID) } req = v1 - *(*[6]Tint32_t)(unsafe.Pointer(bp + 4)) = [6]Tint32_t{} + **(**[6]Tint32_t)(__ccgo_up(bp + 4)) = [6]Tint32_t{} len1 = uint64(0) grlist_len = uint64(0) - *(*[11]uint8)(unsafe.Pointer(bp + 28)) = [11]uint8{} - *(*int32)(unsafe.Pointer(bp + 40)) = 0 + **(**[11]uint8)(__ccgo_up(bp + 28)) = [11]uint8{} + **(**int32)(__ccgo_up(bp + 40)) = 0 if name != 0 { key = name } else { @@ -126082,116 +126082,116 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz } f = X__nscd_query(tls, req, key, bp+4, uint64(24), bp+40) if !(f != 0) { - rv = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + rv = **(**int32)(__ccgo_up(X__errno_location(tls))) goto done } - if !((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRFOUND)] != 0) { + if !((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRFOUND)] != 0) { rv = 0 goto cleanup_f } - if !((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRNAMELEN)] != 0) || !((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRPASSWDLEN)] != 0) { + if !((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRNAMELEN)] != 0) || !((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRPASSWDLEN)] != 0) { rv = int32(EIO) goto cleanup_f } - if Uint64FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRNAMELEN)]) > uint64(0xffffffffffffffff)-Uint64FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRPASSWDLEN)]) { + if Uint64FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRNAMELEN)]) > uint64(0xffffffffffffffff)-Uint64FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRPASSWDLEN)]) { rv = int32(ENOMEM) goto cleanup_f } - len1 = Uint64FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRNAMELEN)] + (*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRPASSWDLEN)]) + len1 = Uint64FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRNAMELEN)] + (**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRPASSWDLEN)]) i = 0 for { - if !(i < (*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)]) { + if !(i < (**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)]) { break } if Xfread(tls, bp+44, uint64(4), uint64(1), f) < uint64(1) { if Xferror(tls, f) != 0 { - v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = **(**int32)(__ccgo_up(X__errno_location(tls))) } else { v1 = int32(EIO) } rv = v1 goto cleanup_f } - if *(*int32)(unsafe.Pointer(bp + 40)) != 0 { - v5 = *(*Tuint32_t)(unsafe.Pointer(bp + 44)) + if **(**int32)(__ccgo_up(bp + 40)) != 0 { + v5 = **(**Tuint32_t)(__ccgo_up(bp + 44)) v6 = v5>>int32(24) | v5>>int32(8)&uint32(0xff00) | v5< uint64(0xffffffffffffffff)-grlist_len || uint64(*(*Tuint32_t)(unsafe.Pointer(bp + 44))) > uint64(0xffffffffffffffff)-len1 { + if uint64(**(**Tuint32_t)(__ccgo_up(bp + 44))) > uint64(0xffffffffffffffff)-grlist_len || uint64(**(**Tuint32_t)(__ccgo_up(bp + 44))) > uint64(0xffffffffffffffff)-len1 { rv = int32(ENOMEM) goto cleanup_f } - len1 = len1 + uint64(*(*Tuint32_t)(unsafe.Pointer(bp + 44))) - grlist_len = grlist_len + uint64(*(*Tuint32_t)(unsafe.Pointer(bp + 44))) + len1 = len1 + uint64(**(**Tuint32_t)(__ccgo_up(bp + 44))) + grlist_len = grlist_len + uint64(**(**Tuint32_t)(__ccgo_up(bp + 44))) goto _3 _3: ; i = i + 1 } - if len1 > *(*Tsize_t)(unsafe.Pointer(size)) || !(*(*uintptr)(unsafe.Pointer(buf)) != 0) { - tmp = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(buf)), len1) + if len1 > **(**Tsize_t)(__ccgo_up(size)) || !(**(**uintptr)(__ccgo_up(buf)) != 0) { + tmp = Xrealloc(tls, **(**uintptr)(__ccgo_up(buf)), len1) if !(tmp != 0) { - rv = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + rv = **(**int32)(__ccgo_up(X__errno_location(tls))) goto cleanup_f } - *(*uintptr)(unsafe.Pointer(buf)) = tmp - *(*Tsize_t)(unsafe.Pointer(size)) = len1 + **(**uintptr)(__ccgo_up(buf)) = tmp + **(**Tsize_t)(__ccgo_up(size)) = len1 } - if !(Xfread(tls, *(*uintptr)(unsafe.Pointer(buf)), len1, uint64(1), f) != 0) { + if !(Xfread(tls, **(**uintptr)(__ccgo_up(buf)), len1, uint64(1), f) != 0) { if Xferror(tls, f) != 0 { - v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = **(**int32)(__ccgo_up(X__errno_location(tls))) } else { v1 = int32(EIO) } rv = v1 goto cleanup_f } - if Uint64FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)]+int32(1)) > *(*Tsize_t)(unsafe.Pointer(nmem)) { - if Uint64FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)]+int32(1)) > Uint64FromUint64(0xffffffffffffffff)/Uint64FromInt64(8) { + if Uint64FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)]+int32(1)) > **(**Tsize_t)(__ccgo_up(nmem)) { + if Uint64FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)]+int32(1)) > Uint64FromUint64(0xffffffffffffffff)/Uint64FromInt64(8) { rv = int32(ENOMEM) goto cleanup_f } - tmp1 = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(mem)), Uint64FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)]+Int32FromInt32(1))*uint64(8)) + tmp1 = Xrealloc(tls, **(**uintptr)(__ccgo_up(mem)), Uint64FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)]+Int32FromInt32(1))*uint64(8)) if !(tmp1 != 0) { - rv = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + rv = **(**int32)(__ccgo_up(X__errno_location(tls))) goto cleanup_f } - *(*uintptr)(unsafe.Pointer(mem)) = tmp1 - *(*Tsize_t)(unsafe.Pointer(nmem)) = Uint64FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)] + int32(1)) + **(**uintptr)(__ccgo_up(mem)) = tmp1 + **(**Tsize_t)(__ccgo_up(nmem)) = Uint64FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)] + int32(1)) } - if (*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)] != 0 { - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)))) = *(*uintptr)(unsafe.Pointer(buf)) + uintptr((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRNAMELEN)]) + uintptr((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRPASSWDLEN)]) - ptr = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)))) + if (**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)] != 0 { + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)))) = **(**uintptr)(__ccgo_up(buf)) + uintptr((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRNAMELEN)]) + uintptr((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRPASSWDLEN)]) + ptr = **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)))) i = Int32FromInt32(0) for { - if !(ptr != *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem))))+uintptr(grlist_len)) { + if !(ptr != **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem))))+uintptr(grlist_len)) { break } - if !(*(*uint8)(unsafe.Pointer(ptr)) != 0) { + if !(**(**uint8)(__ccgo_up(ptr)) != 0) { i = i + 1 v10 = i - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v10)*8)) = ptr + uintptr(1) + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)) + uintptr(v10)*8)) = ptr + uintptr(1) } goto _9 _9: ; ptr = ptr + 1 } - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(i)*8)) = uintptr(0) - if i != (*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)] { + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)) + uintptr(i)*8)) = uintptr(0) + if i != (**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)] { rv = int32(EIO) goto cleanup_f } } else { - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)))) = uintptr(0) + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)))) = uintptr(0) } - (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = *(*uintptr)(unsafe.Pointer(buf)) - (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = (*Tgroup)(unsafe.Pointer(gr)).Fgr_name + uintptr((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRNAMELEN)]) - (*Tgroup)(unsafe.Pointer(gr)).Fgr_gid = Uint32FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRGID)]) - (*Tgroup)(unsafe.Pointer(gr)).Fgr_mem = *(*uintptr)(unsafe.Pointer(mem)) - if *(*uint8)(unsafe.Pointer((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd + uintptr(-Int32FromInt32(1)))) != 0 || *(*uint8)(unsafe.Pointer((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd + uintptr((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRPASSWDLEN)]-int32(1)))) != 0 { + (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = **(**uintptr)(__ccgo_up(buf)) + (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = (*Tgroup)(unsafe.Pointer(gr)).Fgr_name + uintptr((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRNAMELEN)]) + (*Tgroup)(unsafe.Pointer(gr)).Fgr_gid = Uint32FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRGID)]) + (*Tgroup)(unsafe.Pointer(gr)).Fgr_mem = **(**uintptr)(__ccgo_up(mem)) + if **(**uint8)(__ccgo_up((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd + uintptr(-Int32FromInt32(1)))) != 0 || **(**uint8)(__ccgo_up((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd + uintptr((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRPASSWDLEN)]-int32(1)))) != 0 { rv = int32(EIO) goto cleanup_f } @@ -126199,7 +126199,7 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz rv = int32(EIO) goto cleanup_f } - *(*uintptr)(unsafe.Pointer(res)) = gr + **(**uintptr)(__ccgo_up(res)) = gr goto cleanup_f cleanup_f: ; @@ -126209,9 +126209,9 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz goto done done: ; - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) if rv != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = rv + **(**int32)(__ccgo_up(X__errno_location(tls))) = rv } return rv } @@ -126227,42 +126227,42 @@ func _getgr_r(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, size var _ /* mem at bp+16 */ uintptr var _ /* nmem at bp+24 */ Tsize_t _, _ = i, rv - *(*uintptr)(unsafe.Pointer(bp)) = uintptr(0) - *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint64(0) - *(*uintptr)(unsafe.Pointer(bp + 16)) = uintptr(0) - *(*Tsize_t)(unsafe.Pointer(bp + 24)) = uint64(0) + **(**uintptr)(__ccgo_up(bp)) = uintptr(0) + **(**Tsize_t)(__ccgo_up(bp + 8)) = uint64(0) + **(**uintptr)(__ccgo_up(bp + 16)) = uintptr(0) + **(**Tsize_t)(__ccgo_up(bp + 24)) = uint64(0) rv = 0 _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp+32) rv = X__getgr_a(tls, name, gid, gr, bp, bp+8, bp+16, bp+24, res) - if *(*uintptr)(unsafe.Pointer(res)) != 0 && size < *(*Tsize_t)(unsafe.Pointer(bp + 8))+(*(*Tsize_t)(unsafe.Pointer(bp + 24))+uint64(1))*uint64(8)+uint64(32) { - *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) + if **(**uintptr)(__ccgo_up(res)) != 0 && size < **(**Tsize_t)(__ccgo_up(bp + 8))+(**(**Tsize_t)(__ccgo_up(bp + 24))+uint64(1))*uint64(8)+uint64(32) { + **(**uintptr)(__ccgo_up(res)) = uintptr(0) rv = int32(ERANGE) } - if *(*uintptr)(unsafe.Pointer(res)) != 0 { + if **(**uintptr)(__ccgo_up(res)) != 0 { buf = buf + uintptr((uint64(16)-uint64(buf))%uint64(16)) (*Tgroup)(unsafe.Pointer(gr)).Fgr_mem = buf - buf = buf + uintptr((*(*Tsize_t)(unsafe.Pointer(bp + 24))+uint64(1))*uint64(8)) - Xmemcpy(tls, buf, *(*uintptr)(unsafe.Pointer(bp)), *(*Tsize_t)(unsafe.Pointer(bp + 8))) - (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = uintptr(int64((*Tgroup)(unsafe.Pointer(gr)).Fgr_name)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf - (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = uintptr(int64((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf + buf = buf + uintptr((**(**Tsize_t)(__ccgo_up(bp + 24))+uint64(1))*uint64(8)) + Xmemcpy(tls, buf, **(**uintptr)(__ccgo_up(bp)), **(**Tsize_t)(__ccgo_up(bp + 8))) + (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = uintptr(int64((*Tgroup)(unsafe.Pointer(gr)).Fgr_name)-int64(**(**uintptr)(__ccgo_up(bp)))) + buf + (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = uintptr(int64((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd)-int64(**(**uintptr)(__ccgo_up(bp)))) + buf i = uint64(0) for { - if !(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + uintptr(i)*8)) != 0) { + if !(**(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 16)) + uintptr(i)*8)) != 0) { break } - *(*uintptr)(unsafe.Pointer((*Tgroup)(unsafe.Pointer(gr)).Fgr_mem + uintptr(i)*8)) = uintptr(int64(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + uintptr(i)*8)))-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf + **(**uintptr)(__ccgo_up((*Tgroup)(unsafe.Pointer(gr)).Fgr_mem + uintptr(i)*8)) = uintptr(int64(**(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 16)) + uintptr(i)*8)))-int64(**(**uintptr)(__ccgo_up(bp)))) + buf goto _1 _1: ; i = i + 1 } - *(*uintptr)(unsafe.Pointer((*Tgroup)(unsafe.Pointer(gr)).Fgr_mem + uintptr(i)*8)) = uintptr(0) + **(**uintptr)(__ccgo_up((*Tgroup)(unsafe.Pointer(gr)).Fgr_mem + uintptr(i)*8)) = uintptr(0) } - Xfree(tls, *(*uintptr)(unsafe.Pointer(bp + 16))) - Xfree(tls, *(*uintptr)(unsafe.Pointer(bp))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 32)), uintptr(0)) + Xfree(tls, **(**uintptr)(__ccgo_up(bp + 16))) + Xfree(tls, **(**uintptr)(__ccgo_up(bp))) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 32)), uintptr(0)) if rv != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = rv + **(**int32)(__ccgo_up(X__errno_location(tls))) = rv } return rv } @@ -126308,8 +126308,8 @@ func Xgetgrent(tls *TLS) (r uintptr) { var _ /* nmem at bp+16 */ Tsize_t var _ /* res at bp+0 */ uintptr var _ /* size at bp+8 */ Tsize_t - *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint64(0) - *(*Tsize_t)(unsafe.Pointer(bp + 16)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp + 8)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp + 16)) = uint64(0) if !(_f1 != 0) { _f1 = Xfopen(tls, __ccgo_ts+1277, __ccgo_ts+412) } @@ -126317,7 +126317,7 @@ func Xgetgrent(tls *TLS) (r uintptr) { return uintptr(0) } X__getgrent_a(tls, _f1, uintptr(unsafe.Pointer(&_gr1)), uintptr(unsafe.Pointer(&_line3)), bp+8, uintptr(unsafe.Pointer(&_mem1)), bp+16, bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func Xgetgrgid(tls *TLS, gid Tgid_t) (r uintptr) { @@ -126330,10 +126330,10 @@ func Xgetgrgid(tls *TLS, gid Tgid_t) (r uintptr) { var _ /* nmem at bp+16 */ Tsize_t var _ /* res at bp+0 */ uintptr var _ /* size at bp+8 */ Tsize_t - *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint64(0) - *(*Tsize_t)(unsafe.Pointer(bp + 16)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp + 8)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp + 16)) = uint64(0) X__getgr_a(tls, uintptr(0), gid, uintptr(unsafe.Pointer(&_gr1)), uintptr(unsafe.Pointer(&_line3)), bp+8, uintptr(unsafe.Pointer(&_mem1)), bp+16, bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func Xgetgrnam(tls *TLS, name uintptr) (r uintptr) { @@ -126346,10 +126346,10 @@ func Xgetgrnam(tls *TLS, name uintptr) (r uintptr) { var _ /* nmem at bp+16 */ Tsize_t var _ /* res at bp+0 */ uintptr var _ /* size at bp+8 */ Tsize_t - *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint64(0) - *(*Tsize_t)(unsafe.Pointer(bp + 16)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp + 8)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp + 16)) = uint64(0) X__getgr_a(tls, name, uint32(0), uintptr(unsafe.Pointer(&_gr1)), uintptr(unsafe.Pointer(&_line3)), bp+8, uintptr(unsafe.Pointer(&_mem1)), bp+16, bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func Xendgrent(tls *TLS) { @@ -126364,14 +126364,14 @@ func _atou(tls *TLS, s uintptr) (r uint32) { _ = x x = uint32(0) for { - if !(Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-int32('0')) < uint32(10)) { + if !(Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-int32('0')) < uint32(10)) { break } - x = uint32(10)*x + Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-Int32FromUint8('0')) + x = uint32(10)*x + Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-Int32FromUint8('0')) goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s)) = *(*uintptr)(unsafe.Pointer(s)) + 1 + **(**uintptr)(__ccgo_up(s)) = **(**uintptr)(__ccgo_up(s)) + 1 } return x } @@ -126397,107 +126397,107 @@ func X__getgrent_a(tls *TLS, f uintptr, gr uintptr, line uintptr, size uintptr, l = v2 if v2 < 0 { if Xferror(tls, f) != 0 { - v3 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v3 = **(**int32)(__ccgo_up(X__errno_location(tls))) } else { v3 = 0 } rv = v3 - Xfree(tls, *(*uintptr)(unsafe.Pointer(line))) - *(*uintptr)(unsafe.Pointer(line)) = uintptr(0) + Xfree(tls, **(**uintptr)(__ccgo_up(line))) + **(**uintptr)(__ccgo_up(line)) = uintptr(0) gr = uintptr(0) goto end } - *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(line)) + uintptr(l-int64(1)))) = uint8(0) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(line)) - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(line)) + uintptr(l-int64(1)))) = uint8(0) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(line)) + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = v4 - v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v4 + v4 = Xstrchr(tls, **(**uintptr)(__ccgo_up(bp)), int32(':')) + **(**uintptr)(__ccgo_up(bp)) = v4 if !(v4 != 0) { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) - (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = *(*uintptr)(unsafe.Pointer(bp)) - v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v4 + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) + (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = **(**uintptr)(__ccgo_up(bp)) + v4 = Xstrchr(tls, **(**uintptr)(__ccgo_up(bp)), int32(':')) + **(**uintptr)(__ccgo_up(bp)) = v4 if !(v4 != 0) { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) (*Tgroup)(unsafe.Pointer(gr)).Fgr_gid = _atou(tls, bp) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32(':') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) != int32(':') { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) - mems = *(*uintptr)(unsafe.Pointer(bp)) + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) + mems = **(**uintptr)(__ccgo_up(bp)) break goto _1 _1: } - *(*Tsize_t)(unsafe.Pointer(nmem)) = BoolUint64(!!(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) != 0)) + **(**Tsize_t)(__ccgo_up(nmem)) = BoolUint64(!!(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))) != 0)) for { - if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) != 0) { + if !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))) != 0) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32(',') { - *(*Tsize_t)(unsafe.Pointer(nmem)) = *(*Tsize_t)(unsafe.Pointer(nmem)) + 1 + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) == int32(',') { + **(**Tsize_t)(__ccgo_up(nmem)) = **(**Tsize_t)(__ccgo_up(nmem)) + 1 } goto _10 _10: ; - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - } - Xfree(tls, *(*uintptr)(unsafe.Pointer(mem))) - *(*uintptr)(unsafe.Pointer(mem)) = Xcalloc(tls, uint64(8), *(*Tsize_t)(unsafe.Pointer(nmem))+uint64(1)) - if !(*(*uintptr)(unsafe.Pointer(mem)) != 0) { - rv = *(*int32)(unsafe.Pointer(X__errno_location(tls))) - Xfree(tls, *(*uintptr)(unsafe.Pointer(line))) - *(*uintptr)(unsafe.Pointer(line)) = uintptr(0) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + } + Xfree(tls, **(**uintptr)(__ccgo_up(mem))) + **(**uintptr)(__ccgo_up(mem)) = Xcalloc(tls, uint64(8), **(**Tsize_t)(__ccgo_up(nmem))+uint64(1)) + if !(**(**uintptr)(__ccgo_up(mem)) != 0) { + rv = **(**int32)(__ccgo_up(X__errno_location(tls))) + Xfree(tls, **(**uintptr)(__ccgo_up(line))) + **(**uintptr)(__ccgo_up(line)) = uintptr(0) gr = uintptr(0) goto end } - if *(*uint8)(unsafe.Pointer(mems)) != 0 { - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)))) = mems - *(*uintptr)(unsafe.Pointer(bp)) = mems + if **(**uint8)(__ccgo_up(mems)) != 0 { + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)))) = mems + **(**uintptr)(__ccgo_up(bp)) = mems i = Uint64FromInt32(0) for { - if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) != 0) { + if !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))) != 0) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32(',') { - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) == int32(',') { + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) i = i + 1 v13 = i - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v13)*8)) = *(*uintptr)(unsafe.Pointer(bp)) + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)) + uintptr(v13)*8)) = **(**uintptr)(__ccgo_up(bp)) } goto _11 _11: ; - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 } i = i + 1 v13 = i - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v13)*8)) = uintptr(0) + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)) + uintptr(v13)*8)) = uintptr(0) } else { - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)))) = uintptr(0) + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)))) = uintptr(0) } - (*Tgroup)(unsafe.Pointer(gr)).Fgr_mem = *(*uintptr)(unsafe.Pointer(mem)) + (*Tgroup)(unsafe.Pointer(gr)).Fgr_mem = **(**uintptr)(__ccgo_up(mem)) goto end end: ; - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 8)), uintptr(0)) - *(*uintptr)(unsafe.Pointer(res)) = gr + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 8)), uintptr(0)) + **(**uintptr)(__ccgo_up(res)) = gr if rv != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = rv + **(**int32)(__ccgo_up(X__errno_location(tls))) = rv } return rv } @@ -126526,44 +126526,44 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, i, n, nbytes, nlim, nscdbuf, ret, rv, v1, v14, v3, v4, v6, v9 ret = -int32(1) n = int64(1) - *(*int32)(unsafe.Pointer(bp + 40)) = 0 + **(**int32)(__ccgo_up(bp + 40)) = 0 nscdbuf = uintptr(0) - *(*uintptr)(unsafe.Pointer(bp + 56)) = uintptr(0) - *(*uintptr)(unsafe.Pointer(bp + 64)) = uintptr(0) - *(*Tsize_t)(unsafe.Pointer(bp + 72)) = uint64(0) - nlim = *(*int32)(unsafe.Pointer(ngroups)) + **(**uintptr)(__ccgo_up(bp + 56)) = uintptr(0) + **(**uintptr)(__ccgo_up(bp + 64)) = uintptr(0) + **(**Tsize_t)(__ccgo_up(bp + 72)) = uint64(0) + nlim = **(**int32)(__ccgo_up(ngroups)) if nlim >= int32(1) { v1 = groups groups += 4 - *(*Tgid_t)(unsafe.Pointer(v1)) = gid + **(**Tgid_t)(__ccgo_up(v1)) = gid } f = X__nscd_query(tls, int32(GETINITGR), user, bp+44, uint64(12), bp+40) if !(f != 0) { goto cleanup } - if (*(*[3]Tint32_t)(unsafe.Pointer(bp + 44)))[int32(INITGRFOUND)] != 0 { - nscdbuf = Xcalloc(tls, Uint64FromInt32((*(*[3]Tint32_t)(unsafe.Pointer(bp + 44)))[int32(INITGRNGRPS)]), uint64(4)) + if (**(**[3]Tint32_t)(__ccgo_up(bp + 44)))[int32(INITGRFOUND)] != 0 { + nscdbuf = Xcalloc(tls, Uint64FromInt32((**(**[3]Tint32_t)(__ccgo_up(bp + 44)))[int32(INITGRNGRPS)]), uint64(4)) if !(nscdbuf != 0) { goto cleanup } - nbytes = uint64(4) * Uint64FromInt32((*(*[3]Tint32_t)(unsafe.Pointer(bp + 44)))[int32(INITGRNGRPS)]) + nbytes = uint64(4) * Uint64FromInt32((**(**[3]Tint32_t)(__ccgo_up(bp + 44)))[int32(INITGRNGRPS)]) if nbytes != 0 && !(Xfread(tls, nscdbuf, nbytes, uint64(1), f) != 0) { if !(Xferror(tls, f) != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EIO) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EIO) } goto cleanup } - if *(*int32)(unsafe.Pointer(bp + 40)) != 0 { + if **(**int32)(__ccgo_up(bp + 40)) != 0 { i = 0 for { - if !(i < int64((*(*[3]Tint32_t)(unsafe.Pointer(bp + 44)))[int32(INITGRNGRPS)])) { + if !(i < int64((**(**[3]Tint32_t)(__ccgo_up(bp + 44)))[int32(INITGRNGRPS)])) { break } - v3 = *(*Tuint32_t)(unsafe.Pointer(nscdbuf + uintptr(i)*4)) + v3 = **(**Tuint32_t)(__ccgo_up(nscdbuf + uintptr(i)*4)) v4 = v3>>int32(24) | v3>>int32(8)&uint32(0xff00) | v3<= Uint64FromUint64(0xffffffffffffffff)/Uint64FromInt32(8) { + if Uint64FromInt32((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWNAMELEN)]|(**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWPASSWDLEN)]|(**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWGECOSLEN)]|(**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWDIRLEN)]|(**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWSHELLLEN)]) >= Uint64FromUint64(0xffffffffffffffff)/Uint64FromInt32(8) { rv = int32(ENOMEM) goto cleanup_f } - len1 = Uint64FromInt32((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWNAMELEN)] + (*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWPASSWDLEN)] + (*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWGECOSLEN)] + (*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWDIRLEN)] + (*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWSHELLLEN)]) - if len1 > *(*Tsize_t)(unsafe.Pointer(size)) || !(*(*uintptr)(unsafe.Pointer(buf)) != 0) { - tmp = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(buf)), len1) + len1 = Uint64FromInt32((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWNAMELEN)] + (**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWPASSWDLEN)] + (**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWGECOSLEN)] + (**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWDIRLEN)] + (**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWSHELLLEN)]) + if len1 > **(**Tsize_t)(__ccgo_up(size)) || !(**(**uintptr)(__ccgo_up(buf)) != 0) { + tmp = Xrealloc(tls, **(**uintptr)(__ccgo_up(buf)), len1) if !(tmp != 0) { - rv = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + rv = **(**int32)(__ccgo_up(X__errno_location(tls))) goto cleanup_f } - *(*uintptr)(unsafe.Pointer(buf)) = tmp - *(*Tsize_t)(unsafe.Pointer(size)) = len1 + **(**uintptr)(__ccgo_up(buf)) = tmp + **(**Tsize_t)(__ccgo_up(size)) = len1 } - if !(Xfread(tls, *(*uintptr)(unsafe.Pointer(buf)), len1, uint64(1), f) != 0) { + if !(Xfread(tls, **(**uintptr)(__ccgo_up(buf)), len1, uint64(1), f) != 0) { if Xferror(tls, f) != 0 { - v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = **(**int32)(__ccgo_up(X__errno_location(tls))) } else { v1 = int32(EIO) } rv = v1 goto cleanup_f } - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = *(*uintptr)(unsafe.Pointer(buf)) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name + uintptr((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWNAMELEN)]) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd + uintptr((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWPASSWDLEN)]) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos + uintptr((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWGECOSLEN)]) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir + uintptr((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWDIRLEN)]) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_uid = Uint32FromInt32((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWUID)]) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gid = Uint32FromInt32((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWGID)]) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = **(**uintptr)(__ccgo_up(buf)) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name + uintptr((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWNAMELEN)]) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd + uintptr((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWPASSWDLEN)]) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos + uintptr((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWGECOSLEN)]) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir + uintptr((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWDIRLEN)]) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_uid = Uint32FromInt32((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWUID)]) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gid = Uint32FromInt32((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWGID)]) /* Don't assume that nscd made sure to null terminate strings. * It's supposed to, but malicious nscd should be ignored * rather than causing a crash. */ - if *(*uint8)(unsafe.Pointer((*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd + uintptr(-Int32FromInt32(1)))) != 0 || *(*uint8)(unsafe.Pointer((*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos + uintptr(-Int32FromInt32(1)))) != 0 || *(*uint8)(unsafe.Pointer((*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir + uintptr(-Int32FromInt32(1)))) != 0 || *(*uint8)(unsafe.Pointer((*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell + uintptr((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWSHELLLEN)]-int32(1)))) != 0 { + if **(**uint8)(__ccgo_up((*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd + uintptr(-Int32FromInt32(1)))) != 0 || **(**uint8)(__ccgo_up((*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos + uintptr(-Int32FromInt32(1)))) != 0 || **(**uint8)(__ccgo_up((*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir + uintptr(-Int32FromInt32(1)))) != 0 || **(**uint8)(__ccgo_up((*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell + uintptr((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWSHELLLEN)]-int32(1)))) != 0 { rv = int32(EIO) goto cleanup_f } @@ -126799,7 +126799,7 @@ func X__getpw_a(tls *TLS, name uintptr, uid Tuid_t, pw uintptr, buf uintptr, siz rv = int32(EIO) goto cleanup_f } - *(*uintptr)(unsafe.Pointer(res)) = pw + **(**uintptr)(__ccgo_up(res)) = pw goto cleanup_f cleanup_f: ; @@ -126809,9 +126809,9 @@ func X__getpw_a(tls *TLS, name uintptr, uid Tuid_t, pw uintptr, buf uintptr, siz goto done done: ; - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 4)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 4)), uintptr(0)) if rv != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = rv + **(**int32)(__ccgo_up(X__errno_location(tls))) = rv } return rv } @@ -126824,27 +126824,27 @@ func _getpw_r(tls *TLS, name uintptr, uid Tuid_t, pw uintptr, buf uintptr, size var _ /* len at bp+8 */ Tsize_t var _ /* line at bp+0 */ uintptr _ = rv - *(*uintptr)(unsafe.Pointer(bp)) = uintptr(0) - *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint64(0) + **(**uintptr)(__ccgo_up(bp)) = uintptr(0) + **(**Tsize_t)(__ccgo_up(bp + 8)) = uint64(0) rv = 0 _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp+16) rv = X__getpw_a(tls, name, uid, pw, bp, bp+8, res) - if *(*uintptr)(unsafe.Pointer(res)) != 0 && size < *(*Tsize_t)(unsafe.Pointer(bp + 8)) { - *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) + if **(**uintptr)(__ccgo_up(res)) != 0 && size < **(**Tsize_t)(__ccgo_up(bp + 8)) { + **(**uintptr)(__ccgo_up(res)) = uintptr(0) rv = int32(ERANGE) } - if *(*uintptr)(unsafe.Pointer(res)) != 0 { - Xmemcpy(tls, buf, *(*uintptr)(unsafe.Pointer(bp)), *(*Tsize_t)(unsafe.Pointer(bp + 8))) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_name)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf + if **(**uintptr)(__ccgo_up(res)) != 0 { + Xmemcpy(tls, buf, **(**uintptr)(__ccgo_up(bp)), **(**Tsize_t)(__ccgo_up(bp + 8))) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_name)-int64(**(**uintptr)(__ccgo_up(bp)))) + buf + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd)-int64(**(**uintptr)(__ccgo_up(bp)))) + buf + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos)-int64(**(**uintptr)(__ccgo_up(bp)))) + buf + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir)-int64(**(**uintptr)(__ccgo_up(bp)))) + buf + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell)-int64(**(**uintptr)(__ccgo_up(bp)))) + buf } - Xfree(tls, *(*uintptr)(unsafe.Pointer(bp))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 16)), uintptr(0)) + Xfree(tls, **(**uintptr)(__ccgo_up(bp))) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 16)), uintptr(0)) if rv != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = rv + **(**int32)(__ccgo_up(X__errno_location(tls))) = rv } return rv } @@ -126895,7 +126895,7 @@ func Xgetpwent(tls *TLS) (r uintptr) { return uintptr(0) } X__getpwent_a(tls, _f2, uintptr(unsafe.Pointer(&_pw1)), uintptr(unsafe.Pointer(&_line4)), uintptr(unsafe.Pointer(&_size)), bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func Xgetpwuid(tls *TLS, uid Tuid_t) (r uintptr) { @@ -126907,7 +126907,7 @@ func Xgetpwuid(tls *TLS, uid Tuid_t) (r uintptr) { defer tls.Free(16) var _ /* res at bp+0 */ uintptr X__getpw_a(tls, uintptr(0), uid, uintptr(unsafe.Pointer(&_pw1)), uintptr(unsafe.Pointer(&_line4)), uintptr(unsafe.Pointer(&_size)), bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func Xgetpwnam(tls *TLS, name uintptr) (r uintptr) { @@ -126919,7 +126919,7 @@ func Xgetpwnam(tls *TLS, name uintptr) (r uintptr) { defer tls.Free(16) var _ /* res at bp+0 */ uintptr X__getpw_a(tls, name, uint32(0), uintptr(unsafe.Pointer(&_pw1)), uintptr(unsafe.Pointer(&_line4)), uintptr(unsafe.Pointer(&_size)), bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func Xendpwent(tls *TLS) { @@ -126934,14 +126934,14 @@ func _atou1(tls *TLS, s uintptr) (r uint32) { _ = x x = uint32(0) for { - if !(Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-int32('0')) < uint32(10)) { + if !(Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-int32('0')) < uint32(10)) { break } - x = uint32(10)*x + Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-Int32FromUint8('0')) + x = uint32(10)*x + Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-Int32FromUint8('0')) goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s)) = *(*uintptr)(unsafe.Pointer(s)) + 1 + **(**uintptr)(__ccgo_up(s)) = **(**uintptr)(__ccgo_up(s)) + 1 } return x } @@ -126966,79 +126966,79 @@ func X__getpwent_a(tls *TLS, f uintptr, pw uintptr, line uintptr, size uintptr, l = v2 if v2 < 0 { if Xferror(tls, f) != 0 { - v3 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v3 = **(**int32)(__ccgo_up(X__errno_location(tls))) } else { v3 = 0 } rv = v3 - Xfree(tls, *(*uintptr)(unsafe.Pointer(line))) - *(*uintptr)(unsafe.Pointer(line)) = uintptr(0) + Xfree(tls, **(**uintptr)(__ccgo_up(line))) + **(**uintptr)(__ccgo_up(line)) = uintptr(0) pw = uintptr(0) break } - *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(line)) + uintptr(l-int64(1)))) = uint8(0) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(line)) - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(line)) + uintptr(l-int64(1)))) = uint8(0) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(line)) + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = v4 - v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v4 + v4 = Xstrchr(tls, **(**uintptr)(__ccgo_up(bp)), int32(':')) + **(**uintptr)(__ccgo_up(bp)) = v4 if !(v4 != 0) { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = *(*uintptr)(unsafe.Pointer(bp)) - v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v4 + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = **(**uintptr)(__ccgo_up(bp)) + v4 = Xstrchr(tls, **(**uintptr)(__ccgo_up(bp)), int32(':')) + **(**uintptr)(__ccgo_up(bp)) = v4 if !(v4 != 0) { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) (*Tpasswd)(unsafe.Pointer(pw)).Fpw_uid = _atou1(tls, bp) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32(':') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) != int32(':') { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gid = _atou1(tls, bp) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32(':') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) != int32(':') { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = *(*uintptr)(unsafe.Pointer(bp)) - v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v4 + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = **(**uintptr)(__ccgo_up(bp)) + v4 = Xstrchr(tls, **(**uintptr)(__ccgo_up(bp)), int32(':')) + **(**uintptr)(__ccgo_up(bp)) = v4 if !(v4 != 0) { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = *(*uintptr)(unsafe.Pointer(bp)) - v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v4 + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = **(**uintptr)(__ccgo_up(bp)) + v4 = Xstrchr(tls, **(**uintptr)(__ccgo_up(bp)), int32(':')) + **(**uintptr)(__ccgo_up(bp)) = v4 if !(v4 != 0) { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = *(*uintptr)(unsafe.Pointer(bp)) + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = **(**uintptr)(__ccgo_up(bp)) break goto _1 _1: } - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 8)), uintptr(0)) - *(*uintptr)(unsafe.Pointer(res)) = pw + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 8)), uintptr(0)) + **(**uintptr)(__ccgo_up(res)) = pw if rv != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = rv + **(**int32)(__ccgo_up(X__errno_location(tls))) = rv } return rv } @@ -127102,7 +127102,7 @@ func X__nscd_query(tls *TLS, req Tint32_t, key uintptr, buf uintptr, len1 Tsize_ var _ /* req_buf at bp+32 */ [3]Tint32_t _, _, _, _, _, _, _ = errno_save, f, fd, i, v1, v3, v4 f = uintptr(0) - *(*[3]Tint32_t)(unsafe.Pointer(bp + 32)) = [3]Tint32_t{ + **(**[3]Tint32_t)(__ccgo_up(bp + 32)) = [3]Tint32_t{ 0: int32(NSCDVERSION), 1: req, 2: Int32FromUint64(Xstrnlen(tls, key, uint64(LOGIN_NAME_MAX)) + uint64(1)), @@ -127117,23 +127117,23 @@ func X__nscd_query(tls *TLS, req Tint32_t, key uintptr, buf uintptr, len1 Tsize_ Fiov_len: _strlen(tls, key) + uint64(1), }, } - *(*Tmsghdr)(unsafe.Pointer(bp + 48)) = Tmsghdr{ + **(**Tmsghdr)(__ccgo_up(bp + 48)) = Tmsghdr{ Fmsg_iov: bp, Fmsg_iovlen: int32(2), } - errno_save = *(*int32)(unsafe.Pointer(X__errno_location(tls))) - *(*int32)(unsafe.Pointer(swap)) = 0 + errno_save = **(**int32)(__ccgo_up(X__errno_location(tls))) + **(**int32)(__ccgo_up(swap)) = 0 goto retry retry: ; Xmemset(tls, buf, 0, len1) - *(*Tint32_t)(unsafe.Pointer(buf)) = int32(NSCDVERSION) + **(**Tint32_t)(__ccgo_up(buf)) = int32(NSCDVERSION) fd = Xsocket(tls, int32(PF_LOCAL), Int32FromInt32(SOCK_STREAM)|Int32FromInt32(SOCK_CLOEXEC), 0) if fd < 0 { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EAFNOSUPPORT) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EAFNOSUPPORT) { f = Xfopen(tls, __ccgo_ts+1300, __ccgo_ts+1310) if f != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = errno_save + **(**int32)(__ccgo_up(X__errno_location(tls))) = errno_save } return f } @@ -127145,7 +127145,7 @@ retry: Xclose(tls, fd) return uintptr(0) } - if (*(*[3]Tint32_t)(unsafe.Pointer(bp + 32)))[int32(2)] > int32(LOGIN_NAME_MAX) { + if (**(**[3]Tint32_t)(__ccgo_up(bp + 32)))[int32(2)] > int32(LOGIN_NAME_MAX) { return f } if Xconnect(tls, fd, uintptr(unsafe.Pointer(&_addr)), uint32(24)) < 0 { @@ -127153,8 +127153,8 @@ retry: * result and the caller is responsible for calling * fclose on the (unconnected) socket. The value of * errno must be left unchanged in this case. */ - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EACCES) || *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ECONNREFUSED) || *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENOENT) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = errno_save + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EACCES) || **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ECONNREFUSED) || **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENOENT) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = errno_save return f } goto error @@ -127171,41 +127171,41 @@ retry: if Xferror(tls, f) != 0 { goto error } - if !(*(*int32)(unsafe.Pointer(swap)) != 0) { + if !(**(**int32)(__ccgo_up(swap)) != 0) { Xfclose(tls, f) i = uint64(0) for { if !(i < Uint64FromInt64(12)/Uint64FromInt64(4)) { break } - v3 = Uint32FromInt32((*(*[3]Tint32_t)(unsafe.Pointer(bp + 32)))[i]) + v3 = Uint32FromInt32((**(**[3]Tint32_t)(__ccgo_up(bp + 32)))[i]) v4 = v3>>int32(24) | v3>>int32(8)&uint32(0xff00) | v3<>int32(24) | v3>>int32(8)&uint32(0xff00) | v3<> int32(16)) - *(*uint16)(unsafe.Pointer(xi + 2*2)) = uint16(x >> int32(32)) + x = uint64(uint32(**(**uint16)(__ccgo_up(xi)))|(uint32(**(**uint16)(__ccgo_up(xi + 1*2)))+0)<> int32(16)) + **(**uint16)(__ccgo_up(xi + 2*2)) = uint16(x >> int32(32)) return x & uint64(0xffffffffffff) } @@ -127515,8 +127515,8 @@ func Xrand_r(tls *TLS, seed uintptr) (r int32) { } var v1 uint32 _ = v1 - v1 = *(*uint32)(unsafe.Pointer(seed))*Uint32FromInt32(1103515245) + Uint32FromInt32(12345) - *(*uint32)(unsafe.Pointer(seed)) = v1 + v1 = **(**uint32)(__ccgo_up(seed))*Uint32FromInt32(1103515245) + Uint32FromInt32(12345) + **(**uint32)(__ccgo_up(seed)) = v1 return Int32FromUint32(_temper(tls, v1) / uint32(2)) } @@ -127575,15 +127575,15 @@ func _lcg64(tls *TLS, x Tuint64_t) (r Tuint64_t) { } func _savestate(tls *TLS) (r uintptr) { - *(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(-Int32FromInt32(1))*4)) = Uint32FromInt32(_n<> int32(16)) - _i = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(-Int32FromInt32(1))*4)) >> Int32FromInt32(8) & uint32(0xff)) - _j = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(-Int32FromInt32(1))*4)) & uint32(0xff)) + _n = Int32FromUint32(**(**Tuint32_t)(__ccgo_up(_x1 + uintptr(-Int32FromInt32(1))*4)) >> int32(16)) + _i = Int32FromUint32(**(**Tuint32_t)(__ccgo_up(_x1 + uintptr(-Int32FromInt32(1))*4)) >> Int32FromInt32(8) & uint32(0xff)) + _j = Int32FromUint32(**(**Tuint32_t)(__ccgo_up(_x1 + uintptr(-Int32FromInt32(1))*4)) & uint32(0xff)) } func ___srandom(tls *TLS, seed uint32) { @@ -127592,7 +127592,7 @@ func ___srandom(tls *TLS, seed uint32) { _, _, _ = k, s, v1 s = uint64(seed) if _n == 0 { - *(*Tuint32_t)(unsafe.Pointer(_x1)) = uint32(s) + **(**Tuint32_t)(__ccgo_up(_x1)) = uint32(s) return } if _n == int32(31) || _n == int32(7) { @@ -127608,14 +127608,14 @@ func ___srandom(tls *TLS, seed uint32) { break } s = _lcg64(tls, s) - *(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(k)*4)) = uint32(s >> int32(32)) + **(**Tuint32_t)(__ccgo_up(_x1 + uintptr(k)*4)) = uint32(s >> int32(32)) goto _2 _2: ; k = k + 1 } /* make sure x contains at least one odd number */ - *(*Tuint32_t)(unsafe.Pointer(_x1)) |= uint32(1) + **(**Tuint32_t)(__ccgo_up(_x1)) |= uint32(1) } func Xsrandom(tls *TLS, seed uint32) { @@ -127688,13 +127688,13 @@ func Xrandom(tls *TLS) (r int64) { _, _, _ = k, v1, v2 ___lock(tls, uintptr(unsafe.Pointer(&_lock3))) if _n == 0 { - v1 = _lcg31(tls, *(*Tuint32_t)(unsafe.Pointer(_x1))) - *(*Tuint32_t)(unsafe.Pointer(_x1)) = v1 + v1 = _lcg31(tls, **(**Tuint32_t)(__ccgo_up(_x1))) + **(**Tuint32_t)(__ccgo_up(_x1)) = v1 k = Int64FromUint32(v1) goto end } - *(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(_i)*4)) += *(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(_j)*4)) - k = Int64FromUint32(*(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(_i)*4)) >> int32(1)) + **(**Tuint32_t)(__ccgo_up(_x1 + uintptr(_i)*4)) += **(**Tuint32_t)(__ccgo_up(_x1 + uintptr(_j)*4)) + k = Int64FromUint32(**(**Tuint32_t)(__ccgo_up(_x1 + uintptr(_i)*4)) >> int32(1)) _i = _i + 1 v2 = _i if v2 == _n { @@ -127900,8 +127900,8 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { defer func() { Xrealloc(tls, b, 0) }() path = Xgetenv(tls, __ccgo_ts+1403) seen_eacces = 0 - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOENT) - if !(*(*uint8)(unsafe.Pointer(file)) != 0) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOENT) + if !(**(**uint8)(__ccgo_up(file)) != 0) { return -int32(1) } if Xstrchr(tls, file, int32('/')) != 0 { @@ -127912,7 +127912,7 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { } k = Xstrnlen(tls, file, Uint64FromInt32(Int32FromInt32(NAME_MAX)+Int32FromInt32(1))) if k > uint64(NAME_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENAMETOOLONG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENAMETOOLONG) return -int32(1) } l = Xstrnlen(tls, path, Uint64FromInt32(Int32FromInt32(PATH_MAX)-Int32FromInt32(1))) + uint64(1) @@ -127924,7 +127924,7 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { if Uint64FromInt64(int64(z)-int64(p)) >= l { v3 = z z = z + 1 - if !(*(*uint8)(unsafe.Pointer(v3)) != 0) { + if !(**(**uint8)(__ccgo_up(v3)) != 0) { break } goto _1 @@ -127933,7 +127933,7 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { *(*uint8)(unsafe.Add(unsafe.Pointer(b), int64(z)-int64(p))) = uint8('/') Xmemcpy(tls, b+uintptr(int64(z)-int64(p))+BoolUintptr(z > p), file, k+uint64(1)) Xexecve(tls, b, argv, envp) - switch *(*int32)(unsafe.Pointer(X__errno_location(tls))) { + switch **(**int32)(__ccgo_up(X__errno_location(tls))) { case int32(EACCES): seen_eacces = int32(1) fallthrough @@ -127945,7 +127945,7 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { } v3 = z z = z + 1 - if !(*(*uint8)(unsafe.Pointer(v3)) != 0) { + if !(**(**uint8)(__ccgo_up(v3)) != 0) { break } goto _1 @@ -127954,7 +127954,7 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { p = z } if seen_eacces != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EACCES) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EACCES) } return -int32(1) } @@ -127991,8 +127991,8 @@ func Xfexecve(tls *TLS, fd int32, argv uintptr, envp uintptr) (r1 int32) { } X__procfdname(tls, bp, Uint32FromInt32(fd)) Xexecve(tls, bp, argv, envp) - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENOENT) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EBADF) + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENOENT) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EBADF) } return -int32(1) } @@ -128229,7 +128229,7 @@ func Xposix_spawnattr_getflags(tls *TLS, attr uintptr, flags uintptr) (r int32) trc("tls=%v attr=%v flags=%v, (%v:)", tls, attr, flags, origin(2)) defer func() { trc("-> %v", r) }() } - *(*int16)(unsafe.Pointer(flags)) = int16((*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__flags) + **(**int16)(__ccgo_up(flags)) = int16((*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__flags) return 0 } @@ -128238,7 +128238,7 @@ func Xposix_spawnattr_getpgroup(tls *TLS, attr uintptr, pgrp uintptr) (r int32) trc("tls=%v attr=%v pgrp=%v, (%v:)", tls, attr, pgrp, origin(2)) defer func() { trc("-> %v", r) }() } - *(*Tpid_t)(unsafe.Pointer(pgrp)) = (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__pgrp + **(**Tpid_t)(__ccgo_up(pgrp)) = (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__pgrp return 0 } @@ -128247,7 +128247,7 @@ func Xposix_spawnattr_getsigdefault(tls *TLS, attr uintptr, def uintptr) (r int3 trc("tls=%v attr=%v def=%v, (%v:)", tls, attr, def, origin(2)) defer func() { trc("-> %v", r) }() } - *(*Tsigset_t)(unsafe.Pointer(def)) = (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__def + **(**Tsigset_t)(__ccgo_up(def)) = (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__def return 0 } @@ -128256,7 +128256,7 @@ func Xposix_spawnattr_getsigmask(tls *TLS, attr uintptr, mask uintptr) (r int32) trc("tls=%v attr=%v mask=%v, (%v:)", tls, attr, mask, origin(2)) defer func() { trc("-> %v", r) }() } - *(*Tsigset_t)(unsafe.Pointer(mask)) = (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__mask + **(**Tsigset_t)(__ccgo_up(mask)) = (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__mask return 0 } @@ -128265,7 +128265,7 @@ func Xposix_spawnattr_init(tls *TLS, attr uintptr) (r int32) { trc("tls=%v attr=%v, (%v:)", tls, attr, origin(2)) defer func() { trc("-> %v", r) }() } - *(*Tposix_spawnattr_t)(unsafe.Pointer(attr)) = Tposix_spawnattr_t{} + **(**Tposix_spawnattr_t)(__ccgo_up(attr)) = Tposix_spawnattr_t{} return 0 } @@ -128330,7 +128330,7 @@ func Xposix_spawnattr_setsigdefault(tls *TLS, attr uintptr, def uintptr) (r int3 trc("tls=%v attr=%v def=%v, (%v:)", tls, attr, def, origin(2)) defer func() { trc("-> %v", r) }() } - (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__def = *(*Tsigset_t)(unsafe.Pointer(def)) + (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__def = **(**Tsigset_t)(__ccgo_up(def)) return 0 } @@ -128339,7 +128339,7 @@ func Xposix_spawnattr_setsigmask(tls *TLS, attr uintptr, mask uintptr) (r int32) trc("tls=%v attr=%v mask=%v, (%v:)", tls, attr, mask, origin(2)) defer func() { trc("-> %v", r) }() } - (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__mask = *(*Tsigset_t)(unsafe.Pointer(mask)) + (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__mask = **(**Tsigset_t)(__ccgo_up(mask)) return 0 } @@ -128397,20 +128397,20 @@ func _str_next(tls *TLS, str uintptr, n Tsize_t, step uintptr) (r int32) { var _ /* wc at bp+0 */ Twchar_t _ = k if !(n != 0) { - *(*Tsize_t)(unsafe.Pointer(step)) = uint64(0) + **(**Tsize_t)(__ccgo_up(step)) = uint64(0) return 0 } - if uint32(*(*uint8)(unsafe.Pointer(str))) >= uint32(128) { + if uint32(**(**uint8)(__ccgo_up(str))) >= uint32(128) { k = Xmbtowc(tls, bp, str, n) if k < 0 { - *(*Tsize_t)(unsafe.Pointer(step)) = uint64(1) + **(**Tsize_t)(__ccgo_up(step)) = uint64(1) return -int32(1) } - *(*Tsize_t)(unsafe.Pointer(step)) = Uint64FromInt32(k) - return *(*Twchar_t)(unsafe.Pointer(bp)) + **(**Tsize_t)(__ccgo_up(step)) = Uint64FromInt32(k) + return **(**Twchar_t)(__ccgo_up(bp)) } - *(*Tsize_t)(unsafe.Pointer(step)) = uint64(1) - return Int32FromUint8(*(*uint8)(unsafe.Pointer(str))) + **(**Tsize_t)(__ccgo_up(step)) = uint64(1) + return Int32FromUint8(**(**uint8)(__ccgo_up(str))) } func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r int32) { @@ -128421,43 +128421,43 @@ func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r i var _ /* wc at bp+0 */ Twchar_t _, _, _, _ = esc, k, k1, z esc = 0 - if !(m != 0) || !(*(*uint8)(unsafe.Pointer(pat)) != 0) { - *(*Tsize_t)(unsafe.Pointer(step)) = uint64(0) + if !(m != 0) || !(**(**uint8)(__ccgo_up(pat)) != 0) { + **(**Tsize_t)(__ccgo_up(step)) = uint64(0) return END } - *(*Tsize_t)(unsafe.Pointer(step)) = uint64(1) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) == int32('\\') && *(*uint8)(unsafe.Pointer(pat + 1)) != 0 && !(flags&Int32FromInt32(FNM_NOESCAPE) != 0) { - *(*Tsize_t)(unsafe.Pointer(step)) = uint64(2) + **(**Tsize_t)(__ccgo_up(step)) = uint64(1) + if Int32FromUint8(**(**uint8)(__ccgo_up(pat))) == int32('\\') && **(**uint8)(__ccgo_up(pat + 1)) != 0 && !(flags&Int32FromInt32(FNM_NOESCAPE) != 0) { + **(**Tsize_t)(__ccgo_up(step)) = uint64(2) pat = pat + 1 esc = int32(1) goto escaped } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) == int32('[') { + if Int32FromUint8(**(**uint8)(__ccgo_up(pat))) == int32('[') { k = uint64(1) if k < m { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) == int32('^') || Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) == int32('!') { + if Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k)))) == int32('^') || Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k)))) == int32('!') { k = k + 1 } } if k < m { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) == int32(']') { + if Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k)))) == int32(']') { k = k + 1 } } for { - if !(k < m && *(*uint8)(unsafe.Pointer(pat + uintptr(k))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) != int32(']')) { + if !(k < m && **(**uint8)(__ccgo_up(pat + uintptr(k))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k)))) != int32(']')) { break } - if k+uint64(1) < m && *(*uint8)(unsafe.Pointer(pat + uintptr(k+uint64(1)))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) == int32('[') && (Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k+uint64(1))))) == int32(':') || Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k+uint64(1))))) == int32('.') || Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k+uint64(1))))) == int32('=')) { - z = Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k+uint64(1))))) + if k+uint64(1) < m && **(**uint8)(__ccgo_up(pat + uintptr(k+uint64(1)))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k)))) == int32('[') && (Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k+uint64(1))))) == int32(':') || Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k+uint64(1))))) == int32('.') || Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k+uint64(1))))) == int32('=')) { + z = Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k+uint64(1))))) k = k + uint64(2) - if k < m && *(*uint8)(unsafe.Pointer(pat + uintptr(k))) != 0 { + if k < m && **(**uint8)(__ccgo_up(pat + uintptr(k))) != 0 { k = k + 1 } - for k < m && *(*uint8)(unsafe.Pointer(pat + uintptr(k))) != 0 && (Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k-uint64(1))))) != z || Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) != int32(']')) { + for k < m && **(**uint8)(__ccgo_up(pat + uintptr(k))) != 0 && (Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k-uint64(1))))) != z || Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k)))) != int32(']')) { k = k + 1 } - if k == m || !(*(*uint8)(unsafe.Pointer(pat + uintptr(k))) != 0) { + if k == m || !(**(**uint8)(__ccgo_up(pat + uintptr(k))) != 0) { break } } @@ -128466,32 +128466,32 @@ func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r i ; k = k + 1 } - if k == m || !(*(*uint8)(unsafe.Pointer(pat + uintptr(k))) != 0) { - *(*Tsize_t)(unsafe.Pointer(step)) = uint64(1) + if k == m || !(**(**uint8)(__ccgo_up(pat + uintptr(k))) != 0) { + **(**Tsize_t)(__ccgo_up(step)) = uint64(1) return int32('[') } - *(*Tsize_t)(unsafe.Pointer(step)) = k + uint64(1) + **(**Tsize_t)(__ccgo_up(step)) = k + uint64(1) return -int32(3) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) == int32('*') { + if Int32FromUint8(**(**uint8)(__ccgo_up(pat))) == int32('*') { return -int32(5) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) == int32('?') { + if Int32FromUint8(**(**uint8)(__ccgo_up(pat))) == int32('?') { return -int32(4) } goto escaped escaped: ; - if uint32(*(*uint8)(unsafe.Pointer(pat))) >= uint32(128) { + if uint32(**(**uint8)(__ccgo_up(pat))) >= uint32(128) { k1 = Xmbtowc(tls, bp, pat, m) if k1 < 0 { - *(*Tsize_t)(unsafe.Pointer(step)) = uint64(0) + **(**Tsize_t)(__ccgo_up(step)) = uint64(0) return -int32(2) } - *(*Tsize_t)(unsafe.Pointer(step)) = Uint64FromInt32(k1 + esc) - return *(*Twchar_t)(unsafe.Pointer(bp)) + **(**Tsize_t)(__ccgo_up(step)) = Uint64FromInt32(k1 + esc) + return **(**Twchar_t)(__ccgo_up(bp)) } - return Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) + return Int32FromUint8(**(**uint8)(__ccgo_up(pat))) } func _casefold(tls *TLS, k int32) (r int32) { @@ -128518,59 +128518,59 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { _, _, _, _, _ = inv, l, l1, p0, z inv = 0 p = p + 1 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('^') || Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('!') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('^') || Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('!') { inv = int32(1) p = p + 1 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32(']') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32(']') { if k == int32(']') { return BoolInt32(!(inv != 0)) } p = p + 1 } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('-') { if k == int32('-') { return BoolInt32(!(inv != 0)) } p = p + 1 } } - *(*Twchar_t)(unsafe.Pointer(bp)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) + **(**Twchar_t)(__ccgo_up(bp)) = Int32FromUint8(**(**uint8)(__ccgo_up(p + uintptr(-Int32FromInt32(1))))) for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32(']')) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(p))) != int32(']')) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') && Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) != int32(']') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('-') && Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) != int32(']') { l = Xmbtowc(tls, bp+4, p+uintptr(1), uint64(4)) if l < 0 { return 0 } - if *(*Twchar_t)(unsafe.Pointer(bp)) <= *(*Twchar_t)(unsafe.Pointer(bp + 4)) { - if Uint32FromInt32(k)-Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))) <= Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp + 4))-*(*Twchar_t)(unsafe.Pointer(bp))) || Uint32FromInt32(kfold)-Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))) <= Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp + 4))-*(*Twchar_t)(unsafe.Pointer(bp))) { + if **(**Twchar_t)(__ccgo_up(bp)) <= **(**Twchar_t)(__ccgo_up(bp + 4)) { + if Uint32FromInt32(k)-Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))) <= Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp + 4))-**(**Twchar_t)(__ccgo_up(bp))) || Uint32FromInt32(kfold)-Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))) <= Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp + 4))-**(**Twchar_t)(__ccgo_up(bp))) { return BoolInt32(!(inv != 0)) } } p = p + uintptr(l-int32(1)) goto _1 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('[') && (Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32(':') || Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('.') || Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('=')) { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('[') && (Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) == int32(':') || Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) == int32('.') || Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) == int32('=')) { p0 = p + uintptr(2) - z = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) + z = Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) p = p + uintptr(3) - for Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) != z || Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32(']') { + for Int32FromUint8(**(**uint8)(__ccgo_up(p + uintptr(-Int32FromInt32(1))))) != z || Int32FromUint8(**(**uint8)(__ccgo_up(p))) != int32(']') { p = p + 1 } if z == int32(':') && int64(p-uintptr(1))-int64(p0) < int64(16) { Xmemcpy(tls, bp+8, p0, Uint64FromInt64(int64(p-uintptr(1))-int64(p0))) - (*(*[16]uint8)(unsafe.Pointer(bp + 8)))[int64(p-uintptr(1))-int64(p0)] = uint8(0) + (**(**[16]uint8)(__ccgo_up(bp + 8)))[int64(p-uintptr(1))-int64(p0)] = uint8(0) if Xiswctype(tls, Uint32FromInt32(k), Xwctype(tls, bp+8)) != 0 || Xiswctype(tls, Uint32FromInt32(kfold), Xwctype(tls, bp+8)) != 0 { return BoolInt32(!(inv != 0)) } } goto _1 } - if uint32(*(*uint8)(unsafe.Pointer(p))) < uint32(128) { - *(*Twchar_t)(unsafe.Pointer(bp)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + if uint32(**(**uint8)(__ccgo_up(p))) < uint32(128) { + **(**Twchar_t)(__ccgo_up(bp)) = Int32FromUint8(uint8(**(**uint8)(__ccgo_up(p)))) } else { l1 = Xmbtowc(tls, bp, p, uint64(4)) if l1 < 0 { @@ -128578,7 +128578,7 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { } p = p + uintptr(l1-int32(1)) } - if *(*Twchar_t)(unsafe.Pointer(bp)) == k || *(*Twchar_t)(unsafe.Pointer(bp)) == kfold { + if **(**Twchar_t)(__ccgo_up(bp)) == k || **(**Twchar_t)(__ccgo_up(bp)) == kfold { return BoolInt32(!(inv != 0)) } goto _1 @@ -128601,7 +128601,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, endpat, endstr, k, kfold, p, ptail, s, stail, tailcnt, v2, v6, v9 tailcnt = uint64(0) if flags&int32(FNM_PERIOD) != 0 { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(str))) == int32('.') && Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) != int32('.') { + if Int32FromUint8(**(**uint8)(__ccgo_up(str))) == int32('.') && Int32FromUint8(**(**uint8)(__ccgo_up(pat))) != int32('.') { return int32(FNM_NOMATCH) } } @@ -128624,8 +128624,8 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, } return v2 } - str = str + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) - n = n - *(*Tsize_t)(unsafe.Pointer(bp + 8)) + str = str + uintptr(**(**Tsize_t)(__ccgo_up(bp + 8))) + n = n - **(**Tsize_t)(__ccgo_up(bp + 8)) if flags&int32(FNM_CASEFOLD) != 0 { v2 = _casefold(tls, k) } else { @@ -128641,8 +128641,8 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, return int32(FNM_NOMATCH) } } - pat = pat + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) - m = m - *(*Tsize_t)(unsafe.Pointer(bp)) + pat = pat + uintptr(**(**Tsize_t)(__ccgo_up(bp))) + m = m - **(**Tsize_t)(__ccgo_up(bp)) goto _1 } break @@ -128673,7 +128673,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, goto _5 _5: ; - p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(**(**Tsize_t)(__ccgo_up(bp))) } /* Past this point we need not check for UNMATCHABLE in pat, * because all of pat has already been parsed once. */ @@ -128691,8 +128691,8 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, if !(s > str && tailcnt != 0) { break } - if v9 = uint32(*(*uint8)(unsafe.Pointer(s + uintptr(-Int32FromInt32(1))))) < uint32(128); !v9 { - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if v9 = uint32(**(**uint8)(__ccgo_up(s + uintptr(-Int32FromInt32(1))))) < uint32(128); !v9 { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v2 = int32(4) } else { v2 = int32(1) @@ -128704,7 +128704,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, for { s = s - 1 v6 = s - if !(uint32(*(*uint8)(unsafe.Pointer(v6)))-uint32(0x80) < uint32(0x40) && s > str) { + if !(uint32(uint8(**(**uint8)(__ccgo_up(v6))))-uint32(0x80) < uint32(0x40) && s > str) { break } } @@ -128722,7 +128722,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, p = ptail for { c = _pat_next(tls, p, Uint64FromInt64(int64(endpat)-int64(p)), bp, flags) - p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(**(**Tsize_t)(__ccgo_up(bp))) v2 = _str_next(tls, s, Uint64FromInt64(int64(endstr)-int64(s)), bp+8) k = v2 if v2 <= 0 { @@ -128731,7 +128731,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, } break } - s = s + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) + s = s + uintptr(**(**Tsize_t)(__ccgo_up(bp + 8))) if flags&int32(FNM_CASEFOLD) != 0 { v2 = _casefold(tls, k) } else { @@ -128739,7 +128739,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, } kfold = v2 if c == -int32(3) { - if !(_match_bracket(tls, p-uintptr(*(*Tsize_t)(unsafe.Pointer(bp))), k, kfold) != 0) { + if !(_match_bracket(tls, p-uintptr(**(**Tsize_t)(__ccgo_up(bp))), k, kfold) != 0) { return int32(FNM_NOMATCH) } } else { @@ -128759,7 +128759,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, s = str for { c = _pat_next(tls, p, Uint64FromInt64(int64(endpat)-int64(p)), bp, flags) - p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(**(**Tsize_t)(__ccgo_up(bp))) /* Encountering * completes/commits a component */ if c == -int32(5) { pat = p @@ -128777,7 +128777,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, } kfold = v2 if c == -int32(3) { - if !(_match_bracket(tls, p-uintptr(*(*Tsize_t)(unsafe.Pointer(bp))), k, kfold) != 0) { + if !(_match_bracket(tls, p-uintptr(**(**Tsize_t)(__ccgo_up(bp))), k, kfold) != 0) { break } } else { @@ -128785,7 +128785,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, break } } - s = s + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) + s = s + uintptr(**(**Tsize_t)(__ccgo_up(bp + 8))) goto _14 _14: } @@ -128796,7 +128796,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, * char, or past all invalid bytes otherwise. */ k = _str_next(tls, str, Uint64FromInt64(int64(endstr)-int64(str)), bp+8) if k > 0 { - str = str + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) + str = str + uintptr(**(**Tsize_t)(__ccgo_up(bp + 8))) } else { str = str + 1 for { @@ -128828,7 +128828,7 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { for { s = str for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('/')) { + if !(**(**uint8)(__ccgo_up(s)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32('/')) { break } goto _2 @@ -128846,9 +128846,9 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { goto _3 _3: ; - p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(**(**Tsize_t)(__ccgo_up(bp))) } - if c != Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) && (!(*(*uint8)(unsafe.Pointer(s)) != 0) || !(flags&Int32FromInt32(FNM_LEADING_DIR) != 0)) { + if c != Int32FromUint8(**(**uint8)(__ccgo_up(s))) && (!(**(**uint8)(__ccgo_up(s)) != 0) || !(flags&Int32FromInt32(FNM_LEADING_DIR) != 0)) { return int32(FNM_NOMATCH) } if _fnmatch_internal(tls, pat, Uint64FromInt64(int64(p)-int64(pat)), str, Uint64FromInt64(int64(s)-int64(str)), flags) != 0 { @@ -128858,7 +128858,7 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { return 0 } str = s + uintptr(1) - pat = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + pat = p + uintptr(**(**Tsize_t)(__ccgo_up(bp))) goto _1 _1: } @@ -128866,10 +128866,10 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { if flags&int32(FNM_LEADING_DIR) != 0 { s = str for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('/') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32('/') { goto _5 } if !(_fnmatch_internal(tls, pat, Uint64FromInt32(-Int32FromInt32(1)), str, Uint64FromInt64(int64(s)-int64(str)), flags) != 0) { @@ -128919,14 +128919,14 @@ func _append(tls *TLS, tail uintptr, name uintptr, len1 Tsize_t, mark int32) (r if !(new1 != 0) { return -int32(1) } - (*Tmatch)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tail)))).Fnext = new1 + (*Tmatch)(unsafe.Pointer(**(**uintptr)(__ccgo_up(tail)))).Fnext = new1 (*Tmatch)(unsafe.Pointer(new1)).Fnext = UintptrFromInt32(0) Xmemcpy(tls, new1+8, name, len1+uint64(1)) - if mark != 0 && len1 != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(name + uintptr(len1-uint64(1))))) != int32('/') { + if mark != 0 && len1 != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(name + uintptr(len1-uint64(1))))) != int32('/') { *(*uint8)(unsafe.Pointer(new1 + 8 + uintptr(len1))) = uint8('/') *(*uint8)(unsafe.Pointer(new1 + 8 + uintptr(len1+uint64(1)))) = uint8(0) } - *(*uintptr)(unsafe.Pointer(tail)) = new1 + **(**uintptr)(__ccgo_up(tail)) = new1 return 0 } @@ -128946,15 +128946,15 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag } /* Special-case the remaining pattern being all slashes, in * which case we can use caller-passed type if it's a dir. */ - if *(*uint8)(unsafe.Pointer(pat)) != 0 && type1 != int32(DT_DIR) { + if **(**uint8)(__ccgo_up(pat)) != 0 && type1 != int32(DT_DIR) { type1 = 0 } - for pos+uint64(1) < uint64(PATH_MAX) && Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) == int32('/') { + for pos+uint64(1) < uint64(PATH_MAX) && Int32FromUint8(**(**uint8)(__ccgo_up(pat))) == int32('/') { v1 = pos pos = pos + 1 v2 = pat pat = pat + 1 - *(*uint8)(unsafe.Pointer(buf + uintptr(v1))) = *(*uint8)(unsafe.Pointer(v2)) + **(**uint8)(__ccgo_up(buf + uintptr(v1))) = **(**uint8)(__ccgo_up(v2)) } /* Consume maximal [escaped-]literal prefix of pattern, copying * and un-escaping it to the running buffer as we go. */ @@ -128963,10 +128963,10 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag in_bracket = 0 overflow = 0 for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(i)))) != int32('*') && Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(i)))) != int32('?') && (!(in_bracket != 0) || Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(i)))) != int32(']'))) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(i)))) != int32('*') && Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(i)))) != int32('?') && (!(in_bracket != 0) || Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(i)))) != int32(']'))) { break } - if !(*(*uint8)(unsafe.Pointer(pat + uintptr(i))) != 0) { + if !(**(**uint8)(__ccgo_up(pat + uintptr(i))) != 0) { if overflow != 0 { return 0 } @@ -128977,25 +128977,25 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag i = v4 break } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(i)))) == int32('[') { + if Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(i)))) == int32('[') { in_bracket = int32(1) } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(i)))) == int32('\\') && !(flags&Int32FromInt32(GLOB_NOESCAPE) != 0) { + if Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(i)))) == int32('\\') && !(flags&Int32FromInt32(GLOB_NOESCAPE) != 0) { /* Backslashes inside a bracket are (at least by * our interpretation) non-special, so if next * char is ']' we have a complete expression. */ - if in_bracket != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(i+int64(1))))) == int32(']') { + if in_bracket != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(i+int64(1))))) == int32(']') { break } /* Unpaired final backslash never matches. */ - if !(*(*uint8)(unsafe.Pointer(pat + uintptr(i+int64(1)))) != 0) { + if !(**(**uint8)(__ccgo_up(pat + uintptr(i+int64(1)))) != 0) { return 0 } i = i + 1 } } } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(i)))) == int32('/') { + if Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(i)))) == int32('/') { if overflow != 0 { return 0 } @@ -129013,7 +129013,7 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag if pos+Uint64FromInt64(j+Int64FromInt32(1)) < uint64(PATH_MAX) { v4 = j j = j + 1 - *(*uint8)(unsafe.Pointer(buf + uintptr(pos+Uint64FromInt64(v4)))) = *(*uint8)(unsafe.Pointer(pat + uintptr(i))) + **(**uint8)(__ccgo_up(buf + uintptr(pos+Uint64FromInt64(v4)))) = **(**uint8)(__ccgo_up(pat + uintptr(i))) } else { if in_bracket != 0 { overflow = int32(1) @@ -129029,17 +129029,17 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag ; i = i + 1 } - *(*uint8)(unsafe.Pointer(buf + uintptr(pos))) = uint8(0) - if !(*(*uint8)(unsafe.Pointer(pat)) != 0) { + **(**uint8)(__ccgo_up(buf + uintptr(pos))) = uint8(0) + if !(**(**uint8)(__ccgo_up(pat)) != 0) { if flags&int32(GLOB_MARK) != 0 && (!(type1 != 0) || type1 == int32(DT_LNK)) && !(Xstat(tls, buf, bp) != 0) { - if (*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFDIR) { + if (**(**Tstat)(__ccgo_up(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFDIR) { type1 = int32(DT_DIR) } else { type1 = int32(DT_REG) } } if !(type1 != 0) && Xlstat(tls, buf, bp) != 0 { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(ENOENT) && ((*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(ENOENT) && ((*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, **(**int32)(__ccgo_up(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0) { return int32(GLOB_ABORTED) } return 0 @@ -129056,7 +129056,7 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag if p2 != 0 && !(flags&Int32FromInt32(GLOB_NOESCAPE) != 0) { p = p2 for { - if !(p > pat && Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) == int32('\\')) { + if !(p > pat && Int32FromUint8(**(**uint8)(__ccgo_up(p + uintptr(-Int32FromInt32(1))))) == int32('\\')) { break } goto _6 @@ -129076,14 +129076,14 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag } dir = Xopendir(tls, v2) if !(dir != 0) { - if (*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0 { + if (*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, **(**int32)(__ccgo_up(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0 { return int32(GLOB_ABORTED) } return 0 } - old_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + old_errno = **(**int32)(__ccgo_up(X__errno_location(tls))) for { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = 0 + **(**int32)(__ccgo_up(X__errno_location(tls))) = 0 v2 = Xreaddir(tls, dir) de = v2 if !(v2 != 0) { @@ -129098,7 +129098,7 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag continue } if p2 != 0 { - *(*uint8)(unsafe.Pointer(p2)) = uint8(0) + **(**uint8)(__ccgo_up(p2)) = uint8(0) } if flags&int32(GLOB_NOESCAPE) != 0 { v9 = int32(FNM_NOESCAPE) @@ -129116,12 +129116,12 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag } /* With GLOB_PERIOD, don't allow matching . or .. unless * fnmatch would match them with FNM_PERIOD rules in effect. */ - if p2 != 0 && flags&int32(GLOB_PERIOD) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(de + 19))) == int32('.') && (!(*(*uint8)(unsafe.Pointer(de + 19 + 1)) != 0) || Int32FromUint8(*(*uint8)(unsafe.Pointer(de + 19 + 1))) == int32('.') && !(*(*uint8)(unsafe.Pointer(de + 19 + 2)) != 0)) && Xfnmatch(tls, pat, de+19, fnm_flags|int32(FNM_PERIOD)) != 0 { + if p2 != 0 && flags&int32(GLOB_PERIOD) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(de + 19))) == int32('.') && (!(**(**uint8)(__ccgo_up(de + 19 + 1)) != 0) || Int32FromUint8(**(**uint8)(__ccgo_up(de + 19 + 1))) == int32('.') && !(**(**uint8)(__ccgo_up(de + 19 + 2)) != 0)) && Xfnmatch(tls, pat, de+19, fnm_flags|int32(FNM_PERIOD)) != 0 { continue } Xmemcpy(tls, buf+uintptr(pos), de+19, l+uint64(1)) if p2 != 0 { - *(*uint8)(unsafe.Pointer(p2)) = saved_sep + **(**uint8)(__ccgo_up(p2)) = saved_sep } if p2 != 0 { v2 = p2 @@ -129134,15 +129134,15 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag return r } } - readerr = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + readerr = **(**int32)(__ccgo_up(X__errno_location(tls))) if p2 != 0 { - *(*uint8)(unsafe.Pointer(p2)) = saved_sep + **(**uint8)(__ccgo_up(p2)) = saved_sep } Xclosedir(tls, dir) - if readerr != 0 && ((*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0) { + if readerr != 0 && ((*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, **(**int32)(__ccgo_up(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0) { return int32(GLOB_ABORTED) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = old_errno + **(**int32)(__ccgo_up(X__errno_location(tls))) = old_errno return 0 } @@ -129168,7 +129168,7 @@ func _freelist(tls *TLS, head uintptr) { } func _sort(tls *TLS, a uintptr, b uintptr) (r int32) { - return Xstrcmp(tls, *(*uintptr)(unsafe.Pointer(a)), *(*uintptr)(unsafe.Pointer(b))) + return Xstrcmp(tls, **(**uintptr)(__ccgo_up(a)), **(**uintptr)(__ccgo_up(b))) } func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { @@ -129181,25 +129181,25 @@ func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { var _ /* pw at bp+0 */ Tpasswd var _ /* res at bp+48 */ uintptr _, _, _, _, _, _, _, _, _ = delim, home, i, name_end, p, v1, v10, v2, v4 - p = *(*uintptr)(unsafe.Pointer(pat)) + uintptr(1) + p = **(**uintptr)(__ccgo_up(pat)) + uintptr(1) i = uint64(0) name_end = X__strchrnul(tls, p, int32('/')) - v1 = *(*uint8)(unsafe.Pointer(name_end)) + v1 = **(**uint8)(__ccgo_up(name_end)) delim = v1 if v1 != 0 { v2 = name_end name_end = name_end + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8(0) + **(**uint8)(__ccgo_up(v2)) = uint8(0) } - *(*uintptr)(unsafe.Pointer(pat)) = name_end - if *(*uint8)(unsafe.Pointer(p)) != 0 { + **(**uintptr)(__ccgo_up(pat)) = name_end + if **(**uint8)(__ccgo_up(p)) != 0 { v2 = UintptrFromInt32(0) } else { v2 = Xgetenv(tls, __ccgo_ts+1437) } home = v2 if !(home != 0) { - if *(*uint8)(unsafe.Pointer(p)) != 0 { + if **(**uint8)(__ccgo_up(p)) != 0 { v4 = Xgetpwnam_r(tls, p, bp, buf, uint64(PATH_MAX), bp+48) } else { v4 = Xgetpwuid_r(tls, Xgetuid(tls), bp, buf, uint64(PATH_MAX), bp+48) @@ -129218,7 +129218,7 @@ func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { return int32(GLOB_NOSPACE) _7: ; - if !!(*(*uintptr)(unsafe.Pointer(bp + 48)) != 0) { + if !!(**(**uintptr)(__ccgo_up(bp + 48)) != 0) { goto _9 } _6: @@ -129228,26 +129228,26 @@ func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { ; _8: ; - home = (*(*Tpasswd)(unsafe.Pointer(bp))).Fpw_dir + home = (**(**Tpasswd)(__ccgo_up(bp))).Fpw_dir } - for i < Uint64FromInt32(Int32FromInt32(PATH_MAX)-Int32FromInt32(2)) && *(*uint8)(unsafe.Pointer(home)) != 0 { + for i < Uint64FromInt32(Int32FromInt32(PATH_MAX)-Int32FromInt32(2)) && **(**uint8)(__ccgo_up(home)) != 0 { v10 = i i = i + 1 v2 = home home = home + 1 - *(*uint8)(unsafe.Pointer(buf + uintptr(v10))) = *(*uint8)(unsafe.Pointer(v2)) + **(**uint8)(__ccgo_up(buf + uintptr(v10))) = **(**uint8)(__ccgo_up(v2)) } - if *(*uint8)(unsafe.Pointer(home)) != 0 { + if **(**uint8)(__ccgo_up(home)) != 0 { return int32(GLOB_NOMATCH) } v1 = delim - *(*uint8)(unsafe.Pointer(buf + uintptr(i))) = v1 + **(**uint8)(__ccgo_up(buf + uintptr(i))) = v1 if v1 != 0 { i = i + 1 v10 = i - *(*uint8)(unsafe.Pointer(buf + uintptr(v10))) = uint8(0) + **(**uint8)(__ccgo_up(buf + uintptr(v10))) = uint8(0) } - *(*Tsize_t)(unsafe.Pointer(pos)) = i + **(**Tsize_t)(__ccgo_up(pos)) = i return 0 } @@ -129270,10 +129270,10 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint var _ /* s at bp+4120 */ uintptr var _ /* tail at bp+8 */ uintptr _, _, _, _, _, _, _ = cnt, error1, i, offs, p, pathv, v1 - *(*Tmatch)(unsafe.Pointer(bp)) = struct { + **(**Tmatch)(__ccgo_up(bp)) = struct { Fnext uintptr }{} - *(*uintptr)(unsafe.Pointer(bp + 8)) = bp + **(**uintptr)(__ccgo_up(bp + 8)) = bp if flags&int32(GLOB_DOOFFS) != 0 { v1 = (*Tglob_t)(unsafe.Pointer(g)).Fgl_offs } else { @@ -129289,19 +129289,19 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathc = uint64(0) (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv = UintptrFromInt32(0) } - if *(*uint8)(unsafe.Pointer(pat)) != 0 { + if **(**uint8)(__ccgo_up(pat)) != 0 { p = Xstrdup(tls, pat) if !(p != 0) { return int32(GLOB_NOSPACE) } - (*(*[4096]uint8)(unsafe.Pointer(bp + 16)))[0] = uint8(0) - *(*Tsize_t)(unsafe.Pointer(bp + 4112)) = uint64(0) - *(*uintptr)(unsafe.Pointer(bp + 4120)) = p - if flags&(Int32FromInt32(GLOB_TILDE)|Int32FromInt32(GLOB_TILDE_CHECK)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('~') { + (**(**[4096]uint8)(__ccgo_up(bp + 16)))[0] = uint8(0) + **(**Tsize_t)(__ccgo_up(bp + 4112)) = uint64(0) + **(**uintptr)(__ccgo_up(bp + 4120)) = p + if flags&(Int32FromInt32(GLOB_TILDE)|Int32FromInt32(GLOB_TILDE_CHECK)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('~') { error1 = _expand_tilde(tls, bp+4120, bp+16, bp+4112) } if !(error1 != 0) { - error1 = _do_glob(tls, bp+16, *(*Tsize_t)(unsafe.Pointer(bp + 4112)), 0, *(*uintptr)(unsafe.Pointer(bp + 4120)), flags, __ccgo_fp_errfunc, bp+8) + error1 = _do_glob(tls, bp+16, **(**Tsize_t)(__ccgo_up(bp + 4112)), 0, **(**uintptr)(__ccgo_up(bp + 4120)), flags, __ccgo_fp_errfunc, bp+8) } Xfree(tls, p) } @@ -129310,20 +129310,20 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint return error1 } cnt = uint64(0) - *(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*Tmatch)(unsafe.Pointer(bp))).Fnext + **(**uintptr)(__ccgo_up(bp + 8)) = (**(**Tmatch)(__ccgo_up(bp))).Fnext for { - if !(*(*uintptr)(unsafe.Pointer(bp + 8)) != 0) { + if !(**(**uintptr)(__ccgo_up(bp + 8)) != 0) { break } goto _2 _2: ; - *(*uintptr)(unsafe.Pointer(bp + 8)) = (*Tmatch)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fnext + **(**uintptr)(__ccgo_up(bp + 8)) = (*Tmatch)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp + 8)))).Fnext cnt = cnt + 1 } if !(cnt != 0) { if flags&int32(GLOB_NOCHECK) != 0 { - *(*uintptr)(unsafe.Pointer(bp + 8)) = bp + **(**uintptr)(__ccgo_up(bp + 8)) = bp if _append(tls, bp+8, pat, _strlen(tls, pat), 0) != 0 { return int32(GLOB_NOSPACE) } @@ -129353,7 +129353,7 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint if !(i < offs) { break } - *(*uintptr)(unsafe.Pointer((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(i)*8)) = UintptrFromInt32(0) + **(**uintptr)(__ccgo_up((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(i)*8)) = UintptrFromInt32(0) goto _3 _3: ; @@ -129361,20 +129361,20 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint } } i = uint64(0) - *(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*Tmatch)(unsafe.Pointer(bp))).Fnext + **(**uintptr)(__ccgo_up(bp + 8)) = (**(**Tmatch)(__ccgo_up(bp))).Fnext for { if !(i < cnt) { break } - *(*uintptr)(unsafe.Pointer((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(offs+i)*8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + **(**uintptr)(__ccgo_up((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(offs+i)*8)) = **(**uintptr)(__ccgo_up(bp + 8)) + 8 goto _4 _4: ; - *(*uintptr)(unsafe.Pointer(bp + 8)) = (*Tmatch)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fnext + **(**uintptr)(__ccgo_up(bp + 8)) = (*Tmatch)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp + 8)))).Fnext i = i + 1 } - *(*uintptr)(unsafe.Pointer((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(offs+i)*8)) = UintptrFromInt32(0) - *(*Tsize_t)(unsafe.Pointer(g)) += cnt + **(**uintptr)(__ccgo_up((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(offs+i)*8)) = UintptrFromInt32(0) + **(**Tsize_t)(__ccgo_up(g)) += cnt if !(flags&Int32FromInt32(GLOB_NOSORT) != 0) { Xqsort(tls, (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv+uintptr(offs)*8, cnt, uint64(8), __ccgo_fp(_sort)) } @@ -129392,7 +129392,7 @@ func Xglobfree(tls *TLS, g uintptr) { if !(i < (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathc) { break } - Xfree(tls, *(*uintptr)(unsafe.Pointer((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr((*Tglob_t)(unsafe.Pointer(g)).Fgl_offs+i)*8))-uintptr(uint64(UintptrFromInt32(0)+8))) + Xfree(tls, **(**uintptr)(__ccgo_up((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr((*Tglob_t)(unsafe.Pointer(g)).Fgl_offs+i)*8))-uintptr(uint64(UintptrFromInt32(0)+8))) goto _1 _1: ; @@ -129791,7 +129791,7 @@ func _tre_stack_push(tls *TLS, s uintptr, value Ttre_stack_item) (r Treg_errcode var new_size int32 _, _ = new_buffer, new_size if (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr < (*Ttre_stack_t)(unsafe.Pointer(s)).Fsize { - *(*Ttre_stack_item)(unsafe.Pointer((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr((*Ttre_stack_t)(unsafe.Pointer(s)).Fptr)*8)) = value + **(**Ttre_stack_item)(__ccgo_up((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr((*Ttre_stack_t)(unsafe.Pointer(s)).Fptr)*8)) = value (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr = (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr + 1 } else { if (*Ttre_stack_t)(unsafe.Pointer(s)).Fsize >= (*Ttre_stack_t)(unsafe.Pointer(s)).Fmax_size { @@ -129825,7 +129825,7 @@ func _tre_stack_push_voidptr(tls *TLS, s uintptr, value uintptr) (r Treg_errcode defer tls.Free(16) var _ /* item at bp+0 */ Ttre_stack_item *(*uintptr)(unsafe.Pointer(bp)) = value - return _tre_stack_push(tls, s, *(*Ttre_stack_item)(unsafe.Pointer(bp))) + return _tre_stack_push(tls, s, **(**Ttre_stack_item)(__ccgo_up(bp))) } func _tre_stack_pop_int(tls *TLS, s uintptr) (r int32) { @@ -129835,7 +129835,7 @@ func _tre_stack_pop_int(tls *TLS, s uintptr) (r int32) { v2 = s + 12 *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) - 1 v1 = *(*int32)(unsafe.Pointer(v2)) - return *(*int32)(unsafe.Pointer(&*(*Ttre_stack_item)(unsafe.Pointer((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr(v1)*8)))) + return *(*int32)(unsafe.Pointer(&**(**Ttre_stack_item)(__ccgo_up((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr(v1)*8)))) } func _tre_stack_pop_voidptr(tls *TLS, s uintptr) (r uintptr) { @@ -129935,7 +129935,7 @@ func _tre_expand_macro(tls *TLS, s uintptr) (r uintptr) { _ = i i = 0 for { - if !(_tre_macros[i].Fc != 0 && Int32FromUint8(_tre_macros[i].Fc) != Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))) { + if !(_tre_macros[i].Fc != 0 && Int32FromUint8(_tre_macros[i].Fc) != Int32FromUint8(**(**uint8)(__ccgo_up(s)))) { break } goto _1 @@ -129952,7 +129952,7 @@ func _tre_compare_lit(tls *TLS, a uintptr, b uintptr) (r int32) { la = a lb = b /* assumes the range of valid code_min is < INT_MAX */ - return int32((*Ttre_literal_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(la)))).Fcode_min - (*Ttre_literal_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(lb)))).Fcode_min) + return int32((*Ttre_literal_t)(unsafe.Pointer(**(**uintptr)(__ccgo_up(la)))).Fcode_min - (*Ttre_literal_t)(unsafe.Pointer(**(**uintptr)(__ccgo_up(lb)))).Fcode_min) } type Tliterals = struct { @@ -129970,7 +129970,7 @@ func _tre_new_lit(tls *TLS, p uintptr) (r uintptr) { if (*Tliterals)(unsafe.Pointer(p)).Fcap1 >= Int32FromInt32(1)< max { @@ -130162,7 +130162,7 @@ func _parse_bracket_terms(tls *TLS, ctx uintptr, s uintptr, ls uintptr, neg uint v6 = neg + 4 v2 = *(*int32)(unsafe.Pointer(v6)) *(*int32)(unsafe.Pointer(v6)) = *(*int32)(unsafe.Pointer(v6)) + 1 - *(*Ttre_ctype_t)(unsafe.Pointer(neg + 8 + uintptr(v2)*8)) = class + **(**Ttre_ctype_t)(__ccgo_up(neg + 8 + uintptr(v2)*8)) = class } else { lit = _tre_new_lit(tls, ls) if !(lit != 0) { @@ -130202,23 +130202,23 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { _, _, _, _, _, _, _, _, _, _, _ = err, i, lit, max, min, n, nc, negmax, negmin, node, v1 node = uintptr(0) nc = uintptr(0) - (*(*Tliterals)(unsafe.Pointer(bp))).Fmem = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem - (*(*Tliterals)(unsafe.Pointer(bp))).Flen1 = 0 - (*(*Tliterals)(unsafe.Pointer(bp))).Fcap1 = int32(32) - (*(*Tliterals)(unsafe.Pointer(bp))).Fa = Xmalloc(tls, Uint64FromInt32((*(*Tliterals)(unsafe.Pointer(bp))).Fcap1)*uint64(8)) - if !((*(*Tliterals)(unsafe.Pointer(bp))).Fa != 0) { + (**(**Tliterals)(__ccgo_up(bp))).Fmem = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem + (**(**Tliterals)(__ccgo_up(bp))).Flen1 = 0 + (**(**Tliterals)(__ccgo_up(bp))).Fcap1 = int32(32) + (**(**Tliterals)(__ccgo_up(bp))).Fa = Xmalloc(tls, Uint64FromInt32((**(**Tliterals)(__ccgo_up(bp))).Fcap1)*uint64(8)) + if !((**(**Tliterals)(__ccgo_up(bp))).Fa != 0) { return int32(REG_ESPACE) } - (*(*Tneg)(unsafe.Pointer(bp + 24))).Flen1 = 0 - (*(*Tneg)(unsafe.Pointer(bp + 24))).Fnegate = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('^')) - if (*(*Tneg)(unsafe.Pointer(bp + 24))).Fnegate != 0 { + (**(**Tneg)(__ccgo_up(bp + 24))).Flen1 = 0 + (**(**Tneg)(__ccgo_up(bp + 24))).Fnegate = BoolInt32(Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('^')) + if (**(**Tneg)(__ccgo_up(bp + 24))).Fnegate != 0 { s = s + 1 } err = _parse_bracket_terms(tls, ctx, s, bp, bp+24) if err != REG_OK { goto parse_bracket_done } - if (*(*Tneg)(unsafe.Pointer(bp + 24))).Fnegate != 0 { + if (**(**Tneg)(__ccgo_up(bp + 24))).Fnegate != 0 { /* * With REG_NEWLINE, POSIX requires that newlines are not matched by * any form of a non-matching list. @@ -130234,7 +130234,7 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition = -int32(1) } /* Sort the array if we need to negate it. */ - Xqsort(tls, (*(*Tliterals)(unsafe.Pointer(bp))).Fa, Uint64FromInt32((*(*Tliterals)(unsafe.Pointer(bp))).Flen1), uint64(8), __ccgo_fp(_tre_compare_lit)) + Xqsort(tls, (**(**Tliterals)(__ccgo_up(bp))).Fa, Uint64FromInt32((**(**Tliterals)(__ccgo_up(bp))).Flen1), uint64(8), __ccgo_fp(_tre_compare_lit)) /* extra lit for the last negated range */ lit = _tre_new_lit(tls, bp) if !(lit != 0) { @@ -130245,14 +130245,14 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max = int64(Int32FromInt32(TRE_CHAR_MAX) + Int32FromInt32(1)) (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition = -int32(1) /* negated classes */ - if (*(*Tneg)(unsafe.Pointer(bp + 24))).Flen1 != 0 { - nc = X__tre_mem_alloc_impl(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, 0, UintptrFromInt32(0), 0, Uint64FromInt32((*(*Tneg)(unsafe.Pointer(bp + 24))).Flen1+Int32FromInt32(1))*uint64(8)) + if (**(**Tneg)(__ccgo_up(bp + 24))).Flen1 != 0 { + nc = X__tre_mem_alloc_impl(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, 0, UintptrFromInt32(0), 0, Uint64FromInt32((**(**Tneg)(__ccgo_up(bp + 24))).Flen1+Int32FromInt32(1))*uint64(8)) if !(nc != 0) { err = int32(REG_ESPACE) goto parse_bracket_done } - Xmemcpy(tls, nc, bp+24+8, Uint64FromInt32((*(*Tneg)(unsafe.Pointer(bp + 24))).Flen1)*uint64(8)) - *(*Ttre_ctype_t)(unsafe.Pointer(nc + uintptr((*(*Tneg)(unsafe.Pointer(bp + 24))).Flen1)*8)) = uint64(0) + Xmemcpy(tls, nc, bp+24+8, Uint64FromInt32((**(**Tneg)(__ccgo_up(bp + 24))).Flen1)*uint64(8)) + **(**Ttre_ctype_t)(__ccgo_up(nc + uintptr((**(**Tneg)(__ccgo_up(bp + 24))).Flen1)*8)) = uint64(0) } } /* Build a union of the items in the array, negated if necessary. */ @@ -130261,13 +130261,13 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { negmax = v1 i = 0 for { - if !(i < (*(*Tliterals)(unsafe.Pointer(bp))).Flen1) { + if !(i < (**(**Tliterals)(__ccgo_up(bp))).Flen1) { break } - lit = *(*uintptr)(unsafe.Pointer((*(*Tliterals)(unsafe.Pointer(bp))).Fa + uintptr(i)*8)) + lit = **(**uintptr)(__ccgo_up((**(**Tliterals)(__ccgo_up(bp))).Fa + uintptr(i)*8)) min = int32((*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min) max = int32((*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max) - if (*(*Tneg)(unsafe.Pointer(bp + 24))).Fnegate != 0 { + if (**(**Tneg)(__ccgo_up(bp + 24))).Fnegate != 0 { if min <= negmin { /* Overlap. */ if max+int32(1) >= negmin { @@ -130299,22 +130299,22 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { goto parse_bracket_done parse_bracket_done: ; - Xfree(tls, (*(*Tliterals)(unsafe.Pointer(bp))).Fa) + Xfree(tls, (**(**Tliterals)(__ccgo_up(bp))).Fa) (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition + 1 (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = node return err } func _parse_dup_count(tls *TLS, s uintptr, n uintptr) (r uintptr) { - *(*int32)(unsafe.Pointer(n)) = -int32(1) - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + **(**int32)(__ccgo_up(n)) = -int32(1) + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return s } - *(*int32)(unsafe.Pointer(n)) = 0 + **(**int32)(__ccgo_up(n)) = 0 for { - *(*int32)(unsafe.Pointer(n)) = int32(10)**(*int32)(unsafe.Pointer(n)) + (Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) - int32('0')) + **(**int32)(__ccgo_up(n)) = int32(10)***(**int32)(__ccgo_up(n)) + (Int32FromUint8(**(**uint8)(__ccgo_up(s))) - int32('0')) s = s + 1 - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) || *(*int32)(unsafe.Pointer(n)) > int32(RE_DUP_MAX) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) || **(**int32)(__ccgo_up(n)) > int32(RE_DUP_MAX) { break } goto _1 @@ -130332,26 +130332,26 @@ func _parse_dup(tls *TLS, s uintptr, ere int32, pmin uintptr, pmax uintptr) (r u var _ /* min at bp+0 */ int32 _, _, _, _, _ = v1, v2, v3, v4, v5 s = _parse_dup_count(tls, s, bp) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32(',') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32(',') { s = _parse_dup_count(tls, s+uintptr(1), bp+4) } else { - *(*int32)(unsafe.Pointer(bp + 4)) = *(*int32)(unsafe.Pointer(bp)) + **(**int32)(__ccgo_up(bp + 4)) = **(**int32)(__ccgo_up(bp)) } - if v3 = *(*int32)(unsafe.Pointer(bp + 4)) < *(*int32)(unsafe.Pointer(bp)) && *(*int32)(unsafe.Pointer(bp + 4)) >= 0 || *(*int32)(unsafe.Pointer(bp + 4)) > int32(RE_DUP_MAX) || *(*int32)(unsafe.Pointer(bp)) > int32(RE_DUP_MAX) || *(*int32)(unsafe.Pointer(bp)) < 0; !v3 { + if v3 = **(**int32)(__ccgo_up(bp + 4)) < **(**int32)(__ccgo_up(bp)) && **(**int32)(__ccgo_up(bp + 4)) >= 0 || **(**int32)(__ccgo_up(bp + 4)) > int32(RE_DUP_MAX) || **(**int32)(__ccgo_up(bp)) > int32(RE_DUP_MAX) || **(**int32)(__ccgo_up(bp)) < 0; !v3 { if v2 = !(ere != 0); v2 { v1 = s s = s + 1 } } - if v5 = v3 || v2 && Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) != int32('\\'); !v5 { + if v5 = v3 || v2 && Int32FromUint8(**(**uint8)(__ccgo_up(v1))) != int32('\\'); !v5 { v4 = s s = s + 1 } - if v5 || Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) != int32('}') { + if v5 || Int32FromUint8(**(**uint8)(__ccgo_up(v4))) != int32('}') { return uintptr(0) } - *(*int32)(unsafe.Pointer(pmin)) = *(*int32)(unsafe.Pointer(bp)) - *(*int32)(unsafe.Pointer(pmax)) = *(*int32)(unsafe.Pointer(bp + 4)) + **(**int32)(__ccgo_up(pmin)) = **(**int32)(__ccgo_up(bp)) + **(**int32)(__ccgo_up(pmax)) = **(**int32)(__ccgo_up(bp + 4)) return s } @@ -130414,7 +130414,7 @@ func _parse_atom(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { var _ /* wc at bp+0 */ Twchar_t _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, ere, err, i, len1, node, p, tmp1, tmp11, tmp2, tmp21, v, val, v14, v16 ere = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fcflags & int32(REG_EXTENDED) - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(s))) { case int32('['): goto _1 case int32('\\'): @@ -130456,7 +130456,7 @@ _2: /* extensions: \b, \B, \<, \>, \xHH \x{HHHH} */ s = s + 1 v14 = s - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(v14))) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(v14))) { case 0: return int32(REG_EESCAPE) case int32('b'): @@ -130471,7 +130471,7 @@ _2: s = s + 1 v = 0 len1 = int32(2) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('{') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('{') { len1 = int32(8) s = s + 1 } @@ -130480,7 +130480,7 @@ _2: if !(i < len1 && v < int32(0x110000)) { break } - c = _hexval1(tls, uint32(*(*uint8)(unsafe.Pointer(s + uintptr(i))))) + c = _hexval1(tls, uint32(**(**uint8)(__ccgo_up(s + uintptr(i))))) if c < 0 { break } @@ -130492,7 +130492,7 @@ _2: } s = s + uintptr(i) if len1 == int32(8) { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('}') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32('}') { return int32(REG_EBRACE) } s = s + 1 @@ -130523,9 +130523,9 @@ _2: /* fallthrough */ fallthrough default: - if !(ere != 0) && uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('1') < uint32(9) { + if !(ere != 0) && uint32(**(**uint8)(__ccgo_up(s)))-uint32('1') < uint32(9) { /* back reference */ - val = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) - int32('0') + val = Int32FromUint8(**(**uint8)(__ccgo_up(s))) - int32('0') v14 = ctx + 44 v16 = *(*int32)(unsafe.Pointer(v14)) *(*int32)(unsafe.Pointer(v14)) = *(*int32)(unsafe.Pointer(v14)) + 1 @@ -130580,7 +130580,7 @@ _4: _5: ; /* '$' is special everywhere in EREs, and at the end of a BRE subexpression. */ - if !(ere != 0) && *(*uint8)(unsafe.Pointer(s + 1)) != 0 && (Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) != int32('\\') || Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 2))) != int32(')') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 2))) != int32('|')) { + if !(ere != 0) && **(**uint8)(__ccgo_up(s + 1)) != 0 && (Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) != int32('\\') || Int32FromUint8(**(**uint8)(__ccgo_up(s + 2))) != int32(')') && Int32FromUint8(**(**uint8)(__ccgo_up(s + 2))) != int32('|')) { goto parse_literal } node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(2), int32(ASSERT_AT_EOL), -int32(1)) @@ -130616,17 +130616,17 @@ parse_literal: if len1 < 0 { return int32(REG_BADPAT) } - if (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fcflags&int32(REG_ICASE) != 0 && (Xiswupper(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp)))) != 0 || Xiswlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp)))) != 0) { + if (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fcflags&int32(REG_ICASE) != 0 && (Xiswupper(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp)))) != 0 || Xiswlower(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp)))) != 0) { /* multiple opposite case characters are not supported */ - tmp11 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint32(Xtowupper(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))))), Int32FromUint32(Xtowupper(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))))), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) - tmp21 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint32(Xtowlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))))), Int32FromUint32(Xtowlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))))), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) + tmp11 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint32(Xtowupper(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))))), Int32FromUint32(Xtowupper(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))))), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) + tmp21 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint32(Xtowlower(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))))), Int32FromUint32(Xtowlower(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))))), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) if tmp11 != 0 && tmp21 != 0 { node = _tre_ast_new_union(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, tmp11, tmp21) } else { node = uintptr(0) } } else { - node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, *(*Twchar_t)(unsafe.Pointer(bp)), *(*Twchar_t)(unsafe.Pointer(bp)), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) + node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, **(**Twchar_t)(__ccgo_up(bp)), **(**Twchar_t)(__ccgo_up(bp)), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) } (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition + 1 s = s + uintptr(len1) @@ -130668,7 +130668,7 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { return err } for { - if !(ere != 0) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('\\') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) == int32('(') || ere != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('(') { + if !(ere != 0) && Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('\\') && Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) == int32('(') || ere != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('(') { v1 = _tre_stack_push_voidptr(tls, stack, nunion) err = v1 if v1 != REG_OK { @@ -130697,7 +130697,7 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart = s goto _3 } - if !(ere != 0) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('\\') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) == int32(')') || ere != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32(')') && depth != 0 { + if !(ere != 0) && Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('\\') && Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) == int32(')') || ere != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32(')') && depth != 0 { (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(1), -int32(1), -int32(1)) if !((*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn != 0) { return int32(REG_ESPACE) @@ -130713,52 +130713,52 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { parse_iter: ; for { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('\\') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('*') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32('\\') && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32('*') { if !(ere != 0) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('+') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('?') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('{') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32('+') && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32('?') && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32('{') { break } } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('\\') && ere != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('\\') && ere != 0 { break } /* extension: treat \+, \? as repetitions in BRE */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('\\') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) != int32('+') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) != int32('?') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) != int32('{') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('\\') && Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) != int32('+') && Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) != int32('?') && Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) != int32('{') { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('\\') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('\\') { s = s + 1 } /* handle ^* at the start of a BRE. */ - if !(ere != 0) && s == (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart+uintptr(1) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(-Int32FromInt32(1))))) == int32('^') { + if !(ere != 0) && s == (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart+uintptr(1) && Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(-Int32FromInt32(1))))) == int32('^') { break } /* extension: multiple consecutive *+?{,} is unspecified, but (a+)+ has to be supported so accepting a++ makes sense, note however that the RE_DUP_MAX limit can be circumvented: (a{255}){255} uses a lot of memory.. */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('{') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('{') { s = _parse_dup(tls, s+uintptr(1), ere, bp, bp+4) if !(s != 0) { return int32(REG_BADBR) } } else { - *(*int32)(unsafe.Pointer(bp)) = 0 - *(*int32)(unsafe.Pointer(bp + 4)) = -int32(1) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('+') { - *(*int32)(unsafe.Pointer(bp)) = int32(1) + **(**int32)(__ccgo_up(bp)) = 0 + **(**int32)(__ccgo_up(bp + 4)) = -int32(1) + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('+') { + **(**int32)(__ccgo_up(bp)) = int32(1) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('?') { - *(*int32)(unsafe.Pointer(bp + 4)) = int32(1) + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('?') { + **(**int32)(__ccgo_up(bp + 4)) = int32(1) } s = s + 1 } - if *(*int32)(unsafe.Pointer(bp + 4)) == 0 { + if **(**int32)(__ccgo_up(bp + 4)) == 0 { (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(1), -int32(1), -int32(1)) } else { - (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = _tre_ast_new_iter(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn, *(*int32)(unsafe.Pointer(bp)), *(*int32)(unsafe.Pointer(bp + 4)), 0) + (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = _tre_ast_new_iter(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn, **(**int32)(__ccgo_up(bp)), **(**int32)(__ccgo_up(bp + 4)), 0) } if !((*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn != 0) { return int32(REG_ESPACE) @@ -130767,13 +130767,13 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { _9: } nbranch = _tre_ast_new_catenation(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, nbranch, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn) - if ere != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('|') || ere != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32(')') && depth != 0 || !(ere != 0) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('\\') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) == int32(')') || !(ere != 0) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('\\') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) == int32('|') || !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if ere != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('|') || ere != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32(')') && depth != 0 || !(ere != 0) && Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('\\') && Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) == int32(')') || !(ere != 0) && Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('\\') && Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) == int32('|') || !(**(**uint8)(__ccgo_up(s)) != 0) { /* extension: empty branch is unspecified (), (|a), (a|) here they are not rejected but match on empty string */ - c = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) + c = Int32FromUint8(**(**uint8)(__ccgo_up(s))) nunion = _tre_ast_new_union(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, nunion, nbranch) nbranch = uintptr(0) - if c == int32('\\') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) == int32('|') { + if c == int32('\\') && Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) == int32('|') { s = s + uintptr(2) (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart = s } else { @@ -130919,22 +130919,22 @@ func _tre_purge_regset(tls *TLS, regset uintptr, tnfa uintptr, tag int32) { _, _, _ = i, id, start i = 0 for { - if !(*(*int32)(unsafe.Pointer(regset + uintptr(i)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(regset + uintptr(i)*4)) >= 0) { break } - id = *(*int32)(unsafe.Pointer(regset + uintptr(i)*4)) / int32(2) - start = BoolInt32(!(*(*int32)(unsafe.Pointer(regset + uintptr(i)*4))%Int32FromInt32(2) != 0)) + id = **(**int32)(__ccgo_up(regset + uintptr(i)*4)) / int32(2) + start = BoolInt32(!(**(**int32)(__ccgo_up(regset + uintptr(i)*4))%Int32FromInt32(2) != 0)) if start != 0 { - (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id)*16))).Fso_tag = tag + (**(**Ttre_submatch_data_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id)*16))).Fso_tag = tag } else { - (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id)*16))).Feo_tag = tag + (**(**Ttre_submatch_data_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id)*16))).Feo_tag = tag } goto _1 _1: ; i = i + 1 } - *(*int32)(unsafe.Pointer(regset)) = -int32(1) + **(**int32)(__ccgo_up(regset)) = -int32(1) } // C documentation @@ -130963,20 +130963,20 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u direction = int32(_TRE_TAG_MINIMIZE) if !(first_pass != 0) { (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fend_tag = 0 - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags)) = -int32(1) + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags)) = -int32(1) } regset = Xmalloc(tls, uint64(4)*uint64(((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches+Uint32FromInt32(1))*Uint32FromInt32(2))) if regset == UintptrFromInt32(0) { return int32(REG_ESPACE) } - *(*int32)(unsafe.Pointer(regset)) = -int32(1) + **(**int32)(__ccgo_up(regset)) = -int32(1) orig_regset = regset parents = Xmalloc(tls, uint64(4)*uint64((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches+Uint32FromInt32(1))) if parents == UintptrFromInt32(0) { Xfree(tls, regset) return int32(REG_ESPACE) } - *(*int32)(unsafe.Pointer(parents)) = -int32(1) + **(**int32)(__ccgo_up(parents)) = -int32(1) saved_states = Xmalloc(tls, uint64(8)*uint64((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches+Uint32FromInt32(1))) if saved_states == UintptrFromInt32(0) { Xfree(tls, regset) @@ -130988,7 +130988,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u if !(i <= (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches) { break } - (*(*Ttre_tag_states_t)(unsafe.Pointer(saved_states + uintptr(i)*8))).Ftag = -int32(1) + (**(**Ttre_tag_states_t)(__ccgo_up(saved_states + uintptr(i)*8))).Ftag = -int32(1) goto _1 _1: ; @@ -131027,7 +131027,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u /* Add end of this submatch to regset. */ i1 = 0 for { - if !(*(*int32)(unsafe.Pointer(regset + uintptr(i1)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(regset + uintptr(i1)*4)) >= 0) { break } goto _11 @@ -131035,12 +131035,12 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i1 = i1 + 1 } - *(*int32)(unsafe.Pointer(regset + uintptr(i1)*4)) = id*int32(2) + int32(1) - *(*int32)(unsafe.Pointer(regset + uintptr(i1+int32(1))*4)) = -int32(1) + **(**int32)(__ccgo_up(regset + uintptr(i1)*4)) = id*int32(2) + int32(1) + **(**int32)(__ccgo_up(regset + uintptr(i1+int32(1))*4)) = -int32(1) /* Pop this submatch from the parents stack. */ i1 = 0 for { - if !(*(*int32)(unsafe.Pointer(parents + uintptr(i1)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(parents + uintptr(i1)*4)) >= 0) { break } goto _12 @@ -131048,7 +131048,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i1 = i1 + 1 } - *(*int32)(unsafe.Pointer(parents + uintptr(i1-int32(1))*4)) = -int32(1) + **(**int32)(__ccgo_up(parents + uintptr(i1-int32(1))*4)) = -int32(1) goto _10 _3: ; @@ -131058,7 +131058,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u /* Add start of this submatch to regset. */ i2 = 0 for { - if !(*(*int32)(unsafe.Pointer(regset + uintptr(i2)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(regset + uintptr(i2)*4)) >= 0) { break } goto _13 @@ -131066,12 +131066,12 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i2 = i2 + 1 } - *(*int32)(unsafe.Pointer(regset + uintptr(i2)*4)) = id1 * int32(2) - *(*int32)(unsafe.Pointer(regset + uintptr(i2+int32(1))*4)) = -int32(1) + **(**int32)(__ccgo_up(regset + uintptr(i2)*4)) = id1 * int32(2) + **(**int32)(__ccgo_up(regset + uintptr(i2+int32(1))*4)) = -int32(1) if !(first_pass != 0) { i2 = 0 for { - if !(*(*int32)(unsafe.Pointer(parents + uintptr(i2)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(parents + uintptr(i2)*4)) >= 0) { break } goto _14 @@ -131079,26 +131079,26 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i2 = i2 + 1 } - (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id1)*16))).Fparents = UintptrFromInt32(0) + (**(**Ttre_submatch_data_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id1)*16))).Fparents = UintptrFromInt32(0) if i2 > 0 { p = Xmalloc(tls, uint64(4)*Uint64FromInt32(i2+Int32FromInt32(1))) if p == UintptrFromInt32(0) { status = int32(REG_ESPACE) goto _10 } - (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id1)*16))).Fparents = p + (**(**Ttre_submatch_data_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id1)*16))).Fparents = p i2 = 0 for { - if !(*(*int32)(unsafe.Pointer(parents + uintptr(i2)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(parents + uintptr(i2)*4)) >= 0) { break } - *(*int32)(unsafe.Pointer(p + uintptr(i2)*4)) = *(*int32)(unsafe.Pointer(parents + uintptr(i2)*4)) + **(**int32)(__ccgo_up(p + uintptr(i2)*4)) = **(**int32)(__ccgo_up(parents + uintptr(i2)*4)) goto _15 _15: ; i2 = i2 + 1 } - *(*int32)(unsafe.Pointer(p + uintptr(i2)*4)) = -int32(1) + **(**int32)(__ccgo_up(p + uintptr(i2)*4)) = -int32(1) } } /* Add end of this submatch to regset after processing this @@ -131116,16 +131116,16 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u case int32(_LITERAL): lit = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj if !((*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min < Int64FromInt32(0)) || (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min == int64(-int32(4)) { - if *(*int32)(unsafe.Pointer(regset)) >= 0 { + if **(**int32)(__ccgo_up(regset)) >= 0 { /* Regset is not empty, so add a tag before the literal or backref. */ if !(first_pass != 0) { status = _tre_add_tag_left(tls, mem, node, tag) - *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = direction + **(**Ttre_tag_direction_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = direction if minimal_tag >= 0 { i3 = 0 for { - if !(*(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3)*4)) >= 0) { break } goto _16 @@ -131133,9 +131133,9 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i3 = i3 + 1 } - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3)*4)) = tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3+int32(1))*4)) = minimal_tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3+int32(2))*4)) = -int32(1) + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3)*4)) = tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3+int32(1))*4)) = minimal_tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) num_minimals = num_minimals + 1 } @@ -131143,7 +131143,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u } else { (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fnum_tags = int32(1) } - *(*int32)(unsafe.Pointer(regset)) = -int32(1) + **(**int32)(__ccgo_up(regset)) = -int32(1) tag = next_tag num_tags = num_tags + 1 next_tag = next_tag + 1 @@ -131203,7 +131203,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u case int32(_ITERATION): iter = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj if first_pass != 0 { - status = _tre_stack_push_int(tls, stack, BoolInt32(*(*int32)(unsafe.Pointer(regset)) >= 0 || int32(uint32(*(*uint8)(unsafe.Pointer(iter + 16))&0x1>>0)) != 0)) + status = _tre_stack_push_int(tls, stack, BoolInt32(**(**int32)(__ccgo_up(regset)) >= 0 || int32(uint32(*(*uint8)(unsafe.Pointer(iter + 16))&0x1>>0)) != 0)) if status != REG_OK { break } @@ -131234,18 +131234,18 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u break } /* Regset is not empty, so add a tag here. */ - if *(*int32)(unsafe.Pointer(regset)) >= 0 || int32(uint32(*(*uint8)(unsafe.Pointer(iter + 16))&0x1>>0)) != 0 { + if **(**int32)(__ccgo_up(regset)) >= 0 || int32(uint32(*(*uint8)(unsafe.Pointer(iter + 16))&0x1>>0)) != 0 { if !(first_pass != 0) { status = _tre_add_tag_left(tls, mem, node, tag) if int32(uint32(*(*uint8)(unsafe.Pointer(iter + 16))&0x1>>0)) != 0 { - *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = int32(_TRE_TAG_MAXIMIZE) + **(**Ttre_tag_direction_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = int32(_TRE_TAG_MAXIMIZE) } else { - *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = direction + **(**Ttre_tag_direction_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = direction } if minimal_tag >= 0 { i4 = 0 for { - if !(*(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4)*4)) >= 0) { break } goto _17 @@ -131253,15 +131253,15 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i4 = i4 + 1 } - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4)*4)) = tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4+int32(1))*4)) = minimal_tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4+int32(2))*4)) = -int32(1) + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4)*4)) = tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4+int32(1))*4)) = minimal_tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) num_minimals = num_minimals + 1 } _tre_purge_regset(tls, regset, tnfa, tag) } - *(*int32)(unsafe.Pointer(regset)) = -int32(1) + **(**int32)(__ccgo_up(regset)) = -int32(1) tag = next_tag num_tags = num_tags + 1 next_tag = next_tag + 1 @@ -131271,7 +131271,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u uni = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj left1 = (*Ttre_union_t)(unsafe.Pointer(uni)).Fleft right1 = (*Ttre_union_t)(unsafe.Pointer(uni)).Fright - if *(*int32)(unsafe.Pointer(regset)) >= 0 { + if **(**int32)(__ccgo_up(regset)) >= 0 { left_tag = next_tag right_tag = next_tag + int32(1) } else { @@ -131291,7 +131291,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u if status != REG_OK { break } - status = _tre_stack_push_int(tls, stack, BoolInt32(*(*int32)(unsafe.Pointer(regset)) >= 0)) + status = _tre_stack_push_int(tls, stack, BoolInt32(**(**int32)(__ccgo_up(regset)) >= 0)) if status != REG_OK { break } @@ -131335,14 +131335,14 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u break } /* Regset is not empty, so add a tag here. */ - if *(*int32)(unsafe.Pointer(regset)) >= 0 { + if **(**int32)(__ccgo_up(regset)) >= 0 { if !(first_pass != 0) { status = _tre_add_tag_left(tls, mem, node, tag) - *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = direction + **(**Ttre_tag_direction_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = direction if minimal_tag >= 0 { i5 = 0 for { - if !(*(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5)*4)) >= 0) { break } goto _18 @@ -131350,15 +131350,15 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i5 = i5 + 1 } - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5)*4)) = tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5+int32(1))*4)) = minimal_tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5+int32(2))*4)) = -int32(1) + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5)*4)) = tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5+int32(1))*4)) = minimal_tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) num_minimals = num_minimals + 1 } _tre_purge_regset(tls, regset, tnfa, tag) } - *(*int32)(unsafe.Pointer(regset)) = -int32(1) + **(**int32)(__ccgo_up(regset)) = -int32(1) tag = next_tag num_tags = num_tags + 1 next_tag = next_tag + 1 @@ -131375,7 +131375,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u /* Push this submatch on the parents stack. */ i6 = 0 for { - if !(*(*int32)(unsafe.Pointer(parents + uintptr(i6)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(parents + uintptr(i6)*4)) >= 0) { break } goto _19 @@ -131383,8 +131383,8 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i6 = i6 + 1 } - *(*int32)(unsafe.Pointer(parents + uintptr(i6)*4)) = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fsubmatch_id - *(*int32)(unsafe.Pointer(parents + uintptr(i6+int32(1))*4)) = -int32(1) + **(**int32)(__ccgo_up(parents + uintptr(i6)*4)) = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fsubmatch_id + **(**int32)(__ccgo_up(parents + uintptr(i6+int32(1))*4)) = -int32(1) } goto _10 /* end case: ADDTAGS_RECURSE */ _4: @@ -131432,7 +131432,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u will be restored at ADDTAGS_AFTER_UNION_RIGHT below. */ _21: ; - if !(*(*int32)(unsafe.Pointer(regset)) >= 0) { + if !(**(**int32)(__ccgo_up(regset)) >= 0) { goto _20 } regset += 4 @@ -131469,11 +131469,11 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u if (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fnum_submatches > 0 { if !(first_pass != 0) { status = _tre_add_tag_right(tls, mem, left2, tag_left) - *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag_left)*4)) = int32(_TRE_TAG_MAXIMIZE) + **(**Ttre_tag_direction_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag_left)*4)) = int32(_TRE_TAG_MAXIMIZE) if status == REG_OK { status = _tre_add_tag_right(tls, mem, right2, tag_right) } - *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag_right)*4)) = int32(_TRE_TAG_MAXIMIZE) + **(**Ttre_tag_direction_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag_right)*4)) = int32(_TRE_TAG_MAXIMIZE) } num_tags = num_tags + int32(2) } @@ -131491,7 +131491,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u if !(first_pass != 0) && minimal_tag >= 0 { i7 = 0 for { - if !(*(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7)*4)) >= 0) { break } goto _23 @@ -131499,9 +131499,9 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i7 = i7 + 1 } - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7)*4)) = tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7+int32(1))*4)) = minimal_tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7+int32(2))*4)) = -int32(1) + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7)*4)) = tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7+int32(1))*4)) = minimal_tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) num_minimals = num_minimals + 1 } @@ -131558,7 +131558,7 @@ func _tre_copy_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, flags i /* XXX - e.g. [ab] has only one position but two nodes, so we are creating holes in the state space here. Not fatal, just wastes memory. */ - pos = pos + *(*int32)(unsafe.Pointer(pos_add)) + pos = pos + **(**int32)(__ccgo_up(pos_add)) num_copied = num_copied + 1 } else { if (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min == int64(-int32(3)) && flags&int32(COPY_REMOVE_TAGS) != 0 { @@ -131570,30 +131570,30 @@ func _tre_copy_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, flags i } else { if (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min == int64(-int32(3)) && flags&int32(COPY_MAXIMIZE_FIRST_TAG) != 0 && first_tag != 0 { /* Maximize the first tag. */ - *(*Ttre_tag_direction_t)(unsafe.Pointer(tag_directions + uintptr(max)*4)) = int32(_TRE_TAG_MAXIMIZE) + **(**Ttre_tag_direction_t)(__ccgo_up(tag_directions + uintptr(max)*4)) = int32(_TRE_TAG_MAXIMIZE) first_tag = 0 } } } - *(*uintptr)(unsafe.Pointer(result)) = _tre_ast_new_literal(tls, mem, min, max, pos) - if *(*uintptr)(unsafe.Pointer(result)) == UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(result)) = _tre_ast_new_literal(tls, mem, min, max, pos) + if **(**uintptr)(__ccgo_up(result)) == UintptrFromInt32(0) { status = int32(REG_ESPACE) } else { - p = (*Ttre_ast_node_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(result)))).Fobj + p = (*Ttre_ast_node_t)(unsafe.Pointer(**(**uintptr)(__ccgo_up(result)))).Fobj (*Ttre_literal_t)(unsafe.Pointer(p)).Fclass = (*Ttre_literal_t)(unsafe.Pointer(lit)).Fclass (*Ttre_literal_t)(unsafe.Pointer(p)).Fneg_classes = (*Ttre_literal_t)(unsafe.Pointer(lit)).Fneg_classes } - if pos > *(*int32)(unsafe.Pointer(max_pos)) { - *(*int32)(unsafe.Pointer(max_pos)) = pos + if pos > **(**int32)(__ccgo_up(max_pos)) { + **(**int32)(__ccgo_up(max_pos)) = pos } case int32(_UNION): uni = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj - *(*uintptr)(unsafe.Pointer(result)) = _tre_ast_new_union(tls, mem, (*Ttre_union_t)(unsafe.Pointer(uni)).Fleft, (*Ttre_union_t)(unsafe.Pointer(uni)).Fright) - if *(*uintptr)(unsafe.Pointer(result)) == UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(result)) = _tre_ast_new_union(tls, mem, (*Ttre_union_t)(unsafe.Pointer(uni)).Fleft, (*Ttre_union_t)(unsafe.Pointer(uni)).Fright) + if **(**uintptr)(__ccgo_up(result)) == UintptrFromInt32(0) { status = int32(REG_ESPACE) break } - tmp = (*Ttre_ast_node_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(result)))).Fobj + tmp = (*Ttre_ast_node_t)(unsafe.Pointer(**(**uintptr)(__ccgo_up(result)))).Fobj result = tmp status = _tre_stack_push_voidptr(tls, stack, (*Ttre_union_t)(unsafe.Pointer(uni)).Fright) if status != REG_OK { @@ -131621,12 +131621,12 @@ func _tre_copy_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, flags i } case int32(_CATENATION): cat = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj - *(*uintptr)(unsafe.Pointer(result)) = _tre_ast_new_catenation(tls, mem, (*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft, (*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright) - if *(*uintptr)(unsafe.Pointer(result)) == UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(result)) = _tre_ast_new_catenation(tls, mem, (*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft, (*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright) + if **(**uintptr)(__ccgo_up(result)) == UintptrFromInt32(0) { status = int32(REG_ESPACE) break } - tmp1 = (*Ttre_ast_node_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(result)))).Fobj + tmp1 = (*Ttre_ast_node_t)(unsafe.Pointer(**(**uintptr)(__ccgo_up(result)))).Fobj (*Ttre_catenation_t)(unsafe.Pointer(tmp1)).Fleft = UintptrFromInt32(0) (*Ttre_catenation_t)(unsafe.Pointer(tmp1)).Fright = UintptrFromInt32(0) result = tmp1 @@ -131664,12 +131664,12 @@ func _tre_copy_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, flags i if status != REG_OK { break } - *(*uintptr)(unsafe.Pointer(result)) = _tre_ast_new_iter(tls, mem, (*Ttre_iteration_t)(unsafe.Pointer(iter)).Farg, (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmin, (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmax, int32(uint32(*(*uint8)(unsafe.Pointer(iter + 16))&0x1>>0))) - if *(*uintptr)(unsafe.Pointer(result)) == UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(result)) = _tre_ast_new_iter(tls, mem, (*Ttre_iteration_t)(unsafe.Pointer(iter)).Farg, (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmin, (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmax, int32(uint32(*(*uint8)(unsafe.Pointer(iter + 16))&0x1>>0))) + if **(**uintptr)(__ccgo_up(result)) == UintptrFromInt32(0) { status = int32(REG_ESPACE) break } - iter = (*Ttre_ast_node_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(result)))).Fobj + iter = (*Ttre_ast_node_t)(unsafe.Pointer(**(**uintptr)(__ccgo_up(result)))).Fobj result = iter default: break @@ -131677,7 +131677,7 @@ func _tre_copy_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, flags i break } } - *(*int32)(unsafe.Pointer(pos_add)) += num_copied + **(**int32)(__ccgo_up(pos_add)) += num_copied return status } @@ -131705,9 +131705,9 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _status, _status1, bottom, cat, flags, iter, iter1, iter_depth, j, lit, node, pos_add_last, pos_add_save, pos_add_total, seq1, status, symbol, tmp, uni, v2 status = REG_OK bottom = _tre_stack_num_objects(tls, stack) - *(*int32)(unsafe.Pointer(bp)) = 0 + **(**int32)(__ccgo_up(bp)) = 0 pos_add_total = 0 - *(*int32)(unsafe.Pointer(bp + 4)) = 0 + **(**int32)(__ccgo_up(bp + 4)) = 0 iter_depth = 0 _status = _tre_stack_push_voidptr(tls, stack, ast) if _status != REG_OK { @@ -131729,9 +131729,9 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit case int32(_LITERAL): lit = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj if !((*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min < Int64FromInt32(0)) || (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min == int64(-int32(4)) { - *(*int32)(unsafe.Pointer(lit + 16)) += *(*int32)(unsafe.Pointer(bp)) - if (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition > *(*int32)(unsafe.Pointer(bp + 4)) { - *(*int32)(unsafe.Pointer(bp + 4)) = (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition + **(**int32)(__ccgo_up(lit + 16)) += **(**int32)(__ccgo_up(bp)) + if (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition > **(**int32)(__ccgo_up(bp + 4)) { + **(**int32)(__ccgo_up(bp + 4)) = (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition } } case int32(_UNION): @@ -131772,7 +131772,7 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit } case int32(_ITERATION): iter = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj - status = _tre_stack_push_int(tls, stack, *(*int32)(unsafe.Pointer(bp))) + status = _tre_stack_push_int(tls, stack, **(**int32)(__ccgo_up(bp))) if status != REG_OK { break } @@ -131796,7 +131796,7 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit then don't increase the `pos' fields of the nodes now, it will get done when expanding. */ if (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmin > int32(1) || (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmax > int32(1) { - *(*int32)(unsafe.Pointer(bp)) = 0 + **(**int32)(__ccgo_up(bp)) = 0 } iter_depth = iter_depth + 1 default: @@ -131804,12 +131804,12 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit } case int32(_EXPAND_AFTER_ITER): iter1 = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj - *(*int32)(unsafe.Pointer(bp)) = _tre_stack_pop_int(tls, stack) - pos_add_last = *(*int32)(unsafe.Pointer(bp)) + **(**int32)(__ccgo_up(bp)) = _tre_stack_pop_int(tls, stack) + pos_add_last = **(**int32)(__ccgo_up(bp)) if (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Fmin > int32(1) || (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Fmax > int32(1) { seq1 = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(bp + 8)) = UintptrFromInt32(0) - pos_add_save = *(*int32)(unsafe.Pointer(bp)) + **(**uintptr)(__ccgo_up(bp + 8)) = UintptrFromInt32(0) + pos_add_save = **(**int32)(__ccgo_up(bp)) /* Create a catenated sequence of copies of the node. */ j = 0 for { @@ -131823,15 +131823,15 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit } /* Remove tags from all but the last copy. */ flags = v2 - pos_add_save = *(*int32)(unsafe.Pointer(bp)) + pos_add_save = **(**int32)(__ccgo_up(bp)) status = _tre_copy_ast(tls, mem, stack, (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Farg, flags, bp, tag_directions, bp+16, bp+4) if status != REG_OK { return status } if seq1 != UintptrFromInt32(0) { - seq1 = _tre_ast_new_catenation(tls, mem, seq1, *(*uintptr)(unsafe.Pointer(bp + 16))) + seq1 = _tre_ast_new_catenation(tls, mem, seq1, **(**uintptr)(__ccgo_up(bp + 16))) } else { - seq1 = *(*uintptr)(unsafe.Pointer(bp + 16)) + seq1 = **(**uintptr)(__ccgo_up(bp + 16)) } if seq1 == UintptrFromInt32(0) { return int32(REG_ESPACE) @@ -131843,13 +131843,13 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit } if (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Fmax == -int32(1) { /* No upper limit. */ - pos_add_save = *(*int32)(unsafe.Pointer(bp)) + pos_add_save = **(**int32)(__ccgo_up(bp)) status = _tre_copy_ast(tls, mem, stack, (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Farg, 0, bp, UintptrFromInt32(0), bp+8, bp+4) if status != REG_OK { return status } - *(*uintptr)(unsafe.Pointer(bp + 8)) = _tre_ast_new_iter(tls, mem, *(*uintptr)(unsafe.Pointer(bp + 8)), 0, -int32(1), 0) - if *(*uintptr)(unsafe.Pointer(bp + 8)) == UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(bp + 8)) = _tre_ast_new_iter(tls, mem, **(**uintptr)(__ccgo_up(bp + 8)), 0, -int32(1), 0) + if **(**uintptr)(__ccgo_up(bp + 8)) == UintptrFromInt32(0) { return int32(REG_ESPACE) } } else { @@ -131858,25 +131858,25 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit if !(j < (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Fmax) { break } - pos_add_save = *(*int32)(unsafe.Pointer(bp)) + pos_add_save = **(**int32)(__ccgo_up(bp)) status = _tre_copy_ast(tls, mem, stack, (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Farg, 0, bp, UintptrFromInt32(0), bp+24, bp+4) if status != REG_OK { return status } - if *(*uintptr)(unsafe.Pointer(bp + 8)) != UintptrFromInt32(0) { - *(*uintptr)(unsafe.Pointer(bp + 8)) = _tre_ast_new_catenation(tls, mem, *(*uintptr)(unsafe.Pointer(bp + 24)), *(*uintptr)(unsafe.Pointer(bp + 8))) + if **(**uintptr)(__ccgo_up(bp + 8)) != UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(bp + 8)) = _tre_ast_new_catenation(tls, mem, **(**uintptr)(__ccgo_up(bp + 24)), **(**uintptr)(__ccgo_up(bp + 8))) } else { - *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 24)) + **(**uintptr)(__ccgo_up(bp + 8)) = **(**uintptr)(__ccgo_up(bp + 24)) } - if *(*uintptr)(unsafe.Pointer(bp + 8)) == UintptrFromInt32(0) { + if **(**uintptr)(__ccgo_up(bp + 8)) == UintptrFromInt32(0) { return int32(REG_ESPACE) } tmp = _tre_ast_new_literal(tls, mem, -int32(1), -int32(1), -int32(1)) if tmp == UintptrFromInt32(0) { return int32(REG_ESPACE) } - *(*uintptr)(unsafe.Pointer(bp + 8)) = _tre_ast_new_union(tls, mem, tmp, *(*uintptr)(unsafe.Pointer(bp + 8))) - if *(*uintptr)(unsafe.Pointer(bp + 8)) == UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(bp + 8)) = _tre_ast_new_union(tls, mem, tmp, **(**uintptr)(__ccgo_up(bp + 8))) + if **(**uintptr)(__ccgo_up(bp + 8)) == UintptrFromInt32(0) { return int32(REG_ESPACE) } goto _3 @@ -131885,12 +131885,12 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit j = j + 1 } } - *(*int32)(unsafe.Pointer(bp)) = pos_add_save + **(**int32)(__ccgo_up(bp)) = pos_add_save if seq1 == UintptrFromInt32(0) { - seq1 = *(*uintptr)(unsafe.Pointer(bp + 8)) + seq1 = **(**uintptr)(__ccgo_up(bp + 8)) } else { - if *(*uintptr)(unsafe.Pointer(bp + 8)) != UintptrFromInt32(0) { - seq1 = _tre_ast_new_catenation(tls, mem, seq1, *(*uintptr)(unsafe.Pointer(bp + 8))) + if **(**uintptr)(__ccgo_up(bp + 8)) != UintptrFromInt32(0) { + seq1 = _tre_ast_new_catenation(tls, mem, seq1, **(**uintptr)(__ccgo_up(bp + 8))) } } if seq1 == UintptrFromInt32(0) { @@ -131900,21 +131900,21 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit (*Ttre_ast_node_t)(unsafe.Pointer(node)).Ftype1 = (*Ttre_ast_node_t)(unsafe.Pointer(seq1)).Ftype1 } iter_depth = iter_depth - 1 - pos_add_total = pos_add_total + (*(*int32)(unsafe.Pointer(bp)) - pos_add_last) + pos_add_total = pos_add_total + (**(**int32)(__ccgo_up(bp)) - pos_add_last) if iter_depth == 0 { - *(*int32)(unsafe.Pointer(bp)) = pos_add_total + **(**int32)(__ccgo_up(bp)) = pos_add_total } default: break } } - *(*int32)(unsafe.Pointer(position)) += pos_add_total + **(**int32)(__ccgo_up(position)) += pos_add_total /* `max_pos' should never be larger than `*position' if the above code works, but just an extra safeguard let's make sure `*position' is set large enough so enough memory will be allocated for the transition table. */ - if *(*int32)(unsafe.Pointer(bp + 4)) > *(*int32)(unsafe.Pointer(position)) { - *(*int32)(unsafe.Pointer(position)) = *(*int32)(unsafe.Pointer(bp + 4)) + if **(**int32)(__ccgo_up(bp + 4)) > **(**int32)(__ccgo_up(position)) { + **(**int32)(__ccgo_up(position)) = **(**int32)(__ccgo_up(bp + 4)) } return status } @@ -131926,9 +131926,9 @@ func _tre_set_empty(tls *TLS, mem Ttre_mem_t) (r uintptr) { if new_set == UintptrFromInt32(0) { return UintptrFromInt32(0) } - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fposition = -int32(1) - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fcode_min = -int32(1) - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fcode_max = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fposition = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fcode_min = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fcode_max = -int32(1) return new_set } @@ -131939,15 +131939,15 @@ func _tre_set_one(tls *TLS, mem Ttre_mem_t, position int32, code_min int32, code if new_set == UintptrFromInt32(0) { return UintptrFromInt32(0) } - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fposition = position - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fcode_min = code_min - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fcode_max = code_max - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fclass = class - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fneg_classes = neg_classes - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fbackref = backref - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + 1*56))).Fposition = -int32(1) - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + 1*56))).Fcode_min = -int32(1) - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + 1*56))).Fcode_max = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fposition = position + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fcode_min = code_min + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fcode_max = code_max + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fclass = class + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fneg_classes = neg_classes + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fbackref = backref + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + 1*56))).Fposition = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + 1*56))).Fcode_min = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + 1*56))).Fcode_max = -int32(1) return new_set } @@ -131957,7 +131957,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u _, _, _, _, _, _, _ = i, j, new_set, new_tags, num_tags, s1, s2 num_tags = 0 for { - if !(tags != UintptrFromInt32(0) && *(*int32)(unsafe.Pointer(tags + uintptr(num_tags)*4)) >= 0) { + if !(tags != UintptrFromInt32(0) && **(**int32)(__ccgo_up(tags + uintptr(num_tags)*4)) >= 0) { break } goto _1 @@ -131967,7 +131967,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u } s1 = 0 for { - if !((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fposition >= 0) { + if !((**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fposition >= 0) { break } goto _2 @@ -131977,7 +131977,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u } s2 = 0 for { - if !((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fposition >= 0) { + if !((**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fposition >= 0) { break } goto _3 @@ -131991,22 +131991,22 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u } s1 = 0 for { - if !((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fposition >= 0) { + if !((**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fposition >= 0) { break } - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Fposition = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fposition - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Fcode_min = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fcode_min - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Fcode_max = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fcode_max - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Fassertions = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fassertions | assertions - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Fclass = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fclass - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Fneg_classes = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fneg_classes - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Fbackref = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fbackref - if (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Ftags == UintptrFromInt32(0) && tags == UintptrFromInt32(0) { - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Ftags = UintptrFromInt32(0) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Fposition = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fposition + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Fcode_min = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fcode_min + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Fcode_max = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fcode_max + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Fassertions = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fassertions | assertions + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Fclass = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fclass + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Fneg_classes = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fneg_classes + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Fbackref = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fbackref + if (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Ftags == UintptrFromInt32(0) && tags == UintptrFromInt32(0) { + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Ftags = UintptrFromInt32(0) } else { i = 0 for { - if !((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Ftags != UintptrFromInt32(0) && *(*int32)(unsafe.Pointer((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Ftags + uintptr(i)*4)) >= 0) { + if !((**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Ftags != UintptrFromInt32(0) && **(**int32)(__ccgo_up((**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Ftags + uintptr(i)*4)) >= 0) { break } goto _5 @@ -132023,7 +132023,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u if !(j < i) { break } - *(*int32)(unsafe.Pointer(new_tags + uintptr(j)*4)) = *(*int32)(unsafe.Pointer((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Ftags + uintptr(j)*4)) + **(**int32)(__ccgo_up(new_tags + uintptr(j)*4)) = **(**int32)(__ccgo_up((**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Ftags + uintptr(j)*4)) goto _6 _6: ; @@ -132034,14 +132034,14 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u if !(i < num_tags) { break } - *(*int32)(unsafe.Pointer(new_tags + uintptr(j+i)*4)) = *(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) + **(**int32)(__ccgo_up(new_tags + uintptr(j+i)*4)) = **(**int32)(__ccgo_up(tags + uintptr(i)*4)) goto _7 _7: ; i = i + 1 } - *(*int32)(unsafe.Pointer(new_tags + uintptr(j+i)*4)) = -int32(1) - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Ftags = new_tags + **(**int32)(__ccgo_up(new_tags + uintptr(j+i)*4)) = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Ftags = new_tags } goto _4 _4: @@ -132050,23 +132050,23 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u } s2 = 0 for { - if !((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fposition >= 0) { + if !((**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fposition >= 0) { break } - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fposition = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fposition - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fcode_min = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fcode_min - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fcode_max = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fcode_max + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Fposition = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fposition + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Fcode_min = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fcode_min + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Fcode_max = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fcode_max /* XXX - why not | assertions here as well? */ - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fassertions = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fassertions - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fclass = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fclass - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fneg_classes = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fneg_classes - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fbackref = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fbackref - if (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Ftags == UintptrFromInt32(0) { - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Ftags = UintptrFromInt32(0) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Fassertions = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fassertions + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Fclass = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fclass + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Fneg_classes = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fneg_classes + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Fbackref = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fbackref + if (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Ftags == UintptrFromInt32(0) { + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Ftags = UintptrFromInt32(0) } else { i = 0 for { - if !(*(*int32)(unsafe.Pointer((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Ftags + uintptr(i)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Ftags + uintptr(i)*4)) >= 0) { break } goto _9 @@ -132083,21 +132083,21 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u if !(j < i) { break } - *(*int32)(unsafe.Pointer(new_tags + uintptr(j)*4)) = *(*int32)(unsafe.Pointer((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Ftags + uintptr(j)*4)) + **(**int32)(__ccgo_up(new_tags + uintptr(j)*4)) = **(**int32)(__ccgo_up((**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Ftags + uintptr(j)*4)) goto _10 _10: ; j = j + 1 } - *(*int32)(unsafe.Pointer(new_tags + uintptr(j)*4)) = -int32(1) - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Ftags = new_tags + **(**int32)(__ccgo_up(new_tags + uintptr(j)*4)) = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Ftags = new_tags } goto _8 _8: ; s2 = s2 + 1 } - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fposition = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Fposition = -int32(1) return new_set } @@ -132115,7 +132115,7 @@ func _tre_match_empty(tls *TLS, stack uintptr, node uintptr, tags uintptr, asser bottom = _tre_stack_num_objects(tls, stack) status = REG_OK if num_tags_seen != 0 { - *(*int32)(unsafe.Pointer(num_tags_seen)) = 0 + **(**int32)(__ccgo_up(num_tags_seen)) = 0 } status = _tre_stack_push_voidptr(tls, stack, node) /* Walk through the tree recursively. */ @@ -132131,10 +132131,10 @@ func _tre_match_empty(tls *TLS, stack uintptr, node uintptr, tags uintptr, asser /* Add the tag to `tags'. */ i = 0 for { - if !(*(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(tags + uintptr(i)*4)) >= 0) { break } - if int64(*(*int32)(unsafe.Pointer(tags + uintptr(i)*4))) == (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max { + if int64(**(**int32)(__ccgo_up(tags + uintptr(i)*4))) == (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max { break } goto _1 @@ -132142,13 +132142,13 @@ func _tre_match_empty(tls *TLS, stack uintptr, node uintptr, tags uintptr, asser ; i = i + 1 } - if *(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) < 0 { - *(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) = int32((*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max) - *(*int32)(unsafe.Pointer(tags + uintptr(i+int32(1))*4)) = -int32(1) + if **(**int32)(__ccgo_up(tags + uintptr(i)*4)) < 0 { + **(**int32)(__ccgo_up(tags + uintptr(i)*4)) = int32((*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max) + **(**int32)(__ccgo_up(tags + uintptr(i+int32(1))*4)) = -int32(1) } } if num_tags_seen != 0 { - *(*int32)(unsafe.Pointer(num_tags_seen)) = *(*int32)(unsafe.Pointer(num_tags_seen)) + 1 + **(**int32)(__ccgo_up(num_tags_seen)) = **(**int32)(__ccgo_up(num_tags_seen)) + 1 } } case int64(-int32(2)): @@ -132392,12 +132392,12 @@ func _tre_compute_nfl(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr) (r return status } /* Allocate arrays for the tags and parameters. */ - tags = Xmalloc(tls, uint64(4)*Uint64FromInt32(*(*int32)(unsafe.Pointer(bp))+Int32FromInt32(1))) + tags = Xmalloc(tls, uint64(4)*Uint64FromInt32(**(**int32)(__ccgo_up(bp))+Int32FromInt32(1))) if !(tags != 0) { return int32(REG_ESPACE) } - *(*int32)(unsafe.Pointer(tags)) = -int32(1) - *(*int32)(unsafe.Pointer(bp + 4)) = 0 + **(**int32)(__ccgo_up(tags)) = -int32(1) + **(**int32)(__ccgo_up(bp + 4)) = 0 /* Second pass with tre_mach_empty() to get the list of tags and parameters. */ status = _tre_match_empty(tls, stack, (*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft, tags, bp+4, UintptrFromInt32(0)) @@ -132405,7 +132405,7 @@ func _tre_compute_nfl(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr) (r Xfree(tls, tags) return status } - (*Ttre_ast_node_t)(unsafe.Pointer(node)).Ffirstpos = _tre_set_union(tls, mem, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright)).Ffirstpos, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft)).Ffirstpos, tags, *(*int32)(unsafe.Pointer(bp + 4))) + (*Ttre_ast_node_t)(unsafe.Pointer(node)).Ffirstpos = _tre_set_union(tls, mem, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright)).Ffirstpos, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft)).Ffirstpos, tags, **(**int32)(__ccgo_up(bp + 4))) Xfree(tls, tags) if !((*Ttre_ast_node_t)(unsafe.Pointer(node)).Ffirstpos != 0) { return int32(REG_ESPACE) @@ -132423,12 +132423,12 @@ func _tre_compute_nfl(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr) (r return status } /* Allocate arrays for the tags and parameters. */ - tags = Xmalloc(tls, uint64(4)*Uint64FromInt32(*(*int32)(unsafe.Pointer(bp))+Int32FromInt32(1))) + tags = Xmalloc(tls, uint64(4)*Uint64FromInt32(**(**int32)(__ccgo_up(bp))+Int32FromInt32(1))) if !(tags != 0) { return int32(REG_ESPACE) } - *(*int32)(unsafe.Pointer(tags)) = -int32(1) - *(*int32)(unsafe.Pointer(bp + 4)) = 0 + **(**int32)(__ccgo_up(tags)) = -int32(1) + **(**int32)(__ccgo_up(bp + 4)) = 0 /* Second pass with tre_mach_empty() to get the list of tags and parameters. */ status = _tre_match_empty(tls, stack, (*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright, tags, bp+4, UintptrFromInt32(0)) @@ -132436,7 +132436,7 @@ func _tre_compute_nfl(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr) (r Xfree(tls, tags) return status } - (*Ttre_ast_node_t)(unsafe.Pointer(node)).Flastpos = _tre_set_union(tls, mem, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft)).Flastpos, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright)).Flastpos, tags, *(*int32)(unsafe.Pointer(bp + 4))) + (*Ttre_ast_node_t)(unsafe.Pointer(node)).Flastpos = _tre_set_union(tls, mem, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft)).Flastpos, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright)).Flastpos, tags, **(**int32)(__ccgo_up(bp + 4))) Xfree(tls, tags) if !((*Ttre_ast_node_t)(unsafe.Pointer(node)).Flastpos != 0) { return int32(REG_ESPACE) @@ -132472,7 +132472,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun prev_p2_pos = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fposition /* Set `trans' to point to the next unused transition from position `p1->position'. */ - trans = transitions + uintptr(*(*int32)(unsafe.Pointer(offs + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)))*56 + trans = transitions + uintptr(**(**int32)(__ccgo_up(offs + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)))*56 for (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fstate != UintptrFromInt32(0) { trans += 56 } @@ -132483,7 +132483,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun the transition from `p1' to `p2'. */ (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fcode_min = Uint32FromInt32((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fcode_min) (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fcode_max = Uint32FromInt32((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fcode_max) - (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fstate = transitions + uintptr(*(*int32)(unsafe.Pointer(offs + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fposition)*4)))*56 + (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fstate = transitions + uintptr(**(**int32)(__ccgo_up(offs + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fposition)*4)))*56 (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fstate_id = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fposition if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fclass != 0 { v1 = int32(ASSERT_CHAR_CLASS) @@ -132498,14 +132498,14 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fassertions = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fassertions | (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fassertions | v1 | v2 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fbackref >= 0 { *(*int32)(unsafe.Pointer(&(*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fu)) = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fbackref - *(*int32)(unsafe.Pointer(trans + 32)) |= int32(ASSERT_BACKREF) + **(**int32)(__ccgo_up(trans + 32)) |= int32(ASSERT_BACKREF) } else { *(*Ttre_ctype_t)(unsafe.Pointer(trans + 40)) = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fclass } if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes != UintptrFromInt32(0) { i = 0 for { - if !(*(*Ttre_ctype_t)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes + uintptr(i)*8)) != Uint64FromInt32(0)) { + if !(**(**Ttre_ctype_t)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes + uintptr(i)*8)) != Uint64FromInt32(0)) { break } goto _3 @@ -132519,29 +132519,29 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun } i = 0 for { - if !(*(*Ttre_ctype_t)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes + uintptr(i)*8)) != Uint64FromInt32(0)) { + if !(**(**Ttre_ctype_t)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes + uintptr(i)*8)) != Uint64FromInt32(0)) { break } - *(*Ttre_ctype_t)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes + uintptr(i)*8)) = *(*Ttre_ctype_t)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes + uintptr(i)*8)) + **(**Ttre_ctype_t)(__ccgo_up((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes + uintptr(i)*8)) = **(**Ttre_ctype_t)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes + uintptr(i)*8)) goto _4 _4: ; i = i + 1 } - *(*Ttre_ctype_t)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes + uintptr(i)*8)) = Uint64FromInt32(0) + **(**Ttre_ctype_t)(__ccgo_up((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes + uintptr(i)*8)) = Uint64FromInt32(0) } else { (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes = UintptrFromInt32(0) } /* Find out how many tags this transition has. */ i = 0 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags != UintptrFromInt32(0) { - for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) >= 0 { + for **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) >= 0 { i = i + 1 } } j = 0 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags != UintptrFromInt32(0) { - for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) >= 0 { + for **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) >= 0 { j = j + 1 } } @@ -132558,15 +132558,15 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun } i = 0 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags != UintptrFromInt32(0) { - for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) >= 0 { - *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(i)*4)) = *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) + for **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) >= 0 { + **(**int32)(__ccgo_up((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(i)*4)) = **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) i = i + 1 } } l = i j = 0 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags != UintptrFromInt32(0) { - for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) >= 0 { + for **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) >= 0 { /* Don't add duplicates. */ dup = 0 k = 0 @@ -132574,7 +132574,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun if !(k < i) { break } - if *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(k)*4)) == *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) { + if **(**int32)(__ccgo_up((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(k)*4)) == **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) { dup = int32(1) break } @@ -132586,12 +132586,12 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun if !(dup != 0) { v1 = l l = l + 1 - *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(v1)*4)) = *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) + **(**int32)(__ccgo_up((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(v1)*4)) = **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) } j = j + 1 } } - *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(l)*4)) = -int32(1) + **(**int32)(__ccgo_up((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(l)*4)) = -int32(1) } p2 += 56 } @@ -132603,7 +132603,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun for (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition >= 0 { p2 = orig_p2 for (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fposition >= 0 { - *(*int32)(unsafe.Pointer(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)) = *(*int32)(unsafe.Pointer(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)) + 1 + **(**int32)(__ccgo_up(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)) = **(**int32)(__ccgo_up(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)) + 1 p2 += 56 } p1 += 56 @@ -132694,11 +132694,11 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { } /* Parse the regexp. */ Xmemset(tls, bp, 0, uint64(56)) - (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fmem = mem - (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fstack = stack - (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fstart = regex - (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fcflags = cflags - (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fmax_backref = -int32(1) + (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fmem = mem + (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fstack = stack + (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fstart = regex + (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fcflags = cflags + (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fmax_backref = -int32(1) errcode = _tre_parse(tls, bp) if errcode != REG_OK { errcode = errcode @@ -132706,10 +132706,10 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { goto error_exit } } - (*Tregex_t)(unsafe.Pointer(preg)).Fre_nsub = Uint64FromInt32((*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fsubmatch_id - int32(1)) - tree = (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fn + (*Tregex_t)(unsafe.Pointer(preg)).Fre_nsub = Uint64FromInt32((**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fsubmatch_id - int32(1)) + tree = (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fn /* Referring to nonexistent subexpressions is illegal. */ - if (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fmax_backref > Int32FromUint64((*Tregex_t)(unsafe.Pointer(preg)).Fre_nsub) { + if (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fmax_backref > Int32FromUint64((*Tregex_t)(unsafe.Pointer(preg)).Fre_nsub) { errcode = int32(REG_ESUBREG) if int32(1) != 0 { goto error_exit @@ -132723,9 +132723,9 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { goto error_exit } } - (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fhave_backrefs = BoolInt32((*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fmax_backref >= 0) + (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fhave_backrefs = BoolInt32((**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fmax_backref >= 0) (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fhave_approx = 0 - (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches = Uint32FromInt32((*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fsubmatch_id) + (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches = Uint32FromInt32((**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fsubmatch_id) /* Set up tags for submatch addressing. If REG_NOSUB is set and the regexp does not have back references, this can be skipped. */ if (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fhave_backrefs != 0 || !(cflags&Int32FromInt32(REG_NOSUB) != 0) { @@ -132755,7 +132755,7 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { goto error_exit } } - submatch_data = Xcalloc(tls, uint64(Uint32FromInt32((*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fsubmatch_id)), uint64(16)) + submatch_data = Xcalloc(tls, uint64(Uint32FromInt32((**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fsubmatch_id)), uint64(16)) if submatch_data == UintptrFromInt32(0) { errcode = int32(REG_ESPACE) if int32(1) != 0 { @@ -132808,14 +132808,14 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { goto error_exit } } - counts = Xmalloc(tls, uint64(4)*Uint64FromInt32((*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fposition)) + counts = Xmalloc(tls, uint64(4)*Uint64FromInt32((**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fposition)) if counts == UintptrFromInt32(0) { errcode = int32(REG_ESPACE) if int32(1) != 0 { goto error_exit } } - offs = Xmalloc(tls, uint64(4)*Uint64FromInt32((*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fposition)) + offs = Xmalloc(tls, uint64(4)*Uint64FromInt32((**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fposition)) if offs == UintptrFromInt32(0) { errcode = int32(REG_ESPACE) if int32(1) != 0 { @@ -132824,10 +132824,10 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { } i = 0 for { - if !(i < (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fposition) { + if !(i < (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fposition) { break } - *(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) = 0 + **(**int32)(__ccgo_up(counts + uintptr(i)*4)) = 0 goto _3 _3: ; @@ -132837,12 +132837,12 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { add = 0 i = 0 for { - if !(i < (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fposition) { + if !(i < (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fposition) { break } - *(*int32)(unsafe.Pointer(offs + uintptr(i)*4)) = add - add = add + (*(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) + int32(1)) - *(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) = 0 + **(**int32)(__ccgo_up(offs + uintptr(i)*4)) = add + add = add + (**(**int32)(__ccgo_up(counts + uintptr(i)*4)) + int32(1)) + **(**int32)(__ccgo_up(counts + uintptr(i)*4)) = 0 goto _4 _4: ; @@ -132885,15 +132885,15 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { if !((*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fposition >= 0) { break } - (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Fstate = transitions + uintptr(*(*int32)(unsafe.Pointer(offs + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fposition)*4)))*56 - (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Fstate_id = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fposition - (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Ftags = UintptrFromInt32(0) + (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*56))).Fstate = transitions + uintptr(**(**int32)(__ccgo_up(offs + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fposition)*4)))*56 + (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*56))).Fstate_id = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fposition + (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*56))).Ftags = UintptrFromInt32(0) /* Copy the arrays p->tags, and p->params, they are allocated from a tre_mem object. */ if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Ftags != 0 { j = 0 for { - if !(*(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Ftags + uintptr(j)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Ftags + uintptr(j)*4)) >= 0) { break } goto _6 @@ -132901,26 +132901,26 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { ; j = j + 1 } - (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Ftags = Xmalloc(tls, uint64(4)*Uint64FromInt32(j+Int32FromInt32(1))) - if !((*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Ftags != 0) { + (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*56))).Ftags = Xmalloc(tls, uint64(4)*Uint64FromInt32(j+Int32FromInt32(1))) + if !((**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*56))).Ftags != 0) { errcode = int32(REG_ESPACE) if int32(1) != 0 { goto error_exit } } - Xmemcpy(tls, (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Ftags, (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Ftags, uint64(4)*Uint64FromInt32(j+Int32FromInt32(1))) + Xmemcpy(tls, (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*56))).Ftags, (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Ftags, uint64(4)*Uint64FromInt32(j+Int32FromInt32(1))) } - (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Fassertions = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fassertions + (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*56))).Fassertions = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fassertions i = i + 1 goto _5 _5: ; p += 56 } - (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Fstate = UintptrFromInt32(0) + (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*56))).Fstate = UintptrFromInt32(0) (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_transitions = Uint32FromInt32(add) - (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ffinal = transitions + uintptr(*(*int32)(unsafe.Pointer(offs + uintptr((*(*Ttre_pos_and_tags_t)(unsafe.Pointer((*Ttre_ast_node_t)(unsafe.Pointer(tree)).Flastpos))).Fposition)*4)))*56 - (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_states = (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fposition + (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ffinal = transitions + uintptr(**(**int32)(__ccgo_up(offs + uintptr((**(**Ttre_pos_and_tags_t)(__ccgo_up((*Ttre_ast_node_t)(unsafe.Pointer(tree)).Flastpos))).Fposition)*4)))*56 + (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_states = (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fposition (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags = cflags X__tre_mem_destroy(tls, mem) _tre_stack_destroy(tls, stack) @@ -132963,12 +132963,12 @@ func Xregfree(tls *TLS, preg uintptr) { if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_transitions) { break } - if (*(*Ttre_tnfa_transition_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Fstate != 0 { - if (*(*Ttre_tnfa_transition_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Ftags != 0 { - Xfree(tls, (*(*Ttre_tnfa_transition_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Ftags) + if (**(**Ttre_tnfa_transition_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Fstate != 0 { + if (**(**Ttre_tnfa_transition_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Ftags != 0 { + Xfree(tls, (**(**Ttre_tnfa_transition_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Ftags) } - if (*(*Ttre_tnfa_transition_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Fneg_classes != 0 { - Xfree(tls, (*(*Ttre_tnfa_transition_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Fneg_classes) + if (**(**Ttre_tnfa_transition_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Fneg_classes != 0 { + Xfree(tls, (**(**Ttre_tnfa_transition_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Fneg_classes) } } goto _1 @@ -133001,8 +133001,8 @@ func Xregfree(tls *TLS, preg uintptr) { if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches) { break } - if (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(i)*16))).Fparents != 0 { - Xfree(tls, (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(i)*16))).Fparents) + if (**(**Ttre_submatch_data_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(i)*16))).Fparents != 0 { + Xfree(tls, (**(**Ttre_submatch_data_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(i)*16))).Fparents) } goto _3 _3: @@ -133042,7 +133042,7 @@ func Xregerror(tls *TLS, e int32, preg uintptr, buf uintptr, size Tsize_t) (r Ts _ = s s = uintptr(unsafe.Pointer(&_messages)) for { - if !(e != 0 && *(*uint8)(unsafe.Pointer(s)) != 0) { + if !(e != 0 && **(**uint8)(__ccgo_up(s)) != 0) { break } goto _1 @@ -133051,7 +133051,7 @@ func Xregerror(tls *TLS, e int32, preg uintptr, buf uintptr, size Tsize_t) (r Ts e = e - 1 s = s + uintptr(_strlen(tls, s)+uint64(1)) } - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { s = s + 1 } s = X__lctrans_cur(tls, s) @@ -133077,18 +133077,18 @@ func _tre_tag_order(tls *TLS, num_tags int32, tag_directions uintptr, t1 uintptr if !(i < num_tags) { break } - if *(*Ttre_tag_direction_t)(unsafe.Pointer(tag_directions + uintptr(i)*4)) == int32(_TRE_TAG_MINIMIZE) { - if *(*Tregoff_t)(unsafe.Pointer(t1 + uintptr(i)*8)) < *(*Tregoff_t)(unsafe.Pointer(t2 + uintptr(i)*8)) { + if **(**Ttre_tag_direction_t)(__ccgo_up(tag_directions + uintptr(i)*4)) == int32(_TRE_TAG_MINIMIZE) { + if **(**Tregoff_t)(__ccgo_up(t1 + uintptr(i)*8)) < **(**Tregoff_t)(__ccgo_up(t2 + uintptr(i)*8)) { return int32(1) } - if *(*Tregoff_t)(unsafe.Pointer(t1 + uintptr(i)*8)) > *(*Tregoff_t)(unsafe.Pointer(t2 + uintptr(i)*8)) { + if **(**Tregoff_t)(__ccgo_up(t1 + uintptr(i)*8)) > **(**Tregoff_t)(__ccgo_up(t2 + uintptr(i)*8)) { return 0 } } else { - if *(*Tregoff_t)(unsafe.Pointer(t1 + uintptr(i)*8)) > *(*Tregoff_t)(unsafe.Pointer(t2 + uintptr(i)*8)) { + if **(**Tregoff_t)(__ccgo_up(t1 + uintptr(i)*8)) > **(**Tregoff_t)(__ccgo_up(t2 + uintptr(i)*8)) { return int32(1) } - if *(*Tregoff_t)(unsafe.Pointer(t1 + uintptr(i)*8)) < *(*Tregoff_t)(unsafe.Pointer(t2 + uintptr(i)*8)) { + if **(**Tregoff_t)(__ccgo_up(t1 + uintptr(i)*8)) < **(**Tregoff_t)(__ccgo_up(t2 + uintptr(i)*8)) { return 0 } } @@ -133102,8 +133102,8 @@ func _tre_tag_order(tls *TLS, num_tags int32, tag_directions uintptr, t1 uintptr } func _tre_neg_char_classes_match(tls *TLS, classes uintptr, wc Ttre_cint_t, icase int32) (r int32) { - for *(*Ttre_ctype_t)(unsafe.Pointer(classes)) != Uint64FromInt32(0) { - if !(icase != 0) && Xiswctype(tls, wc, *(*Ttre_ctype_t)(unsafe.Pointer(classes))) != 0 || icase != 0 && (Xiswctype(tls, Xtowupper(tls, wc), *(*Ttre_ctype_t)(unsafe.Pointer(classes))) != 0 || Xiswctype(tls, Xtowlower(tls, wc), *(*Ttre_ctype_t)(unsafe.Pointer(classes))) != 0) { + for **(**Ttre_ctype_t)(__ccgo_up(classes)) != Uint64FromInt32(0) { + if !(icase != 0) && Xiswctype(tls, wc, **(**Ttre_ctype_t)(__ccgo_up(classes))) != 0 || icase != 0 && (Xiswctype(tls, Xtowupper(tls, wc), **(**Ttre_ctype_t)(__ccgo_up(classes))) != 0 || Xiswctype(tls, Xtowlower(tls, wc), **(**Ttre_ctype_t)(__ccgo_up(classes))) != 0) { return int32(1) } else { classes += 8 @@ -133156,7 +133156,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = buf, end, i, match_eo, new_match, num_tags, pbytes, pos, pos_add_next, prev_c, rbytes, reach, reach_i, reach_next, reach_next_i, reach_pos, reg_newline, reg_notbol, reg_noteol, ret, skip, start, str_byte, tag_i, tbytes, tmp_buf, tmp_iptr, tmp_tags, total_bytes, trans_i, xbytes, v1, v18, v7 /* State variables required by GET_NEXT_WCHAR. */ prev_c = 0 - *(*Ttre_char_t)(unsafe.Pointer(bp)) = 0 + **(**Ttre_char_t)(__ccgo_up(bp)) = 0 str_byte = string1 pos = int64(-int32(1)) pos_add_next = int64(1) @@ -133236,9 +133236,9 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_states) { break } - (*(*Ttre_tnfa_reach_t)(unsafe.Pointer(reach + uintptr(i)*16))).Ftags = tmp_buf + (**(**Ttre_tnfa_reach_t)(__ccgo_up(reach + uintptr(i)*16))).Ftags = tmp_buf tmp_buf = tmp_buf + uintptr(xbytes) - (*(*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next + uintptr(i)*16))).Ftags = tmp_buf + (**(**Ttre_tnfa_reach_t)(__ccgo_up(reach_next + uintptr(i)*16))).Ftags = tmp_buf tmp_buf = tmp_buf + uintptr(xbytes) goto _5 _5: @@ -133250,13 +133250,13 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_states) { break } - (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr(i)*16))).Fpos = int64(-int32(1)) + (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr(i)*16))).Fpos = int64(-int32(1)) goto _6 _6: ; i = i + 1 } - prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + prev_c = **(**Ttre_char_t)(__ccgo_up(bp)) pos = pos + pos_add_next v7 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) pos_add_next = v7 @@ -133276,8 +133276,8 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if match_eo < 0 { trans_i = (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Finitial for (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate != UintptrFromInt32(0) { - if (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos < pos { - if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\000') || reg_noteol != 0) && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0 || !(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) || (*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && *(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\000') && BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) == BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || *(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('\000') || BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) != BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0))) { + if (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos < pos { + if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (**(**Ttre_char_t)(__ccgo_up(bp)) != int32('\000') || reg_noteol != 0) && (**(**Ttre_char_t)(__ccgo_up(bp)) != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0 || !(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) || (**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && **(**Ttre_char_t)(__ccgo_up(bp)) != int32('\000') && BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) == BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || **(**Ttre_char_t)(__ccgo_up(bp)) == int32('\000') || BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) != BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0))) { trans_i += 56 continue } @@ -133287,7 +133287,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < num_tags) { break } - *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(i)*8)) = int64(-int32(1)) + **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(i)*8)) = int64(-int32(1)) goto _8 _8: ; @@ -133295,9 +133295,9 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags } tag_i = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags if tag_i != 0 { - for *(*int32)(unsafe.Pointer(tag_i)) >= 0 { - if *(*int32)(unsafe.Pointer(tag_i)) < num_tags { - *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(*(*int32)(unsafe.Pointer(tag_i)))*8)) = pos + for **(**int32)(__ccgo_up(tag_i)) >= 0 { + if **(**int32)(__ccgo_up(tag_i)) < num_tags { + **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(**(**int32)(__ccgo_up(tag_i)))*8)) = pos } tag_i += 4 } @@ -133310,15 +133310,15 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < num_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(i)*8)) = *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(i)*8)) + **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(i)*8)) = **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(i)*8)) goto _9 _9: ; i = i + 1 } } - (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos = pos - (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags = reach_next_i + 8 + (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos = pos + (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags = reach_next_i + 8 reach_next_i += 16 } trans_i += 56 @@ -133331,10 +133331,10 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags } } /* Check for end of string. */ - if !(*(*Ttre_char_t)(unsafe.Pointer(bp)) != 0) { + if !(**(**Ttre_char_t)(__ccgo_up(bp)) != 0) { break } - prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + prev_c = **(**Ttre_char_t)(__ccgo_up(bp)) pos = pos + pos_add_next v7 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) pos_add_next = v7 @@ -133364,16 +133364,16 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags skip = 0 i = 0 for { - if !(*(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i)*4)) >= 0) { break } - end = *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i)*4)) - start = *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i+int32(1))*4)) + end = **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i)*4)) + start = **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i+int32(1))*4)) if end >= num_tags { skip = int32(1) break } else { - if *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Ftags + uintptr(start)*8)) == *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(start)*8)) && *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Ftags + uintptr(end)*8)) < *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(end)*8)) { + if **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Ftags + uintptr(start)*8)) == **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(start)*8)) && **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Ftags + uintptr(end)*8)) < **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(end)*8)) { skip = int32(1) break } @@ -133417,7 +133417,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags } /* Does this transition match the input symbol? */ if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fcode_min <= Uint32FromInt32(prev_c) && (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fcode_max >= Uint32FromInt32(prev_c) { - if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\000') || reg_noteol != 0) && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0 || !(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) || (*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && *(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\000') && BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) == BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || *(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('\000') || BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) != BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && !((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&Int32FromInt32(REG_ICASE) != 0) && !(Xiswctype(tls, Uint32FromInt32(prev_c), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE) != 0 && !(Xiswctype(tls, Xtowlower(tls, Uint32FromInt32(prev_c)), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) && !(Xiswctype(tls, Xtowupper(tls, Uint32FromInt32(prev_c)), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS_NEG) != 0 && _tre_neg_char_classes_match(tls, (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fneg_classes, Uint32FromInt32(prev_c), (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE)) != 0)) { + if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (**(**Ttre_char_t)(__ccgo_up(bp)) != int32('\000') || reg_noteol != 0) && (**(**Ttre_char_t)(__ccgo_up(bp)) != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0 || !(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) || (**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && **(**Ttre_char_t)(__ccgo_up(bp)) != int32('\000') && BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) == BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || **(**Ttre_char_t)(__ccgo_up(bp)) == int32('\000') || BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) != BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && !((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&Int32FromInt32(REG_ICASE) != 0) && !(Xiswctype(tls, Uint32FromInt32(prev_c), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE) != 0 && !(Xiswctype(tls, Xtowlower(tls, Uint32FromInt32(prev_c)), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) && !(Xiswctype(tls, Xtowupper(tls, Uint32FromInt32(prev_c)), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS_NEG) != 0 && _tre_neg_char_classes_match(tls, (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fneg_classes, Uint32FromInt32(prev_c), (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE)) != 0)) { goto _14 } /* Compute the tags after this transition. */ @@ -133426,7 +133426,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < num_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(tmp_tags + uintptr(i)*8)) = *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Ftags + uintptr(i)*8)) + **(**Tregoff_t)(__ccgo_up(tmp_tags + uintptr(i)*8)) = **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Ftags + uintptr(i)*8)) goto _15 _15: ; @@ -133434,22 +133434,22 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags } tag_i = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags if tag_i != UintptrFromInt32(0) { - for *(*int32)(unsafe.Pointer(tag_i)) >= 0 { - if *(*int32)(unsafe.Pointer(tag_i)) < num_tags { - *(*Tregoff_t)(unsafe.Pointer(tmp_tags + uintptr(*(*int32)(unsafe.Pointer(tag_i)))*8)) = pos + for **(**int32)(__ccgo_up(tag_i)) >= 0 { + if **(**int32)(__ccgo_up(tag_i)) < num_tags { + **(**Tregoff_t)(__ccgo_up(tmp_tags + uintptr(**(**int32)(__ccgo_up(tag_i)))*8)) = pos } tag_i += 4 } } - if (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos < pos { + if (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos < pos { /* Found an unvisited node. */ (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Fstate = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate tmp_iptr = (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags = tmp_tags tmp_tags = tmp_iptr - (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos = pos - (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags = reach_next_i + 8 - if (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Fstate == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ffinal && (match_eo == int64(-int32(1)) || num_tags > 0 && *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags)) <= *(*Tregoff_t)(unsafe.Pointer(match_tags))) { + (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos = pos + (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags = reach_next_i + 8 + if (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Fstate == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ffinal && (match_eo == int64(-int32(1)) || num_tags > 0 && **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags)) <= **(**Tregoff_t)(__ccgo_up(match_tags))) { match_eo = pos new_match = int32(1) i = 0 @@ -133457,7 +133457,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < num_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(i)*8)) = *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(i)*8)) + **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(i)*8)) = **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(i)*8)) goto _16 _16: ; @@ -133469,10 +133469,10 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags /* Another path has also reached this state. We choose the winner by examining the tag values for both paths. */ - if _tre_tag_order(tls, num_tags, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions, tmp_tags, *(*uintptr)(unsafe.Pointer((*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags))) != 0 { + if _tre_tag_order(tls, num_tags, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions, tmp_tags, **(**uintptr)(__ccgo_up((**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags))) != 0 { /* The new path wins. */ - tmp_iptr = *(*uintptr)(unsafe.Pointer((*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags)) - *(*uintptr)(unsafe.Pointer((*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags)) = tmp_tags + tmp_iptr = **(**uintptr)(__ccgo_up((**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags)) + **(**uintptr)(__ccgo_up((**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags)) = tmp_tags if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ffinal { match_eo = pos new_match = int32(1) @@ -133481,7 +133481,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < num_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(i)*8)) = *(*Tregoff_t)(unsafe.Pointer(tmp_tags + uintptr(i)*8)) + **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(i)*8)) = **(**Tregoff_t)(__ccgo_up(tmp_tags + uintptr(i)*8)) goto _17 _17: ; @@ -133504,7 +133504,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags } (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Fstate = UintptrFromInt32(0) } - *(*Tregoff_t)(unsafe.Pointer(match_end_ofs)) = match_eo + **(**Tregoff_t)(__ccgo_up(match_end_ofs)) = match_eo if match_eo >= 0 { v18 = REG_OK } else { @@ -133575,7 +133575,7 @@ func _tre_tnfa_run_backtrack(tls *TLS, tnfa uintptr, string1 uintptr, match_tags _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bt, bt_len, empty_br_match, eo, i, i1, i2, i3, i4, match_eo, mem, next_c_start, next_state, next_tags, pmatch, pos, pos_add_next, pos_start, prev_c, reg_newline, reg_notbol, reg_noteol, result, ret, s, s1, so, stack, state, states_seen, str_byte, str_byte_start, tags, tmp, tmp1, trans_i, v20, v3, v6 /* State variables required by GET_NEXT_WCHAR. */ prev_c = 0 - *(*Ttre_char_t)(unsafe.Pointer(bp)) = 0 + **(**Ttre_char_t)(__ccgo_up(bp)) = 0 str_byte = string1 pos = 0 pos_add_next = int64(1) @@ -133629,9 +133629,9 @@ retry: if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(i)*8)) = int64(-int32(1)) + **(**Tregoff_t)(__ccgo_up(tags + uintptr(i)*8)) = int64(-int32(1)) if match_tags != 0 { - *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(i)*8)) = int64(-int32(1)) + **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(i)*8)) = int64(-int32(1)) } goto _1 _1: @@ -133643,7 +133643,7 @@ retry: if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_states) { break } - *(*int32)(unsafe.Pointer(states_seen + uintptr(i)*4)) = 0 + **(**int32)(__ccgo_up(states_seen + uintptr(i)*4)) = 0 goto _2 _2: ; @@ -133651,7 +133651,7 @@ retry: } state = UintptrFromInt32(0) pos = pos_start - prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + prev_c = **(**Ttre_char_t)(__ccgo_up(bp)) pos = pos + pos_add_next v3 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) pos_add_next = v3 @@ -133665,7 +133665,7 @@ retry: } str_byte = str_byte + uintptr(pos_add_next) pos_start = pos - next_c_start = *(*Ttre_char_t)(unsafe.Pointer(bp)) + next_c_start = **(**Ttre_char_t)(__ccgo_up(bp)) str_byte_start = str_byte /* Handle initial states. */ next_tags = UintptrFromInt32(0) @@ -133674,7 +133674,7 @@ retry: if !((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate != 0) { break } - if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\000') || reg_noteol != 0) && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0 || !(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) || (*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && *(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\000') && BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) == BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || *(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('\000') || BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) != BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0))) { + if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (**(**Ttre_char_t)(__ccgo_up(bp)) != int32('\000') || reg_noteol != 0) && (**(**Ttre_char_t)(__ccgo_up(bp)) != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0 || !(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) || (**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && **(**Ttre_char_t)(__ccgo_up(bp)) != int32('\000') && BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) == BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || **(**Ttre_char_t)(__ccgo_up(bp)) == int32('\000') || BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) != BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0))) { goto _4 } if state == UintptrFromInt32(0) { @@ -133723,13 +133723,13 @@ retry: (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstr_byte = str_byte (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate_id = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id - (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fnext_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fnext_c = **(**Ttre_char_t)(__ccgo_up(bp)) i1 = 0 for { if !(i1 < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_tags) { break } - *(*Tregoff_t)(unsafe.Pointer((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(i1)*8)) = *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(i1)*8)) + **(**Tregoff_t)(__ccgo_up((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(i1)*8)) = **(**Tregoff_t)(__ccgo_up(tags + uintptr(i1)*8)) goto _5 _5: ; @@ -133737,10 +133737,10 @@ retry: } tmp = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags if tmp != 0 { - for *(*int32)(unsafe.Pointer(tmp)) >= 0 { + for **(**int32)(__ccgo_up(tmp)) >= 0 { v6 = tmp tmp += 4 - *(*Tregoff_t)(unsafe.Pointer((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(*(*int32)(unsafe.Pointer(v6)))*8)) = pos + **(**Tregoff_t)(__ccgo_up((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(**(**int32)(__ccgo_up(v6)))*8)) = pos } } } @@ -133751,10 +133751,10 @@ retry: } if next_tags != 0 { for { - if !(*(*int32)(unsafe.Pointer(next_tags)) >= 0) { + if !(**(**int32)(__ccgo_up(next_tags)) >= 0) { break } - *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(*(*int32)(unsafe.Pointer(next_tags)))*8)) = pos + **(**Tregoff_t)(__ccgo_up(tags + uintptr(**(**int32)(__ccgo_up(next_tags)))*8)) = pos goto _7 _7: ; @@ -133779,7 +133779,7 @@ _9: if !(i2 < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(i2)*8)) = *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(i2)*8)) + **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(i2)*8)) = **(**Tregoff_t)(__ccgo_up(tags + uintptr(i2)*8)) goto _10 _10: ; @@ -133799,8 +133799,8 @@ _9: /* Get the substring we need to match against. Remember to turn off REG_NOSUB temporarily. */ _tre_fill_pmatch(tls, Uint64FromInt32(bt+int32(1)), pmatch, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags & ^Int32FromInt32(REG_NOSUB), tnfa, tags, pos) - so = (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(bt)*16))).Frm_so - eo = (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(bt)*16))).Frm_eo + so = (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(bt)*16))).Frm_so + eo = (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(bt)*16))).Frm_eo bt_len = eo - so result = Xstrncmp(tls, string1+uintptr(so), str_byte-uintptr(1), Uint64FromInt64(bt_len)) if result == 0 { @@ -133808,15 +133808,15 @@ _9: if bt_len == 0 { empty_br_match = int32(1) } - if empty_br_match != 0 && *(*int32)(unsafe.Pointer(states_seen + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*4)) != 0 { + if empty_br_match != 0 && **(**int32)(__ccgo_up(states_seen + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*4)) != 0 { goto backtrack } - *(*int32)(unsafe.Pointer(states_seen + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*4)) = empty_br_match + **(**int32)(__ccgo_up(states_seen + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*4)) = empty_br_match /* Advance in input string and resync `prev_c', `next_c' and pos. */ str_byte = str_byte + uintptr(bt_len-int64(1)) pos = pos + (bt_len - int64(1)) - prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + prev_c = **(**Ttre_char_t)(__ccgo_up(bp)) pos = pos + pos_add_next v3 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) pos_add_next = v3 @@ -133834,11 +133834,11 @@ _9: } } else { /* Check for end of string. */ - if *(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('\000') { + if **(**Ttre_char_t)(__ccgo_up(bp)) == int32('\000') { goto backtrack } /* Read the next character. */ - prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + prev_c = **(**Ttre_char_t)(__ccgo_up(bp)) pos = pos + pos_add_next v3 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) pos_add_next = v3 @@ -133859,7 +133859,7 @@ _9: break } if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fcode_min <= Uint32FromInt32(prev_c) && (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fcode_max >= Uint32FromInt32(prev_c) { - if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\000') || reg_noteol != 0) && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0 || !(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) || (*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && *(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\000') && BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) == BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || *(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('\000') || BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) != BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && !((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&Int32FromInt32(REG_ICASE) != 0) && !(Xiswctype(tls, Uint32FromInt32(prev_c), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE) != 0 && !(Xiswctype(tls, Xtowlower(tls, Uint32FromInt32(prev_c)), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) && !(Xiswctype(tls, Xtowupper(tls, Uint32FromInt32(prev_c)), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS_NEG) != 0 && _tre_neg_char_classes_match(tls, (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fneg_classes, Uint32FromInt32(prev_c), (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE)) != 0)) { + if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (**(**Ttre_char_t)(__ccgo_up(bp)) != int32('\000') || reg_noteol != 0) && (**(**Ttre_char_t)(__ccgo_up(bp)) != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0 || !(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) || (**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && **(**Ttre_char_t)(__ccgo_up(bp)) != int32('\000') && BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) == BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || **(**Ttre_char_t)(__ccgo_up(bp)) == int32('\000') || BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) != BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && !((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&Int32FromInt32(REG_ICASE) != 0) && !(Xiswctype(tls, Uint32FromInt32(prev_c), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE) != 0 && !(Xiswctype(tls, Xtowlower(tls, Uint32FromInt32(prev_c)), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) && !(Xiswctype(tls, Xtowupper(tls, Uint32FromInt32(prev_c)), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS_NEG) != 0 && _tre_neg_char_classes_match(tls, (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fneg_classes, Uint32FromInt32(prev_c), (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE)) != 0)) { goto _13 } if next_state == UintptrFromInt32(0) { @@ -133911,13 +133911,13 @@ _9: (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstr_byte = str_byte (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate_id = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id - (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fnext_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fnext_c = **(**Ttre_char_t)(__ccgo_up(bp)) i3 = 0 for { if !(i3 < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_tags) { break } - *(*Tregoff_t)(unsafe.Pointer((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(i3)*8)) = *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(i3)*8)) + **(**Tregoff_t)(__ccgo_up((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(i3)*8)) = **(**Tregoff_t)(__ccgo_up(tags + uintptr(i3)*8)) goto _14 _14: ; @@ -133925,10 +133925,10 @@ _9: } tmp1 = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags for { - if !(tmp1 != 0 && *(*int32)(unsafe.Pointer(tmp1)) >= 0) { + if !(tmp1 != 0 && **(**int32)(__ccgo_up(tmp1)) >= 0) { break } - *(*Tregoff_t)(unsafe.Pointer((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(*(*int32)(unsafe.Pointer(tmp1)))*8)) = pos + **(**Tregoff_t)(__ccgo_up((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(**(**int32)(__ccgo_up(tmp1)))*8)) = pos goto _15 _15: ; @@ -133948,10 +133948,10 @@ _9: state = next_state /* Update the tag values. */ if next_tags != 0 { - for *(*int32)(unsafe.Pointer(next_tags)) >= 0 { + for **(**int32)(__ccgo_up(next_tags)) >= 0 { v6 = next_tags next_tags += 4 - *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(*(*int32)(unsafe.Pointer(v6)))*8)) = pos + **(**Tregoff_t)(__ccgo_up(tags + uintptr(**(**int32)(__ccgo_up(v6)))*8)) = pos } } goto _17 @@ -133963,18 +133963,18 @@ backtrack: /* A matching transition was not found. Try to backtrack. */ if (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fprev != 0 { if (*Ttre_tnfa_transition_t)(unsafe.Pointer((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate)).Fassertions&int32(ASSERT_BACKREF) != 0 { - *(*int32)(unsafe.Pointer(states_seen + uintptr((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate_id)*4)) = 0 + **(**int32)(__ccgo_up(states_seen + uintptr((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate_id)*4)) = 0 } pos = (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fpos str_byte = (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstr_byte state = (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate - *(*Ttre_char_t)(unsafe.Pointer(bp)) = (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fnext_c + **(**Ttre_char_t)(__ccgo_up(bp)) = (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fnext_c i4 = 0 for { if !(i4 < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(i4)*8)) = *(*Tregoff_t)(unsafe.Pointer((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(i4)*8)) + **(**Tregoff_t)(__ccgo_up(tags + uintptr(i4)*8)) = **(**Tregoff_t)(__ccgo_up((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(i4)*8)) goto _19 _19: ; @@ -133985,10 +133985,10 @@ backtrack: if match_eo < 0 { /* Try starting from a later position in the input string. */ /* Check for end of string. */ - if *(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('\000') { + if **(**Ttre_char_t)(__ccgo_up(bp)) == int32('\000') { goto _8 } - *(*Ttre_char_t)(unsafe.Pointer(bp)) = next_c_start + **(**Ttre_char_t)(__ccgo_up(bp)) = next_c_start str_byte = str_byte_start goto retry } else { @@ -134006,7 +134006,7 @@ _8: v20 = int32(REG_NOMATCH) } ret = v20 - *(*Tregoff_t)(unsafe.Pointer(match_end_ofs)) = match_eo + **(**Tregoff_t)(__ccgo_up(match_end_ofs)) = match_eo goto error_exit error_exit: ; @@ -134041,22 +134041,22 @@ func _tre_fill_pmatch(tls *TLS, nmatch Tsize_t, pmatch uintptr, cflags int32, tn /* Construct submatch offsets from the tags. */ submatch_data = (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data for i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches && uint64(i) < nmatch { - if (*(*Ttre_submatch_data_t)(unsafe.Pointer(submatch_data + uintptr(i)*16))).Fso_tag == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fend_tag { - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = match_eo + if (**(**Ttre_submatch_data_t)(__ccgo_up(submatch_data + uintptr(i)*16))).Fso_tag == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fend_tag { + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_so = match_eo } else { - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = *(*Tregoff_t)(unsafe.Pointer(tags + uintptr((*(*Ttre_submatch_data_t)(unsafe.Pointer(submatch_data + uintptr(i)*16))).Fso_tag)*8)) + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_so = **(**Tregoff_t)(__ccgo_up(tags + uintptr((**(**Ttre_submatch_data_t)(__ccgo_up(submatch_data + uintptr(i)*16))).Fso_tag)*8)) } - if (*(*Ttre_submatch_data_t)(unsafe.Pointer(submatch_data + uintptr(i)*16))).Feo_tag == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fend_tag { - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = match_eo + if (**(**Ttre_submatch_data_t)(__ccgo_up(submatch_data + uintptr(i)*16))).Feo_tag == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fend_tag { + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_eo = match_eo } else { - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = *(*Tregoff_t)(unsafe.Pointer(tags + uintptr((*(*Ttre_submatch_data_t)(unsafe.Pointer(submatch_data + uintptr(i)*16))).Feo_tag)*8)) + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_eo = **(**Tregoff_t)(__ccgo_up(tags + uintptr((**(**Ttre_submatch_data_t)(__ccgo_up(submatch_data + uintptr(i)*16))).Feo_tag)*8)) } /* If either of the endpoints were not used, this submatch was not part of the match. */ - if (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so == int64(-int32(1)) || (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo == int64(-int32(1)) { + if (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_so == int64(-int32(1)) || (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_eo == int64(-int32(1)) { v1 = int64(-Int32FromInt32(1)) - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = v1 - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = v1 + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_eo = v1 + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_so = v1 } i = i + 1 } @@ -134064,19 +134064,19 @@ func _tre_fill_pmatch(tls *TLS, nmatch Tsize_t, pmatch uintptr, cflags int32, tn submatches. */ i = uint32(0) for i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches && uint64(i) < nmatch { - if (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo == int64(-int32(1)) { + if (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_eo == int64(-int32(1)) { } - parents = (*(*Ttre_submatch_data_t)(unsafe.Pointer(submatch_data + uintptr(i)*16))).Fparents + parents = (**(**Ttre_submatch_data_t)(__ccgo_up(submatch_data + uintptr(i)*16))).Fparents if parents != UintptrFromInt32(0) { j = uint32(0) for { - if !(*(*int32)(unsafe.Pointer(parents + uintptr(j)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(parents + uintptr(j)*4)) >= 0) { break } - if (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so < (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(*(*int32)(unsafe.Pointer(parents + uintptr(j)*4)))*16))).Frm_so || (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo > (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(*(*int32)(unsafe.Pointer(parents + uintptr(j)*4)))*16))).Frm_eo { + if (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_so < (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(**(**int32)(__ccgo_up(parents + uintptr(j)*4)))*16))).Frm_so || (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_eo > (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(**(**int32)(__ccgo_up(parents + uintptr(j)*4)))*16))).Frm_eo { v1 = int64(-Int32FromInt32(1)) - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = v1 - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = v1 + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_eo = v1 + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_so = v1 } goto _2 _2: @@ -134088,8 +134088,8 @@ func _tre_fill_pmatch(tls *TLS, nmatch Tsize_t, pmatch uintptr, cflags int32, tn } } for uint64(i) < nmatch { - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = int64(-int32(1)) - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = int64(-int32(1)) + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_so = int64(-int32(1)) + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_eo = int64(-int32(1)) i = i + 1 } } @@ -134130,7 +134130,7 @@ func Xregexec(tls *TLS, preg uintptr, string1 uintptr, nmatch Tsize_t, pmatch ui } if status == REG_OK { /* A match was found, so fill the submatch registers. */ - _tre_fill_pmatch(tls, nmatch, pmatch, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags, tnfa, tags, *(*Tregoff_t)(unsafe.Pointer(bp))) + _tre_fill_pmatch(tls, nmatch, pmatch, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags, tnfa, tags, **(**Tregoff_t)(__ccgo_up(bp))) } if tags != 0 { Xfree(tls, tags) @@ -134248,8 +134248,8 @@ func X__tre_mem_alloc_impl(tls *TLS, mem Ttre_mem_t, provided int32, provided_bl size = size + v1 /* Allocate from current block. */ ptr = (*Ttre_mem_struct)(unsafe.Pointer(mem)).Fptr - *(*uintptr)(unsafe.Pointer(mem + 16)) += uintptr(size) - *(*Tsize_t)(unsafe.Pointer(mem + 24)) -= size + **(**uintptr)(__ccgo_up(mem + 16)) += uintptr(size) + **(**Tsize_t)(__ccgo_up(mem + 24)) -= size /* Set to zero if needed. */ if zero != 0 { Xmemset(tls, ptr, 0, size) @@ -134314,10 +134314,10 @@ func _keyhash(tls *TLS, k uintptr) (r Tsize_t) { _, _, _ = h, p, v1 p = k h = uint64(0) - for *(*uint8)(unsafe.Pointer(p)) != 0 { + for **(**uint8)(__ccgo_up(p)) != 0 { v1 = p p = p + 1 - h = uint64(31)*h + uint64(*(*uint8)(unsafe.Pointer(v1))) + h = uint64(31)*h + uint64(**(**uint8)(__ccgo_up(v1))) } return h } @@ -134370,7 +134370,7 @@ func _resize(tls *TLS, nel Tsize_t, htab uintptr) (r int32) { j = j + 1 i = i + v4 } - *(*TENTRY)(unsafe.Pointer(newe)) = *(*TENTRY)(unsafe.Pointer(e)) + **(**TENTRY)(__ccgo_up(newe)) = **(**TENTRY)(__ccgo_up(e)) } goto _2 _2: @@ -134426,7 +134426,7 @@ func Xhsearch(tls *TLS, item TENTRY, action TACTION) (r uintptr) { defer tls.Free(16) var _ /* e at bp+0 */ uintptr ___hsearch_r(tls, item, action, bp, uintptr(unsafe.Pointer(&_htab))) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func ___hcreate_r(tls *TLS, nel Tsize_t, htab uintptr) (r1 int32) { @@ -134459,14 +134459,14 @@ func ___hsearch_r(tls *TLS, item TENTRY, action TACTION, retval uintptr, htab ui hash = _keyhash(tls, item.Fkey) e = _lookup(tls, item.Fkey, hash, htab) if (*TENTRY)(unsafe.Pointer(e)).Fkey != 0 { - *(*uintptr)(unsafe.Pointer(retval)) = e + **(**uintptr)(__ccgo_up(retval)) = e return int32(1) } if action == int32(_FIND) { - *(*uintptr)(unsafe.Pointer(retval)) = uintptr(0) + **(**uintptr)(__ccgo_up(retval)) = uintptr(0) return 0 } - *(*TENTRY)(unsafe.Pointer(e)) = item + **(**TENTRY)(__ccgo_up(e)) = item v2 = (*Thsearch_data)(unsafe.Pointer(htab)).F__tab + 16 *(*Tsize_t)(unsafe.Pointer(v2)) = *(*Tsize_t)(unsafe.Pointer(v2)) + 1 v1 = *(*Tsize_t)(unsafe.Pointer(v2)) @@ -134474,12 +134474,12 @@ func ___hsearch_r(tls *TLS, item TENTRY, action TACTION, retval uintptr, htab ui if !(_resize(tls, uint64(2)*(*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused, htab) != 0) { (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused = (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused - 1 (*TENTRY)(unsafe.Pointer(e)).Fkey = uintptr(0) - *(*uintptr)(unsafe.Pointer(retval)) = uintptr(0) + **(**uintptr)(__ccgo_up(retval)) = uintptr(0) return 0 } e = _lookup(tls, item.Fkey, hash, htab) } - *(*uintptr)(unsafe.Pointer(retval)) = e + **(**uintptr)(__ccgo_up(retval)) = e return int32(1) } @@ -134539,7 +134539,7 @@ func Xlsearch(tls *TLS, key uintptr, base uintptr, nelp uintptr, width Tsize_t, defer func() {}() v1 = width p = base - n = *(*Tsize_t)(unsafe.Pointer(nelp)) + n = **(**Tsize_t)(__ccgo_up(nelp)) i = uint64(0) for { if !(i < n) { @@ -134553,7 +134553,7 @@ func Xlsearch(tls *TLS, key uintptr, base uintptr, nelp uintptr, width Tsize_t, ; i = i + 1 } - *(*Tsize_t)(unsafe.Pointer(nelp)) = n + uint64(1) + **(**Tsize_t)(__ccgo_up(nelp)) = n + uint64(1) return Xmemcpy(tls, p+uintptr(n)*uintptr(v1), key, width) } @@ -134571,7 +134571,7 @@ func Xlfind(tls *TLS, key uintptr, base uintptr, nelp uintptr, width Tsize_t, __ defer func() {}() v1 = width p = base - n = *(*Tsize_t)(unsafe.Pointer(nelp)) + n = **(**Tsize_t)(__ccgo_up(nelp)) i = uint64(0) for { if !(i < n) { @@ -134610,7 +134610,7 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui if !(rootp != 0) { return uintptr(0) } - n = *(*uintptr)(unsafe.Pointer(rootp)) + n = **(**uintptr)(__ccgo_up(rootp)) i = 0 /* *a[0] is an arbitrary non-null pointer that is returned when the root node is deleted. */ @@ -134631,34 +134631,34 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui v1 = i i = i + 1 a[v1] = n + 8 + BoolUintptr(c > 0)*8 - n = *(*uintptr)(unsafe.Pointer(n + 8 + BoolUintptr(c > 0)*8)) + n = **(**uintptr)(__ccgo_up(n + 8 + BoolUintptr(c > 0)*8)) goto _3 _3: } - parent = *(*uintptr)(unsafe.Pointer(a[i-int32(2)])) - if *(*uintptr)(unsafe.Pointer(n + 8)) != 0 { + parent = **(**uintptr)(__ccgo_up(a[i-int32(2)])) + if **(**uintptr)(__ccgo_up(n + 8)) != 0 { /* free the preceding node instead of the deleted one. */ deleted = n v1 = i i = i + 1 a[v1] = n + 8 - n = *(*uintptr)(unsafe.Pointer(n + 8)) - for *(*uintptr)(unsafe.Pointer(n + 8 + 1*8)) != 0 { + n = **(**uintptr)(__ccgo_up(n + 8)) + for **(**uintptr)(__ccgo_up(n + 8 + 1*8)) != 0 { v1 = i i = i + 1 a[v1] = n + 8 + 1*8 - n = *(*uintptr)(unsafe.Pointer(n + 8 + 1*8)) + n = **(**uintptr)(__ccgo_up(n + 8 + 1*8)) } (*Tnode1)(unsafe.Pointer(deleted)).Fkey = (*Tnode1)(unsafe.Pointer(n)).Fkey - child = *(*uintptr)(unsafe.Pointer(n + 8)) + child = **(**uintptr)(__ccgo_up(n + 8)) } else { - child = *(*uintptr)(unsafe.Pointer(n + 8 + 1*8)) + child = **(**uintptr)(__ccgo_up(n + 8 + 1*8)) } /* freed node has at most one child, move it up and rebalance. */ Xfree(tls, n) i = i - 1 v1 = i - *(*uintptr)(unsafe.Pointer(a[v1])) = child + **(**uintptr)(__ccgo_up(a[v1])) = child for { i = i - 1 v1 = i @@ -134681,8 +134681,8 @@ func Xtdestroy(tls *TLS, root uintptr, __ccgo_fp_freekey uintptr) { if r == uintptr(0) { return } - Xtdestroy(tls, *(*uintptr)(unsafe.Pointer(r + 8)), __ccgo_fp_freekey) - Xtdestroy(tls, *(*uintptr)(unsafe.Pointer(r + 8 + 1*8)), __ccgo_fp_freekey) + Xtdestroy(tls, **(**uintptr)(__ccgo_up(r + 8)), __ccgo_fp_freekey) + Xtdestroy(tls, **(**uintptr)(__ccgo_up(r + 8 + 1*8)), __ccgo_fp_freekey) if __ccgo_fp_freekey != 0 { (*(*func(*TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_freekey})))(tls, (*Tnode1)(unsafe.Pointer(r)).Fkey) } @@ -134702,7 +134702,7 @@ func Xtfind(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r uint if !(rootp != 0) { return uintptr(0) } - n = *(*uintptr)(unsafe.Pointer(rootp)) + n = **(**uintptr)(__ccgo_up(rootp)) for { if !(n != 0) { break @@ -134711,7 +134711,7 @@ func Xtfind(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r uint if !(c != 0) { break } - n = *(*uintptr)(unsafe.Pointer(n + 8 + BoolUintptr(c > 0)*8)) + n = **(**uintptr)(__ccgo_up(n + 8 + BoolUintptr(c > 0)*8)) goto _1 _1: } @@ -134733,11 +134733,11 @@ func _rot(tls *TLS, p uintptr, x uintptr, dir int32) (r int32) { var hx, hz int32 var y, z uintptr _, _, _, _ = hx, hz, y, z - y = *(*uintptr)(unsafe.Pointer(x + 8 + uintptr(dir)*8)) - z = *(*uintptr)(unsafe.Pointer(y + 8 + BoolUintptr(!(dir != 0))*8)) + y = **(**uintptr)(__ccgo_up(x + 8 + uintptr(dir)*8)) + z = **(**uintptr)(__ccgo_up(y + 8 + BoolUintptr(!(dir != 0))*8)) hx = (*Tnode1)(unsafe.Pointer(x)).Fh hz = _height(tls, z) - if hz > _height(tls, *(*uintptr)(unsafe.Pointer(y + 8 + uintptr(dir)*8))) { + if hz > _height(tls, **(**uintptr)(__ccgo_up(y + 8 + uintptr(dir)*8))) { /* * x * / \ dir z @@ -134745,10 +134745,10 @@ func _rot(tls *TLS, p uintptr, x uintptr, dir int32) (r int32) { * z D /| | * / \ A B C D * B C */ - *(*uintptr)(unsafe.Pointer(x + 8 + uintptr(dir)*8)) = *(*uintptr)(unsafe.Pointer(z + 8 + BoolUintptr(!(dir != 0))*8)) - *(*uintptr)(unsafe.Pointer(y + 8 + BoolUintptr(!(dir != 0))*8)) = *(*uintptr)(unsafe.Pointer(z + 8 + uintptr(dir)*8)) - *(*uintptr)(unsafe.Pointer(z + 8 + BoolUintptr(!(dir != 0))*8)) = x - *(*uintptr)(unsafe.Pointer(z + 8 + uintptr(dir)*8)) = y + **(**uintptr)(__ccgo_up(x + 8 + uintptr(dir)*8)) = **(**uintptr)(__ccgo_up(z + 8 + BoolUintptr(!(dir != 0))*8)) + **(**uintptr)(__ccgo_up(y + 8 + BoolUintptr(!(dir != 0))*8)) = **(**uintptr)(__ccgo_up(z + 8 + uintptr(dir)*8)) + **(**uintptr)(__ccgo_up(z + 8 + BoolUintptr(!(dir != 0))*8)) = x + **(**uintptr)(__ccgo_up(z + 8 + uintptr(dir)*8)) = y (*Tnode1)(unsafe.Pointer(x)).Fh = hz (*Tnode1)(unsafe.Pointer(y)).Fh = hz (*Tnode1)(unsafe.Pointer(z)).Fh = hz + int32(1) @@ -134758,13 +134758,13 @@ func _rot(tls *TLS, p uintptr, x uintptr, dir int32) (r int32) { * / \ / * A y --> x D * / \ / * z D A z */ - *(*uintptr)(unsafe.Pointer(x + 8 + uintptr(dir)*8)) = z - *(*uintptr)(unsafe.Pointer(y + 8 + BoolUintptr(!(dir != 0))*8)) = x + **(**uintptr)(__ccgo_up(x + 8 + uintptr(dir)*8)) = z + **(**uintptr)(__ccgo_up(y + 8 + BoolUintptr(!(dir != 0))*8)) = x (*Tnode1)(unsafe.Pointer(x)).Fh = hz + int32(1) (*Tnode1)(unsafe.Pointer(y)).Fh = hz + int32(2) z = y } - *(*uintptr)(unsafe.Pointer(p)) = z + **(**uintptr)(__ccgo_up(p)) = z return (*Tnode1)(unsafe.Pointer(z)).Fh - hx } @@ -134779,9 +134779,9 @@ func X__tsearch_balance(tls *TLS, p uintptr) (r int32) { var h0, h1, old, v1 int32 var n uintptr _, _, _, _, _ = h0, h1, n, old, v1 - n = *(*uintptr)(unsafe.Pointer(p)) - h0 = _height(tls, *(*uintptr)(unsafe.Pointer(n + 8))) - h1 = _height(tls, *(*uintptr)(unsafe.Pointer(n + 8 + 1*8))) + n = **(**uintptr)(__ccgo_up(p)) + h0 = _height(tls, **(**uintptr)(__ccgo_up(n + 8))) + h1 = _height(tls, **(**uintptr)(__ccgo_up(n + 8 + 1*8))) if Uint32FromInt32(h0-h1)+uint32(1) < uint32(3) { old = (*Tnode1)(unsafe.Pointer(n)).Fh if h0 < h1 { @@ -134810,7 +134810,7 @@ func Xtsearch(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r1 u if !(rootp != 0) { return uintptr(0) } - n = *(*uintptr)(unsafe.Pointer(rootp)) + n = **(**uintptr)(__ccgo_up(rootp)) i = 0 v1 = i i = i + 1 @@ -134826,7 +134826,7 @@ func Xtsearch(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r1 u v1 = i i = i + 1 a[v1] = n + 8 + BoolUintptr(c > 0)*8 - n = *(*uintptr)(unsafe.Pointer(n + 8 + BoolUintptr(c > 0)*8)) + n = **(**uintptr)(__ccgo_up(n + 8 + BoolUintptr(c > 0)*8)) goto _2 _2: } @@ -134836,13 +134836,13 @@ func Xtsearch(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r1 u } (*Tnode1)(unsafe.Pointer(r)).Fkey = key v4 = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(r + 8 + 1*8)) = v4 - *(*uintptr)(unsafe.Pointer(r + 8)) = v4 + **(**uintptr)(__ccgo_up(r + 8 + 1*8)) = v4 + **(**uintptr)(__ccgo_up(r + 8)) = v4 (*Tnode1)(unsafe.Pointer(r)).Fh = int32(1) /* insert new node, rebalance ancestors. */ i = i - 1 v1 = i - *(*uintptr)(unsafe.Pointer(a[v1])) = r + **(**uintptr)(__ccgo_up(a[v1])) = r for { if v7 = i != 0; v7 { i = i - 1 @@ -134863,9 +134863,9 @@ func _walk(tls *TLS, r uintptr, __ccgo_fp_action uintptr, d int32) { (*(*func(*TLS, uintptr, TVISIT, int32))(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_action})))(tls, r, int32(_leaf), d) } else { (*(*func(*TLS, uintptr, TVISIT, int32))(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_action})))(tls, r, int32(_preorder), d) - _walk(tls, *(*uintptr)(unsafe.Pointer(r + 8)), __ccgo_fp_action, d+int32(1)) + _walk(tls, **(**uintptr)(__ccgo_up(r + 8)), __ccgo_fp_action, d+int32(1)) (*(*func(*TLS, uintptr, TVISIT, int32))(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_action})))(tls, r, int32(_postorder), d) - _walk(tls, *(*uintptr)(unsafe.Pointer(r + 8 + 1*8)), __ccgo_fp_action, d+int32(1)) + _walk(tls, **(**uintptr)(__ccgo_up(r + 8 + 1*8)), __ccgo_fp_action, d+int32(1)) (*(*func(*TLS, uintptr, TVISIT, int32))(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_action})))(tls, r, int32(_endorder), d) } } @@ -134934,7 +134934,7 @@ func Xpselect(tls *TLS, n int32, rfds uintptr, wfds uintptr, efds uintptr, ts ui var v3 uintptr var _ /* data at bp+16 */ [2]Tsyscall_arg_t _, _, _, _, _ = ns, s, v1, v2, v3 - *(*[2]Tsyscall_arg_t)(unsafe.Pointer(bp + 16)) = [2]Tsyscall_arg_t{ + **(**[2]Tsyscall_arg_t)(__ccgo_up(bp + 16)) = [2]Tsyscall_arg_t{ 0: Int64FromUint64(uint64(mask)), 1: int64(Int32FromInt32(_NSIG) / Int32FromInt32(8)), } @@ -135053,10 +135053,10 @@ func Xgetitimer(tls *TLS, which int32, old uintptr) (r1 int32) { if uint64(8) > uint64(8) { r = int32(X__syscall2(tls, int64(SYS_getitimer), int64(which), int64(bp))) if !(r != 0) { - (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_sec = (*(*[4]int64)(unsafe.Pointer(bp)))[0] - (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_usec = (*(*[4]int64)(unsafe.Pointer(bp)))[int32(1)] - (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_sec = (*(*[4]int64)(unsafe.Pointer(bp)))[int32(2)] - (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_usec = (*(*[4]int64)(unsafe.Pointer(bp)))[int32(3)] + (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_sec = (**(**[4]int64)(__ccgo_up(bp)))[0] + (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_usec = (**(**[4]int64)(__ccgo_up(bp)))[int32(1)] + (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_sec = (**(**[4]int64)(__ccgo_up(bp)))[int32(2)] + (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_usec = (**(**[4]int64)(__ccgo_up(bp)))[int32(3)] } return int32(X__syscall_ret(tls, Uint64FromInt32(r))) } @@ -135077,7 +135077,7 @@ func Xkillpg(tls *TLS, pgid Tpid_t, sig int32) (r int32) { defer func() { trc("-> %v", r) }() } if pgid < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } return Xkill(tls, -pgid, sig) @@ -135113,7 +135113,7 @@ func Xpsignal(tls *TLS, sig int32, msg uintptr) { * not permitted to do so. */ old_locale = (*TFILE)(unsafe.Pointer(f)).Flocale old_mode = (*TFILE)(unsafe.Pointer(f)).Fmode - old_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + old_errno = **(**int32)(__ccgo_up(X__errno_location(tls))) if msg != 0 { v2 = msg } else { @@ -135125,7 +135125,7 @@ func Xpsignal(tls *TLS, sig int32, msg uintptr) { v3 = __ccgo_ts } if Xfprintf(tls, f, __ccgo_ts+1114, VaList(bp+8, v2, v3, s)) >= 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = old_errno + **(**int32)(__ccgo_up(X__errno_location(tls))) = old_errno } (*TFILE)(unsafe.Pointer(f)).Fmode = old_mode (*TFILE)(unsafe.Pointer(f)).Flocale = old_locale @@ -135192,10 +135192,10 @@ func Xsetitimer(tls *TLS, which int32, new1 uintptr, old uintptr) (r1 int32) { } r = int32(X__syscall3(tls, int64(SYS_setitimer), int64(which), int64(bp), int64(bp+32))) if !(r != 0) && old != 0 { - (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_sec = (*(*[4]int64)(unsafe.Pointer(bp + 32)))[0] - (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_usec = (*(*[4]int64)(unsafe.Pointer(bp + 32)))[int32(1)] - (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_sec = (*(*[4]int64)(unsafe.Pointer(bp + 32)))[int32(2)] - (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_usec = (*(*[4]int64)(unsafe.Pointer(bp + 32)))[int32(3)] + (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_sec = (**(**[4]int64)(__ccgo_up(bp + 32)))[0] + (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_usec = (**(**[4]int64)(__ccgo_up(bp + 32)))[int32(1)] + (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_sec = (**(**[4]int64)(__ccgo_up(bp + 32)))[int32(2)] + (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_usec = (**(**[4]int64)(__ccgo_up(bp + 32)))[int32(3)] } return int32(X__syscall_ret(tls, Uint64FromInt32(r))) } @@ -135284,7 +135284,7 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old1 uintptr) (r2 int32) Fv Tuint64_t }{} *(*uint64)(unsafe.Pointer(bp + 8)) = Uint64FromInt64(v2) - if *(*Tuint32_t)(unsafe.Pointer(bp + 8)) != 0 { + if **(**Tuint32_t)(__ccgo_up(bp + 8)) != 0 { v13 = v12 // __asm__ __volatile__ ("sync" : : : "memory"); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 40, __ccgo_ts+1529) @@ -135319,7 +135319,7 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old1 uintptr) (r2 int32) goto _21 _21: } - if *(*Tuint32_t)(unsafe.Pointer(bp + 8 + 1*4)) != 0 { + if **(**Tuint32_t)(__ccgo_up(bp + 8 + 1*4)) != 0 { v22 = v12 + uintptr(1)*4 // __asm__ __volatile__ ("sync" : : : "memory"); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 40, __ccgo_ts+1529) @@ -135378,15 +135378,15 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old1 uintptr) (r2 int32) X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 40, __ccgo_ts+1529) } } - (*(*Tk_sigaction)(unsafe.Pointer(bp + 16))).Fhandler = *(*uintptr)(unsafe.Pointer(sa)) - (*(*Tk_sigaction)(unsafe.Pointer(bp + 16))).Fflags = Uint64FromInt32((*Tsigaction)(unsafe.Pointer(sa)).Fsa_flags) - (*(*Tk_sigaction)(unsafe.Pointer(bp + 16))).Fflags |= uint64(0x04000000) + (**(**Tk_sigaction)(__ccgo_up(bp + 16))).Fhandler = *(*uintptr)(unsafe.Pointer(sa)) + (**(**Tk_sigaction)(__ccgo_up(bp + 16))).Fflags = Uint64FromInt32((*Tsigaction)(unsafe.Pointer(sa)).Fsa_flags) + (**(**Tk_sigaction)(__ccgo_up(bp + 16))).Fflags |= uint64(0x04000000) if Uint32FromInt32((*Tsigaction)(unsafe.Pointer(sa)).Fsa_flags)&uint32(4) != 0 { v1 = __ccgo_fp(X__restore_rt) } else { v1 = __ccgo_fp(X__restore) } - (*(*Tk_sigaction)(unsafe.Pointer(bp + 16))).Frestorer = v1 + (**(**Tk_sigaction)(__ccgo_up(bp + 16))).Frestorer = v1 Xmemcpy(tls, bp+16+24, sa+8, Uint64FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))) } if sa != 0 { @@ -135401,8 +135401,8 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old1 uintptr) (r2 int32) } r1 = int32(X__syscall4(tls, int64(SYS_rt_sigaction), int64(sig), int64(v1), int64(v3), int64(Int32FromInt32(_NSIG)/Int32FromInt32(8)))) if old1 != 0 && !(r1 != 0) { - *(*uintptr)(unsafe.Pointer(old1)) = (*(*Tk_sigaction)(unsafe.Pointer(bp + 48))).Fhandler - (*Tsigaction)(unsafe.Pointer(old1)).Fsa_flags = Int32FromUint64((*(*Tk_sigaction)(unsafe.Pointer(bp + 48))).Fflags) + *(*uintptr)(unsafe.Pointer(old1)) = (**(**Tk_sigaction)(__ccgo_up(bp + 48))).Fhandler + (*Tsigaction)(unsafe.Pointer(old1)).Fsa_flags = Int32FromUint64((**(**Tk_sigaction)(__ccgo_up(bp + 48))).Fflags) Xmemcpy(tls, old1+8, bp+48+24, Uint64FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))) } return int32(X__syscall_ret(tls, Uint64FromInt32(r1))) @@ -135419,7 +135419,7 @@ func X__sigaction(tls *TLS, sig int32, sa uintptr, old uintptr) (r1 int32) { var _ /* set at bp+0 */ [1]uint64 _ = r if Uint32FromInt32(sig)-uint32(32) < uint32(3) || Uint32FromInt32(sig)-uint32(1) >= Uint32FromInt32(Int32FromInt32(_NSIG)-Int32FromInt32(1)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } /* Doing anything with the disposition of SIGABRT requires a lock, @@ -135454,10 +135454,10 @@ func Xsigaddset(tls *TLS, set uintptr, sig int32) (r int32) { _ = s s = Uint32FromInt32(sig - int32(1)) if s >= Uint32FromInt32(Int32FromInt32(_NSIG)-Int32FromInt32(1)) || Uint32FromInt32(sig)-uint32(32) < uint32(3) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } - *(*uint64)(unsafe.Pointer(set + uintptr(uint64(s/uint32(8))/uint64(8))*8)) |= uint64(1) << (uint64(s) & (Uint64FromInt32(8)*Uint64FromInt64(8) - Uint64FromInt32(1))) + **(**uint64)(__ccgo_up(set + uintptr(uint64(s/uint32(8))/uint64(8))*8)) |= uint64(1) << (uint64(s) & (Uint64FromInt32(8)*Uint64FromInt64(8) - Uint64FromInt32(1))) return 0 } @@ -135468,11 +135468,11 @@ func Xsigaltstack(tls *TLS, ss uintptr, old uintptr) (r int32) { } if ss != 0 { if !((*Tstack_t)(unsafe.Pointer(ss)).Fss_flags&Int32FromInt32(SS_DISABLE) != 0) && (*Tstack_t)(unsafe.Pointer(ss)).Fss_size < uint64(MINSIGSTKSZ) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return -int32(1) } if (*Tstack_t)(unsafe.Pointer(ss)).Fss_flags&int32(SS_ONSTACK) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } } @@ -135497,7 +135497,7 @@ func Xsigandset(tls *TLS, dest uintptr, left uintptr, right uintptr) (r1 int32) if !(i < Uint64FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))/Uint64FromInt64(8)) { break } - *(*uint64)(unsafe.Pointer(d + uintptr(i)*8)) = *(*uint64)(unsafe.Pointer(l + uintptr(i)*8)) & *(*uint64)(unsafe.Pointer(r + uintptr(i)*8)) + **(**uint64)(__ccgo_up(d + uintptr(i)*8)) = **(**uint64)(__ccgo_up(l + uintptr(i)*8)) & **(**uint64)(__ccgo_up(r + uintptr(i)*8)) goto _1 _1: ; @@ -135515,10 +135515,10 @@ func Xsigdelset(tls *TLS, set uintptr, sig int32) (r int32) { _ = s s = Uint32FromInt32(sig - int32(1)) if s >= Uint32FromInt32(Int32FromInt32(_NSIG)-Int32FromInt32(1)) || Uint32FromInt32(sig)-uint32(32) < uint32(3) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } - *(*uint64)(unsafe.Pointer(set + uintptr(uint64(s/uint32(8))/uint64(8))*8)) &= ^(Uint64FromUint64(1) << (uint64(s) & (Uint64FromInt32(8)*Uint64FromInt64(8) - Uint64FromInt32(1)))) + **(**uint64)(__ccgo_up(set + uintptr(uint64(s/uint32(8))/uint64(8))*8)) &= ^(Uint64FromUint64(1) << (uint64(s) & (Uint64FromInt32(8)*Uint64FromInt64(8) - Uint64FromInt32(1)))) return 0 } @@ -135527,13 +135527,13 @@ func Xsigemptyset(tls *TLS, set uintptr) (r int32) { trc("tls=%v set=%v, (%v:)", tls, set, origin(2)) defer func() { trc("-> %v", r) }() } - *(*uint64)(unsafe.Pointer(set)) = uint64(0) + **(**uint64)(__ccgo_up(set)) = uint64(0) if Bool(uint64(8) == uint64(4)) || Bool(int32(_NSIG) > int32(65)) { - *(*uint64)(unsafe.Pointer(set + 1*8)) = uint64(0) + **(**uint64)(__ccgo_up(set + 1*8)) = uint64(0) } if Bool(uint64(8) == uint64(4)) && Bool(int32(_NSIG) > int32(65)) { - *(*uint64)(unsafe.Pointer(set + 2*8)) = uint64(0) - *(*uint64)(unsafe.Pointer(set + 3*8)) = uint64(0) + **(**uint64)(__ccgo_up(set + 2*8)) = uint64(0) + **(**uint64)(__ccgo_up(set + 3*8)) = uint64(0) } return 0 } @@ -135552,9 +135552,9 @@ func Xsigfillset(tls *TLS, set uintptr) (r int32) { trc("tls=%v set=%v, (%v:)", tls, set, origin(2)) defer func() { trc("-> %v", r) }() } - *(*uint64)(unsafe.Pointer(set)) = uint64(0xfffffffc7fffffff) + **(**uint64)(__ccgo_up(set)) = uint64(0xfffffffc7fffffff) if int32(_NSIG) > int32(65) { - *(*uint64)(unsafe.Pointer(set + 1*8)) = uint64(0xffffffffffffffff) + **(**uint64)(__ccgo_up(set + 1*8)) = uint64(0xffffffffffffffff) } return 0 } @@ -135571,7 +135571,7 @@ func Xsigisemptyset(tls *TLS, set uintptr) (r int32) { if !(i < Uint64FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))/Uint64FromInt64(8)) { break } - if *(*uint64)(unsafe.Pointer(set + uintptr(i)*8)) != 0 { + if **(**uint64)(__ccgo_up(set + uintptr(i)*8)) != 0 { return 0 } goto _1 @@ -135593,7 +135593,7 @@ func Xsigismember(tls *TLS, set uintptr, sig int32) (r int32) { if s >= Uint32FromInt32(Int32FromInt32(_NSIG)-Int32FromInt32(1)) { return 0 } - return BoolInt32(!!(*(*uint64)(unsafe.Pointer(set + uintptr(uint64(s/uint32(8))/uint64(8))*8))&(Uint64FromUint64(1)<<(uint64(s)&(Uint64FromInt32(8)*Uint64FromInt64(8)-Uint64FromInt32(1)))) != 0)) + return BoolInt32(!!(**(**uint64)(__ccgo_up(set + uintptr(uint64(s/uint32(8))/uint64(8))*8))&(Uint64FromUint64(1)<<(uint64(s)&(Uint64FromInt32(8)*Uint64FromInt64(8)-Uint64FromInt32(1)))) != 0)) } func Xsigorset(tls *TLS, dest uintptr, left uintptr, right uintptr) (r1 int32) { @@ -135612,7 +135612,7 @@ func Xsigorset(tls *TLS, dest uintptr, left uintptr, right uintptr) (r1 int32) { if !(i < Uint64FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))/Uint64FromInt64(8)) { break } - *(*uint64)(unsafe.Pointer(d + uintptr(i)*8)) = *(*uint64)(unsafe.Pointer(l + uintptr(i)*8)) | *(*uint64)(unsafe.Pointer(r + uintptr(i)*8)) + **(**uint64)(__ccgo_up(d + uintptr(i)*8)) = **(**uint64)(__ccgo_up(l + uintptr(i)*8)) | **(**uint64)(__ccgo_up(r + uintptr(i)*8)) goto _1 _1: ; @@ -135640,7 +135640,7 @@ func Xsigprocmask(tls *TLS, how int32, set uintptr, old uintptr) (r1 int32) { if !(r != 0) { return r } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = r + **(**int32)(__ccgo_up(X__errno_location(tls))) = r return -int32(1) } @@ -135656,8 +135656,8 @@ func Xsigqueue(tls *TLS, pid Tpid_t, sig int32, value Tsigval) (r1 int32) { var _ /* si at bp+0 */ Tsiginfo_t _ = r Xmemset(tls, bp, 0, uint64(128)) - (*(*Tsiginfo_t)(unsafe.Pointer(bp))).Fsi_signo = sig - (*(*Tsiginfo_t)(unsafe.Pointer(bp))).Fsi_code = -int32(1) + (**(**Tsiginfo_t)(__ccgo_up(bp))).Fsi_signo = sig + (**(**Tsiginfo_t)(__ccgo_up(bp))).Fsi_code = -int32(1) *(*Tsigval)(unsafe.Pointer(bp + 16 + 8)) = value *(*Tuid_t)(unsafe.Pointer(bp + 16 + 4)) = Xgetuid(tls) X__block_app_sigs(tls, bp+128) @@ -135755,7 +135755,7 @@ func Xsigwait(tls *TLS, mask uintptr, sig uintptr) (r int32) { if Xsigtimedwait(tls, mask, bp, uintptr(0)) < 0 { return -int32(1) } - *(*int32)(unsafe.Pointer(sig)) = (*(*Tsiginfo_t)(unsafe.Pointer(bp))).Fsi_signo + **(**int32)(__ccgo_up(sig)) = (**(**Tsiginfo_t)(__ccgo_up(bp))).Fsi_signo return 0 } @@ -135804,7 +135804,7 @@ func X__xmknod(tls *TLS, ver int32, path uintptr, mode Tmode_t, dev uintptr) (r trc("tls=%v ver=%v path=%v mode=%v dev=%v, (%v:)", tls, ver, path, mode, dev, origin(2)) defer func() { trc("-> %v", r) }() } - return Xmknod(tls, path, mode, *(*Tdev_t)(unsafe.Pointer(dev))) + return Xmknod(tls, path, mode, **(**Tdev_t)(__ccgo_up(dev))) } func X__xmknodat(tls *TLS, ver int32, fd int32, path uintptr, mode Tmode_t, dev uintptr) (r int32) { @@ -135812,7 +135812,7 @@ func X__xmknodat(tls *TLS, ver int32, fd int32, path uintptr, mode Tmode_t, dev trc("tls=%v ver=%v fd=%v path=%v mode=%v dev=%v, (%v:)", tls, ver, fd, path, mode, dev, origin(2)) defer func() { trc("-> %v", r) }() } - return Xmknodat(tls, fd, path, mode, *(*Tdev_t)(unsafe.Pointer(dev))) + return Xmknodat(tls, fd, path, mode, **(**Tdev_t)(__ccgo_up(dev))) } func Xchmod(tls *TLS, path uintptr, mode Tmode_t) (r int32) { @@ -135865,7 +135865,7 @@ func Xfchmodat(tls *TLS, fd int32, path uintptr, mode Tmode_t, flag int32) (r in if Xfstatat(tls, fd, path, bp, flag) != 0 { return -int32(1) } - if (*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { + if (**(**Tstat)(__ccgo_up(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { return int32(X__syscall_ret(tls, Uint64FromInt32(-Int32FromInt32(EOPNOTSUPP)))) } v1 = int32(X__syscall3(tls, int64(SYS_openat), int64(fd), int64(path), int64(Int32FromInt32(O_RDONLY)|Int32FromInt32(O_PATH)|Int32FromInt32(O_NOFOLLOW)|Int32FromInt32(O_NOCTTY)|Int32FromInt32(O_CLOEXEC)))) @@ -135879,7 +135879,7 @@ func Xfchmodat(tls *TLS, fd int32, path uintptr, mode Tmode_t, flag int32) (r in X__procfdname(tls, bp+144, Uint32FromInt32(fd2)) ret = Xstat(tls, bp+144, bp) if !(ret != 0) { - if (*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { + if (**(**Tstat)(__ccgo_up(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { ret = int32(X__syscall_ret(tls, Uint64FromInt32(-Int32FromInt32(EOPNOTSUPP)))) } else { ret = int32(X__syscall_ret(tls, Uint64FromInt64(X__syscall3(tls, int64(SYS_fchmodat), int64(-Int32FromInt32(100)), int64(bp+144), Int64FromUint32(mode))))) @@ -135959,28 +135959,28 @@ func _fstatat_statx(tls *TLS, fd int32, path uintptr, st uintptr, flag int32) (r if ret != 0 { return ret } - *(*Tstat)(unsafe.Pointer(st)) = Tstat{ - Fst_dev: uint64(uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_dev_major)&Uint64FromUint64(0xfffff000)<= 0 && !(*(*uint8)(unsafe.Pointer(path)) != 0) { + if flag == int32(AT_EMPTY_PATH) && fd >= 0 && !(**(**uint8)(__ccgo_up(path)) != 0) { ret = int32(X__syscall2(tls, int64(SYS_fstat), int64(fd), int64(bp))) if ret == -int32(EBADF) && X__syscall2(tls, int64(SYS_fcntl), int64(fd), int64(Int32FromInt32(F_GETFD))) >= 0 { ret = int32(X__syscall4(tls, int64(SYS_newfstatat), int64(fd), int64(path), int64(bp), int64(flag))) @@ -136023,10 +136023,10 @@ func _fstatat_kstat(tls *TLS, fd int32, path uintptr, st uintptr, flag int32) (r } } } else { - if (fd == -int32(100) || Int32FromUint8(*(*uint8)(unsafe.Pointer(path))) == int32('/')) && flag == int32(AT_SYMLINK_NOFOLLOW) { + if (fd == -int32(100) || Int32FromUint8(**(**uint8)(__ccgo_up(path))) == int32('/')) && flag == int32(AT_SYMLINK_NOFOLLOW) { ret = int32(X__syscall2(tls, int64(SYS_lstat), int64(path), int64(bp))) } else { - if (fd == -int32(100) || Int32FromUint8(*(*uint8)(unsafe.Pointer(path))) == int32('/')) && !(flag != 0) { + if (fd == -int32(100) || Int32FromUint8(**(**uint8)(__ccgo_up(path))) == int32('/')) && !(flag != 0) { ret = int32(X__syscall2(tls, int64(SYS_stat), int64(path), int64(bp))) } else { ret = int32(X__syscall4(tls, int64(SYS_newfstatat), int64(fd), int64(path), int64(bp), int64(flag))) @@ -136036,28 +136036,28 @@ func _fstatat_kstat(tls *TLS, fd int32, path uintptr, st uintptr, flag int32) (r if ret != 0 { return ret } - *(*Tstat)(unsafe.Pointer(st)) = Tstat{ - Fst_dev: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_dev, - Fst_ino: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_ino, - Fst_nlink: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_nlink, - Fst_mode: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_mode, - Fst_uid: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_uid, - Fst_gid: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_gid, - Fst_rdev: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_rdev, - Fst_size: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_size, - Fst_blksize: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_blksize, - Fst_blocks: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_blocks, + **(**Tstat)(__ccgo_up(st)) = Tstat{ + Fst_dev: (**(**Tkstat)(__ccgo_up(bp))).Fst_dev, + Fst_ino: (**(**Tkstat)(__ccgo_up(bp))).Fst_ino, + Fst_nlink: (**(**Tkstat)(__ccgo_up(bp))).Fst_nlink, + Fst_mode: (**(**Tkstat)(__ccgo_up(bp))).Fst_mode, + Fst_uid: (**(**Tkstat)(__ccgo_up(bp))).Fst_uid, + Fst_gid: (**(**Tkstat)(__ccgo_up(bp))).Fst_gid, + Fst_rdev: (**(**Tkstat)(__ccgo_up(bp))).Fst_rdev, + Fst_size: (**(**Tkstat)(__ccgo_up(bp))).Fst_size, + Fst_blksize: (**(**Tkstat)(__ccgo_up(bp))).Fst_blksize, + Fst_blocks: (**(**Tkstat)(__ccgo_up(bp))).Fst_blocks, Fst_atim: Ttimespec{ - Ftv_sec: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_atime_sec, - Ftv_nsec: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_atime_nsec, + Ftv_sec: (**(**Tkstat)(__ccgo_up(bp))).Fst_atime_sec, + Ftv_nsec: (**(**Tkstat)(__ccgo_up(bp))).Fst_atime_nsec, }, Fst_mtim: Ttimespec{ - Ftv_sec: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_mtime_sec, - Ftv_nsec: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_mtime_nsec, + Ftv_sec: (**(**Tkstat)(__ccgo_up(bp))).Fst_mtime_sec, + Ftv_nsec: (**(**Tkstat)(__ccgo_up(bp))).Fst_mtime_nsec, }, Fst_ctim: Ttimespec{ - Ftv_sec: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_ctime_sec, - Ftv_nsec: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_ctime_nsec, + Ftv_sec: (**(**Tkstat)(__ccgo_up(bp))).Fst_ctime_sec, + Ftv_nsec: (**(**Tkstat)(__ccgo_up(bp))).Fst_ctime_nsec, }, } return 0 @@ -136113,11 +136113,11 @@ func X__futimesat(tls *TLS, dirfd int32, pathname uintptr, times uintptr) (r int if !(i < int32(2)) { break } - if Uint64FromInt64((*(*Ttimeval)(unsafe.Pointer(times + uintptr(i)*16))).Ftv_usec) >= uint64(1000000) { + if Uint64FromInt64((**(**Ttimeval)(__ccgo_up(times + uintptr(i)*16))).Ftv_usec) >= uint64(1000000) { return int32(X__syscall_ret(tls, Uint64FromInt32(-Int32FromInt32(EINVAL)))) } - (*(*[2]Ttimespec)(unsafe.Pointer(bp)))[i].Ftv_sec = (*(*Ttimeval)(unsafe.Pointer(times + uintptr(i)*16))).Ftv_sec - (*(*[2]Ttimespec)(unsafe.Pointer(bp)))[i].Ftv_nsec = (*(*Ttimeval)(unsafe.Pointer(times + uintptr(i)*16))).Ftv_usec * int64(1000) + (**(**[2]Ttimespec)(__ccgo_up(bp)))[i].Ftv_sec = (**(**Ttimeval)(__ccgo_up(times + uintptr(i)*16))).Ftv_sec + (**(**[2]Ttimespec)(__ccgo_up(bp)))[i].Ftv_nsec = (**(**Ttimeval)(__ccgo_up(times + uintptr(i)*16))).Ftv_usec * int64(1000) goto _1 _1: ; @@ -136213,7 +136213,7 @@ func Xstat(tls *TLS, path uintptr, buf uintptr) (r int32) { } func ___statfs(tls *TLS, path uintptr, buf uintptr) (r int32) { - *(*Tstatfs)(unsafe.Pointer(buf)) = Tstatfs{} + **(**Tstatfs)(__ccgo_up(buf)) = Tstatfs{} return int32(X__syscall_ret(tls, Uint64FromInt64(X__syscall3(tls, int64(SYS_statfs64), int64(path), Int64FromUint64(Uint64FromInt64(120)), int64(buf))))) } @@ -136222,14 +136222,14 @@ func Xfstatfs(tls *TLS, fd int32, buf uintptr) (r int32) { trc("tls=%v fd=%v buf=%v, (%v:)", tls, fd, buf, origin(2)) defer func() { trc("-> %v", r) }() } - *(*Tstatfs)(unsafe.Pointer(buf)) = Tstatfs{} + **(**Tstatfs)(__ccgo_up(buf)) = Tstatfs{} return int32(X__syscall_ret(tls, Uint64FromInt64(X__syscall3(tls, int64(SYS_fstatfs64), int64(fd), Int64FromUint64(Uint64FromInt64(120)), int64(buf))))) } func _fixup(tls *TLS, out uintptr, in uintptr) { var v1 uint64 _ = v1 - *(*Tstatvfs)(unsafe.Pointer(out)) = Tstatvfs{} + **(**Tstatvfs)(__ccgo_up(out)) = Tstatvfs{} (*Tstatvfs)(unsafe.Pointer(out)).Ff_bsize = (*Tstatfs)(unsafe.Pointer(in)).Ff_bsize if (*Tstatfs)(unsafe.Pointer(in)).Ff_frsize != 0 { v1 = (*Tstatfs)(unsafe.Pointer(in)).Ff_frsize @@ -136243,7 +136243,7 @@ func _fixup(tls *TLS, out uintptr, in uintptr) { (*Tstatvfs)(unsafe.Pointer(out)).Ff_files = (*Tstatfs)(unsafe.Pointer(in)).Ff_files (*Tstatvfs)(unsafe.Pointer(out)).Ff_ffree = (*Tstatfs)(unsafe.Pointer(in)).Ff_ffree (*Tstatvfs)(unsafe.Pointer(out)).Ff_favail = (*Tstatfs)(unsafe.Pointer(in)).Ff_ffree - (*Tstatvfs)(unsafe.Pointer(out)).Ff_fsid = Uint64FromInt32(*(*int32)(unsafe.Pointer(in + 56))) + (*Tstatvfs)(unsafe.Pointer(out)).Ff_fsid = Uint64FromInt32(**(**int32)(__ccgo_up(in + 56))) (*Tstatvfs)(unsafe.Pointer(out)).Ff_flag = (*Tstatfs)(unsafe.Pointer(in)).Ff_flags (*Tstatvfs)(unsafe.Pointer(out)).Ff_namemax = (*Tstatfs)(unsafe.Pointer(in)).Ff_namelen (*Tstatvfs)(unsafe.Pointer(out)).Ff_type = uint32((*Tstatfs)(unsafe.Pointer(in)).Ff_type) @@ -136298,7 +136298,7 @@ func Xutimensat(tls *TLS, fd int32, path uintptr, times uintptr, flags int32) (r var tv uintptr var _ /* tmp at bp+0 */ [4]int64 _, _, _ = i, r, tv - if times != 0 && (*(*Ttimespec)(unsafe.Pointer(times))).Ftv_nsec == int64(UTIME_NOW) && (*(*Ttimespec)(unsafe.Pointer(times + 1*16))).Ftv_nsec == int64(UTIME_NOW) { + if times != 0 && (**(**Ttimespec)(__ccgo_up(times))).Ftv_nsec == int64(UTIME_NOW) && (**(**Ttimespec)(__ccgo_up(times + 1*16))).Ftv_nsec == int64(UTIME_NOW) { times = uintptr(0) } r = int32(X__syscall4(tls, int64(SYS_utimensat), int64(fd), int64(path), int64(times), int64(flags))) @@ -136313,14 +136313,14 @@ func Xutimensat(tls *TLS, fd int32, path uintptr, times uintptr, flags int32) (r if !(i < int32(2)) { break } - if Uint64FromInt64((*(*Ttimespec)(unsafe.Pointer(times + uintptr(i)*16))).Ftv_nsec) >= uint64(1000000000) { - if (*(*Ttimespec)(unsafe.Pointer(times + uintptr(i)*16))).Ftv_nsec == int64(UTIME_NOW) || (*(*Ttimespec)(unsafe.Pointer(times + uintptr(i)*16))).Ftv_nsec == int64(UTIME_OMIT) { + if Uint64FromInt64((**(**Ttimespec)(__ccgo_up(times + uintptr(i)*16))).Ftv_nsec) >= uint64(1000000000) { + if (**(**Ttimespec)(__ccgo_up(times + uintptr(i)*16))).Ftv_nsec == int64(UTIME_NOW) || (**(**Ttimespec)(__ccgo_up(times + uintptr(i)*16))).Ftv_nsec == int64(UTIME_OMIT) { return int32(X__syscall_ret(tls, Uint64FromInt32(-Int32FromInt32(ENOSYS)))) } return int32(X__syscall_ret(tls, Uint64FromInt32(-Int32FromInt32(EINVAL)))) } - (*(*[4]int64)(unsafe.Pointer(bp)))[int32(2)*i+0] = (*(*Ttimespec)(unsafe.Pointer(times + uintptr(i)*16))).Ftv_sec - (*(*[4]int64)(unsafe.Pointer(bp)))[int32(2)*i+int32(1)] = (*(*Ttimespec)(unsafe.Pointer(times + uintptr(i)*16))).Ftv_nsec / int64(1000) + (**(**[4]int64)(__ccgo_up(bp)))[int32(2)*i+0] = (**(**Ttimespec)(__ccgo_up(times + uintptr(i)*16))).Ftv_sec + (**(**[4]int64)(__ccgo_up(bp)))[int32(2)*i+int32(1)] = (**(**Ttimespec)(__ccgo_up(times + uintptr(i)*16))).Ftv_nsec / int64(1000) goto _1 _1: ; @@ -136355,8 +136355,8 @@ func X__fdopen(tls *TLS, fd int32, mode uintptr) (r uintptr) { var _ /* wsz at bp+0 */ Twinsize _, _, _, _ = f, flags, v1, v2 /* Check for valid initial mode character */ - if !(Xstrchr(tls, __ccgo_ts+1546, Int32FromUint8(*(*uint8)(unsafe.Pointer(mode)))) != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if !(Xstrchr(tls, __ccgo_ts+1546, Int32FromUint8(**(**uint8)(__ccgo_up(mode)))) != 0) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } /* Allocate FILE+buffer or fail */ @@ -136369,7 +136369,7 @@ func X__fdopen(tls *TLS, fd int32, mode uintptr) (r uintptr) { Xmemset(tls, f, 0, uint64(232)) /* Impose mode restrictions */ if !(Xstrchr(tls, mode, int32('+')) != 0) { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('r') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) == int32('r') { v2 = int32(F_NOWR) } else { v2 = int32(F_NORD) @@ -136381,12 +136381,12 @@ func X__fdopen(tls *TLS, fd int32, mode uintptr) (r uintptr) { X__syscall3(tls, int64(SYS_fcntl), int64(fd), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) } /* Set append mode on fd if opened for append */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('a') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) == int32('a') { flags = int32(X__syscall2(tls, int64(SYS_fcntl), int64(fd), int64(Int32FromInt32(F_GETFL)))) if !(flags&Int32FromInt32(O_APPEND) != 0) { X__syscall3(tls, int64(SYS_fcntl), int64(fd), int64(Int32FromInt32(F_SETFL)), int64(flags|Int32FromInt32(O_APPEND))) } - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_APP) + **(**uint32)(__ccgo_up(f)) |= uint32(F_APP) } (*TFILE)(unsafe.Pointer(f)).Ffd = fd (*TFILE)(unsafe.Pointer(f)).Fbuf = f + uintptr(232) + uintptr(UNGET) @@ -136426,7 +136426,7 @@ func X__fmodeflags(tls *TLS, mode uintptr) (r int32) { if Xstrchr(tls, mode, int32('+')) != 0 { flags = int32(O_RDWR) } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('r') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) == int32('r') { flags = O_RDONLY } else { flags = int32(O_WRONLY) @@ -136438,13 +136438,13 @@ func X__fmodeflags(tls *TLS, mode uintptr) (r int32) { if Xstrchr(tls, mode, int32('e')) != 0 { flags = flags | int32(O_CLOEXEC) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) != int32('r') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) != int32('r') { flags = flags | int32(O_CREAT) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('w') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) == int32('w') { flags = flags | int32(O_TRUNC) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('a') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) == int32('a') { flags = flags | int32(O_APPEND) } return flags @@ -136482,22 +136482,22 @@ func X__overflow(tls *TLS, f uintptr, _c int32) (r int32) { var v2, v3 uintptr var _ /* c at bp+0 */ uint8 _, _, _ = v1, v2, v3 - *(*uint8)(unsafe.Pointer(bp)) = Uint8FromInt32(_c) + **(**uint8)(__ccgo_up(bp)) = Uint8FromInt32(_c) if !((*TFILE)(unsafe.Pointer(f)).Fwend != 0) && X__towrite(tls, f) != 0 { return -int32(1) } - if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwend && Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) != (*TFILE)(unsafe.Pointer(f)).Flbf { - v1 = *(*uint8)(unsafe.Pointer(bp)) + if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwend && Int32FromUint8(**(**uint8)(__ccgo_up(bp))) != (*TFILE)(unsafe.Pointer(f)).Flbf { + v1 = **(**uint8)(__ccgo_up(bp)) v3 = f + 40 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - *(*uint8)(unsafe.Pointer(v2)) = v1 + **(**uint8)(__ccgo_up(v2)) = v1 return Int32FromUint8(v1) } if (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fwrite})))(tls, f, bp, uint64(1)) != uint64(1) { return -int32(1) } - return Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) + return Int32FromUint8(**(**uint8)(__ccgo_up(bp))) } func _dummy9(tls *TLS, fd int32) (r int32) { @@ -136535,7 +136535,7 @@ func X__stdio_exit(tls *TLS) { } var f uintptr _ = f - f = *(*uintptr)(unsafe.Pointer(X__ofl_lock(tls))) + f = **(**uintptr)(__ccgo_up(X__ofl_lock(tls))) for { if !(f != 0) { break @@ -136571,7 +136571,7 @@ func X__stdio_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { var v3, v4 uintptr var _ /* iov at bp+0 */ [2]Tiovec _, _, _, _, _ = cnt, v1, v2, v3, v4 - *(*[2]Tiovec)(unsafe.Pointer(bp)) = [2]Tiovec{ + **(**[2]Tiovec)(__ccgo_up(bp)) = [2]Tiovec{ 0: { Fiov_base: buf, Fiov_len: len1 - BoolUint64(!!((*TFILE)(unsafe.Pointer(f)).Fbuf_size != 0)), @@ -136581,10 +136581,10 @@ func X__stdio_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { Fiov_len: (*TFILE)(unsafe.Pointer(f)).Fbuf_size, }, } - if (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len != 0 { + if (**(**[2]Tiovec)(__ccgo_up(bp)))[0].Fiov_len != 0 { v1 = X__syscall_ret(tls, Uint64FromInt64(X__syscall3(tls, int64(SYS_readv), int64((*TFILE)(unsafe.Pointer(f)).Ffd), int64(bp), int64(Int32FromInt32(2))))) } else { - v1 = X__syscall_ret(tls, Uint64FromInt64(X__syscall3(tls, int64(SYS_read), int64((*TFILE)(unsafe.Pointer(f)).Ffd), int64((*(*[2]Tiovec)(unsafe.Pointer(bp)))[int32(1)].Fiov_base), Int64FromUint64((*(*[2]Tiovec)(unsafe.Pointer(bp)))[int32(1)].Fiov_len)))) + v1 = X__syscall_ret(tls, Uint64FromInt64(X__syscall3(tls, int64(SYS_read), int64((*TFILE)(unsafe.Pointer(f)).Ffd), int64((**(**[2]Tiovec)(__ccgo_up(bp)))[int32(1)].Fiov_base), Int64FromUint64((**(**[2]Tiovec)(__ccgo_up(bp)))[int32(1)].Fiov_len)))) } cnt = v1 if cnt <= 0 { @@ -136593,20 +136593,20 @@ func X__stdio_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { } else { v2 = int32(F_EOF) } - *(*uint32)(unsafe.Pointer(f)) |= Uint32FromInt32(v2) + **(**uint32)(__ccgo_up(f)) |= Uint32FromInt32(v2) return uint64(0) } - if Uint64FromInt64(cnt) <= (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len { + if Uint64FromInt64(cnt) <= (**(**[2]Tiovec)(__ccgo_up(bp)))[0].Fiov_len { return Uint64FromInt64(cnt) } - cnt = Int64FromUint64(uint64(cnt) - (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len) + cnt = Int64FromUint64(uint64(cnt) - (**(**[2]Tiovec)(__ccgo_up(bp)))[0].Fiov_len) (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(cnt) if (*TFILE)(unsafe.Pointer(f)).Fbuf_size != 0 { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(buf + uintptr(len1-uint64(1)))) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(buf + uintptr(len1-uint64(1)))) = **(**uint8)(__ccgo_up(v3)) } return len1 } @@ -136633,7 +136633,7 @@ func X__stdio_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) var v5 uint64 var _ /* iovs at bp+0 */ [2]Tiovec _, _, _, _, _, _, _ = cnt, iov, iovcnt, rem, v2, v3, v5 - *(*[2]Tiovec)(unsafe.Pointer(bp)) = [2]Tiovec{ + **(**[2]Tiovec)(__ccgo_up(bp)) = [2]Tiovec{ 0: { Fiov_base: (*TFILE)(unsafe.Pointer(f)).Fwbase, Fiov_len: Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Fwpos) - int64((*TFILE)(unsafe.Pointer(f)).Fwbase)), @@ -136644,7 +136644,7 @@ func X__stdio_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) }, } iov = bp - rem = (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len + (*(*Tiovec)(unsafe.Pointer(iov + 1*16))).Fiov_len + rem = (**(**Tiovec)(__ccgo_up(iov))).Fiov_len + (**(**Tiovec)(__ccgo_up(iov + 1*16))).Fiov_len iovcnt = int32(2) for { cnt = X__syscall_ret(tls, Uint64FromInt64(X__syscall3(tls, int64(SYS_writev), int64((*TFILE)(unsafe.Pointer(f)).Ffd), int64(iov), int64(iovcnt)))) @@ -136661,22 +136661,22 @@ func X__stdio_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) v2 = v3 (*TFILE)(unsafe.Pointer(f)).Fwbase = v2 (*TFILE)(unsafe.Pointer(f)).Fwpos = v2 - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) if iovcnt == int32(2) { v5 = uint64(0) } else { - v5 = len1 - (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len + v5 = len1 - (**(**Tiovec)(__ccgo_up(iov))).Fiov_len } return v5 } rem = rem - Uint64FromInt64(cnt) - if Uint64FromInt64(cnt) > (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len { - cnt = Int64FromUint64(uint64(cnt) - (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len) + if Uint64FromInt64(cnt) > (**(**Tiovec)(__ccgo_up(iov))).Fiov_len { + cnt = Int64FromUint64(uint64(cnt) - (**(**Tiovec)(__ccgo_up(iov))).Fiov_len) iov += 16 iovcnt = iovcnt - 1 } - (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_base = (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_base + uintptr(cnt) - (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len -= Uint64FromInt64(cnt) + (**(**Tiovec)(__ccgo_up(iov))).Fiov_base = (**(**Tiovec)(__ccgo_up(iov))).Fiov_base + uintptr(cnt) + (**(**Tiovec)(__ccgo_up(iov))).Fiov_len -= Uint64FromInt64(cnt) goto _1 _1: } @@ -136706,7 +136706,7 @@ func X__toread(tls *TLS, f uintptr) (r int32) { var v1, v2 uintptr var v4 int32 _, _, _ = v1, v2, v4 - *(*int32)(unsafe.Pointer(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) + **(**int32)(__ccgo_up(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwbase { (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fwrite})))(tls, f, uintptr(0), uint64(0)) } @@ -136716,7 +136716,7 @@ func X__toread(tls *TLS, f uintptr) (r int32) { (*TFILE)(unsafe.Pointer(f)).Fwbase = v1 (*TFILE)(unsafe.Pointer(f)).Fwpos = v1 if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_NORD) != 0 { - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) return -int32(1) } v1 = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr((*TFILE)(unsafe.Pointer(f)).Fbuf_size) @@ -136744,9 +136744,9 @@ func X__towrite(tls *TLS, f uintptr) (r int32) { } var v1 uintptr _ = v1 - *(*int32)(unsafe.Pointer(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) + **(**int32)(__ccgo_up(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_NOWR) != 0 { - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) return -int32(1) } /* Clear read buffer (easier than summoning nasal demons) */ @@ -136780,7 +136780,7 @@ func X__uflow(tls *TLS, f uintptr) (r int32) { defer tls.Free(16) var _ /* c at bp+0 */ uint8 if !(X__toread(tls, f) != 0) && (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fread})))(tls, f, bp, uint64(1)) == uint64(1) { - return Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) + return Int32FromUint8(**(**uint8)(__ccgo_up(bp))) } return -int32(1) } @@ -136811,7 +136811,7 @@ func Xclearerr(tls *TLS, f uintptr) { v1 = 0 } __need_unlock = v1 - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^(Int32FromInt32(F_EOF) | Int32FromInt32(F_ERR))) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^(Int32FromInt32(F_EOF) | Int32FromInt32(F_ERR))) if __need_unlock != 0 { ___unlockfile(tls, f) } @@ -136972,7 +136972,7 @@ func X__freadptr(tls *TLS, f uintptr, sizep uintptr) (r uintptr) { if (*TFILE)(unsafe.Pointer(f)).Frpos == (*TFILE)(unsafe.Pointer(f)).Frend { return uintptr(0) } - *(*Tsize_t)(unsafe.Pointer(sizep)) = Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Frend) - int64((*TFILE)(unsafe.Pointer(f)).Frpos)) + **(**Tsize_t)(__ccgo_up(sizep)) = Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Frend) - int64((*TFILE)(unsafe.Pointer(f)).Frpos)) return (*TFILE)(unsafe.Pointer(f)).Frpos } @@ -136980,14 +136980,14 @@ func X__freadptrinc(tls *TLS, f uintptr, inc Tsize_t) { if __ccgo_strace { trc("tls=%v f=%v inc=%v, (%v:)", tls, f, inc, origin(2)) } - *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(inc) + **(**uintptr)(__ccgo_up(f + 8)) += uintptr(inc) } func X__fseterr(tls *TLS, f uintptr) { if __ccgo_strace { trc("tls=%v f=%v, (%v:)", tls, f, origin(2)) } - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) } func _dummy10(tls *TLS, f uintptr) { @@ -137030,8 +137030,8 @@ func Xfclose(tls *TLS, f uintptr) (r1 int32) { if (*TFILE)(unsafe.Pointer(f)).Fnext != 0 { (*TFILE)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Fnext)).Fprev = (*TFILE)(unsafe.Pointer(f)).Fprev } - if *(*uintptr)(unsafe.Pointer(head)) == f { - *(*uintptr)(unsafe.Pointer(head)) = (*TFILE)(unsafe.Pointer(f)).Fnext + if **(**uintptr)(__ccgo_up(head)) == f { + **(**uintptr)(__ccgo_up(head)) = (*TFILE)(unsafe.Pointer(f)).Fnext } X__ofl_unlock(tls) Xfree(tls, (*TFILE)(unsafe.Pointer(f)).Fgetln_buf) @@ -137132,7 +137132,7 @@ func Xfflush(tls *TLS, f uintptr) (r1 int32) { if AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stderr_used))) != 0 { r = r | Xfflush(tls, AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stderr_used)))) } - f = *(*uintptr)(unsafe.Pointer(X__ofl_lock(tls))) + f = **(**uintptr)(__ccgo_up(X__ofl_lock(tls))) for { if !(f != 0) { break @@ -137246,7 +137246,7 @@ _11: v2 = f + 8 v1 = *(*uintptr)(unsafe.Pointer(v2)) *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(v2)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v1))) } else { v3 = X__uflow(tls, f) } @@ -137314,7 +137314,7 @@ func Xfgetc(tls *TLS, f1 uintptr) (r int32) { v6 = v1 + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(v5))) } else { v4 = X__uflow(tls, v1) } @@ -137350,7 +137350,7 @@ func Xfgetln(tls *TLS, f uintptr, plen uintptr) (r uintptr) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__uflow(tls, f) } @@ -137363,14 +137363,14 @@ func Xfgetln(tls *TLS, f uintptr, plen uintptr) (r uintptr) { ret = (*TFILE)(unsafe.Pointer(f)).Frpos z = z + 1 v3 = z - *(*Tsize_t)(unsafe.Pointer(plen)) = Uint64FromInt64(int64(v3) - int64(ret)) + **(**Tsize_t)(__ccgo_up(plen)) = Uint64FromInt64(int64(v3) - int64(ret)) (*TFILE)(unsafe.Pointer(f)).Frpos = z } else { *(*[1]Tsize_t)(unsafe.Pointer(bp)) = [1]Tsize_t{} v8 = Xgetline(tls, f+168, bp, f) l = v8 if v8 > 0 { - *(*Tsize_t)(unsafe.Pointer(plen)) = Uint64FromInt64(l) + **(**Tsize_t)(__ccgo_up(plen)) = Uint64FromInt64(l) ret = (*TFILE)(unsafe.Pointer(f)).Fgetln_buf } } @@ -137391,7 +137391,7 @@ func Xfgetpos(tls *TLS, f uintptr, pos uintptr) (r int32) { if off < 0 { return -int32(1) } - *(*int64)(unsafe.Pointer(pos)) = off + **(**int64)(__ccgo_up(pos)) = off return 0 } @@ -137415,14 +137415,14 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { } __need_unlock = v1 if n <= int32(1) { - *(*int32)(unsafe.Pointer(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) + **(**int32)(__ccgo_up(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) if __need_unlock != 0 { ___unlockfile(tls, f) } if n < int32(1) { return uintptr(0) } - *(*uint8)(unsafe.Pointer(s)) = uint8(0) + **(**uint8)(__ccgo_up(s)) = uint8(0) return s } n = n - 1 @@ -137442,7 +137442,7 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { } k = v3 Xmemcpy(tls, p, (*TFILE)(unsafe.Pointer(f)).Frpos, k) - *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(k) + **(**uintptr)(__ccgo_up(f + 8)) += uintptr(k) p = p + uintptr(k) n = Int32FromUint64(uint64(n) - k) if z != 0 || !(n != 0) { @@ -137453,7 +137453,7 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { v7 = f + 8 v6 = *(*uintptr)(unsafe.Pointer(v7)) *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) + 1 - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(v6))) } else { v4 = X__uflow(tls, f) } @@ -137469,13 +137469,13 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { v8 = Uint8FromInt32(c) v6 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v6)) = v8 + **(**uint8)(__ccgo_up(v6)) = v8 if Int32FromUint8(v8) == int32('\n') { break } } if s != 0 { - *(*uint8)(unsafe.Pointer(p)) = uint8(0) + **(**uint8)(__ccgo_up(p)) = uint8(0) } if __need_unlock != 0 { ___unlockfile(tls, f) @@ -137505,43 +137505,43 @@ func ___fgetwc_unlocked_internal(tls *TLS, f uintptr) (r Twint_t) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { l = Uint64FromInt32(Xmbtowc(tls, bp, (*TFILE)(unsafe.Pointer(f)).Frpos, Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Frend)-int64((*TFILE)(unsafe.Pointer(f)).Frpos)))) if l+uint64(1) >= uint64(1) { - *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(l + BoolUint64(!(l != 0))) /* l==0 means 1 byte, null */ - return Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))) + **(**uintptr)(__ccgo_up(f + 8)) += uintptr(l + BoolUint64(!(l != 0))) /* l==0 means 1 byte, null */ + return Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))) } } /* Convert character byte-by-byte */ - *(*Tmbstate_t)(unsafe.Pointer(bp + 8)) = Tmbstate_t{} + **(**Tmbstate_t)(__ccgo_up(bp + 8)) = Tmbstate_t{} first = int32(1) for cond := true; cond; cond = l == Uint64FromInt32(-Int32FromInt32(2)) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__uflow(tls, f) } v1 = v2 c = v1 - *(*uint8)(unsafe.Pointer(bp + 16)) = Uint8FromInt32(v1) + **(**uint8)(__ccgo_up(bp + 16)) = Uint8FromInt32(v1) if c < 0 { if !(first != 0) { - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EILSEQ) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EILSEQ) } return uint32(0xffffffff) } l = Xmbrtowc(tls, bp, bp+16, uint64(1), bp+8) if l == Uint64FromInt32(-Int32FromInt32(1)) { if !(first != 0) { - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) - Xungetc(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + 16))), f) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) + Xungetc(tls, Int32FromUint8(**(**uint8)(__ccgo_up(bp + 16))), f) } return uint32(0xffffffff) } first = 0 } - return Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))) + return Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))) } func X__fgetwc_unlocked(tls *TLS, f uintptr) (r Twint_t) { @@ -137554,13 +137554,13 @@ func X__fgetwc_unlocked(tls *TLS, f uintptr) (r Twint_t) { var wc Twchar_t _, _, _ = loc, ploc, wc ploc = uintptr(___get_tp(tls)) + 152 - loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) + loc = **(**Tlocale_t)(__ccgo_up(ploc)) if (*TFILE)(unsafe.Pointer(f)).Fmode <= 0 { Xfwide(tls, f, int32(1)) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale + **(**Tlocale_t)(__ccgo_up(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale wc = Int32FromUint32(___fgetwc_unlocked_internal(tls, f)) - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return Uint32FromInt32(wc) } @@ -137632,7 +137632,7 @@ func Xfgetws(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { } v4 = p p += 4 - *(*Twchar_t)(unsafe.Pointer(v4)) = Int32FromUint32(c) + **(**Twchar_t)(__ccgo_up(v4)) = Int32FromUint32(c) if c == uint32('\n') { break } @@ -137641,7 +137641,7 @@ func Xfgetws(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { ; n = n - 1 } - *(*Twchar_t)(unsafe.Pointer(p)) = 0 + **(**Twchar_t)(__ccgo_up(p)) = 0 if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_ERR) != 0 { p = s } @@ -137682,7 +137682,7 @@ func Xfileno(tls *TLS, f uintptr) (r int32) { ___unlockfile(tls, f) } if fd < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EBADF) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EBADF) return -int32(1) } return fd @@ -137735,7 +137735,7 @@ func _mseek(tls *TLS, f uintptr, off Toff_t, whence int32) (r Toff_t) { goto fail fail: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) _1: ; @@ -137743,7 +137743,7 @@ _1: 1: (*Tcookie)(unsafe.Pointer(c)).Fpos, 2: (*Tcookie)(unsafe.Pointer(c)).Flen1, } - base = Int64FromUint64(*(*Tsize_t)(unsafe.Pointer(bp + uintptr(whence)*8))) + base = Int64FromUint64(**(**Tsize_t)(__ccgo_up(bp + uintptr(whence)*8))) if off < -base || off > Int64FromUint64((*Tcookie)(unsafe.Pointer(c)).Fsize)-base { goto fail } @@ -137763,10 +137763,10 @@ func _mread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { } if len1 > rem { len1 = rem - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_EOF) + **(**uint32)(__ccgo_up(f)) |= uint32(F_EOF) } Xmemcpy(tls, buf, (*Tcookie)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie)(unsafe.Pointer(c)).Fpos), len1) - *(*Tsize_t)(unsafe.Pointer(c)) += len1 + **(**Tsize_t)(__ccgo_up(c)) += len1 rem = rem - len1 if rem > (*TFILE)(unsafe.Pointer(f)).Fbuf_size { rem = (*TFILE)(unsafe.Pointer(f)).Fbuf_size @@ -137774,7 +137774,7 @@ func _mread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(rem) Xmemcpy(tls, (*TFILE)(unsafe.Pointer(f)).Frpos, (*Tcookie)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie)(unsafe.Pointer(c)).Fpos), rem) - *(*Tsize_t)(unsafe.Pointer(c)) += rem + **(**Tsize_t)(__ccgo_up(c)) += rem return len1 } @@ -137798,14 +137798,14 @@ func _mwrite(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { len1 = rem } Xmemcpy(tls, (*Tcookie)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie)(unsafe.Pointer(c)).Fpos), buf, len1) - *(*Tsize_t)(unsafe.Pointer(c)) += len1 + **(**Tsize_t)(__ccgo_up(c)) += len1 if (*Tcookie)(unsafe.Pointer(c)).Fpos > (*Tcookie)(unsafe.Pointer(c)).Flen1 { (*Tcookie)(unsafe.Pointer(c)).Flen1 = (*Tcookie)(unsafe.Pointer(c)).Fpos if (*Tcookie)(unsafe.Pointer(c)).Flen1 < (*Tcookie)(unsafe.Pointer(c)).Fsize { - *(*uint8)(unsafe.Pointer((*Tcookie)(unsafe.Pointer(c)).Fbuf + uintptr((*Tcookie)(unsafe.Pointer(c)).Flen1))) = uint8(0) + **(**uint8)(__ccgo_up((*Tcookie)(unsafe.Pointer(c)).Fbuf + uintptr((*Tcookie)(unsafe.Pointer(c)).Flen1))) = uint8(0) } else { if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_NORD) != 0 && (*Tcookie)(unsafe.Pointer(c)).Fsize != 0 { - *(*uint8)(unsafe.Pointer((*Tcookie)(unsafe.Pointer(c)).Fbuf + uintptr((*Tcookie)(unsafe.Pointer(c)).Fsize-uint64(1)))) = uint8(0) + **(**uint8)(__ccgo_up((*Tcookie)(unsafe.Pointer(c)).Fbuf + uintptr((*Tcookie)(unsafe.Pointer(c)).Fsize-uint64(1)))) = uint8(0) } } } @@ -137827,12 +137827,12 @@ func Xfmemopen(tls *TLS, buf uintptr, size Tsize_t, mode uintptr) (r uintptr) { var v3 Tsize_t _, _, _, _, _ = f, plus, v1, v2, v3 plus = BoolInt32(!!(Xstrchr(tls, mode, int32('+')) != 0)) - if !(Xstrchr(tls, __ccgo_ts+1546, Int32FromUint8(*(*uint8)(unsafe.Pointer(mode)))) != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if !(Xstrchr(tls, __ccgo_ts+1546, Int32FromUint8(**(**uint8)(__ccgo_up(mode)))) != 0) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } if !(buf != 0) && size > Uint64FromInt64(Int64FromInt64(INT64_MAX)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return uintptr(0) } if buf != 0 { @@ -137856,25 +137856,25 @@ func Xfmemopen(tls *TLS, buf uintptr, size Tsize_t, mode uintptr) (r uintptr) { } (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fbuf = buf (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fsize = size - (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fmode = Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) + (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fmode = Int32FromUint8(**(**uint8)(__ccgo_up(mode))) if !(plus != 0) { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('r') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) == int32('r') { v2 = int32(F_NOWR) } else { v2 = int32(F_NORD) } (*Tmem_FILE)(unsafe.Pointer(f)).Ff.Fflags = Uint32FromInt32(v2) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('r') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) == int32('r') { (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Flen1 = size } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('a') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) == int32('a') { v3 = Xstrnlen(tls, buf, size) (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fpos = v3 (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Flen1 = v3 } else { if plus != 0 { - *(*uint8)(unsafe.Pointer((*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fbuf)) = uint8(0) + **(**uint8)(__ccgo_up((*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fbuf)) = uint8(0) } } } @@ -137897,8 +137897,8 @@ func Xfopen(tls *TLS, filename uintptr, mode uintptr) (r uintptr) { var fd, flags int32 _, _, _ = f, fd, flags /* Check for valid initial mode character */ - if !(Xstrchr(tls, __ccgo_ts+1546, Int32FromUint8(*(*uint8)(unsafe.Pointer(mode)))) != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if !(Xstrchr(tls, __ccgo_ts+1546, Int32FromUint8(**(**uint8)(__ccgo_up(mode)))) != 0) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } /* Compute the flags to pass to open() */ @@ -137965,7 +137965,7 @@ func _cookieread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - *(*uint8)(unsafe.Pointer(buf + uintptr(v1))) = *(*uint8)(unsafe.Pointer(v2)) + **(**uint8)(__ccgo_up(buf + uintptr(v1))) = **(**uint8)(__ccgo_up(v2)) return readlen goto bail bail: @@ -137975,7 +137975,7 @@ bail: } else { v4 = int32(F_ERR) } - *(*uint32)(unsafe.Pointer(f)) |= Uint32FromInt32(v4) + **(**uint32)(__ccgo_up(f)) |= Uint32FromInt32(v4) v2 = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = v2 (*TFILE)(unsafe.Pointer(f)).Frpos = v2 @@ -138005,7 +138005,7 @@ func _cookiewrite(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { v1 = v2 (*TFILE)(unsafe.Pointer(f)).Fwbase = v1 (*TFILE)(unsafe.Pointer(f)).Fwpos = v1 - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) return uint64(0) } return Uint64FromInt64(ret) @@ -138020,18 +138020,18 @@ func _cookieseek(tls *TLS, f uintptr, _off Toff_t, whence int32) (r Toff_t) { _, _ = fc, res fc = (*TFILE)(unsafe.Pointer(f)).Fcookie if Uint32FromInt32(whence) > uint32(2) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) } if !((*Tfcookie)(unsafe.Pointer(fc)).Fiofuncs.Fseek != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOPNOTSUPP) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOPNOTSUPP) return int64(-int32(1)) } res = (*(*func(*TLS, uintptr, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{(*Tfcookie)(unsafe.Pointer(fc)).Fiofuncs.Fseek})))(tls, (*Tfcookie)(unsafe.Pointer(fc)).Fcookie, bp, whence) if res < 0 { return int64(res) } - return *(*Toff_t)(unsafe.Pointer(bp)) + return **(**Toff_t)(__ccgo_up(bp)) } func _cookieclose(tls *TLS, f uintptr) (r int32) { @@ -138053,8 +138053,8 @@ func Xfopencookie(tls *TLS, cookie uintptr, mode uintptr, iofuncs Tcookie_io_fun var v2 int32 _, _, _ = f, v1, v2 /* Check for valid initial mode character */ - if !(Xstrchr(tls, __ccgo_ts+1546, Int32FromUint8(*(*uint8)(unsafe.Pointer(mode)))) != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if !(Xstrchr(tls, __ccgo_ts+1546, Int32FromUint8(**(**uint8)(__ccgo_up(mode)))) != 0) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } /* Allocate FILE+fcookie+buffer or fail */ @@ -138067,7 +138067,7 @@ func Xfopencookie(tls *TLS, cookie uintptr, mode uintptr, iofuncs Tcookie_io_fun Xmemset(tls, f, 0, uint64(232)) /* Impose mode restrictions */ if !(Xstrchr(tls, mode, int32('+')) != 0) { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('r') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) == int32('r') { v2 = int32(F_NOWR) } else { v2 = int32(F_NORD) @@ -138153,7 +138153,7 @@ _11: v2 = f + 40 v1 = *(*uintptr)(unsafe.Pointer(v2)) *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(v2)) + 1 - *(*uint8)(unsafe.Pointer(v1)) = v13 + **(**uint8)(__ccgo_up(v1)) = v13 v3 = Int32FromUint8(v13) } else { v3 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) @@ -138225,7 +138225,7 @@ func Xfputc(tls *TLS, c1 int32, f1 uintptr) (r int32) { v8 = v2 + 40 v7 = *(*uintptr)(unsafe.Pointer(v8)) *(*uintptr)(unsafe.Pointer(v8)) = *(*uintptr)(unsafe.Pointer(v8)) + 1 - *(*uint8)(unsafe.Pointer(v7)) = v6 + **(**uint8)(__ccgo_up(v7)) = v6 v5 = Int32FromUint8(v6) } else { v5 = X__overflow(tls, v2, Int32FromUint8(Uint8FromInt32(v1))) @@ -138272,18 +138272,18 @@ func X__fputwc_unlocked(tls *TLS, c Twchar_t, f uintptr) (r Twint_t) { var _ /* mbc at bp+0 */ [4]uint8 _, _, _, _, _, _, _ = l, loc, ploc, v1, v2, v3, v4 ploc = uintptr(___get_tp(tls)) + 152 - loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) + loc = **(**Tlocale_t)(__ccgo_up(ploc)) if (*TFILE)(unsafe.Pointer(f)).Fmode <= 0 { Xfwide(tls, f, int32(1)) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale + **(**Tlocale_t)(__ccgo_up(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale if BoolInt32(Uint32FromInt32(c) < uint32(128)) != 0 { if Int32FromUint8(Uint8FromInt32(c)) != (*TFILE)(unsafe.Pointer(f)).Flbf && (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwend { v2 = Uint8FromInt32(c) v4 = f + 40 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(v3)) = v2 + **(**uint8)(__ccgo_up(v3)) = v2 v1 = Int32FromUint8(v2) } else { v1 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) @@ -138295,7 +138295,7 @@ func X__fputwc_unlocked(tls *TLS, c Twchar_t, f uintptr) (r Twint_t) { if l < 0 { c = Int32FromUint32(0xffffffff) } else { - *(*uintptr)(unsafe.Pointer(f + 40)) += uintptr(l) + **(**uintptr)(__ccgo_up(f + 40)) += uintptr(l) } } else { l = Xwctomb(tls, bp, c) @@ -138305,9 +138305,9 @@ func X__fputwc_unlocked(tls *TLS, c Twchar_t, f uintptr) (r Twint_t) { } } if Uint32FromInt32(c) == uint32(0xffffffff) { - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return Uint32FromInt32(c) } @@ -138364,7 +138364,7 @@ func Xfputws(tls *TLS, _ws uintptr, f uintptr) (r int32) { _, _, _, _, _, _, _ = __need_unlock, l, loc, ploc, v1, v2, v3 l = uint64(0) ploc = uintptr(___get_tp(tls)) + 152 - loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) + loc = **(**Tlocale_t)(__ccgo_up(ploc)) if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) } else { @@ -138372,9 +138372,9 @@ func Xfputws(tls *TLS, _ws uintptr, f uintptr) (r int32) { } __need_unlock = v1 Xfwide(tls, f, int32(1)) - *(*Tlocale_t)(unsafe.Pointer(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale + **(**Tlocale_t)(__ccgo_up(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale for { - if v3 = *(*uintptr)(unsafe.Pointer(bp)) != 0; v3 { + if v3 = **(**uintptr)(__ccgo_up(bp)) != 0; v3 { v2 = Xwcsrtombs(tls, bp+8, bp, uint64(1024), uintptr(0)) l = v2 } @@ -138385,14 +138385,14 @@ func Xfputws(tls *TLS, _ws uintptr, f uintptr) (r int32) { if __need_unlock != 0 { ___unlockfile(tls, f) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return -int32(1) } } if __need_unlock != 0 { ___unlockfile(tls, f) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return Int32FromUint64(l) /* 0 or -1 */ } @@ -138426,7 +138426,7 @@ func Xfread(tls *TLS, destv uintptr, size Tsize_t, nmemb Tsize_t, f uintptr) (r v1 = 0 } __need_unlock = v1 - *(*int32)(unsafe.Pointer(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) + **(**int32)(__ccgo_up(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { /* First exhaust the buffer. */ if Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Frend)-int64((*TFILE)(unsafe.Pointer(f)).Frpos)) < l { @@ -138436,7 +138436,7 @@ func Xfread(tls *TLS, destv uintptr, size Tsize_t, nmemb Tsize_t, f uintptr) (r } k = v2 Xmemcpy(tls, dest, (*TFILE)(unsafe.Pointer(f)).Frpos, k) - *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(k) + **(**uintptr)(__ccgo_up(f + 8)) += uintptr(k) dest = dest + uintptr(k) l = l - k } @@ -138576,7 +138576,7 @@ func X__fseeko_unlocked(tls *TLS, f uintptr, off Toff_t, whence int32) (r int32) _, _ = v1, v2 /* Fail immediately for invalid whence argument. */ if whence != int32(1) && whence != 0 && whence != int32(2) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } /* Adjust relative offset for unread data in buffer, if any. */ @@ -138604,7 +138604,7 @@ func X__fseeko_unlocked(tls *TLS, f uintptr, off Toff_t, whence int32) (r int32) v1 = UintptrFromInt32(0) (*TFILE)(unsafe.Pointer(f)).Frend = v1 (*TFILE)(unsafe.Pointer(f)).Frpos = v1 - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) return 0 } @@ -138649,7 +138649,7 @@ func Xfsetpos(tls *TLS, f uintptr, pos uintptr) (r int32) { trc("tls=%v f=%v pos=%v, (%v:)", tls, f, pos, origin(2)) defer func() { trc("-> %v", r) }() } - return X__fseeko(tls, f, *(*int64)(unsafe.Pointer(pos)), 0) + return X__fseeko(tls, f, int64(**(**int64)(__ccgo_up(pos))), 0) } /* Support signed or unsigned plain-char */ @@ -138719,7 +138719,7 @@ func Xftell(tls *TLS, f uintptr) (r int64) { _ = pos pos = X__ftello(tls, f) if pos > int64(0x7fffffffffffffff) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return int64(-int32(1)) } return pos @@ -138882,7 +138882,7 @@ func Xfwide(tls *TLS, f uintptr, mode int32) (r int32) { __need_unlock = v1 if mode != 0 { if !((*TFILE)(unsafe.Pointer(f)).Flocale != 0) { - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v3 = int32(4) } else { v3 = int32(1) @@ -138942,7 +138942,7 @@ func X__fwritex(tls *TLS, s uintptr, l Tsize_t, f uintptr) (r Tsize_t) { /* Match /^(.*\n|)/ */ i = l for { - if !(i != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(i-uint64(1))))) != int32('\n')) { + if !(i != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(i-uint64(1))))) != int32('\n')) { break } goto _1 @@ -138960,7 +138960,7 @@ func X__fwritex(tls *TLS, s uintptr, l Tsize_t, f uintptr) (r Tsize_t) { } } Xmemcpy(tls, (*TFILE)(unsafe.Pointer(f)).Fwpos, s, l) - *(*uintptr)(unsafe.Pointer(f + 40)) += uintptr(l) + **(**uintptr)(__ccgo_up(f + 40)) += uintptr(l) return l + i } @@ -139071,7 +139071,7 @@ _11: v2 = f + 8 v1 = *(*uintptr)(unsafe.Pointer(v2)) *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(v2)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v1))) } else { v3 = X__uflow(tls, f) } @@ -139139,7 +139139,7 @@ func Xgetc(tls *TLS, f1 uintptr) (r int32) { v6 = v1 + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(v5))) } else { v4 = X__uflow(tls, v1) } @@ -139172,7 +139172,7 @@ func Xgetc_unlocked(tls *TLS, f uintptr) (r int32) { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__uflow(tls, f) } @@ -139241,7 +139241,7 @@ _11: v2 = f + 8 v1 = *(*uintptr)(unsafe.Pointer(v2)) *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(v2)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v1))) } else { v3 = X__uflow(tls, f) } @@ -139309,7 +139309,7 @@ func Xgetchar(tls *TLS) (r int32) { v6 = v1 + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(v5))) } else { v4 = X__uflow(tls, v1) } @@ -139334,7 +139334,7 @@ func Xgetchar_unlocked(tls *TLS) (r int32) { v3 = uintptr(unsafe.Pointer(&X__stdin_FILE)) + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__uflow(tls, uintptr(unsafe.Pointer(&X__stdin_FILE))) } @@ -139360,16 +139360,16 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize } __need_unlock = v1 if !(n != 0) || !(s != 0) { - *(*int32)(unsafe.Pointer(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**int32)(__ccgo_up(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) if __need_unlock != 0 { ___unlockfile(tls, f) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) } - if !(*(*uintptr)(unsafe.Pointer(s)) != 0) { - *(*Tsize_t)(unsafe.Pointer(n)) = uint64(0) + if !(**(**uintptr)(__ccgo_up(s)) != 0) { + **(**Tsize_t)(__ccgo_up(n)) = uint64(0) } for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { @@ -139384,36 +139384,36 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize z = uintptr(0) k = uint64(0) } - if i+k >= *(*Tsize_t)(unsafe.Pointer(n)) { + if i+k >= **(**Tsize_t)(__ccgo_up(n)) { m = i + k + uint64(2) if !(z != 0) && m < Uint64FromUint64(0xffffffffffffffff)/Uint64FromInt32(4) { m = m + m/uint64(2) } - tmp = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(s)), m) + tmp = Xrealloc(tls, **(**uintptr)(__ccgo_up(s)), m) if !(tmp != 0) { m = i + k + uint64(2) - tmp = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(s)), m) + tmp = Xrealloc(tls, **(**uintptr)(__ccgo_up(s)), m) if !(tmp != 0) { /* Copy as much as fits and ensure no * pushback remains in the FILE buf. */ - k = *(*Tsize_t)(unsafe.Pointer(n)) - i - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(s))+uintptr(i), (*TFILE)(unsafe.Pointer(f)).Frpos, k) - *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(k) - *(*int32)(unsafe.Pointer(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + k = **(**Tsize_t)(__ccgo_up(n)) - i + Xmemcpy(tls, **(**uintptr)(__ccgo_up(s))+uintptr(i), (*TFILE)(unsafe.Pointer(f)).Frpos, k) + **(**uintptr)(__ccgo_up(f + 8)) += uintptr(k) + **(**int32)(__ccgo_up(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) if __need_unlock != 0 { ___unlockfile(tls, f) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return int64(-int32(1)) } } - *(*uintptr)(unsafe.Pointer(s)) = tmp - *(*Tsize_t)(unsafe.Pointer(n)) = m + **(**uintptr)(__ccgo_up(s)) = tmp + **(**Tsize_t)(__ccgo_up(n)) = m } if k != 0 { - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(s))+uintptr(i), (*TFILE)(unsafe.Pointer(f)).Frpos, k) - *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(k) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(s))+uintptr(i), (*TFILE)(unsafe.Pointer(f)).Frpos, k) + **(**uintptr)(__ccgo_up(f + 8)) += uintptr(k) i = i + k } if z != 0 { @@ -139423,7 +139423,7 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize v7 = f + 8 v6 = *(*uintptr)(unsafe.Pointer(v7)) *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) + 1 - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(v6))) } else { v4 = X__uflow(tls, f) } @@ -139440,16 +139440,16 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize } /* If the byte read by getc won't fit without growing the * output buffer, push it back for next iteration. */ - if i+uint64(1) >= *(*Tsize_t)(unsafe.Pointer(n)) { + if i+uint64(1) >= **(**Tsize_t)(__ccgo_up(n)) { v7 = f + 8 *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) - 1 v6 = *(*uintptr)(unsafe.Pointer(v7)) - *(*uint8)(unsafe.Pointer(v6)) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(v6)) = Uint8FromInt32(c) } else { v10 = Uint8FromInt32(c) v11 = i i = i + 1 - *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)) + uintptr(v11))) = v10 + **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)) + uintptr(v11))) = v10 if Int32FromUint8(v10) == delim { break } @@ -139457,7 +139457,7 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize goto _2 _2: } - *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)) + uintptr(i))) = uint8(0) + **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)) + uintptr(i))) = uint8(0) if __need_unlock != 0 { ___unlockfile(tls, f) } @@ -139501,7 +139501,7 @@ func Xgets(tls *TLS, s uintptr) (r uintptr) { v5 = uintptr(unsafe.Pointer(&X__stdin_FILE)) + 8 v4 = *(*uintptr)(unsafe.Pointer(v5)) *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v4))) } else { v3 = X__uflow(tls, uintptr(unsafe.Pointer(&X__stdin_FILE))) } @@ -139512,9 +139512,9 @@ func Xgets(tls *TLS, s uintptr) (r uintptr) { } v6 = i i = i + 1 - *(*uint8)(unsafe.Pointer(s + uintptr(v6))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + uintptr(v6))) = Uint8FromInt32(c) } - *(*uint8)(unsafe.Pointer(s + uintptr(i))) = uint8(0) + **(**uint8)(__ccgo_up(s + uintptr(i))) = uint8(0) if c != int32('\n') && (!((*TFILE)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stdin_FILE)))).Fflags&Uint32FromInt32(F_EOF) != 0) || !(i != 0)) { s = uintptr(0) } @@ -139535,7 +139535,7 @@ func Xgetw(tls *TLS, f uintptr) (r int32) { var _ /* x at bp+0 */ int32 _ = v1 if Xfread(tls, bp, uint64(4), uint64(1), f) != 0 { - v1 = *(*int32)(unsafe.Pointer(bp)) + v1 = **(**int32)(__ccgo_up(bp)) } else { v1 = -int32(1) } @@ -139593,11 +139593,11 @@ func X__ofl_add(tls *TLS, f uintptr) (r uintptr) { var head uintptr _ = head head = X__ofl_lock(tls) - (*TFILE)(unsafe.Pointer(f)).Fnext = *(*uintptr)(unsafe.Pointer(head)) - if *(*uintptr)(unsafe.Pointer(head)) != 0 { - (*TFILE)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(head)))).Fprev = f + (*TFILE)(unsafe.Pointer(f)).Fnext = **(**uintptr)(__ccgo_up(head)) + if **(**uintptr)(__ccgo_up(head)) != 0 { + (*TFILE)(unsafe.Pointer(**(**uintptr)(__ccgo_up(head)))).Fprev = f } - *(*uintptr)(unsafe.Pointer(head)) = f + **(**uintptr)(__ccgo_up(head)) = f X__ofl_unlock(tls) return f } @@ -139631,7 +139631,7 @@ func _ms_seek(tls *TLS, f uintptr, off Toff_t, whence int32) (r Toff_t) { goto fail fail: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) _1: ; @@ -139639,7 +139639,7 @@ _1: 1: (*Tcookie1)(unsafe.Pointer(c)).Fpos, 2: (*Tcookie1)(unsafe.Pointer(c)).Flen1, } - base = Int64FromUint64(*(*Tsize_t)(unsafe.Pointer(bp + uintptr(whence)*8))) + base = Int64FromUint64(**(**Tsize_t)(__ccgo_up(bp + uintptr(whence)*8))) if off < -base || off > int64(0x7fffffffffffffff)-base { goto fail } @@ -139668,16 +139668,16 @@ func _ms_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { } v1 = newbuf (*Tcookie1)(unsafe.Pointer(c)).Fbuf = v1 - *(*uintptr)(unsafe.Pointer((*Tcookie1)(unsafe.Pointer(c)).Fbufp)) = v1 + **(**uintptr)(__ccgo_up((*Tcookie1)(unsafe.Pointer(c)).Fbufp)) = v1 Xmemset(tls, (*Tcookie1)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie1)(unsafe.Pointer(c)).Fspace), 0, len2-(*Tcookie1)(unsafe.Pointer(c)).Fspace) (*Tcookie1)(unsafe.Pointer(c)).Fspace = len2 } Xmemcpy(tls, (*Tcookie1)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie1)(unsafe.Pointer(c)).Fpos), buf, len1) - *(*Tsize_t)(unsafe.Pointer(c + 16)) += len1 + **(**Tsize_t)(__ccgo_up(c + 16)) += len1 if (*Tcookie1)(unsafe.Pointer(c)).Fpos >= (*Tcookie1)(unsafe.Pointer(c)).Flen1 { (*Tcookie1)(unsafe.Pointer(c)).Flen1 = (*Tcookie1)(unsafe.Pointer(c)).Fpos } - *(*Tsize_t)(unsafe.Pointer((*Tcookie1)(unsafe.Pointer(c)).Fsizep)) = (*Tcookie1)(unsafe.Pointer(c)).Fpos + **(**Tsize_t)(__ccgo_up((*Tcookie1)(unsafe.Pointer(c)).Fsizep)) = (*Tcookie1)(unsafe.Pointer(c)).Fpos return len1 } @@ -139710,16 +139710,16 @@ func Xopen_memstream(tls *TLS, bufp uintptr, sizep uintptr) (r uintptr) { (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fbufp = bufp (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fsizep = sizep v5 = Uint64FromInt32(0) - *(*Tsize_t)(unsafe.Pointer(sizep)) = v5 + **(**Tsize_t)(__ccgo_up(sizep)) = v5 v4 = v5 (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fspace = v4 v3 = v4 (*Tms_FILE)(unsafe.Pointer(f)).Fc.Flen1 = v3 (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fpos = v3 v1 = buf - *(*uintptr)(unsafe.Pointer(bufp)) = v1 + **(**uintptr)(__ccgo_up(bufp)) = v1 (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fbuf = v1 - *(*uint8)(unsafe.Pointer(buf)) = uint8(0) + **(**uint8)(__ccgo_up(buf)) = uint8(0) (*Tms_FILE)(unsafe.Pointer(f)).Ff.Fflags = uint32(F_NORD) (*Tms_FILE)(unsafe.Pointer(f)).Ff.Ffd = -int32(1) (*Tms_FILE)(unsafe.Pointer(f)).Ff.Fbuf = f + 280 @@ -139765,7 +139765,7 @@ func _wms_seek(tls *TLS, f uintptr, off Toff_t, whence int32) (r Toff_t) { goto fail fail: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) _1: ; @@ -139773,7 +139773,7 @@ _1: 1: (*Tcookie2)(unsafe.Pointer(c)).Fpos, 2: (*Tcookie2)(unsafe.Pointer(c)).Flen1, } - base = Int64FromUint64(*(*Tsize_t)(unsafe.Pointer(bp + uintptr(whence)*8))) + base = Int64FromUint64(**(**Tsize_t)(__ccgo_up(bp + uintptr(whence)*8))) if off < -base || off > Int64FromInt64(0x7fffffffffffffff)/Int64FromInt32(4)-base { goto fail } @@ -139809,7 +139809,7 @@ func _wms_write(tls *TLS, f uintptr, _buf uintptr, len1 Tsize_t) (r Tsize_t) { } v1 = newbuf (*Tcookie2)(unsafe.Pointer(c)).Fbuf = v1 - *(*uintptr)(unsafe.Pointer((*Tcookie2)(unsafe.Pointer(c)).Fbufp)) = v1 + **(**uintptr)(__ccgo_up((*Tcookie2)(unsafe.Pointer(c)).Fbufp)) = v1 Xmemset(tls, (*Tcookie2)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie2)(unsafe.Pointer(c)).Fspace)*4, 0, uint64(4)*(len2-(*Tcookie2)(unsafe.Pointer(c)).Fspace)) (*Tcookie2)(unsafe.Pointer(c)).Fspace = len2 } @@ -139817,11 +139817,11 @@ func _wms_write(tls *TLS, f uintptr, _buf uintptr, len1 Tsize_t) (r Tsize_t) { if len2 == Uint64FromInt32(-Int32FromInt32(1)) { return uint64(0) } - *(*Tsize_t)(unsafe.Pointer(c + 16)) += len2 + **(**Tsize_t)(__ccgo_up(c + 16)) += len2 if (*Tcookie2)(unsafe.Pointer(c)).Fpos >= (*Tcookie2)(unsafe.Pointer(c)).Flen1 { (*Tcookie2)(unsafe.Pointer(c)).Flen1 = (*Tcookie2)(unsafe.Pointer(c)).Fpos } - *(*Tsize_t)(unsafe.Pointer((*Tcookie2)(unsafe.Pointer(c)).Fsizep)) = (*Tcookie2)(unsafe.Pointer(c)).Fpos + **(**Tsize_t)(__ccgo_up((*Tcookie2)(unsafe.Pointer(c)).Fsizep)) = (*Tcookie2)(unsafe.Pointer(c)).Fpos return len1 } @@ -139854,16 +139854,16 @@ func Xopen_wmemstream(tls *TLS, bufp uintptr, sizep uintptr) (r uintptr) { (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fbufp = bufp (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fsizep = sizep v5 = Uint64FromInt32(0) - *(*Tsize_t)(unsafe.Pointer(sizep)) = v5 + **(**Tsize_t)(__ccgo_up(sizep)) = v5 v4 = v5 (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fspace = v4 v3 = v4 (*Twms_FILE)(unsafe.Pointer(f)).Fc.Flen1 = v3 (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fpos = v3 v1 = buf - *(*uintptr)(unsafe.Pointer(bufp)) = v1 + **(**uintptr)(__ccgo_up(bufp)) = v1 (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fbuf = v1 - *(*Twchar_t)(unsafe.Pointer(buf)) = 0 + **(**Twchar_t)(__ccgo_up(buf)) = 0 (*Twms_FILE)(unsafe.Pointer(f)).Ff.Fflags = uint32(F_NORD) (*Twms_FILE)(unsafe.Pointer(f)).Ff.Ffd = -int32(1) (*Twms_FILE)(unsafe.Pointer(f)).Ff.Fbuf = f + 288 @@ -139902,7 +139902,7 @@ func Xpclose(tls *TLS, f uintptr) (r1 int32) { if r < 0 { return int32(X__syscall_ret(tls, Uint64FromInt32(r))) } - return *(*int32)(unsafe.Pointer(bp)) + return **(**int32)(__ccgo_up(bp)) } func Xperror(tls *TLS, msg uintptr) { @@ -139913,7 +139913,7 @@ func Xperror(tls *TLS, msg uintptr) { var errstr, f, old_locale uintptr _, _, _, _, _, _ = __need_unlock, errstr, f, old_locale, old_mode, v1 f = uintptr(unsafe.Pointer(&X__stderr_FILE)) - errstr = Xstrerror(tls, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) + errstr = Xstrerror(tls, **(**int32)(__ccgo_up(X__errno_location(tls)))) if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) } else { @@ -139924,7 +139924,7 @@ func Xperror(tls *TLS, msg uintptr) { * permitted to change them. */ old_locale = (*TFILE)(unsafe.Pointer(f)).Flocale old_mode = (*TFILE)(unsafe.Pointer(f)).Fmode - if msg != 0 && *(*uint8)(unsafe.Pointer(msg)) != 0 { + if msg != 0 && **(**uint8)(__ccgo_up(msg)) != 0 { Xfwrite(tls, msg, _strlen(tls, msg), uint64(1), f) Xfputc(tls, int32(':'), f) Xfputc(tls, int32(' '), f) @@ -140000,7 +140000,7 @@ _11: v2 = f + 40 v1 = *(*uintptr)(unsafe.Pointer(v2)) *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(v2)) + 1 - *(*uint8)(unsafe.Pointer(v1)) = v13 + **(**uint8)(__ccgo_up(v1)) = v13 v3 = Int32FromUint8(v13) } else { v3 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) @@ -140072,7 +140072,7 @@ func Xputc(tls *TLS, c1 int32, f1 uintptr) (r int32) { v8 = v2 + 40 v7 = *(*uintptr)(unsafe.Pointer(v8)) *(*uintptr)(unsafe.Pointer(v8)) = *(*uintptr)(unsafe.Pointer(v8)) + 1 - *(*uint8)(unsafe.Pointer(v7)) = v6 + **(**uint8)(__ccgo_up(v7)) = v6 v5 = Int32FromUint8(v6) } else { v5 = X__overflow(tls, v2, Int32FromUint8(Uint8FromInt32(v1))) @@ -140108,7 +140108,7 @@ func Xputc_unlocked(tls *TLS, c int32, f uintptr) (r int32) { v4 = f + 40 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(v3)) = v2 + **(**uint8)(__ccgo_up(v3)) = v2 v1 = Int32FromUint8(v2) } else { v1 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) @@ -140180,7 +140180,7 @@ _11: v2 = f + 40 v1 = *(*uintptr)(unsafe.Pointer(v2)) *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(v2)) + 1 - *(*uint8)(unsafe.Pointer(v1)) = v13 + **(**uint8)(__ccgo_up(v1)) = v13 v3 = Int32FromUint8(v13) } else { v3 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) @@ -140252,7 +140252,7 @@ func Xputchar(tls *TLS, c1 int32) (r int32) { v8 = v2 + 40 v7 = *(*uintptr)(unsafe.Pointer(v8)) *(*uintptr)(unsafe.Pointer(v8)) = *(*uintptr)(unsafe.Pointer(v8)) + 1 - *(*uint8)(unsafe.Pointer(v7)) = v6 + **(**uint8)(__ccgo_up(v7)) = v6 v5 = Int32FromUint8(v6) } else { v5 = X__overflow(tls, v2, Int32FromUint8(Uint8FromInt32(v1))) @@ -140280,7 +140280,7 @@ func Xputchar_unlocked(tls *TLS, c int32) (r int32) { v4 = uintptr(unsafe.Pointer(&X__stdout_FILE)) + 40 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(v3)) = v2 + **(**uint8)(__ccgo_up(v3)) = v2 v1 = Int32FromUint8(v2) } else { v1 = X__overflow(tls, uintptr(unsafe.Pointer(&X__stdout_FILE)), Int32FromUint8(Uint8FromInt32(c))) @@ -140310,7 +140310,7 @@ func Xputs(tls *TLS, s uintptr) (r1 int32) { v5 = uintptr(unsafe.Pointer(&X__stdout_FILE)) + 40 v4 = *(*uintptr)(unsafe.Pointer(v5)) *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = v3 + **(**uint8)(__ccgo_up(v4)) = v3 v2 = Int32FromUint8(v3) } else { v2 = X__overflow(tls, uintptr(unsafe.Pointer(&X__stdout_FILE)), Int32FromUint8(Uint8FromInt32(Int32FromUint8('\n')))) @@ -140393,7 +140393,7 @@ func Xrewind(tls *TLS, f uintptr) { } __need_unlock = v1 X__fseeko_unlocked(tls, f, 0, 0) - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_ERR)) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^Int32FromInt32(F_ERR)) if __need_unlock != 0 { ___unlockfile(tls, f) } @@ -140483,7 +140483,7 @@ func Xsetvbuf(tls *TLS, f uintptr, buf uintptr, type1 int32, size Tsize_t) (r in return -int32(1) } } - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_SVB) + **(**uint32)(__ccgo_up(f)) |= uint32(F_SVB) return 0 } @@ -140623,14 +140623,14 @@ func Xtempnam(tls *TLS, dir uintptr, pfx uintptr) (r1 uintptr) { pl = _strlen(tls, pfx) l = dl + uint64(1) + pl + uint64(1) + uint64(6) if l >= uint64(PATH_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENAMETOOLONG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENAMETOOLONG) return uintptr(0) } Xmemcpy(tls, bp+1, dir, dl) - (*(*[4096]uint8)(unsafe.Pointer(bp + 1)))[dl] = uint8('/') + (**(**[4096]uint8)(__ccgo_up(bp + 1)))[dl] = uint8('/') Xmemcpy(tls, bp+1+uintptr(dl)+uintptr(1), pfx, pl) - (*(*[4096]uint8)(unsafe.Pointer(bp + 1)))[dl+uint64(1)+pl] = uint8('_') - (*(*[4096]uint8)(unsafe.Pointer(bp + 1)))[l] = uint8(0) + (**(**[4096]uint8)(__ccgo_up(bp + 1)))[dl+uint64(1)+pl] = uint8('_') + (**(**[4096]uint8)(__ccgo_up(bp + 1)))[l] = uint8(0) try = 0 for { if !(try < int32(MAXTRIES)) { @@ -140661,7 +140661,7 @@ func Xtmpfile(tls *TLS) (r uintptr) { var fd, try int32 var _ /* s at bp+0 */ [20]uint8 _, _, _ = f, fd, try - *(*[20]uint8)(unsafe.Pointer(bp)) = [20]uint8{'/', 't', 'm', 'p', '/', 't', 'm', 'p', 'f', 'i', 'l', 'e', '_', 'X', 'X', 'X', 'X', 'X', 'X'} + **(**[20]uint8)(__ccgo_up(bp)) = [20]uint8{'/', 't', 'm', 'p', '/', 't', 'm', 'p', 'f', 'i', 'l', 'e', '_', 'X', 'X', 'X', 'X', 'X', 'X'} try = 0 for { if !(try < int32(MAXTRIES)) { @@ -140696,7 +140696,7 @@ func Xtmpnam(tls *TLS, buf uintptr) (r1 uintptr) { var v2 uintptr var _ /* s at bp+1 */ [19]uint8 _, _, _ = r, try, v2 - *(*[19]uint8)(unsafe.Pointer(bp + 1)) = [19]uint8{'/', 't', 'm', 'p', '/', 't', 'm', 'p', 'n', 'a', 'm', '_', 'X', 'X', 'X', 'X', 'X', 'X'} + **(**[19]uint8)(__ccgo_up(bp + 1)) = [19]uint8{'/', 't', 'm', 'p', '/', 't', 'm', 'p', 'n', 'a', 'm', '_', 'X', 'X', 'X', 'X', 'X', 'X'} try = 0 for { if !(try < int32(MAXTRIES)) { @@ -140752,8 +140752,8 @@ func Xungetc(tls *TLS, c int32, f uintptr) (r int32) { v3 = f + 8 *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) - 1 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(c) - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) + **(**uint8)(__ccgo_up(v2)) = Uint8FromInt32(c) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) if __need_unlock != 0 { ___unlockfile(tls, f) } @@ -140774,7 +140774,7 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { var _ /* mbc at bp+0 */ [4]uint8 _, _, _, _, _, _, _, _ = __need_unlock, l, loc, ploc, v1, v3, v4, v5 ploc = uintptr(___get_tp(tls)) + 152 - loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) + loc = **(**Tlocale_t)(__ccgo_up(ploc)) if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) } else { @@ -140784,7 +140784,7 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { if (*TFILE)(unsafe.Pointer(f)).Fmode <= 0 { Xfwide(tls, f, int32(1)) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale + **(**Tlocale_t)(__ccgo_up(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale if !((*TFILE)(unsafe.Pointer(f)).Frpos != 0) { X__toread(tls, f) } @@ -140796,24 +140796,24 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { if __need_unlock != 0 { ___unlockfile(tls, f) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return uint32(0xffffffff) } if BoolInt32(c < uint32(128)) != 0 { v5 = f + 8 *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) - 1 v4 = *(*uintptr)(unsafe.Pointer(v5)) - *(*uint8)(unsafe.Pointer(v4)) = uint8(c) + **(**uint8)(__ccgo_up(v4)) = uint8(c) } else { v4 = f + 8 *(*uintptr)(unsafe.Pointer(v4)) -= uintptr(l) Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(v4)), bp, Uint64FromInt32(l)) } - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) if __need_unlock != 0 { ___unlockfile(tls, f) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return c } @@ -140832,12 +140832,12 @@ func Xvasprintf(tls *TLS, s uintptr, fmt uintptr, ap Tva_list) (r int32) { _ = ap2 if v2 = l < 0; !v2 { v1 = Xmalloc(tls, uint64(Uint32FromInt32(l)+uint32(1))) - *(*uintptr)(unsafe.Pointer(s)) = v1 + **(**uintptr)(__ccgo_up(s)) = v1 } if v2 || !(v1 != 0) { return -int32(1) } - return Xvsnprintf(tls, *(*uintptr)(unsafe.Pointer(s)), uint64(Uint32FromInt32(l)+uint32(1)), fmt, ap) + return Xvsnprintf(tls, **(**uintptr)(__ccgo_up(s)), uint64(Uint32FromInt32(l)+uint32(1)), fmt, ap) } func Xvdprintf(tls *TLS, fd int32, fmt uintptr, ap Tva_list) (r int32) { @@ -140848,7 +140848,7 @@ func Xvdprintf(tls *TLS, fd int32, fmt uintptr, ap Tva_list) (r int32) { bp := tls.Alloc(240) defer tls.Free(240) var _ /* f at bp+0 */ TFILE - *(*TFILE)(unsafe.Pointer(bp)) = TFILE{ + **(**TFILE)(__ccgo_up(bp)) = TFILE{ Fwrite: __ccgo_fp(X__stdio_write), Fbuf: fmt, Ffd: fd, @@ -141015,41 +141015,41 @@ type Targ = struct { func _pop_arg(tls *TLS, arg uintptr, type1 int32, ap uintptr) { switch type1 { case int32(_PTR): - *(*uintptr)(unsafe.Pointer(arg)) = VaUintptr(&*(*Tva_list)(unsafe.Pointer(ap))) + *(*uintptr)(unsafe.Pointer(arg)) = VaUintptr(&**(**Tva_list)(__ccgo_up(ap))) case int32(_INT): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_UINT): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint32(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint32(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_LONG): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_ULONG): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&**(**Tva_list)(__ccgo_up(ap))) case int32(_ULLONG): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_SHORT): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt16(int16(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt16(int16(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_USHORT): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint16FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint16FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_CHAR): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt8(int8(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt8(int8(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_UCHAR): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint8FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint8FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_LLONG): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_SIZET): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&**(**Tva_list)(__ccgo_up(ap))) case int32(_IMAX): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_UMAX): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&**(**Tva_list)(__ccgo_up(ap))) case int32(_PDIFF): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_UIPTR): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUintptr(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUintptr(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_DBL): - *(*float64)(unsafe.Pointer(arg)) = float64(VaFloat64(&*(*Tva_list)(unsafe.Pointer(ap)))) + *(*float64)(unsafe.Pointer(arg)) = float64(VaFloat64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_LDBL): - *(*float64)(unsafe.Pointer(arg)) = VaFloat64(&*(*Tva_list)(unsafe.Pointer(ap))) + *(*float64)(unsafe.Pointer(arg)) = VaFloat64(&**(**Tva_list)(__ccgo_up(ap))) } } @@ -141099,7 +141099,7 @@ func _fmt_x(tls *TLS, x Tuintmax_t, s uintptr, lower int32) (r uintptr) { } s = s - 1 v2 = s - *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(Int32FromUint8(_xdigits1[x&uint64(15)]) | lower) + **(**uint8)(__ccgo_up(v2)) = Uint8FromInt32(Int32FromUint8(_xdigits1[x&uint64(15)]) | lower) goto _1 _1: ; @@ -141117,7 +141117,7 @@ func _fmt_o(tls *TLS, x Tuintmax_t, s uintptr) (r uintptr) { } s = s - 1 v2 = s - *(*uint8)(unsafe.Pointer(v2)) = uint8(uint64('0') + x&uint64(7)) + **(**uint8)(__ccgo_up(v2)) = uint8(uint64('0') + x&uint64(7)) goto _1 _1: ; @@ -141136,7 +141136,7 @@ func _fmt_u(tls *TLS, x Tuintmax_t, s uintptr) (r uintptr) { } s = s - 1 v2 = s - *(*uint8)(unsafe.Pointer(v2)) = uint8(uint64('0') + x%uint64(10)) + **(**uint8)(__ccgo_up(v2)) = uint8(uint64('0') + x%uint64(10)) goto _1 _1: ; @@ -141149,7 +141149,7 @@ func _fmt_u(tls *TLS, x Tuintmax_t, s uintptr) (r uintptr) { } s = s - 1 v2 = s - *(*uint8)(unsafe.Pointer(v2)) = uint8(uint64('0') + y%uint64(10)) + **(**uint8)(__ccgo_up(v2)) = uint8(uint64('0') + y%uint64(10)) goto _3 _3: ; @@ -141184,7 +141184,7 @@ func _fmt_fp(tls *TLS, f uintptr, y float64, w int32, p int32, fl int32, t int32 var _ /* e2 at bp+512 */ int32 var _ /* ebuf0 at bp+538 */ [12]uint8 _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, b, carry, carry1, d, e, ebuf, estr, i, j, l, need, pl, prefix, r, re, rm, round, round1, s, s1, s2, s3, s4, sh, sh1, small, x, x1, x2, z, v1, v36, v37, v38, v5, v6, v7 - *(*int32)(unsafe.Pointer(bp + 512)) = 0 + **(**int32)(__ccgo_up(bp + 512)) = 0 prefix = __ccgo_ts + 1628 ebuf = bp + 538 + uintptr(Uint64FromInt32(3)*Uint64FromInt64(4)) pl = int32(1) @@ -141238,7 +141238,7 @@ _4: } y = float64(Xfrexpl(tls, y, bp+512) * Float64FromInt32(2)) if y != 0 { - *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) - 1 + **(**int32)(__ccgo_up(bp + 512)) = **(**int32)(__ccgo_up(bp + 512)) - 1 } if t|int32(32) == int32('a') { round = Float64FromFloat64(8) @@ -141261,7 +141261,7 @@ _4: } round = round * Float64FromInt32(16) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(prefix))) == int32('-') { + if Int32FromUint8(**(**uint8)(__ccgo_up(prefix))) == int32('-') { y = -y y = y - round y = y + round @@ -141271,39 +141271,39 @@ _4: y = y - round } } - if *(*int32)(unsafe.Pointer(bp + 512)) < 0 { - v7 = -*(*int32)(unsafe.Pointer(bp + 512)) + if **(**int32)(__ccgo_up(bp + 512)) < 0 { + v7 = -**(**int32)(__ccgo_up(bp + 512)) } else { - v7 = *(*int32)(unsafe.Pointer(bp + 512)) + v7 = **(**int32)(__ccgo_up(bp + 512)) } estr = _fmt_u(tls, Uint64FromInt32(v7), ebuf) if estr == ebuf { estr = estr - 1 v5 = estr - *(*uint8)(unsafe.Pointer(v5)) = uint8('0') + **(**uint8)(__ccgo_up(v5)) = uint8('0') } estr = estr - 1 v5 = estr - if *(*int32)(unsafe.Pointer(bp + 512)) < 0 { + if **(**int32)(__ccgo_up(bp + 512)) < 0 { v7 = int32('-') } else { v7 = int32('+') } - *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(v7) + **(**uint8)(__ccgo_up(v5)) = Uint8FromInt32(v7) estr = estr - 1 v5 = estr - *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(t + (Int32FromUint8('p') - Int32FromUint8('a'))) + **(**uint8)(__ccgo_up(v5)) = Uint8FromInt32(t + (Int32FromUint8('p') - Int32FromUint8('a'))) s = bp + 516 for cond := true; cond; cond = y != 0 { x = int32(y) v5 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(Int32FromUint8(_xdigits1[x]) | t&int32(32)) + **(**uint8)(__ccgo_up(v5)) = Uint8FromInt32(Int32FromUint8(_xdigits1[x]) | t&int32(32)) y = float64(Float64FromInt32(16) * (y - float64(x))) if int64(s)-t__predefined_ptrdiff_t(bp+516) == int64(1) && (y != 0 || p > 0 || Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0) { v5 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v5)) = uint8('.') + **(**uint8)(__ccgo_up(v5)) = uint8('.') } } if int64(p) > int64(Int32FromInt32(INT_MAX)-Int32FromInt32(2))-(int64(ebuf)-int64(estr))-int64(pl) { @@ -141333,9 +141333,9 @@ _4: } if y != 0 { y = y * Float64FromFloat64(2.68435456e+08) - *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) - int32(28) + **(**int32)(__ccgo_up(bp + 512)) = **(**int32)(__ccgo_up(bp + 512)) - int32(28) } - if *(*int32)(unsafe.Pointer(bp + 512)) < 0 { + if **(**int32)(__ccgo_up(bp + 512)) < 0 { v6 = bp + 8 z = v6 v5 = v6 @@ -141349,17 +141349,17 @@ _4: a = v5 } for cond := true; cond; cond = y != 0 { - *(*Tuint32_t)(unsafe.Pointer(z)) = uint32(y) + **(**Tuint32_t)(__ccgo_up(z)) = uint32(y) v5 = z z += 4 - y = float64(Float64FromInt32(1000000000) * (y - float64(*(*Tuint32_t)(unsafe.Pointer(v5))))) + y = float64(Float64FromInt32(1000000000) * (y - float64(**(**Tuint32_t)(__ccgo_up(v5))))) } - for *(*int32)(unsafe.Pointer(bp + 512)) > 0 { + for **(**int32)(__ccgo_up(bp + 512)) > 0 { carry = uint32(0) - if int32(29) < *(*int32)(unsafe.Pointer(bp + 512)) { + if int32(29) < **(**int32)(__ccgo_up(bp + 512)) { v7 = int32(29) } else { - v7 = *(*int32)(unsafe.Pointer(bp + 512)) + v7 = **(**int32)(__ccgo_up(bp + 512)) } sh = v7 d = z - uintptr(1)*4 @@ -141367,8 +141367,8 @@ _4: if !(d >= a) { break } - x1 = uint64(*(*Tuint32_t)(unsafe.Pointer(d)))< a && !(*(*Tuint32_t)(unsafe.Pointer(z + uintptr(-Int32FromInt32(1))*4)) != 0) { + for z > a && !(**(**Tuint32_t)(__ccgo_up(z + uintptr(-Int32FromInt32(1))*4)) != 0) { z -= 4 } - *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) - sh + **(**int32)(__ccgo_up(bp + 512)) = **(**int32)(__ccgo_up(bp + 512)) - sh } - for *(*int32)(unsafe.Pointer(bp + 512)) < 0 { + for **(**int32)(__ccgo_up(bp + 512)) < 0 { carry1 = uint32(0) - if int32(9) < -*(*int32)(unsafe.Pointer(bp + 512)) { + if int32(9) < -**(**int32)(__ccgo_up(bp + 512)) { v7 = int32(9) } else { - v7 = -*(*int32)(unsafe.Pointer(bp + 512)) + v7 = -**(**int32)(__ccgo_up(bp + 512)) } sh1 = v7 need = Int32FromUint32(uint32(1) + (Uint32FromInt32(p)+Uint32FromInt32(LDBL_MANT_DIG)/Uint32FromUint32(3)+uint32(8))/uint32(9)) @@ -141399,21 +141399,21 @@ _4: if !(d < z) { break } - rm = *(*Tuint32_t)(unsafe.Pointer(d)) & Uint32FromInt32(int32(1)<>sh1 + carry1 + rm = **(**Tuint32_t)(__ccgo_up(d)) & Uint32FromInt32(int32(1)<>sh1 + carry1 carry1 = Uint32FromInt32(Int32FromInt32(1000000000)>>sh1) * rm goto _26 _26: ; d += 4 } - if !(*(*Tuint32_t)(unsafe.Pointer(a)) != 0) { + if !(**(**Tuint32_t)(__ccgo_up(a)) != 0) { a += 4 } if carry1 != 0 { v5 = z z += 4 - *(*Tuint32_t)(unsafe.Pointer(v5)) = carry1 + **(**Tuint32_t)(__ccgo_up(v5)) = carry1 } /* Avoid (slow!) computation past requested precision */ if t|int32(32) == int32('f') { @@ -141425,13 +141425,13 @@ _4: if (int64(z)-int64(b))/4 > int64(need) { z = b + uintptr(need)*4 } - *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) + sh1 + **(**int32)(__ccgo_up(bp + 512)) = **(**int32)(__ccgo_up(bp + 512)) + sh1 } if a < z { i = int32(10) e = int32(Int64FromInt32(9) * ((int64(r) - int64(a)) / 4)) for { - if !(*(*Tuint32_t)(unsafe.Pointer(a)) >= Uint32FromInt32(i)) { + if !(**(**Tuint32_t)(__ccgo_up(a)) >= Uint32FromInt32(i)) { break } goto _29 @@ -141462,11 +141462,11 @@ _4: i = i * int32(10) j = j + 1 } - x2 = *(*Tuint32_t)(unsafe.Pointer(d)) % Uint32FromInt32(i) + x2 = **(**Tuint32_t)(__ccgo_up(d)) % Uint32FromInt32(i) /* Are there any significant digits past j? */ if x2 != 0 || d+uintptr(1)*4 != z { round1 = Float64FromInt32(2) / Float64FromFloat64(2.22044604925031308085e-16) - if *(*Tuint32_t)(unsafe.Pointer(d))/Uint32FromInt32(i)&uint32(1) != 0 || i == int32(1000000000) && d > a && *(*Tuint32_t)(unsafe.Pointer(d + uintptr(-Int32FromInt32(1))*4))&uint32(1) != 0 { + if **(**Tuint32_t)(__ccgo_up(d))/Uint32FromInt32(i)&uint32(1) != 0 || i == int32(1000000000) && d > a && **(**Tuint32_t)(__ccgo_up(d + uintptr(-Int32FromInt32(1))*4))&uint32(1) != 0 { round1 = round1 + Float64FromInt32(2) } if x2 < Uint32FromInt32(i/int32(2)) { @@ -141478,29 +141478,29 @@ _4: small = Float64FromFloat64(1.5) } } - if pl != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(prefix))) == int32('-') { + if pl != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(prefix))) == int32('-') { round1 = round1 * float64(-Int32FromInt32(1)) small = small * float64(-Int32FromInt32(1)) } - *(*Tuint32_t)(unsafe.Pointer(d)) -= x2 + **(**Tuint32_t)(__ccgo_up(d)) -= x2 /* Decide whether to round by probing round+small */ if round1+small != round1 { - *(*Tuint32_t)(unsafe.Pointer(d)) = *(*Tuint32_t)(unsafe.Pointer(d)) + Uint32FromInt32(i) - for *(*Tuint32_t)(unsafe.Pointer(d)) > uint32(999999999) { + **(**Tuint32_t)(__ccgo_up(d)) = **(**Tuint32_t)(__ccgo_up(d)) + Uint32FromInt32(i) + for **(**Tuint32_t)(__ccgo_up(d)) > uint32(999999999) { v5 = d d -= 4 - *(*Tuint32_t)(unsafe.Pointer(v5)) = uint32(0) + **(**Tuint32_t)(__ccgo_up(v5)) = uint32(0) if d < a { a -= 4 v5 = a - *(*Tuint32_t)(unsafe.Pointer(v5)) = uint32(0) + **(**Tuint32_t)(__ccgo_up(v5)) = uint32(0) } - *(*Tuint32_t)(unsafe.Pointer(d)) = *(*Tuint32_t)(unsafe.Pointer(d)) + 1 + **(**Tuint32_t)(__ccgo_up(d)) = **(**Tuint32_t)(__ccgo_up(d)) + 1 } i = int32(10) e = int32(Int64FromInt32(9) * ((int64(r) - int64(a)) / 4)) for { - if !(*(*Tuint32_t)(unsafe.Pointer(a)) >= Uint32FromInt32(i)) { + if !(**(**Tuint32_t)(__ccgo_up(a)) >= Uint32FromInt32(i)) { break } goto _33 @@ -141516,7 +141516,7 @@ _4: } } for { - if !(z > a && !(*(*Tuint32_t)(unsafe.Pointer(z + uintptr(-Int32FromInt32(1))*4)) != 0)) { + if !(z > a && !(**(**Tuint32_t)(__ccgo_up(z + uintptr(-Int32FromInt32(1))*4)) != 0)) { break } goto _34 @@ -141537,11 +141537,11 @@ _4: } if !(Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0) { /* Count trailing zeros in last place */ - if z > a && *(*Tuint32_t)(unsafe.Pointer(z + uintptr(-Int32FromInt32(1))*4)) != 0 { + if z > a && **(**Tuint32_t)(__ccgo_up(z + uintptr(-Int32FromInt32(1))*4)) != 0 { i = int32(10) j = Int32FromInt32(0) for { - if !(*(*Tuint32_t)(unsafe.Pointer(z + uintptr(-Int32FromInt32(1))*4))%Uint32FromInt32(i) == uint32(0)) { + if !(**(**Tuint32_t)(__ccgo_up(z + uintptr(-Int32FromInt32(1))*4))%Uint32FromInt32(i) == uint32(0)) { break } goto _35 @@ -141611,7 +141611,7 @@ _4: for int64(ebuf)-int64(estr) < int64(2) { estr = estr - 1 v5 = estr - *(*uint8)(unsafe.Pointer(v5)) = uint8('0') + **(**uint8)(__ccgo_up(v5)) = uint8('0') } estr = estr - 1 v5 = estr @@ -141620,10 +141620,10 @@ _4: } else { v7 = int32('+') } - *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(v7) + **(**uint8)(__ccgo_up(v5)) = Uint8FromInt32(v7) estr = estr - 1 v5 = estr - *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(t) + **(**uint8)(__ccgo_up(v5)) = Uint8FromInt32(t) if int64(ebuf)-int64(estr) > int64(int32(INT_MAX)-l) { return -int32(1) } @@ -141644,18 +141644,18 @@ _4: if !(d <= r) { break } - s2 = _fmt_u(tls, uint64(*(*Tuint32_t)(unsafe.Pointer(d))), bp+516+uintptr(9)) + s2 = _fmt_u(tls, uint64(**(**Tuint32_t)(__ccgo_up(d))), bp+516+uintptr(9)) if d != a { for s2 > bp+516 { s2 = s2 - 1 v5 = s2 - *(*uint8)(unsafe.Pointer(v5)) = uint8('0') + **(**uint8)(__ccgo_up(v5)) = uint8('0') } } else { if s2 == bp+516+uintptr(9) { s2 = s2 - 1 v5 = s2 - *(*uint8)(unsafe.Pointer(v5)) = uint8('0') + **(**uint8)(__ccgo_up(v5)) = uint8('0') } } _out(tls, f, s2, Uint64FromInt64(int64(bp+516+uintptr(9))-int64(s2))) @@ -141671,11 +141671,11 @@ _4: if !(d < z && p > 0) { break } - s3 = _fmt_u(tls, uint64(*(*Tuint32_t)(unsafe.Pointer(d))), bp+516+uintptr(9)) + s3 = _fmt_u(tls, uint64(**(**Tuint32_t)(__ccgo_up(d))), bp+516+uintptr(9)) for s3 > bp+516 { s3 = s3 - 1 v5 = s3 - *(*uint8)(unsafe.Pointer(v5)) = uint8('0') + **(**uint8)(__ccgo_up(v5)) = uint8('0') } if int32(9) < p { v7 = int32(9) @@ -141699,17 +141699,17 @@ _4: if !(d < z && p >= 0) { break } - s4 = _fmt_u(tls, uint64(*(*Tuint32_t)(unsafe.Pointer(d))), bp+516+uintptr(9)) + s4 = _fmt_u(tls, uint64(**(**Tuint32_t)(__ccgo_up(d))), bp+516+uintptr(9)) if s4 == bp+516+uintptr(9) { s4 = s4 - 1 v5 = s4 - *(*uint8)(unsafe.Pointer(v5)) = uint8('0') + **(**uint8)(__ccgo_up(v5)) = uint8('0') } if d != a { for s4 > bp+516 { s4 = s4 - 1 v5 = s4 - *(*uint8)(unsafe.Pointer(v5)) = uint8('0') + **(**uint8)(__ccgo_up(v5)) = uint8('0') } } else { v5 = s4 @@ -141748,18 +141748,18 @@ func _getint(tls *TLS, s uintptr) (r int32) { _ = i i = 0 for { - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-uint32('0') < uint32(10)) != 0) { break } - if Uint32FromInt32(i) > Uint32FromInt32(INT_MAX)/Uint32FromUint32(10) || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-int32('0') > int32(INT_MAX)-int32(10)*i { + if Uint32FromInt32(i) > Uint32FromInt32(INT_MAX)/Uint32FromUint32(10) || Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-int32('0') > int32(INT_MAX)-int32(10)*i { i = -int32(1) } else { - i = int32(10)*i + (Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s))))) - int32('0')) + i = int32(10)*i + (Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(s))))) - int32('0')) } goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s)) = *(*uintptr)(unsafe.Pointer(s)) + 1 + **(**uintptr)(__ccgo_up(s)) = **(**uintptr)(__ccgo_up(s)) + 1 } return i } @@ -141780,7 +141780,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, var _ /* s at bp+0 */ uintptr var _ /* wc at bp+40 */ [2]Twchar_t _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argpos, cnt, fl, i, l, l10n, p, pl, prefix, ps, st, t, w, ws, xp, z, v31, v34, v45, v5, v6, v8 - *(*uintptr)(unsafe.Pointer(bp)) = fmt + **(**uintptr)(__ccgo_up(bp)) = fmt l10n = uint32(0) cnt = 0 l = 0 @@ -141793,30 +141793,30 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } /* Update output count, end loop when fmt is exhausted */ cnt = cnt + l - if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) != 0) { + if !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))) != 0) { break } /* Handle literal text and %% format specifiers */ - a = *(*uintptr)(unsafe.Pointer(bp)) + a = **(**uintptr)(__ccgo_up(bp)) for { - if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32('%')) { + if !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) != int32('%')) { break } goto _2 _2: ; - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 } - z = *(*uintptr)(unsafe.Pointer(bp)) + z = **(**uintptr)(__ccgo_up(bp)) for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('%') && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1))) == int32('%')) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) == int32('%') && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1))) == int32('%')) { break } goto _3 _3: ; z = z + 1 - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(2) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + uintptr(2) } if int64(z)-int64(a) > int64(int32(INT_MAX)-cnt) { goto overflow @@ -141828,46 +141828,46 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if l != 0 { goto _1 } - if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2))) == int32('$') { + if BoolInt32(uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 2))) == int32('$') { l10n = uint32(1) - argpos = Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1))) - int32('0') - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(3) + argpos = Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1))) - int32('0') + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + uintptr(3) } else { argpos = -int32(1) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 } /* Read modifier flags */ fl = uint32(0) for { - if !(uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-uint32(' ') < uint32(32) && (Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('0')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('\'')-Int32FromUint8(' ')))&(uint32(1)<<(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-int32(' '))) != 0) { + if !(uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))))-uint32(' ') < uint32(32) && (Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('0')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('\'')-Int32FromUint8(' ')))&(uint32(1)<<(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))))-int32(' '))) != 0) { break } - fl = fl | uint32(1)<<(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-int32(' ')) + fl = fl | uint32(1)<<(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))))-int32(' ')) goto _4 _4: ; - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 } /* Read field width */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('*') { - if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2))) == int32('$') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) == int32('*') { + if BoolInt32(uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 2))) == int32('$') { l10n = uint32(1) if !(f != 0) { - *(*int32)(unsafe.Pointer(nl_type + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))-int32('0'))*4)) = int32(_INT) + **(**int32)(__ccgo_up(nl_type + uintptr(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1)))-int32('0'))*4)) = int32(_INT) w = Int32FromInt32(0) } else { - w = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))-int32('0'))*8))) + w = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1)))-int32('0'))*8))) } - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(3) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + uintptr(3) } else { if !(l10n != 0) { if f != 0 { - v5 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) + v5 = VaInt32(&**(**Tva_list)(__ccgo_up(ap))) } else { v5 = 0 } w = v5 - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 } else { goto inval } @@ -141884,32 +141884,32 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } } /* Read precision */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('.') && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1))) == int32('*') { - if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 3))) == int32('$') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) == int32('.') && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1))) == int32('*') { + if BoolInt32(uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 2)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 3))) == int32('$') { if !(f != 0) { - *(*int32)(unsafe.Pointer(nl_type + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2)))-int32('0'))*4)) = int32(_INT) + **(**int32)(__ccgo_up(nl_type + uintptr(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 2)))-int32('0'))*4)) = int32(_INT) p = Int32FromInt32(0) } else { - p = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2)))-int32('0'))*8))) + p = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 2)))-int32('0'))*8))) } - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(4) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + uintptr(4) } else { if !(l10n != 0) { if f != 0 { - v5 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) + v5 = VaInt32(&**(**Tva_list)(__ccgo_up(ap))) } else { v5 = 0 } p = v5 - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(2) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + uintptr(2) } else { goto inval } } xp = BoolInt32(p >= 0) } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('.') { - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) == int32('.') { + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 p = _getint(tls, bp) xp = int32(1) } else { @@ -141920,13 +141920,13 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, /* Format specifier state machine */ st = uint32(0) for cond := true; cond; cond = st-uint32(1) < uint32(_STOP) { - if uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-uint32('A') > Uint32FromInt32(Int32FromUint8('z')-Int32FromUint8('A')) { + if uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))))-uint32('A') > Uint32FromInt32(Int32FromUint8('z')-Int32FromUint8('A')) { goto inval } ps = st - v8 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - st = uint32(*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_states)) + uintptr(st)*58 + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(v8)))-int32('A'))))) + v8 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + st = uint32(**(**uint8)(__ccgo_up(uintptr(unsafe.Pointer(&_states)) + uintptr(st)*58 + uintptr(Int32FromUint8(**(**uint8)(__ccgo_up(v8)))-int32('A'))))) } if !(st != 0) { goto inval @@ -141939,9 +141939,9 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } else { if argpos >= 0 { if !(f != 0) { - *(*int32)(unsafe.Pointer(nl_type + uintptr(argpos)*4)) = Int32FromUint32(st) + **(**int32)(__ccgo_up(nl_type + uintptr(argpos)*4)) = Int32FromUint32(st) } else { - *(*Targ)(unsafe.Pointer(bp + 8)) = *(*Targ)(unsafe.Pointer(nl_arg + uintptr(argpos)*8)) + **(**Targ)(__ccgo_up(bp + 8)) = **(**Targ)(__ccgo_up(nl_arg + uintptr(argpos)*8)) } } else { if f != 0 { @@ -141961,7 +141961,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, z = bp + 16 + uintptr(24) prefix = __ccgo_ts + 1659 pl = 0 - t = Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + uintptr(-Int32FromInt32(1))))) + t = Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + uintptr(-Int32FromInt32(1))))) /* Transform ls,lc -> S,C */ if ps != 0 && t&int32(15) == int32(3) { t = t & ^Int32FromInt32(32) @@ -142019,19 +142019,19 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, ; switch ps { case uint32(_BARE): - *(*int32)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) = cnt + **(**int32)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 8)))) = cnt case uint32(_LPRE): - *(*int64)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) = int64(cnt) + **(**int64)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 8)))) = int64(cnt) case uint32(_LLPRE): - *(*int64)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) = int64(cnt) + **(**int64)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 8)))) = int64(cnt) case uint32(_HPRE): - *(*uint16)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) = Uint16FromInt32(cnt) + **(**uint16)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 8)))) = Uint16FromInt32(cnt) case uint32(_HHPRE): - *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) = Uint8FromInt32(cnt) + **(**uint8)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 8)))) = Uint8FromInt32(cnt) case uint32(_ZTPRE): - *(*Tsize_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) = Uint64FromInt32(cnt) + **(**Tsize_t)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 8)))) = Uint64FromInt32(cnt) case uint32(_JPRE): - *(*Tuintmax_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) = Uint64FromInt32(cnt) + **(**Tuintmax_t)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 8)))) = Uint64FromInt32(cnt) break } goto _1 @@ -142117,7 +142117,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, p = v5 v8 = z - uintptr(v5) a = v8 - *(*uint8)(unsafe.Pointer(v8)) = uint8(*(*Tuintmax_t)(unsafe.Pointer(bp + 8))) + **(**uint8)(__ccgo_up(v8)) = uint8(*(*Tuintmax_t)(unsafe.Pointer(bp + 8))) fl = fl & ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) goto _30 _19: @@ -142125,7 +142125,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if !(int32(1) != 0) { goto _37 } - a = Xstrerror(tls, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) + a = Xstrerror(tls, **(**int32)(__ccgo_up(X__errno_location(tls)))) goto _38 _37: ; @@ -142145,7 +142145,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, v5 = p } z = a + uintptr(Xstrnlen(tls, a, Uint64FromInt32(v5))) - if p < 0 && *(*uint8)(unsafe.Pointer(z)) != 0 { + if p < 0 && **(**uint8)(__ccgo_up(z)) != 0 { goto overflow } p = int32(int64(z) - int64(a)) @@ -142156,8 +142156,8 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if !(*(*Tuintmax_t)(unsafe.Pointer(bp + 8)) != 0) { goto narrow_c } - (*(*[2]Twchar_t)(unsafe.Pointer(bp + 40)))[0] = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(bp + 8))) - (*(*[2]Twchar_t)(unsafe.Pointer(bp + 40)))[int32(1)] = 0 + (**(**[2]Twchar_t)(__ccgo_up(bp + 40)))[0] = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(bp + 8))) + (**(**[2]Twchar_t)(__ccgo_up(bp + 40)))[int32(1)] = 0 *(*uintptr)(unsafe.Pointer(bp + 8)) = bp + 40 p = -int32(1) _21: @@ -142167,10 +142167,10 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, l = v5 i = Uint64FromInt32(v5) for { - if v45 = i < Uint64FromInt32(p) && *(*Twchar_t)(unsafe.Pointer(ws)) != 0; v45 { + if v45 = i < Uint64FromInt32(p) && **(**Twchar_t)(__ccgo_up(ws)) != 0; v45 { v8 = ws ws += 4 - v6 = Xwctomb(tls, bp+48, *(*Twchar_t)(unsafe.Pointer(v8))) + v6 = Xwctomb(tls, bp+48, **(**Twchar_t)(__ccgo_up(v8))) l = v6 } if !(v45 && v6 >= 0 && Uint64FromInt32(l) <= Uint64FromInt32(p)-i) { @@ -142192,10 +142192,10 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, ws = *(*uintptr)(unsafe.Pointer(bp + 8)) i = uint64(0) for { - if v45 = i < uint64(0+Uint32FromInt32(p)) && *(*Twchar_t)(unsafe.Pointer(ws)) != 0; v45 { + if v45 = i < uint64(0+Uint32FromInt32(p)) && **(**Twchar_t)(__ccgo_up(ws)) != 0; v45 { v8 = ws ws += 4 - v5 = Xwctomb(tls, bp+48, *(*Twchar_t)(unsafe.Pointer(v8))) + v5 = Xwctomb(tls, bp+48, **(**Twchar_t)(__ccgo_up(v8))) l = v5 } if !(v45 && i+Uint64FromInt32(v5) <= Uint64FromInt32(p)) { @@ -142271,17 +142271,17 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } i = uint64(1) for { - if !(i <= uint64(NL_ARGMAX) && *(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)) != 0) { + if !(i <= uint64(NL_ARGMAX) && **(**int32)(__ccgo_up(nl_type + uintptr(i)*4)) != 0) { break } - _pop_arg(tls, nl_arg+uintptr(i)*8, *(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)), ap) + _pop_arg(tls, nl_arg+uintptr(i)*8, **(**int32)(__ccgo_up(nl_type + uintptr(i)*4)), ap) goto _51 _51: ; i = i + 1 } for { - if !(i <= uint64(NL_ARGMAX) && !(*(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)) != 0)) { + if !(i <= uint64(NL_ARGMAX) && !(**(**int32)(__ccgo_up(nl_type + uintptr(i)*4)) != 0)) { break } goto _52 @@ -142296,12 +142296,12 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto inval inval: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) goto overflow overflow: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return -int32(1) } @@ -142319,12 +142319,12 @@ func Xvfprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { var _ /* nl_arg at bp+48 */ [10]Targ var _ /* nl_type at bp+8 */ [10]int32 _, _, _, _, _, _, _ = __need_unlock, olderr, ret, saved_buf, v1, v2, v3 - *(*[10]int32)(unsafe.Pointer(bp + 8)) = [10]int32{} + **(**[10]int32)(__ccgo_up(bp + 8)) = [10]int32{} saved_buf = uintptr(0) /* the copy allows passing va_list* even if va_list is an array */ - *(*Tva_list)(unsafe.Pointer(bp)) = ap + **(**Tva_list)(__ccgo_up(bp)) = ap if _printf_core(tls, uintptr(0), fmt, bp, bp+48, bp+8) < 0 { - _ = *(*Tva_list)(unsafe.Pointer(bp)) + _ = **(**Tva_list)(__ccgo_up(bp)) return -int32(1) } if AtomicLoadPInt32(f+140) >= 0 { @@ -142334,7 +142334,7 @@ func Xvfprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } __need_unlock = v1 olderr = Int32FromUint32((*TFILE)(unsafe.Pointer(f)).Fflags & uint32(F_ERR)) - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_ERR)) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^Int32FromInt32(F_ERR)) if !((*TFILE)(unsafe.Pointer(f)).Fbuf_size != 0) { saved_buf = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Fbuf = bp + 128 @@ -142366,11 +142366,11 @@ func Xvfprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_ERR) != 0 { ret = -int32(1) } - *(*uint32)(unsafe.Pointer(f)) |= Uint32FromInt32(olderr) + **(**uint32)(__ccgo_up(f)) |= Uint32FromInt32(olderr) if __need_unlock != 0 { ___unlockfile(tls, f) } - _ = *(*Tva_list)(unsafe.Pointer(bp)) + _ = **(**Tva_list)(__ccgo_up(bp)) return ret } @@ -142387,15 +142387,15 @@ func _store_int(tls *TLS, dest uintptr, size int32, i uint64) { } switch size { case -int32(2): - *(*uint8)(unsafe.Pointer(dest)) = uint8(i) + **(**uint8)(__ccgo_up(dest)) = uint8(i) case -int32(1): - *(*int16)(unsafe.Pointer(dest)) = Int16FromUint64(i) + **(**int16)(__ccgo_up(dest)) = Int16FromUint64(i) case SIZE_def: - *(*int32)(unsafe.Pointer(dest)) = Int32FromUint64(i) + **(**int32)(__ccgo_up(dest)) = Int32FromUint64(i) case int32(SIZE_l): - *(*int64)(unsafe.Pointer(dest)) = Int64FromUint64(i) + **(**int64)(__ccgo_up(dest)) = Int64FromUint64(i) case int32(SIZE_ll): - *(*int64)(unsafe.Pointer(dest)) = Int64FromUint64(i) + **(**int64)(__ccgo_up(dest)) = Int64FromUint64(i) break } } @@ -142458,17 +142458,17 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } p = fmt for { - if !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if !(**(**uint8)(__ccgo_up(p)) != 0) { break } alloc = 0 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v3 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _5 _5: if v3 != 0 { for { - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) v6 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _8 _8: @@ -142483,7 +142483,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v1 = X__shgetc(tls, f) } @@ -142501,16 +142501,16 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { pos = pos + ((*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf))) goto _2 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32('%') || Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('%') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) != int32('%') || Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) == int32('%') { X__shlim(tls, f, int64(Int32FromInt32(0))) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('%') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('%') { p = p + 1 for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v3 = X__shgetc(tls, f) } @@ -142529,13 +142529,13 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v1 = X__shgetc(tls, f) } c = v1 } - if c != Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) { + if c != Int32FromUint8(**(**uint8)(__ccgo_up(p))) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } @@ -142548,12 +142548,12 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { goto _2 } p = p + 1 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('*') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('*') { dest = uintptr(0) p = p + 1 } else { - if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('$') { - dest = _arg_n(tls, ap, Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))-int32('0'))) + if BoolInt32(uint32(**(**uint8)(__ccgo_up(p)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) == int32('$') { + dest = _arg_n(tls, ap, Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(p)))-int32('0'))) p = p + uintptr(2) } else { dest = VaUintptr(&ap) @@ -142561,16 +142561,16 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } width = 0 for { - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p)))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(p)))-uint32('0') < uint32(10)) != 0) { break } - width = int32(10)*width + Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - int32('0') + width = int32(10)*width + Int32FromUint8(**(**uint8)(__ccgo_up(p))) - int32('0') goto _25 _25: ; p = p + 1 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('m') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('m') { wcs = uintptr(0) s = uintptr(0) alloc = BoolInt32(!!(dest != 0)) @@ -142581,16 +142581,16 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { size = SIZE_def v10 = p p = p + 1 - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(v10))) { case int32('h'): - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('h') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('h') { p = p + 1 size = -Int32FromInt32(2) } else { size = -int32(1) } case int32('l'): - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('l') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('l') { p = p + 1 size = Int32FromInt32(SIZE_ll) } else { @@ -142649,7 +142649,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { default: goto fmt_fail } - t = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + t = Int32FromUint8(**(**uint8)(__ccgo_up(p))) /* C or S */ if t&int32(0x2f) == int32(3) { t = t | int32(32) @@ -142673,7 +142673,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v1 = X__shgetc(tls, f) } @@ -142695,7 +142695,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v1 = X__shgetc(tls, f) } @@ -142752,58 +142752,58 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { ; if t == int32('c') || t == int32('s') { Xmemset(tls, bp+16, -int32(1), uint64(257)) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[0] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[0] = uint8(0) if t == int32('s') { - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\t')] = uint8(0) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\n')] = uint8(0) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\v')] = uint8(0) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\f')] = uint8(0) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\r')] = uint8(0) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8(' ')] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\t')] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\n')] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\v')] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\f')] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\r')] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8(' ')] = uint8(0) } } else { p = p + 1 v10 = p - if Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) == int32('^') { + if Int32FromUint8(**(**uint8)(__ccgo_up(v10))) == int32('^') { p = p + 1 invert = Int32FromInt32(1) } else { invert = 0 } Xmemset(tls, bp+16, invert, uint64(257)) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[0] = uint8(0) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') { + (**(**[257]uint8)(__ccgo_up(bp + 16)))[0] = uint8(0) + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('-') { p = p + 1 - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('-')] = Uint8FromInt32(Int32FromInt32(1) - invert) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('-')] = Uint8FromInt32(Int32FromInt32(1) - invert) } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32(']') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32(']') { p = p + 1 - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8(']')] = Uint8FromInt32(Int32FromInt32(1) - invert) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8(']')] = Uint8FromInt32(Int32FromInt32(1) - invert) } } for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32(']')) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(p))) != int32(']')) { break } - if !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if !(**(**uint8)(__ccgo_up(p)) != 0) { goto fmt_fail } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') && *(*uint8)(unsafe.Pointer(p + 1)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) != int32(']') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('-') && **(**uint8)(__ccgo_up(p + 1)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) != int32(']') { v10 = p p = p + 1 - c = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10 + uintptr(-Int32FromInt32(1))))) + c = Int32FromUint8(**(**uint8)(__ccgo_up(v10 + uintptr(-Int32FromInt32(1))))) for { - if !(c < Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))) { + if !(c < Int32FromUint8(**(**uint8)(__ccgo_up(p)))) { break } - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[int32(1)+c] = Uint8FromInt32(int32(1) - invert) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[int32(1)+c] = Uint8FromInt32(int32(1) - invert) goto _57 _57: ; c = c + 1 } } - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[int32(1)+Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))] = Uint8FromInt32(int32(1) - invert) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[int32(1)+Int32FromUint8(**(**uint8)(__ccgo_up(p)))] = Uint8FromInt32(int32(1) - invert) goto _56 _56: ; @@ -142828,19 +142828,19 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } else { wcs = dest } - *(*Tmbstate_t)(unsafe.Pointer(bp + 8)) = Tmbstate_t{} + **(**Tmbstate_t)(__ccgo_up(bp + 8)) = Tmbstate_t{} for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v3 = X__shgetc(tls, f) } v1 = v3 c = v1 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { + if !((**(**[257]uint8)(__ccgo_up(bp + 16)))[v1+int32(1)] != 0) { break } *(*uint8)(unsafe.Pointer(bp)) = Uint8FromInt32(c) @@ -142853,7 +142853,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if wcs != 0 { v64 = i i = i + 1 - *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(v64)*4)) = *(*Twchar_t)(unsafe.Pointer(bp + 276)) + **(**Twchar_t)(__ccgo_up(wcs + uintptr(v64)*4)) = **(**Twchar_t)(__ccgo_up(bp + 276)) } if alloc != 0 && i == k { k = k + (k + uint64(1)) @@ -142878,18 +142878,18 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v3 = X__shgetc(tls, f) } v1 = v3 c = v1 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { + if !((**(**[257]uint8)(__ccgo_up(bp + 16)))[v1+int32(1)] != 0) { break } v64 = i i = i + 1 - *(*uint8)(unsafe.Pointer(s + uintptr(v64))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + uintptr(v64))) = Uint8FromInt32(c) if i == k { k = k + (k + uint64(1)) tmp1 = Xrealloc(tls, s, k) @@ -142908,18 +142908,18 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v17 = f + 8 v11 = *(*uintptr)(unsafe.Pointer(v17)) *(*uintptr)(unsafe.Pointer(v17)) = *(*uintptr)(unsafe.Pointer(v17)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v11))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v11))) } else { v3 = X__shgetc(tls, f) } v1 = v3 c = v1 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { + if !((**(**[257]uint8)(__ccgo_up(bp + 16)))[v1+int32(1)] != 0) { break } v64 = i i = i + 1 - *(*uint8)(unsafe.Pointer(s + uintptr(v64))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + uintptr(v64))) = Uint8FromInt32(c) } } else { for { @@ -142927,13 +142927,13 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v3 = X__shgetc(tls, f) } v1 = v3 c = v1 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { + if !((**(**[257]uint8)(__ccgo_up(bp + 16)))[v1+int32(1)] != 0) { break } } @@ -142951,17 +142951,17 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } if alloc != 0 { if size == int32(SIZE_l) { - *(*uintptr)(unsafe.Pointer(dest)) = wcs + **(**uintptr)(__ccgo_up(dest)) = wcs } else { - *(*uintptr)(unsafe.Pointer(dest)) = s + **(**uintptr)(__ccgo_up(dest)) = s } } if t != int32('c') { if wcs != 0 { - *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) = 0 + **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) = 0 } if s != 0 { - *(*uint8)(unsafe.Pointer(s + uintptr(i))) = uint8(0) + **(**uint8)(__ccgo_up(s + uintptr(i))) = uint8(0) } } goto _54 @@ -142994,7 +142994,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { goto match_fail } if t == int32('p') && dest != 0 { - *(*uintptr)(unsafe.Pointer(dest)) = uintptr(x) + **(**uintptr)(__ccgo_up(dest)) = uintptr(x) } else { _store_int(tls, dest, size, x) } @@ -143022,11 +143022,11 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if dest != 0 { switch size { case SIZE_def: - *(*float32)(unsafe.Pointer(dest)) = float32(y) + **(**float32)(__ccgo_up(dest)) = float32(y) case int32(SIZE_l): - *(*float64)(unsafe.Pointer(dest)) = y + **(**float64)(__ccgo_up(dest)) = y case int32(SIZE_L): - *(*float64)(unsafe.Pointer(dest)) = y + **(**float64)(__ccgo_up(dest)) = y break } } @@ -143192,41 +143192,41 @@ var _states1 = [8][58]uint8{ func _pop_arg1(tls *TLS, arg uintptr, type1 int32, ap uintptr) { switch type1 { case int32(_PTR): - *(*uintptr)(unsafe.Pointer(arg)) = VaUintptr(&*(*Tva_list)(unsafe.Pointer(ap))) + *(*uintptr)(unsafe.Pointer(arg)) = VaUintptr(&**(**Tva_list)(__ccgo_up(ap))) case int32(_INT): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_UINT): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint32(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint32(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_LONG): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_ULONG): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&**(**Tva_list)(__ccgo_up(ap))) case int32(_ULLONG): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_SHORT): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt16(int16(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt16(int16(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_USHORT): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint16FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint16FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_CHAR): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt8(int8(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt8(int8(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_UCHAR): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint8FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint8FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_LLONG): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_SIZET): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&**(**Tva_list)(__ccgo_up(ap))) case int32(_IMAX): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_UMAX): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&**(**Tva_list)(__ccgo_up(ap))) case int32(_PDIFF): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_UIPTR): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUintptr(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUintptr(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_DBL): - *(*float64)(unsafe.Pointer(arg)) = float64(VaFloat64(&*(*Tva_list)(unsafe.Pointer(ap)))) + *(*float64)(unsafe.Pointer(arg)) = float64(VaFloat64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_LDBL): - *(*float64)(unsafe.Pointer(arg)) = VaFloat64(&*(*Tva_list)(unsafe.Pointer(ap))) + *(*float64)(unsafe.Pointer(arg)) = VaFloat64(&**(**Tva_list)(__ccgo_up(ap))) } } @@ -143242,7 +143242,7 @@ func _out1(tls *TLS, f uintptr, s uintptr, l Tsize_t) { } v2 = s s += 4 - Xfputwc(tls, *(*Twchar_t)(unsafe.Pointer(v2)), f) + Xfputwc(tls, **(**Twchar_t)(__ccgo_up(v2)), f) } } @@ -143260,18 +143260,18 @@ func _getint1(tls *TLS, s uintptr) (r int32) { _ = i i = 0 for { - if !(BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-uint32('0') < uint32(10)) != 0) { break } - if Uint32FromInt32(i) > Uint32FromInt32(INT_MAX)/Uint32FromUint32(10) || *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s))))-int32('0') > int32(INT_MAX)-int32(10)*i { + if Uint32FromInt32(i) > Uint32FromInt32(INT_MAX)/Uint32FromUint32(10) || **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(s))))-int32('0') > int32(INT_MAX)-int32(10)*i { i = -int32(1) } else { - i = int32(10)*i + (*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))) - int32('0')) + i = int32(10)*i + (**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))) - int32('0')) } goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s)) += 4 + **(**uintptr)(__ccgo_up(s)) += 4 } return i } @@ -143302,7 +143302,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, var _ /* s at bp+8 */ uintptr var _ /* wc at bp+40 */ Twchar_t _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argpos, bs, cnt, fl, i, l, l10n, p, ps, st, t, w, xp, z, v15, v5, v6, v7, v8, v9 - *(*uintptr)(unsafe.Pointer(bp + 8)) = fmt + **(**uintptr)(__ccgo_up(bp + 8)) = fmt l10n = uint32(0) cnt = 0 l = 0 @@ -143315,30 +143315,30 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } /* Update output count, end loop when fmt is exhausted */ cnt = cnt + l - if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) != 0) { + if !(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) != 0) { break } /* Handle literal text and %% format specifiers */ - a = *(*uintptr)(unsafe.Pointer(bp + 8)) + a = **(**uintptr)(__ccgo_up(bp + 8)) for { - if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) != 0 && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) != int32('%')) { + if !(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) != 0 && **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) != int32('%')) { break } goto _2 _2: ; - *(*uintptr)(unsafe.Pointer(bp + 8)) += 4 + **(**uintptr)(__ccgo_up(bp + 8)) += 4 } - z = *(*uintptr)(unsafe.Pointer(bp + 8)) + z = **(**uintptr)(__ccgo_up(bp + 8)) for { - if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) == int32('%') && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4)) == int32('%')) { + if !(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) == int32('%') && **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 1*4)) == int32('%')) { break } goto _3 _3: ; z += 4 - *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(2)*4 + **(**uintptr)(__ccgo_up(bp + 8)) = **(**uintptr)(__ccgo_up(bp + 8)) + uintptr(2)*4 } if (int64(z)-int64(a))/4 > int64(int32(INT_MAX)-cnt) { goto overflow @@ -143350,42 +143350,42 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if l != 0 { goto _1 } - if BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4)))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4)) == int32('$') { + if BoolInt32(Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 1*4)))-uint32('0') < uint32(10)) != 0 && **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 2*4)) == int32('$') { l10n = uint32(1) - argpos = *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4)) - int32('0') - *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(3)*4 + argpos = **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 1*4)) - int32('0') + **(**uintptr)(__ccgo_up(bp + 8)) = **(**uintptr)(__ccgo_up(bp + 8)) + uintptr(3)*4 } else { argpos = -int32(1) - *(*uintptr)(unsafe.Pointer(bp + 8)) += 4 + **(**uintptr)(__ccgo_up(bp + 8)) += 4 } /* Read modifier flags */ fl = uint32(0) for { - if !(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))))-uint32(' ') < uint32(32) && (Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('0')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('\'')-Int32FromUint8(' ')))&(uint32(1)<<(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8))))-int32(' '))) != 0) { + if !(Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))))-uint32(' ') < uint32(32) && (Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('0')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('\'')-Int32FromUint8(' ')))&(uint32(1)<<(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8))))-int32(' '))) != 0) { break } - fl = fl | uint32(1)<<(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8))))-int32(' ')) + fl = fl | uint32(1)<<(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8))))-int32(' ')) goto _4 _4: ; - *(*uintptr)(unsafe.Pointer(bp + 8)) += 4 + **(**uintptr)(__ccgo_up(bp + 8)) += 4 } /* Read field width */ - if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) == int32('*') { - if BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4)))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4)) == int32('$') { + if **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) == int32('*') { + if BoolInt32(Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 1*4)))-uint32('0') < uint32(10)) != 0 && **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 2*4)) == int32('$') { l10n = uint32(1) - *(*int32)(unsafe.Pointer(nl_type + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4))-int32('0'))*4)) = int32(_INT) - w = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4))-int32('0'))*8))) - *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(3)*4 + **(**int32)(__ccgo_up(nl_type + uintptr(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 1*4))-int32('0'))*4)) = int32(_INT) + w = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 1*4))-int32('0'))*8))) + **(**uintptr)(__ccgo_up(bp + 8)) = **(**uintptr)(__ccgo_up(bp + 8)) + uintptr(3)*4 } else { if !(l10n != 0) { if f != 0 { - v5 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) + v5 = VaInt32(&**(**Tva_list)(__ccgo_up(ap))) } else { v5 = 0 } w = v5 - *(*uintptr)(unsafe.Pointer(bp + 8)) += 4 + **(**uintptr)(__ccgo_up(bp + 8)) += 4 } else { goto inval } @@ -143402,28 +143402,28 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } } /* Read precision */ - if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) == int32('.') && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4)) == int32('*') { - if BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4)))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 3*4)) == int32('$') { - *(*int32)(unsafe.Pointer(nl_type + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4))-int32('0'))*4)) = int32(_INT) - p = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4))-int32('0'))*8))) - *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(4)*4 + if **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) == int32('.') && **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 1*4)) == int32('*') { + if BoolInt32(Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 2*4)))-uint32('0') < uint32(10)) != 0 && **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 3*4)) == int32('$') { + **(**int32)(__ccgo_up(nl_type + uintptr(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 2*4))-int32('0'))*4)) = int32(_INT) + p = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 2*4))-int32('0'))*8))) + **(**uintptr)(__ccgo_up(bp + 8)) = **(**uintptr)(__ccgo_up(bp + 8)) + uintptr(4)*4 } else { if !(l10n != 0) { if f != 0 { - v5 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) + v5 = VaInt32(&**(**Tva_list)(__ccgo_up(ap))) } else { v5 = 0 } p = v5 - *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(2)*4 + **(**uintptr)(__ccgo_up(bp + 8)) = **(**uintptr)(__ccgo_up(bp + 8)) + uintptr(2)*4 } else { goto inval } } xp = BoolInt32(p >= 0) } else { - if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) == int32('.') { - *(*uintptr)(unsafe.Pointer(bp + 8)) += 4 + if **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) == int32('.') { + **(**uintptr)(__ccgo_up(bp + 8)) += 4 p = _getint1(tls, bp+8) xp = int32(1) } else { @@ -143434,13 +143434,13 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, /* Format specifier state machine */ st = uint32(0) for cond := true; cond; cond = st-uint32(1) < uint32(_STOP) { - if Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))))-uint32('A') > Uint32FromInt32(Int32FromUint8('z')-Int32FromUint8('A')) { + if Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))))-uint32('A') > Uint32FromInt32(Int32FromUint8('z')-Int32FromUint8('A')) { goto inval } ps = st - v8 = *(*uintptr)(unsafe.Pointer(bp + 8)) - *(*uintptr)(unsafe.Pointer(bp + 8)) += 4 - st = uint32(*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_states1)) + uintptr(st)*58 + uintptr(*(*Twchar_t)(unsafe.Pointer(v8))-int32('A'))))) + v8 = **(**uintptr)(__ccgo_up(bp + 8)) + **(**uintptr)(__ccgo_up(bp + 8)) += 4 + st = uint32(**(**uint8)(__ccgo_up(uintptr(unsafe.Pointer(&_states1)) + uintptr(st)*58 + uintptr(**(**Twchar_t)(__ccgo_up(v8))-int32('A'))))) } if !(st != 0) { goto inval @@ -143452,8 +143452,8 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } } else { if argpos >= 0 { - *(*int32)(unsafe.Pointer(nl_type + uintptr(argpos)*4)) = Int32FromUint32(st) - *(*Targ)(unsafe.Pointer(bp + 16)) = *(*Targ)(unsafe.Pointer(nl_arg + uintptr(argpos)*8)) + **(**int32)(__ccgo_up(nl_type + uintptr(argpos)*4)) = Int32FromUint32(st) + **(**Targ)(__ccgo_up(bp + 16)) = **(**Targ)(__ccgo_up(nl_arg + uintptr(argpos)*8)) } else { if f != 0 { _pop_arg1(tls, bp+16, Int32FromUint32(st), ap) @@ -143469,7 +143469,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_ERR) != 0 { return -int32(1) } - t = *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(-Int32FromInt32(1))*4)) + t = **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + uintptr(-Int32FromInt32(1))*4)) if ps != 0 && t&int32(15) == int32(3) { t = t & ^Int32FromInt32(32) } @@ -143477,19 +143477,19 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, case int32('n'): switch ps { case uint32(_BARE): - *(*int32)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))) = cnt + **(**int32)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 16)))) = cnt case uint32(_LPRE): - *(*int64)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))) = int64(cnt) + **(**int64)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 16)))) = int64(cnt) case uint32(_LLPRE): - *(*int64)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))) = int64(cnt) + **(**int64)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 16)))) = int64(cnt) case uint32(_HPRE): - *(*uint16)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))) = Uint16FromInt32(cnt) + **(**uint16)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 16)))) = Uint16FromInt32(cnt) case uint32(_HHPRE): - *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))) = Uint8FromInt32(cnt) + **(**uint8)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 16)))) = Uint8FromInt32(cnt) case uint32(_ZTPRE): - *(*Tsize_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))) = Uint64FromInt32(cnt) + **(**Tsize_t)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 16)))) = Uint64FromInt32(cnt) case uint32(_JPRE): - *(*Tuintmax_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))) = Uint64FromInt32(cnt) + **(**Tuintmax_t)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 16)))) = Uint64FromInt32(cnt) break } goto _1 @@ -143518,7 +143518,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, v5 = p } z = a + uintptr(Xwcsnlen(tls, a, Uint64FromInt32(v5)))*4 - if p < 0 && *(*Twchar_t)(unsafe.Pointer(z)) != 0 { + if p < 0 && **(**Twchar_t)(__ccgo_up(z)) != 0 { goto overflow } p = int32((int64(z) - int64(a)) / 4) @@ -143531,7 +143531,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, l = w goto _1 case int32('m'): - *(*uintptr)(unsafe.Pointer(bp + 16)) = Xstrerror(tls, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) + *(*uintptr)(unsafe.Pointer(bp + 16)) = Xstrerror(tls, **(**int32)(__ccgo_up(X__errno_location(tls)))) fallthrough case int32('s'): if !(*(*uintptr)(unsafe.Pointer(bp + 16)) != 0) { @@ -143563,7 +143563,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if i < 0 { return -int32(1) } - if p < 0 && *(*uint8)(unsafe.Pointer(bs)) != 0 { + if p < 0 && **(**uint8)(__ccgo_up(bs)) != 0 { goto overflow } p = l @@ -143624,17 +143624,17 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } i = int32(1) for { - if !(i <= int32(NL_ARGMAX) && *(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)) != 0) { + if !(i <= int32(NL_ARGMAX) && **(**int32)(__ccgo_up(nl_type + uintptr(i)*4)) != 0) { break } - _pop_arg1(tls, nl_arg+uintptr(i)*8, *(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)), ap) + _pop_arg1(tls, nl_arg+uintptr(i)*8, **(**int32)(__ccgo_up(nl_type + uintptr(i)*4)), ap) goto _17 _17: ; i = i + 1 } for { - if !(i <= int32(NL_ARGMAX) && !(*(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)) != 0)) { + if !(i <= int32(NL_ARGMAX) && !(**(**int32)(__ccgo_up(nl_type + uintptr(i)*4)) != 0)) { break } goto _18 @@ -143649,12 +143649,12 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto inval inval: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) goto overflow overflow: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return -int32(1) } @@ -143670,11 +143670,11 @@ func Xvfwprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { var _ /* nl_arg at bp+48 */ [10]Targ var _ /* nl_type at bp+8 */ [10]int32 _, _, _, _ = __need_unlock, olderr, ret, v1 - *(*[10]int32)(unsafe.Pointer(bp + 8)) = [10]int32{} + **(**[10]int32)(__ccgo_up(bp + 8)) = [10]int32{} /* the copy allows passing va_list* even if va_list is an array */ - *(*Tva_list)(unsafe.Pointer(bp)) = ap + **(**Tva_list)(__ccgo_up(bp)) = ap if _wprintf_core(tls, uintptr(0), fmt, bp, bp+48, bp+8) < 0 { - _ = *(*Tva_list)(unsafe.Pointer(bp)) + _ = **(**Tva_list)(__ccgo_up(bp)) return -int32(1) } if AtomicLoadPInt32(f+140) >= 0 { @@ -143685,16 +143685,16 @@ func Xvfwprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { __need_unlock = v1 Xfwide(tls, f, int32(1)) olderr = Int32FromUint32((*TFILE)(unsafe.Pointer(f)).Fflags & uint32(F_ERR)) - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_ERR)) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^Int32FromInt32(F_ERR)) ret = _wprintf_core(tls, f, fmt, bp, bp+48, bp+8) if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_ERR) != 0 { ret = -int32(1) } - *(*uint32)(unsafe.Pointer(f)) |= Uint32FromInt32(olderr) + **(**uint32)(__ccgo_up(f)) |= Uint32FromInt32(olderr) if __need_unlock != 0 { ___unlockfile(tls, f) } - _ = *(*Tva_list)(unsafe.Pointer(bp)) + _ = **(**Tva_list)(__ccgo_up(bp)) return ret } @@ -143704,15 +143704,15 @@ func _store_int1(tls *TLS, dest uintptr, size int32, i uint64) { } switch size { case -int32(2): - *(*uint8)(unsafe.Pointer(dest)) = uint8(i) + **(**uint8)(__ccgo_up(dest)) = uint8(i) case -int32(1): - *(*int16)(unsafe.Pointer(dest)) = Int16FromUint64(i) + **(**int16)(__ccgo_up(dest)) = Int16FromUint64(i) case SIZE_def: - *(*int32)(unsafe.Pointer(dest)) = Int32FromUint64(i) + **(**int32)(__ccgo_up(dest)) = Int32FromUint64(i) case int32(SIZE_l): - *(*int64)(unsafe.Pointer(dest)) = Int64FromUint64(i) + **(**int64)(__ccgo_up(dest)) = Int64FromUint64(i) case int32(SIZE_ll): - *(*int64)(unsafe.Pointer(dest)) = Int64FromUint64(i) + **(**int64)(__ccgo_up(dest)) = Int64FromUint64(i) break } } @@ -143744,13 +143744,13 @@ func _in_set(tls *TLS, set uintptr, c int32) (r int32) { var p, v3 uintptr _, _, _ = j, p, v3 p = set - if *(*Twchar_t)(unsafe.Pointer(p)) == int32('-') { + if **(**Twchar_t)(__ccgo_up(p)) == int32('-') { if c == int32('-') { return int32(1) } p += 4 } else { - if *(*Twchar_t)(unsafe.Pointer(p)) == int32(']') { + if **(**Twchar_t)(__ccgo_up(p)) == int32(']') { if c == int32(']') { return int32(1) } @@ -143758,15 +143758,15 @@ func _in_set(tls *TLS, set uintptr, c int32) (r int32) { } } for { - if !(*(*Twchar_t)(unsafe.Pointer(p)) != 0 && *(*Twchar_t)(unsafe.Pointer(p)) != int32(']')) { + if !(**(**Twchar_t)(__ccgo_up(p)) != 0 && **(**Twchar_t)(__ccgo_up(p)) != int32(']')) { break } - if *(*Twchar_t)(unsafe.Pointer(p)) == int32('-') && *(*Twchar_t)(unsafe.Pointer(p + 1*4)) != 0 && *(*Twchar_t)(unsafe.Pointer(p + 1*4)) != int32(']') { + if **(**Twchar_t)(__ccgo_up(p)) == int32('-') && **(**Twchar_t)(__ccgo_up(p + 1*4)) != 0 && **(**Twchar_t)(__ccgo_up(p + 1*4)) != int32(']') { v3 = p p += 4 - j = *(*Twchar_t)(unsafe.Pointer(v3 + uintptr(-Int32FromInt32(1))*4)) + j = **(**Twchar_t)(__ccgo_up(v3 + uintptr(-Int32FromInt32(1))*4)) for { - if !(j < *(*Twchar_t)(unsafe.Pointer(p))) { + if !(j < **(**Twchar_t)(__ccgo_up(p))) { break } if c == j { @@ -143778,7 +143778,7 @@ func _in_set(tls *TLS, set uintptr, c int32) (r int32) { j = j + 1 } } - if c == *(*Twchar_t)(unsafe.Pointer(p)) { + if c == **(**Twchar_t)(__ccgo_up(p)) { return int32(1) } goto _1 @@ -143816,20 +143816,20 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { Xfwide(tls, f, int32(1)) p = fmt for { - if !(*(*Twchar_t)(unsafe.Pointer(p)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(p)) != 0) { break } alloc = 0 - if Xiswspace(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(p)))) != 0 { - for Xiswspace(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(p + 1*4)))) != 0 { + if Xiswspace(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(p)))) != 0 { + for Xiswspace(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(p + 1*4)))) != 0 { p += 4 } for { - if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { + if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(**(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) + v4 = uint32(**(**uint8)(__ccgo_up(v5))) } else { v4 = Xgetwc(tls, f) } @@ -143844,21 +143844,21 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v6 = f + 8 *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 v5 = *(*uintptr)(unsafe.Pointer(v6)) - _ = *(*uint8)(unsafe.Pointer(v5)) + _ = **(**uint8)(__ccgo_up(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } goto _2 } - if *(*Twchar_t)(unsafe.Pointer(p)) != int32('%') || *(*Twchar_t)(unsafe.Pointer(p + 1*4)) == int32('%') { - if *(*Twchar_t)(unsafe.Pointer(p)) == int32('%') { + if **(**Twchar_t)(__ccgo_up(p)) != int32('%') || **(**Twchar_t)(__ccgo_up(p + 1*4)) == int32('%') { + if **(**Twchar_t)(__ccgo_up(p)) == int32('%') { p += 4 for { - if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { + if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(**(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) + v4 = uint32(**(**uint8)(__ccgo_up(v5))) } else { v4 = Xgetwc(tls, f) } @@ -143870,22 +143870,22 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { pos = pos + 1 } } else { - if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { + if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(**(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) + v4 = uint32(**(**uint8)(__ccgo_up(v5))) } else { v4 = Xgetwc(tls, f) } c = Int32FromUint32(v4) } - if c != *(*Twchar_t)(unsafe.Pointer(p)) { + if c != **(**Twchar_t)(__ccgo_up(p)) { if (*TFILE)(unsafe.Pointer(f)).Frend != 0 && Uint32FromInt32(c) < uint32(128) { v6 = f + 8 *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 v5 = *(*uintptr)(unsafe.Pointer(v6)) - _ = *(*uint8)(unsafe.Pointer(v5)) + _ = **(**uint8)(__ccgo_up(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -143898,12 +143898,12 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { goto _2 } p += 4 - if *(*Twchar_t)(unsafe.Pointer(p)) == int32('*') { + if **(**Twchar_t)(__ccgo_up(p)) == int32('*') { dest = uintptr(0) p += 4 } else { - if BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(p)))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(p + 1*4)) == int32('$') { - dest = _arg_n1(tls, ap, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(p))-int32('0'))) + if BoolInt32(Uint32FromInt32(**(**Twchar_t)(__ccgo_up(p)))-uint32('0') < uint32(10)) != 0 && **(**Twchar_t)(__ccgo_up(p + 1*4)) == int32('$') { + dest = _arg_n1(tls, ap, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(p))-int32('0'))) p = p + uintptr(2)*4 } else { dest = VaUintptr(&ap) @@ -143911,16 +143911,16 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } width = 0 for { - if !(BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(p)))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(Uint32FromInt32(**(**Twchar_t)(__ccgo_up(p)))-uint32('0') < uint32(10)) != 0) { break } - width = int32(10)*width + *(*Twchar_t)(unsafe.Pointer(p)) - int32('0') + width = int32(10)*width + **(**Twchar_t)(__ccgo_up(p)) - int32('0') goto _18 _18: ; p += 4 } - if *(*Twchar_t)(unsafe.Pointer(p)) == int32('m') { + if **(**Twchar_t)(__ccgo_up(p)) == int32('m') { wcs = uintptr(0) s = uintptr(0) alloc = BoolInt32(!!(dest != 0)) @@ -143931,16 +143931,16 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { size = SIZE_def v5 = p p += 4 - switch *(*Twchar_t)(unsafe.Pointer(v5)) { + switch **(**Twchar_t)(__ccgo_up(v5)) { case int32('h'): - if *(*Twchar_t)(unsafe.Pointer(p)) == int32('h') { + if **(**Twchar_t)(__ccgo_up(p)) == int32('h') { p += 4 size = -Int32FromInt32(2) } else { size = -int32(1) } case int32('l'): - if *(*Twchar_t)(unsafe.Pointer(p)) == int32('l') { + if **(**Twchar_t)(__ccgo_up(p)) == int32('l') { p += 4 size = Int32FromInt32(SIZE_ll) } else { @@ -143999,7 +143999,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { default: goto fmt_fail } - t = *(*Twchar_t)(unsafe.Pointer(p)) + t = **(**Twchar_t)(__ccgo_up(p)) /* Transform S,C -> ls,lc */ if t&int32(0x2f) == int32(3) { size = int32(SIZE_l) @@ -144008,11 +144008,11 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if t != int32('n') { if t != int32('[') && t|int32(32) != int32('c') { for { - if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { + if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(**(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) + v4 = uint32(**(**uint8)(__ccgo_up(v5))) } else { v4 = Xgetwc(tls, f) } @@ -144024,11 +144024,11 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { pos = pos + 1 } } else { - if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { + if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(**(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) + v4 = uint32(**(**uint8)(__ccgo_up(v5))) } else { v4 = Xgetwc(tls, f) } @@ -144041,7 +144041,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v6 = f + 8 *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 v5 = *(*uintptr)(unsafe.Pointer(v6)) - _ = *(*uint8)(unsafe.Pointer(v5)) + _ = **(**uint8)(__ccgo_up(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -144069,18 +144069,18 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } else { p += 4 v5 = p - if *(*Twchar_t)(unsafe.Pointer(v5)) == int32('^') { + if **(**Twchar_t)(__ccgo_up(v5)) == int32('^') { p += 4 invert = Int32FromInt32(1) } else { invert = 0 } set = p - if *(*Twchar_t)(unsafe.Pointer(p)) == int32(']') { + if **(**Twchar_t)(__ccgo_up(p)) == int32(']') { p += 4 } - for *(*Twchar_t)(unsafe.Pointer(p)) != int32(']') { - if !(*(*Twchar_t)(unsafe.Pointer(p)) != 0) { + for **(**Twchar_t)(__ccgo_up(p)) != int32(']') { + if !(**(**Twchar_t)(__ccgo_up(p)) != 0) { goto fmt_fail } p += 4 @@ -144124,11 +144124,11 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } } for width != 0 { - if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { + if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(**(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) + v4 = uint32(**(**uint8)(__ccgo_up(v5))) } else { v4 = Xgetwc(tls, f) } @@ -144143,7 +144143,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if wcs != 0 { v37 = i i = i + 1 - *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(v37)*4)) = c + **(**Twchar_t)(__ccgo_up(wcs + uintptr(v37)*4)) = c if alloc != 0 && i == k { k = k + (k + uint64(1)) tmp1 = Xrealloc(tls, wcs, k*uint64(4)) @@ -144183,7 +144183,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v6 = f + 8 *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 v5 = *(*uintptr)(unsafe.Pointer(v6)) - _ = *(*uint8)(unsafe.Pointer(v5)) + _ = **(**uint8)(__ccgo_up(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -144193,17 +144193,17 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } if alloc != 0 { if size == int32(SIZE_l) { - *(*uintptr)(unsafe.Pointer(dest)) = wcs + **(**uintptr)(__ccgo_up(dest)) = wcs } else { - *(*uintptr)(unsafe.Pointer(dest)) = s + **(**uintptr)(__ccgo_up(dest)) = s } } if t != int32('c') { if wcs != 0 { - *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) = 0 + **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) = 0 } if s != 0 { - *(*uint8)(unsafe.Pointer(s + uintptr(i))) = uint8(0) + **(**uint8)(__ccgo_up(s + uintptr(i))) = uint8(0) } } case int32('d'): @@ -144239,7 +144239,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { width = 0 } Xsnprintf(tls, bp+8, uint64(22), __ccgo_ts+1712, VaList(bp+40, int32(1)+BoolInt32(!(dest != 0)), __ccgo_ts+1730, width, uintptr(unsafe.Pointer(&_size_pfx))+uintptr(size+int32(2))*3, t)) - *(*Toff_t)(unsafe.Pointer(bp)) = 0 + **(**Toff_t)(__ccgo_up(bp)) = 0 if dest != 0 { v5 = dest } else { @@ -144248,11 +144248,11 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if Xfscanf(tls, f, bp+8, VaList(bp+40, v5, bp)) == -int32(1) { goto input_fail } else { - if !(*(*Toff_t)(unsafe.Pointer(bp)) != 0) { + if !(**(**Toff_t)(__ccgo_up(bp)) != 0) { goto match_fail } } - pos = pos + *(*Toff_t)(unsafe.Pointer(bp)) + pos = pos + **(**Toff_t)(__ccgo_up(bp)) default: goto fmt_fail } @@ -144378,8 +144378,8 @@ func _sn_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { k = v1 if k != 0 { Xmemcpy(tls, (*Tcookie3)(unsafe.Pointer(c)).Fs, (*TFILE)(unsafe.Pointer(f)).Fwbase, k) - *(*uintptr)(unsafe.Pointer(c)) += uintptr(k) - *(*Tsize_t)(unsafe.Pointer(c + 8)) -= k + **(**uintptr)(__ccgo_up(c)) += uintptr(k) + **(**Tsize_t)(__ccgo_up(c + 8)) -= k } if (*Tcookie3)(unsafe.Pointer(c)).Fn < l { v1 = (*Tcookie3)(unsafe.Pointer(c)).Fn @@ -144389,10 +144389,10 @@ func _sn_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { k = v1 if k != 0 { Xmemcpy(tls, (*Tcookie3)(unsafe.Pointer(c)).Fs, s, k) - *(*uintptr)(unsafe.Pointer(c)) += uintptr(k) - *(*Tsize_t)(unsafe.Pointer(c + 8)) -= k + **(**uintptr)(__ccgo_up(c)) += uintptr(k) + **(**Tsize_t)(__ccgo_up(c + 8)) -= k } - *(*uint8)(unsafe.Pointer((*Tcookie3)(unsafe.Pointer(c)).Fs)) = uint8(0) + **(**uint8)(__ccgo_up((*Tcookie3)(unsafe.Pointer(c)).Fs)) = uint8(0) v3 = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Fwbase = v3 (*TFILE)(unsafe.Pointer(f)).Fwpos = v3 @@ -144424,18 +144424,18 @@ func Xvsnprintf(tls *TLS, s uintptr, n Tsize_t, fmt uintptr, ap Tva_list) (r int } else { v2 = uint64(0) } - *(*Tcookie3)(unsafe.Pointer(bp + 8)) = Tcookie3{ + **(**Tcookie3)(__ccgo_up(bp + 8)) = Tcookie3{ Fs: v1, Fn: v2, } - *(*TFILE)(unsafe.Pointer(bp + 24)) = TFILE{ + **(**TFILE)(__ccgo_up(bp + 24)) = TFILE{ Fwrite: __ccgo_fp(_sn_write), Fbuf: bp, Flock: -int32(1), Flbf: -int32(1), Fcookie: bp + 8, } - *(*uint8)(unsafe.Pointer((*(*Tcookie3)(unsafe.Pointer(bp + 8))).Fs)) = uint8(0) + **(**uint8)(__ccgo_up((**(**Tcookie3)(__ccgo_up(bp + 8))).Fs)) = uint8(0) return Xvfprintf(tls, bp+24, fmt, ap) } @@ -144484,7 +144484,7 @@ func Xvsscanf(tls *TLS, s uintptr, fmt uintptr, ap Tva_list) (r int32) { bp := tls.Alloc(240) defer tls.Free(240) var _ /* f at bp+0 */ TFILE - *(*TFILE)(unsafe.Pointer(bp)) = TFILE{ + **(**TFILE)(__ccgo_up(bp)) = TFILE{ Fread: __ccgo_fp(_string_read), Fbuf: s, Flock: -int32(1), @@ -144534,14 +144534,14 @@ func _sw_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { (*Tcookie4)(unsafe.Pointer(c)).Fl = (*Tcookie4)(unsafe.Pointer(c)).Fl - 1 (*Tcookie4)(unsafe.Pointer(c)).Fws += 4 } - *(*Twchar_t)(unsafe.Pointer((*Tcookie4)(unsafe.Pointer(c)).Fws)) = 0 + **(**Twchar_t)(__ccgo_up((*Tcookie4)(unsafe.Pointer(c)).Fws)) = 0 if i < 0 { v4 = UintptrFromInt32(0) (*TFILE)(unsafe.Pointer(f)).Fwend = v4 v3 = v4 (*TFILE)(unsafe.Pointer(f)).Fwbase = v3 (*TFILE)(unsafe.Pointer(f)).Fwpos = v3 - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) return Uint64FromInt32(i) } (*TFILE)(unsafe.Pointer(f)).Fwend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr((*TFILE)(unsafe.Pointer(f)).Fbuf_size) @@ -144563,11 +144563,11 @@ func Xvswprintf(tls *TLS, s uintptr, n Tsize_t, fmt uintptr, ap Tva_list) (r1 in var _ /* c at bp+256 */ Tcookie4 var _ /* f at bp+272 */ TFILE _, _ = r, v1 - *(*Tcookie4)(unsafe.Pointer(bp + 256)) = Tcookie4{ + **(**Tcookie4)(__ccgo_up(bp + 256)) = Tcookie4{ Fws: s, Fl: n - uint64(1), } - *(*TFILE)(unsafe.Pointer(bp + 272)) = TFILE{ + **(**TFILE)(__ccgo_up(bp + 272)) = TFILE{ Fwrite: __ccgo_fp(_sw_write), Fbuf: bp, Fbuf_size: uint64(256), @@ -144595,8 +144595,8 @@ func _wstring_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { var v1, v2 uintptr var _ /* src at bp+0 */ uintptr _, _, _ = k, v1, v2 - *(*uintptr)(unsafe.Pointer(bp)) = (*TFILE)(unsafe.Pointer(f)).Fcookie - if !(*(*uintptr)(unsafe.Pointer(bp)) != 0) { + **(**uintptr)(__ccgo_up(bp)) = (*TFILE)(unsafe.Pointer(f)).Fcookie + if !(**(**uintptr)(__ccgo_up(bp)) != 0) { return uint64(0) } k = Xwcsrtombs(tls, (*TFILE)(unsafe.Pointer(f)).Fbuf, bp, (*TFILE)(unsafe.Pointer(f)).Fbuf_size, uintptr(0)) @@ -144608,14 +144608,14 @@ func _wstring_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { } (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(k) - (*TFILE)(unsafe.Pointer(f)).Fcookie = *(*uintptr)(unsafe.Pointer(bp)) + (*TFILE)(unsafe.Pointer(f)).Fcookie = **(**uintptr)(__ccgo_up(bp)) if !(len1 != 0) || !(k != 0) { return uint64(0) } v2 = f + 8 v1 = *(*uintptr)(unsafe.Pointer(v2)) *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(v2)) + 1 - *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v1)) + **(**uint8)(__ccgo_up(buf)) = **(**uint8)(__ccgo_up(v1)) return uint64(1) } @@ -144628,7 +144628,7 @@ func Xvswscanf(tls *TLS, s uintptr, fmt uintptr, ap Tva_list) (r int32) { defer tls.Free(496) var _ /* buf at bp+0 */ [256]uint8 var _ /* f at bp+256 */ TFILE - *(*TFILE)(unsafe.Pointer(bp + 256)) = TFILE{ + **(**TFILE)(__ccgo_up(bp + 256)) = TFILE{ Fread: __ccgo_fp(_wstring_read), Fbuf: bp, Fbuf_size: uint64(256), @@ -144740,7 +144740,7 @@ func Xatoi(tls *TLS, s uintptr) (r int32) { n = 0 neg = 0 for { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(s))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _3 _3: @@ -144749,7 +144749,7 @@ func Xatoi(tls *TLS, s uintptr) (r int32) { } s = s + 1 } - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(s))) { case int32('-'): neg = int32(1) fallthrough @@ -144757,10 +144757,10 @@ func Xatoi(tls *TLS, s uintptr) (r int32) { s = s + 1 } /* Compute n as a negative number to avoid overflow on INT_MIN */ - for BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { + for BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-uint32('0') < uint32(10)) != 0 { v4 = s s = s + 1 - n = int32(10)*n - (Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) - int32('0')) + n = int32(10)*n - (Int32FromUint8(**(**uint8)(__ccgo_up(v4))) - int32('0')) } if neg != 0 { v1 = n @@ -144782,7 +144782,7 @@ func Xatol(tls *TLS, s uintptr) (r int64) { n = 0 neg = 0 for { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(s))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _3 _3: @@ -144791,7 +144791,7 @@ func Xatol(tls *TLS, s uintptr) (r int64) { } s = s + 1 } - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(s))) { case int32('-'): neg = int32(1) fallthrough @@ -144799,10 +144799,10 @@ func Xatol(tls *TLS, s uintptr) (r int64) { s = s + 1 } /* Compute n as a negative number to avoid overflow on LONG_MIN */ - for BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { + for BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-uint32('0') < uint32(10)) != 0 { v4 = s s = s + 1 - n = int64(10)*n - int64(Int32FromUint8(*(*uint8)(unsafe.Pointer(v4)))-Int32FromUint8('0')) + n = int64(10)*n - int64(Int32FromUint8(**(**uint8)(__ccgo_up(v4)))-Int32FromUint8('0')) } if neg != 0 { v5 = n @@ -144824,7 +144824,7 @@ func Xatoll(tls *TLS, s uintptr) (r int64) { n = 0 neg = 0 for { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(s))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _3 _3: @@ -144833,7 +144833,7 @@ func Xatoll(tls *TLS, s uintptr) (r int64) { } s = s + 1 } - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(s))) { case int32('-'): neg = int32(1) fallthrough @@ -144841,10 +144841,10 @@ func Xatoll(tls *TLS, s uintptr) (r int64) { s = s + 1 } /* Compute n as a negative number to avoid overflow on LLONG_MIN */ - for BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { + for BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-uint32('0') < uint32(10)) != 0 { v4 = s s = s + 1 - n = int64(10)*n - int64(Int32FromUint8(*(*uint8)(unsafe.Pointer(v4)))-Int32FromUint8('0')) + n = int64(10)*n - int64(Int32FromUint8(**(**uint8)(__ccgo_up(v4)))-Int32FromUint8('0')) } if neg != 0 { v5 = n @@ -144906,24 +144906,24 @@ func Xecvt(tls *TLS, x float64, n int32, dp uintptr, sign uintptr) (r uintptr) { n = int32(15) } Xsprintf(tls, bp, __ccgo_ts+1733, VaList(bp+40, n-int32(1), x)) - v1 = BoolInt32(Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp)))[0]) == Int32FromUint8('-')) - *(*int32)(unsafe.Pointer(sign)) = v1 + v1 = BoolInt32(Int32FromUint8((**(**[32]uint8)(__ccgo_up(bp)))[0]) == Int32FromUint8('-')) + **(**int32)(__ccgo_up(sign)) = v1 i = v1 j = 0 for { - if !(Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp)))[i]) != int32('e')) { + if !(Int32FromUint8((**(**[32]uint8)(__ccgo_up(bp)))[i]) != int32('e')) { break } - _buf8[j] = (*(*[32]uint8)(unsafe.Pointer(bp)))[i] + _buf8[j] = (**(**[32]uint8)(__ccgo_up(bp)))[i] goto _2 _2: ; v1 = i i = i + 1 - j = j + BoolInt32(Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp)))[v1]) != int32('.')) + j = j + BoolInt32(Int32FromUint8((**(**[32]uint8)(__ccgo_up(bp)))[v1]) != int32('.')) } _buf8[j] = uint8(0) - *(*int32)(unsafe.Pointer(dp)) = Xatoi(tls, bp+uintptr(i)+uintptr(1)) + int32(1) + **(**int32)(__ccgo_up(dp)) = Xatoi(tls, bp+uintptr(i)+uintptr(1)) + int32(1) return uintptr(unsafe.Pointer(&_buf8)) } @@ -144943,15 +144943,15 @@ func Xfcvt(tls *TLS, x float64, n int32, dp uintptr, sign uintptr) (r uintptr) { n = int32(1400) } Xsprintf(tls, bp, __ccgo_ts+1738, VaList(bp+1512, n, x)) - i = BoolInt32(Int32FromUint8((*(*[1500]uint8)(unsafe.Pointer(bp)))[0]) == int32('-')) - if Int32FromUint8((*(*[1500]uint8)(unsafe.Pointer(bp)))[i]) == int32('0') { + i = BoolInt32(Int32FromUint8((**(**[1500]uint8)(__ccgo_up(bp)))[0]) == int32('-')) + if Int32FromUint8((**(**[1500]uint8)(__ccgo_up(bp)))[i]) == int32('0') { lz = Int32FromUint64(Xstrspn(tls, bp+uintptr(i)+uintptr(2), __ccgo_ts+1706)) } else { lz = -Int32FromUint64(Xstrcspn(tls, bp+uintptr(i), __ccgo_ts+606)) } if n <= lz { - *(*int32)(unsafe.Pointer(sign)) = i - *(*int32)(unsafe.Pointer(dp)) = int32(1) + **(**int32)(__ccgo_up(sign)) = i + **(**int32)(__ccgo_up(dp)) = int32(1) if Uint32FromInt32(n) > uint32(14) { n = int32(14) } @@ -145056,13 +145056,13 @@ func _pntz(tls *TLS, p uintptr) (r1 int32) { var v1, v5 uint64 var v8 bool _, _, _, _, _, _, _ = r, v1, v2, v4, v5, v6, v8 - v1 = *(*Tsize_t)(unsafe.Pointer(p)) - uint64(1) + v1 = **(**Tsize_t)(__ccgo_up(p)) - uint64(1) v2 = _a_ctz_64(tls, v1) goto _3 _3: r = v2 if v8 = r != 0; !v8 { - v5 = *(*Tsize_t)(unsafe.Pointer(p + 1*8)) + v5 = **(**Tsize_t)(__ccgo_up(p + 1*8)) v6 = _a_ctz_64(tls, v5) goto _7 _7: @@ -145086,7 +145086,7 @@ func _cycle(tls *TLS, width Tsize_t, ar uintptr, n int32) { if n < int32(2) { return } - *(*uintptr)(unsafe.Pointer(ar + uintptr(n)*8)) = bp + **(**uintptr)(__ccgo_up(ar + uintptr(n)*8)) = bp for width != 0 { if uint64(256) < width { v1 = uint64(256) @@ -145094,14 +145094,14 @@ func _cycle(tls *TLS, width Tsize_t, ar uintptr, n int32) { v1 = width } l = v1 - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(ar + uintptr(n)*8)), *(*uintptr)(unsafe.Pointer(ar)), l) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(ar + uintptr(n)*8)), **(**uintptr)(__ccgo_up(ar)), l) i = 0 for { if !(i < n) { break } - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(ar + uintptr(i)*8)), *(*uintptr)(unsafe.Pointer(ar + uintptr(i+int32(1))*8)), l) - *(*uintptr)(unsafe.Pointer(ar + uintptr(i)*8)) += uintptr(l) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(ar + uintptr(i)*8)), **(**uintptr)(__ccgo_up(ar + uintptr(i+int32(1))*8)), l) + **(**uintptr)(__ccgo_up(ar + uintptr(i)*8)) += uintptr(l) goto _2 _2: ; @@ -145117,23 +145117,23 @@ func _cycle(tls *TLS, width Tsize_t, ar uintptr, n int32) { func _shl(tls *TLS, p uintptr, n int32) { if Uint64FromInt32(n) >= Uint64FromInt32(8)*Uint64FromInt64(8) { n = Int32FromUint64(uint64(n) - Uint64FromInt32(8)*Uint64FromInt64(8)) - *(*Tsize_t)(unsafe.Pointer(p + 1*8)) = *(*Tsize_t)(unsafe.Pointer(p)) - *(*Tsize_t)(unsafe.Pointer(p)) = uint64(0) + **(**Tsize_t)(__ccgo_up(p + 1*8)) = **(**Tsize_t)(__ccgo_up(p)) + **(**Tsize_t)(__ccgo_up(p)) = uint64(0) } - *(*Tsize_t)(unsafe.Pointer(p + 1*8)) <<= Uint64FromInt32(n) - *(*Tsize_t)(unsafe.Pointer(p + 1*8)) |= *(*Tsize_t)(unsafe.Pointer(p)) >> (Uint64FromInt64(8)*Uint64FromInt32(8) - Uint64FromInt32(n)) - *(*Tsize_t)(unsafe.Pointer(p)) <<= Uint64FromInt32(n) + **(**Tsize_t)(__ccgo_up(p + 1*8)) <<= Uint64FromInt32(n) + **(**Tsize_t)(__ccgo_up(p + 1*8)) |= **(**Tsize_t)(__ccgo_up(p)) >> (Uint64FromInt64(8)*Uint64FromInt32(8) - Uint64FromInt32(n)) + **(**Tsize_t)(__ccgo_up(p)) <<= Uint64FromInt32(n) } func _shr(tls *TLS, p uintptr, n int32) { if Uint64FromInt32(n) >= Uint64FromInt32(8)*Uint64FromInt64(8) { n = Int32FromUint64(uint64(n) - Uint64FromInt32(8)*Uint64FromInt64(8)) - *(*Tsize_t)(unsafe.Pointer(p)) = *(*Tsize_t)(unsafe.Pointer(p + 1*8)) - *(*Tsize_t)(unsafe.Pointer(p + 1*8)) = uint64(0) + **(**Tsize_t)(__ccgo_up(p)) = **(**Tsize_t)(__ccgo_up(p + 1*8)) + **(**Tsize_t)(__ccgo_up(p + 1*8)) = uint64(0) } - *(*Tsize_t)(unsafe.Pointer(p)) >>= Uint64FromInt32(n) - *(*Tsize_t)(unsafe.Pointer(p)) |= *(*Tsize_t)(unsafe.Pointer(p + 1*8)) << (Uint64FromInt64(8)*Uint64FromInt32(8) - Uint64FromInt32(n)) - *(*Tsize_t)(unsafe.Pointer(p + 1*8)) >>= Uint64FromInt32(n) + **(**Tsize_t)(__ccgo_up(p)) >>= Uint64FromInt32(n) + **(**Tsize_t)(__ccgo_up(p)) |= **(**Tsize_t)(__ccgo_up(p + 1*8)) << (Uint64FromInt64(8)*Uint64FromInt32(8) - Uint64FromInt32(n)) + **(**Tsize_t)(__ccgo_up(p + 1*8)) >>= Uint64FromInt32(n) } func _sift(tls *TLS, head uintptr, width Tsize_t, __ccgo_fp_cmp Tcmpfun, arg uintptr, pshift int32, lp uintptr) { @@ -145144,23 +145144,23 @@ func _sift(tls *TLS, head uintptr, width Tsize_t, __ccgo_fp_cmp Tcmpfun, arg uin var _ /* ar at bp+0 */ [113]uintptr _, _, _, _ = i, lf, rt, v1 i = int32(1) - (*(*[113]uintptr)(unsafe.Pointer(bp)))[0] = head + (**(**[113]uintptr)(__ccgo_up(bp)))[0] = head for pshift > int32(1) { rt = head - uintptr(width) - lf = head - uintptr(width) - uintptr(*(*Tsize_t)(unsafe.Pointer(lp + uintptr(pshift-int32(2))*8))) - if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, (*(*[113]uintptr)(unsafe.Pointer(bp)))[0], lf, arg) >= 0 && (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, (*(*[113]uintptr)(unsafe.Pointer(bp)))[0], rt, arg) >= 0 { + lf = head - uintptr(width) - uintptr(**(**Tsize_t)(__ccgo_up(lp + uintptr(pshift-int32(2))*8))) + if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, (**(**[113]uintptr)(__ccgo_up(bp)))[0], lf, arg) >= 0 && (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, (**(**[113]uintptr)(__ccgo_up(bp)))[0], rt, arg) >= 0 { break } if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, lf, rt, arg) >= 0 { v1 = i i = i + 1 - (*(*[113]uintptr)(unsafe.Pointer(bp)))[v1] = lf + (**(**[113]uintptr)(__ccgo_up(bp)))[v1] = lf head = lf pshift = pshift - int32(1) } else { v1 = i i = i + 1 - (*(*[113]uintptr)(unsafe.Pointer(bp)))[v1] = rt + (**(**[113]uintptr)(__ccgo_up(bp)))[v1] = rt head = rt pshift = pshift - int32(2) } @@ -145177,24 +145177,24 @@ func _trinkle(tls *TLS, head uintptr, width Tsize_t, __ccgo_fp_cmp Tcmpfun, arg var _ /* p at bp+0 */ [2]Tsize_t _, _, _, _, _, _ = i, lf, rt, stepson, trail, v1 i = int32(1) - (*(*[2]Tsize_t)(unsafe.Pointer(bp)))[0] = *(*Tsize_t)(unsafe.Pointer(pp)) - (*(*[2]Tsize_t)(unsafe.Pointer(bp)))[int32(1)] = *(*Tsize_t)(unsafe.Pointer(pp + 1*8)) - (*(*[113]uintptr)(unsafe.Pointer(bp + 16)))[0] = head - for (*(*[2]Tsize_t)(unsafe.Pointer(bp)))[0] != uint64(1) || (*(*[2]Tsize_t)(unsafe.Pointer(bp)))[int32(1)] != uint64(0) { - stepson = head - uintptr(*(*Tsize_t)(unsafe.Pointer(lp + uintptr(pshift)*8))) - if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, stepson, (*(*[113]uintptr)(unsafe.Pointer(bp + 16)))[0], arg) <= 0 { + (**(**[2]Tsize_t)(__ccgo_up(bp)))[0] = **(**Tsize_t)(__ccgo_up(pp)) + (**(**[2]Tsize_t)(__ccgo_up(bp)))[int32(1)] = **(**Tsize_t)(__ccgo_up(pp + 1*8)) + (**(**[113]uintptr)(__ccgo_up(bp + 16)))[0] = head + for (**(**[2]Tsize_t)(__ccgo_up(bp)))[0] != uint64(1) || (**(**[2]Tsize_t)(__ccgo_up(bp)))[int32(1)] != uint64(0) { + stepson = head - uintptr(**(**Tsize_t)(__ccgo_up(lp + uintptr(pshift)*8))) + if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, stepson, (**(**[113]uintptr)(__ccgo_up(bp + 16)))[0], arg) <= 0 { break } if !(trusty != 0) && pshift > int32(1) { rt = head - uintptr(width) - lf = head - uintptr(width) - uintptr(*(*Tsize_t)(unsafe.Pointer(lp + uintptr(pshift-int32(2))*8))) + lf = head - uintptr(width) - uintptr(**(**Tsize_t)(__ccgo_up(lp + uintptr(pshift-int32(2))*8))) if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, rt, stepson, arg) >= 0 || (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, lf, stepson, arg) >= 0 { break } } v1 = i i = i + 1 - (*(*[113]uintptr)(unsafe.Pointer(bp + 16)))[v1] = stepson + (**(**[113]uintptr)(__ccgo_up(bp + 16)))[v1] = stepson head = stepson trail = _pntz(tls, bp) _shr(tls, bp, trail) @@ -145222,7 +145222,7 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm var _ /* p at bp+768 */ [2]Tsize_t _, _, _, _, _, _, _, _ = head, high, i, pshift, size, trail, v2, v3 size = width * nel - *(*[2]Tsize_t)(unsafe.Pointer(bp + 768)) = [2]Tsize_t{ + **(**[2]Tsize_t)(__ccgo_up(bp + 768)) = [2]Tsize_t{ 0: uint64(1), } pshift = int32(1) @@ -145233,12 +145233,12 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm high = head + uintptr(size) - uintptr(width) /* Precompute Leonardo numbers, scaled by element width */ v2 = width - (*(*[96]Tsize_t)(unsafe.Pointer(bp)))[int32(1)] = v2 - (*(*[96]Tsize_t)(unsafe.Pointer(bp)))[0] = v2 + (**(**[96]Tsize_t)(__ccgo_up(bp)))[int32(1)] = v2 + (**(**[96]Tsize_t)(__ccgo_up(bp)))[0] = v2 i = Uint64FromInt32(2) for { - v3 = (*(*[96]Tsize_t)(unsafe.Pointer(bp)))[i-uint64(2)] + (*(*[96]Tsize_t)(unsafe.Pointer(bp)))[i-uint64(1)] + width - (*(*[96]Tsize_t)(unsafe.Pointer(bp)))[i] = v3 + v3 = (**(**[96]Tsize_t)(__ccgo_up(bp)))[i-uint64(2)] + (**(**[96]Tsize_t)(__ccgo_up(bp)))[i-uint64(1)] + width + (**(**[96]Tsize_t)(__ccgo_up(bp)))[i] = v3 if !(v3 < size) { break } @@ -145248,12 +145248,12 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm i = i + 1 } for head < high { - if (*(*[2]Tsize_t)(unsafe.Pointer(bp + 768)))[0]&uint64(3) == uint64(3) { + if (**(**[2]Tsize_t)(__ccgo_up(bp + 768)))[0]&uint64(3) == uint64(3) { _sift(tls, head, width, __ccgo_fp_cmp, arg, pshift, bp) _shr(tls, bp+768, int32(2)) pshift = pshift + int32(2) } else { - if (*(*[96]Tsize_t)(unsafe.Pointer(bp)))[pshift-int32(1)] >= Uint64FromInt64(int64(high)-int64(head)) { + if (**(**[96]Tsize_t)(__ccgo_up(bp)))[pshift-int32(1)] >= Uint64FromInt64(int64(high)-int64(head)) { _trinkle(tls, head, width, __ccgo_fp_cmp, arg, bp+768, pshift, 0, bp) } else { _sift(tls, head, width, __ccgo_fp_cmp, arg, pshift, bp) @@ -145266,11 +145266,11 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm pshift = int32(1) } } - *(*Tsize_t)(unsafe.Pointer(bp + 768)) |= uint64(1) + **(**Tsize_t)(__ccgo_up(bp + 768)) |= uint64(1) head = head + uintptr(width) } _trinkle(tls, head, width, __ccgo_fp_cmp, arg, bp+768, pshift, 0, bp) - for pshift != int32(1) || (*(*[2]Tsize_t)(unsafe.Pointer(bp + 768)))[0] != uint64(1) || (*(*[2]Tsize_t)(unsafe.Pointer(bp + 768)))[int32(1)] != uint64(0) { + for pshift != int32(1) || (**(**[2]Tsize_t)(__ccgo_up(bp + 768)))[0] != uint64(1) || (**(**[2]Tsize_t)(__ccgo_up(bp + 768)))[int32(1)] != uint64(0) { if pshift <= int32(1) { trail = _pntz(tls, bp+768) _shr(tls, bp+768, trail) @@ -145278,11 +145278,11 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm } else { _shl(tls, bp+768, int32(2)) pshift = pshift - int32(2) - *(*Tsize_t)(unsafe.Pointer(bp + 768)) ^= uint64(7) + **(**Tsize_t)(__ccgo_up(bp + 768)) ^= uint64(7) _shr(tls, bp+768, int32(1)) - _trinkle(tls, head-uintptr((*(*[96]Tsize_t)(unsafe.Pointer(bp)))[pshift])-uintptr(width), width, __ccgo_fp_cmp, arg, bp+768, pshift+int32(1), int32(1), bp) + _trinkle(tls, head-uintptr((**(**[96]Tsize_t)(__ccgo_up(bp)))[pshift])-uintptr(width), width, __ccgo_fp_cmp, arg, bp+768, pshift+int32(1), int32(1), bp) _shl(tls, bp+768, int32(1)) - *(*Tsize_t)(unsafe.Pointer(bp + 768)) |= uint64(1) + **(**Tsize_t)(__ccgo_up(bp + 768)) |= uint64(1) _trinkle(tls, head-uintptr(width), width, __ccgo_fp_cmp, arg, bp+768, pshift, int32(1), bp) } head = head - uintptr(width) @@ -145332,7 +145332,7 @@ func _strtox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { } else { v1 = s } - *(*uintptr)(unsafe.Pointer(p)) = v1 + **(**uintptr)(__ccgo_up(p)) = v1 } return y } @@ -145377,7 +145377,7 @@ func _strtox1(tls *TLS, s uintptr, p uintptr, base int32, lim uint64) (r uint64) y = X__intscan(tls, bp, Uint32FromInt32(base), int32(1), lim) if p != 0 { cnt = Uint64FromInt64((*TFILE)(unsafe.Pointer(bp)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(bp)).Frpos) - int64((*TFILE)(unsafe.Pointer(bp)).Fbuf))) - *(*uintptr)(unsafe.Pointer(p)) = s + uintptr(cnt) + **(**uintptr)(__ccgo_up(p)) = s + uintptr(cnt) } return y } @@ -145488,20 +145488,20 @@ func _do_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { var v2 int32 _, _, _, _, _ = i, wcs, v2, v3, v4 wcs = (*TFILE)(unsafe.Pointer(f)).Fcookie - if !(*(*Twchar_t)(unsafe.Pointer(wcs)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(wcs)) != 0) { wcs = __ccgo_ts + 1764 } i = uint64(0) for { - if !(i < (*TFILE)(unsafe.Pointer(f)).Fbuf_size && *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) != 0) { + if !(i < (*TFILE)(unsafe.Pointer(f)).Fbuf_size && **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) != 0) { break } - if *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) < int32(128) { - v2 = *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) + if **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) < int32(128) { + v2 = **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) } else { v2 = int32('@') } - *(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(i))) = Uint8FromInt32(v2) + **(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(i))) = Uint8FromInt32(v2) goto _1 _1: ; @@ -145514,7 +145514,7 @@ func _do_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(buf)) = **(**uint8)(__ccgo_up(v3)) return uint64(1) } return uint64(0) @@ -145530,20 +145530,20 @@ func _wcstox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { var _ /* f at bp+64 */ TFILE _, _, _, _, _ = cnt, t, y, v1, v2 t = s - *(*TFILE)(unsafe.Pointer(bp + 64)) = TFILE{} - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fflags = uint32(0) + **(**TFILE)(__ccgo_up(bp + 64)) = TFILE{} + (**(**TFILE)(__ccgo_up(bp + 64))).Fflags = uint32(0) v2 = bp + UintptrFromInt32(4) - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fbuf = v2 + (**(**TFILE)(__ccgo_up(bp + 64))).Fbuf = v2 v1 = v2 - (*(*TFILE)(unsafe.Pointer(bp + 64))).Frend = v1 - (*(*TFILE)(unsafe.Pointer(bp + 64))).Frpos = v1 - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fbuf_size = Uint64FromInt64(64) - Uint64FromInt32(4) + (**(**TFILE)(__ccgo_up(bp + 64))).Frend = v1 + (**(**TFILE)(__ccgo_up(bp + 64))).Frpos = v1 + (**(**TFILE)(__ccgo_up(bp + 64))).Fbuf_size = Uint64FromInt64(64) - Uint64FromInt32(4) AtomicStorePInt32(bp+64+140, -int32(1)) - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fread = __ccgo_fp(_do_read) - for Xiswspace(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(t)))) != 0 { + (**(**TFILE)(__ccgo_up(bp + 64))).Fread = __ccgo_fp(_do_read) + for Xiswspace(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(t)))) != 0 { t += 4 } - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fcookie = t + (**(**TFILE)(__ccgo_up(bp + 64))).Fcookie = t X__shlim(tls, bp+64, int64(Int32FromInt32(0))) y = X__floatscan(tls, bp+64, prec, int32(1)) if p != 0 { @@ -145553,7 +145553,7 @@ func _wcstox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { } else { v1 = s } - *(*uintptr)(unsafe.Pointer(p)) = v1 + **(**uintptr)(__ccgo_up(p)) = v1 } return y } @@ -145592,20 +145592,20 @@ func _do_read1(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { var v2 int32 _, _, _, _, _ = i, wcs, v2, v3, v4 wcs = (*TFILE)(unsafe.Pointer(f)).Fcookie - if !(*(*Twchar_t)(unsafe.Pointer(wcs)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(wcs)) != 0) { wcs = __ccgo_ts + 1764 } i = uint64(0) for { - if !(i < (*TFILE)(unsafe.Pointer(f)).Fbuf_size && *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) != 0) { + if !(i < (*TFILE)(unsafe.Pointer(f)).Fbuf_size && **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) != 0) { break } - if *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) < int32(128) { - v2 = *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) + if **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) < int32(128) { + v2 = **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) } else { v2 = int32('@') } - *(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(i))) = Uint8FromInt32(v2) + **(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(i))) = Uint8FromInt32(v2) goto _1 _1: ; @@ -145618,7 +145618,7 @@ func _do_read1(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(buf)) = **(**uint8)(__ccgo_up(v3)) return uint64(1) } return uint64(0) @@ -145634,20 +145634,20 @@ func _wcstox1(tls *TLS, s uintptr, p uintptr, base int32, lim uint64) (r uint64) var _ /* f at bp+64 */ TFILE _, _, _, _, _ = cnt, t, y, v1, v2 t = s - *(*TFILE)(unsafe.Pointer(bp + 64)) = TFILE{} - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fflags = uint32(0) + **(**TFILE)(__ccgo_up(bp + 64)) = TFILE{} + (**(**TFILE)(__ccgo_up(bp + 64))).Fflags = uint32(0) v2 = bp + UintptrFromInt32(4) - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fbuf = v2 + (**(**TFILE)(__ccgo_up(bp + 64))).Fbuf = v2 v1 = v2 - (*(*TFILE)(unsafe.Pointer(bp + 64))).Frend = v1 - (*(*TFILE)(unsafe.Pointer(bp + 64))).Frpos = v1 - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fbuf_size = Uint64FromInt64(64) - Uint64FromInt32(4) + (**(**TFILE)(__ccgo_up(bp + 64))).Frend = v1 + (**(**TFILE)(__ccgo_up(bp + 64))).Frpos = v1 + (**(**TFILE)(__ccgo_up(bp + 64))).Fbuf_size = Uint64FromInt64(64) - Uint64FromInt32(4) AtomicStorePInt32(bp+64+140, -int32(1)) - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fread = __ccgo_fp(_do_read1) - for Xiswspace(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(t)))) != 0 { + (**(**TFILE)(__ccgo_up(bp + 64))).Fread = __ccgo_fp(_do_read1) + for Xiswspace(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(t)))) != 0 { t += 4 } - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fcookie = t + (**(**TFILE)(__ccgo_up(bp + 64))).Fcookie = t X__shlim(tls, bp+64, int64(Int32FromInt32(0))) y = X__intscan(tls, bp+64, Uint32FromInt32(base), int32(1), lim) if p != 0 { @@ -145657,7 +145657,7 @@ func _wcstox1(tls *TLS, s uintptr, p uintptr, base int32, lim uint64) (r uint64) } else { v1 = s } - *(*uintptr)(unsafe.Pointer(p)) = v1 + **(**uintptr)(__ccgo_up(p)) = v1 } return y } @@ -145776,8 +145776,8 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt if uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) == uint64(d)&(Uint64FromInt64(8)-Uint64FromInt32(1)) { for { if v3 = uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) != 0 && n != 0; v3 { - v2 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v2 + v2 = **(**uint8)(__ccgo_up(s)) + **(**uint8)(__ccgo_up(d)) = v2 } if !(v3 && Int32FromUint8(v2) != c) { break @@ -145796,10 +145796,10 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt wd = d ws = s for { - if !(n >= uint64(8) && !((*(*uint64)(unsafe.Pointer(ws))^k-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^(*(*uint64)(unsafe.Pointer(ws))^k) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { + if !(n >= uint64(8) && !((**(**uint64)(__ccgo_up(ws))^k-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^(**(**uint64)(__ccgo_up(ws))^k) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { break } - *(*uint64)(unsafe.Pointer(wd)) = *(*uint64)(unsafe.Pointer(ws)) + **(**uint64)(__ccgo_up(wd)) = **(**uint64)(__ccgo_up(ws)) goto _4 _4: ; @@ -145812,8 +145812,8 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt } for { if v3 = n != 0; v3 { - v2 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v2 + v2 = **(**uint8)(__ccgo_up(s)) + **(**uint8)(__ccgo_up(d)) = v2 } if !(v3 && Int32FromUint8(v2) != c) { break @@ -145856,7 +145856,7 @@ func Xmemchr(tls *TLS, src uintptr, c int32, n Tsize_t) (r uintptr) { s = src c = Int32FromUint8(Uint8FromInt32(c)) for { - if !(uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) != 0 && n != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != c) { + if !(uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) != 0 && n != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != c) { break } goto _1 @@ -145865,11 +145865,11 @@ func Xmemchr(tls *TLS, src uintptr, c int32, n Tsize_t) (r uintptr) { s = s + 1 n = n - 1 } - if n != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != c { + if n != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != c { k = Uint64FromInt32(-Int32FromInt32(1)) / Uint64FromInt32(UCHAR_MAX) * Uint64FromInt32(c) w = s for { - if !(n >= Uint64FromInt64(8) && !((*(*uint64)(unsafe.Pointer(w))^k-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^(*(*uint64)(unsafe.Pointer(w))^k) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { + if !(n >= Uint64FromInt64(8) && !((**(**uint64)(__ccgo_up(w))^k-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^(**(**uint64)(__ccgo_up(w))^k) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { break } goto _2 @@ -145881,7 +145881,7 @@ func Xmemchr(tls *TLS, src uintptr, c int32, n Tsize_t) (r uintptr) { s = w } for { - if !(n != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != c) { + if !(n != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != c) { break } goto _3 @@ -145909,7 +145909,7 @@ func Xmemcmp(tls *TLS, vl uintptr, vr uintptr, n Tsize_t) (r1 int32) { l = vl r = vr for { - if !(n != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))) { + if !(n != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(l))) == Int32FromUint8(**(**uint8)(__ccgo_up(r)))) { break } goto _1 @@ -145920,7 +145920,7 @@ func Xmemcmp(tls *TLS, vl uintptr, vr uintptr, n Tsize_t) (r1 int32) { r = r + 1 } if n != 0 { - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(l))) - Int32FromUint8(**(**uint8)(__ccgo_up(r))) } else { v2 = 0 } @@ -145948,7 +145948,7 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) goto _1 _1: ; @@ -145959,10 +145959,10 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { if !(n >= uint64(16)) { break } - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(0))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(4))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(4))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(8))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(8))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(12))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(12))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(0))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(0))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(4))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(4))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(8))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(8))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(12))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(12))) goto _4 _4: ; @@ -145971,13 +145971,13 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { n = n - uint64(16) } if n&uint64(8) != 0 { - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(0))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(4))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(4))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(0))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(0))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(4))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(4))) d = d + uintptr(8) s = s + uintptr(8) } if n&uint64(4) != 0 { - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(0))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(0))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(0))) d = d + uintptr(4) s = s + uintptr(4) } @@ -145986,50 +145986,50 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) } if n&uint64(1) != 0 { - *(*uint8)(unsafe.Pointer(d)) = *(*uint8)(unsafe.Pointer(s)) + **(**uint8)(__ccgo_up(d)) = **(**uint8)(__ccgo_up(s)) } return dest } if n >= uint64(32) { switch uint64(d) % Uint64FromInt32(4) { case uint64(1): - w = *(*uint32)(unsafe.Pointer(s)) + w = **(**uint32)(__ccgo_up(s)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) n = n - uint64(3) for { if !(n >= uint64(17)) { break } - x = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(1))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = w>>Int32FromInt32(24) | x<>Int32FromInt32(24) | w<>Int32FromInt32(24) | x<>Int32FromInt32(24) | w<>Int32FromInt32(24) | x<>Int32FromInt32(24) | w<>Int32FromInt32(24) | x<>Int32FromInt32(24) | w<= uint64(18)) { break } - x = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(2))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = w>>Int32FromInt32(16) | x<>Int32FromInt32(16) | w<>Int32FromInt32(16) | x<>Int32FromInt32(16) | w<>Int32FromInt32(16) | x<>Int32FromInt32(16) | w<>Int32FromInt32(16) | x<>Int32FromInt32(16) | w<= uint64(19)) { break } - x = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(3))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = w>>Int32FromInt32(8) | x<>Int32FromInt32(8) | w<>Int32FromInt32(8) | x<>Int32FromInt32(8) | w<>Int32FromInt32(8) | x<>Int32FromInt32(8) | w<>Int32FromInt32(8) | x<>Int32FromInt32(8) | w< Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(ip+k)))) > Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(jp+k)))) { jp = jp + k k = uint64(1) p = jp - ip @@ -146431,7 +146431,7 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin p = v2 k = v2 for jp+k < l { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(ip+k)))) == Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(jp+k)))) { if k == p { jp = jp + p k = uint64(1) @@ -146439,7 +146439,7 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin k = k + 1 } } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) < Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(ip+k)))) < Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(jp+k)))) { jp = jp + k k = uint64(1) p = jp - ip @@ -146478,8 +146478,8 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin return uintptr(0) } /* Check last byte first; advance by shift on mismatch */ - if (*(*[4]Tsize_t)(unsafe.Pointer(bp)))[uint64(*(*uint8)(unsafe.Pointer(h + uintptr(l-uint64(1)))))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(*(*uint8)(unsafe.Pointer(h + uintptr(l-uint64(1)))))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0 { - k = l - shift[*(*uint8)(unsafe.Pointer(h + uintptr(l-uint64(1))))] + if (**(**[4]Tsize_t)(__ccgo_up(bp)))[uint64(**(**uint8)(__ccgo_up(h + uintptr(l-uint64(1)))))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(**(**uint8)(__ccgo_up(h + uintptr(l-uint64(1)))))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0 { + k = l - shift[**(**uint8)(__ccgo_up(h + uintptr(l-uint64(1))))] if k != 0 { if k < mem { k = mem @@ -146501,7 +146501,7 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin } k = v8 for { - if !(k < l && Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(h + uintptr(k))))) { + if !(k < l && Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(k)))) == Int32FromUint8(**(**uint8)(__ccgo_up(h + uintptr(k))))) { break } goto _10 @@ -146517,7 +146517,7 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin /* Compare left half */ k = ms + uint64(1) for { - if !(k > mem && Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(k-uint64(1))))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(h + uintptr(k-uint64(1)))))) { + if !(k > mem && Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(k-uint64(1))))) == Int32FromUint8(**(**uint8)(__ccgo_up(h + uintptr(k-uint64(1)))))) { break } goto _12 @@ -146554,7 +146554,7 @@ func Xmemmem(tls *TLS, h0 uintptr, k Tsize_t, n0 uintptr, l Tsize_t) (r uintptr) return uintptr(0) } /* Use faster algorithms for short needles */ - h = Xmemchr(tls, h0, Int32FromUint8(*(*uint8)(unsafe.Pointer(n))), k) + h = Xmemchr(tls, h0, Int32FromUint8(**(**uint8)(__ccgo_up(n))), k) if !(h != 0) || l == uint64(1) { return h } @@ -146606,13 +146606,13 @@ func Xmemmove(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) } for { if !(n >= Uint64FromInt64(8)) { break } - *(*TWT)(unsafe.Pointer(d)) = *(*TWT)(unsafe.Pointer(s)) + **(**TWT)(__ccgo_up(d)) = **(**TWT)(__ccgo_up(s)) goto _4 _4: ; @@ -146629,7 +146629,7 @@ func Xmemmove(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) goto _5 _5: ; @@ -146643,16 +146643,16 @@ func Xmemmove(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { if !(v1 != 0) { return dest } - *(*uint8)(unsafe.Pointer(d + uintptr(n))) = *(*uint8)(unsafe.Pointer(s + uintptr(n))) + **(**uint8)(__ccgo_up(d + uintptr(n))) = **(**uint8)(__ccgo_up(s + uintptr(n))) } for n >= Uint64FromInt64(8) { n = n - Uint64FromInt64(8) - *(*TWT)(unsafe.Pointer(d + uintptr(n))) = *(*TWT)(unsafe.Pointer(s + uintptr(n))) + **(**TWT)(__ccgo_up(d + uintptr(n))) = **(**TWT)(__ccgo_up(s + uintptr(n))) } } for n != 0 { n = n - 1 - *(*uint8)(unsafe.Pointer(d + uintptr(n))) = *(*uint8)(unsafe.Pointer(s + uintptr(n))) + **(**uint8)(__ccgo_up(d + uintptr(n))) = **(**uint8)(__ccgo_up(s + uintptr(n))) } } return dest @@ -146682,7 +146682,7 @@ func X__memrchr(tls *TLS, m uintptr, c int32, n Tsize_t) (r uintptr) { if !(v1 != 0) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(n)))) == c { + if Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(n)))) == c { return s + uintptr(n) } } @@ -146714,20 +146714,20 @@ func Xmemset(tls *TLS, dest uintptr, c int32, n Tsize_t) (r uintptr) { if !(n != 0) { return dest } - *(*uint8)(unsafe.Pointer(s)) = Uint8FromInt32(c) - *(*uint8)(unsafe.Pointer(s + uintptr(n-uint64(1)))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s)) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + uintptr(n-uint64(1)))) = Uint8FromInt32(c) if n <= uint64(2) { return dest } - *(*uint8)(unsafe.Pointer(s + 1)) = Uint8FromInt32(c) - *(*uint8)(unsafe.Pointer(s + 2)) = Uint8FromInt32(c) - *(*uint8)(unsafe.Pointer(s + uintptr(n-uint64(2)))) = Uint8FromInt32(c) - *(*uint8)(unsafe.Pointer(s + uintptr(n-uint64(3)))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + 1)) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + 2)) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + uintptr(n-uint64(2)))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + uintptr(n-uint64(3)))) = Uint8FromInt32(c) if n <= uint64(6) { return dest } - *(*uint8)(unsafe.Pointer(s + 3)) = Uint8FromInt32(c) - *(*uint8)(unsafe.Pointer(s + uintptr(n-uint64(4)))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + 3)) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + uintptr(n-uint64(4)))) = Uint8FromInt32(c) if n <= uint64(8) { return dest } @@ -146745,26 +146745,26 @@ func Xmemset(tls *TLS, dest uintptr, c int32, n Tsize_t) (r uintptr) { * As in the initial byte-based head/tail fill, each * conditional below ensures that the subsequent offsets * are valid (e.g. !(n<=24) implies n>=28). */ - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(0))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(4))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(0))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(4))) = c32 if n <= uint64(8) { return dest } - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(4))) = c32 - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(8))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(12))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(8))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(4))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(8))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(12))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(8))) = c32 if n <= uint64(24) { return dest } - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(12))) = c32 - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(16))) = c32 - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(20))) = c32 - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(24))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(28))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(24))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(20))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(16))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(12))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(16))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(20))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(24))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(28))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(24))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(20))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(16))) = c32 /* Align to a multiple of 8 so we can fill 64 bits at a time, * and avoid writing the same bytes twice as much as is * practical without introducing additional branching. */ @@ -146779,10 +146779,10 @@ func Xmemset(tls *TLS, dest uintptr, c int32, n Tsize_t) (r uintptr) { if !(n >= uint64(32)) { break } - *(*uint64)(unsafe.Pointer(s + UintptrFromInt32(0))) = c64 - *(*uint64)(unsafe.Pointer(s + UintptrFromInt32(8))) = c64 - *(*uint64)(unsafe.Pointer(s + UintptrFromInt32(16))) = c64 - *(*uint64)(unsafe.Pointer(s + UintptrFromInt32(24))) = c64 + **(**uint64)(__ccgo_up(s + UintptrFromInt32(0))) = c64 + **(**uint64)(__ccgo_up(s + UintptrFromInt32(8))) = c64 + **(**uint64)(__ccgo_up(s + UintptrFromInt32(16))) = c64 + **(**uint64)(__ccgo_up(s + UintptrFromInt32(24))) = c64 goto _1 _1: ; @@ -146824,8 +146824,8 @@ func X__stpcpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { if !(uint64(s)%Uint64FromInt64(8) != 0) { break } - v2 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v2 + v2 = **(**uint8)(__ccgo_up(s)) + **(**uint8)(__ccgo_up(d)) = v2 if !(v2 != 0) { return d } @@ -146838,7 +146838,7 @@ func X__stpcpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { wd = d ws = s for { - if !!((*(*uint64)(unsafe.Pointer(ws))-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^*(*uint64)(unsafe.Pointer(ws)) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0) { + if !!((**(**uint64)(__ccgo_up(ws))-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^**(**uint64)(__ccgo_up(ws)) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0) { break } goto _3 @@ -146848,14 +146848,14 @@ func X__stpcpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { wd += 8 v5 = ws ws += 8 - *(*uint64)(unsafe.Pointer(v4)) = *(*uint64)(unsafe.Pointer(v5)) + **(**uint64)(__ccgo_up(v4)) = **(**uint64)(__ccgo_up(v5)) } d = wd s = ws } for { - v2 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v2 + v2 = **(**uint8)(__ccgo_up(s)) + **(**uint8)(__ccgo_up(d)) = v2 if !(v2 != 0) { break } @@ -146908,8 +146908,8 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { if uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) == uint64(d)&(Uint64FromInt64(8)-Uint64FromInt32(1)) { for { if v3 = uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) != 0 && n != 0; v3 { - v2 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v2 + v2 = **(**uint8)(__ccgo_up(s)) + **(**uint8)(__ccgo_up(d)) = v2 } if !(v3 && v2 != 0) { break @@ -146921,16 +146921,16 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { s = s + 1 d = d + 1 } - if !(n != 0) || !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(n != 0) || !(**(**uint8)(__ccgo_up(s)) != 0) { goto tail } wd = d ws = s for { - if !(n >= uint64(8) && !((*(*uint64)(unsafe.Pointer(ws))-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^*(*uint64)(unsafe.Pointer(ws)) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { + if !(n >= uint64(8) && !((**(**uint64)(__ccgo_up(ws))-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^**(**uint64)(__ccgo_up(ws)) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { break } - *(*uint64)(unsafe.Pointer(wd)) = *(*uint64)(unsafe.Pointer(ws)) + **(**uint64)(__ccgo_up(wd)) = **(**uint64)(__ccgo_up(ws)) goto _4 _4: ; @@ -146943,8 +146943,8 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { } for { if v3 = n != 0; v3 { - v2 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v2 + v2 = **(**uint8)(__ccgo_up(s)) + **(**uint8)(__ccgo_up(d)) = v2 } if !(v3 && v2 != 0) { break @@ -146990,7 +146990,7 @@ func Xstrcasecmp(tls *TLS, _l uintptr, _r uintptr) (r1 int32) { l = _l r = _r for { - if !(*(*uint8)(unsafe.Pointer(l)) != 0 && *(*uint8)(unsafe.Pointer(r)) != 0 && (Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) || Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(l)))) == Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))))) { + if !(**(**uint8)(__ccgo_up(l)) != 0 && **(**uint8)(__ccgo_up(r)) != 0 && (Int32FromUint8(**(**uint8)(__ccgo_up(l))) == Int32FromUint8(**(**uint8)(__ccgo_up(r))) || Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(l)))) == Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(r)))))) { break } goto _1 @@ -146999,7 +146999,7 @@ func Xstrcasecmp(tls *TLS, _l uintptr, _r uintptr) (r1 int32) { l = l + 1 r = r + 1 } - return Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(l)))) - Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))) + return Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(l)))) - Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(r)))) } func X__strcasecmp_l(tls *TLS, l uintptr, r uintptr, loc Tlocale_t) (r1 int32) { @@ -147027,7 +147027,7 @@ func Xstrcasestr(tls *TLS, h uintptr, n uintptr) (r uintptr) { _ = l l = _strlen(tls, n) for { - if !(*(*uint8)(unsafe.Pointer(h)) != 0) { + if !(**(**uint8)(__ccgo_up(h)) != 0) { break } if !(Xstrncasecmp(tls, h, n, l) != 0) { @@ -147058,7 +147058,7 @@ func Xstrchr(tls *TLS, s uintptr, c int32) (r1 uintptr) { var r, v1 uintptr _, _ = r, v1 r = X__strchrnul(tls, s, c) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) == Int32FromUint8(Uint8FromInt32(c)) { + if Int32FromUint8(**(**uint8)(__ccgo_up(r))) == Int32FromUint8(Uint8FromInt32(c)) { v1 = r } else { v1 = uintptr(0) @@ -147093,7 +147093,7 @@ func X__strchrnul(tls *TLS, s uintptr, c int32) (r uintptr) { if !(uint64(s)%Uint64FromInt64(8) != 0) { break } - if !(*(*uint8)(unsafe.Pointer(s)) != 0) || Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == c { + if !(**(**uint8)(__ccgo_up(s)) != 0) || Int32FromUint8(**(**uint8)(__ccgo_up(s))) == c { return s } goto _1 @@ -147104,7 +147104,7 @@ func X__strchrnul(tls *TLS, s uintptr, c int32) (r uintptr) { k = Uint64FromInt32(-Int32FromInt32(1)) / Uint64FromInt32(UCHAR_MAX) * Uint64FromInt32(c) w = s for { - if !(!((*(*uint64)(unsafe.Pointer(w))-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^*(*uint64)(unsafe.Pointer(w)) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0) && !((*(*uint64)(unsafe.Pointer(w))^k-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^(*(*uint64)(unsafe.Pointer(w))^k) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { + if !(!((**(**uint64)(__ccgo_up(w))-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^**(**uint64)(__ccgo_up(w)) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0) && !((**(**uint64)(__ccgo_up(w))^k-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^(**(**uint64)(__ccgo_up(w))^k) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { break } goto _2 @@ -147114,7 +147114,7 @@ func X__strchrnul(tls *TLS, s uintptr, c int32) (r uintptr) { } s = w for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != c) { + if !(**(**uint8)(__ccgo_up(s)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != c) { break } goto _3 @@ -147148,7 +147148,7 @@ func Xstrcmp(tls *TLS, l uintptr, r uintptr) (r1 int32) { defer func() { trc("-> %v", r1) }() } for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) && *(*uint8)(unsafe.Pointer(l)) != 0) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(l))) == Int32FromUint8(**(**uint8)(__ccgo_up(r))) && **(**uint8)(__ccgo_up(l)) != 0) { break } goto _1 @@ -147157,7 +147157,7 @@ func Xstrcmp(tls *TLS, l uintptr, r uintptr) (r1 int32) { l = l + 1 r = r + 1 } - return Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) + return Int32FromUint8(**(**uint8)(__ccgo_up(l))) - Int32FromUint8(**(**uint8)(__ccgo_up(r))) } func Xstrcpy(tls *TLS, dest uintptr, src uintptr) (r uintptr) { @@ -147181,14 +147181,14 @@ func Xstrcspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { var _ /* byteset at bp+0 */ [4]Tsize_t _, _, _ = a, v2, v3 a = s - if !(*(*uint8)(unsafe.Pointer(c)) != 0) || !(*(*uint8)(unsafe.Pointer(c + 1)) != 0) { - return Uint64FromInt64(int64(X__strchrnul(tls, s, Int32FromUint8(*(*uint8)(unsafe.Pointer(c))))) - int64(a)) + if !(**(**uint8)(__ccgo_up(c)) != 0) || !(**(**uint8)(__ccgo_up(c + 1)) != 0) { + return Uint64FromInt64(int64(X__strchrnul(tls, s, Int32FromUint8(**(**uint8)(__ccgo_up(c))))) - int64(a)) } Xmemset(tls, bp, 0, uint64(32)) for { - if v3 = *(*uint8)(unsafe.Pointer(c)) != 0; v3 { - v2 = bp + uintptr(uint64(*(*uint8)(unsafe.Pointer(c)))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 - *(*Tsize_t)(unsafe.Pointer(v2)) |= Uint64FromInt32(1) << (uint64(*(*uint8)(unsafe.Pointer(c))) % (Uint64FromInt32(8) * Uint64FromInt64(8))) + if v3 = **(**uint8)(__ccgo_up(c)) != 0; v3 { + v2 = bp + uintptr(uint64(**(**uint8)(__ccgo_up(c)))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 + *(*Tsize_t)(unsafe.Pointer(v2)) |= Uint64FromInt32(1) << (uint64(**(**uint8)(__ccgo_up(c))) % (Uint64FromInt32(8) * Uint64FromInt64(8))) } if !(v3 && *(*Tsize_t)(unsafe.Pointer(v2)) != 0) { break @@ -147199,7 +147199,7 @@ func Xstrcspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { c = c + 1 } for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0 && !((*(*[4]Tsize_t)(unsafe.Pointer(bp)))[uint64(*(*uint8)(unsafe.Pointer(s)))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(*(*uint8)(unsafe.Pointer(s)))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0)) { + if !(**(**uint8)(__ccgo_up(s)) != 0 && !((**(**[4]Tsize_t)(__ccgo_up(bp)))[uint64(**(**uint8)(__ccgo_up(s)))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(**(**uint8)(__ccgo_up(s)))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0)) { break } goto _4 @@ -147239,7 +147239,7 @@ func Xstrerror_r(tls *TLS, err int32, buf uintptr, buflen Tsize_t) (r int32) { if l >= buflen { if buflen != 0 { Xmemcpy(tls, buf, msg, buflen-uint64(1)) - *(*uint8)(unsafe.Pointer(buf + uintptr(buflen-uint64(1)))) = uint8(0) + **(**uint8)(__ccgo_up(buf + uintptr(buflen-uint64(1)))) = uint8(0) } return int32(ERANGE) } @@ -147299,8 +147299,8 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { if uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) == uint64(d)&(Uint64FromInt64(8)-Uint64FromInt32(1)) { for { if v4 = uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) != 0 && n != 0; v4 { - v3 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v3 + v3 = **(**uint8)(__ccgo_up(s)) + **(**uint8)(__ccgo_up(d)) = v3 } if !(v4 && v3 != 0) { break @@ -147312,14 +147312,14 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { s = s + 1 d = d + 1 } - if n != 0 && *(*uint8)(unsafe.Pointer(s)) != 0 { + if n != 0 && **(**uint8)(__ccgo_up(s)) != 0 { wd = d ws = s for { - if !(n >= uint64(8) && !((*(*uint64)(unsafe.Pointer(ws))-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^*(*uint64)(unsafe.Pointer(ws)) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { + if !(n >= uint64(8) && !((**(**uint64)(__ccgo_up(ws))-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^**(**uint64)(__ccgo_up(ws)) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { break } - *(*Tsize_t)(unsafe.Pointer(wd)) = *(*uint64)(unsafe.Pointer(ws)) + **(**Tsize_t)(__ccgo_up(wd)) = **(**uint64)(__ccgo_up(ws)) goto _5 _5: ; @@ -147333,8 +147333,8 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { } for { if v4 = n != 0; v4 { - v3 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v3 + v3 = **(**uint8)(__ccgo_up(s)) + **(**uint8)(__ccgo_up(d)) = v3 } if !(v4 && v3 != 0) { break @@ -147346,7 +147346,7 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { s = s + 1 d = d + 1 } - *(*uint8)(unsafe.Pointer(d)) = uint8(0) + **(**uint8)(__ccgo_up(d)) = uint8(0) goto finish finish: ; @@ -147372,7 +147372,7 @@ func Xstrncasecmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { return 0 } for { - if !(*(*uint8)(unsafe.Pointer(l)) != 0 && *(*uint8)(unsafe.Pointer(r)) != 0 && n != 0 && (Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) || Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(l)))) == Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))))) { + if !(**(**uint8)(__ccgo_up(l)) != 0 && **(**uint8)(__ccgo_up(r)) != 0 && n != 0 && (Int32FromUint8(**(**uint8)(__ccgo_up(l))) == Int32FromUint8(**(**uint8)(__ccgo_up(r))) || Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(l)))) == Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(r)))))) { break } goto _2 @@ -147382,7 +147382,7 @@ func Xstrncasecmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { r = r + 1 n = n - 1 } - return Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(l)))) - Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))) + return Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(l)))) - Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(r)))) } func X__strncasecmp_l(tls *TLS, l uintptr, r uintptr, n Tsize_t, loc Tlocale_t) (r1 int32) { @@ -147410,17 +147410,17 @@ func Xstrncat(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { _, _, _ = a, v1, v2 a = d d = d + uintptr(_strlen(tls, d)) - for n != 0 && *(*uint8)(unsafe.Pointer(s)) != 0 { + for n != 0 && **(**uint8)(__ccgo_up(s)) != 0 { n = n - 1 v1 = d d = d + 1 v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v1)) = *(*uint8)(unsafe.Pointer(v2)) + **(**uint8)(__ccgo_up(v1)) = **(**uint8)(__ccgo_up(v2)) } v1 = d d = d + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) return a } @@ -147440,7 +147440,7 @@ func Xstrncmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { return 0 } for { - if !(*(*uint8)(unsafe.Pointer(l)) != 0 && *(*uint8)(unsafe.Pointer(r)) != 0 && n != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))) { + if !(**(**uint8)(__ccgo_up(l)) != 0 && **(**uint8)(__ccgo_up(r)) != 0 && n != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(l))) == Int32FromUint8(**(**uint8)(__ccgo_up(r)))) { break } goto _2 @@ -147450,7 +147450,7 @@ func Xstrncmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { r = r + 1 n = n - 1 } - return Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) + return Int32FromUint8(**(**uint8)(__ccgo_up(l))) - Int32FromUint8(**(**uint8)(__ccgo_up(r))) } func Xstrncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { @@ -147476,7 +147476,7 @@ func Xstrndup(tls *TLS, s uintptr, n Tsize_t) (r uintptr) { return UintptrFromInt32(0) } Xmemcpy(tls, d, s, l) - *(*uint8)(unsafe.Pointer(d + uintptr(l))) = uint8(0) + **(**uint8)(__ccgo_up(d + uintptr(l))) = uint8(0) return d } @@ -147505,7 +147505,7 @@ func Xstrpbrk(tls *TLS, s uintptr, b uintptr) (r uintptr) { var v1 uintptr _ = v1 s = s + uintptr(Xstrcspn(tls, s, b)) - if *(*uint8)(unsafe.Pointer(s)) != 0 { + if **(**uint8)(__ccgo_up(s)) != 0 { v1 = s } else { v1 = uintptr(0) @@ -147528,19 +147528,19 @@ func Xstrsep(tls *TLS, str uintptr, sep uintptr) (r uintptr) { } var end, s, v1 uintptr _, _, _ = end, s, v1 - s = *(*uintptr)(unsafe.Pointer(str)) + s = **(**uintptr)(__ccgo_up(str)) if !(s != 0) { return UintptrFromInt32(0) } end = s + uintptr(Xstrcspn(tls, s, sep)) - if *(*uint8)(unsafe.Pointer(end)) != 0 { + if **(**uint8)(__ccgo_up(end)) != 0 { v1 = end end = end + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) } else { end = uintptr(0) } - *(*uintptr)(unsafe.Pointer(str)) = end + **(**uintptr)(__ccgo_up(str)) = end return s } @@ -147566,7 +147566,7 @@ func Xstrsignal(tls *TLS, signum int32) (r uintptr) { break } for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { break } goto _3 @@ -147594,13 +147594,13 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { var _ /* byteset at bp+0 */ [4]Tsize_t _, _, _ = a, v3, v4 a = s - *(*[4]Tsize_t)(unsafe.Pointer(bp)) = [4]Tsize_t{} - if !(*(*uint8)(unsafe.Pointer(c)) != 0) { + **(**[4]Tsize_t)(__ccgo_up(bp)) = [4]Tsize_t{} + if !(**(**uint8)(__ccgo_up(c)) != 0) { return uint64(0) } - if !(*(*uint8)(unsafe.Pointer(c + 1)) != 0) { + if !(**(**uint8)(__ccgo_up(c + 1)) != 0) { for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(c)))) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(s))) == Int32FromUint8(**(**uint8)(__ccgo_up(c)))) { break } goto _1 @@ -147611,9 +147611,9 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { return Uint64FromInt64(int64(s) - int64(a)) } for { - if v4 = *(*uint8)(unsafe.Pointer(c)) != 0; v4 { - v3 = bp + uintptr(uint64(*(*uint8)(unsafe.Pointer(c)))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 - *(*Tsize_t)(unsafe.Pointer(v3)) |= Uint64FromInt32(1) << (uint64(*(*uint8)(unsafe.Pointer(c))) % (Uint64FromInt32(8) * Uint64FromInt64(8))) + if v4 = **(**uint8)(__ccgo_up(c)) != 0; v4 { + v3 = bp + uintptr(uint64(**(**uint8)(__ccgo_up(c)))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 + *(*Tsize_t)(unsafe.Pointer(v3)) |= Uint64FromInt32(1) << (uint64(**(**uint8)(__ccgo_up(c))) % (Uint64FromInt32(8) * Uint64FromInt64(8))) } if !(v4 && *(*Tsize_t)(unsafe.Pointer(v3)) != 0) { break @@ -147624,7 +147624,7 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { c = c + 1 } for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0 && (*(*[4]Tsize_t)(unsafe.Pointer(bp)))[uint64(*(*uint8)(unsafe.Pointer(s)))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(*(*uint8)(unsafe.Pointer(s)))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0 && (**(**[4]Tsize_t)(__ccgo_up(bp)))[uint64(**(**uint8)(__ccgo_up(s)))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(**(**uint8)(__ccgo_up(s)))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0) { break } goto _5 @@ -147639,11 +147639,11 @@ func _twobyte_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { var hw, nw Tuint16_t var v2 uintptr _, _, _ = hw, nw, v2 - nw = Uint16FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(n)))< Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(ip+k)))) > Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(jp+k)))) { jp = jp + k k = uint64(1) p = jp - ip @@ -147777,7 +147777,7 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { p = v2 k = v2 for jp+k < l { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(ip+k)))) == Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(jp+k)))) { if k == p { jp = jp + p k = uint64(1) @@ -147785,7 +147785,7 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { k = k + 1 } } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) < Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(ip+k)))) < Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(jp+k)))) { jp = jp + k k = uint64(1) p = jp - ip @@ -147836,8 +147836,8 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { } } /* Check last byte first; advance by shift on mismatch */ - if (*(*[4]Tsize_t)(unsafe.Pointer(bp)))[uint64(*(*uint8)(unsafe.Pointer(h + uintptr(l-uint64(1)))))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(*(*uint8)(unsafe.Pointer(h + uintptr(l-uint64(1)))))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0 { - k = l - shift[*(*uint8)(unsafe.Pointer(h + uintptr(l-uint64(1))))] + if (**(**[4]Tsize_t)(__ccgo_up(bp)))[uint64(**(**uint8)(__ccgo_up(h + uintptr(l-uint64(1)))))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(**(**uint8)(__ccgo_up(h + uintptr(l-uint64(1)))))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0 { + k = l - shift[**(**uint8)(__ccgo_up(h + uintptr(l-uint64(1))))] if k != 0 { if k < mem { k = mem @@ -147859,7 +147859,7 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { } k = v8 for { - if !(*(*uint8)(unsafe.Pointer(n + uintptr(k))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(h + uintptr(k))))) { + if !(**(**uint8)(__ccgo_up(n + uintptr(k))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(k)))) == Int32FromUint8(**(**uint8)(__ccgo_up(h + uintptr(k))))) { break } goto _10 @@ -147867,7 +147867,7 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { ; k = k + 1 } - if *(*uint8)(unsafe.Pointer(n + uintptr(k))) != 0 { + if **(**uint8)(__ccgo_up(n + uintptr(k))) != 0 { h = h + uintptr(k-ms) mem = uint64(0) goto _9 @@ -147875,7 +147875,7 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { /* Compare left half */ k = ms + uint64(1) for { - if !(k > mem && Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(k-uint64(1))))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(h + uintptr(k-uint64(1)))))) { + if !(k > mem && Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(k-uint64(1))))) == Int32FromUint8(**(**uint8)(__ccgo_up(h + uintptr(k-uint64(1)))))) { break } goto _12 @@ -147900,30 +147900,30 @@ func Xstrstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { defer func() { trc("-> %v", r) }() } /* Return immediately on empty needle */ - if !(*(*uint8)(unsafe.Pointer(n)) != 0) { + if !(**(**uint8)(__ccgo_up(n)) != 0) { return h } /* Use faster algorithms for short needles */ - h = Xstrchr(tls, h, Int32FromUint8(*(*uint8)(unsafe.Pointer(n)))) - if !(h != 0) || !(*(*uint8)(unsafe.Pointer(n + 1)) != 0) { + h = Xstrchr(tls, h, Int32FromUint8(**(**uint8)(__ccgo_up(n)))) + if !(h != 0) || !(**(**uint8)(__ccgo_up(n + 1)) != 0) { return h } - if !(*(*uint8)(unsafe.Pointer(h + 1)) != 0) { + if !(**(**uint8)(__ccgo_up(h + 1)) != 0) { return uintptr(0) } - if !(*(*uint8)(unsafe.Pointer(n + 2)) != 0) { + if !(**(**uint8)(__ccgo_up(n + 2)) != 0) { return _twobyte_strstr(tls, h, n) } - if !(*(*uint8)(unsafe.Pointer(h + 2)) != 0) { + if !(**(**uint8)(__ccgo_up(h + 2)) != 0) { return uintptr(0) } - if !(*(*uint8)(unsafe.Pointer(n + 3)) != 0) { + if !(**(**uint8)(__ccgo_up(n + 3)) != 0) { return _threebyte_strstr(tls, h, n) } - if !(*(*uint8)(unsafe.Pointer(h + 3)) != 0) { + if !(**(**uint8)(__ccgo_up(h + 3)) != 0) { return uintptr(0) } - if !(*(*uint8)(unsafe.Pointer(n + 4)) != 0) { + if !(**(**uint8)(__ccgo_up(n + 4)) != 0) { return _fourbyte_strstr(tls, h, n) } return _twoway_strstr(tls, h, n) @@ -147945,16 +147945,16 @@ func Xstrtok(tls *TLS, s uintptr, sep uintptr) (r uintptr) { return UintptrFromInt32(0) } s = s + uintptr(Xstrspn(tls, s, sep)) - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { v1 = UintptrFromInt32(0) _p2 = v1 return v1 } _p2 = s + uintptr(Xstrcspn(tls, s, sep)) - if *(*uint8)(unsafe.Pointer(_p2)) != 0 { + if **(**uint8)(__ccgo_up(_p2)) != 0 { v1 = _p2 _p2 = _p2 + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) } else { _p2 = uintptr(0) } @@ -147972,26 +147972,26 @@ func Xstrtok_r(tls *TLS, s uintptr, sep uintptr, p uintptr) (r uintptr) { var v2 bool _, _, _ = v1, v2, v3 if v2 = !(s != 0); v2 { - v1 = *(*uintptr)(unsafe.Pointer(p)) + v1 = **(**uintptr)(__ccgo_up(p)) s = v1 } if v2 && !(v1 != 0) { return UintptrFromInt32(0) } s = s + uintptr(Xstrspn(tls, s, sep)) - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { v1 = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(p)) = v1 + **(**uintptr)(__ccgo_up(p)) = v1 return v1 } - *(*uintptr)(unsafe.Pointer(p)) = s + uintptr(Xstrcspn(tls, s, sep)) - if *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)))) != 0 { + **(**uintptr)(__ccgo_up(p)) = s + uintptr(Xstrcspn(tls, s, sep)) + if **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)))) != 0 { v3 = p v1 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) } else { - *(*uintptr)(unsafe.Pointer(p)) = uintptr(0) + **(**uintptr)(__ccgo_up(p)) = uintptr(0) } return s } @@ -148014,10 +148014,10 @@ func Xstrverscmp(tls *TLS, l0 uintptr, r0 uintptr) (r1 int32) { i = v2 dp = v2 for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(l + uintptr(i)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(r + uintptr(i))))) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(l + uintptr(i)))) == Int32FromUint8(**(**uint8)(__ccgo_up(r + uintptr(i))))) { break } - c = Int32FromUint8(*(*uint8)(unsafe.Pointer(l + uintptr(i)))) + c = Int32FromUint8(**(**uint8)(__ccgo_up(l + uintptr(i)))) if !(c != 0) { return 0 } @@ -148034,15 +148034,15 @@ func Xstrverscmp(tls *TLS, l0 uintptr, r0 uintptr) (r1 int32) { ; i = i + 1 } - if Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(l + uintptr(dp))))-int32('1')) < uint32(9) && Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(r + uintptr(dp))))-int32('1')) < uint32(9) { + if Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(l + uintptr(dp))))-int32('1')) < uint32(9) && Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(r + uintptr(dp))))-int32('1')) < uint32(9) { /* If we're looking at non-degenerate digit sequences starting * with nonzero digits, longest digit string is greater. */ j = i for { - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(l + uintptr(j))))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(l + uintptr(j))))-uint32('0') < uint32(10)) != 0) { break } - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(r + uintptr(j))))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(r + uintptr(j))))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return int32(1) } goto _3 @@ -148050,17 +148050,17 @@ func Xstrverscmp(tls *TLS, l0 uintptr, r0 uintptr) (r1 int32) { ; j = j + 1 } - if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(r + uintptr(j))))-uint32('0') < uint32(10)) != 0 { + if BoolInt32(uint32(**(**uint8)(__ccgo_up(r + uintptr(j))))-uint32('0') < uint32(10)) != 0 { return -int32(1) } } else { - if z != 0 && dp < i && (BoolInt32(uint32(*(*uint8)(unsafe.Pointer(l + uintptr(i))))-uint32('0') < uint32(10)) != 0 || BoolInt32(uint32(*(*uint8)(unsafe.Pointer(r + uintptr(i))))-uint32('0') < uint32(10)) != 0) { + if z != 0 && dp < i && (BoolInt32(uint32(**(**uint8)(__ccgo_up(l + uintptr(i))))-uint32('0') < uint32(10)) != 0 || BoolInt32(uint32(**(**uint8)(__ccgo_up(r + uintptr(i))))-uint32('0') < uint32(10)) != 0) { /* Otherwise, if common prefix of digit sequence is * all zeros, digits order less than non-digits. */ - return Int32FromUint8(Uint8FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(l + uintptr(i))))-Int32FromUint8('0'))) - Int32FromUint8(Uint8FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(r + uintptr(i))))-Int32FromUint8('0'))) + return Int32FromUint8(Uint8FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(l + uintptr(i))))-Int32FromUint8('0'))) - Int32FromUint8(Uint8FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(r + uintptr(i))))-Int32FromUint8('0'))) } } - return Int32FromUint8(*(*uint8)(unsafe.Pointer(l + uintptr(i)))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r + uintptr(i)))) + return Int32FromUint8(**(**uint8)(__ccgo_up(l + uintptr(i)))) - Int32FromUint8(**(**uint8)(__ccgo_up(r + uintptr(i)))) } func Xswab(tls *TLS, _src uintptr, _dest uintptr, n Tssize_t) { @@ -148075,8 +148075,8 @@ func Xswab(tls *TLS, _src uintptr, _dest uintptr, n Tssize_t) { if !(n > int64(1)) { break } - *(*uint8)(unsafe.Pointer(dest)) = *(*uint8)(unsafe.Pointer(src + 1)) - *(*uint8)(unsafe.Pointer(dest + 1)) = *(*uint8)(unsafe.Pointer(src)) + **(**uint8)(__ccgo_up(dest)) = **(**uint8)(__ccgo_up(src + 1)) + **(**uint8)(__ccgo_up(dest + 1)) = **(**uint8)(__ccgo_up(src)) dest = dest + uintptr(2) src = src + uintptr(2) goto _1 @@ -148138,7 +148138,7 @@ func Xwcschr(tls *TLS, s uintptr, c Twchar_t) (r uintptr) { return s + uintptr(Xwcslen(tls, s))*4 } for { - if !(*(*Twchar_t)(unsafe.Pointer(s)) != 0 && *(*Twchar_t)(unsafe.Pointer(s)) != c) { + if !(**(**Twchar_t)(__ccgo_up(s)) != 0 && **(**Twchar_t)(__ccgo_up(s)) != c) { break } goto _1 @@ -148146,7 +148146,7 @@ func Xwcschr(tls *TLS, s uintptr, c Twchar_t) (r uintptr) { ; s += 4 } - if *(*Twchar_t)(unsafe.Pointer(s)) != 0 { + if **(**Twchar_t)(__ccgo_up(s)) != 0 { v2 = s } else { v2 = uintptr(0) @@ -148162,7 +148162,7 @@ func Xwcscmp(tls *TLS, l uintptr, r uintptr) (r1 int32) { var v2 int32 _ = v2 for { - if !(*(*Twchar_t)(unsafe.Pointer(l)) == *(*Twchar_t)(unsafe.Pointer(r)) && *(*Twchar_t)(unsafe.Pointer(l)) != 0 && *(*Twchar_t)(unsafe.Pointer(r)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(l)) == **(**Twchar_t)(__ccgo_up(r)) && **(**Twchar_t)(__ccgo_up(l)) != 0 && **(**Twchar_t)(__ccgo_up(r)) != 0) { break } goto _1 @@ -148171,10 +148171,10 @@ func Xwcscmp(tls *TLS, l uintptr, r uintptr) (r1 int32) { l += 4 r += 4 } - if *(*Twchar_t)(unsafe.Pointer(l)) < *(*Twchar_t)(unsafe.Pointer(r)) { + if **(**Twchar_t)(__ccgo_up(l)) < **(**Twchar_t)(__ccgo_up(r)) { v2 = -int32(1) } else { - v2 = BoolInt32(*(*Twchar_t)(unsafe.Pointer(l)) > *(*Twchar_t)(unsafe.Pointer(r))) + v2 = BoolInt32(**(**Twchar_t)(__ccgo_up(l)) > **(**Twchar_t)(__ccgo_up(r))) } return v2 } @@ -148191,10 +148191,10 @@ func Xwcscpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { for { v2 = s s += 4 - v1 = *(*Twchar_t)(unsafe.Pointer(v2)) + v1 = **(**Twchar_t)(__ccgo_up(v2)) v3 = d d += 4 - *(*Twchar_t)(unsafe.Pointer(v3)) = v1 + **(**Twchar_t)(__ccgo_up(v3)) = v1 if !(v1 != 0) { break } @@ -148210,13 +148210,13 @@ func Xwcscspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { var a, v2, v3 uintptr var v1 uint64 _, _, _, _ = a, v1, v2, v3 - if !(*(*Twchar_t)(unsafe.Pointer(c)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(c)) != 0) { return Xwcslen(tls, s) } - if !(*(*Twchar_t)(unsafe.Pointer(c + 1*4)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(c + 1*4)) != 0) { v3 = s a = v3 - v2 = Xwcschr(tls, v3, *(*Twchar_t)(unsafe.Pointer(c))) + v2 = Xwcschr(tls, v3, **(**Twchar_t)(__ccgo_up(c))) s = v2 if v2 != 0 { v1 = Uint64FromInt64((int64(s) - int64(a)) / 4) @@ -148227,7 +148227,7 @@ func Xwcscspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { } a = s for { - if !(*(*Twchar_t)(unsafe.Pointer(s)) != 0 && !(Xwcschr(tls, c, *(*Twchar_t)(unsafe.Pointer(s))) != 0)) { + if !(**(**Twchar_t)(__ccgo_up(s)) != 0 && !(Xwcschr(tls, c, **(**Twchar_t)(__ccgo_up(s))) != 0)) { break } goto _4 @@ -148263,7 +148263,7 @@ func Xwcslen(tls *TLS, s uintptr) (r Tsize_t) { _ = a a = s for { - if !(*(*Twchar_t)(unsafe.Pointer(s)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(s)) != 0) { break } goto _1 @@ -148287,7 +148287,7 @@ func Xwcsncasecmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { return 0 } for { - if !(*(*Twchar_t)(unsafe.Pointer(l)) != 0 && *(*Twchar_t)(unsafe.Pointer(r)) != 0 && n != 0 && (*(*Twchar_t)(unsafe.Pointer(l)) == *(*Twchar_t)(unsafe.Pointer(r)) || Xtowlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(l)))) == Xtowlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(r)))))) { + if !(**(**Twchar_t)(__ccgo_up(l)) != 0 && **(**Twchar_t)(__ccgo_up(r)) != 0 && n != 0 && (**(**Twchar_t)(__ccgo_up(l)) == **(**Twchar_t)(__ccgo_up(r)) || Xtowlower(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(l)))) == Xtowlower(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(r)))))) { break } goto _2 @@ -148297,7 +148297,7 @@ func Xwcsncasecmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { r += 4 n = n - 1 } - return Int32FromUint32(Xtowlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(l)))) - Xtowlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(r))))) + return Int32FromUint32(Xtowlower(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(l)))) - Xtowlower(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(r))))) } func Xwcsncasecmp_l(tls *TLS, l uintptr, r uintptr, n Tsize_t, locale Tlocale_t) (r1 int32) { @@ -148317,17 +148317,17 @@ func Xwcsncat(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { _, _, _ = a, v1, v2 a = d d = d + uintptr(Xwcslen(tls, d))*4 - for n != 0 && *(*Twchar_t)(unsafe.Pointer(s)) != 0 { + for n != 0 && **(**Twchar_t)(__ccgo_up(s)) != 0 { n = n - 1 v1 = d d += 4 v2 = s s += 4 - *(*Twchar_t)(unsafe.Pointer(v1)) = *(*Twchar_t)(unsafe.Pointer(v2)) + **(**Twchar_t)(__ccgo_up(v1)) = **(**Twchar_t)(__ccgo_up(v2)) } v1 = d d += 4 - *(*Twchar_t)(unsafe.Pointer(v1)) = 0 + **(**Twchar_t)(__ccgo_up(v1)) = 0 return a } @@ -148339,7 +148339,7 @@ func Xwcsncmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { var v2, v3 int32 _, _ = v2, v3 for { - if !(n != 0 && *(*Twchar_t)(unsafe.Pointer(l)) == *(*Twchar_t)(unsafe.Pointer(r)) && *(*Twchar_t)(unsafe.Pointer(l)) != 0 && *(*Twchar_t)(unsafe.Pointer(r)) != 0) { + if !(n != 0 && **(**Twchar_t)(__ccgo_up(l)) == **(**Twchar_t)(__ccgo_up(r)) && **(**Twchar_t)(__ccgo_up(l)) != 0 && **(**Twchar_t)(__ccgo_up(r)) != 0) { break } goto _1 @@ -148350,10 +148350,10 @@ func Xwcsncmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { r += 4 } if n != 0 { - if *(*Twchar_t)(unsafe.Pointer(l)) < *(*Twchar_t)(unsafe.Pointer(r)) { + if **(**Twchar_t)(__ccgo_up(l)) < **(**Twchar_t)(__ccgo_up(r)) { v3 = -int32(1) } else { - v3 = BoolInt32(*(*Twchar_t)(unsafe.Pointer(l)) > *(*Twchar_t)(unsafe.Pointer(r))) + v3 = BoolInt32(**(**Twchar_t)(__ccgo_up(l)) > **(**Twchar_t)(__ccgo_up(r))) } v2 = v3 } else { @@ -148370,13 +148370,13 @@ func Xwcsncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { var a, v1, v2 uintptr _, _, _ = a, v1, v2 a = d - for n != 0 && *(*Twchar_t)(unsafe.Pointer(s)) != 0 { + for n != 0 && **(**Twchar_t)(__ccgo_up(s)) != 0 { n = n - 1 v1 = d d += 4 v2 = s s += 4 - *(*Twchar_t)(unsafe.Pointer(v1)) = *(*Twchar_t)(unsafe.Pointer(v2)) + **(**Twchar_t)(__ccgo_up(v1)) = **(**Twchar_t)(__ccgo_up(v2)) } Xwmemset(tls, d, 0, n) return a @@ -148404,7 +148404,7 @@ func Xwcspbrk(tls *TLS, s uintptr, b uintptr) (r uintptr) { var v1 uintptr _ = v1 s = s + uintptr(Xwcscspn(tls, s, b))*4 - if *(*Twchar_t)(unsafe.Pointer(s)) != 0 { + if **(**Twchar_t)(__ccgo_up(s)) != 0 { v1 = s } else { v1 = UintptrFromInt32(0) @@ -148421,7 +148421,7 @@ func Xwcsrchr(tls *TLS, s uintptr, c Twchar_t) (r uintptr) { _, _ = p, v2 p = s + uintptr(Xwcslen(tls, s))*4 for { - if !(p >= s && *(*Twchar_t)(unsafe.Pointer(p)) != c) { + if !(p >= s && **(**Twchar_t)(__ccgo_up(p)) != c) { break } goto _1 @@ -148446,7 +148446,7 @@ func Xwcsspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { _ = a a = s for { - if !(*(*Twchar_t)(unsafe.Pointer(s)) != 0 && Xwcschr(tls, c, *(*Twchar_t)(unsafe.Pointer(s))) != 0) { + if !(**(**Twchar_t)(__ccgo_up(s)) != 0 && Xwcschr(tls, c, **(**Twchar_t)(__ccgo_up(s))) != 0) { break } goto _1 @@ -148465,7 +148465,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { /* Computing length of needle */ l = uint64(0) for { - if !(*(*Twchar_t)(unsafe.Pointer(n + uintptr(l)*4)) != 0 && *(*Twchar_t)(unsafe.Pointer(h + uintptr(l)*4)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(n + uintptr(l)*4)) != 0 && **(**Twchar_t)(__ccgo_up(h + uintptr(l)*4)) != 0) { break } goto _1 @@ -148473,7 +148473,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { ; l = l + 1 } - if *(*Twchar_t)(unsafe.Pointer(n + uintptr(l)*4)) != 0 { + if **(**Twchar_t)(__ccgo_up(n + uintptr(l)*4)) != 0 { return uintptr(0) } /* hit the end of h */ /* Compute maximal suffix */ @@ -148483,7 +148483,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { p = v2 k = v2 for jp+k < l { - if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) == *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { + if **(**Twchar_t)(__ccgo_up(n + uintptr(ip+k)*4)) == **(**Twchar_t)(__ccgo_up(n + uintptr(jp+k)*4)) { if k == p { jp = jp + p k = uint64(1) @@ -148491,7 +148491,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { k = k + 1 } } else { - if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) > *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { + if **(**Twchar_t)(__ccgo_up(n + uintptr(ip+k)*4)) > **(**Twchar_t)(__ccgo_up(n + uintptr(jp+k)*4)) { jp = jp + k k = uint64(1) p = jp - ip @@ -148514,7 +148514,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { p = v2 k = v2 for jp+k < l { - if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) == *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { + if **(**Twchar_t)(__ccgo_up(n + uintptr(ip+k)*4)) == **(**Twchar_t)(__ccgo_up(n + uintptr(jp+k)*4)) { if k == p { jp = jp + p k = uint64(1) @@ -148522,7 +148522,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { k = k + 1 } } else { - if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) < *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { + if **(**Twchar_t)(__ccgo_up(n + uintptr(ip+k)*4)) < **(**Twchar_t)(__ccgo_up(n + uintptr(jp+k)*4)) { jp = jp + k k = uint64(1) p = jp - ip @@ -148580,7 +148580,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { } k = v8 for { - if !(*(*Twchar_t)(unsafe.Pointer(n + uintptr(k)*4)) != 0 && *(*Twchar_t)(unsafe.Pointer(n + uintptr(k)*4)) == *(*Twchar_t)(unsafe.Pointer(h + uintptr(k)*4))) { + if !(**(**Twchar_t)(__ccgo_up(n + uintptr(k)*4)) != 0 && **(**Twchar_t)(__ccgo_up(n + uintptr(k)*4)) == **(**Twchar_t)(__ccgo_up(h + uintptr(k)*4))) { break } goto _10 @@ -148588,7 +148588,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { ; k = k + 1 } - if *(*Twchar_t)(unsafe.Pointer(n + uintptr(k)*4)) != 0 { + if **(**Twchar_t)(__ccgo_up(n + uintptr(k)*4)) != 0 { h = h + uintptr(k-ms)*4 mem = uint64(0) goto _9 @@ -148596,7 +148596,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { /* Compare left half */ k = ms + uint64(1) for { - if !(k > mem && *(*Twchar_t)(unsafe.Pointer(n + uintptr(k-uint64(1))*4)) == *(*Twchar_t)(unsafe.Pointer(h + uintptr(k-uint64(1))*4))) { + if !(k > mem && **(**Twchar_t)(__ccgo_up(n + uintptr(k-uint64(1))*4)) == **(**Twchar_t)(__ccgo_up(h + uintptr(k-uint64(1))*4))) { break } goto _12 @@ -148621,18 +148621,18 @@ func Xwcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { defer func() { trc("-> %v", r) }() } /* Return immediately on empty needle or haystack */ - if !(*(*Twchar_t)(unsafe.Pointer(n)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(n)) != 0) { return h } - if !(*(*Twchar_t)(unsafe.Pointer(h)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(h)) != 0) { return uintptr(0) } /* Use faster algorithms for short needles */ - h = Xwcschr(tls, h, *(*Twchar_t)(unsafe.Pointer(n))) - if !(h != 0) || !(*(*Twchar_t)(unsafe.Pointer(n + 1*4)) != 0) { + h = Xwcschr(tls, h, **(**Twchar_t)(__ccgo_up(n))) + if !(h != 0) || !(**(**Twchar_t)(__ccgo_up(n + 1*4)) != 0) { return h } - if !(*(*Twchar_t)(unsafe.Pointer(h + 1*4)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(h + 1*4)) != 0) { return uintptr(0) } return _twoway_wcsstr(tls, h, n) @@ -148647,26 +148647,26 @@ func Xwcstok(tls *TLS, s uintptr, sep uintptr, p uintptr) (r uintptr) { var v2 bool _, _, _ = v1, v2, v3 if v2 = !(s != 0); v2 { - v1 = *(*uintptr)(unsafe.Pointer(p)) + v1 = **(**uintptr)(__ccgo_up(p)) s = v1 } if v2 && !(v1 != 0) { return UintptrFromInt32(0) } s = s + uintptr(Xwcsspn(tls, s, sep))*4 - if !(*(*Twchar_t)(unsafe.Pointer(s)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(s)) != 0) { v1 = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(p)) = v1 + **(**uintptr)(__ccgo_up(p)) = v1 return v1 } - *(*uintptr)(unsafe.Pointer(p)) = s + uintptr(Xwcscspn(tls, s, sep))*4 - if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)))) != 0 { + **(**uintptr)(__ccgo_up(p)) = s + uintptr(Xwcscspn(tls, s, sep))*4 + if **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(p)))) != 0 { v3 = p v1 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) += 4 - *(*Twchar_t)(unsafe.Pointer(v1)) = 0 + **(**Twchar_t)(__ccgo_up(v1)) = 0 } else { - *(*uintptr)(unsafe.Pointer(p)) = uintptr(0) + **(**uintptr)(__ccgo_up(p)) = uintptr(0) } return s } @@ -148687,7 +148687,7 @@ func Xwmemchr(tls *TLS, s uintptr, c Twchar_t, n Tsize_t) (r uintptr) { var v2 uintptr _ = v2 for { - if !(n != 0 && *(*Twchar_t)(unsafe.Pointer(s)) != c) { + if !(n != 0 && **(**Twchar_t)(__ccgo_up(s)) != c) { break } goto _1 @@ -148712,7 +148712,7 @@ func Xwmemcmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { var v2, v3 int32 _, _ = v2, v3 for { - if !(n != 0 && *(*Twchar_t)(unsafe.Pointer(l)) == *(*Twchar_t)(unsafe.Pointer(r))) { + if !(n != 0 && **(**Twchar_t)(__ccgo_up(l)) == **(**Twchar_t)(__ccgo_up(r))) { break } goto _1 @@ -148723,10 +148723,10 @@ func Xwmemcmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { r += 4 } if n != 0 { - if *(*Twchar_t)(unsafe.Pointer(l)) < *(*Twchar_t)(unsafe.Pointer(r)) { + if **(**Twchar_t)(__ccgo_up(l)) < **(**Twchar_t)(__ccgo_up(r)) { v3 = -int32(1) } else { - v3 = BoolInt32(*(*Twchar_t)(unsafe.Pointer(l)) > *(*Twchar_t)(unsafe.Pointer(r))) + v3 = BoolInt32(**(**Twchar_t)(__ccgo_up(l)) > **(**Twchar_t)(__ccgo_up(r))) } v2 = v3 } else { @@ -148754,7 +148754,7 @@ func Xwmemcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { d += 4 v3 = s s += 4 - *(*Twchar_t)(unsafe.Pointer(v2)) = *(*Twchar_t)(unsafe.Pointer(v3)) + **(**Twchar_t)(__ccgo_up(v2)) = **(**Twchar_t)(__ccgo_up(v3)) } return a } @@ -148778,7 +148778,7 @@ func Xwmemmove(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { if !(v1 != 0) { break } - *(*Twchar_t)(unsafe.Pointer(d + uintptr(n)*4)) = *(*Twchar_t)(unsafe.Pointer(s + uintptr(n)*4)) + **(**Twchar_t)(__ccgo_up(d + uintptr(n)*4)) = **(**Twchar_t)(__ccgo_up(s + uintptr(n)*4)) } } else { for { @@ -148791,7 +148791,7 @@ func Xwmemmove(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { d += 4 v4 = s s += 4 - *(*Twchar_t)(unsafe.Pointer(v3)) = *(*Twchar_t)(unsafe.Pointer(v4)) + **(**Twchar_t)(__ccgo_up(v3)) = **(**Twchar_t)(__ccgo_up(v4)) } } return d0 @@ -148814,7 +148814,7 @@ func Xwmemset(tls *TLS, d uintptr, c Twchar_t, n Tsize_t) (r uintptr) { } v2 = d d += 4 - *(*Twchar_t)(unsafe.Pointer(v2)) = c + **(**Twchar_t)(__ccgo_up(v2)) = c } return ret } @@ -148830,7 +148830,7 @@ func Xmkdtemp(tls *TLS, template uintptr) (r uintptr) { l = _strlen(tls, template) retries = int32(100) if l < uint64(6) || Xmemcmp(tls, template+uintptr(l)-uintptr(6), __ccgo_ts+1772, uint64(6)) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } for { @@ -148843,7 +148843,7 @@ func Xmkdtemp(tls *TLS, template uintptr) (r uintptr) { ; retries = retries - 1 v1 = retries - if !(v1 != 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EEXIST)) { + if !(v1 != 0 && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EEXIST)) { break } } @@ -148871,7 +148871,7 @@ func X__mkostemps(tls *TLS, template uintptr, len1 int32, flags int32) (r int32) _, _, _, _ = fd, l, retries, v1 l = _strlen(tls, template) if l < uint64(6) || Uint64FromInt32(len1) > l-uint64(6) || Xmemcmp(tls, template+uintptr(l)-uintptr(len1)-uintptr(6), __ccgo_ts+1772, uint64(6)) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } flags = flags - flags&(Int32FromInt32(03)|Int32FromInt32(O_PATH)) @@ -148888,7 +148888,7 @@ func X__mkostemps(tls *TLS, template uintptr, len1 int32, flags int32) (r int32) ; retries = retries - 1 v1 = retries - if !(v1 != 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EEXIST)) { + if !(v1 != 0 && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EEXIST)) { break } } @@ -148934,15 +148934,15 @@ func Xmktemp(tls *TLS, template uintptr) (r uintptr) { l = _strlen(tls, template) retries = int32(100) if l < uint64(6) || Xmemcmp(tls, template+uintptr(l)-uintptr(6), __ccgo_ts+1772, uint64(6)) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) - *(*uint8)(unsafe.Pointer(template)) = uint8(0) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) + **(**uint8)(__ccgo_up(template)) = uint8(0) return template } for { ___randname(tls, template+uintptr(l)-uintptr(6)) if Xstat(tls, template, bp) != 0 { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(ENOENT) { - *(*uint8)(unsafe.Pointer(template)) = uint8(0) + if **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(ENOENT) { + **(**uint8)(__ccgo_up(template)) = uint8(0) } return template } @@ -148955,8 +148955,8 @@ func Xmktemp(tls *TLS, template uintptr) (r uintptr) { break } } - *(*uint8)(unsafe.Pointer(template)) = uint8(0) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EEXIST) + **(**uint8)(__ccgo_up(template)) = uint8(0) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EEXIST) return template } @@ -148980,13 +148980,13 @@ func Xcfmakeraw(tls *TLS, t uintptr) { if __ccgo_strace { trc("tls=%v t=%v, (%v:)", tls, t, origin(2)) } - *(*Ttcflag_t)(unsafe.Pointer(t)) &= Uint32FromInt32(^(Int32FromInt32(IGNBRK) | Int32FromInt32(BRKINT) | Int32FromInt32(PARMRK) | Int32FromInt32(ISTRIP) | Int32FromInt32(INLCR) | Int32FromInt32(IGNCR) | Int32FromInt32(ICRNL) | Int32FromInt32(IXON))) - *(*Ttcflag_t)(unsafe.Pointer(t + 4)) &= Uint32FromInt32(^Int32FromInt32(OPOST)) - *(*Ttcflag_t)(unsafe.Pointer(t + 12)) &= Uint32FromInt32(^(Int32FromInt32(ECHO) | Int32FromInt32(ECHONL) | Int32FromInt32(ICANON) | Int32FromInt32(ISIG) | Int32FromInt32(IEXTEN))) - *(*Ttcflag_t)(unsafe.Pointer(t + 8)) &= Uint32FromInt32(^(Int32FromInt32(CSIZE) | Int32FromInt32(PARENB))) - *(*Ttcflag_t)(unsafe.Pointer(t + 8)) |= uint32(CS8) - *(*Tcc_t)(unsafe.Pointer(t + 16 + 5)) = uint8(1) - *(*Tcc_t)(unsafe.Pointer(t + 16 + 7)) = uint8(0) + **(**Ttcflag_t)(__ccgo_up(t)) &= Uint32FromInt32(^(Int32FromInt32(IGNBRK) | Int32FromInt32(BRKINT) | Int32FromInt32(PARMRK) | Int32FromInt32(ISTRIP) | Int32FromInt32(INLCR) | Int32FromInt32(IGNCR) | Int32FromInt32(ICRNL) | Int32FromInt32(IXON))) + **(**Ttcflag_t)(__ccgo_up(t + 4)) &= Uint32FromInt32(^Int32FromInt32(OPOST)) + **(**Ttcflag_t)(__ccgo_up(t + 12)) &= Uint32FromInt32(^(Int32FromInt32(ECHO) | Int32FromInt32(ECHONL) | Int32FromInt32(ICANON) | Int32FromInt32(ISIG) | Int32FromInt32(IEXTEN))) + **(**Ttcflag_t)(__ccgo_up(t + 8)) &= Uint32FromInt32(^(Int32FromInt32(CSIZE) | Int32FromInt32(PARENB))) + **(**Ttcflag_t)(__ccgo_up(t + 8)) |= uint32(CS8) + **(**Tcc_t)(__ccgo_up(t + 16 + 5)) = uint8(1) + **(**Tcc_t)(__ccgo_up(t + 16 + 7)) = uint8(0) } func Xcfsetospeed(tls *TLS, tio uintptr, speed Tspeed_t) (r int32) { @@ -148995,11 +148995,11 @@ func Xcfsetospeed(tls *TLS, tio uintptr, speed Tspeed_t) (r int32) { defer func() { trc("-> %v", r) }() } if speed&Uint32FromInt32(^Int32FromInt32(CBAUD)) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } - *(*Ttcflag_t)(unsafe.Pointer(tio + 8)) &= Uint32FromInt32(^Int32FromInt32(CBAUD)) - *(*Ttcflag_t)(unsafe.Pointer(tio + 8)) |= speed + **(**Ttcflag_t)(__ccgo_up(tio + 8)) &= Uint32FromInt32(^Int32FromInt32(CBAUD)) + **(**Ttcflag_t)(__ccgo_up(tio + 8)) |= speed return 0 } @@ -149078,7 +149078,7 @@ func Xtcgetsid(tls *TLS, fd int32) (r Tpid_t) { if Xioctl(tls, fd, int32(TIOCGSID), VaList(bp+16, bp)) < 0 { return -int32(1) } - return *(*int32)(unsafe.Pointer(bp)) + return **(**int32)(__ccgo_up(bp)) } func Xtcgetwinsize(tls *TLS, fd int32, wsz uintptr) (r int32) { @@ -149108,7 +149108,7 @@ func Xtcsetattr(tls *TLS, fd int32, act int32, tio uintptr) (r int32) { bp := tls.Alloc(16) defer tls.Free(16) if act < 0 || act > int32(2) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } return Xioctl(tls, fd, Int32FromUint64(uint64(Uint32FromUint32(4)<')) { + if !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)) + uintptr(i))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)) + uintptr(i)))) != int32('>')) { break } if i < int32(TZNAME_MAX) { - *(*uint8)(unsafe.Pointer(d + uintptr(i))) = *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))) + **(**uint8)(__ccgo_up(d + uintptr(i))) = **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)) + uintptr(i))) } goto _1 _1: ; i = i + 1 } - if *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))) != 0 { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + if **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)) + uintptr(i))) != 0 { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 } } else { i = 0 for { - if !(Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))))|int32(32)-int32('a')) < uint32(26)) { + if !(Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)) + uintptr(i))))|int32(32)-int32('a')) < uint32(26)) { break } if i < int32(TZNAME_MAX) { - *(*uint8)(unsafe.Pointer(d + uintptr(i))) = *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))) + **(**uint8)(__ccgo_up(d + uintptr(i))) = **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)) + uintptr(i))) } goto _2 _2: @@ -149452,17 +149452,17 @@ func _getname(tls *TLS, d uintptr, p uintptr) { i = i + 1 } } - *(*uintptr)(unsafe.Pointer(p)) += uintptr(i) + **(**uintptr)(__ccgo_up(p)) += uintptr(i) if i < int32(TZNAME_MAX) { v3 = i } else { v3 = int32(TZNAME_MAX) } - *(*uint8)(unsafe.Pointer(d + uintptr(v3))) = uint8(0) + **(**uint8)(__ccgo_up(d + uintptr(v3))) = uint8(0) } func _zi_read32(tls *TLS, z uintptr) (r Tuint32_t) { - return uint32(*(*uint8)(unsafe.Pointer(z)))< Uint64FromInt32(Int32FromInt32(PATH_MAX)+Int32FromInt32(1)) { - *(*uintptr)(unsafe.Pointer(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) + **(**uintptr)(__ccgo_up(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) i = Uint64FromInt32(3) } if i >= _old_tz_size { @@ -149545,13 +149545,13 @@ func _do_tzset(tls *TLS) { _old_tz = Xmalloc(tls, _old_tz_size) } if _old_tz != 0 { - Xmemcpy(tls, _old_tz, *(*uintptr)(unsafe.Pointer(bp + 288)), i+uint64(1)) + Xmemcpy(tls, _old_tz, **(**uintptr)(__ccgo_up(bp + 288)), i+uint64(1)) } posix_form = 0 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) != int32(':') { - *(*uintptr)(unsafe.Pointer(bp + 296)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) != int32(':') { + **(**uintptr)(__ccgo_up(bp + 296)) = **(**uintptr)(__ccgo_up(bp + 288)) _getname(tls, bp+308, bp+296) - if *(*uintptr)(unsafe.Pointer(bp + 296)) != *(*uintptr)(unsafe.Pointer(bp + 288)) && (Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 296))))) == int32('+') || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 296))))) == int32('-') || BoolInt32(uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 296)))))-uint32('0') < uint32(10)) != 0 || !(Xstrcmp(tls, bp+308, __ccgo_ts+1797) != 0) || !(Xstrcmp(tls, bp+308, __ccgo_ts+1801) != 0)) { + if **(**uintptr)(__ccgo_up(bp + 296)) != **(**uintptr)(__ccgo_up(bp + 288)) && (Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 296))))) == int32('+') || Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 296))))) == int32('-') || BoolInt32(uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 296)))))-uint32('0') < uint32(10)) != 0 || !(Xstrcmp(tls, bp+308, __ccgo_ts+1797) != 0) || !(Xstrcmp(tls, bp+308, __ccgo_ts+1801) != 0)) { posix_form = int32(1) } } @@ -149559,21 +149559,21 @@ func _do_tzset(tls *TLS) { * pathame beginning with "."; in secure mode, only the * standard path will be searched. */ if !(posix_form != 0) { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32(':') { - *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32(':') { + **(**uintptr)(__ccgo_up(bp + 288)) = **(**uintptr)(__ccgo_up(bp + 288)) + 1 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32('/') || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32('.') { - if !(X__libc.Fsecure != 0) || !(Xstrcmp(tls, *(*uintptr)(unsafe.Pointer(bp + 288)), __ccgo_ts+1782) != 0) { - map1 = X__map_file(tls, *(*uintptr)(unsafe.Pointer(bp + 288)), uintptr(unsafe.Pointer(&_map_size))) + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32('/') || Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32('.') { + if !(X__libc.Fsecure != 0) || !(Xstrcmp(tls, **(**uintptr)(__ccgo_up(bp + 288)), __ccgo_ts+1782) != 0) { + map1 = X__map_file(tls, **(**uintptr)(__ccgo_up(bp + 288)), uintptr(unsafe.Pointer(&_map_size))) } } else { - l = _strlen(tls, *(*uintptr)(unsafe.Pointer(bp + 288))) - if l <= uint64(NAME_MAX) && !(Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp + 288)), int32('.')) != 0) { - Xmemcpy(tls, pathname, *(*uintptr)(unsafe.Pointer(bp + 288)), l+uint64(1)) - *(*uint8)(unsafe.Pointer(pathname + uintptr(l))) = uint8(0) + l = _strlen(tls, **(**uintptr)(__ccgo_up(bp + 288))) + if l <= uint64(NAME_MAX) && !(Xstrchr(tls, **(**uintptr)(__ccgo_up(bp + 288)), int32('.')) != 0) { + Xmemcpy(tls, pathname, **(**uintptr)(__ccgo_up(bp + 288)), l+uint64(1)) + **(**uint8)(__ccgo_up(pathname + uintptr(l))) = uint8(0) try = uintptr(unsafe.Pointer(&_search)) for { - if !(!(map1 != 0) && *(*uint8)(unsafe.Pointer(try)) != 0) { + if !(!(map1 != 0) && **(**uint8)(__ccgo_up(try)) != 0) { break } l = _strlen(tls, try) @@ -149587,18 +149587,18 @@ func _do_tzset(tls *TLS) { } } if !(map1 != 0) { - *(*uintptr)(unsafe.Pointer(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) + **(**uintptr)(__ccgo_up(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) } } if map1 != 0 && (_map_size < uint64(44) || Xmemcmp(tls, map1, __ccgo_ts+1805, uint64(4)) != 0) { X__munmap(tls, map1, _map_size) map1 = uintptr(0) - *(*uintptr)(unsafe.Pointer(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) + **(**uintptr)(__ccgo_up(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) } _zi = map1 if map1 != 0 { scale = int32(2) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(map1 + 4))) != int32('1') { + if Int32FromUint8(**(**uint8)(__ccgo_up(map1 + 4))) != int32('1') { *(*[6]uint8)(unsafe.Pointer(bp)) = [6]uint8{ 0: uint8(1), 1: uint8(1), @@ -149617,18 +149617,18 @@ func _do_tzset(tls *TLS) { _types = _index + uintptr(_zi_read32(tls, _trans-uintptr(12))) _abbrevs = _types + uintptr(uint32(6)*_zi_read32(tls, _trans-uintptr(8))) _abbrevs_end = _abbrevs + uintptr(_zi_read32(tls, _trans-uintptr(4))) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(_zi + uintptr(_map_size-uint64(1))))) == int32('\n') { - *(*uintptr)(unsafe.Pointer(bp + 288)) = _zi + uintptr(_map_size) - uintptr(2) + if Int32FromUint8(**(**uint8)(__ccgo_up(_zi + uintptr(_map_size-uint64(1))))) == int32('\n') { + **(**uintptr)(__ccgo_up(bp + 288)) = _zi + uintptr(_map_size) - uintptr(2) for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) != int32('\n')) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) != int32('\n')) { break } goto _4 _4: ; - *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) - 1 + **(**uintptr)(__ccgo_up(bp + 288)) = **(**uintptr)(__ccgo_up(bp + 288)) - 1 } - *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 + **(**uintptr)(__ccgo_up(bp + 288)) = **(**uintptr)(__ccgo_up(bp + 288)) + 1 } else { v5 = UintptrFromInt32(0) Xtzname[int32(1)] = v5 @@ -149643,12 +149643,12 @@ func _do_tzset(tls *TLS) { if !(p1 < _abbrevs) { break } - if !(*(*uint8)(unsafe.Pointer(p1 + 4)) != 0) && !(Xtzname[0] != 0) { - Xtzname[0] = _abbrevs + uintptr(*(*uint8)(unsafe.Pointer(p1 + 5))) + if !(**(**uint8)(__ccgo_up(p1 + 4)) != 0) && !(Xtzname[0] != 0) { + Xtzname[0] = _abbrevs + uintptr(**(**uint8)(__ccgo_up(p1 + 5))) Xtimezone = Int64FromUint32(-_zi_read32(tls, p1)) } - if *(*uint8)(unsafe.Pointer(p1 + 4)) != 0 && !(Xtzname[int32(1)] != 0) { - Xtzname[int32(1)] = _abbrevs + uintptr(*(*uint8)(unsafe.Pointer(p1 + 5))) + if **(**uint8)(__ccgo_up(p1 + 4)) != 0 && !(Xtzname[int32(1)] != 0) { + Xtzname[int32(1)] = _abbrevs + uintptr(**(**uint8)(__ccgo_up(p1 + 5))) _dst_off = Int32FromUint32(-_zi_read32(tls, p1)) Xdaylight = int32(1) } @@ -149670,8 +149670,8 @@ func _do_tzset(tls *TLS) { return } } - if !(*(*uintptr)(unsafe.Pointer(bp + 288)) != 0) { - *(*uintptr)(unsafe.Pointer(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) + if !(**(**uintptr)(__ccgo_up(bp + 288)) != 0) { + **(**uintptr)(__ccgo_up(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) } _getname(tls, uintptr(unsafe.Pointer(&_std_name)), bp+288) Xtzname[0] = uintptr(unsafe.Pointer(&_std_name)) @@ -149680,7 +149680,7 @@ func _do_tzset(tls *TLS) { Xtzname[int32(1)] = uintptr(unsafe.Pointer(&_dst_name)) if _dst_name[0] != 0 { Xdaylight = int32(1) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32('+') || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32('-') || Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288)))))-int32('0')) < uint32(10) { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32('+') || Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32('-') || Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288)))))-int32('0')) < uint32(10) { _dst_off = _getoff(tls, bp+288) } else { _dst_off = int32(Xtimezone - int64(3600)) @@ -149689,12 +149689,12 @@ func _do_tzset(tls *TLS) { Xdaylight = 0 _dst_off = int32(Xtimezone) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32(',') { - *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32(',') { + **(**uintptr)(__ccgo_up(bp + 288)) = **(**uintptr)(__ccgo_up(bp + 288)) + 1 _getrule(tls, bp+288, uintptr(unsafe.Pointer(&_r0))) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32(',') { - *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32(',') { + **(**uintptr)(__ccgo_up(bp + 288)) = **(**uintptr)(__ccgo_up(bp + 288)) + 1 _getrule(tls, bp+288, uintptr(unsafe.Pointer(&_r12))) } } @@ -149715,7 +149715,7 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { n = Uint64FromInt64((int64(_index) - int64(_trans)) >> scale) if !(n != 0) { if alt != 0 { - *(*Tsize_t)(unsafe.Pointer(alt)) = uint64(0) + **(**Tsize_t)(__ccgo_up(alt)) = uint64(0) } return uint64(0) } @@ -149729,7 +149729,7 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { x = Uint64FromInt32(Int32FromUint64(x)) } if local != 0 { - off = Int32FromUint32(_zi_read32(tls, _types+uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(m-uint64(1)))))))) + off = Int32FromUint32(_zi_read32(tls, _types+uintptr(int32(6)*Int32FromUint8(**(**uint8)(__ccgo_up(_index + uintptr(m-uint64(1)))))))) } if t-int64(off) < int64(Int64FromUint64(x)) { n = n / uint64(2) @@ -149758,7 +149758,7 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { if !(i != 0) { break } - if !(*(*uint8)(unsafe.Pointer(_types + uintptr(i-uint64(6)+uint64(4)))) != 0) { + if !(**(**uint8)(__ccgo_up(_types + uintptr(i-uint64(6)+uint64(4)))) != 0) { j = i - uint64(6) } goto _1 @@ -149773,24 +149773,24 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { * and the index-zero (after transition) type as the alt. */ if t-int64(off) < int64(Int64FromUint64(x)) { if alt != 0 { - *(*Tsize_t)(unsafe.Pointer(alt)) = uint64(*(*uint8)(unsafe.Pointer(_index))) + **(**Tsize_t)(__ccgo_up(alt)) = uint64(**(**uint8)(__ccgo_up(_index))) } return j / uint64(6) } } /* Try to find a neighboring opposite-DST-status rule. */ if alt != 0 { - if a != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(_types + uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(a-uint64(1)))))+int32(4))))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(_types + uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(a))))+int32(4))))) { - *(*Tsize_t)(unsafe.Pointer(alt)) = uint64(*(*uint8)(unsafe.Pointer(_index + uintptr(a-uint64(1))))) + if a != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(_types + uintptr(int32(6)*Int32FromUint8(**(**uint8)(__ccgo_up(_index + uintptr(a-uint64(1)))))+int32(4))))) != Int32FromUint8(**(**uint8)(__ccgo_up(_types + uintptr(int32(6)*Int32FromUint8(**(**uint8)(__ccgo_up(_index + uintptr(a))))+int32(4))))) { + **(**Tsize_t)(__ccgo_up(alt)) = uint64(**(**uint8)(__ccgo_up(_index + uintptr(a-uint64(1))))) } else { - if a+uint64(1) < n && Int32FromUint8(*(*uint8)(unsafe.Pointer(_types + uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(a+uint64(1)))))+int32(4))))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(_types + uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(a))))+int32(4))))) { - *(*Tsize_t)(unsafe.Pointer(alt)) = uint64(*(*uint8)(unsafe.Pointer(_index + uintptr(a+uint64(1))))) + if a+uint64(1) < n && Int32FromUint8(**(**uint8)(__ccgo_up(_types + uintptr(int32(6)*Int32FromUint8(**(**uint8)(__ccgo_up(_index + uintptr(a+uint64(1)))))+int32(4))))) != Int32FromUint8(**(**uint8)(__ccgo_up(_types + uintptr(int32(6)*Int32FromUint8(**(**uint8)(__ccgo_up(_index + uintptr(a))))+int32(4))))) { + **(**Tsize_t)(__ccgo_up(alt)) = uint64(**(**uint8)(__ccgo_up(_index + uintptr(a+uint64(1))))) } else { - *(*Tsize_t)(unsafe.Pointer(alt)) = uint64(*(*uint8)(unsafe.Pointer(_index + uintptr(a)))) + **(**Tsize_t)(__ccgo_up(alt)) = uint64(**(**uint8)(__ccgo_up(_index + uintptr(a)))) } } } - return uint64(*(*uint8)(unsafe.Pointer(_index + uintptr(a)))) + return uint64(**(**uint8)(__ccgo_up(_index + uintptr(a)))) } func _days_in_month1(tls *TLS, m int32, is_leap int32) (r int32) { @@ -149812,28 +149812,28 @@ func _rule_to_secs(tls *TLS, rule uintptr, year int32) (r int64) { var _ /* is_leap at bp+0 */ int32 _, _, _, _, _, _, _ = d, days, m, n, t, wday, x t = X__year_to_secs(tls, int64(year), bp) - if *(*int32)(unsafe.Pointer(rule)) != int32('M') { - x = *(*int32)(unsafe.Pointer(rule + 1*4)) - if *(*int32)(unsafe.Pointer(rule)) == int32('J') && (x < int32(60) || !(*(*int32)(unsafe.Pointer(bp)) != 0)) { + if **(**int32)(__ccgo_up(rule)) != int32('M') { + x = **(**int32)(__ccgo_up(rule + 1*4)) + if **(**int32)(__ccgo_up(rule)) == int32('J') && (x < int32(60) || !(**(**int32)(__ccgo_up(bp)) != 0)) { x = x - 1 } t = t + int64(int32(86400)*x) } else { - m = *(*int32)(unsafe.Pointer(rule + 1*4)) - n = *(*int32)(unsafe.Pointer(rule + 2*4)) - d = *(*int32)(unsafe.Pointer(rule + 3*4)) - t = t + int64(X__month_to_secs(tls, m-int32(1), *(*int32)(unsafe.Pointer(bp)))) + m = **(**int32)(__ccgo_up(rule + 1*4)) + n = **(**int32)(__ccgo_up(rule + 2*4)) + d = **(**int32)(__ccgo_up(rule + 3*4)) + t = t + int64(X__month_to_secs(tls, m-int32(1), **(**int32)(__ccgo_up(bp)))) wday = int32((t+int64(Int32FromInt32(4)*Int32FromInt32(86400)))%int64(Int32FromInt32(7)*Int32FromInt32(86400))) / int32(86400) days = d - wday if days < 0 { days = days + int32(7) } - if n == int32(5) && days+int32(28) >= _days_in_month1(tls, m, *(*int32)(unsafe.Pointer(bp))) { + if n == int32(5) && days+int32(28) >= _days_in_month1(tls, m, **(**int32)(__ccgo_up(bp))) { n = int32(4) } t = t + int64(int32(86400)*(days+int32(7)*(n-int32(1)))) } - t = t + int64(*(*int32)(unsafe.Pointer(rule + 4*4))) + t = t + int64(**(**int32)(__ccgo_up(rule + 4*4))) return t } @@ -149859,11 +149859,11 @@ func X__secs_to_zone(tls *TLS, t int64, local int32, isdst uintptr, offset uintp if _zi != 0 { i = _scan_trans(tls, t, local, bp) if i != Uint64FromInt32(-Int32FromInt32(1)) { - *(*int32)(unsafe.Pointer(isdst)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(_types + uintptr(uint64(6)*i+uint64(4))))) - *(*int64)(unsafe.Pointer(offset)) = int64(Int32FromUint32(_zi_read32(tls, _types+uintptr(uint64(6)*i)))) - *(*uintptr)(unsafe.Pointer(zonename)) = _abbrevs + uintptr(*(*uint8)(unsafe.Pointer(_types + uintptr(uint64(6)*i+uint64(5))))) + **(**int32)(__ccgo_up(isdst)) = Int32FromUint8(**(**uint8)(__ccgo_up(_types + uintptr(uint64(6)*i+uint64(4))))) + **(**int64)(__ccgo_up(offset)) = int64(Int32FromUint32(_zi_read32(tls, _types+uintptr(uint64(6)*i)))) + **(**uintptr)(__ccgo_up(zonename)) = _abbrevs + uintptr(**(**uint8)(__ccgo_up(_types + uintptr(uint64(6)*i+uint64(5))))) if oppoff != 0 { - *(*int64)(unsafe.Pointer(oppoff)) = int64(Int32FromUint32(_zi_read32(tls, _types+uintptr(uint64(6)**(*Tsize_t)(unsafe.Pointer(bp)))))) + **(**int64)(__ccgo_up(oppoff)) = int64(Int32FromUint32(_zi_read32(tls, _types+uintptr(uint64(6)***(**Tsize_t)(__ccgo_up(bp)))))) } ___unlock(tls, uintptr(unsafe.Pointer(&_lock4))) return @@ -149901,23 +149901,23 @@ func X__secs_to_zone(tls *TLS, t int64, local int32, isdst uintptr, offset uintp goto std std: ; - *(*int32)(unsafe.Pointer(isdst)) = 0 - *(*int64)(unsafe.Pointer(offset)) = -Xtimezone + **(**int32)(__ccgo_up(isdst)) = 0 + **(**int64)(__ccgo_up(offset)) = -Xtimezone if oppoff != 0 { - *(*int64)(unsafe.Pointer(oppoff)) = int64(-_dst_off) + **(**int64)(__ccgo_up(oppoff)) = int64(-_dst_off) } - *(*uintptr)(unsafe.Pointer(zonename)) = Xtzname[0] + **(**uintptr)(__ccgo_up(zonename)) = Xtzname[0] ___unlock(tls, uintptr(unsafe.Pointer(&_lock4))) return goto dst dst: ; - *(*int32)(unsafe.Pointer(isdst)) = int32(1) - *(*int64)(unsafe.Pointer(offset)) = int64(-_dst_off) + **(**int32)(__ccgo_up(isdst)) = int32(1) + **(**int64)(__ccgo_up(offset)) = int64(-_dst_off) if oppoff != 0 { - *(*int64)(unsafe.Pointer(oppoff)) = -Xtimezone + **(**int64)(__ccgo_up(oppoff)) = -Xtimezone } - *(*uintptr)(unsafe.Pointer(zonename)) = Xtzname[int32(1)] + **(**uintptr)(__ccgo_up(zonename)) = Xtzname[int32(1)] ___unlock(tls, uintptr(unsafe.Pointer(&_lock4))) } @@ -149960,11 +149960,11 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { if !((y-Int32FromInt32(68))&Int32FromInt32(3) != 0) { leaps = leaps - 1 if is_leap != 0 { - *(*int32)(unsafe.Pointer(is_leap)) = int32(1) + **(**int32)(__ccgo_up(is_leap)) = int32(1) } } else { if is_leap != 0 { - *(*int32)(unsafe.Pointer(is_leap)) = 0 + **(**int32)(__ccgo_up(is_leap)) = 0 } } return int64(int32(31536000)*(y-int32(70)) + int32(86400)*leaps) @@ -149979,7 +149979,7 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { rem = rem + int32(400) } if !(rem != 0) { - *(*int32)(unsafe.Pointer(is_leap)) = int32(1) + **(**int32)(__ccgo_up(is_leap)) = int32(1) centuries = 0 leaps1 = 0 } else { @@ -150000,15 +150000,15 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { } } if !(rem != 0) { - *(*int32)(unsafe.Pointer(is_leap)) = 0 + **(**int32)(__ccgo_up(is_leap)) = 0 leaps1 = 0 } else { leaps1 = Int32FromUint32(Uint32FromInt32(rem) / uint32(4)) rem = Int32FromUint32(uint32(rem) % Uint32FromUint32(4)) - *(*int32)(unsafe.Pointer(is_leap)) = BoolInt32(!(rem != 0)) + **(**int32)(__ccgo_up(is_leap)) = BoolInt32(!(rem != 0)) } } - leaps1 = leaps1 + (int32(97)*cycles + int32(24)*centuries - *(*int32)(unsafe.Pointer(is_leap))) + leaps1 = leaps1 + (int32(97)*cycles + int32(24)*centuries - **(**int32)(__ccgo_up(is_leap))) return (year-int64(100))*int64(31536000) + int64(leaps1)*int64(86400) + int64(946684800) + int64(86400) } @@ -150071,10 +150071,10 @@ func Xclock(tls *TLS) (r Tclock_t) { if X__clock_gettime(tls, int32(CLOCK_PROCESS_CPUTIME_ID), bp) != 0 { return int64(-int32(1)) } - if (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec > Int64FromInt64(0x7fffffffffffffff)/Int64FromInt32(1000000) || (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_nsec/int64(1000) > int64(0x7fffffffffffffff)-int64(1000000)*(*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec { + if (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec > Int64FromInt64(0x7fffffffffffffff)/Int64FromInt32(1000000) || (**(**Ttimespec)(__ccgo_up(bp))).Ftv_nsec/int64(1000) > int64(0x7fffffffffffffff)-int64(1000000)*(**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec { return int64(-int32(1)) } - return (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec*int64(1000000) + (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_nsec/int64(1000) + return (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec*int64(1000000) + (**(**Ttimespec)(__ccgo_up(bp))).Ftv_nsec/int64(1000) } func Xclock_getcpuclockid(tls *TLS, pid Tpid_t, clk uintptr) (r int32) { @@ -150096,7 +150096,7 @@ func Xclock_getcpuclockid(tls *TLS, pid Tpid_t, clk uintptr) (r int32) { if ret != 0 { return -ret } - *(*Tclockid_t)(unsafe.Pointer(clk)) = id + **(**Tclockid_t)(__ccgo_up(clk)) = id return 0 } @@ -150226,8 +150226,8 @@ func Xftime(tls *TLS, tp uintptr) (r int32) { var _ /* ts at bp+0 */ Ttimespec _ = v1 Xclock_gettime(tls, CLOCK_REALTIME, bp) - (*Ttimeb)(unsafe.Pointer(tp)).Ftime = (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec - (*Ttimeb)(unsafe.Pointer(tp)).Fmillitm = Uint16FromInt64((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_nsec / int64(1000000)) + (*Ttimeb)(unsafe.Pointer(tp)).Ftime = (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec + (*Ttimeb)(unsafe.Pointer(tp)).Fmillitm = Uint16FromInt64((**(**Ttimespec)(__ccgo_up(bp))).Ftv_nsec / int64(1000000)) v1 = Int16FromInt32(0) (*Ttimeb)(unsafe.Pointer(tp)).Fdstflag = v1 (*Ttimeb)(unsafe.Pointer(tp)).Ftimezone = v1 @@ -150255,7 +150255,7 @@ func Xgetdate(tls *TLS, s uintptr) (r uintptr) { } f = Xfopen(tls, datemsk, __ccgo_ts+412) if !(f != 0) { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENOMEM) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENOMEM) { Xgetdate_err = int32(6) } else { Xgetdate_err = int32(2) @@ -150264,7 +150264,7 @@ func Xgetdate(tls *TLS, s uintptr) (r uintptr) { } for Xfgets(tls, bp, int32(100), f) != 0 { p = Xstrptime(tls, s, bp, uintptr(unsafe.Pointer(&_tmbuf))) - if p != 0 && !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if p != 0 && !(**(**uint8)(__ccgo_up(p)) != 0) { ret = uintptr(unsafe.Pointer(&_tmbuf)) goto out } @@ -150280,7 +150280,7 @@ out: if f != 0 { Xfclose(tls, f) } - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 100)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 100)), uintptr(0)) return ret } @@ -150298,8 +150298,8 @@ func Xgettimeofday(tls *TLS, tv uintptr, tz uintptr) (r int32) { return 0 } Xclock_gettime(tls, CLOCK_REALTIME, bp) - (*Ttimeval)(unsafe.Pointer(tv)).Ftv_sec = (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec - (*Ttimeval)(unsafe.Pointer(tv)).Ftv_usec = int64(int32((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_nsec) / int32(1000)) + (*Ttimeval)(unsafe.Pointer(tv)).Ftv_sec = (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec + (*Ttimeval)(unsafe.Pointer(tv)).Ftv_usec = int64(int32((**(**Ttimespec)(__ccgo_up(bp))).Ftv_nsec) / int32(1000)) return 0 } @@ -150318,8 +150318,8 @@ func X__gmtime_r(tls *TLS, t uintptr, tm uintptr) (r uintptr) { trc("tls=%v t=%v tm=%v, (%v:)", tls, t, tm, origin(2)) defer func() { trc("-> %v", r) }() } - if X__secs_to_tm(tls, *(*Ttime_t)(unsafe.Pointer(t)), tm) < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + if X__secs_to_tm(tls, int64(**(**Ttime_t)(__ccgo_up(t))), tm) < 0 { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return uintptr(0) } (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst = 0 @@ -150362,13 +150362,13 @@ func X__localtime_r(tls *TLS, t uintptr, tm uintptr) (r uintptr) { } /* Reject time_t values whose year would overflow int because * __secs_to_zone cannot safely handle them. */ - if *(*Ttime_t)(unsafe.Pointer(t)) < int64(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff))*Int64FromInt64(31622400) || *(*Ttime_t)(unsafe.Pointer(t)) > Int64FromInt32(INT_MAX)*Int64FromInt64(31622400) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + if int64(**(**Ttime_t)(__ccgo_up(t))) < int64(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff))*Int64FromInt64(31622400) || int64(**(**Ttime_t)(__ccgo_up(t))) > Int64FromInt32(INT_MAX)*Int64FromInt64(31622400) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return uintptr(0) } - X__secs_to_zone(tls, *(*Ttime_t)(unsafe.Pointer(t)), 0, tm+32, tm+40, uintptr(0), tm+48) - if X__secs_to_tm(tls, *(*Ttime_t)(unsafe.Pointer(t))+(*Ttm)(unsafe.Pointer(tm)).F__tm_gmtoff, tm) < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + X__secs_to_zone(tls, int64(**(**Ttime_t)(__ccgo_up(t))), 0, tm+32, tm+40, uintptr(0), tm+48) + if X__secs_to_tm(tls, int64(**(**Ttime_t)(__ccgo_up(t)))+(*Ttm)(unsafe.Pointer(tm)).F__tm_gmtoff, tm) < 0 { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return uintptr(0) } return tm @@ -150404,23 +150404,23 @@ func Xmktime(tls *TLS, tm uintptr) (r Ttime_t) { _ = t t = X__tm_to_secs(tls, tm) X__secs_to_zone(tls, t, int32(1), bp+32, bp+40, bp+56, bp+48) - if (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst >= 0 && (*(*Ttm)(unsafe.Pointer(bp))).Ftm_isdst != (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst { - t = t - (*(*int64)(unsafe.Pointer(bp + 56)) - (*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff) + if (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst >= 0 && (**(**Ttm)(__ccgo_up(bp))).Ftm_isdst != (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst { + t = t - int64(**(**int64)(__ccgo_up(bp + 56))-(**(**Ttm)(__ccgo_up(bp))).F__tm_gmtoff) } - t = t - (*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff + t = t - int64((**(**Ttm)(__ccgo_up(bp))).F__tm_gmtoff) if t != t { goto error } X__secs_to_zone(tls, t, 0, bp+32, bp+40, bp+56, bp+48) - if X__secs_to_tm(tls, t+(*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff, bp) < 0 { + if X__secs_to_tm(tls, t+int64((**(**Ttm)(__ccgo_up(bp))).F__tm_gmtoff), bp) < 0 { goto error } - *(*Ttm)(unsafe.Pointer(tm)) = *(*Ttm)(unsafe.Pointer(bp)) + **(**Ttm)(__ccgo_up(tm)) = **(**Ttm)(__ccgo_up(bp)) return t goto error error: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return int64(-int32(1)) } @@ -150581,7 +150581,7 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc val = int64((*Ttm)(unsafe.Pointer(tm)).Ftm_min) goto number case int32('n'): - *(*Tsize_t)(unsafe.Pointer(l)) = uint64(1) + **(**Tsize_t)(__ccgo_up(l)) = uint64(1) return __ccgo_ts + 398 case int32('p'): if (*Ttm)(unsafe.Pointer(tm)).Ftm_hour >= int32(12) { @@ -150600,20 +150600,20 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc item = v1 fmt = X__nl_langinfo_l(tls, item, loc) d = s - *(*Tsize_t)(unsafe.Pointer(l)) = uint64(0) + **(**Tsize_t)(__ccgo_up(l)) = uint64(0) for { - if !(*(*uint8)(unsafe.Pointer(fmt)) != 0) { + if !(**(**uint8)(__ccgo_up(fmt)) != 0) { break } v4 = d d = d + 1 v5 = fmt fmt = fmt + 1 - *(*uint8)(unsafe.Pointer(v4)) = Uint8FromInt32(Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))))) + **(**uint8)(__ccgo_up(v4)) = Uint8FromInt32(Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(v5))))) goto _3 _3: ; - *(*Tsize_t)(unsafe.Pointer(l)) = *(*Tsize_t)(unsafe.Pointer(l)) + 1 + **(**Tsize_t)(__ccgo_up(l)) = **(**Tsize_t)(__ccgo_up(l)) + 1 } return s case int32('r'): @@ -150630,7 +150630,7 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc val = int64((*Ttm)(unsafe.Pointer(tm)).Ftm_sec) goto number case int32('t'): - *(*Tsize_t)(unsafe.Pointer(l)) = uint64(1) + **(**Tsize_t)(__ccgo_up(l)) = uint64(1) return __ccgo_ts + 1442 case int32('T'): fmt = __ccgo_ts + 1886 @@ -150672,27 +150672,27 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc case int32('Y'): val = int64((*Ttm)(unsafe.Pointer(tm)).Ftm_year) + int64(1900) if val >= int64(10000) { - *(*Tsize_t)(unsafe.Pointer(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1895, VaList(bp+8, val))) + **(**Tsize_t)(__ccgo_up(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1895, VaList(bp+8, val))) return s } width = int32(4) goto number case int32('z'): if (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst < 0 { - *(*Tsize_t)(unsafe.Pointer(l)) = uint64(0) + **(**Tsize_t)(__ccgo_up(l)) = uint64(0) return __ccgo_ts } - *(*Tsize_t)(unsafe.Pointer(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1901, VaList(bp+8, (*Ttm)(unsafe.Pointer(tm)).F__tm_gmtoff/int64(3600)*int64(100)+(*Ttm)(unsafe.Pointer(tm)).F__tm_gmtoff%int64(3600)/int64(60)))) + **(**Tsize_t)(__ccgo_up(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1901, VaList(bp+8, (*Ttm)(unsafe.Pointer(tm)).F__tm_gmtoff/int64(3600)*int64(100)+(*Ttm)(unsafe.Pointer(tm)).F__tm_gmtoff%int64(3600)/int64(60)))) return s case int32('Z'): if (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst < 0 { - *(*Tsize_t)(unsafe.Pointer(l)) = uint64(0) + **(**Tsize_t)(__ccgo_up(l)) = uint64(0) return __ccgo_ts } fmt = X__tm_to_tzname(tls, tm) goto string case int32('%'): - *(*Tsize_t)(unsafe.Pointer(l)) = uint64(1) + **(**Tsize_t)(__ccgo_up(l)) = uint64(1) return __ccgo_ts + 445 default: return uintptr(0) @@ -150707,13 +150707,13 @@ number: } switch v1 { case int32('-'): - *(*Tsize_t)(unsafe.Pointer(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1908, VaList(bp+8, val))) + **(**Tsize_t)(__ccgo_up(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1908, VaList(bp+8, val))) case int32('_'): - *(*Tsize_t)(unsafe.Pointer(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1913, VaList(bp+8, width, val))) + **(**Tsize_t)(__ccgo_up(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1913, VaList(bp+8, width, val))) case int32('0'): fallthrough default: - *(*Tsize_t)(unsafe.Pointer(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1919, VaList(bp+8, width, val))) + **(**Tsize_t)(__ccgo_up(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1919, VaList(bp+8, width, val))) break } return s @@ -150724,7 +150724,7 @@ nl_strcat: goto string string: ; - *(*Tsize_t)(unsafe.Pointer(l)) = _strlen(tls, fmt) + **(**Tsize_t)(__ccgo_up(l)) = _strlen(tls, fmt) return fmt goto nl_strftime nl_strftime: @@ -150733,8 +150733,8 @@ nl_strftime: goto recu_strftime recu_strftime: ; - *(*Tsize_t)(unsafe.Pointer(l)) = X__strftime_l(tls, s, uint64(100), fmt, tm, loc) - if !(*(*Tsize_t)(unsafe.Pointer(l)) != 0) { + **(**Tsize_t)(__ccgo_up(l)) = X__strftime_l(tls, s, uint64(100), fmt, tm, loc) + if !(**(**Tsize_t)(__ccgo_up(l)) != 0) { return uintptr(0) } return s @@ -150761,46 +150761,46 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl if !(l < n) { break } - if !(*(*uint8)(unsafe.Pointer(f)) != 0) { - *(*uint8)(unsafe.Pointer(s + uintptr(l))) = uint8(0) + if !(**(**uint8)(__ccgo_up(f)) != 0) { + **(**uint8)(__ccgo_up(s + uintptr(l))) = uint8(0) return l } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) != int32('%') { + if Int32FromUint8(**(**uint8)(__ccgo_up(f))) != int32('%') { v2 = l l = l + 1 - *(*uint8)(unsafe.Pointer(s + uintptr(v2))) = *(*uint8)(unsafe.Pointer(f)) + **(**uint8)(__ccgo_up(s + uintptr(v2))) = **(**uint8)(__ccgo_up(f)) goto _1 } f = f + 1 pad = 0 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('-') || Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('_') || Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('0') { + if Int32FromUint8(**(**uint8)(__ccgo_up(f))) == int32('-') || Int32FromUint8(**(**uint8)(__ccgo_up(f))) == int32('_') || Int32FromUint8(**(**uint8)(__ccgo_up(f))) == int32('0') { v3 = f f = f + 1 - pad = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + pad = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } - v4 = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == Int32FromUint8('+')) + v4 = BoolInt32(Int32FromUint8(**(**uint8)(__ccgo_up(f))) == Int32FromUint8('+')) plus = v4 if v4 != 0 { f = f + 1 } - if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(f)))-uint32('0') < uint32(10)) != 0 { + if BoolInt32(uint32(**(**uint8)(__ccgo_up(f)))-uint32('0') < uint32(10)) != 0 { width = Xstrtoul(tls, f, bp+112, int32(10)) } else { width = uint64(0) - *(*uintptr)(unsafe.Pointer(bp + 112)) = f + **(**uintptr)(__ccgo_up(bp + 112)) = f } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 112))))) == int32('C') || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 112))))) == int32('F') || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 112))))) == int32('G') || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 112))))) == int32('Y') { - if !(width != 0) && *(*uintptr)(unsafe.Pointer(bp + 112)) != f { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 112))))) == int32('C') || Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 112))))) == int32('F') || Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 112))))) == int32('G') || Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 112))))) == int32('Y') { + if !(width != 0) && **(**uintptr)(__ccgo_up(bp + 112)) != f { width = uint64(1) } } else { width = uint64(0) } - f = *(*uintptr)(unsafe.Pointer(bp + 112)) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('E') || Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('O') { + f = **(**uintptr)(__ccgo_up(bp + 112)) + if Int32FromUint8(**(**uint8)(__ccgo_up(f))) == int32('E') || Int32FromUint8(**(**uint8)(__ccgo_up(f))) == int32('O') { f = f + 1 } - t = X__strftime_fmt_1(tls, bp+8, bp, Int32FromUint8(*(*uint8)(unsafe.Pointer(f))), tm, loc, pad) + t = X__strftime_fmt_1(tls, bp+8, bp, Int32FromUint8(**(**uint8)(__ccgo_up(f))), tm, loc, pad) if !(t != 0) { break } @@ -150808,26 +150808,26 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl /* Trim off any sign and leading zeros, then * count remaining digits to determine behavior * for the + flag. */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(t))) == int32('+') || Int32FromUint8(*(*uint8)(unsafe.Pointer(t))) == int32('-') { + if Int32FromUint8(**(**uint8)(__ccgo_up(t))) == int32('+') || Int32FromUint8(**(**uint8)(__ccgo_up(t))) == int32('-') { t = t + 1 - *(*Tsize_t)(unsafe.Pointer(bp)) = *(*Tsize_t)(unsafe.Pointer(bp)) - 1 + **(**Tsize_t)(__ccgo_up(bp)) = **(**Tsize_t)(__ccgo_up(bp)) - 1 } for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(t))) == int32('0') && Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(t + 1)))-int32('0')) < uint32(10)) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(t))) == int32('0') && Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(t + 1)))-int32('0')) < uint32(10)) { break } goto _5 _5: ; t = t + 1 - *(*Tsize_t)(unsafe.Pointer(bp)) = *(*Tsize_t)(unsafe.Pointer(bp)) - 1 + **(**Tsize_t)(__ccgo_up(bp)) = **(**Tsize_t)(__ccgo_up(bp)) - 1 } - if width < *(*Tsize_t)(unsafe.Pointer(bp)) { - width = *(*Tsize_t)(unsafe.Pointer(bp)) + if width < **(**Tsize_t)(__ccgo_up(bp)) { + width = **(**Tsize_t)(__ccgo_up(bp)) } d = uint64(0) for { - if !(Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(t + uintptr(d))))-int32('0')) < uint32(10)) { + if !(Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(t + uintptr(d))))-int32('0')) < uint32(10)) { break } goto _6 @@ -150838,41 +150838,41 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl if (*Ttm)(unsafe.Pointer(tm)).Ftm_year < -int32(1900) { v2 = l l = l + 1 - *(*uint8)(unsafe.Pointer(s + uintptr(v2))) = uint8('-') + **(**uint8)(__ccgo_up(s + uintptr(v2))) = uint8('-') width = width - 1 } else { if v9 = plus != 0; v9 { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 112))))) == int32('C') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 112))))) == int32('C') { v4 = int32(3) } else { v4 = int32(5) } } - if v9 && d+(width-*(*Tsize_t)(unsafe.Pointer(bp))) >= Uint64FromInt32(v4) { + if v9 && d+(width-**(**Tsize_t)(__ccgo_up(bp))) >= Uint64FromInt32(v4) { v2 = l l = l + 1 - *(*uint8)(unsafe.Pointer(s + uintptr(v2))) = uint8('+') + **(**uint8)(__ccgo_up(s + uintptr(v2))) = uint8('+') width = width - 1 } } for { - if !(width > *(*Tsize_t)(unsafe.Pointer(bp)) && l < n) { + if !(width > **(**Tsize_t)(__ccgo_up(bp)) && l < n) { break } v2 = l l = l + 1 - *(*uint8)(unsafe.Pointer(s + uintptr(v2))) = uint8('0') + **(**uint8)(__ccgo_up(s + uintptr(v2))) = uint8('0') goto _11 _11: ; width = width - 1 } } - if *(*Tsize_t)(unsafe.Pointer(bp)) > n-l { - *(*Tsize_t)(unsafe.Pointer(bp)) = n - l + if **(**Tsize_t)(__ccgo_up(bp)) > n-l { + **(**Tsize_t)(__ccgo_up(bp)) = n - l } - Xmemcpy(tls, s+uintptr(l), t, *(*Tsize_t)(unsafe.Pointer(bp))) - l = l + *(*Tsize_t)(unsafe.Pointer(bp)) + Xmemcpy(tls, s+uintptr(l), t, **(**Tsize_t)(__ccgo_up(bp))) + l = l + **(**Tsize_t)(__ccgo_up(bp)) goto _1 _1: ; @@ -150882,7 +150882,7 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl if l == n { l = n - uint64(1) } - *(*uint8)(unsafe.Pointer(s + uintptr(l))) = uint8(0) + **(**uint8)(__ccgo_up(s + uintptr(l))) = uint8(0) } return uint64(0) } @@ -150920,18 +150920,18 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { var _ /* relyear at bp+8 */ int32 _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = adj, dest, ex, i, len1, min, neg, range1, w, want_century, v1, v2, v5, v6, v8, v9 want_century = 0 - *(*int32)(unsafe.Pointer(bp + 4)) = 0 - *(*int32)(unsafe.Pointer(bp + 8)) = 0 - for *(*uint8)(unsafe.Pointer(f)) != 0 { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) != int32('%') { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) + **(**int32)(__ccgo_up(bp + 4)) = 0 + **(**int32)(__ccgo_up(bp + 8)) = 0 + for **(**uint8)(__ccgo_up(f)) != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(f))) != int32('%') { + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(f))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _3 _3: if v2 != 0 { for { - if v8 = *(*uint8)(unsafe.Pointer(s)) != 0; v8 { - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) + if v8 = **(**uint8)(__ccgo_up(s)) != 0; v8 { + v5 = Int32FromUint8(**(**uint8)(__ccgo_up(s))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _7 _7: @@ -150945,7 +150945,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { s = s + 1 } } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) != Int32FromUint8(**(**uint8)(__ccgo_up(f))) { return uintptr(0) } else { s = s + 1 @@ -150955,19 +150955,19 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { continue } f = f + 1 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('+') { + if Int32FromUint8(**(**uint8)(__ccgo_up(f))) == int32('+') { f = f + 1 } - if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(f)))-uint32('0') < uint32(10)) != 0 { + if BoolInt32(uint32(**(**uint8)(__ccgo_up(f)))-uint32('0') < uint32(10)) != 0 { w = Int32FromUint64(Xstrtoul(tls, f, bp+16, int32(10))) - f = *(*uintptr)(unsafe.Pointer(bp + 16)) + f = **(**uintptr)(__ccgo_up(bp + 16)) } else { w = -int32(1) } adj = 0 v9 = f f = f + 1 - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(v9))) { case int32('A'): goto _10 case int32('a'): @@ -151118,8 +151118,8 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { ; _44: ; - if v8 = *(*uint8)(unsafe.Pointer(s)) != 0; v8 { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) + if v8 = **(**uint8)(__ccgo_up(s)) != 0; v8 { + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(s))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _47 _47: @@ -151141,15 +151141,15 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { ex = Xnl_langinfo(tls, int32(AM_STR)) len1 = _strlen(tls, ex) if !(Xstrncasecmp(tls, s, ex, len1) != 0) { - *(*int32)(unsafe.Pointer(tm + 8)) %= int32(12) + **(**int32)(__ccgo_up(tm + 8)) %= int32(12) s = s + uintptr(len1) goto _41 } ex = Xnl_langinfo(tls, int32(PM_STR)) len1 = _strlen(tls, ex) if !(Xstrncasecmp(tls, s, ex, len1) != 0) { - *(*int32)(unsafe.Pointer(tm + 8)) %= int32(12) - *(*int32)(unsafe.Pointer(tm + 8)) += int32(12) + **(**int32)(__ccgo_up(tm + 8)) %= int32(12) + **(**int32)(__ccgo_up(tm + 8)) += int32(12) s = s + uintptr(len1) goto _41 } @@ -151229,7 +151229,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { ; v9 = s s = s + 1 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) != int32('%') { + if Int32FromUint8(**(**uint8)(__ccgo_up(v9))) != int32('%') { return uintptr(0) } goto _41 @@ -151239,27 +151239,27 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { goto numeric_range numeric_range: ; - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } - *(*int32)(unsafe.Pointer(dest)) = 0 + **(**int32)(__ccgo_up(dest)) = 0 i = int32(1) for { - if !(i <= min+range1 && BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0) { + if !(i <= min+range1 && BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-uint32('0') < uint32(10)) != 0) { break } v9 = s s = s + 1 - *(*int32)(unsafe.Pointer(dest)) = *(*int32)(unsafe.Pointer(dest))*int32(10) + Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) - int32('0') + **(**int32)(__ccgo_up(dest)) = **(**int32)(__ccgo_up(dest))*int32(10) + Int32FromUint8(**(**uint8)(__ccgo_up(v9))) - int32('0') goto _50 _50: ; i = i * int32(10) } - if Uint32FromInt32(*(*int32)(unsafe.Pointer(dest))-min) >= Uint32FromInt32(range1) { + if Uint32FromInt32(**(**int32)(__ccgo_up(dest))-min) >= Uint32FromInt32(range1) { return uintptr(0) } - *(*int32)(unsafe.Pointer(dest)) -= adj + **(**int32)(__ccgo_up(dest)) -= adj switch int64(dest) - int64(tm) { case Int64FromUint64(uint64(UintptrFromInt32(0) + 28)): } @@ -151268,36 +151268,36 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { numeric_digits: ; neg = 0 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('+') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('+') { s = s + 1 } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('-') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('-') { neg = int32(1) s = s + 1 } } - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } v1 = Int32FromInt32(0) i = v1 - *(*int32)(unsafe.Pointer(dest)) = v1 + **(**int32)(__ccgo_up(dest)) = v1 for { - if !(i < w && BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0) { + if !(i < w && BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-uint32('0') < uint32(10)) != 0) { break } v9 = s s = s + 1 - *(*int32)(unsafe.Pointer(dest)) = *(*int32)(unsafe.Pointer(dest))*int32(10) + Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) - int32('0') + **(**int32)(__ccgo_up(dest)) = **(**int32)(__ccgo_up(dest))*int32(10) + Int32FromUint8(**(**uint8)(__ccgo_up(v9))) - int32('0') goto _52 _52: ; i = i + 1 } if neg != 0 { - *(*int32)(unsafe.Pointer(dest)) = -*(*int32)(unsafe.Pointer(dest)) + **(**int32)(__ccgo_up(dest)) = -**(**int32)(__ccgo_up(dest)) } - *(*int32)(unsafe.Pointer(dest)) -= adj + **(**int32)(__ccgo_up(dest)) -= adj goto update goto symbolic_range symbolic_range: @@ -151313,7 +151313,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { goto _55 } s = s + uintptr(len1) - *(*int32)(unsafe.Pointer(dest)) = i % range1 + **(**int32)(__ccgo_up(dest)) = i % range1 break goto _55 _55: @@ -151331,12 +151331,12 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { _41: } if want_century != 0 { - (*Ttm)(unsafe.Pointer(tm)).Ftm_year = *(*int32)(unsafe.Pointer(bp + 8)) + (*Ttm)(unsafe.Pointer(tm)).Ftm_year = **(**int32)(__ccgo_up(bp + 8)) if want_century&int32(2) != 0 { - *(*int32)(unsafe.Pointer(tm + 20)) += *(*int32)(unsafe.Pointer(bp + 4))*int32(100) - int32(1900) + **(**int32)(__ccgo_up(tm + 20)) += **(**int32)(__ccgo_up(bp + 4))*int32(100) - int32(1900) } else { if (*Ttm)(unsafe.Pointer(tm)).Ftm_year <= int32(68) { - *(*int32)(unsafe.Pointer(tm + 20)) += int32(100) + **(**int32)(__ccgo_up(tm + 20)) += int32(100) } } } @@ -151353,9 +151353,9 @@ func Xtime(tls *TLS, t uintptr) (r Ttime_t) { var _ /* ts at bp+0 */ Ttimespec X__clock_gettime(tls, CLOCK_REALTIME, bp) if t != 0 { - *(*Ttime_t)(unsafe.Pointer(t)) = (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec + **(**Ttime_t)(__ccgo_up(t)) = (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec } - return (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec + return (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec } func Xtimegm(tls *TLS, tm uintptr) (r Ttime_t) { @@ -151370,10 +151370,10 @@ func Xtimegm(tls *TLS, tm uintptr) (r Ttime_t) { _ = t t = X__tm_to_secs(tls, tm) if X__secs_to_tm(tls, t, bp) < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return int64(-int32(1)) } - *(*Ttm1)(unsafe.Pointer(tm)) = *(*Ttm1)(unsafe.Pointer(bp)) + **(**Ttm1)(__ccgo_up(tm)) = **(**Ttm1)(__ccgo_up(bp)) (*Ttm1)(unsafe.Pointer(tm)).Ftm_isdst = 0 (*Ttm1)(unsafe.Pointer(tm)).Ftm_gmtoff = 0 (*Ttm1)(unsafe.Pointer(tm)).Ftm_zone = uintptr(unsafe.Pointer(&X__utc)) @@ -151531,92 +151531,92 @@ func X__wcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl if !(l < n) { break } - if !(*(*Twchar_t)(unsafe.Pointer(f)) != 0) { - *(*Twchar_t)(unsafe.Pointer(s + uintptr(l)*4)) = 0 + if !(**(**Twchar_t)(__ccgo_up(f)) != 0) { + **(**Twchar_t)(__ccgo_up(s + uintptr(l)*4)) = 0 return l } - if *(*Twchar_t)(unsafe.Pointer(f)) != int32('%') { + if **(**Twchar_t)(__ccgo_up(f)) != int32('%') { v2 = l l = l + 1 - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = *(*Twchar_t)(unsafe.Pointer(f)) + **(**Twchar_t)(__ccgo_up(s + uintptr(v2)*4)) = **(**Twchar_t)(__ccgo_up(f)) goto _1 } f += 4 pad = 0 - if *(*Twchar_t)(unsafe.Pointer(f)) == int32('-') || *(*Twchar_t)(unsafe.Pointer(f)) == int32('_') || *(*Twchar_t)(unsafe.Pointer(f)) == int32('0') { + if **(**Twchar_t)(__ccgo_up(f)) == int32('-') || **(**Twchar_t)(__ccgo_up(f)) == int32('_') || **(**Twchar_t)(__ccgo_up(f)) == int32('0') { v3 = f f += 4 - pad = *(*Twchar_t)(unsafe.Pointer(v3)) + pad = **(**Twchar_t)(__ccgo_up(v3)) } - v4 = BoolInt32(*(*Twchar_t)(unsafe.Pointer(f)) == Int32FromUint8('+')) + v4 = BoolInt32(**(**Twchar_t)(__ccgo_up(f)) == Int32FromUint8('+')) plus = v4 if v4 != 0 { f += 4 } width = Xwcstoul(tls, f, bp+512, int32(10)) - if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 512)))) == int32('C') || *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 512)))) == int32('F') || *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 512)))) == int32('G') || *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 512)))) == int32('Y') { - if !(width != 0) && *(*uintptr)(unsafe.Pointer(bp + 512)) != f { + if **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 512)))) == int32('C') || **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 512)))) == int32('F') || **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 512)))) == int32('G') || **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 512)))) == int32('Y') { + if !(width != 0) && **(**uintptr)(__ccgo_up(bp + 512)) != f { width = uint64(1) } } else { width = uint64(0) } - f = *(*uintptr)(unsafe.Pointer(bp + 512)) - if *(*Twchar_t)(unsafe.Pointer(f)) == int32('E') || *(*Twchar_t)(unsafe.Pointer(f)) == int32('O') { + f = **(**uintptr)(__ccgo_up(bp + 512)) + if **(**Twchar_t)(__ccgo_up(f)) == int32('E') || **(**Twchar_t)(__ccgo_up(f)) == int32('O') { f += 4 } - t_mb = X__strftime_fmt_1(tls, bp+8, bp, *(*Twchar_t)(unsafe.Pointer(f)), tm, loc, pad) + t_mb = X__strftime_fmt_1(tls, bp+8, bp, **(**Twchar_t)(__ccgo_up(f)), tm, loc, pad) if !(t_mb != 0) { break } - *(*Tsize_t)(unsafe.Pointer(bp)) = Xmbstowcs(tls, bp+108, t_mb, Uint64FromInt64(400)/Uint64FromInt64(4)) - if *(*Tsize_t)(unsafe.Pointer(bp)) == Uint64FromInt32(-Int32FromInt32(1)) { + **(**Tsize_t)(__ccgo_up(bp)) = Xmbstowcs(tls, bp+108, t_mb, Uint64FromInt64(400)/Uint64FromInt64(4)) + if **(**Tsize_t)(__ccgo_up(bp)) == Uint64FromInt32(-Int32FromInt32(1)) { return uint64(0) } t = bp + 108 if width != 0 { for { - if !(*(*Twchar_t)(unsafe.Pointer(t)) == int32('+') || *(*Twchar_t)(unsafe.Pointer(t)) == int32('-') || *(*Twchar_t)(unsafe.Pointer(t)) == int32('0') && *(*Twchar_t)(unsafe.Pointer(t + 1*4)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(t)) == int32('+') || **(**Twchar_t)(__ccgo_up(t)) == int32('-') || **(**Twchar_t)(__ccgo_up(t)) == int32('0') && **(**Twchar_t)(__ccgo_up(t + 1*4)) != 0) { break } goto _5 _5: ; t += 4 - *(*Tsize_t)(unsafe.Pointer(bp)) = *(*Tsize_t)(unsafe.Pointer(bp)) - 1 + **(**Tsize_t)(__ccgo_up(bp)) = **(**Tsize_t)(__ccgo_up(bp)) - 1 } width = width - 1 if plus != 0 && (*Ttm)(unsafe.Pointer(tm)).Ftm_year >= Int32FromInt32(10000)-Int32FromInt32(1900) { v2 = l l = l + 1 - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = int32('+') + **(**Twchar_t)(__ccgo_up(s + uintptr(v2)*4)) = int32('+') } else { if (*Ttm)(unsafe.Pointer(tm)).Ftm_year < -int32(1900) { v2 = l l = l + 1 - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = int32('-') + **(**Twchar_t)(__ccgo_up(s + uintptr(v2)*4)) = int32('-') } else { width = width + 1 } } for { - if !(width > *(*Tsize_t)(unsafe.Pointer(bp)) && l < n) { + if !(width > **(**Tsize_t)(__ccgo_up(bp)) && l < n) { break } v2 = l l = l + 1 - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = int32('0') + **(**Twchar_t)(__ccgo_up(s + uintptr(v2)*4)) = int32('0') goto _8 _8: ; width = width - 1 } } - if *(*Tsize_t)(unsafe.Pointer(bp)) >= n-l { - *(*Tsize_t)(unsafe.Pointer(bp)) = n - l + if **(**Tsize_t)(__ccgo_up(bp)) >= n-l { + **(**Tsize_t)(__ccgo_up(bp)) = n - l } - Xwmemcpy(tls, s+uintptr(l)*4, t, *(*Tsize_t)(unsafe.Pointer(bp))) - l = l + *(*Tsize_t)(unsafe.Pointer(bp)) + Xwmemcpy(tls, s+uintptr(l)*4, t, **(**Tsize_t)(__ccgo_up(bp))) + l = l + **(**Tsize_t)(__ccgo_up(bp)) goto _1 _1: ; @@ -151626,7 +151626,7 @@ func X__wcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl if l == n { l = n - uint64(1) } - *(*Twchar_t)(unsafe.Pointer(s + uintptr(l)*4)) = 0 + **(**Twchar_t)(__ccgo_up(s + uintptr(l)*4)) = 0 } return uint64(0) } @@ -151679,14 +151679,14 @@ func Xalarm(tls *TLS, seconds uint32) (r uint32) { defer tls.Free(64) var _ /* it at bp+0 */ Titimerval var _ /* old at bp+32 */ Titimerval - *(*Titimerval)(unsafe.Pointer(bp)) = Titimerval{ + **(**Titimerval)(__ccgo_up(bp)) = Titimerval{ Fit_value: Ttimeval{ Ftv_sec: Int64FromUint32(seconds), }, } - *(*Titimerval)(unsafe.Pointer(bp + 32)) = Titimerval{} + **(**Titimerval)(__ccgo_up(bp + 32)) = Titimerval{} Xsetitimer(tls, ITIMER_REAL, bp, bp+32) - return Uint32FromInt64((*(*Titimerval)(unsafe.Pointer(bp + 32))).Fit_value.Ftv_sec + BoolInt64(!!((*(*Titimerval)(unsafe.Pointer(bp + 32))).Fit_value.Ftv_usec != 0))) + return Uint32FromInt64((**(**Titimerval)(__ccgo_up(bp + 32))).Fit_value.Ftv_sec + BoolInt64(!!((**(**Titimerval)(__ccgo_up(bp + 32))).Fit_value.Ftv_usec != 0))) } func Xchdir(tls *TLS, path uintptr) (r int32) { @@ -151827,7 +151827,7 @@ func _checker(tls *TLS, p uintptr) (r int32) { if X__syscall2(tls, int64(SYS_setregid), X__syscall0(tls, int64(SYS_getegid)), int64(-Int32FromInt32(1))) != 0 || X__syscall2(tls, int64(SYS_setreuid), X__syscall0(tls, int64(SYS_geteuid)), int64(-Int32FromInt32(1))) != 0 { X__syscall1(tls, int64(SYS_exit), int64(Int32FromInt32(1))) } - *(*int32)(unsafe.Pointer(bp)) = int32(X__syscall4(tls, int64(SYS_faccessat), int64((*Tctx1)(unsafe.Pointer(c)).Ffd), int64((*Tctx1)(unsafe.Pointer(c)).Ffilename), int64((*Tctx1)(unsafe.Pointer(c)).Famode), int64(Int32FromInt32(0)))) + **(**int32)(__ccgo_up(bp)) = int32(X__syscall4(tls, int64(SYS_faccessat), int64((*Tctx1)(unsafe.Pointer(c)).Ffd), int64((*Tctx1)(unsafe.Pointer(c)).Ffilename), int64((*Tctx1)(unsafe.Pointer(c)).Famode), int64(Int32FromInt32(0)))) X__syscall3(tls, int64(SYS_write), int64((*Tctx1)(unsafe.Pointer(c)).Fp), int64(bp), Int64FromUint64(Uint64FromInt64(4))) return 0 } @@ -151942,7 +151942,7 @@ func Xgetcwd(tls *TLS, buf uintptr, size Tsize_t) (r uintptr) { size = v1 } else { if !(size != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } } @@ -151950,8 +151950,8 @@ func Xgetcwd(tls *TLS, buf uintptr, size Tsize_t) (r uintptr) { if ret < 0 { return uintptr(0) } - if ret == 0 || Int32FromUint8(*(*uint8)(unsafe.Pointer(buf))) != int32('/') { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOENT) + if ret == 0 || Int32FromUint8(**(**uint8)(__ccgo_up(buf))) != int32('/') { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOENT) return uintptr(0) } if buf == tmp { @@ -152015,8 +152015,8 @@ func Xgethostname(tls *TLS, name uintptr, len1 Tsize_t) (r int32) { i = uint64(0) for { if v3 = i < len1; v3 { - v2 = *(*uint8)(unsafe.Pointer(bp + 65 + uintptr(i))) - *(*uint8)(unsafe.Pointer(name + uintptr(i))) = v2 + v2 = **(**uint8)(__ccgo_up(bp + 65 + uintptr(i))) + **(**uint8)(__ccgo_up(name + uintptr(i))) = v2 } if !(v3 && v2 != 0) { break @@ -152027,7 +152027,7 @@ func Xgethostname(tls *TLS, name uintptr, len1 Tsize_t) (r int32) { i = i + 1 } if i != 0 && i == len1 { - *(*uint8)(unsafe.Pointer(name + uintptr(i-uint64(1)))) = uint8(0) + **(**uint8)(__ccgo_up(name + uintptr(i-uint64(1)))) = uint8(0) } return 0 } @@ -152120,8 +152120,8 @@ func Xisatty(tls *TLS, fd int32) (r1 int32) { if r == uint64(0) { return int32(1) } - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(EBADF) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOTTY) + if **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(EBADF) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOTTY) } return 0 } @@ -152163,7 +152163,7 @@ func X__lseek(tls *TLS, fd int32, offset Toff_t, whence int32) (r Toff_t) { if X__syscall_ret(tls, Uint64FromInt64(X__syscall5(tls, int64(SYS__llseek), int64(fd), offset>>Int32FromInt32(32), offset, int64(bp), int64(whence)))) != 0 { v1 = int64(-int32(1)) } else { - v1 = *(*Toff_t)(unsafe.Pointer(bp)) + v1 = **(**Toff_t)(__ccgo_up(bp)) } return v1 } @@ -152196,8 +152196,8 @@ func Xnice(tls *TLS, inc int32) (r int32) { prio = -int32(NZERO) } if Xsetpriority(tls, PRIO_PROCESS, uint32(0), prio) != 0 { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EACCES) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EPERM) + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EACCES) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EPERM) } return -int32(1) } else { @@ -152244,12 +152244,12 @@ func Xpipe2(tls *TLS, fd uintptr, flag int32) (r int32) { return ret } if flag&int32(O_CLOEXEC) != 0 { - X__syscall3(tls, int64(SYS_fcntl), int64(*(*int32)(unsafe.Pointer(fd))), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) - X__syscall3(tls, int64(SYS_fcntl), int64(*(*int32)(unsafe.Pointer(fd + 1*4))), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) + X__syscall3(tls, int64(SYS_fcntl), int64(**(**int32)(__ccgo_up(fd))), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) + X__syscall3(tls, int64(SYS_fcntl), int64(**(**int32)(__ccgo_up(fd + 1*4))), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) } if flag&int32(O_NONBLOCK) != 0 { - X__syscall3(tls, int64(SYS_fcntl), int64(*(*int32)(unsafe.Pointer(fd))), int64(Int32FromInt32(F_SETFL)), int64(Int32FromInt32(O_NONBLOCK))) - X__syscall3(tls, int64(SYS_fcntl), int64(*(*int32)(unsafe.Pointer(fd + 1*4))), int64(Int32FromInt32(F_SETFL)), int64(Int32FromInt32(O_NONBLOCK))) + X__syscall3(tls, int64(SYS_fcntl), int64(**(**int32)(__ccgo_up(fd))), int64(Int32FromInt32(F_SETFL)), int64(Int32FromInt32(O_NONBLOCK))) + X__syscall3(tls, int64(SYS_fcntl), int64(**(**int32)(__ccgo_up(fd + 1*4))), int64(Int32FromInt32(F_SETFL)), int64(Int32FromInt32(O_NONBLOCK))) } return 0 } @@ -152448,7 +152448,7 @@ func X__setxid(tls *TLS, nr int32, id int32, eid int32, sid int32) (r int32) { _ = v1 /* ret is initially nonzero so that failure of the first thread does not * trigger the safety kill above. */ - *(*Tctx2)(unsafe.Pointer(bp)) = Tctx2{ + **(**Tctx2)(__ccgo_up(bp)) = Tctx2{ Fid: id, Feid: eid, Fsid: sid, @@ -152456,10 +152456,10 @@ func X__setxid(tls *TLS, nr int32, id int32, eid int32, sid int32) (r int32) { Fret: int32(1), } ___synccall(tls, __ccgo_fp(_do_setxid), bp) - if (*(*Tctx2)(unsafe.Pointer(bp))).Fret > 0 { + if (**(**Tctx2)(__ccgo_up(bp))).Fret > 0 { v1 = -int32(EAGAIN) } else { - v1 = (*(*Tctx2)(unsafe.Pointer(bp))).Fret + v1 = (**(**Tctx2)(__ccgo_up(bp))).Fret } return int32(X__syscall_ret(tls, Uint64FromInt32(v1))) } @@ -152472,11 +152472,11 @@ func Xsleep(tls *TLS, seconds uint32) (r uint32) { bp := tls.Alloc(16) defer tls.Free(16) var _ /* tv at bp+0 */ Ttimespec - *(*Ttimespec)(unsafe.Pointer(bp)) = Ttimespec{ + **(**Ttimespec)(__ccgo_up(bp)) = Ttimespec{ Ftv_sec: Int64FromUint32(seconds), } if Xnanosleep(tls, bp, bp) != 0 { - return Uint32FromInt64((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec) + return Uint32FromInt64((**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec) } return uint32(0) } @@ -152515,7 +152515,7 @@ func Xtcgetpgrp(tls *TLS, fd int32) (r Tpid_t) { if Xioctl(tls, fd, Int32FromUint64(uint64(Uint32FromUint32(2)<> int32(32)) - *(*int32)(unsafe.Pointer(expt)) = Int32FromUint32(hx>>Int32FromInt32(20) - Uint32FromInt32(Int32FromInt32(0x3ff)+Int32FromInt32(1023)) + _k) + **(**int32)(__ccgo_up(expt)) = Int32FromUint32(hx>>Int32FromInt32(20) - Uint32FromInt32(Int32FromInt32(0x3ff)+Int32FromInt32(1023)) + _k) v1 = uint64(hx&Uint32FromInt32(0xfffff)|Uint32FromInt32((Int32FromInt32(0x3ff)+Int32FromInt32(1023))<>Int32FromInt32(23) - Uint32FromInt32(Int32FromInt32(0x7f)+Int32FromInt32(127)) + _k1) + **(**int32)(__ccgo_up(expt)) = Int32FromUint32(hx>>Int32FromInt32(23) - Uint32FromInt32(Int32FromInt32(0x7f)+Int32FromInt32(127)) + _k1) v1 = hx&uint32(0x7fffff) | Uint32FromInt32((Int32FromInt32(0x7f)+Int32FromInt32(127))< uint32(35) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uint64(0) } } @@ -3269,7 +3269,7 @@ func Xfpathconf(tls *TLS, fd int32, name int32) (r int64) { defer func() { trc("-> %v", r) }() } if Uint64FromInt32(name) >= Uint64FromInt64(42)/Uint64FromInt64(2) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) } return int64(_values[name]) @@ -7333,7 +7333,7 @@ func Xsysconf(tls *TLS, name int32) (r int64) { var _ /* si at bp+144 */ Tsysinfo _, _, _, _, _, _, _ = cnt, i, mem, val, v1, v3, v5 if Uint64FromInt32(name) >= Uint64FromInt64(502)/Uint64FromInt64(2) || !(_values1[name] != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) } else { if int32(_values1[name]) >= -int32(1) { @@ -7341,13 +7341,13 @@ func Xsysconf(tls *TLS, name int32) (r int64) { } else { if int32(_values1[name]) < -int32(256) { Xgetrlimit(tls, int32(_values1[name])&int32(16383), bp) - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur == ^Uint64FromUint64(0) { + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur == ^Uint64FromUint64(0) { return int64(-int32(1)) } - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur > uint64(0x7fffffffffffffff) { + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur > uint64(0x7fffffffffffffff) { v1 = uint64(0x7fffffffffffffff) } else { - v1 = (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur + v1 = (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur } return Int64FromUint64(v1) } @@ -7369,7 +7369,7 @@ func Xsysconf(tls *TLS, name int32) (r int64) { case (-Int32FromInt32(256) | Int32FromInt32(6)) & Int32FromInt32(255): fallthrough case (-Int32FromInt32(256) | Int32FromInt32(7)) & Int32FromInt32(255): - *(*[128]uint8)(unsafe.Pointer(bp + 16)) = [128]uint8{ + **(**[128]uint8)(__ccgo_up(bp + 16)) = [128]uint8{ 0: uint8(1), } X__syscall3(tls, int64(SYS_sched_getaffinity), int64(Int32FromInt32(0)), Int64FromUint64(Uint64FromInt64(128)), int64(bp+16)) @@ -7381,14 +7381,14 @@ func Xsysconf(tls *TLS, name int32) (r int64) { break } for { - if !((*(*[128]uint8)(unsafe.Pointer(bp + 16)))[i] != 0) { + if !((**(**[128]uint8)(__ccgo_up(bp + 16)))[i] != 0) { break } goto _4 _4: ; v5 = bp + 16 + uintptr(i) - *(*uint8)(unsafe.Pointer(v5)) = uint8(int32(*(*uint8)(unsafe.Pointer(v5))) & (Int32FromUint8((*(*[128]uint8)(unsafe.Pointer(bp + 16)))[i]) - Int32FromInt32(1))) + *(*uint8)(unsafe.Pointer(v5)) = uint8(int32(*(*uint8)(unsafe.Pointer(v5))) & (Int32FromUint8((**(**[128]uint8)(__ccgo_up(bp + 16)))[i]) - Int32FromInt32(1))) cnt = cnt + 1 } goto _2 @@ -7401,15 +7401,15 @@ func Xsysconf(tls *TLS, name int32) (r int64) { fallthrough case (-Int32FromInt32(256) | Int32FromInt32(9)) & Int32FromInt32(255): X__lsysinfo(tls, bp+144) - if !((*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fmem_unit != 0) { - (*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fmem_unit = uint32(1) + if !((**(**Tsysinfo)(__ccgo_up(bp + 144))).Fmem_unit != 0) { + (**(**Tsysinfo)(__ccgo_up(bp + 144))).Fmem_unit = uint32(1) } if name == int32(_SC_PHYS_PAGES) { - mem = (*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Ftotalram + mem = uint64((**(**Tsysinfo)(__ccgo_up(bp + 144))).Ftotalram) } else { - mem = (*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Ffreeram + (*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fbufferram + mem = uint64((**(**Tsysinfo)(__ccgo_up(bp + 144))).Ffreeram + (**(**Tsysinfo)(__ccgo_up(bp + 144))).Fbufferram) } - mem = mem * uint64((*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fmem_unit) + mem = mem * uint64((**(**Tsysinfo)(__ccgo_up(bp + 144))).Fmem_unit) mem = mem / X__libc.Fpage_size if mem > uint64(0x7fffffffffffffff) { v1 = uint64(0x7fffffffffffffff) @@ -8809,7 +8809,7 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { for cond := true; cond; cond = dptr < end { v1 = sptr sptr = sptr + 1 - tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = uint32(**(**uint8)(__ccgo_up(v1))) tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) @@ -8821,7 +8821,7 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { c1 = tmp v1 = sptr sptr = sptr + 1 - tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = uint32(**(**uint8)(__ccgo_up(v1))) tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) @@ -8833,13 +8833,13 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { c2 = tmp v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(c1<>int32(4)) + **(**uint8)(__ccgo_up(v1)) = uint8(c1<>int32(4)) if dptr >= end { break } v1 = sptr sptr = sptr + 1 - tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = uint32(**(**uint8)(__ccgo_up(v1))) tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) @@ -8851,13 +8851,13 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { c3 = tmp v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(c2&uint32(0x0F)<>int32(2)) + **(**uint8)(__ccgo_up(v1)) = uint8(c2&uint32(0x0F)<>int32(2)) if dptr >= end { break } v1 = sptr sptr = sptr + 1 - tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = uint32(**(**uint8)(__ccgo_up(v1))) tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) @@ -8869,7 +8869,7 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { c4 = tmp v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(c3&uint32(0x03)<>int32(2)] + **(**uint8)(__ccgo_up(v1)) = _BF_itoa64[c1>>int32(2)] c1 = c1 & uint32(0x03) << int32(4) if sptr >= end { v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] + **(**uint8)(__ccgo_up(v1)) = _BF_itoa64[c1] break } v1 = sptr sptr = sptr + 1 - c2 = uint32(*(*uint8)(unsafe.Pointer(v1))) + c2 = uint32(**(**uint8)(__ccgo_up(v1))) c1 = c1 | c2>>int32(4) v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] + **(**uint8)(__ccgo_up(v1)) = _BF_itoa64[c1] c1 = c2 & uint32(0x0f) << int32(2) if sptr >= end { v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] + **(**uint8)(__ccgo_up(v1)) = _BF_itoa64[c1] break } v1 = sptr sptr = sptr + 1 - c2 = uint32(*(*uint8)(unsafe.Pointer(v1))) + c2 = uint32(**(**uint8)(__ccgo_up(v1))) c1 = c1 | c2>>int32(6) v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] + **(**uint8)(__ccgo_up(v1)) = _BF_itoa64[c1] v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c2&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _BF_itoa64[c2&uint32(0x3f)] } } @@ -8930,11 +8930,11 @@ func _BF_swap(tls *TLS, x uintptr, count int32) { v1 = int32(1) if *(*uint8)(unsafe.Pointer(&v1)) != 0 { for { - tmp = *(*TBF_word)(unsafe.Pointer(x)) + tmp = **(**TBF_word)(__ccgo_up(x)) tmp = tmp<>Int32FromInt32(16) v4 = x x += 4 - *(*TBF_word)(unsafe.Pointer(v4)) = tmp&uint32(0x00FF00FF)<>Int32FromInt32(8)&uint32(0x00FF00FF) + **(**TBF_word)(__ccgo_up(v4)) = tmp&uint32(0x00FF00FF)<>Int32FromInt32(8)&uint32(0x00FF00FF) goto _3 _3: ; @@ -8954,7 +8954,7 @@ func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, e _, _, _, _, _, _, _ = i, ptr, tmp1, tmp2, tmp3, tmp4, v2 ptr = start for cond := true; cond; cond = ptr < end { - L = L ^ *(*TBF_word)(unsafe.Pointer(ctx)) + L = L ^ **(**TBF_word)(__ccgo_up(ctx)) i = 0 for { if !(i < int32(16)) { @@ -8966,12 +8966,12 @@ func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, e tmp3 = L >> int32(16) tmp3 = tmp3 & uint32(0xFF) tmp4 = L >> int32(24) - tmp1 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 3*1024 + uintptr(tmp1)*4)) - tmp2 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 2*1024 + uintptr(tmp2)*4)) - tmp3 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 1*1024 + uintptr(tmp3)*4)) - tmp3 = tmp3 + *(*TBF_word)(unsafe.Pointer(ctx + 72 + uintptr(tmp4)*4)) + tmp1 = **(**TBF_word)(__ccgo_up(ctx + 72 + 3*1024 + uintptr(tmp1)*4)) + tmp2 = **(**TBF_word)(__ccgo_up(ctx + 72 + 2*1024 + uintptr(tmp2)*4)) + tmp3 = **(**TBF_word)(__ccgo_up(ctx + 72 + 1*1024 + uintptr(tmp3)*4)) + tmp3 = tmp3 + **(**TBF_word)(__ccgo_up(ctx + 72 + uintptr(tmp4)*4)) tmp3 = tmp3 ^ tmp2 - R = R ^ *(*TBF_word)(unsafe.Pointer(ctx + uintptr(i+int32(1))*4)) + R = R ^ **(**TBF_word)(__ccgo_up(ctx + uintptr(i+int32(1))*4)) tmp3 = tmp3 + tmp1 R = R ^ tmp3 tmp1 = R & uint32(0xFF) @@ -8980,12 +8980,12 @@ func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, e tmp3 = R >> int32(16) tmp3 = tmp3 & uint32(0xFF) tmp4 = R >> int32(24) - tmp1 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 3*1024 + uintptr(tmp1)*4)) - tmp2 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 2*1024 + uintptr(tmp2)*4)) - tmp3 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 1*1024 + uintptr(tmp3)*4)) - tmp3 = tmp3 + *(*TBF_word)(unsafe.Pointer(ctx + 72 + uintptr(tmp4)*4)) + tmp1 = **(**TBF_word)(__ccgo_up(ctx + 72 + 3*1024 + uintptr(tmp1)*4)) + tmp2 = **(**TBF_word)(__ccgo_up(ctx + 72 + 2*1024 + uintptr(tmp2)*4)) + tmp3 = **(**TBF_word)(__ccgo_up(ctx + 72 + 1*1024 + uintptr(tmp3)*4)) + tmp3 = tmp3 + **(**TBF_word)(__ccgo_up(ctx + 72 + uintptr(tmp4)*4)) tmp3 = tmp3 ^ tmp2 - L = L ^ *(*TBF_word)(unsafe.Pointer(ctx + uintptr(i+int32(1)+int32(1))*4)) + L = L ^ **(**TBF_word)(__ccgo_up(ctx + uintptr(i+int32(1)+int32(1))*4)) tmp3 = tmp3 + tmp1 L = L ^ tmp3 goto _1 @@ -8995,13 +8995,13 @@ func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, e } tmp4 = R R = L - L = tmp4 ^ *(*TBF_word)(unsafe.Pointer(ctx + uintptr(Int32FromInt32(BF_N)+Int32FromInt32(1))*4)) + L = tmp4 ^ **(**TBF_word)(__ccgo_up(ctx + uintptr(Int32FromInt32(BF_N)+Int32FromInt32(1))*4)) v2 = ptr ptr += 4 - *(*TBF_word)(unsafe.Pointer(v2)) = L + **(**TBF_word)(__ccgo_up(v2)) = L v2 = ptr ptr += 4 - *(*TBF_word)(unsafe.Pointer(v2)) = R + **(**TBF_word)(__ccgo_up(v2)) = R } return L } @@ -9061,17 +9061,17 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags break } v1 = Uint32FromInt32(0) - (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)] = v1 - (*(*[2]TBF_word)(unsafe.Pointer(bp)))[0] = v1 + (**(**[2]TBF_word)(__ccgo_up(bp)))[int32(1)] = v1 + (**(**[2]TBF_word)(__ccgo_up(bp)))[0] = v1 j = uint32(0) for { if !(j < uint32(4)) { break } - *(*TBF_word)(unsafe.Pointer(bp)) <<= uint32(8) - *(*TBF_word)(unsafe.Pointer(bp)) |= uint32(*(*uint8)(unsafe.Pointer(ptr))) /* correct */ - *(*TBF_word)(unsafe.Pointer(bp + 1*4)) <<= uint32(8) - *(*TBF_word)(unsafe.Pointer(bp + 1*4)) |= Uint32FromInt8(Int8FromUint8(*(*uint8)(unsafe.Pointer(ptr)))) /* bug */ + **(**TBF_word)(__ccgo_up(bp)) <<= uint32(8) + **(**TBF_word)(__ccgo_up(bp)) |= uint32(uint8(**(**uint8)(__ccgo_up(ptr)))) /* correct */ + **(**TBF_word)(__ccgo_up(bp + 1*4)) <<= uint32(8) + **(**TBF_word)(__ccgo_up(bp + 1*4)) |= Uint32FromInt8(Int8FromUint8(**(**uint8)(__ccgo_up(ptr)))) /* bug */ /* * Sign extension in the first char has no effect - nothing to overwrite yet, * and those extra 24 bits will be fully shifted out of the 32-bit word. For @@ -9079,9 +9079,9 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags * extension in tmp[1] occurs. Once this flag is set, it remains set. */ if j != 0 { - sign = sign | (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)]&uint32(0x80) + sign = sign | (**(**[2]TBF_word)(__ccgo_up(bp)))[int32(1)]&uint32(0x80) } - if !(*(*uint8)(unsafe.Pointer(ptr)) != 0) { + if !(**(**uint8)(__ccgo_up(ptr)) != 0) { ptr = key } else { ptr = ptr + 1 @@ -9091,9 +9091,9 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags ; j = j + 1 } - diff = diff | ((*(*[2]TBF_word)(unsafe.Pointer(bp)))[0] ^ (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)]) /* Non-zero on any differences */ - *(*TBF_word)(unsafe.Pointer(expanded + uintptr(i)*4)) = (*(*[2]TBF_word)(unsafe.Pointer(bp)))[bug] - *(*TBF_word)(unsafe.Pointer(initial + uintptr(i)*4)) = *(*TBF_word)(unsafe.Pointer(uintptr(unsafe.Pointer(&_BF_init_state)) + uintptr(i)*4)) ^ (*(*[2]TBF_word)(unsafe.Pointer(bp)))[bug] + diff = diff | ((**(**[2]TBF_word)(__ccgo_up(bp)))[0] ^ (**(**[2]TBF_word)(__ccgo_up(bp)))[int32(1)]) /* Non-zero on any differences */ + **(**TBF_word)(__ccgo_up(expanded + uintptr(i)*4)) = (**(**[2]TBF_word)(__ccgo_up(bp)))[bug] + **(**TBF_word)(__ccgo_up(initial + uintptr(i)*4)) = **(**TBF_word)(__ccgo_up(uintptr(unsafe.Pointer(&_BF_init_state)) + uintptr(i)*4)) ^ (**(**[2]TBF_word)(__ccgo_up(bp)))[bug] goto _2 _2: ; @@ -9124,7 +9124,7 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags * state that could be directly specified by a password to the buggy algorithm * (and to the fully correct one as well, but that's a side-effect). */ - *(*TBF_word)(unsafe.Pointer(initial)) ^= sign + **(**TBF_word)(__ccgo_up(initial)) ^= sign } var _flags_by_subtype = [26]uint8{ @@ -9151,28 +9151,28 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w } } _, _, _, _, _, _, _, _, _, _, _, _ = L, L1, R, count, done, i, ptr, tmp1, tmp2, tmp3, tmp4, v1 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(setting))) != int32('$') || Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 1))) != int32('2') || Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 2)))-int32('a')) > uint32(25) || !(_flags_by_subtype[Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 2)))-int32('a')] != 0) || Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 3))) != int32('$') || Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 4)))-int32('0')) > uint32(1) || Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 5)))-int32('0')) > uint32(9) || Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 6))) != int32('$') { + if Int32FromUint8(**(**uint8)(__ccgo_up(setting))) != int32('$') || Int32FromUint8(**(**uint8)(__ccgo_up(setting + 1))) != int32('2') || Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(setting + 2)))-int32('a')) > uint32(25) || !(_flags_by_subtype[Int32FromUint8(**(**uint8)(__ccgo_up(setting + 2)))-int32('a')] != 0) || Int32FromUint8(**(**uint8)(__ccgo_up(setting + 3))) != int32('$') || Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(setting + 4)))-int32('0')) > uint32(1) || Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(setting + 5)))-int32('0')) > uint32(9) || Int32FromUint8(**(**uint8)(__ccgo_up(setting + 6))) != int32('$') { return UintptrFromInt32(0) } - count = Uint32FromInt32(1) << ((Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 4)))-int32('0'))*int32(10) + (Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 5))) - int32('0'))) + count = Uint32FromInt32(1) << ((Int32FromUint8(**(**uint8)(__ccgo_up(setting + 4)))-int32('0'))*int32(10) + (Int32FromUint8(**(**uint8)(__ccgo_up(setting + 5))) - int32('0'))) if count < min || _BF_decode(tls, bp+4240, setting+7, int32(16)) != 0 { return UintptrFromInt32(0) } _BF_swap(tls, bp+4240, int32(4)) - _BF_set_key(tls, key, bp+4168, bp, _flags_by_subtype[Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 2)))-int32('a')]) + _BF_set_key(tls, key, bp+4168, bp, _flags_by_subtype[Int32FromUint8(**(**uint8)(__ccgo_up(setting + 2)))-int32('a')]) Xmemcpy(tls, bp+72, uintptr(unsafe.Pointer(&_BF_init_state))+72, uint64(4096)) L = uint32(0) R = uint32(0) ptr = bp for cond := true; cond; cond = int32(1) != 0 { - L = _BF_encrypt(tls, bp, L^*(*TBF_word)(unsafe.Pointer(bp + 4240)), R^*(*TBF_word)(unsafe.Pointer(bp + 4240 + 1*4)), ptr, ptr) - R = *(*TBF_word)(unsafe.Pointer(ptr + UintptrFromInt32(1)*4)) + L = _BF_encrypt(tls, bp, L^**(**TBF_word)(__ccgo_up(bp + 4240)), R^**(**TBF_word)(__ccgo_up(bp + 4240 + 1*4)), ptr, ptr) + R = **(**TBF_word)(__ccgo_up(ptr + UintptrFromInt32(1)*4)) ptr = ptr + uintptr(2)*4 if ptr >= bp+uintptr(Int32FromInt32(BF_N)+Int32FromInt32(2)+Int32FromInt32(4)*Int32FromInt32(0x100))*4 { break } - L = _BF_encrypt(tls, bp, L^*(*TBF_word)(unsafe.Pointer(bp + 4240 + 2*4)), R^*(*TBF_word)(unsafe.Pointer(bp + 4240 + 3*4)), ptr, ptr) - R = *(*TBF_word)(unsafe.Pointer(ptr + UintptrFromInt32(1)*4)) + L = _BF_encrypt(tls, bp, L^**(**TBF_word)(__ccgo_up(bp + 4240 + 2*4)), R^**(**TBF_word)(__ccgo_up(bp + 4240 + 3*4)), ptr, ptr) + R = **(**TBF_word)(__ccgo_up(ptr + UintptrFromInt32(1)*4)) ptr = ptr + uintptr(2)*4 } for { @@ -9181,8 +9181,8 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w if !(i < Int32FromInt32(BF_N)+Int32FromInt32(2)) { break } - *(*TBF_word)(unsafe.Pointer(bp + uintptr(i)*4)) ^= *(*TBF_word)(unsafe.Pointer(bp + 4168 + uintptr(i)*4)) - *(*TBF_word)(unsafe.Pointer(bp + uintptr(i+int32(1))*4)) ^= *(*TBF_word)(unsafe.Pointer(bp + 4168 + uintptr(i+int32(1))*4)) + **(**TBF_word)(__ccgo_up(bp + uintptr(i)*4)) ^= **(**TBF_word)(__ccgo_up(bp + 4168 + uintptr(i)*4)) + **(**TBF_word)(__ccgo_up(bp + uintptr(i+int32(1))*4)) ^= **(**TBF_word)(__ccgo_up(bp + 4168 + uintptr(i+int32(1))*4)) goto _3 _3: ; @@ -9195,26 +9195,26 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w break } done = int32(1) - tmp1 = *(*TBF_word)(unsafe.Pointer(bp + 4240)) - tmp2 = *(*TBF_word)(unsafe.Pointer(bp + 4240 + 1*4)) - tmp3 = *(*TBF_word)(unsafe.Pointer(bp + 4240 + 2*4)) - tmp4 = *(*TBF_word)(unsafe.Pointer(bp + 4240 + 3*4)) + tmp1 = **(**TBF_word)(__ccgo_up(bp + 4240)) + tmp2 = **(**TBF_word)(__ccgo_up(bp + 4240 + 1*4)) + tmp3 = **(**TBF_word)(__ccgo_up(bp + 4240 + 2*4)) + tmp4 = **(**TBF_word)(__ccgo_up(bp + 4240 + 3*4)) i = 0 for { if !(i < int32(BF_N)) { break } - *(*TBF_word)(unsafe.Pointer(bp + uintptr(i)*4)) ^= tmp1 - *(*TBF_word)(unsafe.Pointer(bp + uintptr(i+int32(1))*4)) ^= tmp2 - *(*TBF_word)(unsafe.Pointer(bp + uintptr(i+int32(2))*4)) ^= tmp3 - *(*TBF_word)(unsafe.Pointer(bp + uintptr(i+int32(3))*4)) ^= tmp4 + **(**TBF_word)(__ccgo_up(bp + uintptr(i)*4)) ^= tmp1 + **(**TBF_word)(__ccgo_up(bp + uintptr(i+int32(1))*4)) ^= tmp2 + **(**TBF_word)(__ccgo_up(bp + uintptr(i+int32(2))*4)) ^= tmp3 + **(**TBF_word)(__ccgo_up(bp + uintptr(i+int32(3))*4)) ^= tmp4 goto _4 _4: ; i = i + int32(4) } - *(*TBF_word)(unsafe.Pointer(bp + 16*4)) ^= tmp1 - *(*TBF_word)(unsafe.Pointer(bp + 17*4)) ^= tmp2 + **(**TBF_word)(__ccgo_up(bp + 16*4)) ^= tmp1 + **(**TBF_word)(__ccgo_up(bp + 17*4)) ^= tmp2 } goto _2 _2: @@ -9231,10 +9231,10 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w break } L1 = _BF_magic_w[i] - (*(*[2]TBF_word)(unsafe.Pointer(bp + 4264)))[int32(1)] = _BF_magic_w[i+int32(1)] + (**(**[2]TBF_word)(__ccgo_up(bp + 4264)))[int32(1)] = _BF_magic_w[i+int32(1)] count = uint32(64) for { - L1 = _BF_encrypt(tls, bp, L1, (*(*[2]TBF_word)(unsafe.Pointer(bp + 4264)))[int32(1)], bp+4264, bp+4264) + L1 = _BF_encrypt(tls, bp, L1, (**(**[2]TBF_word)(__ccgo_up(bp + 4264)))[int32(1)], bp+4264, bp+4264) goto _7 _7: ; @@ -9244,20 +9244,20 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w break } } - *(*TBF_word)(unsafe.Pointer(bp + 4240 + uintptr(i)*4)) = L1 - *(*TBF_word)(unsafe.Pointer(bp + 4240 + uintptr(i+int32(1))*4)) = (*(*[2]TBF_word)(unsafe.Pointer(bp + 4264)))[int32(1)] + **(**TBF_word)(__ccgo_up(bp + 4240 + uintptr(i)*4)) = L1 + **(**TBF_word)(__ccgo_up(bp + 4240 + uintptr(i+int32(1))*4)) = (**(**[2]TBF_word)(__ccgo_up(bp + 4264)))[int32(1)] goto _5 _5: ; i = i + int32(2) } Xmemcpy(tls, output, setting, Uint64FromInt32(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1))) - *(*uint8)(unsafe.Pointer(output + uintptr(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1)))) = _BF_itoa64[Int32FromUint8(_BF_atoi64[Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1)))))-int32(0x20)])&int32(0x30)] + **(**uint8)(__ccgo_up(output + uintptr(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1)))) = _BF_itoa64[Int32FromUint8(_BF_atoi64[Int32FromUint8(**(**uint8)(__ccgo_up(setting + uintptr(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1)))))-int32(0x20)])&int32(0x30)] /* This has to be bug-compatible with the original implementation, so * only encode 23 of the 24 bytes. :-) */ _BF_swap(tls, bp+4240, int32(6)) _BF_encode(tls, output+uintptr(Int32FromInt32(7)+Int32FromInt32(22)), bp+4240, int32(23)) - *(*uint8)(unsafe.Pointer(output + uintptr(Int32FromInt32(7)+Int32FromInt32(22)+Int32FromInt32(31)))) = uint8('\000') + **(**uint8)(__ccgo_up(output + uintptr(Int32FromInt32(7)+Int32FromInt32(22)+Int32FromInt32(31)))) = uint8('\000') return output } @@ -9316,19 +9316,19 @@ func X__crypt_blowfish(tls *TLS, key uintptr, setting uintptr, output uintptr) ( */ Xmemcpy(tls, bp, test_setting, uint64(30)) if retval != 0 { - flags = uint32(_flags_by_subtype[Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 2)))-int32('a')]) + flags = uint32(_flags_by_subtype[Int32FromUint8(**(**uint8)(__ccgo_up(setting + 2)))-int32('a')]) test_hash = uintptr(unsafe.Pointer(&_test_hashes)) + uintptr(flags&uint32(1))*34 - *(*uint8)(unsafe.Pointer(bp + 2)) = *(*uint8)(unsafe.Pointer(setting + 2)) + **(**uint8)(__ccgo_up(bp + 2)) = **(**uint8)(__ccgo_up(setting + 2)) } Xmemset(tls, bp+30, int32(0x55), uint64(63)) - *(*uint8)(unsafe.Pointer(bp + 30 + uintptr(Uint64FromInt64(63)-Uint64FromInt32(1)))) = uint8(0) + **(**uint8)(__ccgo_up(bp + 30 + uintptr(Uint64FromInt64(63)-Uint64FromInt32(1)))) = uint8(0) p = _BF_crypt(tls, test_key, bp, bp+30, uint32(1)) ok = BoolInt32(p == bp+30 && !(Xmemcmp(tls, p, bp, Uint64FromInt32(Int32FromInt32(7)+Int32FromInt32(22))) != 0) && !(Xmemcmp(tls, p+uintptr(Int32FromInt32(7)+Int32FromInt32(22)), test_hash, Uint64FromInt32(Int32FromInt32(31)+Int32FromInt32(1)+Int32FromInt32(1)+Int32FromInt32(1))) != 0)) k = __ccgo_ts + 58 - _BF_set_key(tls, k, bp+96, bp+168, uint8(2)) /* $2a$ */ - _BF_set_key(tls, k, bp+240, bp+312, uint8(4)) /* $2y$ */ - *(*TBF_word)(unsafe.Pointer(bp + 168)) ^= uint32(0x10000) /* undo the safety (for comparison) */ - ok = BoolInt32(ok != 0 && (*(*TBF_key)(unsafe.Pointer(bp + 168)))[0] == uint32(0xdb9c59bc) && (*(*TBF_key)(unsafe.Pointer(bp + 240)))[int32(17)] == uint32(0x33343500) && !(Xmemcmp(tls, bp+96, bp+240, uint64(72)) != 0) && !(Xmemcmp(tls, bp+168, bp+312, uint64(72)) != 0)) + _BF_set_key(tls, k, bp+96, bp+168, uint8(2)) /* $2a$ */ + _BF_set_key(tls, k, bp+240, bp+312, uint8(4)) /* $2y$ */ + **(**TBF_word)(__ccgo_up(bp + 168)) ^= uint32(0x10000) /* undo the safety (for comparison) */ + ok = BoolInt32(ok != 0 && (**(**TBF_key)(__ccgo_up(bp + 168)))[0] == uint32(0xdb9c59bc) && (**(**TBF_key)(__ccgo_up(bp + 240)))[int32(17)] == uint32(0x33343500) && !(Xmemcmp(tls, bp+96, bp+240, uint64(72)) != 0) && !(Xmemcmp(tls, bp+168, bp+312, uint64(72)) != 0)) if ok != 0 && retval != 0 { return retval } @@ -11178,8 +11178,8 @@ func X__des_setkey(tls *TLS, key uintptr, ekey uintptr) { var i, ibit, j, round, shifts uint32 var k0, k1, kl, kr, rawkey0, rawkey1, t0, t1, v1 Tuint32_t _, _, _, _, _, _, _, _, _, _, _, _, _, _ = i, ibit, j, k0, k1, kl, kr, rawkey0, rawkey1, round, shifts, t0, t1, v1 - rawkey0 = uint32(*(*uint8)(unsafe.Pointer(key + 3))) | uint32(*(*uint8)(unsafe.Pointer(key + 2)))<>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskl)) + uintptr(i+uint32(4))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4))) - k1 = k1 | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j)*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) + k0 = k0 | (**(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_key_perm_maskl)) + uintptr(i)*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_key_perm_maskl)) + uintptr(i+uint32(4))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4))) + k1 = k1 | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j)*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) ibit = ibit - uint32(4) - k1 = k1 | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j+uint32(1))*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(i+uint32(8))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4))) + k1 = k1 | (**(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j+uint32(1))*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(i+uint32(8))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4))) goto _2 _2: ; @@ -11224,19 +11224,19 @@ func X__des_setkey(tls *TLS, key uintptr, ekey uintptr) { if !(i < uint32(4)) { break } - kl = kl | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskl0)) + uintptr(i)*32 + uintptr(t0>>ibit&uint32(7))*4)) - kr = kr | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskr0)) + uintptr(i)*32 + uintptr(t1>>ibit&uint32(7))*4)) + kl = kl | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_comp_maskl0)) + uintptr(i)*32 + uintptr(t0>>ibit&uint32(7))*4)) + kr = kr | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_comp_maskr0)) + uintptr(i)*32 + uintptr(t1>>ibit&uint32(7))*4)) ibit = ibit - uint32(4) - kl = kl | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskl1)) + uintptr(i)*64 + uintptr(t0>>ibit&uint32(0xf))*4)) - kr = kr | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskr1)) + uintptr(i)*64 + uintptr(t1>>ibit&uint32(0xf))*4)) + kl = kl | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_comp_maskl1)) + uintptr(i)*64 + uintptr(t0>>ibit&uint32(0xf))*4)) + kr = kr | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_comp_maskr1)) + uintptr(i)*64 + uintptr(t1>>ibit&uint32(0xf))*4)) ibit = ibit - uint32(3) goto _5 _5: ; i = i + 1 } - *(*Tuint32_t)(unsafe.Pointer(ekey + uintptr(round)*4)) = kl - *(*Tuint32_t)(unsafe.Pointer(ekey + 64 + uintptr(round)*4)) = kr + **(**Tuint32_t)(__ccgo_up(ekey + uintptr(round)*4)) = kl + **(**Tuint32_t)(__ccgo_up(ekey + 64 + uintptr(round)*4)) = kr goto _3 _3: ; @@ -11270,8 +11270,8 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui if !(i < uint32(8)) { break } - l = l | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4))) - r = r | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4))) + l = l | (**(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4))) + r = r | (**(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4))) goto _2 _2: ; @@ -11309,15 +11309,15 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui f = (r48l ^ r48r) & saltbits v5 = kl kl += 4 - r48l = r48l ^ (f ^ *(*Tuint32_t)(unsafe.Pointer(v5))) + r48l = r48l ^ (f ^ **(**Tuint32_t)(__ccgo_up(v5))) v5 = kr kr += 4 - r48r = r48r ^ (f ^ *(*Tuint32_t)(unsafe.Pointer(v5))) + r48r = r48r ^ (f ^ **(**Tuint32_t)(__ccgo_up(v5))) /* * Do S-box lookups (which shrink it back to 32 bits) * and do the P-box permutation at the same time. */ - f = *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + uintptr(r48l>>int32(18))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 1*256 + uintptr(r48l>>Int32FromInt32(12)&uint32(0x3f))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 2*256 + uintptr(r48l>>Int32FromInt32(6)&uint32(0x3f))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 3*256 + uintptr(r48l&uint32(0x3f))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 4*256 + uintptr(r48r>>int32(18))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 5*256 + uintptr(r48r>>Int32FromInt32(12)&uint32(0x3f))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 6*256 + uintptr(r48r>>Int32FromInt32(6)&uint32(0x3f))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 7*256 + uintptr(r48r&uint32(0x3f))*4)) + f = **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + uintptr(r48l>>int32(18))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 1*256 + uintptr(r48l>>Int32FromInt32(12)&uint32(0x3f))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 2*256 + uintptr(r48l>>Int32FromInt32(6)&uint32(0x3f))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 3*256 + uintptr(r48l&uint32(0x3f))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 4*256 + uintptr(r48r>>int32(18))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 5*256 + uintptr(r48r>>Int32FromInt32(12)&uint32(0x3f))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 6*256 + uintptr(r48r>>Int32FromInt32(6)&uint32(0x3f))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 7*256 + uintptr(r48r&uint32(0x3f))*4)) /* * Now that we've permuted things, complete f(). */ @@ -11340,17 +11340,17 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui if !(i1 < uint32(4)) { break } - ro = ro | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4))) + ro = ro | (**(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4))) ibit1 = ibit1 - uint32(4) - lo = lo | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4))) + lo = lo | (**(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4))) goto _8 _8: ; i1 = i1 + 1 ibit1 = ibit1 - uint32(4) } - *(*Tuint32_t)(unsafe.Pointer(l_out)) = lo - *(*Tuint32_t)(unsafe.Pointer(r_out)) = ro + **(**Tuint32_t)(__ccgo_up(l_out)) = lo + **(**Tuint32_t)(__ccgo_up(r_out)) = ro } func _des_cipher(tls *TLS, in uintptr, out uintptr, count Tuint32_t, saltbits Tuint32_t, ekey uintptr) { @@ -11360,17 +11360,17 @@ func _des_cipher(tls *TLS, in uintptr, out uintptr, count Tuint32_t, saltbits Tu var _ /* l_out at bp+0 */ Tuint32_t var _ /* r_out at bp+4 */ Tuint32_t _, _ = rawl, rawr - rawl = uint32(*(*uint8)(unsafe.Pointer(in + 3))) | uint32(*(*uint8)(unsafe.Pointer(in + 2)))<> int32(24)) - *(*uint8)(unsafe.Pointer(out + 1)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp)) >> int32(16)) - *(*uint8)(unsafe.Pointer(out + 2)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp)) >> int32(8)) - *(*uint8)(unsafe.Pointer(out + 3)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp))) - *(*uint8)(unsafe.Pointer(out + 4)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp + 4)) >> int32(24)) - *(*uint8)(unsafe.Pointer(out + 5)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp + 4)) >> int32(16)) - *(*uint8)(unsafe.Pointer(out + 6)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp + 4)) >> int32(8)) - *(*uint8)(unsafe.Pointer(out + 7)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp + 4))) + **(**uint8)(__ccgo_up(out)) = uint8(**(**Tuint32_t)(__ccgo_up(bp)) >> int32(24)) + **(**uint8)(__ccgo_up(out + 1)) = uint8(**(**Tuint32_t)(__ccgo_up(bp)) >> int32(16)) + **(**uint8)(__ccgo_up(out + 2)) = uint8(**(**Tuint32_t)(__ccgo_up(bp)) >> int32(8)) + **(**uint8)(__ccgo_up(out + 3)) = uint8(**(**Tuint32_t)(__ccgo_up(bp))) + **(**uint8)(__ccgo_up(out + 4)) = uint8(**(**Tuint32_t)(__ccgo_up(bp + 4)) >> int32(24)) + **(**uint8)(__ccgo_up(out + 5)) = uint8(**(**Tuint32_t)(__ccgo_up(bp + 4)) >> int32(16)) + **(**uint8)(__ccgo_up(out + 6)) = uint8(**(**Tuint32_t)(__ccgo_up(bp + 4)) >> int32(8)) + **(**uint8)(__ccgo_up(out + 7)) = uint8(**(**Tuint32_t)(__ccgo_up(bp + 4))) } func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uintptr) (r uintptr) { @@ -11394,13 +11394,13 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin for q <= bp+128+uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) { v1 = q q = q + 1 - *(*uint8)(unsafe.Pointer(v1)) = Uint8FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(key))) << int32(1)) - if *(*uint8)(unsafe.Pointer(key)) != 0 { + **(**uint8)(__ccgo_up(v1)) = Uint8FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(key))) << int32(1)) + if **(**uint8)(__ccgo_up(key)) != 0 { key = key + 1 } } X__des_setkey(tls, bp+128, bp) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(setting))) == int32('_') { + if Int32FromUint8(**(**uint8)(__ccgo_up(setting))) == int32('_') { /* * "new"-style: * setting - underscore, 4 chars of count, 4 chars of salt @@ -11412,8 +11412,8 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin if !(i < uint32(5)) { break } - value = _ascii_to_bin(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(i))))) - if Int32FromUint8(_ascii64[value]) != Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(i)))) { + value = _ascii_to_bin(tls, Int32FromUint8(**(**uint8)(__ccgo_up(setting + uintptr(i))))) + if Int32FromUint8(_ascii64[value]) != Int32FromUint8(**(**uint8)(__ccgo_up(setting + uintptr(i)))) { return UintptrFromInt32(0) } count = count | value<<((i-uint32(1))*uint32(6)) @@ -11431,8 +11431,8 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin if !(i < uint32(9)) { break } - value1 = _ascii_to_bin(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(i))))) - if Int32FromUint8(_ascii64[value1]) != Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(i)))) { + value1 = _ascii_to_bin(tls, Int32FromUint8(**(**uint8)(__ccgo_up(setting + uintptr(i))))) + if Int32FromUint8(_ascii64[value1]) != Int32FromUint8(**(**uint8)(__ccgo_up(setting + uintptr(i)))) { return UintptrFromInt32(0) } salt = salt | value1<<((i-uint32(5))*uint32(6)) @@ -11441,7 +11441,7 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin ; i = i + 1 } - for *(*uint8)(unsafe.Pointer(key)) != 0 { + for **(**uint8)(__ccgo_up(key)) != 0 { /* * Encrypt the key with itself. */ @@ -11450,18 +11450,18 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin * And XOR with the next 8 characters of the key. */ q = bp + 128 - for q <= bp+128+uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) && *(*uint8)(unsafe.Pointer(key)) != 0 { + for q <= bp+128+uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) && **(**uint8)(__ccgo_up(key)) != 0 { v4 = q q = q + 1 v1 = v4 v5 = key key = key + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(int32(*(*uint8)(unsafe.Pointer(v1))) ^ Int32FromUint8(*(*uint8)(unsafe.Pointer(v5)))<> int32(8) + l = **(**Tuint32_t)(__ccgo_up(bp + 136)) >> int32(8) v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l&uint32(0x3f)] - l = *(*Tuint32_t)(unsafe.Pointer(bp + 136))<>Int32FromInt32(16)&uint32(0xffff) + **(**uint8)(__ccgo_up(v1)) = _ascii64[l&uint32(0x3f)] + l = **(**Tuint32_t)(__ccgo_up(bp + 136))<>Int32FromInt32(16)&uint32(0xffff) v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l&uint32(0x3f)] - l = *(*Tuint32_t)(unsafe.Pointer(bp + 140)) << int32(2) + **(**uint8)(__ccgo_up(v1)) = _ascii64[l&uint32(0x3f)] + l = **(**Tuint32_t)(__ccgo_up(bp + 140)) << int32(2) v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l&uint32(0x3f)] - *(*uint8)(unsafe.Pointer(p)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = _ascii64[l&uint32(0x3f)] + **(**uint8)(__ccgo_up(p)) = uint8(0) return output } @@ -11538,7 +11538,7 @@ func X__crypt_des(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uin test_key = __ccgo_ts + 72 test_setting = __ccgo_ts + 93 test_hash = __ccgo_ts + 103 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(setting))) != int32('_') { + if Int32FromUint8(**(**uint8)(__ccgo_up(setting))) != int32('_') { test_setting = __ccgo_ts + 124 test_hash = __ccgo_ts + 127 } @@ -11557,7 +11557,7 @@ func X__crypt_des(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uin if p != 0 && !(Xstrcmp(tls, p, test_hash) != 0) && retval != 0 { return retval } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(setting))) == int32('*') { + if Int32FromUint8(**(**uint8)(__ccgo_up(setting))) == int32('*') { v1 = __ccgo_ts + 141 } else { v1 = __ccgo_ts + 70 @@ -11658,80 +11658,80 @@ func _processblock(tls *TLS, s uintptr, buf uintptr) { if !(i < uint32(16)) { break } - (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] = uint32(*(*Tuint8_t)(unsafe.Pointer(buf + uintptr(uint32(4)*i)))) - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(i)*4)) |= uint32(*(*Tuint8_t)(unsafe.Pointer(buf + uintptr(uint32(4)*i+uint32(1))))) << int32(8) - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(i)*4)) |= uint32(*(*Tuint8_t)(unsafe.Pointer(buf + uintptr(uint32(4)*i+uint32(2))))) << int32(16) - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(i)*4)) |= uint32(*(*Tuint8_t)(unsafe.Pointer(buf + uintptr(uint32(4)*i+uint32(3))))) << int32(24) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[i] = uint32(**(**Tuint8_t)(__ccgo_up(buf + uintptr(uint32(4)*i)))) + **(**Tuint32_t)(__ccgo_up(bp + uintptr(i)*4)) |= uint32(**(**Tuint8_t)(__ccgo_up(buf + uintptr(uint32(4)*i+uint32(1))))) << int32(8) + **(**Tuint32_t)(__ccgo_up(bp + uintptr(i)*4)) |= uint32(**(**Tuint8_t)(__ccgo_up(buf + uintptr(uint32(4)*i+uint32(2))))) << int32(16) + **(**Tuint32_t)(__ccgo_up(bp + uintptr(i)*4)) |= uint32(**(**Tuint8_t)(__ccgo_up(buf + uintptr(uint32(4)*i+uint32(3))))) << int32(24) goto _1 _1: ; i = i + 1 } - a = *(*Tuint32_t)(unsafe.Pointer(s + 8)) - b = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) - c = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 2*4)) - d = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) + a = **(**Tuint32_t)(__ccgo_up(s + 8)) + b = **(**Tuint32_t)(__ccgo_up(s + 8 + 1*4)) + c = **(**Tuint32_t)(__ccgo_up(s + 8 + 2*4)) + d = **(**Tuint32_t)(__ccgo_up(s + 8 + 3*4)) i = uint32(0) for i < uint32(16) { - a = a + (d ^ b&(c^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) + a = a + (d ^ b&(c^d) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[i] + _tab[i]) a = _rol(tls, a, int32(7)) + b i = i + 1 - d = d + (c ^ a&(b^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) + d = d + (c ^ a&(b^c) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[i] + _tab[i]) d = _rol(tls, d, int32(12)) + a i = i + 1 - c = c + (b ^ d&(a^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) + c = c + (b ^ d&(a^b) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[i] + _tab[i]) c = _rol(tls, c, int32(17)) + d i = i + 1 - b = b + (a ^ c&(d^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) + b = b + (a ^ c&(d^a) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[i] + _tab[i]) b = _rol(tls, b, int32(22)) + c i = i + 1 } for i < uint32(32) { - a = a + (c ^ d&(c^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) + a = a + (c ^ d&(c^b) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) a = _rol(tls, a, int32(5)) + b i = i + 1 - d = d + (b ^ c&(b^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) + d = d + (b ^ c&(b^a) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) d = _rol(tls, d, int32(9)) + a i = i + 1 - c = c + (a ^ b&(a^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) + c = c + (a ^ b&(a^d) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) c = _rol(tls, c, int32(14)) + d i = i + 1 - b = b + (d ^ a&(d^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) + b = b + (d ^ a&(d^c) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) b = _rol(tls, b, int32(20)) + c i = i + 1 } for i < uint32(48) { - a = a + (b ^ c ^ d + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) + a = a + (b ^ c ^ d + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) a = _rol(tls, a, int32(4)) + b i = i + 1 - d = d + (a ^ b ^ c + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) + d = d + (a ^ b ^ c + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) d = _rol(tls, d, int32(11)) + a i = i + 1 - c = c + (d ^ a ^ b + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) + c = c + (d ^ a ^ b + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) c = _rol(tls, c, int32(16)) + d i = i + 1 - b = b + (c ^ d ^ a + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) + b = b + (c ^ d ^ a + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) b = _rol(tls, b, int32(23)) + c i = i + 1 } for i < uint32(64) { - a = a + (c ^ (b | ^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) + a = a + (c ^ (b | ^d) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) a = _rol(tls, a, int32(6)) + b i = i + 1 - d = d + (b ^ (a | ^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) + d = d + (b ^ (a | ^c) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) d = _rol(tls, d, int32(10)) + a i = i + 1 - c = c + (a ^ (d | ^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) + c = c + (a ^ (d | ^b) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) c = _rol(tls, c, int32(15)) + d i = i + 1 - b = b + (d ^ (c | ^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) + b = b + (d ^ (c | ^a) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) b = _rol(tls, b, int32(21)) + c i = i + 1 } - *(*Tuint32_t)(unsafe.Pointer(s + 8)) += a - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) += b - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 2*4)) += c - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) += d + **(**Tuint32_t)(__ccgo_up(s + 8)) += a + **(**Tuint32_t)(__ccgo_up(s + 8 + 1*4)) += b + **(**Tuint32_t)(__ccgo_up(s + 8 + 2*4)) += c + **(**Tuint32_t)(__ccgo_up(s + 8 + 3*4)) += d } func _pad(tls *TLS, s uintptr) { @@ -11740,31 +11740,31 @@ func _pad(tls *TLS, s uintptr) { r = uint32((*Tmd5)(unsafe.Pointer(s)).Flen1 % uint64(64)) v1 = r r = r + 1 - *(*Tuint8_t)(unsafe.Pointer(s + 24 + uintptr(v1))) = uint8(0x80) + **(**Tuint8_t)(__ccgo_up(s + 24 + uintptr(v1))) = uint8(0x80) if r > uint32(56) { Xmemset(tls, s+24+uintptr(r), 0, uint64(uint32(64)-r)) r = uint32(0) _processblock(tls, s, s+24) } Xmemset(tls, s+24+uintptr(r), 0, uint64(uint32(56)-r)) - *(*Tuint64_t)(unsafe.Pointer(s)) *= uint64(8) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 56)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 57)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(8)) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 58)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(16)) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 59)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(24)) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 60)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(32)) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 61)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(40)) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 62)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(48)) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 63)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(56)) + **(**Tuint64_t)(__ccgo_up(s)) *= uint64(8) + **(**Tuint8_t)(__ccgo_up(s + 24 + 56)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1) + **(**Tuint8_t)(__ccgo_up(s + 24 + 57)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(8)) + **(**Tuint8_t)(__ccgo_up(s + 24 + 58)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(16)) + **(**Tuint8_t)(__ccgo_up(s + 24 + 59)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(24)) + **(**Tuint8_t)(__ccgo_up(s + 24 + 60)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(32)) + **(**Tuint8_t)(__ccgo_up(s + 24 + 61)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(40)) + **(**Tuint8_t)(__ccgo_up(s + 24 + 62)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(48)) + **(**Tuint8_t)(__ccgo_up(s + 24 + 63)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(56)) _processblock(tls, s, s+24) } func _md5_init(tls *TLS, s uintptr) { (*Tmd5)(unsafe.Pointer(s)).Flen1 = uint64(0) - *(*Tuint32_t)(unsafe.Pointer(s + 8)) = uint32(0x67452301) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) = uint32(0xefcdab89) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 2*4)) = uint32(0x98badcfe) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) = uint32(0x10325476) + **(**Tuint32_t)(__ccgo_up(s + 8)) = uint32(0x67452301) + **(**Tuint32_t)(__ccgo_up(s + 8 + 1*4)) = uint32(0xefcdab89) + **(**Tuint32_t)(__ccgo_up(s + 8 + 2*4)) = uint32(0x98badcfe) + **(**Tuint32_t)(__ccgo_up(s + 8 + 3*4)) = uint32(0x10325476) } func _md5_sum(tls *TLS, s uintptr, md uintptr) { @@ -11776,10 +11776,10 @@ func _md5_sum(tls *TLS, s uintptr, md uintptr) { if !(i < int32(4)) { break } - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4))) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i+int32(1)))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4)) >> int32(8)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i+int32(2)))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4)) >> int32(16)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i+int32(3)))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4)) >> int32(24)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4))) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i+int32(1)))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4)) >> int32(8)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i+int32(2)))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4)) >> int32(16)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i+int32(3)))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4)) >> int32(24)) goto _1 _1: ; @@ -11793,7 +11793,7 @@ func _md5_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { _, _ = p, r p = m r = uint32((*Tmd5)(unsafe.Pointer(s)).Flen1 % uint64(64)) - *(*Tuint64_t)(unsafe.Pointer(s)) += len1 + **(**Tuint64_t)(__ccgo_up(s)) += len1 if r != 0 { if len1 < uint64(uint32(64)-r) { Xmemcpy(tls, s+24+uintptr(r), p, len1) @@ -11860,7 +11860,7 @@ func _to64(tls *TLS, s uintptr, u uint32, n int32) (r uintptr) { } v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = _b64[u%uint32(64)] + **(**uint8)(__ccgo_up(v2)) = _b64[u%uint32(64)] u = u / uint32(64) } return s @@ -11886,7 +11886,7 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt salt = setting + uintptr(3) i = uint32(0) for { - if !(i < uint32(SALT_MAX) && *(*uint8)(unsafe.Pointer(salt + uintptr(i))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(salt + uintptr(i)))) != int32('$')) { + if !(i < uint32(SALT_MAX) && **(**uint8)(__ccgo_up(salt + uintptr(i))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(salt + uintptr(i)))) != int32('$')) { break } goto _1 @@ -11917,7 +11917,7 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt i = uint32(uint64(i) - Uint64FromInt64(16)) } _md5_update(tls, bp, bp+88, uint64(i)) - (*(*[16]uint8)(unsafe.Pointer(bp + 88)))[0] = uint8(0) + (**(**[16]uint8)(__ccgo_up(bp + 88)))[0] = uint8(0) i = klen for { if !(i != 0) { @@ -11968,20 +11968,20 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt p = output + uintptr(3) + uintptr(slen) v5 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v5)) = uint8('$') + **(**uint8)(__ccgo_up(v5)) = uint8('$') i = uint32(0) for { if !(i < uint32(5)) { break } - p = _to64(tls, p, Uint32FromInt32(Int32FromUint8((*(*[16]uint8)(unsafe.Pointer(bp + 88)))[*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_perm)) + uintptr(i)*3))])<>Int32FromInt32(10) + (*(*[64]Tuint32_t)(unsafe.Pointer(bp)))[i-int32(7)] + (_ror(tls, (*(*[64]Tuint32_t)(unsafe.Pointer(bp)))[i-int32(15)], int32(7)) ^ _ror(tls, (*(*[64]Tuint32_t)(unsafe.Pointer(bp)))[i-int32(15)], int32(18)) ^ (*(*[64]Tuint32_t)(unsafe.Pointer(bp)))[i-int32(15)]>>Int32FromInt32(3)) + (*(*[64]Tuint32_t)(unsafe.Pointer(bp)))[i-int32(16)] + (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i] = _ror(tls, (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(2)], int32(17)) ^ _ror(tls, (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(2)], int32(19)) ^ (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(2)]>>Int32FromInt32(10) + (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(7)] + (_ror(tls, (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(15)], int32(7)) ^ _ror(tls, (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(15)], int32(18)) ^ (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(15)]>>Int32FromInt32(3)) + (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(16)] goto _2 _2: ; i = i + 1 } - a = *(*Tuint32_t)(unsafe.Pointer(s + 8)) - b = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) - c = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 2*4)) - d = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) - e = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 4*4)) - f = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 5*4)) - g = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 6*4)) - h = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 7*4)) + a = **(**Tuint32_t)(__ccgo_up(s + 8)) + b = **(**Tuint32_t)(__ccgo_up(s + 8 + 1*4)) + c = **(**Tuint32_t)(__ccgo_up(s + 8 + 2*4)) + d = **(**Tuint32_t)(__ccgo_up(s + 8 + 3*4)) + e = **(**Tuint32_t)(__ccgo_up(s + 8 + 4*4)) + f = **(**Tuint32_t)(__ccgo_up(s + 8 + 5*4)) + g = **(**Tuint32_t)(__ccgo_up(s + 8 + 6*4)) + h = **(**Tuint32_t)(__ccgo_up(s + 8 + 7*4)) i = 0 for { if !(i < int32(64)) { break } - t1 = h + (_ror(tls, e, int32(6)) ^ _ror(tls, e, int32(11)) ^ _ror(tls, e, int32(25))) + (g ^ e&(f^g)) + _K[i] + (*(*[64]Tuint32_t)(unsafe.Pointer(bp)))[i] + t1 = h + (_ror(tls, e, int32(6)) ^ _ror(tls, e, int32(11)) ^ _ror(tls, e, int32(25))) + (g ^ e&(f^g)) + _K[i] + (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i] t2 = _ror(tls, a, int32(2)) ^ _ror(tls, a, int32(13)) ^ _ror(tls, a, int32(22)) + (a&b | c&(a|b)) h = g g = f @@ -12218,14 +12218,14 @@ func _processblock1(tls *TLS, s uintptr, buf uintptr) { ; i = i + 1 } - *(*Tuint32_t)(unsafe.Pointer(s + 8)) += a - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) += b - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 2*4)) += c - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) += d - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 4*4)) += e - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 5*4)) += f - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 6*4)) += g - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 7*4)) += h + **(**Tuint32_t)(__ccgo_up(s + 8)) += a + **(**Tuint32_t)(__ccgo_up(s + 8 + 1*4)) += b + **(**Tuint32_t)(__ccgo_up(s + 8 + 2*4)) += c + **(**Tuint32_t)(__ccgo_up(s + 8 + 3*4)) += d + **(**Tuint32_t)(__ccgo_up(s + 8 + 4*4)) += e + **(**Tuint32_t)(__ccgo_up(s + 8 + 5*4)) += f + **(**Tuint32_t)(__ccgo_up(s + 8 + 6*4)) += g + **(**Tuint32_t)(__ccgo_up(s + 8 + 7*4)) += h } func _pad1(tls *TLS, s uintptr) { @@ -12234,35 +12234,35 @@ func _pad1(tls *TLS, s uintptr) { r = uint32((*Tsha256)(unsafe.Pointer(s)).Flen1 % uint64(64)) v1 = r r = r + 1 - *(*Tuint8_t)(unsafe.Pointer(s + 40 + uintptr(v1))) = uint8(0x80) + **(**Tuint8_t)(__ccgo_up(s + 40 + uintptr(v1))) = uint8(0x80) if r > uint32(56) { Xmemset(tls, s+40+uintptr(r), 0, uint64(uint32(64)-r)) r = uint32(0) _processblock1(tls, s, s+40) } Xmemset(tls, s+40+uintptr(r), 0, uint64(uint32(56)-r)) - *(*Tuint64_t)(unsafe.Pointer(s)) *= uint64(8) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 56)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(56)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 57)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(48)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 58)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(40)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 59)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(32)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 60)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(24)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 61)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(16)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 62)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(8)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 63)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1) + **(**Tuint64_t)(__ccgo_up(s)) *= uint64(8) + **(**Tuint8_t)(__ccgo_up(s + 40 + 56)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(56)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 57)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(48)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 58)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(40)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 59)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(32)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 60)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(24)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 61)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(16)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 62)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(8)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 63)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1) _processblock1(tls, s, s+40) } func _sha256_init(tls *TLS, s uintptr) { (*Tsha256)(unsafe.Pointer(s)).Flen1 = uint64(0) - *(*Tuint32_t)(unsafe.Pointer(s + 8)) = uint32(0x6a09e667) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) = uint32(0xbb67ae85) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 2*4)) = uint32(0x3c6ef372) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) = uint32(0xa54ff53a) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 4*4)) = uint32(0x510e527f) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 5*4)) = uint32(0x9b05688c) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 6*4)) = uint32(0x1f83d9ab) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 7*4)) = uint32(0x5be0cd19) + **(**Tuint32_t)(__ccgo_up(s + 8)) = uint32(0x6a09e667) + **(**Tuint32_t)(__ccgo_up(s + 8 + 1*4)) = uint32(0xbb67ae85) + **(**Tuint32_t)(__ccgo_up(s + 8 + 2*4)) = uint32(0x3c6ef372) + **(**Tuint32_t)(__ccgo_up(s + 8 + 3*4)) = uint32(0xa54ff53a) + **(**Tuint32_t)(__ccgo_up(s + 8 + 4*4)) = uint32(0x510e527f) + **(**Tuint32_t)(__ccgo_up(s + 8 + 5*4)) = uint32(0x9b05688c) + **(**Tuint32_t)(__ccgo_up(s + 8 + 6*4)) = uint32(0x1f83d9ab) + **(**Tuint32_t)(__ccgo_up(s + 8 + 7*4)) = uint32(0x5be0cd19) } func _sha256_sum(tls *TLS, s uintptr, md uintptr) { @@ -12274,10 +12274,10 @@ func _sha256_sum(tls *TLS, s uintptr, md uintptr) { if !(i < int32(8)) { break } - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4)) >> int32(24)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i+int32(1)))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4)) >> int32(16)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i+int32(2)))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4)) >> int32(8)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i+int32(3)))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4))) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4)) >> int32(24)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i+int32(1)))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4)) >> int32(16)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i+int32(2)))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4)) >> int32(8)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i+int32(3)))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4))) goto _1 _1: ; @@ -12291,7 +12291,7 @@ func _sha256_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { _, _ = p, r p = m r = uint32((*Tsha256)(unsafe.Pointer(s)).Flen1 % uint64(64)) - *(*Tuint64_t)(unsafe.Pointer(s)) += len1 + **(**Tuint64_t)(__ccgo_up(s)) += len1 if r != 0 { if len1 < uint64(uint32(64)-r) { Xmemcpy(tls, s+40+uintptr(r), p, len1) @@ -12330,7 +12330,7 @@ func _to641(tls *TLS, s uintptr, u uint32, n int32) (r uintptr) { } v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = _b641[u%uint32(64)] + **(**uint8)(__ccgo_up(v2)) = _b641[u%uint32(64)] u = u / uint32(64) } return s @@ -12373,7 +12373,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui var _ /* rounds at bp+200 */ [20]uint8 var _ /* smd at bp+168 */ [32]uint8 _, _, _, _, _, _, _ = i, klen, p, r, salt, slen, u - *(*[20]uint8)(unsafe.Pointer(bp + 200)) = [20]uint8{} + **(**[20]uint8)(__ccgo_up(bp + 200)) = [20]uint8{} /* reject large keys */ klen = uint32(Xstrnlen(tls, key, Uint64FromInt32(Int32FromInt32(KEY_MAX1)+Int32FromInt32(1)))) if klen > uint32(KEY_MAX1) { @@ -12399,14 +12399,14 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui * the host's value of ULONG_MAX. */ salt = salt + uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(salt)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(salt)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } u = Xstrtoul(tls, salt, bp+224, int32(10)) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 224))))) != int32('$') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 224))))) != int32('$') { return uintptr(0) } - salt = *(*uintptr)(unsafe.Pointer(bp + 224)) + uintptr(1) + salt = **(**uintptr)(__ccgo_up(bp + 224)) + uintptr(1) if u < uint64(ROUNDS_MIN) { r = uint32(ROUNDS_MIN) } else { @@ -12421,11 +12421,11 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui } i = uint32(0) for { - if !(i < uint32(SALT_MAX1) && *(*uint8)(unsafe.Pointer(salt + uintptr(i))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(salt + uintptr(i)))) != int32('$')) { + if !(i < uint32(SALT_MAX1) && **(**uint8)(__ccgo_up(salt + uintptr(i))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(salt + uintptr(i)))) != int32('$')) { break } /* reject characters that interfere with /etc/shadow parsing */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(salt + uintptr(i)))) == int32('\n') || Int32FromUint8(*(*uint8)(unsafe.Pointer(salt + uintptr(i)))) == int32(':') { + if Int32FromUint8(**(**uint8)(__ccgo_up(salt + uintptr(i)))) == int32('\n') || Int32FromUint8(**(**uint8)(__ccgo_up(salt + uintptr(i)))) == int32(':') { return uintptr(0) } goto _1 @@ -12479,7 +12479,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui _sha256_init(tls, bp) i = uint32(0) for { - if !(i < Uint32FromInt32(int32(16)+Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp + 104)))[0]))) { + if !(i < Uint32FromInt32(int32(16)+Int32FromUint8((**(**[32]uint8)(__ccgo_up(bp + 104)))[0]))) { break } _sha256_update(tls, bp, salt, uint64(slen)) @@ -12526,14 +12526,14 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui if !(i < uint32(10)) { break } - p = _to641(tls, p, Uint32FromInt32(Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp + 104)))[*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_perm1)) + uintptr(i)*3))])<>Int32FromInt32(6) + (*(*[80]Tuint64_t)(unsafe.Pointer(bp)))[i-int32(7)] + (_ror1(tls, (*(*[80]Tuint64_t)(unsafe.Pointer(bp)))[i-int32(15)], int32(1)) ^ _ror1(tls, (*(*[80]Tuint64_t)(unsafe.Pointer(bp)))[i-int32(15)], int32(8)) ^ (*(*[80]Tuint64_t)(unsafe.Pointer(bp)))[i-int32(15)]>>Int32FromInt32(7)) + (*(*[80]Tuint64_t)(unsafe.Pointer(bp)))[i-int32(16)] + (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i] = _ror1(tls, (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(2)], int32(19)) ^ _ror1(tls, (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(2)], int32(61)) ^ (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(2)]>>Int32FromInt32(6) + (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(7)] + (_ror1(tls, (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(15)], int32(1)) ^ _ror1(tls, (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(15)], int32(8)) ^ (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(15)]>>Int32FromInt32(7)) + (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(16)] goto _2 _2: ; i = i + 1 } - a = *(*Tuint64_t)(unsafe.Pointer(s + 8)) - b = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 1*8)) - c = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 2*8)) - d = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 3*8)) - e = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 4*8)) - f = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 5*8)) - g = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 6*8)) - h = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 7*8)) + a = **(**Tuint64_t)(__ccgo_up(s + 8)) + b = **(**Tuint64_t)(__ccgo_up(s + 8 + 1*8)) + c = **(**Tuint64_t)(__ccgo_up(s + 8 + 2*8)) + d = **(**Tuint64_t)(__ccgo_up(s + 8 + 3*8)) + e = **(**Tuint64_t)(__ccgo_up(s + 8 + 4*8)) + f = **(**Tuint64_t)(__ccgo_up(s + 8 + 5*8)) + g = **(**Tuint64_t)(__ccgo_up(s + 8 + 6*8)) + h = **(**Tuint64_t)(__ccgo_up(s + 8 + 7*8)) i = 0 for { if !(i < int32(80)) { break } - t1 = h + (_ror1(tls, e, int32(14)) ^ _ror1(tls, e, int32(18)) ^ _ror1(tls, e, int32(41))) + (g ^ e&(f^g)) + _K1[i] + (*(*[80]Tuint64_t)(unsafe.Pointer(bp)))[i] + t1 = h + (_ror1(tls, e, int32(14)) ^ _ror1(tls, e, int32(18)) ^ _ror1(tls, e, int32(41))) + (g ^ e&(f^g)) + _K1[i] + (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i] t2 = _ror1(tls, a, int32(28)) ^ _ror1(tls, a, int32(34)) ^ _ror1(tls, a, int32(39)) + (a&b | c&(a|b)) h = g g = f @@ -12773,14 +12773,14 @@ func _processblock2(tls *TLS, s uintptr, buf uintptr) { ; i = i + 1 } - *(*Tuint64_t)(unsafe.Pointer(s + 8)) += a - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 1*8)) += b - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 2*8)) += c - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 3*8)) += d - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 4*8)) += e - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 5*8)) += f - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 6*8)) += g - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 7*8)) += h + **(**Tuint64_t)(__ccgo_up(s + 8)) += a + **(**Tuint64_t)(__ccgo_up(s + 8 + 1*8)) += b + **(**Tuint64_t)(__ccgo_up(s + 8 + 2*8)) += c + **(**Tuint64_t)(__ccgo_up(s + 8 + 3*8)) += d + **(**Tuint64_t)(__ccgo_up(s + 8 + 4*8)) += e + **(**Tuint64_t)(__ccgo_up(s + 8 + 5*8)) += f + **(**Tuint64_t)(__ccgo_up(s + 8 + 6*8)) += g + **(**Tuint64_t)(__ccgo_up(s + 8 + 7*8)) += h } func _pad2(tls *TLS, s uintptr) { @@ -12789,35 +12789,35 @@ func _pad2(tls *TLS, s uintptr) { r = uint32((*Tsha512)(unsafe.Pointer(s)).Flen1 % uint64(128)) v1 = r r = r + 1 - *(*Tuint8_t)(unsafe.Pointer(s + 72 + uintptr(v1))) = uint8(0x80) + **(**Tuint8_t)(__ccgo_up(s + 72 + uintptr(v1))) = uint8(0x80) if r > uint32(112) { Xmemset(tls, s+72+uintptr(r), 0, uint64(uint32(128)-r)) r = uint32(0) _processblock2(tls, s, s+72) } Xmemset(tls, s+72+uintptr(r), 0, uint64(uint32(120)-r)) - *(*Tuint64_t)(unsafe.Pointer(s)) *= uint64(8) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 120)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(56)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 121)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(48)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 122)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(40)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 123)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(32)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 124)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(24)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 125)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(16)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 126)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(8)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 127)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1) + **(**Tuint64_t)(__ccgo_up(s)) *= uint64(8) + **(**Tuint8_t)(__ccgo_up(s + 72 + 120)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(56)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 121)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(48)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 122)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(40)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 123)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(32)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 124)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(24)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 125)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(16)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 126)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(8)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 127)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1) _processblock2(tls, s, s+72) } func _sha512_init(tls *TLS, s uintptr) { (*Tsha512)(unsafe.Pointer(s)).Flen1 = uint64(0) - *(*Tuint64_t)(unsafe.Pointer(s + 8)) = uint64(0x6a09e667f3bcc908) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 1*8)) = uint64(0xbb67ae8584caa73b) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 2*8)) = uint64(0x3c6ef372fe94f82b) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 3*8)) = uint64(0xa54ff53a5f1d36f1) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 4*8)) = uint64(0x510e527fade682d1) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 5*8)) = uint64(0x9b05688c2b3e6c1f) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 6*8)) = uint64(0x1f83d9abfb41bd6b) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 7*8)) = uint64(0x5be0cd19137e2179) + **(**Tuint64_t)(__ccgo_up(s + 8)) = uint64(0x6a09e667f3bcc908) + **(**Tuint64_t)(__ccgo_up(s + 8 + 1*8)) = uint64(0xbb67ae8584caa73b) + **(**Tuint64_t)(__ccgo_up(s + 8 + 2*8)) = uint64(0x3c6ef372fe94f82b) + **(**Tuint64_t)(__ccgo_up(s + 8 + 3*8)) = uint64(0xa54ff53a5f1d36f1) + **(**Tuint64_t)(__ccgo_up(s + 8 + 4*8)) = uint64(0x510e527fade682d1) + **(**Tuint64_t)(__ccgo_up(s + 8 + 5*8)) = uint64(0x9b05688c2b3e6c1f) + **(**Tuint64_t)(__ccgo_up(s + 8 + 6*8)) = uint64(0x1f83d9abfb41bd6b) + **(**Tuint64_t)(__ccgo_up(s + 8 + 7*8)) = uint64(0x5be0cd19137e2179) } func _sha512_sum(tls *TLS, s uintptr, md uintptr) { @@ -12829,14 +12829,14 @@ func _sha512_sum(tls *TLS, s uintptr, md uintptr) { if !(i < int32(8)) { break } - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(56)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(1)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(48)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(2)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(40)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(3)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(32)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(4)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(24)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(5)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(16)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(6)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(8)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(7)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8))) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(56)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(1)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(48)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(2)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(40)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(3)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(32)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(4)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(24)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(5)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(16)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(6)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(8)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(7)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8))) goto _1 _1: ; @@ -12850,7 +12850,7 @@ func _sha512_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { _, _ = p, r p = m r = uint32((*Tsha512)(unsafe.Pointer(s)).Flen1 % uint64(128)) - *(*Tuint64_t)(unsafe.Pointer(s)) += len1 + **(**Tuint64_t)(__ccgo_up(s)) += len1 if r != 0 { if len1 < uint64(uint32(128)-r) { Xmemcpy(tls, s+72+uintptr(r), p, len1) @@ -12889,7 +12889,7 @@ func _to642(tls *TLS, s uintptr, u uint32, n int32) (r uintptr) { } v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = _b642[u%uint32(64)] + **(**uint8)(__ccgo_up(v2)) = _b642[u%uint32(64)] u = u / uint32(64) } return s @@ -12932,11 +12932,11 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui var _ /* rounds at bp+392 */ [20]uint8 var _ /* smd at bp+328 */ [64]uint8 _, _, _, _, _, _, _ = i, klen, p, r, salt, slen, u - *(*[20]uint8)(unsafe.Pointer(bp + 392)) = [20]uint8{} + **(**[20]uint8)(__ccgo_up(bp + 392)) = [20]uint8{} /* reject large keys */ i = uint32(0) for { - if !(i <= uint32(KEY_MAX1) && *(*uint8)(unsafe.Pointer(key + uintptr(i))) != 0) { + if !(i <= uint32(KEY_MAX1) && **(**uint8)(__ccgo_up(key + uintptr(i))) != 0) { break } goto _1 @@ -12968,14 +12968,14 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui * the host's value of ULONG_MAX. */ salt = salt + uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(salt)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(salt)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } u = Xstrtoul(tls, salt, bp+416, int32(10)) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 416))))) != int32('$') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 416))))) != int32('$') { return uintptr(0) } - salt = *(*uintptr)(unsafe.Pointer(bp + 416)) + uintptr(1) + salt = **(**uintptr)(__ccgo_up(bp + 416)) + uintptr(1) if u < uint64(ROUNDS_MIN) { r = uint32(ROUNDS_MIN) } else { @@ -12990,11 +12990,11 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui } i = uint32(0) for { - if !(i < uint32(SALT_MAX1) && *(*uint8)(unsafe.Pointer(salt + uintptr(i))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(salt + uintptr(i)))) != int32('$')) { + if !(i < uint32(SALT_MAX1) && **(**uint8)(__ccgo_up(salt + uintptr(i))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(salt + uintptr(i)))) != int32('$')) { break } /* reject characters that interfere with /etc/shadow parsing */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(salt + uintptr(i)))) == int32('\n') || Int32FromUint8(*(*uint8)(unsafe.Pointer(salt + uintptr(i)))) == int32(':') { + if Int32FromUint8(**(**uint8)(__ccgo_up(salt + uintptr(i)))) == int32('\n') || Int32FromUint8(**(**uint8)(__ccgo_up(salt + uintptr(i)))) == int32(':') { return uintptr(0) } goto _2 @@ -13048,7 +13048,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui _sha512_init(tls, bp) i = uint32(0) for { - if !(i < Uint32FromInt32(int32(16)+Int32FromUint8((*(*[64]uint8)(unsafe.Pointer(bp + 200)))[0]))) { + if !(i < Uint32FromInt32(int32(16)+Int32FromUint8((**(**[64]uint8)(__ccgo_up(bp + 200)))[0]))) { break } _sha512_update(tls, bp, salt, uint64(slen)) @@ -13095,14 +13095,14 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui if !(i < uint32(21)) { break } - p = _to642(tls, p, Uint32FromInt32(Int32FromUint8((*(*[64]uint8)(unsafe.Pointer(bp + 200)))[*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_perm2)) + uintptr(i)*3))])<= 0) { break } v3 = bp + uintptr(i) - *(*uint8)(unsafe.Pointer(v3)) = uint8(uint32(*(*uint8)(unsafe.Pointer(v3))) | Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(key)))&Int32FromInt32(1))<= 0) { break } - *(*Tuint32_t)(unsafe.Pointer(bp + 128 + uintptr(i)*4)) |= Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))&Int32FromInt32(1)) << j + **(**Tuint32_t)(__ccgo_up(bp + 128 + uintptr(i)*4)) |= Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(p)))&Int32FromInt32(1)) << j goto _2 _2: ; @@ -13320,15 +13320,15 @@ func Xencrypt(tls *TLS, block uintptr, edflag int32) { if !(i < int32(16)) { break } - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(i)*4)) = *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&___encrypt_key)) + uintptr(int32(15)-i)*4)) - *(*Tuint32_t)(unsafe.Pointer(bp + 64 + uintptr(i)*4)) = *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&___encrypt_key)) + 64 + uintptr(int32(15)-i)*4)) + **(**Tuint32_t)(__ccgo_up(bp + uintptr(i)*4)) = **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&___encrypt_key)) + uintptr(int32(15)-i)*4)) + **(**Tuint32_t)(__ccgo_up(bp + 64 + uintptr(i)*4)) = **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&___encrypt_key)) + 64 + uintptr(int32(15)-i)*4)) goto _3 _3: ; i = i + 1 } } - X__do_des(tls, (*(*[2]Tuint32_t)(unsafe.Pointer(bp + 128)))[0], (*(*[2]Tuint32_t)(unsafe.Pointer(bp + 128)))[int32(1)], bp+128, bp+128+uintptr(1)*4, uint32(1), uint32(0), key) + X__do_des(tls, (**(**[2]Tuint32_t)(__ccgo_up(bp + 128)))[0], (**(**[2]Tuint32_t)(__ccgo_up(bp + 128)))[int32(1)], bp+128, bp+128+uintptr(1)*4, uint32(1), uint32(0), key) p = block i = 0 for { @@ -13342,7 +13342,7 @@ func Xencrypt(tls *TLS, block uintptr, edflag int32) { } v6 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v6)) = uint8((*(*[2]Tuint32_t)(unsafe.Pointer(bp + 128)))[i] >> j & uint32(1)) + **(**uint8)(__ccgo_up(v6)) = uint8((**(**[2]Tuint32_t)(__ccgo_up(bp + 128)))[i] >> j & uint32(1)) goto _5 _5: ; @@ -13818,7 +13818,7 @@ func X__ctype_get_mb_cur_max(tls *TLS) (r Tsize_t) { } var v1 int32 _ = v1 - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v1 = int32(4) } else { v1 = int32(1) @@ -17382,10 +17382,10 @@ func Xwctype(tls *TLS, s uintptr) (r Twctype_t) { i = int32(1) p = uintptr(unsafe.Pointer(&_names)) for { - if !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if !(**(**uint8)(__ccgo_up(p)) != 0) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) && !(Xstrcmp(tls, s, p) != 0) { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == Int32FromUint8(**(**uint8)(__ccgo_up(p))) && !(Xstrcmp(tls, s, p) != 0) { return Uint64FromInt32(i) } goto _1 @@ -22131,9 +22131,9 @@ func _casemap(tls *TLS, c uint32, dir int32) (r1 int32) { xn = Uint32FromInt32(rd & int32(0xff)) xb = Uint32FromInt32(rd) >> int32(8) for xn != 0 { - try = uint32(*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_exceptions)) + uintptr(xb+xn/uint32(2))*2))) + try = uint32(**(**uint8)(__ccgo_up(uintptr(unsafe.Pointer(&_exceptions)) + uintptr(xb+xn/uint32(2))*2))) if try == c { - r = _rules[*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_exceptions)) + uintptr(xb+xn/uint32(2))*2 + 1))] + r = _rules[**(**uint8)(__ccgo_up(uintptr(unsafe.Pointer(&_exceptions)) + uintptr(xb+xn/uint32(2))*2 + 1))] rt = Uint32FromInt32(r & int32(255)) rd = r >> int32(8) if rt < uint32(2) { @@ -22226,8 +22226,8 @@ func Xwcswidth(tls *TLS, wcs uintptr, n Tsize_t) (r int32) { for { v2 = n n = n - 1 - if v4 = v2 != 0 && *(*Twchar_t)(unsafe.Pointer(wcs)) != 0; v4 { - v3 = Xwcwidth(tls, *(*Twchar_t)(unsafe.Pointer(wcs))) + if v4 = v2 != 0 && **(**Twchar_t)(__ccgo_up(wcs)) != 0; v4 { + v3 = Xwcwidth(tls, **(**Twchar_t)(__ccgo_up(wcs))) k = v3 } if !(v4 && v3 >= 0) { @@ -24427,7 +24427,7 @@ func Xalphasort(tls *TLS, a uintptr, b uintptr) (r int32) { trc("tls=%v a=%v b=%v, (%v:)", tls, a, b, origin(2)) defer func() { trc("-> %v", r) }() } - return Xstrcoll(tls, *(*uintptr)(unsafe.Pointer(a))+19, *(*uintptr)(unsafe.Pointer(b))+19) + return Xstrcoll(tls, **(**uintptr)(__ccgo_up(a))+19, **(**uintptr)(__ccgo_up(b))+19) } type TDIR = struct { @@ -24596,11 +24596,11 @@ func Xfdopendir(tls *TLS, fd int32) (r uintptr) { return uintptr(0) } if Xfcntl(tls, fd, int32(F_GETFL), 0)&int32(O_PATH) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EBADF) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EBADF) return uintptr(0) } - if !((*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&Uint32FromInt32(S_IFMT) == Uint32FromInt32(S_IFDIR)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOTDIR) + if !((**(**Tstat)(__ccgo_up(bp))).Fst_mode&Uint32FromInt32(S_IFMT) == Uint32FromInt32(S_IFDIR)) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOTDIR) return uintptr(0) } v1 = Xcalloc(tls, uint64(1), uint64(2072)) @@ -24735,7 +24735,7 @@ func Xreaddir(tls *TLS, dir uintptr) (r uintptr) { len1 = int32(X__syscall3(tls, int64(SYS_getdents64), int64((*TDIR)(unsafe.Pointer(dir)).Ffd), int64(dir+24), Int64FromUint64(Uint64FromInt64(2048)))) if len1 <= 0 { if len1 < 0 && len1 != -int32(ENOENT) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = -len1 + **(**int32)(__ccgo_up(X__errno_location(tls))) = -len1 } return uintptr(0) } @@ -24743,7 +24743,7 @@ func Xreaddir(tls *TLS, dir uintptr) (r uintptr) { (*TDIR)(unsafe.Pointer(dir)).Fbuf_pos = 0 } de = dir + 24 + uintptr((*TDIR)(unsafe.Pointer(dir)).Fbuf_pos) - *(*int32)(unsafe.Pointer(dir + 12)) += Int32FromUint16((*Tdirent)(unsafe.Pointer(de)).Fd_reclen) + **(**int32)(__ccgo_up(dir + 12)) += Int32FromUint16((*Tdirent)(unsafe.Pointer(de)).Fd_reclen) (*TDIR)(unsafe.Pointer(dir)).Ftell = (*Tdirent)(unsafe.Pointer(de)).Fd_off return de } @@ -24756,24 +24756,24 @@ func Xreaddir_r(tls *TLS, dir uintptr, buf uintptr, result uintptr) (r int32) { var de uintptr var errno_save, ret, v1 int32 _, _, _, _ = de, errno_save, ret, v1 - errno_save = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + errno_save = **(**int32)(__ccgo_up(X__errno_location(tls))) ___lock(tls, dir+20) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = 0 + **(**int32)(__ccgo_up(X__errno_location(tls))) = 0 de = Xreaddir(tls, dir) - v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = **(**int32)(__ccgo_up(X__errno_location(tls))) ret = v1 if v1 != 0 { ___unlock(tls, dir+20) return ret } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = errno_save + **(**int32)(__ccgo_up(X__errno_location(tls))) = errno_save if de != 0 { Xmemcpy(tls, buf, de, uint64((*Tdirent)(unsafe.Pointer(de)).Fd_reclen)) } else { buf = UintptrFromInt32(0) } ___unlock(tls, dir+20) - *(*uintptr)(unsafe.Pointer(result)) = buf + **(**uintptr)(__ccgo_up(result)) = buf return 0 } @@ -24809,12 +24809,12 @@ func Xscandir(tls *TLS, path uintptr, res uintptr, __ccgo_fp_sel uintptr, __ccgo names = uintptr(0) cnt = uint64(0) len1 = uint64(0) - old_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + old_errno = **(**int32)(__ccgo_up(X__errno_location(tls))) if !(d != 0) { return -int32(1) } for { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = 0 + **(**int32)(__ccgo_up(X__errno_location(tls))) = 0 v1 = Xreaddir(tls, d) de = v1 if !(v1 != 0) { @@ -24834,16 +24834,16 @@ func Xscandir(tls *TLS, path uintptr, res uintptr, __ccgo_fp_sel uintptr, __ccgo } names = tmp } - *(*uintptr)(unsafe.Pointer(names + uintptr(cnt)*8)) = Xmalloc(tls, uint64((*Tdirent)(unsafe.Pointer(de)).Fd_reclen)) - if !(*(*uintptr)(unsafe.Pointer(names + uintptr(cnt)*8)) != 0) { + **(**uintptr)(__ccgo_up(names + uintptr(cnt)*8)) = Xmalloc(tls, uint64((*Tdirent)(unsafe.Pointer(de)).Fd_reclen)) + if !(**(**uintptr)(__ccgo_up(names + uintptr(cnt)*8)) != 0) { break } v2 = cnt cnt = cnt + 1 - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(names + uintptr(v2)*8)), de, uint64((*Tdirent)(unsafe.Pointer(de)).Fd_reclen)) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(names + uintptr(v2)*8)), de, uint64((*Tdirent)(unsafe.Pointer(de)).Fd_reclen)) } Xclosedir(tls, d) - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != 0 { + if **(**int32)(__ccgo_up(X__errno_location(tls))) != 0 { if names != 0 { for { v2 = cnt @@ -24851,17 +24851,17 @@ func Xscandir(tls *TLS, path uintptr, res uintptr, __ccgo_fp_sel uintptr, __ccgo if !(v2 > uint64(0)) { break } - Xfree(tls, *(*uintptr)(unsafe.Pointer(names + uintptr(cnt)*8))) + Xfree(tls, **(**uintptr)(__ccgo_up(names + uintptr(cnt)*8))) } } Xfree(tls, names) return -int32(1) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = old_errno + **(**int32)(__ccgo_up(X__errno_location(tls))) = old_errno if __ccgo_fp_cmp != 0 { Xqsort(tls, names, cnt, uint64(8), __ccgo_fp_cmp) } - *(*uintptr)(unsafe.Pointer(res)) = names + **(**uintptr)(__ccgo_up(res)) = names return Int32FromUint64(cnt) } @@ -24892,7 +24892,7 @@ func Xversionsort(tls *TLS, a uintptr, b uintptr) (r int32) { trc("tls=%v a=%v b=%v, (%v:)", tls, a, b, origin(2)) defer func() { trc("-> %v", r) }() } - return Xstrverscmp(tls, *(*uintptr)(unsafe.Pointer(a))+19, *(*uintptr)(unsafe.Pointer(b))+19) + return Xstrverscmp(tls, **(**uintptr)(__ccgo_up(a))+19, **(**uintptr)(__ccgo_up(b))+19) } func X__reset_tls(tls *TLS) { @@ -24904,7 +24904,7 @@ func X__reset_tls(tls *TLS) { var self Tpthread_t _, _, _, _, _ = i, mem, n, p, self self = uintptr(___get_tp(tls)) - n = *(*Tuintptr_t)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(self)).Fdtv)) + n = **(**Tuintptr_t)(__ccgo_up((*t__pthread)(unsafe.Pointer(self)).Fdtv)) if n != 0 { p = X__libc.Ftls_head i = Uint64FromInt32(1) @@ -24912,7 +24912,7 @@ func X__reset_tls(tls *TLS) { if !(i <= n) { break } - mem = uintptr(*(*Tuintptr_t)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(self)).Fdtv + uintptr(i)*8)) - Uint64FromInt32(DTP_OFFSET)) + mem = uintptr(**(**Tuintptr_t)(__ccgo_up((*t__pthread)(unsafe.Pointer(self)).Fdtv + uintptr(i)*8)) - Uint64FromInt32(DTP_OFFSET)) Xmemcpy(tls, mem, (*Ttls_module)(unsafe.Pointer(p)).Fimage, (*Ttls_module)(unsafe.Pointer(p)).Flen1) Xmemset(tls, mem+uintptr((*Ttls_module)(unsafe.Pointer(p)).Flen1), 0, (*Ttls_module)(unsafe.Pointer(p)).Fsize-(*Ttls_module)(unsafe.Pointer(p)).Flen1) goto _1 @@ -24938,7 +24938,7 @@ func X__init_ssp(tls *TLS, entropy uintptr) { * The NULL byte is on the second byte so that off-by-ones can * still be detected. Endianness is taken care of * automatically. */ - *(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stack_chk_guard)) + 1)) = uint8(0) + **(**uint8)(__ccgo_up(uintptr(unsafe.Pointer(&X__stack_chk_guard)) + 1)) = uint8(0) (*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Fcanary = X__stack_chk_guard } @@ -24946,7 +24946,7 @@ func X__stack_chk_fail(tls *TLS) { if __ccgo_strace { trc("tls=%v, (%v:)", tls, origin(2)) } - *(*uint8)(unsafe.Pointer(UintptrFromInt32(0))) = uint8(0) + **(**uint8)(__ccgo_up(UintptrFromInt32(0))) = uint8(0) } func X__stack_chk_fail_local(tls *TLS) { @@ -24973,10 +24973,10 @@ func Xclearenv(tls *TLS) (r int32) { e = Xenviron Xenviron = uintptr(0) if e != 0 { - for *(*uintptr)(unsafe.Pointer(e)) != 0 { + for **(**uintptr)(__ccgo_up(e)) != 0 { v1 = e e += 8 - X__env_rm_add(tls, *(*uintptr)(unsafe.Pointer(v1)), uintptr(0)) + X__env_rm_add(tls, **(**uintptr)(__ccgo_up(v1)), uintptr(0)) } } return 0 @@ -24991,14 +24991,14 @@ func Xgetenv(tls *TLS, name uintptr) (r uintptr) { var l Tsize_t _, _ = e, l l = Uint64FromInt64(int64(X__strchrnul(tls, name, int32('='))) - int64(name)) - if l != 0 && !(*(*uint8)(unsafe.Pointer(name + uintptr(l))) != 0) && Xenviron != 0 { + if l != 0 && !(**(**uint8)(__ccgo_up(name + uintptr(l))) != 0) && Xenviron != 0 { e = Xenviron for { - if !(*(*uintptr)(unsafe.Pointer(e)) != 0) { + if !(**(**uintptr)(__ccgo_up(e)) != 0) { break } - if !(Xstrncmp(tls, name, *(*uintptr)(unsafe.Pointer(e)), l) != 0) && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(e)) + uintptr(l)))) == int32('=') { - return *(*uintptr)(unsafe.Pointer(e)) + uintptr(l) + uintptr(1) + if !(Xstrncmp(tls, name, **(**uintptr)(__ccgo_up(e)), l) != 0) && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(e)) + uintptr(l)))) == int32('=') { + return **(**uintptr)(__ccgo_up(e)) + uintptr(l) + uintptr(1) } goto _1 _1: @@ -25024,12 +25024,12 @@ func X__putenv(tls *TLS, s uintptr, l Tsize_t, r uintptr) (r1 int32) { if Xenviron != 0 { e = Xenviron for { - if !(*(*uintptr)(unsafe.Pointer(e)) != 0) { + if !(**(**uintptr)(__ccgo_up(e)) != 0) { break } - if !(Xstrncmp(tls, s, *(*uintptr)(unsafe.Pointer(e)), l+uint64(1)) != 0) { - tmp = *(*uintptr)(unsafe.Pointer(e)) - *(*uintptr)(unsafe.Pointer(e)) = s + if !(Xstrncmp(tls, s, **(**uintptr)(__ccgo_up(e)), l+uint64(1)) != 0) { + tmp = **(**uintptr)(__ccgo_up(e)) + **(**uintptr)(__ccgo_up(e)) = s X__env_rm_add(tls, tmp, r) return 0 } @@ -25055,8 +25055,8 @@ func X__putenv(tls *TLS, s uintptr, l Tsize_t, r uintptr) (r1 int32) { } Xfree(tls, _oldenv) } - *(*uintptr)(unsafe.Pointer(newenv + uintptr(i)*8)) = s - *(*uintptr)(unsafe.Pointer(newenv + uintptr(i+uint64(1))*8)) = uintptr(0) + **(**uintptr)(__ccgo_up(newenv + uintptr(i)*8)) = s + **(**uintptr)(__ccgo_up(newenv + uintptr(i+uint64(1))*8)) = uintptr(0) v2 = newenv _oldenv = v2 Xenviron = v2 @@ -25081,7 +25081,7 @@ func Xputenv(tls *TLS, s uintptr) (r int32) { var l Tsize_t _ = l l = Uint64FromInt64(int64(X__strchrnul(tls, s, int32('='))) - int64(s)) - if !(l != 0) || !(*(*uint8)(unsafe.Pointer(s + uintptr(l))) != 0) { + if !(l != 0) || !(**(**uint8)(__ccgo_up(s + uintptr(l))) != 0) { return Xunsetenv(tls, s) } return X__putenv(tls, s, l, uintptr(0)) @@ -25126,13 +25126,13 @@ func X__env_rm_add(tls *TLS, old uintptr, new1 uintptr) { if !(i < _env_alloced_n) { break } - if *(*uintptr)(unsafe.Pointer(_env_alloced + uintptr(i)*8)) == old { - *(*uintptr)(unsafe.Pointer(_env_alloced + uintptr(i)*8)) = new1 + if **(**uintptr)(__ccgo_up(_env_alloced + uintptr(i)*8)) == old { + **(**uintptr)(__ccgo_up(_env_alloced + uintptr(i)*8)) = new1 Xfree(tls, old) return } else { - if !(*(*uintptr)(unsafe.Pointer(_env_alloced + uintptr(i)*8)) != 0) && new1 != 0 { - *(*uintptr)(unsafe.Pointer(_env_alloced + uintptr(i)*8)) = new1 + if !(**(**uintptr)(__ccgo_up(_env_alloced + uintptr(i)*8)) != 0) && new1 != 0 { + **(**uintptr)(__ccgo_up(_env_alloced + uintptr(i)*8)) = new1 new1 = uintptr(0) } } @@ -25152,7 +25152,7 @@ func X__env_rm_add(tls *TLS, old uintptr, new1 uintptr) { _env_alloced = v2 v3 = _env_alloced_n _env_alloced_n = _env_alloced_n + 1 - *(*uintptr)(unsafe.Pointer(v2 + uintptr(v3)*8)) = new1 + **(**uintptr)(__ccgo_up(v2 + uintptr(v3)*8)) = new1 } var _env_alloced uintptr @@ -25172,8 +25172,8 @@ func Xsetenv(tls *TLS, var1 uintptr, value uintptr, overwrite int32) (r int32) { v1 = Uint64FromInt64(int64(X__strchrnul(tls, var1, int32('='))) - int64(var1)) l1 = v1 } - if v2 || !(v1 != 0) || *(*uint8)(unsafe.Pointer(var1 + uintptr(l1))) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if v2 || !(v1 != 0) || **(**uint8)(__ccgo_up(var1 + uintptr(l1))) != 0 { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } if !(overwrite != 0) && Xgetenv(tls, var1) != 0 { @@ -25185,7 +25185,7 @@ func Xsetenv(tls *TLS, var1 uintptr, value uintptr, overwrite int32) (r int32) { return -int32(1) } Xmemcpy(tls, s, var1, l1) - *(*uint8)(unsafe.Pointer(s + uintptr(l1))) = uint8('=') + **(**uint8)(__ccgo_up(s + uintptr(l1))) = uint8('=') Xmemcpy(tls, s+uintptr(l1)+uintptr(1), value, l2+uint64(1)) return X__putenv(tls, s, l1, s) } @@ -25202,24 +25202,24 @@ func Xunsetenv(tls *TLS, name uintptr) (r int32) { var l Tsize_t _, _, _, _ = e, eo, l, v2 l = Uint64FromInt64(int64(X__strchrnul(tls, name, int32('='))) - int64(name)) - if !(l != 0) || *(*uint8)(unsafe.Pointer(name + uintptr(l))) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if !(l != 0) || **(**uint8)(__ccgo_up(name + uintptr(l))) != 0 { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } if Xenviron != 0 { e = Xenviron eo = e for { - if !(*(*uintptr)(unsafe.Pointer(e)) != 0) { + if !(**(**uintptr)(__ccgo_up(e)) != 0) { break } - if !(Xstrncmp(tls, name, *(*uintptr)(unsafe.Pointer(e)), l) != 0) && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(e)) + uintptr(l)))) == int32('=') { - X__env_rm_add(tls, *(*uintptr)(unsafe.Pointer(e)), uintptr(0)) + if !(Xstrncmp(tls, name, **(**uintptr)(__ccgo_up(e)), l) != 0) && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(e)) + uintptr(l)))) == int32('=') { + X__env_rm_add(tls, **(**uintptr)(__ccgo_up(e)), uintptr(0)) } else { if eo != e { v2 = eo eo += 8 - *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(e)) + **(**uintptr)(__ccgo_up(v2)) = **(**uintptr)(__ccgo_up(e)) } else { eo += 8 } @@ -25230,7 +25230,7 @@ func Xunsetenv(tls *TLS, name uintptr) (r int32) { e += 8 } if eo != e { - *(*uintptr)(unsafe.Pointer(eo)) = uintptr(0) + **(**uintptr)(__ccgo_up(eo)) = uintptr(0) } } return 0 @@ -25540,7 +25540,7 @@ func X__strerror_l(tls *TLS, e int32, loc Tlocale_t) (r uintptr) { e = 0 } s = uintptr(unsafe.Pointer(&_errmsgstr)) + uintptr(_errmsgidx[e]) - return X__lctrans(tls, s, *(*uintptr)(unsafe.Pointer(loc + 5*8))) + return X__lctrans(tls, s, **(**uintptr)(__ccgo_up(loc + 5*8))) } func Xstrerror(tls *TLS, e int32) (r uintptr) { @@ -25677,10 +25677,10 @@ func Xfcntl(tls *TLS, fd int32, cmd int32, va uintptr) (r int32) { if ret != 0 { return int32(X__syscall_ret(tls, Uint64FromInt32(ret))) } - if (*(*Tf_owner_ex)(unsafe.Pointer(bp))).Ftype1 == int32(F_OWNER_PGRP) { - v1 = -(*(*Tf_owner_ex)(unsafe.Pointer(bp))).Fpid + if (**(**Tf_owner_ex)(__ccgo_up(bp))).Ftype1 == int32(F_OWNER_PGRP) { + v1 = -(**(**Tf_owner_ex)(__ccgo_up(bp))).Fpid } else { - v1 = (*(*Tf_owner_ex)(unsafe.Pointer(bp))).Fpid + v1 = (**(**Tf_owner_ex)(__ccgo_up(bp))).Fpid } return v1 } @@ -25852,7 +25852,7 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -25863,7 +25863,7 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -25893,7 +25893,7 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -25912,7 +25912,7 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -25929,7 +25929,7 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -25982,7 +25982,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__shgetc(tls, f) } @@ -25994,7 +25994,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__shgetc(tls, f) } @@ -26012,14 +26012,14 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__shgetc(tls, f) } c = v2 } } - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0] = uint32(0) + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[0] = uint32(0) for { if !(Uint32FromInt32(c-int32('0')) < uint32(10) || c == int32('.')) { break @@ -26037,9 +26037,9 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, lnz = int32(dc) } if j != 0 { - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k]*uint32(10) + Uint32FromInt32(c) - uint32('0') + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] = (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k]*uint32(10) + Uint32FromInt32(c) - uint32('0') } else { - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] = Uint32FromInt32(c - int32('0')) + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] = Uint32FromInt32(c - int32('0')) } j = j + 1 v2 = j @@ -26052,7 +26052,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, dc = dc + 1 if c != int32('0') { lnz = (Int32FromInt32(KMAX) - Int32FromInt32(4)) * Int32FromInt32(9) - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(Int32FromInt32(KMAX)-Int32FromInt32(4))*4)) |= uint32(1) + **(**Tuint32_t)(__ccgo_up(bp + uintptr(Int32FromInt32(KMAX)-Int32FromInt32(4))*4)) |= uint32(1) } } } @@ -26063,7 +26063,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__shgetc(tls, f) } @@ -26094,24 +26094,24 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, } } if !(gotdig != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) X__shlim(tls, f, int64(Int32FromInt32(0))) return Float64FromInt32(0) } /* Handle zero specially to avoid nasty special cases later */ - if !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0] != 0) { + if !((**(**[128]Tuint32_t)(__ccgo_up(bp)))[0] != 0) { return float64(float64(sign) * float64(0)) } /* Optimize small integers (w/no exponent) and over/under-flow */ - if lrp == dc && dc < int64(10) && (bits > int32(30) || (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0]>>bits == uint32(0)) { - return float64(float64(sign) * float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0])) + if lrp == dc && dc < int64(10) && (bits > int32(30) || (**(**[128]Tuint32_t)(__ccgo_up(bp)))[0]>>bits == uint32(0)) { + return float64(float64(sign) * float64((**(**[128]Tuint32_t)(__ccgo_up(bp)))[0])) } if lrp > int64(-emin/int32(2)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return float64(float64(float64(sign)*Float64FromFloat64(1.79769313486231570815e+308)) * Float64FromFloat64(1.79769313486231570815e+308)) } if lrp < int64(emin-Int32FromInt32(2)*Int32FromInt32(LDBL_MANT_DIG)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return float64(float64(float64(sign)*Float64FromFloat64(2.22507385850720138309e-308)) * Float64FromFloat64(2.22507385850720138309e-308)) } /* Align incomplete final B1B digit */ @@ -26120,7 +26120,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if !(j < int32(9)) { break } - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(k)*4)) *= uint32(10) + **(**Tuint32_t)(__ccgo_up(bp + uintptr(k)*4)) *= uint32(10) goto _17 _17: ; @@ -26136,19 +26136,19 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, /* Optimize small to mid-size integers (even in exp. notation) */ if lnz < int32(9) && lnz <= rp && rp < int32(18) { if rp == int32(9) { - return float64(float64(sign) * float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0])) + return float64(float64(sign) * float64((**(**[128]Tuint32_t)(__ccgo_up(bp)))[0])) } if rp < int32(9) { - return float64(float64(sign)*float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0])) / float64(_p10s[int32(8)-rp]) + return float64(float64(sign)*float64((**(**[128]Tuint32_t)(__ccgo_up(bp)))[0])) / float64(_p10s[int32(8)-rp]) } bitlim = bits - int32(3)*(rp-Int32FromInt32(9)) - if bitlim > int32(30) || (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0]>>bitlim == uint32(0) { - return float64(float64(float64(sign)*float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0])) * float64(_p10s[rp-int32(10)])) + if bitlim > int32(30) || (**(**[128]Tuint32_t)(__ccgo_up(bp)))[0]>>bitlim == uint32(0) { + return float64(float64(float64(sign)*float64((**(**[128]Tuint32_t)(__ccgo_up(bp)))[0])) * float64(_p10s[rp-int32(10)])) } } /* Drop trailing zeros */ for { - if !!((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[z-int32(1)] != 0) { + if !!((**(**[128]Tuint32_t)(__ccgo_up(bp)))[z-int32(1)] != 0) { break } goto _18 @@ -26171,10 +26171,10 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if !(k != z) { break } - tmp = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] % Uint32FromInt32(p10) - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k]/Uint32FromInt32(p10) + carry + tmp = (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] % Uint32FromInt32(p10) + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] = (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k]/Uint32FromInt32(p10) + carry carry = Uint32FromInt32(int32(1000000000)/p10) * tmp - if k == a && !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] != 0) { + if k == a && !((**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] != 0) { a = (a + int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) rp = rp - int32(9) } @@ -26186,25 +26186,25 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if carry != 0 { v2 = z z = z + 1 - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v2] = carry + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[v2] = carry } rp = rp + (int32(9) - rpm9) } /* Upscale until desired number of bits are left of radix point */ - for rp < Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) || rp == Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) && (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[a] < _th[0] { + for rp < Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) || rp == Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) && (**(**[128]Tuint32_t)(__ccgo_up(bp)))[a] < _th[0] { carry1 = uint32(0) e2 = e2 - int32(29) k = (z - int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) for { - tmp1 = uint64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k])< uint64(1000000000) { carry1 = uint32(tmp1 / uint64(1000000000)) - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] = uint32(tmp1 % uint64(1000000000)) + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] = uint32(tmp1 % uint64(1000000000)) } else { carry1 = uint32(0) - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] = uint32(tmp1) + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] = uint32(tmp1) } - if k == (z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) && k != a && !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] != 0) { + if k == (z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) && k != a && !((**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] != 0) { z = k } if k == a { @@ -26220,9 +26220,9 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, a = (a - int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) if a == z { z = (z - int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr((z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)))*4)) |= (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[z] + **(**Tuint32_t)(__ccgo_up(bp + uintptr((z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)))*4)) |= (**(**[128]Tuint32_t)(__ccgo_up(bp)))[z] } - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[a] = carry1 + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[a] = carry1 } } /* Downscale until exactly number of bits are left of radix point */ @@ -26235,11 +26235,11 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, break } k = (a + i) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) - if k == z || (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] < _th[i] { + if k == z || (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] < _th[i] { i = int32(LD_B1B_DIG) break } - if (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))] > _th[i] { + if (**(**[128]Tuint32_t)(__ccgo_up(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))] > _th[i] { break } goto _24 @@ -26260,10 +26260,10 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if !(k != z) { break } - tmp2 = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] & Uint32FromInt32(int32(1)<>sh + carry2 + tmp2 = (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] & Uint32FromInt32(int32(1)<>sh + carry2 carry2 = Uint32FromInt32(Int32FromInt32(1000000000)>>sh) * tmp2 - if k == a && !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] != 0) { + if k == a && !((**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] != 0) { a = (a + int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) i = i - 1 rp = rp - int32(9) @@ -26275,10 +26275,10 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, } if carry2 != 0 { if (z+int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) != a { - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[z] = carry2 + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[z] = carry2 z = (z + int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) } else { - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr((z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)))*4)) |= uint32(1) + **(**Tuint32_t)(__ccgo_up(bp + uintptr((z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)))*4)) |= uint32(1) } } goto _23 @@ -26295,9 +26295,9 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if (a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1)) == z { v6 = (z + Int32FromInt32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) z = v6 - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v6-int32(1)] = uint32(0) + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[v6-int32(1)] = uint32(0) } - y = float64(Float64FromFloat64(1e+09)*y) + float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))]) + y = float64(Float64FromFloat64(1e+09)*y) + float64((**(**[128]Tuint32_t)(__ccgo_up(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))]) goto _26 _26: ; @@ -26321,7 +26321,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, } /* Process tail of decimal input so it can affect rounding */ if (a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1)) != z { - t = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))] + t = (**(**[128]Tuint32_t)(__ccgo_up(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))] if t < uint32(500000000) && (t != 0 || (a+i+int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) != z) { frac = frac + float64(float64(0.25)*float64(sign)) } else { @@ -26352,7 +26352,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, e2 = e2 + 1 } if e2+int32(LDBL_MANT_DIG) > emax || denormal != 0 && frac != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) } } return Xscalbnl(tls, y, e2) @@ -26395,7 +26395,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26413,7 +26413,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26425,7 +26425,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26444,7 +26444,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26491,7 +26491,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26545,11 +26545,11 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 return float64(float64(sign) * float64(0)) } if e2 > int64(-emin) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return float64(float64(float64(sign)*Float64FromFloat64(1.79769313486231570815e+308)) * Float64FromFloat64(1.79769313486231570815e+308)) } if e2 < int64(emin-Int32FromInt32(2)*Int32FromInt32(LDBL_MANT_DIG)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return float64(float64(float64(sign)*Float64FromFloat64(2.22507385850720138309e-308)) * Float64FromFloat64(2.22507385850720138309e-308)) } for x < uint32(0x80000000) { @@ -26578,7 +26578,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 y = bias + float64(float64(sign)*float64(x)) + float64(float64(sign)*y) y = y - bias if !(y != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) } return Xscalbnl(tls, y, int32(e2)) } @@ -26611,7 +26611,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__shgetc(tls, f) } @@ -26631,7 +26631,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -26639,7 +26639,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { } i = uint64(0) for { - if !(i < uint64(8) && c|int32(32) == Int32FromUint8(*(*uint8)(unsafe.Pointer(__ccgo_ts + 247 + uintptr(i))))) { + if !(i < uint64(8) && c|int32(32) == Int32FromUint8(**(**uint8)(__ccgo_up(__ccgo_ts + 247 + uintptr(i))))) { break } if i < uint64(7) { @@ -26647,7 +26647,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -26683,7 +26683,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { if !(i != 0) { i = uint64(0) for { - if !(i < uint64(3) && c|int32(32) == Int32FromUint8(*(*uint8)(unsafe.Pointer(__ccgo_ts + 256 + uintptr(i))))) { + if !(i < uint64(3) && c|int32(32) == Int32FromUint8(**(**uint8)(__ccgo_up(__ccgo_ts + 256 + uintptr(i))))) { break } if i < uint64(2) { @@ -26691,7 +26691,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -26708,7 +26708,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -26724,7 +26724,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -26739,7 +26739,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if !(pok != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) X__shlim(tls, f, int64(Int32FromInt32(0))) return Float64FromInt32(0) } @@ -26765,7 +26765,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) X__shlim(tls, f, int64(Int32FromInt32(0))) return Float64FromInt32(0) } @@ -26774,7 +26774,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27065,7 +27065,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint val = uintptr(unsafe.Pointer(&_table6)) + uintptr(1) neg = 0 if base > uint32(36) || base == uint32(1) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uint64(0) } for { @@ -27073,7 +27073,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__shgetc(tls, f) } @@ -27093,7 +27093,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27104,7 +27104,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27114,12 +27114,12 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } c = v1 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) >= int32(16) { + if Int32FromUint8(**(**uint8)(__ccgo_up(val + uintptr(c)))) >= int32(16) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } @@ -27142,12 +27142,12 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint if base == uint32(0) { base = uint32(10) } - if uint32(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) >= base { + if uint32(**(**uint8)(__ccgo_up(val + uintptr(c)))) >= base { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } X__shlim(tls, f, int64(Int32FromInt32(0))) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uint64(0) } } @@ -27165,7 +27165,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27184,7 +27184,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27195,13 +27195,13 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint } } else { if !(base&(base-Uint32FromInt32(1)) != 0) { - bs = Int32FromUint8(*(*uint8)(unsafe.Pointer(__ccgo_ts + 260 + uintptr(uint32(0x17)*base>>int32(5)&uint32(7))))) + bs = Int32FromUint8(**(**uint8)(__ccgo_up(__ccgo_ts + 260 + uintptr(uint32(0x17)*base>>int32(5)&uint32(7))))) x = uint32(0) for { - if !(uint32(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) < base && x <= Uint32FromUint32(0xffffffff)/Uint32FromInt32(32)) { + if !(uint32(**(**uint8)(__ccgo_up(val + uintptr(c)))) < base && x <= Uint32FromUint32(0xffffffff)/Uint32FromInt32(32)) { break } - x = x<>bs) { + if !(uint32(**(**uint8)(__ccgo_up(val + uintptr(c)))) < base && y <= (Uint64FromUint64(2)*Uint64FromInt64(0x7fffffffffffffff)+Uint64FromInt32(1))>>bs) { break } - y = y<= lim { if !(lim&Uint64FromInt32(1) != 0) && !(neg != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return lim - uint64(1) } else { if y > lim { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return lim } } @@ -27328,8 +27328,8 @@ func X__procfdname(tls *TLS, buf uintptr, fd uint32) { _, _, _, _ = i, j, v2, v5 i = uint32(0) for { - v2 = *(*uint8)(unsafe.Pointer(__ccgo_ts + 269 + uintptr(i))) - *(*uint8)(unsafe.Pointer(buf + uintptr(i))) = v2 + v2 = **(**uint8)(__ccgo_up(__ccgo_ts + 269 + uintptr(i))) + **(**uint8)(__ccgo_up(buf + uintptr(i))) = v2 if !(v2 != 0) { break } @@ -27339,8 +27339,8 @@ func X__procfdname(tls *TLS, buf uintptr, fd uint32) { i = i + 1 } if !(fd != 0) { - *(*uint8)(unsafe.Pointer(buf + uintptr(i))) = uint8('0') - *(*uint8)(unsafe.Pointer(buf + uintptr(i+uint32(1)))) = uint8(0) + **(**uint8)(__ccgo_up(buf + uintptr(i))) = uint8('0') + **(**uint8)(__ccgo_up(buf + uintptr(i+uint32(1)))) = uint8(0) return } j = fd @@ -27354,14 +27354,14 @@ func X__procfdname(tls *TLS, buf uintptr, fd uint32) { j = j / uint32(10) i = i + 1 } - *(*uint8)(unsafe.Pointer(buf + uintptr(i))) = uint8(0) + **(**uint8)(__ccgo_up(buf + uintptr(i))) = uint8(0) for { if !(fd != 0) { break } i = i - 1 v5 = i - *(*uint8)(unsafe.Pointer(buf + uintptr(v5))) = uint8(uint32('0') + fd%uint32(10)) + **(**uint8)(__ccgo_up(buf + uintptr(v5))) = uint8(uint32('0') + fd%uint32(10)) goto _4 _4: ; @@ -27416,7 +27416,7 @@ func X__shgetc(tls *TLS, f uintptr) (r int32) { } (*TFILE)(unsafe.Pointer(f)).Fshcnt = int64((*TFILE)(unsafe.Pointer(f)).Fbuf) - int64((*TFILE)(unsafe.Pointer(f)).Frpos) + cnt if (*TFILE)(unsafe.Pointer(f)).Frpos <= (*TFILE)(unsafe.Pointer(f)).Fbuf { - *(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos + uintptr(-Int32FromInt32(1)))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos + uintptr(-Int32FromInt32(1)))) = Uint8FromInt32(c) } return c } @@ -27427,7 +27427,7 @@ func X__syscall_ret(tls *TLS, r uint64) (r1 int64) { defer func() { trc("-> %v", r1) }() } if r > -Uint64FromUint64(4096) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = Int32FromUint64(-r) + **(**int32)(__ccgo_up(X__errno_location(tls))) = Int32FromUint64(-r) return int64(-int32(1)) } return Int64FromUint64(r) @@ -27550,10 +27550,10 @@ func X__vdsosym(tls *TLS, vername uintptr, name uintptr) (r uintptr) { _, _, _, _, _, _, _, _, _, _, _ = base, dynv, eh, hashtab, i, p, ph, strings, syms, verdef, versym i = uint64(0) for { - if !(*(*Tsize_t)(unsafe.Pointer(X__libc.Fauxv + uintptr(i)*8)) != uint64(AT_SYSINFO_EHDR)) { + if !(**(**Tsize_t)(__ccgo_up(X__libc.Fauxv + uintptr(i)*8)) != uint64(AT_SYSINFO_EHDR)) { break } - if !(*(*Tsize_t)(unsafe.Pointer(X__libc.Fauxv + uintptr(i)*8)) != 0) { + if !(**(**Tsize_t)(__ccgo_up(X__libc.Fauxv + uintptr(i)*8)) != 0) { return uintptr(0) } goto _1 @@ -27561,10 +27561,10 @@ func X__vdsosym(tls *TLS, vername uintptr, name uintptr) (r uintptr) { ; i = i + uint64(2) } - if !(*(*Tsize_t)(unsafe.Pointer(X__libc.Fauxv + uintptr(i+uint64(1))*8)) != 0) { + if !(**(**Tsize_t)(__ccgo_up(X__libc.Fauxv + uintptr(i+uint64(1))*8)) != 0) { return uintptr(0) } - eh = uintptr(*(*Tsize_t)(unsafe.Pointer(X__libc.Fauxv + uintptr(i+uint64(1))*8))) + eh = uintptr(**(**Tsize_t)(__ccgo_up(X__libc.Fauxv + uintptr(i+uint64(1))*8))) ph = eh + uintptr((*TEhdr)(unsafe.Pointer(eh)).Fe_phoff) dynv = uintptr(0) base = Uint64FromInt32(-Int32FromInt32(1)) @@ -27596,11 +27596,11 @@ func X__vdsosym(tls *TLS, vername uintptr, name uintptr) (r uintptr) { verdef = uintptr(0) i = uint64(0) for { - if !(*(*Tsize_t)(unsafe.Pointer(dynv + uintptr(i)*8)) != 0) { + if !(**(**Tsize_t)(__ccgo_up(dynv + uintptr(i)*8)) != 0) { break } - p = uintptr(base + *(*Tsize_t)(unsafe.Pointer(dynv + uintptr(i+uint64(1))*8))) - switch *(*Tsize_t)(unsafe.Pointer(dynv + uintptr(i)*8)) { + p = uintptr(base + **(**Tsize_t)(__ccgo_up(dynv + uintptr(i+uint64(1))*8))) + switch **(**Tsize_t)(__ccgo_up(dynv + uintptr(i)*8)) { case uint64(DT_STRTAB): strings = p case uint64(DT_SYMTAB): @@ -27626,25 +27626,25 @@ func X__vdsosym(tls *TLS, vername uintptr, name uintptr) (r uintptr) { } i = uint64(0) for { - if !(i < uint64(*(*TElf_Symndx)(unsafe.Pointer(hashtab + 1*4)))) { + if !(i < uint64(**(**TElf_Symndx)(__ccgo_up(hashtab + 1*4)))) { break } - if !(Int32FromInt32(1)<<(Int32FromUint8((*(*TSym)(unsafe.Pointer(syms + uintptr(i)*24))).Fst_info)&Int32FromInt32(0xf))&(Int32FromInt32(1)<>Int32FromInt32(4))&(Int32FromInt32(1)<>Int32FromInt32(4))&(Int32FromInt32(1)< int64(1000) || (*Ttimeval)(unsafe.Pointer(in)).Ftv_usec > int64(1000000000) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } - (*(*Ttimex)(unsafe.Pointer(bp))).Foffset = (*Ttimeval)(unsafe.Pointer(in)).Ftv_sec*int64(1000000) + (*Ttimeval)(unsafe.Pointer(in)).Ftv_usec - (*(*Ttimex)(unsafe.Pointer(bp))).Fmodes = uint32(ADJ_OFFSET_SINGLESHOT) + (**(**Ttimex)(__ccgo_up(bp))).Foffset = (*Ttimeval)(unsafe.Pointer(in)).Ftv_sec*int64(1000000) + (*Ttimeval)(unsafe.Pointer(in)).Ftv_usec + (**(**Ttimex)(__ccgo_up(bp))).Fmodes = uint32(ADJ_OFFSET_SINGLESHOT) } if Xadjtimex(tls, bp) < 0 { return -int32(1) } if out != 0 { - (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec = (*(*Ttimex)(unsafe.Pointer(bp))).Foffset / int64(1000000) - v1 = (*(*Ttimex)(unsafe.Pointer(bp))).Foffset % Int64FromInt32(1000000) + (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec = (**(**Ttimex)(__ccgo_up(bp))).Foffset / int64(1000000) + v1 = (**(**Ttimex)(__ccgo_up(bp))).Foffset % Int64FromInt32(1000000) (*Ttimeval)(unsafe.Pointer(out)).Ftv_usec = v1 if v1 < 0 { (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec = (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec - 1 - *(*Tsuseconds_t)(unsafe.Pointer(out + 8)) += int64(1000000) + **(**Tsuseconds_t)(__ccgo_up(out + 8)) += int64(1000000) } } return 0 @@ -29197,7 +29197,7 @@ func Xclock_adjtime(tls *TLS, clock_id Tclockid_t, utx uintptr) (r1 int32) { _ = r r = -int32(ENOSYS) if uint64(8) > uint64(8) { - *(*Tktimex)(unsafe.Pointer(bp)) = Tktimex{ + **(**Tktimex)(__ccgo_up(bp)) = Tktimex{ Fmodes: (*Ttimex)(unsafe.Pointer(utx)).Fmodes, Foffset: (*Ttimex)(unsafe.Pointer(utx)).Foffset, Ffreq: (*Ttimex)(unsafe.Pointer(utx)).Ffreq, @@ -29226,27 +29226,27 @@ func Xclock_adjtime(tls *TLS, clock_id Tclockid_t, utx uintptr) (r1 int32) { r = int32(X__syscall2(tls, int64(SYS_clock_adjtime), int64(clock_id), int64(bp))) } if r >= 0 { - (*Ttimex)(unsafe.Pointer(utx)).Fmodes = (*(*Tktimex)(unsafe.Pointer(bp))).Fmodes - (*Ttimex)(unsafe.Pointer(utx)).Foffset = (*(*Tktimex)(unsafe.Pointer(bp))).Foffset - (*Ttimex)(unsafe.Pointer(utx)).Ffreq = (*(*Tktimex)(unsafe.Pointer(bp))).Ffreq - (*Ttimex)(unsafe.Pointer(utx)).Fmaxerror = (*(*Tktimex)(unsafe.Pointer(bp))).Fmaxerror - (*Ttimex)(unsafe.Pointer(utx)).Festerror = (*(*Tktimex)(unsafe.Pointer(bp))).Festerror - (*Ttimex)(unsafe.Pointer(utx)).Fstatus = (*(*Tktimex)(unsafe.Pointer(bp))).Fstatus - (*Ttimex)(unsafe.Pointer(utx)).Fconstant = (*(*Tktimex)(unsafe.Pointer(bp))).Fconstant - (*Ttimex)(unsafe.Pointer(utx)).Fprecision = (*(*Tktimex)(unsafe.Pointer(bp))).Fprecision - (*Ttimex)(unsafe.Pointer(utx)).Ftolerance = (*(*Tktimex)(unsafe.Pointer(bp))).Ftolerance - (*Ttimex)(unsafe.Pointer(utx)).Ftime.Ftv_sec = (*(*Tktimex)(unsafe.Pointer(bp))).Ftime_sec - (*Ttimex)(unsafe.Pointer(utx)).Ftime.Ftv_usec = (*(*Tktimex)(unsafe.Pointer(bp))).Ftime_usec - (*Ttimex)(unsafe.Pointer(utx)).Ftick = (*(*Tktimex)(unsafe.Pointer(bp))).Ftick - (*Ttimex)(unsafe.Pointer(utx)).Fppsfreq = (*(*Tktimex)(unsafe.Pointer(bp))).Fppsfreq - (*Ttimex)(unsafe.Pointer(utx)).Fjitter = (*(*Tktimex)(unsafe.Pointer(bp))).Fjitter - (*Ttimex)(unsafe.Pointer(utx)).Fshift = (*(*Tktimex)(unsafe.Pointer(bp))).Fshift - (*Ttimex)(unsafe.Pointer(utx)).Fstabil = (*(*Tktimex)(unsafe.Pointer(bp))).Fstabil - (*Ttimex)(unsafe.Pointer(utx)).Fjitcnt = (*(*Tktimex)(unsafe.Pointer(bp))).Fjitcnt - (*Ttimex)(unsafe.Pointer(utx)).Fcalcnt = (*(*Tktimex)(unsafe.Pointer(bp))).Fcalcnt - (*Ttimex)(unsafe.Pointer(utx)).Ferrcnt = (*(*Tktimex)(unsafe.Pointer(bp))).Ferrcnt - (*Ttimex)(unsafe.Pointer(utx)).Fstbcnt = (*(*Tktimex)(unsafe.Pointer(bp))).Fstbcnt - (*Ttimex)(unsafe.Pointer(utx)).Ftai = (*(*Tktimex)(unsafe.Pointer(bp))).Ftai + (*Ttimex)(unsafe.Pointer(utx)).Fmodes = (**(**Tktimex)(__ccgo_up(bp))).Fmodes + (*Ttimex)(unsafe.Pointer(utx)).Foffset = (**(**Tktimex)(__ccgo_up(bp))).Foffset + (*Ttimex)(unsafe.Pointer(utx)).Ffreq = (**(**Tktimex)(__ccgo_up(bp))).Ffreq + (*Ttimex)(unsafe.Pointer(utx)).Fmaxerror = (**(**Tktimex)(__ccgo_up(bp))).Fmaxerror + (*Ttimex)(unsafe.Pointer(utx)).Festerror = (**(**Tktimex)(__ccgo_up(bp))).Festerror + (*Ttimex)(unsafe.Pointer(utx)).Fstatus = (**(**Tktimex)(__ccgo_up(bp))).Fstatus + (*Ttimex)(unsafe.Pointer(utx)).Fconstant = (**(**Tktimex)(__ccgo_up(bp))).Fconstant + (*Ttimex)(unsafe.Pointer(utx)).Fprecision = (**(**Tktimex)(__ccgo_up(bp))).Fprecision + (*Ttimex)(unsafe.Pointer(utx)).Ftolerance = (**(**Tktimex)(__ccgo_up(bp))).Ftolerance + (*Ttimex)(unsafe.Pointer(utx)).Ftime.Ftv_sec = (**(**Tktimex)(__ccgo_up(bp))).Ftime_sec + (*Ttimex)(unsafe.Pointer(utx)).Ftime.Ftv_usec = (**(**Tktimex)(__ccgo_up(bp))).Ftime_usec + (*Ttimex)(unsafe.Pointer(utx)).Ftick = (**(**Tktimex)(__ccgo_up(bp))).Ftick + (*Ttimex)(unsafe.Pointer(utx)).Fppsfreq = (**(**Tktimex)(__ccgo_up(bp))).Fppsfreq + (*Ttimex)(unsafe.Pointer(utx)).Fjitter = (**(**Tktimex)(__ccgo_up(bp))).Fjitter + (*Ttimex)(unsafe.Pointer(utx)).Fshift = (**(**Tktimex)(__ccgo_up(bp))).Fshift + (*Ttimex)(unsafe.Pointer(utx)).Fstabil = (**(**Tktimex)(__ccgo_up(bp))).Fstabil + (*Ttimex)(unsafe.Pointer(utx)).Fjitcnt = (**(**Tktimex)(__ccgo_up(bp))).Fjitcnt + (*Ttimex)(unsafe.Pointer(utx)).Fcalcnt = (**(**Tktimex)(__ccgo_up(bp))).Fcalcnt + (*Ttimex)(unsafe.Pointer(utx)).Ferrcnt = (**(**Tktimex)(__ccgo_up(bp))).Ferrcnt + (*Ttimex)(unsafe.Pointer(utx)).Fstbcnt = (**(**Tktimex)(__ccgo_up(bp))).Fstbcnt + (*Ttimex)(unsafe.Pointer(utx)).Ftai = (**(**Tktimex)(__ccgo_up(bp))).Ftai } return int32(X__syscall_ret(tls, Uint64FromInt32(r))) } @@ -30288,12 +30288,12 @@ func Xprlimit(tls *TLS, pid Tpid_t, resource int32, new_limit uintptr, old_limit var _ /* tmp at bp+0 */ Trlimit _ = r if new_limit != 0 && Bool(^Uint64FromUint64(0) != ^Uint64FromUint64(0)) { - *(*Trlimit)(unsafe.Pointer(bp)) = *(*Trlimit)(unsafe.Pointer(new_limit)) - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur >= ^Uint64FromUint64(0) { - (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur = ^Uint64FromUint64(0) + **(**Trlimit)(__ccgo_up(bp)) = **(**Trlimit)(__ccgo_up(new_limit)) + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur >= ^Uint64FromUint64(0) { + (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur = ^Uint64FromUint64(0) } - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_max >= ^Uint64FromUint64(0) { - (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_max = ^Uint64FromUint64(0) + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_max >= ^Uint64FromUint64(0) { + (**(**Trlimit)(__ccgo_up(bp))).Frlim_max = ^Uint64FromUint64(0) } new_limit = bp } @@ -30478,7 +30478,7 @@ func Xptrace(tls *TLS, req int32, va uintptr) (r int64) { if ret < 0 || Uint32FromInt32(req)-uint32(1) >= uint32(3) { return ret } - return *(*int64)(unsafe.Pointer(bp)) + return **(**int64)(__ccgo_up(bp)) } func Xpwritev2(tls *TLS, fd int32, iov uintptr, count int32, ofs Toff_t, flags int32) (r Tssize_t) { @@ -30778,22 +30778,22 @@ func Xstatx(tls *TLS, dirfd int32, path uintptr, flags int32, mask uint32, stx u if ret != 0 { return ret } - (*Tstatx)(unsafe.Pointer(stx)).Fstx_dev_major = uint32((*(*Tstat)(unsafe.Pointer(bp))).Fst_dev>>Int32FromInt32(31)>>Int32FromInt32(1)&Uint64FromUint32(0xfffff000) | (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev>>Int32FromInt32(8)&Uint64FromInt32(0x00000fff)) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_dev_minor = uint32((*(*Tstat)(unsafe.Pointer(bp))).Fst_dev>>Int32FromInt32(12)&Uint64FromUint32(0xffffff00) | (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev&Uint64FromInt32(0x000000ff)) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_ino = (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino - (*Tstatx)(unsafe.Pointer(stx)).Fstx_mode = uint16((*(*Tstat)(unsafe.Pointer(bp))).Fst_mode) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_nlink = (*(*Tstat)(unsafe.Pointer(bp))).Fst_nlink - (*Tstatx)(unsafe.Pointer(stx)).Fstx_uid = (*(*Tstat)(unsafe.Pointer(bp))).Fst_uid - (*Tstatx)(unsafe.Pointer(stx)).Fstx_gid = (*(*Tstat)(unsafe.Pointer(bp))).Fst_gid - (*Tstatx)(unsafe.Pointer(stx)).Fstx_size = Uint64FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_size) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_blksize = Uint32FromInt32((*(*Tstat)(unsafe.Pointer(bp))).Fst_blksize) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_blocks = Uint64FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_blocks) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_atime.Ftv_sec = (*(*Tstat)(unsafe.Pointer(bp))).Fst_atim.Ftv_sec - (*Tstatx)(unsafe.Pointer(stx)).Fstx_atime.Ftv_nsec = Uint32FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_atim.Ftv_nsec) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_mtime.Ftv_sec = (*(*Tstat)(unsafe.Pointer(bp))).Fst_mtim.Ftv_sec - (*Tstatx)(unsafe.Pointer(stx)).Fstx_mtime.Ftv_nsec = Uint32FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_mtim.Ftv_nsec) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_ctime.Ftv_sec = (*(*Tstat)(unsafe.Pointer(bp))).Fst_ctim.Ftv_sec - (*Tstatx)(unsafe.Pointer(stx)).Fstx_ctime.Ftv_nsec = Uint32FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_ctim.Ftv_nsec) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_dev_major = uint32((**(**Tstat)(__ccgo_up(bp))).Fst_dev>>Int32FromInt32(31)>>Int32FromInt32(1)&Uint64FromUint32(0xfffff000) | (**(**Tstat)(__ccgo_up(bp))).Fst_dev>>Int32FromInt32(8)&Uint64FromInt32(0x00000fff)) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_dev_minor = uint32((**(**Tstat)(__ccgo_up(bp))).Fst_dev>>Int32FromInt32(12)&Uint64FromUint32(0xffffff00) | (**(**Tstat)(__ccgo_up(bp))).Fst_dev&Uint64FromInt32(0x000000ff)) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_ino = (**(**Tstat)(__ccgo_up(bp))).Fst_ino + (*Tstatx)(unsafe.Pointer(stx)).Fstx_mode = uint16((**(**Tstat)(__ccgo_up(bp))).Fst_mode) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_nlink = (**(**Tstat)(__ccgo_up(bp))).Fst_nlink + (*Tstatx)(unsafe.Pointer(stx)).Fstx_uid = (**(**Tstat)(__ccgo_up(bp))).Fst_uid + (*Tstatx)(unsafe.Pointer(stx)).Fstx_gid = (**(**Tstat)(__ccgo_up(bp))).Fst_gid + (*Tstatx)(unsafe.Pointer(stx)).Fstx_size = Uint64FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_size) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_blksize = Uint32FromInt32((**(**Tstat)(__ccgo_up(bp))).Fst_blksize) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_blocks = Uint64FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_blocks) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_atime.Ftv_sec = (**(**Tstat)(__ccgo_up(bp))).Fst_atim.Ftv_sec + (*Tstatx)(unsafe.Pointer(stx)).Fstx_atime.Ftv_nsec = Uint32FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_atim.Ftv_nsec) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_mtime.Ftv_sec = (**(**Tstat)(__ccgo_up(bp))).Fst_mtim.Ftv_sec + (*Tstatx)(unsafe.Pointer(stx)).Fstx_mtime.Ftv_nsec = Uint32FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_mtim.Ftv_nsec) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_ctime.Ftv_sec = (**(**Tstat)(__ccgo_up(bp))).Fst_ctim.Ftv_sec + (*Tstatx)(unsafe.Pointer(stx)).Fstx_ctime.Ftv_nsec = Uint32FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_ctim.Ftv_nsec) (*Tstatx)(unsafe.Pointer(stx)).Fstx_btime = Tstatx_timestamp{} (*Tstatx)(unsafe.Pointer(stx)).Fstx_mask = uint32(0x7ff) return 0 @@ -30807,8 +30807,8 @@ func Xstime(tls *TLS, t uintptr) (r int32) { bp := tls.Alloc(16) defer tls.Free(16) var _ /* tv at bp+0 */ Ttimeval - *(*Ttimeval)(unsafe.Pointer(bp)) = Ttimeval{ - Ftv_sec: *(*Ttime_t)(unsafe.Pointer(t)), + **(**Ttimeval)(__ccgo_up(bp)) = Ttimeval{ + Ftv_sec: **(**Ttime_t)(__ccgo_up(t)), } return Xsettimeofday(tls, bp, UintptrFromInt32(0)) } @@ -31001,12 +31001,12 @@ func Xwait4(tls *TLS, pid Tpid_t, status uintptr, options int32, ru uintptr) (r1 if r > 0 && ru != 0 && Bool(uint64(8) > uint64(8)) { Xmemcpy(tls, bp, dest, Uint64FromInt32(4)*Uint64FromInt64(8)) (*Trusage)(unsafe.Pointer(ru)).Fru_utime = Ttimeval{ - Ftv_sec: (*(*[4]int64)(unsafe.Pointer(bp)))[0], - Ftv_usec: (*(*[4]int64)(unsafe.Pointer(bp)))[int32(1)], + Ftv_sec: (**(**[4]int64)(__ccgo_up(bp)))[0], + Ftv_usec: (**(**[4]int64)(__ccgo_up(bp)))[int32(1)], } (*Trusage)(unsafe.Pointer(ru)).Fru_stime = Ttimeval{ - Ftv_sec: (*(*[4]int64)(unsafe.Pointer(bp)))[int32(2)], - Ftv_usec: (*(*[4]int64)(unsafe.Pointer(bp)))[int32(3)], + Ftv_sec: (**(**[4]int64)(__ccgo_up(bp)))[int32(2)], + Ftv_usec: (**(**[4]int64)(__ccgo_up(bp)))[int32(3)], } } return int32(X__syscall_ret(tls, Uint64FromInt32(r))) @@ -31129,7 +31129,7 @@ func X__lctrans_cur(tls *TLS, msg uintptr) (r uintptr) { trc("tls=%v msg=%v, (%v:)", tls, msg, origin(2)) defer func() { trc("-> %v", r) }() } - return X__lctrans_impl(tls, msg, *(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale + 5*8))) + return X__lctrans_impl(tls, msg, **(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale + 5*8))) } func _swapc(tls *TLS, x Tuint32_t, c int32) (r Tuint32_t) { @@ -31153,27 +31153,27 @@ func X__mo_lookup(tls *TLS, p uintptr, size Tsize_t, s uintptr) (r uintptr) { var sign, sw int32 _, _, _, _, _, _, _, _, _, _, _ = b, mo, n, o, ol, os, sign, sw, t, tl, ts mo = p - sw = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(mo)) - uint32(0x950412de)) + sw = Int32FromUint32(**(**Tuint32_t)(__ccgo_up(mo)) - uint32(0x950412de)) b = uint32(0) - n = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + 2*4)), sw) - o = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + 3*4)), sw) - t = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + 4*4)), sw) + n = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + 2*4)), sw) + o = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + 3*4)), sw) + t = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + 4*4)), sw) if uint64(n) >= size/uint64(4) || uint64(o) >= size-uint64(uint32(4)*n) || uint64(t) >= size-uint64(uint32(4)*n) || (o|t)%uint32(4) != 0 { return uintptr(0) } o = o / uint32(4) t = t / uint32(4) for { - ol = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + uintptr(o+uint32(2)*(b+n/uint32(2)))*4)), sw) - os = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + uintptr(o+uint32(2)*(b+n/uint32(2))+uint32(1))*4)), sw) - if uint64(os) >= size || uint64(ol) >= size-uint64(os) || *(*uint8)(unsafe.Pointer(p + uintptr(os+ol))) != 0 { + ol = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + uintptr(o+uint32(2)*(b+n/uint32(2)))*4)), sw) + os = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + uintptr(o+uint32(2)*(b+n/uint32(2))+uint32(1))*4)), sw) + if uint64(os) >= size || uint64(ol) >= size-uint64(os) || **(**uint8)(__ccgo_up(p + uintptr(os+ol))) != 0 { return uintptr(0) } sign = Xstrcmp(tls, s, p+uintptr(os)) if !(sign != 0) { - tl = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + uintptr(t+uint32(2)*(b+n/uint32(2)))*4)), sw) - ts = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + uintptr(t+uint32(2)*(b+n/uint32(2))+uint32(1))*4)), sw) - if uint64(ts) >= size || uint64(tl) >= size-uint64(ts) || *(*uint8)(unsafe.Pointer(p + uintptr(ts+tl))) != 0 { + tl = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + uintptr(t+uint32(2)*(b+n/uint32(2)))*4)), sw) + ts = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + uintptr(t+uint32(2)*(b+n/uint32(2))+uint32(1))*4)), sw) + if uint64(ts) >= size || uint64(tl) >= size-uint64(ts) || **(**uint8)(__ccgo_up(p + uintptr(ts+tl))) != 0 { return uintptr(0) } return p + uintptr(ts) @@ -31203,7 +31203,7 @@ func Xbind_textdomain_codeset(tls *TLS, domainname uintptr, codeset uintptr) (r defer func() { trc("-> %v", r) }() } if codeset != 0 && Xstrcasecmp(tls, codeset, __ccgo_ts+420) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) } return UintptrFromInt32(0) } @@ -31231,7 +31231,7 @@ func Xcatclose(tls *TLS, catd Tnl_catd) (r int32) { var v1, v2 Tuint32_t _, _, _ = map1, v1, v2 map1 = catd - v1 = *(*Tuint32_t)(unsafe.Pointer(map1 + UintptrFromInt32(8))) + v1 = **(**Tuint32_t)(__ccgo_up(map1 + UintptrFromInt32(8))) v2 = v1>>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v4>>int32(8)&uint32(0xff00) | v4<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v4>>int32(8)&uint32(0xff00) | v4<>int32(24) | v7>>int32(8)&uint32(0xff00) | v7<>int32(24) | v10>>int32(8)&uint32(0xff00) | v10<>int32(24) | v13>>int32(8)&uint32(0xff00) | v13<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v4>>int32(8)&uint32(0xff00) | v4<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v5>>int32(8)&uint32(0xff00) | v5< uint64(NAME_MAX) || dirlen >= uint64(PATH_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } ___lock(tls, uintptr(unsafe.Pointer(&_lock1))) @@ -31712,7 +31712,7 @@ func Xdcngettext(tls *TLS, domainname uintptr, msgid1 uintptr, msgid2 uintptr, n _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = alt_modlen, catlen, catname, csp, dirlen, dirname, domlen, l, lm, loc, loclen, locname, locp, map1, modlen, modname, name, np, old, old_cats, old_errno, p1, plural, q, r, rem, rule, trans, v11, v12, v20, v3, v5, v6 defer func() { Xrealloc(tls, name, 0) }() loc = (*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale - old_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + old_errno = **(**int32)(__ccgo_up(X__errno_location(tls))) /* match gnu gettext behaviour */ if !(msgid1 != 0) { goto notrans @@ -31743,14 +31743,14 @@ func Xdcngettext(tls *TLS, domainname uintptr, msgid1 uintptr, msgid2 uintptr, n if !(q != 0) { goto notrans } - lm = *(*uintptr)(unsafe.Pointer(loc + uintptr(category)*8)) + lm = **(**uintptr)(__ccgo_up(loc + uintptr(category)*8)) if !!(lm != 0) { goto _2 } goto notrans notrans: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = old_errno + **(**int32)(__ccgo_up(X__errno_location(tls))) = old_errno if n == uint64(1) { v3 = msgid1 } else { @@ -31823,21 +31823,21 @@ _2: } p1 = Xcalloc(tls, uint64(64), uint64(1)) if !(p1 != 0) { - X__munmap(tls, map1, *(*Tsize_t)(unsafe.Pointer(bp))) + X__munmap(tls, map1, **(**Tsize_t)(__ccgo_up(bp))) goto notrans } (*Tmsgcat)(unsafe.Pointer(p1)).Fcat = category (*Tmsgcat)(unsafe.Pointer(p1)).Fbinding = q (*Tmsgcat)(unsafe.Pointer(p1)).Flm = lm (*Tmsgcat)(unsafe.Pointer(p1)).Fmap1 = map1 - (*Tmsgcat)(unsafe.Pointer(p1)).Fmap_size = *(*Tsize_t)(unsafe.Pointer(bp)) + (*Tmsgcat)(unsafe.Pointer(p1)).Fmap_size = **(**Tsize_t)(__ccgo_up(bp)) rule = __ccgo_ts + 494 np = uint64(2) r = X__mo_lookup(tls, (*Tmsgcat)(unsafe.Pointer(p1)).Fmap1, (*Tmsgcat)(unsafe.Pointer(p1)).Fmap_size, __ccgo_ts) for r != 0 && Xstrncmp(tls, r, __ccgo_ts+500, uint64(13)) != 0 { - *(*uintptr)(unsafe.Pointer(bp + 8)) = Xstrchr(tls, r, int32('\n')) - if *(*uintptr)(unsafe.Pointer(bp + 8)) != 0 { - v3 = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(1) + **(**uintptr)(__ccgo_up(bp + 8)) = Xstrchr(tls, r, int32('\n')) + if **(**uintptr)(__ccgo_up(bp + 8)) != 0 { + v3 = **(**uintptr)(__ccgo_up(bp + 8)) + uintptr(1) } else { v3 = uintptr(0) } @@ -31846,7 +31846,7 @@ _2: if r != 0 { r = r + uintptr(13) for { - v11 = Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) + v11 = Int32FromUint8(**(**uint8)(__ccgo_up(r))) v12 = BoolInt32(v11 == int32(' ') || Uint32FromInt32(v11)-uint32('\t') < uint32(5)) goto _13 _13: @@ -31857,15 +31857,15 @@ _2: } if !(Xstrncmp(tls, r, __ccgo_ts+514, uint64(9)) != 0) { np = Xstrtoul(tls, r+uintptr(9), bp+8, int32(10)) - r = *(*uintptr)(unsafe.Pointer(bp + 8)) + r = **(**uintptr)(__ccgo_up(bp + 8)) } - for *(*uint8)(unsafe.Pointer(r)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) != int32(';') { + for **(**uint8)(__ccgo_up(r)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(r))) != int32(';') { r = r + 1 } - if *(*uint8)(unsafe.Pointer(r)) != 0 { + if **(**uint8)(__ccgo_up(r)) != 0 { r = r + 1 for { - v11 = Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) + v11 = Int32FromUint8(**(**uint8)(__ccgo_up(r))) v12 = BoolInt32(v11 == int32(' ') || Uint32FromInt32(v11)-uint32('\t') < uint32(5)) goto _16 _16: @@ -31928,7 +31928,7 @@ _2: trans = trans + uintptr(l+uint64(1)) } } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = old_errno + **(**int32)(__ccgo_up(X__errno_location(tls))) = old_errno return trans } @@ -31972,7 +31972,7 @@ func X__duplocale(tls *TLS, old Tlocale_t) (r Tlocale_t) { if old == uintptr(-Int32FromInt32(1)) { old = uintptr(unsafe.Pointer(&X__libc)) + 56 } - *(*t__locale_struct)(unsafe.Pointer(new1)) = *(*t__locale_struct)(unsafe.Pointer(old)) + **(**t__locale_struct)(__ccgo_up(new1)) = **(**t__locale_struct)(__ccgo_up(old)) return new1 } @@ -98146,13 +98146,13 @@ var _rev_jis = [6879]uint16{ func _fuzzycmp(tls *TLS, a uintptr, b uintptr) (r int32) { for { - if !(*(*uint8)(unsafe.Pointer(a)) != 0 && *(*uint8)(unsafe.Pointer(b)) != 0) { + if !(**(**uint8)(__ccgo_up(a)) != 0 && **(**uint8)(__ccgo_up(b)) != 0) { break } - for *(*uint8)(unsafe.Pointer(a)) != 0 && uint32(*(*uint8)(unsafe.Pointer(a)))|uint32(32)-uint32('a') > uint32(26) && Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(a)))-int32('0')) > uint32(10) { + for **(**uint8)(__ccgo_up(a)) != 0 && uint32(**(**uint8)(__ccgo_up(a)))|uint32(32)-uint32('a') > uint32(26) && Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(a)))-int32('0')) > uint32(10) { a = a + 1 } - if uint32(*(*uint8)(unsafe.Pointer(a)))|uint32(32) != uint32(*(*uint8)(unsafe.Pointer(b))) { + if uint32(**(**uint8)(__ccgo_up(a)))|uint32(32) != uint32(**(**uint8)(__ccgo_up(b))) { return int32(1) } goto _1 @@ -98161,23 +98161,23 @@ func _fuzzycmp(tls *TLS, a uintptr, b uintptr) (r int32) { a = a + 1 b = b + 1 } - return BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(a))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(b)))) + return BoolInt32(Int32FromUint8(**(**uint8)(__ccgo_up(a))) != Int32FromUint8(**(**uint8)(__ccgo_up(b)))) } func _find_charmap(tls *TLS, name uintptr) (r Tsize_t) { var s uintptr _ = s - if !(*(*uint8)(unsafe.Pointer(name)) != 0) { + if !(**(**uint8)(__ccgo_up(name)) != 0) { name = uintptr(unsafe.Pointer(&_charmaps)) } /* "utf8" */ s = uintptr(unsafe.Pointer(&_charmaps)) for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { break } if !(_fuzzycmp(tls, name, s) != 0) { for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { break } goto _2 @@ -98188,11 +98188,11 @@ func _find_charmap(tls *TLS, name uintptr) (r Tsize_t) { return Uint64FromInt64(int64(s+uintptr(1)) - t__predefined_ptrdiff_t(uintptr(unsafe.Pointer(&_charmaps)))) } s = s + uintptr(_strlen(tls, s)+uint64(1)) - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) > int32(0200) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { + if Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) > int32(0200) { s = s + uintptr(2) } else { - s = s + uintptr(uint32(2)+(uint32(64)-uint32(*(*uint8)(unsafe.Pointer(s + 1))))*uint32(5)) + s = s + uintptr(uint32(2)+(uint32(64)-uint32(**(**uint8)(__ccgo_up(s + 1))))*uint32(5)) } } goto _1 @@ -98235,7 +98235,7 @@ func Xiconv_open(tls *TLS, to uintptr, from uintptr) (r Ticonv_t) { f = v2 } if v3 || v2 == Uint64FromInt32(-Int32FromInt32(1)) || Int32FromUint8(_charmaps[t]) >= int32(0330) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(-Int32FromInt32(1)) } cd = _combine_to_from(tls, t, f) @@ -98260,26 +98260,26 @@ func Xiconv_open(tls *TLS, to uintptr, from uintptr) (r Ticonv_t) { func _get_16(tls *TLS, s uintptr, e int32) (r uint32) { e = e & int32(1) - return Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(e))))<> int32(8)) - *(*uint8)(unsafe.Pointer(s + uintptr(int32(1)-e))) = uint8(c) + **(**uint8)(__ccgo_up(s + uintptr(e))) = uint8(c >> int32(8)) + **(**uint8)(__ccgo_up(s + uintptr(int32(1)-e))) = uint8(c) } func _get_32(tls *TLS, s uintptr, e int32) (r uint32) { e = e & int32(3) - return (uint32(*(*uint8)(unsafe.Pointer(s + uintptr(e))))+0)<> int32(24)) - *(*uint8)(unsafe.Pointer(s + uintptr(e^int32(1)))) = uint8(c >> int32(16)) - *(*uint8)(unsafe.Pointer(s + uintptr(e^int32(2)))) = uint8(c >> int32(8)) - *(*uint8)(unsafe.Pointer(s + uintptr(e^int32(3)))) = uint8(c) + **(**uint8)(__ccgo_up(s + uintptr(e^0))) = uint8(c >> int32(24)) + **(**uint8)(__ccgo_up(s + uintptr(e^int32(1)))) = uint8(c >> int32(16)) + **(**uint8)(__ccgo_up(s + uintptr(e^int32(2)))) = uint8(c >> int32(8)) + **(**uint8)(__ccgo_up(s + uintptr(e^int32(3)))) = uint8(c) } /* Adapt as needed */ @@ -98287,11 +98287,11 @@ func _put_32(tls *TLS, s uintptr, c uint32, e int32) { func _legacy_map(tls *TLS, map1 uintptr, c uint32) (r uint32) { var x, v1 uint32 _, _ = x, v1 - if c < Uint32FromInt32(int32(4)*Int32FromUint8(*(*uint8)(unsafe.Pointer(map1 + uintptr(-Int32FromInt32(1)))))) { + if c < Uint32FromInt32(int32(4)*Int32FromUint8(**(**uint8)(__ccgo_up(map1 + uintptr(-Int32FromInt32(1)))))) { return c } - x = c - Uint32FromInt32(int32(4)*Int32FromUint8(*(*uint8)(unsafe.Pointer(map1 + uintptr(-Int32FromInt32(1)))))) - x = Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(map1 + uintptr(x*uint32(5)/uint32(4)))))>>(uint32(2)*x%uint32(8)) | Int32FromUint8(*(*uint8)(unsafe.Pointer(map1 + uintptr(x*uint32(5)/uint32(4)+uint32(1)))))<<(uint32(8)-uint32(2)*x%uint32(8))&int32(1023)) + x = c - Uint32FromInt32(int32(4)*Int32FromUint8(**(**uint8)(__ccgo_up(map1 + uintptr(-Int32FromInt32(1)))))) + x = Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(map1 + uintptr(x*uint32(5)/uint32(4)))))>>(uint32(2)*x%uint32(8)) | Int32FromUint8(**(**uint8)(__ccgo_up(map1 + uintptr(x*uint32(5)/uint32(4)+uint32(1)))))<<(uint32(8)-uint32(2)*x%uint32(8))&int32(1023)) if x < uint32(256) { v1 = x } else { @@ -98308,7 +98308,7 @@ func _uni_to_jis(tls *TLS, c uint32) (r uint32) { for { i = nel / uint32(2) j = uint32(_rev_jis[b+i]) - d = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(j/uint32(256))*188 + uintptr(j%uint32(256))*2))) + d = uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(j/uint32(256))*188 + uintptr(j%uint32(256))*2))) if d == c { return j + uint32(0x2121) } else { @@ -98361,20 +98361,20 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui from = uint32(_extract_from(tls, cd)) map1 = uintptr(unsafe.Pointer(&_charmaps)) + uintptr(from) + uintptr(1) tomap = uintptr(unsafe.Pointer(&_charmaps)) + uintptr(to) + uintptr(1) - *(*Tmbstate_t)(unsafe.Pointer(bp + 24)) = Tmbstate_t{} - type1 = *(*uint8)(unsafe.Pointer(map1 + uintptr(-Int32FromInt32(1)))) - totype = *(*uint8)(unsafe.Pointer(tomap + uintptr(-Int32FromInt32(1)))) + **(**Tmbstate_t)(__ccgo_up(bp + 24)) = Tmbstate_t{} + type1 = **(**uint8)(__ccgo_up(map1 + uintptr(-Int32FromInt32(1)))) + totype = **(**uint8)(__ccgo_up(tomap + uintptr(-Int32FromInt32(1)))) ploc = uintptr(___get_tp(tls)) + 152 - loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) - if !(in != 0) || !(*(*uintptr)(unsafe.Pointer(in)) != 0) || !(*(*Tsize_t)(unsafe.Pointer(inb)) != 0) { + loc = **(**Tlocale_t)(__ccgo_up(ploc)) + if !(in != 0) || !(**(**uintptr)(__ccgo_up(in)) != 0) || !(**(**Tsize_t)(__ccgo_up(inb)) != 0) { return uint64(0) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = uintptr(unsafe.Pointer(&X__c_dot_utf8_locale)) + **(**Tlocale_t)(__ccgo_up(ploc)) = uintptr(unsafe.Pointer(&X__c_dot_utf8_locale)) for { - if !(*(*Tsize_t)(unsafe.Pointer(inb)) != 0) { + if !(**(**Tsize_t)(__ccgo_up(inb)) != 0) { break } - c = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in))))) + c = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in))))) l = uint64(1) switch Int32FromUint8(type1) { case int32(UTF_8): @@ -98426,14 +98426,14 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if c < uint32(128) { goto _23 } - l = Xmbrtowc(tls, bp+32, *(*uintptr)(unsafe.Pointer(in)), *(*Tsize_t)(unsafe.Pointer(inb)), bp+24) + l = Xmbrtowc(tls, bp+32, **(**uintptr)(__ccgo_up(in)), **(**Tsize_t)(__ccgo_up(inb)), bp+24) if l == Uint64FromInt32(-Int32FromInt32(1)) { goto ilseq } if l == Uint64FromInt32(-Int32FromInt32(2)) { goto starved } - c = Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp + 32))) + c = Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp + 32))) goto _23 _3: ; @@ -98444,10 +98444,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui _4: ; l = uint64(4) - if *(*Tsize_t)(unsafe.Pointer(inb)) < l { + if **(**Tsize_t)(__ccgo_up(inb)) < l { goto starved } - c = Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in))))) + c = Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(in))))) if !(0 != 0) { goto _24 } @@ -98456,10 +98456,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui _5: ; l = uint64(4) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(4) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(4) { goto starved } - c = _get_32(tls, *(*uintptr)(unsafe.Pointer(in)), Int32FromUint8(type1)) + c = _get_32(tls, **(**uintptr)(__ccgo_up(in)), Int32FromUint8(type1)) _24: ; if c-uint32(0xd800) < uint32(0x800) || c >= uint32(0x110000) { @@ -98475,10 +98475,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui _7: ; l = uint64(2) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(2) { goto starved } - c = _get_16(tls, *(*uintptr)(unsafe.Pointer(in)), Int32FromUint8(type1)) + c = _get_16(tls, **(**uintptr)(__ccgo_up(in)), Int32FromUint8(type1)) if c-Uint32FromInt32(0xdc00) < uint32(0x400) { goto ilseq } @@ -98487,10 +98487,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto ilseq } l = uint64(4) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(4) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(4) { goto starved } - d = _get_16(tls, *(*uintptr)(unsafe.Pointer(in))+UintptrFromInt32(2), Int32FromUint8(type1)) + d = _get_16(tls, **(**uintptr)(__ccgo_up(in))+UintptrFromInt32(2), Int32FromUint8(type1)) if d-Uint32FromInt32(0xdc00) >= uint32(0x400) { goto ilseq } @@ -98503,10 +98503,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui ; l = uint64(0) if !((*Tstateful_cd)(unsafe.Pointer(scd)).Fstate != 0) { - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(2) { goto starved } - c = _get_16(tls, *(*uintptr)(unsafe.Pointer(in)), 0) + c = _get_16(tls, **(**uintptr)(__ccgo_up(in)), 0) if Int32FromUint8(type1) == int32(UCS2) { if c == uint32(0xfffe) { v26 = int32(UCS2LE) @@ -98533,10 +98533,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui ; l = uint64(0) if !((*Tstateful_cd)(unsafe.Pointer(scd)).Fstate != 0) { - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(4) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(4) { goto starved } - c = _get_32(tls, *(*uintptr)(unsafe.Pointer(in)), 0) + c = _get_32(tls, **(**uintptr)(__ccgo_up(in)), 0) if c == uint32(0xfffe0000) { v25 = int32(UTF_32LE) } else { @@ -98559,10 +98559,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _23 } l = uint64(2) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(2) { goto starved } - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(1)))) if c-uint32(129) <= Uint32FromInt32(Int32FromInt32(159)-Int32FromInt32(129)) { c = c - uint32(129) } else { @@ -98590,7 +98590,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if c >= uint32(84) { goto ilseq } - c = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(c)*188 + uintptr(d)*2))) + c = uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(c)*188 + uintptr(d)*2))) if !(c != 0) { goto ilseq } @@ -98601,10 +98601,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _23 } l = uint64(2) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(2) { goto starved } - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(1)))) if c == uint32(0x8e) { c = d if c-uint32(0xa1) > Uint32FromInt32(Int32FromInt32(0xdf)-Int32FromInt32(0xa1)) { @@ -98618,7 +98618,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if c >= uint32(84) || d >= uint32(94) { goto ilseq } - c = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(c)*188 + uintptr(d)*2))) + c = uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(c)*188 + uintptr(d)*2))) if !(c != 0) { goto ilseq } @@ -98630,11 +98630,11 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } if c == uint32('\033') { l = uint64(3) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(3) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(3) { goto starved } - c = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(2)))) + c = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(1)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(2)))) if c != uint32('(') && c != uint32('$') { goto ilseq } @@ -98669,16 +98669,16 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui fallthrough case uint32(3): l = uint64(2) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(2) { goto starved } - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(1)))) c = c - uint32(0x21) d = d - uint32(0x21) if c >= uint32(84) || d >= uint32(94) { goto ilseq } - c = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(c)*188 + uintptr(d)*2))) + c = uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(c)*188 + uintptr(d)*2))) if !(c != 0) { goto ilseq } @@ -98716,10 +98716,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto ilseq } l = uint64(2) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(2) { goto starved } - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(1)))) if d < uint32(0xa1) && Int32FromUint8(type1) == int32(GB2312) { goto ilseq } @@ -98728,16 +98728,16 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto ilseq } l = uint64(4) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(4) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(4) { goto starved } c = (uint32(10)*c + d - uint32('0')) * uint32(1260) - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(2)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(2)))) if d-uint32(0x81) > uint32(126) { goto ilseq } c = c + uint32(10)*(d-uint32(0x81)) - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(3)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(3)))) if d-uint32('0') > uint32(9) { goto ilseq } @@ -98759,7 +98759,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if !(j < int32(190)) { break } - if uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_gb18030)) + uintptr(i)*380 + uintptr(j)*2)))-d <= c-d { + if uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_gb18030)) + uintptr(i)*380 + uintptr(j)*2)))-d <= c-d { k = k + 1 } goto _31 @@ -98783,7 +98783,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if d > uint32(63) { d = d - 1 } - c = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_gb18030)) + uintptr(c)*380 + uintptr(d)*2))) + c = uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_gb18030)) + uintptr(c)*380 + uintptr(d)*2))) goto _23 _20: ; @@ -98791,10 +98791,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _23 } l = uint64(2) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(2) { goto starved } - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(1)))) if d-uint32(0x40) >= Uint32FromInt32(Int32FromInt32(0xff)-Int32FromInt32(0x40)) || d-uint32(0x7f) < Uint32FromInt32(Int32FromInt32(0xa1)-Int32FromInt32(0x7f)) { goto ilseq } @@ -98817,21 +98817,21 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui * range in the hkscs table then hard-coded * here. Ugly, yes. */ if c/uint32(256) == uint32(0xdc) { - *(*uintptr)(unsafe.Pointer(bp + 48)) = bp + 40 + **(**uintptr)(__ccgo_up(bp + 48)) = bp + 40 *(*uintptr)(unsafe.Pointer(bp)) = __ccgo_ts + 543 + uintptr(c%uint32(256)) *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint64(4) *(*Tsize_t)(unsafe.Pointer(bp + 16)) = uint64(8) tmpx = Xiconv(tls, _combine_to_from(tls, uint64(to), _find_charmap(tls, __ccgo_ts+560)), bp, bp+8, bp+48, bp+16) - tmplen = Uint64FromInt64(int64(*(*uintptr)(unsafe.Pointer(bp + 48))) - t__predefined_ptrdiff_t(bp+40)) - if tmplen > *(*Tsize_t)(unsafe.Pointer(outb)) { + tmplen = Uint64FromInt64(int64(**(**uintptr)(__ccgo_up(bp + 48))) - t__predefined_ptrdiff_t(bp+40)) + if tmplen > **(**Tsize_t)(__ccgo_up(outb)) { goto toobig } if tmpx != 0 { x = x + 1 } - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(out)), bp+40, tmplen) - *(*uintptr)(unsafe.Pointer(out)) += uintptr(tmplen) - *(*Tsize_t)(unsafe.Pointer(outb)) -= tmplen + Xmemcpy(tls, **(**uintptr)(__ccgo_up(out)), bp+40, tmplen) + **(**uintptr)(__ccgo_up(out)) += uintptr(tmplen) + **(**Tsize_t)(__ccgo_up(outb)) -= tmplen goto _1 } if !(c != 0) { @@ -98840,7 +98840,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _23 } c = c - uint32(0xa1) - c = Uint32FromInt32(Int32FromUint16(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_big5)) + uintptr(c)*314 + uintptr(d)*2))) | BoolInt32(c == uint32(0x27) && (d == uint32(0x3a) || d == uint32(0x3c) || d == uint32(0x42)))<= uint32(93) || d >= uint32(94) { @@ -98898,7 +98898,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if !(j1 < int32(94)) { break } - if uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ksc)) + uintptr(i1)*188 + uintptr(j1)*2)))-d <= c-d { + if uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_ksc)) + uintptr(i1)*188 + uintptr(j1)*2)))-d <= c-d { k = k + 1 } goto _34 @@ -98918,7 +98918,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } goto _23 } - c = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ksc)) + uintptr(c)*188 + uintptr(d)*2))) + c = uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_ksc)) + uintptr(c)*188 + uintptr(d)*2))) if !(c != 0) { goto ilseq } @@ -98971,26 +98971,26 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _51 _35: ; - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(4) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(4) { goto toobig } - *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(out)))) = Int32FromUint32(c) - *(*uintptr)(unsafe.Pointer(out)) += uintptr(4) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(4) + **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(out)))) = Int32FromUint32(c) + **(**uintptr)(__ccgo_up(out)) += uintptr(4) + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(4) goto _51 _36: ; - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(4) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(4) { k = Uint64FromInt32(Xwctomb(tls, bp+56, Int32FromUint32(c))) - if *(*Tsize_t)(unsafe.Pointer(outb)) < k { + if **(**Tsize_t)(__ccgo_up(outb)) < k { goto toobig } - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(out)), bp+56, k) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(out)), bp+56, k) } else { - k = Uint64FromInt32(Xwctomb(tls, *(*uintptr)(unsafe.Pointer(out)), Int32FromUint32(c))) + k = Uint64FromInt32(Xwctomb(tls, **(**uintptr)(__ccgo_up(out)), Int32FromUint32(c))) } - *(*uintptr)(unsafe.Pointer(out)) += uintptr(k) - *(*Tsize_t)(unsafe.Pointer(outb)) -= k + **(**uintptr)(__ccgo_up(out)) += uintptr(k) + **(**Tsize_t)(__ccgo_up(outb)) -= k goto _51 _37: ; @@ -99006,7 +99006,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui ; _38: ; - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(1) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(1) { goto toobig } if !(c < uint32(256) && c == _legacy_map(tls, tomap, c)) { @@ -99015,14 +99015,14 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto revout revout: ; - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(1) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(1) { goto toobig } v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8(c) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(1) + **(**uint8)(__ccgo_up(v54)) = uint8(c) + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(1) goto _51 _53: ; @@ -99064,7 +99064,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if !(c != 0) { goto subst } - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(2) { goto toobig } d = c % uint32(256) @@ -99077,7 +99077,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } else { v25 = int32(176) } - *(*uint8)(unsafe.Pointer(v54)) = uint8((c+uint32(1))/uint32(2) + Uint32FromInt32(v25)) + **(**uint8)(__ccgo_up(v54)) = uint8((c+uint32(1))/uint32(2) + Uint32FromInt32(v25)) v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 @@ -99086,8 +99086,8 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } else { v62 = d + uint32(126) } - *(*uint8)(unsafe.Pointer(v54)) = uint8(v62) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(2) + **(**uint8)(__ccgo_up(v54)) = uint8(v62) + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(2) goto _51 _40: ; @@ -99102,18 +99102,18 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if !(c != 0) { goto subst } - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(2) { goto toobig } v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8(c/uint32(256) + uint32(0x80)) + **(**uint8)(__ccgo_up(v54)) = uint8(c/uint32(256) + uint32(0x80)) v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8(c%uint32(256) + uint32(0x80)) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(2) + **(**uint8)(__ccgo_up(v54)) = uint8(c%uint32(256) + uint32(0x80)) + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(2) goto _51 _41: ; @@ -99121,102 +99121,102 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto revout } if c-uint32(0xff61) <= Uint32FromInt32(Int32FromInt32(0xdf)-Int32FromInt32(0xa1)) || c == uint32(0xa5) || c == uint32(0x203e) { - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(7) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(7) { goto toobig } v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('\033') + **(**uint8)(__ccgo_up(v54)) = uint8('\033') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('(') + **(**uint8)(__ccgo_up(v54)) = uint8('(') if c == uint32(0xa5) { v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('J') + **(**uint8)(__ccgo_up(v54)) = uint8('J') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('\\') + **(**uint8)(__ccgo_up(v54)) = uint8('\\') } else { if c == uint32(0x203e) { v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('J') + **(**uint8)(__ccgo_up(v54)) = uint8('J') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('~') + **(**uint8)(__ccgo_up(v54)) = uint8('~') } else { v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('I') + **(**uint8)(__ccgo_up(v54)) = uint8('I') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8(c - uint32(0xff61) + uint32(0x21)) + **(**uint8)(__ccgo_up(v54)) = uint8(c - uint32(0xff61) + uint32(0x21)) } } v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('\033') + **(**uint8)(__ccgo_up(v54)) = uint8('\033') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('(') + **(**uint8)(__ccgo_up(v54)) = uint8('(') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('B') - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(7) + **(**uint8)(__ccgo_up(v54)) = uint8('B') + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(7) goto _51 } c = _uni_to_jis(tls, c) if !(c != 0) { goto subst } - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(8) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(8) { goto toobig } v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('\033') + **(**uint8)(__ccgo_up(v54)) = uint8('\033') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('$') + **(**uint8)(__ccgo_up(v54)) = uint8('$') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('B') + **(**uint8)(__ccgo_up(v54)) = uint8('B') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8(c / uint32(256)) + **(**uint8)(__ccgo_up(v54)) = uint8(c / uint32(256)) v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8(c % uint32(256)) + **(**uint8)(__ccgo_up(v54)) = uint8(c % uint32(256)) v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('\033') + **(**uint8)(__ccgo_up(v54)) = uint8('\033') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('(') + **(**uint8)(__ccgo_up(v54)) = uint8('(') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('B') - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(8) + **(**uint8)(__ccgo_up(v54)) = uint8('B') + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(8) goto _51 _42: ; @@ -99235,22 +99235,22 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if c >= uint32(0x10000) { c = uint32(0xFFFD) } - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(2) { goto toobig } - _put_16(tls, *(*uintptr)(unsafe.Pointer(out)), c, Int32FromUint8(totype)) - *(*uintptr)(unsafe.Pointer(out)) += uintptr(2) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(2) + _put_16(tls, **(**uintptr)(__ccgo_up(out)), c, Int32FromUint8(totype)) + **(**uintptr)(__ccgo_up(out)) += uintptr(2) + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(2) goto _51 } - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(4) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(4) { goto toobig } c = c - uint32(0x10000) - _put_16(tls, *(*uintptr)(unsafe.Pointer(out)), c>>int32(10)|uint32(0xd800), Int32FromUint8(totype)) - _put_16(tls, *(*uintptr)(unsafe.Pointer(out))+UintptrFromInt32(2), c&uint32(0x3ff)|uint32(0xdc00), Int32FromUint8(totype)) - *(*uintptr)(unsafe.Pointer(out)) += uintptr(4) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(4) + _put_16(tls, **(**uintptr)(__ccgo_up(out)), c>>int32(10)|uint32(0xd800), Int32FromUint8(totype)) + _put_16(tls, **(**uintptr)(__ccgo_up(out))+UintptrFromInt32(2), c&uint32(0x3ff)|uint32(0xdc00), Int32FromUint8(totype)) + **(**uintptr)(__ccgo_up(out)) += uintptr(4) + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(4) goto _51 _48: ; @@ -99259,22 +99259,22 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui ; _49: ; - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(4) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(4) { goto toobig } - _put_32(tls, *(*uintptr)(unsafe.Pointer(out)), c, Int32FromUint8(totype)) - *(*uintptr)(unsafe.Pointer(out)) += uintptr(4) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(4) + _put_32(tls, **(**uintptr)(__ccgo_up(out)), c, Int32FromUint8(totype)) + **(**uintptr)(__ccgo_up(out)) += uintptr(4) + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(4) goto _51 _51: ; goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(in)) += uintptr(l) - *(*Tsize_t)(unsafe.Pointer(inb)) -= l + **(**uintptr)(__ccgo_up(in)) += uintptr(l) + **(**Tsize_t)(__ccgo_up(inb)) -= l } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return x goto ilseq ilseq: @@ -99296,8 +99296,8 @@ starved: goto end end: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = err - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**int32)(__ccgo_up(X__errno_location(tls))) = err + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return x } @@ -99328,7 +99328,7 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { cat = item >> int32(16) idx = item & int32(65535) if item == int32(CODESET) { - if *(*uintptr)(unsafe.Pointer(loc)) != 0 { + if **(**uintptr)(__ccgo_up(loc)) != 0 { v1 = __ccgo_ts + 420 } else { v1 = __ccgo_ts + 565 @@ -99337,8 +99337,8 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { } /* _NL_LOCALE_NAME extension */ if idx == int32(65535) && cat < int32(LC_ALL) { - if *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*8)) != 0 { - v1 = *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*8)) + 16 + if **(**uintptr)(__ccgo_up(loc + uintptr(cat)*8)) != 0 { + v1 = **(**uintptr)(__ccgo_up(loc + uintptr(cat)*8)) + 16 } else { v1 = __ccgo_ts + 571 } @@ -99373,7 +99373,7 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { break } for { - if !(*(*uint8)(unsafe.Pointer(str)) != 0) { + if !(**(**uint8)(__ccgo_up(str)) != 0) { break } goto _4 @@ -99387,8 +99387,8 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { idx = idx - 1 str = str + 1 } - if cat != int32(LC_NUMERIC) && *(*uint8)(unsafe.Pointer(str)) != 0 { - str = X__lctrans(tls, str, *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*8))) + if cat != int32(LC_NUMERIC) && **(**uint8)(__ccgo_up(str)) != 0 { + str = X__lctrans(tls, str, **(**uintptr)(__ccgo_up(loc + uintptr(cat)*8))) } return str } @@ -99461,18 +99461,18 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = builtin, l, map1, n, new1, p, path, z, v1, v2, v3, v4, v5, v6, v7 new1 = uintptr(0) path = uintptr(0) - if !(*(*uint8)(unsafe.Pointer(val)) != 0) { + if !(**(**uint8)(__ccgo_up(val)) != 0) { v1 = Xgetenv(tls, __ccgo_ts+573) val = v1 - if v3 = v1 != 0 && *(*uint8)(unsafe.Pointer(val)) != 0; !v3 { + if v3 = v1 != 0 && **(**uint8)(__ccgo_up(val)) != 0; !v3 { v2 = Xgetenv(tls, uintptr(unsafe.Pointer(&_envvars))+uintptr(cat)*12) val = v2 } - if v5 = v3 || v2 != 0 && *(*uint8)(unsafe.Pointer(val)) != 0; !v5 { + if v5 = v3 || v2 != 0 && **(**uint8)(__ccgo_up(val)) != 0; !v5 { v4 = Xgetenv(tls, __ccgo_ts+434) val = v4 } - if v7 = v5 || v4 != 0 && *(*uint8)(unsafe.Pointer(val)) != 0; !v7 { + if v7 = v5 || v4 != 0 && **(**uint8)(__ccgo_up(val)) != 0; !v7 { v6 = __ccgo_ts + 580 val = v6 } @@ -99481,7 +99481,7 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { /* Limit name length and forbid leading dot or any slashes. */ n = uint64(0) for { - if !(n < uint64(LOCALE_NAME_MAX) && *(*uint8)(unsafe.Pointer(val + uintptr(n))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(val + uintptr(n)))) != int32('/')) { + if !(n < uint64(LOCALE_NAME_MAX) && **(**uint8)(__ccgo_up(val + uintptr(n))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(val + uintptr(n)))) != int32('/')) { break } goto _8 @@ -99489,12 +99489,12 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { ; n = n + 1 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(val))) == int32('.') || *(*uint8)(unsafe.Pointer(val + uintptr(n))) != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(val))) == int32('.') || **(**uint8)(__ccgo_up(val + uintptr(n))) != 0 { val = __ccgo_ts + 580 } - builtin = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(val))) == int32('C') && !(*(*uint8)(unsafe.Pointer(val + 1)) != 0) || !(Xstrcmp(tls, val, __ccgo_ts+580) != 0) || !(Xstrcmp(tls, val, __ccgo_ts+588) != 0)) + builtin = BoolInt32(Int32FromUint8(**(**uint8)(__ccgo_up(val))) == int32('C') && !(**(**uint8)(__ccgo_up(val + 1)) != 0) || !(Xstrcmp(tls, val, __ccgo_ts+580) != 0) || !(Xstrcmp(tls, val, __ccgo_ts+588) != 0)) if builtin != 0 { - if cat == LC_CTYPE && Int32FromUint8(*(*uint8)(unsafe.Pointer(val + 1))) == int32('.') { + if cat == LC_CTYPE && Int32FromUint8(**(**uint8)(__ccgo_up(val + 1))) == int32('.') { return uintptr(unsafe.Pointer(&X__c_dot_utf8)) } return uintptr(0) @@ -99518,7 +99518,7 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { /* FIXME: add a default path? */ if path != 0 { for { - if !(*(*uint8)(unsafe.Pointer(path)) != 0) { + if !(**(**uint8)(__ccgo_up(path)) != 0) { break } z = X__strchrnul(tls, path, int32(':')) @@ -99527,20 +99527,20 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { goto _10 } Xmemcpy(tls, bp, path, l) - (*(*[256]uint8)(unsafe.Pointer(bp)))[l] = uint8('/') + (**(**[256]uint8)(__ccgo_up(bp)))[l] = uint8('/') Xmemcpy(tls, bp+uintptr(l)+uintptr(1), val, n) - (*(*[256]uint8)(unsafe.Pointer(bp)))[l+uint64(1)+n] = uint8(0) + (**(**[256]uint8)(__ccgo_up(bp)))[l+uint64(1)+n] = uint8(0) map1 = X__map_file(tls, bp, bp+256) if map1 != 0 { new1 = Xmalloc(tls, uint64(48)) if !(new1 != 0) { - X__munmap(tls, map1, *(*Tsize_t)(unsafe.Pointer(bp + 256))) + X__munmap(tls, map1, **(**Tsize_t)(__ccgo_up(bp + 256))) break } (*t__locale_map)(unsafe.Pointer(new1)).Fmap1 = map1 - (*t__locale_map)(unsafe.Pointer(new1)).Fmap_size = *(*Tsize_t)(unsafe.Pointer(bp + 256)) + (*t__locale_map)(unsafe.Pointer(new1)).Fmap_size = **(**Tsize_t)(__ccgo_up(bp + 256)) Xmemcpy(tls, new1+16, val, n) - *(*uint8)(unsafe.Pointer(new1 + 16 + uintptr(n))) = uint8(0) + **(**uint8)(__ccgo_up(new1 + 16 + uintptr(n))) = uint8(0) (*t__locale_map)(unsafe.Pointer(new1)).Fnext = AtomicLoadPUintptr(uintptr(unsafe.Pointer(&_loc_head))) AtomicStorePUintptr(uintptr(unsafe.Pointer(&_loc_head)), new1) break @@ -99548,7 +99548,7 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { goto _10 _10: ; - path = z + BoolUintptr(!!(*(*uint8)(unsafe.Pointer(z)) != 0)) + path = z + BoolUintptr(!!(**(**uint8)(__ccgo_up(z)) != 0)) } } /* If no locale definition was found, make a locale map @@ -99563,7 +99563,7 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { (*t__locale_map)(unsafe.Pointer(new1)).Fmap1 = X__c_dot_utf8.Fmap1 (*t__locale_map)(unsafe.Pointer(new1)).Fmap_size = X__c_dot_utf8.Fmap_size Xmemcpy(tls, new1+16, val, n) - *(*uint8)(unsafe.Pointer(new1 + 16 + uintptr(n))) = uint8(0) + **(**uint8)(__ccgo_up(new1 + 16 + uintptr(n))) = uint8(0) (*t__locale_map)(unsafe.Pointer(new1)).Fnext = AtomicLoadPUintptr(uintptr(unsafe.Pointer(&_loc_head))) AtomicStorePUintptr(uintptr(unsafe.Pointer(&_loc_head)), new1) } @@ -99647,7 +99647,7 @@ func _do_newlocale(tls *TLS, mask int32, name uintptr, loc Tlocale_t) (r Tlocale break } if !(mask&(Int32FromInt32(1)<,< are accepted with or without = */ - if i < int32(6) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) == Int32FromUint8(_opch2[i]) { + if i < int32(6) && Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) == Int32FromUint8(_opch2[i]) { (*Tst)(unsafe.Pointer(st)).Fop = i return s + uintptr(2) } @@ -99953,12 +99953,12 @@ func _evalexpr(tls *TLS, st uintptr, s uintptr, d int32) (r uintptr) { return __ccgo_ts } s = _evalbinop(tls, st, s, 0, d) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('?') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32('?') { return s } a = (*Tst)(unsafe.Pointer(st)).Fr s = _evalexpr(tls, st, s+uintptr(1), d) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32(':') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32(':') { return __ccgo_ts } b = (*Tst)(unsafe.Pointer(st)).Fr @@ -99982,10 +99982,10 @@ func X__pleval(tls *TLS, s uintptr, n uint64) (r uint64) { var v1 uint64 var _ /* st at bp+0 */ Tst _ = v1 - (*(*Tst)(unsafe.Pointer(bp))).Fn = n + (**(**Tst)(__ccgo_up(bp))).Fn = n s = _evalexpr(tls, bp, s, int32(100)) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32(';') { - v1 = (*(*Tst)(unsafe.Pointer(bp))).Fr + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32(';') { + v1 = (**(**Tst)(__ccgo_up(bp))).Fr } else { v1 = Uint64FromInt32(-Int32FromInt32(1)) } @@ -100018,7 +100018,7 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { * on the format, so it can easily be changed if needed. */ if cat == int32(LC_ALL) { if name != 0 { - *(*[24]uint8)(unsafe.Pointer(bp + 48)) = [24]uint8{'C', '.', 'U', 'T', 'F', '-', '8'} + **(**[24]uint8)(__ccgo_up(bp + 48)) = [24]uint8{'C', '.', 'U', 'T', 'F', '-', '8'} p = name i = 0 for { @@ -100028,8 +100028,8 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { z = X__strchrnul(tls, p, int32(';')) if int64(z)-int64(p) <= int64(LOCALE_NAME_MAX) { Xmemcpy(tls, bp+48, p, Uint64FromInt64(int64(z)-int64(p))) - (*(*[24]uint8)(unsafe.Pointer(bp + 48)))[int64(z)-int64(p)] = uint8(0) - if *(*uint8)(unsafe.Pointer(z)) != 0 { + (**(**[24]uint8)(__ccgo_up(bp + 48)))[int64(z)-int64(p)] = uint8(0) + if **(**uint8)(__ccgo_up(z)) != 0 { p = z + uintptr(1) } } @@ -100038,13 +100038,13 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { ___unlock(tls, uintptr(unsafe.Pointer(&X__locale_lock))) return uintptr(0) } - *(*uintptr)(unsafe.Pointer(bp + uintptr(i)*8)) = lm + **(**uintptr)(__ccgo_up(bp + uintptr(i)*8)) = lm goto _1 _1: ; i = i + 1 } - X__libc.Fglobal_locale = *(*t__locale_struct)(unsafe.Pointer(bp)) + X__libc.Fglobal_locale = **(**t__locale_struct)(__ccgo_up(bp)) } s = uintptr(unsafe.Pointer(&_buf1)) same = 0 @@ -100053,8 +100053,8 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { if !(i < int32(LC_ALL)) { break } - lm1 = *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 56 + uintptr(i)*8)) - if lm1 == *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 56)) { + lm1 = **(**uintptr)(__ccgo_up(uintptr(unsafe.Pointer(&X__libc)) + 56 + uintptr(i)*8)) + if lm1 == **(**uintptr)(__ccgo_up(uintptr(unsafe.Pointer(&X__libc)) + 56)) { same = same + 1 } if lm1 != 0 { @@ -100065,7 +100065,7 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { part1 = v3 l = _strlen(tls, part1) Xmemcpy(tls, s, part1, l) - *(*uint8)(unsafe.Pointer(s + uintptr(l))) = uint8(';') + **(**uint8)(__ccgo_up(s + uintptr(l))) = uint8(';') s = s + uintptr(l+uint64(1)) goto _2 _2: @@ -100074,7 +100074,7 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { } s = s - 1 v3 = s - *(*uint8)(unsafe.Pointer(v3)) = uint8(0) + **(**uint8)(__ccgo_up(v3)) = uint8(0) ___unlock(tls, uintptr(unsafe.Pointer(&X__locale_lock))) if same == int32(LC_ALL) { v3 = part1 @@ -100089,9 +100089,9 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { ___unlock(tls, uintptr(unsafe.Pointer(&X__locale_lock))) return uintptr(0) } - *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 56 + uintptr(cat)*8)) = lm + **(**uintptr)(__ccgo_up(uintptr(unsafe.Pointer(&X__libc)) + 56 + uintptr(cat)*8)) = lm } else { - lm = *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 56 + uintptr(cat)*8)) + lm = **(**uintptr)(__ccgo_up(uintptr(unsafe.Pointer(&X__libc)) + 56 + uintptr(cat)*8)) } if lm != 0 { v3 = lm + 16 @@ -100138,10 +100138,10 @@ func _vstrfmon_l(tls *TLS, s uintptr, n Tsize_t, loc Tlocale_t, fmt uintptr, ap s0 = s _3: ; - if !(n != 0 && *(*uint8)(unsafe.Pointer(fmt)) != 0) { + if !(n != 0 && **(**uint8)(__ccgo_up(fmt)) != 0) { goto _1 } - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) != int32('%')) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(fmt))) != int32('%')) { goto _4 } goto literal @@ -100151,13 +100151,13 @@ literal: s = s + 1 v6 = fmt fmt = fmt + 1 - *(*uint8)(unsafe.Pointer(v5)) = *(*uint8)(unsafe.Pointer(v6)) + **(**uint8)(__ccgo_up(v5)) = **(**uint8)(__ccgo_up(v6)) n = n - 1 goto _2 _4: ; fmt = fmt + 1 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) == int32('%') { + if Int32FromUint8(**(**uint8)(__ccgo_up(fmt))) == int32('%') { goto literal } fill = int32(' ') @@ -100166,11 +100166,11 @@ _4: nosym = 0 left = 0 for { - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(fmt))) { case int32('='): fmt = fmt + 1 v5 = fmt - fill = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + fill = Int32FromUint8(**(**uint8)(__ccgo_up(v5))) goto _7 case int32('^'): nogrp = int32(1) @@ -100195,10 +100195,10 @@ _4: } fw = 0 for { - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(fmt)))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(fmt)))-uint32('0') < uint32(10)) != 0) { break } - fw = int32(10)*fw + (Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) - int32('0')) + fw = int32(10)*fw + (Int32FromUint8(**(**uint8)(__ccgo_up(fmt))) - int32('0')) goto _9 _9: ; @@ -100206,28 +100206,28 @@ _4: } lp = 0 rp = int32(2) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) == int32('#') { + if Int32FromUint8(**(**uint8)(__ccgo_up(fmt))) == int32('#') { lp = 0 fmt = fmt + 1 for { - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(fmt)))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(fmt)))-uint32('0') < uint32(10)) != 0) { break } - lp = int32(10)*lp + (Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) - int32('0')) + lp = int32(10)*lp + (Int32FromUint8(**(**uint8)(__ccgo_up(fmt))) - int32('0')) goto _10 _10: ; fmt = fmt + 1 } } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) == int32('.') { + if Int32FromUint8(**(**uint8)(__ccgo_up(fmt))) == int32('.') { rp = 0 fmt = fmt + 1 for { - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(fmt)))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(fmt)))-uint32('0') < uint32(10)) != 0) { break } - rp = int32(10)*rp + (Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) - int32('0')) + rp = int32(10)*rp + (Int32FromUint8(**(**uint8)(__ccgo_up(fmt))) - int32('0')) goto _11 _11: ; @@ -100236,7 +100236,7 @@ _4: } v5 = fmt fmt = fmt + 1 - intl = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) == int32('i')) + intl = BoolInt32(Int32FromUint8(**(**uint8)(__ccgo_up(v5))) == int32('i')) w = lp + int32(1) + rp if !(left != 0) && fw > w { w = fw @@ -100244,7 +100244,7 @@ _4: x = VaFloat64(&ap) l = Uint64FromInt32(Xsnprintf(tls, s, n, __ccgo_ts+609, VaList(bp+8, w, rp, x))) if l >= n { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(E2BIG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(E2BIG) return int64(-int32(1)) } s = s + uintptr(l) @@ -100409,7 +100409,7 @@ func Xtextdomain(tls *TLS, domainname uintptr) (r uintptr) { } domlen = _strlen(tls, domainname) if domlen > uint64(NAME_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } if !(_current_domain != 0) { @@ -100519,7 +100519,7 @@ func X__wcsxfrm_l(tls *TLS, dest uintptr, src uintptr, n Tsize_t, loc Tlocale_t) } else { if n != 0 { Xwmemcpy(tls, dest, src, n-uint64(1)) - *(*Twchar_t)(unsafe.Pointer(dest + uintptr(n-uint64(1))*4)) = 0 + **(**Twchar_t)(__ccgo_up(dest + uintptr(n-uint64(1))*4)) = 0 } } return l @@ -100550,7 +100550,7 @@ func Xreallocarray(tls *TLS, ptr uintptr, m Tsize_t, n Tsize_t) (r uintptr) { defer func() { trc("-> %v", r) }() } if n != 0 && m > Uint64FromInt32(-Int32FromInt32(1))/n { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return uintptr(0) } return Xrealloc(tls, ptr, m*n) @@ -100943,25 +100943,25 @@ func X__rem_pio2(tls *TLS, x float64, y uintptr) (r1 int32) { if ix <= uint32(0x4002d97c) { /* |x| ~<= 3pi/4 */ if !(sign != 0) { z = x - _pio2_1 /* one round good to 85 bits */ - *(*float64)(unsafe.Pointer(y)) = z - _pio2_1t - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) - _pio2_1t + **(**float64)(__ccgo_up(y)) = z - _pio2_1t + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) - _pio2_1t return int32(1) } else { z = x + _pio2_1 - *(*float64)(unsafe.Pointer(y)) = z + _pio2_1t - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) + _pio2_1t + **(**float64)(__ccgo_up(y)) = z + _pio2_1t + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) + _pio2_1t return -int32(1) } } else { if !(sign != 0) { z = x - float64(Float64FromInt32(2)*_pio2_1) - *(*float64)(unsafe.Pointer(y)) = z - Tdouble_t(Float64FromInt32(2)*_pio2_1t) - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) - Tdouble_t(Float64FromInt32(2)*_pio2_1t) + **(**float64)(__ccgo_up(y)) = z - Tdouble_t(Float64FromInt32(2)*_pio2_1t) + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) - Tdouble_t(Float64FromInt32(2)*_pio2_1t) return int32(2) } else { z = x + float64(Float64FromInt32(2)*_pio2_1) - *(*float64)(unsafe.Pointer(y)) = z + Tdouble_t(Float64FromInt32(2)*_pio2_1t) - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) + Tdouble_t(Float64FromInt32(2)*_pio2_1t) + **(**float64)(__ccgo_up(y)) = z + Tdouble_t(Float64FromInt32(2)*_pio2_1t) + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) + Tdouble_t(Float64FromInt32(2)*_pio2_1t) return -int32(2) } } @@ -100973,13 +100973,13 @@ func X__rem_pio2(tls *TLS, x float64, y uintptr) (r1 int32) { } if !(sign != 0) { z = x - float64(Float64FromInt32(3)*_pio2_1) - *(*float64)(unsafe.Pointer(y)) = z - Tdouble_t(Float64FromInt32(3)*_pio2_1t) - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) - Tdouble_t(Float64FromInt32(3)*_pio2_1t) + **(**float64)(__ccgo_up(y)) = z - Tdouble_t(Float64FromInt32(3)*_pio2_1t) + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) - Tdouble_t(Float64FromInt32(3)*_pio2_1t) return int32(3) } else { z = x + float64(Float64FromInt32(3)*_pio2_1) - *(*float64)(unsafe.Pointer(y)) = z + Tdouble_t(Float64FromInt32(3)*_pio2_1t) - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) + Tdouble_t(Float64FromInt32(3)*_pio2_1t) + **(**float64)(__ccgo_up(y)) = z + Tdouble_t(Float64FromInt32(3)*_pio2_1t) + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) + Tdouble_t(Float64FromInt32(3)*_pio2_1t) return -int32(3) } } else { @@ -100988,13 +100988,13 @@ func X__rem_pio2(tls *TLS, x float64, y uintptr) (r1 int32) { } if !(sign != 0) { z = x - float64(Float64FromInt32(4)*_pio2_1) - *(*float64)(unsafe.Pointer(y)) = z - Tdouble_t(Float64FromInt32(4)*_pio2_1t) - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) - Tdouble_t(Float64FromInt32(4)*_pio2_1t) + **(**float64)(__ccgo_up(y)) = z - Tdouble_t(Float64FromInt32(4)*_pio2_1t) + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) - Tdouble_t(Float64FromInt32(4)*_pio2_1t) return int32(4) } else { z = x + float64(Float64FromInt32(4)*_pio2_1) - *(*float64)(unsafe.Pointer(y)) = z + Tdouble_t(Float64FromInt32(4)*_pio2_1t) - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) + Tdouble_t(Float64FromInt32(4)*_pio2_1t) + **(**float64)(__ccgo_up(y)) = z + Tdouble_t(Float64FromInt32(4)*_pio2_1t) + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) + Tdouble_t(Float64FromInt32(4)*_pio2_1t) return -int32(4) } } @@ -101024,8 +101024,8 @@ medium: w = Tdouble_t(fn * _pio2_1t) } } - *(*float64)(unsafe.Pointer(y)) = r - w - *(*float64)(unsafe.Pointer(bp)) = *(*float64)(unsafe.Pointer(y)) + **(**float64)(__ccgo_up(y)) = r - w + *(*float64)(unsafe.Pointer(bp)) = **(**float64)(__ccgo_up(y)) ey = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(52) & uint64(0x7ff)) ex = Int32FromUint32(ix >> int32(20)) if ex-ey > int32(16) { /* 2nd round, good to 118 bits */ @@ -101033,18 +101033,18 @@ medium: w = Tdouble_t(fn * _pio2_2) r = t - w w = Tdouble_t(fn*_pio2_2t) - (t - r - w) - *(*float64)(unsafe.Pointer(y)) = r - w - *(*float64)(unsafe.Pointer(bp)) = *(*float64)(unsafe.Pointer(y)) + **(**float64)(__ccgo_up(y)) = r - w + *(*float64)(unsafe.Pointer(bp)) = **(**float64)(__ccgo_up(y)) ey = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(52) & uint64(0x7ff)) if ex-ey > int32(49) { /* 3rd round, good to 151 bits, covers all cases */ t = r w = Tdouble_t(fn * _pio2_3) r = t - w w = Tdouble_t(fn*_pio2_3t) - (t - r - w) - *(*float64)(unsafe.Pointer(y)) = r - w + **(**float64)(__ccgo_up(y)) = r - w } } - *(*float64)(unsafe.Pointer(y + 1*8)) = r - *(*float64)(unsafe.Pointer(y)) - w + **(**float64)(__ccgo_up(y + 1*8)) = r - **(**float64)(__ccgo_up(y)) - w return n _1: ; @@ -101053,8 +101053,8 @@ _1: */ if ix >= uint32(0x7ff00000) { /* x is inf or NaN */ v2 = x - x - *(*float64)(unsafe.Pointer(y + 1*8)) = v2 - *(*float64)(unsafe.Pointer(y)) = v2 + **(**float64)(__ccgo_up(y + 1*8)) = v2 + **(**float64)(__ccgo_up(y)) = v2 return 0 } /* set z = scalbn(|x|,-ilogb(x)+23) */ @@ -101067,26 +101067,26 @@ _1: if !(i < int32(2)) { break } - (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i] = float64(int32(z)) - z = Tdouble_t((z - (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i]) * float64(1.6777216e+07)) + (**(**[3]float64)(__ccgo_up(bp + 8)))[i] = float64(int32(z)) + z = Tdouble_t((z - (**(**[3]float64)(__ccgo_up(bp + 8)))[i]) * float64(1.6777216e+07)) goto _3 _3: ; i = i + 1 } - (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i] = z + (**(**[3]float64)(__ccgo_up(bp + 8)))[i] = z /* skip zero terms, first term is non-zero */ - for (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i] == float64(0) { + for (**(**[3]float64)(__ccgo_up(bp + 8)))[i] == float64(0) { i = i - 1 } n = X__rem_pio2_large(tls, bp+8, bp+32, Int32FromUint32(ix>>Int32FromInt32(20))-(Int32FromInt32(0x3ff)+Int32FromInt32(23)), i+int32(1), int32(1)) if sign != 0 { - *(*float64)(unsafe.Pointer(y)) = -(*(*[2]float64)(unsafe.Pointer(bp + 32)))[0] - *(*float64)(unsafe.Pointer(y + 1*8)) = -(*(*[2]float64)(unsafe.Pointer(bp + 32)))[int32(1)] + **(**float64)(__ccgo_up(y)) = -(**(**[2]float64)(__ccgo_up(bp + 32)))[0] + **(**float64)(__ccgo_up(y + 1*8)) = -(**(**[2]float64)(__ccgo_up(bp + 32)))[int32(1)] return -n } - *(*float64)(unsafe.Pointer(y)) = (*(*[2]float64)(unsafe.Pointer(bp + 32)))[0] - *(*float64)(unsafe.Pointer(y + 1*8)) = (*(*[2]float64)(unsafe.Pointer(bp + 32)))[int32(1)] + **(**float64)(__ccgo_up(y)) = (**(**[2]float64)(__ccgo_up(bp + 32)))[0] + **(**float64)(__ccgo_up(y + 1*8)) = (**(**[2]float64)(__ccgo_up(bp + 32)))[int32(1)] return n } @@ -101248,7 +101248,7 @@ func X__rem_pio2_large(tls *TLS, x uintptr, y uintptr, e0 int32, nx int32, prec if !(j <= jx) { break } - fw = fw + float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8))*f[jx+i-j]) + fw = fw + float64(**(**float64)(__ccgo_up(x + uintptr(j)*8))*f[jx+i-j]) goto _4 _4: ; @@ -101273,7 +101273,7 @@ recompute: break } fw = float64(int32(float64(Float64FromFloat64(5.960464477539063e-08) * z))) - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] = int32(z - float64(Float64FromFloat64(1.6777216e+07)*fw)) + (**(**[20]Tint32_t)(__ccgo_up(bp)))[i] = int32(z - float64(Float64FromFloat64(1.6777216e+07)*fw)) z = q[j-int32(1)] + fw goto _5 _5: @@ -101288,13 +101288,13 @@ recompute: z = z - float64(n) ih = 0 if q0 > 0 { /* need iq[jz-1] to determine n */ - i = (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz-int32(1)] >> (int32(24) - q0) + i = (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz-int32(1)] >> (int32(24) - q0) n = n + i - *(*Tint32_t)(unsafe.Pointer(bp + uintptr(jz-int32(1))*4)) -= i << (int32(24) - q0) - ih = (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz-int32(1)] >> (int32(23) - q0) + **(**Tint32_t)(__ccgo_up(bp + uintptr(jz-int32(1))*4)) -= i << (int32(24) - q0) + ih = (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz-int32(1)] >> (int32(23) - q0) } else { if q0 == 0 { - ih = (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz-int32(1)] >> int32(23) + ih = (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz-int32(1)] >> int32(23) } else { if z >= float64(0.5) { ih = int32(2) @@ -101309,14 +101309,14 @@ recompute: if !(i < jz) { break } /* compute 1-q */ - j = (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] + j = (**(**[20]Tint32_t)(__ccgo_up(bp)))[i] if carry == 0 { if j != 0 { carry = int32(1) - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] = int32(0x1000000) - j + (**(**[20]Tint32_t)(__ccgo_up(bp)))[i] = int32(0x1000000) - j } } else { - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] = int32(0xffffff) - j + (**(**[20]Tint32_t)(__ccgo_up(bp)))[i] = int32(0xffffff) - j } goto _6 _6: @@ -101326,9 +101326,9 @@ recompute: if q0 > 0 { /* rare case: chance is 1 in 12 */ switch q0 { case int32(1): - *(*Tint32_t)(unsafe.Pointer(bp + uintptr(jz-int32(1))*4)) &= int32(0x7fffff) + **(**Tint32_t)(__ccgo_up(bp + uintptr(jz-int32(1))*4)) &= int32(0x7fffff) case int32(2): - *(*Tint32_t)(unsafe.Pointer(bp + uintptr(jz-int32(1))*4)) &= int32(0x3fffff) + **(**Tint32_t)(__ccgo_up(bp + uintptr(jz-int32(1))*4)) &= int32(0x3fffff) break } } @@ -101347,7 +101347,7 @@ recompute: if !(i >= jk) { break } - j = j | (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] + j = j | (**(**[20]Tint32_t)(__ccgo_up(bp)))[i] goto _7 _7: ; @@ -101356,7 +101356,7 @@ recompute: if j == 0 { /* need recomputation */ k = int32(1) for { - if !((*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jk-k] == 0) { + if !((**(**[20]Tint32_t)(__ccgo_up(bp)))[jk-k] == 0) { break } goto _8 @@ -101376,7 +101376,7 @@ recompute: if !(j <= jx) { break } - fw = fw + float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8))*f[jx+i-j]) + fw = fw + float64(**(**float64)(__ccgo_up(x + uintptr(j)*8))*f[jx+i-j]) goto _10 _10: ; @@ -101396,7 +101396,7 @@ recompute: if z == float64(0) { jz = jz - int32(1) q0 = q0 - int32(24) - for (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] == 0 { + for (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz] == 0 { jz = jz - 1 q0 = q0 - int32(24) } @@ -101404,12 +101404,12 @@ recompute: z = Xscalbn(tls, z, -q0) if z >= float64(1.6777216e+07) { fw = float64(int32(float64(Float64FromFloat64(5.960464477539063e-08) * z))) - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(z - float64(Float64FromFloat64(1.6777216e+07)*fw)) + (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz] = int32(z - float64(Float64FromFloat64(1.6777216e+07)*fw)) jz = jz + int32(1) q0 = q0 + int32(24) - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(fw) + (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz] = int32(fw) } else { - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(z) + (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz] = int32(z) } } /* convert integer "bit" chunk to floating-point value */ @@ -101419,7 +101419,7 @@ recompute: if !(i >= 0) { break } - q[i] = float64(fw * float64((*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i])) + q[i] = float64(fw * float64((**(**[20]Tint32_t)(__ccgo_up(bp)))[i])) fw = fw * float64(5.960464477539063e-08) goto _11 _11: @@ -101444,7 +101444,7 @@ recompute: ; k = k + 1 } - (*(*[20]float64)(unsafe.Pointer(bp + 80)))[jz-i] = fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[jz-i] = fw goto _12 _12: ; @@ -101470,7 +101470,7 @@ _14: if !(i >= 0) { break } - fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[i] goto _19 _19: ; @@ -101481,7 +101481,7 @@ _14: } else { v2 = -fw } - *(*float64)(unsafe.Pointer(y)) = v2 + **(**float64)(__ccgo_up(y)) = v2 goto _18 _16: ; @@ -101493,7 +101493,7 @@ _15: if !(i >= 0) { break } - fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[i] goto _21 _21: ; @@ -101506,14 +101506,14 @@ _15: } else { v2 = -fw } - *(*float64)(unsafe.Pointer(y)) = v2 - fw = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[0] - fw + **(**float64)(__ccgo_up(y)) = v2 + fw = (**(**[20]float64)(__ccgo_up(bp + 80)))[0] - fw i = int32(1) for { if !(i <= jz) { break } - fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[i] goto _23 _23: ; @@ -101524,7 +101524,7 @@ _15: } else { v2 = -fw } - *(*float64)(unsafe.Pointer(y + 1*8)) = v2 + **(**float64)(__ccgo_up(y + 1*8)) = v2 goto _18 _17: ; /* painful */ @@ -101534,9 +101534,9 @@ _27: if !(i > 0) { goto _25 } - fw = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i-int32(1)] + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] - *(*float64)(unsafe.Pointer(bp + 80 + uintptr(i)*8)) += (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i-int32(1)] - fw - (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i-int32(1)] = fw + fw = (**(**[20]float64)(__ccgo_up(bp + 80)))[i-int32(1)] + (**(**[20]float64)(__ccgo_up(bp + 80)))[i] + **(**float64)(__ccgo_up(bp + 80 + uintptr(i)*8)) += (**(**[20]float64)(__ccgo_up(bp + 80)))[i-int32(1)] - fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[i-int32(1)] = fw goto _26 _26: ; @@ -101550,9 +101550,9 @@ _25: if !(i > int32(1)) { break } - fw = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i-int32(1)] + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] - *(*float64)(unsafe.Pointer(bp + 80 + uintptr(i)*8)) += (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i-int32(1)] - fw - (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i-int32(1)] = fw + fw = (**(**[20]float64)(__ccgo_up(bp + 80)))[i-int32(1)] + (**(**[20]float64)(__ccgo_up(bp + 80)))[i] + **(**float64)(__ccgo_up(bp + 80 + uintptr(i)*8)) += (**(**[20]float64)(__ccgo_up(bp + 80)))[i-int32(1)] - fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[i-int32(1)] = fw goto _28 _28: ; @@ -101564,20 +101564,20 @@ _25: if !(i >= int32(2)) { break } - fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[i] goto _29 _29: ; i = i - 1 } if ih == 0 { - *(*float64)(unsafe.Pointer(y)) = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[0] - *(*float64)(unsafe.Pointer(y + 1*8)) = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[int32(1)] - *(*float64)(unsafe.Pointer(y + 2*8)) = fw + **(**float64)(__ccgo_up(y)) = (**(**[20]float64)(__ccgo_up(bp + 80)))[0] + **(**float64)(__ccgo_up(y + 1*8)) = (**(**[20]float64)(__ccgo_up(bp + 80)))[int32(1)] + **(**float64)(__ccgo_up(y + 2*8)) = fw } else { - *(*float64)(unsafe.Pointer(y)) = -(*(*[20]float64)(unsafe.Pointer(bp + 80)))[0] - *(*float64)(unsafe.Pointer(y + 1*8)) = -(*(*[20]float64)(unsafe.Pointer(bp + 80)))[int32(1)] - *(*float64)(unsafe.Pointer(y + 2*8)) = -fw + **(**float64)(__ccgo_up(y)) = -(**(**[20]float64)(__ccgo_up(bp + 80)))[0] + **(**float64)(__ccgo_up(y + 1*8)) = -(**(**[20]float64)(__ccgo_up(bp + 80)))[int32(1)] + **(**float64)(__ccgo_up(y + 2*8)) = -fw } _18: ; @@ -101631,36 +101631,36 @@ func X__rem_pio2f(tls *TLS, x float32, y uintptr) (r int32) { /* Use a specialized rint() to get fn. */ fn = Tdouble_t(float64(x)*_invpio21) + _toint1 - _toint1 n = int32(fn) - *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) + **(**float64)(__ccgo_up(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) /* Matters with directed rounding. */ - if *(*float64)(unsafe.Pointer(y)) < -_pio41 { + if **(**float64)(__ccgo_up(y)) < -_pio41 { n = n - 1 fn = fn - 1 - *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) + **(**float64)(__ccgo_up(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) } else { - if *(*float64)(unsafe.Pointer(y)) > _pio41 { + if **(**float64)(__ccgo_up(y)) > _pio41 { n = n + 1 fn = fn + 1 - *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) + **(**float64)(__ccgo_up(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) } } return n } if ix >= uint32(0x7f800000) { /* x is inf or NaN */ - *(*float64)(unsafe.Pointer(y)) = float64(x - x) + **(**float64)(__ccgo_up(y)) = float64(x - x) return 0 } /* scale x into [2^23, 2^24-1] */ sign = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(bp)) >> int32(31)) e0 = Int32FromUint32(ix>>Int32FromInt32(23) - Uint32FromInt32(Int32FromInt32(0x7f)+Int32FromInt32(23))) /* e0 = ilogb(|x|)-23, positive */ *(*Tuint32_t)(unsafe.Pointer(bp)) = ix - Uint32FromInt32(e0<>int32(52)&uint64(0x7ff) < Uint64FromInt32(Int32FromInt32(0x3ff)+Int32FromInt32(4)) { if !(y != 0) { - return _p10[int32(*(*float64)(unsafe.Pointer(bp)))+int32(15)] + return _p10[int32(**(**float64)(__ccgo_up(bp)))+int32(15)] } y = Xexp2(tls, float64(float64(3.321928094887362)*y)) - return float64(y * _p10[int32(*(*float64)(unsafe.Pointer(bp)))+int32(15)]) + return float64(y * _p10[int32(**(**float64)(__ccgo_up(bp)))+int32(15)]) } return Xpow(tls, float64(10), x) } @@ -104309,14 +104309,14 @@ func Xexp10f(tls *TLS, x float32) (r float32) { Fi [0]Tuint32_t Ff float32 }{} - *(*float32)(unsafe.Pointer(bp + 4)) = *(*float32)(unsafe.Pointer(bp)) + *(*float32)(unsafe.Pointer(bp + 4)) = **(**float32)(__ccgo_up(bp)) /* fabsf(n) < 8 without raising invalid on nan */ if *(*Tuint32_t)(unsafe.Pointer(bp + 4))>>int32(23)&uint32(0xff) < Uint32FromInt32(Int32FromInt32(0x7f)+Int32FromInt32(3)) { if !(y != 0) { - return _p101[int32(*(*float32)(unsafe.Pointer(bp)))+int32(7)] + return _p101[int32(**(**float32)(__ccgo_up(bp)))+int32(7)] } y = Xexp2f(tls, float32(Float32FromFloat32(3.321928094887362)*y)) - return float32(y * _p101[int32(*(*float32)(unsafe.Pointer(bp)))+int32(7)]) + return float32(y * _p101[int32(**(**float32)(__ccgo_up(bp)))+int32(7)]) } return float32(Xexp2(tls, float64(float64(3.321928094887362)*float64(x)))) } @@ -104480,16 +104480,16 @@ _5: /* 2^(k/N) ~= scale * (1 + tail). */ idx = uint64(2) * (ki % Uint64FromInt32(Int32FromInt32(1)<>Int32FromInt32(32) + BoolUint64(t1 > *(*Tuint64_t)(unsafe.Pointer(lo))) + **(**Tuint64_t)(__ccgo_up(lo)) = t1 + t2<>Int32FromInt32(32) + BoolUint64(t1 > **(**Tuint64_t)(__ccgo_up(lo))) } func Xfma(tls *TLS, x1 float64, y1 float64, z float64) (r2 float64) { @@ -105395,11 +105395,11 @@ func Xfma(tls *TLS, x1 float64, y1 float64, z float64) (r2 float64) { if d == 0 { } else { if d < int32(64) { - *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = *(*Tuint64_t)(unsafe.Pointer(bp))<<(int32(64)-d) | *(*Tuint64_t)(unsafe.Pointer(bp + 8))>>d | BoolUint64(!!(*(*Tuint64_t)(unsafe.Pointer(bp + 8))<<(Int32FromInt32(64)-d) != 0)) - *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp)) >> d + **(**Tuint64_t)(__ccgo_up(bp + 8)) = **(**Tuint64_t)(__ccgo_up(bp))<<(int32(64)-d) | **(**Tuint64_t)(__ccgo_up(bp + 8))>>d | BoolUint64(!!(**(**Tuint64_t)(__ccgo_up(bp + 8))<<(Int32FromInt32(64)-d) != 0)) + **(**Tuint64_t)(__ccgo_up(bp)) = **(**Tuint64_t)(__ccgo_up(bp)) >> d } else { - *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = uint64(1) - *(*Tuint64_t)(unsafe.Pointer(bp)) = uint64(0) + **(**Tuint64_t)(__ccgo_up(bp + 8)) = uint64(1) + **(**Tuint64_t)(__ccgo_up(bp)) = uint64(0) } } } @@ -105422,24 +105422,24 @@ func Xfma(tls *TLS, x1 float64, y1 float64, z float64) (r2 float64) { nonzero = int32(1) if samesign != 0 { /* r += z */ - *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) + zlo - *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp)) + (zhi + BoolUint64(*(*Tuint64_t)(unsafe.Pointer(bp + 8)) < zlo)) + **(**Tuint64_t)(__ccgo_up(bp + 8)) = **(**Tuint64_t)(__ccgo_up(bp + 8)) + zlo + **(**Tuint64_t)(__ccgo_up(bp)) = **(**Tuint64_t)(__ccgo_up(bp)) + (zhi + BoolUint64(**(**Tuint64_t)(__ccgo_up(bp + 8)) < zlo)) } else { /* r -= z */ - t = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) - *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) - zlo - *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp)) - zhi - BoolUint64(t < *(*Tuint64_t)(unsafe.Pointer(bp + 8))) - if *(*Tuint64_t)(unsafe.Pointer(bp))>>int32(63) != 0 { - *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = -*(*Tuint64_t)(unsafe.Pointer(bp + 8)) - *(*Tuint64_t)(unsafe.Pointer(bp)) = -*(*Tuint64_t)(unsafe.Pointer(bp)) - BoolUint64(!!(*(*Tuint64_t)(unsafe.Pointer(bp + 8)) != 0)) + t = **(**Tuint64_t)(__ccgo_up(bp + 8)) + **(**Tuint64_t)(__ccgo_up(bp + 8)) = **(**Tuint64_t)(__ccgo_up(bp + 8)) - zlo + **(**Tuint64_t)(__ccgo_up(bp)) = **(**Tuint64_t)(__ccgo_up(bp)) - zhi - BoolUint64(t < **(**Tuint64_t)(__ccgo_up(bp + 8))) + if **(**Tuint64_t)(__ccgo_up(bp))>>int32(63) != 0 { + **(**Tuint64_t)(__ccgo_up(bp + 8)) = -**(**Tuint64_t)(__ccgo_up(bp + 8)) + **(**Tuint64_t)(__ccgo_up(bp)) = -**(**Tuint64_t)(__ccgo_up(bp)) - BoolUint64(!!(**(**Tuint64_t)(__ccgo_up(bp + 8)) != 0)) sign = BoolInt32(!(sign != 0)) } - nonzero = BoolInt32(!!(*(*Tuint64_t)(unsafe.Pointer(bp)) != 0)) + nonzero = BoolInt32(!!(**(**Tuint64_t)(__ccgo_up(bp)) != 0)) } /* set rhi to top 63bit of the result (last bit is sticky) */ if nonzero != 0 { e = e + int32(64) - v1 = *(*Tuint64_t)(unsafe.Pointer(bp)) + v1 = **(**Tuint64_t)(__ccgo_up(bp)) if v1>>Int32FromInt32(32) != 0 { y = uint32(v1 >> int32(32)) r = Int32FromInt32(0) @@ -105472,10 +105472,10 @@ func Xfma(tls *TLS, x1 float64, y1 float64, z float64) (r2 float64) { _3: d = v2 - int32(1) /* note: d > 0 */ - *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp))<>(int32(64)-d) | BoolUint64(!!(*(*Tuint64_t)(unsafe.Pointer(bp + 8))<>(int32(64)-d) | BoolUint64(!!(**(**Tuint64_t)(__ccgo_up(bp + 8))<>Int32FromInt32(32) != 0 { y = uint32(v1 >> int32(32)) r = Int32FromInt32(0) @@ -105508,9 +105508,9 @@ func Xfma(tls *TLS, x1 float64, y1 float64, z float64) (r2 float64) { _6: d = v2 - int32(1) if d < 0 { - *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp + 8))>>int32(1) | *(*Tuint64_t)(unsafe.Pointer(bp + 8))&uint64(1) + **(**Tuint64_t)(__ccgo_up(bp)) = **(**Tuint64_t)(__ccgo_up(bp + 8))>>int32(1) | **(**Tuint64_t)(__ccgo_up(bp + 8))&uint64(1) } else { - *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) << d + **(**Tuint64_t)(__ccgo_up(bp)) = **(**Tuint64_t)(__ccgo_up(bp + 8)) << d } } else { /* exact +-0 */ @@ -105519,7 +105519,7 @@ func Xfma(tls *TLS, x1 float64, y1 float64, z float64) (r2 float64) { } e = e - d /* convert to double */ - i = Int64FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp))) /* i is in [1<<62,(1<<63)-1] */ + i = Int64FromUint64(**(**Tuint64_t)(__ccgo_up(bp))) /* i is in [1<<62,(1<<63)-1] */ if sign != 0 { i = -i } @@ -105540,8 +105540,8 @@ func Xfma(tls *TLS, x1 float64, y1 float64, z float64) (r2 float64) { } /* one bit is lost when scaled, add another top bit to only round once at conversion if it is inexact */ - if *(*Tuint64_t)(unsafe.Pointer(bp))<>int32(1) | *(*Tuint64_t)(unsafe.Pointer(bp))&uint64(1) | Uint64FromUint64(1)<>int32(1)|**(**Tuint64_t)(__ccgo_up(bp))&uint64(1)) | Uint64FromUint64(1)<>d | BoolUint64(!!(*(*Tuint64_t)(unsafe.Pointer(bp))<<(Int32FromInt32(64)-d) != 0))) << d) + i = Int64FromUint64((**(**Tuint64_t)(__ccgo_up(bp))>>d | BoolUint64(!!(**(**Tuint64_t)(__ccgo_up(bp))<<(Int32FromInt32(64)-d) != 0))) << d) if sign != 0 { i = -i } @@ -106141,9 +106141,9 @@ func Xfrexp(tls *TLS, x float64, e uintptr) (r float64) { if !(ee != 0) { if x != 0 { x = Xfrexp(tls, float64(x*float64(1.8446744073709552e+19)), e) - *(*int32)(unsafe.Pointer(e)) -= int32(64) + **(**int32)(__ccgo_up(e)) -= int32(64) } else { - *(*int32)(unsafe.Pointer(e)) = 0 + **(**int32)(__ccgo_up(e)) = 0 } return x } else { @@ -106151,7 +106151,7 @@ func Xfrexp(tls *TLS, x float64, e uintptr) (r float64) { return x } } - *(*int32)(unsafe.Pointer(e)) = ee - int32(0x3fe) + **(**int32)(__ccgo_up(e)) = ee - int32(0x3fe) v1 = bp *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & Uint64FromUint64(0x800fffffffffffff)) v1 = bp @@ -106185,9 +106185,9 @@ func Xfrexpf(tls *TLS, x float32, e uintptr) (r float32) { if !(ee != 0) { if x != 0 { x = Xfrexpf(tls, float32(float64(x)*float64(1.8446744073709552e+19)), e) - *(*int32)(unsafe.Pointer(e)) -= int32(64) + **(**int32)(__ccgo_up(e)) -= int32(64) } else { - *(*int32)(unsafe.Pointer(e)) = 0 + **(**int32)(__ccgo_up(e)) = 0 } return x } else { @@ -106195,7 +106195,7 @@ func Xfrexpf(tls *TLS, x float32, e uintptr) (r float32) { return x } } - *(*int32)(unsafe.Pointer(e)) = ee - int32(0x7e) + **(**int32)(__ccgo_up(e)) = ee - int32(0x7e) v1 = bp *(*Tuint32_t)(unsafe.Pointer(v1)) = Tuint32_t(uint64(*(*Tuint32_t)(unsafe.Pointer(v1))) & Uint64FromUint64(0x807fffff)) v1 = bp @@ -106219,8 +106219,8 @@ func _sq(tls *TLS, hi uintptr, lo uintptr, x float64) { xc = Tdouble_t(x * (Float64FromFloat64(1.34217728e+08) + Float64FromInt32(1))) xh = x - xc + xc xl = x - xh - *(*Tdouble_t)(unsafe.Pointer(hi)) = Tdouble_t(x * x) - *(*Tdouble_t)(unsafe.Pointer(lo)) = Tdouble_t(xh*xh) - *(*Tdouble_t)(unsafe.Pointer(hi)) + Tdouble_t(Tdouble_t(Float64FromInt32(2)*xh)*xl) + Tdouble_t(xl*xl) + **(**Tdouble_t)(__ccgo_up(hi)) = Tdouble_t(x * x) + **(**Tdouble_t)(__ccgo_up(lo)) = Tdouble_t(xh*xh) - **(**Tdouble_t)(__ccgo_up(hi)) + Tdouble_t(Tdouble_t(Float64FromInt32(2)*xh)*xl) + Tdouble_t(xl*xl) } func Xhypot(tls *TLS, x float64, y float64) (r float64) { @@ -106272,21 +106272,21 @@ func Xhypot(tls *TLS, x float64, y float64) (r float64) { v1 = bp + 8 *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & (-Uint64FromUint64(1) >> Int32FromInt32(1))) if *(*Tuint64_t)(unsafe.Pointer(bp)) < *(*Tuint64_t)(unsafe.Pointer(bp + 8)) { - ut = *(*struct { + ut = **(**struct { Fi [0]Tuint64_t Ff float64 - })(unsafe.Pointer(bp)) - *(*struct { + })(__ccgo_up(bp)) + **(**struct { Fi [0]Tuint64_t Ff float64 - })(unsafe.Pointer(bp)) = *(*struct { + })(__ccgo_up(bp)) = **(**struct { Fi [0]Tuint64_t Ff float64 - })(unsafe.Pointer(bp + 8)) - *(*struct { + })(__ccgo_up(bp + 8)) + **(**struct { Fi [0]Tuint64_t Ff float64 - })(unsafe.Pointer(bp + 8)) = ut + })(__ccgo_up(bp + 8)) = ut } /* special cases */ ex = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(52)) @@ -106321,7 +106321,7 @@ func Xhypot(tls *TLS, x float64, y float64) (r float64) { } _sq(tls, bp+16, bp+24, x) _sq(tls, bp+32, bp+40, y) - return float64(z * Xsqrt(tls, *(*Tdouble_t)(unsafe.Pointer(bp + 40))+*(*Tdouble_t)(unsafe.Pointer(bp + 24))+*(*Tdouble_t)(unsafe.Pointer(bp + 32))+*(*Tdouble_t)(unsafe.Pointer(bp + 16)))) + return float64(z * Xsqrt(tls, **(**Tdouble_t)(__ccgo_up(bp + 40))+**(**Tdouble_t)(__ccgo_up(bp + 24))+**(**Tdouble_t)(__ccgo_up(bp + 32))+**(**Tdouble_t)(__ccgo_up(bp + 16)))) } func Xhypotf(tls *TLS, x float32, y float32) (r float32) { @@ -106364,21 +106364,21 @@ func Xhypotf(tls *TLS, x float32, y float32) (r float32) { *(*Tuint32_t)(unsafe.Pointer(bp)) &= -Uint32FromUint32(1) >> Int32FromInt32(1) *(*Tuint32_t)(unsafe.Pointer(bp + 4)) &= -Uint32FromUint32(1) >> Int32FromInt32(1) if *(*Tuint32_t)(unsafe.Pointer(bp)) < *(*Tuint32_t)(unsafe.Pointer(bp + 4)) { - ut = *(*struct { + ut = **(**struct { Fi [0]Tuint32_t Ff float32 - })(unsafe.Pointer(bp)) - *(*struct { + })(__ccgo_up(bp)) + **(**struct { Fi [0]Tuint32_t Ff float32 - })(unsafe.Pointer(bp)) = *(*struct { + })(__ccgo_up(bp)) = **(**struct { Fi [0]Tuint32_t Ff float32 - })(unsafe.Pointer(bp + 4)) - *(*struct { + })(__ccgo_up(bp + 4)) + **(**struct { Fi [0]Tuint32_t Ff float32 - })(unsafe.Pointer(bp + 4)) = ut + })(__ccgo_up(bp + 4)) = ut } x = *(*float32)(unsafe.Pointer(bp)) y = *(*float32)(unsafe.Pointer(bp + 4)) @@ -106806,8 +106806,8 @@ func _pzero(tls *TLS, x float64) (r1 float64) { } } z = float64(1) / float64(x*x) - r = *(*float64)(unsafe.Pointer(p)) + float64(z*(*(*float64)(unsafe.Pointer(p + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 4*8))+float64(z**(*float64)(unsafe.Pointer(p + 5*8))))))))))) - s = float64(1) + float64(z*(*(*float64)(unsafe.Pointer(q))+float64(z*(*(*float64)(unsafe.Pointer(q + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 3*8))+float64(z**(*float64)(unsafe.Pointer(q + 4*8))))))))))) + r = **(**float64)(__ccgo_up(p)) + float64(z*(**(**float64)(__ccgo_up(p + 1*8))+float64(z*(**(**float64)(__ccgo_up(p + 2*8))+float64(z*(**(**float64)(__ccgo_up(p + 3*8))+float64(z*(**(**float64)(__ccgo_up(p + 4*8))+float64(z***(**float64)(__ccgo_up(p + 5*8))))))))))) + s = float64(1) + float64(z*(**(**float64)(__ccgo_up(q))+float64(z*(**(**float64)(__ccgo_up(q + 1*8))+float64(z*(**(**float64)(__ccgo_up(q + 2*8))+float64(z*(**(**float64)(__ccgo_up(q + 3*8))+float64(z***(**float64)(__ccgo_up(q + 4*8))))))))))) return float64(1) + r/s } @@ -106914,8 +106914,8 @@ func _qzero(tls *TLS, x float64) (r1 float64) { } } z = float64(1) / float64(x*x) - r = *(*float64)(unsafe.Pointer(p)) + float64(z*(*(*float64)(unsafe.Pointer(p + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 4*8))+float64(z**(*float64)(unsafe.Pointer(p + 5*8))))))))))) - s = float64(1) + float64(z*(*(*float64)(unsafe.Pointer(q))+float64(z*(*(*float64)(unsafe.Pointer(q + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 4*8))+float64(z**(*float64)(unsafe.Pointer(q + 5*8))))))))))))) + r = **(**float64)(__ccgo_up(p)) + float64(z*(**(**float64)(__ccgo_up(p + 1*8))+float64(z*(**(**float64)(__ccgo_up(p + 2*8))+float64(z*(**(**float64)(__ccgo_up(p + 3*8))+float64(z*(**(**float64)(__ccgo_up(p + 4*8))+float64(z***(**float64)(__ccgo_up(p + 5*8))))))))))) + s = float64(1) + float64(z*(**(**float64)(__ccgo_up(q))+float64(z*(**(**float64)(__ccgo_up(q + 1*8))+float64(z*(**(**float64)(__ccgo_up(q + 2*8))+float64(z*(**(**float64)(__ccgo_up(q + 3*8))+float64(z*(**(**float64)(__ccgo_up(q + 4*8))+float64(z***(**float64)(__ccgo_up(q + 5*8))))))))))))) return (-Float64FromFloat64(0.125) + r/s) / x } @@ -107139,8 +107139,8 @@ func _pzerof(tls *TLS, x float32) (r1 float32) { } } z = Float32FromFloat32(1) / float32(x*x) - r = *(*float32)(unsafe.Pointer(p)) + float32(z*(*(*float32)(unsafe.Pointer(p + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 3*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 4*4))+float32(z**(*float32)(unsafe.Pointer(p + 5*4))))))))))) - s = Float32FromFloat32(1) + float32(z*(*(*float32)(unsafe.Pointer(q))+float32(z*(*(*float32)(unsafe.Pointer(q + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 3*4))+float32(z**(*float32)(unsafe.Pointer(q + 4*4))))))))))) + r = **(**float32)(__ccgo_up(p)) + float32(z*(**(**float32)(__ccgo_up(p + 1*4))+float32(z*(**(**float32)(__ccgo_up(p + 2*4))+float32(z*(**(**float32)(__ccgo_up(p + 3*4))+float32(z*(**(**float32)(__ccgo_up(p + 4*4))+float32(z***(**float32)(__ccgo_up(p + 5*4))))))))))) + s = Float32FromFloat32(1) + float32(z*(**(**float32)(__ccgo_up(q))+float32(z*(**(**float32)(__ccgo_up(q + 1*4))+float32(z*(**(**float32)(__ccgo_up(q + 2*4))+float32(z*(**(**float32)(__ccgo_up(q + 3*4))+float32(z***(**float32)(__ccgo_up(q + 4*4))))))))))) return Float32FromFloat32(1) + r/s } @@ -107247,8 +107247,8 @@ func _qzerof(tls *TLS, x float32) (r1 float32) { } } z = Float32FromFloat32(1) / float32(x*x) - r = *(*float32)(unsafe.Pointer(p)) + float32(z*(*(*float32)(unsafe.Pointer(p + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 3*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 4*4))+float32(z**(*float32)(unsafe.Pointer(p + 5*4))))))))))) - s = Float32FromFloat32(1) + float32(z*(*(*float32)(unsafe.Pointer(q))+float32(z*(*(*float32)(unsafe.Pointer(q + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 3*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 4*4))+float32(z**(*float32)(unsafe.Pointer(q + 5*4))))))))))))) + r = **(**float32)(__ccgo_up(p)) + float32(z*(**(**float32)(__ccgo_up(p + 1*4))+float32(z*(**(**float32)(__ccgo_up(p + 2*4))+float32(z*(**(**float32)(__ccgo_up(p + 3*4))+float32(z*(**(**float32)(__ccgo_up(p + 4*4))+float32(z***(**float32)(__ccgo_up(p + 5*4))))))))))) + s = Float32FromFloat32(1) + float32(z*(**(**float32)(__ccgo_up(q))+float32(z*(**(**float32)(__ccgo_up(q + 1*4))+float32(z*(**(**float32)(__ccgo_up(q + 2*4))+float32(z*(**(**float32)(__ccgo_up(q + 3*4))+float32(z*(**(**float32)(__ccgo_up(q + 4*4))+float32(z***(**float32)(__ccgo_up(q + 5*4))))))))))))) return (-Float32FromFloat32(0.125) + r/s) / x } @@ -107485,8 +107485,8 @@ func _pone(tls *TLS, x float64) (r1 float64) { } } z = float64(1) / float64(x*x) - r = *(*float64)(unsafe.Pointer(p)) + float64(z*(*(*float64)(unsafe.Pointer(p + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 4*8))+float64(z**(*float64)(unsafe.Pointer(p + 5*8))))))))))) - s = float64(1) + float64(z*(*(*float64)(unsafe.Pointer(q))+float64(z*(*(*float64)(unsafe.Pointer(q + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 3*8))+float64(z**(*float64)(unsafe.Pointer(q + 4*8))))))))))) + r = **(**float64)(__ccgo_up(p)) + float64(z*(**(**float64)(__ccgo_up(p + 1*8))+float64(z*(**(**float64)(__ccgo_up(p + 2*8))+float64(z*(**(**float64)(__ccgo_up(p + 3*8))+float64(z*(**(**float64)(__ccgo_up(p + 4*8))+float64(z***(**float64)(__ccgo_up(p + 5*8))))))))))) + s = float64(1) + float64(z*(**(**float64)(__ccgo_up(q))+float64(z*(**(**float64)(__ccgo_up(q + 1*8))+float64(z*(**(**float64)(__ccgo_up(q + 2*8))+float64(z*(**(**float64)(__ccgo_up(q + 3*8))+float64(z***(**float64)(__ccgo_up(q + 4*8))))))))))) return float64(1) + r/s } @@ -107592,8 +107592,8 @@ func _qone(tls *TLS, x float64) (r1 float64) { } } z = float64(1) / float64(x*x) - r = *(*float64)(unsafe.Pointer(p)) + float64(z*(*(*float64)(unsafe.Pointer(p + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 4*8))+float64(z**(*float64)(unsafe.Pointer(p + 5*8))))))))))) - s = float64(1) + float64(z*(*(*float64)(unsafe.Pointer(q))+float64(z*(*(*float64)(unsafe.Pointer(q + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 4*8))+float64(z**(*float64)(unsafe.Pointer(q + 5*8))))))))))))) + r = **(**float64)(__ccgo_up(p)) + float64(z*(**(**float64)(__ccgo_up(p + 1*8))+float64(z*(**(**float64)(__ccgo_up(p + 2*8))+float64(z*(**(**float64)(__ccgo_up(p + 3*8))+float64(z*(**(**float64)(__ccgo_up(p + 4*8))+float64(z***(**float64)(__ccgo_up(p + 5*8))))))))))) + s = float64(1) + float64(z*(**(**float64)(__ccgo_up(q))+float64(z*(**(**float64)(__ccgo_up(q + 1*8))+float64(z*(**(**float64)(__ccgo_up(q + 2*8))+float64(z*(**(**float64)(__ccgo_up(q + 3*8))+float64(z*(**(**float64)(__ccgo_up(q + 4*8))+float64(z***(**float64)(__ccgo_up(q + 5*8))))))))))))) return (float64(0.375) + r/s) / x } @@ -107816,8 +107816,8 @@ func _ponef(tls *TLS, x float32) (r1 float32) { } } z = Float32FromFloat32(1) / float32(x*x) - r = *(*float32)(unsafe.Pointer(p)) + float32(z*(*(*float32)(unsafe.Pointer(p + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 3*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 4*4))+float32(z**(*float32)(unsafe.Pointer(p + 5*4))))))))))) - s = Float32FromFloat32(1) + float32(z*(*(*float32)(unsafe.Pointer(q))+float32(z*(*(*float32)(unsafe.Pointer(q + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 3*4))+float32(z**(*float32)(unsafe.Pointer(q + 4*4))))))))))) + r = **(**float32)(__ccgo_up(p)) + float32(z*(**(**float32)(__ccgo_up(p + 1*4))+float32(z*(**(**float32)(__ccgo_up(p + 2*4))+float32(z*(**(**float32)(__ccgo_up(p + 3*4))+float32(z*(**(**float32)(__ccgo_up(p + 4*4))+float32(z***(**float32)(__ccgo_up(p + 5*4))))))))))) + s = Float32FromFloat32(1) + float32(z*(**(**float32)(__ccgo_up(q))+float32(z*(**(**float32)(__ccgo_up(q + 1*4))+float32(z*(**(**float32)(__ccgo_up(q + 2*4))+float32(z*(**(**float32)(__ccgo_up(q + 3*4))+float32(z***(**float32)(__ccgo_up(q + 4*4))))))))))) return Float32FromFloat32(1) + r/s } @@ -107923,8 +107923,8 @@ func _qonef(tls *TLS, x float32) (r1 float32) { } } z = Float32FromFloat32(1) / float32(x*x) - r = *(*float32)(unsafe.Pointer(p)) + float32(z*(*(*float32)(unsafe.Pointer(p + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 3*4))+float32(z*(*(*float32)(unsafe.Pointer(p + 4*4))+float32(z**(*float32)(unsafe.Pointer(p + 5*4))))))))))) - s = Float32FromFloat32(1) + float32(z*(*(*float32)(unsafe.Pointer(q))+float32(z*(*(*float32)(unsafe.Pointer(q + 1*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 2*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 3*4))+float32(z*(*(*float32)(unsafe.Pointer(q + 4*4))+float32(z**(*float32)(unsafe.Pointer(q + 5*4))))))))))))) + r = **(**float32)(__ccgo_up(p)) + float32(z*(**(**float32)(__ccgo_up(p + 1*4))+float32(z*(**(**float32)(__ccgo_up(p + 2*4))+float32(z*(**(**float32)(__ccgo_up(p + 3*4))+float32(z*(**(**float32)(__ccgo_up(p + 4*4))+float32(z***(**float32)(__ccgo_up(p + 5*4))))))))))) + s = Float32FromFloat32(1) + float32(z*(**(**float32)(__ccgo_up(q))+float32(z*(**(**float32)(__ccgo_up(q + 1*4))+float32(z*(**(**float32)(__ccgo_up(q + 2*4))+float32(z*(**(**float32)(__ccgo_up(q + 3*4))+float32(z*(**(**float32)(__ccgo_up(q + 4*4))+float32(z***(**float32)(__ccgo_up(q + 5*4))))))))))))) return (Float32FromFloat32(0.375) + r/s) / x } @@ -108605,7 +108605,7 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { }{} *(*float64)(unsafe.Pointer(bp)) = x /* purge off +-inf, NaN, +-0, tiny and negative arguments */ - *(*int32)(unsafe.Pointer(signgamp)) = int32(1) + **(**int32)(__ccgo_up(signgamp)) = int32(1) sign = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(63)) ix = uint32(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(32) & uint64(0x7fffffff)) if ix >= uint32(0x7ff00000) { @@ -108614,7 +108614,7 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { if ix < Uint32FromInt32((Int32FromInt32(0x3ff)-Int32FromInt32(70))< float64(0) { - *(*int32)(unsafe.Pointer(signgamp)) = -int32(1) + **(**int32)(__ccgo_up(signgamp)) = -int32(1) } else { t = -t } @@ -108862,7 +108862,7 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { }{} *(*float32)(unsafe.Pointer(bp)) = x /* purge off +-inf, NaN, +-0, tiny and negative arguments */ - *(*int32)(unsafe.Pointer(signgamp)) = int32(1) + **(**int32)(__ccgo_up(signgamp)) = int32(1) sign = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(bp)) >> int32(31)) ix = *(*Tuint32_t)(unsafe.Pointer(bp)) & uint32(0x7fffffff) if ix >= uint32(0x7f800000) { @@ -108870,7 +108870,7 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { } if ix < uint32(0x35000000) { /* |x| < 2**-21, return -log(|x|) */ if sign != 0 { - *(*int32)(unsafe.Pointer(signgamp)) = -int32(1) + **(**int32)(__ccgo_up(signgamp)) = -int32(1) x = -x } return -Xlogf(tls, x) @@ -108882,7 +108882,7 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { return Float32FromFloat32(1) / (x - x) } if t > Float32FromFloat32(0) { - *(*int32)(unsafe.Pointer(signgamp)) = -int32(1) + **(**int32)(__ccgo_up(signgamp)) = -int32(1) } else { t = -t } @@ -109128,15 +109128,15 @@ func Xlog(tls *TLS, x1 float64) (r1 float64) { r = x1 - float64(1) r2 = Tdouble_t(r * r) r3 = Tdouble_t(r * r2) - y1 = Tdouble_t(r3 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 1*8)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 2*8))) + float64(r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 3*8))) + float64(r3*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 4*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 5*8)))+float64(r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 6*8)))+float64(r3*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 7*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 8*8)))+float64(r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 9*8)))+float64(r3**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 10*8))))))))) + y1 = Tdouble_t(r3 * (**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 1*8)) + float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 2*8))) + float64(r2***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 3*8))) + float64(r3*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 4*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 5*8)))+float64(r2***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 6*8)))+float64(r3*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 7*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 8*8)))+float64(r2***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 9*8)))+float64(r3***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 10*8))))))))) /* Worst-case error is around 0.507 ULP. */ w = Tdouble_t(r * float64(1.34217728e+08)) rhi = r + w - w rlo = r - rhi - w = Tdouble_t(Tdouble_t(rhi*rhi) * *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56))) /* B[0] == -0.5. */ + w = Tdouble_t(Tdouble_t(rhi*rhi) * **(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56))) /* B[0] == -0.5. */ hi = r + w lo = r - hi + w - lo = lo + Tdouble_t(float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56))*rlo)*(rhi+r)) + lo = lo + Tdouble_t(float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56))*rlo)*(rhi+r)) y1 = y1 + lo y1 = y1 + hi y = y1 @@ -109169,14 +109169,14 @@ func Xlog(tls *TLS, x1 float64) (r1 float64) { i = Int32FromUint64(tmp >> (Int32FromInt32(52) - Int32FromInt32(LOG_TABLE_BITS)) % Uint64FromInt32(Int32FromInt32(1)<> int32(52)) /* arithmetic shift */ iz = uint64(ix - tmp&(Uint64FromUint64(0xfff)< 0x1p-4: 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma). */ - y1 = lo + Tdouble_t(r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16))) + Tdouble_t(Tdouble_t(r*r2)*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 1*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 2*8)))+float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 3*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 4*8))))))) + hi + y1 = lo + Tdouble_t(r2***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 16))) + Tdouble_t(Tdouble_t(r*r2)*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 1*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 2*8)))+float64(r2*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 3*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 4*8))))))) + hi y = y1 v1 = y goto _11 @@ -109638,10 +109638,10 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { r2 = Tdouble_t(r * r) /* rounding error: 0x1p-62. */ r4 = Tdouble_t(r2 * r2) /* Worst-case error is less than 0.54 ULP (0.55 ULP without fma). */ - p = Tdouble_t(r2 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 1*8))))) + p = Tdouble_t(r2 * (**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64)) + float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 1*8))))) y1 = hi + p lo = lo + (hi - y1 + p) - lo = lo + Tdouble_t(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 2*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 3*8)))+float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 4*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 5*8)))))+float64(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 6*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 7*8)))+float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 8*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 9*8))))))))) + lo = lo + Tdouble_t(r4*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 2*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 3*8)))+float64(r2*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 4*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 5*8)))))+float64(r4*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 6*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 7*8)))+float64(r2*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 8*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 9*8))))))))) y1 = y1 + lo y = y1 v1 = y @@ -109673,14 +109673,14 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { i = Int32FromUint64(tmp >> (Int32FromInt32(52) - Int32FromInt32(LOG2_TABLE_BITS)) % Uint64FromInt32(Int32FromInt32(1)<> int32(52)) /* arithmetic shift */ iz = uint64(ix - tmp&(Uint64FromUint64(0xfff)< 0x1p-4: 0.547 ULP (0.550 ULP without fma). ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma). */ - p = *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 1*8))) + float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 2*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 3*8))))) + float64(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 4*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 5*8))))) + p = **(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 16)) + float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 1*8))) + float64(r2*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 2*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 3*8))))) + float64(r4*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 4*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 5*8))))) y1 = lo + Tdouble_t(r2*p) + hi y = y1 v1 = y @@ -109771,23 +109771,23 @@ func Xlog2f(tls *TLS, x1 float32) (r1 float32) { top = tmp & uint32(0xff800000) iz = ix - top k = Int32FromUint32(tmp) >> int32(23) /* arithmetic shift */ - invc = (*(*struct { + invc = (**(**struct { Finvc float64 Flogc float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + uintptr(i)*16))).Finvc - logc = (*(*struct { + })(__ccgo_up(uintptr(unsafe.Pointer(&X__log2f_data)) + uintptr(i)*16))).Finvc + logc = (**(**struct { Finvc float64 Flogc float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + uintptr(i)*16))).Flogc + })(__ccgo_up(uintptr(unsafe.Pointer(&X__log2f_data)) + uintptr(i)*16))).Flogc z = float64(*(*float32)(unsafe.Pointer(&iz))) /* log2(x) = log1p(z/c-1)/ln2 + log2(c) + k */ r = Tdouble_t(z*invc) - Float64FromInt32(1) y0 = logc + float64(k) /* Pipelined polynomial evaluation to approximate log1p(r)/ln2. */ r2 = Tdouble_t(r * r) - y1 = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 1*8))*r) + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 2*8)) - y1 = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256))*r2) + y1 - p = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 3*8))*r) + y0 + y1 = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 1*8))*r) + **(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 2*8)) + y1 = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2f_data)) + 256))*r2) + y1 + p = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 3*8))*r) + y0 y1 = Tdouble_t(y1*r2) + p y = float32(y1) v1 = y @@ -109960,22 +109960,22 @@ func Xlogf(tls *TLS, x1 float32) (r1 float32) { i = Int32FromUint32(tmp >> (Int32FromInt32(23) - Int32FromInt32(LOGF_TABLE_BITS)) % Uint32FromInt32(Int32FromInt32(1)<> int32(23) /* arithmetic shift */ iz = ix - tmp&uint32(0xff800000) - invc = (*(*struct { + invc = (**(**struct { Finvc float64 Flogc float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + uintptr(i)*16))).Finvc - logc = (*(*struct { + })(__ccgo_up(uintptr(unsafe.Pointer(&X__logf_data)) + uintptr(i)*16))).Finvc + logc = (**(**struct { Finvc float64 Flogc float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + uintptr(i)*16))).Flogc + })(__ccgo_up(uintptr(unsafe.Pointer(&X__logf_data)) + uintptr(i)*16))).Flogc z = float64(*(*float32)(unsafe.Pointer(&iz))) /* log(x) = log1p(z/c-1) + log(c) + k*Ln2 */ r = Tdouble_t(z*invc) - Float64FromInt32(1) y0 = logc + Tdouble_t(float64(k)*X__logf_data.Fln2) /* Pipelined polynomial evaluation to approximate log1p(r). */ r2 = Tdouble_t(r * r) - y1 = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + 264 + 1*8))*r) + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + 264 + 2*8)) - y1 = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + 264))*r2) + y1 + y1 = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__logf_data)) + 264 + 1*8))*r) + **(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__logf_data)) + 264 + 2*8)) + y1 = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__logf_data)) + 264))*r2) + y1 y1 = Tdouble_t(y1*r2) + (y0 + r) y = float32(y1) v1 = y @@ -110100,7 +110100,7 @@ func Xmodf(tls *TLS, x float64, iptr uintptr) (r float64) { e = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp))>>Int32FromInt32(52)&Uint64FromInt32(0x7ff)) - int32(0x3ff) /* no fractional part */ if e >= int32(52) { - *(*float64)(unsafe.Pointer(iptr)) = x + **(**float64)(__ccgo_up(iptr)) = x if e == int32(0x400) && *(*Tuint64_t)(unsafe.Pointer(bp))<> Int32FromInt32(12) >> e) if *(*Tuint64_t)(unsafe.Pointer(bp))&mask == uint64(0) { - *(*float64)(unsafe.Pointer(iptr)) = x + **(**float64)(__ccgo_up(iptr)) = x v1 = bp *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & (Uint64FromUint64(1) << Int32FromInt32(63))) return *(*float64)(unsafe.Pointer(bp)) } *(*Tuint64_t)(unsafe.Pointer(bp)) &= ^mask - *(*float64)(unsafe.Pointer(iptr)) = *(*float64)(unsafe.Pointer(bp)) + **(**float64)(__ccgo_up(iptr)) = *(*float64)(unsafe.Pointer(bp)) return x - *(*float64)(unsafe.Pointer(bp)) } @@ -110152,7 +110152,7 @@ func Xmodff(tls *TLS, x float32, iptr uintptr) (r float32) { e = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(bp))>>Int32FromInt32(23)&Uint32FromInt32(0xff)) - int32(0x7f) /* no fractional part */ if e >= int32(23) { - *(*float32)(unsafe.Pointer(iptr)) = x + **(**float32)(__ccgo_up(iptr)) = x if e == int32(0x80) && *(*Tuint32_t)(unsafe.Pointer(bp))<> e) if *(*Tuint32_t)(unsafe.Pointer(bp))&mask == uint32(0) { - *(*float32)(unsafe.Pointer(iptr)) = x + **(**float32)(__ccgo_up(iptr)) = x *(*Tuint32_t)(unsafe.Pointer(bp)) &= uint32(0x80000000) return *(*float32)(unsafe.Pointer(bp)) } *(*Tuint32_t)(unsafe.Pointer(bp)) &= ^mask - *(*float32)(unsafe.Pointer(iptr)) = *(*float32)(unsafe.Pointer(bp)) + **(**float32)(__ccgo_up(iptr)) = *(*float32)(unsafe.Pointer(bp)) return x - *(*float32)(unsafe.Pointer(bp)) } @@ -110187,7 +110187,7 @@ func Xmodfl(tls *TLS, x float64, iptr uintptr) (r1 float64) { var _ /* d at bp+0 */ float64 _ = r r = Xmodf(tls, x, bp) - *(*float64)(unsafe.Pointer(iptr)) = *(*float64)(unsafe.Pointer(bp)) + **(**float64)(__ccgo_up(iptr)) = float64(**(**float64)(__ccgo_up(bp))) return r } @@ -110589,24 +110589,24 @@ func _log_inline(tls *TLS, ix Tuint64_t, tail uintptr) (r1 Tdouble_t) { z = *(*float64)(unsafe.Pointer(&iz)) kd = float64(k) /* log(x) = k*Ln2 + log(c) + log1p(z/c-1). */ - invc = (*(*struct { + invc = (**(**struct { Finvc float64 Fpad float64 Flogc float64 Flogctail float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Finvc - logc = (*(*struct { + })(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Finvc + logc = (**(**struct { Finvc float64 Fpad float64 Flogc float64 Flogctail float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Flogc - logctail = (*(*struct { + })(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Flogc + logctail = (**(**struct { Finvc float64 Fpad float64 Flogc float64 Flogctail float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Flogctail + })(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Flogctail /* Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible. */ r = float64(X__builtin_fma(tls, z, invc, -Float64FromFloat64(1))) @@ -110615,7 +110615,7 @@ func _log_inline(tls *TLS, ix Tuint64_t, tail uintptr) (r1 Tdouble_t) { t2 = t1 + r lo1 = Tdouble_t(kd*X__pow_log_data.Fln2lo) + logctail lo2 = t1 - t2 + r - ar = Tdouble_t(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16)) * r) /* A[0] = -0.5. */ + ar = Tdouble_t(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16)) * r) /* A[0] = -0.5. */ ar2 = Tdouble_t(r * ar) ar3 = Tdouble_t(r * ar2) /* k*Ln2 + log(c) + r + A[0]*r*r. */ @@ -110623,10 +110623,10 @@ func _log_inline(tls *TLS, ix Tuint64_t, tail uintptr) (r1 Tdouble_t) { lo3 = float64(X__builtin_fma(tls, ar, r, -ar2)) lo4 = t2 - hi + ar2 /* p = log1p(r) - r - A[0]*r*r. */ - p = Tdouble_t(ar3 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 1*8)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 2*8))) + float64(ar2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 3*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 4*8)))+float64(ar2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 5*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 6*8))))))))) + p = Tdouble_t(ar3 * (**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 1*8)) + float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 2*8))) + float64(ar2*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 3*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 4*8)))+float64(ar2*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 5*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 6*8))))))))) lo = lo1 + lo2 + lo3 + lo4 + p y = hi + lo - *(*Tdouble_t)(unsafe.Pointer(tail)) = hi - y + lo + **(**Tdouble_t)(__ccgo_up(tail)) = hi - y + lo return y } @@ -110746,16 +110746,16 @@ _4: /* 2^(k/N) ~= scale * (1 + tail). */ idx = uint64(2) * (ki % Uint64FromInt32(Int32FromInt32(1)<> (Int32FromInt32(23) - Int32FromInt32(POWF_SCALE_BITS)) /* arithmetic shift */ - invc = (*(*struct { + invc = (**(**struct { Finvc float64 Flogc float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + uintptr(i)*16))).Finvc - logc = (*(*struct { + })(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + uintptr(i)*16))).Finvc + logc = (**(**struct { Finvc float64 Flogc float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + uintptr(i)*16))).Flogc + })(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + uintptr(i)*16))).Flogc z = float64(*(*float32)(unsafe.Pointer(&iz))) /* log2(x) = log1p(z/c-1)/ln2 + log2(c) + k */ r = Tdouble_t(z*invc) - Float64FromInt32(1) y0 = logc + float64(k) /* Pipelined polynomial evaluation to approximate log1p(r)/ln2. */ r2 = Tdouble_t(r * r) - y = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256))*r) + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 1*8)) - p = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 2*8))*r) + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 3*8)) + y = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256))*r) + **(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 1*8)) + p = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 2*8))*r) + **(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 3*8)) r4 = Tdouble_t(r2 * r2) - q = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 4*8))*r) + y0 + q = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 4*8))*r) + y0 q = Tdouble_t(p*r2) + q y = Tdouble_t(y*r4) + q return y @@ -111017,13 +111017,13 @@ _2: kd = kd - X__exp2f_data.Fshift_scaled /* k/N */ r = xd - kd /* exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1) */ - t = *(*Tuint64_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + uintptr(ki%Uint64FromInt32(Int32FromInt32(1)<> int32(63)) sy = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp + 16)) >> int32(63)) uxi = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) - *(*int32)(unsafe.Pointer(quo)) = 0 + **(**int32)(__ccgo_up(quo)) = 0 if v3 = *(*Tuint64_t)(unsafe.Pointer(bp + 16))<> int32(31)) sy = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(bp + 8)) >> int32(31)) uxi = *(*Tuint32_t)(unsafe.Pointer(bp + 4)) - *(*int32)(unsafe.Pointer(quo)) = 0 + **(**int32)(__ccgo_up(quo)) = 0 if v3 = *(*Tuint32_t)(unsafe.Pointer(bp + 8))<= uint32(0x7ff00000) { v1 = x3 - x3 - *(*float64)(unsafe.Pointer(cos)) = v1 - *(*float64)(unsafe.Pointer(sin)) = v1 + **(**float64)(__ccgo_up(cos)) = v1 + **(**float64)(__ccgo_up(sin)) = v1 return } /* argument reduction needed */ n = Uint32FromInt32(X__rem_pio2(tls, x3, bp)) - s = X__sin(tls, (*(*[2]float64)(unsafe.Pointer(bp)))[0], (*(*[2]float64)(unsafe.Pointer(bp)))[int32(1)], int32(1)) - c = X__cos(tls, (*(*[2]float64)(unsafe.Pointer(bp)))[0], (*(*[2]float64)(unsafe.Pointer(bp)))[int32(1)]) + s = X__sin(tls, (**(**[2]float64)(__ccgo_up(bp)))[0], (**(**[2]float64)(__ccgo_up(bp)))[int32(1)], int32(1)) + c = X__cos(tls, (**(**[2]float64)(__ccgo_up(bp)))[0], (**(**[2]float64)(__ccgo_up(bp)))[int32(1)]) switch n & Uint32FromInt32(3) { case uint32(0): - *(*float64)(unsafe.Pointer(sin)) = s - *(*float64)(unsafe.Pointer(cos)) = c + **(**float64)(__ccgo_up(sin)) = s + **(**float64)(__ccgo_up(cos)) = c case uint32(1): - *(*float64)(unsafe.Pointer(sin)) = c - *(*float64)(unsafe.Pointer(cos)) = -s + **(**float64)(__ccgo_up(sin)) = c + **(**float64)(__ccgo_up(cos)) = -s case uint32(2): - *(*float64)(unsafe.Pointer(sin)) = -s - *(*float64)(unsafe.Pointer(cos)) = -c + **(**float64)(__ccgo_up(sin)) = -s + **(**float64)(__ccgo_up(cos)) = -c case uint32(3): fallthrough default: - *(*float64)(unsafe.Pointer(sin)) = -c - *(*float64)(unsafe.Pointer(cos)) = s + **(**float64)(__ccgo_up(sin)) = -c + **(**float64)(__ccgo_up(cos)) = s break } } @@ -112264,23 +112264,23 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { y2 = float64(v1) } } - *(*float32)(unsafe.Pointer(sin)) = x3 - *(*float32)(unsafe.Pointer(cos)) = Float32FromFloat32(1) + **(**float32)(__ccgo_up(sin)) = x3 + **(**float32)(__ccgo_up(cos)) = Float32FromFloat32(1) return } - *(*float32)(unsafe.Pointer(sin)) = X__sindf(tls, float64(x3)) - *(*float32)(unsafe.Pointer(cos)) = X__cosdf(tls, float64(x3)) + **(**float32)(__ccgo_up(sin)) = X__sindf(tls, float64(x3)) + **(**float32)(__ccgo_up(cos)) = X__cosdf(tls, float64(x3)) return } /* |x| ~<= 5*pi/4 */ if ix <= uint32(0x407b53d1) { if ix <= uint32(0x4016cbe3) { /* |x| ~<= 3pi/4 */ if sign != 0 { - *(*float32)(unsafe.Pointer(sin)) = -X__cosdf(tls, float64(x3)+_s1pio2) - *(*float32)(unsafe.Pointer(cos)) = X__sindf(tls, float64(x3)+_s1pio2) + **(**float32)(__ccgo_up(sin)) = -X__cosdf(tls, float64(x3)+_s1pio2) + **(**float32)(__ccgo_up(cos)) = X__sindf(tls, float64(x3)+_s1pio2) } else { - *(*float32)(unsafe.Pointer(sin)) = X__cosdf(tls, _s1pio2-float64(x3)) - *(*float32)(unsafe.Pointer(cos)) = X__sindf(tls, _s1pio2-float64(x3)) + **(**float32)(__ccgo_up(sin)) = X__cosdf(tls, _s1pio2-float64(x3)) + **(**float32)(__ccgo_up(cos)) = X__sindf(tls, _s1pio2-float64(x3)) } return } @@ -112290,24 +112290,24 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { } else { v4 = float64(x3) - _s2pio2 } - *(*float32)(unsafe.Pointer(sin)) = -X__sindf(tls, v4) + **(**float32)(__ccgo_up(sin)) = -X__sindf(tls, v4) if sign != 0 { v4 = float64(x3) + _s2pio2 } else { v4 = float64(x3) - _s2pio2 } - *(*float32)(unsafe.Pointer(cos)) = -X__cosdf(tls, v4) + **(**float32)(__ccgo_up(cos)) = -X__cosdf(tls, v4) return } /* |x| ~<= 9*pi/4 */ if ix <= uint32(0x40e231d5) { if ix <= uint32(0x40afeddf) { /* |x| ~<= 7*pi/4 */ if sign != 0 { - *(*float32)(unsafe.Pointer(sin)) = X__cosdf(tls, float64(x3)+_s3pio2) - *(*float32)(unsafe.Pointer(cos)) = -X__sindf(tls, float64(x3)+_s3pio2) + **(**float32)(__ccgo_up(sin)) = X__cosdf(tls, float64(x3)+_s3pio2) + **(**float32)(__ccgo_up(cos)) = -X__sindf(tls, float64(x3)+_s3pio2) } else { - *(*float32)(unsafe.Pointer(sin)) = -X__cosdf(tls, float64(x3)-_s3pio2) - *(*float32)(unsafe.Pointer(cos)) = X__sindf(tls, float64(x3)-_s3pio2) + **(**float32)(__ccgo_up(sin)) = -X__cosdf(tls, float64(x3)-_s3pio2) + **(**float32)(__ccgo_up(cos)) = X__sindf(tls, float64(x3)-_s3pio2) } return } @@ -112316,41 +112316,41 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { } else { v4 = float64(x3) - _s4pio2 } - *(*float32)(unsafe.Pointer(sin)) = X__sindf(tls, v4) + **(**float32)(__ccgo_up(sin)) = X__sindf(tls, v4) if sign != 0 { v4 = float64(x3) + _s4pio2 } else { v4 = float64(x3) - _s4pio2 } - *(*float32)(unsafe.Pointer(cos)) = X__cosdf(tls, v4) + **(**float32)(__ccgo_up(cos)) = X__cosdf(tls, v4) return } /* sin(Inf or NaN) is NaN */ if ix >= uint32(0x7f800000) { v1 = x3 - x3 - *(*float32)(unsafe.Pointer(cos)) = v1 - *(*float32)(unsafe.Pointer(sin)) = v1 + **(**float32)(__ccgo_up(cos)) = v1 + **(**float32)(__ccgo_up(sin)) = v1 return } /* general argument reduction needed */ n = Uint32FromInt32(X__rem_pio2f(tls, x3, bp)) - s = X__sindf(tls, *(*float64)(unsafe.Pointer(bp))) - c = X__cosdf(tls, *(*float64)(unsafe.Pointer(bp))) + s = X__sindf(tls, **(**float64)(__ccgo_up(bp))) + c = X__cosdf(tls, **(**float64)(__ccgo_up(bp))) switch n & Uint32FromInt32(3) { case uint32(0): - *(*float32)(unsafe.Pointer(sin)) = s - *(*float32)(unsafe.Pointer(cos)) = c + **(**float32)(__ccgo_up(sin)) = s + **(**float32)(__ccgo_up(cos)) = c case uint32(1): - *(*float32)(unsafe.Pointer(sin)) = c - *(*float32)(unsafe.Pointer(cos)) = -s + **(**float32)(__ccgo_up(sin)) = c + **(**float32)(__ccgo_up(cos)) = -s case uint32(2): - *(*float32)(unsafe.Pointer(sin)) = -s - *(*float32)(unsafe.Pointer(cos)) = -c + **(**float32)(__ccgo_up(sin)) = -s + **(**float32)(__ccgo_up(cos)) = -c case uint32(3): fallthrough default: - *(*float32)(unsafe.Pointer(sin)) = -c - *(*float32)(unsafe.Pointer(cos)) = s + **(**float32)(__ccgo_up(sin)) = -c + **(**float32)(__ccgo_up(cos)) = s break } } @@ -112366,8 +112366,8 @@ func Xsincosl(tls *TLS, x float64, sin uintptr, cos uintptr) { var _ /* cosd at bp+8 */ float64 var _ /* sind at bp+0 */ float64 Xsincos(tls, x, bp, bp+8) - *(*float64)(unsafe.Pointer(sin)) = *(*float64)(unsafe.Pointer(bp)) - *(*float64)(unsafe.Pointer(cos)) = *(*float64)(unsafe.Pointer(bp + 8)) + **(**float64)(__ccgo_up(sin)) = float64(**(**float64)(__ccgo_up(bp))) + **(**float64)(__ccgo_up(cos)) = float64(**(**float64)(__ccgo_up(bp + 8))) } const M_PI_27 = 1.5707963267948966 @@ -112466,13 +112466,13 @@ func Xsinf(tls *TLS, x3 float32) (r float32) { n = X__rem_pio2f(tls, x3, bp) switch n & Int32FromInt32(3) { case 0: - return X__sindf(tls, *(*float64)(unsafe.Pointer(bp))) + return X__sindf(tls, **(**float64)(__ccgo_up(bp))) case int32(1): - return X__cosdf(tls, *(*float64)(unsafe.Pointer(bp))) + return X__cosdf(tls, **(**float64)(__ccgo_up(bp))) case int32(2): - return X__sindf(tls, -*(*float64)(unsafe.Pointer(bp))) + return X__sindf(tls, -**(**float64)(__ccgo_up(bp))) default: - return -X__cosdf(tls, *(*float64)(unsafe.Pointer(bp))) + return -X__cosdf(tls, **(**float64)(__ccgo_up(bp))) } return r } @@ -112918,7 +112918,7 @@ func Xtan(tls *TLS, x3 float64) (r float64) { } /* argument reduction */ n = Uint32FromInt32(X__rem_pio2(tls, x3, bp)) - return X__tan(tls, (*(*[2]float64)(unsafe.Pointer(bp)))[0], (*(*[2]float64)(unsafe.Pointer(bp)))[int32(1)], Int32FromUint32(n&uint32(1))) + return X__tan(tls, (**(**[2]float64)(__ccgo_up(bp)))[0], (**(**[2]float64)(__ccgo_up(bp)))[int32(1)], Int32FromUint32(n&uint32(1))) } const M_PI_29 = 1.5707963267948966 @@ -113019,7 +113019,7 @@ func Xtanf(tls *TLS, x3 float32) (r float32) { } /* argument reduction */ n = Uint32FromInt32(X__rem_pio2f(tls, x3, bp)) - return X__tandf(tls, *(*float64)(unsafe.Pointer(bp)), Int32FromUint32(n&uint32(1))) + return X__tandf(tls, **(**float64)(__ccgo_up(bp)), Int32FromUint32(n&uint32(1))) } const M_PI_210 = 0 @@ -113559,10 +113559,10 @@ func Xa64l(tls *TLS, s uintptr) (r int64) { x = uint32(0) e = 0 for { - if !(e < int32(36) && *(*uint8)(unsafe.Pointer(s)) != 0) { + if !(e < int32(36) && **(**uint8)(__ccgo_up(s)) != 0) { break } - d = Xstrchr(tls, uintptr(unsafe.Pointer(&_digits)), Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))) + d = Xstrchr(tls, uintptr(unsafe.Pointer(&_digits)), Int32FromUint8(**(**uint8)(__ccgo_up(s)))) if !(d != 0) { break } @@ -113590,14 +113590,14 @@ func Xl64a(tls *TLS, x0 int64) (r uintptr) { if !(x != 0) { break } - *(*uint8)(unsafe.Pointer(p)) = _digits[x&uint32(63)] + **(**uint8)(__ccgo_up(p)) = _digits[x&uint32(63)] goto _1 _1: ; p = p + 1 x = x >> uint32(6) } - *(*uint8)(unsafe.Pointer(p)) = uint8(0) + **(**uint8)(__ccgo_up(p)) = uint8(0) return uintptr(unsafe.Pointer(&_s)) } @@ -113610,22 +113610,22 @@ func Xbasename(tls *TLS, s uintptr) (r uintptr) { } var i Tsize_t _ = i - if !(s != 0) || !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(s != 0) || !(**(**uint8)(__ccgo_up(s)) != 0) { return __ccgo_ts + 607 } i = _strlen(tls, s) - uint64(1) for { - if !(i != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(i)))) == int32('/')) { + if !(i != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(i)))) == int32('/')) { break } - *(*uint8)(unsafe.Pointer(s + uintptr(i))) = uint8(0) + **(**uint8)(__ccgo_up(s + uintptr(i))) = uint8(0) goto _1 _1: ; i = i - 1 } for { - if !(i != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(i-uint64(1))))) != int32('/')) { + if !(i != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(i-uint64(1))))) != int32('/')) { break } goto _2 @@ -113651,12 +113651,12 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { } var i Tsize_t _ = i - if !(s != 0) || !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(s != 0) || !(**(**uint8)(__ccgo_up(s)) != 0) { return __ccgo_ts + 607 } i = _strlen(tls, s) - uint64(1) for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(i)))) == int32('/')) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(i)))) == int32('/')) { break } if !(i != 0) { @@ -113668,7 +113668,7 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { i = i - 1 } for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(i)))) != int32('/')) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(i)))) != int32('/')) { break } if !(i != 0) { @@ -113680,7 +113680,7 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { i = i - 1 } for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(i)))) == int32('/')) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(i)))) == int32('/')) { break } if !(i != 0) { @@ -113691,7 +113691,7 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { ; i = i - 1 } - *(*uint8)(unsafe.Pointer(s + uintptr(i+uint64(1)))) = uint8(0) + **(**uint8)(__ccgo_up(s + uintptr(i+uint64(1)))) = uint8(0) return s } @@ -113772,10 +113772,10 @@ func __strcolcmp(tls *TLS, lstr uintptr, bstr uintptr) (r int32) { var i Tsize_t _ = i i = uint64(0) - for *(*uint8)(unsafe.Pointer(lstr + uintptr(i))) != 0 && *(*uint8)(unsafe.Pointer(bstr + uintptr(i))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(bstr + uintptr(i)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(lstr + uintptr(i)))) { + for **(**uint8)(__ccgo_up(lstr + uintptr(i))) != 0 && **(**uint8)(__ccgo_up(bstr + uintptr(i))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(bstr + uintptr(i)))) == Int32FromUint8(**(**uint8)(__ccgo_up(lstr + uintptr(i)))) { i = i + 1 } - if *(*uint8)(unsafe.Pointer(lstr + uintptr(i))) != 0 || *(*uint8)(unsafe.Pointer(bstr + uintptr(i))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(bstr + uintptr(i)))) != int32(':') { + if **(**uint8)(__ccgo_up(lstr + uintptr(i))) != 0 || **(**uint8)(__ccgo_up(bstr + uintptr(i))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(bstr + uintptr(i)))) != int32(':') { return int32(1) } return 0 @@ -113873,7 +113873,7 @@ func Xfmtmsg(tls *TLS, classification int64, label uintptr, severity int32, text } } if classification&int64(MM_PRINT) != 0 { - for cmsg != 0 && *(*uint8)(unsafe.Pointer(cmsg)) != 0 { + for cmsg != 0 && **(**uint8)(__ccgo_up(cmsg)) != 0 { i = 0 for { if !(msgs[i] != 0) { @@ -113949,7 +113949,7 @@ func Xfmtmsg(tls *TLS, classification int64, label uintptr, severity int32, text if ret&(Int32FromInt32(MM_NOCON)|Int32FromInt32(MM_NOMSG)) == Int32FromInt32(MM_NOCON)|Int32FromInt32(MM_NOMSG) { ret = -int32(1) } - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) return ret } @@ -113965,7 +113965,7 @@ func Xget_current_dir_name(tls *TLS) (r uintptr) { var _ /* b at bp+128 */ Tstat _ = res res = Xgetenv(tls, __ccgo_ts+731) - if res != 0 && *(*uint8)(unsafe.Pointer(res)) != 0 && !(Xstat(tls, res, bp) != 0) && !(Xstat(tls, __ccgo_ts+607, bp+128) != 0) && (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev == (*(*Tstat)(unsafe.Pointer(bp + 128))).Fst_dev && (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino == (*(*Tstat)(unsafe.Pointer(bp + 128))).Fst_ino { + if res != 0 && **(**uint8)(__ccgo_up(res)) != 0 && !(Xstat(tls, res, bp) != 0) && !(Xstat(tls, __ccgo_ts+607, bp+128) != 0) && (**(**Tstat)(__ccgo_up(bp))).Fst_dev == (**(**Tstat)(__ccgo_up(bp + 128))).Fst_dev && (**(**Tstat)(__ccgo_up(bp))).Fst_ino == (**(**Tstat)(__ccgo_up(bp + 128))).Fst_ino { return Xstrdup(tls, res) } return Xgetcwd(tls, uintptr(0), uint64(0)) @@ -113983,18 +113983,18 @@ func X__getauxval(tls *TLS, item uint64) (r uint64) { return uint64(X__libc.Fsecure) } for { - if !(*(*Tsize_t)(unsafe.Pointer(auxv)) != 0) { + if !(**(**Tsize_t)(__ccgo_up(auxv)) != 0) { break } - if *(*Tsize_t)(unsafe.Pointer(auxv)) == item { - return *(*Tsize_t)(unsafe.Pointer(auxv + 1*8)) + if **(**Tsize_t)(__ccgo_up(auxv)) == item { + return **(**Tsize_t)(__ccgo_up(auxv + 1*8)) } goto _1 _1: ; auxv = auxv + uintptr(2)*8 } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOENT) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOENT) return uint64(0) } @@ -114025,7 +114025,7 @@ func Xgetdomainname(tls *TLS, name uintptr, len1 Tsize_t) (r int32) { var _ /* temp at bp+0 */ Tutsname Xuname(tls, bp) if !(len1 != 0) || _strlen(tls, bp+325) >= len1 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } Xstrcpy(tls, name, bp+325) @@ -114046,14 +114046,14 @@ func Xgetentropy(tls *TLS, buffer uintptr, len1 Tsize_t) (r int32) { ret = 0 pos = buffer if len1 > uint64(256) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EIO) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EIO) return -int32(1) } _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp) for len1 != 0 { ret = int32(Xgetrandom(tls, pos, len1, uint32(0))) if ret < 0 { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EINTR) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EINTR) { continue } else { break @@ -114063,7 +114063,7 @@ func Xgetentropy(tls *TLS, buffer uintptr, len1 Tsize_t) (r int32) { len1 = len1 - Uint64FromInt32(ret) ret = 0 } - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) return ret } @@ -114115,46 +114115,46 @@ func Xgetopt(tls *TLS, argc int32, argv uintptr, optstring uintptr) (r int32) { X__optpos = 0 Xoptind = int32(1) } - if Xoptind >= argc || !(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) != 0) { + if Xoptind >= argc || !(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) != 0) { return -int32(1) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))))) != int32('-') { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) == int32('-') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8))))) != int32('-') { + if Int32FromUint8(**(**uint8)(__ccgo_up(optstring))) == int32('-') { v1 = Xoptind Xoptind = Xoptind + 1 - Xoptarg = *(*uintptr)(unsafe.Pointer(argv + uintptr(v1)*8)) + Xoptarg = **(**uintptr)(__ccgo_up(argv + uintptr(v1)*8)) return int32(1) } return -int32(1) } - if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1)) != 0) { + if !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + 1)) != 0) { return -int32(1) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1))) == int32('-') && !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 2)) != 0) { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + 1))) == int32('-') && !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + 2)) != 0) { Xoptind = Xoptind + 1 return -Int32FromInt32(1) } if !(X__optpos != 0) { X__optpos = X__optpos + 1 } - v1 = Xmbtowc(tls, bp, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))+uintptr(X__optpos), uint64(MB_LEN_MAX)) + v1 = Xmbtowc(tls, bp, **(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8))+uintptr(X__optpos), uint64(MB_LEN_MAX)) k = v1 if v1 < 0 { k = int32(1) - *(*Twchar_t)(unsafe.Pointer(bp)) = int32(0xfffd) /* replacement char */ + **(**Twchar_t)(__ccgo_up(bp)) = int32(0xfffd) /* replacement char */ } - optchar = *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + uintptr(X__optpos) + optchar = **(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + uintptr(X__optpos) X__optpos = X__optpos + k - if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + uintptr(X__optpos))) != 0) { + if !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + uintptr(X__optpos))) != 0) { Xoptind = Xoptind + 1 X__optpos = 0 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) == int32('-') || Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) == int32('+') { + if Int32FromUint8(**(**uint8)(__ccgo_up(optstring))) == int32('-') || Int32FromUint8(**(**uint8)(__ccgo_up(optstring))) == int32('+') { optstring = optstring + 1 } i = 0 - *(*Twchar_t)(unsafe.Pointer(bp + 4)) = 0 - for cond := true; cond; cond = l != 0 && *(*Twchar_t)(unsafe.Pointer(bp + 4)) != *(*Twchar_t)(unsafe.Pointer(bp)) { + **(**Twchar_t)(__ccgo_up(bp + 4)) = 0 + for cond := true; cond; cond = l != 0 && **(**Twchar_t)(__ccgo_up(bp + 4)) != **(**Twchar_t)(__ccgo_up(bp)) { l = Xmbtowc(tls, bp+4, optstring+uintptr(i), uint64(MB_LEN_MAX)) if l > 0 { i = i + l @@ -114162,36 +114162,36 @@ func Xgetopt(tls *TLS, argc int32, argv uintptr, optstring uintptr) (r int32) { i = i + 1 } } - if *(*Twchar_t)(unsafe.Pointer(bp + 4)) != *(*Twchar_t)(unsafe.Pointer(bp)) || *(*Twchar_t)(unsafe.Pointer(bp)) == int32(':') { - Xoptopt = *(*Twchar_t)(unsafe.Pointer(bp)) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) != int32(':') && Xopterr != 0 { - X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), __ccgo_ts+735, optchar, Uint64FromInt32(k)) + if **(**Twchar_t)(__ccgo_up(bp + 4)) != **(**Twchar_t)(__ccgo_up(bp)) || **(**Twchar_t)(__ccgo_up(bp)) == int32(':') { + Xoptopt = **(**Twchar_t)(__ccgo_up(bp)) + if Int32FromUint8(**(**uint8)(__ccgo_up(optstring))) != int32(':') && Xopterr != 0 { + X__getopt_msg(tls, **(**uintptr)(__ccgo_up(argv)), __ccgo_ts+735, optchar, Uint64FromInt32(k)) } return int32('?') } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring + uintptr(i)))) == int32(':') { + if Int32FromUint8(**(**uint8)(__ccgo_up(optstring + uintptr(i)))) == int32(':') { Xoptarg = uintptr(0) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring + uintptr(i+int32(1))))) != int32(':') || X__optpos != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(optstring + uintptr(i+int32(1))))) != int32(':') || X__optpos != 0 { v1 = Xoptind Xoptind = Xoptind + 1 - Xoptarg = *(*uintptr)(unsafe.Pointer(argv + uintptr(v1)*8)) + Xoptarg = **(**uintptr)(__ccgo_up(argv + uintptr(v1)*8)) if X__optpos != 0 { Xoptarg = Xoptarg + uintptr(X__optpos) } X__optpos = 0 } if Xoptind > argc { - Xoptopt = *(*Twchar_t)(unsafe.Pointer(bp)) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) == int32(':') { + Xoptopt = **(**Twchar_t)(__ccgo_up(bp)) + if Int32FromUint8(**(**uint8)(__ccgo_up(optstring))) == int32(':') { return int32(':') } if Xopterr != 0 { - X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), __ccgo_ts+759, optchar, Uint64FromInt32(k)) + X__getopt_msg(tls, **(**uintptr)(__ccgo_up(argv)), __ccgo_ts+759, optchar, Uint64FromInt32(k)) } return int32('?') } } - return *(*Twchar_t)(unsafe.Pointer(bp)) + return **(**Twchar_t)(__ccgo_up(bp)) } func X__posix_getopt(tls *TLS, argc int32, argv uintptr, optstring uintptr) (r int32) { @@ -114218,19 +114218,19 @@ func _permute(tls *TLS, argv uintptr, dest int32, src int32) { var i int32 _, _, _ = av, i, tmp av = argv - tmp = *(*uintptr)(unsafe.Pointer(av + uintptr(src)*8)) + tmp = **(**uintptr)(__ccgo_up(av + uintptr(src)*8)) i = src for { if !(i > dest) { break } - *(*uintptr)(unsafe.Pointer(av + uintptr(i)*8)) = *(*uintptr)(unsafe.Pointer(av + uintptr(i-int32(1))*8)) + **(**uintptr)(__ccgo_up(av + uintptr(i)*8)) = **(**uintptr)(__ccgo_up(av + uintptr(i-int32(1))*8)) goto _1 _1: ; i = i - 1 } - *(*uintptr)(unsafe.Pointer(av + uintptr(dest)*8)) = tmp + **(**uintptr)(__ccgo_up(av + uintptr(dest)*8)) = tmp } func ___getopt_long(tls *TLS, argc int32, argv uintptr, optstring uintptr, longopts uintptr, idx uintptr, longonly int32) (r int32) { @@ -114241,17 +114241,17 @@ func ___getopt_long(tls *TLS, argc int32, argv uintptr, optstring uintptr, longo X__optpos = 0 Xoptind = int32(1) } - if Xoptind >= argc || !(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) != 0) { + if Xoptind >= argc || !(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) != 0) { return -int32(1) } skipped = Xoptind - if Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) != int32('+') && Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) != int32('-') { + if Int32FromUint8(**(**uint8)(__ccgo_up(optstring))) != int32('+') && Int32FromUint8(**(**uint8)(__ccgo_up(optstring))) != int32('-') { i = Xoptind for { - if i >= argc || !(*(*uintptr)(unsafe.Pointer(argv + uintptr(i)*8)) != 0) { + if i >= argc || !(**(**uintptr)(__ccgo_up(argv + uintptr(i)*8)) != 0) { return -int32(1) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(i)*8))))) == int32('-') && *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(i)*8)) + 1)) != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(i)*8))))) == int32('-') && **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(i)*8)) + 1)) != 0 { break } goto _1 @@ -114286,31 +114286,31 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, var cnt, colon, i, j, l, match, v2 int32 _, _, _, _, _, _, _, _, _, _, _, _ = arg, cnt, colon, i, j, l, match, name, opt, start, v2, v5 Xoptarg = uintptr(0) - if longopts != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))))) == int32('-') && (longonly != 0 && *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1))) != int32('-') || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1))) == int32('-') && *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 2)) != 0) { - colon = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring + BoolUintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) == int32('+') || Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) == int32('-'))))) == int32(':')) - start = *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + uintptr(1) + if longopts != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8))))) == int32('-') && (longonly != 0 && **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + 1)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + 1))) != int32('-') || Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + 1))) == int32('-') && **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + 2)) != 0) { + colon = BoolInt32(Int32FromUint8(**(**uint8)(__ccgo_up(optstring + BoolUintptr(Int32FromUint8(**(**uint8)(__ccgo_up(optstring))) == int32('+') || Int32FromUint8(**(**uint8)(__ccgo_up(optstring))) == int32('-'))))) == int32(':')) + start = **(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + uintptr(1) v2 = Int32FromInt32(0) i = v2 cnt = v2 for { - if !((*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname != 0) { + if !((**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fname != 0) { break } - name = (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname + name = (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fname opt = start - if Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) == int32('-') { + if Int32FromUint8(**(**uint8)(__ccgo_up(opt))) == int32('-') { opt = opt + 1 } - for *(*uint8)(unsafe.Pointer(opt)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) != int32('=') && Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) { + for **(**uint8)(__ccgo_up(opt)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(opt))) != int32('=') && Int32FromUint8(**(**uint8)(__ccgo_up(opt))) == Int32FromUint8(**(**uint8)(__ccgo_up(name))) { name = name + 1 opt = opt + 1 } - if *(*uint8)(unsafe.Pointer(opt)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) != int32('=') { + if **(**uint8)(__ccgo_up(opt)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(opt))) != int32('=') { goto _1 } arg = opt match = i - if !(*(*uint8)(unsafe.Pointer(name)) != 0) { + if !(**(**uint8)(__ccgo_up(name)) != 0) { cnt = int32(1) break } @@ -114324,12 +114324,12 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, l = int32(int64(arg) - int64(start)) i = 0 for { - if !(*(*uint8)(unsafe.Pointer(optstring + uintptr(i))) != 0) { + if !(**(**uint8)(__ccgo_up(optstring + uintptr(i))) != 0) { break } j = 0 for { - if !(j < l && Int32FromUint8(*(*uint8)(unsafe.Pointer(start + uintptr(j)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring + uintptr(i+j))))) { + if !(j < l && Int32FromUint8(**(**uint8)(__ccgo_up(start + uintptr(j)))) == Int32FromUint8(**(**uint8)(__ccgo_up(optstring + uintptr(i+j))))) { break } goto _4 @@ -114351,44 +114351,44 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, i = match opt = arg Xoptind = Xoptind + 1 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) == int32('=') { - if !((*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fhas_arg != 0) { - Xoptopt = (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fval + if Int32FromUint8(**(**uint8)(__ccgo_up(opt))) == int32('=') { + if !((**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fhas_arg != 0) { + Xoptopt = (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fval if colon != 0 || !(Xopterr != 0) { return int32('?') } - X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), __ccgo_ts+791, (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname, _strlen(tls, (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname)) + X__getopt_msg(tls, **(**uintptr)(__ccgo_up(argv)), __ccgo_ts+791, (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fname, _strlen(tls, (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fname)) return int32('?') } Xoptarg = opt + uintptr(1) } else { - if (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fhas_arg == int32(required_argument) { - v5 = *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + if (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fhas_arg == int32(required_argument) { + v5 = **(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) Xoptarg = v5 if !(v5 != 0) { - Xoptopt = (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fval + Xoptopt = (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fval if colon != 0 { return int32(':') } if !(Xopterr != 0) { return int32('?') } - X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), __ccgo_ts+759, (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname, _strlen(tls, (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname)) + X__getopt_msg(tls, **(**uintptr)(__ccgo_up(argv)), __ccgo_ts+759, (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fname, _strlen(tls, (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fname)) return int32('?') } Xoptind = Xoptind + 1 } } if idx != 0 { - *(*int32)(unsafe.Pointer(idx)) = i + **(**int32)(__ccgo_up(idx)) = i } - if (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fflag != 0 { - *(*int32)(unsafe.Pointer((*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fflag)) = (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fval + if (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fflag != 0 { + **(**int32)(__ccgo_up((**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fflag)) = (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fval return 0 } - return (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fval + return (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fval } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1))) == int32('-') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + 1))) == int32('-') { Xoptopt = 0 if !(colon != 0) && Xopterr != 0 { if cnt != 0 { @@ -114396,7 +114396,7 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, } else { v5 = __ccgo_ts + 735 } - X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), v5, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))+uintptr(2), _strlen(tls, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))+uintptr(2))) + X__getopt_msg(tls, **(**uintptr)(__ccgo_up(argv)), v5, **(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8))+uintptr(2), _strlen(tls, **(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8))+uintptr(2))) } Xoptind = Xoptind + 1 return int32('?') @@ -114471,22 +114471,22 @@ func Xgetrlimit(tls *TLS, resource int32, rlim uintptr) (r int32) { (*Trlimit)(unsafe.Pointer(rlim)).Frlim_max = ^Uint64FromUint64(0) } } - if !(ret != 0) || *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(ENOSYS) { + if !(ret != 0) || **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(ENOSYS) { return ret } if X__syscall_ret(tls, Uint64FromInt64(X__syscall2(tls, int64(SYS_getrlimit), int64(resource), int64(bp)))) < 0 { return -int32(1) } - if (*(*[2]uint64)(unsafe.Pointer(bp)))[0] == -Uint64FromUint64(1) { + if (**(**[2]uint64)(__ccgo_up(bp)))[0] == -Uint64FromUint64(1) { v1 = ^Uint64FromUint64(0) } else { - v1 = (*(*[2]uint64)(unsafe.Pointer(bp)))[0] + v1 = (**(**[2]uint64)(__ccgo_up(bp)))[0] } (*Trlimit)(unsafe.Pointer(rlim)).Frlim_cur = v1 - if (*(*[2]uint64)(unsafe.Pointer(bp)))[int32(1)] == -Uint64FromUint64(1) { + if (**(**[2]uint64)(__ccgo_up(bp)))[int32(1)] == -Uint64FromUint64(1) { v1 = ^Uint64FromUint64(0) } else { - v1 = (*(*[2]uint64)(unsafe.Pointer(bp)))[int32(1)] + v1 = (**(**[2]uint64)(__ccgo_up(bp)))[int32(1)] } (*Trlimit)(unsafe.Pointer(rlim)).Frlim_max = v1 if (*Trlimit)(unsafe.Pointer(rlim)).Frlim_cur >= ^Uint64FromUint64(0) { @@ -114514,12 +114514,12 @@ func Xgetrusage(tls *TLS, who int32, ru uintptr) (r1 int32) { if !(r != 0) && Bool(uint64(8) > uint64(8)) { Xmemcpy(tls, bp, dest, Uint64FromInt32(4)*Uint64FromInt64(8)) (*Trusage)(unsafe.Pointer(ru)).Fru_utime = Ttimeval{ - Ftv_sec: (*(*[4]int64)(unsafe.Pointer(bp)))[0], - Ftv_usec: (*(*[4]int64)(unsafe.Pointer(bp)))[int32(1)], + Ftv_sec: (**(**[4]int64)(__ccgo_up(bp)))[0], + Ftv_usec: (**(**[4]int64)(__ccgo_up(bp)))[int32(1)], } (*Trusage)(unsafe.Pointer(ru)).Fru_stime = Ttimeval{ - Ftv_sec: (*(*[4]int64)(unsafe.Pointer(bp)))[int32(2)], - Ftv_usec: (*(*[4]int64)(unsafe.Pointer(bp)))[int32(3)], + Ftv_sec: (**(**[4]int64)(__ccgo_up(bp)))[int32(2)], + Ftv_usec: (**(**[4]int64)(__ccgo_up(bp)))[int32(3)], } } return int32(X__syscall_ret(tls, Uint64FromInt32(r))) @@ -114534,30 +114534,30 @@ func Xgetsubopt(tls *TLS, opt uintptr, keys uintptr, val uintptr) (r int32) { var l Tsize_t var s, v1, v2 uintptr _, _, _, _, _ = i, l, s, v1, v2 - s = *(*uintptr)(unsafe.Pointer(opt)) - *(*uintptr)(unsafe.Pointer(val)) = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(opt)) = Xstrchr(tls, s, int32(',')) - if *(*uintptr)(unsafe.Pointer(opt)) != 0 { + s = **(**uintptr)(__ccgo_up(opt)) + **(**uintptr)(__ccgo_up(val)) = UintptrFromInt32(0) + **(**uintptr)(__ccgo_up(opt)) = Xstrchr(tls, s, int32(',')) + if **(**uintptr)(__ccgo_up(opt)) != 0 { v2 = opt v1 = *(*uintptr)(unsafe.Pointer(v2)) *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(v2)) + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) } else { - *(*uintptr)(unsafe.Pointer(opt)) = s + uintptr(_strlen(tls, s)) + **(**uintptr)(__ccgo_up(opt)) = s + uintptr(_strlen(tls, s)) } i = 0 for { - if !(*(*uintptr)(unsafe.Pointer(keys + uintptr(i)*8)) != 0) { + if !(**(**uintptr)(__ccgo_up(keys + uintptr(i)*8)) != 0) { break } - l = _strlen(tls, *(*uintptr)(unsafe.Pointer(keys + uintptr(i)*8))) - if Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(keys + uintptr(i)*8)), s, l) != 0 { + l = _strlen(tls, **(**uintptr)(__ccgo_up(keys + uintptr(i)*8))) + if Xstrncmp(tls, **(**uintptr)(__ccgo_up(keys + uintptr(i)*8)), s, l) != 0 { goto _3 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(l)))) == int32('=') { - *(*uintptr)(unsafe.Pointer(val)) = s + uintptr(l) + uintptr(1) + if Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(l)))) == int32('=') { + **(**uintptr)(__ccgo_up(val)) = s + uintptr(l) + uintptr(1) } else { - if *(*uint8)(unsafe.Pointer(s + uintptr(l))) != 0 { + if **(**uint8)(__ccgo_up(s + uintptr(l))) != 0 { goto _3 } } @@ -114846,7 +114846,7 @@ func _convert_ioctl_struct(tls *TLS, map1 uintptr, old uintptr, new1 uintptr, di if !(i < Int32FromUint8((*Tioctl_compat_map)(unsafe.Pointer(map1)).Fnoffs)) { break } - ts_offset = Int32FromUint8(*(*uint8)(unsafe.Pointer(map1 + 12 + uintptr(i)))) + ts_offset = Int32FromUint8(**(**uint8)(__ccgo_up(map1 + 12 + uintptr(i)))) len1 = ts_offset - old_offset if dir == int32(W) { Xmemcpy(tls, old+uintptr(old_offset), new1+uintptr(new_offset), Uint64FromInt32(len1)) @@ -114864,11 +114864,11 @@ func _convert_ioctl_struct(tls *TLS, map1 uintptr, old uintptr, new1 uintptr, di new_offset = new_offset + (align-int32(1))&-new_offset if dir == int32(W) { Xmemcpy(tls, bp, new1+uintptr(new_offset), uint64(8)) - *(*int64)(unsafe.Pointer(bp + 8)) = *(*int64)(unsafe.Pointer(bp)) + **(**int64)(__ccgo_up(bp + 8)) = int64(**(**int64)(__ccgo_up(bp))) Xmemcpy(tls, old+uintptr(old_offset), bp+8, uint64(8)) } else { Xmemcpy(tls, bp+8, old+uintptr(old_offset), uint64(8)) - *(*int64)(unsafe.Pointer(bp)) = *(*int64)(unsafe.Pointer(bp + 8)) + **(**int64)(__ccgo_up(bp)) = int64(**(**int64)(__ccgo_up(bp + 8))) Xmemcpy(tls, new1+uintptr(new_offset), bp, uint64(8)) } new_offset = Int32FromUint64(uint64(new_offset) + Uint64FromInt64(8)) @@ -114946,31 +114946,31 @@ func Xlockf(tls *TLS, fd int32, op int32, size Toff_t) (r int32) { bp := tls.Alloc(48) defer tls.Free(48) var _ /* l at bp+0 */ Tflock - *(*Tflock)(unsafe.Pointer(bp)) = Tflock{ + **(**Tflock)(__ccgo_up(bp)) = Tflock{ Fl_type: int16(F_WRLCK), Fl_whence: int16(1), Fl_len: size, } switch op { case int32(F_TEST): - (*(*Tflock)(unsafe.Pointer(bp))).Fl_type = F_RDLCK + (**(**Tflock)(__ccgo_up(bp))).Fl_type = F_RDLCK if Xfcntl(tls, fd, int32(F_GETLK), VaList(bp+40, bp)) < 0 { return -int32(1) } - if int32((*(*Tflock)(unsafe.Pointer(bp))).Fl_type) == int32(F_UNLCK) || (*(*Tflock)(unsafe.Pointer(bp))).Fl_pid == Xgetpid(tls) { + if int32((**(**Tflock)(__ccgo_up(bp))).Fl_type) == int32(F_UNLCK) || (**(**Tflock)(__ccgo_up(bp))).Fl_pid == Xgetpid(tls) { return 0 } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EACCES) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EACCES) return -int32(1) case F_ULOCK: - (*(*Tflock)(unsafe.Pointer(bp))).Fl_type = int16(F_UNLCK) + (**(**Tflock)(__ccgo_up(bp))).Fl_type = int16(F_UNLCK) fallthrough case int32(F_TLOCK): return Xfcntl(tls, fd, int32(F_SETLK), VaList(bp+40, bp)) case int32(F_LOCK): return Xfcntl(tls, fd, int32(F_SETLKW), VaList(bp+40, bp)) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } @@ -115072,23 +115072,23 @@ func _unescape_ent(tls *TLS, beg uintptr) (r uintptr) { _, _, _, _, _, _, _ = cval, dest, i, src, val, v1, v2 dest = beg src = beg - for *(*uint8)(unsafe.Pointer(src)) != 0 { + for **(**uint8)(__ccgo_up(src)) != 0 { cval = uint8(0) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) != int32('\\') { + if Int32FromUint8(**(**uint8)(__ccgo_up(src))) != int32('\\') { v1 = dest dest = dest + 1 v2 = src src = src + 1 - *(*uint8)(unsafe.Pointer(v1)) = *(*uint8)(unsafe.Pointer(v2)) + **(**uint8)(__ccgo_up(v1)) = **(**uint8)(__ccgo_up(v2)) continue } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 1))) == int32('\\') { + if Int32FromUint8(**(**uint8)(__ccgo_up(src + 1))) == int32('\\') { src = src + 1 v1 = dest dest = dest + 1 v2 = src src = src + 1 - *(*uint8)(unsafe.Pointer(v1)) = *(*uint8)(unsafe.Pointer(v2)) + **(**uint8)(__ccgo_up(v1)) = **(**uint8)(__ccgo_up(v2)) continue } val = src + uintptr(1) @@ -115097,11 +115097,11 @@ func _unescape_ent(tls *TLS, beg uintptr) (r uintptr) { if !(i < int32(3)) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(val))) >= int32('0') && Int32FromUint8(*(*uint8)(unsafe.Pointer(val))) <= int32('7') { + if Int32FromUint8(**(**uint8)(__ccgo_up(val))) >= int32('0') && Int32FromUint8(**(**uint8)(__ccgo_up(val))) <= int32('7') { cval = Uint8FromInt32(int32(cval) << Int32FromInt32(3)) v1 = val val = val + 1 - cval = Uint8FromInt32(int32(cval) + (Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) - Int32FromUint8('0'))) + cval = Uint8FromInt32(int32(cval) + (Int32FromUint8(**(**uint8)(__ccgo_up(v1))) - Int32FromUint8('0'))) } else { break } @@ -115113,17 +115113,17 @@ func _unescape_ent(tls *TLS, beg uintptr) (r uintptr) { if cval != 0 { v1 = dest dest = dest + 1 - *(*uint8)(unsafe.Pointer(v1)) = cval + **(**uint8)(__ccgo_up(v1)) = cval src = val } else { v1 = dest dest = dest + 1 v2 = src src = src + 1 - *(*uint8)(unsafe.Pointer(v1)) = *(*uint8)(unsafe.Pointer(v2)) + **(**uint8)(__ccgo_up(v1)) = **(**uint8)(__ccgo_up(v2)) } } - *(*uint8)(unsafe.Pointer(dest)) = uint8(0) + **(**uint8)(__ccgo_up(dest)) = uint8(0) return beg } @@ -115141,7 +115141,7 @@ func Xgetmntent_r(tls *TLS, f uintptr, mnt uintptr, linebuf uintptr, buflen int3 use_internal = BoolInt32(linebuf == uintptr(unsafe.Pointer(&_internal_buf))) (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_freq = 0 (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_passno = 0 - for cond := true; cond; cond = Int32FromUint8(*(*uint8)(unsafe.Pointer(linebuf + uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[0])))) == int32('#') || Uint64FromInt32((*(*[8]int32)(unsafe.Pointer(bp)))[int32(1)]) == len1 { + for cond := true; cond; cond = Int32FromUint8(**(**uint8)(__ccgo_up(linebuf + uintptr((**(**[8]int32)(__ccgo_up(bp)))[0])))) == int32('#') || Uint64FromInt32((**(**[8]int32)(__ccgo_up(bp)))[int32(1)]) == len1 { if use_internal != 0 { Xgetline(tls, uintptr(unsafe.Pointer(&_internal_buf)), uintptr(unsafe.Pointer(&_internal_bufsize)), f) linebuf = _internal_buf @@ -115153,7 +115153,7 @@ func Xgetmntent_r(tls *TLS, f uintptr, mnt uintptr, linebuf uintptr, buflen int3 } if !(Xstrchr(tls, linebuf, int32('\n')) != 0) { Xfscanf(tls, f, __ccgo_ts+852, 0) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return uintptr(0) } len1 = _strlen(tls, linebuf) @@ -115165,7 +115165,7 @@ func Xgetmntent_r(tls *TLS, f uintptr, mnt uintptr, linebuf uintptr, buflen int3 if !(i < Uint64FromInt64(32)/Uint64FromInt64(4)) { break } - (*(*[8]int32)(unsafe.Pointer(bp)))[i] = Int32FromUint64(len1) + (**(**[8]int32)(__ccgo_up(bp)))[i] = Int32FromUint64(len1) goto _1 _1: ; @@ -115173,14 +115173,14 @@ func Xgetmntent_r(tls *TLS, f uintptr, mnt uintptr, linebuf uintptr, buflen int3 } Xsscanf(tls, linebuf, __ccgo_ts+864, VaList(bp+40, bp, bp+uintptr(1)*4, bp+uintptr(2)*4, bp+uintptr(3)*4, bp+uintptr(4)*4, bp+uintptr(5)*4, bp+uintptr(6)*4, bp+uintptr(7)*4, mnt+32, mnt+36)) } - *(*uint8)(unsafe.Pointer(linebuf + uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(1)]))) = uint8(0) - *(*uint8)(unsafe.Pointer(linebuf + uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(3)]))) = uint8(0) - *(*uint8)(unsafe.Pointer(linebuf + uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(5)]))) = uint8(0) - *(*uint8)(unsafe.Pointer(linebuf + uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(7)]))) = uint8(0) - (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_fsname = _unescape_ent(tls, linebuf+uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[0])) - (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_dir = _unescape_ent(tls, linebuf+uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(2)])) - (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_type = _unescape_ent(tls, linebuf+uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(4)])) - (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_opts = _unescape_ent(tls, linebuf+uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(6)])) + **(**uint8)(__ccgo_up(linebuf + uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(1)]))) = uint8(0) + **(**uint8)(__ccgo_up(linebuf + uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(3)]))) = uint8(0) + **(**uint8)(__ccgo_up(linebuf + uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(5)]))) = uint8(0) + **(**uint8)(__ccgo_up(linebuf + uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(7)]))) = uint8(0) + (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_fsname = _unescape_ent(tls, linebuf+uintptr((**(**[8]int32)(__ccgo_up(bp)))[0])) + (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_dir = _unescape_ent(tls, linebuf+uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(2)])) + (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_type = _unescape_ent(tls, linebuf+uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(4)])) + (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_opts = _unescape_ent(tls, linebuf+uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(6)])) return mnt } @@ -115237,39 +115237,39 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag var _ /* st at bp+0 */ Tstat _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, de, dfd, err, j, k, l, r, type1, v1, v10, v2, v3, v8 l = _strlen(tls, path) - if l != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(path + uintptr(l-uint64(1))))) == int32('/') { + if l != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(path + uintptr(l-uint64(1))))) == int32('/') { v1 = l - uint64(1) } else { v1 = l } j = v1 v2 = Uint64FromInt32(0) - (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino = v2 - (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev = v2 + (**(**Tstat)(__ccgo_up(bp))).Fst_ino = v2 + (**(**Tstat)(__ccgo_up(bp))).Fst_dev = v2 if flags&int32(FTW_PHYS) != 0 { v3 = Xlstat(tls, path, bp) } else { v3 = BoolInt32(Xstat(tls, path, bp) < 0) } if v3 != 0 { - if !(flags&Int32FromInt32(FTW_PHYS) != 0) && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENOENT) && !(Xlstat(tls, path, bp) != 0) { + if !(flags&Int32FromInt32(FTW_PHYS) != 0) && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENOENT) && !(Xlstat(tls, path, bp) != 0) { type1 = int32(FTW_SLN) } else { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(EACCES) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(EACCES) { return -int32(1) } else { type1 = int32(FTW_NS) } } } else { - if (*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFDIR) { + if (**(**Tstat)(__ccgo_up(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFDIR) { if flags&int32(FTW_DEPTH) != 0 { type1 = int32(FTW_DP) } else { type1 = int32(FTW_D) } } else { - if (*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { + if (**(**Tstat)(__ccgo_up(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { if flags&int32(FTW_PHYS) != 0 { type1 = int32(FTW_SL) } else { @@ -115280,26 +115280,26 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag } } } - if flags&int32(FTW_MOUNT) != 0 && h != 0 && type1 != int32(FTW_NS) && (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev != (*Thistory)(unsafe.Pointer(h)).Fdev { + if flags&int32(FTW_MOUNT) != 0 && h != 0 && type1 != int32(FTW_NS) && (**(**Tstat)(__ccgo_up(bp))).Fst_dev != (*Thistory)(unsafe.Pointer(h)).Fdev { return 0 } - (*(*Thistory)(unsafe.Pointer(bp + 128))).Fchain = h - (*(*Thistory)(unsafe.Pointer(bp + 128))).Fdev = (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev - (*(*Thistory)(unsafe.Pointer(bp + 128))).Fino = (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino + (**(**Thistory)(__ccgo_up(bp + 128))).Fchain = h + (**(**Thistory)(__ccgo_up(bp + 128))).Fdev = (**(**Tstat)(__ccgo_up(bp))).Fst_dev + (**(**Thistory)(__ccgo_up(bp + 128))).Fino = (**(**Tstat)(__ccgo_up(bp))).Fst_ino if h != 0 { v3 = (*Thistory)(unsafe.Pointer(h)).Flevel + int32(1) } else { v3 = 0 } - (*(*Thistory)(unsafe.Pointer(bp + 128))).Flevel = v3 - (*(*Thistory)(unsafe.Pointer(bp + 128))).Fbase = Int32FromUint64(j + uint64(1)) - (*(*TFTW)(unsafe.Pointer(bp + 160))).Flevel = (*(*Thistory)(unsafe.Pointer(bp + 128))).Flevel + (**(**Thistory)(__ccgo_up(bp + 128))).Flevel = v3 + (**(**Thistory)(__ccgo_up(bp + 128))).Fbase = Int32FromUint64(j + uint64(1)) + (**(**TFTW)(__ccgo_up(bp + 160))).Flevel = (**(**Thistory)(__ccgo_up(bp + 128))).Flevel if h != 0 { - (*(*TFTW)(unsafe.Pointer(bp + 160))).Fbase = (*Thistory)(unsafe.Pointer(h)).Fbase + (**(**TFTW)(__ccgo_up(bp + 160))).Fbase = (*Thistory)(unsafe.Pointer(h)).Fbase } else { k = j for { - if !(k != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(path + uintptr(k)))) == int32('/')) { + if !(k != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(path + uintptr(k)))) == int32('/')) { break } goto _5 @@ -115308,7 +115308,7 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag k = k - 1 } for { - if !(k != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(path + uintptr(k-uint64(1))))) != int32('/')) { + if !(k != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(path + uintptr(k-uint64(1))))) != int32('/')) { break } goto _6 @@ -115316,11 +115316,11 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag ; k = k - 1 } - (*(*TFTW)(unsafe.Pointer(bp + 160))).Fbase = Int32FromUint64(k) + (**(**TFTW)(__ccgo_up(bp + 160))).Fbase = Int32FromUint64(k) } if type1 == int32(FTW_D) || type1 == int32(FTW_DP) { dfd = Xopen(tls, path, O_RDONLY, 0) - err = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + err = **(**int32)(__ccgo_up(X__errno_location(tls))) if dfd < 0 && err == int32(EACCES) { type1 = int32(FTW_DNR) } @@ -115339,7 +115339,7 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag if !(h != 0) { break } - if (*Thistory)(unsafe.Pointer(h)).Fdev == (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev && (*Thistory)(unsafe.Pointer(h)).Fino == (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino { + if (*Thistory)(unsafe.Pointer(h)).Fdev == (**(**Tstat)(__ccgo_up(bp))).Fst_dev && (*Thistory)(unsafe.Pointer(h)).Fino == (**(**Tstat)(__ccgo_up(bp))).Fst_ino { return 0 } goto _9 @@ -115349,7 +115349,7 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag } if (type1 == int32(FTW_D) || type1 == int32(FTW_DP)) && fd_limit != 0 { if dfd < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = err + **(**int32)(__ccgo_up(X__errno_location(tls))) = err return -int32(1) } d = Xfdopendir(tls, dfd) @@ -115360,15 +115360,15 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag if !(v10 != 0) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(de + 19))) == int32('.') && (!(*(*uint8)(unsafe.Pointer(de + 19 + 1)) != 0) || Int32FromUint8(*(*uint8)(unsafe.Pointer(de + 19 + 1))) == int32('.') && !(*(*uint8)(unsafe.Pointer(de + 19 + 2)) != 0)) { + if Int32FromUint8(**(**uint8)(__ccgo_up(de + 19))) == int32('.') && (!(**(**uint8)(__ccgo_up(de + 19 + 1)) != 0) || Int32FromUint8(**(**uint8)(__ccgo_up(de + 19 + 1))) == int32('.') && !(**(**uint8)(__ccgo_up(de + 19 + 2)) != 0)) { continue } if _strlen(tls, de+19) >= uint64(PATH_MAX)-l { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENAMETOOLONG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENAMETOOLONG) Xclosedir(tls, d) return -int32(1) } - *(*uint8)(unsafe.Pointer(path + uintptr(j))) = uint8('/') + **(**uint8)(__ccgo_up(path + uintptr(j))) = uint8('/') Xstrcpy(tls, path+uintptr(j)+uintptr(1), de+19) v3 = _do_nftw(tls, path, __ccgo_fp_fn, fd_limit-int32(1), flags, bp+128) r = v3 @@ -115383,7 +115383,7 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag return -int32(1) } } - *(*uint8)(unsafe.Pointer(path + uintptr(l))) = uint8(0) + **(**uint8)(__ccgo_up(path + uintptr(l))) = uint8(0) if v8 = flags&int32(FTW_DEPTH) != 0; v8 { v3 = (*(*func(*TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_fn})))(tls, path, bp, type1, bp+160) r = v3 @@ -115413,13 +115413,13 @@ func Xnftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flags i } l = _strlen(tls, path) if l > uint64(PATH_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENAMETOOLONG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENAMETOOLONG) return -int32(1) } Xmemcpy(tls, bp+4, path, l+uint64(1)) _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp) r = _do_nftw(tls, bp+4, __ccgo_fp_fn, fd_limit, flags, UintptrFromInt32(0)) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) return r } @@ -115437,7 +115437,7 @@ func Xopenpty(tls *TLS, pm uintptr, ps uintptr, name uintptr, tio uintptr, ws ui var _ /* cs at bp+4 */ int32 var _ /* n at bp+0 */ int32 _, _, _ = m, s, v1 - *(*int32)(unsafe.Pointer(bp)) = 0 + **(**int32)(__ccgo_up(bp)) = 0 m = Xopen(tls, __ccgo_ts+938, Int32FromInt32(O_RDWR)|Int32FromInt32(O_NOCTTY), 0) if m < 0 { return -int32(1) @@ -115449,7 +115449,7 @@ func Xopenpty(tls *TLS, pm uintptr, ps uintptr, name uintptr, tio uintptr, ws ui if !(name != 0) { name = bp + 8 } - Xsnprintf(tls, name, uint64(20), __ccgo_ts+948, VaList(bp+40, *(*int32)(unsafe.Pointer(bp)))) + Xsnprintf(tls, name, uint64(20), __ccgo_ts+948, VaList(bp+40, **(**int32)(__ccgo_up(bp)))) v1 = Xopen(tls, name, Int32FromInt32(O_RDWR)|Int32FromInt32(O_NOCTTY), 0) s = v1 if v1 < 0 { @@ -115461,15 +115461,15 @@ func Xopenpty(tls *TLS, pm uintptr, ps uintptr, name uintptr, tio uintptr, ws ui if ws != 0 { Xioctl(tls, s, int32(TIOCSWINSZ), VaList(bp+40, ws)) } - *(*int32)(unsafe.Pointer(pm)) = m - *(*int32)(unsafe.Pointer(ps)) = s - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 4)), uintptr(0)) + **(**int32)(__ccgo_up(pm)) = m + **(**int32)(__ccgo_up(ps)) = s + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 4)), uintptr(0)) return 0 goto fail fail: ; Xclose(tls, m) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 4)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 4)), uintptr(0)) return -int32(1) } @@ -115482,7 +115482,7 @@ func Xptsname(tls *TLS, fd int32) (r uintptr) { _ = err err = X__ptsname_r(tls, fd, uintptr(unsafe.Pointer(&_buf2)), uint64(22)) if err != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = err + **(**int32)(__ccgo_up(X__errno_location(tls))) = err return uintptr(0) } return uintptr(unsafe.Pointer(&_buf2)) @@ -115498,8 +115498,8 @@ func Xposix_openpt(tls *TLS, flags int32) (r1 int32) { var r int32 _ = r r = Xopen(tls, __ccgo_ts+938, flags, 0) - if r < 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENOSPC) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EAGAIN) + if r < 0 && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENOSPC) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EAGAIN) } return r } @@ -115520,7 +115520,7 @@ func Xunlockpt(tls *TLS, fd int32) (r int32) { bp := tls.Alloc(32) defer tls.Free(32) var _ /* unlock at bp+0 */ int32 - *(*int32)(unsafe.Pointer(bp)) = 0 + **(**int32)(__ccgo_up(bp)) = 0 return Xioctl(tls, fd, int32(TIOCSPTLCK), VaList(bp+16, bp)) } @@ -115542,7 +115542,7 @@ func X__ptsname_r(tls *TLS, fd int32, buf uintptr, len1 Tsize_t) (r int32) { if v1 != 0 { return -err } - if Uint64FromInt32(Xsnprintf(tls, buf, len1, __ccgo_ts+948, VaList(bp+16, *(*int32)(unsafe.Pointer(bp))))) >= len1 { + if Uint64FromInt32(Xsnprintf(tls, buf, len1, __ccgo_ts+948, VaList(bp+16, **(**int32)(__ccgo_up(bp))))) >= len1 { return int32(ERANGE) } return 0 @@ -115560,7 +115560,7 @@ func _slash_len(tls *TLS, s uintptr) (r Tsize_t) { var s0 uintptr _ = s0 s0 = s - for Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('/') { + for Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('/') { s = s + 1 } return Uint64FromInt64(int64(s) - int64(s0)) @@ -115584,12 +115584,12 @@ func Xrealpath(tls *TLS, filename uintptr, resolved uintptr) (r uintptr) { nup = uint64(0) check_dir = 0 if !(filename != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } l = Xstrnlen(tls, filename, uint64(4097)) if !(l != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOENT) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOENT) return uintptr(0) } if l >= uint64(PATH_MAX) { @@ -115609,19 +115609,19 @@ _3: ; /* If stack starts with /, the whole component is / or // * and the output state must be reset. */ - if Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p]) == int32('/') { + if Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[p]) == int32('/') { check_dir = 0 nup = uint64(0) q = uint64(0) v4 = q q = q + 1 - (*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[v4] = uint8('/') + (**(**[4096]uint8)(__ccgo_up(bp + 4097)))[v4] = uint8('/') p = p + 1 /* Initial // is special. */ - if Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p]) == int32('/') && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p+uint64(1)]) != int32('/') { + if Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[p]) == int32('/') && Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[p+uint64(1)]) != int32('/') { v4 = q q = q + 1 - (*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[v4] = uint8('/') + (**(**[4096]uint8)(__ccgo_up(bp + 4097)))[v4] = uint8('/') } goto _2 } @@ -115633,30 +115633,30 @@ _3: goto _1 } /* Skip any . component but preserve check_dir status. */ - if l == uint64(1) && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p]) == int32('.') { + if l == uint64(1) && Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[p]) == int32('.') { p = p + l goto _2 } /* Copy next component onto output at least temporarily, to * call readlink, but wait to advance output position until * determining it's not a link. */ - if q != 0 && Int32FromUint8((*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[q-uint64(1)]) != int32('/') { + if q != 0 && Int32FromUint8((**(**[4096]uint8)(__ccgo_up(bp + 4097)))[q-uint64(1)]) != int32('/') { if !(p != 0) { goto toolong } p = p - 1 v4 = p - (*(*[4097]uint8)(unsafe.Pointer(bp)))[v4] = uint8('/') + (**(**[4097]uint8)(__ccgo_up(bp)))[v4] = uint8('/') l = l + 1 } if q+l >= uint64(PATH_MAX) { goto toolong } Xmemcpy(tls, bp+4097+uintptr(q), bp+uintptr(p), l) - (*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[q+l] = uint8(0) + (**(**[4096]uint8)(__ccgo_up(bp + 4097)))[q+l] = uint8(0) p = p + l up = 0 - if l0 == uint64(2) && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p-uint64(2)]) == int32('.') && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p-uint64(1)]) == int32('.') { + if l0 == uint64(2) && Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[p-uint64(2)]) == int32('.') && Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[p-uint64(1)]) == int32('.') { up = int32(1) /* Any non-.. path components we could cancel start * after nup repetitions of the 3-byte string "../"; @@ -115678,13 +115678,13 @@ _3: goto toolong } if !(k != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOENT) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOENT) return uintptr(0) } if !(k < 0) { goto _8 } - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(EINVAL) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(EINVAL) { return uintptr(0) } goto skip_readlink @@ -115692,10 +115692,10 @@ skip_readlink: ; check_dir = 0 if up != 0 { - for q != 0 && Int32FromUint8((*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[q-uint64(1)]) != int32('/') { + for q != 0 && Int32FromUint8((**(**[4096]uint8)(__ccgo_up(bp + 4097)))[q-uint64(1)]) != int32('/') { q = q - 1 } - if q > uint64(1) && (q > uint64(2) || Int32FromUint8((*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[0]) != int32('/')) { + if q > uint64(1) && (q > uint64(2) || Int32FromUint8((**(**[4096]uint8)(__ccgo_up(bp + 4097)))[0]) != int32('/')) { q = q - 1 } goto _2 @@ -115703,20 +115703,20 @@ skip_readlink: if l0 != 0 { q = q + l } - check_dir = Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p]) + check_dir = Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[p]) goto _2 _8: ; cnt = cnt + 1 v4 = cnt if v4 == uint64(SYMLOOP_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ELOOP) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ELOOP) return uintptr(0) } /* If link contents end in /, strip any slashes already on * stack to avoid /->// or //->/// or spurious toolong. */ - if Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[k-int64(1)]) == int32('/') { - for Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p]) == int32('/') { + if Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[k-int64(1)]) == int32('/') { + for Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[p]) == int32('/') { p = p + 1 } } @@ -115733,8 +115733,8 @@ _2: goto _1 _1: ; - (*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[q] = uint8(0) - if Int32FromUint8((*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[0]) != int32('/') { + (**(**[4096]uint8)(__ccgo_up(bp + 4097)))[q] = uint8(0) + if Int32FromUint8((**(**[4096]uint8)(__ccgo_up(bp + 4097)))[0]) != int32('/') { if !(Xgetcwd(tls, bp, uint64(4097)) != 0) { return uintptr(0) } @@ -115747,7 +115747,7 @@ _1: if !(v4 != 0) { break } - for l > uint64(1) && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[l-uint64(1)]) != int32('/') { + for l > uint64(1) && Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[l-uint64(1)]) != int32('/') { l = l - 1 } if l > uint64(1) { @@ -115758,10 +115758,10 @@ _1: p = p + 1 } } - if q-p != 0 && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[l-uint64(1)]) != int32('/') { + if q-p != 0 && Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[l-uint64(1)]) != int32('/') { v4 = l l = l + 1 - (*(*[4097]uint8)(unsafe.Pointer(bp)))[v4] = uint8('/') + (**(**[4097]uint8)(__ccgo_up(bp)))[v4] = uint8('/') } if l+(q-p)+uint64(1) >= uint64(PATH_MAX) { goto toolong @@ -115778,7 +115778,7 @@ _1: goto toolong toolong: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENAMETOOLONG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENAMETOOLONG) return uintptr(0) } @@ -115827,12 +115827,12 @@ func Xsetrlimit(tls *TLS, resource int32, rlim uintptr) (r int32) { var _ /* tmp at bp+0 */ Trlimit _, _, _ = ret, v1, v2 if ^Uint64FromUint64(0) != ^Uint64FromUint64(0) { - *(*Trlimit)(unsafe.Pointer(bp)) = *(*Trlimit)(unsafe.Pointer(rlim)) - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur >= ^Uint64FromUint64(0) { - (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur = ^Uint64FromUint64(0) + **(**Trlimit)(__ccgo_up(bp)) = **(**Trlimit)(__ccgo_up(rlim)) + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur >= ^Uint64FromUint64(0) { + (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur = ^Uint64FromUint64(0) } - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_max >= ^Uint64FromUint64(0) { - (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_max = ^Uint64FromUint64(0) + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_max >= ^Uint64FromUint64(0) { + (**(**Trlimit)(__ccgo_up(bp))).Frlim_max = ^Uint64FromUint64(0) } rlim = bp } @@ -115850,7 +115850,7 @@ func Xsetrlimit(tls *TLS, resource int32, rlim uintptr) (r int32) { } else { v2 = ^Uint64FromUint64(0) } - *(*Tctx)(unsafe.Pointer(bp + 16)) = Tctx{ + **(**Tctx)(__ccgo_up(bp + 16)) = Tctx{ Flim: [2]uint64{ 0: v1, 1: v2, @@ -115859,9 +115859,9 @@ func Xsetrlimit(tls *TLS, resource int32, rlim uintptr) (r int32) { Ferr: -int32(1), } ___synccall(tls, __ccgo_fp(_do_setrlimit), bp+16) - if (*(*Tctx)(unsafe.Pointer(bp + 16))).Ferr != 0 { - if (*(*Tctx)(unsafe.Pointer(bp + 16))).Ferr > 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = (*(*Tctx)(unsafe.Pointer(bp + 16))).Ferr + if (**(**Tctx)(__ccgo_up(bp + 16))).Ferr != 0 { + if (**(**Tctx)(__ccgo_up(bp + 16))).Ferr > 0 { + **(**int32)(__ccgo_up(X__errno_location(tls))) = (**(**Tctx)(__ccgo_up(bp + 16))).Ferr } return -int32(1) } @@ -116241,7 +116241,7 @@ func Xcloselog(tls *TLS) { Xclose(tls, _log_fd) _log_fd = -int32(1) ___unlock(tls, uintptr(unsafe.Pointer(&_lock2))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) } func ___openlog(tls *TLS) { @@ -116275,7 +116275,7 @@ func Xopenlog(tls *TLS, ident uintptr, opt int32, facility int32) { ___openlog(tls) } ___unlock(tls, uintptr(unsafe.Pointer(&_lock2))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) } func _is_lost_conn(tls *TLS, e int32) (r int32) { @@ -116292,14 +116292,14 @@ func __vsyslog(tls *TLS, priority int32, message uintptr, ap Tva_list) { var _ /* timebuf at bp+0 */ [16]uint8 var _ /* tm at bp+24 */ Ttm _, _, _, _, _, _ = errno_save, fd, l, l2, pid, v1 - errno_save = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + errno_save = **(**int32)(__ccgo_up(X__errno_location(tls))) if _log_fd < 0 { ___openlog(tls) } if !(priority&Int32FromInt32(LOG_FACMASK) != 0) { priority = priority | _log_facility } - *(*Ttime_t)(unsafe.Pointer(bp + 16)) = Xtime(tls, UintptrFromInt32(0)) + **(**Ttime_t)(__ccgo_up(bp + 16)) = Xtime(tls, UintptrFromInt32(0)) Xgmtime_r(tls, bp+16, bp+24) Xstrftime_l(tls, bp, uint64(16), __ccgo_ts+960, bp+24, uintptr(unsafe.Pointer(&X__c_locale))) if _log_opt&int32(LOG_PID) != 0 { @@ -116309,7 +116309,7 @@ func __vsyslog(tls *TLS, priority int32, message uintptr, ap Tva_list) { } pid = v1 l = Xsnprintf(tls, bp+80, uint64(1024), __ccgo_ts+969, VaList(bp+1120, priority, bp, bp+1104, uintptr(unsafe.Pointer(&_log_ident)), __ccgo_ts+991+BoolUintptr(!(pid != 0)), pid, __ccgo_ts+993+BoolUintptr(!(pid != 0)))) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = errno_save + **(**int32)(__ccgo_up(X__errno_location(tls))) = errno_save l2 = Xvsnprintf(tls, bp+80+uintptr(l), uint64(1024)-Uint64FromInt32(l), message, ap) if l2 >= 0 { if Uint64FromInt32(l2) >= uint64(1024)-Uint64FromInt32(l) { @@ -116317,20 +116317,20 @@ func __vsyslog(tls *TLS, priority int32, message uintptr, ap Tva_list) { } else { l = l + l2 } - if Int32FromUint8((*(*[1024]uint8)(unsafe.Pointer(bp + 80)))[l-int32(1)]) != int32('\n') { + if Int32FromUint8((**(**[1024]uint8)(__ccgo_up(bp + 80)))[l-int32(1)]) != int32('\n') { v1 = l l = l + 1 - (*(*[1024]uint8)(unsafe.Pointer(bp + 80)))[v1] = uint8('\n') + (**(**[1024]uint8)(__ccgo_up(bp + 80)))[v1] = uint8('\n') } - if Xsend(tls, _log_fd, bp+80, Uint64FromInt32(l), 0) < 0 && (!(_is_lost_conn(tls, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) != 0) || Xconnect(tls, _log_fd, uintptr(unsafe.Pointer(&_log_addr)), uint32(12)) < 0 || Xsend(tls, _log_fd, bp+80, Uint64FromInt32(l), 0) < 0) && _log_opt&int32(LOG_CONS) != 0 { + if Xsend(tls, _log_fd, bp+80, Uint64FromInt32(l), 0) < 0 && (!(_is_lost_conn(tls, **(**int32)(__ccgo_up(X__errno_location(tls)))) != 0) || Xconnect(tls, _log_fd, uintptr(unsafe.Pointer(&_log_addr)), uint32(12)) < 0 || Xsend(tls, _log_fd, bp+80, Uint64FromInt32(l), 0) < 0) && _log_opt&int32(LOG_CONS) != 0 { fd = Xopen(tls, __ccgo_ts+688, Int32FromInt32(O_WRONLY)|Int32FromInt32(O_NOCTTY)|Int32FromInt32(O_CLOEXEC), 0) if fd >= 0 { - Xdprintf(tls, fd, __ccgo_ts+995, VaList(bp+1120, l-*(*int32)(unsafe.Pointer(bp + 1104)), bp+80+uintptr(*(*int32)(unsafe.Pointer(bp + 1104))))) + Xdprintf(tls, fd, __ccgo_ts+995, VaList(bp+1120, l-**(**int32)(__ccgo_up(bp + 1104)), bp+80+uintptr(**(**int32)(__ccgo_up(bp + 1104))))) Xclose(tls, fd) } } if _log_opt&int32(LOG_PERROR) != 0 { - Xdprintf(tls, int32(2), __ccgo_ts+995, VaList(bp+1120, l-*(*int32)(unsafe.Pointer(bp + 1104)), bp+80+uintptr(*(*int32)(unsafe.Pointer(bp + 1104))))) + Xdprintf(tls, int32(2), __ccgo_ts+995, VaList(bp+1120, l-**(**int32)(__ccgo_up(bp + 1104)), bp+80+uintptr(**(**int32)(__ccgo_up(bp + 1104))))) } } } @@ -116346,7 +116346,7 @@ func ___vsyslog(tls *TLS, priority int32, message uintptr, ap Tva_list) { ___lock(tls, uintptr(unsafe.Pointer(&_lock2))) __vsyslog(tls, priority, message, ap) ___unlock(tls, uintptr(unsafe.Pointer(&_lock2))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) } func Xsyslog(tls *TLS, priority int32, message uintptr, va uintptr) { @@ -116431,11 +116431,11 @@ func X__mmap(tls *TLS, start uintptr, len1 Tsize_t, prot int32, flags int32, fd var ret int64 _ = ret if Uint64FromInt64(off)&(-Uint64FromUint64(0x2000)<<(Uint64FromInt32(8)*Uint64FromInt64(8)-Uint64FromInt32(1))|(Uint64FromUint64(4096)-Uint64FromInt32(1))) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(-Int32FromInt32(1)) } if len1 >= Uint64FromInt64(Int64FromInt64(INT64_MAX)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return uintptr(-Int32FromInt32(1)) } if flags&int32(MAP_FIXED) != 0 { @@ -116490,7 +116490,7 @@ func X__mremap(tls *TLS, old_addr uintptr, old_len Tsize_t, new_len Tsize_t, fla _, _ = ap, new_addr new_addr = uintptr(0) if new_len >= Uint64FromInt64(Int64FromInt64(INT64_MAX)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return uintptr(-Int32FromInt32(1)) } if flags&int32(MREMAP_FIXED) != 0 { @@ -116572,17 +116572,17 @@ func X__shm_mapname(tls *TLS, name uintptr, buf uintptr) (r uintptr) { } var p, v1 uintptr _, _ = p, v1 - for Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) == int32('/') { + for Int32FromUint8(**(**uint8)(__ccgo_up(name))) == int32('/') { name = name + 1 } v1 = X__strchrnul(tls, name, int32('/')) p = v1 - if *(*uint8)(unsafe.Pointer(v1)) != 0 || p == name || int64(p)-int64(name) <= int64(2) && Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) == int32('.') && Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) == int32('.') { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if **(**uint8)(__ccgo_up(v1)) != 0 || p == name || int64(p)-int64(name) <= int64(2) && Int32FromUint8(**(**uint8)(__ccgo_up(name))) == int32('.') && Int32FromUint8(**(**uint8)(__ccgo_up(p + uintptr(-Int32FromInt32(1))))) == int32('.') { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } if int64(p)-int64(name) > int64(NAME_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENAMETOOLONG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENAMETOOLONG) return uintptr(0) } Xmemcpy(tls, buf, __ccgo_ts+1000, uint64(9)) @@ -116609,7 +116609,7 @@ func Xshm_open(tls *TLS, name uintptr, flag int32, mode Tmode_t) (r int32) { } _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp) fd = Xopen(tls, name, flag|int32(O_NOFOLLOW)|int32(O_CLOEXEC)|int32(O_NONBLOCK), VaList(bp+280, mode)) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) return fd } @@ -116647,7 +116647,7 @@ func Xbtowc(tls *TLS, c int32) (r Twint_t) { if Uint32FromInt32(b) < uint32(128) { v1 = Uint32FromInt32(b) } else { - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v3 = int32(4) } else { v3 = int32(1) @@ -116679,22 +116679,22 @@ func Xc16rtomb(tls *TLS, s uintptr, c16 Tchar16_t, ps uintptr) (r Tsize_t) { } x = ps if !(s != 0) { - if *(*uint32)(unsafe.Pointer(x)) != 0 { + if **(**uint32)(__ccgo_up(x)) != 0 { goto ilseq } return uint64(1) } - if !(*(*uint32)(unsafe.Pointer(x)) != 0) && uint32(c16)-uint32(0xd800) < uint32(0x400) { - *(*uint32)(unsafe.Pointer(x)) = Uint32FromInt32((Int32FromUint16(c16) - int32(0xd7c0)) << int32(10)) + if !(**(**uint32)(__ccgo_up(x)) != 0) && uint32(c16)-uint32(0xd800) < uint32(0x400) { + **(**uint32)(__ccgo_up(x)) = Uint32FromInt32((Int32FromUint16(c16) - int32(0xd7c0)) << int32(10)) return uint64(0) } - if *(*uint32)(unsafe.Pointer(x)) != 0 { + if **(**uint32)(__ccgo_up(x)) != 0 { if uint32(c16)-uint32(0xdc00) >= uint32(0x400) { goto ilseq } else { - wc = Int32FromUint32(*(*uint32)(unsafe.Pointer(x)) + uint32(c16) - uint32(0xdc00)) + wc = Int32FromUint32(**(**uint32)(__ccgo_up(x)) + uint32(c16) - uint32(0xdc00)) } - *(*uint32)(unsafe.Pointer(x)) = uint32(0) + **(**uint32)(__ccgo_up(x)) = uint32(0) } else { wc = Int32FromUint16(c16) } @@ -116702,8 +116702,8 @@ func Xc16rtomb(tls *TLS, s uintptr, c16 Tchar16_t, ps uintptr) (r Tsize_t) { goto ilseq ilseq: ; - *(*uint32)(unsafe.Pointer(x)) = uint32(0) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EILSEQ) + **(**uint32)(__ccgo_up(x)) = uint32(0) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EILSEQ) return Uint64FromInt32(-Int32FromInt32(1)) } @@ -116762,21 +116762,21 @@ func Xmbrtoc16(tls *TLS, pc16 uintptr, s uintptr, n Tsize_t, ps uintptr) (r Tsiz } /* mbrtowc states for partial UTF-8 characters have the high bit set; * we use nonzero states without high bit for pending surrogates. */ - if Int32FromUint32(*(*uint32)(unsafe.Pointer(pending))) > 0 { + if Int32FromUint32(**(**uint32)(__ccgo_up(pending))) > 0 { if pc16 != 0 { - *(*Tchar16_t)(unsafe.Pointer(pc16)) = uint16(*(*uint32)(unsafe.Pointer(pending))) + **(**Tchar16_t)(__ccgo_up(pc16)) = uint16(**(**uint32)(__ccgo_up(pending))) } - *(*uint32)(unsafe.Pointer(pending)) = uint32(0) + **(**uint32)(__ccgo_up(pending)) = uint32(0) return Uint64FromInt32(-Int32FromInt32(3)) } ret = Xmbrtowc(tls, bp, s, n, ps) if ret <= uint64(4) { - if *(*Twchar_t)(unsafe.Pointer(bp)) >= int32(0x10000) { - *(*uint32)(unsafe.Pointer(pending)) = Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))&int32(0x3ff) + int32(0xdc00)) - *(*Twchar_t)(unsafe.Pointer(bp)) = int32(0xd7c0) + *(*Twchar_t)(unsafe.Pointer(bp))>>Int32FromInt32(10) + if **(**Twchar_t)(__ccgo_up(bp)) >= int32(0x10000) { + **(**uint32)(__ccgo_up(pending)) = Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))&int32(0x3ff) + int32(0xdc00)) + **(**Twchar_t)(__ccgo_up(bp)) = int32(0xd7c0) + **(**Twchar_t)(__ccgo_up(bp))>>Int32FromInt32(10) } if pc16 != 0 { - *(*Tchar16_t)(unsafe.Pointer(pc16)) = Uint16FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))) + **(**Tchar16_t)(__ccgo_up(pc16)) = Uint16FromInt32(**(**Twchar_t)(__ccgo_up(bp))) } } return ret @@ -116802,7 +116802,7 @@ func Xmbrtoc32(tls *TLS, pc32 uintptr, s uintptr, n Tsize_t, ps uintptr) (r Tsiz } ret = Xmbrtowc(tls, bp, s, n, ps) if ret <= uint64(4) && pc32 != 0 { - *(*Tchar32_t)(unsafe.Pointer(pc32)) = Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))) + **(**Tchar32_t)(__ccgo_up(pc32)) = Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))) } return ret } @@ -116828,7 +116828,7 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize if !(st != 0) { st = uintptr(unsafe.Pointer(&_internal_state3)) } - c = *(*uint32)(unsafe.Pointer(st)) + c = **(**uint32)(__ccgo_up(st)) if !(s != 0) { if c != 0 { goto ilseq @@ -116843,30 +116843,30 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize return Uint64FromInt32(-Int32FromInt32(2)) } if !(c != 0) { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) < int32(0x80) { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) - *(*Twchar_t)(unsafe.Pointer(wc)) = v1 + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) < int32(0x80) { + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(s))) + **(**Twchar_t)(__ccgo_up(wc)) = v1 return BoolUint64(!!(v1 != 0)) } - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v2 = int32(4) } else { v2 = int32(1) } if v2 == int32(1) { - *(*Twchar_t)(unsafe.Pointer(wc)) = Int32FromInt32(0xdfff) & int32(Int8FromUint8(*(*uint8)(unsafe.Pointer(s)))) + **(**Twchar_t)(__ccgo_up(wc)) = Int32FromInt32(0xdfff) & int32(Int8FromUint8(**(**uint8)(__ccgo_up(s)))) return Uint64FromInt32(1) } - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { goto ilseq } v3 = s s = s + 1 - c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v3)))-uint32(0xc2)] + c = X__fsmu8[uint32(**(**uint8)(__ccgo_up(v3)))-uint32(0xc2)] n = n - 1 } if n != 0 { - if (Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { + if (Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { goto ilseq } goto loop @@ -116874,27 +116874,27 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize ; v3 = s s = s + 1 - c = c<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { goto ilseq } goto loop } } - *(*uint32)(unsafe.Pointer(st)) = c + **(**uint32)(__ccgo_up(st)) = c return Uint64FromInt32(-Int32FromInt32(2)) goto ilseq ilseq: ; - *(*uint32)(unsafe.Pointer(st)) = uint32(0) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EILSEQ) + **(**uint32)(__ccgo_up(st)) = uint32(0) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EILSEQ) return Uint64FromInt32(-Int32FromInt32(1)) } @@ -116905,7 +116905,7 @@ func Xmbsinit(tls *TLS, st uintptr) (r int32) { trc("tls=%v st=%v, (%v:)", tls, st, origin(2)) defer func() { trc("-> %v", r) }() } - return BoolInt32(!(st != 0) || !(*(*uint32)(unsafe.Pointer(st)) != 0)) + return BoolInt32(!(st != 0) || !(**(**uint32)(__ccgo_up(st)) != 0)) } func Xmbsnrtowcs(tls *TLS, wcs uintptr, src uintptr, n Tsize_t, wn Tsize_t, st uintptr) (r Tsize_t) { @@ -116923,7 +116923,7 @@ func Xmbsnrtowcs(tls *TLS, wcs uintptr, src uintptr, n Tsize_t, wn Tsize_t, st u var _ /* wbuf at bp+0 */ [256]Twchar_t _, _, _, _, _, _, _, _ = cnt, l, n2, tmp_s, ws, v1, v2, v3 cnt = uint64(0) - *(*uintptr)(unsafe.Pointer(bp + 1024)) = *(*uintptr)(unsafe.Pointer(src)) + **(**uintptr)(__ccgo_up(bp + 1024)) = **(**uintptr)(__ccgo_up(src)) if !(wcs != 0) { ws = bp wn = Uint64FromInt64(1024) / Uint64FromInt64(4) @@ -116934,7 +116934,7 @@ func Xmbsnrtowcs(tls *TLS, wcs uintptr, src uintptr, n Tsize_t, wn Tsize_t, st u * that mbsrtowcs never reads more than n input bytes. thus * we can use mbsrtowcs as long as it's practical.. */ for { - if v2 = *(*uintptr)(unsafe.Pointer(bp + 1024)) != 0 && wn != 0; v2 { + if v2 = **(**uintptr)(__ccgo_up(bp + 1024)) != 0 && wn != 0; v2 { v1 = n / Uint64FromInt32(4) n2 = v1 } @@ -116944,7 +116944,7 @@ func Xmbsnrtowcs(tls *TLS, wcs uintptr, src uintptr, n Tsize_t, wn Tsize_t, st u if n2 >= wn { n2 = wn } - tmp_s = *(*uintptr)(unsafe.Pointer(bp + 1024)) + tmp_s = **(**uintptr)(__ccgo_up(bp + 1024)) l = Xmbsrtowcs(tls, ws, bp+1024, n2, st) if !(l+Uint64FromInt32(1) != 0) { cnt = l @@ -116955,31 +116955,31 @@ func Xmbsnrtowcs(tls *TLS, wcs uintptr, src uintptr, n Tsize_t, wn Tsize_t, st u ws = ws + uintptr(l)*4 wn = wn - l } - if *(*uintptr)(unsafe.Pointer(bp + 1024)) != 0 { - v3 = n - Uint64FromInt64(int64(*(*uintptr)(unsafe.Pointer(bp + 1024)))-int64(tmp_s)) + if **(**uintptr)(__ccgo_up(bp + 1024)) != 0 { + v3 = n - Uint64FromInt64(int64(**(**uintptr)(__ccgo_up(bp + 1024)))-int64(tmp_s)) } else { v3 = uint64(0) } n = v3 cnt = cnt + l } - if *(*uintptr)(unsafe.Pointer(bp + 1024)) != 0 { + if **(**uintptr)(__ccgo_up(bp + 1024)) != 0 { for wn != 0 && n != 0 { - l = Xmbrtowc(tls, ws, *(*uintptr)(unsafe.Pointer(bp + 1024)), n, st) + l = Xmbrtowc(tls, ws, **(**uintptr)(__ccgo_up(bp + 1024)), n, st) if l+uint64(2) <= uint64(2) { if !(l+Uint64FromInt32(1) != 0) { cnt = l break } if !(l != 0) { - *(*uintptr)(unsafe.Pointer(bp + 1024)) = uintptr(0) + **(**uintptr)(__ccgo_up(bp + 1024)) = uintptr(0) break } /* have to roll back partial character */ - *(*uint32)(unsafe.Pointer(st)) = uint32(0) + **(**uint32)(__ccgo_up(st)) = uint32(0) break } - *(*uintptr)(unsafe.Pointer(bp + 1024)) = *(*uintptr)(unsafe.Pointer(bp + 1024)) + uintptr(l) + **(**uintptr)(__ccgo_up(bp + 1024)) = **(**uintptr)(__ccgo_up(bp + 1024)) + uintptr(l) n = n - l /* safe - this loop runs fewer than sizeof(wbuf)/8 times */ ws += 4 @@ -116988,7 +116988,7 @@ func Xmbsnrtowcs(tls *TLS, wcs uintptr, src uintptr, n Tsize_t, wn Tsize_t, st u } } if wcs != 0 { - *(*uintptr)(unsafe.Pointer(src)) = *(*uintptr)(unsafe.Pointer(bp + 1024)) + **(**uintptr)(__ccgo_up(src)) = **(**uintptr)(__ccgo_up(bp + 1024)) } return cnt } @@ -117004,22 +117004,22 @@ func Xmbsrtowcs(tls *TLS, ws uintptr, src uintptr, wn Tsize_t, st uintptr) (r Ts var v2 bool var v3 int32 _, _, _, _, _, _, _, _ = c, s, wn0, v1, v2, v3, v5, v6 - s = *(*uintptr)(unsafe.Pointer(src)) + s = **(**uintptr)(__ccgo_up(src)) wn0 = wn c = uint32(0) if v2 = st != 0; v2 { - v1 = *(*uint32)(unsafe.Pointer(st)) + v1 = **(**uint32)(__ccgo_up(st)) c = v1 } if v2 && v1 != 0 { if ws != 0 { - *(*uint32)(unsafe.Pointer(st)) = uint32(0) + **(**uint32)(__ccgo_up(st)) = uint32(0) goto resume } else { goto resume0 } } - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v3 = int32(4) } else { v3 = int32(1) @@ -117030,24 +117030,24 @@ func Xmbsrtowcs(tls *TLS, ws uintptr, src uintptr, wn Tsize_t, st uintptr) (r Ts } for { if !(wn != 0) { - *(*uintptr)(unsafe.Pointer(src)) = s + **(**uintptr)(__ccgo_up(src)) = s return wn0 } - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { break } v5 = s s = s + 1 - c = uint32(*(*uint8)(unsafe.Pointer(v5))) + c = uint32(**(**uint8)(__ccgo_up(v5))) v5 = ws ws += 4 - *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromInt32(0xdfff) & int32(Int8FromUint32(c)) + **(**Twchar_t)(__ccgo_up(v5)) = Int32FromInt32(0xdfff) & int32(Int8FromUint32(c)) wn = wn - 1 goto _4 _4: } - *(*Twchar_t)(unsafe.Pointer(ws)) = 0 - *(*uintptr)(unsafe.Pointer(src)) = uintptr(0) + **(**Twchar_t)(__ccgo_up(ws)) = 0 + **(**uintptr)(__ccgo_up(src)) = uintptr(0) return wn0 - wn } if !!(ws != 0) { @@ -117055,39 +117055,39 @@ func Xmbsrtowcs(tls *TLS, ws uintptr, src uintptr, wn Tsize_t, st uintptr) (r Ts } _11: ; - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) && uint64(s)%uint64(4) == uint64(0) { - for !((*(*uint32)(unsafe.Pointer(s))|(*(*uint32)(unsafe.Pointer(s))-Uint32FromInt32(0x01010101)))&Uint32FromUint32(0x80808080) != 0) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(1) < uint32(0x7f) && uint64(s)%uint64(4) == uint64(0) { + for !((**(**uint32)(__ccgo_up(s))|(**(**uint32)(__ccgo_up(s))-Uint32FromInt32(0x01010101)))&Uint32FromUint32(0x80808080) != 0) { s = s + uintptr(4) wn = wn - uint64(4) } } - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(1) < uint32(0x7f) { s = s + 1 wn = wn - 1 goto _10 } - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { goto _9 } v5 = s s = s + 1 - c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v5)))-uint32(0xc2)] + c = X__fsmu8[uint32(**(**uint8)(__ccgo_up(v5)))-uint32(0xc2)] goto resume0 resume0: ; - if (Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { + if (Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { s = s - 1 goto _9 } s = s + 1 if c&(Uint32FromUint32(1)<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { s = s - uintptr(2) goto _9 } s = s + 1 if c&(Uint32FromUint32(1)<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { s = s - uintptr(3) goto _9 } @@ -117109,80 +117109,80 @@ _7: _15: ; if !(wn != 0) { - *(*uintptr)(unsafe.Pointer(src)) = s + **(**uintptr)(__ccgo_up(src)) = s return wn0 } - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) && uint64(s)%uint64(4) == uint64(0) { - for wn >= uint64(5) && !((*(*uint32)(unsafe.Pointer(s))|(*(*uint32)(unsafe.Pointer(s))-Uint32FromInt32(0x01010101)))&Uint32FromUint32(0x80808080) != 0) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(1) < uint32(0x7f) && uint64(s)%uint64(4) == uint64(0) { + for wn >= uint64(5) && !((**(**uint32)(__ccgo_up(s))|(**(**uint32)(__ccgo_up(s))-Uint32FromInt32(0x01010101)))&Uint32FromUint32(0x80808080) != 0) { v5 = ws ws += 4 v6 = s s = s + 1 - *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + **(**Twchar_t)(__ccgo_up(v5)) = Int32FromUint8(**(**uint8)(__ccgo_up(v6))) v5 = ws ws += 4 v6 = s s = s + 1 - *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + **(**Twchar_t)(__ccgo_up(v5)) = Int32FromUint8(**(**uint8)(__ccgo_up(v6))) v5 = ws ws += 4 v6 = s s = s + 1 - *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + **(**Twchar_t)(__ccgo_up(v5)) = Int32FromUint8(**(**uint8)(__ccgo_up(v6))) v5 = ws ws += 4 v6 = s s = s + 1 - *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + **(**Twchar_t)(__ccgo_up(v5)) = Int32FromUint8(**(**uint8)(__ccgo_up(v6))) wn = wn - uint64(4) } } - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(1) < uint32(0x7f) { v5 = ws ws += 4 v6 = s s = s + 1 - *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + **(**Twchar_t)(__ccgo_up(v5)) = Int32FromUint8(**(**uint8)(__ccgo_up(v6))) wn = wn - 1 goto _14 } - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { goto _13 } v5 = s s = s + 1 - c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v5)))-uint32(0xc2)] + c = X__fsmu8[uint32(**(**uint8)(__ccgo_up(v5)))-uint32(0xc2)] goto resume resume: ; - if (Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { + if (Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { s = s - 1 goto _13 } v5 = s s = s + 1 - c = c<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { s = s - uintptr(2) goto _13 } v5 = s s = s + 1 - c = c<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { s = s - uintptr(3) goto _13 } v5 = s s = s + 1 - c = c< Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { goto ilseq } v3 = s s = s + 1 - c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v3)))-uint32(0xc2)] + c = X__fsmu8[uint32(**(**uint8)(__ccgo_up(v3)))-uint32(0xc2)] /* Avoid excessive checks against n: If shifting the state n-1 * times does not clear the high bit, then the value of n is * insufficient to read a character */ if n < uint64(4) && c<<(uint64(6)*n-uint64(6))&(Uint32FromUint32(1)<>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { + if (Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { goto ilseq } v3 = s s = s + 1 - c = c<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { goto ilseq } v3 = s s = s + 1 - c = c<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { goto ilseq } v3 = s s = s + 1 - *(*Twchar_t)(unsafe.Pointer(wc)) = Int32FromUint32(c<>Int32FromInt32(6)) - *(*uint8)(unsafe.Pointer(s)) = Uint8FromInt32(int32(0x80) | wc&int32(0x3f)) + **(**uint8)(__ccgo_up(v2)) = Uint8FromInt32(int32(0xc0) | wc>>Int32FromInt32(6)) + **(**uint8)(__ccgo_up(s)) = Uint8FromInt32(int32(0x80) | wc&int32(0x3f)) return uint64(2) } else { if Uint32FromInt32(wc) < uint32(0xd800) || Uint32FromInt32(wc)-uint32(0xe000) < uint32(0x2000) { v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(int32(0xe0) | wc>>Int32FromInt32(12)) + **(**uint8)(__ccgo_up(v2)) = Uint8FromInt32(int32(0xe0) | wc>>Int32FromInt32(12)) v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(int32(0x80) | wc>>Int32FromInt32(6)&int32(0x3f)) - *(*uint8)(unsafe.Pointer(s)) = Uint8FromInt32(int32(0x80) | wc&int32(0x3f)) + **(**uint8)(__ccgo_up(v2)) = Uint8FromInt32(int32(0x80) | wc>>Int32FromInt32(6)&int32(0x3f)) + **(**uint8)(__ccgo_up(s)) = Uint8FromInt32(int32(0x80) | wc&int32(0x3f)) return uint64(3) } else { if Uint32FromInt32(wc)-uint32(0x10000) < uint32(0x100000) { v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(int32(0xf0) | wc>>Int32FromInt32(18)) + **(**uint8)(__ccgo_up(v2)) = Uint8FromInt32(int32(0xf0) | wc>>Int32FromInt32(18)) v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(int32(0x80) | wc>>Int32FromInt32(12)&int32(0x3f)) + **(**uint8)(__ccgo_up(v2)) = Uint8FromInt32(int32(0x80) | wc>>Int32FromInt32(12)&int32(0x3f)) v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(int32(0x80) | wc>>Int32FromInt32(6)&int32(0x3f)) - *(*uint8)(unsafe.Pointer(s)) = Uint8FromInt32(int32(0x80) | wc&int32(0x3f)) + **(**uint8)(__ccgo_up(v2)) = Uint8FromInt32(int32(0x80) | wc>>Int32FromInt32(6)&int32(0x3f)) + **(**uint8)(__ccgo_up(s)) = Uint8FromInt32(int32(0x80) | wc&int32(0x3f)) return uint64(4) } } } } } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EILSEQ) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EILSEQ) return Uint64FromInt32(-Int32FromInt32(1)) } @@ -117379,7 +117379,7 @@ func Xwcsnrtombs(tls *TLS, dst uintptr, wcs uintptr, wn Tsize_t, n Tsize_t, st u var ws, v1 uintptr var _ /* tmp at bp+0 */ [4]uint8 _, _, _, _ = cnt, l, ws, v1 - ws = *(*uintptr)(unsafe.Pointer(wcs)) + ws = **(**uintptr)(__ccgo_up(wcs)) cnt = uint64(0) if !(dst != 0) { n = uint64(0) @@ -117390,7 +117390,7 @@ func Xwcsnrtombs(tls *TLS, dst uintptr, wcs uintptr, wn Tsize_t, n Tsize_t, st u } else { v1 = dst } - l = Xwcrtomb(tls, v1, *(*Twchar_t)(unsafe.Pointer(ws)), uintptr(0)) + l = Xwcrtomb(tls, v1, **(**Twchar_t)(__ccgo_up(ws)), uintptr(0)) if l == Uint64FromInt32(-Int32FromInt32(1)) { cnt = Uint64FromInt32(-Int32FromInt32(1)) break @@ -117405,7 +117405,7 @@ func Xwcsnrtombs(tls *TLS, dst uintptr, wcs uintptr, wn Tsize_t, n Tsize_t, st u dst = dst + uintptr(l) n = n - l } - if !(*(*Twchar_t)(unsafe.Pointer(ws)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(ws)) != 0) { ws = uintptr(0) break } @@ -117414,7 +117414,7 @@ func Xwcsnrtombs(tls *TLS, dst uintptr, wcs uintptr, wn Tsize_t, n Tsize_t, st u cnt = cnt + l } if dst != 0 { - *(*uintptr)(unsafe.Pointer(wcs)) = ws + **(**uintptr)(__ccgo_up(wcs)) = ws } return cnt } @@ -117433,13 +117433,13 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize N = n if !(s != 0) { n = uint64(0) - ws2 = *(*uintptr)(unsafe.Pointer(ws)) + ws2 = **(**uintptr)(__ccgo_up(ws)) for { - if !(*(*Twchar_t)(unsafe.Pointer(ws2)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(ws2)) != 0) { break } - if Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(ws2))) >= uint32(0x80) { - l = Xwcrtomb(tls, bp, *(*Twchar_t)(unsafe.Pointer(ws2)), uintptr(0)) + if Uint32FromInt32(**(**Twchar_t)(__ccgo_up(ws2))) >= uint32(0x80) { + l = Xwcrtomb(tls, bp, **(**Twchar_t)(__ccgo_up(ws2)), uintptr(0)) if !(l+Uint64FromInt32(1) != 0) { return Uint64FromInt32(-Int32FromInt32(1)) } @@ -117455,13 +117455,13 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize return n } for n >= uint64(4) { - if Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))))-uint32(1) >= uint32(0x7f) { - if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))) != 0) { - *(*uint8)(unsafe.Pointer(s)) = uint8(0) - *(*uintptr)(unsafe.Pointer(ws)) = uintptr(0) + if Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))))-uint32(1) >= uint32(0x7f) { + if !(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))) != 0) { + **(**uint8)(__ccgo_up(s)) = uint8(0) + **(**uintptr)(__ccgo_up(ws)) = uintptr(0) return N - n } - l = Xwcrtomb(tls, s, *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))), uintptr(0)) + l = Xwcrtomb(tls, s, **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))), uintptr(0)) if !(l+Uint64FromInt32(1) != 0) { return Uint64FromInt32(-Int32FromInt32(1)) } @@ -117470,35 +117470,35 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize } else { v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) + **(**uint8)(__ccgo_up(v2)) = Uint8FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws))))) n = n - 1 } - *(*uintptr)(unsafe.Pointer(ws)) += 4 + **(**uintptr)(__ccgo_up(ws)) += 4 } for n != 0 { - if Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))))-uint32(1) >= uint32(0x7f) { - if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))) != 0) { - *(*uint8)(unsafe.Pointer(s)) = uint8(0) - *(*uintptr)(unsafe.Pointer(ws)) = uintptr(0) + if Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))))-uint32(1) >= uint32(0x7f) { + if !(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))) != 0) { + **(**uint8)(__ccgo_up(s)) = uint8(0) + **(**uintptr)(__ccgo_up(ws)) = uintptr(0) return N - n } - l = Xwcrtomb(tls, bp, *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))), uintptr(0)) + l = Xwcrtomb(tls, bp, **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))), uintptr(0)) if !(l+Uint64FromInt32(1) != 0) { return Uint64FromInt32(-Int32FromInt32(1)) } if l > n { return N - n } - Xwcrtomb(tls, s, *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))), uintptr(0)) + Xwcrtomb(tls, s, **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))), uintptr(0)) s = s + uintptr(l) n = n - l } else { v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) + **(**uint8)(__ccgo_up(v2)) = Uint8FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws))))) n = n - 1 } - *(*uintptr)(unsafe.Pointer(ws)) += 4 + **(**uintptr)(__ccgo_up(ws)) += 4 } return N } @@ -117524,7 +117524,7 @@ func Xwctob(tls *TLS, c Twint_t) (r int32) { if c < uint32(128) { return Int32FromUint32(c) } - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v1 = int32(4) } else { v1 = int32(1) @@ -117622,11 +117622,11 @@ func Xaccept4(tls *TLS, fd int32, addr uintptr, len1 uintptr, flg int32) (r1 int goto _9 _9: ret = int32(X__syscall_ret(tls, Uint64FromInt64(v8))) - if ret >= 0 || *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(ENOSYS) && *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(EINVAL) { + if ret >= 0 || **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(ENOSYS) && **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(EINVAL) { return ret } if flg & ^(Int32FromInt32(SOCK_CLOEXEC)|Int32FromInt32(SOCK_NONBLOCK)) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } ret = Xaccept(tls, fd, addr, len1) @@ -118598,13 +118598,13 @@ func _getoffs(tls *TLS, offs uintptr, base uintptr, s uintptr) (r int32) { _, _ = i, v2 i = 0 for { - for Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))&int32(0xc0) != 0 { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))&int32(0xc0) != int32(0xc0) { + for Int32FromUint8(**(**uint8)(__ccgo_up(s)))&int32(0xc0) != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(s)))&int32(0xc0) != int32(0xc0) { return 0 } - s = base + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))&Int32FromInt32(0x3f)<= int64(0x4000) { @@ -118612,8 +118612,8 @@ func _getoffs(tls *TLS, offs uintptr, base uintptr, s uintptr) (r int32) { } v2 = i i = i + 1 - *(*int16)(unsafe.Pointer(offs + uintptr(v2)*2)) = int16(int64(s) - int64(base)) - s = s + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))+int32(1)) + **(**int16)(__ccgo_up(offs + uintptr(v2)*2)) = int16(int64(s) - int64(base)) + s = s + uintptr(Int32FromUint8(**(**uint8)(__ccgo_up(s)))+int32(1)) goto _1 _1: } @@ -118631,7 +118631,7 @@ func _getlens(tls *TLS, lens uintptr, s uintptr, l int32) (r int32) { k = 0 for { for { - if !(j < l && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(j)))) != int32('.')) { + if !(j < l && Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(j)))) != int32('.')) { break } goto _2 @@ -118644,7 +118644,7 @@ func _getlens(tls *TLS, lens uintptr, s uintptr, l int32) (r int32) { } v3 = i i = i + 1 - *(*uint8)(unsafe.Pointer(lens + uintptr(v3))) = Uint8FromInt32(j - k) + **(**uint8)(__ccgo_up(lens + uintptr(v3))) = Uint8FromInt32(j - k) if j == l { return i } @@ -118674,15 +118674,15 @@ func _match(tls *TLS, offset uintptr, base uintptr, dn uintptr, end uintptr, len for { nlen = nlen - 1 v2 = nlen - l = Int32FromUint8(*(*uint8)(unsafe.Pointer(lens + uintptr(v2)))) + l = Int32FromUint8(**(**uint8)(__ccgo_up(lens + uintptr(v2)))) noff = noff - 1 v2 = noff - o = int32((*(*[128]int16)(unsafe.Pointer(bp)))[v2]) + o = int32((**(**[128]int16)(__ccgo_up(bp)))[v2]) end = end - uintptr(l) - if l != Int32FromUint8(*(*uint8)(unsafe.Pointer(base + uintptr(o)))) || Xmemcmp(tls, base+uintptr(o)+uintptr(1), end, Uint64FromInt32(l)) != 0 { + if l != Int32FromUint8(**(**uint8)(__ccgo_up(base + uintptr(o)))) || Xmemcmp(tls, base+uintptr(o)+uintptr(1), end, Uint64FromInt32(l)) != 0 { return m } - *(*int32)(unsafe.Pointer(offset)) = o + **(**int32)(__ccgo_up(offset)) = o m = m + l if nlen != 0 { m = m + 1 @@ -118713,14 +118713,14 @@ func Xdn_comp(tls *TLS, src uintptr, dst uintptr, space int32, dnptrs uintptr, l m = 0 bestlen = 0 l = Xstrnlen(tls, src, uint64(255)) - if l != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(src + uintptr(l-uint64(1))))) == int32('.') { + if l != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(src + uintptr(l-uint64(1))))) == int32('.') { l = l - 1 } if l > uint64(253) || space <= 0 { return -int32(1) } if !(l != 0) { - *(*uint8)(unsafe.Pointer(dst)) = uint8(0) + **(**uint8)(__ccgo_up(dst)) = uint8(0) return int32(1) } end = src + uintptr(l) @@ -118729,16 +118729,16 @@ func Xdn_comp(tls *TLS, src uintptr, dst uintptr, space int32, dnptrs uintptr, l return -int32(1) } p = dnptrs - if p != 0 && *(*uintptr)(unsafe.Pointer(p)) != 0 { + if p != 0 && **(**uintptr)(__ccgo_up(p)) != 0 { p += 8 for { - if !(*(*uintptr)(unsafe.Pointer(p)) != 0) { + if !(**(**uintptr)(__ccgo_up(p)) != 0) { break } - m = _match(tls, bp, *(*uintptr)(unsafe.Pointer(dnptrs)), *(*uintptr)(unsafe.Pointer(p)), end, bp+4, n) + m = _match(tls, bp, **(**uintptr)(__ccgo_up(dnptrs)), **(**uintptr)(__ccgo_up(p)), end, bp+4, n) if m > bestlen { bestlen = m - bestoff = *(*int32)(unsafe.Pointer(bp)) + bestoff = **(**int32)(__ccgo_up(bp)) if Uint64FromInt32(m) == l { break } @@ -118761,37 +118761,37 @@ func Xdn_comp(tls *TLS, src uintptr, dst uintptr, space int32, dnptrs uintptr, l if !(Uint64FromInt32(i) < l-Uint64FromInt32(bestlen)) { break } - *(*uint8)(unsafe.Pointer(dst + uintptr(i))) = (*(*[127]uint8)(unsafe.Pointer(bp + 4)))[j] + **(**uint8)(__ccgo_up(dst + uintptr(i))) = (**(**[127]uint8)(__ccgo_up(bp + 4)))[j] goto _2 _2: ; v3 = j j = j + 1 - i = i + (Int32FromUint8((*(*[127]uint8)(unsafe.Pointer(bp + 4)))[v3]) + int32(1)) + i = i + (Int32FromUint8((**(**[127]uint8)(__ccgo_up(bp + 4)))[v3]) + int32(1)) } /* add tail */ if bestlen != 0 { v3 = i i = i + 1 - *(*uint8)(unsafe.Pointer(dst + uintptr(v3))) = Uint8FromInt32(int32(0xc0) | bestoff>>int32(8)) + **(**uint8)(__ccgo_up(dst + uintptr(v3))) = Uint8FromInt32(int32(0xc0) | bestoff>>int32(8)) v3 = i i = i + 1 - *(*uint8)(unsafe.Pointer(dst + uintptr(v3))) = Uint8FromInt32(bestoff) + **(**uint8)(__ccgo_up(dst + uintptr(v3))) = Uint8FromInt32(bestoff) } else { v3 = i i = i + 1 - *(*uint8)(unsafe.Pointer(dst + uintptr(v3))) = uint8(0) + **(**uint8)(__ccgo_up(dst + uintptr(v3))) = uint8(0) } /* save dst pointer */ - if i > int32(2) && lastdnptr != 0 && dnptrs != 0 && *(*uintptr)(unsafe.Pointer(dnptrs)) != 0 { - for *(*uintptr)(unsafe.Pointer(p)) != 0 { + if i > int32(2) && lastdnptr != 0 && dnptrs != 0 && **(**uintptr)(__ccgo_up(dnptrs)) != 0 { + for **(**uintptr)(__ccgo_up(p)) != 0 { p += 8 } if p+uintptr(1)*8 < lastdnptr { v8 = p p += 8 - *(*uintptr)(unsafe.Pointer(v8)) = dst - *(*uintptr)(unsafe.Pointer(p)) = uintptr(0) + **(**uintptr)(__ccgo_up(v8)) = dst + **(**uintptr)(__ccgo_up(p)) = uintptr(0) } } return i @@ -118824,11 +118824,11 @@ func X__dn_expand(tls *TLS, base uintptr, end uintptr, src uintptr, dest uintptr break } /* loop invariants: p= int64(end)-int64(p) || int64(j) >= int64(dend)-int64(dest) { return -int32(1) } @@ -118859,10 +118859,10 @@ func X__dn_expand(tls *TLS, base uintptr, end uintptr, src uintptr, dest uintptr dest = dest + 1 v4 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v3)) = *(*uint8)(unsafe.Pointer(v4)) + **(**uint8)(__ccgo_up(v3)) = uint8(**(**uint8)(__ccgo_up(v4))) } } else { - *(*uint8)(unsafe.Pointer(dest)) = uint8(0) + **(**uint8)(__ccgo_up(dest)) = uint8(0) if len1 < 0 { len1 = int32(int64(p+uintptr(1)) - int64(src)) } @@ -118894,20 +118894,20 @@ func Xdn_skipname(tls *TLS, s uintptr, end uintptr) (r int32) { _ = p p = s for p < end { - if !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if !(**(**uint8)(__ccgo_up(p)) != 0) { return int32(int64(p) - int64(s) + int64(1)) } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) >= int32(192) { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) >= int32(192) { if p+uintptr(1) < end { return int32(int64(p) - int64(s) + int64(2)) } else { break } } else { - if int64(end)-int64(p) < int64(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))+int32(1)) { + if int64(end)-int64(p) < int64(Int32FromUint8(**(**uint8)(__ccgo_up(p)))+int32(1)) { break } else { - p = p + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))+int32(1)) + p = p + uintptr(Int32FromUint8(**(**uint8)(__ccgo_up(p)))+int32(1)) } } } @@ -119023,25 +119023,25 @@ func X__dns_parse(tls *TLS, r uintptr, rlen int32, __ccgo_fp_callback uintptr, c if rlen < int32(12) { return -int32(1) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 3)))&int32(15) != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(r + 3)))&int32(15) != 0 { return 0 } p = r + uintptr(12) - qdcount = Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 4)))*int32(256) + Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 5))) - ancount = Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 6)))*int32(256) + Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 7))) + qdcount = Int32FromUint8(**(**uint8)(__ccgo_up(r + 4)))*int32(256) + Int32FromUint8(**(**uint8)(__ccgo_up(r + 5))) + ancount = Int32FromUint8(**(**uint8)(__ccgo_up(r + 6)))*int32(256) + Int32FromUint8(**(**uint8)(__ccgo_up(r + 7))) for { v1 = qdcount qdcount = qdcount - 1 if !(v1 != 0) { break } - for int64(p)-int64(r) < int64(rlen) && uint32(*(*uint8)(unsafe.Pointer(p)))-uint32(1) < uint32(127) { + for int64(p)-int64(r) < int64(rlen) && uint32(**(**uint8)(__ccgo_up(p)))-uint32(1) < uint32(127) { p = p + 1 } if p > r+uintptr(rlen)-uintptr(6) { return -int32(1) } - p = p + uintptr(int32(5)+BoolInt32(!!(*(*uint8)(unsafe.Pointer(p)) != 0))) + p = p + uintptr(int32(5)+BoolInt32(!!(**(**uint8)(__ccgo_up(p)) != 0))) } for { v1 = ancount @@ -119049,18 +119049,18 @@ func X__dns_parse(tls *TLS, r uintptr, rlen int32, __ccgo_fp_callback uintptr, c if !(v1 != 0) { break } - for int64(p)-int64(r) < int64(rlen) && uint32(*(*uint8)(unsafe.Pointer(p)))-uint32(1) < uint32(127) { + for int64(p)-int64(r) < int64(rlen) && uint32(**(**uint8)(__ccgo_up(p)))-uint32(1) < uint32(127) { p = p + 1 } if p > r+uintptr(rlen)-uintptr(12) { return -int32(1) } - p = p + uintptr(int32(1)+BoolInt32(!!(*(*uint8)(unsafe.Pointer(p)) != 0))) - len1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 8)))*int32(256) + Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 9))) + p = p + uintptr(int32(1)+BoolInt32(!!(**(**uint8)(__ccgo_up(p)) != 0))) + len1 = Int32FromUint8(**(**uint8)(__ccgo_up(p + 8)))*int32(256) + Int32FromUint8(**(**uint8)(__ccgo_up(p + 9))) if int64(len1+int32(10)) > int64(r+uintptr(rlen))-int64(p) { return -int32(1) } - if (*(*func(*TLS, uintptr, int32, uintptr, int32, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_callback})))(tls, ctx, Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))), p+uintptr(10), len1, r, rlen) < 0 { + if (*(*func(*TLS, uintptr, int32, uintptr, int32, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_callback})))(tls, ctx, Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))), p+uintptr(10), len1, r, rlen) < 0 { return -int32(1) } p = p + uintptr(int32(10)+len1) @@ -119402,27 +119402,27 @@ func Xether_aton_r(tls *TLS, x uintptr, p_a uintptr) (r uintptr) { break } if ii != 0 { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(x))) != int32(':') { + if Int32FromUint8(**(**uint8)(__ccgo_up(x))) != int32(':') { return uintptr(0) } else { x = x + 1 } } n = Xstrtoul(tls, x, bp+8, int32(16)) - x = *(*uintptr)(unsafe.Pointer(bp + 8)) + x = **(**uintptr)(__ccgo_up(bp + 8)) if n > uint64(0xFF) { return uintptr(0) } /* bad byte */ - *(*Tuint8_t)(unsafe.Pointer(bp + uintptr(ii))) = uint8(n) + **(**Tuint8_t)(__ccgo_up(bp + uintptr(ii))) = uint8(n) goto _1 _1: ; ii = ii + 1 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(x))) != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(x))) != 0 { return uintptr(0) } /* bad format */ - *(*Tether_addr)(unsafe.Pointer(p_a)) = *(*Tether_addr)(unsafe.Pointer(bp)) + **(**Tether_addr)(__ccgo_up(p_a)) = **(**Tether_addr)(__ccgo_up(bp)) return p_a } @@ -119457,7 +119457,7 @@ func Xether_ntoa_r(tls *TLS, p_a uintptr, x uintptr) (r uintptr) { } else { v2 = __ccgo_ts + 1015 } - x = x + uintptr(Xsprintf(tls, x, v2, VaList(bp+8, Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(p_a + uintptr(ii))))))) + x = x + uintptr(Xsprintf(tls, x, v2, VaList(bp+8, Int32FromUint8(**(**Tuint8_t)(__ccgo_up(p_a + uintptr(ii))))))) goto _1 _1: ; @@ -119542,11 +119542,11 @@ func Xgai_strerror(tls *TLS, ecode int32) (r uintptr) { s = uintptr(unsafe.Pointer(&_msgs)) ecode = ecode + 1 for { - if !(ecode != 0 && *(*uint8)(unsafe.Pointer(s)) != 0) { + if !(ecode != 0 && **(**uint8)(__ccgo_up(s)) != 0) { break } for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { break } goto _2 @@ -119560,7 +119560,7 @@ func Xgai_strerror(tls *TLS, ecode int32) (r uintptr) { ecode = ecode + 1 s = s + 1 } - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { s = s + 1 } return X__lctrans_cur(tls, s) @@ -119636,15 +119636,15 @@ func Xgetaddrinfo(tls *TLS, host uintptr, serv uintptr, hint uintptr, res uintpt if s >= 0 { _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp+1608) r = Xconnect(tls, s, ta[i], tl[i]) - saved_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 1608)), uintptr(0)) + saved_errno = **(**int32)(__ccgo_up(X__errno_location(tls))) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 1608)), uintptr(0)) Xclose(tls, s) if !(r != 0) { goto _1 } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = saved_errno + **(**int32)(__ccgo_up(X__errno_location(tls))) = saved_errno } - switch *(*int32)(unsafe.Pointer(X__errno_location(tls))) { + switch **(**int32)(__ccgo_up(X__errno_location(tls))) { case int32(EADDRNOTAVAIL): fallthrough case int32(EAFNOSUPPORT): @@ -119702,32 +119702,32 @@ func Xgetaddrinfo(tls *TLS, host uintptr, serv uintptr, hint uintptr, res uintpt if !(j < nservs) { break } - (*(*Taibuf)(unsafe.Pointer(out + uintptr(k)*88))).Fslot = int16(k) - if (*(*[48]Taddress)(unsafe.Pointer(bp + 8)))[i].Ffamily == int32(PF_INET) { + (**(**Taibuf)(__ccgo_up(out + uintptr(k)*88))).Fslot = int16(k) + if (**(**[48]Taddress)(__ccgo_up(bp + 8)))[i].Ffamily == int32(PF_INET) { v5 = uint64(16) } else { v5 = uint64(28) } - (*(*Taibuf)(unsafe.Pointer(out + uintptr(k)*88))).Fai = Taddrinfo{ - Fai_family: (*(*[48]Taddress)(unsafe.Pointer(bp + 8)))[i].Ffamily, - Fai_socktype: Int32FromUint8((*(*[2]Tservice)(unsafe.Pointer(bp)))[j].Fsocktype), - Fai_protocol: Int32FromUint8((*(*[2]Tservice)(unsafe.Pointer(bp)))[j].Fproto), + (**(**Taibuf)(__ccgo_up(out + uintptr(k)*88))).Fai = Taddrinfo{ + Fai_family: (**(**[48]Taddress)(__ccgo_up(bp + 8)))[i].Ffamily, + Fai_socktype: Int32FromUint8((**(**[2]Tservice)(__ccgo_up(bp)))[j].Fsocktype), + Fai_protocol: Int32FromUint8((**(**[2]Tservice)(__ccgo_up(bp)))[j].Fproto), Fai_addrlen: uint32(v5), Fai_addr: out + uintptr(k)*88 + 48, Fai_canonname: outcanon, } if k != 0 { - (*(*Taibuf)(unsafe.Pointer(out + uintptr(k-int32(1))*88))).Fai.Fai_next = out + uintptr(k)*88 + (**(**Taibuf)(__ccgo_up(out + uintptr(k-int32(1))*88))).Fai.Fai_next = out + uintptr(k)*88 } - switch (*(*[48]Taddress)(unsafe.Pointer(bp + 8)))[i].Ffamily { + switch (**(**[48]Taddress)(__ccgo_up(bp + 8)))[i].Ffamily { case int32(PF_INET): *(*Tsa_family_t)(unsafe.Pointer(out + uintptr(k)*88 + 48)) = uint16(PF_INET) - *(*Tin_port_t)(unsafe.Pointer(out + uintptr(k)*88 + 48 + 2)) = Xhtons(tls, (*(*[2]Tservice)(unsafe.Pointer(bp)))[j].Fport) + *(*Tin_port_t)(unsafe.Pointer(out + uintptr(k)*88 + 48 + 2)) = Xhtons(tls, (**(**[2]Tservice)(__ccgo_up(bp)))[j].Fport) Xmemcpy(tls, out+uintptr(k)*88+48+4, bp+8+uintptr(i)*28+8, uint64(4)) case int32(PF_INET6): *(*Tsa_family_t)(unsafe.Pointer(out + uintptr(k)*88 + 48)) = uint16(PF_INET6) - *(*Tin_port_t)(unsafe.Pointer(out + uintptr(k)*88 + 48 + 2)) = Xhtons(tls, (*(*[2]Tservice)(unsafe.Pointer(bp)))[j].Fport) - *(*Tuint32_t)(unsafe.Pointer(out + uintptr(k)*88 + 48 + 24)) = (*(*[48]Taddress)(unsafe.Pointer(bp + 8)))[i].Fscopeid + *(*Tin_port_t)(unsafe.Pointer(out + uintptr(k)*88 + 48 + 2)) = Xhtons(tls, (**(**[2]Tservice)(__ccgo_up(bp)))[j].Fport) + *(*Tuint32_t)(unsafe.Pointer(out + uintptr(k)*88 + 48 + 24)) = (**(**[48]Taddress)(__ccgo_up(bp + 8)))[i].Fscopeid Xmemcpy(tls, out+uintptr(k)*88+48+8, bp+8+uintptr(i)*28+8, uint64(16)) break } @@ -119742,8 +119742,8 @@ func Xgetaddrinfo(tls *TLS, host uintptr, serv uintptr, hint uintptr, res uintpt ; i = i + 1 } - (*(*Taibuf)(unsafe.Pointer(out))).Fref = int16(nais) - *(*uintptr)(unsafe.Pointer(res)) = out + (**(**Taibuf)(__ccgo_up(out))).Fref = int16(nais) + **(**uintptr)(__ccgo_up(res)) = out return 0 } @@ -119874,12 +119874,12 @@ func Xgethostbyaddr(tls *TLS, a uintptr, l Tsocklen_t, af int32) (r uintptr) { size = size + (size + uint64(1)) _h = Xmalloc(tls, size) if !(_h != 0) { - *(*int32)(unsafe.Pointer(X__h_errno_location(tls))) = int32(NO_RECOVERY) + **(**int32)(__ccgo_up(X__h_errno_location(tls))) = int32(NO_RECOVERY) return uintptr(0) } err = Xgethostbyaddr_r(tls, a, l, af, _h, _h+UintptrFromInt32(1)*32, size-uint64(32), bp, X__h_errno_location(tls)) } - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } var _h uintptr @@ -119916,7 +119916,7 @@ func Xgethostbyaddr_r(tls *TLS, a uintptr, l Tsocklen_t, af int32, h uintptr, bu v1 = uint64(16) } sl = uint32(v1) - *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) + **(**uintptr)(__ccgo_up(res)) = uintptr(0) /* Load address argument into sockaddr structure */ if af == int32(PF_INET6) && l == uint32(16) { Xmemcpy(tls, bp+8, a, uint64(16)) @@ -119924,7 +119924,7 @@ func Xgethostbyaddr_r(tls *TLS, a uintptr, l Tsocklen_t, af int32, h uintptr, bu if af == int32(PF_INET) && l == uint32(4) { Xmemcpy(tls, bp+4, a, uint64(4)) } else { - *(*int32)(unsafe.Pointer(err)) = int32(NO_RECOVERY) + **(**int32)(__ccgo_up(err)) = int32(NO_RECOVERY) return int32(EINVAL) } } @@ -119942,33 +119942,33 @@ func Xgethostbyaddr_r(tls *TLS, a uintptr, l Tsocklen_t, af int32, h uintptr, bu buf = buf + uintptr(Uint64FromInt32(2)*Uint64FromInt64(8)) (*Thostent)(unsafe.Pointer(h)).Fh_aliases = buf buf = buf + uintptr(Uint64FromInt32(2)*Uint64FromInt64(8)) - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list)) = buf - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list)), a, uint64(l)) + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_addr_list)) = buf + Xmemcpy(tls, **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_addr_list)), a, uint64(l)) buf = buf + uintptr(l) - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + 1*8)) = uintptr(0) - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) = buf - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = uintptr(0) + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + 1*8)) = uintptr(0) + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) = buf + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = uintptr(0) switch Xgetnameinfo(tls, bp, sl, buf, uint32(buflen), uintptr(0), uint32(0), 0) { case -int32(3): - *(*int32)(unsafe.Pointer(err)) = int32(TRY_AGAIN) + **(**int32)(__ccgo_up(err)) = int32(TRY_AGAIN) return int32(EAGAIN) case -int32(12): return int32(ERANGE) default: fallthrough case -int32(4): - *(*int32)(unsafe.Pointer(err)) = int32(NO_RECOVERY) + **(**int32)(__ccgo_up(err)) = int32(NO_RECOVERY) return int32(EBADMSG) case -int32(11): - *(*int32)(unsafe.Pointer(err)) = int32(NO_RECOVERY) - return *(*int32)(unsafe.Pointer(X__errno_location(tls))) + **(**int32)(__ccgo_up(err)) = int32(NO_RECOVERY) + return **(**int32)(__ccgo_up(X__errno_location(tls))) case 0: break } (*Thostent)(unsafe.Pointer(h)).Fh_addrtype = af (*Thostent)(unsafe.Pointer(h)).Fh_length = Int32FromUint32(l) - (*Thostent)(unsafe.Pointer(h)).Fh_name = *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) - *(*uintptr)(unsafe.Pointer(res)) = h + (*Thostent)(unsafe.Pointer(h)).Fh_name = **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) + **(**uintptr)(__ccgo_up(res)) = h return 0 } @@ -119997,12 +119997,12 @@ func Xgethostbyname2(tls *TLS, name uintptr, af int32) (r uintptr) { size = size + (size + uint64(1)) _h1 = Xmalloc(tls, size) if !(_h1 != 0) { - *(*int32)(unsafe.Pointer(X__h_errno_location(tls))) = int32(NO_RECOVERY) + **(**int32)(__ccgo_up(X__h_errno_location(tls))) = int32(NO_RECOVERY) return uintptr(0) } err = Xgethostbyname2_r(tls, name, af, _h1, _h1+UintptrFromInt32(1)*32, size-uint64(32), bp, X__h_errno_location(tls)) } - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } var _h1 uintptr @@ -120020,27 +120020,27 @@ func Xgethostbyname2_r(tls *TLS, name uintptr, af int32, h uintptr, buf uintptr, var _ /* addrs at bp+0 */ [48]Taddress var _ /* canon at bp+1344 */ [256]uint8 _, _, _, _, _, _ = align, cnt, i, need, v1, v3 - *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) + **(**uintptr)(__ccgo_up(res)) = uintptr(0) cnt = X__lookup_name(tls, bp, bp+1344, name, af, int32(AI_CANONNAME)) if cnt < 0 { switch cnt { case -int32(2): - *(*int32)(unsafe.Pointer(err)) = int32(HOST_NOT_FOUND) + **(**int32)(__ccgo_up(err)) = int32(HOST_NOT_FOUND) return 0 case -int32(5): - *(*int32)(unsafe.Pointer(err)) = int32(NO_DATA) + **(**int32)(__ccgo_up(err)) = int32(NO_DATA) return 0 case -int32(3): - *(*int32)(unsafe.Pointer(err)) = int32(TRY_AGAIN) + **(**int32)(__ccgo_up(err)) = int32(TRY_AGAIN) return int32(EAGAIN) default: fallthrough case -int32(4): - *(*int32)(unsafe.Pointer(err)) = int32(NO_RECOVERY) + **(**int32)(__ccgo_up(err)) = int32(NO_RECOVERY) return int32(EBADMSG) case -int32(11): - *(*int32)(unsafe.Pointer(err)) = int32(NO_RECOVERY) - return *(*int32)(unsafe.Pointer(X__errno_location(tls))) + **(**int32)(__ccgo_up(err)) = int32(NO_RECOVERY) + return **(**int32)(__ccgo_up(X__errno_location(tls))) } } (*Thostent)(unsafe.Pointer(h)).Fh_addrtype = af @@ -120070,29 +120070,29 @@ func Xgethostbyname2_r(tls *TLS, name uintptr, af int32, h uintptr, buf uintptr, if !(i < cnt) { break } - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)) = buf + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)) = buf buf = buf + uintptr((*Thostent)(unsafe.Pointer(h)).Fh_length) - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)), bp+uintptr(i)*28+8, Uint64FromInt32((*Thostent)(unsafe.Pointer(h)).Fh_length)) + Xmemcpy(tls, **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)), bp+uintptr(i)*28+8, Uint64FromInt32((*Thostent)(unsafe.Pointer(h)).Fh_length)) goto _2 _2: ; i = i + 1 } - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)) = uintptr(0) + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)) = uintptr(0) v3 = buf - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) = v3 + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) = v3 (*Thostent)(unsafe.Pointer(h)).Fh_name = v3 Xstrcpy(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name, bp+1344) buf = buf + uintptr(_strlen(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name)+uint64(1)) if Xstrcmp(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name, name) != 0 { - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = buf - Xstrcpy(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)), name) - buf = buf + uintptr(_strlen(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)))+uint64(1)) + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = buf + Xstrcpy(tls, **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)), name) + buf = buf + uintptr(_strlen(tls, **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)))+uint64(1)) } else { - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = uintptr(0) + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = uintptr(0) } - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 2*8)) = uintptr(0) - *(*uintptr)(unsafe.Pointer(res)) = h + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 2*8)) = uintptr(0) + **(**uintptr)(__ccgo_up(res)) = h return 0 } @@ -120321,7 +120321,7 @@ func _copy_addr(tls *TLS, r uintptr, af int32, sa uintptr, addr uintptr, addrlen case int32(PF_INET6): dst = sa + 8 len1 = int32(16) - if Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(addr))) == int32(0xfe) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(addr + 1)))&int32(0xc0) == int32(0x80) || Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(addr))) == int32(0xff) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(addr + 1)))&int32(0xf) == int32(0x2) { + if Int32FromUint8(**(**Tuint8_t)(__ccgo_up(addr))) == int32(0xfe) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(addr + 1)))&int32(0xc0) == int32(0x80) || Int32FromUint8(**(**Tuint8_t)(__ccgo_up(addr))) == int32(0xff) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(addr + 1)))&int32(0xf) == int32(0x2) { (*(*Tsockaddr_in6)(unsafe.Pointer(sa))).Fsin6_scope_id = Uint32FromInt32(ifindex) } default: @@ -120332,7 +120332,7 @@ func _copy_addr(tls *TLS, r uintptr, af int32, sa uintptr, addr uintptr, addrlen } (*Tsockany)(unsafe.Pointer(sa)).Fsa.Fsa_family = Uint16FromInt32(af) Xmemcpy(tls, dst, addr, Uint64FromInt32(len1)) - *(*uintptr)(unsafe.Pointer(r)) = sa + **(**uintptr)(__ccgo_up(r)) = sa } func _gen_netmask(tls *TLS, r uintptr, af int32, sa uintptr, prefixlen int32) { @@ -120341,7 +120341,7 @@ func _gen_netmask(tls *TLS, r uintptr, af int32, sa uintptr, prefixlen int32) { var i, v1 int32 var _ /* addr at bp+0 */ [16]Tuint8_t _, _ = i, v1 - *(*[16]Tuint8_t)(unsafe.Pointer(bp)) = [16]Tuint8_t{} + **(**[16]Tuint8_t)(__ccgo_up(bp)) = [16]Tuint8_t{} if Uint64FromInt32(prefixlen) > Uint64FromInt32(8)*Uint64FromInt64(16) { prefixlen = Int32FromUint64(Uint64FromInt32(8) * Uint64FromInt64(16)) } @@ -120350,7 +120350,7 @@ func _gen_netmask(tls *TLS, r uintptr, af int32, sa uintptr, prefixlen int32) { if Uint64FromInt32(i) < uint64(16) { v1 = i i = i + 1 - (*(*[16]Tuint8_t)(unsafe.Pointer(bp)))[v1] = Uint8FromInt32(int32(0xff) << (int32(8) - prefixlen%int32(8))) + (**(**[16]Tuint8_t)(__ccgo_up(bp)))[v1] = Uint8FromInt32(int32(0xff) << (int32(8) - prefixlen%int32(8))) } _copy_addr(tls, r, af, sa, bp, uint64(16), 0) } @@ -120364,7 +120364,7 @@ func _copy_lladdr(tls *TLS, r uintptr, sa uintptr, addr uintptr, addrlen Tsize_t (*(*Tsockaddr_ll_hack)(unsafe.Pointer(sa))).Fsll_hatype = hatype (*(*Tsockaddr_ll_hack)(unsafe.Pointer(sa))).Fsll_halen = uint8(addrlen) Xmemcpy(tls, sa+12, addr, addrlen) - *(*uintptr)(unsafe.Pointer(r)) = sa + **(**uintptr)(__ccgo_up(r)) = sa } func _netlink_msg_to_ifaddr(tls *TLS, pctx uintptr, h uintptr) (r int32) { @@ -120393,7 +120393,7 @@ func _netlink_msg_to_ifaddr(tls *TLS, pctx uintptr, h uintptr) (r int32) { rta = rta + uintptr((Int32FromUint16((*Trtattr)(unsafe.Pointer(rta)).Frta_len)+Int32FromInt32(3)) & ^Int32FromInt32(3)) } } else { - ifs0 = *(*uintptr)(unsafe.Pointer(ctx + 16 + uintptr((*Tifaddrmsg)(unsafe.Pointer(ifa)).Fifa_index%uint32(IFADDRS_HASH_SIZE))*8)) + ifs0 = **(**uintptr)(__ccgo_up(ctx + 16 + uintptr((*Tifaddrmsg)(unsafe.Pointer(ifa)).Fifa_index%uint32(IFADDRS_HASH_SIZE))*8)) for { if !(ifs0 != 0) { break @@ -120444,8 +120444,8 @@ func _netlink_msg_to_ifaddr(tls *TLS, pctx uintptr, h uintptr) (r int32) { } if (*Tifaddrs_storage)(unsafe.Pointer(ifs)).Fifa.Fifa_name != 0 { bucket = (*Tifaddrs_storage)(unsafe.Pointer(ifs)).Findex % uint32(IFADDRS_HASH_SIZE) - (*Tifaddrs_storage)(unsafe.Pointer(ifs)).Fhash_next = *(*uintptr)(unsafe.Pointer(ctx + 16 + uintptr(bucket)*8)) - *(*uintptr)(unsafe.Pointer(ctx + 16 + uintptr(bucket)*8)) = ifs + (*Tifaddrs_storage)(unsafe.Pointer(ifs)).Fhash_next = **(**uintptr)(__ccgo_up(ctx + 16 + uintptr(bucket)*8)) + **(**uintptr)(__ccgo_up(ctx + 16 + uintptr(bucket)*8)) = ifs } } else { (*Tifaddrs_storage)(unsafe.Pointer(ifs)).Fifa.Fifa_name = (*Tifaddrs_storage)(unsafe.Pointer(ifs0)).Fifa.Fifa_name @@ -120520,7 +120520,7 @@ func Xgetifaddrs(tls *TLS, ifap uintptr) (r1 int32) { Xmemset(tls, ctx, 0, uint64(528)) r = X__rtnetlink_enumerate(tls, PF_UNSPEC, PF_UNSPEC, __ccgo_fp(_netlink_msg_to_ifaddr), ctx) if r == 0 { - *(*uintptr)(unsafe.Pointer(ifap)) = (*Tifaddrs_ctx)(unsafe.Pointer(ctx)).Ffirst + **(**uintptr)(__ccgo_up(ifap)) = (*Tifaddrs_ctx)(unsafe.Pointer(ctx)).Ffirst } else { Xfreeifaddrs(tls, (*Tifaddrs_ctx)(unsafe.Pointer(ctx)).Ffirst) } @@ -120535,11 +120535,11 @@ func _itoa(tls *TLS, p uintptr, x uint32) (r uintptr) { p = p + uintptr(Uint64FromInt32(3)*Uint64FromInt64(4)) p = p - 1 v1 = p - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) for cond := true; cond; cond = x != 0 { p = p - 1 v1 = p - *(*uint8)(unsafe.Pointer(v1)) = uint8(uint32('0') + x%uint32(10)) + **(**uint8)(__ccgo_up(v1)) = uint8(uint32('0') + x%uint32(10)) x = x / uint32(10) } return p @@ -120548,7 +120548,7 @@ func _itoa(tls *TLS, p uintptr, x uint32) (r uintptr) { func _mkptr4(tls *TLS, s uintptr, ip uintptr) { bp := tls.Alloc(48) defer tls.Free(48) - Xsprintf(tls, s, __ccgo_ts+1021, VaList(bp+8, Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + 3))), Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + 2))), Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + 1))), Int32FromUint8(*(*uint8)(unsafe.Pointer(ip))))) + Xsprintf(tls, s, __ccgo_ts+1021, VaList(bp+8, Int32FromUint8(**(**uint8)(__ccgo_up(ip + 3))), Int32FromUint8(**(**uint8)(__ccgo_up(ip + 2))), Int32FromUint8(**(**uint8)(__ccgo_up(ip + 1))), Int32FromUint8(**(**uint8)(__ccgo_up(ip))))) } func _mkptr6(tls *TLS, s uintptr, ip uintptr) { @@ -120562,16 +120562,16 @@ func _mkptr6(tls *TLS, s uintptr, ip uintptr) { } v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = _xdigits[Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + uintptr(i))))&int32(15)] + **(**uint8)(__ccgo_up(v2)) = _xdigits[Int32FromUint8(**(**uint8)(__ccgo_up(ip + uintptr(i))))&int32(15)] v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8('.') + **(**uint8)(__ccgo_up(v2)) = uint8('.') v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = _xdigits[Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + uintptr(i))))>>int32(4)] + **(**uint8)(__ccgo_up(v2)) = _xdigits[Int32FromUint8(**(**uint8)(__ccgo_up(ip + uintptr(i))))>>int32(4)] v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8('.') + **(**uint8)(__ccgo_up(v2)) = uint8('.') goto _1 _1: ; @@ -120609,13 +120609,13 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int if v1 != 0 { v2 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8('\n') - *(*uint8)(unsafe.Pointer(p)) = Uint8FromInt32(0) + **(**uint8)(__ccgo_up(v2)) = uint8('\n') + **(**uint8)(__ccgo_up(p)) = Uint8FromInt32(0) } p = bp for { - if v7 = *(*uint8)(unsafe.Pointer(p)) != 0; v7 { - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + if v7 = **(**uint8)(__ccgo_up(p)) != 0; v7 { + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v5 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _6 _6: @@ -120628,26 +120628,26 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int ; p = p + 1 } - if !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if !(**(**uint8)(__ccgo_up(p)) != 0) { continue } v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) if X__lookup_ipliteral(tls, bp+1560, bp, PF_UNSPEC) <= 0 { continue } - if (*(*Taddress)(unsafe.Pointer(bp + 1560))).Ffamily == int32(PF_INET) { + if (**(**Taddress)(__ccgo_up(bp + 1560))).Ffamily == int32(PF_INET) { Xmemcpy(tls, bp+1560+8+uintptr(12), bp+1560+8, uint64(4)) Xmemcpy(tls, bp+1560+8, __ccgo_ts+1066, uint64(12)) - (*(*Taddress)(unsafe.Pointer(bp + 1560))).Fscopeid = uint32(0) + (**(**Taddress)(__ccgo_up(bp + 1560))).Fscopeid = uint32(0) } - if Xmemcmp(tls, a, bp+1560+8, uint64(16)) != 0 || (*(*Taddress)(unsafe.Pointer(bp + 1560))).Fscopeid != scopeid { + if Xmemcmp(tls, a, bp+1560+8, uint64(16)) != 0 || (**(**Taddress)(__ccgo_up(bp + 1560))).Fscopeid != scopeid { continue } for { - if v7 = *(*uint8)(unsafe.Pointer(p)) != 0; v7 { - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + if v7 = **(**uint8)(__ccgo_up(p)) != 0; v7 { + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v5 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _12 _12: @@ -120662,8 +120662,8 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int } z = p for { - if v7 = *(*uint8)(unsafe.Pointer(z)) != 0; v7 { - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(z))) + if v7 = **(**uint8)(__ccgo_up(z)) != 0; v7 { + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(z))) v5 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _17 _17: @@ -120676,7 +120676,7 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int ; z = z + 1 } - *(*uint8)(unsafe.Pointer(z)) = uint8(0) + **(**uint8)(__ccgo_up(z)) = uint8(0) if int64(z)-int64(p) < int64(256) { Xmemcpy(tls, buf, p, Uint64FromInt64(int64(z)-int64(p)+int64(1))) break @@ -120707,13 +120707,13 @@ func _reverse_services(tls *TLS, buf uintptr, port int32, dgram int32) { if v1 != 0 { v2 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8('\n') - *(*uint8)(unsafe.Pointer(p)) = Uint8FromInt32(0) + **(**uint8)(__ccgo_up(v2)) = uint8('\n') + **(**uint8)(__ccgo_up(p)) = Uint8FromInt32(0) } p = bp for { - if v7 = *(*uint8)(unsafe.Pointer(p)) != 0; v7 { - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + if v7 = **(**uint8)(__ccgo_up(p)) != 0; v7 { + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v5 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _6 _6: @@ -120726,20 +120726,20 @@ func _reverse_services(tls *TLS, buf uintptr, port int32, dgram int32) { ; p = p + 1 } - if !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if !(**(**uint8)(__ccgo_up(p)) != 0) { continue } v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) svport = Xstrtoul(tls, p, bp+128, int32(10)) - if svport != Uint64FromInt32(port) || *(*uintptr)(unsafe.Pointer(bp + 128)) == p { + if svport != Uint64FromInt32(port) || **(**uintptr)(__ccgo_up(bp + 128)) == p { continue } - if dgram != 0 && Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(bp + 128)), __ccgo_ts+1093, uint64(4)) != 0 { + if dgram != 0 && Xstrncmp(tls, **(**uintptr)(__ccgo_up(bp + 128)), __ccgo_ts+1093, uint64(4)) != 0 { continue } - if !(dgram != 0) && Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(bp + 128)), __ccgo_ts+1098, uint64(4)) != 0 { + if !(dgram != 0) && Xstrncmp(tls, **(**uintptr)(__ccgo_up(bp + 128)), __ccgo_ts+1098, uint64(4)) != 0 { continue } if int64(p)-t__predefined_ptrdiff_t(bp) > int64(32) { @@ -120756,7 +120756,7 @@ func _dns_parse_callback(tls *TLS, c uintptr, rr int32, data uintptr, len1 int32 return 0 } if X__dn_expand(tls, packet, packet+uintptr(plen), data, c, int32(256)) <= 0 { - *(*uint8)(unsafe.Pointer(c)) = uint8(0) + **(**uint8)(__ccgo_up(c)) = uint8(0) } return 0 } @@ -120802,15 +120802,15 @@ func Xgetnameinfo(tls *TLS, sa uintptr, sl Tsocklen_t, node uintptr, nodelen Tso return -int32(6) } if node != 0 && nodelen != 0 { - (*(*[256]uint8)(unsafe.Pointer(bp + 78)))[0] = uint8(0) + (**(**[256]uint8)(__ccgo_up(bp + 78)))[0] = uint8(0) if !(flags&Int32FromInt32(NI_NUMERICHOST) != 0) { _reverse_hosts(tls, bp+78, a, scopeid, af) } - if !(*(*uint8)(unsafe.Pointer(bp + 78)) != 0) && !(flags&Int32FromInt32(NI_NUMERICHOST) != 0) { + if !(**(**uint8)(__ccgo_up(bp + 78)) != 0) && !(flags&Int32FromInt32(NI_NUMERICHOST) != 0) { qlen = X__res_mkquery(tls, 0, bp, int32(1), int32(RR_PTR), uintptr(0), 0, uintptr(0), bp+347, int32(96)) - (*(*[96]uint8)(unsafe.Pointer(bp + 347)))[int32(3)] = uint8(0) /* don't need AD flag */ + (**(**[96]uint8)(__ccgo_up(bp + 347)))[int32(3)] = uint8(0) /* don't need AD flag */ rlen = X__res_send(tls, bp+347, qlen, bp+443, int32(512)) - (*(*[256]uint8)(unsafe.Pointer(bp + 78)))[0] = uint8(0) + (**(**[256]uint8)(__ccgo_up(bp + 78)))[0] = uint8(0) if rlen > 0 { if Uint64FromInt32(rlen) > uint64(512) { rlen = int32(512) @@ -120818,14 +120818,14 @@ func Xgetnameinfo(tls *TLS, sa uintptr, sl Tsocklen_t, node uintptr, nodelen Tso X__dns_parse(tls, bp+443, rlen, __ccgo_fp(_dns_parse_callback), bp+78) } } - if !(*(*uint8)(unsafe.Pointer(bp + 78)) != 0) { + if !(**(**uint8)(__ccgo_up(bp + 78)) != 0) { if flags&int32(NI_NAMEREQD) != 0 { return -int32(2) } Xinet_ntop(tls, af, a, bp+78, uint32(256)) if scopeid != 0 { p = uintptr(0) - if !(flags&Int32FromInt32(NI_NUMERICSCOPE) != 0) && (Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a))) == int32(0xfe) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 1)))&int32(0xc0) == int32(0x80) || Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a))) == int32(0xff) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 1)))&int32(0xf) == int32(0x2)) { + if !(flags&Int32FromInt32(NI_NUMERICSCOPE) != 0) && (Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a))) == int32(0xfe) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 1)))&int32(0xc0) == int32(0x80) || Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a))) == int32(0xff) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 1)))&int32(0xf) == int32(0x2)) { p = Xif_indextoname(tls, scopeid, bp+955+uintptr(1)) } if !(p != 0) { @@ -120833,7 +120833,7 @@ func Xgetnameinfo(tls *TLS, sa uintptr, sl Tsocklen_t, node uintptr, nodelen Tso } p = p - 1 v1 = p - *(*uint8)(unsafe.Pointer(v1)) = uint8('%') + **(**uint8)(__ccgo_up(v1)) = uint8('%') Xstrcat(tls, bp+78, p) } } @@ -120845,11 +120845,11 @@ func Xgetnameinfo(tls *TLS, sa uintptr, sl Tsocklen_t, node uintptr, nodelen Tso if serv != 0 && servlen != 0 { p1 = bp + 78 port = Int32FromUint16(Xntohs(tls, (*Tsockaddr_in)(unsafe.Pointer(sa)).Fsin_port)) - (*(*[256]uint8)(unsafe.Pointer(bp + 78)))[0] = uint8(0) + (**(**[256]uint8)(__ccgo_up(bp + 78)))[0] = uint8(0) if !(flags&Int32FromInt32(NI_NUMERICSERV) != 0) { _reverse_services(tls, bp+78, port, flags&int32(NI_DGRAM)) } - if !(*(*uint8)(unsafe.Pointer(p1)) != 0) { + if !(**(**uint8)(__ccgo_up(p1)) != 0) { p1 = _itoa(tls, bp+334, Uint32FromInt32(port)) } if _strlen(tls, p1) >= uint64(servlen) { @@ -120924,11 +120924,11 @@ func Xgetservbyname_r(tls *TLS, name uintptr, prots uintptr, se uintptr, buf uin var _ /* end at bp+8 */ uintptr var _ /* servs at bp+0 */ [2]Tservice _, _, _, _ = align, cnt, proto, v1 - *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) + **(**uintptr)(__ccgo_up(res)) = uintptr(0) /* Don't treat numeric port number strings as service records. */ - *(*uintptr)(unsafe.Pointer(bp + 8)) = __ccgo_ts + **(**uintptr)(__ccgo_up(bp + 8)) = __ccgo_ts Xstrtoul(tls, name, bp+8, int32(10)) - if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) != 0) { + if !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) != 0) { return int32(ENOENT) } /* Align buffer */ @@ -120963,16 +120963,16 @@ func Xgetservbyname_r(tls *TLS, name uintptr, prots uintptr, se uintptr, buf uin } (*Tservent)(unsafe.Pointer(se)).Fs_name = name (*Tservent)(unsafe.Pointer(se)).Fs_aliases = buf - *(*uintptr)(unsafe.Pointer((*Tservent)(unsafe.Pointer(se)).Fs_aliases)) = (*Tservent)(unsafe.Pointer(se)).Fs_name - *(*uintptr)(unsafe.Pointer((*Tservent)(unsafe.Pointer(se)).Fs_aliases + 1*8)) = uintptr(0) - (*Tservent)(unsafe.Pointer(se)).Fs_port = Int32FromUint16(Xhtons(tls, (*(*[2]Tservice)(unsafe.Pointer(bp)))[0].Fport)) - if Int32FromUint8((*(*[2]Tservice)(unsafe.Pointer(bp)))[0].Fproto) == int32(IPPROTO_TCP) { + **(**uintptr)(__ccgo_up((*Tservent)(unsafe.Pointer(se)).Fs_aliases)) = (*Tservent)(unsafe.Pointer(se)).Fs_name + **(**uintptr)(__ccgo_up((*Tservent)(unsafe.Pointer(se)).Fs_aliases + 1*8)) = uintptr(0) + (*Tservent)(unsafe.Pointer(se)).Fs_port = Int32FromUint16(Xhtons(tls, (**(**[2]Tservice)(__ccgo_up(bp)))[0].Fport)) + if Int32FromUint8((**(**[2]Tservice)(__ccgo_up(bp)))[0].Fproto) == int32(IPPROTO_TCP) { v1 = __ccgo_ts + 1103 } else { v1 = __ccgo_ts + 1107 } (*Tservent)(unsafe.Pointer(se)).Fs_proto = v1 - *(*uintptr)(unsafe.Pointer(res)) = se + **(**uintptr)(__ccgo_up(res)) = se return 0 } @@ -121052,7 +121052,7 @@ _9: if true { break } - if uint64(*(*Tsocklen_t)(unsafe.Pointer(optlen))) < uint64(16) { + if uint64(**(**Tsocklen_t)(__ccgo_up(optlen))) < uint64(16) { return int32(X__syscall_ret(tls, Uint64FromInt32(-Int32FromInt32(EINVAL)))) } if optname == int32(SO_RCVTIMEO) { @@ -121089,9 +121089,9 @@ _9: break } tv = optval - (*Ttimeval)(unsafe.Pointer(tv)).Ftv_sec = (*(*[2]int64)(unsafe.Pointer(bp + 8)))[0] - (*Ttimeval)(unsafe.Pointer(tv)).Ftv_usec = (*(*[2]int64)(unsafe.Pointer(bp + 8)))[int32(1)] - *(*Tsocklen_t)(unsafe.Pointer(optlen)) = uint32(16) + (*Ttimeval)(unsafe.Pointer(tv)).Ftv_sec = (**(**[2]int64)(__ccgo_up(bp + 8)))[0] + (*Ttimeval)(unsafe.Pointer(tv)).Ftv_usec = (**(**[2]int64)(__ccgo_up(bp + 8)))[int32(1)] + **(**Tsocklen_t)(__ccgo_up(optlen)) = uint32(16) case int32(SO_TIMESTAMP): fallthrough case int32(SO_TIMESTAMPNS): @@ -121161,7 +121161,7 @@ func Xherror(tls *TLS, msg uintptr) { } else { v2 = __ccgo_ts } - Xfprintf(tls, uintptr(unsafe.Pointer(&X__stderr_FILE)), __ccgo_ts+1111, VaList(bp+8, v1, v2, Xhstrerror(tls, *(*int32)(unsafe.Pointer(X__h_errno_location(tls)))))) + Xfprintf(tls, uintptr(unsafe.Pointer(&X__stderr_FILE)), __ccgo_ts+1111, VaList(bp+8, v1, v2, Xhstrerror(tls, **(**int32)(__ccgo_up(X__h_errno_location(tls)))))) } var _msgs1 = [84]uint8{'H', 'o', 's', 't', ' ', 'n', 'o', 't', ' ', 'f', 'o', 'u', 'n', 'd', 0, 'T', 'r', 'y', ' ', 'a', 'g', 'a', 'i', 'n', 0, 'N', 'o', 'n', '-', 'r', 'e', 'c', 'o', 'v', 'e', 'r', 'a', 'b', 'l', 'e', ' ', 'e', 'r', 'r', 'o', 'r', 0, 'A', 'd', 'd', 'r', 'e', 's', 's', ' ', 'n', 'o', 't', ' ', 'a', 'v', 'a', 'i', 'l', 'a', 'b', 'l', 'e', 0, 0, 'U', 'n', 'k', 'n', 'o', 'w', 'n', ' ', 'e', 'r', 'r', 'o', 'r'} @@ -121176,11 +121176,11 @@ func Xhstrerror(tls *TLS, ecode int32) (r uintptr) { s = uintptr(unsafe.Pointer(&_msgs1)) ecode = ecode - 1 for { - if !(ecode != 0 && *(*uint8)(unsafe.Pointer(s)) != 0) { + if !(ecode != 0 && **(**uint8)(__ccgo_up(s)) != 0) { break } for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { break } goto _2 @@ -121194,7 +121194,7 @@ func Xhstrerror(tls *TLS, ecode int32) (r uintptr) { ecode = ecode - 1 s = s + 1 } - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { s = s + 1 } return X__lctrans_cur(tls, s) @@ -121282,8 +121282,8 @@ func Xif_indextoname(tls *TLS, index uint32, name uintptr) (r1 uintptr) { r = Xioctl(tls, fd, int32(SIOCGIFNAME), VaList(bp+48, bp)) X__syscall1(tls, int64(SYS_close), int64(fd)) if r < 0 { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENODEV) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENXIO) + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENODEV) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENXIO) } return uintptr(0) } @@ -121336,7 +121336,7 @@ func _netlink_msg_to_nameindex(tls *TLS, pctx uintptr, h uintptr) (r int32) { } /* suppress duplicates */ bucket = index % int32(IFADDRS_HASH_SIZE) - i = *(*uint32)(unsafe.Pointer(ctx + 24 + uintptr(bucket)*4)) + i = **(**uint32)(__ccgo_up(ctx + 24 + uintptr(bucket)*4)) for i != 0 { map1 = (*Tifnameindexctx)(unsafe.Pointer(ctx)).Flist + uintptr(i-uint32(1))*28 if (*Tifnamemap)(unsafe.Pointer(map1)).Findex == Uint32FromInt32(index) && Int32FromUint8((*Tifnamemap)(unsafe.Pointer(map1)).Fnamelen) == namelen && Xmemcmp(tls, map1+9, rta+UintptrFromInt64(4), Uint64FromInt32(namelen)) == 0 { @@ -121365,10 +121365,10 @@ func _netlink_msg_to_nameindex(tls *TLS, pctx uintptr, h uintptr) (r int32) { (*Tifnamemap)(unsafe.Pointer(map1)).Findex = Uint32FromInt32(index) (*Tifnamemap)(unsafe.Pointer(map1)).Fnamelen = Uint8FromInt32(namelen) Xmemcpy(tls, map1+9, rta+UintptrFromInt64(4), Uint64FromInt32(namelen)) - *(*uint32)(unsafe.Pointer(ctx + 8)) += Uint32FromInt32(namelen + int32(1)) + **(**uint32)(__ccgo_up(ctx + 8)) += Uint32FromInt32(namelen + int32(1)) (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum = (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum + 1 - (*Tifnamemap)(unsafe.Pointer(map1)).Fhash_next = *(*uint32)(unsafe.Pointer(ctx + 24 + uintptr(bucket)*4)) - *(*uint32)(unsafe.Pointer(ctx + 24 + uintptr(bucket)*4)) = (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum + (*Tifnamemap)(unsafe.Pointer(map1)).Fhash_next = **(**uint32)(__ccgo_up(ctx + 24 + uintptr(bucket)*4)) + **(**uint32)(__ccgo_up(ctx + 24 + uintptr(bucket)*4)) = (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum return 0 goto _1 _1: @@ -121415,7 +121415,7 @@ func Xif_nameindex(tls *TLS) (r uintptr) { p = p + uintptr((*Tifnamemap)(unsafe.Pointer(s)).Fnamelen) v2 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8(0) + **(**uint8)(__ccgo_up(v2)) = uint8(0) goto _1 _1: ; @@ -121428,9 +121428,9 @@ func Xif_nameindex(tls *TLS) (r uintptr) { goto err err: ; - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 280)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 280)), uintptr(0)) Xfree(tls, (*Tifnameindexctx)(unsafe.Pointer(ctx)).Flist) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOBUFS) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOBUFS) return ifs } @@ -121471,7 +121471,7 @@ func Xinet_addr(tls *TLS, p uintptr) (r Tin_addr_t) { if !(X__inet_aton(tls, p, bp) != 0) { return Uint32FromInt32(-Int32FromInt32(1)) } - return (*(*Tin_addr)(unsafe.Pointer(bp))).Fs_addr + return (**(**Tin_addr)(__ccgo_up(bp))).Fs_addr } func X__inet_aton(tls *TLS, s0 uintptr, dest uintptr) (r int32) { @@ -121488,20 +121488,20 @@ func X__inet_aton(tls *TLS, s0 uintptr, dest uintptr) (r int32) { _, _, _ = d, i, s s = s0 d = dest - *(*[4]uint64)(unsafe.Pointer(bp)) = [4]uint64{} + **(**[4]uint64)(__ccgo_up(bp)) = [4]uint64{} i = 0 for { if !(i < int32(4)) { break } - (*(*[4]uint64)(unsafe.Pointer(bp)))[i] = Xstrtoul(tls, s, bp+32, 0) - if *(*uintptr)(unsafe.Pointer(bp + 32)) == s || *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32))))) != int32('.') || !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + (**(**[4]uint64)(__ccgo_up(bp)))[i] = Xstrtoul(tls, s, bp+32, 0) + if **(**uintptr)(__ccgo_up(bp + 32)) == s || **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 32)))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 32))))) != int32('.') || !(BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return 0 } - if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)))) != 0) { + if !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 32)))) != 0) { break } - s = *(*uintptr)(unsafe.Pointer(bp + 32)) + uintptr(1) + s = **(**uintptr)(__ccgo_up(bp + 32)) + uintptr(1) goto _1 _1: ; @@ -121512,26 +121512,26 @@ func X__inet_aton(tls *TLS, s0 uintptr, dest uintptr) (r int32) { } switch i { case 0: - (*(*[4]uint64)(unsafe.Pointer(bp)))[int32(1)] = (*(*[4]uint64)(unsafe.Pointer(bp)))[0] & uint64(0xffffff) - *(*uint64)(unsafe.Pointer(bp)) >>= uint64(24) + (**(**[4]uint64)(__ccgo_up(bp)))[int32(1)] = (**(**[4]uint64)(__ccgo_up(bp)))[0] & uint64(0xffffff) + **(**uint64)(__ccgo_up(bp)) >>= uint64(24) fallthrough case int32(1): - (*(*[4]uint64)(unsafe.Pointer(bp)))[int32(2)] = (*(*[4]uint64)(unsafe.Pointer(bp)))[int32(1)] & uint64(0xffff) - *(*uint64)(unsafe.Pointer(bp + 1*8)) >>= uint64(16) + (**(**[4]uint64)(__ccgo_up(bp)))[int32(2)] = (**(**[4]uint64)(__ccgo_up(bp)))[int32(1)] & uint64(0xffff) + **(**uint64)(__ccgo_up(bp + 1*8)) >>= uint64(16) fallthrough case int32(2): - (*(*[4]uint64)(unsafe.Pointer(bp)))[int32(3)] = (*(*[4]uint64)(unsafe.Pointer(bp)))[int32(2)] & uint64(0xff) - *(*uint64)(unsafe.Pointer(bp + 2*8)) >>= uint64(8) + (**(**[4]uint64)(__ccgo_up(bp)))[int32(3)] = (**(**[4]uint64)(__ccgo_up(bp)))[int32(2)] & uint64(0xff) + **(**uint64)(__ccgo_up(bp + 2*8)) >>= uint64(8) } i = 0 for { if !(i < int32(4)) { break } - if (*(*[4]uint64)(unsafe.Pointer(bp)))[i] > uint64(255) { + if (**(**[4]uint64)(__ccgo_up(bp)))[i] > uint64(255) { return 0 } - *(*uint8)(unsafe.Pointer(d + uintptr(i))) = uint8((*(*[4]uint64)(unsafe.Pointer(bp)))[i]) + **(**uint8)(__ccgo_up(d + uintptr(i))) = uint8((**(**[4]uint64)(__ccgo_up(bp)))[i]) goto _2 _2: ; @@ -121620,7 +121620,7 @@ func Xinet_ntoa(tls *TLS, _in Tin_addr) (r uintptr) { var a uintptr _ = a a = bp - Xsnprintf(tls, uintptr(unsafe.Pointer(&_buf4)), uint64(16), __ccgo_ts+1119, VaList(bp+16, Int32FromUint8(*(*uint8)(unsafe.Pointer(a))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 1))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 2))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 3))))) + Xsnprintf(tls, uintptr(unsafe.Pointer(&_buf4)), uint64(16), __ccgo_ts+1119, VaList(bp+16, Int32FromUint8(**(**uint8)(__ccgo_up(a))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 1))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 2))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 3))))) return uintptr(unsafe.Pointer(&_buf4)) } @@ -121641,14 +121641,14 @@ func Xinet_ntop(tls *TLS, af int32, a0 uintptr, s uintptr, l Tsocklen_t) (r uint a = a0 switch af { case int32(PF_INET): - if Uint32FromInt32(Xsnprintf(tls, s, uint64(l), __ccgo_ts+1119, VaList(bp+112, Int32FromUint8(*(*uint8)(unsafe.Pointer(a))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 1))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 2))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 3)))))) < l { + if Uint32FromInt32(Xsnprintf(tls, s, uint64(l), __ccgo_ts+1119, VaList(bp+112, Int32FromUint8(**(**uint8)(__ccgo_up(a))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 1))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 2))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 3)))))) < l { return s } case int32(PF_INET6): if Xmemcmp(tls, a, __ccgo_ts+1066, uint64(12)) != 0 { - Xsnprintf(tls, bp, uint64(100), __ccgo_ts+1131, VaList(bp+112, int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 1))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 2)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 3))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 4)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 5))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 6)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 7))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 8)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 9))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 10)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 11))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 12)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 13))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 14)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 15))))) + Xsnprintf(tls, bp, uint64(100), __ccgo_ts+1131, VaList(bp+112, int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 1))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 2)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 3))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 4)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 5))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 6)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 7))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 8)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 9))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 10)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 11))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 12)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 13))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 14)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 15))))) } else { - Xsnprintf(tls, bp, uint64(100), __ccgo_ts+1155, VaList(bp+112, int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 1))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 2)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 3))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 4)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 5))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 6)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 7))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 8)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 9))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 10)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 11))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 12))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 13))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 14))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 15))))) + Xsnprintf(tls, bp, uint64(100), __ccgo_ts+1155, VaList(bp+112, int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 1))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 2)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 3))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 4)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 5))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 6)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 7))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 8)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 9))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 10)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 11))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 12))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 13))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 14))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 15))))) } /* Replace longest /(^0|:)[:0]{2,}/ with "::" */ v2 = Int32FromInt32(0) @@ -121656,10 +121656,10 @@ func Xinet_ntop(tls *TLS, af int32, a0 uintptr, s uintptr, l Tsocklen_t) (r uint i = v2 max = Int32FromInt32(2) for { - if !((*(*[100]uint8)(unsafe.Pointer(bp)))[i] != 0) { + if !((**(**[100]uint8)(__ccgo_up(bp)))[i] != 0) { break } - if i != 0 && Int32FromUint8((*(*[100]uint8)(unsafe.Pointer(bp)))[i]) != int32(':') { + if i != 0 && Int32FromUint8((**(**[100]uint8)(__ccgo_up(bp)))[i]) != int32(':') { goto _1 } j = Int32FromUint64(Xstrspn(tls, bp+uintptr(i), __ccgo_ts+1185)) @@ -121674,8 +121674,8 @@ func Xinet_ntop(tls *TLS, af int32, a0 uintptr, s uintptr, l Tsocklen_t) (r uint } if max > int32(3) { v3 = Uint8FromUint8(':') - (*(*[100]uint8)(unsafe.Pointer(bp)))[best+int32(1)] = v3 - (*(*[100]uint8)(unsafe.Pointer(bp)))[best] = v3 + (**(**[100]uint8)(__ccgo_up(bp)))[best+int32(1)] = v3 + (**(**[100]uint8)(__ccgo_up(bp)))[best] = v3 Xmemmove(tls, bp+uintptr(best)+uintptr(2), bp+uintptr(best)+uintptr(max), Uint64FromInt32(i-best-max+int32(1))) } if _strlen(tls, bp) < uint64(l) { @@ -121683,10 +121683,10 @@ func Xinet_ntop(tls *TLS, af int32, a0 uintptr, s uintptr, l Tsocklen_t) (r uint return s } default: - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EAFNOSUPPORT) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EAFNOSUPPORT) return uintptr(0) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOSPC) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOSPC) return uintptr(0) } @@ -121726,23 +121726,23 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { j = v3 v = v3 for { - if !(j < int32(3) && BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s + uintptr(j))))-uint32('0') < uint32(10)) != 0) { + if !(j < int32(3) && BoolInt32(uint32(**(**uint8)(__ccgo_up(s + uintptr(j))))-uint32('0') < uint32(10)) != 0) { break } - v = int32(10)*v + Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(j)))) - int32('0') + v = int32(10)*v + Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(j)))) - int32('0') goto _2 _2: ; j = j + 1 } - if j == 0 || j > int32(1) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('0') || v > int32(255) { + if j == 0 || j > int32(1) && Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('0') || v > int32(255) { return 0 } - *(*uint8)(unsafe.Pointer(a + uintptr(i))) = Uint8FromInt32(v) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(j)))) == 0 && i == int32(3) { + **(**uint8)(__ccgo_up(a + uintptr(i))) = Uint8FromInt32(v) + if Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(j)))) == 0 && i == int32(3) { return int32(1) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(j)))) != int32('.') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(j)))) != int32('.') { return 0 } s = s + uintptr(j+int32(1)) @@ -121754,25 +121754,25 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { return 0 } else { if af != int32(PF_INET6) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EAFNOSUPPORT) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EAFNOSUPPORT) return -int32(1) } } - if v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32(':'); v5 { + if v5 = Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32(':'); v5 { s = s + 1 v4 = s } - if v5 && Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) != int32(':') { + if v5 && Int32FromUint8(**(**uint8)(__ccgo_up(v4))) != int32(':') { return 0 } i = 0 for { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32(':') && brk < 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32(':') && brk < 0 { brk = i - (*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[i&int32(7)] = uint16(0) + (**(**[8]Tuint16_t)(__ccgo_up(bp)))[i&int32(7)] = uint16(0) s = s + 1 v4 = s - if !(*(*uint8)(unsafe.Pointer(v4)) != 0) { + if !(**(**uint8)(__ccgo_up(v4)) != 0) { break } if i == int32(7) { @@ -121785,7 +121785,7 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { v = v3 for { if v5 = j < int32(4); v5 { - v9 = _hexval(tls, uint32(*(*uint8)(unsafe.Pointer(s + uintptr(j))))) + v9 = _hexval(tls, uint32(**(**uint8)(__ccgo_up(s + uintptr(j))))) d = v9 } if !(v5 && v9 >= 0) { @@ -121800,20 +121800,20 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { if j == 0 { return 0 } - (*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[i&int32(7)] = Uint16FromInt32(v) - if !(*(*uint8)(unsafe.Pointer(s + uintptr(j))) != 0) && (brk >= 0 || i == int32(7)) { + (**(**[8]Tuint16_t)(__ccgo_up(bp)))[i&int32(7)] = Uint16FromInt32(v) + if !(**(**uint8)(__ccgo_up(s + uintptr(j))) != 0) && (brk >= 0 || i == int32(7)) { break } if i == int32(7) { return 0 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(j)))) != int32(':') { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(j)))) != int32('.') || i < int32(6) && brk < 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(j)))) != int32(':') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(j)))) != int32('.') || i < int32(6) && brk < 0 { return 0 } need_v4 = int32(1) i = i + 1 - (*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[i&int32(7)] = uint16(0) + (**(**[8]Tuint16_t)(__ccgo_up(bp)))[i&int32(7)] = uint16(0) break } s = s + uintptr(j+int32(1)) @@ -121829,7 +121829,7 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { if !(j < int32(7)-i) { break } - (*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[brk+j] = uint16(0) + (**(**[8]Tuint16_t)(__ccgo_up(bp)))[brk+j] = uint16(0) goto _12 _12: ; @@ -121843,10 +121843,10 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { } v4 = a a = a + 1 - *(*uint8)(unsafe.Pointer(v4)) = Uint8FromInt32(Int32FromUint16((*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[j]) >> int32(8)) + **(**uint8)(__ccgo_up(v4)) = Uint8FromInt32(Int32FromUint16((**(**[8]Tuint16_t)(__ccgo_up(bp)))[j]) >> int32(8)) v4 = a a = a + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8((*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[j]) + **(**uint8)(__ccgo_up(v4)) = uint8((**(**[8]Tuint16_t)(__ccgo_up(bp)))[j]) goto _13 _13: ; @@ -121909,15 +121909,15 @@ func X__lookup_ipliteral(tls *TLS, buf uintptr, name uintptr, family int32) (r i return -int32(5) } Xmemcpy(tls, buf+8, bp, uint64(4)) - (*(*Taddress)(unsafe.Pointer(buf))).Ffamily = int32(PF_INET) - (*(*Taddress)(unsafe.Pointer(buf))).Fscopeid = uint32(0) + (**(**Taddress)(__ccgo_up(buf))).Ffamily = int32(PF_INET) + (**(**Taddress)(__ccgo_up(buf))).Fscopeid = uint32(0) return int32(1) } p = Xstrchr(tls, name, int32('%')) scopeid = uint64(0) if p != 0 && int64(p)-int64(name) < int64(64) { Xmemcpy(tls, bp+20, name, Uint64FromInt64(int64(p)-int64(name))) - (*(*[64]uint8)(unsafe.Pointer(bp + 20)))[int64(p)-int64(name)] = uint8(0) + (**(**[64]uint8)(__ccgo_up(bp + 20)))[int64(p)-int64(name)] = uint8(0) name = bp + 20 } if Xinet_pton(tls, int32(PF_INET6), name, bp+4) <= 0 { @@ -121927,17 +121927,17 @@ func X__lookup_ipliteral(tls *TLS, buf uintptr, name uintptr, family int32) (r i return -int32(5) } Xmemcpy(tls, buf+8, bp+4, uint64(16)) - (*(*Taddress)(unsafe.Pointer(buf))).Ffamily = int32(PF_INET6) + (**(**Taddress)(__ccgo_up(buf))).Ffamily = int32(PF_INET6) if p != 0 { p = p + 1 v1 = p - if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(v1)))-uint32('0') < uint32(10)) != 0 { + if BoolInt32(uint32(**(**uint8)(__ccgo_up(v1)))-uint32('0') < uint32(10)) != 0 { scopeid = Xstrtoull(tls, p, bp+88, int32(10)) } else { - *(*uintptr)(unsafe.Pointer(bp + 88)) = p - uintptr(1) + **(**uintptr)(__ccgo_up(bp + 88)) = p - uintptr(1) } - if *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 88)))) != 0 { - if !(Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(bp + 4))) == int32(0xfe) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(bp + 4 + 1)))&int32(0xc0) == int32(0x80)) && !(Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(bp + 4))) == int32(0xff) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(bp + 4 + 1)))&int32(0xf) == int32(0x2)) { + if **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 88)))) != 0 { + if !(Int32FromUint8(**(**Tuint8_t)(__ccgo_up(bp + 4))) == int32(0xfe) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(bp + 4 + 1)))&int32(0xc0) == int32(0x80)) && !(Int32FromUint8(**(**Tuint8_t)(__ccgo_up(bp + 4))) == int32(0xff) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(bp + 4 + 1)))&int32(0xf) == int32(0x2)) { return -int32(2) } scopeid = uint64(Xif_nametoindex(tls, p)) @@ -121949,7 +121949,7 @@ func X__lookup_ipliteral(tls *TLS, buf uintptr, name uintptr, family int32) (r i return -int32(2) } } - (*(*Taddress)(unsafe.Pointer(buf))).Fscopeid = uint32(scopeid) + (**(**Taddress)(__ccgo_up(buf))).Fscopeid = uint32(scopeid) return int32(1) } @@ -121973,7 +121973,7 @@ func _is_valid_hostname(tls *TLS, host uintptr) (r int32) { } s = host for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) >= int32(0x80) || Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('.') || Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('-') || Xisalnum(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))) != 0) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(s))) >= int32(0x80) || Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('.') || Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('-') || Xisalnum(tls, Int32FromUint8(**(**uint8)(__ccgo_up(s)))) != 0) { break } goto _1 @@ -121981,7 +121981,7 @@ func _is_valid_hostname(tls *TLS, host uintptr) (r int32) { ; s = s + 1 } - return BoolInt32(!(*(*uint8)(unsafe.Pointer(s)) != 0)) + return BoolInt32(!(**(**uint8)(__ccgo_up(s)) != 0)) } func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags int32) (r int32) { @@ -121995,14 +121995,14 @@ func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags in if family != int32(PF_INET6) { v1 = cnt cnt = cnt + 1 - *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ + **(**Taddress)(__ccgo_up(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET), } } if family != int32(PF_INET) { v1 = cnt cnt = cnt + 1 - *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ + **(**Taddress)(__ccgo_up(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET6), } } @@ -122010,7 +122010,7 @@ func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags in if family != int32(PF_INET6) { v1 = cnt cnt = cnt + 1 - *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ + **(**Taddress)(__ccgo_up(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET), Faddr: [16]Tuint8_t{ 0: uint8(127), @@ -122021,7 +122021,7 @@ func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags in if family != int32(PF_INET) { v1 = cnt cnt = cnt + 1 - *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ + **(**Taddress)(__ccgo_up(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET6), Faddr: [16]Tuint8_t{ 15: uint8(1), @@ -122053,7 +122053,7 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family have_canon = 0 f = X__fopen_rb_ca(tls, __ccgo_ts+1055, bp+1544, bp+512, uint64(1032)) if !(f != 0) { - switch *(*int32)(unsafe.Pointer(X__errno_location(tls))) { + switch **(**int32)(__ccgo_up(X__errno_location(tls))) { case int32(ENOENT): fallthrough case int32(ENOTDIR): @@ -122070,21 +122070,21 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family if v1 != 0 { v2 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8('\n') - *(*uint8)(unsafe.Pointer(p)) = Uint8FromInt32(0) + **(**uint8)(__ccgo_up(v2)) = uint8('\n') + **(**uint8)(__ccgo_up(p)) = Uint8FromInt32(0) } p = bp + uintptr(1) for { v1 = Xstrstr(tls, p, name) p = v1 if v12 = v1 != 0; v12 { - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) + v5 = Int32FromUint8(**(**uint8)(__ccgo_up(p + uintptr(-Int32FromInt32(1))))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _7 _7: ; if v11 = !(v6 != 0); !v11 { - v8 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(l)))) + v8 = Int32FromUint8(**(**uint8)(__ccgo_up(p + uintptr(l)))) v9 = BoolInt32(v8 == int32(' ') || Uint32FromInt32(v8)-uint32('\t') < uint32(5)) goto _10 _10: @@ -122104,8 +122104,8 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family /* Isolate IP address to parse */ p = bp for { - if v11 = *(*uint8)(unsafe.Pointer(p)) != 0; v11 { - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + if v11 = **(**uint8)(__ccgo_up(p)) != 0; v11 { + v5 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _16 _16: @@ -122120,7 +122120,7 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family } v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) switch _name_from_numeric(tls, buf+uintptr(cnt)*28, bp, family) { case int32(1): cnt = cnt + 1 @@ -122135,8 +122135,8 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family } /* Extract first name as canonical name */ for { - if v11 = *(*uint8)(unsafe.Pointer(p)) != 0; v11 { - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + if v11 = **(**uint8)(__ccgo_up(p)) != 0; v11 { + v5 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _22 _22: @@ -122151,8 +122151,8 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family } z = p for { - if v11 = *(*uint8)(unsafe.Pointer(z)) != 0; v11 { - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(z))) + if v11 = **(**uint8)(__ccgo_up(z)) != 0; v11 { + v5 = Int32FromUint8(**(**uint8)(__ccgo_up(z))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _27 _27: @@ -122165,7 +122165,7 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family ; z = z + 1 } - *(*uint8)(unsafe.Pointer(z)) = uint8(0) + **(**uint8)(__ccgo_up(z)) = uint8(0) if _is_valid_hostname(tls, p) != 0 { have_canon = int32(1) Xmemcpy(tls, canon, p, Uint64FromInt64(int64(z)-int64(p)+int64(1))) @@ -122220,8 +122220,8 @@ func _dns_parse_callback1(tls *TLS, c uintptr, rr int32, data uintptr, len1 int3 family = int32(PF_INET6) break } - (*(*Taddress)(unsafe.Pointer((*Tdpc_ctx)(unsafe.Pointer(ctx)).Faddrs + uintptr((*Tdpc_ctx)(unsafe.Pointer(ctx)).Fcnt)*28))).Ffamily = family - (*(*Taddress)(unsafe.Pointer((*Tdpc_ctx)(unsafe.Pointer(ctx)).Faddrs + uintptr((*Tdpc_ctx)(unsafe.Pointer(ctx)).Fcnt)*28))).Fscopeid = uint32(0) + (**(**Taddress)(__ccgo_up((*Tdpc_ctx)(unsafe.Pointer(ctx)).Faddrs + uintptr((*Tdpc_ctx)(unsafe.Pointer(ctx)).Fcnt)*28))).Ffamily = family + (**(**Taddress)(__ccgo_up((*Tdpc_ctx)(unsafe.Pointer(ctx)).Faddrs + uintptr((*Tdpc_ctx)(unsafe.Pointer(ctx)).Fcnt)*28))).Fscopeid = uint32(0) v2 = ctx + 16 v1 = *(*int32)(unsafe.Pointer(v2)) *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) + 1 @@ -122242,16 +122242,16 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i var _ /* qlens at bp+10192 */ [2]int32 var _ /* qp at bp+10160 */ [2]uintptr _, _, _ = i, nq, qtypes - *(*[2]uintptr)(unsafe.Pointer(bp + 10160)) = [2]uintptr{ + **(**[2]uintptr)(__ccgo_up(bp + 10160)) = [2]uintptr{ 0: bp, 1: bp + 1*280, } - *(*[2]uintptr)(unsafe.Pointer(bp + 10176)) = [2]uintptr{ + **(**[2]uintptr)(__ccgo_up(bp + 10176)) = [2]uintptr{ 0: bp + 560, 1: bp + 560 + 1*4800, } nq = 0 - *(*Tdpc_ctx)(unsafe.Pointer(bp + 10208)) = Tdpc_ctx{ + **(**Tdpc_ctx)(__ccgo_up(bp + 10208)) = Tdpc_ctx{ Faddrs: buf, Fcanon: canon, } @@ -122261,15 +122261,15 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i break } if family != _afrr[i].Faf { - (*(*[2]int32)(unsafe.Pointer(bp + 10192)))[nq] = X__res_mkquery(tls, 0, name, int32(1), _afrr[i].Frr, uintptr(0), 0, uintptr(0), bp+uintptr(nq)*280, int32(280)) - if (*(*[2]int32)(unsafe.Pointer(bp + 10192)))[nq] == -int32(1) { + (**(**[2]int32)(__ccgo_up(bp + 10192)))[nq] = X__res_mkquery(tls, 0, name, int32(1), _afrr[i].Frr, uintptr(0), 0, uintptr(0), bp+uintptr(nq)*280, int32(280)) + if (**(**[2]int32)(__ccgo_up(bp + 10192)))[nq] == -int32(1) { return 0 } qtypes[nq] = _afrr[i].Frr - *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280 + 3)) = uint8(0) /* don't need AD flag */ + **(**uint8)(__ccgo_up(bp + uintptr(nq)*280 + 3)) = uint8(0) /* don't need AD flag */ /* Ensure query IDs are distinct. */ - if nq != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) { - *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280)) = *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280)) + 1 + if nq != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(bp + uintptr(nq)*280))) == Int32FromUint8(**(**uint8)(__ccgo_up(bp))) { + **(**uint8)(__ccgo_up(bp + uintptr(nq)*280)) = **(**uint8)(__ccgo_up(bp + uintptr(nq)*280)) + 1 } nq = nq + 1 } @@ -122286,13 +122286,13 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if !(i < nq) { break } - if (*(*[2]int32)(unsafe.Pointer(bp + 10200)))[i] < int32(4) || Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + 560 + uintptr(i)*4800 + 3)))&int32(15) == int32(2) { + if (**(**[2]int32)(__ccgo_up(bp + 10200)))[i] < int32(4) || Int32FromUint8(**(**uint8)(__ccgo_up(bp + 560 + uintptr(i)*4800 + 3)))&int32(15) == int32(2) { return -int32(3) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + 560 + uintptr(i)*4800 + 3)))&int32(15) == int32(3) { + if Int32FromUint8(**(**uint8)(__ccgo_up(bp + 560 + uintptr(i)*4800 + 3)))&int32(15) == int32(3) { return 0 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + 560 + uintptr(i)*4800 + 3)))&int32(15) != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(bp + 560 + uintptr(i)*4800 + 3)))&int32(15) != 0 { return -int32(4) } goto _2 @@ -122305,18 +122305,18 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if !(i >= 0) { break } - (*(*Tdpc_ctx)(unsafe.Pointer(bp + 10208))).Frrtype = qtypes[i] - if Uint64FromInt32((*(*[2]int32)(unsafe.Pointer(bp + 10200)))[i]) > uint64(4800) { - (*(*[2]int32)(unsafe.Pointer(bp + 10200)))[i] = int32(4800) + (**(**Tdpc_ctx)(__ccgo_up(bp + 10208))).Frrtype = qtypes[i] + if Uint64FromInt32((**(**[2]int32)(__ccgo_up(bp + 10200)))[i]) > uint64(4800) { + (**(**[2]int32)(__ccgo_up(bp + 10200)))[i] = int32(4800) } - X__dns_parse(tls, bp+560+uintptr(i)*4800, (*(*[2]int32)(unsafe.Pointer(bp + 10200)))[i], __ccgo_fp(_dns_parse_callback1), bp+10208) + X__dns_parse(tls, bp+560+uintptr(i)*4800, (**(**[2]int32)(__ccgo_up(bp + 10200)))[i], __ccgo_fp(_dns_parse_callback1), bp+10208) goto _3 _3: ; i = i - 1 } - if (*(*Tdpc_ctx)(unsafe.Pointer(bp + 10208))).Fcnt != 0 { - return (*(*Tdpc_ctx)(unsafe.Pointer(bp + 10208))).Fcnt + if (**(**Tdpc_ctx)(__ccgo_up(bp + 10208))).Fcnt != 0 { + return (**(**Tdpc_ctx)(__ccgo_up(bp + 10208))).Fcnt } return -int32(5) } @@ -122354,10 +122354,10 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f l = v2 dots = v2 for { - if !(*(*uint8)(unsafe.Pointer(name + uintptr(l))) != 0) { + if !(**(**uint8)(__ccgo_up(name + uintptr(l))) != 0) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(name + uintptr(l)))) == int32('.') { + if Int32FromUint8(**(**uint8)(__ccgo_up(name + uintptr(l)))) == int32('.') { dots = dots + 1 } goto _1 @@ -122365,14 +122365,14 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f ; l = l + 1 } - if dots >= uint64((*(*Tresolvconf)(unsafe.Pointer(bp + 256))).Fndots) || Int32FromUint8(*(*uint8)(unsafe.Pointer(name + uintptr(l-uint64(1))))) == int32('.') { - *(*uint8)(unsafe.Pointer(bp)) = uint8(0) + if dots >= uint64((**(**Tresolvconf)(__ccgo_up(bp + 256))).Fndots) || Int32FromUint8(**(**uint8)(__ccgo_up(name + uintptr(l-uint64(1))))) == int32('.') { + **(**uint8)(__ccgo_up(bp)) = uint8(0) } /* Strip final dot for canon, fail if multiple trailing dots. */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(name + uintptr(l-uint64(1))))) == int32('.') { + if Int32FromUint8(**(**uint8)(__ccgo_up(name + uintptr(l-uint64(1))))) == int32('.') { l = l - 1 } - if !(l != 0) || Int32FromUint8(*(*uint8)(unsafe.Pointer(name + uintptr(l-uint64(1))))) == int32('.') { + if !(l != 0) || Int32FromUint8(**(**uint8)(__ccgo_up(name + uintptr(l-uint64(1))))) == int32('.') { return -int32(2) } /* This can never happen; the caller already checked length. */ @@ -122384,14 +122384,14 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f * name is not a CNAME record) and serves as a buffer for passing * the full requested name to name_from_dns. */ Xmemcpy(tls, canon, name, l) - *(*uint8)(unsafe.Pointer(canon + uintptr(l))) = uint8('.') + **(**uint8)(__ccgo_up(canon + uintptr(l))) = uint8('.') p = bp for { - if !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if !(**(**uint8)(__ccgo_up(p)) != 0) { break } for { - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v5 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _7 _7: @@ -122405,8 +122405,8 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f } z = p for { - if v12 = *(*uint8)(unsafe.Pointer(z)) != 0; v12 { - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(z))) + if v12 = **(**uint8)(__ccgo_up(z)) != 0; v12 { + v5 = Int32FromUint8(**(**uint8)(__ccgo_up(z))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _11 _11: @@ -122424,7 +122424,7 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f } if Uint64FromInt64(int64(z)-int64(p)) < uint64(256)-l-uint64(1) { Xmemcpy(tls, canon+uintptr(l)+uintptr(1), p, Uint64FromInt64(int64(z)-int64(p))) - *(*uint8)(unsafe.Pointer(canon + uintptr(Uint64FromInt64(int64(z)-int64(p)+int64(1))+l))) = uint8(0) + **(**uint8)(__ccgo_up(canon + uintptr(Uint64FromInt64(int64(z)-int64(p)+int64(1))+l))) = uint8(0) cnt = _name_from_dns(tls, buf, canon, canon, family, bp+256) if cnt != 0 { return cnt @@ -122435,7 +122435,7 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f ; p = z } - *(*uint8)(unsafe.Pointer(canon + uintptr(l))) = uint8(0) + **(**uint8)(__ccgo_up(canon + uintptr(l))) = uint8(0) return _name_from_dns(tls, buf, canon, name, family, bp+256) } @@ -122496,7 +122496,7 @@ func _policyof(tls *TLS, a uintptr) (r uintptr) { if Xmemcmp(tls, a, uintptr(unsafe.Pointer(&_defpolicy))+uintptr(i)*20, uint64(_defpolicy[i].Flen1)) != 0 { goto _1 } - if Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + uintptr(_defpolicy[i].Flen1))))&Int32FromUint8(_defpolicy[i].Fmask) != Int32FromUint8(*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_defpolicy)) + uintptr(i)*20 + uintptr(_defpolicy[i].Flen1)))) { + if Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + uintptr(_defpolicy[i].Flen1))))&Int32FromUint8(_defpolicy[i].Fmask) != Int32FromUint8(**(**uint8)(__ccgo_up(uintptr(unsafe.Pointer(&_defpolicy)) + uintptr(i)*20 + uintptr(_defpolicy[i].Flen1)))) { goto _1 } return uintptr(unsafe.Pointer(&_defpolicy)) + uintptr(i)*20 @@ -122513,16 +122513,16 @@ func _labelof(tls *TLS, a uintptr) (r int32) { } func _scopeof(tls *TLS, a uintptr) (r int32) { - if Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a))) == int32(0xff) { - return Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 1))) & int32(15) + if Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a))) == int32(0xff) { + return Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 1))) & int32(15) } - if Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a))) == int32(0xfe) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 1)))&int32(0xc0) == int32(0x80) { + if Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a))) == int32(0xfe) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 1)))&int32(0xc0) == int32(0x80) { return int32(2) } - if *(*Tuint32_t)(unsafe.Pointer(a)) == uint32(0) && *(*Tuint32_t)(unsafe.Pointer(a + 1*4)) == uint32(0) && *(*Tuint32_t)(unsafe.Pointer(a + 2*4)) == uint32(0) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 12))) == 0 && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 13))) == 0 && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 14))) == 0 && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 15))) == int32(1) { + if **(**Tuint32_t)(__ccgo_up(a)) == uint32(0) && **(**Tuint32_t)(__ccgo_up(a + 1*4)) == uint32(0) && **(**Tuint32_t)(__ccgo_up(a + 2*4)) == uint32(0) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 12))) == 0 && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 13))) == 0 && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 14))) == 0 && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 15))) == int32(1) { return int32(2) } - if Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a))) == int32(0xfe) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 1)))&int32(0xc0) == int32(0xc0) { + if Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a))) == int32(0xfe) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 1)))&int32(0xc0) == int32(0xc0) { return int32(5) } return int32(14) @@ -122533,7 +122533,7 @@ func _prefixmatch(tls *TLS, s uintptr, d uintptr) (r int32) { _ = i i = uint32(0) for { - if !(i < uint32(128) && !((Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(s + uintptr(i/uint32(8)))))^Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(d + uintptr(i/uint32(8))))))&(Int32FromInt32(128)>>(i%Uint32FromInt32(8))) != 0)) { + if !(i < uint32(128) && !((Int32FromUint8(**(**Tuint8_t)(__ccgo_up(s + uintptr(i/uint32(8)))))^Int32FromUint8(**(**Tuint8_t)(__ccgo_up(d + uintptr(i/uint32(8))))))&(Int32FromInt32(128)>>(i%Uint32FromInt32(8))) != 0)) { break } goto _1 @@ -122571,7 +122571,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i var _ /* salen at bp+92 */ Tsocklen_t _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cnt, da, dalen, dlabel, dpolicy, dprec, dscope, family1, fd, i, j, key, l, prefixlen, sa, v1 cnt = 0 - *(*uint8)(unsafe.Pointer(canon)) = uint8(0) + **(**uint8)(__ccgo_up(canon)) = uint8(0) if name != 0 { /* reject empty name and check len so it fits into temp bufs */ l = Xstrnlen(tls, name, uint64(255)) @@ -122615,7 +122615,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i /* If any v6 results exist, remove v4 results. */ i = 0 for { - if !(i < cnt && (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily != int32(PF_INET6)) { + if !(i < cnt && (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Ffamily != int32(PF_INET6)) { break } goto _2 @@ -122629,10 +122629,10 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if !(i < cnt) { break } - if (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily == int32(PF_INET6) { + if (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Ffamily == int32(PF_INET6) { v1 = j j = j + 1 - *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = *(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28)) + **(**Taddress)(__ccgo_up(buf + uintptr(v1)*28)) = **(**Taddress)(__ccgo_up(buf + uintptr(i)*28)) } goto _3 _3: @@ -122650,12 +122650,12 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if !(i < cnt) { break } - if (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily != int32(PF_INET) { + if (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Ffamily != int32(PF_INET) { goto _6 } Xmemcpy(tls, buf+uintptr(i)*28+8+uintptr(12), buf+uintptr(i)*28+8, uint64(4)) Xmemcpy(tls, buf+uintptr(i)*28+8, __ccgo_ts+1066, uint64(12)) - (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily = int32(PF_INET6) + (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Ffamily = int32(PF_INET6) goto _6 _6: ; @@ -122672,7 +122672,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if !(i < cnt) { break } - if (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily != int32(PF_INET) { + if (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Ffamily != int32(PF_INET) { break } goto _7 @@ -122694,16 +122694,16 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if !(i < cnt) { break } - family1 = (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily + family1 = (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Ffamily key = 0 - *(*Tsockaddr_in6)(unsafe.Pointer(bp + 4)) = Tsockaddr_in6{} - *(*Tsockaddr_in6)(unsafe.Pointer(bp + 32)) = Tsockaddr_in6{ + **(**Tsockaddr_in6)(__ccgo_up(bp + 4)) = Tsockaddr_in6{} + **(**Tsockaddr_in6)(__ccgo_up(bp + 32)) = Tsockaddr_in6{ Fsin6_family: uint16(PF_INET6), Fsin6_port: uint16(65535), - Fsin6_scope_id: (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Fscopeid, + Fsin6_scope_id: (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Fscopeid, } - *(*Tsockaddr_in)(unsafe.Pointer(bp + 60)) = Tsockaddr_in{} - *(*Tsockaddr_in)(unsafe.Pointer(bp + 76)) = Tsockaddr_in{ + **(**Tsockaddr_in)(__ccgo_up(bp + 60)) = Tsockaddr_in{} + **(**Tsockaddr_in)(__ccgo_up(bp + 76)) = Tsockaddr_in{ Fsin_family: uint16(PF_INET), Fsin_port: uint16(65535), } @@ -122712,7 +122712,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i da = bp + 32 dalen = uint32(28) sa = bp + 4 - *(*Tsocklen_t)(unsafe.Pointer(bp + 92)) = uint32(28) + **(**Tsocklen_t)(__ccgo_up(bp + 92)) = uint32(28) } else { Xmemcpy(tls, bp+4+8, __ccgo_ts+1066, uint64(12)) Xmemcpy(tls, bp+32+8+uintptr(12), buf+uintptr(i)*28+8, uint64(4)) @@ -122722,7 +122722,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i da = bp + 76 dalen = uint32(16) sa = bp + 60 - *(*Tsocklen_t)(unsafe.Pointer(bp + 92)) = uint32(16) + **(**Tsocklen_t)(__ccgo_up(bp + 92)) = uint32(16) } dpolicy = _policyof(tls, bp+32+8) dscope = _scopeof(tls, bp+32+8) @@ -122752,14 +122752,14 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i key = key | (int32(15)-dscope)< uint64(65535) { return -int32(8) } if proto != int32(IPPROTO_UDP) { - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fport = uint16(port) - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_STREAM) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fport = uint16(port) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_STREAM) v1 = cnt cnt = cnt + 1 - (*(*Tservice)(unsafe.Pointer(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_TCP) + (**(**Tservice)(__ccgo_up(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_TCP) } if proto != int32(IPPROTO_TCP) { - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fport = uint16(port) - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_DGRAM) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fport = uint16(port) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_DGRAM) v1 = cnt cnt = cnt + 1 - (*(*Tservice)(unsafe.Pointer(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_UDP) + (**(**Tservice)(__ccgo_up(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_UDP) } return cnt } @@ -122845,7 +122845,7 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i l = _strlen(tls, name) f = X__fopen_rb_ca(tls, __ccgo_ts+1079, bp+1168, bp+136, uint64(1032)) if !(f != 0) { - switch *(*int32)(unsafe.Pointer(X__errno_location(tls))) { + switch **(**int32)(__ccgo_up(X__errno_location(tls))) { case int32(ENOENT): fallthrough case int32(ENOTDIR): @@ -122862,8 +122862,8 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i if v3 != 0 { v4 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8('\n') - *(*uint8)(unsafe.Pointer(p)) = Uint8FromInt32(0) + **(**uint8)(__ccgo_up(v4)) = uint8('\n') + **(**uint8)(__ccgo_up(p)) = Uint8FromInt32(0) } /* Find service name */ p = bp @@ -122874,7 +122874,7 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i break } if v10 = p > bp; v10 { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(p + uintptr(-Int32FromInt32(1))))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _9 _9: @@ -122882,8 +122882,8 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i if v10 && !(v2 != 0) { goto _5 } - if v10 = *(*uint8)(unsafe.Pointer(p + uintptr(l))) != 0; v10 { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(l)))) + if v10 = **(**uint8)(__ccgo_up(p + uintptr(l))) != 0; v10 { + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(p + uintptr(l)))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _13 _13: @@ -122903,8 +122903,8 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i /* Skip past canonical name at beginning of line */ p = bp for { - if v10 = *(*uint8)(unsafe.Pointer(p)) != 0; v10 { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + if v10 = **(**uint8)(__ccgo_up(p)) != 0; v10 { + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _18 _18: @@ -122918,28 +122918,28 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i p = p + 1 } port = Xstrtoul(tls, p, bp+128, int32(10)) - if port > uint64(65535) || *(*uintptr)(unsafe.Pointer(bp + 128)) == p { + if port > uint64(65535) || **(**uintptr)(__ccgo_up(bp + 128)) == p { continue } - if !(Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(bp + 128)), __ccgo_ts+1093, uint64(4)) != 0) { + if !(Xstrncmp(tls, **(**uintptr)(__ccgo_up(bp + 128)), __ccgo_ts+1093, uint64(4)) != 0) { if proto == int32(IPPROTO_TCP) { continue } - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fport = uint16(port) - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_DGRAM) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fport = uint16(port) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_DGRAM) v1 = cnt cnt = cnt + 1 - (*(*Tservice)(unsafe.Pointer(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_UDP) + (**(**Tservice)(__ccgo_up(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_UDP) } - if !(Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(bp + 128)), __ccgo_ts+1098, uint64(4)) != 0) { + if !(Xstrncmp(tls, **(**uintptr)(__ccgo_up(bp + 128)), __ccgo_ts+1098, uint64(4)) != 0) { if proto == int32(IPPROTO_UDP) { continue } - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fport = uint16(port) - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_STREAM) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fport = uint16(port) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_STREAM) v1 = cnt cnt = cnt + 1 - (*(*Tservice)(unsafe.Pointer(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_TCP) + (**(**Tservice)(__ccgo_up(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_TCP) } } X__fclose_ca(tls, f) @@ -122969,58 +122969,58 @@ func ___netlink_enumerate(tls *TLS, fd int32, seq uint32, type1 int32, af int32, (*(*struct { Fnlh Tnlmsghdr Fg Trtgenmsg - })(unsafe.Pointer(&*(*struct { + })(unsafe.Pointer(&**(**struct { Freq [0]struct { Fnlh Tnlmsghdr Fg Trtgenmsg } Freply [0]Tnlmsghdr Fbuf [8192]Tuint8_t - })(unsafe.Pointer(bp))))).Fnlh.Fnlmsg_len = uint32(20) + })(__ccgo_up(bp))))).Fnlh.Fnlmsg_len = uint32(20) (*(*struct { Fnlh Tnlmsghdr Fg Trtgenmsg - })(unsafe.Pointer(&*(*struct { + })(unsafe.Pointer(&**(**struct { Freq [0]struct { Fnlh Tnlmsghdr Fg Trtgenmsg } Freply [0]Tnlmsghdr Fbuf [8192]Tuint8_t - })(unsafe.Pointer(bp))))).Fnlh.Fnlmsg_type = Uint16FromInt32(type1) + })(__ccgo_up(bp))))).Fnlh.Fnlmsg_type = Uint16FromInt32(type1) (*(*struct { Fnlh Tnlmsghdr Fg Trtgenmsg - })(unsafe.Pointer(&*(*struct { + })(unsafe.Pointer(&**(**struct { Freq [0]struct { Fnlh Tnlmsghdr Fg Trtgenmsg } Freply [0]Tnlmsghdr Fbuf [8192]Tuint8_t - })(unsafe.Pointer(bp))))).Fnlh.Fnlmsg_flags = Uint16FromInt32(Int32FromInt32(NLM_F_ROOT) | Int32FromInt32(NLM_F_MATCH) | Int32FromInt32(NLM_F_REQUEST)) + })(__ccgo_up(bp))))).Fnlh.Fnlmsg_flags = Uint16FromInt32(Int32FromInt32(NLM_F_ROOT) | Int32FromInt32(NLM_F_MATCH) | Int32FromInt32(NLM_F_REQUEST)) (*(*struct { Fnlh Tnlmsghdr Fg Trtgenmsg - })(unsafe.Pointer(&*(*struct { + })(unsafe.Pointer(&**(**struct { Freq [0]struct { Fnlh Tnlmsghdr Fg Trtgenmsg } Freply [0]Tnlmsghdr Fbuf [8192]Tuint8_t - })(unsafe.Pointer(bp))))).Fnlh.Fnlmsg_seq = seq + })(__ccgo_up(bp))))).Fnlh.Fnlmsg_seq = seq (*(*struct { Fnlh Tnlmsghdr Fg Trtgenmsg - })(unsafe.Pointer(&*(*struct { + })(unsafe.Pointer(&**(**struct { Freq [0]struct { Fnlh Tnlmsghdr Fg Trtgenmsg } Freply [0]Tnlmsghdr Fbuf [8192]Tuint8_t - })(unsafe.Pointer(bp))))).Fg.Frtgen_family = Uint8FromInt32(af) + })(__ccgo_up(bp))))).Fg.Frtgen_family = Uint8FromInt32(af) r = int32(Xsend(tls, fd, bp, uint64(20), 0)) if r < 0 { return r @@ -123096,7 +123096,7 @@ func Xns_get16(tls *TLS, cp uintptr) (r uint32) { trc("tls=%v cp=%v, (%v:)", tls, cp, origin(2)) defer func() { trc("-> %v", r) }() } - return Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(cp)))< %v", r) }() } - return uint64(uint32(*(*uint8)(unsafe.Pointer(cp)))<> int32(8)) + **(**uint8)(__ccgo_up(v1)) = uint8(s >> int32(8)) v1 = cp cp = cp + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(s) + **(**uint8)(__ccgo_up(v1)) = uint8(s) } func Xns_put32(tls *TLS, l uint64, cp uintptr) { @@ -123129,16 +123129,16 @@ func Xns_put32(tls *TLS, l uint64, cp uintptr) { _ = v1 v1 = cp cp = cp + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(l >> int32(24)) + **(**uint8)(__ccgo_up(v1)) = uint8(l >> int32(24)) v1 = cp cp = cp + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(l >> int32(16)) + **(**uint8)(__ccgo_up(v1)) = uint8(l >> int32(16)) v1 = cp cp = cp + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(l >> int32(8)) + **(**uint8)(__ccgo_up(v1)) = uint8(l >> int32(8)) v1 = cp cp = cp + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(l) + **(**uint8)(__ccgo_up(v1)) = uint8(l) } func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int32) { @@ -123163,7 +123163,7 @@ func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int3 break } msg = msg + uintptr(2) - *(*Tuint16_t)(unsafe.Pointer(handle + 20 + uintptr(i)*2)) = uint16(Xns_get16(tls, msg-uintptr(2))) + **(**Tuint16_t)(__ccgo_up(handle + 20 + uintptr(i)*2)) = uint16(Xns_get16(tls, msg-uintptr(2))) goto _1 _1: ; @@ -123174,15 +123174,15 @@ func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int3 if !(i < int32(_ns_s_max)) { break } - if *(*Tuint16_t)(unsafe.Pointer(handle + 20 + uintptr(i)*2)) != 0 { - *(*uintptr)(unsafe.Pointer(handle + 32 + uintptr(i)*8)) = msg - r = Xns_skiprr(tls, msg, (*Tns_msg)(unsafe.Pointer(handle)).F_eom, i, Int32FromUint16(*(*Tuint16_t)(unsafe.Pointer(handle + 20 + uintptr(i)*2)))) + if **(**Tuint16_t)(__ccgo_up(handle + 20 + uintptr(i)*2)) != 0 { + **(**uintptr)(__ccgo_up(handle + 32 + uintptr(i)*8)) = msg + r = Xns_skiprr(tls, msg, (*Tns_msg)(unsafe.Pointer(handle)).F_eom, i, Int32FromUint16(**(**Tuint16_t)(__ccgo_up(handle + 20 + uintptr(i)*2)))) if r < 0 { return -int32(1) } msg = msg + uintptr(r) } else { - *(*uintptr)(unsafe.Pointer(handle + 32 + uintptr(i)*8)) = UintptrFromInt32(0) + **(**uintptr)(__ccgo_up(handle + 32 + uintptr(i)*8)) = UintptrFromInt32(0) } goto _2 _2: @@ -123199,7 +123199,7 @@ func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int3 goto bad bad: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EMSGSIZE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EMSGSIZE) return -int32(1) } @@ -123243,7 +123243,7 @@ func Xns_skiprr(tls *TLS, ptr uintptr, eom uintptr, section Tns_sect, count int3 goto bad bad: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EMSGSIZE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EMSGSIZE) return -int32(1) } @@ -123261,31 +123261,31 @@ func Xns_parserr(tls *TLS, handle uintptr, section Tns_sect, rrnum int32, rr uin if section != (*Tns_msg)(unsafe.Pointer(handle)).F_sect { (*Tns_msg)(unsafe.Pointer(handle)).F_sect = section (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum = 0 - (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr = *(*uintptr)(unsafe.Pointer(handle + 32 + uintptr(section)*8)) + (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr = **(**uintptr)(__ccgo_up(handle + 32 + uintptr(section)*8)) } if rrnum == -int32(1) { rrnum = (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum } - if rrnum < 0 || rrnum >= Int32FromUint16(*(*Tuint16_t)(unsafe.Pointer(handle + 20 + uintptr(section)*2))) { + if rrnum < 0 || rrnum >= Int32FromUint16(**(**Tuint16_t)(__ccgo_up(handle + 20 + uintptr(section)*2))) { goto bad } if rrnum < (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum { (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum = 0 - (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr = *(*uintptr)(unsafe.Pointer(handle + 32 + uintptr(section)*8)) + (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr = **(**uintptr)(__ccgo_up(handle + 32 + uintptr(section)*8)) } if rrnum > (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum { r = Xns_skiprr(tls, (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr, (*Tns_msg)(unsafe.Pointer(handle)).F_eom, section, rrnum-(*Tns_msg)(unsafe.Pointer(handle)).F_rrnum) if r < 0 { return -int32(1) } - *(*uintptr)(unsafe.Pointer(handle + 72)) += uintptr(r) + **(**uintptr)(__ccgo_up(handle + 72)) += uintptr(r) (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum = rrnum } r = Xns_name_uncompress(tls, (*Tns_msg)(unsafe.Pointer(handle)).F_msg, (*Tns_msg)(unsafe.Pointer(handle)).F_eom, (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr, rr, uint64(NS_MAXDNAME)) if r < 0 { return -int32(1) } - *(*uintptr)(unsafe.Pointer(handle + 72)) += uintptr(r) + **(**uintptr)(__ccgo_up(handle + 72)) += uintptr(r) if int64(Int32FromInt32(2)*Int32FromInt32(NS_INT16SZ)) > int64((*Tns_msg)(unsafe.Pointer(handle)).F_eom)-int64((*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr) { goto size } @@ -123309,14 +123309,14 @@ func Xns_parserr(tls *TLS, handle uintptr, section Tns_sect, rrnum int32, rr uin goto size } (*Tns_rr)(unsafe.Pointer(rr)).Frdata = (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr - *(*uintptr)(unsafe.Pointer(handle + 72)) += uintptr((*Tns_rr)(unsafe.Pointer(rr)).Frdlength) + **(**uintptr)(__ccgo_up(handle + 72)) += uintptr((*Tns_rr)(unsafe.Pointer(rr)).Frdlength) } else { (*Tns_rr)(unsafe.Pointer(rr)).Fttl = uint32(0) (*Tns_rr)(unsafe.Pointer(rr)).Frdlength = uint16(0) (*Tns_rr)(unsafe.Pointer(rr)).Frdata = UintptrFromInt32(0) } (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum = (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum + 1 - if (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum > Int32FromUint16(*(*Tuint16_t)(unsafe.Pointer(handle + 20 + uintptr(section)*2))) { + if (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum > Int32FromUint16(**(**Tuint16_t)(__ccgo_up(handle + 20 + uintptr(section)*2))) { (*Tns_msg)(unsafe.Pointer(handle)).F_sect = section + int32(1) if (*Tns_msg)(unsafe.Pointer(handle)).F_sect == int32(_ns_s_max) { (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum = -int32(1) @@ -123329,12 +123329,12 @@ func Xns_parserr(tls *TLS, handle uintptr, section Tns_sect, rrnum int32, rr uin goto bad bad: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENODEV) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENODEV) return -int32(1) goto size size: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EMSGSIZE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EMSGSIZE) return -int32(1) } @@ -123347,7 +123347,7 @@ func Xns_name_uncompress(tls *TLS, msg uintptr, eom uintptr, src uintptr, dst ui _ = r r = Xdn_expand(tls, msg, eom, src, dst, Int32FromUint64(dstsiz)) if r < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EMSGSIZE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EMSGSIZE) } return r } @@ -123592,9 +123592,9 @@ func X__convert_scm_timestamps(tls *TLS, msg uintptr, csize Tsocklen_t) { common: ; Xmemcpy(tls, bp, cmsg+UintptrFromInt32(1)*16, uint64(8)) - (*(*[2]int64)(unsafe.Pointer(bp + 8)))[0] = *(*int64)(unsafe.Pointer(bp)) + (**(**[2]int64)(__ccgo_up(bp + 8)))[0] = int64(**(**int64)(__ccgo_up(bp))) Xmemcpy(tls, bp, cmsg+UintptrFromInt32(1)*16+uintptr(8), uint64(8)) - (*(*[2]int64)(unsafe.Pointer(bp + 8)))[int32(1)] = *(*int64)(unsafe.Pointer(bp)) + (**(**[2]int64)(__ccgo_up(bp + 8)))[int32(1)] = int64(**(**int64)(__ccgo_up(bp))) goto _5 _5: } @@ -123613,7 +123613,7 @@ func X__convert_scm_timestamps(tls *TLS, msg uintptr, csize Tsocklen_t) { return } if (Uint64FromInt64(16)+Uint64FromInt64(8)-Uint64FromInt32(1)) & ^(Uint64FromInt64(8)-Uint64FromInt32(1)) + (Uint64FromInt64(16)+Uint64FromInt64(8)-Uint64FromInt32(1)) & ^(Uint64FromInt64(8)-Uint64FromInt32(1)) > uint64(csize-(*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_controllen) { - *(*int32)(unsafe.Pointer(msg + 48)) |= int32(MSG_CTRUNC) + **(**int32)(__ccgo_up(msg + 48)) |= int32(MSG_CTRUNC) return } v2 = msg + 40 @@ -123648,10 +123648,10 @@ func Xrecvmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r2 Tssize_t) { orig_controllen = (*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_controllen orig = msg if msg != 0 { - *(*Tmsghdr)(unsafe.Pointer(bp)) = *(*Tmsghdr)(unsafe.Pointer(msg)) + **(**Tmsghdr)(__ccgo_up(bp)) = **(**Tmsghdr)(__ccgo_up(msg)) v1 = Int32FromInt32(0) - (*(*Tmsghdr)(unsafe.Pointer(bp))).F__pad2 = v1 - (*(*Tmsghdr)(unsafe.Pointer(bp))).F__pad1 = v1 + (**(**Tmsghdr)(__ccgo_up(bp))).F__pad2 = v1 + (**(**Tmsghdr)(__ccgo_up(bp))).F__pad1 = v1 msg = bp } v1 = int32(SYS_recvmsg) @@ -123679,7 +123679,7 @@ _10: X__convert_scm_timestamps(tls, msg, orig_controllen) } if orig != 0 { - *(*Tmsghdr)(unsafe.Pointer(orig)) = *(*Tmsghdr)(unsafe.Pointer(bp)) + **(**Tmsghdr)(__ccgo_up(orig)) = **(**Tmsghdr)(__ccgo_up(bp)) } return r1 } @@ -123705,10 +123705,10 @@ func X__res_mkquery(tls *TLS, op int32, dname uintptr, class int32, type1 int32, var _ /* ts at bp+280 */ Ttimespec _, _, _, _, _ = i, id, j, l, n l = Xstrnlen(tls, dname, uint64(255)) - if l != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(dname + uintptr(l-uint64(1))))) == int32('.') { + if l != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(dname + uintptr(l-uint64(1))))) == int32('.') { l = l - 1 } - if l != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(dname + uintptr(l-uint64(1))))) == int32('.') { + if l != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(dname + uintptr(l-uint64(1))))) == int32('.') { return -int32(1) } n = Int32FromUint64(uint64(17) + l + BoolUint64(!!(l != 0))) @@ -123717,18 +123717,18 @@ func X__res_mkquery(tls *TLS, op int32, dname uintptr, class int32, type1 int32, } /* Construct query template - ID will be filled later */ Xmemset(tls, bp, 0, Uint64FromInt32(n)) - (*(*[280]uint8)(unsafe.Pointer(bp)))[int32(2)] = Uint8FromInt32(op*int32(8) + int32(1)) - (*(*[280]uint8)(unsafe.Pointer(bp)))[int32(3)] = uint8(32) /* AD */ - (*(*[280]uint8)(unsafe.Pointer(bp)))[int32(5)] = uint8(1) + (**(**[280]uint8)(__ccgo_up(bp)))[int32(2)] = Uint8FromInt32(op*int32(8) + int32(1)) + (**(**[280]uint8)(__ccgo_up(bp)))[int32(3)] = uint8(32) /* AD */ + (**(**[280]uint8)(__ccgo_up(bp)))[int32(5)] = uint8(1) Xmemcpy(tls, bp+uintptr(13), dname, l) i = int32(13) for { - if !((*(*[280]uint8)(unsafe.Pointer(bp)))[i] != 0) { + if !((**(**[280]uint8)(__ccgo_up(bp)))[i] != 0) { break } j = i for { - if !((*(*[280]uint8)(unsafe.Pointer(bp)))[j] != 0 && Int32FromUint8((*(*[280]uint8)(unsafe.Pointer(bp)))[j]) != int32('.')) { + if !((**(**[280]uint8)(__ccgo_up(bp)))[j] != 0 && Int32FromUint8((**(**[280]uint8)(__ccgo_up(bp)))[j]) != int32('.')) { break } goto _2 @@ -123739,19 +123739,19 @@ func X__res_mkquery(tls *TLS, op int32, dname uintptr, class int32, type1 int32, if Uint32FromInt32(j-i)-uint32(1) > uint32(62) { return -int32(1) } - (*(*[280]uint8)(unsafe.Pointer(bp)))[i-int32(1)] = Uint8FromInt32(j - i) + (**(**[280]uint8)(__ccgo_up(bp)))[i-int32(1)] = Uint8FromInt32(j - i) goto _1 _1: ; i = j + int32(1) } - (*(*[280]uint8)(unsafe.Pointer(bp)))[i+int32(1)] = Uint8FromInt32(type1) - (*(*[280]uint8)(unsafe.Pointer(bp)))[i+int32(3)] = Uint8FromInt32(class) + (**(**[280]uint8)(__ccgo_up(bp)))[i+int32(1)] = Uint8FromInt32(type1) + (**(**[280]uint8)(__ccgo_up(bp)))[i+int32(3)] = Uint8FromInt32(class) /* Make a reasonably unpredictable id */ Xclock_gettime(tls, CLOCK_REALTIME, bp+280) - id = Int32FromUint64((Uint64FromInt64((*(*Ttimespec)(unsafe.Pointer(bp + 280))).Ftv_nsec) + Uint64FromInt64((*(*Ttimespec)(unsafe.Pointer(bp + 280))).Ftv_nsec)/uint64(65536)) & uint64(0xffff)) - (*(*[280]uint8)(unsafe.Pointer(bp)))[0] = Uint8FromInt32(id / int32(256)) - (*(*[280]uint8)(unsafe.Pointer(bp)))[int32(1)] = Uint8FromInt32(id) + id = Int32FromUint64((Uint64FromInt64((**(**Ttimespec)(__ccgo_up(bp + 280))).Ftv_nsec) + Uint64FromInt64((**(**Ttimespec)(__ccgo_up(bp + 280))).Ftv_nsec)/uint64(65536)) & uint64(0xffff)) + (**(**[280]uint8)(__ccgo_up(bp)))[0] = Uint8FromInt32(id / int32(256)) + (**(**[280]uint8)(__ccgo_up(bp)))[int32(1)] = Uint8FromInt32(id) Xmemcpy(tls, buf, bp, Uint64FromInt32(n)) return n } @@ -123868,11 +123868,11 @@ func _cleanup(tls *TLS, p uintptr) { pfd = p i = 0 for { - if !((*(*Tpollfd)(unsafe.Pointer(pfd + uintptr(i)*8))).Ffd >= -int32(1)) { + if !((**(**Tpollfd)(__ccgo_up(pfd + uintptr(i)*8))).Ffd >= -int32(1)) { break } - if (*(*Tpollfd)(unsafe.Pointer(pfd + uintptr(i)*8))).Ffd >= 0 { - X__syscall1(tls, int64(SYS_close), int64((*(*Tpollfd)(unsafe.Pointer(pfd + uintptr(i)*8))).Ffd)) + if (**(**Tpollfd)(__ccgo_up(pfd + uintptr(i)*8))).Ffd >= 0 { + X__syscall1(tls, int64(SYS_close), int64((**(**Tpollfd)(__ccgo_up(pfd + uintptr(i)*8))).Ffd)) } goto _1 _1: @@ -123885,10 +123885,10 @@ func _mtime(tls *TLS) (r uint64) { bp := tls.Alloc(16) defer tls.Free(16) var _ /* ts at bp+0 */ Ttimespec - if Xclock_gettime(tls, int32(CLOCK_MONOTONIC), bp) < 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENOSYS) { + if Xclock_gettime(tls, int32(CLOCK_MONOTONIC), bp) < 0 && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENOSYS) { Xclock_gettime(tls, CLOCK_REALTIME, bp) } - return Uint64FromInt64((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec)*uint64(1000) + Uint64FromInt64((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_nsec/int64(1000000)) + return Uint64FromInt64((**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec)*uint64(1000) + Uint64FromInt64((**(**Ttimespec)(__ccgo_up(bp))).Ftv_nsec/int64(1000000)) } func _start_tcp(tls *TLS, pfd uintptr, family int32, sa uintptr, sl Tsocklen_t, q uintptr, ql int32) (r1 int32) { @@ -123911,7 +123911,7 @@ func _start_tcp(tls *TLS, pfd uintptr, family int32, sa uintptr, sl Tsocklen_t, Fiov_len: Uint64FromInt32(ql), }, } - *(*Tmsghdr)(unsafe.Pointer(bp + 40)) = Tmsghdr{ + **(**Tmsghdr)(__ccgo_up(bp + 40)) = Tmsghdr{ Fmsg_name: sa, Fmsg_namelen: sl, Fmsg_iov: bp, @@ -123929,12 +123929,12 @@ func _start_tcp(tls *TLS, pfd uintptr, family int32, sa uintptr, sl Tsocklen_t, if r >= 0 { return r } - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EINPROGRESS) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EINPROGRESS) { return 0 } } r = Xconnect(tls, fd, sa, sl) - if !(r != 0) || *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EINPROGRESS) { + if !(r != 0) || **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EINPROGRESS) { return 0 } Xclose(tls, fd) @@ -123953,7 +123953,7 @@ func _step_mh(tls *TLS, mh uintptr, n Tsize_t) { return } (*Tiovec)(unsafe.Pointer((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov)).Fiov_base = (*Tiovec)(unsafe.Pointer((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov)).Fiov_base + uintptr(n) - *(*Tsize_t)(unsafe.Pointer((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov + 8)) -= n + **(**Tsize_t)(__ccgo_up((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov + 8)) -= n } /* Internal contract for __res_msend[_rc]: asize must be >=512, nqueries @@ -124005,11 +124005,11 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a F__ccgo_pad2 [12]byte }{} *(*uint16)(unsafe.Pointer(bp + 88)) = uint16(0) - *(*[3]struct { + **(**[3]struct { Fsin6 [0]Tsockaddr_in6 Fsin Tsockaddr_in F__ccgo_pad2 [12]byte - })(unsafe.Pointer(bp + 116)) = [3]struct { + })(__ccgo_up(bp + 116)) = [3]struct { Fsin6 [0]Tsockaddr_in6 Fsin Tsockaddr_in F__ccgo_pad2 [12]byte @@ -124036,16 +124036,16 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a iplit = conf + uintptr(nns)*28 if (*Taddress)(unsafe.Pointer(iplit)).Ffamily == int32(PF_INET) { Xmemcpy(tls, bp+116+uintptr(nns)*28+4, iplit+8, uint64(4)) - (*(*[3]struct { + (**(**[3]struct { Fsin6 [0]Tsockaddr_in6 Fsin Tsockaddr_in F__ccgo_pad2 [12]byte - })(unsafe.Pointer(bp + 116)))[nns].Fsin.Fsin_port = Xhtons(tls, uint16(53)) - (*(*[3]struct { + })(__ccgo_up(bp + 116)))[nns].Fsin.Fsin_port = Xhtons(tls, uint16(53)) + (**(**[3]struct { Fsin6 [0]Tsockaddr_in6 Fsin Tsockaddr_in F__ccgo_pad2 [12]byte - })(unsafe.Pointer(bp + 116)))[nns].Fsin.Fsin_family = uint16(PF_INET) + })(__ccgo_up(bp + 116)))[nns].Fsin.Fsin_family = uint16(PF_INET) } else { sl = uint32(28) Xmemcpy(tls, bp+116+uintptr(nns)*28+8, iplit+8, uint64(16)) @@ -124063,10 +124063,10 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a /* Get local address and open/bind a socket */ fd = Xsocket(tls, family, Int32FromInt32(SOCK_DGRAM)|Int32FromInt32(SOCK_CLOEXEC)|Int32FromInt32(SOCK_NONBLOCK), 0) /* Handle case where system lacks IPv6 support */ - if fd < 0 && family == int32(PF_INET6) && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EAFNOSUPPORT) { + if fd < 0 && family == int32(PF_INET6) && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EAFNOSUPPORT) { i = 0 for { - if !(i < nns && (*(*Taddress)(unsafe.Pointer(conf + uintptr(nns)*28))).Ffamily == int32(PF_INET6)) { + if !(i < nns && (**(**Taddress)(__ccgo_up(conf + uintptr(nns)*28))).Ffamily == int32(PF_INET6)) { break } goto _7 @@ -124075,7 +124075,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a i = i + 1 } if i == nns { - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 200)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 200)), uintptr(0)) return -int32(1) } fd = Xsocket(tls, int32(PF_INET), Int32FromInt32(SOCK_DGRAM)|Int32FromInt32(SOCK_CLOEXEC)|Int32FromInt32(SOCK_NONBLOCK), 0) @@ -124091,11 +124091,11 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a if !(i < nns) { break } - if Int32FromUint16((*(*[3]struct { + if Int32FromUint16((**(**[3]struct { Fsin6 [0]Tsockaddr_in6 Fsin Tsockaddr_in F__ccgo_pad2 [12]byte - })(unsafe.Pointer(bp + 116)))[i].Fsin.Fsin_family) != int32(PF_INET) { + })(__ccgo_up(bp + 116)))[i].Fsin.Fsin_family) != int32(PF_INET) { goto _8 } Xmemcpy(tls, bp+116+uintptr(i)*28+8+uintptr(12), bp+116+uintptr(i)*28+4, uint64(4)) @@ -124109,16 +124109,16 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a i = i + 1 } } - (*(*struct { + (**(**struct { Fsin6 [0]Tsockaddr_in6 Fsin Tsockaddr_in F__ccgo_pad2 [12]byte - })(unsafe.Pointer(bp + 88))).Fsin.Fsin_family = Uint16FromInt32(family) + })(__ccgo_up(bp + 88))).Fsin.Fsin_family = Uint16FromInt32(family) if fd < 0 || Xbind(tls, fd, bp+88, sl) < 0 { if fd >= 0 { Xclose(tls, fd) } - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 200)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 200)), uintptr(0)) return -int32(1) } /* Past this point, there are no errors. Each individual query will @@ -124139,7 +124139,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), nqueries*8))).Fevents = int16(POLLIN) (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), (nqueries+int32(1))*8))).Ffd = -int32(2) __pthread_cleanup_push(tls, bp+208, __ccgo_fp(_cleanup), pfd) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 200)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 200)), uintptr(0)) Xmemset(tls, alens, 0, uint64(4)*Uint64FromInt32(nqueries)) retry_interval = timeout / attempts next = 0 @@ -124155,7 +124155,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a * have an accepted answer. */ i = 0 for { - if !(i < nqueries && *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) > 0) { + if !(i < nqueries && **(**int32)(__ccgo_up(alens + uintptr(i)*4)) > 0) { break } goto _12 @@ -124173,13 +124173,13 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a if !(i < nqueries) { break } - if !(*(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) != 0) { + if !(**(**int32)(__ccgo_up(alens + uintptr(i)*4)) != 0) { j = 0 for { if !(j < nns) { break } - Xsendto(tls, fd, *(*uintptr)(unsafe.Pointer(queries + uintptr(i)*8)), Uint64FromInt32(*(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))), int32(MSG_NOSIGNAL), bp+116+uintptr(j)*28, sl) + Xsendto(tls, fd, **(**uintptr)(__ccgo_up(queries + uintptr(i)*8)), Uint64FromInt32(**(**int32)(__ccgo_up(qlens + uintptr(i)*4))), int32(MSG_NOSIGNAL), bp+116+uintptr(j)*28, sl) goto _14 _14: ; @@ -124201,11 +124201,11 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a for next < nqueries { *(*[1]Tiovec)(unsafe.Pointer(bp + 8)) = [1]Tiovec{ 0: { - Fiov_base: *(*uintptr)(unsafe.Pointer(answers + uintptr(next)*8)), + Fiov_base: **(**uintptr)(__ccgo_up(answers + uintptr(next)*8)), Fiov_len: Uint64FromInt32(asize), }, } - *(*Tmsghdr)(unsafe.Pointer(bp + 232)) = Tmsghdr{ + **(**Tmsghdr)(__ccgo_up(bp + 232)) = Tmsghdr{ Fmsg_name: bp + 88, Fmsg_namelen: sl, Fmsg_iov: bp + 8, @@ -124236,7 +124236,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a /* Find which query this answer goes with, if any */ i = next for { - if !(i < nqueries && (Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(answers + uintptr(next)*8))))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(queries + uintptr(i)*8))))) || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(answers + uintptr(next)*8)) + 1))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(queries + uintptr(i)*8)) + 1))))) { + if !(i < nqueries && (Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(answers + uintptr(next)*8))))) != Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(queries + uintptr(i)*8))))) || Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(answers + uintptr(next)*8)) + 1))) != Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(queries + uintptr(i)*8)) + 1))))) { break } goto _16 @@ -124247,13 +124247,13 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a if i == nqueries { continue } - if *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) != 0 { + if **(**int32)(__ccgo_up(alens + uintptr(i)*4)) != 0 { continue } /* Only accept positive or negative responses; * retry immediately on server failure, and ignore * all other codes such as refusal. */ - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(answers + uintptr(next)*8)) + 3))) & Int32FromInt32(15) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(answers + uintptr(next)*8)) + 3))) & Int32FromInt32(15) { case 0: fallthrough case int32(3): @@ -124263,7 +124263,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a servfail_retry = servfail_retry - 1 } if v18 && v6 != 0 { - Xsendto(tls, fd, *(*uintptr)(unsafe.Pointer(queries + uintptr(i)*8)), Uint64FromInt32(*(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))), int32(MSG_NOSIGNAL), bp+116+uintptr(j)*28, sl) + Xsendto(tls, fd, **(**uintptr)(__ccgo_up(queries + uintptr(i)*8)), Uint64FromInt32(**(**int32)(__ccgo_up(qlens + uintptr(i)*4))), int32(MSG_NOSIGNAL), bp+116+uintptr(j)*28, sl) } fallthrough default: @@ -124271,10 +124271,10 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a } /* Store answer in the right slot, or update next * available temp slot if it's already in place. */ - *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) = rlen + **(**int32)(__ccgo_up(alens + uintptr(i)*4)) = rlen if i == next { for { - if !(next < nqueries && *(*int32)(unsafe.Pointer(alens + uintptr(next)*4)) != 0) { + if !(next < nqueries && **(**int32)(__ccgo_up(alens + uintptr(next)*4)) != 0) { break } goto _19 @@ -124283,18 +124283,18 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a next = next + 1 } } else { - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(answers + uintptr(i)*8)), *(*uintptr)(unsafe.Pointer(answers + uintptr(next)*8)), Uint64FromInt32(rlen)) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(answers + uintptr(i)*8)), **(**uintptr)(__ccgo_up(answers + uintptr(next)*8)), Uint64FromInt32(rlen)) } /* Ignore further UDP if all slots full or TCP-mode */ if next == nqueries { (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), nqueries*8))).Fevents = 0 } /* If answer is truncated (TC bit), fallback to TCP */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(answers + uintptr(i)*8)) + 2)))&int32(2) != 0 || (*(*Tmsghdr)(unsafe.Pointer(bp + 232))).Fmsg_flags&int32(MSG_TRUNC) != 0 { - *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) = -int32(1) + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(answers + uintptr(i)*8)) + 2)))&int32(2) != 0 || (**(**Tmsghdr)(__ccgo_up(bp + 232))).Fmsg_flags&int32(MSG_TRUNC) != 0 { + **(**int32)(__ccgo_up(alens + uintptr(i)*4)) = -int32(1) _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), uintptr(0)) - r = _start_tcp(tls, pfd+uintptr(i)*8, family, bp+116+uintptr(j)*28, sl, *(*uintptr)(unsafe.Pointer(queries + uintptr(i)*8)), *(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 200)), uintptr(0)) + r = _start_tcp(tls, pfd+uintptr(i)*8, family, bp+116+uintptr(j)*28, sl, **(**uintptr)(__ccgo_up(queries + uintptr(i)*8)), **(**int32)(__ccgo_up(qlens + uintptr(i)*4))) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 200)), uintptr(0)) if r >= 0 { *(*int32)(unsafe.Add(unsafe.Pointer(qpos), i*4)) = r *(*int32)(unsafe.Add(unsafe.Pointer(apos), i*4)) = 0 @@ -124309,8 +124309,8 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a } if int32((*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), i*8))).Frevents)&int32(POLLOUT) != 0 { *(*[2]Tuint8_t)(unsafe.Pointer(bp + 52)) = [2]Tuint8_t{ - 0: Uint8FromInt32(*(*int32)(unsafe.Pointer(qlens + uintptr(i)*4)) >> int32(8)), - 1: Uint8FromInt32(*(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))), + 0: Uint8FromInt32(**(**int32)(__ccgo_up(qlens + uintptr(i)*4)) >> int32(8)), + 1: Uint8FromInt32(**(**int32)(__ccgo_up(qlens + uintptr(i)*4))), } *(*[2]Tiovec)(unsafe.Pointer(bp + 24)) = [2]Tiovec{ 0: { @@ -124318,11 +124318,11 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a Fiov_len: uint64(2), }, 1: { - Fiov_base: *(*uintptr)(unsafe.Pointer(queries + uintptr(i)*8)), - Fiov_len: Uint64FromInt32(*(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))), + Fiov_base: **(**uintptr)(__ccgo_up(queries + uintptr(i)*8)), + Fiov_len: Uint64FromInt32(**(**int32)(__ccgo_up(qlens + uintptr(i)*4))), }, } - *(*Tmsghdr)(unsafe.Pointer(bp + 288)) = Tmsghdr{ + **(**Tmsghdr)(__ccgo_up(bp + 288)) = Tmsghdr{ Fmsg_iov: bp + 24, Fmsg_iovlen: int32(2), } @@ -124331,8 +124331,8 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a if r < 0 { goto out } - *(*int32)(unsafe.Pointer(qpos + uintptr(i)*4)) += r - if *(*int32)(unsafe.Add(unsafe.Pointer(qpos), i*4)) == *(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))+int32(2) { + **(**int32)(__ccgo_up(qpos + uintptr(i)*4)) += r + if *(*int32)(unsafe.Add(unsafe.Pointer(qpos), i*4)) == **(**int32)(__ccgo_up(qlens + uintptr(i)*4))+int32(2) { (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), i*8))).Fevents = int16(POLLIN) } } @@ -124353,11 +124353,11 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a Fiov_len: uint64(2), }, 1: { - Fiov_base: *(*uintptr)(unsafe.Pointer(answers + uintptr(i)*8)), + Fiov_base: **(**uintptr)(__ccgo_up(answers + uintptr(i)*8)), Fiov_len: Uint64FromInt32(asize), }, } - *(*Tmsghdr)(unsafe.Pointer(bp + 344)) = Tmsghdr{ + **(**Tmsghdr)(__ccgo_up(bp + 344)) = Tmsghdr{ Fmsg_iov: bp + 56, Fmsg_iovlen: int32(2), } @@ -124366,25 +124366,25 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a if r <= 0 { goto out } - *(*int32)(unsafe.Pointer(apos + uintptr(i)*4)) += r + **(**int32)(__ccgo_up(apos + uintptr(i)*4)) += r if *(*int32)(unsafe.Add(unsafe.Pointer(apos), i*4)) < int32(2) { goto _21 } - alen = Int32FromUint8(*(*uint8)(unsafe.Pointer(alen_buf + uintptr(i)*2)))*int32(256) + Int32FromUint8(*(*uint8)(unsafe.Pointer(alen_buf + uintptr(i)*2 + 1))) + alen = Int32FromUint8(**(**uint8)(__ccgo_up(alen_buf + uintptr(i)*2)))*int32(256) + Int32FromUint8(**(**uint8)(__ccgo_up(alen_buf + uintptr(i)*2 + 1))) if alen < int32(13) { goto out } if *(*int32)(unsafe.Add(unsafe.Pointer(apos), i*4)) < alen+int32(2) && *(*int32)(unsafe.Add(unsafe.Pointer(apos), i*4)) < asize+int32(2) { goto _21 } - rcode = Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(answers + uintptr(i)*8)) + 3))) & int32(15) + rcode = Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(answers + uintptr(i)*8)) + 3))) & int32(15) if rcode != 0 && rcode != int32(3) { goto out } /* Storing the length here commits the accepted answer. * Immediately close TCP socket so as not to consume * resources we no longer need. */ - *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) = alen + **(**int32)(__ccgo_up(alens + uintptr(i)*4)) = alen X__syscall1(tls, int64(SYS_close), int64((*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), i*8))).Ffd)) (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), i*8))).Ffd = -int32(1) } @@ -124408,8 +124408,8 @@ out: if !(i < nqueries) { break } - if *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) < 0 { - *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) = 0 + if **(**int32)(__ccgo_up(alens + uintptr(i)*4)) < 0 { + **(**int32)(__ccgo_up(alens + uintptr(i)*4)) = 0 } goto _22 _22: @@ -124447,23 +124447,23 @@ func X__res_send(tls *TLS, _msg uintptr, _msglen int32, _answer uintptr, _anslen var r, v1 int32 var _ /* buf at bp+28 */ [512]uint8 _, _ = r, v1 - if *(*int32)(unsafe.Pointer(bp + 24)) < int32(512) { - r = X__res_send(tls, *(*uintptr)(unsafe.Pointer(bp)), *(*int32)(unsafe.Pointer(bp + 8)), bp+28, int32(512)) + if **(**int32)(__ccgo_up(bp + 24)) < int32(512) { + r = X__res_send(tls, **(**uintptr)(__ccgo_up(bp)), **(**int32)(__ccgo_up(bp + 8)), bp+28, int32(512)) if r >= 0 { - if r < *(*int32)(unsafe.Pointer(bp + 24)) { + if r < **(**int32)(__ccgo_up(bp + 24)) { v1 = r } else { - v1 = *(*int32)(unsafe.Pointer(bp + 24)) + v1 = **(**int32)(__ccgo_up(bp + 24)) } - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(bp + 16)), bp+28, Uint64FromInt32(v1)) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(bp + 16)), bp+28, Uint64FromInt32(v1)) } return r } - r = X__res_msend(tls, int32(1), bp, bp+8, bp+16, bp+24, *(*int32)(unsafe.Pointer(bp + 24))) - if r < 0 || !(*(*int32)(unsafe.Pointer(bp + 24)) != 0) { + r = X__res_msend(tls, int32(1), bp, bp+8, bp+16, bp+24, **(**int32)(__ccgo_up(bp + 24))) + if r < 0 || !(**(**int32)(__ccgo_up(bp + 24)) != 0) { v1 = -int32(1) } else { - v1 = *(*int32)(unsafe.Pointer(bp + 24)) + v1 = **(**int32)(__ccgo_up(bp + 24)) } return v1 } @@ -124510,11 +124510,11 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ (*Tresolvconf)(unsafe.Pointer(conf)).Ftimeout = uint32(5) (*Tresolvconf)(unsafe.Pointer(conf)).Fattempts = uint32(2) if search != 0 { - *(*uint8)(unsafe.Pointer(search)) = uint8(0) + **(**uint8)(__ccgo_up(search)) = uint8(0) } f = X__fopen_rb_ca(tls, __ccgo_ts+1188, bp+512, bp+256, uint64(256)) if !(f != 0) { - switch *(*int32)(unsafe.Pointer(X__errno_location(tls))) { + switch **(**int32)(__ccgo_up(X__errno_location(tls))) { case int32(ENOENT): fallthrough case int32(ENOTDIR): @@ -124533,17 +124533,17 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ continue } if v4 = !(Xstrncmp(tls, bp, __ccgo_ts+1205, uint64(7)) != 0); v4 { - v1 = Int32FromUint8((*(*[256]uint8)(unsafe.Pointer(bp)))[int32(7)]) + v1 = Int32FromUint8((**(**[256]uint8)(__ccgo_up(bp)))[int32(7)]) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _3 _3: } if v4 && v2 != 0 { p = Xstrstr(tls, bp, __ccgo_ts+1213) - if p != 0 && BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p + 6)))-uint32('0') < uint32(10)) != 0 { + if p != 0 && BoolInt32(uint32(**(**uint8)(__ccgo_up(p + 6)))-uint32('0') < uint32(10)) != 0 { p = p + uintptr(6) x = Xstrtoul(tls, p, bp+744, int32(10)) - if *(*uintptr)(unsafe.Pointer(bp + 744)) != p { + if **(**uintptr)(__ccgo_up(bp + 744)) != p { if x > uint64(15) { v5 = uint64(15) } else { @@ -124553,10 +124553,10 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ } } p = Xstrstr(tls, bp, __ccgo_ts+1220) - if p != 0 && BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p + 9)))-uint32('0') < uint32(10)) != 0 { + if p != 0 && BoolInt32(uint32(**(**uint8)(__ccgo_up(p + 9)))-uint32('0') < uint32(10)) != 0 { p = p + uintptr(9) x1 = Xstrtoul(tls, p, bp+744, int32(10)) - if *(*uintptr)(unsafe.Pointer(bp + 744)) != p { + if **(**uintptr)(__ccgo_up(bp + 744)) != p { if x1 > uint64(10) { v5 = uint64(10) } else { @@ -124566,10 +124566,10 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ } } p = Xstrstr(tls, bp, __ccgo_ts+1230) - if p != 0 && (BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p + 8)))-uint32('0') < uint32(10)) != 0 || Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 8))) == int32('.')) { + if p != 0 && (BoolInt32(uint32(**(**uint8)(__ccgo_up(p + 8)))-uint32('0') < uint32(10)) != 0 || Int32FromUint8(**(**uint8)(__ccgo_up(p + 8))) == int32('.')) { p = p + uintptr(8) x2 = Xstrtoul(tls, p, bp+744, int32(10)) - if *(*uintptr)(unsafe.Pointer(bp + 744)) != p { + if **(**uintptr)(__ccgo_up(bp + 744)) != p { if x2 > uint64(60) { v5 = uint64(60) } else { @@ -124581,7 +124581,7 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ continue } if v4 = !(Xstrncmp(tls, bp, __ccgo_ts+1239, uint64(10)) != 0); v4 { - v1 = Int32FromUint8((*(*[256]uint8)(unsafe.Pointer(bp)))[int32(10)]) + v1 = Int32FromUint8((**(**[256]uint8)(__ccgo_up(bp)))[int32(10)]) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _10 _10: @@ -124592,7 +124592,7 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ } p = bp + uintptr(11) for { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _15 _15: @@ -124604,10 +124604,10 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ ; p = p + 1 } - *(*uintptr)(unsafe.Pointer(bp + 744)) = p + **(**uintptr)(__ccgo_up(bp + 744)) = p for { - if v4 = *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 744)))) != 0; v4 { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 744))))) + if v4 = **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 744)))) != 0; v4 { + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 744))))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _19 _19: @@ -124618,9 +124618,9 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ goto _16 _16: ; - *(*uintptr)(unsafe.Pointer(bp + 744)) = *(*uintptr)(unsafe.Pointer(bp + 744)) + 1 + **(**uintptr)(__ccgo_up(bp + 744)) = **(**uintptr)(__ccgo_up(bp + 744)) + 1 } - *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 744)))) = uint8(0) + **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 744)))) = uint8(0) if X__lookup_ipliteral(tls, conf+uintptr(nns)*28, p, PF_UNSPEC) > 0 { nns = nns + 1 } @@ -124630,7 +124630,7 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ continue } if v4 = Xstrncmp(tls, bp, __ccgo_ts+1250, uint64(6)) != 0 && Xstrncmp(tls, bp, __ccgo_ts+1257, uint64(6)) != 0; !v4 { - v1 = Int32FromUint8((*(*[256]uint8)(unsafe.Pointer(bp)))[int32(6)]) + v1 = Int32FromUint8((**(**[256]uint8)(__ccgo_up(bp)))[int32(6)]) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _23 _23: @@ -124640,7 +124640,7 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ } p = bp + uintptr(7) for { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _28 _28: @@ -124706,7 +124706,7 @@ func Xsendmmsg(tls *TLS, fd int32, msgvec uintptr, vlen uint32, flags uint32) (r if r < 0 { goto error } - (*(*Tmmsghdr)(unsafe.Pointer(msgvec + uintptr(i)*64))).Fmsg_len = Uint32FromInt64(r) + (**(**Tmmsghdr)(__ccgo_up(msgvec + uintptr(i)*64))).Fmsg_len = Uint32FromInt64(r) goto _1 _1: ; @@ -124739,18 +124739,18 @@ func Xsendmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r1 Tssize_t) { var _ /* h at bp+0 */ Tmsghdr _, _, _, _, _, _, _, _, _, _, _ = c1, r, v1, v10, v11, v12, v3, v6, v7, v8, v9 if msg != 0 { - *(*Tmsghdr)(unsafe.Pointer(bp)) = *(*Tmsghdr)(unsafe.Pointer(msg)) + **(**Tmsghdr)(__ccgo_up(bp)) = **(**Tmsghdr)(__ccgo_up(msg)) v1 = Int32FromInt32(0) - (*(*Tmsghdr)(unsafe.Pointer(bp))).F__pad2 = v1 - (*(*Tmsghdr)(unsafe.Pointer(bp))).F__pad1 = v1 + (**(**Tmsghdr)(__ccgo_up(bp))).F__pad2 = v1 + (**(**Tmsghdr)(__ccgo_up(bp))).F__pad1 = v1 msg = bp - if (*(*Tmsghdr)(unsafe.Pointer(bp))).Fmsg_controllen != 0 { - if uint64((*(*Tmsghdr)(unsafe.Pointer(bp))).Fmsg_controllen) > uint64(1056) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + if (**(**Tmsghdr)(__ccgo_up(bp))).Fmsg_controllen != 0 { + if uint64((**(**Tmsghdr)(__ccgo_up(bp))).Fmsg_controllen) > uint64(1056) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return int64(-int32(1)) } - Xmemcpy(tls, bp+56, (*(*Tmsghdr)(unsafe.Pointer(bp))).Fmsg_control, uint64((*(*Tmsghdr)(unsafe.Pointer(bp))).Fmsg_controllen)) - (*(*Tmsghdr)(unsafe.Pointer(bp))).Fmsg_control = bp + 56 + Xmemcpy(tls, bp+56, (**(**Tmsghdr)(__ccgo_up(bp))).Fmsg_control, uint64((**(**Tmsghdr)(__ccgo_up(bp))).Fmsg_controllen)) + (**(**Tmsghdr)(__ccgo_up(bp))).Fmsg_control = bp + 56 if uint64((*Tmsghdr)(unsafe.Pointer(bp)).Fmsg_controllen) >= uint64(16) { v3 = (*Tmsghdr)(unsafe.Pointer(bp)).Fmsg_control } else { @@ -125023,7 +125023,7 @@ func Xsockatmark(tls *TLS, s int32) (r int32) { if Xioctl(tls, s, int32(SIOCATMARK), VaList(bp+16, bp)) < 0 { return -int32(1) } - return *(*int32)(unsafe.Pointer(bp)) + return **(**int32)(__ccgo_up(bp)) } func Xsocket(tls *TLS, domain int32, type1 int32, protocol int32) (r1 int32) { @@ -125121,7 +125121,7 @@ func Xsocketpair(tls *TLS, domain int32, type1 int32, protocol int32, fd uintptr goto _9 _9: r1 = int32(X__syscall_ret(tls, Uint64FromInt64(v8))) - if r1 < 0 && (*(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EINVAL) || *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EPROTONOSUPPORT)) && type1&(Int32FromInt32(SOCK_CLOEXEC)|Int32FromInt32(SOCK_NONBLOCK)) != 0 { + if r1 < 0 && (**(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EINVAL) || **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EPROTONOSUPPORT)) && type1&(Int32FromInt32(SOCK_CLOEXEC)|Int32FromInt32(SOCK_NONBLOCK)) != 0 { v10 = int32(SYS_socketpair) _ = int32(__SC_socketpair) v11 = int64(domain) @@ -125147,12 +125147,12 @@ _9: return r1 } if type1&int32(SOCK_CLOEXEC) != 0 { - X__syscall3(tls, int64(SYS_fcntl), int64(*(*int32)(unsafe.Pointer(fd))), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) - X__syscall3(tls, int64(SYS_fcntl), int64(*(*int32)(unsafe.Pointer(fd + 1*4))), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) + X__syscall3(tls, int64(SYS_fcntl), int64(**(**int32)(__ccgo_up(fd))), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) + X__syscall3(tls, int64(SYS_fcntl), int64(**(**int32)(__ccgo_up(fd + 1*4))), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) } if type1&int32(SOCK_NONBLOCK) != 0 { - X__syscall3(tls, int64(SYS_fcntl), int64(*(*int32)(unsafe.Pointer(fd))), int64(Int32FromInt32(F_SETFL)), int64(Int32FromInt32(O_NONBLOCK))) - X__syscall3(tls, int64(SYS_fcntl), int64(*(*int32)(unsafe.Pointer(fd + 1*4))), int64(Int32FromInt32(F_SETFL)), int64(Int32FromInt32(O_NONBLOCK))) + X__syscall3(tls, int64(SYS_fcntl), int64(**(**int32)(__ccgo_up(fd))), int64(Int32FromInt32(F_SETFL)), int64(Int32FromInt32(O_NONBLOCK))) + X__syscall3(tls, int64(SYS_fcntl), int64(**(**int32)(__ccgo_up(fd + 1*4))), int64(Int32FromInt32(F_SETFL)), int64(Int32FromInt32(O_NONBLOCK))) } } return r1 @@ -125189,10 +125189,10 @@ func Xfgetgrent(tls *TLS, f uintptr) (r uintptr) { var _ /* nmem at bp+16 */ Tsize_t var _ /* res at bp+0 */ uintptr var _ /* size at bp+8 */ Tsize_t - *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint64(0) - *(*Tsize_t)(unsafe.Pointer(bp + 16)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp + 8)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp + 16)) = uint64(0) X__getgrent_a(tls, f, uintptr(unsafe.Pointer(&_gr)), uintptr(unsafe.Pointer(&_line1)), bp+8, uintptr(unsafe.Pointer(&_mem)), bp+16, bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } var _line1 uintptr @@ -125210,9 +125210,9 @@ func Xfgetpwent(tls *TLS, f uintptr) (r uintptr) { defer tls.Free(16) var _ /* res at bp+8 */ uintptr var _ /* size at bp+0 */ Tsize_t - *(*Tsize_t)(unsafe.Pointer(bp)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp)) = uint64(0) X__getpwent_a(tls, f, uintptr(unsafe.Pointer(&_pw)), uintptr(unsafe.Pointer(&_line2)), bp, bp+8) - return *(*uintptr)(unsafe.Pointer(bp + 8)) + return **(**uintptr)(__ccgo_up(bp + 8)) } var _line2 uintptr @@ -125258,11 +125258,11 @@ func _itoa1(tls *TLS, p uintptr, x Tuint32_t) (r uintptr) { p = p + uintptr(11) p = p - 1 v1 = p - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) for cond := true; cond; cond = x != 0 { p = p - 1 v1 = p - *(*uint8)(unsafe.Pointer(v1)) = uint8(uint32('0') + x%uint32(10)) + **(**uint8)(__ccgo_up(v1)) = uint8(uint32('0') + x%uint32(10)) x = x / uint32(10) } return p @@ -125287,36 +125287,36 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz var _ /* swap at bp+40 */ int32 _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, grlist_len, i, key, len1, ptr, req, rv, tmp, tmp1, v1, v10, v5, v6 rv = 0 - *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) + **(**uintptr)(__ccgo_up(res)) = uintptr(0) _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp) f = Xfopen(tls, __ccgo_ts+1274, __ccgo_ts+315) if !(f != 0) { - rv = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + rv = **(**int32)(__ccgo_up(X__errno_location(tls))) goto done } for { v1 = X__getgrent_a(tls, f, gr, buf, size, mem, nmem, res) rv = v1 - if !(!(v1 != 0) && *(*uintptr)(unsafe.Pointer(res)) != 0) { + if !(!(v1 != 0) && **(**uintptr)(__ccgo_up(res)) != 0) { break } - if name != 0 && !(Xstrcmp(tls, name, (*Tgroup)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(res)))).Fgr_name) != 0) || !(name != 0) && (*Tgroup)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(res)))).Fgr_gid == gid { + if name != 0 && !(Xstrcmp(tls, name, (*Tgroup)(unsafe.Pointer(**(**uintptr)(__ccgo_up(res)))).Fgr_name) != 0) || !(name != 0) && (*Tgroup)(unsafe.Pointer(**(**uintptr)(__ccgo_up(res)))).Fgr_gid == gid { break } } Xfclose(tls, f) - if !(*(*uintptr)(unsafe.Pointer(res)) != 0) && (rv == 0 || rv == int32(ENOENT) || rv == int32(ENOTDIR)) { + if !(**(**uintptr)(__ccgo_up(res)) != 0) && (rv == 0 || rv == int32(ENOENT) || rv == int32(ENOTDIR)) { if name != 0 { v1 = int32(GETGRBYNAME) } else { v1 = int32(GETGRBYGID) } req = v1 - *(*[6]Tint32_t)(unsafe.Pointer(bp + 4)) = [6]Tint32_t{} + **(**[6]Tint32_t)(__ccgo_up(bp + 4)) = [6]Tint32_t{} len1 = uint64(0) grlist_len = uint64(0) - *(*[11]uint8)(unsafe.Pointer(bp + 28)) = [11]uint8{} - *(*int32)(unsafe.Pointer(bp + 40)) = 0 + **(**[11]uint8)(__ccgo_up(bp + 28)) = [11]uint8{} + **(**int32)(__ccgo_up(bp + 40)) = 0 if name != 0 { key = name } else { @@ -125328,116 +125328,116 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz } f = X__nscd_query(tls, req, key, bp+4, uint64(24), bp+40) if !(f != 0) { - rv = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + rv = **(**int32)(__ccgo_up(X__errno_location(tls))) goto done } - if !((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRFOUND)] != 0) { + if !((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRFOUND)] != 0) { rv = 0 goto cleanup_f } - if !((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRNAMELEN)] != 0) || !((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRPASSWDLEN)] != 0) { + if !((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRNAMELEN)] != 0) || !((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRPASSWDLEN)] != 0) { rv = int32(EIO) goto cleanup_f } - if Uint64FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRNAMELEN)]) > uint64(0xffffffffffffffff)-Uint64FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRPASSWDLEN)]) { + if Uint64FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRNAMELEN)]) > uint64(0xffffffffffffffff)-Uint64FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRPASSWDLEN)]) { rv = int32(ENOMEM) goto cleanup_f } - len1 = Uint64FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRNAMELEN)] + (*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRPASSWDLEN)]) + len1 = Uint64FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRNAMELEN)] + (**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRPASSWDLEN)]) i = 0 for { - if !(i < (*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)]) { + if !(i < (**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)]) { break } if Xfread(tls, bp+44, uint64(4), uint64(1), f) < uint64(1) { if Xferror(tls, f) != 0 { - v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = **(**int32)(__ccgo_up(X__errno_location(tls))) } else { v1 = int32(EIO) } rv = v1 goto cleanup_f } - if *(*int32)(unsafe.Pointer(bp + 40)) != 0 { - v5 = *(*Tuint32_t)(unsafe.Pointer(bp + 44)) + if **(**int32)(__ccgo_up(bp + 40)) != 0 { + v5 = **(**Tuint32_t)(__ccgo_up(bp + 44)) v6 = v5>>int32(24) | v5>>int32(8)&uint32(0xff00) | v5< uint64(0xffffffffffffffff)-grlist_len || uint64(*(*Tuint32_t)(unsafe.Pointer(bp + 44))) > uint64(0xffffffffffffffff)-len1 { + if uint64(**(**Tuint32_t)(__ccgo_up(bp + 44))) > uint64(0xffffffffffffffff)-grlist_len || uint64(**(**Tuint32_t)(__ccgo_up(bp + 44))) > uint64(0xffffffffffffffff)-len1 { rv = int32(ENOMEM) goto cleanup_f } - len1 = len1 + uint64(*(*Tuint32_t)(unsafe.Pointer(bp + 44))) - grlist_len = grlist_len + uint64(*(*Tuint32_t)(unsafe.Pointer(bp + 44))) + len1 = len1 + uint64(**(**Tuint32_t)(__ccgo_up(bp + 44))) + grlist_len = grlist_len + uint64(**(**Tuint32_t)(__ccgo_up(bp + 44))) goto _3 _3: ; i = i + 1 } - if len1 > *(*Tsize_t)(unsafe.Pointer(size)) || !(*(*uintptr)(unsafe.Pointer(buf)) != 0) { - tmp = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(buf)), len1) + if len1 > **(**Tsize_t)(__ccgo_up(size)) || !(**(**uintptr)(__ccgo_up(buf)) != 0) { + tmp = Xrealloc(tls, **(**uintptr)(__ccgo_up(buf)), len1) if !(tmp != 0) { - rv = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + rv = **(**int32)(__ccgo_up(X__errno_location(tls))) goto cleanup_f } - *(*uintptr)(unsafe.Pointer(buf)) = tmp - *(*Tsize_t)(unsafe.Pointer(size)) = len1 + **(**uintptr)(__ccgo_up(buf)) = tmp + **(**Tsize_t)(__ccgo_up(size)) = len1 } - if !(Xfread(tls, *(*uintptr)(unsafe.Pointer(buf)), len1, uint64(1), f) != 0) { + if !(Xfread(tls, **(**uintptr)(__ccgo_up(buf)), len1, uint64(1), f) != 0) { if Xferror(tls, f) != 0 { - v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = **(**int32)(__ccgo_up(X__errno_location(tls))) } else { v1 = int32(EIO) } rv = v1 goto cleanup_f } - if Uint64FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)]+int32(1)) > *(*Tsize_t)(unsafe.Pointer(nmem)) { - if Uint64FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)]+int32(1)) > Uint64FromUint64(0xffffffffffffffff)/Uint64FromInt64(8) { + if Uint64FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)]+int32(1)) > **(**Tsize_t)(__ccgo_up(nmem)) { + if Uint64FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)]+int32(1)) > Uint64FromUint64(0xffffffffffffffff)/Uint64FromInt64(8) { rv = int32(ENOMEM) goto cleanup_f } - tmp1 = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(mem)), Uint64FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)]+Int32FromInt32(1))*uint64(8)) + tmp1 = Xrealloc(tls, **(**uintptr)(__ccgo_up(mem)), Uint64FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)]+Int32FromInt32(1))*uint64(8)) if !(tmp1 != 0) { - rv = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + rv = **(**int32)(__ccgo_up(X__errno_location(tls))) goto cleanup_f } - *(*uintptr)(unsafe.Pointer(mem)) = tmp1 - *(*Tsize_t)(unsafe.Pointer(nmem)) = Uint64FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)] + int32(1)) + **(**uintptr)(__ccgo_up(mem)) = tmp1 + **(**Tsize_t)(__ccgo_up(nmem)) = Uint64FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)] + int32(1)) } - if (*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)] != 0 { - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)))) = *(*uintptr)(unsafe.Pointer(buf)) + uintptr((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRNAMELEN)]) + uintptr((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRPASSWDLEN)]) - ptr = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)))) + if (**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)] != 0 { + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)))) = **(**uintptr)(__ccgo_up(buf)) + uintptr((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRNAMELEN)]) + uintptr((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRPASSWDLEN)]) + ptr = **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)))) i = Int32FromInt32(0) for { - if !(ptr != *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem))))+uintptr(grlist_len)) { + if !(ptr != **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem))))+uintptr(grlist_len)) { break } - if !(*(*uint8)(unsafe.Pointer(ptr)) != 0) { + if !(**(**uint8)(__ccgo_up(ptr)) != 0) { i = i + 1 v10 = i - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v10)*8)) = ptr + uintptr(1) + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)) + uintptr(v10)*8)) = ptr + uintptr(1) } goto _9 _9: ; ptr = ptr + 1 } - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(i)*8)) = uintptr(0) - if i != (*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)] { + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)) + uintptr(i)*8)) = uintptr(0) + if i != (**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)] { rv = int32(EIO) goto cleanup_f } } else { - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)))) = uintptr(0) + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)))) = uintptr(0) } - (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = *(*uintptr)(unsafe.Pointer(buf)) - (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = (*Tgroup)(unsafe.Pointer(gr)).Fgr_name + uintptr((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRNAMELEN)]) - (*Tgroup)(unsafe.Pointer(gr)).Fgr_gid = Uint32FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRGID)]) - (*Tgroup)(unsafe.Pointer(gr)).Fgr_mem = *(*uintptr)(unsafe.Pointer(mem)) - if *(*uint8)(unsafe.Pointer((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd + uintptr(-Int32FromInt32(1)))) != 0 || *(*uint8)(unsafe.Pointer((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd + uintptr((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRPASSWDLEN)]-int32(1)))) != 0 { + (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = **(**uintptr)(__ccgo_up(buf)) + (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = (*Tgroup)(unsafe.Pointer(gr)).Fgr_name + uintptr((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRNAMELEN)]) + (*Tgroup)(unsafe.Pointer(gr)).Fgr_gid = Uint32FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRGID)]) + (*Tgroup)(unsafe.Pointer(gr)).Fgr_mem = **(**uintptr)(__ccgo_up(mem)) + if **(**uint8)(__ccgo_up((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd + uintptr(-Int32FromInt32(1)))) != 0 || **(**uint8)(__ccgo_up((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd + uintptr((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRPASSWDLEN)]-int32(1)))) != 0 { rv = int32(EIO) goto cleanup_f } @@ -125445,7 +125445,7 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz rv = int32(EIO) goto cleanup_f } - *(*uintptr)(unsafe.Pointer(res)) = gr + **(**uintptr)(__ccgo_up(res)) = gr goto cleanup_f cleanup_f: ; @@ -125455,9 +125455,9 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz goto done done: ; - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) if rv != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = rv + **(**int32)(__ccgo_up(X__errno_location(tls))) = rv } return rv } @@ -125473,42 +125473,42 @@ func _getgr_r(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, size var _ /* mem at bp+16 */ uintptr var _ /* nmem at bp+24 */ Tsize_t _, _ = i, rv - *(*uintptr)(unsafe.Pointer(bp)) = uintptr(0) - *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint64(0) - *(*uintptr)(unsafe.Pointer(bp + 16)) = uintptr(0) - *(*Tsize_t)(unsafe.Pointer(bp + 24)) = uint64(0) + **(**uintptr)(__ccgo_up(bp)) = uintptr(0) + **(**Tsize_t)(__ccgo_up(bp + 8)) = uint64(0) + **(**uintptr)(__ccgo_up(bp + 16)) = uintptr(0) + **(**Tsize_t)(__ccgo_up(bp + 24)) = uint64(0) rv = 0 _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp+32) rv = X__getgr_a(tls, name, gid, gr, bp, bp+8, bp+16, bp+24, res) - if *(*uintptr)(unsafe.Pointer(res)) != 0 && size < *(*Tsize_t)(unsafe.Pointer(bp + 8))+(*(*Tsize_t)(unsafe.Pointer(bp + 24))+uint64(1))*uint64(8)+uint64(32) { - *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) + if **(**uintptr)(__ccgo_up(res)) != 0 && size < **(**Tsize_t)(__ccgo_up(bp + 8))+(**(**Tsize_t)(__ccgo_up(bp + 24))+uint64(1))*uint64(8)+uint64(32) { + **(**uintptr)(__ccgo_up(res)) = uintptr(0) rv = int32(ERANGE) } - if *(*uintptr)(unsafe.Pointer(res)) != 0 { + if **(**uintptr)(__ccgo_up(res)) != 0 { buf = buf + uintptr((uint64(16)-uint64(buf))%uint64(16)) (*Tgroup)(unsafe.Pointer(gr)).Fgr_mem = buf - buf = buf + uintptr((*(*Tsize_t)(unsafe.Pointer(bp + 24))+uint64(1))*uint64(8)) - Xmemcpy(tls, buf, *(*uintptr)(unsafe.Pointer(bp)), *(*Tsize_t)(unsafe.Pointer(bp + 8))) - (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = uintptr(int64((*Tgroup)(unsafe.Pointer(gr)).Fgr_name)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf - (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = uintptr(int64((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf + buf = buf + uintptr((**(**Tsize_t)(__ccgo_up(bp + 24))+uint64(1))*uint64(8)) + Xmemcpy(tls, buf, **(**uintptr)(__ccgo_up(bp)), **(**Tsize_t)(__ccgo_up(bp + 8))) + (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = uintptr(int64((*Tgroup)(unsafe.Pointer(gr)).Fgr_name)-int64(**(**uintptr)(__ccgo_up(bp)))) + buf + (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = uintptr(int64((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd)-int64(**(**uintptr)(__ccgo_up(bp)))) + buf i = uint64(0) for { - if !(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + uintptr(i)*8)) != 0) { + if !(**(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 16)) + uintptr(i)*8)) != 0) { break } - *(*uintptr)(unsafe.Pointer((*Tgroup)(unsafe.Pointer(gr)).Fgr_mem + uintptr(i)*8)) = uintptr(int64(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + uintptr(i)*8)))-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf + **(**uintptr)(__ccgo_up((*Tgroup)(unsafe.Pointer(gr)).Fgr_mem + uintptr(i)*8)) = uintptr(int64(**(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 16)) + uintptr(i)*8)))-int64(**(**uintptr)(__ccgo_up(bp)))) + buf goto _1 _1: ; i = i + 1 } - *(*uintptr)(unsafe.Pointer((*Tgroup)(unsafe.Pointer(gr)).Fgr_mem + uintptr(i)*8)) = uintptr(0) + **(**uintptr)(__ccgo_up((*Tgroup)(unsafe.Pointer(gr)).Fgr_mem + uintptr(i)*8)) = uintptr(0) } - Xfree(tls, *(*uintptr)(unsafe.Pointer(bp + 16))) - Xfree(tls, *(*uintptr)(unsafe.Pointer(bp))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 32)), uintptr(0)) + Xfree(tls, **(**uintptr)(__ccgo_up(bp + 16))) + Xfree(tls, **(**uintptr)(__ccgo_up(bp))) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 32)), uintptr(0)) if rv != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = rv + **(**int32)(__ccgo_up(X__errno_location(tls))) = rv } return rv } @@ -125554,8 +125554,8 @@ func Xgetgrent(tls *TLS) (r uintptr) { var _ /* nmem at bp+16 */ Tsize_t var _ /* res at bp+0 */ uintptr var _ /* size at bp+8 */ Tsize_t - *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint64(0) - *(*Tsize_t)(unsafe.Pointer(bp + 16)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp + 8)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp + 16)) = uint64(0) if !(_f1 != 0) { _f1 = Xfopen(tls, __ccgo_ts+1274, __ccgo_ts+315) } @@ -125563,7 +125563,7 @@ func Xgetgrent(tls *TLS) (r uintptr) { return uintptr(0) } X__getgrent_a(tls, _f1, uintptr(unsafe.Pointer(&_gr1)), uintptr(unsafe.Pointer(&_line3)), bp+8, uintptr(unsafe.Pointer(&_mem1)), bp+16, bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func Xgetgrgid(tls *TLS, gid Tgid_t) (r uintptr) { @@ -125576,10 +125576,10 @@ func Xgetgrgid(tls *TLS, gid Tgid_t) (r uintptr) { var _ /* nmem at bp+16 */ Tsize_t var _ /* res at bp+0 */ uintptr var _ /* size at bp+8 */ Tsize_t - *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint64(0) - *(*Tsize_t)(unsafe.Pointer(bp + 16)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp + 8)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp + 16)) = uint64(0) X__getgr_a(tls, uintptr(0), gid, uintptr(unsafe.Pointer(&_gr1)), uintptr(unsafe.Pointer(&_line3)), bp+8, uintptr(unsafe.Pointer(&_mem1)), bp+16, bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func Xgetgrnam(tls *TLS, name uintptr) (r uintptr) { @@ -125592,10 +125592,10 @@ func Xgetgrnam(tls *TLS, name uintptr) (r uintptr) { var _ /* nmem at bp+16 */ Tsize_t var _ /* res at bp+0 */ uintptr var _ /* size at bp+8 */ Tsize_t - *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint64(0) - *(*Tsize_t)(unsafe.Pointer(bp + 16)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp + 8)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp + 16)) = uint64(0) X__getgr_a(tls, name, uint32(0), uintptr(unsafe.Pointer(&_gr1)), uintptr(unsafe.Pointer(&_line3)), bp+8, uintptr(unsafe.Pointer(&_mem1)), bp+16, bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func Xendgrent(tls *TLS) { @@ -125610,14 +125610,14 @@ func _atou(tls *TLS, s uintptr) (r uint32) { _ = x x = uint32(0) for { - if !(Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-int32('0')) < uint32(10)) { + if !(Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-int32('0')) < uint32(10)) { break } - x = uint32(10)*x + Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-Int32FromUint8('0')) + x = uint32(10)*x + Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-Int32FromUint8('0')) goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s)) = *(*uintptr)(unsafe.Pointer(s)) + 1 + **(**uintptr)(__ccgo_up(s)) = **(**uintptr)(__ccgo_up(s)) + 1 } return x } @@ -125643,107 +125643,107 @@ func X__getgrent_a(tls *TLS, f uintptr, gr uintptr, line uintptr, size uintptr, l = v2 if v2 < 0 { if Xferror(tls, f) != 0 { - v3 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v3 = **(**int32)(__ccgo_up(X__errno_location(tls))) } else { v3 = 0 } rv = v3 - Xfree(tls, *(*uintptr)(unsafe.Pointer(line))) - *(*uintptr)(unsafe.Pointer(line)) = uintptr(0) + Xfree(tls, **(**uintptr)(__ccgo_up(line))) + **(**uintptr)(__ccgo_up(line)) = uintptr(0) gr = uintptr(0) goto end } - *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(line)) + uintptr(l-int64(1)))) = uint8(0) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(line)) - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(line)) + uintptr(l-int64(1)))) = uint8(0) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(line)) + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = v4 - v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v4 + v4 = Xstrchr(tls, **(**uintptr)(__ccgo_up(bp)), int32(':')) + **(**uintptr)(__ccgo_up(bp)) = v4 if !(v4 != 0) { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) - (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = *(*uintptr)(unsafe.Pointer(bp)) - v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v4 + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) + (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = **(**uintptr)(__ccgo_up(bp)) + v4 = Xstrchr(tls, **(**uintptr)(__ccgo_up(bp)), int32(':')) + **(**uintptr)(__ccgo_up(bp)) = v4 if !(v4 != 0) { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) (*Tgroup)(unsafe.Pointer(gr)).Fgr_gid = _atou(tls, bp) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32(':') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) != int32(':') { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) - mems = *(*uintptr)(unsafe.Pointer(bp)) + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) + mems = **(**uintptr)(__ccgo_up(bp)) break goto _1 _1: } - *(*Tsize_t)(unsafe.Pointer(nmem)) = BoolUint64(!!(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) != 0)) + **(**Tsize_t)(__ccgo_up(nmem)) = BoolUint64(!!(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))) != 0)) for { - if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) != 0) { + if !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))) != 0) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32(',') { - *(*Tsize_t)(unsafe.Pointer(nmem)) = *(*Tsize_t)(unsafe.Pointer(nmem)) + 1 + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) == int32(',') { + **(**Tsize_t)(__ccgo_up(nmem)) = **(**Tsize_t)(__ccgo_up(nmem)) + 1 } goto _10 _10: ; - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - } - Xfree(tls, *(*uintptr)(unsafe.Pointer(mem))) - *(*uintptr)(unsafe.Pointer(mem)) = Xcalloc(tls, uint64(8), *(*Tsize_t)(unsafe.Pointer(nmem))+uint64(1)) - if !(*(*uintptr)(unsafe.Pointer(mem)) != 0) { - rv = *(*int32)(unsafe.Pointer(X__errno_location(tls))) - Xfree(tls, *(*uintptr)(unsafe.Pointer(line))) - *(*uintptr)(unsafe.Pointer(line)) = uintptr(0) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + } + Xfree(tls, **(**uintptr)(__ccgo_up(mem))) + **(**uintptr)(__ccgo_up(mem)) = Xcalloc(tls, uint64(8), **(**Tsize_t)(__ccgo_up(nmem))+uint64(1)) + if !(**(**uintptr)(__ccgo_up(mem)) != 0) { + rv = **(**int32)(__ccgo_up(X__errno_location(tls))) + Xfree(tls, **(**uintptr)(__ccgo_up(line))) + **(**uintptr)(__ccgo_up(line)) = uintptr(0) gr = uintptr(0) goto end } - if *(*uint8)(unsafe.Pointer(mems)) != 0 { - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)))) = mems - *(*uintptr)(unsafe.Pointer(bp)) = mems + if **(**uint8)(__ccgo_up(mems)) != 0 { + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)))) = mems + **(**uintptr)(__ccgo_up(bp)) = mems i = Uint64FromInt32(0) for { - if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) != 0) { + if !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))) != 0) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32(',') { - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) == int32(',') { + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) i = i + 1 v13 = i - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v13)*8)) = *(*uintptr)(unsafe.Pointer(bp)) + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)) + uintptr(v13)*8)) = **(**uintptr)(__ccgo_up(bp)) } goto _11 _11: ; - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 } i = i + 1 v13 = i - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v13)*8)) = uintptr(0) + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)) + uintptr(v13)*8)) = uintptr(0) } else { - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)))) = uintptr(0) + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)))) = uintptr(0) } - (*Tgroup)(unsafe.Pointer(gr)).Fgr_mem = *(*uintptr)(unsafe.Pointer(mem)) + (*Tgroup)(unsafe.Pointer(gr)).Fgr_mem = **(**uintptr)(__ccgo_up(mem)) goto end end: ; - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 8)), uintptr(0)) - *(*uintptr)(unsafe.Pointer(res)) = gr + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 8)), uintptr(0)) + **(**uintptr)(__ccgo_up(res)) = gr if rv != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = rv + **(**int32)(__ccgo_up(X__errno_location(tls))) = rv } return rv } @@ -125772,44 +125772,44 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, i, n, nbytes, nlim, nscdbuf, ret, rv, v1, v14, v3, v4, v6, v9 ret = -int32(1) n = int64(1) - *(*int32)(unsafe.Pointer(bp + 40)) = 0 + **(**int32)(__ccgo_up(bp + 40)) = 0 nscdbuf = uintptr(0) - *(*uintptr)(unsafe.Pointer(bp + 56)) = uintptr(0) - *(*uintptr)(unsafe.Pointer(bp + 64)) = uintptr(0) - *(*Tsize_t)(unsafe.Pointer(bp + 72)) = uint64(0) - nlim = *(*int32)(unsafe.Pointer(ngroups)) + **(**uintptr)(__ccgo_up(bp + 56)) = uintptr(0) + **(**uintptr)(__ccgo_up(bp + 64)) = uintptr(0) + **(**Tsize_t)(__ccgo_up(bp + 72)) = uint64(0) + nlim = **(**int32)(__ccgo_up(ngroups)) if nlim >= int32(1) { v1 = groups groups += 4 - *(*Tgid_t)(unsafe.Pointer(v1)) = gid + **(**Tgid_t)(__ccgo_up(v1)) = gid } f = X__nscd_query(tls, int32(GETINITGR), user, bp+44, uint64(12), bp+40) if !(f != 0) { goto cleanup } - if (*(*[3]Tint32_t)(unsafe.Pointer(bp + 44)))[int32(INITGRFOUND)] != 0 { - nscdbuf = Xcalloc(tls, Uint64FromInt32((*(*[3]Tint32_t)(unsafe.Pointer(bp + 44)))[int32(INITGRNGRPS)]), uint64(4)) + if (**(**[3]Tint32_t)(__ccgo_up(bp + 44)))[int32(INITGRFOUND)] != 0 { + nscdbuf = Xcalloc(tls, Uint64FromInt32((**(**[3]Tint32_t)(__ccgo_up(bp + 44)))[int32(INITGRNGRPS)]), uint64(4)) if !(nscdbuf != 0) { goto cleanup } - nbytes = uint64(4) * Uint64FromInt32((*(*[3]Tint32_t)(unsafe.Pointer(bp + 44)))[int32(INITGRNGRPS)]) + nbytes = uint64(4) * Uint64FromInt32((**(**[3]Tint32_t)(__ccgo_up(bp + 44)))[int32(INITGRNGRPS)]) if nbytes != 0 && !(Xfread(tls, nscdbuf, nbytes, uint64(1), f) != 0) { if !(Xferror(tls, f) != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EIO) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EIO) } goto cleanup } - if *(*int32)(unsafe.Pointer(bp + 40)) != 0 { + if **(**int32)(__ccgo_up(bp + 40)) != 0 { i = 0 for { - if !(i < int64((*(*[3]Tint32_t)(unsafe.Pointer(bp + 44)))[int32(INITGRNGRPS)])) { + if !(i < int64((**(**[3]Tint32_t)(__ccgo_up(bp + 44)))[int32(INITGRNGRPS)])) { break } - v3 = *(*Tuint32_t)(unsafe.Pointer(nscdbuf + uintptr(i)*4)) + v3 = **(**Tuint32_t)(__ccgo_up(nscdbuf + uintptr(i)*4)) v4 = v3>>int32(24) | v3>>int32(8)&uint32(0xff00) | v3<= Uint64FromUint64(0xffffffffffffffff)/Uint64FromInt32(8) { + if Uint64FromInt32((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWNAMELEN)]|(**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWPASSWDLEN)]|(**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWGECOSLEN)]|(**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWDIRLEN)]|(**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWSHELLLEN)]) >= Uint64FromUint64(0xffffffffffffffff)/Uint64FromInt32(8) { rv = int32(ENOMEM) goto cleanup_f } - len1 = Uint64FromInt32((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWNAMELEN)] + (*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWPASSWDLEN)] + (*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWGECOSLEN)] + (*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWDIRLEN)] + (*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWSHELLLEN)]) - if len1 > *(*Tsize_t)(unsafe.Pointer(size)) || !(*(*uintptr)(unsafe.Pointer(buf)) != 0) { - tmp = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(buf)), len1) + len1 = Uint64FromInt32((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWNAMELEN)] + (**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWPASSWDLEN)] + (**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWGECOSLEN)] + (**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWDIRLEN)] + (**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWSHELLLEN)]) + if len1 > **(**Tsize_t)(__ccgo_up(size)) || !(**(**uintptr)(__ccgo_up(buf)) != 0) { + tmp = Xrealloc(tls, **(**uintptr)(__ccgo_up(buf)), len1) if !(tmp != 0) { - rv = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + rv = **(**int32)(__ccgo_up(X__errno_location(tls))) goto cleanup_f } - *(*uintptr)(unsafe.Pointer(buf)) = tmp - *(*Tsize_t)(unsafe.Pointer(size)) = len1 + **(**uintptr)(__ccgo_up(buf)) = tmp + **(**Tsize_t)(__ccgo_up(size)) = len1 } - if !(Xfread(tls, *(*uintptr)(unsafe.Pointer(buf)), len1, uint64(1), f) != 0) { + if !(Xfread(tls, **(**uintptr)(__ccgo_up(buf)), len1, uint64(1), f) != 0) { if Xferror(tls, f) != 0 { - v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = **(**int32)(__ccgo_up(X__errno_location(tls))) } else { v1 = int32(EIO) } rv = v1 goto cleanup_f } - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = *(*uintptr)(unsafe.Pointer(buf)) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name + uintptr((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWNAMELEN)]) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd + uintptr((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWPASSWDLEN)]) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos + uintptr((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWGECOSLEN)]) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir + uintptr((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWDIRLEN)]) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_uid = Uint32FromInt32((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWUID)]) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gid = Uint32FromInt32((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWGID)]) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = **(**uintptr)(__ccgo_up(buf)) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name + uintptr((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWNAMELEN)]) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd + uintptr((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWPASSWDLEN)]) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos + uintptr((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWGECOSLEN)]) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir + uintptr((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWDIRLEN)]) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_uid = Uint32FromInt32((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWUID)]) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gid = Uint32FromInt32((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWGID)]) /* Don't assume that nscd made sure to null terminate strings. * It's supposed to, but malicious nscd should be ignored * rather than causing a crash. */ - if *(*uint8)(unsafe.Pointer((*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd + uintptr(-Int32FromInt32(1)))) != 0 || *(*uint8)(unsafe.Pointer((*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos + uintptr(-Int32FromInt32(1)))) != 0 || *(*uint8)(unsafe.Pointer((*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir + uintptr(-Int32FromInt32(1)))) != 0 || *(*uint8)(unsafe.Pointer((*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell + uintptr((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWSHELLLEN)]-int32(1)))) != 0 { + if **(**uint8)(__ccgo_up((*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd + uintptr(-Int32FromInt32(1)))) != 0 || **(**uint8)(__ccgo_up((*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos + uintptr(-Int32FromInt32(1)))) != 0 || **(**uint8)(__ccgo_up((*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir + uintptr(-Int32FromInt32(1)))) != 0 || **(**uint8)(__ccgo_up((*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell + uintptr((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWSHELLLEN)]-int32(1)))) != 0 { rv = int32(EIO) goto cleanup_f } @@ -126045,7 +126045,7 @@ func X__getpw_a(tls *TLS, name uintptr, uid Tuid_t, pw uintptr, buf uintptr, siz rv = int32(EIO) goto cleanup_f } - *(*uintptr)(unsafe.Pointer(res)) = pw + **(**uintptr)(__ccgo_up(res)) = pw goto cleanup_f cleanup_f: ; @@ -126055,9 +126055,9 @@ func X__getpw_a(tls *TLS, name uintptr, uid Tuid_t, pw uintptr, buf uintptr, siz goto done done: ; - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 4)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 4)), uintptr(0)) if rv != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = rv + **(**int32)(__ccgo_up(X__errno_location(tls))) = rv } return rv } @@ -126070,27 +126070,27 @@ func _getpw_r(tls *TLS, name uintptr, uid Tuid_t, pw uintptr, buf uintptr, size var _ /* len at bp+8 */ Tsize_t var _ /* line at bp+0 */ uintptr _ = rv - *(*uintptr)(unsafe.Pointer(bp)) = uintptr(0) - *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint64(0) + **(**uintptr)(__ccgo_up(bp)) = uintptr(0) + **(**Tsize_t)(__ccgo_up(bp + 8)) = uint64(0) rv = 0 _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp+16) rv = X__getpw_a(tls, name, uid, pw, bp, bp+8, res) - if *(*uintptr)(unsafe.Pointer(res)) != 0 && size < *(*Tsize_t)(unsafe.Pointer(bp + 8)) { - *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) + if **(**uintptr)(__ccgo_up(res)) != 0 && size < **(**Tsize_t)(__ccgo_up(bp + 8)) { + **(**uintptr)(__ccgo_up(res)) = uintptr(0) rv = int32(ERANGE) } - if *(*uintptr)(unsafe.Pointer(res)) != 0 { - Xmemcpy(tls, buf, *(*uintptr)(unsafe.Pointer(bp)), *(*Tsize_t)(unsafe.Pointer(bp + 8))) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_name)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf + if **(**uintptr)(__ccgo_up(res)) != 0 { + Xmemcpy(tls, buf, **(**uintptr)(__ccgo_up(bp)), **(**Tsize_t)(__ccgo_up(bp + 8))) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_name)-int64(**(**uintptr)(__ccgo_up(bp)))) + buf + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd)-int64(**(**uintptr)(__ccgo_up(bp)))) + buf + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos)-int64(**(**uintptr)(__ccgo_up(bp)))) + buf + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir)-int64(**(**uintptr)(__ccgo_up(bp)))) + buf + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell)-int64(**(**uintptr)(__ccgo_up(bp)))) + buf } - Xfree(tls, *(*uintptr)(unsafe.Pointer(bp))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 16)), uintptr(0)) + Xfree(tls, **(**uintptr)(__ccgo_up(bp))) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 16)), uintptr(0)) if rv != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = rv + **(**int32)(__ccgo_up(X__errno_location(tls))) = rv } return rv } @@ -126141,7 +126141,7 @@ func Xgetpwent(tls *TLS) (r uintptr) { return uintptr(0) } X__getpwent_a(tls, _f2, uintptr(unsafe.Pointer(&_pw1)), uintptr(unsafe.Pointer(&_line4)), uintptr(unsafe.Pointer(&_size)), bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func Xgetpwuid(tls *TLS, uid Tuid_t) (r uintptr) { @@ -126153,7 +126153,7 @@ func Xgetpwuid(tls *TLS, uid Tuid_t) (r uintptr) { defer tls.Free(16) var _ /* res at bp+0 */ uintptr X__getpw_a(tls, uintptr(0), uid, uintptr(unsafe.Pointer(&_pw1)), uintptr(unsafe.Pointer(&_line4)), uintptr(unsafe.Pointer(&_size)), bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func Xgetpwnam(tls *TLS, name uintptr) (r uintptr) { @@ -126165,7 +126165,7 @@ func Xgetpwnam(tls *TLS, name uintptr) (r uintptr) { defer tls.Free(16) var _ /* res at bp+0 */ uintptr X__getpw_a(tls, name, uint32(0), uintptr(unsafe.Pointer(&_pw1)), uintptr(unsafe.Pointer(&_line4)), uintptr(unsafe.Pointer(&_size)), bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func Xendpwent(tls *TLS) { @@ -126180,14 +126180,14 @@ func _atou1(tls *TLS, s uintptr) (r uint32) { _ = x x = uint32(0) for { - if !(Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-int32('0')) < uint32(10)) { + if !(Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-int32('0')) < uint32(10)) { break } - x = uint32(10)*x + Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-Int32FromUint8('0')) + x = uint32(10)*x + Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-Int32FromUint8('0')) goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s)) = *(*uintptr)(unsafe.Pointer(s)) + 1 + **(**uintptr)(__ccgo_up(s)) = **(**uintptr)(__ccgo_up(s)) + 1 } return x } @@ -126212,79 +126212,79 @@ func X__getpwent_a(tls *TLS, f uintptr, pw uintptr, line uintptr, size uintptr, l = v2 if v2 < 0 { if Xferror(tls, f) != 0 { - v3 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v3 = **(**int32)(__ccgo_up(X__errno_location(tls))) } else { v3 = 0 } rv = v3 - Xfree(tls, *(*uintptr)(unsafe.Pointer(line))) - *(*uintptr)(unsafe.Pointer(line)) = uintptr(0) + Xfree(tls, **(**uintptr)(__ccgo_up(line))) + **(**uintptr)(__ccgo_up(line)) = uintptr(0) pw = uintptr(0) break } - *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(line)) + uintptr(l-int64(1)))) = uint8(0) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(line)) - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(line)) + uintptr(l-int64(1)))) = uint8(0) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(line)) + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = v4 - v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v4 + v4 = Xstrchr(tls, **(**uintptr)(__ccgo_up(bp)), int32(':')) + **(**uintptr)(__ccgo_up(bp)) = v4 if !(v4 != 0) { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = *(*uintptr)(unsafe.Pointer(bp)) - v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v4 + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = **(**uintptr)(__ccgo_up(bp)) + v4 = Xstrchr(tls, **(**uintptr)(__ccgo_up(bp)), int32(':')) + **(**uintptr)(__ccgo_up(bp)) = v4 if !(v4 != 0) { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) (*Tpasswd)(unsafe.Pointer(pw)).Fpw_uid = _atou1(tls, bp) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32(':') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) != int32(':') { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gid = _atou1(tls, bp) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32(':') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) != int32(':') { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = *(*uintptr)(unsafe.Pointer(bp)) - v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v4 + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = **(**uintptr)(__ccgo_up(bp)) + v4 = Xstrchr(tls, **(**uintptr)(__ccgo_up(bp)), int32(':')) + **(**uintptr)(__ccgo_up(bp)) = v4 if !(v4 != 0) { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = *(*uintptr)(unsafe.Pointer(bp)) - v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v4 + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = **(**uintptr)(__ccgo_up(bp)) + v4 = Xstrchr(tls, **(**uintptr)(__ccgo_up(bp)), int32(':')) + **(**uintptr)(__ccgo_up(bp)) = v4 if !(v4 != 0) { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = *(*uintptr)(unsafe.Pointer(bp)) + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = **(**uintptr)(__ccgo_up(bp)) break goto _1 _1: } - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 8)), uintptr(0)) - *(*uintptr)(unsafe.Pointer(res)) = pw + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 8)), uintptr(0)) + **(**uintptr)(__ccgo_up(res)) = pw if rv != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = rv + **(**int32)(__ccgo_up(X__errno_location(tls))) = rv } return rv } @@ -126348,7 +126348,7 @@ func X__nscd_query(tls *TLS, req Tint32_t, key uintptr, buf uintptr, len1 Tsize_ var _ /* req_buf at bp+32 */ [3]Tint32_t _, _, _, _, _, _, _ = errno_save, f, fd, i, v1, v3, v4 f = uintptr(0) - *(*[3]Tint32_t)(unsafe.Pointer(bp + 32)) = [3]Tint32_t{ + **(**[3]Tint32_t)(__ccgo_up(bp + 32)) = [3]Tint32_t{ 0: int32(NSCDVERSION), 1: req, 2: Int32FromUint64(Xstrnlen(tls, key, uint64(LOGIN_NAME_MAX)) + uint64(1)), @@ -126363,23 +126363,23 @@ func X__nscd_query(tls *TLS, req Tint32_t, key uintptr, buf uintptr, len1 Tsize_ Fiov_len: _strlen(tls, key) + uint64(1), }, } - *(*Tmsghdr)(unsafe.Pointer(bp + 48)) = Tmsghdr{ + **(**Tmsghdr)(__ccgo_up(bp + 48)) = Tmsghdr{ Fmsg_iov: bp, Fmsg_iovlen: int32(2), } - errno_save = *(*int32)(unsafe.Pointer(X__errno_location(tls))) - *(*int32)(unsafe.Pointer(swap)) = 0 + errno_save = **(**int32)(__ccgo_up(X__errno_location(tls))) + **(**int32)(__ccgo_up(swap)) = 0 goto retry retry: ; Xmemset(tls, buf, 0, len1) - *(*Tint32_t)(unsafe.Pointer(buf)) = int32(NSCDVERSION) + **(**Tint32_t)(__ccgo_up(buf)) = int32(NSCDVERSION) fd = Xsocket(tls, int32(PF_LOCAL), Int32FromInt32(SOCK_STREAM)|Int32FromInt32(SOCK_CLOEXEC), 0) if fd < 0 { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EAFNOSUPPORT) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EAFNOSUPPORT) { f = Xfopen(tls, __ccgo_ts+1297, __ccgo_ts+1307) if f != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = errno_save + **(**int32)(__ccgo_up(X__errno_location(tls))) = errno_save } return f } @@ -126391,7 +126391,7 @@ retry: Xclose(tls, fd) return uintptr(0) } - if (*(*[3]Tint32_t)(unsafe.Pointer(bp + 32)))[int32(2)] > int32(LOGIN_NAME_MAX) { + if (**(**[3]Tint32_t)(__ccgo_up(bp + 32)))[int32(2)] > int32(LOGIN_NAME_MAX) { return f } if Xconnect(tls, fd, uintptr(unsafe.Pointer(&_addr)), uint32(24)) < 0 { @@ -126399,8 +126399,8 @@ retry: * result and the caller is responsible for calling * fclose on the (unconnected) socket. The value of * errno must be left unchanged in this case. */ - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EACCES) || *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ECONNREFUSED) || *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENOENT) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = errno_save + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EACCES) || **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ECONNREFUSED) || **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENOENT) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = errno_save return f } goto error @@ -126417,41 +126417,41 @@ retry: if Xferror(tls, f) != 0 { goto error } - if !(*(*int32)(unsafe.Pointer(swap)) != 0) { + if !(**(**int32)(__ccgo_up(swap)) != 0) { Xfclose(tls, f) i = uint64(0) for { if !(i < Uint64FromInt64(12)/Uint64FromInt64(4)) { break } - v3 = Uint32FromInt32((*(*[3]Tint32_t)(unsafe.Pointer(bp + 32)))[i]) + v3 = Uint32FromInt32((**(**[3]Tint32_t)(__ccgo_up(bp + 32)))[i]) v4 = v3>>int32(24) | v3>>int32(8)&uint32(0xff00) | v3<>int32(24) | v3>>int32(8)&uint32(0xff00) | v3<> int32(16)) - *(*uint16)(unsafe.Pointer(xi + 2*2)) = uint16(x >> int32(32)) + x = uint64(uint32(**(**uint16)(__ccgo_up(xi)))|(uint32(**(**uint16)(__ccgo_up(xi + 1*2)))+0)<> int32(16)) + **(**uint16)(__ccgo_up(xi + 2*2)) = uint16(x >> int32(32)) return x & uint64(0xffffffffffff) } @@ -126761,8 +126761,8 @@ func Xrand_r(tls *TLS, seed uintptr) (r int32) { } var v1 uint32 _ = v1 - v1 = *(*uint32)(unsafe.Pointer(seed))*Uint32FromInt32(1103515245) + Uint32FromInt32(12345) - *(*uint32)(unsafe.Pointer(seed)) = v1 + v1 = **(**uint32)(__ccgo_up(seed))*Uint32FromInt32(1103515245) + Uint32FromInt32(12345) + **(**uint32)(__ccgo_up(seed)) = v1 return Int32FromUint32(_temper(tls, v1) / uint32(2)) } @@ -126821,15 +126821,15 @@ func _lcg64(tls *TLS, x Tuint64_t) (r Tuint64_t) { } func _savestate(tls *TLS) (r uintptr) { - *(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(-Int32FromInt32(1))*4)) = Uint32FromInt32(_n<> int32(16)) - _i = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(-Int32FromInt32(1))*4)) >> Int32FromInt32(8) & uint32(0xff)) - _j = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(-Int32FromInt32(1))*4)) & uint32(0xff)) + _n = Int32FromUint32(**(**Tuint32_t)(__ccgo_up(_x1 + uintptr(-Int32FromInt32(1))*4)) >> int32(16)) + _i = Int32FromUint32(**(**Tuint32_t)(__ccgo_up(_x1 + uintptr(-Int32FromInt32(1))*4)) >> Int32FromInt32(8) & uint32(0xff)) + _j = Int32FromUint32(**(**Tuint32_t)(__ccgo_up(_x1 + uintptr(-Int32FromInt32(1))*4)) & uint32(0xff)) } func ___srandom(tls *TLS, seed uint32) { @@ -126838,7 +126838,7 @@ func ___srandom(tls *TLS, seed uint32) { _, _, _ = k, s, v1 s = uint64(seed) if _n == 0 { - *(*Tuint32_t)(unsafe.Pointer(_x1)) = uint32(s) + **(**Tuint32_t)(__ccgo_up(_x1)) = uint32(s) return } if _n == int32(31) || _n == int32(7) { @@ -126854,14 +126854,14 @@ func ___srandom(tls *TLS, seed uint32) { break } s = _lcg64(tls, s) - *(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(k)*4)) = uint32(s >> int32(32)) + **(**Tuint32_t)(__ccgo_up(_x1 + uintptr(k)*4)) = uint32(s >> int32(32)) goto _2 _2: ; k = k + 1 } /* make sure x contains at least one odd number */ - *(*Tuint32_t)(unsafe.Pointer(_x1)) |= uint32(1) + **(**Tuint32_t)(__ccgo_up(_x1)) |= uint32(1) } func Xsrandom(tls *TLS, seed uint32) { @@ -126934,13 +126934,13 @@ func Xrandom(tls *TLS) (r int64) { _, _, _ = k, v1, v2 ___lock(tls, uintptr(unsafe.Pointer(&_lock3))) if _n == 0 { - v1 = _lcg31(tls, *(*Tuint32_t)(unsafe.Pointer(_x1))) - *(*Tuint32_t)(unsafe.Pointer(_x1)) = v1 + v1 = _lcg31(tls, **(**Tuint32_t)(__ccgo_up(_x1))) + **(**Tuint32_t)(__ccgo_up(_x1)) = v1 k = Int64FromUint32(v1) goto end } - *(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(_i)*4)) += *(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(_j)*4)) - k = Int64FromUint32(*(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(_i)*4)) >> int32(1)) + **(**Tuint32_t)(__ccgo_up(_x1 + uintptr(_i)*4)) += **(**Tuint32_t)(__ccgo_up(_x1 + uintptr(_j)*4)) + k = Int64FromUint32(**(**Tuint32_t)(__ccgo_up(_x1 + uintptr(_i)*4)) >> int32(1)) _i = _i + 1 v2 = _i if v2 == _n { @@ -127146,8 +127146,8 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { defer func() { Xrealloc(tls, b, 0) }() path = Xgetenv(tls, __ccgo_ts+1400) seen_eacces = 0 - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOENT) - if !(*(*uint8)(unsafe.Pointer(file)) != 0) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOENT) + if !(**(**uint8)(__ccgo_up(file)) != 0) { return -int32(1) } if Xstrchr(tls, file, int32('/')) != 0 { @@ -127158,7 +127158,7 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { } k = Xstrnlen(tls, file, Uint64FromInt32(Int32FromInt32(NAME_MAX)+Int32FromInt32(1))) if k > uint64(NAME_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENAMETOOLONG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENAMETOOLONG) return -int32(1) } l = Xstrnlen(tls, path, Uint64FromInt32(Int32FromInt32(PATH_MAX)-Int32FromInt32(1))) + uint64(1) @@ -127170,7 +127170,7 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { if Uint64FromInt64(int64(z)-int64(p)) >= l { v3 = z z = z + 1 - if !(*(*uint8)(unsafe.Pointer(v3)) != 0) { + if !(**(**uint8)(__ccgo_up(v3)) != 0) { break } goto _1 @@ -127179,7 +127179,7 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { *(*uint8)(unsafe.Add(unsafe.Pointer(b), int64(z)-int64(p))) = uint8('/') Xmemcpy(tls, b+uintptr(int64(z)-int64(p))+BoolUintptr(z > p), file, k+uint64(1)) Xexecve(tls, b, argv, envp) - switch *(*int32)(unsafe.Pointer(X__errno_location(tls))) { + switch **(**int32)(__ccgo_up(X__errno_location(tls))) { case int32(EACCES): seen_eacces = int32(1) fallthrough @@ -127191,7 +127191,7 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { } v3 = z z = z + 1 - if !(*(*uint8)(unsafe.Pointer(v3)) != 0) { + if !(**(**uint8)(__ccgo_up(v3)) != 0) { break } goto _1 @@ -127200,7 +127200,7 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { p = z } if seen_eacces != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EACCES) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EACCES) } return -int32(1) } @@ -127237,8 +127237,8 @@ func Xfexecve(tls *TLS, fd int32, argv uintptr, envp uintptr) (r1 int32) { } X__procfdname(tls, bp, Uint32FromInt32(fd)) Xexecve(tls, bp, argv, envp) - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENOENT) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EBADF) + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENOENT) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EBADF) } return -int32(1) } @@ -127475,7 +127475,7 @@ func Xposix_spawnattr_getflags(tls *TLS, attr uintptr, flags uintptr) (r int32) trc("tls=%v attr=%v flags=%v, (%v:)", tls, attr, flags, origin(2)) defer func() { trc("-> %v", r) }() } - *(*int16)(unsafe.Pointer(flags)) = int16((*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__flags) + **(**int16)(__ccgo_up(flags)) = int16((*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__flags) return 0 } @@ -127484,7 +127484,7 @@ func Xposix_spawnattr_getpgroup(tls *TLS, attr uintptr, pgrp uintptr) (r int32) trc("tls=%v attr=%v pgrp=%v, (%v:)", tls, attr, pgrp, origin(2)) defer func() { trc("-> %v", r) }() } - *(*Tpid_t)(unsafe.Pointer(pgrp)) = (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__pgrp + **(**Tpid_t)(__ccgo_up(pgrp)) = (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__pgrp return 0 } @@ -127493,7 +127493,7 @@ func Xposix_spawnattr_getsigdefault(tls *TLS, attr uintptr, def uintptr) (r int3 trc("tls=%v attr=%v def=%v, (%v:)", tls, attr, def, origin(2)) defer func() { trc("-> %v", r) }() } - *(*Tsigset_t)(unsafe.Pointer(def)) = (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__def + **(**Tsigset_t)(__ccgo_up(def)) = (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__def return 0 } @@ -127502,7 +127502,7 @@ func Xposix_spawnattr_getsigmask(tls *TLS, attr uintptr, mask uintptr) (r int32) trc("tls=%v attr=%v mask=%v, (%v:)", tls, attr, mask, origin(2)) defer func() { trc("-> %v", r) }() } - *(*Tsigset_t)(unsafe.Pointer(mask)) = (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__mask + **(**Tsigset_t)(__ccgo_up(mask)) = (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__mask return 0 } @@ -127511,7 +127511,7 @@ func Xposix_spawnattr_init(tls *TLS, attr uintptr) (r int32) { trc("tls=%v attr=%v, (%v:)", tls, attr, origin(2)) defer func() { trc("-> %v", r) }() } - *(*Tposix_spawnattr_t)(unsafe.Pointer(attr)) = Tposix_spawnattr_t{} + **(**Tposix_spawnattr_t)(__ccgo_up(attr)) = Tposix_spawnattr_t{} return 0 } @@ -127576,7 +127576,7 @@ func Xposix_spawnattr_setsigdefault(tls *TLS, attr uintptr, def uintptr) (r int3 trc("tls=%v attr=%v def=%v, (%v:)", tls, attr, def, origin(2)) defer func() { trc("-> %v", r) }() } - (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__def = *(*Tsigset_t)(unsafe.Pointer(def)) + (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__def = **(**Tsigset_t)(__ccgo_up(def)) return 0 } @@ -127585,7 +127585,7 @@ func Xposix_spawnattr_setsigmask(tls *TLS, attr uintptr, mask uintptr) (r int32) trc("tls=%v attr=%v mask=%v, (%v:)", tls, attr, mask, origin(2)) defer func() { trc("-> %v", r) }() } - (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__mask = *(*Tsigset_t)(unsafe.Pointer(mask)) + (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__mask = **(**Tsigset_t)(__ccgo_up(mask)) return 0 } @@ -127643,20 +127643,20 @@ func _str_next(tls *TLS, str uintptr, n Tsize_t, step uintptr) (r int32) { var _ /* wc at bp+0 */ Twchar_t _ = k if !(n != 0) { - *(*Tsize_t)(unsafe.Pointer(step)) = uint64(0) + **(**Tsize_t)(__ccgo_up(step)) = uint64(0) return 0 } - if uint32(*(*uint8)(unsafe.Pointer(str))) >= uint32(128) { + if uint32(**(**uint8)(__ccgo_up(str))) >= uint32(128) { k = Xmbtowc(tls, bp, str, n) if k < 0 { - *(*Tsize_t)(unsafe.Pointer(step)) = uint64(1) + **(**Tsize_t)(__ccgo_up(step)) = uint64(1) return -int32(1) } - *(*Tsize_t)(unsafe.Pointer(step)) = Uint64FromInt32(k) - return *(*Twchar_t)(unsafe.Pointer(bp)) + **(**Tsize_t)(__ccgo_up(step)) = Uint64FromInt32(k) + return **(**Twchar_t)(__ccgo_up(bp)) } - *(*Tsize_t)(unsafe.Pointer(step)) = uint64(1) - return Int32FromUint8(*(*uint8)(unsafe.Pointer(str))) + **(**Tsize_t)(__ccgo_up(step)) = uint64(1) + return Int32FromUint8(**(**uint8)(__ccgo_up(str))) } func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r int32) { @@ -127667,43 +127667,43 @@ func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r i var _ /* wc at bp+0 */ Twchar_t _, _, _, _ = esc, k, k1, z esc = 0 - if !(m != 0) || !(*(*uint8)(unsafe.Pointer(pat)) != 0) { - *(*Tsize_t)(unsafe.Pointer(step)) = uint64(0) + if !(m != 0) || !(**(**uint8)(__ccgo_up(pat)) != 0) { + **(**Tsize_t)(__ccgo_up(step)) = uint64(0) return END } - *(*Tsize_t)(unsafe.Pointer(step)) = uint64(1) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) == int32('\\') && *(*uint8)(unsafe.Pointer(pat + 1)) != 0 && !(flags&Int32FromInt32(FNM_NOESCAPE) != 0) { - *(*Tsize_t)(unsafe.Pointer(step)) = uint64(2) + **(**Tsize_t)(__ccgo_up(step)) = uint64(1) + if Int32FromUint8(**(**uint8)(__ccgo_up(pat))) == int32('\\') && **(**uint8)(__ccgo_up(pat + 1)) != 0 && !(flags&Int32FromInt32(FNM_NOESCAPE) != 0) { + **(**Tsize_t)(__ccgo_up(step)) = uint64(2) pat = pat + 1 esc = int32(1) goto escaped } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) == int32('[') { + if Int32FromUint8(**(**uint8)(__ccgo_up(pat))) == int32('[') { k = uint64(1) if k < m { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) == int32('^') || Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) == int32('!') { + if Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k)))) == int32('^') || Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k)))) == int32('!') { k = k + 1 } } if k < m { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) == int32(']') { + if Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k)))) == int32(']') { k = k + 1 } } for { - if !(k < m && *(*uint8)(unsafe.Pointer(pat + uintptr(k))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) != int32(']')) { + if !(k < m && **(**uint8)(__ccgo_up(pat + uintptr(k))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k)))) != int32(']')) { break } - if k+uint64(1) < m && *(*uint8)(unsafe.Pointer(pat + uintptr(k+uint64(1)))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) == int32('[') && (Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k+uint64(1))))) == int32(':') || Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k+uint64(1))))) == int32('.') || Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k+uint64(1))))) == int32('=')) { - z = Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k+uint64(1))))) + if k+uint64(1) < m && **(**uint8)(__ccgo_up(pat + uintptr(k+uint64(1)))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k)))) == int32('[') && (Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k+uint64(1))))) == int32(':') || Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k+uint64(1))))) == int32('.') || Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k+uint64(1))))) == int32('=')) { + z = Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k+uint64(1))))) k = k + uint64(2) - if k < m && *(*uint8)(unsafe.Pointer(pat + uintptr(k))) != 0 { + if k < m && **(**uint8)(__ccgo_up(pat + uintptr(k))) != 0 { k = k + 1 } - for k < m && *(*uint8)(unsafe.Pointer(pat + uintptr(k))) != 0 && (Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k-uint64(1))))) != z || Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) != int32(']')) { + for k < m && **(**uint8)(__ccgo_up(pat + uintptr(k))) != 0 && (Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k-uint64(1))))) != z || Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k)))) != int32(']')) { k = k + 1 } - if k == m || !(*(*uint8)(unsafe.Pointer(pat + uintptr(k))) != 0) { + if k == m || !(**(**uint8)(__ccgo_up(pat + uintptr(k))) != 0) { break } } @@ -127712,32 +127712,32 @@ func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r i ; k = k + 1 } - if k == m || !(*(*uint8)(unsafe.Pointer(pat + uintptr(k))) != 0) { - *(*Tsize_t)(unsafe.Pointer(step)) = uint64(1) + if k == m || !(**(**uint8)(__ccgo_up(pat + uintptr(k))) != 0) { + **(**Tsize_t)(__ccgo_up(step)) = uint64(1) return int32('[') } - *(*Tsize_t)(unsafe.Pointer(step)) = k + uint64(1) + **(**Tsize_t)(__ccgo_up(step)) = k + uint64(1) return -int32(3) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) == int32('*') { + if Int32FromUint8(**(**uint8)(__ccgo_up(pat))) == int32('*') { return -int32(5) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) == int32('?') { + if Int32FromUint8(**(**uint8)(__ccgo_up(pat))) == int32('?') { return -int32(4) } goto escaped escaped: ; - if uint32(*(*uint8)(unsafe.Pointer(pat))) >= uint32(128) { + if uint32(**(**uint8)(__ccgo_up(pat))) >= uint32(128) { k1 = Xmbtowc(tls, bp, pat, m) if k1 < 0 { - *(*Tsize_t)(unsafe.Pointer(step)) = uint64(0) + **(**Tsize_t)(__ccgo_up(step)) = uint64(0) return -int32(2) } - *(*Tsize_t)(unsafe.Pointer(step)) = Uint64FromInt32(k1 + esc) - return *(*Twchar_t)(unsafe.Pointer(bp)) + **(**Tsize_t)(__ccgo_up(step)) = Uint64FromInt32(k1 + esc) + return **(**Twchar_t)(__ccgo_up(bp)) } - return Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) + return Int32FromUint8(**(**uint8)(__ccgo_up(pat))) } func _casefold(tls *TLS, k int32) (r int32) { @@ -127764,59 +127764,59 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { _, _, _, _, _ = inv, l, l1, p0, z inv = 0 p = p + 1 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('^') || Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('!') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('^') || Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('!') { inv = int32(1) p = p + 1 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32(']') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32(']') { if k == int32(']') { return BoolInt32(!(inv != 0)) } p = p + 1 } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('-') { if k == int32('-') { return BoolInt32(!(inv != 0)) } p = p + 1 } } - *(*Twchar_t)(unsafe.Pointer(bp)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) + **(**Twchar_t)(__ccgo_up(bp)) = Int32FromUint8(**(**uint8)(__ccgo_up(p + uintptr(-Int32FromInt32(1))))) for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32(']')) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(p))) != int32(']')) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') && Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) != int32(']') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('-') && Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) != int32(']') { l = Xmbtowc(tls, bp+4, p+uintptr(1), uint64(4)) if l < 0 { return 0 } - if *(*Twchar_t)(unsafe.Pointer(bp)) <= *(*Twchar_t)(unsafe.Pointer(bp + 4)) { - if Uint32FromInt32(k)-Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))) <= Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp + 4))-*(*Twchar_t)(unsafe.Pointer(bp))) || Uint32FromInt32(kfold)-Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))) <= Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp + 4))-*(*Twchar_t)(unsafe.Pointer(bp))) { + if **(**Twchar_t)(__ccgo_up(bp)) <= **(**Twchar_t)(__ccgo_up(bp + 4)) { + if Uint32FromInt32(k)-Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))) <= Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp + 4))-**(**Twchar_t)(__ccgo_up(bp))) || Uint32FromInt32(kfold)-Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))) <= Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp + 4))-**(**Twchar_t)(__ccgo_up(bp))) { return BoolInt32(!(inv != 0)) } } p = p + uintptr(l-int32(1)) goto _1 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('[') && (Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32(':') || Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('.') || Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('=')) { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('[') && (Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) == int32(':') || Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) == int32('.') || Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) == int32('=')) { p0 = p + uintptr(2) - z = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) + z = Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) p = p + uintptr(3) - for Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) != z || Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32(']') { + for Int32FromUint8(**(**uint8)(__ccgo_up(p + uintptr(-Int32FromInt32(1))))) != z || Int32FromUint8(**(**uint8)(__ccgo_up(p))) != int32(']') { p = p + 1 } if z == int32(':') && int64(p-uintptr(1))-int64(p0) < int64(16) { Xmemcpy(tls, bp+8, p0, Uint64FromInt64(int64(p-uintptr(1))-int64(p0))) - (*(*[16]uint8)(unsafe.Pointer(bp + 8)))[int64(p-uintptr(1))-int64(p0)] = uint8(0) + (**(**[16]uint8)(__ccgo_up(bp + 8)))[int64(p-uintptr(1))-int64(p0)] = uint8(0) if Xiswctype(tls, Uint32FromInt32(k), Xwctype(tls, bp+8)) != 0 || Xiswctype(tls, Uint32FromInt32(kfold), Xwctype(tls, bp+8)) != 0 { return BoolInt32(!(inv != 0)) } } goto _1 } - if uint32(*(*uint8)(unsafe.Pointer(p))) < uint32(128) { - *(*Twchar_t)(unsafe.Pointer(bp)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + if uint32(**(**uint8)(__ccgo_up(p))) < uint32(128) { + **(**Twchar_t)(__ccgo_up(bp)) = Int32FromUint8(uint8(**(**uint8)(__ccgo_up(p)))) } else { l1 = Xmbtowc(tls, bp, p, uint64(4)) if l1 < 0 { @@ -127824,7 +127824,7 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { } p = p + uintptr(l1-int32(1)) } - if *(*Twchar_t)(unsafe.Pointer(bp)) == k || *(*Twchar_t)(unsafe.Pointer(bp)) == kfold { + if **(**Twchar_t)(__ccgo_up(bp)) == k || **(**Twchar_t)(__ccgo_up(bp)) == kfold { return BoolInt32(!(inv != 0)) } goto _1 @@ -127847,7 +127847,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, endpat, endstr, k, kfold, p, ptail, s, stail, tailcnt, v2, v6, v9 tailcnt = uint64(0) if flags&int32(FNM_PERIOD) != 0 { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(str))) == int32('.') && Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) != int32('.') { + if Int32FromUint8(**(**uint8)(__ccgo_up(str))) == int32('.') && Int32FromUint8(**(**uint8)(__ccgo_up(pat))) != int32('.') { return int32(FNM_NOMATCH) } } @@ -127870,8 +127870,8 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, } return v2 } - str = str + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) - n = n - *(*Tsize_t)(unsafe.Pointer(bp + 8)) + str = str + uintptr(**(**Tsize_t)(__ccgo_up(bp + 8))) + n = n - **(**Tsize_t)(__ccgo_up(bp + 8)) if flags&int32(FNM_CASEFOLD) != 0 { v2 = _casefold(tls, k) } else { @@ -127887,8 +127887,8 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, return int32(FNM_NOMATCH) } } - pat = pat + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) - m = m - *(*Tsize_t)(unsafe.Pointer(bp)) + pat = pat + uintptr(**(**Tsize_t)(__ccgo_up(bp))) + m = m - **(**Tsize_t)(__ccgo_up(bp)) goto _1 } break @@ -127919,7 +127919,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, goto _5 _5: ; - p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(**(**Tsize_t)(__ccgo_up(bp))) } /* Past this point we need not check for UNMATCHABLE in pat, * because all of pat has already been parsed once. */ @@ -127937,8 +127937,8 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, if !(s > str && tailcnt != 0) { break } - if v9 = uint32(*(*uint8)(unsafe.Pointer(s + uintptr(-Int32FromInt32(1))))) < uint32(128); !v9 { - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if v9 = uint32(**(**uint8)(__ccgo_up(s + uintptr(-Int32FromInt32(1))))) < uint32(128); !v9 { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v2 = int32(4) } else { v2 = int32(1) @@ -127950,7 +127950,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, for { s = s - 1 v6 = s - if !(uint32(*(*uint8)(unsafe.Pointer(v6)))-uint32(0x80) < uint32(0x40) && s > str) { + if !(uint32(uint8(**(**uint8)(__ccgo_up(v6))))-uint32(0x80) < uint32(0x40) && s > str) { break } } @@ -127968,7 +127968,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, p = ptail for { c = _pat_next(tls, p, Uint64FromInt64(int64(endpat)-int64(p)), bp, flags) - p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(**(**Tsize_t)(__ccgo_up(bp))) v2 = _str_next(tls, s, Uint64FromInt64(int64(endstr)-int64(s)), bp+8) k = v2 if v2 <= 0 { @@ -127977,7 +127977,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, } break } - s = s + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) + s = s + uintptr(**(**Tsize_t)(__ccgo_up(bp + 8))) if flags&int32(FNM_CASEFOLD) != 0 { v2 = _casefold(tls, k) } else { @@ -127985,7 +127985,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, } kfold = v2 if c == -int32(3) { - if !(_match_bracket(tls, p-uintptr(*(*Tsize_t)(unsafe.Pointer(bp))), k, kfold) != 0) { + if !(_match_bracket(tls, p-uintptr(**(**Tsize_t)(__ccgo_up(bp))), k, kfold) != 0) { return int32(FNM_NOMATCH) } } else { @@ -128005,7 +128005,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, s = str for { c = _pat_next(tls, p, Uint64FromInt64(int64(endpat)-int64(p)), bp, flags) - p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(**(**Tsize_t)(__ccgo_up(bp))) /* Encountering * completes/commits a component */ if c == -int32(5) { pat = p @@ -128023,7 +128023,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, } kfold = v2 if c == -int32(3) { - if !(_match_bracket(tls, p-uintptr(*(*Tsize_t)(unsafe.Pointer(bp))), k, kfold) != 0) { + if !(_match_bracket(tls, p-uintptr(**(**Tsize_t)(__ccgo_up(bp))), k, kfold) != 0) { break } } else { @@ -128031,7 +128031,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, break } } - s = s + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) + s = s + uintptr(**(**Tsize_t)(__ccgo_up(bp + 8))) goto _14 _14: } @@ -128042,7 +128042,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, * char, or past all invalid bytes otherwise. */ k = _str_next(tls, str, Uint64FromInt64(int64(endstr)-int64(str)), bp+8) if k > 0 { - str = str + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) + str = str + uintptr(**(**Tsize_t)(__ccgo_up(bp + 8))) } else { str = str + 1 for { @@ -128074,7 +128074,7 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { for { s = str for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('/')) { + if !(**(**uint8)(__ccgo_up(s)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32('/')) { break } goto _2 @@ -128092,9 +128092,9 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { goto _3 _3: ; - p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(**(**Tsize_t)(__ccgo_up(bp))) } - if c != Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) && (!(*(*uint8)(unsafe.Pointer(s)) != 0) || !(flags&Int32FromInt32(FNM_LEADING_DIR) != 0)) { + if c != Int32FromUint8(**(**uint8)(__ccgo_up(s))) && (!(**(**uint8)(__ccgo_up(s)) != 0) || !(flags&Int32FromInt32(FNM_LEADING_DIR) != 0)) { return int32(FNM_NOMATCH) } if _fnmatch_internal(tls, pat, Uint64FromInt64(int64(p)-int64(pat)), str, Uint64FromInt64(int64(s)-int64(str)), flags) != 0 { @@ -128104,7 +128104,7 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { return 0 } str = s + uintptr(1) - pat = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + pat = p + uintptr(**(**Tsize_t)(__ccgo_up(bp))) goto _1 _1: } @@ -128112,10 +128112,10 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { if flags&int32(FNM_LEADING_DIR) != 0 { s = str for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('/') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32('/') { goto _5 } if !(_fnmatch_internal(tls, pat, Uint64FromInt32(-Int32FromInt32(1)), str, Uint64FromInt64(int64(s)-int64(str)), flags) != 0) { @@ -128165,14 +128165,14 @@ func _append(tls *TLS, tail uintptr, name uintptr, len1 Tsize_t, mark int32) (r if !(new1 != 0) { return -int32(1) } - (*Tmatch)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tail)))).Fnext = new1 + (*Tmatch)(unsafe.Pointer(**(**uintptr)(__ccgo_up(tail)))).Fnext = new1 (*Tmatch)(unsafe.Pointer(new1)).Fnext = UintptrFromInt32(0) Xmemcpy(tls, new1+8, name, len1+uint64(1)) - if mark != 0 && len1 != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(name + uintptr(len1-uint64(1))))) != int32('/') { + if mark != 0 && len1 != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(name + uintptr(len1-uint64(1))))) != int32('/') { *(*uint8)(unsafe.Pointer(new1 + 8 + uintptr(len1))) = uint8('/') *(*uint8)(unsafe.Pointer(new1 + 8 + uintptr(len1+uint64(1)))) = uint8(0) } - *(*uintptr)(unsafe.Pointer(tail)) = new1 + **(**uintptr)(__ccgo_up(tail)) = new1 return 0 } @@ -128192,15 +128192,15 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag } /* Special-case the remaining pattern being all slashes, in * which case we can use caller-passed type if it's a dir. */ - if *(*uint8)(unsafe.Pointer(pat)) != 0 && type1 != int32(DT_DIR) { + if **(**uint8)(__ccgo_up(pat)) != 0 && type1 != int32(DT_DIR) { type1 = 0 } - for pos+uint64(1) < uint64(PATH_MAX) && Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) == int32('/') { + for pos+uint64(1) < uint64(PATH_MAX) && Int32FromUint8(**(**uint8)(__ccgo_up(pat))) == int32('/') { v1 = pos pos = pos + 1 v2 = pat pat = pat + 1 - *(*uint8)(unsafe.Pointer(buf + uintptr(v1))) = *(*uint8)(unsafe.Pointer(v2)) + **(**uint8)(__ccgo_up(buf + uintptr(v1))) = **(**uint8)(__ccgo_up(v2)) } /* Consume maximal [escaped-]literal prefix of pattern, copying * and un-escaping it to the running buffer as we go. */ @@ -128209,10 +128209,10 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag in_bracket = 0 overflow = 0 for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(i)))) != int32('*') && Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(i)))) != int32('?') && (!(in_bracket != 0) || Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(i)))) != int32(']'))) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(i)))) != int32('*') && Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(i)))) != int32('?') && (!(in_bracket != 0) || Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(i)))) != int32(']'))) { break } - if !(*(*uint8)(unsafe.Pointer(pat + uintptr(i))) != 0) { + if !(**(**uint8)(__ccgo_up(pat + uintptr(i))) != 0) { if overflow != 0 { return 0 } @@ -128223,25 +128223,25 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag i = v4 break } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(i)))) == int32('[') { + if Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(i)))) == int32('[') { in_bracket = int32(1) } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(i)))) == int32('\\') && !(flags&Int32FromInt32(GLOB_NOESCAPE) != 0) { + if Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(i)))) == int32('\\') && !(flags&Int32FromInt32(GLOB_NOESCAPE) != 0) { /* Backslashes inside a bracket are (at least by * our interpretation) non-special, so if next * char is ']' we have a complete expression. */ - if in_bracket != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(i+int64(1))))) == int32(']') { + if in_bracket != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(i+int64(1))))) == int32(']') { break } /* Unpaired final backslash never matches. */ - if !(*(*uint8)(unsafe.Pointer(pat + uintptr(i+int64(1)))) != 0) { + if !(**(**uint8)(__ccgo_up(pat + uintptr(i+int64(1)))) != 0) { return 0 } i = i + 1 } } } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(i)))) == int32('/') { + if Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(i)))) == int32('/') { if overflow != 0 { return 0 } @@ -128259,7 +128259,7 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag if pos+Uint64FromInt64(j+Int64FromInt32(1)) < uint64(PATH_MAX) { v4 = j j = j + 1 - *(*uint8)(unsafe.Pointer(buf + uintptr(pos+Uint64FromInt64(v4)))) = *(*uint8)(unsafe.Pointer(pat + uintptr(i))) + **(**uint8)(__ccgo_up(buf + uintptr(pos+Uint64FromInt64(v4)))) = **(**uint8)(__ccgo_up(pat + uintptr(i))) } else { if in_bracket != 0 { overflow = int32(1) @@ -128275,17 +128275,17 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag ; i = i + 1 } - *(*uint8)(unsafe.Pointer(buf + uintptr(pos))) = uint8(0) - if !(*(*uint8)(unsafe.Pointer(pat)) != 0) { + **(**uint8)(__ccgo_up(buf + uintptr(pos))) = uint8(0) + if !(**(**uint8)(__ccgo_up(pat)) != 0) { if flags&int32(GLOB_MARK) != 0 && (!(type1 != 0) || type1 == int32(DT_LNK)) && !(Xstat(tls, buf, bp) != 0) { - if (*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFDIR) { + if (**(**Tstat)(__ccgo_up(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFDIR) { type1 = int32(DT_DIR) } else { type1 = int32(DT_REG) } } if !(type1 != 0) && Xlstat(tls, buf, bp) != 0 { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(ENOENT) && ((*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(ENOENT) && ((*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, **(**int32)(__ccgo_up(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0) { return int32(GLOB_ABORTED) } return 0 @@ -128302,7 +128302,7 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag if p2 != 0 && !(flags&Int32FromInt32(GLOB_NOESCAPE) != 0) { p = p2 for { - if !(p > pat && Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) == int32('\\')) { + if !(p > pat && Int32FromUint8(**(**uint8)(__ccgo_up(p + uintptr(-Int32FromInt32(1))))) == int32('\\')) { break } goto _6 @@ -128322,14 +128322,14 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag } dir = Xopendir(tls, v2) if !(dir != 0) { - if (*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0 { + if (*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, **(**int32)(__ccgo_up(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0 { return int32(GLOB_ABORTED) } return 0 } - old_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + old_errno = **(**int32)(__ccgo_up(X__errno_location(tls))) for { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = 0 + **(**int32)(__ccgo_up(X__errno_location(tls))) = 0 v2 = Xreaddir(tls, dir) de = v2 if !(v2 != 0) { @@ -128344,7 +128344,7 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag continue } if p2 != 0 { - *(*uint8)(unsafe.Pointer(p2)) = uint8(0) + **(**uint8)(__ccgo_up(p2)) = uint8(0) } if flags&int32(GLOB_NOESCAPE) != 0 { v9 = int32(FNM_NOESCAPE) @@ -128362,12 +128362,12 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag } /* With GLOB_PERIOD, don't allow matching . or .. unless * fnmatch would match them with FNM_PERIOD rules in effect. */ - if p2 != 0 && flags&int32(GLOB_PERIOD) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(de + 19))) == int32('.') && (!(*(*uint8)(unsafe.Pointer(de + 19 + 1)) != 0) || Int32FromUint8(*(*uint8)(unsafe.Pointer(de + 19 + 1))) == int32('.') && !(*(*uint8)(unsafe.Pointer(de + 19 + 2)) != 0)) && Xfnmatch(tls, pat, de+19, fnm_flags|int32(FNM_PERIOD)) != 0 { + if p2 != 0 && flags&int32(GLOB_PERIOD) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(de + 19))) == int32('.') && (!(**(**uint8)(__ccgo_up(de + 19 + 1)) != 0) || Int32FromUint8(**(**uint8)(__ccgo_up(de + 19 + 1))) == int32('.') && !(**(**uint8)(__ccgo_up(de + 19 + 2)) != 0)) && Xfnmatch(tls, pat, de+19, fnm_flags|int32(FNM_PERIOD)) != 0 { continue } Xmemcpy(tls, buf+uintptr(pos), de+19, l+uint64(1)) if p2 != 0 { - *(*uint8)(unsafe.Pointer(p2)) = saved_sep + **(**uint8)(__ccgo_up(p2)) = saved_sep } if p2 != 0 { v2 = p2 @@ -128380,15 +128380,15 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag return r } } - readerr = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + readerr = **(**int32)(__ccgo_up(X__errno_location(tls))) if p2 != 0 { - *(*uint8)(unsafe.Pointer(p2)) = saved_sep + **(**uint8)(__ccgo_up(p2)) = saved_sep } Xclosedir(tls, dir) - if readerr != 0 && ((*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0) { + if readerr != 0 && ((*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, **(**int32)(__ccgo_up(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0) { return int32(GLOB_ABORTED) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = old_errno + **(**int32)(__ccgo_up(X__errno_location(tls))) = old_errno return 0 } @@ -128414,7 +128414,7 @@ func _freelist(tls *TLS, head uintptr) { } func _sort(tls *TLS, a uintptr, b uintptr) (r int32) { - return Xstrcmp(tls, *(*uintptr)(unsafe.Pointer(a)), *(*uintptr)(unsafe.Pointer(b))) + return Xstrcmp(tls, **(**uintptr)(__ccgo_up(a)), **(**uintptr)(__ccgo_up(b))) } func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { @@ -128427,25 +128427,25 @@ func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { var _ /* pw at bp+0 */ Tpasswd var _ /* res at bp+48 */ uintptr _, _, _, _, _, _, _, _, _ = delim, home, i, name_end, p, v1, v10, v2, v4 - p = *(*uintptr)(unsafe.Pointer(pat)) + uintptr(1) + p = **(**uintptr)(__ccgo_up(pat)) + uintptr(1) i = uint64(0) name_end = X__strchrnul(tls, p, int32('/')) - v1 = *(*uint8)(unsafe.Pointer(name_end)) + v1 = **(**uint8)(__ccgo_up(name_end)) delim = v1 if v1 != 0 { v2 = name_end name_end = name_end + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8(0) + **(**uint8)(__ccgo_up(v2)) = uint8(0) } - *(*uintptr)(unsafe.Pointer(pat)) = name_end - if *(*uint8)(unsafe.Pointer(p)) != 0 { + **(**uintptr)(__ccgo_up(pat)) = name_end + if **(**uint8)(__ccgo_up(p)) != 0 { v2 = UintptrFromInt32(0) } else { v2 = Xgetenv(tls, __ccgo_ts+1434) } home = v2 if !(home != 0) { - if *(*uint8)(unsafe.Pointer(p)) != 0 { + if **(**uint8)(__ccgo_up(p)) != 0 { v4 = Xgetpwnam_r(tls, p, bp, buf, uint64(PATH_MAX), bp+48) } else { v4 = Xgetpwuid_r(tls, Xgetuid(tls), bp, buf, uint64(PATH_MAX), bp+48) @@ -128464,7 +128464,7 @@ func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { return int32(GLOB_NOSPACE) _7: ; - if !!(*(*uintptr)(unsafe.Pointer(bp + 48)) != 0) { + if !!(**(**uintptr)(__ccgo_up(bp + 48)) != 0) { goto _9 } _6: @@ -128474,26 +128474,26 @@ func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { ; _8: ; - home = (*(*Tpasswd)(unsafe.Pointer(bp))).Fpw_dir + home = (**(**Tpasswd)(__ccgo_up(bp))).Fpw_dir } - for i < Uint64FromInt32(Int32FromInt32(PATH_MAX)-Int32FromInt32(2)) && *(*uint8)(unsafe.Pointer(home)) != 0 { + for i < Uint64FromInt32(Int32FromInt32(PATH_MAX)-Int32FromInt32(2)) && **(**uint8)(__ccgo_up(home)) != 0 { v10 = i i = i + 1 v2 = home home = home + 1 - *(*uint8)(unsafe.Pointer(buf + uintptr(v10))) = *(*uint8)(unsafe.Pointer(v2)) + **(**uint8)(__ccgo_up(buf + uintptr(v10))) = **(**uint8)(__ccgo_up(v2)) } - if *(*uint8)(unsafe.Pointer(home)) != 0 { + if **(**uint8)(__ccgo_up(home)) != 0 { return int32(GLOB_NOMATCH) } v1 = delim - *(*uint8)(unsafe.Pointer(buf + uintptr(i))) = v1 + **(**uint8)(__ccgo_up(buf + uintptr(i))) = v1 if v1 != 0 { i = i + 1 v10 = i - *(*uint8)(unsafe.Pointer(buf + uintptr(v10))) = uint8(0) + **(**uint8)(__ccgo_up(buf + uintptr(v10))) = uint8(0) } - *(*Tsize_t)(unsafe.Pointer(pos)) = i + **(**Tsize_t)(__ccgo_up(pos)) = i return 0 } @@ -128516,10 +128516,10 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint var _ /* s at bp+4120 */ uintptr var _ /* tail at bp+8 */ uintptr _, _, _, _, _, _, _ = cnt, error1, i, offs, p, pathv, v1 - *(*Tmatch)(unsafe.Pointer(bp)) = struct { + **(**Tmatch)(__ccgo_up(bp)) = struct { Fnext uintptr }{} - *(*uintptr)(unsafe.Pointer(bp + 8)) = bp + **(**uintptr)(__ccgo_up(bp + 8)) = bp if flags&int32(GLOB_DOOFFS) != 0 { v1 = (*Tglob_t)(unsafe.Pointer(g)).Fgl_offs } else { @@ -128535,19 +128535,19 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathc = uint64(0) (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv = UintptrFromInt32(0) } - if *(*uint8)(unsafe.Pointer(pat)) != 0 { + if **(**uint8)(__ccgo_up(pat)) != 0 { p = Xstrdup(tls, pat) if !(p != 0) { return int32(GLOB_NOSPACE) } - (*(*[4096]uint8)(unsafe.Pointer(bp + 16)))[0] = uint8(0) - *(*Tsize_t)(unsafe.Pointer(bp + 4112)) = uint64(0) - *(*uintptr)(unsafe.Pointer(bp + 4120)) = p - if flags&(Int32FromInt32(GLOB_TILDE)|Int32FromInt32(GLOB_TILDE_CHECK)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('~') { + (**(**[4096]uint8)(__ccgo_up(bp + 16)))[0] = uint8(0) + **(**Tsize_t)(__ccgo_up(bp + 4112)) = uint64(0) + **(**uintptr)(__ccgo_up(bp + 4120)) = p + if flags&(Int32FromInt32(GLOB_TILDE)|Int32FromInt32(GLOB_TILDE_CHECK)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('~') { error1 = _expand_tilde(tls, bp+4120, bp+16, bp+4112) } if !(error1 != 0) { - error1 = _do_glob(tls, bp+16, *(*Tsize_t)(unsafe.Pointer(bp + 4112)), 0, *(*uintptr)(unsafe.Pointer(bp + 4120)), flags, __ccgo_fp_errfunc, bp+8) + error1 = _do_glob(tls, bp+16, **(**Tsize_t)(__ccgo_up(bp + 4112)), 0, **(**uintptr)(__ccgo_up(bp + 4120)), flags, __ccgo_fp_errfunc, bp+8) } Xfree(tls, p) } @@ -128556,20 +128556,20 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint return error1 } cnt = uint64(0) - *(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*Tmatch)(unsafe.Pointer(bp))).Fnext + **(**uintptr)(__ccgo_up(bp + 8)) = (**(**Tmatch)(__ccgo_up(bp))).Fnext for { - if !(*(*uintptr)(unsafe.Pointer(bp + 8)) != 0) { + if !(**(**uintptr)(__ccgo_up(bp + 8)) != 0) { break } goto _2 _2: ; - *(*uintptr)(unsafe.Pointer(bp + 8)) = (*Tmatch)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fnext + **(**uintptr)(__ccgo_up(bp + 8)) = (*Tmatch)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp + 8)))).Fnext cnt = cnt + 1 } if !(cnt != 0) { if flags&int32(GLOB_NOCHECK) != 0 { - *(*uintptr)(unsafe.Pointer(bp + 8)) = bp + **(**uintptr)(__ccgo_up(bp + 8)) = bp if _append(tls, bp+8, pat, _strlen(tls, pat), 0) != 0 { return int32(GLOB_NOSPACE) } @@ -128599,7 +128599,7 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint if !(i < offs) { break } - *(*uintptr)(unsafe.Pointer((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(i)*8)) = UintptrFromInt32(0) + **(**uintptr)(__ccgo_up((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(i)*8)) = UintptrFromInt32(0) goto _3 _3: ; @@ -128607,20 +128607,20 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint } } i = uint64(0) - *(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*Tmatch)(unsafe.Pointer(bp))).Fnext + **(**uintptr)(__ccgo_up(bp + 8)) = (**(**Tmatch)(__ccgo_up(bp))).Fnext for { if !(i < cnt) { break } - *(*uintptr)(unsafe.Pointer((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(offs+i)*8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + **(**uintptr)(__ccgo_up((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(offs+i)*8)) = **(**uintptr)(__ccgo_up(bp + 8)) + 8 goto _4 _4: ; - *(*uintptr)(unsafe.Pointer(bp + 8)) = (*Tmatch)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fnext + **(**uintptr)(__ccgo_up(bp + 8)) = (*Tmatch)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp + 8)))).Fnext i = i + 1 } - *(*uintptr)(unsafe.Pointer((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(offs+i)*8)) = UintptrFromInt32(0) - *(*Tsize_t)(unsafe.Pointer(g)) += cnt + **(**uintptr)(__ccgo_up((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(offs+i)*8)) = UintptrFromInt32(0) + **(**Tsize_t)(__ccgo_up(g)) += cnt if !(flags&Int32FromInt32(GLOB_NOSORT) != 0) { Xqsort(tls, (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv+uintptr(offs)*8, cnt, uint64(8), __ccgo_fp(_sort)) } @@ -128638,7 +128638,7 @@ func Xglobfree(tls *TLS, g uintptr) { if !(i < (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathc) { break } - Xfree(tls, *(*uintptr)(unsafe.Pointer((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr((*Tglob_t)(unsafe.Pointer(g)).Fgl_offs+i)*8))-uintptr(uint64(UintptrFromInt32(0)+8))) + Xfree(tls, **(**uintptr)(__ccgo_up((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr((*Tglob_t)(unsafe.Pointer(g)).Fgl_offs+i)*8))-uintptr(uint64(UintptrFromInt32(0)+8))) goto _1 _1: ; @@ -129037,7 +129037,7 @@ func _tre_stack_push(tls *TLS, s uintptr, value Ttre_stack_item) (r Treg_errcode var new_size int32 _, _ = new_buffer, new_size if (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr < (*Ttre_stack_t)(unsafe.Pointer(s)).Fsize { - *(*Ttre_stack_item)(unsafe.Pointer((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr((*Ttre_stack_t)(unsafe.Pointer(s)).Fptr)*8)) = value + **(**Ttre_stack_item)(__ccgo_up((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr((*Ttre_stack_t)(unsafe.Pointer(s)).Fptr)*8)) = value (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr = (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr + 1 } else { if (*Ttre_stack_t)(unsafe.Pointer(s)).Fsize >= (*Ttre_stack_t)(unsafe.Pointer(s)).Fmax_size { @@ -129071,7 +129071,7 @@ func _tre_stack_push_voidptr(tls *TLS, s uintptr, value uintptr) (r Treg_errcode defer tls.Free(16) var _ /* item at bp+0 */ Ttre_stack_item *(*uintptr)(unsafe.Pointer(bp)) = value - return _tre_stack_push(tls, s, *(*Ttre_stack_item)(unsafe.Pointer(bp))) + return _tre_stack_push(tls, s, **(**Ttre_stack_item)(__ccgo_up(bp))) } func _tre_stack_pop_int(tls *TLS, s uintptr) (r int32) { @@ -129081,7 +129081,7 @@ func _tre_stack_pop_int(tls *TLS, s uintptr) (r int32) { v2 = s + 12 *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) - 1 v1 = *(*int32)(unsafe.Pointer(v2)) - return *(*int32)(unsafe.Pointer(&*(*Ttre_stack_item)(unsafe.Pointer((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr(v1)*8)))) + return *(*int32)(unsafe.Pointer(&**(**Ttre_stack_item)(__ccgo_up((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr(v1)*8)))) } func _tre_stack_pop_voidptr(tls *TLS, s uintptr) (r uintptr) { @@ -129181,7 +129181,7 @@ func _tre_expand_macro(tls *TLS, s uintptr) (r uintptr) { _ = i i = 0 for { - if !(_tre_macros[i].Fc != 0 && Int32FromUint8(_tre_macros[i].Fc) != Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))) { + if !(_tre_macros[i].Fc != 0 && Int32FromUint8(_tre_macros[i].Fc) != Int32FromUint8(**(**uint8)(__ccgo_up(s)))) { break } goto _1 @@ -129198,7 +129198,7 @@ func _tre_compare_lit(tls *TLS, a uintptr, b uintptr) (r int32) { la = a lb = b /* assumes the range of valid code_min is < INT_MAX */ - return int32((*Ttre_literal_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(la)))).Fcode_min - (*Ttre_literal_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(lb)))).Fcode_min) + return int32((*Ttre_literal_t)(unsafe.Pointer(**(**uintptr)(__ccgo_up(la)))).Fcode_min - (*Ttre_literal_t)(unsafe.Pointer(**(**uintptr)(__ccgo_up(lb)))).Fcode_min) } type Tliterals = struct { @@ -129216,7 +129216,7 @@ func _tre_new_lit(tls *TLS, p uintptr) (r uintptr) { if (*Tliterals)(unsafe.Pointer(p)).Fcap1 >= Int32FromInt32(1)< max { @@ -129408,7 +129408,7 @@ func _parse_bracket_terms(tls *TLS, ctx uintptr, s uintptr, ls uintptr, neg uint v6 = neg + 4 v2 = *(*int32)(unsafe.Pointer(v6)) *(*int32)(unsafe.Pointer(v6)) = *(*int32)(unsafe.Pointer(v6)) + 1 - *(*Ttre_ctype_t)(unsafe.Pointer(neg + 8 + uintptr(v2)*8)) = class + **(**Ttre_ctype_t)(__ccgo_up(neg + 8 + uintptr(v2)*8)) = class } else { lit = _tre_new_lit(tls, ls) if !(lit != 0) { @@ -129448,23 +129448,23 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { _, _, _, _, _, _, _, _, _, _, _ = err, i, lit, max, min, n, nc, negmax, negmin, node, v1 node = uintptr(0) nc = uintptr(0) - (*(*Tliterals)(unsafe.Pointer(bp))).Fmem = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem - (*(*Tliterals)(unsafe.Pointer(bp))).Flen1 = 0 - (*(*Tliterals)(unsafe.Pointer(bp))).Fcap1 = int32(32) - (*(*Tliterals)(unsafe.Pointer(bp))).Fa = Xmalloc(tls, Uint64FromInt32((*(*Tliterals)(unsafe.Pointer(bp))).Fcap1)*uint64(8)) - if !((*(*Tliterals)(unsafe.Pointer(bp))).Fa != 0) { + (**(**Tliterals)(__ccgo_up(bp))).Fmem = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem + (**(**Tliterals)(__ccgo_up(bp))).Flen1 = 0 + (**(**Tliterals)(__ccgo_up(bp))).Fcap1 = int32(32) + (**(**Tliterals)(__ccgo_up(bp))).Fa = Xmalloc(tls, Uint64FromInt32((**(**Tliterals)(__ccgo_up(bp))).Fcap1)*uint64(8)) + if !((**(**Tliterals)(__ccgo_up(bp))).Fa != 0) { return int32(REG_ESPACE) } - (*(*Tneg)(unsafe.Pointer(bp + 24))).Flen1 = 0 - (*(*Tneg)(unsafe.Pointer(bp + 24))).Fnegate = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('^')) - if (*(*Tneg)(unsafe.Pointer(bp + 24))).Fnegate != 0 { + (**(**Tneg)(__ccgo_up(bp + 24))).Flen1 = 0 + (**(**Tneg)(__ccgo_up(bp + 24))).Fnegate = BoolInt32(Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('^')) + if (**(**Tneg)(__ccgo_up(bp + 24))).Fnegate != 0 { s = s + 1 } err = _parse_bracket_terms(tls, ctx, s, bp, bp+24) if err != REG_OK { goto parse_bracket_done } - if (*(*Tneg)(unsafe.Pointer(bp + 24))).Fnegate != 0 { + if (**(**Tneg)(__ccgo_up(bp + 24))).Fnegate != 0 { /* * With REG_NEWLINE, POSIX requires that newlines are not matched by * any form of a non-matching list. @@ -129480,7 +129480,7 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition = -int32(1) } /* Sort the array if we need to negate it. */ - Xqsort(tls, (*(*Tliterals)(unsafe.Pointer(bp))).Fa, Uint64FromInt32((*(*Tliterals)(unsafe.Pointer(bp))).Flen1), uint64(8), __ccgo_fp(_tre_compare_lit)) + Xqsort(tls, (**(**Tliterals)(__ccgo_up(bp))).Fa, Uint64FromInt32((**(**Tliterals)(__ccgo_up(bp))).Flen1), uint64(8), __ccgo_fp(_tre_compare_lit)) /* extra lit for the last negated range */ lit = _tre_new_lit(tls, bp) if !(lit != 0) { @@ -129491,14 +129491,14 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max = int64(Int32FromInt32(TRE_CHAR_MAX) + Int32FromInt32(1)) (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition = -int32(1) /* negated classes */ - if (*(*Tneg)(unsafe.Pointer(bp + 24))).Flen1 != 0 { - nc = X__tre_mem_alloc_impl(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, 0, UintptrFromInt32(0), 0, Uint64FromInt32((*(*Tneg)(unsafe.Pointer(bp + 24))).Flen1+Int32FromInt32(1))*uint64(8)) + if (**(**Tneg)(__ccgo_up(bp + 24))).Flen1 != 0 { + nc = X__tre_mem_alloc_impl(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, 0, UintptrFromInt32(0), 0, Uint64FromInt32((**(**Tneg)(__ccgo_up(bp + 24))).Flen1+Int32FromInt32(1))*uint64(8)) if !(nc != 0) { err = int32(REG_ESPACE) goto parse_bracket_done } - Xmemcpy(tls, nc, bp+24+8, Uint64FromInt32((*(*Tneg)(unsafe.Pointer(bp + 24))).Flen1)*uint64(8)) - *(*Ttre_ctype_t)(unsafe.Pointer(nc + uintptr((*(*Tneg)(unsafe.Pointer(bp + 24))).Flen1)*8)) = uint64(0) + Xmemcpy(tls, nc, bp+24+8, Uint64FromInt32((**(**Tneg)(__ccgo_up(bp + 24))).Flen1)*uint64(8)) + **(**Ttre_ctype_t)(__ccgo_up(nc + uintptr((**(**Tneg)(__ccgo_up(bp + 24))).Flen1)*8)) = uint64(0) } } /* Build a union of the items in the array, negated if necessary. */ @@ -129507,13 +129507,13 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { negmax = v1 i = 0 for { - if !(i < (*(*Tliterals)(unsafe.Pointer(bp))).Flen1) { + if !(i < (**(**Tliterals)(__ccgo_up(bp))).Flen1) { break } - lit = *(*uintptr)(unsafe.Pointer((*(*Tliterals)(unsafe.Pointer(bp))).Fa + uintptr(i)*8)) + lit = **(**uintptr)(__ccgo_up((**(**Tliterals)(__ccgo_up(bp))).Fa + uintptr(i)*8)) min = int32((*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min) max = int32((*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max) - if (*(*Tneg)(unsafe.Pointer(bp + 24))).Fnegate != 0 { + if (**(**Tneg)(__ccgo_up(bp + 24))).Fnegate != 0 { if min <= negmin { /* Overlap. */ if max+int32(1) >= negmin { @@ -129545,22 +129545,22 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { goto parse_bracket_done parse_bracket_done: ; - Xfree(tls, (*(*Tliterals)(unsafe.Pointer(bp))).Fa) + Xfree(tls, (**(**Tliterals)(__ccgo_up(bp))).Fa) (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition + 1 (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = node return err } func _parse_dup_count(tls *TLS, s uintptr, n uintptr) (r uintptr) { - *(*int32)(unsafe.Pointer(n)) = -int32(1) - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + **(**int32)(__ccgo_up(n)) = -int32(1) + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return s } - *(*int32)(unsafe.Pointer(n)) = 0 + **(**int32)(__ccgo_up(n)) = 0 for { - *(*int32)(unsafe.Pointer(n)) = int32(10)**(*int32)(unsafe.Pointer(n)) + (Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) - int32('0')) + **(**int32)(__ccgo_up(n)) = int32(10)***(**int32)(__ccgo_up(n)) + (Int32FromUint8(**(**uint8)(__ccgo_up(s))) - int32('0')) s = s + 1 - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) || *(*int32)(unsafe.Pointer(n)) > int32(RE_DUP_MAX) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) || **(**int32)(__ccgo_up(n)) > int32(RE_DUP_MAX) { break } goto _1 @@ -129578,26 +129578,26 @@ func _parse_dup(tls *TLS, s uintptr, ere int32, pmin uintptr, pmax uintptr) (r u var _ /* min at bp+0 */ int32 _, _, _, _, _ = v1, v2, v3, v4, v5 s = _parse_dup_count(tls, s, bp) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32(',') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32(',') { s = _parse_dup_count(tls, s+uintptr(1), bp+4) } else { - *(*int32)(unsafe.Pointer(bp + 4)) = *(*int32)(unsafe.Pointer(bp)) + **(**int32)(__ccgo_up(bp + 4)) = **(**int32)(__ccgo_up(bp)) } - if v3 = *(*int32)(unsafe.Pointer(bp + 4)) < *(*int32)(unsafe.Pointer(bp)) && *(*int32)(unsafe.Pointer(bp + 4)) >= 0 || *(*int32)(unsafe.Pointer(bp + 4)) > int32(RE_DUP_MAX) || *(*int32)(unsafe.Pointer(bp)) > int32(RE_DUP_MAX) || *(*int32)(unsafe.Pointer(bp)) < 0; !v3 { + if v3 = **(**int32)(__ccgo_up(bp + 4)) < **(**int32)(__ccgo_up(bp)) && **(**int32)(__ccgo_up(bp + 4)) >= 0 || **(**int32)(__ccgo_up(bp + 4)) > int32(RE_DUP_MAX) || **(**int32)(__ccgo_up(bp)) > int32(RE_DUP_MAX) || **(**int32)(__ccgo_up(bp)) < 0; !v3 { if v2 = !(ere != 0); v2 { v1 = s s = s + 1 } } - if v5 = v3 || v2 && Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) != int32('\\'); !v5 { + if v5 = v3 || v2 && Int32FromUint8(**(**uint8)(__ccgo_up(v1))) != int32('\\'); !v5 { v4 = s s = s + 1 } - if v5 || Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) != int32('}') { + if v5 || Int32FromUint8(**(**uint8)(__ccgo_up(v4))) != int32('}') { return uintptr(0) } - *(*int32)(unsafe.Pointer(pmin)) = *(*int32)(unsafe.Pointer(bp)) - *(*int32)(unsafe.Pointer(pmax)) = *(*int32)(unsafe.Pointer(bp + 4)) + **(**int32)(__ccgo_up(pmin)) = **(**int32)(__ccgo_up(bp)) + **(**int32)(__ccgo_up(pmax)) = **(**int32)(__ccgo_up(bp + 4)) return s } @@ -129660,7 +129660,7 @@ func _parse_atom(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { var _ /* wc at bp+0 */ Twchar_t _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, ere, err, i, len1, node, p, tmp1, tmp11, tmp2, tmp21, v, val, v14, v16 ere = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fcflags & int32(REG_EXTENDED) - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(s))) { case int32('['): goto _1 case int32('\\'): @@ -129702,7 +129702,7 @@ _2: /* extensions: \b, \B, \<, \>, \xHH \x{HHHH} */ s = s + 1 v14 = s - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(v14))) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(v14))) { case 0: return int32(REG_EESCAPE) case int32('b'): @@ -129717,7 +129717,7 @@ _2: s = s + 1 v = 0 len1 = int32(2) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('{') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('{') { len1 = int32(8) s = s + 1 } @@ -129726,7 +129726,7 @@ _2: if !(i < len1 && v < int32(0x110000)) { break } - c = _hexval1(tls, uint32(*(*uint8)(unsafe.Pointer(s + uintptr(i))))) + c = _hexval1(tls, uint32(**(**uint8)(__ccgo_up(s + uintptr(i))))) if c < 0 { break } @@ -129738,7 +129738,7 @@ _2: } s = s + uintptr(i) if len1 == int32(8) { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('}') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32('}') { return int32(REG_EBRACE) } s = s + 1 @@ -129769,9 +129769,9 @@ _2: /* fallthrough */ fallthrough default: - if !(ere != 0) && uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('1') < uint32(9) { + if !(ere != 0) && uint32(**(**uint8)(__ccgo_up(s)))-uint32('1') < uint32(9) { /* back reference */ - val = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) - int32('0') + val = Int32FromUint8(**(**uint8)(__ccgo_up(s))) - int32('0') v14 = ctx + 44 v16 = *(*int32)(unsafe.Pointer(v14)) *(*int32)(unsafe.Pointer(v14)) = *(*int32)(unsafe.Pointer(v14)) + 1 @@ -129826,7 +129826,7 @@ _4: _5: ; /* '$' is special everywhere in EREs, and at the end of a BRE subexpression. */ - if !(ere != 0) && *(*uint8)(unsafe.Pointer(s + 1)) != 0 && (Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) != int32('\\') || Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 2))) != int32(')') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 2))) != int32('|')) { + if !(ere != 0) && **(**uint8)(__ccgo_up(s + 1)) != 0 && (Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) != int32('\\') || Int32FromUint8(**(**uint8)(__ccgo_up(s + 2))) != int32(')') && Int32FromUint8(**(**uint8)(__ccgo_up(s + 2))) != int32('|')) { goto parse_literal } node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(2), int32(ASSERT_AT_EOL), -int32(1)) @@ -129862,17 +129862,17 @@ parse_literal: if len1 < 0 { return int32(REG_BADPAT) } - if (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fcflags&int32(REG_ICASE) != 0 && (Xiswupper(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp)))) != 0 || Xiswlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp)))) != 0) { + if (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fcflags&int32(REG_ICASE) != 0 && (Xiswupper(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp)))) != 0 || Xiswlower(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp)))) != 0) { /* multiple opposite case characters are not supported */ - tmp11 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint32(Xtowupper(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))))), Int32FromUint32(Xtowupper(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))))), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) - tmp21 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint32(Xtowlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))))), Int32FromUint32(Xtowlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))))), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) + tmp11 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint32(Xtowupper(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))))), Int32FromUint32(Xtowupper(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))))), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) + tmp21 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint32(Xtowlower(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))))), Int32FromUint32(Xtowlower(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))))), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) if tmp11 != 0 && tmp21 != 0 { node = _tre_ast_new_union(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, tmp11, tmp21) } else { node = uintptr(0) } } else { - node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, *(*Twchar_t)(unsafe.Pointer(bp)), *(*Twchar_t)(unsafe.Pointer(bp)), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) + node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, **(**Twchar_t)(__ccgo_up(bp)), **(**Twchar_t)(__ccgo_up(bp)), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) } (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition + 1 s = s + uintptr(len1) @@ -129914,7 +129914,7 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { return err } for { - if !(ere != 0) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('\\') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) == int32('(') || ere != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('(') { + if !(ere != 0) && Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('\\') && Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) == int32('(') || ere != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('(') { v1 = _tre_stack_push_voidptr(tls, stack, nunion) err = v1 if v1 != REG_OK { @@ -129943,7 +129943,7 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart = s goto _3 } - if !(ere != 0) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('\\') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) == int32(')') || ere != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32(')') && depth != 0 { + if !(ere != 0) && Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('\\') && Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) == int32(')') || ere != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32(')') && depth != 0 { (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(1), -int32(1), -int32(1)) if !((*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn != 0) { return int32(REG_ESPACE) @@ -129959,52 +129959,52 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { parse_iter: ; for { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('\\') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('*') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32('\\') && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32('*') { if !(ere != 0) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('+') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('?') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('{') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32('+') && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32('?') && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32('{') { break } } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('\\') && ere != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('\\') && ere != 0 { break } /* extension: treat \+, \? as repetitions in BRE */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('\\') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) != int32('+') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) != int32('?') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) != int32('{') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('\\') && Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) != int32('+') && Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) != int32('?') && Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) != int32('{') { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('\\') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('\\') { s = s + 1 } /* handle ^* at the start of a BRE. */ - if !(ere != 0) && s == (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart+uintptr(1) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(-Int32FromInt32(1))))) == int32('^') { + if !(ere != 0) && s == (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart+uintptr(1) && Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(-Int32FromInt32(1))))) == int32('^') { break } /* extension: multiple consecutive *+?{,} is unspecified, but (a+)+ has to be supported so accepting a++ makes sense, note however that the RE_DUP_MAX limit can be circumvented: (a{255}){255} uses a lot of memory.. */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('{') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('{') { s = _parse_dup(tls, s+uintptr(1), ere, bp, bp+4) if !(s != 0) { return int32(REG_BADBR) } } else { - *(*int32)(unsafe.Pointer(bp)) = 0 - *(*int32)(unsafe.Pointer(bp + 4)) = -int32(1) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('+') { - *(*int32)(unsafe.Pointer(bp)) = int32(1) + **(**int32)(__ccgo_up(bp)) = 0 + **(**int32)(__ccgo_up(bp + 4)) = -int32(1) + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('+') { + **(**int32)(__ccgo_up(bp)) = int32(1) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('?') { - *(*int32)(unsafe.Pointer(bp + 4)) = int32(1) + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('?') { + **(**int32)(__ccgo_up(bp + 4)) = int32(1) } s = s + 1 } - if *(*int32)(unsafe.Pointer(bp + 4)) == 0 { + if **(**int32)(__ccgo_up(bp + 4)) == 0 { (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(1), -int32(1), -int32(1)) } else { - (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = _tre_ast_new_iter(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn, *(*int32)(unsafe.Pointer(bp)), *(*int32)(unsafe.Pointer(bp + 4)), 0) + (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = _tre_ast_new_iter(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn, **(**int32)(__ccgo_up(bp)), **(**int32)(__ccgo_up(bp + 4)), 0) } if !((*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn != 0) { return int32(REG_ESPACE) @@ -130013,13 +130013,13 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { _9: } nbranch = _tre_ast_new_catenation(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, nbranch, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn) - if ere != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('|') || ere != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32(')') && depth != 0 || !(ere != 0) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('\\') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) == int32(')') || !(ere != 0) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('\\') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) == int32('|') || !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if ere != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('|') || ere != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32(')') && depth != 0 || !(ere != 0) && Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('\\') && Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) == int32(')') || !(ere != 0) && Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('\\') && Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) == int32('|') || !(**(**uint8)(__ccgo_up(s)) != 0) { /* extension: empty branch is unspecified (), (|a), (a|) here they are not rejected but match on empty string */ - c = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) + c = Int32FromUint8(**(**uint8)(__ccgo_up(s))) nunion = _tre_ast_new_union(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, nunion, nbranch) nbranch = uintptr(0) - if c == int32('\\') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) == int32('|') { + if c == int32('\\') && Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) == int32('|') { s = s + uintptr(2) (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart = s } else { @@ -130165,22 +130165,22 @@ func _tre_purge_regset(tls *TLS, regset uintptr, tnfa uintptr, tag int32) { _, _, _ = i, id, start i = 0 for { - if !(*(*int32)(unsafe.Pointer(regset + uintptr(i)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(regset + uintptr(i)*4)) >= 0) { break } - id = *(*int32)(unsafe.Pointer(regset + uintptr(i)*4)) / int32(2) - start = BoolInt32(!(*(*int32)(unsafe.Pointer(regset + uintptr(i)*4))%Int32FromInt32(2) != 0)) + id = **(**int32)(__ccgo_up(regset + uintptr(i)*4)) / int32(2) + start = BoolInt32(!(**(**int32)(__ccgo_up(regset + uintptr(i)*4))%Int32FromInt32(2) != 0)) if start != 0 { - (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id)*16))).Fso_tag = tag + (**(**Ttre_submatch_data_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id)*16))).Fso_tag = tag } else { - (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id)*16))).Feo_tag = tag + (**(**Ttre_submatch_data_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id)*16))).Feo_tag = tag } goto _1 _1: ; i = i + 1 } - *(*int32)(unsafe.Pointer(regset)) = -int32(1) + **(**int32)(__ccgo_up(regset)) = -int32(1) } // C documentation @@ -130209,20 +130209,20 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u direction = int32(_TRE_TAG_MINIMIZE) if !(first_pass != 0) { (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fend_tag = 0 - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags)) = -int32(1) + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags)) = -int32(1) } regset = Xmalloc(tls, uint64(4)*uint64(((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches+Uint32FromInt32(1))*Uint32FromInt32(2))) if regset == UintptrFromInt32(0) { return int32(REG_ESPACE) } - *(*int32)(unsafe.Pointer(regset)) = -int32(1) + **(**int32)(__ccgo_up(regset)) = -int32(1) orig_regset = regset parents = Xmalloc(tls, uint64(4)*uint64((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches+Uint32FromInt32(1))) if parents == UintptrFromInt32(0) { Xfree(tls, regset) return int32(REG_ESPACE) } - *(*int32)(unsafe.Pointer(parents)) = -int32(1) + **(**int32)(__ccgo_up(parents)) = -int32(1) saved_states = Xmalloc(tls, uint64(8)*uint64((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches+Uint32FromInt32(1))) if saved_states == UintptrFromInt32(0) { Xfree(tls, regset) @@ -130234,7 +130234,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u if !(i <= (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches) { break } - (*(*Ttre_tag_states_t)(unsafe.Pointer(saved_states + uintptr(i)*8))).Ftag = -int32(1) + (**(**Ttre_tag_states_t)(__ccgo_up(saved_states + uintptr(i)*8))).Ftag = -int32(1) goto _1 _1: ; @@ -130273,7 +130273,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u /* Add end of this submatch to regset. */ i1 = 0 for { - if !(*(*int32)(unsafe.Pointer(regset + uintptr(i1)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(regset + uintptr(i1)*4)) >= 0) { break } goto _11 @@ -130281,12 +130281,12 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i1 = i1 + 1 } - *(*int32)(unsafe.Pointer(regset + uintptr(i1)*4)) = id*int32(2) + int32(1) - *(*int32)(unsafe.Pointer(regset + uintptr(i1+int32(1))*4)) = -int32(1) + **(**int32)(__ccgo_up(regset + uintptr(i1)*4)) = id*int32(2) + int32(1) + **(**int32)(__ccgo_up(regset + uintptr(i1+int32(1))*4)) = -int32(1) /* Pop this submatch from the parents stack. */ i1 = 0 for { - if !(*(*int32)(unsafe.Pointer(parents + uintptr(i1)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(parents + uintptr(i1)*4)) >= 0) { break } goto _12 @@ -130294,7 +130294,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i1 = i1 + 1 } - *(*int32)(unsafe.Pointer(parents + uintptr(i1-int32(1))*4)) = -int32(1) + **(**int32)(__ccgo_up(parents + uintptr(i1-int32(1))*4)) = -int32(1) goto _10 _3: ; @@ -130304,7 +130304,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u /* Add start of this submatch to regset. */ i2 = 0 for { - if !(*(*int32)(unsafe.Pointer(regset + uintptr(i2)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(regset + uintptr(i2)*4)) >= 0) { break } goto _13 @@ -130312,12 +130312,12 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i2 = i2 + 1 } - *(*int32)(unsafe.Pointer(regset + uintptr(i2)*4)) = id1 * int32(2) - *(*int32)(unsafe.Pointer(regset + uintptr(i2+int32(1))*4)) = -int32(1) + **(**int32)(__ccgo_up(regset + uintptr(i2)*4)) = id1 * int32(2) + **(**int32)(__ccgo_up(regset + uintptr(i2+int32(1))*4)) = -int32(1) if !(first_pass != 0) { i2 = 0 for { - if !(*(*int32)(unsafe.Pointer(parents + uintptr(i2)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(parents + uintptr(i2)*4)) >= 0) { break } goto _14 @@ -130325,26 +130325,26 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i2 = i2 + 1 } - (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id1)*16))).Fparents = UintptrFromInt32(0) + (**(**Ttre_submatch_data_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id1)*16))).Fparents = UintptrFromInt32(0) if i2 > 0 { p = Xmalloc(tls, uint64(4)*Uint64FromInt32(i2+Int32FromInt32(1))) if p == UintptrFromInt32(0) { status = int32(REG_ESPACE) goto _10 } - (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id1)*16))).Fparents = p + (**(**Ttre_submatch_data_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id1)*16))).Fparents = p i2 = 0 for { - if !(*(*int32)(unsafe.Pointer(parents + uintptr(i2)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(parents + uintptr(i2)*4)) >= 0) { break } - *(*int32)(unsafe.Pointer(p + uintptr(i2)*4)) = *(*int32)(unsafe.Pointer(parents + uintptr(i2)*4)) + **(**int32)(__ccgo_up(p + uintptr(i2)*4)) = **(**int32)(__ccgo_up(parents + uintptr(i2)*4)) goto _15 _15: ; i2 = i2 + 1 } - *(*int32)(unsafe.Pointer(p + uintptr(i2)*4)) = -int32(1) + **(**int32)(__ccgo_up(p + uintptr(i2)*4)) = -int32(1) } } /* Add end of this submatch to regset after processing this @@ -130362,16 +130362,16 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u case int32(_LITERAL): lit = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj if !((*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min < Int64FromInt32(0)) || (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min == int64(-int32(4)) { - if *(*int32)(unsafe.Pointer(regset)) >= 0 { + if **(**int32)(__ccgo_up(regset)) >= 0 { /* Regset is not empty, so add a tag before the literal or backref. */ if !(first_pass != 0) { status = _tre_add_tag_left(tls, mem, node, tag) - *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = direction + **(**Ttre_tag_direction_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = direction if minimal_tag >= 0 { i3 = 0 for { - if !(*(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3)*4)) >= 0) { break } goto _16 @@ -130379,9 +130379,9 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i3 = i3 + 1 } - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3)*4)) = tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3+int32(1))*4)) = minimal_tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3+int32(2))*4)) = -int32(1) + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3)*4)) = tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3+int32(1))*4)) = minimal_tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) num_minimals = num_minimals + 1 } @@ -130389,7 +130389,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u } else { (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fnum_tags = int32(1) } - *(*int32)(unsafe.Pointer(regset)) = -int32(1) + **(**int32)(__ccgo_up(regset)) = -int32(1) tag = next_tag num_tags = num_tags + 1 next_tag = next_tag + 1 @@ -130449,7 +130449,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u case int32(_ITERATION): iter = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj if first_pass != 0 { - status = _tre_stack_push_int(tls, stack, BoolInt32(*(*int32)(unsafe.Pointer(regset)) >= 0 || int32(uint32(*(*uint8)(unsafe.Pointer(iter + 16))&0x1>>0)) != 0)) + status = _tre_stack_push_int(tls, stack, BoolInt32(**(**int32)(__ccgo_up(regset)) >= 0 || int32(uint32(*(*uint8)(unsafe.Pointer(iter + 16))&0x1>>0)) != 0)) if status != REG_OK { break } @@ -130480,18 +130480,18 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u break } /* Regset is not empty, so add a tag here. */ - if *(*int32)(unsafe.Pointer(regset)) >= 0 || int32(uint32(*(*uint8)(unsafe.Pointer(iter + 16))&0x1>>0)) != 0 { + if **(**int32)(__ccgo_up(regset)) >= 0 || int32(uint32(*(*uint8)(unsafe.Pointer(iter + 16))&0x1>>0)) != 0 { if !(first_pass != 0) { status = _tre_add_tag_left(tls, mem, node, tag) if int32(uint32(*(*uint8)(unsafe.Pointer(iter + 16))&0x1>>0)) != 0 { - *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = int32(_TRE_TAG_MAXIMIZE) + **(**Ttre_tag_direction_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = int32(_TRE_TAG_MAXIMIZE) } else { - *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = direction + **(**Ttre_tag_direction_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = direction } if minimal_tag >= 0 { i4 = 0 for { - if !(*(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4)*4)) >= 0) { break } goto _17 @@ -130499,15 +130499,15 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i4 = i4 + 1 } - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4)*4)) = tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4+int32(1))*4)) = minimal_tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4+int32(2))*4)) = -int32(1) + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4)*4)) = tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4+int32(1))*4)) = minimal_tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) num_minimals = num_minimals + 1 } _tre_purge_regset(tls, regset, tnfa, tag) } - *(*int32)(unsafe.Pointer(regset)) = -int32(1) + **(**int32)(__ccgo_up(regset)) = -int32(1) tag = next_tag num_tags = num_tags + 1 next_tag = next_tag + 1 @@ -130517,7 +130517,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u uni = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj left1 = (*Ttre_union_t)(unsafe.Pointer(uni)).Fleft right1 = (*Ttre_union_t)(unsafe.Pointer(uni)).Fright - if *(*int32)(unsafe.Pointer(regset)) >= 0 { + if **(**int32)(__ccgo_up(regset)) >= 0 { left_tag = next_tag right_tag = next_tag + int32(1) } else { @@ -130537,7 +130537,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u if status != REG_OK { break } - status = _tre_stack_push_int(tls, stack, BoolInt32(*(*int32)(unsafe.Pointer(regset)) >= 0)) + status = _tre_stack_push_int(tls, stack, BoolInt32(**(**int32)(__ccgo_up(regset)) >= 0)) if status != REG_OK { break } @@ -130581,14 +130581,14 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u break } /* Regset is not empty, so add a tag here. */ - if *(*int32)(unsafe.Pointer(regset)) >= 0 { + if **(**int32)(__ccgo_up(regset)) >= 0 { if !(first_pass != 0) { status = _tre_add_tag_left(tls, mem, node, tag) - *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = direction + **(**Ttre_tag_direction_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = direction if minimal_tag >= 0 { i5 = 0 for { - if !(*(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5)*4)) >= 0) { break } goto _18 @@ -130596,15 +130596,15 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i5 = i5 + 1 } - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5)*4)) = tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5+int32(1))*4)) = minimal_tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5+int32(2))*4)) = -int32(1) + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5)*4)) = tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5+int32(1))*4)) = minimal_tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) num_minimals = num_minimals + 1 } _tre_purge_regset(tls, regset, tnfa, tag) } - *(*int32)(unsafe.Pointer(regset)) = -int32(1) + **(**int32)(__ccgo_up(regset)) = -int32(1) tag = next_tag num_tags = num_tags + 1 next_tag = next_tag + 1 @@ -130621,7 +130621,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u /* Push this submatch on the parents stack. */ i6 = 0 for { - if !(*(*int32)(unsafe.Pointer(parents + uintptr(i6)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(parents + uintptr(i6)*4)) >= 0) { break } goto _19 @@ -130629,8 +130629,8 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i6 = i6 + 1 } - *(*int32)(unsafe.Pointer(parents + uintptr(i6)*4)) = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fsubmatch_id - *(*int32)(unsafe.Pointer(parents + uintptr(i6+int32(1))*4)) = -int32(1) + **(**int32)(__ccgo_up(parents + uintptr(i6)*4)) = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fsubmatch_id + **(**int32)(__ccgo_up(parents + uintptr(i6+int32(1))*4)) = -int32(1) } goto _10 /* end case: ADDTAGS_RECURSE */ _4: @@ -130678,7 +130678,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u will be restored at ADDTAGS_AFTER_UNION_RIGHT below. */ _21: ; - if !(*(*int32)(unsafe.Pointer(regset)) >= 0) { + if !(**(**int32)(__ccgo_up(regset)) >= 0) { goto _20 } regset += 4 @@ -130715,11 +130715,11 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u if (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fnum_submatches > 0 { if !(first_pass != 0) { status = _tre_add_tag_right(tls, mem, left2, tag_left) - *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag_left)*4)) = int32(_TRE_TAG_MAXIMIZE) + **(**Ttre_tag_direction_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag_left)*4)) = int32(_TRE_TAG_MAXIMIZE) if status == REG_OK { status = _tre_add_tag_right(tls, mem, right2, tag_right) } - *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag_right)*4)) = int32(_TRE_TAG_MAXIMIZE) + **(**Ttre_tag_direction_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag_right)*4)) = int32(_TRE_TAG_MAXIMIZE) } num_tags = num_tags + int32(2) } @@ -130737,7 +130737,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u if !(first_pass != 0) && minimal_tag >= 0 { i7 = 0 for { - if !(*(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7)*4)) >= 0) { break } goto _23 @@ -130745,9 +130745,9 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i7 = i7 + 1 } - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7)*4)) = tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7+int32(1))*4)) = minimal_tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7+int32(2))*4)) = -int32(1) + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7)*4)) = tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7+int32(1))*4)) = minimal_tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) num_minimals = num_minimals + 1 } @@ -130804,7 +130804,7 @@ func _tre_copy_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, flags i /* XXX - e.g. [ab] has only one position but two nodes, so we are creating holes in the state space here. Not fatal, just wastes memory. */ - pos = pos + *(*int32)(unsafe.Pointer(pos_add)) + pos = pos + **(**int32)(__ccgo_up(pos_add)) num_copied = num_copied + 1 } else { if (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min == int64(-int32(3)) && flags&int32(COPY_REMOVE_TAGS) != 0 { @@ -130816,30 +130816,30 @@ func _tre_copy_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, flags i } else { if (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min == int64(-int32(3)) && flags&int32(COPY_MAXIMIZE_FIRST_TAG) != 0 && first_tag != 0 { /* Maximize the first tag. */ - *(*Ttre_tag_direction_t)(unsafe.Pointer(tag_directions + uintptr(max)*4)) = int32(_TRE_TAG_MAXIMIZE) + **(**Ttre_tag_direction_t)(__ccgo_up(tag_directions + uintptr(max)*4)) = int32(_TRE_TAG_MAXIMIZE) first_tag = 0 } } } - *(*uintptr)(unsafe.Pointer(result)) = _tre_ast_new_literal(tls, mem, min, max, pos) - if *(*uintptr)(unsafe.Pointer(result)) == UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(result)) = _tre_ast_new_literal(tls, mem, min, max, pos) + if **(**uintptr)(__ccgo_up(result)) == UintptrFromInt32(0) { status = int32(REG_ESPACE) } else { - p = (*Ttre_ast_node_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(result)))).Fobj + p = (*Ttre_ast_node_t)(unsafe.Pointer(**(**uintptr)(__ccgo_up(result)))).Fobj (*Ttre_literal_t)(unsafe.Pointer(p)).Fclass = (*Ttre_literal_t)(unsafe.Pointer(lit)).Fclass (*Ttre_literal_t)(unsafe.Pointer(p)).Fneg_classes = (*Ttre_literal_t)(unsafe.Pointer(lit)).Fneg_classes } - if pos > *(*int32)(unsafe.Pointer(max_pos)) { - *(*int32)(unsafe.Pointer(max_pos)) = pos + if pos > **(**int32)(__ccgo_up(max_pos)) { + **(**int32)(__ccgo_up(max_pos)) = pos } case int32(_UNION): uni = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj - *(*uintptr)(unsafe.Pointer(result)) = _tre_ast_new_union(tls, mem, (*Ttre_union_t)(unsafe.Pointer(uni)).Fleft, (*Ttre_union_t)(unsafe.Pointer(uni)).Fright) - if *(*uintptr)(unsafe.Pointer(result)) == UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(result)) = _tre_ast_new_union(tls, mem, (*Ttre_union_t)(unsafe.Pointer(uni)).Fleft, (*Ttre_union_t)(unsafe.Pointer(uni)).Fright) + if **(**uintptr)(__ccgo_up(result)) == UintptrFromInt32(0) { status = int32(REG_ESPACE) break } - tmp = (*Ttre_ast_node_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(result)))).Fobj + tmp = (*Ttre_ast_node_t)(unsafe.Pointer(**(**uintptr)(__ccgo_up(result)))).Fobj result = tmp status = _tre_stack_push_voidptr(tls, stack, (*Ttre_union_t)(unsafe.Pointer(uni)).Fright) if status != REG_OK { @@ -130867,12 +130867,12 @@ func _tre_copy_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, flags i } case int32(_CATENATION): cat = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj - *(*uintptr)(unsafe.Pointer(result)) = _tre_ast_new_catenation(tls, mem, (*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft, (*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright) - if *(*uintptr)(unsafe.Pointer(result)) == UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(result)) = _tre_ast_new_catenation(tls, mem, (*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft, (*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright) + if **(**uintptr)(__ccgo_up(result)) == UintptrFromInt32(0) { status = int32(REG_ESPACE) break } - tmp1 = (*Ttre_ast_node_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(result)))).Fobj + tmp1 = (*Ttre_ast_node_t)(unsafe.Pointer(**(**uintptr)(__ccgo_up(result)))).Fobj (*Ttre_catenation_t)(unsafe.Pointer(tmp1)).Fleft = UintptrFromInt32(0) (*Ttre_catenation_t)(unsafe.Pointer(tmp1)).Fright = UintptrFromInt32(0) result = tmp1 @@ -130910,12 +130910,12 @@ func _tre_copy_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, flags i if status != REG_OK { break } - *(*uintptr)(unsafe.Pointer(result)) = _tre_ast_new_iter(tls, mem, (*Ttre_iteration_t)(unsafe.Pointer(iter)).Farg, (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmin, (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmax, int32(uint32(*(*uint8)(unsafe.Pointer(iter + 16))&0x1>>0))) - if *(*uintptr)(unsafe.Pointer(result)) == UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(result)) = _tre_ast_new_iter(tls, mem, (*Ttre_iteration_t)(unsafe.Pointer(iter)).Farg, (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmin, (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmax, int32(uint32(*(*uint8)(unsafe.Pointer(iter + 16))&0x1>>0))) + if **(**uintptr)(__ccgo_up(result)) == UintptrFromInt32(0) { status = int32(REG_ESPACE) break } - iter = (*Ttre_ast_node_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(result)))).Fobj + iter = (*Ttre_ast_node_t)(unsafe.Pointer(**(**uintptr)(__ccgo_up(result)))).Fobj result = iter default: break @@ -130923,7 +130923,7 @@ func _tre_copy_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, flags i break } } - *(*int32)(unsafe.Pointer(pos_add)) += num_copied + **(**int32)(__ccgo_up(pos_add)) += num_copied return status } @@ -130951,9 +130951,9 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _status, _status1, bottom, cat, flags, iter, iter1, iter_depth, j, lit, node, pos_add_last, pos_add_save, pos_add_total, seq1, status, symbol, tmp, uni, v2 status = REG_OK bottom = _tre_stack_num_objects(tls, stack) - *(*int32)(unsafe.Pointer(bp)) = 0 + **(**int32)(__ccgo_up(bp)) = 0 pos_add_total = 0 - *(*int32)(unsafe.Pointer(bp + 4)) = 0 + **(**int32)(__ccgo_up(bp + 4)) = 0 iter_depth = 0 _status = _tre_stack_push_voidptr(tls, stack, ast) if _status != REG_OK { @@ -130975,9 +130975,9 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit case int32(_LITERAL): lit = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj if !((*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min < Int64FromInt32(0)) || (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min == int64(-int32(4)) { - *(*int32)(unsafe.Pointer(lit + 16)) += *(*int32)(unsafe.Pointer(bp)) - if (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition > *(*int32)(unsafe.Pointer(bp + 4)) { - *(*int32)(unsafe.Pointer(bp + 4)) = (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition + **(**int32)(__ccgo_up(lit + 16)) += **(**int32)(__ccgo_up(bp)) + if (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition > **(**int32)(__ccgo_up(bp + 4)) { + **(**int32)(__ccgo_up(bp + 4)) = (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition } } case int32(_UNION): @@ -131018,7 +131018,7 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit } case int32(_ITERATION): iter = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj - status = _tre_stack_push_int(tls, stack, *(*int32)(unsafe.Pointer(bp))) + status = _tre_stack_push_int(tls, stack, **(**int32)(__ccgo_up(bp))) if status != REG_OK { break } @@ -131042,7 +131042,7 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit then don't increase the `pos' fields of the nodes now, it will get done when expanding. */ if (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmin > int32(1) || (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmax > int32(1) { - *(*int32)(unsafe.Pointer(bp)) = 0 + **(**int32)(__ccgo_up(bp)) = 0 } iter_depth = iter_depth + 1 default: @@ -131050,12 +131050,12 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit } case int32(_EXPAND_AFTER_ITER): iter1 = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj - *(*int32)(unsafe.Pointer(bp)) = _tre_stack_pop_int(tls, stack) - pos_add_last = *(*int32)(unsafe.Pointer(bp)) + **(**int32)(__ccgo_up(bp)) = _tre_stack_pop_int(tls, stack) + pos_add_last = **(**int32)(__ccgo_up(bp)) if (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Fmin > int32(1) || (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Fmax > int32(1) { seq1 = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(bp + 8)) = UintptrFromInt32(0) - pos_add_save = *(*int32)(unsafe.Pointer(bp)) + **(**uintptr)(__ccgo_up(bp + 8)) = UintptrFromInt32(0) + pos_add_save = **(**int32)(__ccgo_up(bp)) /* Create a catenated sequence of copies of the node. */ j = 0 for { @@ -131069,15 +131069,15 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit } /* Remove tags from all but the last copy. */ flags = v2 - pos_add_save = *(*int32)(unsafe.Pointer(bp)) + pos_add_save = **(**int32)(__ccgo_up(bp)) status = _tre_copy_ast(tls, mem, stack, (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Farg, flags, bp, tag_directions, bp+16, bp+4) if status != REG_OK { return status } if seq1 != UintptrFromInt32(0) { - seq1 = _tre_ast_new_catenation(tls, mem, seq1, *(*uintptr)(unsafe.Pointer(bp + 16))) + seq1 = _tre_ast_new_catenation(tls, mem, seq1, **(**uintptr)(__ccgo_up(bp + 16))) } else { - seq1 = *(*uintptr)(unsafe.Pointer(bp + 16)) + seq1 = **(**uintptr)(__ccgo_up(bp + 16)) } if seq1 == UintptrFromInt32(0) { return int32(REG_ESPACE) @@ -131089,13 +131089,13 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit } if (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Fmax == -int32(1) { /* No upper limit. */ - pos_add_save = *(*int32)(unsafe.Pointer(bp)) + pos_add_save = **(**int32)(__ccgo_up(bp)) status = _tre_copy_ast(tls, mem, stack, (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Farg, 0, bp, UintptrFromInt32(0), bp+8, bp+4) if status != REG_OK { return status } - *(*uintptr)(unsafe.Pointer(bp + 8)) = _tre_ast_new_iter(tls, mem, *(*uintptr)(unsafe.Pointer(bp + 8)), 0, -int32(1), 0) - if *(*uintptr)(unsafe.Pointer(bp + 8)) == UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(bp + 8)) = _tre_ast_new_iter(tls, mem, **(**uintptr)(__ccgo_up(bp + 8)), 0, -int32(1), 0) + if **(**uintptr)(__ccgo_up(bp + 8)) == UintptrFromInt32(0) { return int32(REG_ESPACE) } } else { @@ -131104,25 +131104,25 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit if !(j < (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Fmax) { break } - pos_add_save = *(*int32)(unsafe.Pointer(bp)) + pos_add_save = **(**int32)(__ccgo_up(bp)) status = _tre_copy_ast(tls, mem, stack, (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Farg, 0, bp, UintptrFromInt32(0), bp+24, bp+4) if status != REG_OK { return status } - if *(*uintptr)(unsafe.Pointer(bp + 8)) != UintptrFromInt32(0) { - *(*uintptr)(unsafe.Pointer(bp + 8)) = _tre_ast_new_catenation(tls, mem, *(*uintptr)(unsafe.Pointer(bp + 24)), *(*uintptr)(unsafe.Pointer(bp + 8))) + if **(**uintptr)(__ccgo_up(bp + 8)) != UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(bp + 8)) = _tre_ast_new_catenation(tls, mem, **(**uintptr)(__ccgo_up(bp + 24)), **(**uintptr)(__ccgo_up(bp + 8))) } else { - *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 24)) + **(**uintptr)(__ccgo_up(bp + 8)) = **(**uintptr)(__ccgo_up(bp + 24)) } - if *(*uintptr)(unsafe.Pointer(bp + 8)) == UintptrFromInt32(0) { + if **(**uintptr)(__ccgo_up(bp + 8)) == UintptrFromInt32(0) { return int32(REG_ESPACE) } tmp = _tre_ast_new_literal(tls, mem, -int32(1), -int32(1), -int32(1)) if tmp == UintptrFromInt32(0) { return int32(REG_ESPACE) } - *(*uintptr)(unsafe.Pointer(bp + 8)) = _tre_ast_new_union(tls, mem, tmp, *(*uintptr)(unsafe.Pointer(bp + 8))) - if *(*uintptr)(unsafe.Pointer(bp + 8)) == UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(bp + 8)) = _tre_ast_new_union(tls, mem, tmp, **(**uintptr)(__ccgo_up(bp + 8))) + if **(**uintptr)(__ccgo_up(bp + 8)) == UintptrFromInt32(0) { return int32(REG_ESPACE) } goto _3 @@ -131131,12 +131131,12 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit j = j + 1 } } - *(*int32)(unsafe.Pointer(bp)) = pos_add_save + **(**int32)(__ccgo_up(bp)) = pos_add_save if seq1 == UintptrFromInt32(0) { - seq1 = *(*uintptr)(unsafe.Pointer(bp + 8)) + seq1 = **(**uintptr)(__ccgo_up(bp + 8)) } else { - if *(*uintptr)(unsafe.Pointer(bp + 8)) != UintptrFromInt32(0) { - seq1 = _tre_ast_new_catenation(tls, mem, seq1, *(*uintptr)(unsafe.Pointer(bp + 8))) + if **(**uintptr)(__ccgo_up(bp + 8)) != UintptrFromInt32(0) { + seq1 = _tre_ast_new_catenation(tls, mem, seq1, **(**uintptr)(__ccgo_up(bp + 8))) } } if seq1 == UintptrFromInt32(0) { @@ -131146,21 +131146,21 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit (*Ttre_ast_node_t)(unsafe.Pointer(node)).Ftype1 = (*Ttre_ast_node_t)(unsafe.Pointer(seq1)).Ftype1 } iter_depth = iter_depth - 1 - pos_add_total = pos_add_total + (*(*int32)(unsafe.Pointer(bp)) - pos_add_last) + pos_add_total = pos_add_total + (**(**int32)(__ccgo_up(bp)) - pos_add_last) if iter_depth == 0 { - *(*int32)(unsafe.Pointer(bp)) = pos_add_total + **(**int32)(__ccgo_up(bp)) = pos_add_total } default: break } } - *(*int32)(unsafe.Pointer(position)) += pos_add_total + **(**int32)(__ccgo_up(position)) += pos_add_total /* `max_pos' should never be larger than `*position' if the above code works, but just an extra safeguard let's make sure `*position' is set large enough so enough memory will be allocated for the transition table. */ - if *(*int32)(unsafe.Pointer(bp + 4)) > *(*int32)(unsafe.Pointer(position)) { - *(*int32)(unsafe.Pointer(position)) = *(*int32)(unsafe.Pointer(bp + 4)) + if **(**int32)(__ccgo_up(bp + 4)) > **(**int32)(__ccgo_up(position)) { + **(**int32)(__ccgo_up(position)) = **(**int32)(__ccgo_up(bp + 4)) } return status } @@ -131172,9 +131172,9 @@ func _tre_set_empty(tls *TLS, mem Ttre_mem_t) (r uintptr) { if new_set == UintptrFromInt32(0) { return UintptrFromInt32(0) } - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fposition = -int32(1) - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fcode_min = -int32(1) - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fcode_max = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fposition = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fcode_min = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fcode_max = -int32(1) return new_set } @@ -131185,15 +131185,15 @@ func _tre_set_one(tls *TLS, mem Ttre_mem_t, position int32, code_min int32, code if new_set == UintptrFromInt32(0) { return UintptrFromInt32(0) } - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fposition = position - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fcode_min = code_min - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fcode_max = code_max - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fclass = class - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fneg_classes = neg_classes - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fbackref = backref - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + 1*56))).Fposition = -int32(1) - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + 1*56))).Fcode_min = -int32(1) - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + 1*56))).Fcode_max = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fposition = position + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fcode_min = code_min + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fcode_max = code_max + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fclass = class + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fneg_classes = neg_classes + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fbackref = backref + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + 1*56))).Fposition = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + 1*56))).Fcode_min = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + 1*56))).Fcode_max = -int32(1) return new_set } @@ -131203,7 +131203,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u _, _, _, _, _, _, _ = i, j, new_set, new_tags, num_tags, s1, s2 num_tags = 0 for { - if !(tags != UintptrFromInt32(0) && *(*int32)(unsafe.Pointer(tags + uintptr(num_tags)*4)) >= 0) { + if !(tags != UintptrFromInt32(0) && **(**int32)(__ccgo_up(tags + uintptr(num_tags)*4)) >= 0) { break } goto _1 @@ -131213,7 +131213,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u } s1 = 0 for { - if !((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fposition >= 0) { + if !((**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fposition >= 0) { break } goto _2 @@ -131223,7 +131223,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u } s2 = 0 for { - if !((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fposition >= 0) { + if !((**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fposition >= 0) { break } goto _3 @@ -131237,22 +131237,22 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u } s1 = 0 for { - if !((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fposition >= 0) { + if !((**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fposition >= 0) { break } - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Fposition = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fposition - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Fcode_min = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fcode_min - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Fcode_max = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fcode_max - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Fassertions = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fassertions | assertions - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Fclass = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fclass - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Fneg_classes = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fneg_classes - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Fbackref = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fbackref - if (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Ftags == UintptrFromInt32(0) && tags == UintptrFromInt32(0) { - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Ftags = UintptrFromInt32(0) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Fposition = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fposition + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Fcode_min = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fcode_min + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Fcode_max = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fcode_max + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Fassertions = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fassertions | assertions + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Fclass = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fclass + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Fneg_classes = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fneg_classes + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Fbackref = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fbackref + if (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Ftags == UintptrFromInt32(0) && tags == UintptrFromInt32(0) { + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Ftags = UintptrFromInt32(0) } else { i = 0 for { - if !((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Ftags != UintptrFromInt32(0) && *(*int32)(unsafe.Pointer((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Ftags + uintptr(i)*4)) >= 0) { + if !((**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Ftags != UintptrFromInt32(0) && **(**int32)(__ccgo_up((**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Ftags + uintptr(i)*4)) >= 0) { break } goto _5 @@ -131269,7 +131269,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u if !(j < i) { break } - *(*int32)(unsafe.Pointer(new_tags + uintptr(j)*4)) = *(*int32)(unsafe.Pointer((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Ftags + uintptr(j)*4)) + **(**int32)(__ccgo_up(new_tags + uintptr(j)*4)) = **(**int32)(__ccgo_up((**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Ftags + uintptr(j)*4)) goto _6 _6: ; @@ -131280,14 +131280,14 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u if !(i < num_tags) { break } - *(*int32)(unsafe.Pointer(new_tags + uintptr(j+i)*4)) = *(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) + **(**int32)(__ccgo_up(new_tags + uintptr(j+i)*4)) = **(**int32)(__ccgo_up(tags + uintptr(i)*4)) goto _7 _7: ; i = i + 1 } - *(*int32)(unsafe.Pointer(new_tags + uintptr(j+i)*4)) = -int32(1) - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Ftags = new_tags + **(**int32)(__ccgo_up(new_tags + uintptr(j+i)*4)) = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Ftags = new_tags } goto _4 _4: @@ -131296,23 +131296,23 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u } s2 = 0 for { - if !((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fposition >= 0) { + if !((**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fposition >= 0) { break } - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fposition = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fposition - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fcode_min = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fcode_min - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fcode_max = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fcode_max + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Fposition = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fposition + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Fcode_min = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fcode_min + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Fcode_max = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fcode_max /* XXX - why not | assertions here as well? */ - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fassertions = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fassertions - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fclass = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fclass - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fneg_classes = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fneg_classes - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fbackref = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fbackref - if (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Ftags == UintptrFromInt32(0) { - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Ftags = UintptrFromInt32(0) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Fassertions = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fassertions + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Fclass = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fclass + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Fneg_classes = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fneg_classes + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Fbackref = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fbackref + if (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Ftags == UintptrFromInt32(0) { + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Ftags = UintptrFromInt32(0) } else { i = 0 for { - if !(*(*int32)(unsafe.Pointer((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Ftags + uintptr(i)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Ftags + uintptr(i)*4)) >= 0) { break } goto _9 @@ -131329,21 +131329,21 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u if !(j < i) { break } - *(*int32)(unsafe.Pointer(new_tags + uintptr(j)*4)) = *(*int32)(unsafe.Pointer((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Ftags + uintptr(j)*4)) + **(**int32)(__ccgo_up(new_tags + uintptr(j)*4)) = **(**int32)(__ccgo_up((**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Ftags + uintptr(j)*4)) goto _10 _10: ; j = j + 1 } - *(*int32)(unsafe.Pointer(new_tags + uintptr(j)*4)) = -int32(1) - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Ftags = new_tags + **(**int32)(__ccgo_up(new_tags + uintptr(j)*4)) = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Ftags = new_tags } goto _8 _8: ; s2 = s2 + 1 } - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fposition = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Fposition = -int32(1) return new_set } @@ -131361,7 +131361,7 @@ func _tre_match_empty(tls *TLS, stack uintptr, node uintptr, tags uintptr, asser bottom = _tre_stack_num_objects(tls, stack) status = REG_OK if num_tags_seen != 0 { - *(*int32)(unsafe.Pointer(num_tags_seen)) = 0 + **(**int32)(__ccgo_up(num_tags_seen)) = 0 } status = _tre_stack_push_voidptr(tls, stack, node) /* Walk through the tree recursively. */ @@ -131377,10 +131377,10 @@ func _tre_match_empty(tls *TLS, stack uintptr, node uintptr, tags uintptr, asser /* Add the tag to `tags'. */ i = 0 for { - if !(*(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(tags + uintptr(i)*4)) >= 0) { break } - if int64(*(*int32)(unsafe.Pointer(tags + uintptr(i)*4))) == (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max { + if int64(**(**int32)(__ccgo_up(tags + uintptr(i)*4))) == (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max { break } goto _1 @@ -131388,13 +131388,13 @@ func _tre_match_empty(tls *TLS, stack uintptr, node uintptr, tags uintptr, asser ; i = i + 1 } - if *(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) < 0 { - *(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) = int32((*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max) - *(*int32)(unsafe.Pointer(tags + uintptr(i+int32(1))*4)) = -int32(1) + if **(**int32)(__ccgo_up(tags + uintptr(i)*4)) < 0 { + **(**int32)(__ccgo_up(tags + uintptr(i)*4)) = int32((*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max) + **(**int32)(__ccgo_up(tags + uintptr(i+int32(1))*4)) = -int32(1) } } if num_tags_seen != 0 { - *(*int32)(unsafe.Pointer(num_tags_seen)) = *(*int32)(unsafe.Pointer(num_tags_seen)) + 1 + **(**int32)(__ccgo_up(num_tags_seen)) = **(**int32)(__ccgo_up(num_tags_seen)) + 1 } } case int64(-int32(2)): @@ -131638,12 +131638,12 @@ func _tre_compute_nfl(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr) (r return status } /* Allocate arrays for the tags and parameters. */ - tags = Xmalloc(tls, uint64(4)*Uint64FromInt32(*(*int32)(unsafe.Pointer(bp))+Int32FromInt32(1))) + tags = Xmalloc(tls, uint64(4)*Uint64FromInt32(**(**int32)(__ccgo_up(bp))+Int32FromInt32(1))) if !(tags != 0) { return int32(REG_ESPACE) } - *(*int32)(unsafe.Pointer(tags)) = -int32(1) - *(*int32)(unsafe.Pointer(bp + 4)) = 0 + **(**int32)(__ccgo_up(tags)) = -int32(1) + **(**int32)(__ccgo_up(bp + 4)) = 0 /* Second pass with tre_mach_empty() to get the list of tags and parameters. */ status = _tre_match_empty(tls, stack, (*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft, tags, bp+4, UintptrFromInt32(0)) @@ -131651,7 +131651,7 @@ func _tre_compute_nfl(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr) (r Xfree(tls, tags) return status } - (*Ttre_ast_node_t)(unsafe.Pointer(node)).Ffirstpos = _tre_set_union(tls, mem, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright)).Ffirstpos, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft)).Ffirstpos, tags, *(*int32)(unsafe.Pointer(bp + 4))) + (*Ttre_ast_node_t)(unsafe.Pointer(node)).Ffirstpos = _tre_set_union(tls, mem, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright)).Ffirstpos, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft)).Ffirstpos, tags, **(**int32)(__ccgo_up(bp + 4))) Xfree(tls, tags) if !((*Ttre_ast_node_t)(unsafe.Pointer(node)).Ffirstpos != 0) { return int32(REG_ESPACE) @@ -131669,12 +131669,12 @@ func _tre_compute_nfl(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr) (r return status } /* Allocate arrays for the tags and parameters. */ - tags = Xmalloc(tls, uint64(4)*Uint64FromInt32(*(*int32)(unsafe.Pointer(bp))+Int32FromInt32(1))) + tags = Xmalloc(tls, uint64(4)*Uint64FromInt32(**(**int32)(__ccgo_up(bp))+Int32FromInt32(1))) if !(tags != 0) { return int32(REG_ESPACE) } - *(*int32)(unsafe.Pointer(tags)) = -int32(1) - *(*int32)(unsafe.Pointer(bp + 4)) = 0 + **(**int32)(__ccgo_up(tags)) = -int32(1) + **(**int32)(__ccgo_up(bp + 4)) = 0 /* Second pass with tre_mach_empty() to get the list of tags and parameters. */ status = _tre_match_empty(tls, stack, (*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright, tags, bp+4, UintptrFromInt32(0)) @@ -131682,7 +131682,7 @@ func _tre_compute_nfl(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr) (r Xfree(tls, tags) return status } - (*Ttre_ast_node_t)(unsafe.Pointer(node)).Flastpos = _tre_set_union(tls, mem, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft)).Flastpos, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright)).Flastpos, tags, *(*int32)(unsafe.Pointer(bp + 4))) + (*Ttre_ast_node_t)(unsafe.Pointer(node)).Flastpos = _tre_set_union(tls, mem, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft)).Flastpos, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright)).Flastpos, tags, **(**int32)(__ccgo_up(bp + 4))) Xfree(tls, tags) if !((*Ttre_ast_node_t)(unsafe.Pointer(node)).Flastpos != 0) { return int32(REG_ESPACE) @@ -131718,7 +131718,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun prev_p2_pos = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fposition /* Set `trans' to point to the next unused transition from position `p1->position'. */ - trans = transitions + uintptr(*(*int32)(unsafe.Pointer(offs + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)))*56 + trans = transitions + uintptr(**(**int32)(__ccgo_up(offs + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)))*56 for (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fstate != UintptrFromInt32(0) { trans += 56 } @@ -131729,7 +131729,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun the transition from `p1' to `p2'. */ (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fcode_min = Uint32FromInt32((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fcode_min) (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fcode_max = Uint32FromInt32((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fcode_max) - (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fstate = transitions + uintptr(*(*int32)(unsafe.Pointer(offs + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fposition)*4)))*56 + (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fstate = transitions + uintptr(**(**int32)(__ccgo_up(offs + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fposition)*4)))*56 (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fstate_id = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fposition if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fclass != 0 { v1 = int32(ASSERT_CHAR_CLASS) @@ -131744,14 +131744,14 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fassertions = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fassertions | (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fassertions | v1 | v2 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fbackref >= 0 { *(*int32)(unsafe.Pointer(&(*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fu)) = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fbackref - *(*int32)(unsafe.Pointer(trans + 32)) |= int32(ASSERT_BACKREF) + **(**int32)(__ccgo_up(trans + 32)) |= int32(ASSERT_BACKREF) } else { *(*Ttre_ctype_t)(unsafe.Pointer(trans + 40)) = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fclass } if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes != UintptrFromInt32(0) { i = 0 for { - if !(*(*Ttre_ctype_t)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes + uintptr(i)*8)) != Uint64FromInt32(0)) { + if !(**(**Ttre_ctype_t)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes + uintptr(i)*8)) != Uint64FromInt32(0)) { break } goto _3 @@ -131765,29 +131765,29 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun } i = 0 for { - if !(*(*Ttre_ctype_t)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes + uintptr(i)*8)) != Uint64FromInt32(0)) { + if !(**(**Ttre_ctype_t)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes + uintptr(i)*8)) != Uint64FromInt32(0)) { break } - *(*Ttre_ctype_t)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes + uintptr(i)*8)) = *(*Ttre_ctype_t)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes + uintptr(i)*8)) + **(**Ttre_ctype_t)(__ccgo_up((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes + uintptr(i)*8)) = **(**Ttre_ctype_t)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes + uintptr(i)*8)) goto _4 _4: ; i = i + 1 } - *(*Ttre_ctype_t)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes + uintptr(i)*8)) = Uint64FromInt32(0) + **(**Ttre_ctype_t)(__ccgo_up((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes + uintptr(i)*8)) = Uint64FromInt32(0) } else { (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes = UintptrFromInt32(0) } /* Find out how many tags this transition has. */ i = 0 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags != UintptrFromInt32(0) { - for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) >= 0 { + for **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) >= 0 { i = i + 1 } } j = 0 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags != UintptrFromInt32(0) { - for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) >= 0 { + for **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) >= 0 { j = j + 1 } } @@ -131804,15 +131804,15 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun } i = 0 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags != UintptrFromInt32(0) { - for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) >= 0 { - *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(i)*4)) = *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) + for **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) >= 0 { + **(**int32)(__ccgo_up((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(i)*4)) = **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) i = i + 1 } } l = i j = 0 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags != UintptrFromInt32(0) { - for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) >= 0 { + for **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) >= 0 { /* Don't add duplicates. */ dup = 0 k = 0 @@ -131820,7 +131820,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun if !(k < i) { break } - if *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(k)*4)) == *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) { + if **(**int32)(__ccgo_up((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(k)*4)) == **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) { dup = int32(1) break } @@ -131832,12 +131832,12 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun if !(dup != 0) { v1 = l l = l + 1 - *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(v1)*4)) = *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) + **(**int32)(__ccgo_up((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(v1)*4)) = **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) } j = j + 1 } } - *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(l)*4)) = -int32(1) + **(**int32)(__ccgo_up((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(l)*4)) = -int32(1) } p2 += 56 } @@ -131849,7 +131849,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun for (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition >= 0 { p2 = orig_p2 for (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fposition >= 0 { - *(*int32)(unsafe.Pointer(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)) = *(*int32)(unsafe.Pointer(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)) + 1 + **(**int32)(__ccgo_up(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)) = **(**int32)(__ccgo_up(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)) + 1 p2 += 56 } p1 += 56 @@ -131940,11 +131940,11 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { } /* Parse the regexp. */ Xmemset(tls, bp, 0, uint64(56)) - (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fmem = mem - (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fstack = stack - (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fstart = regex - (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fcflags = cflags - (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fmax_backref = -int32(1) + (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fmem = mem + (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fstack = stack + (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fstart = regex + (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fcflags = cflags + (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fmax_backref = -int32(1) errcode = _tre_parse(tls, bp) if errcode != REG_OK { errcode = errcode @@ -131952,10 +131952,10 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { goto error_exit } } - (*Tregex_t)(unsafe.Pointer(preg)).Fre_nsub = Uint64FromInt32((*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fsubmatch_id - int32(1)) - tree = (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fn + (*Tregex_t)(unsafe.Pointer(preg)).Fre_nsub = Uint64FromInt32((**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fsubmatch_id - int32(1)) + tree = (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fn /* Referring to nonexistent subexpressions is illegal. */ - if (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fmax_backref > Int32FromUint64((*Tregex_t)(unsafe.Pointer(preg)).Fre_nsub) { + if (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fmax_backref > Int32FromUint64((*Tregex_t)(unsafe.Pointer(preg)).Fre_nsub) { errcode = int32(REG_ESUBREG) if int32(1) != 0 { goto error_exit @@ -131969,9 +131969,9 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { goto error_exit } } - (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fhave_backrefs = BoolInt32((*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fmax_backref >= 0) + (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fhave_backrefs = BoolInt32((**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fmax_backref >= 0) (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fhave_approx = 0 - (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches = Uint32FromInt32((*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fsubmatch_id) + (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches = Uint32FromInt32((**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fsubmatch_id) /* Set up tags for submatch addressing. If REG_NOSUB is set and the regexp does not have back references, this can be skipped. */ if (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fhave_backrefs != 0 || !(cflags&Int32FromInt32(REG_NOSUB) != 0) { @@ -132001,7 +132001,7 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { goto error_exit } } - submatch_data = Xcalloc(tls, uint64(Uint32FromInt32((*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fsubmatch_id)), uint64(16)) + submatch_data = Xcalloc(tls, uint64(Uint32FromInt32((**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fsubmatch_id)), uint64(16)) if submatch_data == UintptrFromInt32(0) { errcode = int32(REG_ESPACE) if int32(1) != 0 { @@ -132054,14 +132054,14 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { goto error_exit } } - counts = Xmalloc(tls, uint64(4)*Uint64FromInt32((*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fposition)) + counts = Xmalloc(tls, uint64(4)*Uint64FromInt32((**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fposition)) if counts == UintptrFromInt32(0) { errcode = int32(REG_ESPACE) if int32(1) != 0 { goto error_exit } } - offs = Xmalloc(tls, uint64(4)*Uint64FromInt32((*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fposition)) + offs = Xmalloc(tls, uint64(4)*Uint64FromInt32((**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fposition)) if offs == UintptrFromInt32(0) { errcode = int32(REG_ESPACE) if int32(1) != 0 { @@ -132070,10 +132070,10 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { } i = 0 for { - if !(i < (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fposition) { + if !(i < (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fposition) { break } - *(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) = 0 + **(**int32)(__ccgo_up(counts + uintptr(i)*4)) = 0 goto _3 _3: ; @@ -132083,12 +132083,12 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { add = 0 i = 0 for { - if !(i < (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fposition) { + if !(i < (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fposition) { break } - *(*int32)(unsafe.Pointer(offs + uintptr(i)*4)) = add - add = add + (*(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) + int32(1)) - *(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) = 0 + **(**int32)(__ccgo_up(offs + uintptr(i)*4)) = add + add = add + (**(**int32)(__ccgo_up(counts + uintptr(i)*4)) + int32(1)) + **(**int32)(__ccgo_up(counts + uintptr(i)*4)) = 0 goto _4 _4: ; @@ -132131,15 +132131,15 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { if !((*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fposition >= 0) { break } - (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Fstate = transitions + uintptr(*(*int32)(unsafe.Pointer(offs + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fposition)*4)))*56 - (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Fstate_id = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fposition - (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Ftags = UintptrFromInt32(0) + (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*56))).Fstate = transitions + uintptr(**(**int32)(__ccgo_up(offs + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fposition)*4)))*56 + (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*56))).Fstate_id = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fposition + (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*56))).Ftags = UintptrFromInt32(0) /* Copy the arrays p->tags, and p->params, they are allocated from a tre_mem object. */ if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Ftags != 0 { j = 0 for { - if !(*(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Ftags + uintptr(j)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Ftags + uintptr(j)*4)) >= 0) { break } goto _6 @@ -132147,26 +132147,26 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { ; j = j + 1 } - (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Ftags = Xmalloc(tls, uint64(4)*Uint64FromInt32(j+Int32FromInt32(1))) - if !((*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Ftags != 0) { + (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*56))).Ftags = Xmalloc(tls, uint64(4)*Uint64FromInt32(j+Int32FromInt32(1))) + if !((**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*56))).Ftags != 0) { errcode = int32(REG_ESPACE) if int32(1) != 0 { goto error_exit } } - Xmemcpy(tls, (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Ftags, (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Ftags, uint64(4)*Uint64FromInt32(j+Int32FromInt32(1))) + Xmemcpy(tls, (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*56))).Ftags, (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Ftags, uint64(4)*Uint64FromInt32(j+Int32FromInt32(1))) } - (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Fassertions = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fassertions + (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*56))).Fassertions = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fassertions i = i + 1 goto _5 _5: ; p += 56 } - (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Fstate = UintptrFromInt32(0) + (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*56))).Fstate = UintptrFromInt32(0) (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_transitions = Uint32FromInt32(add) - (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ffinal = transitions + uintptr(*(*int32)(unsafe.Pointer(offs + uintptr((*(*Ttre_pos_and_tags_t)(unsafe.Pointer((*Ttre_ast_node_t)(unsafe.Pointer(tree)).Flastpos))).Fposition)*4)))*56 - (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_states = (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fposition + (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ffinal = transitions + uintptr(**(**int32)(__ccgo_up(offs + uintptr((**(**Ttre_pos_and_tags_t)(__ccgo_up((*Ttre_ast_node_t)(unsafe.Pointer(tree)).Flastpos))).Fposition)*4)))*56 + (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_states = (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fposition (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags = cflags X__tre_mem_destroy(tls, mem) _tre_stack_destroy(tls, stack) @@ -132209,12 +132209,12 @@ func Xregfree(tls *TLS, preg uintptr) { if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_transitions) { break } - if (*(*Ttre_tnfa_transition_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Fstate != 0 { - if (*(*Ttre_tnfa_transition_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Ftags != 0 { - Xfree(tls, (*(*Ttre_tnfa_transition_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Ftags) + if (**(**Ttre_tnfa_transition_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Fstate != 0 { + if (**(**Ttre_tnfa_transition_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Ftags != 0 { + Xfree(tls, (**(**Ttre_tnfa_transition_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Ftags) } - if (*(*Ttre_tnfa_transition_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Fneg_classes != 0 { - Xfree(tls, (*(*Ttre_tnfa_transition_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Fneg_classes) + if (**(**Ttre_tnfa_transition_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Fneg_classes != 0 { + Xfree(tls, (**(**Ttre_tnfa_transition_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Fneg_classes) } } goto _1 @@ -132247,8 +132247,8 @@ func Xregfree(tls *TLS, preg uintptr) { if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches) { break } - if (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(i)*16))).Fparents != 0 { - Xfree(tls, (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(i)*16))).Fparents) + if (**(**Ttre_submatch_data_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(i)*16))).Fparents != 0 { + Xfree(tls, (**(**Ttre_submatch_data_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(i)*16))).Fparents) } goto _3 _3: @@ -132288,7 +132288,7 @@ func Xregerror(tls *TLS, e int32, preg uintptr, buf uintptr, size Tsize_t) (r Ts _ = s s = uintptr(unsafe.Pointer(&_messages)) for { - if !(e != 0 && *(*uint8)(unsafe.Pointer(s)) != 0) { + if !(e != 0 && **(**uint8)(__ccgo_up(s)) != 0) { break } goto _1 @@ -132297,7 +132297,7 @@ func Xregerror(tls *TLS, e int32, preg uintptr, buf uintptr, size Tsize_t) (r Ts e = e - 1 s = s + uintptr(_strlen(tls, s)+uint64(1)) } - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { s = s + 1 } s = X__lctrans_cur(tls, s) @@ -132323,18 +132323,18 @@ func _tre_tag_order(tls *TLS, num_tags int32, tag_directions uintptr, t1 uintptr if !(i < num_tags) { break } - if *(*Ttre_tag_direction_t)(unsafe.Pointer(tag_directions + uintptr(i)*4)) == int32(_TRE_TAG_MINIMIZE) { - if *(*Tregoff_t)(unsafe.Pointer(t1 + uintptr(i)*8)) < *(*Tregoff_t)(unsafe.Pointer(t2 + uintptr(i)*8)) { + if **(**Ttre_tag_direction_t)(__ccgo_up(tag_directions + uintptr(i)*4)) == int32(_TRE_TAG_MINIMIZE) { + if **(**Tregoff_t)(__ccgo_up(t1 + uintptr(i)*8)) < **(**Tregoff_t)(__ccgo_up(t2 + uintptr(i)*8)) { return int32(1) } - if *(*Tregoff_t)(unsafe.Pointer(t1 + uintptr(i)*8)) > *(*Tregoff_t)(unsafe.Pointer(t2 + uintptr(i)*8)) { + if **(**Tregoff_t)(__ccgo_up(t1 + uintptr(i)*8)) > **(**Tregoff_t)(__ccgo_up(t2 + uintptr(i)*8)) { return 0 } } else { - if *(*Tregoff_t)(unsafe.Pointer(t1 + uintptr(i)*8)) > *(*Tregoff_t)(unsafe.Pointer(t2 + uintptr(i)*8)) { + if **(**Tregoff_t)(__ccgo_up(t1 + uintptr(i)*8)) > **(**Tregoff_t)(__ccgo_up(t2 + uintptr(i)*8)) { return int32(1) } - if *(*Tregoff_t)(unsafe.Pointer(t1 + uintptr(i)*8)) < *(*Tregoff_t)(unsafe.Pointer(t2 + uintptr(i)*8)) { + if **(**Tregoff_t)(__ccgo_up(t1 + uintptr(i)*8)) < **(**Tregoff_t)(__ccgo_up(t2 + uintptr(i)*8)) { return 0 } } @@ -132348,8 +132348,8 @@ func _tre_tag_order(tls *TLS, num_tags int32, tag_directions uintptr, t1 uintptr } func _tre_neg_char_classes_match(tls *TLS, classes uintptr, wc Ttre_cint_t, icase int32) (r int32) { - for *(*Ttre_ctype_t)(unsafe.Pointer(classes)) != Uint64FromInt32(0) { - if !(icase != 0) && Xiswctype(tls, wc, *(*Ttre_ctype_t)(unsafe.Pointer(classes))) != 0 || icase != 0 && (Xiswctype(tls, Xtowupper(tls, wc), *(*Ttre_ctype_t)(unsafe.Pointer(classes))) != 0 || Xiswctype(tls, Xtowlower(tls, wc), *(*Ttre_ctype_t)(unsafe.Pointer(classes))) != 0) { + for **(**Ttre_ctype_t)(__ccgo_up(classes)) != Uint64FromInt32(0) { + if !(icase != 0) && Xiswctype(tls, wc, **(**Ttre_ctype_t)(__ccgo_up(classes))) != 0 || icase != 0 && (Xiswctype(tls, Xtowupper(tls, wc), **(**Ttre_ctype_t)(__ccgo_up(classes))) != 0 || Xiswctype(tls, Xtowlower(tls, wc), **(**Ttre_ctype_t)(__ccgo_up(classes))) != 0) { return int32(1) } else { classes += 8 @@ -132402,7 +132402,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = buf, end, i, match_eo, new_match, num_tags, pbytes, pos, pos_add_next, prev_c, rbytes, reach, reach_i, reach_next, reach_next_i, reach_pos, reg_newline, reg_notbol, reg_noteol, ret, skip, start, str_byte, tag_i, tbytes, tmp_buf, tmp_iptr, tmp_tags, total_bytes, trans_i, xbytes, v1, v18, v7 /* State variables required by GET_NEXT_WCHAR. */ prev_c = 0 - *(*Ttre_char_t)(unsafe.Pointer(bp)) = 0 + **(**Ttre_char_t)(__ccgo_up(bp)) = 0 str_byte = string1 pos = int64(-int32(1)) pos_add_next = int64(1) @@ -132482,9 +132482,9 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_states) { break } - (*(*Ttre_tnfa_reach_t)(unsafe.Pointer(reach + uintptr(i)*16))).Ftags = tmp_buf + (**(**Ttre_tnfa_reach_t)(__ccgo_up(reach + uintptr(i)*16))).Ftags = tmp_buf tmp_buf = tmp_buf + uintptr(xbytes) - (*(*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next + uintptr(i)*16))).Ftags = tmp_buf + (**(**Ttre_tnfa_reach_t)(__ccgo_up(reach_next + uintptr(i)*16))).Ftags = tmp_buf tmp_buf = tmp_buf + uintptr(xbytes) goto _5 _5: @@ -132496,13 +132496,13 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_states) { break } - (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr(i)*16))).Fpos = int64(-int32(1)) + (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr(i)*16))).Fpos = int64(-int32(1)) goto _6 _6: ; i = i + 1 } - prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + prev_c = **(**Ttre_char_t)(__ccgo_up(bp)) pos = pos + pos_add_next v7 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) pos_add_next = v7 @@ -132522,8 +132522,8 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if match_eo < 0 { trans_i = (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Finitial for (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate != UintptrFromInt32(0) { - if (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos < pos { - if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\000') || reg_noteol != 0) && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0 || !(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) || (*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && *(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\000') && BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) == BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || *(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('\000') || BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) != BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0))) { + if (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos < pos { + if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (**(**Ttre_char_t)(__ccgo_up(bp)) != int32('\000') || reg_noteol != 0) && (**(**Ttre_char_t)(__ccgo_up(bp)) != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0 || !(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) || (**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && **(**Ttre_char_t)(__ccgo_up(bp)) != int32('\000') && BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) == BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || **(**Ttre_char_t)(__ccgo_up(bp)) == int32('\000') || BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) != BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0))) { trans_i += 56 continue } @@ -132533,7 +132533,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < num_tags) { break } - *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(i)*8)) = int64(-int32(1)) + **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(i)*8)) = int64(-int32(1)) goto _8 _8: ; @@ -132541,9 +132541,9 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags } tag_i = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags if tag_i != 0 { - for *(*int32)(unsafe.Pointer(tag_i)) >= 0 { - if *(*int32)(unsafe.Pointer(tag_i)) < num_tags { - *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(*(*int32)(unsafe.Pointer(tag_i)))*8)) = pos + for **(**int32)(__ccgo_up(tag_i)) >= 0 { + if **(**int32)(__ccgo_up(tag_i)) < num_tags { + **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(**(**int32)(__ccgo_up(tag_i)))*8)) = pos } tag_i += 4 } @@ -132556,15 +132556,15 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < num_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(i)*8)) = *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(i)*8)) + **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(i)*8)) = **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(i)*8)) goto _9 _9: ; i = i + 1 } } - (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos = pos - (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags = reach_next_i + 8 + (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos = pos + (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags = reach_next_i + 8 reach_next_i += 16 } trans_i += 56 @@ -132577,10 +132577,10 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags } } /* Check for end of string. */ - if !(*(*Ttre_char_t)(unsafe.Pointer(bp)) != 0) { + if !(**(**Ttre_char_t)(__ccgo_up(bp)) != 0) { break } - prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + prev_c = **(**Ttre_char_t)(__ccgo_up(bp)) pos = pos + pos_add_next v7 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) pos_add_next = v7 @@ -132610,16 +132610,16 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags skip = 0 i = 0 for { - if !(*(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i)*4)) >= 0) { break } - end = *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i)*4)) - start = *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i+int32(1))*4)) + end = **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i)*4)) + start = **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i+int32(1))*4)) if end >= num_tags { skip = int32(1) break } else { - if *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Ftags + uintptr(start)*8)) == *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(start)*8)) && *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Ftags + uintptr(end)*8)) < *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(end)*8)) { + if **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Ftags + uintptr(start)*8)) == **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(start)*8)) && **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Ftags + uintptr(end)*8)) < **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(end)*8)) { skip = int32(1) break } @@ -132663,7 +132663,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags } /* Does this transition match the input symbol? */ if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fcode_min <= Uint32FromInt32(prev_c) && (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fcode_max >= Uint32FromInt32(prev_c) { - if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\000') || reg_noteol != 0) && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0 || !(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) || (*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && *(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\000') && BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) == BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || *(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('\000') || BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) != BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && !((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&Int32FromInt32(REG_ICASE) != 0) && !(Xiswctype(tls, Uint32FromInt32(prev_c), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE) != 0 && !(Xiswctype(tls, Xtowlower(tls, Uint32FromInt32(prev_c)), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) && !(Xiswctype(tls, Xtowupper(tls, Uint32FromInt32(prev_c)), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS_NEG) != 0 && _tre_neg_char_classes_match(tls, (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fneg_classes, Uint32FromInt32(prev_c), (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE)) != 0)) { + if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (**(**Ttre_char_t)(__ccgo_up(bp)) != int32('\000') || reg_noteol != 0) && (**(**Ttre_char_t)(__ccgo_up(bp)) != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0 || !(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) || (**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && **(**Ttre_char_t)(__ccgo_up(bp)) != int32('\000') && BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) == BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || **(**Ttre_char_t)(__ccgo_up(bp)) == int32('\000') || BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) != BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && !((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&Int32FromInt32(REG_ICASE) != 0) && !(Xiswctype(tls, Uint32FromInt32(prev_c), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE) != 0 && !(Xiswctype(tls, Xtowlower(tls, Uint32FromInt32(prev_c)), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) && !(Xiswctype(tls, Xtowupper(tls, Uint32FromInt32(prev_c)), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS_NEG) != 0 && _tre_neg_char_classes_match(tls, (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fneg_classes, Uint32FromInt32(prev_c), (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE)) != 0)) { goto _14 } /* Compute the tags after this transition. */ @@ -132672,7 +132672,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < num_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(tmp_tags + uintptr(i)*8)) = *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Ftags + uintptr(i)*8)) + **(**Tregoff_t)(__ccgo_up(tmp_tags + uintptr(i)*8)) = **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Ftags + uintptr(i)*8)) goto _15 _15: ; @@ -132680,22 +132680,22 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags } tag_i = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags if tag_i != UintptrFromInt32(0) { - for *(*int32)(unsafe.Pointer(tag_i)) >= 0 { - if *(*int32)(unsafe.Pointer(tag_i)) < num_tags { - *(*Tregoff_t)(unsafe.Pointer(tmp_tags + uintptr(*(*int32)(unsafe.Pointer(tag_i)))*8)) = pos + for **(**int32)(__ccgo_up(tag_i)) >= 0 { + if **(**int32)(__ccgo_up(tag_i)) < num_tags { + **(**Tregoff_t)(__ccgo_up(tmp_tags + uintptr(**(**int32)(__ccgo_up(tag_i)))*8)) = pos } tag_i += 4 } } - if (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos < pos { + if (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos < pos { /* Found an unvisited node. */ (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Fstate = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate tmp_iptr = (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags = tmp_tags tmp_tags = tmp_iptr - (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos = pos - (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags = reach_next_i + 8 - if (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Fstate == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ffinal && (match_eo == int64(-int32(1)) || num_tags > 0 && *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags)) <= *(*Tregoff_t)(unsafe.Pointer(match_tags))) { + (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos = pos + (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags = reach_next_i + 8 + if (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Fstate == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ffinal && (match_eo == int64(-int32(1)) || num_tags > 0 && **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags)) <= **(**Tregoff_t)(__ccgo_up(match_tags))) { match_eo = pos new_match = int32(1) i = 0 @@ -132703,7 +132703,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < num_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(i)*8)) = *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(i)*8)) + **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(i)*8)) = **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(i)*8)) goto _16 _16: ; @@ -132715,10 +132715,10 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags /* Another path has also reached this state. We choose the winner by examining the tag values for both paths. */ - if _tre_tag_order(tls, num_tags, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions, tmp_tags, *(*uintptr)(unsafe.Pointer((*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags))) != 0 { + if _tre_tag_order(tls, num_tags, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions, tmp_tags, **(**uintptr)(__ccgo_up((**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags))) != 0 { /* The new path wins. */ - tmp_iptr = *(*uintptr)(unsafe.Pointer((*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags)) - *(*uintptr)(unsafe.Pointer((*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags)) = tmp_tags + tmp_iptr = **(**uintptr)(__ccgo_up((**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags)) + **(**uintptr)(__ccgo_up((**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags)) = tmp_tags if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ffinal { match_eo = pos new_match = int32(1) @@ -132727,7 +132727,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < num_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(i)*8)) = *(*Tregoff_t)(unsafe.Pointer(tmp_tags + uintptr(i)*8)) + **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(i)*8)) = **(**Tregoff_t)(__ccgo_up(tmp_tags + uintptr(i)*8)) goto _17 _17: ; @@ -132750,7 +132750,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags } (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Fstate = UintptrFromInt32(0) } - *(*Tregoff_t)(unsafe.Pointer(match_end_ofs)) = match_eo + **(**Tregoff_t)(__ccgo_up(match_end_ofs)) = match_eo if match_eo >= 0 { v18 = REG_OK } else { @@ -132821,7 +132821,7 @@ func _tre_tnfa_run_backtrack(tls *TLS, tnfa uintptr, string1 uintptr, match_tags _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bt, bt_len, empty_br_match, eo, i, i1, i2, i3, i4, match_eo, mem, next_c_start, next_state, next_tags, pmatch, pos, pos_add_next, pos_start, prev_c, reg_newline, reg_notbol, reg_noteol, result, ret, s, s1, so, stack, state, states_seen, str_byte, str_byte_start, tags, tmp, tmp1, trans_i, v20, v3, v6 /* State variables required by GET_NEXT_WCHAR. */ prev_c = 0 - *(*Ttre_char_t)(unsafe.Pointer(bp)) = 0 + **(**Ttre_char_t)(__ccgo_up(bp)) = 0 str_byte = string1 pos = 0 pos_add_next = int64(1) @@ -132875,9 +132875,9 @@ retry: if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(i)*8)) = int64(-int32(1)) + **(**Tregoff_t)(__ccgo_up(tags + uintptr(i)*8)) = int64(-int32(1)) if match_tags != 0 { - *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(i)*8)) = int64(-int32(1)) + **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(i)*8)) = int64(-int32(1)) } goto _1 _1: @@ -132889,7 +132889,7 @@ retry: if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_states) { break } - *(*int32)(unsafe.Pointer(states_seen + uintptr(i)*4)) = 0 + **(**int32)(__ccgo_up(states_seen + uintptr(i)*4)) = 0 goto _2 _2: ; @@ -132897,7 +132897,7 @@ retry: } state = UintptrFromInt32(0) pos = pos_start - prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + prev_c = **(**Ttre_char_t)(__ccgo_up(bp)) pos = pos + pos_add_next v3 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) pos_add_next = v3 @@ -132911,7 +132911,7 @@ retry: } str_byte = str_byte + uintptr(pos_add_next) pos_start = pos - next_c_start = *(*Ttre_char_t)(unsafe.Pointer(bp)) + next_c_start = **(**Ttre_char_t)(__ccgo_up(bp)) str_byte_start = str_byte /* Handle initial states. */ next_tags = UintptrFromInt32(0) @@ -132920,7 +132920,7 @@ retry: if !((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate != 0) { break } - if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\000') || reg_noteol != 0) && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0 || !(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) || (*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && *(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\000') && BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) == BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || *(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('\000') || BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) != BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0))) { + if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (**(**Ttre_char_t)(__ccgo_up(bp)) != int32('\000') || reg_noteol != 0) && (**(**Ttre_char_t)(__ccgo_up(bp)) != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0 || !(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) || (**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && **(**Ttre_char_t)(__ccgo_up(bp)) != int32('\000') && BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) == BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || **(**Ttre_char_t)(__ccgo_up(bp)) == int32('\000') || BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) != BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0))) { goto _4 } if state == UintptrFromInt32(0) { @@ -132969,13 +132969,13 @@ retry: (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstr_byte = str_byte (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate_id = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id - (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fnext_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fnext_c = **(**Ttre_char_t)(__ccgo_up(bp)) i1 = 0 for { if !(i1 < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_tags) { break } - *(*Tregoff_t)(unsafe.Pointer((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(i1)*8)) = *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(i1)*8)) + **(**Tregoff_t)(__ccgo_up((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(i1)*8)) = **(**Tregoff_t)(__ccgo_up(tags + uintptr(i1)*8)) goto _5 _5: ; @@ -132983,10 +132983,10 @@ retry: } tmp = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags if tmp != 0 { - for *(*int32)(unsafe.Pointer(tmp)) >= 0 { + for **(**int32)(__ccgo_up(tmp)) >= 0 { v6 = tmp tmp += 4 - *(*Tregoff_t)(unsafe.Pointer((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(*(*int32)(unsafe.Pointer(v6)))*8)) = pos + **(**Tregoff_t)(__ccgo_up((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(**(**int32)(__ccgo_up(v6)))*8)) = pos } } } @@ -132997,10 +132997,10 @@ retry: } if next_tags != 0 { for { - if !(*(*int32)(unsafe.Pointer(next_tags)) >= 0) { + if !(**(**int32)(__ccgo_up(next_tags)) >= 0) { break } - *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(*(*int32)(unsafe.Pointer(next_tags)))*8)) = pos + **(**Tregoff_t)(__ccgo_up(tags + uintptr(**(**int32)(__ccgo_up(next_tags)))*8)) = pos goto _7 _7: ; @@ -133025,7 +133025,7 @@ _9: if !(i2 < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(i2)*8)) = *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(i2)*8)) + **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(i2)*8)) = **(**Tregoff_t)(__ccgo_up(tags + uintptr(i2)*8)) goto _10 _10: ; @@ -133045,8 +133045,8 @@ _9: /* Get the substring we need to match against. Remember to turn off REG_NOSUB temporarily. */ _tre_fill_pmatch(tls, Uint64FromInt32(bt+int32(1)), pmatch, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags & ^Int32FromInt32(REG_NOSUB), tnfa, tags, pos) - so = (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(bt)*16))).Frm_so - eo = (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(bt)*16))).Frm_eo + so = (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(bt)*16))).Frm_so + eo = (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(bt)*16))).Frm_eo bt_len = eo - so result = Xstrncmp(tls, string1+uintptr(so), str_byte-uintptr(1), Uint64FromInt64(bt_len)) if result == 0 { @@ -133054,15 +133054,15 @@ _9: if bt_len == 0 { empty_br_match = int32(1) } - if empty_br_match != 0 && *(*int32)(unsafe.Pointer(states_seen + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*4)) != 0 { + if empty_br_match != 0 && **(**int32)(__ccgo_up(states_seen + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*4)) != 0 { goto backtrack } - *(*int32)(unsafe.Pointer(states_seen + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*4)) = empty_br_match + **(**int32)(__ccgo_up(states_seen + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*4)) = empty_br_match /* Advance in input string and resync `prev_c', `next_c' and pos. */ str_byte = str_byte + uintptr(bt_len-int64(1)) pos = pos + (bt_len - int64(1)) - prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + prev_c = **(**Ttre_char_t)(__ccgo_up(bp)) pos = pos + pos_add_next v3 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) pos_add_next = v3 @@ -133080,11 +133080,11 @@ _9: } } else { /* Check for end of string. */ - if *(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('\000') { + if **(**Ttre_char_t)(__ccgo_up(bp)) == int32('\000') { goto backtrack } /* Read the next character. */ - prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + prev_c = **(**Ttre_char_t)(__ccgo_up(bp)) pos = pos + pos_add_next v3 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) pos_add_next = v3 @@ -133105,7 +133105,7 @@ _9: break } if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fcode_min <= Uint32FromInt32(prev_c) && (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fcode_max >= Uint32FromInt32(prev_c) { - if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\000') || reg_noteol != 0) && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0 || !(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) || (*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && *(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\000') && BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) == BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || *(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('\000') || BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) != BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && !((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&Int32FromInt32(REG_ICASE) != 0) && !(Xiswctype(tls, Uint32FromInt32(prev_c), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE) != 0 && !(Xiswctype(tls, Xtowlower(tls, Uint32FromInt32(prev_c)), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) && !(Xiswctype(tls, Xtowupper(tls, Uint32FromInt32(prev_c)), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS_NEG) != 0 && _tre_neg_char_classes_match(tls, (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fneg_classes, Uint32FromInt32(prev_c), (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE)) != 0)) { + if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (**(**Ttre_char_t)(__ccgo_up(bp)) != int32('\000') || reg_noteol != 0) && (**(**Ttre_char_t)(__ccgo_up(bp)) != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0 || !(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) || (**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && **(**Ttre_char_t)(__ccgo_up(bp)) != int32('\000') && BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) == BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || **(**Ttre_char_t)(__ccgo_up(bp)) == int32('\000') || BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) != BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && !((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&Int32FromInt32(REG_ICASE) != 0) && !(Xiswctype(tls, Uint32FromInt32(prev_c), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE) != 0 && !(Xiswctype(tls, Xtowlower(tls, Uint32FromInt32(prev_c)), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) && !(Xiswctype(tls, Xtowupper(tls, Uint32FromInt32(prev_c)), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS_NEG) != 0 && _tre_neg_char_classes_match(tls, (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fneg_classes, Uint32FromInt32(prev_c), (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE)) != 0)) { goto _13 } if next_state == UintptrFromInt32(0) { @@ -133157,13 +133157,13 @@ _9: (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstr_byte = str_byte (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate_id = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id - (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fnext_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fnext_c = **(**Ttre_char_t)(__ccgo_up(bp)) i3 = 0 for { if !(i3 < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_tags) { break } - *(*Tregoff_t)(unsafe.Pointer((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(i3)*8)) = *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(i3)*8)) + **(**Tregoff_t)(__ccgo_up((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(i3)*8)) = **(**Tregoff_t)(__ccgo_up(tags + uintptr(i3)*8)) goto _14 _14: ; @@ -133171,10 +133171,10 @@ _9: } tmp1 = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags for { - if !(tmp1 != 0 && *(*int32)(unsafe.Pointer(tmp1)) >= 0) { + if !(tmp1 != 0 && **(**int32)(__ccgo_up(tmp1)) >= 0) { break } - *(*Tregoff_t)(unsafe.Pointer((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(*(*int32)(unsafe.Pointer(tmp1)))*8)) = pos + **(**Tregoff_t)(__ccgo_up((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(**(**int32)(__ccgo_up(tmp1)))*8)) = pos goto _15 _15: ; @@ -133194,10 +133194,10 @@ _9: state = next_state /* Update the tag values. */ if next_tags != 0 { - for *(*int32)(unsafe.Pointer(next_tags)) >= 0 { + for **(**int32)(__ccgo_up(next_tags)) >= 0 { v6 = next_tags next_tags += 4 - *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(*(*int32)(unsafe.Pointer(v6)))*8)) = pos + **(**Tregoff_t)(__ccgo_up(tags + uintptr(**(**int32)(__ccgo_up(v6)))*8)) = pos } } goto _17 @@ -133209,18 +133209,18 @@ backtrack: /* A matching transition was not found. Try to backtrack. */ if (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fprev != 0 { if (*Ttre_tnfa_transition_t)(unsafe.Pointer((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate)).Fassertions&int32(ASSERT_BACKREF) != 0 { - *(*int32)(unsafe.Pointer(states_seen + uintptr((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate_id)*4)) = 0 + **(**int32)(__ccgo_up(states_seen + uintptr((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate_id)*4)) = 0 } pos = (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fpos str_byte = (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstr_byte state = (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate - *(*Ttre_char_t)(unsafe.Pointer(bp)) = (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fnext_c + **(**Ttre_char_t)(__ccgo_up(bp)) = (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fnext_c i4 = 0 for { if !(i4 < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(i4)*8)) = *(*Tregoff_t)(unsafe.Pointer((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(i4)*8)) + **(**Tregoff_t)(__ccgo_up(tags + uintptr(i4)*8)) = **(**Tregoff_t)(__ccgo_up((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(i4)*8)) goto _19 _19: ; @@ -133231,10 +133231,10 @@ backtrack: if match_eo < 0 { /* Try starting from a later position in the input string. */ /* Check for end of string. */ - if *(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('\000') { + if **(**Ttre_char_t)(__ccgo_up(bp)) == int32('\000') { goto _8 } - *(*Ttre_char_t)(unsafe.Pointer(bp)) = next_c_start + **(**Ttre_char_t)(__ccgo_up(bp)) = next_c_start str_byte = str_byte_start goto retry } else { @@ -133252,7 +133252,7 @@ _8: v20 = int32(REG_NOMATCH) } ret = v20 - *(*Tregoff_t)(unsafe.Pointer(match_end_ofs)) = match_eo + **(**Tregoff_t)(__ccgo_up(match_end_ofs)) = match_eo goto error_exit error_exit: ; @@ -133287,22 +133287,22 @@ func _tre_fill_pmatch(tls *TLS, nmatch Tsize_t, pmatch uintptr, cflags int32, tn /* Construct submatch offsets from the tags. */ submatch_data = (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data for i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches && uint64(i) < nmatch { - if (*(*Ttre_submatch_data_t)(unsafe.Pointer(submatch_data + uintptr(i)*16))).Fso_tag == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fend_tag { - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = match_eo + if (**(**Ttre_submatch_data_t)(__ccgo_up(submatch_data + uintptr(i)*16))).Fso_tag == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fend_tag { + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_so = match_eo } else { - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = *(*Tregoff_t)(unsafe.Pointer(tags + uintptr((*(*Ttre_submatch_data_t)(unsafe.Pointer(submatch_data + uintptr(i)*16))).Fso_tag)*8)) + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_so = **(**Tregoff_t)(__ccgo_up(tags + uintptr((**(**Ttre_submatch_data_t)(__ccgo_up(submatch_data + uintptr(i)*16))).Fso_tag)*8)) } - if (*(*Ttre_submatch_data_t)(unsafe.Pointer(submatch_data + uintptr(i)*16))).Feo_tag == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fend_tag { - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = match_eo + if (**(**Ttre_submatch_data_t)(__ccgo_up(submatch_data + uintptr(i)*16))).Feo_tag == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fend_tag { + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_eo = match_eo } else { - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = *(*Tregoff_t)(unsafe.Pointer(tags + uintptr((*(*Ttre_submatch_data_t)(unsafe.Pointer(submatch_data + uintptr(i)*16))).Feo_tag)*8)) + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_eo = **(**Tregoff_t)(__ccgo_up(tags + uintptr((**(**Ttre_submatch_data_t)(__ccgo_up(submatch_data + uintptr(i)*16))).Feo_tag)*8)) } /* If either of the endpoints were not used, this submatch was not part of the match. */ - if (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so == int64(-int32(1)) || (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo == int64(-int32(1)) { + if (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_so == int64(-int32(1)) || (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_eo == int64(-int32(1)) { v1 = int64(-Int32FromInt32(1)) - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = v1 - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = v1 + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_eo = v1 + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_so = v1 } i = i + 1 } @@ -133310,19 +133310,19 @@ func _tre_fill_pmatch(tls *TLS, nmatch Tsize_t, pmatch uintptr, cflags int32, tn submatches. */ i = uint32(0) for i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches && uint64(i) < nmatch { - if (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo == int64(-int32(1)) { + if (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_eo == int64(-int32(1)) { } - parents = (*(*Ttre_submatch_data_t)(unsafe.Pointer(submatch_data + uintptr(i)*16))).Fparents + parents = (**(**Ttre_submatch_data_t)(__ccgo_up(submatch_data + uintptr(i)*16))).Fparents if parents != UintptrFromInt32(0) { j = uint32(0) for { - if !(*(*int32)(unsafe.Pointer(parents + uintptr(j)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(parents + uintptr(j)*4)) >= 0) { break } - if (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so < (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(*(*int32)(unsafe.Pointer(parents + uintptr(j)*4)))*16))).Frm_so || (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo > (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(*(*int32)(unsafe.Pointer(parents + uintptr(j)*4)))*16))).Frm_eo { + if (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_so < (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(**(**int32)(__ccgo_up(parents + uintptr(j)*4)))*16))).Frm_so || (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_eo > (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(**(**int32)(__ccgo_up(parents + uintptr(j)*4)))*16))).Frm_eo { v1 = int64(-Int32FromInt32(1)) - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = v1 - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = v1 + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_eo = v1 + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_so = v1 } goto _2 _2: @@ -133334,8 +133334,8 @@ func _tre_fill_pmatch(tls *TLS, nmatch Tsize_t, pmatch uintptr, cflags int32, tn } } for uint64(i) < nmatch { - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = int64(-int32(1)) - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = int64(-int32(1)) + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_so = int64(-int32(1)) + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_eo = int64(-int32(1)) i = i + 1 } } @@ -133376,7 +133376,7 @@ func Xregexec(tls *TLS, preg uintptr, string1 uintptr, nmatch Tsize_t, pmatch ui } if status == REG_OK { /* A match was found, so fill the submatch registers. */ - _tre_fill_pmatch(tls, nmatch, pmatch, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags, tnfa, tags, *(*Tregoff_t)(unsafe.Pointer(bp))) + _tre_fill_pmatch(tls, nmatch, pmatch, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags, tnfa, tags, **(**Tregoff_t)(__ccgo_up(bp))) } if tags != 0 { Xfree(tls, tags) @@ -133494,8 +133494,8 @@ func X__tre_mem_alloc_impl(tls *TLS, mem Ttre_mem_t, provided int32, provided_bl size = size + v1 /* Allocate from current block. */ ptr = (*Ttre_mem_struct)(unsafe.Pointer(mem)).Fptr - *(*uintptr)(unsafe.Pointer(mem + 16)) += uintptr(size) - *(*Tsize_t)(unsafe.Pointer(mem + 24)) -= size + **(**uintptr)(__ccgo_up(mem + 16)) += uintptr(size) + **(**Tsize_t)(__ccgo_up(mem + 24)) -= size /* Set to zero if needed. */ if zero != 0 { Xmemset(tls, ptr, 0, size) @@ -133560,10 +133560,10 @@ func _keyhash(tls *TLS, k uintptr) (r Tsize_t) { _, _, _ = h, p, v1 p = k h = uint64(0) - for *(*uint8)(unsafe.Pointer(p)) != 0 { + for **(**uint8)(__ccgo_up(p)) != 0 { v1 = p p = p + 1 - h = uint64(31)*h + uint64(*(*uint8)(unsafe.Pointer(v1))) + h = uint64(31)*h + uint64(**(**uint8)(__ccgo_up(v1))) } return h } @@ -133616,7 +133616,7 @@ func _resize(tls *TLS, nel Tsize_t, htab uintptr) (r int32) { j = j + 1 i = i + v4 } - *(*TENTRY)(unsafe.Pointer(newe)) = *(*TENTRY)(unsafe.Pointer(e)) + **(**TENTRY)(__ccgo_up(newe)) = **(**TENTRY)(__ccgo_up(e)) } goto _2 _2: @@ -133672,7 +133672,7 @@ func Xhsearch(tls *TLS, item TENTRY, action TACTION) (r uintptr) { defer tls.Free(16) var _ /* e at bp+0 */ uintptr ___hsearch_r(tls, item, action, bp, uintptr(unsafe.Pointer(&_htab))) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func ___hcreate_r(tls *TLS, nel Tsize_t, htab uintptr) (r1 int32) { @@ -133705,14 +133705,14 @@ func ___hsearch_r(tls *TLS, item TENTRY, action TACTION, retval uintptr, htab ui hash = _keyhash(tls, item.Fkey) e = _lookup(tls, item.Fkey, hash, htab) if (*TENTRY)(unsafe.Pointer(e)).Fkey != 0 { - *(*uintptr)(unsafe.Pointer(retval)) = e + **(**uintptr)(__ccgo_up(retval)) = e return int32(1) } if action == int32(_FIND) { - *(*uintptr)(unsafe.Pointer(retval)) = uintptr(0) + **(**uintptr)(__ccgo_up(retval)) = uintptr(0) return 0 } - *(*TENTRY)(unsafe.Pointer(e)) = item + **(**TENTRY)(__ccgo_up(e)) = item v2 = (*Thsearch_data)(unsafe.Pointer(htab)).F__tab + 16 *(*Tsize_t)(unsafe.Pointer(v2)) = *(*Tsize_t)(unsafe.Pointer(v2)) + 1 v1 = *(*Tsize_t)(unsafe.Pointer(v2)) @@ -133720,12 +133720,12 @@ func ___hsearch_r(tls *TLS, item TENTRY, action TACTION, retval uintptr, htab ui if !(_resize(tls, uint64(2)*(*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused, htab) != 0) { (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused = (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused - 1 (*TENTRY)(unsafe.Pointer(e)).Fkey = uintptr(0) - *(*uintptr)(unsafe.Pointer(retval)) = uintptr(0) + **(**uintptr)(__ccgo_up(retval)) = uintptr(0) return 0 } e = _lookup(tls, item.Fkey, hash, htab) } - *(*uintptr)(unsafe.Pointer(retval)) = e + **(**uintptr)(__ccgo_up(retval)) = e return int32(1) } @@ -133785,7 +133785,7 @@ func Xlsearch(tls *TLS, key uintptr, base uintptr, nelp uintptr, width Tsize_t, defer func() {}() v1 = width p = base - n = *(*Tsize_t)(unsafe.Pointer(nelp)) + n = **(**Tsize_t)(__ccgo_up(nelp)) i = uint64(0) for { if !(i < n) { @@ -133799,7 +133799,7 @@ func Xlsearch(tls *TLS, key uintptr, base uintptr, nelp uintptr, width Tsize_t, ; i = i + 1 } - *(*Tsize_t)(unsafe.Pointer(nelp)) = n + uint64(1) + **(**Tsize_t)(__ccgo_up(nelp)) = n + uint64(1) return Xmemcpy(tls, p+uintptr(n)*uintptr(v1), key, width) } @@ -133817,7 +133817,7 @@ func Xlfind(tls *TLS, key uintptr, base uintptr, nelp uintptr, width Tsize_t, __ defer func() {}() v1 = width p = base - n = *(*Tsize_t)(unsafe.Pointer(nelp)) + n = **(**Tsize_t)(__ccgo_up(nelp)) i = uint64(0) for { if !(i < n) { @@ -133856,7 +133856,7 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui if !(rootp != 0) { return uintptr(0) } - n = *(*uintptr)(unsafe.Pointer(rootp)) + n = **(**uintptr)(__ccgo_up(rootp)) i = 0 /* *a[0] is an arbitrary non-null pointer that is returned when the root node is deleted. */ @@ -133877,34 +133877,34 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui v1 = i i = i + 1 a[v1] = n + 8 + BoolUintptr(c > 0)*8 - n = *(*uintptr)(unsafe.Pointer(n + 8 + BoolUintptr(c > 0)*8)) + n = **(**uintptr)(__ccgo_up(n + 8 + BoolUintptr(c > 0)*8)) goto _3 _3: } - parent = *(*uintptr)(unsafe.Pointer(a[i-int32(2)])) - if *(*uintptr)(unsafe.Pointer(n + 8)) != 0 { + parent = **(**uintptr)(__ccgo_up(a[i-int32(2)])) + if **(**uintptr)(__ccgo_up(n + 8)) != 0 { /* free the preceding node instead of the deleted one. */ deleted = n v1 = i i = i + 1 a[v1] = n + 8 - n = *(*uintptr)(unsafe.Pointer(n + 8)) - for *(*uintptr)(unsafe.Pointer(n + 8 + 1*8)) != 0 { + n = **(**uintptr)(__ccgo_up(n + 8)) + for **(**uintptr)(__ccgo_up(n + 8 + 1*8)) != 0 { v1 = i i = i + 1 a[v1] = n + 8 + 1*8 - n = *(*uintptr)(unsafe.Pointer(n + 8 + 1*8)) + n = **(**uintptr)(__ccgo_up(n + 8 + 1*8)) } (*Tnode1)(unsafe.Pointer(deleted)).Fkey = (*Tnode1)(unsafe.Pointer(n)).Fkey - child = *(*uintptr)(unsafe.Pointer(n + 8)) + child = **(**uintptr)(__ccgo_up(n + 8)) } else { - child = *(*uintptr)(unsafe.Pointer(n + 8 + 1*8)) + child = **(**uintptr)(__ccgo_up(n + 8 + 1*8)) } /* freed node has at most one child, move it up and rebalance. */ Xfree(tls, n) i = i - 1 v1 = i - *(*uintptr)(unsafe.Pointer(a[v1])) = child + **(**uintptr)(__ccgo_up(a[v1])) = child for { i = i - 1 v1 = i @@ -133927,8 +133927,8 @@ func Xtdestroy(tls *TLS, root uintptr, __ccgo_fp_freekey uintptr) { if r == uintptr(0) { return } - Xtdestroy(tls, *(*uintptr)(unsafe.Pointer(r + 8)), __ccgo_fp_freekey) - Xtdestroy(tls, *(*uintptr)(unsafe.Pointer(r + 8 + 1*8)), __ccgo_fp_freekey) + Xtdestroy(tls, **(**uintptr)(__ccgo_up(r + 8)), __ccgo_fp_freekey) + Xtdestroy(tls, **(**uintptr)(__ccgo_up(r + 8 + 1*8)), __ccgo_fp_freekey) if __ccgo_fp_freekey != 0 { (*(*func(*TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_freekey})))(tls, (*Tnode1)(unsafe.Pointer(r)).Fkey) } @@ -133948,7 +133948,7 @@ func Xtfind(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r uint if !(rootp != 0) { return uintptr(0) } - n = *(*uintptr)(unsafe.Pointer(rootp)) + n = **(**uintptr)(__ccgo_up(rootp)) for { if !(n != 0) { break @@ -133957,7 +133957,7 @@ func Xtfind(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r uint if !(c != 0) { break } - n = *(*uintptr)(unsafe.Pointer(n + 8 + BoolUintptr(c > 0)*8)) + n = **(**uintptr)(__ccgo_up(n + 8 + BoolUintptr(c > 0)*8)) goto _1 _1: } @@ -133979,11 +133979,11 @@ func _rot(tls *TLS, p uintptr, x uintptr, dir int32) (r int32) { var hx, hz int32 var y, z uintptr _, _, _, _ = hx, hz, y, z - y = *(*uintptr)(unsafe.Pointer(x + 8 + uintptr(dir)*8)) - z = *(*uintptr)(unsafe.Pointer(y + 8 + BoolUintptr(!(dir != 0))*8)) + y = **(**uintptr)(__ccgo_up(x + 8 + uintptr(dir)*8)) + z = **(**uintptr)(__ccgo_up(y + 8 + BoolUintptr(!(dir != 0))*8)) hx = (*Tnode1)(unsafe.Pointer(x)).Fh hz = _height(tls, z) - if hz > _height(tls, *(*uintptr)(unsafe.Pointer(y + 8 + uintptr(dir)*8))) { + if hz > _height(tls, **(**uintptr)(__ccgo_up(y + 8 + uintptr(dir)*8))) { /* * x * / \ dir z @@ -133991,10 +133991,10 @@ func _rot(tls *TLS, p uintptr, x uintptr, dir int32) (r int32) { * z D /| | * / \ A B C D * B C */ - *(*uintptr)(unsafe.Pointer(x + 8 + uintptr(dir)*8)) = *(*uintptr)(unsafe.Pointer(z + 8 + BoolUintptr(!(dir != 0))*8)) - *(*uintptr)(unsafe.Pointer(y + 8 + BoolUintptr(!(dir != 0))*8)) = *(*uintptr)(unsafe.Pointer(z + 8 + uintptr(dir)*8)) - *(*uintptr)(unsafe.Pointer(z + 8 + BoolUintptr(!(dir != 0))*8)) = x - *(*uintptr)(unsafe.Pointer(z + 8 + uintptr(dir)*8)) = y + **(**uintptr)(__ccgo_up(x + 8 + uintptr(dir)*8)) = **(**uintptr)(__ccgo_up(z + 8 + BoolUintptr(!(dir != 0))*8)) + **(**uintptr)(__ccgo_up(y + 8 + BoolUintptr(!(dir != 0))*8)) = **(**uintptr)(__ccgo_up(z + 8 + uintptr(dir)*8)) + **(**uintptr)(__ccgo_up(z + 8 + BoolUintptr(!(dir != 0))*8)) = x + **(**uintptr)(__ccgo_up(z + 8 + uintptr(dir)*8)) = y (*Tnode1)(unsafe.Pointer(x)).Fh = hz (*Tnode1)(unsafe.Pointer(y)).Fh = hz (*Tnode1)(unsafe.Pointer(z)).Fh = hz + int32(1) @@ -134004,13 +134004,13 @@ func _rot(tls *TLS, p uintptr, x uintptr, dir int32) (r int32) { * / \ / * A y --> x D * / \ / * z D A z */ - *(*uintptr)(unsafe.Pointer(x + 8 + uintptr(dir)*8)) = z - *(*uintptr)(unsafe.Pointer(y + 8 + BoolUintptr(!(dir != 0))*8)) = x + **(**uintptr)(__ccgo_up(x + 8 + uintptr(dir)*8)) = z + **(**uintptr)(__ccgo_up(y + 8 + BoolUintptr(!(dir != 0))*8)) = x (*Tnode1)(unsafe.Pointer(x)).Fh = hz + int32(1) (*Tnode1)(unsafe.Pointer(y)).Fh = hz + int32(2) z = y } - *(*uintptr)(unsafe.Pointer(p)) = z + **(**uintptr)(__ccgo_up(p)) = z return (*Tnode1)(unsafe.Pointer(z)).Fh - hx } @@ -134025,9 +134025,9 @@ func X__tsearch_balance(tls *TLS, p uintptr) (r int32) { var h0, h1, old, v1 int32 var n uintptr _, _, _, _, _ = h0, h1, n, old, v1 - n = *(*uintptr)(unsafe.Pointer(p)) - h0 = _height(tls, *(*uintptr)(unsafe.Pointer(n + 8))) - h1 = _height(tls, *(*uintptr)(unsafe.Pointer(n + 8 + 1*8))) + n = **(**uintptr)(__ccgo_up(p)) + h0 = _height(tls, **(**uintptr)(__ccgo_up(n + 8))) + h1 = _height(tls, **(**uintptr)(__ccgo_up(n + 8 + 1*8))) if Uint32FromInt32(h0-h1)+uint32(1) < uint32(3) { old = (*Tnode1)(unsafe.Pointer(n)).Fh if h0 < h1 { @@ -134056,7 +134056,7 @@ func Xtsearch(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r1 u if !(rootp != 0) { return uintptr(0) } - n = *(*uintptr)(unsafe.Pointer(rootp)) + n = **(**uintptr)(__ccgo_up(rootp)) i = 0 v1 = i i = i + 1 @@ -134072,7 +134072,7 @@ func Xtsearch(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r1 u v1 = i i = i + 1 a[v1] = n + 8 + BoolUintptr(c > 0)*8 - n = *(*uintptr)(unsafe.Pointer(n + 8 + BoolUintptr(c > 0)*8)) + n = **(**uintptr)(__ccgo_up(n + 8 + BoolUintptr(c > 0)*8)) goto _2 _2: } @@ -134082,13 +134082,13 @@ func Xtsearch(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r1 u } (*Tnode1)(unsafe.Pointer(r)).Fkey = key v4 = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(r + 8 + 1*8)) = v4 - *(*uintptr)(unsafe.Pointer(r + 8)) = v4 + **(**uintptr)(__ccgo_up(r + 8 + 1*8)) = v4 + **(**uintptr)(__ccgo_up(r + 8)) = v4 (*Tnode1)(unsafe.Pointer(r)).Fh = int32(1) /* insert new node, rebalance ancestors. */ i = i - 1 v1 = i - *(*uintptr)(unsafe.Pointer(a[v1])) = r + **(**uintptr)(__ccgo_up(a[v1])) = r for { if v7 = i != 0; v7 { i = i - 1 @@ -134109,9 +134109,9 @@ func _walk(tls *TLS, r uintptr, __ccgo_fp_action uintptr, d int32) { (*(*func(*TLS, uintptr, TVISIT, int32))(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_action})))(tls, r, int32(_leaf), d) } else { (*(*func(*TLS, uintptr, TVISIT, int32))(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_action})))(tls, r, int32(_preorder), d) - _walk(tls, *(*uintptr)(unsafe.Pointer(r + 8)), __ccgo_fp_action, d+int32(1)) + _walk(tls, **(**uintptr)(__ccgo_up(r + 8)), __ccgo_fp_action, d+int32(1)) (*(*func(*TLS, uintptr, TVISIT, int32))(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_action})))(tls, r, int32(_postorder), d) - _walk(tls, *(*uintptr)(unsafe.Pointer(r + 8 + 1*8)), __ccgo_fp_action, d+int32(1)) + _walk(tls, **(**uintptr)(__ccgo_up(r + 8 + 1*8)), __ccgo_fp_action, d+int32(1)) (*(*func(*TLS, uintptr, TVISIT, int32))(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_action})))(tls, r, int32(_endorder), d) } } @@ -134193,7 +134193,7 @@ func Xpselect(tls *TLS, n int32, rfds uintptr, wfds uintptr, efds uintptr, ts ui var v3 uintptr var _ /* data at bp+16 */ [2]Tsyscall_arg_t _, _, _, _, _ = ns, s, v1, v2, v3 - *(*[2]Tsyscall_arg_t)(unsafe.Pointer(bp + 16)) = [2]Tsyscall_arg_t{ + **(**[2]Tsyscall_arg_t)(__ccgo_up(bp + 16)) = [2]Tsyscall_arg_t{ 0: Int64FromUint64(uint64(mask)), 1: int64(Int32FromInt32(_NSIG) / Int32FromInt32(8)), } @@ -134315,10 +134315,10 @@ func Xgetitimer(tls *TLS, which int32, old uintptr) (r1 int32) { if uint64(8) > uint64(8) { r = int32(X__syscall2(tls, int64(SYS_getitimer), int64(which), int64(bp))) if !(r != 0) { - (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_sec = (*(*[4]int64)(unsafe.Pointer(bp)))[0] - (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_usec = (*(*[4]int64)(unsafe.Pointer(bp)))[int32(1)] - (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_sec = (*(*[4]int64)(unsafe.Pointer(bp)))[int32(2)] - (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_usec = (*(*[4]int64)(unsafe.Pointer(bp)))[int32(3)] + (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_sec = (**(**[4]int64)(__ccgo_up(bp)))[0] + (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_usec = (**(**[4]int64)(__ccgo_up(bp)))[int32(1)] + (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_sec = (**(**[4]int64)(__ccgo_up(bp)))[int32(2)] + (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_usec = (**(**[4]int64)(__ccgo_up(bp)))[int32(3)] } return int32(X__syscall_ret(tls, Uint64FromInt32(r))) } @@ -134339,7 +134339,7 @@ func Xkillpg(tls *TLS, pgid Tpid_t, sig int32) (r int32) { defer func() { trc("-> %v", r) }() } if pgid < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } return Xkill(tls, -pgid, sig) @@ -134375,7 +134375,7 @@ func Xpsignal(tls *TLS, sig int32, msg uintptr) { * not permitted to do so. */ old_locale = (*TFILE)(unsafe.Pointer(f)).Flocale old_mode = (*TFILE)(unsafe.Pointer(f)).Fmode - old_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + old_errno = **(**int32)(__ccgo_up(X__errno_location(tls))) if msg != 0 { v2 = msg } else { @@ -134387,7 +134387,7 @@ func Xpsignal(tls *TLS, sig int32, msg uintptr) { v3 = __ccgo_ts } if Xfprintf(tls, f, __ccgo_ts+1111, VaList(bp+8, v2, v3, s)) >= 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = old_errno + **(**int32)(__ccgo_up(X__errno_location(tls))) = old_errno } (*TFILE)(unsafe.Pointer(f)).Fmode = old_mode (*TFILE)(unsafe.Pointer(f)).Flocale = old_locale @@ -134454,10 +134454,10 @@ func Xsetitimer(tls *TLS, which int32, new1 uintptr, old uintptr) (r1 int32) { } r = int32(X__syscall3(tls, int64(SYS_setitimer), int64(which), int64(bp), int64(bp+32))) if !(r != 0) && old != 0 { - (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_sec = (*(*[4]int64)(unsafe.Pointer(bp + 32)))[0] - (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_usec = (*(*[4]int64)(unsafe.Pointer(bp + 32)))[int32(1)] - (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_sec = (*(*[4]int64)(unsafe.Pointer(bp + 32)))[int32(2)] - (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_usec = (*(*[4]int64)(unsafe.Pointer(bp + 32)))[int32(3)] + (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_sec = (**(**[4]int64)(__ccgo_up(bp + 32)))[0] + (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_usec = (**(**[4]int64)(__ccgo_up(bp + 32)))[int32(1)] + (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_sec = (**(**[4]int64)(__ccgo_up(bp + 32)))[int32(2)] + (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_usec = (**(**[4]int64)(__ccgo_up(bp + 32)))[int32(3)] } return int32(X__syscall_ret(tls, Uint64FromInt32(r))) } @@ -134537,7 +134537,7 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old2 uintptr) (r1 int32) Fv Tuint64_t }{} *(*uint64)(unsafe.Pointer(bp + 8)) = Uint64FromInt64(v2) - if *(*Tuint32_t)(unsafe.Pointer(bp + 8)) != 0 { + if **(**Tuint32_t)(__ccgo_up(bp + 8)) != 0 { v9 = v8 for { old1 = AtomicLoadPInt32(v9) @@ -134563,7 +134563,7 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old2 uintptr) (r1 int32) goto _13 _13: } - if *(*Tuint32_t)(unsafe.Pointer(bp + 8 + 1*4)) != 0 { + if **(**Tuint32_t)(__ccgo_up(bp + 8 + 1*4)) != 0 { v14 = v8 + uintptr(1)*4 for { old1 = AtomicLoadPInt32(v14) @@ -134613,8 +134613,8 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old2 uintptr) (r1 int32) X__assert_fail(tls, __ccgo_ts+353, __ccgo_ts+388, 4, __ccgo_ts+1526) } } - (*(*Tk_sigaction)(unsafe.Pointer(bp + 16))).Fhandler = *(*uintptr)(unsafe.Pointer(sa)) - (*(*Tk_sigaction)(unsafe.Pointer(bp + 16))).Fflags = Uint64FromInt32((*Tsigaction)(unsafe.Pointer(sa)).Fsa_flags) + (**(**Tk_sigaction)(__ccgo_up(bp + 16))).Fhandler = *(*uintptr)(unsafe.Pointer(sa)) + (**(**Tk_sigaction)(__ccgo_up(bp + 16))).Fflags = Uint64FromInt32((*Tsigaction)(unsafe.Pointer(sa)).Fsa_flags) Xmemcpy(tls, bp+16+16, sa+8, Uint64FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))) } if sa != 0 { @@ -134629,8 +134629,8 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old2 uintptr) (r1 int32) } r = int32(X__syscall4(tls, int64(SYS_rt_sigaction), int64(sig), int64(v1), int64(v3), int64(Int32FromInt32(_NSIG)/Int32FromInt32(8)))) if old2 != 0 && !(r != 0) { - *(*uintptr)(unsafe.Pointer(old2)) = (*(*Tk_sigaction)(unsafe.Pointer(bp + 48))).Fhandler - (*Tsigaction)(unsafe.Pointer(old2)).Fsa_flags = Int32FromUint64((*(*Tk_sigaction)(unsafe.Pointer(bp + 48))).Fflags) + *(*uintptr)(unsafe.Pointer(old2)) = (**(**Tk_sigaction)(__ccgo_up(bp + 48))).Fhandler + (*Tsigaction)(unsafe.Pointer(old2)).Fsa_flags = Int32FromUint64((**(**Tk_sigaction)(__ccgo_up(bp + 48))).Fflags) Xmemcpy(tls, old2+8, bp+48+16, Uint64FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))) } return int32(X__syscall_ret(tls, Uint64FromInt32(r))) @@ -134647,7 +134647,7 @@ func X__sigaction(tls *TLS, sig int32, sa uintptr, old uintptr) (r1 int32) { var _ /* set at bp+0 */ [1]uint64 _ = r if Uint32FromInt32(sig)-uint32(32) < uint32(3) || Uint32FromInt32(sig)-uint32(1) >= Uint32FromInt32(Int32FromInt32(_NSIG)-Int32FromInt32(1)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } /* Doing anything with the disposition of SIGABRT requires a lock, @@ -134682,10 +134682,10 @@ func Xsigaddset(tls *TLS, set uintptr, sig int32) (r int32) { _ = s s = Uint32FromInt32(sig - int32(1)) if s >= Uint32FromInt32(Int32FromInt32(_NSIG)-Int32FromInt32(1)) || Uint32FromInt32(sig)-uint32(32) < uint32(3) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } - *(*uint64)(unsafe.Pointer(set + uintptr(uint64(s/uint32(8))/uint64(8))*8)) |= uint64(1) << (uint64(s) & (Uint64FromInt32(8)*Uint64FromInt64(8) - Uint64FromInt32(1))) + **(**uint64)(__ccgo_up(set + uintptr(uint64(s/uint32(8))/uint64(8))*8)) |= uint64(1) << (uint64(s) & (Uint64FromInt32(8)*Uint64FromInt64(8) - Uint64FromInt32(1))) return 0 } @@ -134696,11 +134696,11 @@ func Xsigaltstack(tls *TLS, ss uintptr, old uintptr) (r int32) { } if ss != 0 { if !((*Tstack_t)(unsafe.Pointer(ss)).Fss_flags&Int32FromInt32(SS_DISABLE) != 0) && (*Tstack_t)(unsafe.Pointer(ss)).Fss_size < uint64(MINSIGSTKSZ) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return -int32(1) } if (*Tstack_t)(unsafe.Pointer(ss)).Fss_flags&int32(SS_ONSTACK) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } } @@ -134725,7 +134725,7 @@ func Xsigandset(tls *TLS, dest uintptr, left uintptr, right uintptr) (r1 int32) if !(i < Uint64FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))/Uint64FromInt64(8)) { break } - *(*uint64)(unsafe.Pointer(d + uintptr(i)*8)) = *(*uint64)(unsafe.Pointer(l + uintptr(i)*8)) & *(*uint64)(unsafe.Pointer(r + uintptr(i)*8)) + **(**uint64)(__ccgo_up(d + uintptr(i)*8)) = **(**uint64)(__ccgo_up(l + uintptr(i)*8)) & **(**uint64)(__ccgo_up(r + uintptr(i)*8)) goto _1 _1: ; @@ -134743,10 +134743,10 @@ func Xsigdelset(tls *TLS, set uintptr, sig int32) (r int32) { _ = s s = Uint32FromInt32(sig - int32(1)) if s >= Uint32FromInt32(Int32FromInt32(_NSIG)-Int32FromInt32(1)) || Uint32FromInt32(sig)-uint32(32) < uint32(3) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } - *(*uint64)(unsafe.Pointer(set + uintptr(uint64(s/uint32(8))/uint64(8))*8)) &= ^(Uint64FromUint64(1) << (uint64(s) & (Uint64FromInt32(8)*Uint64FromInt64(8) - Uint64FromInt32(1)))) + **(**uint64)(__ccgo_up(set + uintptr(uint64(s/uint32(8))/uint64(8))*8)) &= ^(Uint64FromUint64(1) << (uint64(s) & (Uint64FromInt32(8)*Uint64FromInt64(8) - Uint64FromInt32(1)))) return 0 } @@ -134755,13 +134755,13 @@ func Xsigemptyset(tls *TLS, set uintptr) (r int32) { trc("tls=%v set=%v, (%v:)", tls, set, origin(2)) defer func() { trc("-> %v", r) }() } - *(*uint64)(unsafe.Pointer(set)) = uint64(0) + **(**uint64)(__ccgo_up(set)) = uint64(0) if Bool(uint64(8) == uint64(4)) || Bool(int32(_NSIG) > int32(65)) { - *(*uint64)(unsafe.Pointer(set + 1*8)) = uint64(0) + **(**uint64)(__ccgo_up(set + 1*8)) = uint64(0) } if Bool(uint64(8) == uint64(4)) && Bool(int32(_NSIG) > int32(65)) { - *(*uint64)(unsafe.Pointer(set + 2*8)) = uint64(0) - *(*uint64)(unsafe.Pointer(set + 3*8)) = uint64(0) + **(**uint64)(__ccgo_up(set + 2*8)) = uint64(0) + **(**uint64)(__ccgo_up(set + 3*8)) = uint64(0) } return 0 } @@ -134780,9 +134780,9 @@ func Xsigfillset(tls *TLS, set uintptr) (r int32) { trc("tls=%v set=%v, (%v:)", tls, set, origin(2)) defer func() { trc("-> %v", r) }() } - *(*uint64)(unsafe.Pointer(set)) = uint64(0xfffffffc7fffffff) + **(**uint64)(__ccgo_up(set)) = uint64(0xfffffffc7fffffff) if int32(_NSIG) > int32(65) { - *(*uint64)(unsafe.Pointer(set + 1*8)) = uint64(0xffffffffffffffff) + **(**uint64)(__ccgo_up(set + 1*8)) = uint64(0xffffffffffffffff) } return 0 } @@ -134799,7 +134799,7 @@ func Xsigisemptyset(tls *TLS, set uintptr) (r int32) { if !(i < Uint64FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))/Uint64FromInt64(8)) { break } - if *(*uint64)(unsafe.Pointer(set + uintptr(i)*8)) != 0 { + if **(**uint64)(__ccgo_up(set + uintptr(i)*8)) != 0 { return 0 } goto _1 @@ -134821,7 +134821,7 @@ func Xsigismember(tls *TLS, set uintptr, sig int32) (r int32) { if s >= Uint32FromInt32(Int32FromInt32(_NSIG)-Int32FromInt32(1)) { return 0 } - return BoolInt32(!!(*(*uint64)(unsafe.Pointer(set + uintptr(uint64(s/uint32(8))/uint64(8))*8))&(Uint64FromUint64(1)<<(uint64(s)&(Uint64FromInt32(8)*Uint64FromInt64(8)-Uint64FromInt32(1)))) != 0)) + return BoolInt32(!!(**(**uint64)(__ccgo_up(set + uintptr(uint64(s/uint32(8))/uint64(8))*8))&(Uint64FromUint64(1)<<(uint64(s)&(Uint64FromInt32(8)*Uint64FromInt64(8)-Uint64FromInt32(1)))) != 0)) } func Xsigorset(tls *TLS, dest uintptr, left uintptr, right uintptr) (r1 int32) { @@ -134840,7 +134840,7 @@ func Xsigorset(tls *TLS, dest uintptr, left uintptr, right uintptr) (r1 int32) { if !(i < Uint64FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))/Uint64FromInt64(8)) { break } - *(*uint64)(unsafe.Pointer(d + uintptr(i)*8)) = *(*uint64)(unsafe.Pointer(l + uintptr(i)*8)) | *(*uint64)(unsafe.Pointer(r + uintptr(i)*8)) + **(**uint64)(__ccgo_up(d + uintptr(i)*8)) = **(**uint64)(__ccgo_up(l + uintptr(i)*8)) | **(**uint64)(__ccgo_up(r + uintptr(i)*8)) goto _1 _1: ; @@ -134868,7 +134868,7 @@ func Xsigprocmask(tls *TLS, how int32, set uintptr, old uintptr) (r1 int32) { if !(r != 0) { return r } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = r + **(**int32)(__ccgo_up(X__errno_location(tls))) = r return -int32(1) } @@ -134884,8 +134884,8 @@ func Xsigqueue(tls *TLS, pid Tpid_t, sig int32, value Tsigval) (r1 int32) { var _ /* si at bp+0 */ Tsiginfo_t _ = r Xmemset(tls, bp, 0, uint64(128)) - (*(*Tsiginfo_t)(unsafe.Pointer(bp))).Fsi_signo = sig - (*(*Tsiginfo_t)(unsafe.Pointer(bp))).Fsi_code = -int32(1) + (**(**Tsiginfo_t)(__ccgo_up(bp))).Fsi_signo = sig + (**(**Tsiginfo_t)(__ccgo_up(bp))).Fsi_code = -int32(1) *(*Tsigval)(unsafe.Pointer(bp + 16 + 8)) = value *(*Tuid_t)(unsafe.Pointer(bp + 16 + 4)) = Xgetuid(tls) X__block_app_sigs(tls, bp+128) @@ -134981,7 +134981,7 @@ func Xsigwait(tls *TLS, mask uintptr, sig uintptr) (r int32) { if Xsigtimedwait(tls, mask, bp, uintptr(0)) < 0 { return -int32(1) } - *(*int32)(unsafe.Pointer(sig)) = (*(*Tsiginfo_t)(unsafe.Pointer(bp))).Fsi_signo + **(**int32)(__ccgo_up(sig)) = (**(**Tsiginfo_t)(__ccgo_up(bp))).Fsi_signo return 0 } @@ -135030,7 +135030,7 @@ func X__xmknod(tls *TLS, ver int32, path uintptr, mode Tmode_t, dev uintptr) (r trc("tls=%v ver=%v path=%v mode=%v dev=%v, (%v:)", tls, ver, path, mode, dev, origin(2)) defer func() { trc("-> %v", r) }() } - return Xmknod(tls, path, mode, *(*Tdev_t)(unsafe.Pointer(dev))) + return Xmknod(tls, path, mode, **(**Tdev_t)(__ccgo_up(dev))) } func X__xmknodat(tls *TLS, ver int32, fd int32, path uintptr, mode Tmode_t, dev uintptr) (r int32) { @@ -135038,7 +135038,7 @@ func X__xmknodat(tls *TLS, ver int32, fd int32, path uintptr, mode Tmode_t, dev trc("tls=%v ver=%v fd=%v path=%v mode=%v dev=%v, (%v:)", tls, ver, fd, path, mode, dev, origin(2)) defer func() { trc("-> %v", r) }() } - return Xmknodat(tls, fd, path, mode, *(*Tdev_t)(unsafe.Pointer(dev))) + return Xmknodat(tls, fd, path, mode, **(**Tdev_t)(__ccgo_up(dev))) } func Xchmod(tls *TLS, path uintptr, mode Tmode_t) (r int32) { @@ -135091,7 +135091,7 @@ func Xfchmodat(tls *TLS, fd int32, path uintptr, mode Tmode_t, flag int32) (r in if Xfstatat(tls, fd, path, bp, flag) != 0 { return -int32(1) } - if (*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { + if (**(**Tstat)(__ccgo_up(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { return int32(X__syscall_ret(tls, Uint64FromInt32(-Int32FromInt32(EOPNOTSUPP)))) } v1 = int32(X__syscall3(tls, int64(SYS_openat), int64(fd), int64(path), int64(Int32FromInt32(O_RDONLY)|Int32FromInt32(O_PATH)|Int32FromInt32(O_NOFOLLOW)|Int32FromInt32(O_NOCTTY)|Int32FromInt32(O_CLOEXEC)))) @@ -135105,7 +135105,7 @@ func Xfchmodat(tls *TLS, fd int32, path uintptr, mode Tmode_t, flag int32) (r in X__procfdname(tls, bp+128, Uint32FromInt32(fd2)) ret = Xstat(tls, bp+128, bp) if !(ret != 0) { - if (*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { + if (**(**Tstat)(__ccgo_up(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { ret = int32(X__syscall_ret(tls, Uint64FromInt32(-Int32FromInt32(EOPNOTSUPP)))) } else { ret = int32(X__syscall_ret(tls, Uint64FromInt64(X__syscall3(tls, int64(SYS_fchmodat), int64(-Int32FromInt32(100)), int64(bp+128), Int64FromUint32(mode))))) @@ -135185,28 +135185,28 @@ func _fstatat_statx(tls *TLS, fd int32, path uintptr, st uintptr, flag int32) (r if ret != 0 { return ret } - *(*Tstat)(unsafe.Pointer(st)) = Tstat{ - Fst_dev: uint64(uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_dev_major)&Uint64FromUint64(0xfffff000)<= 0 && !(*(*uint8)(unsafe.Pointer(path)) != 0) { + if flag == int32(AT_EMPTY_PATH) && fd >= 0 && !(**(**uint8)(__ccgo_up(path)) != 0) { ret = int32(X__syscall2(tls, int64(SYS_fstat), int64(fd), int64(bp))) if ret == -int32(EBADF) && X__syscall2(tls, int64(SYS_fcntl), int64(fd), int64(Int32FromInt32(F_GETFD))) >= 0 { ret = int32(X__syscall4(tls, int64(SYS_newfstatat), int64(fd), int64(path), int64(bp), int64(flag))) @@ -135256,28 +135256,28 @@ func _fstatat_kstat(tls *TLS, fd int32, path uintptr, st uintptr, flag int32) (r if ret != 0 { return ret } - *(*Tstat)(unsafe.Pointer(st)) = Tstat{ - Fst_dev: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_dev, - Fst_ino: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_ino, - Fst_mode: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_mode, - Fst_nlink: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_nlink, - Fst_uid: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_uid, - Fst_gid: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_gid, - Fst_rdev: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_rdev, - Fst_size: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_size, - Fst_blksize: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_blksize, - Fst_blocks: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_blocks, + **(**Tstat)(__ccgo_up(st)) = Tstat{ + Fst_dev: (**(**Tkstat)(__ccgo_up(bp))).Fst_dev, + Fst_ino: (**(**Tkstat)(__ccgo_up(bp))).Fst_ino, + Fst_mode: (**(**Tkstat)(__ccgo_up(bp))).Fst_mode, + Fst_nlink: (**(**Tkstat)(__ccgo_up(bp))).Fst_nlink, + Fst_uid: (**(**Tkstat)(__ccgo_up(bp))).Fst_uid, + Fst_gid: (**(**Tkstat)(__ccgo_up(bp))).Fst_gid, + Fst_rdev: (**(**Tkstat)(__ccgo_up(bp))).Fst_rdev, + Fst_size: (**(**Tkstat)(__ccgo_up(bp))).Fst_size, + Fst_blksize: (**(**Tkstat)(__ccgo_up(bp))).Fst_blksize, + Fst_blocks: (**(**Tkstat)(__ccgo_up(bp))).Fst_blocks, Fst_atim: Ttimespec{ - Ftv_sec: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_atime_sec, - Ftv_nsec: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_atime_nsec, + Ftv_sec: (**(**Tkstat)(__ccgo_up(bp))).Fst_atime_sec, + Ftv_nsec: (**(**Tkstat)(__ccgo_up(bp))).Fst_atime_nsec, }, Fst_mtim: Ttimespec{ - Ftv_sec: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_mtime_sec, - Ftv_nsec: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_mtime_nsec, + Ftv_sec: (**(**Tkstat)(__ccgo_up(bp))).Fst_mtime_sec, + Ftv_nsec: (**(**Tkstat)(__ccgo_up(bp))).Fst_mtime_nsec, }, Fst_ctim: Ttimespec{ - Ftv_sec: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_ctime_sec, - Ftv_nsec: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_ctime_nsec, + Ftv_sec: (**(**Tkstat)(__ccgo_up(bp))).Fst_ctime_sec, + Ftv_nsec: (**(**Tkstat)(__ccgo_up(bp))).Fst_ctime_nsec, }, } return 0 @@ -135333,11 +135333,11 @@ func X__futimesat(tls *TLS, dirfd int32, pathname uintptr, times uintptr) (r int if !(i < int32(2)) { break } - if Uint64FromInt64((*(*Ttimeval)(unsafe.Pointer(times + uintptr(i)*16))).Ftv_usec) >= uint64(1000000) { + if Uint64FromInt64((**(**Ttimeval)(__ccgo_up(times + uintptr(i)*16))).Ftv_usec) >= uint64(1000000) { return int32(X__syscall_ret(tls, Uint64FromInt32(-Int32FromInt32(EINVAL)))) } - (*(*[2]Ttimespec)(unsafe.Pointer(bp)))[i].Ftv_sec = (*(*Ttimeval)(unsafe.Pointer(times + uintptr(i)*16))).Ftv_sec - (*(*[2]Ttimespec)(unsafe.Pointer(bp)))[i].Ftv_nsec = (*(*Ttimeval)(unsafe.Pointer(times + uintptr(i)*16))).Ftv_usec * int64(1000) + (**(**[2]Ttimespec)(__ccgo_up(bp)))[i].Ftv_sec = (**(**Ttimeval)(__ccgo_up(times + uintptr(i)*16))).Ftv_sec + (**(**[2]Ttimespec)(__ccgo_up(bp)))[i].Ftv_nsec = (**(**Ttimeval)(__ccgo_up(times + uintptr(i)*16))).Ftv_usec * int64(1000) goto _1 _1: ; @@ -135433,7 +135433,7 @@ func Xstat(tls *TLS, path uintptr, buf uintptr) (r int32) { } func ___statfs(tls *TLS, path uintptr, buf uintptr) (r int32) { - *(*Tstatfs)(unsafe.Pointer(buf)) = Tstatfs{} + **(**Tstatfs)(__ccgo_up(buf)) = Tstatfs{} return int32(X__syscall_ret(tls, Uint64FromInt64(X__syscall2(tls, int64(SYS_statfs), int64(path), int64(buf))))) } @@ -135442,14 +135442,14 @@ func Xfstatfs(tls *TLS, fd int32, buf uintptr) (r int32) { trc("tls=%v fd=%v buf=%v, (%v:)", tls, fd, buf, origin(2)) defer func() { trc("-> %v", r) }() } - *(*Tstatfs)(unsafe.Pointer(buf)) = Tstatfs{} + **(**Tstatfs)(__ccgo_up(buf)) = Tstatfs{} return int32(X__syscall_ret(tls, Uint64FromInt64(X__syscall2(tls, int64(SYS_fstatfs), int64(fd), int64(buf))))) } func _fixup(tls *TLS, out uintptr, in uintptr) { var v1 uint64 _ = v1 - *(*Tstatvfs)(unsafe.Pointer(out)) = Tstatvfs{} + **(**Tstatvfs)(__ccgo_up(out)) = Tstatvfs{} (*Tstatvfs)(unsafe.Pointer(out)).Ff_bsize = (*Tstatfs)(unsafe.Pointer(in)).Ff_bsize if (*Tstatfs)(unsafe.Pointer(in)).Ff_frsize != 0 { v1 = (*Tstatfs)(unsafe.Pointer(in)).Ff_frsize @@ -135463,7 +135463,7 @@ func _fixup(tls *TLS, out uintptr, in uintptr) { (*Tstatvfs)(unsafe.Pointer(out)).Ff_files = (*Tstatfs)(unsafe.Pointer(in)).Ff_files (*Tstatvfs)(unsafe.Pointer(out)).Ff_ffree = (*Tstatfs)(unsafe.Pointer(in)).Ff_ffree (*Tstatvfs)(unsafe.Pointer(out)).Ff_favail = (*Tstatfs)(unsafe.Pointer(in)).Ff_ffree - (*Tstatvfs)(unsafe.Pointer(out)).Ff_fsid = Uint64FromInt32(*(*int32)(unsafe.Pointer(in + 56))) + (*Tstatvfs)(unsafe.Pointer(out)).Ff_fsid = Uint64FromInt32(**(**int32)(__ccgo_up(in + 56))) (*Tstatvfs)(unsafe.Pointer(out)).Ff_flag = (*Tstatfs)(unsafe.Pointer(in)).Ff_flags (*Tstatvfs)(unsafe.Pointer(out)).Ff_namemax = (*Tstatfs)(unsafe.Pointer(in)).Ff_namelen (*Tstatvfs)(unsafe.Pointer(out)).Ff_type = uint32((*Tstatfs)(unsafe.Pointer(in)).Ff_type) @@ -135514,7 +135514,7 @@ func Xutimensat(tls *TLS, fd int32, path uintptr, times uintptr, flags int32) (r } var r int32 _ = r - if times != 0 && (*(*Ttimespec)(unsafe.Pointer(times))).Ftv_nsec == int64(UTIME_NOW) && (*(*Ttimespec)(unsafe.Pointer(times + 1*16))).Ftv_nsec == int64(UTIME_NOW) { + if times != 0 && (**(**Ttimespec)(__ccgo_up(times))).Ftv_nsec == int64(UTIME_NOW) && (**(**Ttimespec)(__ccgo_up(times + 1*16))).Ftv_nsec == int64(UTIME_NOW) { times = uintptr(0) } r = int32(X__syscall4(tls, int64(SYS_utimensat), int64(fd), int64(path), int64(times), int64(flags))) @@ -135541,8 +135541,8 @@ func X__fdopen(tls *TLS, fd int32, mode uintptr) (r uintptr) { var _ /* wsz at bp+0 */ Twinsize _, _, _, _ = f, flags, v1, v2 /* Check for valid initial mode character */ - if !(Xstrchr(tls, __ccgo_ts+1543, Int32FromUint8(*(*uint8)(unsafe.Pointer(mode)))) != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if !(Xstrchr(tls, __ccgo_ts+1543, Int32FromUint8(**(**uint8)(__ccgo_up(mode)))) != 0) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } /* Allocate FILE+buffer or fail */ @@ -135555,7 +135555,7 @@ func X__fdopen(tls *TLS, fd int32, mode uintptr) (r uintptr) { Xmemset(tls, f, 0, uint64(232)) /* Impose mode restrictions */ if !(Xstrchr(tls, mode, int32('+')) != 0) { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('r') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) == int32('r') { v2 = int32(F_NOWR) } else { v2 = int32(F_NORD) @@ -135567,12 +135567,12 @@ func X__fdopen(tls *TLS, fd int32, mode uintptr) (r uintptr) { X__syscall3(tls, int64(SYS_fcntl), int64(fd), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) } /* Set append mode on fd if opened for append */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('a') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) == int32('a') { flags = int32(X__syscall2(tls, int64(SYS_fcntl), int64(fd), int64(Int32FromInt32(F_GETFL)))) if !(flags&Int32FromInt32(O_APPEND) != 0) { X__syscall3(tls, int64(SYS_fcntl), int64(fd), int64(Int32FromInt32(F_SETFL)), int64(flags|Int32FromInt32(O_APPEND))) } - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_APP) + **(**uint32)(__ccgo_up(f)) |= uint32(F_APP) } (*TFILE)(unsafe.Pointer(f)).Ffd = fd (*TFILE)(unsafe.Pointer(f)).Fbuf = f + uintptr(232) + uintptr(UNGET) @@ -135612,7 +135612,7 @@ func X__fmodeflags(tls *TLS, mode uintptr) (r int32) { if Xstrchr(tls, mode, int32('+')) != 0 { flags = int32(O_RDWR) } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('r') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) == int32('r') { flags = O_RDONLY } else { flags = int32(O_WRONLY) @@ -135624,13 +135624,13 @@ func X__fmodeflags(tls *TLS, mode uintptr) (r int32) { if Xstrchr(tls, mode, int32('e')) != 0 { flags = flags | int32(O_CLOEXEC) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) != int32('r') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) != int32('r') { flags = flags | int32(O_CREAT) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('w') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) == int32('w') { flags = flags | int32(O_TRUNC) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('a') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) == int32('a') { flags = flags | int32(O_APPEND) } return flags @@ -135668,22 +135668,22 @@ func X__overflow(tls *TLS, f uintptr, _c int32) (r int32) { var v2, v3 uintptr var _ /* c at bp+0 */ uint8 _, _, _ = v1, v2, v3 - *(*uint8)(unsafe.Pointer(bp)) = Uint8FromInt32(_c) + **(**uint8)(__ccgo_up(bp)) = Uint8FromInt32(_c) if !((*TFILE)(unsafe.Pointer(f)).Fwend != 0) && X__towrite(tls, f) != 0 { return -int32(1) } - if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwend && Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) != (*TFILE)(unsafe.Pointer(f)).Flbf { - v1 = *(*uint8)(unsafe.Pointer(bp)) + if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwend && Int32FromUint8(**(**uint8)(__ccgo_up(bp))) != (*TFILE)(unsafe.Pointer(f)).Flbf { + v1 = **(**uint8)(__ccgo_up(bp)) v3 = f + 40 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - *(*uint8)(unsafe.Pointer(v2)) = v1 + **(**uint8)(__ccgo_up(v2)) = v1 return Int32FromUint8(v1) } if (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fwrite})))(tls, f, bp, uint64(1)) != uint64(1) { return -int32(1) } - return Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) + return Int32FromUint8(**(**uint8)(__ccgo_up(bp))) } func _dummy9(tls *TLS, fd int32) (r int32) { @@ -135721,7 +135721,7 @@ func X__stdio_exit(tls *TLS) { } var f uintptr _ = f - f = *(*uintptr)(unsafe.Pointer(X__ofl_lock(tls))) + f = **(**uintptr)(__ccgo_up(X__ofl_lock(tls))) for { if !(f != 0) { break @@ -135757,7 +135757,7 @@ func X__stdio_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { var v3, v4 uintptr var _ /* iov at bp+0 */ [2]Tiovec _, _, _, _, _ = cnt, v1, v2, v3, v4 - *(*[2]Tiovec)(unsafe.Pointer(bp)) = [2]Tiovec{ + **(**[2]Tiovec)(__ccgo_up(bp)) = [2]Tiovec{ 0: { Fiov_base: buf, Fiov_len: len1 - BoolUint64(!!((*TFILE)(unsafe.Pointer(f)).Fbuf_size != 0)), @@ -135767,10 +135767,10 @@ func X__stdio_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { Fiov_len: (*TFILE)(unsafe.Pointer(f)).Fbuf_size, }, } - if (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len != 0 { + if (**(**[2]Tiovec)(__ccgo_up(bp)))[0].Fiov_len != 0 { v1 = X__syscall_ret(tls, Uint64FromInt64(X__syscall3(tls, int64(SYS_readv), int64((*TFILE)(unsafe.Pointer(f)).Ffd), int64(bp), int64(Int32FromInt32(2))))) } else { - v1 = X__syscall_ret(tls, Uint64FromInt64(X__syscall3(tls, int64(SYS_read), int64((*TFILE)(unsafe.Pointer(f)).Ffd), int64((*(*[2]Tiovec)(unsafe.Pointer(bp)))[int32(1)].Fiov_base), Int64FromUint64((*(*[2]Tiovec)(unsafe.Pointer(bp)))[int32(1)].Fiov_len)))) + v1 = X__syscall_ret(tls, Uint64FromInt64(X__syscall3(tls, int64(SYS_read), int64((*TFILE)(unsafe.Pointer(f)).Ffd), int64((**(**[2]Tiovec)(__ccgo_up(bp)))[int32(1)].Fiov_base), Int64FromUint64((**(**[2]Tiovec)(__ccgo_up(bp)))[int32(1)].Fiov_len)))) } cnt = v1 if cnt <= 0 { @@ -135779,20 +135779,20 @@ func X__stdio_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { } else { v2 = int32(F_EOF) } - *(*uint32)(unsafe.Pointer(f)) |= Uint32FromInt32(v2) + **(**uint32)(__ccgo_up(f)) |= Uint32FromInt32(v2) return uint64(0) } - if Uint64FromInt64(cnt) <= (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len { + if Uint64FromInt64(cnt) <= (**(**[2]Tiovec)(__ccgo_up(bp)))[0].Fiov_len { return Uint64FromInt64(cnt) } - cnt = Int64FromUint64(uint64(cnt) - (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len) + cnt = Int64FromUint64(uint64(cnt) - (**(**[2]Tiovec)(__ccgo_up(bp)))[0].Fiov_len) (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(cnt) if (*TFILE)(unsafe.Pointer(f)).Fbuf_size != 0 { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(buf + uintptr(len1-uint64(1)))) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(buf + uintptr(len1-uint64(1)))) = **(**uint8)(__ccgo_up(v3)) } return len1 } @@ -135819,7 +135819,7 @@ func X__stdio_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) var v5 uint64 var _ /* iovs at bp+0 */ [2]Tiovec _, _, _, _, _, _, _ = cnt, iov, iovcnt, rem, v2, v3, v5 - *(*[2]Tiovec)(unsafe.Pointer(bp)) = [2]Tiovec{ + **(**[2]Tiovec)(__ccgo_up(bp)) = [2]Tiovec{ 0: { Fiov_base: (*TFILE)(unsafe.Pointer(f)).Fwbase, Fiov_len: Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Fwpos) - int64((*TFILE)(unsafe.Pointer(f)).Fwbase)), @@ -135830,7 +135830,7 @@ func X__stdio_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) }, } iov = bp - rem = (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len + (*(*Tiovec)(unsafe.Pointer(iov + 1*16))).Fiov_len + rem = (**(**Tiovec)(__ccgo_up(iov))).Fiov_len + (**(**Tiovec)(__ccgo_up(iov + 1*16))).Fiov_len iovcnt = int32(2) for { cnt = X__syscall_ret(tls, Uint64FromInt64(X__syscall3(tls, int64(SYS_writev), int64((*TFILE)(unsafe.Pointer(f)).Ffd), int64(iov), int64(iovcnt)))) @@ -135847,22 +135847,22 @@ func X__stdio_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) v2 = v3 (*TFILE)(unsafe.Pointer(f)).Fwbase = v2 (*TFILE)(unsafe.Pointer(f)).Fwpos = v2 - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) if iovcnt == int32(2) { v5 = uint64(0) } else { - v5 = len1 - (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len + v5 = len1 - (**(**Tiovec)(__ccgo_up(iov))).Fiov_len } return v5 } rem = rem - Uint64FromInt64(cnt) - if Uint64FromInt64(cnt) > (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len { - cnt = Int64FromUint64(uint64(cnt) - (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len) + if Uint64FromInt64(cnt) > (**(**Tiovec)(__ccgo_up(iov))).Fiov_len { + cnt = Int64FromUint64(uint64(cnt) - (**(**Tiovec)(__ccgo_up(iov))).Fiov_len) iov += 16 iovcnt = iovcnt - 1 } - (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_base = (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_base + uintptr(cnt) - (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len -= Uint64FromInt64(cnt) + (**(**Tiovec)(__ccgo_up(iov))).Fiov_base = (**(**Tiovec)(__ccgo_up(iov))).Fiov_base + uintptr(cnt) + (**(**Tiovec)(__ccgo_up(iov))).Fiov_len -= Uint64FromInt64(cnt) goto _1 _1: } @@ -135892,7 +135892,7 @@ func X__toread(tls *TLS, f uintptr) (r int32) { var v1, v2 uintptr var v4 int32 _, _, _ = v1, v2, v4 - *(*int32)(unsafe.Pointer(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) + **(**int32)(__ccgo_up(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwbase { (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fwrite})))(tls, f, uintptr(0), uint64(0)) } @@ -135902,7 +135902,7 @@ func X__toread(tls *TLS, f uintptr) (r int32) { (*TFILE)(unsafe.Pointer(f)).Fwbase = v1 (*TFILE)(unsafe.Pointer(f)).Fwpos = v1 if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_NORD) != 0 { - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) return -int32(1) } v1 = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr((*TFILE)(unsafe.Pointer(f)).Fbuf_size) @@ -135930,9 +135930,9 @@ func X__towrite(tls *TLS, f uintptr) (r int32) { } var v1 uintptr _ = v1 - *(*int32)(unsafe.Pointer(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) + **(**int32)(__ccgo_up(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_NOWR) != 0 { - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) return -int32(1) } /* Clear read buffer (easier than summoning nasal demons) */ @@ -135966,7 +135966,7 @@ func X__uflow(tls *TLS, f uintptr) (r int32) { defer tls.Free(16) var _ /* c at bp+0 */ uint8 if !(X__toread(tls, f) != 0) && (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fread})))(tls, f, bp, uint64(1)) == uint64(1) { - return Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) + return Int32FromUint8(**(**uint8)(__ccgo_up(bp))) } return -int32(1) } @@ -135997,7 +135997,7 @@ func Xclearerr(tls *TLS, f uintptr) { v1 = 0 } __need_unlock = v1 - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^(Int32FromInt32(F_EOF) | Int32FromInt32(F_ERR))) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^(Int32FromInt32(F_EOF) | Int32FromInt32(F_ERR))) if __need_unlock != 0 { ___unlockfile(tls, f) } @@ -136158,7 +136158,7 @@ func X__freadptr(tls *TLS, f uintptr, sizep uintptr) (r uintptr) { if (*TFILE)(unsafe.Pointer(f)).Frpos == (*TFILE)(unsafe.Pointer(f)).Frend { return uintptr(0) } - *(*Tsize_t)(unsafe.Pointer(sizep)) = Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Frend) - int64((*TFILE)(unsafe.Pointer(f)).Frpos)) + **(**Tsize_t)(__ccgo_up(sizep)) = Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Frend) - int64((*TFILE)(unsafe.Pointer(f)).Frpos)) return (*TFILE)(unsafe.Pointer(f)).Frpos } @@ -136166,14 +136166,14 @@ func X__freadptrinc(tls *TLS, f uintptr, inc Tsize_t) { if __ccgo_strace { trc("tls=%v f=%v inc=%v, (%v:)", tls, f, inc, origin(2)) } - *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(inc) + **(**uintptr)(__ccgo_up(f + 8)) += uintptr(inc) } func X__fseterr(tls *TLS, f uintptr) { if __ccgo_strace { trc("tls=%v f=%v, (%v:)", tls, f, origin(2)) } - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) } func _dummy10(tls *TLS, f uintptr) { @@ -136216,8 +136216,8 @@ func Xfclose(tls *TLS, f uintptr) (r1 int32) { if (*TFILE)(unsafe.Pointer(f)).Fnext != 0 { (*TFILE)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Fnext)).Fprev = (*TFILE)(unsafe.Pointer(f)).Fprev } - if *(*uintptr)(unsafe.Pointer(head)) == f { - *(*uintptr)(unsafe.Pointer(head)) = (*TFILE)(unsafe.Pointer(f)).Fnext + if **(**uintptr)(__ccgo_up(head)) == f { + **(**uintptr)(__ccgo_up(head)) = (*TFILE)(unsafe.Pointer(f)).Fnext } X__ofl_unlock(tls) Xfree(tls, (*TFILE)(unsafe.Pointer(f)).Fgetln_buf) @@ -136318,7 +136318,7 @@ func Xfflush(tls *TLS, f uintptr) (r1 int32) { if AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stderr_used))) != 0 { r = r | Xfflush(tls, AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stderr_used)))) } - f = *(*uintptr)(unsafe.Pointer(X__ofl_lock(tls))) + f = **(**uintptr)(__ccgo_up(X__ofl_lock(tls))) for { if !(f != 0) { break @@ -136407,7 +136407,7 @@ _2: v5 = f + 8 v4 = *(*uintptr)(unsafe.Pointer(v5)) *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v4))) } else { v1 = X__uflow(tls, f) } @@ -136466,7 +136466,7 @@ func Xfgetc(tls *TLS, f1 uintptr) (r int32) { v6 = v1 + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(v5))) } else { v4 = X__uflow(tls, v1) } @@ -136502,7 +136502,7 @@ func Xfgetln(tls *TLS, f uintptr, plen uintptr) (r uintptr) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__uflow(tls, f) } @@ -136515,14 +136515,14 @@ func Xfgetln(tls *TLS, f uintptr, plen uintptr) (r uintptr) { ret = (*TFILE)(unsafe.Pointer(f)).Frpos z = z + 1 v3 = z - *(*Tsize_t)(unsafe.Pointer(plen)) = Uint64FromInt64(int64(v3) - int64(ret)) + **(**Tsize_t)(__ccgo_up(plen)) = Uint64FromInt64(int64(v3) - int64(ret)) (*TFILE)(unsafe.Pointer(f)).Frpos = z } else { *(*[1]Tsize_t)(unsafe.Pointer(bp)) = [1]Tsize_t{} v8 = Xgetline(tls, f+168, bp, f) l = v8 if v8 > 0 { - *(*Tsize_t)(unsafe.Pointer(plen)) = Uint64FromInt64(l) + **(**Tsize_t)(__ccgo_up(plen)) = Uint64FromInt64(l) ret = (*TFILE)(unsafe.Pointer(f)).Fgetln_buf } } @@ -136543,7 +136543,7 @@ func Xfgetpos(tls *TLS, f uintptr, pos uintptr) (r int32) { if off < 0 { return -int32(1) } - *(*int64)(unsafe.Pointer(pos)) = off + **(**int64)(__ccgo_up(pos)) = off return 0 } @@ -136567,14 +136567,14 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { } __need_unlock = v1 if n <= int32(1) { - *(*int32)(unsafe.Pointer(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) + **(**int32)(__ccgo_up(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) if __need_unlock != 0 { ___unlockfile(tls, f) } if n < int32(1) { return uintptr(0) } - *(*uint8)(unsafe.Pointer(s)) = uint8(0) + **(**uint8)(__ccgo_up(s)) = uint8(0) return s } n = n - 1 @@ -136594,7 +136594,7 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { } k = v3 Xmemcpy(tls, p, (*TFILE)(unsafe.Pointer(f)).Frpos, k) - *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(k) + **(**uintptr)(__ccgo_up(f + 8)) += uintptr(k) p = p + uintptr(k) n = Int32FromUint64(uint64(n) - k) if z != 0 || !(n != 0) { @@ -136605,7 +136605,7 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { v7 = f + 8 v6 = *(*uintptr)(unsafe.Pointer(v7)) *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) + 1 - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(v6))) } else { v4 = X__uflow(tls, f) } @@ -136621,13 +136621,13 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { v8 = Uint8FromInt32(c) v6 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v6)) = v8 + **(**uint8)(__ccgo_up(v6)) = v8 if Int32FromUint8(v8) == int32('\n') { break } } if s != 0 { - *(*uint8)(unsafe.Pointer(p)) = uint8(0) + **(**uint8)(__ccgo_up(p)) = uint8(0) } if __need_unlock != 0 { ___unlockfile(tls, f) @@ -136657,43 +136657,43 @@ func ___fgetwc_unlocked_internal(tls *TLS, f uintptr) (r Twint_t) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { l = Uint64FromInt32(Xmbtowc(tls, bp, (*TFILE)(unsafe.Pointer(f)).Frpos, Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Frend)-int64((*TFILE)(unsafe.Pointer(f)).Frpos)))) if l+uint64(1) >= uint64(1) { - *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(l + BoolUint64(!(l != 0))) /* l==0 means 1 byte, null */ - return Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))) + **(**uintptr)(__ccgo_up(f + 8)) += uintptr(l + BoolUint64(!(l != 0))) /* l==0 means 1 byte, null */ + return Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))) } } /* Convert character byte-by-byte */ - *(*Tmbstate_t)(unsafe.Pointer(bp + 8)) = Tmbstate_t{} + **(**Tmbstate_t)(__ccgo_up(bp + 8)) = Tmbstate_t{} first = int32(1) for cond := true; cond; cond = l == Uint64FromInt32(-Int32FromInt32(2)) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__uflow(tls, f) } v1 = v2 c = v1 - *(*uint8)(unsafe.Pointer(bp + 16)) = Uint8FromInt32(v1) + **(**uint8)(__ccgo_up(bp + 16)) = Uint8FromInt32(v1) if c < 0 { if !(first != 0) { - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EILSEQ) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EILSEQ) } return uint32(0xffffffff) } l = Xmbrtowc(tls, bp, bp+16, uint64(1), bp+8) if l == Uint64FromInt32(-Int32FromInt32(1)) { if !(first != 0) { - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) - Xungetc(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + 16))), f) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) + Xungetc(tls, Int32FromUint8(**(**uint8)(__ccgo_up(bp + 16))), f) } return uint32(0xffffffff) } first = 0 } - return Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))) + return Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))) } func X__fgetwc_unlocked(tls *TLS, f uintptr) (r Twint_t) { @@ -136706,13 +136706,13 @@ func X__fgetwc_unlocked(tls *TLS, f uintptr) (r Twint_t) { var wc Twchar_t _, _, _ = loc, ploc, wc ploc = uintptr(___get_tp(tls)) + 152 - loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) + loc = **(**Tlocale_t)(__ccgo_up(ploc)) if (*TFILE)(unsafe.Pointer(f)).Fmode <= 0 { Xfwide(tls, f, int32(1)) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale + **(**Tlocale_t)(__ccgo_up(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale wc = Int32FromUint32(___fgetwc_unlocked_internal(tls, f)) - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return Uint32FromInt32(wc) } @@ -136784,7 +136784,7 @@ func Xfgetws(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { } v4 = p p += 4 - *(*Twchar_t)(unsafe.Pointer(v4)) = Int32FromUint32(c) + **(**Twchar_t)(__ccgo_up(v4)) = Int32FromUint32(c) if c == uint32('\n') { break } @@ -136793,7 +136793,7 @@ func Xfgetws(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { ; n = n - 1 } - *(*Twchar_t)(unsafe.Pointer(p)) = 0 + **(**Twchar_t)(__ccgo_up(p)) = 0 if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_ERR) != 0 { p = s } @@ -136834,7 +136834,7 @@ func Xfileno(tls *TLS, f uintptr) (r int32) { ___unlockfile(tls, f) } if fd < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EBADF) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EBADF) return -int32(1) } return fd @@ -136887,7 +136887,7 @@ func _mseek(tls *TLS, f uintptr, off Toff_t, whence int32) (r Toff_t) { goto fail fail: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) _1: ; @@ -136895,7 +136895,7 @@ _1: 1: (*Tcookie)(unsafe.Pointer(c)).Fpos, 2: (*Tcookie)(unsafe.Pointer(c)).Flen1, } - base = Int64FromUint64(*(*Tsize_t)(unsafe.Pointer(bp + uintptr(whence)*8))) + base = Int64FromUint64(**(**Tsize_t)(__ccgo_up(bp + uintptr(whence)*8))) if off < -base || off > Int64FromUint64((*Tcookie)(unsafe.Pointer(c)).Fsize)-base { goto fail } @@ -136915,10 +136915,10 @@ func _mread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { } if len1 > rem { len1 = rem - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_EOF) + **(**uint32)(__ccgo_up(f)) |= uint32(F_EOF) } Xmemcpy(tls, buf, (*Tcookie)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie)(unsafe.Pointer(c)).Fpos), len1) - *(*Tsize_t)(unsafe.Pointer(c)) += len1 + **(**Tsize_t)(__ccgo_up(c)) += len1 rem = rem - len1 if rem > (*TFILE)(unsafe.Pointer(f)).Fbuf_size { rem = (*TFILE)(unsafe.Pointer(f)).Fbuf_size @@ -136926,7 +136926,7 @@ func _mread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(rem) Xmemcpy(tls, (*TFILE)(unsafe.Pointer(f)).Frpos, (*Tcookie)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie)(unsafe.Pointer(c)).Fpos), rem) - *(*Tsize_t)(unsafe.Pointer(c)) += rem + **(**Tsize_t)(__ccgo_up(c)) += rem return len1 } @@ -136950,14 +136950,14 @@ func _mwrite(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { len1 = rem } Xmemcpy(tls, (*Tcookie)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie)(unsafe.Pointer(c)).Fpos), buf, len1) - *(*Tsize_t)(unsafe.Pointer(c)) += len1 + **(**Tsize_t)(__ccgo_up(c)) += len1 if (*Tcookie)(unsafe.Pointer(c)).Fpos > (*Tcookie)(unsafe.Pointer(c)).Flen1 { (*Tcookie)(unsafe.Pointer(c)).Flen1 = (*Tcookie)(unsafe.Pointer(c)).Fpos if (*Tcookie)(unsafe.Pointer(c)).Flen1 < (*Tcookie)(unsafe.Pointer(c)).Fsize { - *(*uint8)(unsafe.Pointer((*Tcookie)(unsafe.Pointer(c)).Fbuf + uintptr((*Tcookie)(unsafe.Pointer(c)).Flen1))) = uint8(0) + **(**uint8)(__ccgo_up((*Tcookie)(unsafe.Pointer(c)).Fbuf + uintptr((*Tcookie)(unsafe.Pointer(c)).Flen1))) = uint8(0) } else { if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_NORD) != 0 && (*Tcookie)(unsafe.Pointer(c)).Fsize != 0 { - *(*uint8)(unsafe.Pointer((*Tcookie)(unsafe.Pointer(c)).Fbuf + uintptr((*Tcookie)(unsafe.Pointer(c)).Fsize-uint64(1)))) = uint8(0) + **(**uint8)(__ccgo_up((*Tcookie)(unsafe.Pointer(c)).Fbuf + uintptr((*Tcookie)(unsafe.Pointer(c)).Fsize-uint64(1)))) = uint8(0) } } } @@ -136979,12 +136979,12 @@ func Xfmemopen(tls *TLS, buf uintptr, size Tsize_t, mode uintptr) (r uintptr) { var v3 Tsize_t _, _, _, _, _ = f, plus, v1, v2, v3 plus = BoolInt32(!!(Xstrchr(tls, mode, int32('+')) != 0)) - if !(Xstrchr(tls, __ccgo_ts+1543, Int32FromUint8(*(*uint8)(unsafe.Pointer(mode)))) != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if !(Xstrchr(tls, __ccgo_ts+1543, Int32FromUint8(**(**uint8)(__ccgo_up(mode)))) != 0) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } if !(buf != 0) && size > Uint64FromInt64(Int64FromInt64(INT64_MAX)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return uintptr(0) } if buf != 0 { @@ -137008,25 +137008,25 @@ func Xfmemopen(tls *TLS, buf uintptr, size Tsize_t, mode uintptr) (r uintptr) { } (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fbuf = buf (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fsize = size - (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fmode = Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) + (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fmode = Int32FromUint8(**(**uint8)(__ccgo_up(mode))) if !(plus != 0) { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('r') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) == int32('r') { v2 = int32(F_NOWR) } else { v2 = int32(F_NORD) } (*Tmem_FILE)(unsafe.Pointer(f)).Ff.Fflags = Uint32FromInt32(v2) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('r') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) == int32('r') { (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Flen1 = size } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('a') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) == int32('a') { v3 = Xstrnlen(tls, buf, size) (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fpos = v3 (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Flen1 = v3 } else { if plus != 0 { - *(*uint8)(unsafe.Pointer((*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fbuf)) = uint8(0) + **(**uint8)(__ccgo_up((*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fbuf)) = uint8(0) } } } @@ -137049,8 +137049,8 @@ func Xfopen(tls *TLS, filename uintptr, mode uintptr) (r uintptr) { var fd, flags int32 _, _, _ = f, fd, flags /* Check for valid initial mode character */ - if !(Xstrchr(tls, __ccgo_ts+1543, Int32FromUint8(*(*uint8)(unsafe.Pointer(mode)))) != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if !(Xstrchr(tls, __ccgo_ts+1543, Int32FromUint8(**(**uint8)(__ccgo_up(mode)))) != 0) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } /* Compute the flags to pass to open() */ @@ -137117,7 +137117,7 @@ func _cookieread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - *(*uint8)(unsafe.Pointer(buf + uintptr(v1))) = *(*uint8)(unsafe.Pointer(v2)) + **(**uint8)(__ccgo_up(buf + uintptr(v1))) = **(**uint8)(__ccgo_up(v2)) return readlen goto bail bail: @@ -137127,7 +137127,7 @@ bail: } else { v4 = int32(F_ERR) } - *(*uint32)(unsafe.Pointer(f)) |= Uint32FromInt32(v4) + **(**uint32)(__ccgo_up(f)) |= Uint32FromInt32(v4) v2 = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = v2 (*TFILE)(unsafe.Pointer(f)).Frpos = v2 @@ -137157,7 +137157,7 @@ func _cookiewrite(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { v1 = v2 (*TFILE)(unsafe.Pointer(f)).Fwbase = v1 (*TFILE)(unsafe.Pointer(f)).Fwpos = v1 - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) return uint64(0) } return Uint64FromInt64(ret) @@ -137172,18 +137172,18 @@ func _cookieseek(tls *TLS, f uintptr, _off Toff_t, whence int32) (r Toff_t) { _, _ = fc, res fc = (*TFILE)(unsafe.Pointer(f)).Fcookie if Uint32FromInt32(whence) > uint32(2) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) } if !((*Tfcookie)(unsafe.Pointer(fc)).Fiofuncs.Fseek != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOPNOTSUPP) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOPNOTSUPP) return int64(-int32(1)) } res = (*(*func(*TLS, uintptr, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{(*Tfcookie)(unsafe.Pointer(fc)).Fiofuncs.Fseek})))(tls, (*Tfcookie)(unsafe.Pointer(fc)).Fcookie, bp, whence) if res < 0 { return int64(res) } - return *(*Toff_t)(unsafe.Pointer(bp)) + return **(**Toff_t)(__ccgo_up(bp)) } func _cookieclose(tls *TLS, f uintptr) (r int32) { @@ -137205,8 +137205,8 @@ func Xfopencookie(tls *TLS, cookie uintptr, mode uintptr, iofuncs Tcookie_io_fun var v2 int32 _, _, _ = f, v1, v2 /* Check for valid initial mode character */ - if !(Xstrchr(tls, __ccgo_ts+1543, Int32FromUint8(*(*uint8)(unsafe.Pointer(mode)))) != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if !(Xstrchr(tls, __ccgo_ts+1543, Int32FromUint8(**(**uint8)(__ccgo_up(mode)))) != 0) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } /* Allocate FILE+fcookie+buffer or fail */ @@ -137219,7 +137219,7 @@ func Xfopencookie(tls *TLS, cookie uintptr, mode uintptr, iofuncs Tcookie_io_fun Xmemset(tls, f, 0, uint64(232)) /* Impose mode restrictions */ if !(Xstrchr(tls, mode, int32('+')) != 0) { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('r') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) == int32('r') { v2 = int32(F_NOWR) } else { v2 = int32(F_NORD) @@ -137280,7 +137280,7 @@ _2: v6 = f + 40 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - *(*uint8)(unsafe.Pointer(v5)) = v4 + **(**uint8)(__ccgo_up(v5)) = v4 v1 = Int32FromUint8(v4) } else { v1 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) @@ -137343,7 +137343,7 @@ func Xfputc(tls *TLS, c1 int32, f1 uintptr) (r int32) { v8 = v2 + 40 v7 = *(*uintptr)(unsafe.Pointer(v8)) *(*uintptr)(unsafe.Pointer(v8)) = *(*uintptr)(unsafe.Pointer(v8)) + 1 - *(*uint8)(unsafe.Pointer(v7)) = v6 + **(**uint8)(__ccgo_up(v7)) = v6 v5 = Int32FromUint8(v6) } else { v5 = X__overflow(tls, v2, Int32FromUint8(Uint8FromInt32(v1))) @@ -137390,18 +137390,18 @@ func X__fputwc_unlocked(tls *TLS, c Twchar_t, f uintptr) (r Twint_t) { var _ /* mbc at bp+0 */ [4]uint8 _, _, _, _, _, _, _ = l, loc, ploc, v1, v2, v3, v4 ploc = uintptr(___get_tp(tls)) + 152 - loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) + loc = **(**Tlocale_t)(__ccgo_up(ploc)) if (*TFILE)(unsafe.Pointer(f)).Fmode <= 0 { Xfwide(tls, f, int32(1)) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale + **(**Tlocale_t)(__ccgo_up(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale if BoolInt32(Uint32FromInt32(c) < uint32(128)) != 0 { if Int32FromUint8(Uint8FromInt32(c)) != (*TFILE)(unsafe.Pointer(f)).Flbf && (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwend { v2 = Uint8FromInt32(c) v4 = f + 40 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(v3)) = v2 + **(**uint8)(__ccgo_up(v3)) = v2 v1 = Int32FromUint8(v2) } else { v1 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) @@ -137413,7 +137413,7 @@ func X__fputwc_unlocked(tls *TLS, c Twchar_t, f uintptr) (r Twint_t) { if l < 0 { c = Int32FromUint32(0xffffffff) } else { - *(*uintptr)(unsafe.Pointer(f + 40)) += uintptr(l) + **(**uintptr)(__ccgo_up(f + 40)) += uintptr(l) } } else { l = Xwctomb(tls, bp, c) @@ -137423,9 +137423,9 @@ func X__fputwc_unlocked(tls *TLS, c Twchar_t, f uintptr) (r Twint_t) { } } if Uint32FromInt32(c) == uint32(0xffffffff) { - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return Uint32FromInt32(c) } @@ -137482,7 +137482,7 @@ func Xfputws(tls *TLS, _ws uintptr, f uintptr) (r int32) { _, _, _, _, _, _, _ = __need_unlock, l, loc, ploc, v1, v2, v3 l = uint64(0) ploc = uintptr(___get_tp(tls)) + 152 - loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) + loc = **(**Tlocale_t)(__ccgo_up(ploc)) if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) } else { @@ -137490,9 +137490,9 @@ func Xfputws(tls *TLS, _ws uintptr, f uintptr) (r int32) { } __need_unlock = v1 Xfwide(tls, f, int32(1)) - *(*Tlocale_t)(unsafe.Pointer(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale + **(**Tlocale_t)(__ccgo_up(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale for { - if v3 = *(*uintptr)(unsafe.Pointer(bp)) != 0; v3 { + if v3 = **(**uintptr)(__ccgo_up(bp)) != 0; v3 { v2 = Xwcsrtombs(tls, bp+8, bp, uint64(1024), uintptr(0)) l = v2 } @@ -137503,14 +137503,14 @@ func Xfputws(tls *TLS, _ws uintptr, f uintptr) (r int32) { if __need_unlock != 0 { ___unlockfile(tls, f) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return -int32(1) } } if __need_unlock != 0 { ___unlockfile(tls, f) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return Int32FromUint64(l) /* 0 or -1 */ } @@ -137544,7 +137544,7 @@ func Xfread(tls *TLS, destv uintptr, size Tsize_t, nmemb Tsize_t, f uintptr) (r v1 = 0 } __need_unlock = v1 - *(*int32)(unsafe.Pointer(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) + **(**int32)(__ccgo_up(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { /* First exhaust the buffer. */ if Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Frend)-int64((*TFILE)(unsafe.Pointer(f)).Frpos)) < l { @@ -137554,7 +137554,7 @@ func Xfread(tls *TLS, destv uintptr, size Tsize_t, nmemb Tsize_t, f uintptr) (r } k = v2 Xmemcpy(tls, dest, (*TFILE)(unsafe.Pointer(f)).Frpos, k) - *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(k) + **(**uintptr)(__ccgo_up(f + 8)) += uintptr(k) dest = dest + uintptr(k) l = l - k } @@ -137694,7 +137694,7 @@ func X__fseeko_unlocked(tls *TLS, f uintptr, off Toff_t, whence int32) (r int32) _, _ = v1, v2 /* Fail immediately for invalid whence argument. */ if whence != int32(1) && whence != 0 && whence != int32(2) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } /* Adjust relative offset for unread data in buffer, if any. */ @@ -137722,7 +137722,7 @@ func X__fseeko_unlocked(tls *TLS, f uintptr, off Toff_t, whence int32) (r int32) v1 = UintptrFromInt32(0) (*TFILE)(unsafe.Pointer(f)).Frend = v1 (*TFILE)(unsafe.Pointer(f)).Frpos = v1 - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) return 0 } @@ -137767,7 +137767,7 @@ func Xfsetpos(tls *TLS, f uintptr, pos uintptr) (r int32) { trc("tls=%v f=%v pos=%v, (%v:)", tls, f, pos, origin(2)) defer func() { trc("-> %v", r) }() } - return X__fseeko(tls, f, *(*int64)(unsafe.Pointer(pos)), 0) + return X__fseeko(tls, f, int64(**(**int64)(__ccgo_up(pos))), 0) } /* Support signed or unsigned plain-char */ @@ -137837,7 +137837,7 @@ func Xftell(tls *TLS, f uintptr) (r int64) { _ = pos pos = X__ftello(tls, f) if pos > int64(0x7fffffffffffffff) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return int64(-int32(1)) } return pos @@ -137975,7 +137975,7 @@ func Xfwide(tls *TLS, f uintptr, mode int32) (r int32) { __need_unlock = v1 if mode != 0 { if !((*TFILE)(unsafe.Pointer(f)).Flocale != 0) { - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v3 = int32(4) } else { v3 = int32(1) @@ -138035,7 +138035,7 @@ func X__fwritex(tls *TLS, s uintptr, l Tsize_t, f uintptr) (r Tsize_t) { /* Match /^(.*\n|)/ */ i = l for { - if !(i != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(i-uint64(1))))) != int32('\n')) { + if !(i != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(i-uint64(1))))) != int32('\n')) { break } goto _1 @@ -138053,7 +138053,7 @@ func X__fwritex(tls *TLS, s uintptr, l Tsize_t, f uintptr) (r Tsize_t) { } } Xmemcpy(tls, (*TFILE)(unsafe.Pointer(f)).Fwpos, s, l) - *(*uintptr)(unsafe.Pointer(f + 40)) += uintptr(l) + **(**uintptr)(__ccgo_up(f + 40)) += uintptr(l) return l + i } @@ -138139,7 +138139,7 @@ _2: v5 = f + 8 v4 = *(*uintptr)(unsafe.Pointer(v5)) *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v4))) } else { v1 = X__uflow(tls, f) } @@ -138198,7 +138198,7 @@ func Xgetc(tls *TLS, f1 uintptr) (r int32) { v6 = v1 + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(v5))) } else { v4 = X__uflow(tls, v1) } @@ -138231,7 +138231,7 @@ func Xgetc_unlocked(tls *TLS, f uintptr) (r int32) { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__uflow(tls, f) } @@ -138275,7 +138275,7 @@ _2: v5 = f + 8 v4 = *(*uintptr)(unsafe.Pointer(v5)) *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v4))) } else { v1 = X__uflow(tls, f) } @@ -138334,7 +138334,7 @@ func Xgetchar(tls *TLS) (r int32) { v6 = v1 + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(v5))) } else { v4 = X__uflow(tls, v1) } @@ -138359,7 +138359,7 @@ func Xgetchar_unlocked(tls *TLS) (r int32) { v3 = uintptr(unsafe.Pointer(&X__stdin_FILE)) + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__uflow(tls, uintptr(unsafe.Pointer(&X__stdin_FILE))) } @@ -138385,16 +138385,16 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize } __need_unlock = v1 if !(n != 0) || !(s != 0) { - *(*int32)(unsafe.Pointer(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**int32)(__ccgo_up(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) if __need_unlock != 0 { ___unlockfile(tls, f) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) } - if !(*(*uintptr)(unsafe.Pointer(s)) != 0) { - *(*Tsize_t)(unsafe.Pointer(n)) = uint64(0) + if !(**(**uintptr)(__ccgo_up(s)) != 0) { + **(**Tsize_t)(__ccgo_up(n)) = uint64(0) } for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { @@ -138409,36 +138409,36 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize z = uintptr(0) k = uint64(0) } - if i+k >= *(*Tsize_t)(unsafe.Pointer(n)) { + if i+k >= **(**Tsize_t)(__ccgo_up(n)) { m = i + k + uint64(2) if !(z != 0) && m < Uint64FromUint64(0xffffffffffffffff)/Uint64FromInt32(4) { m = m + m/uint64(2) } - tmp = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(s)), m) + tmp = Xrealloc(tls, **(**uintptr)(__ccgo_up(s)), m) if !(tmp != 0) { m = i + k + uint64(2) - tmp = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(s)), m) + tmp = Xrealloc(tls, **(**uintptr)(__ccgo_up(s)), m) if !(tmp != 0) { /* Copy as much as fits and ensure no * pushback remains in the FILE buf. */ - k = *(*Tsize_t)(unsafe.Pointer(n)) - i - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(s))+uintptr(i), (*TFILE)(unsafe.Pointer(f)).Frpos, k) - *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(k) - *(*int32)(unsafe.Pointer(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + k = **(**Tsize_t)(__ccgo_up(n)) - i + Xmemcpy(tls, **(**uintptr)(__ccgo_up(s))+uintptr(i), (*TFILE)(unsafe.Pointer(f)).Frpos, k) + **(**uintptr)(__ccgo_up(f + 8)) += uintptr(k) + **(**int32)(__ccgo_up(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) if __need_unlock != 0 { ___unlockfile(tls, f) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return int64(-int32(1)) } } - *(*uintptr)(unsafe.Pointer(s)) = tmp - *(*Tsize_t)(unsafe.Pointer(n)) = m + **(**uintptr)(__ccgo_up(s)) = tmp + **(**Tsize_t)(__ccgo_up(n)) = m } if k != 0 { - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(s))+uintptr(i), (*TFILE)(unsafe.Pointer(f)).Frpos, k) - *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(k) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(s))+uintptr(i), (*TFILE)(unsafe.Pointer(f)).Frpos, k) + **(**uintptr)(__ccgo_up(f + 8)) += uintptr(k) i = i + k } if z != 0 { @@ -138448,7 +138448,7 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize v7 = f + 8 v6 = *(*uintptr)(unsafe.Pointer(v7)) *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) + 1 - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(v6))) } else { v4 = X__uflow(tls, f) } @@ -138465,16 +138465,16 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize } /* If the byte read by getc won't fit without growing the * output buffer, push it back for next iteration. */ - if i+uint64(1) >= *(*Tsize_t)(unsafe.Pointer(n)) { + if i+uint64(1) >= **(**Tsize_t)(__ccgo_up(n)) { v7 = f + 8 *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) - 1 v6 = *(*uintptr)(unsafe.Pointer(v7)) - *(*uint8)(unsafe.Pointer(v6)) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(v6)) = Uint8FromInt32(c) } else { v10 = Uint8FromInt32(c) v11 = i i = i + 1 - *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)) + uintptr(v11))) = v10 + **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)) + uintptr(v11))) = v10 if Int32FromUint8(v10) == delim { break } @@ -138482,7 +138482,7 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize goto _2 _2: } - *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)) + uintptr(i))) = uint8(0) + **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)) + uintptr(i))) = uint8(0) if __need_unlock != 0 { ___unlockfile(tls, f) } @@ -138526,7 +138526,7 @@ func Xgets(tls *TLS, s uintptr) (r uintptr) { v5 = uintptr(unsafe.Pointer(&X__stdin_FILE)) + 8 v4 = *(*uintptr)(unsafe.Pointer(v5)) *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v4))) } else { v3 = X__uflow(tls, uintptr(unsafe.Pointer(&X__stdin_FILE))) } @@ -138537,9 +138537,9 @@ func Xgets(tls *TLS, s uintptr) (r uintptr) { } v6 = i i = i + 1 - *(*uint8)(unsafe.Pointer(s + uintptr(v6))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + uintptr(v6))) = Uint8FromInt32(c) } - *(*uint8)(unsafe.Pointer(s + uintptr(i))) = uint8(0) + **(**uint8)(__ccgo_up(s + uintptr(i))) = uint8(0) if c != int32('\n') && (!((*TFILE)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stdin_FILE)))).Fflags&Uint32FromInt32(F_EOF) != 0) || !(i != 0)) { s = uintptr(0) } @@ -138560,7 +138560,7 @@ func Xgetw(tls *TLS, f uintptr) (r int32) { var _ /* x at bp+0 */ int32 _ = v1 if Xfread(tls, bp, uint64(4), uint64(1), f) != 0 { - v1 = *(*int32)(unsafe.Pointer(bp)) + v1 = **(**int32)(__ccgo_up(bp)) } else { v1 = -int32(1) } @@ -138618,11 +138618,11 @@ func X__ofl_add(tls *TLS, f uintptr) (r uintptr) { var head uintptr _ = head head = X__ofl_lock(tls) - (*TFILE)(unsafe.Pointer(f)).Fnext = *(*uintptr)(unsafe.Pointer(head)) - if *(*uintptr)(unsafe.Pointer(head)) != 0 { - (*TFILE)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(head)))).Fprev = f + (*TFILE)(unsafe.Pointer(f)).Fnext = **(**uintptr)(__ccgo_up(head)) + if **(**uintptr)(__ccgo_up(head)) != 0 { + (*TFILE)(unsafe.Pointer(**(**uintptr)(__ccgo_up(head)))).Fprev = f } - *(*uintptr)(unsafe.Pointer(head)) = f + **(**uintptr)(__ccgo_up(head)) = f X__ofl_unlock(tls) return f } @@ -138656,7 +138656,7 @@ func _ms_seek(tls *TLS, f uintptr, off Toff_t, whence int32) (r Toff_t) { goto fail fail: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) _1: ; @@ -138664,7 +138664,7 @@ _1: 1: (*Tcookie1)(unsafe.Pointer(c)).Fpos, 2: (*Tcookie1)(unsafe.Pointer(c)).Flen1, } - base = Int64FromUint64(*(*Tsize_t)(unsafe.Pointer(bp + uintptr(whence)*8))) + base = Int64FromUint64(**(**Tsize_t)(__ccgo_up(bp + uintptr(whence)*8))) if off < -base || off > int64(0x7fffffffffffffff)-base { goto fail } @@ -138693,16 +138693,16 @@ func _ms_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { } v1 = newbuf (*Tcookie1)(unsafe.Pointer(c)).Fbuf = v1 - *(*uintptr)(unsafe.Pointer((*Tcookie1)(unsafe.Pointer(c)).Fbufp)) = v1 + **(**uintptr)(__ccgo_up((*Tcookie1)(unsafe.Pointer(c)).Fbufp)) = v1 Xmemset(tls, (*Tcookie1)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie1)(unsafe.Pointer(c)).Fspace), 0, len2-(*Tcookie1)(unsafe.Pointer(c)).Fspace) (*Tcookie1)(unsafe.Pointer(c)).Fspace = len2 } Xmemcpy(tls, (*Tcookie1)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie1)(unsafe.Pointer(c)).Fpos), buf, len1) - *(*Tsize_t)(unsafe.Pointer(c + 16)) += len1 + **(**Tsize_t)(__ccgo_up(c + 16)) += len1 if (*Tcookie1)(unsafe.Pointer(c)).Fpos >= (*Tcookie1)(unsafe.Pointer(c)).Flen1 { (*Tcookie1)(unsafe.Pointer(c)).Flen1 = (*Tcookie1)(unsafe.Pointer(c)).Fpos } - *(*Tsize_t)(unsafe.Pointer((*Tcookie1)(unsafe.Pointer(c)).Fsizep)) = (*Tcookie1)(unsafe.Pointer(c)).Fpos + **(**Tsize_t)(__ccgo_up((*Tcookie1)(unsafe.Pointer(c)).Fsizep)) = (*Tcookie1)(unsafe.Pointer(c)).Fpos return len1 } @@ -138735,16 +138735,16 @@ func Xopen_memstream(tls *TLS, bufp uintptr, sizep uintptr) (r uintptr) { (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fbufp = bufp (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fsizep = sizep v5 = Uint64FromInt32(0) - *(*Tsize_t)(unsafe.Pointer(sizep)) = v5 + **(**Tsize_t)(__ccgo_up(sizep)) = v5 v4 = v5 (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fspace = v4 v3 = v4 (*Tms_FILE)(unsafe.Pointer(f)).Fc.Flen1 = v3 (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fpos = v3 v1 = buf - *(*uintptr)(unsafe.Pointer(bufp)) = v1 + **(**uintptr)(__ccgo_up(bufp)) = v1 (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fbuf = v1 - *(*uint8)(unsafe.Pointer(buf)) = uint8(0) + **(**uint8)(__ccgo_up(buf)) = uint8(0) (*Tms_FILE)(unsafe.Pointer(f)).Ff.Fflags = uint32(F_NORD) (*Tms_FILE)(unsafe.Pointer(f)).Ff.Ffd = -int32(1) (*Tms_FILE)(unsafe.Pointer(f)).Ff.Fbuf = f + 280 @@ -138790,7 +138790,7 @@ func _wms_seek(tls *TLS, f uintptr, off Toff_t, whence int32) (r Toff_t) { goto fail fail: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) _1: ; @@ -138798,7 +138798,7 @@ _1: 1: (*Tcookie2)(unsafe.Pointer(c)).Fpos, 2: (*Tcookie2)(unsafe.Pointer(c)).Flen1, } - base = Int64FromUint64(*(*Tsize_t)(unsafe.Pointer(bp + uintptr(whence)*8))) + base = Int64FromUint64(**(**Tsize_t)(__ccgo_up(bp + uintptr(whence)*8))) if off < -base || off > Int64FromInt64(0x7fffffffffffffff)/Int64FromInt32(4)-base { goto fail } @@ -138834,7 +138834,7 @@ func _wms_write(tls *TLS, f uintptr, _buf uintptr, len1 Tsize_t) (r Tsize_t) { } v1 = newbuf (*Tcookie2)(unsafe.Pointer(c)).Fbuf = v1 - *(*uintptr)(unsafe.Pointer((*Tcookie2)(unsafe.Pointer(c)).Fbufp)) = v1 + **(**uintptr)(__ccgo_up((*Tcookie2)(unsafe.Pointer(c)).Fbufp)) = v1 Xmemset(tls, (*Tcookie2)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie2)(unsafe.Pointer(c)).Fspace)*4, 0, uint64(4)*(len2-(*Tcookie2)(unsafe.Pointer(c)).Fspace)) (*Tcookie2)(unsafe.Pointer(c)).Fspace = len2 } @@ -138842,11 +138842,11 @@ func _wms_write(tls *TLS, f uintptr, _buf uintptr, len1 Tsize_t) (r Tsize_t) { if len2 == Uint64FromInt32(-Int32FromInt32(1)) { return uint64(0) } - *(*Tsize_t)(unsafe.Pointer(c + 16)) += len2 + **(**Tsize_t)(__ccgo_up(c + 16)) += len2 if (*Tcookie2)(unsafe.Pointer(c)).Fpos >= (*Tcookie2)(unsafe.Pointer(c)).Flen1 { (*Tcookie2)(unsafe.Pointer(c)).Flen1 = (*Tcookie2)(unsafe.Pointer(c)).Fpos } - *(*Tsize_t)(unsafe.Pointer((*Tcookie2)(unsafe.Pointer(c)).Fsizep)) = (*Tcookie2)(unsafe.Pointer(c)).Fpos + **(**Tsize_t)(__ccgo_up((*Tcookie2)(unsafe.Pointer(c)).Fsizep)) = (*Tcookie2)(unsafe.Pointer(c)).Fpos return len1 } @@ -138879,16 +138879,16 @@ func Xopen_wmemstream(tls *TLS, bufp uintptr, sizep uintptr) (r uintptr) { (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fbufp = bufp (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fsizep = sizep v5 = Uint64FromInt32(0) - *(*Tsize_t)(unsafe.Pointer(sizep)) = v5 + **(**Tsize_t)(__ccgo_up(sizep)) = v5 v4 = v5 (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fspace = v4 v3 = v4 (*Twms_FILE)(unsafe.Pointer(f)).Fc.Flen1 = v3 (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fpos = v3 v1 = buf - *(*uintptr)(unsafe.Pointer(bufp)) = v1 + **(**uintptr)(__ccgo_up(bufp)) = v1 (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fbuf = v1 - *(*Twchar_t)(unsafe.Pointer(buf)) = 0 + **(**Twchar_t)(__ccgo_up(buf)) = 0 (*Twms_FILE)(unsafe.Pointer(f)).Ff.Fflags = uint32(F_NORD) (*Twms_FILE)(unsafe.Pointer(f)).Ff.Ffd = -int32(1) (*Twms_FILE)(unsafe.Pointer(f)).Ff.Fbuf = f + 288 @@ -138927,7 +138927,7 @@ func Xpclose(tls *TLS, f uintptr) (r1 int32) { if r < 0 { return int32(X__syscall_ret(tls, Uint64FromInt32(r))) } - return *(*int32)(unsafe.Pointer(bp)) + return **(**int32)(__ccgo_up(bp)) } func Xperror(tls *TLS, msg uintptr) { @@ -138938,7 +138938,7 @@ func Xperror(tls *TLS, msg uintptr) { var errstr, f, old_locale uintptr _, _, _, _, _, _ = __need_unlock, errstr, f, old_locale, old_mode, v1 f = uintptr(unsafe.Pointer(&X__stderr_FILE)) - errstr = Xstrerror(tls, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) + errstr = Xstrerror(tls, **(**int32)(__ccgo_up(X__errno_location(tls)))) if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) } else { @@ -138949,7 +138949,7 @@ func Xperror(tls *TLS, msg uintptr) { * permitted to change them. */ old_locale = (*TFILE)(unsafe.Pointer(f)).Flocale old_mode = (*TFILE)(unsafe.Pointer(f)).Fmode - if msg != 0 && *(*uint8)(unsafe.Pointer(msg)) != 0 { + if msg != 0 && **(**uint8)(__ccgo_up(msg)) != 0 { Xfwrite(tls, msg, _strlen(tls, msg), uint64(1), f) Xfputc(tls, int32(':'), f) Xfputc(tls, int32(' '), f) @@ -139000,7 +139000,7 @@ _2: v6 = f + 40 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - *(*uint8)(unsafe.Pointer(v5)) = v4 + **(**uint8)(__ccgo_up(v5)) = v4 v1 = Int32FromUint8(v4) } else { v1 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) @@ -139063,7 +139063,7 @@ func Xputc(tls *TLS, c1 int32, f1 uintptr) (r int32) { v8 = v2 + 40 v7 = *(*uintptr)(unsafe.Pointer(v8)) *(*uintptr)(unsafe.Pointer(v8)) = *(*uintptr)(unsafe.Pointer(v8)) + 1 - *(*uint8)(unsafe.Pointer(v7)) = v6 + **(**uint8)(__ccgo_up(v7)) = v6 v5 = Int32FromUint8(v6) } else { v5 = X__overflow(tls, v2, Int32FromUint8(Uint8FromInt32(v1))) @@ -139099,7 +139099,7 @@ func Xputc_unlocked(tls *TLS, c int32, f uintptr) (r int32) { v4 = f + 40 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(v3)) = v2 + **(**uint8)(__ccgo_up(v3)) = v2 v1 = Int32FromUint8(v2) } else { v1 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) @@ -139146,7 +139146,7 @@ _2: v6 = f + 40 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - *(*uint8)(unsafe.Pointer(v5)) = v4 + **(**uint8)(__ccgo_up(v5)) = v4 v1 = Int32FromUint8(v4) } else { v1 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) @@ -139209,7 +139209,7 @@ func Xputchar(tls *TLS, c1 int32) (r int32) { v8 = v2 + 40 v7 = *(*uintptr)(unsafe.Pointer(v8)) *(*uintptr)(unsafe.Pointer(v8)) = *(*uintptr)(unsafe.Pointer(v8)) + 1 - *(*uint8)(unsafe.Pointer(v7)) = v6 + **(**uint8)(__ccgo_up(v7)) = v6 v5 = Int32FromUint8(v6) } else { v5 = X__overflow(tls, v2, Int32FromUint8(Uint8FromInt32(v1))) @@ -139237,7 +139237,7 @@ func Xputchar_unlocked(tls *TLS, c int32) (r int32) { v4 = uintptr(unsafe.Pointer(&X__stdout_FILE)) + 40 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(v3)) = v2 + **(**uint8)(__ccgo_up(v3)) = v2 v1 = Int32FromUint8(v2) } else { v1 = X__overflow(tls, uintptr(unsafe.Pointer(&X__stdout_FILE)), Int32FromUint8(Uint8FromInt32(c))) @@ -139267,7 +139267,7 @@ func Xputs(tls *TLS, s uintptr) (r1 int32) { v5 = uintptr(unsafe.Pointer(&X__stdout_FILE)) + 40 v4 = *(*uintptr)(unsafe.Pointer(v5)) *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = v3 + **(**uint8)(__ccgo_up(v4)) = v3 v2 = Int32FromUint8(v3) } else { v2 = X__overflow(tls, uintptr(unsafe.Pointer(&X__stdout_FILE)), Int32FromUint8(Uint8FromInt32(Int32FromUint8('\n')))) @@ -139350,7 +139350,7 @@ func Xrewind(tls *TLS, f uintptr) { } __need_unlock = v1 X__fseeko_unlocked(tls, f, 0, 0) - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_ERR)) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^Int32FromInt32(F_ERR)) if __need_unlock != 0 { ___unlockfile(tls, f) } @@ -139440,7 +139440,7 @@ func Xsetvbuf(tls *TLS, f uintptr, buf uintptr, type1 int32, size Tsize_t) (r in return -int32(1) } } - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_SVB) + **(**uint32)(__ccgo_up(f)) |= uint32(F_SVB) return 0 } @@ -139580,14 +139580,14 @@ func Xtempnam(tls *TLS, dir uintptr, pfx uintptr) (r1 uintptr) { pl = _strlen(tls, pfx) l = dl + uint64(1) + pl + uint64(1) + uint64(6) if l >= uint64(PATH_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENAMETOOLONG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENAMETOOLONG) return uintptr(0) } Xmemcpy(tls, bp+1, dir, dl) - (*(*[4096]uint8)(unsafe.Pointer(bp + 1)))[dl] = uint8('/') + (**(**[4096]uint8)(__ccgo_up(bp + 1)))[dl] = uint8('/') Xmemcpy(tls, bp+1+uintptr(dl)+uintptr(1), pfx, pl) - (*(*[4096]uint8)(unsafe.Pointer(bp + 1)))[dl+uint64(1)+pl] = uint8('_') - (*(*[4096]uint8)(unsafe.Pointer(bp + 1)))[l] = uint8(0) + (**(**[4096]uint8)(__ccgo_up(bp + 1)))[dl+uint64(1)+pl] = uint8('_') + (**(**[4096]uint8)(__ccgo_up(bp + 1)))[l] = uint8(0) try = 0 for { if !(try < int32(MAXTRIES)) { @@ -139618,7 +139618,7 @@ func Xtmpfile(tls *TLS) (r uintptr) { var fd, try int32 var _ /* s at bp+0 */ [20]uint8 _, _, _ = f, fd, try - *(*[20]uint8)(unsafe.Pointer(bp)) = [20]uint8{'/', 't', 'm', 'p', '/', 't', 'm', 'p', 'f', 'i', 'l', 'e', '_', 'X', 'X', 'X', 'X', 'X', 'X'} + **(**[20]uint8)(__ccgo_up(bp)) = [20]uint8{'/', 't', 'm', 'p', '/', 't', 'm', 'p', 'f', 'i', 'l', 'e', '_', 'X', 'X', 'X', 'X', 'X', 'X'} try = 0 for { if !(try < int32(MAXTRIES)) { @@ -139653,7 +139653,7 @@ func Xtmpnam(tls *TLS, buf uintptr) (r1 uintptr) { var v2 uintptr var _ /* s at bp+1 */ [19]uint8 _, _, _ = r, try, v2 - *(*[19]uint8)(unsafe.Pointer(bp + 1)) = [19]uint8{'/', 't', 'm', 'p', '/', 't', 'm', 'p', 'n', 'a', 'm', '_', 'X', 'X', 'X', 'X', 'X', 'X'} + **(**[19]uint8)(__ccgo_up(bp + 1)) = [19]uint8{'/', 't', 'm', 'p', '/', 't', 'm', 'p', 'n', 'a', 'm', '_', 'X', 'X', 'X', 'X', 'X', 'X'} try = 0 for { if !(try < int32(MAXTRIES)) { @@ -139709,8 +139709,8 @@ func Xungetc(tls *TLS, c int32, f uintptr) (r int32) { v3 = f + 8 *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) - 1 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(c) - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) + **(**uint8)(__ccgo_up(v2)) = Uint8FromInt32(c) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) if __need_unlock != 0 { ___unlockfile(tls, f) } @@ -139731,7 +139731,7 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { var _ /* mbc at bp+0 */ [4]uint8 _, _, _, _, _, _, _, _ = __need_unlock, l, loc, ploc, v1, v3, v4, v5 ploc = uintptr(___get_tp(tls)) + 152 - loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) + loc = **(**Tlocale_t)(__ccgo_up(ploc)) if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) } else { @@ -139741,7 +139741,7 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { if (*TFILE)(unsafe.Pointer(f)).Fmode <= 0 { Xfwide(tls, f, int32(1)) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale + **(**Tlocale_t)(__ccgo_up(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale if !((*TFILE)(unsafe.Pointer(f)).Frpos != 0) { X__toread(tls, f) } @@ -139753,24 +139753,24 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { if __need_unlock != 0 { ___unlockfile(tls, f) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return uint32(0xffffffff) } if BoolInt32(c < uint32(128)) != 0 { v5 = f + 8 *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) - 1 v4 = *(*uintptr)(unsafe.Pointer(v5)) - *(*uint8)(unsafe.Pointer(v4)) = uint8(c) + **(**uint8)(__ccgo_up(v4)) = uint8(c) } else { v4 = f + 8 *(*uintptr)(unsafe.Pointer(v4)) -= uintptr(l) Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(v4)), bp, Uint64FromInt32(l)) } - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) if __need_unlock != 0 { ___unlockfile(tls, f) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return c } @@ -139789,12 +139789,12 @@ func Xvasprintf(tls *TLS, s uintptr, fmt uintptr, ap Tva_list) (r int32) { _ = ap2 if v2 = l < 0; !v2 { v1 = Xmalloc(tls, uint64(Uint32FromInt32(l)+uint32(1))) - *(*uintptr)(unsafe.Pointer(s)) = v1 + **(**uintptr)(__ccgo_up(s)) = v1 } if v2 || !(v1 != 0) { return -int32(1) } - return Xvsnprintf(tls, *(*uintptr)(unsafe.Pointer(s)), uint64(Uint32FromInt32(l)+uint32(1)), fmt, ap) + return Xvsnprintf(tls, **(**uintptr)(__ccgo_up(s)), uint64(Uint32FromInt32(l)+uint32(1)), fmt, ap) } func Xvdprintf(tls *TLS, fd int32, fmt uintptr, ap Tva_list) (r int32) { @@ -139805,7 +139805,7 @@ func Xvdprintf(tls *TLS, fd int32, fmt uintptr, ap Tva_list) (r int32) { bp := tls.Alloc(240) defer tls.Free(240) var _ /* f at bp+0 */ TFILE - *(*TFILE)(unsafe.Pointer(bp)) = TFILE{ + **(**TFILE)(__ccgo_up(bp)) = TFILE{ Fwrite: __ccgo_fp(X__stdio_write), Fbuf: fmt, Ffd: fd, @@ -139972,41 +139972,41 @@ type Targ = struct { func _pop_arg(tls *TLS, arg uintptr, type1 int32, ap uintptr) { switch type1 { case int32(_PTR): - *(*uintptr)(unsafe.Pointer(arg)) = VaUintptr(&*(*Tva_list)(unsafe.Pointer(ap))) + *(*uintptr)(unsafe.Pointer(arg)) = VaUintptr(&**(**Tva_list)(__ccgo_up(ap))) case int32(_INT): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_UINT): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint32(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint32(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_LONG): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_ULONG): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&**(**Tva_list)(__ccgo_up(ap))) case int32(_ULLONG): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_SHORT): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt16(int16(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt16(int16(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_USHORT): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint16FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint16FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_CHAR): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt8(int8(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt8(int8(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_UCHAR): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint8FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint8FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_LLONG): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_SIZET): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&**(**Tva_list)(__ccgo_up(ap))) case int32(_IMAX): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_UMAX): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&**(**Tva_list)(__ccgo_up(ap))) case int32(_PDIFF): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_UIPTR): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUintptr(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUintptr(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_DBL): - *(*float64)(unsafe.Pointer(arg)) = float64(VaFloat64(&*(*Tva_list)(unsafe.Pointer(ap)))) + *(*float64)(unsafe.Pointer(arg)) = float64(VaFloat64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_LDBL): - *(*float64)(unsafe.Pointer(arg)) = VaFloat64(&*(*Tva_list)(unsafe.Pointer(ap))) + *(*float64)(unsafe.Pointer(arg)) = VaFloat64(&**(**Tva_list)(__ccgo_up(ap))) } } @@ -140056,7 +140056,7 @@ func _fmt_x(tls *TLS, x Tuintmax_t, s uintptr, lower int32) (r uintptr) { } s = s - 1 v2 = s - *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(Int32FromUint8(_xdigits1[x&uint64(15)]) | lower) + **(**uint8)(__ccgo_up(v2)) = Uint8FromInt32(Int32FromUint8(_xdigits1[x&uint64(15)]) | lower) goto _1 _1: ; @@ -140074,7 +140074,7 @@ func _fmt_o(tls *TLS, x Tuintmax_t, s uintptr) (r uintptr) { } s = s - 1 v2 = s - *(*uint8)(unsafe.Pointer(v2)) = uint8(uint64('0') + x&uint64(7)) + **(**uint8)(__ccgo_up(v2)) = uint8(uint64('0') + x&uint64(7)) goto _1 _1: ; @@ -140093,7 +140093,7 @@ func _fmt_u(tls *TLS, x Tuintmax_t, s uintptr) (r uintptr) { } s = s - 1 v2 = s - *(*uint8)(unsafe.Pointer(v2)) = uint8(uint64('0') + x%uint64(10)) + **(**uint8)(__ccgo_up(v2)) = uint8(uint64('0') + x%uint64(10)) goto _1 _1: ; @@ -140106,7 +140106,7 @@ func _fmt_u(tls *TLS, x Tuintmax_t, s uintptr) (r uintptr) { } s = s - 1 v2 = s - *(*uint8)(unsafe.Pointer(v2)) = uint8(uint64('0') + y%uint64(10)) + **(**uint8)(__ccgo_up(v2)) = uint8(uint64('0') + y%uint64(10)) goto _3 _3: ; @@ -140141,7 +140141,7 @@ func _fmt_fp(tls *TLS, f uintptr, y float64, w int32, p int32, fl int32, t int32 var _ /* e2 at bp+512 */ int32 var _ /* ebuf0 at bp+538 */ [12]uint8 _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, b, carry, carry1, d, e, ebuf, estr, i, j, l, need, pl, prefix, r, re, rm, round, round1, s, s1, s2, s3, s4, sh, sh1, small, x, x1, x2, z, v1, v36, v37, v38, v5, v6, v7 - *(*int32)(unsafe.Pointer(bp + 512)) = 0 + **(**int32)(__ccgo_up(bp + 512)) = 0 prefix = __ccgo_ts + 1625 ebuf = bp + 538 + uintptr(Uint64FromInt32(3)*Uint64FromInt64(4)) pl = int32(1) @@ -140195,7 +140195,7 @@ _4: } y = float64(Xfrexpl(tls, y, bp+512) * Float64FromInt32(2)) if y != 0 { - *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) - 1 + **(**int32)(__ccgo_up(bp + 512)) = **(**int32)(__ccgo_up(bp + 512)) - 1 } if t|int32(32) == int32('a') { round = Float64FromFloat64(8) @@ -140218,7 +140218,7 @@ _4: } round = round * Float64FromInt32(16) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(prefix))) == int32('-') { + if Int32FromUint8(**(**uint8)(__ccgo_up(prefix))) == int32('-') { y = -y y = y - round y = y + round @@ -140228,39 +140228,39 @@ _4: y = y - round } } - if *(*int32)(unsafe.Pointer(bp + 512)) < 0 { - v7 = -*(*int32)(unsafe.Pointer(bp + 512)) + if **(**int32)(__ccgo_up(bp + 512)) < 0 { + v7 = -**(**int32)(__ccgo_up(bp + 512)) } else { - v7 = *(*int32)(unsafe.Pointer(bp + 512)) + v7 = **(**int32)(__ccgo_up(bp + 512)) } estr = _fmt_u(tls, Uint64FromInt32(v7), ebuf) if estr == ebuf { estr = estr - 1 v5 = estr - *(*uint8)(unsafe.Pointer(v5)) = uint8('0') + **(**uint8)(__ccgo_up(v5)) = uint8('0') } estr = estr - 1 v5 = estr - if *(*int32)(unsafe.Pointer(bp + 512)) < 0 { + if **(**int32)(__ccgo_up(bp + 512)) < 0 { v7 = int32('-') } else { v7 = int32('+') } - *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(v7) + **(**uint8)(__ccgo_up(v5)) = Uint8FromInt32(v7) estr = estr - 1 v5 = estr - *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(t + (Int32FromUint8('p') - Int32FromUint8('a'))) + **(**uint8)(__ccgo_up(v5)) = Uint8FromInt32(t + (Int32FromUint8('p') - Int32FromUint8('a'))) s = bp + 516 for cond := true; cond; cond = y != 0 { x = int32(y) v5 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(Int32FromUint8(_xdigits1[x]) | t&int32(32)) + **(**uint8)(__ccgo_up(v5)) = Uint8FromInt32(Int32FromUint8(_xdigits1[x]) | t&int32(32)) y = float64(Float64FromInt32(16) * (y - float64(x))) if int64(s)-t__predefined_ptrdiff_t(bp+516) == int64(1) && (y != 0 || p > 0 || Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0) { v5 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v5)) = uint8('.') + **(**uint8)(__ccgo_up(v5)) = uint8('.') } } if int64(p) > int64(Int32FromInt32(INT_MAX)-Int32FromInt32(2))-(int64(ebuf)-int64(estr))-int64(pl) { @@ -140290,9 +140290,9 @@ _4: } if y != 0 { y = y * Float64FromFloat64(2.68435456e+08) - *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) - int32(28) + **(**int32)(__ccgo_up(bp + 512)) = **(**int32)(__ccgo_up(bp + 512)) - int32(28) } - if *(*int32)(unsafe.Pointer(bp + 512)) < 0 { + if **(**int32)(__ccgo_up(bp + 512)) < 0 { v6 = bp + 8 z = v6 v5 = v6 @@ -140306,17 +140306,17 @@ _4: a = v5 } for cond := true; cond; cond = y != 0 { - *(*Tuint32_t)(unsafe.Pointer(z)) = uint32(y) + **(**Tuint32_t)(__ccgo_up(z)) = uint32(y) v5 = z z += 4 - y = float64(Float64FromInt32(1000000000) * (y - float64(*(*Tuint32_t)(unsafe.Pointer(v5))))) + y = float64(Float64FromInt32(1000000000) * (y - float64(**(**Tuint32_t)(__ccgo_up(v5))))) } - for *(*int32)(unsafe.Pointer(bp + 512)) > 0 { + for **(**int32)(__ccgo_up(bp + 512)) > 0 { carry = uint32(0) - if int32(29) < *(*int32)(unsafe.Pointer(bp + 512)) { + if int32(29) < **(**int32)(__ccgo_up(bp + 512)) { v7 = int32(29) } else { - v7 = *(*int32)(unsafe.Pointer(bp + 512)) + v7 = **(**int32)(__ccgo_up(bp + 512)) } sh = v7 d = z - uintptr(1)*4 @@ -140324,8 +140324,8 @@ _4: if !(d >= a) { break } - x1 = uint64(*(*Tuint32_t)(unsafe.Pointer(d)))< a && !(*(*Tuint32_t)(unsafe.Pointer(z + uintptr(-Int32FromInt32(1))*4)) != 0) { + for z > a && !(**(**Tuint32_t)(__ccgo_up(z + uintptr(-Int32FromInt32(1))*4)) != 0) { z -= 4 } - *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) - sh + **(**int32)(__ccgo_up(bp + 512)) = **(**int32)(__ccgo_up(bp + 512)) - sh } - for *(*int32)(unsafe.Pointer(bp + 512)) < 0 { + for **(**int32)(__ccgo_up(bp + 512)) < 0 { carry1 = uint32(0) - if int32(9) < -*(*int32)(unsafe.Pointer(bp + 512)) { + if int32(9) < -**(**int32)(__ccgo_up(bp + 512)) { v7 = int32(9) } else { - v7 = -*(*int32)(unsafe.Pointer(bp + 512)) + v7 = -**(**int32)(__ccgo_up(bp + 512)) } sh1 = v7 need = Int32FromUint32(uint32(1) + (Uint32FromInt32(p)+Uint32FromInt32(LDBL_MANT_DIG)/Uint32FromUint32(3)+uint32(8))/uint32(9)) @@ -140356,21 +140356,21 @@ _4: if !(d < z) { break } - rm = *(*Tuint32_t)(unsafe.Pointer(d)) & Uint32FromInt32(int32(1)<>sh1 + carry1 + rm = **(**Tuint32_t)(__ccgo_up(d)) & Uint32FromInt32(int32(1)<>sh1 + carry1 carry1 = Uint32FromInt32(Int32FromInt32(1000000000)>>sh1) * rm goto _26 _26: ; d += 4 } - if !(*(*Tuint32_t)(unsafe.Pointer(a)) != 0) { + if !(**(**Tuint32_t)(__ccgo_up(a)) != 0) { a += 4 } if carry1 != 0 { v5 = z z += 4 - *(*Tuint32_t)(unsafe.Pointer(v5)) = carry1 + **(**Tuint32_t)(__ccgo_up(v5)) = carry1 } /* Avoid (slow!) computation past requested precision */ if t|int32(32) == int32('f') { @@ -140382,13 +140382,13 @@ _4: if (int64(z)-int64(b))/4 > int64(need) { z = b + uintptr(need)*4 } - *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) + sh1 + **(**int32)(__ccgo_up(bp + 512)) = **(**int32)(__ccgo_up(bp + 512)) + sh1 } if a < z { i = int32(10) e = int32(Int64FromInt32(9) * ((int64(r) - int64(a)) / 4)) for { - if !(*(*Tuint32_t)(unsafe.Pointer(a)) >= Uint32FromInt32(i)) { + if !(**(**Tuint32_t)(__ccgo_up(a)) >= Uint32FromInt32(i)) { break } goto _29 @@ -140419,11 +140419,11 @@ _4: i = i * int32(10) j = j + 1 } - x2 = *(*Tuint32_t)(unsafe.Pointer(d)) % Uint32FromInt32(i) + x2 = **(**Tuint32_t)(__ccgo_up(d)) % Uint32FromInt32(i) /* Are there any significant digits past j? */ if x2 != 0 || d+uintptr(1)*4 != z { round1 = Float64FromInt32(2) / Float64FromFloat64(2.22044604925031308085e-16) - if *(*Tuint32_t)(unsafe.Pointer(d))/Uint32FromInt32(i)&uint32(1) != 0 || i == int32(1000000000) && d > a && *(*Tuint32_t)(unsafe.Pointer(d + uintptr(-Int32FromInt32(1))*4))&uint32(1) != 0 { + if **(**Tuint32_t)(__ccgo_up(d))/Uint32FromInt32(i)&uint32(1) != 0 || i == int32(1000000000) && d > a && **(**Tuint32_t)(__ccgo_up(d + uintptr(-Int32FromInt32(1))*4))&uint32(1) != 0 { round1 = round1 + Float64FromInt32(2) } if x2 < Uint32FromInt32(i/int32(2)) { @@ -140435,29 +140435,29 @@ _4: small = Float64FromFloat64(1.5) } } - if pl != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(prefix))) == int32('-') { + if pl != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(prefix))) == int32('-') { round1 = round1 * float64(-Int32FromInt32(1)) small = small * float64(-Int32FromInt32(1)) } - *(*Tuint32_t)(unsafe.Pointer(d)) -= x2 + **(**Tuint32_t)(__ccgo_up(d)) -= x2 /* Decide whether to round by probing round+small */ if round1+small != round1 { - *(*Tuint32_t)(unsafe.Pointer(d)) = *(*Tuint32_t)(unsafe.Pointer(d)) + Uint32FromInt32(i) - for *(*Tuint32_t)(unsafe.Pointer(d)) > uint32(999999999) { + **(**Tuint32_t)(__ccgo_up(d)) = **(**Tuint32_t)(__ccgo_up(d)) + Uint32FromInt32(i) + for **(**Tuint32_t)(__ccgo_up(d)) > uint32(999999999) { v5 = d d -= 4 - *(*Tuint32_t)(unsafe.Pointer(v5)) = uint32(0) + **(**Tuint32_t)(__ccgo_up(v5)) = uint32(0) if d < a { a -= 4 v5 = a - *(*Tuint32_t)(unsafe.Pointer(v5)) = uint32(0) + **(**Tuint32_t)(__ccgo_up(v5)) = uint32(0) } - *(*Tuint32_t)(unsafe.Pointer(d)) = *(*Tuint32_t)(unsafe.Pointer(d)) + 1 + **(**Tuint32_t)(__ccgo_up(d)) = **(**Tuint32_t)(__ccgo_up(d)) + 1 } i = int32(10) e = int32(Int64FromInt32(9) * ((int64(r) - int64(a)) / 4)) for { - if !(*(*Tuint32_t)(unsafe.Pointer(a)) >= Uint32FromInt32(i)) { + if !(**(**Tuint32_t)(__ccgo_up(a)) >= Uint32FromInt32(i)) { break } goto _33 @@ -140473,7 +140473,7 @@ _4: } } for { - if !(z > a && !(*(*Tuint32_t)(unsafe.Pointer(z + uintptr(-Int32FromInt32(1))*4)) != 0)) { + if !(z > a && !(**(**Tuint32_t)(__ccgo_up(z + uintptr(-Int32FromInt32(1))*4)) != 0)) { break } goto _34 @@ -140494,11 +140494,11 @@ _4: } if !(Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0) { /* Count trailing zeros in last place */ - if z > a && *(*Tuint32_t)(unsafe.Pointer(z + uintptr(-Int32FromInt32(1))*4)) != 0 { + if z > a && **(**Tuint32_t)(__ccgo_up(z + uintptr(-Int32FromInt32(1))*4)) != 0 { i = int32(10) j = Int32FromInt32(0) for { - if !(*(*Tuint32_t)(unsafe.Pointer(z + uintptr(-Int32FromInt32(1))*4))%Uint32FromInt32(i) == uint32(0)) { + if !(**(**Tuint32_t)(__ccgo_up(z + uintptr(-Int32FromInt32(1))*4))%Uint32FromInt32(i) == uint32(0)) { break } goto _35 @@ -140568,7 +140568,7 @@ _4: for int64(ebuf)-int64(estr) < int64(2) { estr = estr - 1 v5 = estr - *(*uint8)(unsafe.Pointer(v5)) = uint8('0') + **(**uint8)(__ccgo_up(v5)) = uint8('0') } estr = estr - 1 v5 = estr @@ -140577,10 +140577,10 @@ _4: } else { v7 = int32('+') } - *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(v7) + **(**uint8)(__ccgo_up(v5)) = Uint8FromInt32(v7) estr = estr - 1 v5 = estr - *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(t) + **(**uint8)(__ccgo_up(v5)) = Uint8FromInt32(t) if int64(ebuf)-int64(estr) > int64(int32(INT_MAX)-l) { return -int32(1) } @@ -140601,18 +140601,18 @@ _4: if !(d <= r) { break } - s2 = _fmt_u(tls, uint64(*(*Tuint32_t)(unsafe.Pointer(d))), bp+516+uintptr(9)) + s2 = _fmt_u(tls, uint64(**(**Tuint32_t)(__ccgo_up(d))), bp+516+uintptr(9)) if d != a { for s2 > bp+516 { s2 = s2 - 1 v5 = s2 - *(*uint8)(unsafe.Pointer(v5)) = uint8('0') + **(**uint8)(__ccgo_up(v5)) = uint8('0') } } else { if s2 == bp+516+uintptr(9) { s2 = s2 - 1 v5 = s2 - *(*uint8)(unsafe.Pointer(v5)) = uint8('0') + **(**uint8)(__ccgo_up(v5)) = uint8('0') } } _out(tls, f, s2, Uint64FromInt64(int64(bp+516+uintptr(9))-int64(s2))) @@ -140628,11 +140628,11 @@ _4: if !(d < z && p > 0) { break } - s3 = _fmt_u(tls, uint64(*(*Tuint32_t)(unsafe.Pointer(d))), bp+516+uintptr(9)) + s3 = _fmt_u(tls, uint64(**(**Tuint32_t)(__ccgo_up(d))), bp+516+uintptr(9)) for s3 > bp+516 { s3 = s3 - 1 v5 = s3 - *(*uint8)(unsafe.Pointer(v5)) = uint8('0') + **(**uint8)(__ccgo_up(v5)) = uint8('0') } if int32(9) < p { v7 = int32(9) @@ -140656,17 +140656,17 @@ _4: if !(d < z && p >= 0) { break } - s4 = _fmt_u(tls, uint64(*(*Tuint32_t)(unsafe.Pointer(d))), bp+516+uintptr(9)) + s4 = _fmt_u(tls, uint64(**(**Tuint32_t)(__ccgo_up(d))), bp+516+uintptr(9)) if s4 == bp+516+uintptr(9) { s4 = s4 - 1 v5 = s4 - *(*uint8)(unsafe.Pointer(v5)) = uint8('0') + **(**uint8)(__ccgo_up(v5)) = uint8('0') } if d != a { for s4 > bp+516 { s4 = s4 - 1 v5 = s4 - *(*uint8)(unsafe.Pointer(v5)) = uint8('0') + **(**uint8)(__ccgo_up(v5)) = uint8('0') } } else { v5 = s4 @@ -140705,18 +140705,18 @@ func _getint(tls *TLS, s uintptr) (r int32) { _ = i i = 0 for { - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-uint32('0') < uint32(10)) != 0) { break } - if Uint32FromInt32(i) > Uint32FromInt32(INT_MAX)/Uint32FromUint32(10) || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-int32('0') > int32(INT_MAX)-int32(10)*i { + if Uint32FromInt32(i) > Uint32FromInt32(INT_MAX)/Uint32FromUint32(10) || Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-int32('0') > int32(INT_MAX)-int32(10)*i { i = -int32(1) } else { - i = int32(10)*i + (Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s))))) - int32('0')) + i = int32(10)*i + (Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(s))))) - int32('0')) } goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s)) = *(*uintptr)(unsafe.Pointer(s)) + 1 + **(**uintptr)(__ccgo_up(s)) = **(**uintptr)(__ccgo_up(s)) + 1 } return i } @@ -140737,7 +140737,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, var _ /* s at bp+0 */ uintptr var _ /* wc at bp+40 */ [2]Twchar_t _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argpos, cnt, fl, i, l, l10n, p, pl, prefix, ps, st, t, w, ws, xp, z, v31, v34, v45, v5, v6, v8 - *(*uintptr)(unsafe.Pointer(bp)) = fmt + **(**uintptr)(__ccgo_up(bp)) = fmt l10n = uint32(0) cnt = 0 l = 0 @@ -140750,30 +140750,30 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } /* Update output count, end loop when fmt is exhausted */ cnt = cnt + l - if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) != 0) { + if !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))) != 0) { break } /* Handle literal text and %% format specifiers */ - a = *(*uintptr)(unsafe.Pointer(bp)) + a = **(**uintptr)(__ccgo_up(bp)) for { - if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32('%')) { + if !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) != int32('%')) { break } goto _2 _2: ; - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 } - z = *(*uintptr)(unsafe.Pointer(bp)) + z = **(**uintptr)(__ccgo_up(bp)) for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('%') && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1))) == int32('%')) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) == int32('%') && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1))) == int32('%')) { break } goto _3 _3: ; z = z + 1 - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(2) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + uintptr(2) } if int64(z)-int64(a) > int64(int32(INT_MAX)-cnt) { goto overflow @@ -140785,46 +140785,46 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if l != 0 { goto _1 } - if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2))) == int32('$') { + if BoolInt32(uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 2))) == int32('$') { l10n = uint32(1) - argpos = Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1))) - int32('0') - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(3) + argpos = Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1))) - int32('0') + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + uintptr(3) } else { argpos = -int32(1) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 } /* Read modifier flags */ fl = uint32(0) for { - if !(uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-uint32(' ') < uint32(32) && (Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('0')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('\'')-Int32FromUint8(' ')))&(uint32(1)<<(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-int32(' '))) != 0) { + if !(uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))))-uint32(' ') < uint32(32) && (Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('0')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('\'')-Int32FromUint8(' ')))&(uint32(1)<<(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))))-int32(' '))) != 0) { break } - fl = fl | uint32(1)<<(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-int32(' ')) + fl = fl | uint32(1)<<(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))))-int32(' ')) goto _4 _4: ; - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 } /* Read field width */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('*') { - if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2))) == int32('$') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) == int32('*') { + if BoolInt32(uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 2))) == int32('$') { l10n = uint32(1) if !(f != 0) { - *(*int32)(unsafe.Pointer(nl_type + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))-int32('0'))*4)) = int32(_INT) + **(**int32)(__ccgo_up(nl_type + uintptr(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1)))-int32('0'))*4)) = int32(_INT) w = Int32FromInt32(0) } else { - w = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))-int32('0'))*8))) + w = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1)))-int32('0'))*8))) } - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(3) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + uintptr(3) } else { if !(l10n != 0) { if f != 0 { - v5 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) + v5 = VaInt32(&**(**Tva_list)(__ccgo_up(ap))) } else { v5 = 0 } w = v5 - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 } else { goto inval } @@ -140841,32 +140841,32 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } } /* Read precision */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('.') && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1))) == int32('*') { - if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 3))) == int32('$') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) == int32('.') && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1))) == int32('*') { + if BoolInt32(uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 2)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 3))) == int32('$') { if !(f != 0) { - *(*int32)(unsafe.Pointer(nl_type + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2)))-int32('0'))*4)) = int32(_INT) + **(**int32)(__ccgo_up(nl_type + uintptr(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 2)))-int32('0'))*4)) = int32(_INT) p = Int32FromInt32(0) } else { - p = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2)))-int32('0'))*8))) + p = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 2)))-int32('0'))*8))) } - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(4) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + uintptr(4) } else { if !(l10n != 0) { if f != 0 { - v5 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) + v5 = VaInt32(&**(**Tva_list)(__ccgo_up(ap))) } else { v5 = 0 } p = v5 - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(2) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + uintptr(2) } else { goto inval } } xp = BoolInt32(p >= 0) } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('.') { - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) == int32('.') { + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 p = _getint(tls, bp) xp = int32(1) } else { @@ -140877,13 +140877,13 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, /* Format specifier state machine */ st = uint32(0) for cond := true; cond; cond = st-uint32(1) < uint32(_STOP) { - if uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-uint32('A') > Uint32FromInt32(Int32FromUint8('z')-Int32FromUint8('A')) { + if uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))))-uint32('A') > Uint32FromInt32(Int32FromUint8('z')-Int32FromUint8('A')) { goto inval } ps = st - v8 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - st = uint32(*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_states)) + uintptr(st)*58 + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(v8)))-int32('A'))))) + v8 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + st = uint32(**(**uint8)(__ccgo_up(uintptr(unsafe.Pointer(&_states)) + uintptr(st)*58 + uintptr(Int32FromUint8(**(**uint8)(__ccgo_up(v8)))-int32('A'))))) } if !(st != 0) { goto inval @@ -140896,9 +140896,9 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } else { if argpos >= 0 { if !(f != 0) { - *(*int32)(unsafe.Pointer(nl_type + uintptr(argpos)*4)) = Int32FromUint32(st) + **(**int32)(__ccgo_up(nl_type + uintptr(argpos)*4)) = Int32FromUint32(st) } else { - *(*Targ)(unsafe.Pointer(bp + 8)) = *(*Targ)(unsafe.Pointer(nl_arg + uintptr(argpos)*8)) + **(**Targ)(__ccgo_up(bp + 8)) = **(**Targ)(__ccgo_up(nl_arg + uintptr(argpos)*8)) } } else { if f != 0 { @@ -140918,7 +140918,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, z = bp + 16 + uintptr(24) prefix = __ccgo_ts + 1656 pl = 0 - t = Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + uintptr(-Int32FromInt32(1))))) + t = Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + uintptr(-Int32FromInt32(1))))) /* Transform ls,lc -> S,C */ if ps != 0 && t&int32(15) == int32(3) { t = t & ^Int32FromInt32(32) @@ -140976,19 +140976,19 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, ; switch ps { case uint32(_BARE): - *(*int32)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) = cnt + **(**int32)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 8)))) = cnt case uint32(_LPRE): - *(*int64)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) = int64(cnt) + **(**int64)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 8)))) = int64(cnt) case uint32(_LLPRE): - *(*int64)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) = int64(cnt) + **(**int64)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 8)))) = int64(cnt) case uint32(_HPRE): - *(*uint16)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) = Uint16FromInt32(cnt) + **(**uint16)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 8)))) = Uint16FromInt32(cnt) case uint32(_HHPRE): - *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) = Uint8FromInt32(cnt) + **(**uint8)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 8)))) = Uint8FromInt32(cnt) case uint32(_ZTPRE): - *(*Tsize_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) = Uint64FromInt32(cnt) + **(**Tsize_t)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 8)))) = Uint64FromInt32(cnt) case uint32(_JPRE): - *(*Tuintmax_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) = Uint64FromInt32(cnt) + **(**Tuintmax_t)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 8)))) = Uint64FromInt32(cnt) break } goto _1 @@ -141074,7 +141074,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, p = v5 v8 = z - uintptr(v5) a = v8 - *(*uint8)(unsafe.Pointer(v8)) = uint8(*(*Tuintmax_t)(unsafe.Pointer(bp + 8))) + **(**uint8)(__ccgo_up(v8)) = uint8(*(*Tuintmax_t)(unsafe.Pointer(bp + 8))) fl = fl & ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) goto _30 _19: @@ -141082,7 +141082,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if !(int32(1) != 0) { goto _37 } - a = Xstrerror(tls, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) + a = Xstrerror(tls, **(**int32)(__ccgo_up(X__errno_location(tls)))) goto _38 _37: ; @@ -141102,7 +141102,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, v5 = p } z = a + uintptr(Xstrnlen(tls, a, Uint64FromInt32(v5))) - if p < 0 && *(*uint8)(unsafe.Pointer(z)) != 0 { + if p < 0 && **(**uint8)(__ccgo_up(z)) != 0 { goto overflow } p = int32(int64(z) - int64(a)) @@ -141113,8 +141113,8 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if !(*(*Tuintmax_t)(unsafe.Pointer(bp + 8)) != 0) { goto narrow_c } - (*(*[2]Twchar_t)(unsafe.Pointer(bp + 40)))[0] = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(bp + 8))) - (*(*[2]Twchar_t)(unsafe.Pointer(bp + 40)))[int32(1)] = 0 + (**(**[2]Twchar_t)(__ccgo_up(bp + 40)))[0] = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(bp + 8))) + (**(**[2]Twchar_t)(__ccgo_up(bp + 40)))[int32(1)] = 0 *(*uintptr)(unsafe.Pointer(bp + 8)) = bp + 40 p = -int32(1) _21: @@ -141124,10 +141124,10 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, l = v5 i = Uint64FromInt32(v5) for { - if v45 = i < Uint64FromInt32(p) && *(*Twchar_t)(unsafe.Pointer(ws)) != 0; v45 { + if v45 = i < Uint64FromInt32(p) && **(**Twchar_t)(__ccgo_up(ws)) != 0; v45 { v8 = ws ws += 4 - v6 = Xwctomb(tls, bp+48, *(*Twchar_t)(unsafe.Pointer(v8))) + v6 = Xwctomb(tls, bp+48, **(**Twchar_t)(__ccgo_up(v8))) l = v6 } if !(v45 && v6 >= 0 && Uint64FromInt32(l) <= Uint64FromInt32(p)-i) { @@ -141149,10 +141149,10 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, ws = *(*uintptr)(unsafe.Pointer(bp + 8)) i = uint64(0) for { - if v45 = i < uint64(0+Uint32FromInt32(p)) && *(*Twchar_t)(unsafe.Pointer(ws)) != 0; v45 { + if v45 = i < uint64(0+Uint32FromInt32(p)) && **(**Twchar_t)(__ccgo_up(ws)) != 0; v45 { v8 = ws ws += 4 - v5 = Xwctomb(tls, bp+48, *(*Twchar_t)(unsafe.Pointer(v8))) + v5 = Xwctomb(tls, bp+48, **(**Twchar_t)(__ccgo_up(v8))) l = v5 } if !(v45 && i+Uint64FromInt32(v5) <= Uint64FromInt32(p)) { @@ -141228,17 +141228,17 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } i = uint64(1) for { - if !(i <= uint64(NL_ARGMAX) && *(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)) != 0) { + if !(i <= uint64(NL_ARGMAX) && **(**int32)(__ccgo_up(nl_type + uintptr(i)*4)) != 0) { break } - _pop_arg(tls, nl_arg+uintptr(i)*8, *(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)), ap) + _pop_arg(tls, nl_arg+uintptr(i)*8, **(**int32)(__ccgo_up(nl_type + uintptr(i)*4)), ap) goto _51 _51: ; i = i + 1 } for { - if !(i <= uint64(NL_ARGMAX) && !(*(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)) != 0)) { + if !(i <= uint64(NL_ARGMAX) && !(**(**int32)(__ccgo_up(nl_type + uintptr(i)*4)) != 0)) { break } goto _52 @@ -141253,12 +141253,12 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto inval inval: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) goto overflow overflow: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return -int32(1) } @@ -141276,12 +141276,12 @@ func Xvfprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { var _ /* nl_arg at bp+48 */ [10]Targ var _ /* nl_type at bp+8 */ [10]int32 _, _, _, _, _, _, _ = __need_unlock, olderr, ret, saved_buf, v1, v2, v3 - *(*[10]int32)(unsafe.Pointer(bp + 8)) = [10]int32{} + **(**[10]int32)(__ccgo_up(bp + 8)) = [10]int32{} saved_buf = uintptr(0) /* the copy allows passing va_list* even if va_list is an array */ - *(*Tva_list)(unsafe.Pointer(bp)) = ap + **(**Tva_list)(__ccgo_up(bp)) = ap if _printf_core(tls, uintptr(0), fmt, bp, bp+48, bp+8) < 0 { - _ = *(*Tva_list)(unsafe.Pointer(bp)) + _ = **(**Tva_list)(__ccgo_up(bp)) return -int32(1) } if AtomicLoadPInt32(f+140) >= 0 { @@ -141291,7 +141291,7 @@ func Xvfprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } __need_unlock = v1 olderr = Int32FromUint32((*TFILE)(unsafe.Pointer(f)).Fflags & uint32(F_ERR)) - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_ERR)) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^Int32FromInt32(F_ERR)) if !((*TFILE)(unsafe.Pointer(f)).Fbuf_size != 0) { saved_buf = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Fbuf = bp + 128 @@ -141323,11 +141323,11 @@ func Xvfprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_ERR) != 0 { ret = -int32(1) } - *(*uint32)(unsafe.Pointer(f)) |= Uint32FromInt32(olderr) + **(**uint32)(__ccgo_up(f)) |= Uint32FromInt32(olderr) if __need_unlock != 0 { ___unlockfile(tls, f) } - _ = *(*Tva_list)(unsafe.Pointer(bp)) + _ = **(**Tva_list)(__ccgo_up(bp)) return ret } @@ -141344,15 +141344,15 @@ func _store_int(tls *TLS, dest uintptr, size int32, i uint64) { } switch size { case -int32(2): - *(*uint8)(unsafe.Pointer(dest)) = uint8(i) + **(**uint8)(__ccgo_up(dest)) = uint8(i) case -int32(1): - *(*int16)(unsafe.Pointer(dest)) = Int16FromUint64(i) + **(**int16)(__ccgo_up(dest)) = Int16FromUint64(i) case SIZE_def: - *(*int32)(unsafe.Pointer(dest)) = Int32FromUint64(i) + **(**int32)(__ccgo_up(dest)) = Int32FromUint64(i) case int32(SIZE_l): - *(*int64)(unsafe.Pointer(dest)) = Int64FromUint64(i) + **(**int64)(__ccgo_up(dest)) = Int64FromUint64(i) case int32(SIZE_ll): - *(*int64)(unsafe.Pointer(dest)) = Int64FromUint64(i) + **(**int64)(__ccgo_up(dest)) = Int64FromUint64(i) break } } @@ -141415,17 +141415,17 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } p = fmt for { - if !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if !(**(**uint8)(__ccgo_up(p)) != 0) { break } alloc = 0 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v3 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _5 _5: if v3 != 0 { for { - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) v6 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _8 _8: @@ -141440,7 +141440,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v1 = X__shgetc(tls, f) } @@ -141458,16 +141458,16 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { pos = pos + ((*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf))) goto _2 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32('%') || Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('%') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) != int32('%') || Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) == int32('%') { X__shlim(tls, f, int64(Int32FromInt32(0))) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('%') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('%') { p = p + 1 for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v3 = X__shgetc(tls, f) } @@ -141486,13 +141486,13 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v1 = X__shgetc(tls, f) } c = v1 } - if c != Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) { + if c != Int32FromUint8(**(**uint8)(__ccgo_up(p))) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } @@ -141505,12 +141505,12 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { goto _2 } p = p + 1 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('*') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('*') { dest = uintptr(0) p = p + 1 } else { - if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('$') { - dest = _arg_n(tls, ap, Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))-int32('0'))) + if BoolInt32(uint32(**(**uint8)(__ccgo_up(p)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) == int32('$') { + dest = _arg_n(tls, ap, Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(p)))-int32('0'))) p = p + uintptr(2) } else { dest = VaUintptr(&ap) @@ -141518,16 +141518,16 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } width = 0 for { - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p)))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(p)))-uint32('0') < uint32(10)) != 0) { break } - width = int32(10)*width + Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - int32('0') + width = int32(10)*width + Int32FromUint8(**(**uint8)(__ccgo_up(p))) - int32('0') goto _25 _25: ; p = p + 1 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('m') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('m') { wcs = uintptr(0) s = uintptr(0) alloc = BoolInt32(!!(dest != 0)) @@ -141538,16 +141538,16 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { size = SIZE_def v10 = p p = p + 1 - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(v10))) { case int32('h'): - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('h') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('h') { p = p + 1 size = -Int32FromInt32(2) } else { size = -int32(1) } case int32('l'): - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('l') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('l') { p = p + 1 size = Int32FromInt32(SIZE_ll) } else { @@ -141606,7 +141606,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { default: goto fmt_fail } - t = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + t = Int32FromUint8(**(**uint8)(__ccgo_up(p))) /* C or S */ if t&int32(0x2f) == int32(3) { t = t | int32(32) @@ -141630,7 +141630,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v1 = X__shgetc(tls, f) } @@ -141652,7 +141652,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v1 = X__shgetc(tls, f) } @@ -141709,58 +141709,58 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { ; if t == int32('c') || t == int32('s') { Xmemset(tls, bp+16, -int32(1), uint64(257)) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[0] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[0] = uint8(0) if t == int32('s') { - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\t')] = uint8(0) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\n')] = uint8(0) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\v')] = uint8(0) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\f')] = uint8(0) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\r')] = uint8(0) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8(' ')] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\t')] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\n')] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\v')] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\f')] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\r')] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8(' ')] = uint8(0) } } else { p = p + 1 v10 = p - if Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) == int32('^') { + if Int32FromUint8(**(**uint8)(__ccgo_up(v10))) == int32('^') { p = p + 1 invert = Int32FromInt32(1) } else { invert = 0 } Xmemset(tls, bp+16, invert, uint64(257)) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[0] = uint8(0) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') { + (**(**[257]uint8)(__ccgo_up(bp + 16)))[0] = uint8(0) + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('-') { p = p + 1 - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('-')] = Uint8FromInt32(Int32FromInt32(1) - invert) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('-')] = Uint8FromInt32(Int32FromInt32(1) - invert) } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32(']') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32(']') { p = p + 1 - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8(']')] = Uint8FromInt32(Int32FromInt32(1) - invert) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8(']')] = Uint8FromInt32(Int32FromInt32(1) - invert) } } for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32(']')) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(p))) != int32(']')) { break } - if !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if !(**(**uint8)(__ccgo_up(p)) != 0) { goto fmt_fail } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') && *(*uint8)(unsafe.Pointer(p + 1)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) != int32(']') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('-') && **(**uint8)(__ccgo_up(p + 1)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) != int32(']') { v10 = p p = p + 1 - c = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10 + uintptr(-Int32FromInt32(1))))) + c = Int32FromUint8(**(**uint8)(__ccgo_up(v10 + uintptr(-Int32FromInt32(1))))) for { - if !(c < Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))) { + if !(c < Int32FromUint8(**(**uint8)(__ccgo_up(p)))) { break } - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[int32(1)+c] = Uint8FromInt32(int32(1) - invert) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[int32(1)+c] = Uint8FromInt32(int32(1) - invert) goto _57 _57: ; c = c + 1 } } - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[int32(1)+Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))] = Uint8FromInt32(int32(1) - invert) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[int32(1)+Int32FromUint8(**(**uint8)(__ccgo_up(p)))] = Uint8FromInt32(int32(1) - invert) goto _56 _56: ; @@ -141785,19 +141785,19 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } else { wcs = dest } - *(*Tmbstate_t)(unsafe.Pointer(bp + 8)) = Tmbstate_t{} + **(**Tmbstate_t)(__ccgo_up(bp + 8)) = Tmbstate_t{} for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v3 = X__shgetc(tls, f) } v1 = v3 c = v1 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { + if !((**(**[257]uint8)(__ccgo_up(bp + 16)))[v1+int32(1)] != 0) { break } *(*uint8)(unsafe.Pointer(bp)) = Uint8FromInt32(c) @@ -141810,7 +141810,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if wcs != 0 { v64 = i i = i + 1 - *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(v64)*4)) = *(*Twchar_t)(unsafe.Pointer(bp + 276)) + **(**Twchar_t)(__ccgo_up(wcs + uintptr(v64)*4)) = **(**Twchar_t)(__ccgo_up(bp + 276)) } if alloc != 0 && i == k { k = k + (k + uint64(1)) @@ -141835,18 +141835,18 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v3 = X__shgetc(tls, f) } v1 = v3 c = v1 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { + if !((**(**[257]uint8)(__ccgo_up(bp + 16)))[v1+int32(1)] != 0) { break } v64 = i i = i + 1 - *(*uint8)(unsafe.Pointer(s + uintptr(v64))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + uintptr(v64))) = Uint8FromInt32(c) if i == k { k = k + (k + uint64(1)) tmp1 = Xrealloc(tls, s, k) @@ -141865,18 +141865,18 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v17 = f + 8 v11 = *(*uintptr)(unsafe.Pointer(v17)) *(*uintptr)(unsafe.Pointer(v17)) = *(*uintptr)(unsafe.Pointer(v17)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v11))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v11))) } else { v3 = X__shgetc(tls, f) } v1 = v3 c = v1 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { + if !((**(**[257]uint8)(__ccgo_up(bp + 16)))[v1+int32(1)] != 0) { break } v64 = i i = i + 1 - *(*uint8)(unsafe.Pointer(s + uintptr(v64))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + uintptr(v64))) = Uint8FromInt32(c) } } else { for { @@ -141884,13 +141884,13 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v3 = X__shgetc(tls, f) } v1 = v3 c = v1 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { + if !((**(**[257]uint8)(__ccgo_up(bp + 16)))[v1+int32(1)] != 0) { break } } @@ -141908,17 +141908,17 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } if alloc != 0 { if size == int32(SIZE_l) { - *(*uintptr)(unsafe.Pointer(dest)) = wcs + **(**uintptr)(__ccgo_up(dest)) = wcs } else { - *(*uintptr)(unsafe.Pointer(dest)) = s + **(**uintptr)(__ccgo_up(dest)) = s } } if t != int32('c') { if wcs != 0 { - *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) = 0 + **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) = 0 } if s != 0 { - *(*uint8)(unsafe.Pointer(s + uintptr(i))) = uint8(0) + **(**uint8)(__ccgo_up(s + uintptr(i))) = uint8(0) } } goto _54 @@ -141951,7 +141951,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { goto match_fail } if t == int32('p') && dest != 0 { - *(*uintptr)(unsafe.Pointer(dest)) = uintptr(x) + **(**uintptr)(__ccgo_up(dest)) = uintptr(x) } else { _store_int(tls, dest, size, x) } @@ -141979,11 +141979,11 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if dest != 0 { switch size { case SIZE_def: - *(*float32)(unsafe.Pointer(dest)) = float32(y) + **(**float32)(__ccgo_up(dest)) = float32(y) case int32(SIZE_l): - *(*float64)(unsafe.Pointer(dest)) = y + **(**float64)(__ccgo_up(dest)) = y case int32(SIZE_L): - *(*float64)(unsafe.Pointer(dest)) = y + **(**float64)(__ccgo_up(dest)) = y break } } @@ -142149,41 +142149,41 @@ var _states1 = [8][58]uint8{ func _pop_arg1(tls *TLS, arg uintptr, type1 int32, ap uintptr) { switch type1 { case int32(_PTR): - *(*uintptr)(unsafe.Pointer(arg)) = VaUintptr(&*(*Tva_list)(unsafe.Pointer(ap))) + *(*uintptr)(unsafe.Pointer(arg)) = VaUintptr(&**(**Tva_list)(__ccgo_up(ap))) case int32(_INT): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_UINT): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint32(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint32(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_LONG): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_ULONG): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&**(**Tva_list)(__ccgo_up(ap))) case int32(_ULLONG): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_SHORT): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt16(int16(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt16(int16(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_USHORT): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint16FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint16FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_CHAR): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt8(int8(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt8(int8(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_UCHAR): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint8FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint8FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_LLONG): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_SIZET): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&**(**Tva_list)(__ccgo_up(ap))) case int32(_IMAX): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_UMAX): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&**(**Tva_list)(__ccgo_up(ap))) case int32(_PDIFF): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_UIPTR): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUintptr(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUintptr(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_DBL): - *(*float64)(unsafe.Pointer(arg)) = float64(VaFloat64(&*(*Tva_list)(unsafe.Pointer(ap)))) + *(*float64)(unsafe.Pointer(arg)) = float64(VaFloat64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_LDBL): - *(*float64)(unsafe.Pointer(arg)) = VaFloat64(&*(*Tva_list)(unsafe.Pointer(ap))) + *(*float64)(unsafe.Pointer(arg)) = VaFloat64(&**(**Tva_list)(__ccgo_up(ap))) } } @@ -142199,7 +142199,7 @@ func _out1(tls *TLS, f uintptr, s uintptr, l Tsize_t) { } v2 = s s += 4 - Xfputwc(tls, *(*Twchar_t)(unsafe.Pointer(v2)), f) + Xfputwc(tls, **(**Twchar_t)(__ccgo_up(v2)), f) } } @@ -142217,18 +142217,18 @@ func _getint1(tls *TLS, s uintptr) (r int32) { _ = i i = 0 for { - if !(BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-uint32('0') < uint32(10)) != 0) { break } - if Uint32FromInt32(i) > Uint32FromInt32(INT_MAX)/Uint32FromUint32(10) || *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s))))-int32('0') > int32(INT_MAX)-int32(10)*i { + if Uint32FromInt32(i) > Uint32FromInt32(INT_MAX)/Uint32FromUint32(10) || **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(s))))-int32('0') > int32(INT_MAX)-int32(10)*i { i = -int32(1) } else { - i = int32(10)*i + (*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))) - int32('0')) + i = int32(10)*i + (**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))) - int32('0')) } goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s)) += 4 + **(**uintptr)(__ccgo_up(s)) += 4 } return i } @@ -142259,7 +142259,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, var _ /* s at bp+8 */ uintptr var _ /* wc at bp+40 */ Twchar_t _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argpos, bs, cnt, fl, i, l, l10n, p, ps, st, t, w, xp, z, v15, v5, v6, v7, v8, v9 - *(*uintptr)(unsafe.Pointer(bp + 8)) = fmt + **(**uintptr)(__ccgo_up(bp + 8)) = fmt l10n = uint32(0) cnt = 0 l = 0 @@ -142272,30 +142272,30 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } /* Update output count, end loop when fmt is exhausted */ cnt = cnt + l - if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) != 0) { + if !(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) != 0) { break } /* Handle literal text and %% format specifiers */ - a = *(*uintptr)(unsafe.Pointer(bp + 8)) + a = **(**uintptr)(__ccgo_up(bp + 8)) for { - if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) != 0 && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) != int32('%')) { + if !(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) != 0 && **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) != int32('%')) { break } goto _2 _2: ; - *(*uintptr)(unsafe.Pointer(bp + 8)) += 4 + **(**uintptr)(__ccgo_up(bp + 8)) += 4 } - z = *(*uintptr)(unsafe.Pointer(bp + 8)) + z = **(**uintptr)(__ccgo_up(bp + 8)) for { - if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) == int32('%') && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4)) == int32('%')) { + if !(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) == int32('%') && **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 1*4)) == int32('%')) { break } goto _3 _3: ; z += 4 - *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(2)*4 + **(**uintptr)(__ccgo_up(bp + 8)) = **(**uintptr)(__ccgo_up(bp + 8)) + uintptr(2)*4 } if (int64(z)-int64(a))/4 > int64(int32(INT_MAX)-cnt) { goto overflow @@ -142307,42 +142307,42 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if l != 0 { goto _1 } - if BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4)))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4)) == int32('$') { + if BoolInt32(Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 1*4)))-uint32('0') < uint32(10)) != 0 && **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 2*4)) == int32('$') { l10n = uint32(1) - argpos = *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4)) - int32('0') - *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(3)*4 + argpos = **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 1*4)) - int32('0') + **(**uintptr)(__ccgo_up(bp + 8)) = **(**uintptr)(__ccgo_up(bp + 8)) + uintptr(3)*4 } else { argpos = -int32(1) - *(*uintptr)(unsafe.Pointer(bp + 8)) += 4 + **(**uintptr)(__ccgo_up(bp + 8)) += 4 } /* Read modifier flags */ fl = uint32(0) for { - if !(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))))-uint32(' ') < uint32(32) && (Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('0')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('\'')-Int32FromUint8(' ')))&(uint32(1)<<(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8))))-int32(' '))) != 0) { + if !(Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))))-uint32(' ') < uint32(32) && (Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('0')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('\'')-Int32FromUint8(' ')))&(uint32(1)<<(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8))))-int32(' '))) != 0) { break } - fl = fl | uint32(1)<<(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8))))-int32(' ')) + fl = fl | uint32(1)<<(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8))))-int32(' ')) goto _4 _4: ; - *(*uintptr)(unsafe.Pointer(bp + 8)) += 4 + **(**uintptr)(__ccgo_up(bp + 8)) += 4 } /* Read field width */ - if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) == int32('*') { - if BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4)))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4)) == int32('$') { + if **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) == int32('*') { + if BoolInt32(Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 1*4)))-uint32('0') < uint32(10)) != 0 && **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 2*4)) == int32('$') { l10n = uint32(1) - *(*int32)(unsafe.Pointer(nl_type + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4))-int32('0'))*4)) = int32(_INT) - w = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4))-int32('0'))*8))) - *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(3)*4 + **(**int32)(__ccgo_up(nl_type + uintptr(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 1*4))-int32('0'))*4)) = int32(_INT) + w = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 1*4))-int32('0'))*8))) + **(**uintptr)(__ccgo_up(bp + 8)) = **(**uintptr)(__ccgo_up(bp + 8)) + uintptr(3)*4 } else { if !(l10n != 0) { if f != 0 { - v5 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) + v5 = VaInt32(&**(**Tva_list)(__ccgo_up(ap))) } else { v5 = 0 } w = v5 - *(*uintptr)(unsafe.Pointer(bp + 8)) += 4 + **(**uintptr)(__ccgo_up(bp + 8)) += 4 } else { goto inval } @@ -142359,28 +142359,28 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } } /* Read precision */ - if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) == int32('.') && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4)) == int32('*') { - if BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4)))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 3*4)) == int32('$') { - *(*int32)(unsafe.Pointer(nl_type + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4))-int32('0'))*4)) = int32(_INT) - p = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4))-int32('0'))*8))) - *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(4)*4 + if **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) == int32('.') && **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 1*4)) == int32('*') { + if BoolInt32(Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 2*4)))-uint32('0') < uint32(10)) != 0 && **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 3*4)) == int32('$') { + **(**int32)(__ccgo_up(nl_type + uintptr(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 2*4))-int32('0'))*4)) = int32(_INT) + p = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 2*4))-int32('0'))*8))) + **(**uintptr)(__ccgo_up(bp + 8)) = **(**uintptr)(__ccgo_up(bp + 8)) + uintptr(4)*4 } else { if !(l10n != 0) { if f != 0 { - v5 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) + v5 = VaInt32(&**(**Tva_list)(__ccgo_up(ap))) } else { v5 = 0 } p = v5 - *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(2)*4 + **(**uintptr)(__ccgo_up(bp + 8)) = **(**uintptr)(__ccgo_up(bp + 8)) + uintptr(2)*4 } else { goto inval } } xp = BoolInt32(p >= 0) } else { - if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) == int32('.') { - *(*uintptr)(unsafe.Pointer(bp + 8)) += 4 + if **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) == int32('.') { + **(**uintptr)(__ccgo_up(bp + 8)) += 4 p = _getint1(tls, bp+8) xp = int32(1) } else { @@ -142391,13 +142391,13 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, /* Format specifier state machine */ st = uint32(0) for cond := true; cond; cond = st-uint32(1) < uint32(_STOP) { - if Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))))-uint32('A') > Uint32FromInt32(Int32FromUint8('z')-Int32FromUint8('A')) { + if Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))))-uint32('A') > Uint32FromInt32(Int32FromUint8('z')-Int32FromUint8('A')) { goto inval } ps = st - v8 = *(*uintptr)(unsafe.Pointer(bp + 8)) - *(*uintptr)(unsafe.Pointer(bp + 8)) += 4 - st = uint32(*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_states1)) + uintptr(st)*58 + uintptr(*(*Twchar_t)(unsafe.Pointer(v8))-int32('A'))))) + v8 = **(**uintptr)(__ccgo_up(bp + 8)) + **(**uintptr)(__ccgo_up(bp + 8)) += 4 + st = uint32(**(**uint8)(__ccgo_up(uintptr(unsafe.Pointer(&_states1)) + uintptr(st)*58 + uintptr(**(**Twchar_t)(__ccgo_up(v8))-int32('A'))))) } if !(st != 0) { goto inval @@ -142409,8 +142409,8 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } } else { if argpos >= 0 { - *(*int32)(unsafe.Pointer(nl_type + uintptr(argpos)*4)) = Int32FromUint32(st) - *(*Targ)(unsafe.Pointer(bp + 16)) = *(*Targ)(unsafe.Pointer(nl_arg + uintptr(argpos)*8)) + **(**int32)(__ccgo_up(nl_type + uintptr(argpos)*4)) = Int32FromUint32(st) + **(**Targ)(__ccgo_up(bp + 16)) = **(**Targ)(__ccgo_up(nl_arg + uintptr(argpos)*8)) } else { if f != 0 { _pop_arg1(tls, bp+16, Int32FromUint32(st), ap) @@ -142426,7 +142426,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_ERR) != 0 { return -int32(1) } - t = *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(-Int32FromInt32(1))*4)) + t = **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + uintptr(-Int32FromInt32(1))*4)) if ps != 0 && t&int32(15) == int32(3) { t = t & ^Int32FromInt32(32) } @@ -142434,19 +142434,19 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, case int32('n'): switch ps { case uint32(_BARE): - *(*int32)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))) = cnt + **(**int32)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 16)))) = cnt case uint32(_LPRE): - *(*int64)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))) = int64(cnt) + **(**int64)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 16)))) = int64(cnt) case uint32(_LLPRE): - *(*int64)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))) = int64(cnt) + **(**int64)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 16)))) = int64(cnt) case uint32(_HPRE): - *(*uint16)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))) = Uint16FromInt32(cnt) + **(**uint16)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 16)))) = Uint16FromInt32(cnt) case uint32(_HHPRE): - *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))) = Uint8FromInt32(cnt) + **(**uint8)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 16)))) = Uint8FromInt32(cnt) case uint32(_ZTPRE): - *(*Tsize_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))) = Uint64FromInt32(cnt) + **(**Tsize_t)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 16)))) = Uint64FromInt32(cnt) case uint32(_JPRE): - *(*Tuintmax_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))) = Uint64FromInt32(cnt) + **(**Tuintmax_t)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 16)))) = Uint64FromInt32(cnt) break } goto _1 @@ -142475,7 +142475,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, v5 = p } z = a + uintptr(Xwcsnlen(tls, a, Uint64FromInt32(v5)))*4 - if p < 0 && *(*Twchar_t)(unsafe.Pointer(z)) != 0 { + if p < 0 && **(**Twchar_t)(__ccgo_up(z)) != 0 { goto overflow } p = int32((int64(z) - int64(a)) / 4) @@ -142488,7 +142488,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, l = w goto _1 case int32('m'): - *(*uintptr)(unsafe.Pointer(bp + 16)) = Xstrerror(tls, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) + *(*uintptr)(unsafe.Pointer(bp + 16)) = Xstrerror(tls, **(**int32)(__ccgo_up(X__errno_location(tls)))) fallthrough case int32('s'): if !(*(*uintptr)(unsafe.Pointer(bp + 16)) != 0) { @@ -142520,7 +142520,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if i < 0 { return -int32(1) } - if p < 0 && *(*uint8)(unsafe.Pointer(bs)) != 0 { + if p < 0 && **(**uint8)(__ccgo_up(bs)) != 0 { goto overflow } p = l @@ -142581,17 +142581,17 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } i = int32(1) for { - if !(i <= int32(NL_ARGMAX) && *(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)) != 0) { + if !(i <= int32(NL_ARGMAX) && **(**int32)(__ccgo_up(nl_type + uintptr(i)*4)) != 0) { break } - _pop_arg1(tls, nl_arg+uintptr(i)*8, *(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)), ap) + _pop_arg1(tls, nl_arg+uintptr(i)*8, **(**int32)(__ccgo_up(nl_type + uintptr(i)*4)), ap) goto _17 _17: ; i = i + 1 } for { - if !(i <= int32(NL_ARGMAX) && !(*(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)) != 0)) { + if !(i <= int32(NL_ARGMAX) && !(**(**int32)(__ccgo_up(nl_type + uintptr(i)*4)) != 0)) { break } goto _18 @@ -142606,12 +142606,12 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto inval inval: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) goto overflow overflow: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return -int32(1) } @@ -142627,11 +142627,11 @@ func Xvfwprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { var _ /* nl_arg at bp+48 */ [10]Targ var _ /* nl_type at bp+8 */ [10]int32 _, _, _, _ = __need_unlock, olderr, ret, v1 - *(*[10]int32)(unsafe.Pointer(bp + 8)) = [10]int32{} + **(**[10]int32)(__ccgo_up(bp + 8)) = [10]int32{} /* the copy allows passing va_list* even if va_list is an array */ - *(*Tva_list)(unsafe.Pointer(bp)) = ap + **(**Tva_list)(__ccgo_up(bp)) = ap if _wprintf_core(tls, uintptr(0), fmt, bp, bp+48, bp+8) < 0 { - _ = *(*Tva_list)(unsafe.Pointer(bp)) + _ = **(**Tva_list)(__ccgo_up(bp)) return -int32(1) } if AtomicLoadPInt32(f+140) >= 0 { @@ -142642,16 +142642,16 @@ func Xvfwprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { __need_unlock = v1 Xfwide(tls, f, int32(1)) olderr = Int32FromUint32((*TFILE)(unsafe.Pointer(f)).Fflags & uint32(F_ERR)) - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_ERR)) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^Int32FromInt32(F_ERR)) ret = _wprintf_core(tls, f, fmt, bp, bp+48, bp+8) if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_ERR) != 0 { ret = -int32(1) } - *(*uint32)(unsafe.Pointer(f)) |= Uint32FromInt32(olderr) + **(**uint32)(__ccgo_up(f)) |= Uint32FromInt32(olderr) if __need_unlock != 0 { ___unlockfile(tls, f) } - _ = *(*Tva_list)(unsafe.Pointer(bp)) + _ = **(**Tva_list)(__ccgo_up(bp)) return ret } @@ -142661,15 +142661,15 @@ func _store_int1(tls *TLS, dest uintptr, size int32, i uint64) { } switch size { case -int32(2): - *(*uint8)(unsafe.Pointer(dest)) = uint8(i) + **(**uint8)(__ccgo_up(dest)) = uint8(i) case -int32(1): - *(*int16)(unsafe.Pointer(dest)) = Int16FromUint64(i) + **(**int16)(__ccgo_up(dest)) = Int16FromUint64(i) case SIZE_def: - *(*int32)(unsafe.Pointer(dest)) = Int32FromUint64(i) + **(**int32)(__ccgo_up(dest)) = Int32FromUint64(i) case int32(SIZE_l): - *(*int64)(unsafe.Pointer(dest)) = Int64FromUint64(i) + **(**int64)(__ccgo_up(dest)) = Int64FromUint64(i) case int32(SIZE_ll): - *(*int64)(unsafe.Pointer(dest)) = Int64FromUint64(i) + **(**int64)(__ccgo_up(dest)) = Int64FromUint64(i) break } } @@ -142701,13 +142701,13 @@ func _in_set(tls *TLS, set uintptr, c int32) (r int32) { var p, v3 uintptr _, _, _ = j, p, v3 p = set - if *(*Twchar_t)(unsafe.Pointer(p)) == int32('-') { + if **(**Twchar_t)(__ccgo_up(p)) == int32('-') { if c == int32('-') { return int32(1) } p += 4 } else { - if *(*Twchar_t)(unsafe.Pointer(p)) == int32(']') { + if **(**Twchar_t)(__ccgo_up(p)) == int32(']') { if c == int32(']') { return int32(1) } @@ -142715,15 +142715,15 @@ func _in_set(tls *TLS, set uintptr, c int32) (r int32) { } } for { - if !(*(*Twchar_t)(unsafe.Pointer(p)) != 0 && *(*Twchar_t)(unsafe.Pointer(p)) != int32(']')) { + if !(**(**Twchar_t)(__ccgo_up(p)) != 0 && **(**Twchar_t)(__ccgo_up(p)) != int32(']')) { break } - if *(*Twchar_t)(unsafe.Pointer(p)) == int32('-') && *(*Twchar_t)(unsafe.Pointer(p + 1*4)) != 0 && *(*Twchar_t)(unsafe.Pointer(p + 1*4)) != int32(']') { + if **(**Twchar_t)(__ccgo_up(p)) == int32('-') && **(**Twchar_t)(__ccgo_up(p + 1*4)) != 0 && **(**Twchar_t)(__ccgo_up(p + 1*4)) != int32(']') { v3 = p p += 4 - j = *(*Twchar_t)(unsafe.Pointer(v3 + uintptr(-Int32FromInt32(1))*4)) + j = **(**Twchar_t)(__ccgo_up(v3 + uintptr(-Int32FromInt32(1))*4)) for { - if !(j < *(*Twchar_t)(unsafe.Pointer(p))) { + if !(j < **(**Twchar_t)(__ccgo_up(p))) { break } if c == j { @@ -142735,7 +142735,7 @@ func _in_set(tls *TLS, set uintptr, c int32) (r int32) { j = j + 1 } } - if c == *(*Twchar_t)(unsafe.Pointer(p)) { + if c == **(**Twchar_t)(__ccgo_up(p)) { return int32(1) } goto _1 @@ -142773,20 +142773,20 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { Xfwide(tls, f, int32(1)) p = fmt for { - if !(*(*Twchar_t)(unsafe.Pointer(p)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(p)) != 0) { break } alloc = 0 - if Xiswspace(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(p)))) != 0 { - for Xiswspace(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(p + 1*4)))) != 0 { + if Xiswspace(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(p)))) != 0 { + for Xiswspace(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(p + 1*4)))) != 0 { p += 4 } for { - if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { + if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(**(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) + v4 = uint32(**(**uint8)(__ccgo_up(v5))) } else { v4 = Xgetwc(tls, f) } @@ -142801,21 +142801,21 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v6 = f + 8 *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 v5 = *(*uintptr)(unsafe.Pointer(v6)) - _ = *(*uint8)(unsafe.Pointer(v5)) + _ = **(**uint8)(__ccgo_up(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } goto _2 } - if *(*Twchar_t)(unsafe.Pointer(p)) != int32('%') || *(*Twchar_t)(unsafe.Pointer(p + 1*4)) == int32('%') { - if *(*Twchar_t)(unsafe.Pointer(p)) == int32('%') { + if **(**Twchar_t)(__ccgo_up(p)) != int32('%') || **(**Twchar_t)(__ccgo_up(p + 1*4)) == int32('%') { + if **(**Twchar_t)(__ccgo_up(p)) == int32('%') { p += 4 for { - if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { + if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(**(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) + v4 = uint32(**(**uint8)(__ccgo_up(v5))) } else { v4 = Xgetwc(tls, f) } @@ -142827,22 +142827,22 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { pos = pos + 1 } } else { - if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { + if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(**(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) + v4 = uint32(**(**uint8)(__ccgo_up(v5))) } else { v4 = Xgetwc(tls, f) } c = Int32FromUint32(v4) } - if c != *(*Twchar_t)(unsafe.Pointer(p)) { + if c != **(**Twchar_t)(__ccgo_up(p)) { if (*TFILE)(unsafe.Pointer(f)).Frend != 0 && Uint32FromInt32(c) < uint32(128) { v6 = f + 8 *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 v5 = *(*uintptr)(unsafe.Pointer(v6)) - _ = *(*uint8)(unsafe.Pointer(v5)) + _ = **(**uint8)(__ccgo_up(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -142855,12 +142855,12 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { goto _2 } p += 4 - if *(*Twchar_t)(unsafe.Pointer(p)) == int32('*') { + if **(**Twchar_t)(__ccgo_up(p)) == int32('*') { dest = uintptr(0) p += 4 } else { - if BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(p)))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(p + 1*4)) == int32('$') { - dest = _arg_n1(tls, ap, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(p))-int32('0'))) + if BoolInt32(Uint32FromInt32(**(**Twchar_t)(__ccgo_up(p)))-uint32('0') < uint32(10)) != 0 && **(**Twchar_t)(__ccgo_up(p + 1*4)) == int32('$') { + dest = _arg_n1(tls, ap, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(p))-int32('0'))) p = p + uintptr(2)*4 } else { dest = VaUintptr(&ap) @@ -142868,16 +142868,16 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } width = 0 for { - if !(BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(p)))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(Uint32FromInt32(**(**Twchar_t)(__ccgo_up(p)))-uint32('0') < uint32(10)) != 0) { break } - width = int32(10)*width + *(*Twchar_t)(unsafe.Pointer(p)) - int32('0') + width = int32(10)*width + **(**Twchar_t)(__ccgo_up(p)) - int32('0') goto _18 _18: ; p += 4 } - if *(*Twchar_t)(unsafe.Pointer(p)) == int32('m') { + if **(**Twchar_t)(__ccgo_up(p)) == int32('m') { wcs = uintptr(0) s = uintptr(0) alloc = BoolInt32(!!(dest != 0)) @@ -142888,16 +142888,16 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { size = SIZE_def v5 = p p += 4 - switch *(*Twchar_t)(unsafe.Pointer(v5)) { + switch **(**Twchar_t)(__ccgo_up(v5)) { case int32('h'): - if *(*Twchar_t)(unsafe.Pointer(p)) == int32('h') { + if **(**Twchar_t)(__ccgo_up(p)) == int32('h') { p += 4 size = -Int32FromInt32(2) } else { size = -int32(1) } case int32('l'): - if *(*Twchar_t)(unsafe.Pointer(p)) == int32('l') { + if **(**Twchar_t)(__ccgo_up(p)) == int32('l') { p += 4 size = Int32FromInt32(SIZE_ll) } else { @@ -142956,7 +142956,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { default: goto fmt_fail } - t = *(*Twchar_t)(unsafe.Pointer(p)) + t = **(**Twchar_t)(__ccgo_up(p)) /* Transform S,C -> ls,lc */ if t&int32(0x2f) == int32(3) { size = int32(SIZE_l) @@ -142965,11 +142965,11 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if t != int32('n') { if t != int32('[') && t|int32(32) != int32('c') { for { - if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { + if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(**(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) + v4 = uint32(**(**uint8)(__ccgo_up(v5))) } else { v4 = Xgetwc(tls, f) } @@ -142981,11 +142981,11 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { pos = pos + 1 } } else { - if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { + if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(**(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) + v4 = uint32(**(**uint8)(__ccgo_up(v5))) } else { v4 = Xgetwc(tls, f) } @@ -142998,7 +142998,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v6 = f + 8 *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 v5 = *(*uintptr)(unsafe.Pointer(v6)) - _ = *(*uint8)(unsafe.Pointer(v5)) + _ = **(**uint8)(__ccgo_up(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -143026,18 +143026,18 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } else { p += 4 v5 = p - if *(*Twchar_t)(unsafe.Pointer(v5)) == int32('^') { + if **(**Twchar_t)(__ccgo_up(v5)) == int32('^') { p += 4 invert = Int32FromInt32(1) } else { invert = 0 } set = p - if *(*Twchar_t)(unsafe.Pointer(p)) == int32(']') { + if **(**Twchar_t)(__ccgo_up(p)) == int32(']') { p += 4 } - for *(*Twchar_t)(unsafe.Pointer(p)) != int32(']') { - if !(*(*Twchar_t)(unsafe.Pointer(p)) != 0) { + for **(**Twchar_t)(__ccgo_up(p)) != int32(']') { + if !(**(**Twchar_t)(__ccgo_up(p)) != 0) { goto fmt_fail } p += 4 @@ -143081,11 +143081,11 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } } for width != 0 { - if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { + if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(**(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) + v4 = uint32(**(**uint8)(__ccgo_up(v5))) } else { v4 = Xgetwc(tls, f) } @@ -143100,7 +143100,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if wcs != 0 { v37 = i i = i + 1 - *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(v37)*4)) = c + **(**Twchar_t)(__ccgo_up(wcs + uintptr(v37)*4)) = c if alloc != 0 && i == k { k = k + (k + uint64(1)) tmp1 = Xrealloc(tls, wcs, k*uint64(4)) @@ -143140,7 +143140,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v6 = f + 8 *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 v5 = *(*uintptr)(unsafe.Pointer(v6)) - _ = *(*uint8)(unsafe.Pointer(v5)) + _ = **(**uint8)(__ccgo_up(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -143150,17 +143150,17 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } if alloc != 0 { if size == int32(SIZE_l) { - *(*uintptr)(unsafe.Pointer(dest)) = wcs + **(**uintptr)(__ccgo_up(dest)) = wcs } else { - *(*uintptr)(unsafe.Pointer(dest)) = s + **(**uintptr)(__ccgo_up(dest)) = s } } if t != int32('c') { if wcs != 0 { - *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) = 0 + **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) = 0 } if s != 0 { - *(*uint8)(unsafe.Pointer(s + uintptr(i))) = uint8(0) + **(**uint8)(__ccgo_up(s + uintptr(i))) = uint8(0) } } case int32('d'): @@ -143196,7 +143196,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { width = 0 } Xsnprintf(tls, bp+8, uint64(22), __ccgo_ts+1709, VaList(bp+40, int32(1)+BoolInt32(!(dest != 0)), __ccgo_ts+1727, width, uintptr(unsafe.Pointer(&_size_pfx))+uintptr(size+int32(2))*3, t)) - *(*Toff_t)(unsafe.Pointer(bp)) = 0 + **(**Toff_t)(__ccgo_up(bp)) = 0 if dest != 0 { v5 = dest } else { @@ -143205,11 +143205,11 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if Xfscanf(tls, f, bp+8, VaList(bp+40, v5, bp)) == -int32(1) { goto input_fail } else { - if !(*(*Toff_t)(unsafe.Pointer(bp)) != 0) { + if !(**(**Toff_t)(__ccgo_up(bp)) != 0) { goto match_fail } } - pos = pos + *(*Toff_t)(unsafe.Pointer(bp)) + pos = pos + **(**Toff_t)(__ccgo_up(bp)) default: goto fmt_fail } @@ -143335,8 +143335,8 @@ func _sn_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { k = v1 if k != 0 { Xmemcpy(tls, (*Tcookie3)(unsafe.Pointer(c)).Fs, (*TFILE)(unsafe.Pointer(f)).Fwbase, k) - *(*uintptr)(unsafe.Pointer(c)) += uintptr(k) - *(*Tsize_t)(unsafe.Pointer(c + 8)) -= k + **(**uintptr)(__ccgo_up(c)) += uintptr(k) + **(**Tsize_t)(__ccgo_up(c + 8)) -= k } if (*Tcookie3)(unsafe.Pointer(c)).Fn < l { v1 = (*Tcookie3)(unsafe.Pointer(c)).Fn @@ -143346,10 +143346,10 @@ func _sn_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { k = v1 if k != 0 { Xmemcpy(tls, (*Tcookie3)(unsafe.Pointer(c)).Fs, s, k) - *(*uintptr)(unsafe.Pointer(c)) += uintptr(k) - *(*Tsize_t)(unsafe.Pointer(c + 8)) -= k + **(**uintptr)(__ccgo_up(c)) += uintptr(k) + **(**Tsize_t)(__ccgo_up(c + 8)) -= k } - *(*uint8)(unsafe.Pointer((*Tcookie3)(unsafe.Pointer(c)).Fs)) = uint8(0) + **(**uint8)(__ccgo_up((*Tcookie3)(unsafe.Pointer(c)).Fs)) = uint8(0) v3 = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Fwbase = v3 (*TFILE)(unsafe.Pointer(f)).Fwpos = v3 @@ -143381,18 +143381,18 @@ func Xvsnprintf(tls *TLS, s uintptr, n Tsize_t, fmt uintptr, ap Tva_list) (r int } else { v2 = uint64(0) } - *(*Tcookie3)(unsafe.Pointer(bp + 8)) = Tcookie3{ + **(**Tcookie3)(__ccgo_up(bp + 8)) = Tcookie3{ Fs: v1, Fn: v2, } - *(*TFILE)(unsafe.Pointer(bp + 24)) = TFILE{ + **(**TFILE)(__ccgo_up(bp + 24)) = TFILE{ Fwrite: __ccgo_fp(_sn_write), Fbuf: bp, Flock: -int32(1), Flbf: -int32(1), Fcookie: bp + 8, } - *(*uint8)(unsafe.Pointer((*(*Tcookie3)(unsafe.Pointer(bp + 8))).Fs)) = uint8(0) + **(**uint8)(__ccgo_up((**(**Tcookie3)(__ccgo_up(bp + 8))).Fs)) = uint8(0) return Xvfprintf(tls, bp+24, fmt, ap) } @@ -143441,7 +143441,7 @@ func Xvsscanf(tls *TLS, s uintptr, fmt uintptr, ap Tva_list) (r int32) { bp := tls.Alloc(240) defer tls.Free(240) var _ /* f at bp+0 */ TFILE - *(*TFILE)(unsafe.Pointer(bp)) = TFILE{ + **(**TFILE)(__ccgo_up(bp)) = TFILE{ Fread: __ccgo_fp(_string_read), Fbuf: s, Flock: -int32(1), @@ -143491,14 +143491,14 @@ func _sw_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { (*Tcookie4)(unsafe.Pointer(c)).Fl = (*Tcookie4)(unsafe.Pointer(c)).Fl - 1 (*Tcookie4)(unsafe.Pointer(c)).Fws += 4 } - *(*Twchar_t)(unsafe.Pointer((*Tcookie4)(unsafe.Pointer(c)).Fws)) = 0 + **(**Twchar_t)(__ccgo_up((*Tcookie4)(unsafe.Pointer(c)).Fws)) = 0 if i < 0 { v4 = UintptrFromInt32(0) (*TFILE)(unsafe.Pointer(f)).Fwend = v4 v3 = v4 (*TFILE)(unsafe.Pointer(f)).Fwbase = v3 (*TFILE)(unsafe.Pointer(f)).Fwpos = v3 - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) return Uint64FromInt32(i) } (*TFILE)(unsafe.Pointer(f)).Fwend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr((*TFILE)(unsafe.Pointer(f)).Fbuf_size) @@ -143520,11 +143520,11 @@ func Xvswprintf(tls *TLS, s uintptr, n Tsize_t, fmt uintptr, ap Tva_list) (r1 in var _ /* c at bp+256 */ Tcookie4 var _ /* f at bp+272 */ TFILE _, _ = r, v1 - *(*Tcookie4)(unsafe.Pointer(bp + 256)) = Tcookie4{ + **(**Tcookie4)(__ccgo_up(bp + 256)) = Tcookie4{ Fws: s, Fl: n - uint64(1), } - *(*TFILE)(unsafe.Pointer(bp + 272)) = TFILE{ + **(**TFILE)(__ccgo_up(bp + 272)) = TFILE{ Fwrite: __ccgo_fp(_sw_write), Fbuf: bp, Fbuf_size: uint64(256), @@ -143552,8 +143552,8 @@ func _wstring_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { var v1, v2 uintptr var _ /* src at bp+0 */ uintptr _, _, _ = k, v1, v2 - *(*uintptr)(unsafe.Pointer(bp)) = (*TFILE)(unsafe.Pointer(f)).Fcookie - if !(*(*uintptr)(unsafe.Pointer(bp)) != 0) { + **(**uintptr)(__ccgo_up(bp)) = (*TFILE)(unsafe.Pointer(f)).Fcookie + if !(**(**uintptr)(__ccgo_up(bp)) != 0) { return uint64(0) } k = Xwcsrtombs(tls, (*TFILE)(unsafe.Pointer(f)).Fbuf, bp, (*TFILE)(unsafe.Pointer(f)).Fbuf_size, uintptr(0)) @@ -143565,14 +143565,14 @@ func _wstring_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { } (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(k) - (*TFILE)(unsafe.Pointer(f)).Fcookie = *(*uintptr)(unsafe.Pointer(bp)) + (*TFILE)(unsafe.Pointer(f)).Fcookie = **(**uintptr)(__ccgo_up(bp)) if !(len1 != 0) || !(k != 0) { return uint64(0) } v2 = f + 8 v1 = *(*uintptr)(unsafe.Pointer(v2)) *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(v2)) + 1 - *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v1)) + **(**uint8)(__ccgo_up(buf)) = **(**uint8)(__ccgo_up(v1)) return uint64(1) } @@ -143585,7 +143585,7 @@ func Xvswscanf(tls *TLS, s uintptr, fmt uintptr, ap Tva_list) (r int32) { defer tls.Free(496) var _ /* buf at bp+0 */ [256]uint8 var _ /* f at bp+256 */ TFILE - *(*TFILE)(unsafe.Pointer(bp + 256)) = TFILE{ + **(**TFILE)(__ccgo_up(bp + 256)) = TFILE{ Fread: __ccgo_fp(_wstring_read), Fbuf: bp, Fbuf_size: uint64(256), @@ -143697,7 +143697,7 @@ func Xatoi(tls *TLS, s uintptr) (r int32) { n = 0 neg = 0 for { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(s))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _3 _3: @@ -143706,7 +143706,7 @@ func Xatoi(tls *TLS, s uintptr) (r int32) { } s = s + 1 } - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(s))) { case int32('-'): neg = int32(1) fallthrough @@ -143714,10 +143714,10 @@ func Xatoi(tls *TLS, s uintptr) (r int32) { s = s + 1 } /* Compute n as a negative number to avoid overflow on INT_MIN */ - for BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { + for BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-uint32('0') < uint32(10)) != 0 { v4 = s s = s + 1 - n = int32(10)*n - (Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) - int32('0')) + n = int32(10)*n - (Int32FromUint8(**(**uint8)(__ccgo_up(v4))) - int32('0')) } if neg != 0 { v1 = n @@ -143739,7 +143739,7 @@ func Xatol(tls *TLS, s uintptr) (r int64) { n = 0 neg = 0 for { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(s))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _3 _3: @@ -143748,7 +143748,7 @@ func Xatol(tls *TLS, s uintptr) (r int64) { } s = s + 1 } - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(s))) { case int32('-'): neg = int32(1) fallthrough @@ -143756,10 +143756,10 @@ func Xatol(tls *TLS, s uintptr) (r int64) { s = s + 1 } /* Compute n as a negative number to avoid overflow on LONG_MIN */ - for BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { + for BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-uint32('0') < uint32(10)) != 0 { v4 = s s = s + 1 - n = int64(10)*n - int64(Int32FromUint8(*(*uint8)(unsafe.Pointer(v4)))-Int32FromUint8('0')) + n = int64(10)*n - int64(Int32FromUint8(**(**uint8)(__ccgo_up(v4)))-Int32FromUint8('0')) } if neg != 0 { v5 = n @@ -143781,7 +143781,7 @@ func Xatoll(tls *TLS, s uintptr) (r int64) { n = 0 neg = 0 for { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(s))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _3 _3: @@ -143790,7 +143790,7 @@ func Xatoll(tls *TLS, s uintptr) (r int64) { } s = s + 1 } - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(s))) { case int32('-'): neg = int32(1) fallthrough @@ -143798,10 +143798,10 @@ func Xatoll(tls *TLS, s uintptr) (r int64) { s = s + 1 } /* Compute n as a negative number to avoid overflow on LLONG_MIN */ - for BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { + for BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-uint32('0') < uint32(10)) != 0 { v4 = s s = s + 1 - n = int64(10)*n - int64(Int32FromUint8(*(*uint8)(unsafe.Pointer(v4)))-Int32FromUint8('0')) + n = int64(10)*n - int64(Int32FromUint8(**(**uint8)(__ccgo_up(v4)))-Int32FromUint8('0')) } if neg != 0 { v5 = n @@ -143863,24 +143863,24 @@ func Xecvt(tls *TLS, x float64, n int32, dp uintptr, sign uintptr) (r uintptr) { n = int32(15) } Xsprintf(tls, bp, __ccgo_ts+1730, VaList(bp+40, n-int32(1), x)) - v1 = BoolInt32(Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp)))[0]) == Int32FromUint8('-')) - *(*int32)(unsafe.Pointer(sign)) = v1 + v1 = BoolInt32(Int32FromUint8((**(**[32]uint8)(__ccgo_up(bp)))[0]) == Int32FromUint8('-')) + **(**int32)(__ccgo_up(sign)) = v1 i = v1 j = 0 for { - if !(Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp)))[i]) != int32('e')) { + if !(Int32FromUint8((**(**[32]uint8)(__ccgo_up(bp)))[i]) != int32('e')) { break } - _buf8[j] = (*(*[32]uint8)(unsafe.Pointer(bp)))[i] + _buf8[j] = (**(**[32]uint8)(__ccgo_up(bp)))[i] goto _2 _2: ; v1 = i i = i + 1 - j = j + BoolInt32(Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp)))[v1]) != int32('.')) + j = j + BoolInt32(Int32FromUint8((**(**[32]uint8)(__ccgo_up(bp)))[v1]) != int32('.')) } _buf8[j] = uint8(0) - *(*int32)(unsafe.Pointer(dp)) = Xatoi(tls, bp+uintptr(i)+uintptr(1)) + int32(1) + **(**int32)(__ccgo_up(dp)) = Xatoi(tls, bp+uintptr(i)+uintptr(1)) + int32(1) return uintptr(unsafe.Pointer(&_buf8)) } @@ -143900,15 +143900,15 @@ func Xfcvt(tls *TLS, x float64, n int32, dp uintptr, sign uintptr) (r uintptr) { n = int32(1400) } Xsprintf(tls, bp, __ccgo_ts+1735, VaList(bp+1512, n, x)) - i = BoolInt32(Int32FromUint8((*(*[1500]uint8)(unsafe.Pointer(bp)))[0]) == int32('-')) - if Int32FromUint8((*(*[1500]uint8)(unsafe.Pointer(bp)))[i]) == int32('0') { + i = BoolInt32(Int32FromUint8((**(**[1500]uint8)(__ccgo_up(bp)))[0]) == int32('-')) + if Int32FromUint8((**(**[1500]uint8)(__ccgo_up(bp)))[i]) == int32('0') { lz = Int32FromUint64(Xstrspn(tls, bp+uintptr(i)+uintptr(2), __ccgo_ts+1703)) } else { lz = -Int32FromUint64(Xstrcspn(tls, bp+uintptr(i), __ccgo_ts+607)) } if n <= lz { - *(*int32)(unsafe.Pointer(sign)) = i - *(*int32)(unsafe.Pointer(dp)) = int32(1) + **(**int32)(__ccgo_up(sign)) = i + **(**int32)(__ccgo_up(dp)) = int32(1) if Uint32FromInt32(n) > uint32(14) { n = int32(14) } @@ -144012,9 +144012,9 @@ func _pntz(tls *TLS, p uintptr) (r1 int32) { var r, v1 int32 var v2 bool _, _, _ = r, v1, v2 - r = _a_ctz_l(tls, *(*Tsize_t)(unsafe.Pointer(p))-uint64(1)) + r = _a_ctz_l(tls, **(**Tsize_t)(__ccgo_up(p))-uint64(1)) if v2 = r != 0; !v2 { - v1 = Int32FromUint64(Uint64FromInt32(8)*Uint64FromInt64(8) + Uint64FromInt32(_a_ctz_l(tls, *(*Tsize_t)(unsafe.Pointer(p + 1*8))))) + v1 = Int32FromUint64(Uint64FromInt32(8)*Uint64FromInt64(8) + Uint64FromInt32(_a_ctz_l(tls, **(**Tsize_t)(__ccgo_up(p + 1*8))))) r = v1 } if v2 || Uint64FromInt32(v1) != Uint64FromInt32(8)*Uint64FromInt64(8) { @@ -144034,7 +144034,7 @@ func _cycle(tls *TLS, width Tsize_t, ar uintptr, n int32) { if n < int32(2) { return } - *(*uintptr)(unsafe.Pointer(ar + uintptr(n)*8)) = bp + **(**uintptr)(__ccgo_up(ar + uintptr(n)*8)) = bp for width != 0 { if uint64(256) < width { v1 = uint64(256) @@ -144042,14 +144042,14 @@ func _cycle(tls *TLS, width Tsize_t, ar uintptr, n int32) { v1 = width } l = v1 - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(ar + uintptr(n)*8)), *(*uintptr)(unsafe.Pointer(ar)), l) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(ar + uintptr(n)*8)), **(**uintptr)(__ccgo_up(ar)), l) i = 0 for { if !(i < n) { break } - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(ar + uintptr(i)*8)), *(*uintptr)(unsafe.Pointer(ar + uintptr(i+int32(1))*8)), l) - *(*uintptr)(unsafe.Pointer(ar + uintptr(i)*8)) += uintptr(l) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(ar + uintptr(i)*8)), **(**uintptr)(__ccgo_up(ar + uintptr(i+int32(1))*8)), l) + **(**uintptr)(__ccgo_up(ar + uintptr(i)*8)) += uintptr(l) goto _2 _2: ; @@ -144065,23 +144065,23 @@ func _cycle(tls *TLS, width Tsize_t, ar uintptr, n int32) { func _shl(tls *TLS, p uintptr, n int32) { if Uint64FromInt32(n) >= Uint64FromInt32(8)*Uint64FromInt64(8) { n = Int32FromUint64(uint64(n) - Uint64FromInt32(8)*Uint64FromInt64(8)) - *(*Tsize_t)(unsafe.Pointer(p + 1*8)) = *(*Tsize_t)(unsafe.Pointer(p)) - *(*Tsize_t)(unsafe.Pointer(p)) = uint64(0) + **(**Tsize_t)(__ccgo_up(p + 1*8)) = **(**Tsize_t)(__ccgo_up(p)) + **(**Tsize_t)(__ccgo_up(p)) = uint64(0) } - *(*Tsize_t)(unsafe.Pointer(p + 1*8)) <<= Uint64FromInt32(n) - *(*Tsize_t)(unsafe.Pointer(p + 1*8)) |= *(*Tsize_t)(unsafe.Pointer(p)) >> (Uint64FromInt64(8)*Uint64FromInt32(8) - Uint64FromInt32(n)) - *(*Tsize_t)(unsafe.Pointer(p)) <<= Uint64FromInt32(n) + **(**Tsize_t)(__ccgo_up(p + 1*8)) <<= Uint64FromInt32(n) + **(**Tsize_t)(__ccgo_up(p + 1*8)) |= **(**Tsize_t)(__ccgo_up(p)) >> (Uint64FromInt64(8)*Uint64FromInt32(8) - Uint64FromInt32(n)) + **(**Tsize_t)(__ccgo_up(p)) <<= Uint64FromInt32(n) } func _shr(tls *TLS, p uintptr, n int32) { if Uint64FromInt32(n) >= Uint64FromInt32(8)*Uint64FromInt64(8) { n = Int32FromUint64(uint64(n) - Uint64FromInt32(8)*Uint64FromInt64(8)) - *(*Tsize_t)(unsafe.Pointer(p)) = *(*Tsize_t)(unsafe.Pointer(p + 1*8)) - *(*Tsize_t)(unsafe.Pointer(p + 1*8)) = uint64(0) + **(**Tsize_t)(__ccgo_up(p)) = **(**Tsize_t)(__ccgo_up(p + 1*8)) + **(**Tsize_t)(__ccgo_up(p + 1*8)) = uint64(0) } - *(*Tsize_t)(unsafe.Pointer(p)) >>= Uint64FromInt32(n) - *(*Tsize_t)(unsafe.Pointer(p)) |= *(*Tsize_t)(unsafe.Pointer(p + 1*8)) << (Uint64FromInt64(8)*Uint64FromInt32(8) - Uint64FromInt32(n)) - *(*Tsize_t)(unsafe.Pointer(p + 1*8)) >>= Uint64FromInt32(n) + **(**Tsize_t)(__ccgo_up(p)) >>= Uint64FromInt32(n) + **(**Tsize_t)(__ccgo_up(p)) |= **(**Tsize_t)(__ccgo_up(p + 1*8)) << (Uint64FromInt64(8)*Uint64FromInt32(8) - Uint64FromInt32(n)) + **(**Tsize_t)(__ccgo_up(p + 1*8)) >>= Uint64FromInt32(n) } func _sift(tls *TLS, head uintptr, width Tsize_t, __ccgo_fp_cmp Tcmpfun, arg uintptr, pshift int32, lp uintptr) { @@ -144092,23 +144092,23 @@ func _sift(tls *TLS, head uintptr, width Tsize_t, __ccgo_fp_cmp Tcmpfun, arg uin var _ /* ar at bp+0 */ [113]uintptr _, _, _, _ = i, lf, rt, v1 i = int32(1) - (*(*[113]uintptr)(unsafe.Pointer(bp)))[0] = head + (**(**[113]uintptr)(__ccgo_up(bp)))[0] = head for pshift > int32(1) { rt = head - uintptr(width) - lf = head - uintptr(width) - uintptr(*(*Tsize_t)(unsafe.Pointer(lp + uintptr(pshift-int32(2))*8))) - if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, (*(*[113]uintptr)(unsafe.Pointer(bp)))[0], lf, arg) >= 0 && (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, (*(*[113]uintptr)(unsafe.Pointer(bp)))[0], rt, arg) >= 0 { + lf = head - uintptr(width) - uintptr(**(**Tsize_t)(__ccgo_up(lp + uintptr(pshift-int32(2))*8))) + if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, (**(**[113]uintptr)(__ccgo_up(bp)))[0], lf, arg) >= 0 && (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, (**(**[113]uintptr)(__ccgo_up(bp)))[0], rt, arg) >= 0 { break } if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, lf, rt, arg) >= 0 { v1 = i i = i + 1 - (*(*[113]uintptr)(unsafe.Pointer(bp)))[v1] = lf + (**(**[113]uintptr)(__ccgo_up(bp)))[v1] = lf head = lf pshift = pshift - int32(1) } else { v1 = i i = i + 1 - (*(*[113]uintptr)(unsafe.Pointer(bp)))[v1] = rt + (**(**[113]uintptr)(__ccgo_up(bp)))[v1] = rt head = rt pshift = pshift - int32(2) } @@ -144125,24 +144125,24 @@ func _trinkle(tls *TLS, head uintptr, width Tsize_t, __ccgo_fp_cmp Tcmpfun, arg var _ /* p at bp+0 */ [2]Tsize_t _, _, _, _, _, _ = i, lf, rt, stepson, trail, v1 i = int32(1) - (*(*[2]Tsize_t)(unsafe.Pointer(bp)))[0] = *(*Tsize_t)(unsafe.Pointer(pp)) - (*(*[2]Tsize_t)(unsafe.Pointer(bp)))[int32(1)] = *(*Tsize_t)(unsafe.Pointer(pp + 1*8)) - (*(*[113]uintptr)(unsafe.Pointer(bp + 16)))[0] = head - for (*(*[2]Tsize_t)(unsafe.Pointer(bp)))[0] != uint64(1) || (*(*[2]Tsize_t)(unsafe.Pointer(bp)))[int32(1)] != uint64(0) { - stepson = head - uintptr(*(*Tsize_t)(unsafe.Pointer(lp + uintptr(pshift)*8))) - if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, stepson, (*(*[113]uintptr)(unsafe.Pointer(bp + 16)))[0], arg) <= 0 { + (**(**[2]Tsize_t)(__ccgo_up(bp)))[0] = **(**Tsize_t)(__ccgo_up(pp)) + (**(**[2]Tsize_t)(__ccgo_up(bp)))[int32(1)] = **(**Tsize_t)(__ccgo_up(pp + 1*8)) + (**(**[113]uintptr)(__ccgo_up(bp + 16)))[0] = head + for (**(**[2]Tsize_t)(__ccgo_up(bp)))[0] != uint64(1) || (**(**[2]Tsize_t)(__ccgo_up(bp)))[int32(1)] != uint64(0) { + stepson = head - uintptr(**(**Tsize_t)(__ccgo_up(lp + uintptr(pshift)*8))) + if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, stepson, (**(**[113]uintptr)(__ccgo_up(bp + 16)))[0], arg) <= 0 { break } if !(trusty != 0) && pshift > int32(1) { rt = head - uintptr(width) - lf = head - uintptr(width) - uintptr(*(*Tsize_t)(unsafe.Pointer(lp + uintptr(pshift-int32(2))*8))) + lf = head - uintptr(width) - uintptr(**(**Tsize_t)(__ccgo_up(lp + uintptr(pshift-int32(2))*8))) if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, rt, stepson, arg) >= 0 || (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, lf, stepson, arg) >= 0 { break } } v1 = i i = i + 1 - (*(*[113]uintptr)(unsafe.Pointer(bp + 16)))[v1] = stepson + (**(**[113]uintptr)(__ccgo_up(bp + 16)))[v1] = stepson head = stepson trail = _pntz(tls, bp) _shr(tls, bp, trail) @@ -144170,7 +144170,7 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm var _ /* p at bp+768 */ [2]Tsize_t _, _, _, _, _, _, _, _ = head, high, i, pshift, size, trail, v2, v3 size = width * nel - *(*[2]Tsize_t)(unsafe.Pointer(bp + 768)) = [2]Tsize_t{ + **(**[2]Tsize_t)(__ccgo_up(bp + 768)) = [2]Tsize_t{ 0: uint64(1), } pshift = int32(1) @@ -144181,12 +144181,12 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm high = head + uintptr(size) - uintptr(width) /* Precompute Leonardo numbers, scaled by element width */ v2 = width - (*(*[96]Tsize_t)(unsafe.Pointer(bp)))[int32(1)] = v2 - (*(*[96]Tsize_t)(unsafe.Pointer(bp)))[0] = v2 + (**(**[96]Tsize_t)(__ccgo_up(bp)))[int32(1)] = v2 + (**(**[96]Tsize_t)(__ccgo_up(bp)))[0] = v2 i = Uint64FromInt32(2) for { - v3 = (*(*[96]Tsize_t)(unsafe.Pointer(bp)))[i-uint64(2)] + (*(*[96]Tsize_t)(unsafe.Pointer(bp)))[i-uint64(1)] + width - (*(*[96]Tsize_t)(unsafe.Pointer(bp)))[i] = v3 + v3 = (**(**[96]Tsize_t)(__ccgo_up(bp)))[i-uint64(2)] + (**(**[96]Tsize_t)(__ccgo_up(bp)))[i-uint64(1)] + width + (**(**[96]Tsize_t)(__ccgo_up(bp)))[i] = v3 if !(v3 < size) { break } @@ -144196,12 +144196,12 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm i = i + 1 } for head < high { - if (*(*[2]Tsize_t)(unsafe.Pointer(bp + 768)))[0]&uint64(3) == uint64(3) { + if (**(**[2]Tsize_t)(__ccgo_up(bp + 768)))[0]&uint64(3) == uint64(3) { _sift(tls, head, width, __ccgo_fp_cmp, arg, pshift, bp) _shr(tls, bp+768, int32(2)) pshift = pshift + int32(2) } else { - if (*(*[96]Tsize_t)(unsafe.Pointer(bp)))[pshift-int32(1)] >= Uint64FromInt64(int64(high)-int64(head)) { + if (**(**[96]Tsize_t)(__ccgo_up(bp)))[pshift-int32(1)] >= Uint64FromInt64(int64(high)-int64(head)) { _trinkle(tls, head, width, __ccgo_fp_cmp, arg, bp+768, pshift, 0, bp) } else { _sift(tls, head, width, __ccgo_fp_cmp, arg, pshift, bp) @@ -144214,11 +144214,11 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm pshift = int32(1) } } - *(*Tsize_t)(unsafe.Pointer(bp + 768)) |= uint64(1) + **(**Tsize_t)(__ccgo_up(bp + 768)) |= uint64(1) head = head + uintptr(width) } _trinkle(tls, head, width, __ccgo_fp_cmp, arg, bp+768, pshift, 0, bp) - for pshift != int32(1) || (*(*[2]Tsize_t)(unsafe.Pointer(bp + 768)))[0] != uint64(1) || (*(*[2]Tsize_t)(unsafe.Pointer(bp + 768)))[int32(1)] != uint64(0) { + for pshift != int32(1) || (**(**[2]Tsize_t)(__ccgo_up(bp + 768)))[0] != uint64(1) || (**(**[2]Tsize_t)(__ccgo_up(bp + 768)))[int32(1)] != uint64(0) { if pshift <= int32(1) { trail = _pntz(tls, bp+768) _shr(tls, bp+768, trail) @@ -144226,11 +144226,11 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm } else { _shl(tls, bp+768, int32(2)) pshift = pshift - int32(2) - *(*Tsize_t)(unsafe.Pointer(bp + 768)) ^= uint64(7) + **(**Tsize_t)(__ccgo_up(bp + 768)) ^= uint64(7) _shr(tls, bp+768, int32(1)) - _trinkle(tls, head-uintptr((*(*[96]Tsize_t)(unsafe.Pointer(bp)))[pshift])-uintptr(width), width, __ccgo_fp_cmp, arg, bp+768, pshift+int32(1), int32(1), bp) + _trinkle(tls, head-uintptr((**(**[96]Tsize_t)(__ccgo_up(bp)))[pshift])-uintptr(width), width, __ccgo_fp_cmp, arg, bp+768, pshift+int32(1), int32(1), bp) _shl(tls, bp+768, int32(1)) - *(*Tsize_t)(unsafe.Pointer(bp + 768)) |= uint64(1) + **(**Tsize_t)(__ccgo_up(bp + 768)) |= uint64(1) _trinkle(tls, head-uintptr(width), width, __ccgo_fp_cmp, arg, bp+768, pshift, int32(1), bp) } head = head - uintptr(width) @@ -144280,7 +144280,7 @@ func _strtox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { } else { v1 = s } - *(*uintptr)(unsafe.Pointer(p)) = v1 + **(**uintptr)(__ccgo_up(p)) = v1 } return y } @@ -144325,7 +144325,7 @@ func _strtox1(tls *TLS, s uintptr, p uintptr, base int32, lim uint64) (r uint64) y = X__intscan(tls, bp, Uint32FromInt32(base), int32(1), lim) if p != 0 { cnt = Uint64FromInt64((*TFILE)(unsafe.Pointer(bp)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(bp)).Frpos) - int64((*TFILE)(unsafe.Pointer(bp)).Fbuf))) - *(*uintptr)(unsafe.Pointer(p)) = s + uintptr(cnt) + **(**uintptr)(__ccgo_up(p)) = s + uintptr(cnt) } return y } @@ -144436,20 +144436,20 @@ func _do_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { var v2 int32 _, _, _, _, _ = i, wcs, v2, v3, v4 wcs = (*TFILE)(unsafe.Pointer(f)).Fcookie - if !(*(*Twchar_t)(unsafe.Pointer(wcs)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(wcs)) != 0) { wcs = __ccgo_ts + 1761 } i = uint64(0) for { - if !(i < (*TFILE)(unsafe.Pointer(f)).Fbuf_size && *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) != 0) { + if !(i < (*TFILE)(unsafe.Pointer(f)).Fbuf_size && **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) != 0) { break } - if *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) < int32(128) { - v2 = *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) + if **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) < int32(128) { + v2 = **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) } else { v2 = int32('@') } - *(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(i))) = Uint8FromInt32(v2) + **(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(i))) = Uint8FromInt32(v2) goto _1 _1: ; @@ -144462,7 +144462,7 @@ func _do_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(buf)) = **(**uint8)(__ccgo_up(v3)) return uint64(1) } return uint64(0) @@ -144478,20 +144478,20 @@ func _wcstox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { var _ /* f at bp+64 */ TFILE _, _, _, _, _ = cnt, t, y, v1, v2 t = s - *(*TFILE)(unsafe.Pointer(bp + 64)) = TFILE{} - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fflags = uint32(0) + **(**TFILE)(__ccgo_up(bp + 64)) = TFILE{} + (**(**TFILE)(__ccgo_up(bp + 64))).Fflags = uint32(0) v2 = bp + UintptrFromInt32(4) - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fbuf = v2 + (**(**TFILE)(__ccgo_up(bp + 64))).Fbuf = v2 v1 = v2 - (*(*TFILE)(unsafe.Pointer(bp + 64))).Frend = v1 - (*(*TFILE)(unsafe.Pointer(bp + 64))).Frpos = v1 - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fbuf_size = Uint64FromInt64(64) - Uint64FromInt32(4) + (**(**TFILE)(__ccgo_up(bp + 64))).Frend = v1 + (**(**TFILE)(__ccgo_up(bp + 64))).Frpos = v1 + (**(**TFILE)(__ccgo_up(bp + 64))).Fbuf_size = Uint64FromInt64(64) - Uint64FromInt32(4) AtomicStorePInt32(bp+64+140, -int32(1)) - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fread = __ccgo_fp(_do_read) - for Xiswspace(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(t)))) != 0 { + (**(**TFILE)(__ccgo_up(bp + 64))).Fread = __ccgo_fp(_do_read) + for Xiswspace(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(t)))) != 0 { t += 4 } - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fcookie = t + (**(**TFILE)(__ccgo_up(bp + 64))).Fcookie = t X__shlim(tls, bp+64, int64(Int32FromInt32(0))) y = X__floatscan(tls, bp+64, prec, int32(1)) if p != 0 { @@ -144501,7 +144501,7 @@ func _wcstox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { } else { v1 = s } - *(*uintptr)(unsafe.Pointer(p)) = v1 + **(**uintptr)(__ccgo_up(p)) = v1 } return y } @@ -144540,20 +144540,20 @@ func _do_read1(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { var v2 int32 _, _, _, _, _ = i, wcs, v2, v3, v4 wcs = (*TFILE)(unsafe.Pointer(f)).Fcookie - if !(*(*Twchar_t)(unsafe.Pointer(wcs)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(wcs)) != 0) { wcs = __ccgo_ts + 1761 } i = uint64(0) for { - if !(i < (*TFILE)(unsafe.Pointer(f)).Fbuf_size && *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) != 0) { + if !(i < (*TFILE)(unsafe.Pointer(f)).Fbuf_size && **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) != 0) { break } - if *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) < int32(128) { - v2 = *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) + if **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) < int32(128) { + v2 = **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) } else { v2 = int32('@') } - *(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(i))) = Uint8FromInt32(v2) + **(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(i))) = Uint8FromInt32(v2) goto _1 _1: ; @@ -144566,7 +144566,7 @@ func _do_read1(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(buf)) = **(**uint8)(__ccgo_up(v3)) return uint64(1) } return uint64(0) @@ -144582,20 +144582,20 @@ func _wcstox1(tls *TLS, s uintptr, p uintptr, base int32, lim uint64) (r uint64) var _ /* f at bp+64 */ TFILE _, _, _, _, _ = cnt, t, y, v1, v2 t = s - *(*TFILE)(unsafe.Pointer(bp + 64)) = TFILE{} - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fflags = uint32(0) + **(**TFILE)(__ccgo_up(bp + 64)) = TFILE{} + (**(**TFILE)(__ccgo_up(bp + 64))).Fflags = uint32(0) v2 = bp + UintptrFromInt32(4) - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fbuf = v2 + (**(**TFILE)(__ccgo_up(bp + 64))).Fbuf = v2 v1 = v2 - (*(*TFILE)(unsafe.Pointer(bp + 64))).Frend = v1 - (*(*TFILE)(unsafe.Pointer(bp + 64))).Frpos = v1 - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fbuf_size = Uint64FromInt64(64) - Uint64FromInt32(4) + (**(**TFILE)(__ccgo_up(bp + 64))).Frend = v1 + (**(**TFILE)(__ccgo_up(bp + 64))).Frpos = v1 + (**(**TFILE)(__ccgo_up(bp + 64))).Fbuf_size = Uint64FromInt64(64) - Uint64FromInt32(4) AtomicStorePInt32(bp+64+140, -int32(1)) - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fread = __ccgo_fp(_do_read1) - for Xiswspace(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(t)))) != 0 { + (**(**TFILE)(__ccgo_up(bp + 64))).Fread = __ccgo_fp(_do_read1) + for Xiswspace(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(t)))) != 0 { t += 4 } - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fcookie = t + (**(**TFILE)(__ccgo_up(bp + 64))).Fcookie = t X__shlim(tls, bp+64, int64(Int32FromInt32(0))) y = X__intscan(tls, bp+64, Uint32FromInt32(base), int32(1), lim) if p != 0 { @@ -144605,7 +144605,7 @@ func _wcstox1(tls *TLS, s uintptr, p uintptr, base int32, lim uint64) (r uint64) } else { v1 = s } - *(*uintptr)(unsafe.Pointer(p)) = v1 + **(**uintptr)(__ccgo_up(p)) = v1 } return y } @@ -144724,8 +144724,8 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt if uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) == uint64(d)&(Uint64FromInt64(8)-Uint64FromInt32(1)) { for { if v3 = uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) != 0 && n != 0; v3 { - v2 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v2 + v2 = **(**uint8)(__ccgo_up(s)) + **(**uint8)(__ccgo_up(d)) = v2 } if !(v3 && Int32FromUint8(v2) != c) { break @@ -144744,10 +144744,10 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt wd = d ws = s for { - if !(n >= uint64(8) && !((*(*uint64)(unsafe.Pointer(ws))^k-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^(*(*uint64)(unsafe.Pointer(ws))^k) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { + if !(n >= uint64(8) && !((**(**uint64)(__ccgo_up(ws))^k-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^(**(**uint64)(__ccgo_up(ws))^k) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { break } - *(*uint64)(unsafe.Pointer(wd)) = *(*uint64)(unsafe.Pointer(ws)) + **(**uint64)(__ccgo_up(wd)) = **(**uint64)(__ccgo_up(ws)) goto _4 _4: ; @@ -144760,8 +144760,8 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt } for { if v3 = n != 0; v3 { - v2 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v2 + v2 = **(**uint8)(__ccgo_up(s)) + **(**uint8)(__ccgo_up(d)) = v2 } if !(v3 && Int32FromUint8(v2) != c) { break @@ -144804,7 +144804,7 @@ func Xmemchr(tls *TLS, src uintptr, c int32, n Tsize_t) (r uintptr) { s = src c = Int32FromUint8(Uint8FromInt32(c)) for { - if !(uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) != 0 && n != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != c) { + if !(uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) != 0 && n != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != c) { break } goto _1 @@ -144813,11 +144813,11 @@ func Xmemchr(tls *TLS, src uintptr, c int32, n Tsize_t) (r uintptr) { s = s + 1 n = n - 1 } - if n != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != c { + if n != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != c { k = Uint64FromInt32(-Int32FromInt32(1)) / Uint64FromInt32(UCHAR_MAX) * Uint64FromInt32(c) w = s for { - if !(n >= Uint64FromInt64(8) && !((*(*uint64)(unsafe.Pointer(w))^k-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^(*(*uint64)(unsafe.Pointer(w))^k) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { + if !(n >= Uint64FromInt64(8) && !((**(**uint64)(__ccgo_up(w))^k-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^(**(**uint64)(__ccgo_up(w))^k) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { break } goto _2 @@ -144829,7 +144829,7 @@ func Xmemchr(tls *TLS, src uintptr, c int32, n Tsize_t) (r uintptr) { s = w } for { - if !(n != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != c) { + if !(n != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != c) { break } goto _3 @@ -144857,7 +144857,7 @@ func Xmemcmp(tls *TLS, vl uintptr, vr uintptr, n Tsize_t) (r1 int32) { l = vl r = vr for { - if !(n != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))) { + if !(n != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(l))) == Int32FromUint8(**(**uint8)(__ccgo_up(r)))) { break } goto _1 @@ -144868,7 +144868,7 @@ func Xmemcmp(tls *TLS, vl uintptr, vr uintptr, n Tsize_t) (r1 int32) { r = r + 1 } if n != 0 { - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(l))) - Int32FromUint8(**(**uint8)(__ccgo_up(r))) } else { v2 = 0 } @@ -144896,7 +144896,7 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) goto _1 _1: ; @@ -144907,10 +144907,10 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { if !(n >= uint64(16)) { break } - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(0))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(4))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(4))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(8))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(8))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(12))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(12))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(0))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(0))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(4))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(4))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(8))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(8))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(12))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(12))) goto _4 _4: ; @@ -144919,13 +144919,13 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { n = n - uint64(16) } if n&uint64(8) != 0 { - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(0))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(4))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(4))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(0))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(0))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(4))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(4))) d = d + uintptr(8) s = s + uintptr(8) } if n&uint64(4) != 0 { - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(0))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(0))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(0))) d = d + uintptr(4) s = s + uintptr(4) } @@ -144934,50 +144934,50 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) } if n&uint64(1) != 0 { - *(*uint8)(unsafe.Pointer(d)) = *(*uint8)(unsafe.Pointer(s)) + **(**uint8)(__ccgo_up(d)) = **(**uint8)(__ccgo_up(s)) } return dest } if n >= uint64(32) { switch uint64(d) % Uint64FromInt32(4) { case uint64(1): - w = *(*uint32)(unsafe.Pointer(s)) + w = **(**uint32)(__ccgo_up(s)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) n = n - uint64(3) for { if !(n >= uint64(17)) { break } - x = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(1))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = w>>Int32FromInt32(24) | x<>Int32FromInt32(24) | w<>Int32FromInt32(24) | x<>Int32FromInt32(24) | w<>Int32FromInt32(24) | x<>Int32FromInt32(24) | w<>Int32FromInt32(24) | x<>Int32FromInt32(24) | w<= uint64(18)) { break } - x = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(2))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = w>>Int32FromInt32(16) | x<>Int32FromInt32(16) | w<>Int32FromInt32(16) | x<>Int32FromInt32(16) | w<>Int32FromInt32(16) | x<>Int32FromInt32(16) | w<>Int32FromInt32(16) | x<>Int32FromInt32(16) | w<= uint64(19)) { break } - x = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(3))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = w>>Int32FromInt32(8) | x<>Int32FromInt32(8) | w<>Int32FromInt32(8) | x<>Int32FromInt32(8) | w<>Int32FromInt32(8) | x<>Int32FromInt32(8) | w<>Int32FromInt32(8) | x<>Int32FromInt32(8) | w< Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(ip+k)))) > Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(jp+k)))) { jp = jp + k k = uint64(1) p = jp - ip @@ -145379,7 +145379,7 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin p = v2 k = v2 for jp+k < l { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(ip+k)))) == Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(jp+k)))) { if k == p { jp = jp + p k = uint64(1) @@ -145387,7 +145387,7 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin k = k + 1 } } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) < Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(ip+k)))) < Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(jp+k)))) { jp = jp + k k = uint64(1) p = jp - ip @@ -145426,8 +145426,8 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin return uintptr(0) } /* Check last byte first; advance by shift on mismatch */ - if (*(*[4]Tsize_t)(unsafe.Pointer(bp)))[uint64(*(*uint8)(unsafe.Pointer(h + uintptr(l-uint64(1)))))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(*(*uint8)(unsafe.Pointer(h + uintptr(l-uint64(1)))))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0 { - k = l - shift[*(*uint8)(unsafe.Pointer(h + uintptr(l-uint64(1))))] + if (**(**[4]Tsize_t)(__ccgo_up(bp)))[uint64(**(**uint8)(__ccgo_up(h + uintptr(l-uint64(1)))))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(**(**uint8)(__ccgo_up(h + uintptr(l-uint64(1)))))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0 { + k = l - shift[**(**uint8)(__ccgo_up(h + uintptr(l-uint64(1))))] if k != 0 { if k < mem { k = mem @@ -145449,7 +145449,7 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin } k = v8 for { - if !(k < l && Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(h + uintptr(k))))) { + if !(k < l && Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(k)))) == Int32FromUint8(**(**uint8)(__ccgo_up(h + uintptr(k))))) { break } goto _10 @@ -145465,7 +145465,7 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin /* Compare left half */ k = ms + uint64(1) for { - if !(k > mem && Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(k-uint64(1))))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(h + uintptr(k-uint64(1)))))) { + if !(k > mem && Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(k-uint64(1))))) == Int32FromUint8(**(**uint8)(__ccgo_up(h + uintptr(k-uint64(1)))))) { break } goto _12 @@ -145502,7 +145502,7 @@ func Xmemmem(tls *TLS, h0 uintptr, k Tsize_t, n0 uintptr, l Tsize_t) (r uintptr) return uintptr(0) } /* Use faster algorithms for short needles */ - h = Xmemchr(tls, h0, Int32FromUint8(*(*uint8)(unsafe.Pointer(n))), k) + h = Xmemchr(tls, h0, Int32FromUint8(**(**uint8)(__ccgo_up(n))), k) if !(h != 0) || l == uint64(1) { return h } @@ -145554,13 +145554,13 @@ func Xmemmove(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) } for { if !(n >= Uint64FromInt64(8)) { break } - *(*TWT)(unsafe.Pointer(d)) = *(*TWT)(unsafe.Pointer(s)) + **(**TWT)(__ccgo_up(d)) = **(**TWT)(__ccgo_up(s)) goto _4 _4: ; @@ -145577,7 +145577,7 @@ func Xmemmove(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) goto _5 _5: ; @@ -145591,16 +145591,16 @@ func Xmemmove(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { if !(v1 != 0) { return dest } - *(*uint8)(unsafe.Pointer(d + uintptr(n))) = *(*uint8)(unsafe.Pointer(s + uintptr(n))) + **(**uint8)(__ccgo_up(d + uintptr(n))) = **(**uint8)(__ccgo_up(s + uintptr(n))) } for n >= Uint64FromInt64(8) { n = n - Uint64FromInt64(8) - *(*TWT)(unsafe.Pointer(d + uintptr(n))) = *(*TWT)(unsafe.Pointer(s + uintptr(n))) + **(**TWT)(__ccgo_up(d + uintptr(n))) = **(**TWT)(__ccgo_up(s + uintptr(n))) } } for n != 0 { n = n - 1 - *(*uint8)(unsafe.Pointer(d + uintptr(n))) = *(*uint8)(unsafe.Pointer(s + uintptr(n))) + **(**uint8)(__ccgo_up(d + uintptr(n))) = **(**uint8)(__ccgo_up(s + uintptr(n))) } } return dest @@ -145630,7 +145630,7 @@ func X__memrchr(tls *TLS, m uintptr, c int32, n Tsize_t) (r uintptr) { if !(v1 != 0) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(n)))) == c { + if Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(n)))) == c { return s + uintptr(n) } } @@ -145662,20 +145662,20 @@ func Xmemset(tls *TLS, dest uintptr, c int32, n Tsize_t) (r uintptr) { if !(n != 0) { return dest } - *(*uint8)(unsafe.Pointer(s)) = Uint8FromInt32(c) - *(*uint8)(unsafe.Pointer(s + uintptr(n-uint64(1)))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s)) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + uintptr(n-uint64(1)))) = Uint8FromInt32(c) if n <= uint64(2) { return dest } - *(*uint8)(unsafe.Pointer(s + 1)) = Uint8FromInt32(c) - *(*uint8)(unsafe.Pointer(s + 2)) = Uint8FromInt32(c) - *(*uint8)(unsafe.Pointer(s + uintptr(n-uint64(2)))) = Uint8FromInt32(c) - *(*uint8)(unsafe.Pointer(s + uintptr(n-uint64(3)))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + 1)) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + 2)) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + uintptr(n-uint64(2)))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + uintptr(n-uint64(3)))) = Uint8FromInt32(c) if n <= uint64(6) { return dest } - *(*uint8)(unsafe.Pointer(s + 3)) = Uint8FromInt32(c) - *(*uint8)(unsafe.Pointer(s + uintptr(n-uint64(4)))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + 3)) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + uintptr(n-uint64(4)))) = Uint8FromInt32(c) if n <= uint64(8) { return dest } @@ -145693,26 +145693,26 @@ func Xmemset(tls *TLS, dest uintptr, c int32, n Tsize_t) (r uintptr) { * As in the initial byte-based head/tail fill, each * conditional below ensures that the subsequent offsets * are valid (e.g. !(n<=24) implies n>=28). */ - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(0))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(4))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(0))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(4))) = c32 if n <= uint64(8) { return dest } - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(4))) = c32 - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(8))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(12))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(8))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(4))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(8))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(12))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(8))) = c32 if n <= uint64(24) { return dest } - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(12))) = c32 - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(16))) = c32 - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(20))) = c32 - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(24))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(28))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(24))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(20))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(16))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(12))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(16))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(20))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(24))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(28))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(24))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(20))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(16))) = c32 /* Align to a multiple of 8 so we can fill 64 bits at a time, * and avoid writing the same bytes twice as much as is * practical without introducing additional branching. */ @@ -145727,10 +145727,10 @@ func Xmemset(tls *TLS, dest uintptr, c int32, n Tsize_t) (r uintptr) { if !(n >= uint64(32)) { break } - *(*uint64)(unsafe.Pointer(s + UintptrFromInt32(0))) = c64 - *(*uint64)(unsafe.Pointer(s + UintptrFromInt32(8))) = c64 - *(*uint64)(unsafe.Pointer(s + UintptrFromInt32(16))) = c64 - *(*uint64)(unsafe.Pointer(s + UintptrFromInt32(24))) = c64 + **(**uint64)(__ccgo_up(s + UintptrFromInt32(0))) = c64 + **(**uint64)(__ccgo_up(s + UintptrFromInt32(8))) = c64 + **(**uint64)(__ccgo_up(s + UintptrFromInt32(16))) = c64 + **(**uint64)(__ccgo_up(s + UintptrFromInt32(24))) = c64 goto _1 _1: ; @@ -145772,8 +145772,8 @@ func X__stpcpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { if !(uint64(s)%Uint64FromInt64(8) != 0) { break } - v2 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v2 + v2 = **(**uint8)(__ccgo_up(s)) + **(**uint8)(__ccgo_up(d)) = v2 if !(v2 != 0) { return d } @@ -145786,7 +145786,7 @@ func X__stpcpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { wd = d ws = s for { - if !!((*(*uint64)(unsafe.Pointer(ws))-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^*(*uint64)(unsafe.Pointer(ws)) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0) { + if !!((**(**uint64)(__ccgo_up(ws))-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^**(**uint64)(__ccgo_up(ws)) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0) { break } goto _3 @@ -145796,14 +145796,14 @@ func X__stpcpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { wd += 8 v5 = ws ws += 8 - *(*uint64)(unsafe.Pointer(v4)) = *(*uint64)(unsafe.Pointer(v5)) + **(**uint64)(__ccgo_up(v4)) = **(**uint64)(__ccgo_up(v5)) } d = wd s = ws } for { - v2 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v2 + v2 = **(**uint8)(__ccgo_up(s)) + **(**uint8)(__ccgo_up(d)) = v2 if !(v2 != 0) { break } @@ -145856,8 +145856,8 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { if uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) == uint64(d)&(Uint64FromInt64(8)-Uint64FromInt32(1)) { for { if v3 = uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) != 0 && n != 0; v3 { - v2 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v2 + v2 = **(**uint8)(__ccgo_up(s)) + **(**uint8)(__ccgo_up(d)) = v2 } if !(v3 && v2 != 0) { break @@ -145869,16 +145869,16 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { s = s + 1 d = d + 1 } - if !(n != 0) || !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(n != 0) || !(**(**uint8)(__ccgo_up(s)) != 0) { goto tail } wd = d ws = s for { - if !(n >= uint64(8) && !((*(*uint64)(unsafe.Pointer(ws))-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^*(*uint64)(unsafe.Pointer(ws)) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { + if !(n >= uint64(8) && !((**(**uint64)(__ccgo_up(ws))-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^**(**uint64)(__ccgo_up(ws)) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { break } - *(*uint64)(unsafe.Pointer(wd)) = *(*uint64)(unsafe.Pointer(ws)) + **(**uint64)(__ccgo_up(wd)) = **(**uint64)(__ccgo_up(ws)) goto _4 _4: ; @@ -145891,8 +145891,8 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { } for { if v3 = n != 0; v3 { - v2 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v2 + v2 = **(**uint8)(__ccgo_up(s)) + **(**uint8)(__ccgo_up(d)) = v2 } if !(v3 && v2 != 0) { break @@ -145938,7 +145938,7 @@ func Xstrcasecmp(tls *TLS, _l uintptr, _r uintptr) (r1 int32) { l = _l r = _r for { - if !(*(*uint8)(unsafe.Pointer(l)) != 0 && *(*uint8)(unsafe.Pointer(r)) != 0 && (Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) || Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(l)))) == Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))))) { + if !(**(**uint8)(__ccgo_up(l)) != 0 && **(**uint8)(__ccgo_up(r)) != 0 && (Int32FromUint8(**(**uint8)(__ccgo_up(l))) == Int32FromUint8(**(**uint8)(__ccgo_up(r))) || Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(l)))) == Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(r)))))) { break } goto _1 @@ -145947,7 +145947,7 @@ func Xstrcasecmp(tls *TLS, _l uintptr, _r uintptr) (r1 int32) { l = l + 1 r = r + 1 } - return Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(l)))) - Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))) + return Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(l)))) - Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(r)))) } func X__strcasecmp_l(tls *TLS, l uintptr, r uintptr, loc Tlocale_t) (r1 int32) { @@ -145975,7 +145975,7 @@ func Xstrcasestr(tls *TLS, h uintptr, n uintptr) (r uintptr) { _ = l l = _strlen(tls, n) for { - if !(*(*uint8)(unsafe.Pointer(h)) != 0) { + if !(**(**uint8)(__ccgo_up(h)) != 0) { break } if !(Xstrncasecmp(tls, h, n, l) != 0) { @@ -146006,7 +146006,7 @@ func Xstrchr(tls *TLS, s uintptr, c int32) (r1 uintptr) { var r, v1 uintptr _, _ = r, v1 r = X__strchrnul(tls, s, c) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) == Int32FromUint8(Uint8FromInt32(c)) { + if Int32FromUint8(**(**uint8)(__ccgo_up(r))) == Int32FromUint8(Uint8FromInt32(c)) { v1 = r } else { v1 = uintptr(0) @@ -146041,7 +146041,7 @@ func X__strchrnul(tls *TLS, s uintptr, c int32) (r uintptr) { if !(uint64(s)%Uint64FromInt64(8) != 0) { break } - if !(*(*uint8)(unsafe.Pointer(s)) != 0) || Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == c { + if !(**(**uint8)(__ccgo_up(s)) != 0) || Int32FromUint8(**(**uint8)(__ccgo_up(s))) == c { return s } goto _1 @@ -146052,7 +146052,7 @@ func X__strchrnul(tls *TLS, s uintptr, c int32) (r uintptr) { k = Uint64FromInt32(-Int32FromInt32(1)) / Uint64FromInt32(UCHAR_MAX) * Uint64FromInt32(c) w = s for { - if !(!((*(*uint64)(unsafe.Pointer(w))-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^*(*uint64)(unsafe.Pointer(w)) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0) && !((*(*uint64)(unsafe.Pointer(w))^k-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^(*(*uint64)(unsafe.Pointer(w))^k) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { + if !(!((**(**uint64)(__ccgo_up(w))-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^**(**uint64)(__ccgo_up(w)) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0) && !((**(**uint64)(__ccgo_up(w))^k-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^(**(**uint64)(__ccgo_up(w))^k) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { break } goto _2 @@ -146062,7 +146062,7 @@ func X__strchrnul(tls *TLS, s uintptr, c int32) (r uintptr) { } s = w for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != c) { + if !(**(**uint8)(__ccgo_up(s)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != c) { break } goto _3 @@ -146096,7 +146096,7 @@ func Xstrcmp(tls *TLS, l uintptr, r uintptr) (r1 int32) { defer func() { trc("-> %v", r1) }() } for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) && *(*uint8)(unsafe.Pointer(l)) != 0) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(l))) == Int32FromUint8(**(**uint8)(__ccgo_up(r))) && **(**uint8)(__ccgo_up(l)) != 0) { break } goto _1 @@ -146105,7 +146105,7 @@ func Xstrcmp(tls *TLS, l uintptr, r uintptr) (r1 int32) { l = l + 1 r = r + 1 } - return Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) + return Int32FromUint8(**(**uint8)(__ccgo_up(l))) - Int32FromUint8(**(**uint8)(__ccgo_up(r))) } func Xstrcpy(tls *TLS, dest uintptr, src uintptr) (r uintptr) { @@ -146129,14 +146129,14 @@ func Xstrcspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { var _ /* byteset at bp+0 */ [4]Tsize_t _, _, _ = a, v2, v3 a = s - if !(*(*uint8)(unsafe.Pointer(c)) != 0) || !(*(*uint8)(unsafe.Pointer(c + 1)) != 0) { - return Uint64FromInt64(int64(X__strchrnul(tls, s, Int32FromUint8(*(*uint8)(unsafe.Pointer(c))))) - int64(a)) + if !(**(**uint8)(__ccgo_up(c)) != 0) || !(**(**uint8)(__ccgo_up(c + 1)) != 0) { + return Uint64FromInt64(int64(X__strchrnul(tls, s, Int32FromUint8(**(**uint8)(__ccgo_up(c))))) - int64(a)) } Xmemset(tls, bp, 0, uint64(32)) for { - if v3 = *(*uint8)(unsafe.Pointer(c)) != 0; v3 { - v2 = bp + uintptr(uint64(*(*uint8)(unsafe.Pointer(c)))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 - *(*Tsize_t)(unsafe.Pointer(v2)) |= Uint64FromInt32(1) << (uint64(*(*uint8)(unsafe.Pointer(c))) % (Uint64FromInt32(8) * Uint64FromInt64(8))) + if v3 = **(**uint8)(__ccgo_up(c)) != 0; v3 { + v2 = bp + uintptr(uint64(**(**uint8)(__ccgo_up(c)))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 + *(*Tsize_t)(unsafe.Pointer(v2)) |= Uint64FromInt32(1) << (uint64(**(**uint8)(__ccgo_up(c))) % (Uint64FromInt32(8) * Uint64FromInt64(8))) } if !(v3 && *(*Tsize_t)(unsafe.Pointer(v2)) != 0) { break @@ -146147,7 +146147,7 @@ func Xstrcspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { c = c + 1 } for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0 && !((*(*[4]Tsize_t)(unsafe.Pointer(bp)))[uint64(*(*uint8)(unsafe.Pointer(s)))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(*(*uint8)(unsafe.Pointer(s)))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0)) { + if !(**(**uint8)(__ccgo_up(s)) != 0 && !((**(**[4]Tsize_t)(__ccgo_up(bp)))[uint64(**(**uint8)(__ccgo_up(s)))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(**(**uint8)(__ccgo_up(s)))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0)) { break } goto _4 @@ -146187,7 +146187,7 @@ func Xstrerror_r(tls *TLS, err int32, buf uintptr, buflen Tsize_t) (r int32) { if l >= buflen { if buflen != 0 { Xmemcpy(tls, buf, msg, buflen-uint64(1)) - *(*uint8)(unsafe.Pointer(buf + uintptr(buflen-uint64(1)))) = uint8(0) + **(**uint8)(__ccgo_up(buf + uintptr(buflen-uint64(1)))) = uint8(0) } return int32(ERANGE) } @@ -146247,8 +146247,8 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { if uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) == uint64(d)&(Uint64FromInt64(8)-Uint64FromInt32(1)) { for { if v4 = uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) != 0 && n != 0; v4 { - v3 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v3 + v3 = **(**uint8)(__ccgo_up(s)) + **(**uint8)(__ccgo_up(d)) = v3 } if !(v4 && v3 != 0) { break @@ -146260,14 +146260,14 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { s = s + 1 d = d + 1 } - if n != 0 && *(*uint8)(unsafe.Pointer(s)) != 0 { + if n != 0 && **(**uint8)(__ccgo_up(s)) != 0 { wd = d ws = s for { - if !(n >= uint64(8) && !((*(*uint64)(unsafe.Pointer(ws))-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^*(*uint64)(unsafe.Pointer(ws)) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { + if !(n >= uint64(8) && !((**(**uint64)(__ccgo_up(ws))-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^**(**uint64)(__ccgo_up(ws)) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { break } - *(*Tsize_t)(unsafe.Pointer(wd)) = *(*uint64)(unsafe.Pointer(ws)) + **(**Tsize_t)(__ccgo_up(wd)) = **(**uint64)(__ccgo_up(ws)) goto _5 _5: ; @@ -146281,8 +146281,8 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { } for { if v4 = n != 0; v4 { - v3 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v3 + v3 = **(**uint8)(__ccgo_up(s)) + **(**uint8)(__ccgo_up(d)) = v3 } if !(v4 && v3 != 0) { break @@ -146294,7 +146294,7 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { s = s + 1 d = d + 1 } - *(*uint8)(unsafe.Pointer(d)) = uint8(0) + **(**uint8)(__ccgo_up(d)) = uint8(0) goto finish finish: ; @@ -146320,7 +146320,7 @@ func Xstrncasecmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { return 0 } for { - if !(*(*uint8)(unsafe.Pointer(l)) != 0 && *(*uint8)(unsafe.Pointer(r)) != 0 && n != 0 && (Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) || Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(l)))) == Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))))) { + if !(**(**uint8)(__ccgo_up(l)) != 0 && **(**uint8)(__ccgo_up(r)) != 0 && n != 0 && (Int32FromUint8(**(**uint8)(__ccgo_up(l))) == Int32FromUint8(**(**uint8)(__ccgo_up(r))) || Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(l)))) == Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(r)))))) { break } goto _2 @@ -146330,7 +146330,7 @@ func Xstrncasecmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { r = r + 1 n = n - 1 } - return Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(l)))) - Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))) + return Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(l)))) - Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(r)))) } func X__strncasecmp_l(tls *TLS, l uintptr, r uintptr, n Tsize_t, loc Tlocale_t) (r1 int32) { @@ -146358,17 +146358,17 @@ func Xstrncat(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { _, _, _ = a, v1, v2 a = d d = d + uintptr(_strlen(tls, d)) - for n != 0 && *(*uint8)(unsafe.Pointer(s)) != 0 { + for n != 0 && **(**uint8)(__ccgo_up(s)) != 0 { n = n - 1 v1 = d d = d + 1 v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v1)) = *(*uint8)(unsafe.Pointer(v2)) + **(**uint8)(__ccgo_up(v1)) = **(**uint8)(__ccgo_up(v2)) } v1 = d d = d + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) return a } @@ -146388,7 +146388,7 @@ func Xstrncmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { return 0 } for { - if !(*(*uint8)(unsafe.Pointer(l)) != 0 && *(*uint8)(unsafe.Pointer(r)) != 0 && n != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))) { + if !(**(**uint8)(__ccgo_up(l)) != 0 && **(**uint8)(__ccgo_up(r)) != 0 && n != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(l))) == Int32FromUint8(**(**uint8)(__ccgo_up(r)))) { break } goto _2 @@ -146398,7 +146398,7 @@ func Xstrncmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { r = r + 1 n = n - 1 } - return Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) + return Int32FromUint8(**(**uint8)(__ccgo_up(l))) - Int32FromUint8(**(**uint8)(__ccgo_up(r))) } func Xstrncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { @@ -146424,7 +146424,7 @@ func Xstrndup(tls *TLS, s uintptr, n Tsize_t) (r uintptr) { return UintptrFromInt32(0) } Xmemcpy(tls, d, s, l) - *(*uint8)(unsafe.Pointer(d + uintptr(l))) = uint8(0) + **(**uint8)(__ccgo_up(d + uintptr(l))) = uint8(0) return d } @@ -146453,7 +146453,7 @@ func Xstrpbrk(tls *TLS, s uintptr, b uintptr) (r uintptr) { var v1 uintptr _ = v1 s = s + uintptr(Xstrcspn(tls, s, b)) - if *(*uint8)(unsafe.Pointer(s)) != 0 { + if **(**uint8)(__ccgo_up(s)) != 0 { v1 = s } else { v1 = uintptr(0) @@ -146476,19 +146476,19 @@ func Xstrsep(tls *TLS, str uintptr, sep uintptr) (r uintptr) { } var end, s, v1 uintptr _, _, _ = end, s, v1 - s = *(*uintptr)(unsafe.Pointer(str)) + s = **(**uintptr)(__ccgo_up(str)) if !(s != 0) { return UintptrFromInt32(0) } end = s + uintptr(Xstrcspn(tls, s, sep)) - if *(*uint8)(unsafe.Pointer(end)) != 0 { + if **(**uint8)(__ccgo_up(end)) != 0 { v1 = end end = end + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) } else { end = uintptr(0) } - *(*uintptr)(unsafe.Pointer(str)) = end + **(**uintptr)(__ccgo_up(str)) = end return s } @@ -146514,7 +146514,7 @@ func Xstrsignal(tls *TLS, signum int32) (r uintptr) { break } for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { break } goto _3 @@ -146542,13 +146542,13 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { var _ /* byteset at bp+0 */ [4]Tsize_t _, _, _ = a, v3, v4 a = s - *(*[4]Tsize_t)(unsafe.Pointer(bp)) = [4]Tsize_t{} - if !(*(*uint8)(unsafe.Pointer(c)) != 0) { + **(**[4]Tsize_t)(__ccgo_up(bp)) = [4]Tsize_t{} + if !(**(**uint8)(__ccgo_up(c)) != 0) { return uint64(0) } - if !(*(*uint8)(unsafe.Pointer(c + 1)) != 0) { + if !(**(**uint8)(__ccgo_up(c + 1)) != 0) { for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(c)))) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(s))) == Int32FromUint8(**(**uint8)(__ccgo_up(c)))) { break } goto _1 @@ -146559,9 +146559,9 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { return Uint64FromInt64(int64(s) - int64(a)) } for { - if v4 = *(*uint8)(unsafe.Pointer(c)) != 0; v4 { - v3 = bp + uintptr(uint64(*(*uint8)(unsafe.Pointer(c)))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 - *(*Tsize_t)(unsafe.Pointer(v3)) |= Uint64FromInt32(1) << (uint64(*(*uint8)(unsafe.Pointer(c))) % (Uint64FromInt32(8) * Uint64FromInt64(8))) + if v4 = **(**uint8)(__ccgo_up(c)) != 0; v4 { + v3 = bp + uintptr(uint64(**(**uint8)(__ccgo_up(c)))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 + *(*Tsize_t)(unsafe.Pointer(v3)) |= Uint64FromInt32(1) << (uint64(**(**uint8)(__ccgo_up(c))) % (Uint64FromInt32(8) * Uint64FromInt64(8))) } if !(v4 && *(*Tsize_t)(unsafe.Pointer(v3)) != 0) { break @@ -146572,7 +146572,7 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { c = c + 1 } for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0 && (*(*[4]Tsize_t)(unsafe.Pointer(bp)))[uint64(*(*uint8)(unsafe.Pointer(s)))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(*(*uint8)(unsafe.Pointer(s)))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0 && (**(**[4]Tsize_t)(__ccgo_up(bp)))[uint64(**(**uint8)(__ccgo_up(s)))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(**(**uint8)(__ccgo_up(s)))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0) { break } goto _5 @@ -146587,11 +146587,11 @@ func _twobyte_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { var hw, nw Tuint16_t var v2 uintptr _, _, _ = hw, nw, v2 - nw = Uint16FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(n)))< Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(ip+k)))) > Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(jp+k)))) { jp = jp + k k = uint64(1) p = jp - ip @@ -146725,7 +146725,7 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { p = v2 k = v2 for jp+k < l { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(ip+k)))) == Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(jp+k)))) { if k == p { jp = jp + p k = uint64(1) @@ -146733,7 +146733,7 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { k = k + 1 } } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) < Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(ip+k)))) < Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(jp+k)))) { jp = jp + k k = uint64(1) p = jp - ip @@ -146784,8 +146784,8 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { } } /* Check last byte first; advance by shift on mismatch */ - if (*(*[4]Tsize_t)(unsafe.Pointer(bp)))[uint64(*(*uint8)(unsafe.Pointer(h + uintptr(l-uint64(1)))))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(*(*uint8)(unsafe.Pointer(h + uintptr(l-uint64(1)))))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0 { - k = l - shift[*(*uint8)(unsafe.Pointer(h + uintptr(l-uint64(1))))] + if (**(**[4]Tsize_t)(__ccgo_up(bp)))[uint64(**(**uint8)(__ccgo_up(h + uintptr(l-uint64(1)))))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(**(**uint8)(__ccgo_up(h + uintptr(l-uint64(1)))))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0 { + k = l - shift[**(**uint8)(__ccgo_up(h + uintptr(l-uint64(1))))] if k != 0 { if k < mem { k = mem @@ -146807,7 +146807,7 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { } k = v8 for { - if !(*(*uint8)(unsafe.Pointer(n + uintptr(k))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(h + uintptr(k))))) { + if !(**(**uint8)(__ccgo_up(n + uintptr(k))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(k)))) == Int32FromUint8(**(**uint8)(__ccgo_up(h + uintptr(k))))) { break } goto _10 @@ -146815,7 +146815,7 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { ; k = k + 1 } - if *(*uint8)(unsafe.Pointer(n + uintptr(k))) != 0 { + if **(**uint8)(__ccgo_up(n + uintptr(k))) != 0 { h = h + uintptr(k-ms) mem = uint64(0) goto _9 @@ -146823,7 +146823,7 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { /* Compare left half */ k = ms + uint64(1) for { - if !(k > mem && Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(k-uint64(1))))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(h + uintptr(k-uint64(1)))))) { + if !(k > mem && Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(k-uint64(1))))) == Int32FromUint8(**(**uint8)(__ccgo_up(h + uintptr(k-uint64(1)))))) { break } goto _12 @@ -146848,30 +146848,30 @@ func Xstrstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { defer func() { trc("-> %v", r) }() } /* Return immediately on empty needle */ - if !(*(*uint8)(unsafe.Pointer(n)) != 0) { + if !(**(**uint8)(__ccgo_up(n)) != 0) { return h } /* Use faster algorithms for short needles */ - h = Xstrchr(tls, h, Int32FromUint8(*(*uint8)(unsafe.Pointer(n)))) - if !(h != 0) || !(*(*uint8)(unsafe.Pointer(n + 1)) != 0) { + h = Xstrchr(tls, h, Int32FromUint8(**(**uint8)(__ccgo_up(n)))) + if !(h != 0) || !(**(**uint8)(__ccgo_up(n + 1)) != 0) { return h } - if !(*(*uint8)(unsafe.Pointer(h + 1)) != 0) { + if !(**(**uint8)(__ccgo_up(h + 1)) != 0) { return uintptr(0) } - if !(*(*uint8)(unsafe.Pointer(n + 2)) != 0) { + if !(**(**uint8)(__ccgo_up(n + 2)) != 0) { return _twobyte_strstr(tls, h, n) } - if !(*(*uint8)(unsafe.Pointer(h + 2)) != 0) { + if !(**(**uint8)(__ccgo_up(h + 2)) != 0) { return uintptr(0) } - if !(*(*uint8)(unsafe.Pointer(n + 3)) != 0) { + if !(**(**uint8)(__ccgo_up(n + 3)) != 0) { return _threebyte_strstr(tls, h, n) } - if !(*(*uint8)(unsafe.Pointer(h + 3)) != 0) { + if !(**(**uint8)(__ccgo_up(h + 3)) != 0) { return uintptr(0) } - if !(*(*uint8)(unsafe.Pointer(n + 4)) != 0) { + if !(**(**uint8)(__ccgo_up(n + 4)) != 0) { return _fourbyte_strstr(tls, h, n) } return _twoway_strstr(tls, h, n) @@ -146893,16 +146893,16 @@ func Xstrtok(tls *TLS, s uintptr, sep uintptr) (r uintptr) { return UintptrFromInt32(0) } s = s + uintptr(Xstrspn(tls, s, sep)) - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { v1 = UintptrFromInt32(0) _p2 = v1 return v1 } _p2 = s + uintptr(Xstrcspn(tls, s, sep)) - if *(*uint8)(unsafe.Pointer(_p2)) != 0 { + if **(**uint8)(__ccgo_up(_p2)) != 0 { v1 = _p2 _p2 = _p2 + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) } else { _p2 = uintptr(0) } @@ -146920,26 +146920,26 @@ func Xstrtok_r(tls *TLS, s uintptr, sep uintptr, p uintptr) (r uintptr) { var v2 bool _, _, _ = v1, v2, v3 if v2 = !(s != 0); v2 { - v1 = *(*uintptr)(unsafe.Pointer(p)) + v1 = **(**uintptr)(__ccgo_up(p)) s = v1 } if v2 && !(v1 != 0) { return UintptrFromInt32(0) } s = s + uintptr(Xstrspn(tls, s, sep)) - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { v1 = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(p)) = v1 + **(**uintptr)(__ccgo_up(p)) = v1 return v1 } - *(*uintptr)(unsafe.Pointer(p)) = s + uintptr(Xstrcspn(tls, s, sep)) - if *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)))) != 0 { + **(**uintptr)(__ccgo_up(p)) = s + uintptr(Xstrcspn(tls, s, sep)) + if **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)))) != 0 { v3 = p v1 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) } else { - *(*uintptr)(unsafe.Pointer(p)) = uintptr(0) + **(**uintptr)(__ccgo_up(p)) = uintptr(0) } return s } @@ -146962,10 +146962,10 @@ func Xstrverscmp(tls *TLS, l0 uintptr, r0 uintptr) (r1 int32) { i = v2 dp = v2 for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(l + uintptr(i)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(r + uintptr(i))))) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(l + uintptr(i)))) == Int32FromUint8(**(**uint8)(__ccgo_up(r + uintptr(i))))) { break } - c = Int32FromUint8(*(*uint8)(unsafe.Pointer(l + uintptr(i)))) + c = Int32FromUint8(**(**uint8)(__ccgo_up(l + uintptr(i)))) if !(c != 0) { return 0 } @@ -146982,15 +146982,15 @@ func Xstrverscmp(tls *TLS, l0 uintptr, r0 uintptr) (r1 int32) { ; i = i + 1 } - if Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(l + uintptr(dp))))-int32('1')) < uint32(9) && Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(r + uintptr(dp))))-int32('1')) < uint32(9) { + if Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(l + uintptr(dp))))-int32('1')) < uint32(9) && Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(r + uintptr(dp))))-int32('1')) < uint32(9) { /* If we're looking at non-degenerate digit sequences starting * with nonzero digits, longest digit string is greater. */ j = i for { - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(l + uintptr(j))))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(l + uintptr(j))))-uint32('0') < uint32(10)) != 0) { break } - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(r + uintptr(j))))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(r + uintptr(j))))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return int32(1) } goto _3 @@ -146998,17 +146998,17 @@ func Xstrverscmp(tls *TLS, l0 uintptr, r0 uintptr) (r1 int32) { ; j = j + 1 } - if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(r + uintptr(j))))-uint32('0') < uint32(10)) != 0 { + if BoolInt32(uint32(**(**uint8)(__ccgo_up(r + uintptr(j))))-uint32('0') < uint32(10)) != 0 { return -int32(1) } } else { - if z != 0 && dp < i && (BoolInt32(uint32(*(*uint8)(unsafe.Pointer(l + uintptr(i))))-uint32('0') < uint32(10)) != 0 || BoolInt32(uint32(*(*uint8)(unsafe.Pointer(r + uintptr(i))))-uint32('0') < uint32(10)) != 0) { + if z != 0 && dp < i && (BoolInt32(uint32(**(**uint8)(__ccgo_up(l + uintptr(i))))-uint32('0') < uint32(10)) != 0 || BoolInt32(uint32(**(**uint8)(__ccgo_up(r + uintptr(i))))-uint32('0') < uint32(10)) != 0) { /* Otherwise, if common prefix of digit sequence is * all zeros, digits order less than non-digits. */ - return Int32FromUint8(Uint8FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(l + uintptr(i))))-Int32FromUint8('0'))) - Int32FromUint8(Uint8FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(r + uintptr(i))))-Int32FromUint8('0'))) + return Int32FromUint8(Uint8FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(l + uintptr(i))))-Int32FromUint8('0'))) - Int32FromUint8(Uint8FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(r + uintptr(i))))-Int32FromUint8('0'))) } } - return Int32FromUint8(*(*uint8)(unsafe.Pointer(l + uintptr(i)))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r + uintptr(i)))) + return Int32FromUint8(**(**uint8)(__ccgo_up(l + uintptr(i)))) - Int32FromUint8(**(**uint8)(__ccgo_up(r + uintptr(i)))) } func Xswab(tls *TLS, _src uintptr, _dest uintptr, n Tssize_t) { @@ -147023,8 +147023,8 @@ func Xswab(tls *TLS, _src uintptr, _dest uintptr, n Tssize_t) { if !(n > int64(1)) { break } - *(*uint8)(unsafe.Pointer(dest)) = *(*uint8)(unsafe.Pointer(src + 1)) - *(*uint8)(unsafe.Pointer(dest + 1)) = *(*uint8)(unsafe.Pointer(src)) + **(**uint8)(__ccgo_up(dest)) = **(**uint8)(__ccgo_up(src + 1)) + **(**uint8)(__ccgo_up(dest + 1)) = **(**uint8)(__ccgo_up(src)) dest = dest + uintptr(2) src = src + uintptr(2) goto _1 @@ -147086,7 +147086,7 @@ func Xwcschr(tls *TLS, s uintptr, c Twchar_t) (r uintptr) { return s + uintptr(Xwcslen(tls, s))*4 } for { - if !(*(*Twchar_t)(unsafe.Pointer(s)) != 0 && *(*Twchar_t)(unsafe.Pointer(s)) != c) { + if !(**(**Twchar_t)(__ccgo_up(s)) != 0 && **(**Twchar_t)(__ccgo_up(s)) != c) { break } goto _1 @@ -147094,7 +147094,7 @@ func Xwcschr(tls *TLS, s uintptr, c Twchar_t) (r uintptr) { ; s += 4 } - if *(*Twchar_t)(unsafe.Pointer(s)) != 0 { + if **(**Twchar_t)(__ccgo_up(s)) != 0 { v2 = s } else { v2 = uintptr(0) @@ -147110,7 +147110,7 @@ func Xwcscmp(tls *TLS, l uintptr, r uintptr) (r1 int32) { var v2 int32 _ = v2 for { - if !(*(*Twchar_t)(unsafe.Pointer(l)) == *(*Twchar_t)(unsafe.Pointer(r)) && *(*Twchar_t)(unsafe.Pointer(l)) != 0 && *(*Twchar_t)(unsafe.Pointer(r)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(l)) == **(**Twchar_t)(__ccgo_up(r)) && **(**Twchar_t)(__ccgo_up(l)) != 0 && **(**Twchar_t)(__ccgo_up(r)) != 0) { break } goto _1 @@ -147119,10 +147119,10 @@ func Xwcscmp(tls *TLS, l uintptr, r uintptr) (r1 int32) { l += 4 r += 4 } - if *(*Twchar_t)(unsafe.Pointer(l)) < *(*Twchar_t)(unsafe.Pointer(r)) { + if **(**Twchar_t)(__ccgo_up(l)) < **(**Twchar_t)(__ccgo_up(r)) { v2 = -int32(1) } else { - v2 = BoolInt32(*(*Twchar_t)(unsafe.Pointer(l)) > *(*Twchar_t)(unsafe.Pointer(r))) + v2 = BoolInt32(**(**Twchar_t)(__ccgo_up(l)) > **(**Twchar_t)(__ccgo_up(r))) } return v2 } @@ -147139,10 +147139,10 @@ func Xwcscpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { for { v2 = s s += 4 - v1 = *(*Twchar_t)(unsafe.Pointer(v2)) + v1 = **(**Twchar_t)(__ccgo_up(v2)) v3 = d d += 4 - *(*Twchar_t)(unsafe.Pointer(v3)) = v1 + **(**Twchar_t)(__ccgo_up(v3)) = v1 if !(v1 != 0) { break } @@ -147158,13 +147158,13 @@ func Xwcscspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { var a, v2, v3 uintptr var v1 uint64 _, _, _, _ = a, v1, v2, v3 - if !(*(*Twchar_t)(unsafe.Pointer(c)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(c)) != 0) { return Xwcslen(tls, s) } - if !(*(*Twchar_t)(unsafe.Pointer(c + 1*4)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(c + 1*4)) != 0) { v3 = s a = v3 - v2 = Xwcschr(tls, v3, *(*Twchar_t)(unsafe.Pointer(c))) + v2 = Xwcschr(tls, v3, **(**Twchar_t)(__ccgo_up(c))) s = v2 if v2 != 0 { v1 = Uint64FromInt64((int64(s) - int64(a)) / 4) @@ -147175,7 +147175,7 @@ func Xwcscspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { } a = s for { - if !(*(*Twchar_t)(unsafe.Pointer(s)) != 0 && !(Xwcschr(tls, c, *(*Twchar_t)(unsafe.Pointer(s))) != 0)) { + if !(**(**Twchar_t)(__ccgo_up(s)) != 0 && !(Xwcschr(tls, c, **(**Twchar_t)(__ccgo_up(s))) != 0)) { break } goto _4 @@ -147211,7 +147211,7 @@ func Xwcslen(tls *TLS, s uintptr) (r Tsize_t) { _ = a a = s for { - if !(*(*Twchar_t)(unsafe.Pointer(s)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(s)) != 0) { break } goto _1 @@ -147235,7 +147235,7 @@ func Xwcsncasecmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { return 0 } for { - if !(*(*Twchar_t)(unsafe.Pointer(l)) != 0 && *(*Twchar_t)(unsafe.Pointer(r)) != 0 && n != 0 && (*(*Twchar_t)(unsafe.Pointer(l)) == *(*Twchar_t)(unsafe.Pointer(r)) || Xtowlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(l)))) == Xtowlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(r)))))) { + if !(**(**Twchar_t)(__ccgo_up(l)) != 0 && **(**Twchar_t)(__ccgo_up(r)) != 0 && n != 0 && (**(**Twchar_t)(__ccgo_up(l)) == **(**Twchar_t)(__ccgo_up(r)) || Xtowlower(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(l)))) == Xtowlower(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(r)))))) { break } goto _2 @@ -147245,7 +147245,7 @@ func Xwcsncasecmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { r += 4 n = n - 1 } - return Int32FromUint32(Xtowlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(l)))) - Xtowlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(r))))) + return Int32FromUint32(Xtowlower(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(l)))) - Xtowlower(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(r))))) } func Xwcsncasecmp_l(tls *TLS, l uintptr, r uintptr, n Tsize_t, locale Tlocale_t) (r1 int32) { @@ -147265,17 +147265,17 @@ func Xwcsncat(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { _, _, _ = a, v1, v2 a = d d = d + uintptr(Xwcslen(tls, d))*4 - for n != 0 && *(*Twchar_t)(unsafe.Pointer(s)) != 0 { + for n != 0 && **(**Twchar_t)(__ccgo_up(s)) != 0 { n = n - 1 v1 = d d += 4 v2 = s s += 4 - *(*Twchar_t)(unsafe.Pointer(v1)) = *(*Twchar_t)(unsafe.Pointer(v2)) + **(**Twchar_t)(__ccgo_up(v1)) = **(**Twchar_t)(__ccgo_up(v2)) } v1 = d d += 4 - *(*Twchar_t)(unsafe.Pointer(v1)) = 0 + **(**Twchar_t)(__ccgo_up(v1)) = 0 return a } @@ -147287,7 +147287,7 @@ func Xwcsncmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { var v2, v3 int32 _, _ = v2, v3 for { - if !(n != 0 && *(*Twchar_t)(unsafe.Pointer(l)) == *(*Twchar_t)(unsafe.Pointer(r)) && *(*Twchar_t)(unsafe.Pointer(l)) != 0 && *(*Twchar_t)(unsafe.Pointer(r)) != 0) { + if !(n != 0 && **(**Twchar_t)(__ccgo_up(l)) == **(**Twchar_t)(__ccgo_up(r)) && **(**Twchar_t)(__ccgo_up(l)) != 0 && **(**Twchar_t)(__ccgo_up(r)) != 0) { break } goto _1 @@ -147298,10 +147298,10 @@ func Xwcsncmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { r += 4 } if n != 0 { - if *(*Twchar_t)(unsafe.Pointer(l)) < *(*Twchar_t)(unsafe.Pointer(r)) { + if **(**Twchar_t)(__ccgo_up(l)) < **(**Twchar_t)(__ccgo_up(r)) { v3 = -int32(1) } else { - v3 = BoolInt32(*(*Twchar_t)(unsafe.Pointer(l)) > *(*Twchar_t)(unsafe.Pointer(r))) + v3 = BoolInt32(**(**Twchar_t)(__ccgo_up(l)) > **(**Twchar_t)(__ccgo_up(r))) } v2 = v3 } else { @@ -147318,13 +147318,13 @@ func Xwcsncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { var a, v1, v2 uintptr _, _, _ = a, v1, v2 a = d - for n != 0 && *(*Twchar_t)(unsafe.Pointer(s)) != 0 { + for n != 0 && **(**Twchar_t)(__ccgo_up(s)) != 0 { n = n - 1 v1 = d d += 4 v2 = s s += 4 - *(*Twchar_t)(unsafe.Pointer(v1)) = *(*Twchar_t)(unsafe.Pointer(v2)) + **(**Twchar_t)(__ccgo_up(v1)) = **(**Twchar_t)(__ccgo_up(v2)) } Xwmemset(tls, d, 0, n) return a @@ -147352,7 +147352,7 @@ func Xwcspbrk(tls *TLS, s uintptr, b uintptr) (r uintptr) { var v1 uintptr _ = v1 s = s + uintptr(Xwcscspn(tls, s, b))*4 - if *(*Twchar_t)(unsafe.Pointer(s)) != 0 { + if **(**Twchar_t)(__ccgo_up(s)) != 0 { v1 = s } else { v1 = UintptrFromInt32(0) @@ -147369,7 +147369,7 @@ func Xwcsrchr(tls *TLS, s uintptr, c Twchar_t) (r uintptr) { _, _ = p, v2 p = s + uintptr(Xwcslen(tls, s))*4 for { - if !(p >= s && *(*Twchar_t)(unsafe.Pointer(p)) != c) { + if !(p >= s && **(**Twchar_t)(__ccgo_up(p)) != c) { break } goto _1 @@ -147394,7 +147394,7 @@ func Xwcsspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { _ = a a = s for { - if !(*(*Twchar_t)(unsafe.Pointer(s)) != 0 && Xwcschr(tls, c, *(*Twchar_t)(unsafe.Pointer(s))) != 0) { + if !(**(**Twchar_t)(__ccgo_up(s)) != 0 && Xwcschr(tls, c, **(**Twchar_t)(__ccgo_up(s))) != 0) { break } goto _1 @@ -147413,7 +147413,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { /* Computing length of needle */ l = uint64(0) for { - if !(*(*Twchar_t)(unsafe.Pointer(n + uintptr(l)*4)) != 0 && *(*Twchar_t)(unsafe.Pointer(h + uintptr(l)*4)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(n + uintptr(l)*4)) != 0 && **(**Twchar_t)(__ccgo_up(h + uintptr(l)*4)) != 0) { break } goto _1 @@ -147421,7 +147421,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { ; l = l + 1 } - if *(*Twchar_t)(unsafe.Pointer(n + uintptr(l)*4)) != 0 { + if **(**Twchar_t)(__ccgo_up(n + uintptr(l)*4)) != 0 { return uintptr(0) } /* hit the end of h */ /* Compute maximal suffix */ @@ -147431,7 +147431,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { p = v2 k = v2 for jp+k < l { - if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) == *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { + if **(**Twchar_t)(__ccgo_up(n + uintptr(ip+k)*4)) == **(**Twchar_t)(__ccgo_up(n + uintptr(jp+k)*4)) { if k == p { jp = jp + p k = uint64(1) @@ -147439,7 +147439,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { k = k + 1 } } else { - if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) > *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { + if **(**Twchar_t)(__ccgo_up(n + uintptr(ip+k)*4)) > **(**Twchar_t)(__ccgo_up(n + uintptr(jp+k)*4)) { jp = jp + k k = uint64(1) p = jp - ip @@ -147462,7 +147462,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { p = v2 k = v2 for jp+k < l { - if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) == *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { + if **(**Twchar_t)(__ccgo_up(n + uintptr(ip+k)*4)) == **(**Twchar_t)(__ccgo_up(n + uintptr(jp+k)*4)) { if k == p { jp = jp + p k = uint64(1) @@ -147470,7 +147470,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { k = k + 1 } } else { - if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) < *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { + if **(**Twchar_t)(__ccgo_up(n + uintptr(ip+k)*4)) < **(**Twchar_t)(__ccgo_up(n + uintptr(jp+k)*4)) { jp = jp + k k = uint64(1) p = jp - ip @@ -147528,7 +147528,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { } k = v8 for { - if !(*(*Twchar_t)(unsafe.Pointer(n + uintptr(k)*4)) != 0 && *(*Twchar_t)(unsafe.Pointer(n + uintptr(k)*4)) == *(*Twchar_t)(unsafe.Pointer(h + uintptr(k)*4))) { + if !(**(**Twchar_t)(__ccgo_up(n + uintptr(k)*4)) != 0 && **(**Twchar_t)(__ccgo_up(n + uintptr(k)*4)) == **(**Twchar_t)(__ccgo_up(h + uintptr(k)*4))) { break } goto _10 @@ -147536,7 +147536,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { ; k = k + 1 } - if *(*Twchar_t)(unsafe.Pointer(n + uintptr(k)*4)) != 0 { + if **(**Twchar_t)(__ccgo_up(n + uintptr(k)*4)) != 0 { h = h + uintptr(k-ms)*4 mem = uint64(0) goto _9 @@ -147544,7 +147544,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { /* Compare left half */ k = ms + uint64(1) for { - if !(k > mem && *(*Twchar_t)(unsafe.Pointer(n + uintptr(k-uint64(1))*4)) == *(*Twchar_t)(unsafe.Pointer(h + uintptr(k-uint64(1))*4))) { + if !(k > mem && **(**Twchar_t)(__ccgo_up(n + uintptr(k-uint64(1))*4)) == **(**Twchar_t)(__ccgo_up(h + uintptr(k-uint64(1))*4))) { break } goto _12 @@ -147569,18 +147569,18 @@ func Xwcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { defer func() { trc("-> %v", r) }() } /* Return immediately on empty needle or haystack */ - if !(*(*Twchar_t)(unsafe.Pointer(n)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(n)) != 0) { return h } - if !(*(*Twchar_t)(unsafe.Pointer(h)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(h)) != 0) { return uintptr(0) } /* Use faster algorithms for short needles */ - h = Xwcschr(tls, h, *(*Twchar_t)(unsafe.Pointer(n))) - if !(h != 0) || !(*(*Twchar_t)(unsafe.Pointer(n + 1*4)) != 0) { + h = Xwcschr(tls, h, **(**Twchar_t)(__ccgo_up(n))) + if !(h != 0) || !(**(**Twchar_t)(__ccgo_up(n + 1*4)) != 0) { return h } - if !(*(*Twchar_t)(unsafe.Pointer(h + 1*4)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(h + 1*4)) != 0) { return uintptr(0) } return _twoway_wcsstr(tls, h, n) @@ -147595,26 +147595,26 @@ func Xwcstok(tls *TLS, s uintptr, sep uintptr, p uintptr) (r uintptr) { var v2 bool _, _, _ = v1, v2, v3 if v2 = !(s != 0); v2 { - v1 = *(*uintptr)(unsafe.Pointer(p)) + v1 = **(**uintptr)(__ccgo_up(p)) s = v1 } if v2 && !(v1 != 0) { return UintptrFromInt32(0) } s = s + uintptr(Xwcsspn(tls, s, sep))*4 - if !(*(*Twchar_t)(unsafe.Pointer(s)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(s)) != 0) { v1 = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(p)) = v1 + **(**uintptr)(__ccgo_up(p)) = v1 return v1 } - *(*uintptr)(unsafe.Pointer(p)) = s + uintptr(Xwcscspn(tls, s, sep))*4 - if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)))) != 0 { + **(**uintptr)(__ccgo_up(p)) = s + uintptr(Xwcscspn(tls, s, sep))*4 + if **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(p)))) != 0 { v3 = p v1 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) += 4 - *(*Twchar_t)(unsafe.Pointer(v1)) = 0 + **(**Twchar_t)(__ccgo_up(v1)) = 0 } else { - *(*uintptr)(unsafe.Pointer(p)) = uintptr(0) + **(**uintptr)(__ccgo_up(p)) = uintptr(0) } return s } @@ -147635,7 +147635,7 @@ func Xwmemchr(tls *TLS, s uintptr, c Twchar_t, n Tsize_t) (r uintptr) { var v2 uintptr _ = v2 for { - if !(n != 0 && *(*Twchar_t)(unsafe.Pointer(s)) != c) { + if !(n != 0 && **(**Twchar_t)(__ccgo_up(s)) != c) { break } goto _1 @@ -147660,7 +147660,7 @@ func Xwmemcmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { var v2, v3 int32 _, _ = v2, v3 for { - if !(n != 0 && *(*Twchar_t)(unsafe.Pointer(l)) == *(*Twchar_t)(unsafe.Pointer(r))) { + if !(n != 0 && **(**Twchar_t)(__ccgo_up(l)) == **(**Twchar_t)(__ccgo_up(r))) { break } goto _1 @@ -147671,10 +147671,10 @@ func Xwmemcmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { r += 4 } if n != 0 { - if *(*Twchar_t)(unsafe.Pointer(l)) < *(*Twchar_t)(unsafe.Pointer(r)) { + if **(**Twchar_t)(__ccgo_up(l)) < **(**Twchar_t)(__ccgo_up(r)) { v3 = -int32(1) } else { - v3 = BoolInt32(*(*Twchar_t)(unsafe.Pointer(l)) > *(*Twchar_t)(unsafe.Pointer(r))) + v3 = BoolInt32(**(**Twchar_t)(__ccgo_up(l)) > **(**Twchar_t)(__ccgo_up(r))) } v2 = v3 } else { @@ -147702,7 +147702,7 @@ func Xwmemcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { d += 4 v3 = s s += 4 - *(*Twchar_t)(unsafe.Pointer(v2)) = *(*Twchar_t)(unsafe.Pointer(v3)) + **(**Twchar_t)(__ccgo_up(v2)) = **(**Twchar_t)(__ccgo_up(v3)) } return a } @@ -147726,7 +147726,7 @@ func Xwmemmove(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { if !(v1 != 0) { break } - *(*Twchar_t)(unsafe.Pointer(d + uintptr(n)*4)) = *(*Twchar_t)(unsafe.Pointer(s + uintptr(n)*4)) + **(**Twchar_t)(__ccgo_up(d + uintptr(n)*4)) = **(**Twchar_t)(__ccgo_up(s + uintptr(n)*4)) } } else { for { @@ -147739,7 +147739,7 @@ func Xwmemmove(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { d += 4 v4 = s s += 4 - *(*Twchar_t)(unsafe.Pointer(v3)) = *(*Twchar_t)(unsafe.Pointer(v4)) + **(**Twchar_t)(__ccgo_up(v3)) = **(**Twchar_t)(__ccgo_up(v4)) } } return d0 @@ -147762,7 +147762,7 @@ func Xwmemset(tls *TLS, d uintptr, c Twchar_t, n Tsize_t) (r uintptr) { } v2 = d d += 4 - *(*Twchar_t)(unsafe.Pointer(v2)) = c + **(**Twchar_t)(__ccgo_up(v2)) = c } return ret } @@ -147778,7 +147778,7 @@ func Xmkdtemp(tls *TLS, template uintptr) (r uintptr) { l = _strlen(tls, template) retries = int32(100) if l < uint64(6) || Xmemcmp(tls, template+uintptr(l)-uintptr(6), __ccgo_ts+1769, uint64(6)) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } for { @@ -147791,7 +147791,7 @@ func Xmkdtemp(tls *TLS, template uintptr) (r uintptr) { ; retries = retries - 1 v1 = retries - if !(v1 != 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EEXIST)) { + if !(v1 != 0 && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EEXIST)) { break } } @@ -147819,7 +147819,7 @@ func X__mkostemps(tls *TLS, template uintptr, len1 int32, flags int32) (r int32) _, _, _, _ = fd, l, retries, v1 l = _strlen(tls, template) if l < uint64(6) || Uint64FromInt32(len1) > l-uint64(6) || Xmemcmp(tls, template+uintptr(l)-uintptr(len1)-uintptr(6), __ccgo_ts+1769, uint64(6)) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } flags = flags - flags&(Int32FromInt32(03)|Int32FromInt32(O_PATH)) @@ -147836,7 +147836,7 @@ func X__mkostemps(tls *TLS, template uintptr, len1 int32, flags int32) (r int32) ; retries = retries - 1 v1 = retries - if !(v1 != 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EEXIST)) { + if !(v1 != 0 && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EEXIST)) { break } } @@ -147882,15 +147882,15 @@ func Xmktemp(tls *TLS, template uintptr) (r uintptr) { l = _strlen(tls, template) retries = int32(100) if l < uint64(6) || Xmemcmp(tls, template+uintptr(l)-uintptr(6), __ccgo_ts+1769, uint64(6)) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) - *(*uint8)(unsafe.Pointer(template)) = uint8(0) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) + **(**uint8)(__ccgo_up(template)) = uint8(0) return template } for { ___randname(tls, template+uintptr(l)-uintptr(6)) if Xstat(tls, template, bp) != 0 { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(ENOENT) { - *(*uint8)(unsafe.Pointer(template)) = uint8(0) + if **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(ENOENT) { + **(**uint8)(__ccgo_up(template)) = uint8(0) } return template } @@ -147903,8 +147903,8 @@ func Xmktemp(tls *TLS, template uintptr) (r uintptr) { break } } - *(*uint8)(unsafe.Pointer(template)) = uint8(0) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EEXIST) + **(**uint8)(__ccgo_up(template)) = uint8(0) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EEXIST) return template } @@ -147928,13 +147928,13 @@ func Xcfmakeraw(tls *TLS, t uintptr) { if __ccgo_strace { trc("tls=%v t=%v, (%v:)", tls, t, origin(2)) } - *(*Ttcflag_t)(unsafe.Pointer(t)) &= Uint32FromInt32(^(Int32FromInt32(IGNBRK) | Int32FromInt32(BRKINT) | Int32FromInt32(PARMRK) | Int32FromInt32(ISTRIP) | Int32FromInt32(INLCR) | Int32FromInt32(IGNCR) | Int32FromInt32(ICRNL) | Int32FromInt32(IXON))) - *(*Ttcflag_t)(unsafe.Pointer(t + 4)) &= Uint32FromInt32(^Int32FromInt32(OPOST)) - *(*Ttcflag_t)(unsafe.Pointer(t + 12)) &= Uint32FromInt32(^(Int32FromInt32(ECHO) | Int32FromInt32(ECHONL) | Int32FromInt32(ICANON) | Int32FromInt32(ISIG) | Int32FromInt32(IEXTEN))) - *(*Ttcflag_t)(unsafe.Pointer(t + 8)) &= Uint32FromInt32(^(Int32FromInt32(CSIZE) | Int32FromInt32(PARENB))) - *(*Ttcflag_t)(unsafe.Pointer(t + 8)) |= uint32(CS8) - *(*Tcc_t)(unsafe.Pointer(t + 17 + 6)) = uint8(1) - *(*Tcc_t)(unsafe.Pointer(t + 17 + 5)) = uint8(0) + **(**Ttcflag_t)(__ccgo_up(t)) &= Uint32FromInt32(^(Int32FromInt32(IGNBRK) | Int32FromInt32(BRKINT) | Int32FromInt32(PARMRK) | Int32FromInt32(ISTRIP) | Int32FromInt32(INLCR) | Int32FromInt32(IGNCR) | Int32FromInt32(ICRNL) | Int32FromInt32(IXON))) + **(**Ttcflag_t)(__ccgo_up(t + 4)) &= Uint32FromInt32(^Int32FromInt32(OPOST)) + **(**Ttcflag_t)(__ccgo_up(t + 12)) &= Uint32FromInt32(^(Int32FromInt32(ECHO) | Int32FromInt32(ECHONL) | Int32FromInt32(ICANON) | Int32FromInt32(ISIG) | Int32FromInt32(IEXTEN))) + **(**Ttcflag_t)(__ccgo_up(t + 8)) &= Uint32FromInt32(^(Int32FromInt32(CSIZE) | Int32FromInt32(PARENB))) + **(**Ttcflag_t)(__ccgo_up(t + 8)) |= uint32(CS8) + **(**Tcc_t)(__ccgo_up(t + 17 + 6)) = uint8(1) + **(**Tcc_t)(__ccgo_up(t + 17 + 5)) = uint8(0) } func Xcfsetospeed(tls *TLS, tio uintptr, speed Tspeed_t) (r int32) { @@ -147943,11 +147943,11 @@ func Xcfsetospeed(tls *TLS, tio uintptr, speed Tspeed_t) (r int32) { defer func() { trc("-> %v", r) }() } if speed&Uint32FromInt32(^Int32FromInt32(CBAUD)) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } - *(*Ttcflag_t)(unsafe.Pointer(tio + 8)) &= Uint32FromInt32(^Int32FromInt32(CBAUD)) - *(*Ttcflag_t)(unsafe.Pointer(tio + 8)) |= speed + **(**Ttcflag_t)(__ccgo_up(tio + 8)) &= Uint32FromInt32(^Int32FromInt32(CBAUD)) + **(**Ttcflag_t)(__ccgo_up(tio + 8)) |= speed return 0 } @@ -148026,7 +148026,7 @@ func Xtcgetsid(tls *TLS, fd int32) (r Tpid_t) { if Xioctl(tls, fd, int32(TIOCGSID), VaList(bp+16, bp)) < 0 { return -int32(1) } - return *(*int32)(unsafe.Pointer(bp)) + return **(**int32)(__ccgo_up(bp)) } func Xtcgetwinsize(tls *TLS, fd int32, wsz uintptr) (r int32) { @@ -148056,7 +148056,7 @@ func Xtcsetattr(tls *TLS, fd int32, act int32, tio uintptr) (r int32) { bp := tls.Alloc(16) defer tls.Free(16) if act < 0 || act > int32(2) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } return Xioctl(tls, fd, int32(TCSETS)+act, VaList(bp+8, tio)) @@ -148087,8 +148087,8 @@ func X__map_file(tls *TLS, pathname uintptr, size uintptr) (r uintptr) { return uintptr(0) } if !(X__fstat(tls, fd, bp) != 0) { - map1 = X__mmap(tls, uintptr(0), Uint64FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_size), int32(PROT_READ), int32(MAP_SHARED), fd, 0) - *(*Tsize_t)(unsafe.Pointer(size)) = Uint64FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_size) + map1 = X__mmap(tls, uintptr(0), Uint64FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_size), int32(PROT_READ), int32(MAP_SHARED), fd, 0) + **(**Tsize_t)(__ccgo_up(size)) = Uint64FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_size) } X__syscall1(tls, int64(SYS_close), int64(fd)) if map1 == uintptr(-Int32FromInt32(1)) { @@ -148260,7 +148260,7 @@ func X__tm_to_secs(tls *TLS, tm uintptr) (r int64) { year = year + int64(adj) } t = X__year_to_secs(tls, year, bp) - t = t + int64(X__month_to_secs(tls, month, *(*int32)(unsafe.Pointer(bp)))) + t = t + int64(X__month_to_secs(tls, month, **(**int32)(__ccgo_up(bp)))) t = t + int64(86400)*int64((*Ttm)(unsafe.Pointer(tm)).Ftm_mday-Int32FromInt32(1)) t = t + int64(3600)*int64((*Ttm)(unsafe.Pointer(tm)).Ftm_hour) t = t + int64(60)*int64((*Ttm)(unsafe.Pointer(tm)).Ftm_min) @@ -148294,14 +148294,14 @@ func _getint2(tls *TLS, p uintptr) (r int32) { _ = x x = uint32(0) for { - if !(Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)))))-int32('0')) < uint32(10)) { + if !(Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)))))-int32('0')) < uint32(10)) { break } - x = Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)))))-int32('0')) + uint32(10)*x + x = Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)))))-int32('0')) + uint32(10)*x goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 } return Int32FromUint32(x) } @@ -148310,20 +148310,20 @@ func _getoff(tls *TLS, p uintptr) (r int32) { var neg, off, v1 int32 _, _, _ = neg, off, v1 neg = 0 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('-') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) == int32('-') { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 neg = int32(1) } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('+') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) == int32('+') { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 } } off = int32(3600) * _getint2(tls, p) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32(':') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) == int32(':') { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 off = off + int32(60)*_getint2(tls, p) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32(':') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) == int32(':') { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 off = off + _getint2(tls, p) } } @@ -148338,61 +148338,61 @@ func _getoff(tls *TLS, p uintptr) (r int32) { func _getrule(tls *TLS, p uintptr, rule uintptr) { var r, v1 int32 _, _ = r, v1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) - *(*int32)(unsafe.Pointer(rule)) = v1 + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) + **(**int32)(__ccgo_up(rule)) = v1 r = v1 if r != int32('M') { if r == int32('J') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 } else { - *(*int32)(unsafe.Pointer(rule)) = 0 + **(**int32)(__ccgo_up(rule)) = 0 } - *(*int32)(unsafe.Pointer(rule + 1*4)) = _getint2(tls, p) + **(**int32)(__ccgo_up(rule + 1*4)) = _getint2(tls, p) } else { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 - *(*int32)(unsafe.Pointer(rule + 1*4)) = _getint2(tls, p) - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 - *(*int32)(unsafe.Pointer(rule + 2*4)) = _getint2(tls, p) - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 - *(*int32)(unsafe.Pointer(rule + 3*4)) = _getint2(tls, p) - } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('/') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 - *(*int32)(unsafe.Pointer(rule + 4*4)) = _getoff(tls, p) + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 + **(**int32)(__ccgo_up(rule + 1*4)) = _getint2(tls, p) + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 + **(**int32)(__ccgo_up(rule + 2*4)) = _getint2(tls, p) + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 + **(**int32)(__ccgo_up(rule + 3*4)) = _getint2(tls, p) + } + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) == int32('/') { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 + **(**int32)(__ccgo_up(rule + 4*4)) = _getoff(tls, p) } else { - *(*int32)(unsafe.Pointer(rule + 4*4)) = int32(7200) + **(**int32)(__ccgo_up(rule + 4*4)) = int32(7200) } } func _getname(tls *TLS, d uintptr, p uintptr) { var i, v3 int32 _, _ = i, v3 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('<') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) == int32('<') { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 i = 0 for { - if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i)))) != int32('>')) { + if !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)) + uintptr(i))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)) + uintptr(i)))) != int32('>')) { break } if i < int32(TZNAME_MAX) { - *(*uint8)(unsafe.Pointer(d + uintptr(i))) = *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))) + **(**uint8)(__ccgo_up(d + uintptr(i))) = **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)) + uintptr(i))) } goto _1 _1: ; i = i + 1 } - if *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))) != 0 { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + if **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)) + uintptr(i))) != 0 { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 } } else { i = 0 for { - if !(Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))))|int32(32)-int32('a')) < uint32(26)) { + if !(Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)) + uintptr(i))))|int32(32)-int32('a')) < uint32(26)) { break } if i < int32(TZNAME_MAX) { - *(*uint8)(unsafe.Pointer(d + uintptr(i))) = *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))) + **(**uint8)(__ccgo_up(d + uintptr(i))) = **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)) + uintptr(i))) } goto _2 _2: @@ -148400,17 +148400,17 @@ func _getname(tls *TLS, d uintptr, p uintptr) { i = i + 1 } } - *(*uintptr)(unsafe.Pointer(p)) += uintptr(i) + **(**uintptr)(__ccgo_up(p)) += uintptr(i) if i < int32(TZNAME_MAX) { v3 = i } else { v3 = int32(TZNAME_MAX) } - *(*uint8)(unsafe.Pointer(d + uintptr(v3))) = uint8(0) + **(**uint8)(__ccgo_up(d + uintptr(v3))) = uint8(0) } func _zi_read32(tls *TLS, z uintptr) (r Tuint32_t) { - return uint32(*(*uint8)(unsafe.Pointer(z)))< Uint64FromInt32(Int32FromInt32(PATH_MAX)+Int32FromInt32(1)) { - *(*uintptr)(unsafe.Pointer(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) + **(**uintptr)(__ccgo_up(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) i = Uint64FromInt32(3) } if i >= _old_tz_size { @@ -148493,13 +148493,13 @@ func _do_tzset(tls *TLS) { _old_tz = Xmalloc(tls, _old_tz_size) } if _old_tz != 0 { - Xmemcpy(tls, _old_tz, *(*uintptr)(unsafe.Pointer(bp + 288)), i+uint64(1)) + Xmemcpy(tls, _old_tz, **(**uintptr)(__ccgo_up(bp + 288)), i+uint64(1)) } posix_form = 0 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) != int32(':') { - *(*uintptr)(unsafe.Pointer(bp + 296)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) != int32(':') { + **(**uintptr)(__ccgo_up(bp + 296)) = **(**uintptr)(__ccgo_up(bp + 288)) _getname(tls, bp+308, bp+296) - if *(*uintptr)(unsafe.Pointer(bp + 296)) != *(*uintptr)(unsafe.Pointer(bp + 288)) && (Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 296))))) == int32('+') || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 296))))) == int32('-') || BoolInt32(uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 296)))))-uint32('0') < uint32(10)) != 0 || !(Xstrcmp(tls, bp+308, __ccgo_ts+1794) != 0) || !(Xstrcmp(tls, bp+308, __ccgo_ts+1798) != 0)) { + if **(**uintptr)(__ccgo_up(bp + 296)) != **(**uintptr)(__ccgo_up(bp + 288)) && (Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 296))))) == int32('+') || Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 296))))) == int32('-') || BoolInt32(uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 296)))))-uint32('0') < uint32(10)) != 0 || !(Xstrcmp(tls, bp+308, __ccgo_ts+1794) != 0) || !(Xstrcmp(tls, bp+308, __ccgo_ts+1798) != 0)) { posix_form = int32(1) } } @@ -148507,21 +148507,21 @@ func _do_tzset(tls *TLS) { * pathame beginning with "."; in secure mode, only the * standard path will be searched. */ if !(posix_form != 0) { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32(':') { - *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32(':') { + **(**uintptr)(__ccgo_up(bp + 288)) = **(**uintptr)(__ccgo_up(bp + 288)) + 1 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32('/') || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32('.') { - if !(X__libc.Fsecure != 0) || !(Xstrcmp(tls, *(*uintptr)(unsafe.Pointer(bp + 288)), __ccgo_ts+1779) != 0) { - map1 = X__map_file(tls, *(*uintptr)(unsafe.Pointer(bp + 288)), uintptr(unsafe.Pointer(&_map_size))) + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32('/') || Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32('.') { + if !(X__libc.Fsecure != 0) || !(Xstrcmp(tls, **(**uintptr)(__ccgo_up(bp + 288)), __ccgo_ts+1779) != 0) { + map1 = X__map_file(tls, **(**uintptr)(__ccgo_up(bp + 288)), uintptr(unsafe.Pointer(&_map_size))) } } else { - l = _strlen(tls, *(*uintptr)(unsafe.Pointer(bp + 288))) - if l <= uint64(NAME_MAX) && !(Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp + 288)), int32('.')) != 0) { - Xmemcpy(tls, pathname, *(*uintptr)(unsafe.Pointer(bp + 288)), l+uint64(1)) - *(*uint8)(unsafe.Pointer(pathname + uintptr(l))) = uint8(0) + l = _strlen(tls, **(**uintptr)(__ccgo_up(bp + 288))) + if l <= uint64(NAME_MAX) && !(Xstrchr(tls, **(**uintptr)(__ccgo_up(bp + 288)), int32('.')) != 0) { + Xmemcpy(tls, pathname, **(**uintptr)(__ccgo_up(bp + 288)), l+uint64(1)) + **(**uint8)(__ccgo_up(pathname + uintptr(l))) = uint8(0) try = uintptr(unsafe.Pointer(&_search)) for { - if !(!(map1 != 0) && *(*uint8)(unsafe.Pointer(try)) != 0) { + if !(!(map1 != 0) && **(**uint8)(__ccgo_up(try)) != 0) { break } l = _strlen(tls, try) @@ -148535,18 +148535,18 @@ func _do_tzset(tls *TLS) { } } if !(map1 != 0) { - *(*uintptr)(unsafe.Pointer(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) + **(**uintptr)(__ccgo_up(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) } } if map1 != 0 && (_map_size < uint64(44) || Xmemcmp(tls, map1, __ccgo_ts+1802, uint64(4)) != 0) { X__munmap(tls, map1, _map_size) map1 = uintptr(0) - *(*uintptr)(unsafe.Pointer(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) + **(**uintptr)(__ccgo_up(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) } _zi = map1 if map1 != 0 { scale = int32(2) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(map1 + 4))) != int32('1') { + if Int32FromUint8(**(**uint8)(__ccgo_up(map1 + 4))) != int32('1') { *(*[6]uint8)(unsafe.Pointer(bp)) = [6]uint8{ 0: uint8(1), 1: uint8(1), @@ -148565,18 +148565,18 @@ func _do_tzset(tls *TLS) { _types = _index + uintptr(_zi_read32(tls, _trans-uintptr(12))) _abbrevs = _types + uintptr(uint32(6)*_zi_read32(tls, _trans-uintptr(8))) _abbrevs_end = _abbrevs + uintptr(_zi_read32(tls, _trans-uintptr(4))) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(_zi + uintptr(_map_size-uint64(1))))) == int32('\n') { - *(*uintptr)(unsafe.Pointer(bp + 288)) = _zi + uintptr(_map_size) - uintptr(2) + if Int32FromUint8(**(**uint8)(__ccgo_up(_zi + uintptr(_map_size-uint64(1))))) == int32('\n') { + **(**uintptr)(__ccgo_up(bp + 288)) = _zi + uintptr(_map_size) - uintptr(2) for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) != int32('\n')) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) != int32('\n')) { break } goto _4 _4: ; - *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) - 1 + **(**uintptr)(__ccgo_up(bp + 288)) = **(**uintptr)(__ccgo_up(bp + 288)) - 1 } - *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 + **(**uintptr)(__ccgo_up(bp + 288)) = **(**uintptr)(__ccgo_up(bp + 288)) + 1 } else { v5 = UintptrFromInt32(0) Xtzname[int32(1)] = v5 @@ -148591,12 +148591,12 @@ func _do_tzset(tls *TLS) { if !(p1 < _abbrevs) { break } - if !(*(*uint8)(unsafe.Pointer(p1 + 4)) != 0) && !(Xtzname[0] != 0) { - Xtzname[0] = _abbrevs + uintptr(*(*uint8)(unsafe.Pointer(p1 + 5))) + if !(**(**uint8)(__ccgo_up(p1 + 4)) != 0) && !(Xtzname[0] != 0) { + Xtzname[0] = _abbrevs + uintptr(**(**uint8)(__ccgo_up(p1 + 5))) Xtimezone = Int64FromUint32(-_zi_read32(tls, p1)) } - if *(*uint8)(unsafe.Pointer(p1 + 4)) != 0 && !(Xtzname[int32(1)] != 0) { - Xtzname[int32(1)] = _abbrevs + uintptr(*(*uint8)(unsafe.Pointer(p1 + 5))) + if **(**uint8)(__ccgo_up(p1 + 4)) != 0 && !(Xtzname[int32(1)] != 0) { + Xtzname[int32(1)] = _abbrevs + uintptr(**(**uint8)(__ccgo_up(p1 + 5))) _dst_off = Int32FromUint32(-_zi_read32(tls, p1)) Xdaylight = int32(1) } @@ -148618,8 +148618,8 @@ func _do_tzset(tls *TLS) { return } } - if !(*(*uintptr)(unsafe.Pointer(bp + 288)) != 0) { - *(*uintptr)(unsafe.Pointer(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) + if !(**(**uintptr)(__ccgo_up(bp + 288)) != 0) { + **(**uintptr)(__ccgo_up(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) } _getname(tls, uintptr(unsafe.Pointer(&_std_name)), bp+288) Xtzname[0] = uintptr(unsafe.Pointer(&_std_name)) @@ -148628,7 +148628,7 @@ func _do_tzset(tls *TLS) { Xtzname[int32(1)] = uintptr(unsafe.Pointer(&_dst_name)) if _dst_name[0] != 0 { Xdaylight = int32(1) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32('+') || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32('-') || Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288)))))-int32('0')) < uint32(10) { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32('+') || Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32('-') || Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288)))))-int32('0')) < uint32(10) { _dst_off = _getoff(tls, bp+288) } else { _dst_off = int32(Xtimezone - int64(3600)) @@ -148637,12 +148637,12 @@ func _do_tzset(tls *TLS) { Xdaylight = 0 _dst_off = int32(Xtimezone) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32(',') { - *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32(',') { + **(**uintptr)(__ccgo_up(bp + 288)) = **(**uintptr)(__ccgo_up(bp + 288)) + 1 _getrule(tls, bp+288, uintptr(unsafe.Pointer(&_r0))) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32(',') { - *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32(',') { + **(**uintptr)(__ccgo_up(bp + 288)) = **(**uintptr)(__ccgo_up(bp + 288)) + 1 _getrule(tls, bp+288, uintptr(unsafe.Pointer(&_r12))) } } @@ -148663,7 +148663,7 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { n = Uint64FromInt64((int64(_index) - int64(_trans)) >> scale) if !(n != 0) { if alt != 0 { - *(*Tsize_t)(unsafe.Pointer(alt)) = uint64(0) + **(**Tsize_t)(__ccgo_up(alt)) = uint64(0) } return uint64(0) } @@ -148677,7 +148677,7 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { x = Uint64FromInt32(Int32FromUint64(x)) } if local != 0 { - off = Int32FromUint32(_zi_read32(tls, _types+uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(m-uint64(1)))))))) + off = Int32FromUint32(_zi_read32(tls, _types+uintptr(int32(6)*Int32FromUint8(**(**uint8)(__ccgo_up(_index + uintptr(m-uint64(1)))))))) } if t-int64(off) < int64(Int64FromUint64(x)) { n = n / uint64(2) @@ -148706,7 +148706,7 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { if !(i != 0) { break } - if !(*(*uint8)(unsafe.Pointer(_types + uintptr(i-uint64(6)+uint64(4)))) != 0) { + if !(**(**uint8)(__ccgo_up(_types + uintptr(i-uint64(6)+uint64(4)))) != 0) { j = i - uint64(6) } goto _1 @@ -148721,24 +148721,24 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { * and the index-zero (after transition) type as the alt. */ if t-int64(off) < int64(Int64FromUint64(x)) { if alt != 0 { - *(*Tsize_t)(unsafe.Pointer(alt)) = uint64(*(*uint8)(unsafe.Pointer(_index))) + **(**Tsize_t)(__ccgo_up(alt)) = uint64(**(**uint8)(__ccgo_up(_index))) } return j / uint64(6) } } /* Try to find a neighboring opposite-DST-status rule. */ if alt != 0 { - if a != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(_types + uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(a-uint64(1)))))+int32(4))))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(_types + uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(a))))+int32(4))))) { - *(*Tsize_t)(unsafe.Pointer(alt)) = uint64(*(*uint8)(unsafe.Pointer(_index + uintptr(a-uint64(1))))) + if a != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(_types + uintptr(int32(6)*Int32FromUint8(**(**uint8)(__ccgo_up(_index + uintptr(a-uint64(1)))))+int32(4))))) != Int32FromUint8(**(**uint8)(__ccgo_up(_types + uintptr(int32(6)*Int32FromUint8(**(**uint8)(__ccgo_up(_index + uintptr(a))))+int32(4))))) { + **(**Tsize_t)(__ccgo_up(alt)) = uint64(**(**uint8)(__ccgo_up(_index + uintptr(a-uint64(1))))) } else { - if a+uint64(1) < n && Int32FromUint8(*(*uint8)(unsafe.Pointer(_types + uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(a+uint64(1)))))+int32(4))))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(_types + uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(a))))+int32(4))))) { - *(*Tsize_t)(unsafe.Pointer(alt)) = uint64(*(*uint8)(unsafe.Pointer(_index + uintptr(a+uint64(1))))) + if a+uint64(1) < n && Int32FromUint8(**(**uint8)(__ccgo_up(_types + uintptr(int32(6)*Int32FromUint8(**(**uint8)(__ccgo_up(_index + uintptr(a+uint64(1)))))+int32(4))))) != Int32FromUint8(**(**uint8)(__ccgo_up(_types + uintptr(int32(6)*Int32FromUint8(**(**uint8)(__ccgo_up(_index + uintptr(a))))+int32(4))))) { + **(**Tsize_t)(__ccgo_up(alt)) = uint64(**(**uint8)(__ccgo_up(_index + uintptr(a+uint64(1))))) } else { - *(*Tsize_t)(unsafe.Pointer(alt)) = uint64(*(*uint8)(unsafe.Pointer(_index + uintptr(a)))) + **(**Tsize_t)(__ccgo_up(alt)) = uint64(**(**uint8)(__ccgo_up(_index + uintptr(a)))) } } } - return uint64(*(*uint8)(unsafe.Pointer(_index + uintptr(a)))) + return uint64(**(**uint8)(__ccgo_up(_index + uintptr(a)))) } func _days_in_month1(tls *TLS, m int32, is_leap int32) (r int32) { @@ -148760,28 +148760,28 @@ func _rule_to_secs(tls *TLS, rule uintptr, year int32) (r int64) { var _ /* is_leap at bp+0 */ int32 _, _, _, _, _, _, _ = d, days, m, n, t, wday, x t = X__year_to_secs(tls, int64(year), bp) - if *(*int32)(unsafe.Pointer(rule)) != int32('M') { - x = *(*int32)(unsafe.Pointer(rule + 1*4)) - if *(*int32)(unsafe.Pointer(rule)) == int32('J') && (x < int32(60) || !(*(*int32)(unsafe.Pointer(bp)) != 0)) { + if **(**int32)(__ccgo_up(rule)) != int32('M') { + x = **(**int32)(__ccgo_up(rule + 1*4)) + if **(**int32)(__ccgo_up(rule)) == int32('J') && (x < int32(60) || !(**(**int32)(__ccgo_up(bp)) != 0)) { x = x - 1 } t = t + int64(int32(86400)*x) } else { - m = *(*int32)(unsafe.Pointer(rule + 1*4)) - n = *(*int32)(unsafe.Pointer(rule + 2*4)) - d = *(*int32)(unsafe.Pointer(rule + 3*4)) - t = t + int64(X__month_to_secs(tls, m-int32(1), *(*int32)(unsafe.Pointer(bp)))) + m = **(**int32)(__ccgo_up(rule + 1*4)) + n = **(**int32)(__ccgo_up(rule + 2*4)) + d = **(**int32)(__ccgo_up(rule + 3*4)) + t = t + int64(X__month_to_secs(tls, m-int32(1), **(**int32)(__ccgo_up(bp)))) wday = int32((t+int64(Int32FromInt32(4)*Int32FromInt32(86400)))%int64(Int32FromInt32(7)*Int32FromInt32(86400))) / int32(86400) days = d - wday if days < 0 { days = days + int32(7) } - if n == int32(5) && days+int32(28) >= _days_in_month1(tls, m, *(*int32)(unsafe.Pointer(bp))) { + if n == int32(5) && days+int32(28) >= _days_in_month1(tls, m, **(**int32)(__ccgo_up(bp))) { n = int32(4) } t = t + int64(int32(86400)*(days+int32(7)*(n-int32(1)))) } - t = t + int64(*(*int32)(unsafe.Pointer(rule + 4*4))) + t = t + int64(**(**int32)(__ccgo_up(rule + 4*4))) return t } @@ -148807,11 +148807,11 @@ func X__secs_to_zone(tls *TLS, t int64, local int32, isdst uintptr, offset uintp if _zi != 0 { i = _scan_trans(tls, t, local, bp) if i != Uint64FromInt32(-Int32FromInt32(1)) { - *(*int32)(unsafe.Pointer(isdst)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(_types + uintptr(uint64(6)*i+uint64(4))))) - *(*int64)(unsafe.Pointer(offset)) = int64(Int32FromUint32(_zi_read32(tls, _types+uintptr(uint64(6)*i)))) - *(*uintptr)(unsafe.Pointer(zonename)) = _abbrevs + uintptr(*(*uint8)(unsafe.Pointer(_types + uintptr(uint64(6)*i+uint64(5))))) + **(**int32)(__ccgo_up(isdst)) = Int32FromUint8(**(**uint8)(__ccgo_up(_types + uintptr(uint64(6)*i+uint64(4))))) + **(**int64)(__ccgo_up(offset)) = int64(Int32FromUint32(_zi_read32(tls, _types+uintptr(uint64(6)*i)))) + **(**uintptr)(__ccgo_up(zonename)) = _abbrevs + uintptr(**(**uint8)(__ccgo_up(_types + uintptr(uint64(6)*i+uint64(5))))) if oppoff != 0 { - *(*int64)(unsafe.Pointer(oppoff)) = int64(Int32FromUint32(_zi_read32(tls, _types+uintptr(uint64(6)**(*Tsize_t)(unsafe.Pointer(bp)))))) + **(**int64)(__ccgo_up(oppoff)) = int64(Int32FromUint32(_zi_read32(tls, _types+uintptr(uint64(6)***(**Tsize_t)(__ccgo_up(bp)))))) } ___unlock(tls, uintptr(unsafe.Pointer(&_lock4))) return @@ -148849,23 +148849,23 @@ func X__secs_to_zone(tls *TLS, t int64, local int32, isdst uintptr, offset uintp goto std std: ; - *(*int32)(unsafe.Pointer(isdst)) = 0 - *(*int64)(unsafe.Pointer(offset)) = -Xtimezone + **(**int32)(__ccgo_up(isdst)) = 0 + **(**int64)(__ccgo_up(offset)) = -Xtimezone if oppoff != 0 { - *(*int64)(unsafe.Pointer(oppoff)) = int64(-_dst_off) + **(**int64)(__ccgo_up(oppoff)) = int64(-_dst_off) } - *(*uintptr)(unsafe.Pointer(zonename)) = Xtzname[0] + **(**uintptr)(__ccgo_up(zonename)) = Xtzname[0] ___unlock(tls, uintptr(unsafe.Pointer(&_lock4))) return goto dst dst: ; - *(*int32)(unsafe.Pointer(isdst)) = int32(1) - *(*int64)(unsafe.Pointer(offset)) = int64(-_dst_off) + **(**int32)(__ccgo_up(isdst)) = int32(1) + **(**int64)(__ccgo_up(offset)) = int64(-_dst_off) if oppoff != 0 { - *(*int64)(unsafe.Pointer(oppoff)) = -Xtimezone + **(**int64)(__ccgo_up(oppoff)) = -Xtimezone } - *(*uintptr)(unsafe.Pointer(zonename)) = Xtzname[int32(1)] + **(**uintptr)(__ccgo_up(zonename)) = Xtzname[int32(1)] ___unlock(tls, uintptr(unsafe.Pointer(&_lock4))) } @@ -148908,11 +148908,11 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { if !((y-Int32FromInt32(68))&Int32FromInt32(3) != 0) { leaps = leaps - 1 if is_leap != 0 { - *(*int32)(unsafe.Pointer(is_leap)) = int32(1) + **(**int32)(__ccgo_up(is_leap)) = int32(1) } } else { if is_leap != 0 { - *(*int32)(unsafe.Pointer(is_leap)) = 0 + **(**int32)(__ccgo_up(is_leap)) = 0 } } return int64(int32(31536000)*(y-int32(70)) + int32(86400)*leaps) @@ -148927,7 +148927,7 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { rem = rem + int32(400) } if !(rem != 0) { - *(*int32)(unsafe.Pointer(is_leap)) = int32(1) + **(**int32)(__ccgo_up(is_leap)) = int32(1) centuries = 0 leaps1 = 0 } else { @@ -148948,15 +148948,15 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { } } if !(rem != 0) { - *(*int32)(unsafe.Pointer(is_leap)) = 0 + **(**int32)(__ccgo_up(is_leap)) = 0 leaps1 = 0 } else { leaps1 = Int32FromUint32(Uint32FromInt32(rem) / uint32(4)) rem = Int32FromUint32(uint32(rem) % Uint32FromUint32(4)) - *(*int32)(unsafe.Pointer(is_leap)) = BoolInt32(!(rem != 0)) + **(**int32)(__ccgo_up(is_leap)) = BoolInt32(!(rem != 0)) } } - leaps1 = leaps1 + (int32(97)*cycles + int32(24)*centuries - *(*int32)(unsafe.Pointer(is_leap))) + leaps1 = leaps1 + (int32(97)*cycles + int32(24)*centuries - **(**int32)(__ccgo_up(is_leap))) return (year-int64(100))*int64(31536000) + int64(leaps1)*int64(86400) + int64(946684800) + int64(86400) } @@ -148985,7 +148985,7 @@ func X__asctime_r(tls *TLS, tm uintptr, buf uintptr) (r uintptr) { * application developers that they may not be so lucky * on other implementations (e.g. stack smashing..). */ - *(*uint8)(unsafe.Pointer(UintptrFromInt32(0))) = uint8(0) + **(**uint8)(__ccgo_up(UintptrFromInt32(0))) = uint8(0) } return buf } @@ -149018,10 +149018,10 @@ func Xclock(tls *TLS) (r Tclock_t) { if X__clock_gettime(tls, int32(CLOCK_PROCESS_CPUTIME_ID), bp) != 0 { return int64(-int32(1)) } - if (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec > Int64FromInt64(0x7fffffffffffffff)/Int64FromInt32(1000000) || (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_nsec/int64(1000) > int64(0x7fffffffffffffff)-int64(1000000)*(*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec { + if (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec > Int64FromInt64(0x7fffffffffffffff)/Int64FromInt32(1000000) || (**(**Ttimespec)(__ccgo_up(bp))).Ftv_nsec/int64(1000) > int64(0x7fffffffffffffff)-int64(1000000)*(**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec { return int64(-int32(1)) } - return (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec*int64(1000000) + (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_nsec/int64(1000) + return (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec*int64(1000000) + (**(**Ttimespec)(__ccgo_up(bp))).Ftv_nsec/int64(1000) } func Xclock_getcpuclockid(tls *TLS, pid Tpid_t, clk uintptr) (r int32) { @@ -149043,7 +149043,7 @@ func Xclock_getcpuclockid(tls *TLS, pid Tpid_t, clk uintptr) (r int32) { if ret != 0 { return -ret } - *(*Tclockid_t)(unsafe.Pointer(clk)) = id + **(**Tclockid_t)(__ccgo_up(clk)) = id return 0 } @@ -149173,8 +149173,8 @@ func Xftime(tls *TLS, tp uintptr) (r int32) { var _ /* ts at bp+0 */ Ttimespec _ = v1 Xclock_gettime(tls, CLOCK_REALTIME, bp) - (*Ttimeb)(unsafe.Pointer(tp)).Ftime = (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec - (*Ttimeb)(unsafe.Pointer(tp)).Fmillitm = Uint16FromInt64((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_nsec / int64(1000000)) + (*Ttimeb)(unsafe.Pointer(tp)).Ftime = (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec + (*Ttimeb)(unsafe.Pointer(tp)).Fmillitm = Uint16FromInt64((**(**Ttimespec)(__ccgo_up(bp))).Ftv_nsec / int64(1000000)) v1 = Int16FromInt32(0) (*Ttimeb)(unsafe.Pointer(tp)).Fdstflag = v1 (*Ttimeb)(unsafe.Pointer(tp)).Ftimezone = v1 @@ -149202,7 +149202,7 @@ func Xgetdate(tls *TLS, s uintptr) (r uintptr) { } f = Xfopen(tls, datemsk, __ccgo_ts+315) if !(f != 0) { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENOMEM) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENOMEM) { Xgetdate_err = int32(6) } else { Xgetdate_err = int32(2) @@ -149211,7 +149211,7 @@ func Xgetdate(tls *TLS, s uintptr) (r uintptr) { } for Xfgets(tls, bp, int32(100), f) != 0 { p = Xstrptime(tls, s, bp, uintptr(unsafe.Pointer(&_tmbuf))) - if p != 0 && !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if p != 0 && !(**(**uint8)(__ccgo_up(p)) != 0) { ret = uintptr(unsafe.Pointer(&_tmbuf)) goto out } @@ -149227,7 +149227,7 @@ out: if f != 0 { Xfclose(tls, f) } - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 100)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 100)), uintptr(0)) return ret } @@ -149245,8 +149245,8 @@ func Xgettimeofday(tls *TLS, tv uintptr, tz uintptr) (r int32) { return 0 } Xclock_gettime(tls, CLOCK_REALTIME, bp) - (*Ttimeval)(unsafe.Pointer(tv)).Ftv_sec = (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec - (*Ttimeval)(unsafe.Pointer(tv)).Ftv_usec = int64(int32((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_nsec) / int32(1000)) + (*Ttimeval)(unsafe.Pointer(tv)).Ftv_sec = (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec + (*Ttimeval)(unsafe.Pointer(tv)).Ftv_usec = int64(int32((**(**Ttimespec)(__ccgo_up(bp))).Ftv_nsec) / int32(1000)) return 0 } @@ -149265,8 +149265,8 @@ func X__gmtime_r(tls *TLS, t uintptr, tm uintptr) (r uintptr) { trc("tls=%v t=%v tm=%v, (%v:)", tls, t, tm, origin(2)) defer func() { trc("-> %v", r) }() } - if X__secs_to_tm(tls, *(*Ttime_t)(unsafe.Pointer(t)), tm) < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + if X__secs_to_tm(tls, int64(**(**Ttime_t)(__ccgo_up(t))), tm) < 0 { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return uintptr(0) } (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst = 0 @@ -149309,13 +149309,13 @@ func X__localtime_r(tls *TLS, t uintptr, tm uintptr) (r uintptr) { } /* Reject time_t values whose year would overflow int because * __secs_to_zone cannot safely handle them. */ - if *(*Ttime_t)(unsafe.Pointer(t)) < int64(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff))*Int64FromInt64(31622400) || *(*Ttime_t)(unsafe.Pointer(t)) > Int64FromInt32(INT_MAX)*Int64FromInt64(31622400) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + if int64(**(**Ttime_t)(__ccgo_up(t))) < int64(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff))*Int64FromInt64(31622400) || int64(**(**Ttime_t)(__ccgo_up(t))) > Int64FromInt32(INT_MAX)*Int64FromInt64(31622400) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return uintptr(0) } - X__secs_to_zone(tls, *(*Ttime_t)(unsafe.Pointer(t)), 0, tm+32, tm+40, uintptr(0), tm+48) - if X__secs_to_tm(tls, *(*Ttime_t)(unsafe.Pointer(t))+(*Ttm)(unsafe.Pointer(tm)).F__tm_gmtoff, tm) < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + X__secs_to_zone(tls, int64(**(**Ttime_t)(__ccgo_up(t))), 0, tm+32, tm+40, uintptr(0), tm+48) + if X__secs_to_tm(tls, int64(**(**Ttime_t)(__ccgo_up(t)))+(*Ttm)(unsafe.Pointer(tm)).F__tm_gmtoff, tm) < 0 { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return uintptr(0) } return tm @@ -149351,23 +149351,23 @@ func Xmktime(tls *TLS, tm uintptr) (r Ttime_t) { _ = t t = X__tm_to_secs(tls, tm) X__secs_to_zone(tls, t, int32(1), bp+32, bp+40, bp+56, bp+48) - if (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst >= 0 && (*(*Ttm)(unsafe.Pointer(bp))).Ftm_isdst != (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst { - t = t - (*(*int64)(unsafe.Pointer(bp + 56)) - (*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff) + if (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst >= 0 && (**(**Ttm)(__ccgo_up(bp))).Ftm_isdst != (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst { + t = t - int64(**(**int64)(__ccgo_up(bp + 56))-(**(**Ttm)(__ccgo_up(bp))).F__tm_gmtoff) } - t = t - (*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff + t = t - int64((**(**Ttm)(__ccgo_up(bp))).F__tm_gmtoff) if t != t { goto error } X__secs_to_zone(tls, t, 0, bp+32, bp+40, bp+56, bp+48) - if X__secs_to_tm(tls, t+(*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff, bp) < 0 { + if X__secs_to_tm(tls, t+int64((**(**Ttm)(__ccgo_up(bp))).F__tm_gmtoff), bp) < 0 { goto error } - *(*Ttm)(unsafe.Pointer(tm)) = *(*Ttm)(unsafe.Pointer(bp)) + **(**Ttm)(__ccgo_up(tm)) = **(**Ttm)(__ccgo_up(bp)) return t goto error error: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return int64(-int32(1)) } @@ -149528,7 +149528,7 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc val = int64((*Ttm)(unsafe.Pointer(tm)).Ftm_min) goto number case int32('n'): - *(*Tsize_t)(unsafe.Pointer(l)) = uint64(1) + **(**Tsize_t)(__ccgo_up(l)) = uint64(1) return __ccgo_ts + 301 case int32('p'): if (*Ttm)(unsafe.Pointer(tm)).Ftm_hour >= int32(12) { @@ -149547,20 +149547,20 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc item = v1 fmt = X__nl_langinfo_l(tls, item, loc) d = s - *(*Tsize_t)(unsafe.Pointer(l)) = uint64(0) + **(**Tsize_t)(__ccgo_up(l)) = uint64(0) for { - if !(*(*uint8)(unsafe.Pointer(fmt)) != 0) { + if !(**(**uint8)(__ccgo_up(fmt)) != 0) { break } v4 = d d = d + 1 v5 = fmt fmt = fmt + 1 - *(*uint8)(unsafe.Pointer(v4)) = Uint8FromInt32(Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))))) + **(**uint8)(__ccgo_up(v4)) = Uint8FromInt32(Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(v5))))) goto _3 _3: ; - *(*Tsize_t)(unsafe.Pointer(l)) = *(*Tsize_t)(unsafe.Pointer(l)) + 1 + **(**Tsize_t)(__ccgo_up(l)) = **(**Tsize_t)(__ccgo_up(l)) + 1 } return s case int32('r'): @@ -149577,7 +149577,7 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc val = int64((*Ttm)(unsafe.Pointer(tm)).Ftm_sec) goto number case int32('t'): - *(*Tsize_t)(unsafe.Pointer(l)) = uint64(1) + **(**Tsize_t)(__ccgo_up(l)) = uint64(1) return __ccgo_ts + 1439 case int32('T'): fmt = __ccgo_ts + 1871 @@ -149619,27 +149619,27 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc case int32('Y'): val = int64((*Ttm)(unsafe.Pointer(tm)).Ftm_year) + int64(1900) if val >= int64(10000) { - *(*Tsize_t)(unsafe.Pointer(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1880, VaList(bp+8, val))) + **(**Tsize_t)(__ccgo_up(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1880, VaList(bp+8, val))) return s } width = int32(4) goto number case int32('z'): if (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst < 0 { - *(*Tsize_t)(unsafe.Pointer(l)) = uint64(0) + **(**Tsize_t)(__ccgo_up(l)) = uint64(0) return __ccgo_ts } - *(*Tsize_t)(unsafe.Pointer(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1886, VaList(bp+8, (*Ttm)(unsafe.Pointer(tm)).F__tm_gmtoff/int64(3600)*int64(100)+(*Ttm)(unsafe.Pointer(tm)).F__tm_gmtoff%int64(3600)/int64(60)))) + **(**Tsize_t)(__ccgo_up(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1886, VaList(bp+8, (*Ttm)(unsafe.Pointer(tm)).F__tm_gmtoff/int64(3600)*int64(100)+(*Ttm)(unsafe.Pointer(tm)).F__tm_gmtoff%int64(3600)/int64(60)))) return s case int32('Z'): if (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst < 0 { - *(*Tsize_t)(unsafe.Pointer(l)) = uint64(0) + **(**Tsize_t)(__ccgo_up(l)) = uint64(0) return __ccgo_ts } fmt = X__tm_to_tzname(tls, tm) goto string case int32('%'): - *(*Tsize_t)(unsafe.Pointer(l)) = uint64(1) + **(**Tsize_t)(__ccgo_up(l)) = uint64(1) return __ccgo_ts + 446 default: return uintptr(0) @@ -149654,13 +149654,13 @@ number: } switch v1 { case int32('-'): - *(*Tsize_t)(unsafe.Pointer(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1893, VaList(bp+8, val))) + **(**Tsize_t)(__ccgo_up(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1893, VaList(bp+8, val))) case int32('_'): - *(*Tsize_t)(unsafe.Pointer(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1898, VaList(bp+8, width, val))) + **(**Tsize_t)(__ccgo_up(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1898, VaList(bp+8, width, val))) case int32('0'): fallthrough default: - *(*Tsize_t)(unsafe.Pointer(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1904, VaList(bp+8, width, val))) + **(**Tsize_t)(__ccgo_up(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1904, VaList(bp+8, width, val))) break } return s @@ -149671,7 +149671,7 @@ nl_strcat: goto string string: ; - *(*Tsize_t)(unsafe.Pointer(l)) = _strlen(tls, fmt) + **(**Tsize_t)(__ccgo_up(l)) = _strlen(tls, fmt) return fmt goto nl_strftime nl_strftime: @@ -149680,8 +149680,8 @@ nl_strftime: goto recu_strftime recu_strftime: ; - *(*Tsize_t)(unsafe.Pointer(l)) = X__strftime_l(tls, s, uint64(100), fmt, tm, loc) - if !(*(*Tsize_t)(unsafe.Pointer(l)) != 0) { + **(**Tsize_t)(__ccgo_up(l)) = X__strftime_l(tls, s, uint64(100), fmt, tm, loc) + if !(**(**Tsize_t)(__ccgo_up(l)) != 0) { return uintptr(0) } return s @@ -149708,46 +149708,46 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl if !(l < n) { break } - if !(*(*uint8)(unsafe.Pointer(f)) != 0) { - *(*uint8)(unsafe.Pointer(s + uintptr(l))) = uint8(0) + if !(**(**uint8)(__ccgo_up(f)) != 0) { + **(**uint8)(__ccgo_up(s + uintptr(l))) = uint8(0) return l } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) != int32('%') { + if Int32FromUint8(**(**uint8)(__ccgo_up(f))) != int32('%') { v2 = l l = l + 1 - *(*uint8)(unsafe.Pointer(s + uintptr(v2))) = *(*uint8)(unsafe.Pointer(f)) + **(**uint8)(__ccgo_up(s + uintptr(v2))) = **(**uint8)(__ccgo_up(f)) goto _1 } f = f + 1 pad = 0 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('-') || Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('_') || Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('0') { + if Int32FromUint8(**(**uint8)(__ccgo_up(f))) == int32('-') || Int32FromUint8(**(**uint8)(__ccgo_up(f))) == int32('_') || Int32FromUint8(**(**uint8)(__ccgo_up(f))) == int32('0') { v3 = f f = f + 1 - pad = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + pad = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } - v4 = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == Int32FromUint8('+')) + v4 = BoolInt32(Int32FromUint8(**(**uint8)(__ccgo_up(f))) == Int32FromUint8('+')) plus = v4 if v4 != 0 { f = f + 1 } - if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(f)))-uint32('0') < uint32(10)) != 0 { + if BoolInt32(uint32(**(**uint8)(__ccgo_up(f)))-uint32('0') < uint32(10)) != 0 { width = Xstrtoul(tls, f, bp+112, int32(10)) } else { width = uint64(0) - *(*uintptr)(unsafe.Pointer(bp + 112)) = f + **(**uintptr)(__ccgo_up(bp + 112)) = f } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 112))))) == int32('C') || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 112))))) == int32('F') || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 112))))) == int32('G') || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 112))))) == int32('Y') { - if !(width != 0) && *(*uintptr)(unsafe.Pointer(bp + 112)) != f { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 112))))) == int32('C') || Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 112))))) == int32('F') || Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 112))))) == int32('G') || Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 112))))) == int32('Y') { + if !(width != 0) && **(**uintptr)(__ccgo_up(bp + 112)) != f { width = uint64(1) } } else { width = uint64(0) } - f = *(*uintptr)(unsafe.Pointer(bp + 112)) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('E') || Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('O') { + f = **(**uintptr)(__ccgo_up(bp + 112)) + if Int32FromUint8(**(**uint8)(__ccgo_up(f))) == int32('E') || Int32FromUint8(**(**uint8)(__ccgo_up(f))) == int32('O') { f = f + 1 } - t = X__strftime_fmt_1(tls, bp+8, bp, Int32FromUint8(*(*uint8)(unsafe.Pointer(f))), tm, loc, pad) + t = X__strftime_fmt_1(tls, bp+8, bp, Int32FromUint8(**(**uint8)(__ccgo_up(f))), tm, loc, pad) if !(t != 0) { break } @@ -149755,26 +149755,26 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl /* Trim off any sign and leading zeros, then * count remaining digits to determine behavior * for the + flag. */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(t))) == int32('+') || Int32FromUint8(*(*uint8)(unsafe.Pointer(t))) == int32('-') { + if Int32FromUint8(**(**uint8)(__ccgo_up(t))) == int32('+') || Int32FromUint8(**(**uint8)(__ccgo_up(t))) == int32('-') { t = t + 1 - *(*Tsize_t)(unsafe.Pointer(bp)) = *(*Tsize_t)(unsafe.Pointer(bp)) - 1 + **(**Tsize_t)(__ccgo_up(bp)) = **(**Tsize_t)(__ccgo_up(bp)) - 1 } for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(t))) == int32('0') && Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(t + 1)))-int32('0')) < uint32(10)) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(t))) == int32('0') && Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(t + 1)))-int32('0')) < uint32(10)) { break } goto _5 _5: ; t = t + 1 - *(*Tsize_t)(unsafe.Pointer(bp)) = *(*Tsize_t)(unsafe.Pointer(bp)) - 1 + **(**Tsize_t)(__ccgo_up(bp)) = **(**Tsize_t)(__ccgo_up(bp)) - 1 } - if width < *(*Tsize_t)(unsafe.Pointer(bp)) { - width = *(*Tsize_t)(unsafe.Pointer(bp)) + if width < **(**Tsize_t)(__ccgo_up(bp)) { + width = **(**Tsize_t)(__ccgo_up(bp)) } d = uint64(0) for { - if !(Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(t + uintptr(d))))-int32('0')) < uint32(10)) { + if !(Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(t + uintptr(d))))-int32('0')) < uint32(10)) { break } goto _6 @@ -149785,41 +149785,41 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl if (*Ttm)(unsafe.Pointer(tm)).Ftm_year < -int32(1900) { v2 = l l = l + 1 - *(*uint8)(unsafe.Pointer(s + uintptr(v2))) = uint8('-') + **(**uint8)(__ccgo_up(s + uintptr(v2))) = uint8('-') width = width - 1 } else { if v9 = plus != 0; v9 { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 112))))) == int32('C') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 112))))) == int32('C') { v4 = int32(3) } else { v4 = int32(5) } } - if v9 && d+(width-*(*Tsize_t)(unsafe.Pointer(bp))) >= Uint64FromInt32(v4) { + if v9 && d+(width-**(**Tsize_t)(__ccgo_up(bp))) >= Uint64FromInt32(v4) { v2 = l l = l + 1 - *(*uint8)(unsafe.Pointer(s + uintptr(v2))) = uint8('+') + **(**uint8)(__ccgo_up(s + uintptr(v2))) = uint8('+') width = width - 1 } } for { - if !(width > *(*Tsize_t)(unsafe.Pointer(bp)) && l < n) { + if !(width > **(**Tsize_t)(__ccgo_up(bp)) && l < n) { break } v2 = l l = l + 1 - *(*uint8)(unsafe.Pointer(s + uintptr(v2))) = uint8('0') + **(**uint8)(__ccgo_up(s + uintptr(v2))) = uint8('0') goto _11 _11: ; width = width - 1 } } - if *(*Tsize_t)(unsafe.Pointer(bp)) > n-l { - *(*Tsize_t)(unsafe.Pointer(bp)) = n - l + if **(**Tsize_t)(__ccgo_up(bp)) > n-l { + **(**Tsize_t)(__ccgo_up(bp)) = n - l } - Xmemcpy(tls, s+uintptr(l), t, *(*Tsize_t)(unsafe.Pointer(bp))) - l = l + *(*Tsize_t)(unsafe.Pointer(bp)) + Xmemcpy(tls, s+uintptr(l), t, **(**Tsize_t)(__ccgo_up(bp))) + l = l + **(**Tsize_t)(__ccgo_up(bp)) goto _1 _1: ; @@ -149829,7 +149829,7 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl if l == n { l = n - uint64(1) } - *(*uint8)(unsafe.Pointer(s + uintptr(l))) = uint8(0) + **(**uint8)(__ccgo_up(s + uintptr(l))) = uint8(0) } return uint64(0) } @@ -149867,18 +149867,18 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { var _ /* relyear at bp+8 */ int32 _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = adj, dest, ex, i, len1, min, neg, range1, w, want_century, v1, v2, v5, v6, v8, v9 want_century = 0 - *(*int32)(unsafe.Pointer(bp + 4)) = 0 - *(*int32)(unsafe.Pointer(bp + 8)) = 0 - for *(*uint8)(unsafe.Pointer(f)) != 0 { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) != int32('%') { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) + **(**int32)(__ccgo_up(bp + 4)) = 0 + **(**int32)(__ccgo_up(bp + 8)) = 0 + for **(**uint8)(__ccgo_up(f)) != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(f))) != int32('%') { + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(f))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _3 _3: if v2 != 0 { for { - if v8 = *(*uint8)(unsafe.Pointer(s)) != 0; v8 { - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) + if v8 = **(**uint8)(__ccgo_up(s)) != 0; v8 { + v5 = Int32FromUint8(**(**uint8)(__ccgo_up(s))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _7 _7: @@ -149892,7 +149892,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { s = s + 1 } } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) != Int32FromUint8(**(**uint8)(__ccgo_up(f))) { return uintptr(0) } else { s = s + 1 @@ -149902,19 +149902,19 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { continue } f = f + 1 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('+') { + if Int32FromUint8(**(**uint8)(__ccgo_up(f))) == int32('+') { f = f + 1 } - if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(f)))-uint32('0') < uint32(10)) != 0 { + if BoolInt32(uint32(**(**uint8)(__ccgo_up(f)))-uint32('0') < uint32(10)) != 0 { w = Int32FromUint64(Xstrtoul(tls, f, bp+16, int32(10))) - f = *(*uintptr)(unsafe.Pointer(bp + 16)) + f = **(**uintptr)(__ccgo_up(bp + 16)) } else { w = -int32(1) } adj = 0 v9 = f f = f + 1 - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(v9))) { case int32('A'): goto _10 case int32('a'): @@ -150065,8 +150065,8 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { ; _44: ; - if v8 = *(*uint8)(unsafe.Pointer(s)) != 0; v8 { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) + if v8 = **(**uint8)(__ccgo_up(s)) != 0; v8 { + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(s))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _47 _47: @@ -150088,15 +150088,15 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { ex = Xnl_langinfo(tls, int32(AM_STR)) len1 = _strlen(tls, ex) if !(Xstrncasecmp(tls, s, ex, len1) != 0) { - *(*int32)(unsafe.Pointer(tm + 8)) %= int32(12) + **(**int32)(__ccgo_up(tm + 8)) %= int32(12) s = s + uintptr(len1) goto _41 } ex = Xnl_langinfo(tls, int32(PM_STR)) len1 = _strlen(tls, ex) if !(Xstrncasecmp(tls, s, ex, len1) != 0) { - *(*int32)(unsafe.Pointer(tm + 8)) %= int32(12) - *(*int32)(unsafe.Pointer(tm + 8)) += int32(12) + **(**int32)(__ccgo_up(tm + 8)) %= int32(12) + **(**int32)(__ccgo_up(tm + 8)) += int32(12) s = s + uintptr(len1) goto _41 } @@ -150176,7 +150176,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { ; v9 = s s = s + 1 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) != int32('%') { + if Int32FromUint8(**(**uint8)(__ccgo_up(v9))) != int32('%') { return uintptr(0) } goto _41 @@ -150186,27 +150186,27 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { goto numeric_range numeric_range: ; - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } - *(*int32)(unsafe.Pointer(dest)) = 0 + **(**int32)(__ccgo_up(dest)) = 0 i = int32(1) for { - if !(i <= min+range1 && BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0) { + if !(i <= min+range1 && BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-uint32('0') < uint32(10)) != 0) { break } v9 = s s = s + 1 - *(*int32)(unsafe.Pointer(dest)) = *(*int32)(unsafe.Pointer(dest))*int32(10) + Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) - int32('0') + **(**int32)(__ccgo_up(dest)) = **(**int32)(__ccgo_up(dest))*int32(10) + Int32FromUint8(**(**uint8)(__ccgo_up(v9))) - int32('0') goto _50 _50: ; i = i * int32(10) } - if Uint32FromInt32(*(*int32)(unsafe.Pointer(dest))-min) >= Uint32FromInt32(range1) { + if Uint32FromInt32(**(**int32)(__ccgo_up(dest))-min) >= Uint32FromInt32(range1) { return uintptr(0) } - *(*int32)(unsafe.Pointer(dest)) -= adj + **(**int32)(__ccgo_up(dest)) -= adj switch int64(dest) - int64(tm) { case Int64FromUint64(uint64(UintptrFromInt32(0) + 28)): } @@ -150215,36 +150215,36 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { numeric_digits: ; neg = 0 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('+') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('+') { s = s + 1 } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('-') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('-') { neg = int32(1) s = s + 1 } } - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } v1 = Int32FromInt32(0) i = v1 - *(*int32)(unsafe.Pointer(dest)) = v1 + **(**int32)(__ccgo_up(dest)) = v1 for { - if !(i < w && BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0) { + if !(i < w && BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-uint32('0') < uint32(10)) != 0) { break } v9 = s s = s + 1 - *(*int32)(unsafe.Pointer(dest)) = *(*int32)(unsafe.Pointer(dest))*int32(10) + Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) - int32('0') + **(**int32)(__ccgo_up(dest)) = **(**int32)(__ccgo_up(dest))*int32(10) + Int32FromUint8(**(**uint8)(__ccgo_up(v9))) - int32('0') goto _52 _52: ; i = i + 1 } if neg != 0 { - *(*int32)(unsafe.Pointer(dest)) = -*(*int32)(unsafe.Pointer(dest)) + **(**int32)(__ccgo_up(dest)) = -**(**int32)(__ccgo_up(dest)) } - *(*int32)(unsafe.Pointer(dest)) -= adj + **(**int32)(__ccgo_up(dest)) -= adj goto update goto symbolic_range symbolic_range: @@ -150260,7 +150260,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { goto _55 } s = s + uintptr(len1) - *(*int32)(unsafe.Pointer(dest)) = i % range1 + **(**int32)(__ccgo_up(dest)) = i % range1 break goto _55 _55: @@ -150278,12 +150278,12 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { _41: } if want_century != 0 { - (*Ttm)(unsafe.Pointer(tm)).Ftm_year = *(*int32)(unsafe.Pointer(bp + 8)) + (*Ttm)(unsafe.Pointer(tm)).Ftm_year = **(**int32)(__ccgo_up(bp + 8)) if want_century&int32(2) != 0 { - *(*int32)(unsafe.Pointer(tm + 20)) += *(*int32)(unsafe.Pointer(bp + 4))*int32(100) - int32(1900) + **(**int32)(__ccgo_up(tm + 20)) += **(**int32)(__ccgo_up(bp + 4))*int32(100) - int32(1900) } else { if (*Ttm)(unsafe.Pointer(tm)).Ftm_year <= int32(68) { - *(*int32)(unsafe.Pointer(tm + 20)) += int32(100) + **(**int32)(__ccgo_up(tm + 20)) += int32(100) } } } @@ -150300,9 +150300,9 @@ func Xtime(tls *TLS, t uintptr) (r Ttime_t) { var _ /* ts at bp+0 */ Ttimespec X__clock_gettime(tls, CLOCK_REALTIME, bp) if t != 0 { - *(*Ttime_t)(unsafe.Pointer(t)) = (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec + **(**Ttime_t)(__ccgo_up(t)) = (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec } - return (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec + return (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec } func Xtimegm(tls *TLS, tm uintptr) (r Ttime_t) { @@ -150317,10 +150317,10 @@ func Xtimegm(tls *TLS, tm uintptr) (r Ttime_t) { _ = t t = X__tm_to_secs(tls, tm) if X__secs_to_tm(tls, t, bp) < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return int64(-int32(1)) } - *(*Ttm1)(unsafe.Pointer(tm)) = *(*Ttm1)(unsafe.Pointer(bp)) + **(**Ttm1)(__ccgo_up(tm)) = **(**Ttm1)(__ccgo_up(bp)) (*Ttm1)(unsafe.Pointer(tm)).Ftm_isdst = 0 (*Ttm1)(unsafe.Pointer(tm)).Ftm_gmtoff = 0 (*Ttm1)(unsafe.Pointer(tm)).Ftm_zone = uintptr(unsafe.Pointer(&X__utc)) @@ -150478,92 +150478,92 @@ func X__wcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl if !(l < n) { break } - if !(*(*Twchar_t)(unsafe.Pointer(f)) != 0) { - *(*Twchar_t)(unsafe.Pointer(s + uintptr(l)*4)) = 0 + if !(**(**Twchar_t)(__ccgo_up(f)) != 0) { + **(**Twchar_t)(__ccgo_up(s + uintptr(l)*4)) = 0 return l } - if *(*Twchar_t)(unsafe.Pointer(f)) != int32('%') { + if **(**Twchar_t)(__ccgo_up(f)) != int32('%') { v2 = l l = l + 1 - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = *(*Twchar_t)(unsafe.Pointer(f)) + **(**Twchar_t)(__ccgo_up(s + uintptr(v2)*4)) = **(**Twchar_t)(__ccgo_up(f)) goto _1 } f += 4 pad = 0 - if *(*Twchar_t)(unsafe.Pointer(f)) == int32('-') || *(*Twchar_t)(unsafe.Pointer(f)) == int32('_') || *(*Twchar_t)(unsafe.Pointer(f)) == int32('0') { + if **(**Twchar_t)(__ccgo_up(f)) == int32('-') || **(**Twchar_t)(__ccgo_up(f)) == int32('_') || **(**Twchar_t)(__ccgo_up(f)) == int32('0') { v3 = f f += 4 - pad = *(*Twchar_t)(unsafe.Pointer(v3)) + pad = **(**Twchar_t)(__ccgo_up(v3)) } - v4 = BoolInt32(*(*Twchar_t)(unsafe.Pointer(f)) == Int32FromUint8('+')) + v4 = BoolInt32(**(**Twchar_t)(__ccgo_up(f)) == Int32FromUint8('+')) plus = v4 if v4 != 0 { f += 4 } width = Xwcstoul(tls, f, bp+512, int32(10)) - if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 512)))) == int32('C') || *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 512)))) == int32('F') || *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 512)))) == int32('G') || *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 512)))) == int32('Y') { - if !(width != 0) && *(*uintptr)(unsafe.Pointer(bp + 512)) != f { + if **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 512)))) == int32('C') || **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 512)))) == int32('F') || **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 512)))) == int32('G') || **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 512)))) == int32('Y') { + if !(width != 0) && **(**uintptr)(__ccgo_up(bp + 512)) != f { width = uint64(1) } } else { width = uint64(0) } - f = *(*uintptr)(unsafe.Pointer(bp + 512)) - if *(*Twchar_t)(unsafe.Pointer(f)) == int32('E') || *(*Twchar_t)(unsafe.Pointer(f)) == int32('O') { + f = **(**uintptr)(__ccgo_up(bp + 512)) + if **(**Twchar_t)(__ccgo_up(f)) == int32('E') || **(**Twchar_t)(__ccgo_up(f)) == int32('O') { f += 4 } - t_mb = X__strftime_fmt_1(tls, bp+8, bp, *(*Twchar_t)(unsafe.Pointer(f)), tm, loc, pad) + t_mb = X__strftime_fmt_1(tls, bp+8, bp, **(**Twchar_t)(__ccgo_up(f)), tm, loc, pad) if !(t_mb != 0) { break } - *(*Tsize_t)(unsafe.Pointer(bp)) = Xmbstowcs(tls, bp+108, t_mb, Uint64FromInt64(400)/Uint64FromInt64(4)) - if *(*Tsize_t)(unsafe.Pointer(bp)) == Uint64FromInt32(-Int32FromInt32(1)) { + **(**Tsize_t)(__ccgo_up(bp)) = Xmbstowcs(tls, bp+108, t_mb, Uint64FromInt64(400)/Uint64FromInt64(4)) + if **(**Tsize_t)(__ccgo_up(bp)) == Uint64FromInt32(-Int32FromInt32(1)) { return uint64(0) } t = bp + 108 if width != 0 { for { - if !(*(*Twchar_t)(unsafe.Pointer(t)) == int32('+') || *(*Twchar_t)(unsafe.Pointer(t)) == int32('-') || *(*Twchar_t)(unsafe.Pointer(t)) == int32('0') && *(*Twchar_t)(unsafe.Pointer(t + 1*4)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(t)) == int32('+') || **(**Twchar_t)(__ccgo_up(t)) == int32('-') || **(**Twchar_t)(__ccgo_up(t)) == int32('0') && **(**Twchar_t)(__ccgo_up(t + 1*4)) != 0) { break } goto _5 _5: ; t += 4 - *(*Tsize_t)(unsafe.Pointer(bp)) = *(*Tsize_t)(unsafe.Pointer(bp)) - 1 + **(**Tsize_t)(__ccgo_up(bp)) = **(**Tsize_t)(__ccgo_up(bp)) - 1 } width = width - 1 if plus != 0 && (*Ttm)(unsafe.Pointer(tm)).Ftm_year >= Int32FromInt32(10000)-Int32FromInt32(1900) { v2 = l l = l + 1 - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = int32('+') + **(**Twchar_t)(__ccgo_up(s + uintptr(v2)*4)) = int32('+') } else { if (*Ttm)(unsafe.Pointer(tm)).Ftm_year < -int32(1900) { v2 = l l = l + 1 - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = int32('-') + **(**Twchar_t)(__ccgo_up(s + uintptr(v2)*4)) = int32('-') } else { width = width + 1 } } for { - if !(width > *(*Tsize_t)(unsafe.Pointer(bp)) && l < n) { + if !(width > **(**Tsize_t)(__ccgo_up(bp)) && l < n) { break } v2 = l l = l + 1 - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = int32('0') + **(**Twchar_t)(__ccgo_up(s + uintptr(v2)*4)) = int32('0') goto _8 _8: ; width = width - 1 } } - if *(*Tsize_t)(unsafe.Pointer(bp)) >= n-l { - *(*Tsize_t)(unsafe.Pointer(bp)) = n - l + if **(**Tsize_t)(__ccgo_up(bp)) >= n-l { + **(**Tsize_t)(__ccgo_up(bp)) = n - l } - Xwmemcpy(tls, s+uintptr(l)*4, t, *(*Tsize_t)(unsafe.Pointer(bp))) - l = l + *(*Tsize_t)(unsafe.Pointer(bp)) + Xwmemcpy(tls, s+uintptr(l)*4, t, **(**Tsize_t)(__ccgo_up(bp))) + l = l + **(**Tsize_t)(__ccgo_up(bp)) goto _1 _1: ; @@ -150573,7 +150573,7 @@ func X__wcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl if l == n { l = n - uint64(1) } - *(*Twchar_t)(unsafe.Pointer(s + uintptr(l)*4)) = 0 + **(**Twchar_t)(__ccgo_up(s + uintptr(l)*4)) = 0 } return uint64(0) } @@ -150626,14 +150626,14 @@ func Xalarm(tls *TLS, seconds uint32) (r uint32) { defer tls.Free(64) var _ /* it at bp+0 */ Titimerval var _ /* old at bp+32 */ Titimerval - *(*Titimerval)(unsafe.Pointer(bp)) = Titimerval{ + **(**Titimerval)(__ccgo_up(bp)) = Titimerval{ Fit_value: Ttimeval{ Ftv_sec: Int64FromUint32(seconds), }, } - *(*Titimerval)(unsafe.Pointer(bp + 32)) = Titimerval{} + **(**Titimerval)(__ccgo_up(bp + 32)) = Titimerval{} Xsetitimer(tls, ITIMER_REAL, bp, bp+32) - return Uint32FromInt64((*(*Titimerval)(unsafe.Pointer(bp + 32))).Fit_value.Ftv_sec + BoolInt64(!!((*(*Titimerval)(unsafe.Pointer(bp + 32))).Fit_value.Ftv_usec != 0))) + return Uint32FromInt64((**(**Titimerval)(__ccgo_up(bp + 32))).Fit_value.Ftv_sec + BoolInt64(!!((**(**Titimerval)(__ccgo_up(bp + 32))).Fit_value.Ftv_usec != 0))) } func Xchdir(tls *TLS, path uintptr) (r int32) { @@ -150760,7 +150760,7 @@ func _checker(tls *TLS, p uintptr) (r int32) { if X__syscall2(tls, int64(SYS_setregid), X__syscall0(tls, int64(SYS_getegid)), int64(-Int32FromInt32(1))) != 0 || X__syscall2(tls, int64(SYS_setreuid), X__syscall0(tls, int64(SYS_geteuid)), int64(-Int32FromInt32(1))) != 0 { X__syscall1(tls, int64(SYS_exit), int64(Int32FromInt32(1))) } - *(*int32)(unsafe.Pointer(bp)) = int32(X__syscall4(tls, int64(SYS_faccessat), int64((*Tctx1)(unsafe.Pointer(c)).Ffd), int64((*Tctx1)(unsafe.Pointer(c)).Ffilename), int64((*Tctx1)(unsafe.Pointer(c)).Famode), int64(Int32FromInt32(0)))) + **(**int32)(__ccgo_up(bp)) = int32(X__syscall4(tls, int64(SYS_faccessat), int64((*Tctx1)(unsafe.Pointer(c)).Ffd), int64((*Tctx1)(unsafe.Pointer(c)).Ffilename), int64((*Tctx1)(unsafe.Pointer(c)).Famode), int64(Int32FromInt32(0)))) X__syscall3(tls, int64(SYS_write), int64((*Tctx1)(unsafe.Pointer(c)).Fp), int64(bp), Int64FromUint64(Uint64FromInt64(4))) return 0 } @@ -150875,7 +150875,7 @@ func Xgetcwd(tls *TLS, buf uintptr, size Tsize_t) (r uintptr) { size = v1 } else { if !(size != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } } @@ -150883,8 +150883,8 @@ func Xgetcwd(tls *TLS, buf uintptr, size Tsize_t) (r uintptr) { if ret < 0 { return uintptr(0) } - if ret == 0 || Int32FromUint8(*(*uint8)(unsafe.Pointer(buf))) != int32('/') { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOENT) + if ret == 0 || Int32FromUint8(**(**uint8)(__ccgo_up(buf))) != int32('/') { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOENT) return uintptr(0) } if buf == tmp { @@ -150948,8 +150948,8 @@ func Xgethostname(tls *TLS, name uintptr, len1 Tsize_t) (r int32) { i = uint64(0) for { if v3 = i < len1; v3 { - v2 = *(*uint8)(unsafe.Pointer(bp + 65 + uintptr(i))) - *(*uint8)(unsafe.Pointer(name + uintptr(i))) = v2 + v2 = **(**uint8)(__ccgo_up(bp + 65 + uintptr(i))) + **(**uint8)(__ccgo_up(name + uintptr(i))) = v2 } if !(v3 && v2 != 0) { break @@ -150960,7 +150960,7 @@ func Xgethostname(tls *TLS, name uintptr, len1 Tsize_t) (r int32) { i = i + 1 } if i != 0 && i == len1 { - *(*uint8)(unsafe.Pointer(name + uintptr(i-uint64(1)))) = uint8(0) + **(**uint8)(__ccgo_up(name + uintptr(i-uint64(1)))) = uint8(0) } return 0 } @@ -151053,8 +151053,8 @@ func Xisatty(tls *TLS, fd int32) (r1 int32) { if r == uint64(0) { return int32(1) } - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(EBADF) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOTTY) + if **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(EBADF) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOTTY) } return 0 } @@ -151119,8 +151119,8 @@ func Xnice(tls *TLS, inc int32) (r int32) { prio = -int32(NZERO) } if Xsetpriority(tls, PRIO_PROCESS, uint32(0), prio) != 0 { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EACCES) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EPERM) + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EACCES) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EPERM) } return -int32(1) } else { @@ -151167,12 +151167,12 @@ func Xpipe2(tls *TLS, fd uintptr, flag int32) (r int32) { return ret } if flag&int32(O_CLOEXEC) != 0 { - X__syscall3(tls, int64(SYS_fcntl), int64(*(*int32)(unsafe.Pointer(fd))), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) - X__syscall3(tls, int64(SYS_fcntl), int64(*(*int32)(unsafe.Pointer(fd + 1*4))), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) + X__syscall3(tls, int64(SYS_fcntl), int64(**(**int32)(__ccgo_up(fd))), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) + X__syscall3(tls, int64(SYS_fcntl), int64(**(**int32)(__ccgo_up(fd + 1*4))), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) } if flag&int32(O_NONBLOCK) != 0 { - X__syscall3(tls, int64(SYS_fcntl), int64(*(*int32)(unsafe.Pointer(fd))), int64(Int32FromInt32(F_SETFL)), int64(Int32FromInt32(O_NONBLOCK))) - X__syscall3(tls, int64(SYS_fcntl), int64(*(*int32)(unsafe.Pointer(fd + 1*4))), int64(Int32FromInt32(F_SETFL)), int64(Int32FromInt32(O_NONBLOCK))) + X__syscall3(tls, int64(SYS_fcntl), int64(**(**int32)(__ccgo_up(fd))), int64(Int32FromInt32(F_SETFL)), int64(Int32FromInt32(O_NONBLOCK))) + X__syscall3(tls, int64(SYS_fcntl), int64(**(**int32)(__ccgo_up(fd + 1*4))), int64(Int32FromInt32(F_SETFL)), int64(Int32FromInt32(O_NONBLOCK))) } return 0 } @@ -151371,7 +151371,7 @@ func X__setxid(tls *TLS, nr int32, id int32, eid int32, sid int32) (r int32) { _ = v1 /* ret is initially nonzero so that failure of the first thread does not * trigger the safety kill above. */ - *(*Tctx2)(unsafe.Pointer(bp)) = Tctx2{ + **(**Tctx2)(__ccgo_up(bp)) = Tctx2{ Fid: id, Feid: eid, Fsid: sid, @@ -151379,10 +151379,10 @@ func X__setxid(tls *TLS, nr int32, id int32, eid int32, sid int32) (r int32) { Fret: int32(1), } ___synccall(tls, __ccgo_fp(_do_setxid), bp) - if (*(*Tctx2)(unsafe.Pointer(bp))).Fret > 0 { + if (**(**Tctx2)(__ccgo_up(bp))).Fret > 0 { v1 = -int32(EAGAIN) } else { - v1 = (*(*Tctx2)(unsafe.Pointer(bp))).Fret + v1 = (**(**Tctx2)(__ccgo_up(bp))).Fret } return int32(X__syscall_ret(tls, Uint64FromInt32(v1))) } @@ -151395,11 +151395,11 @@ func Xsleep(tls *TLS, seconds uint32) (r uint32) { bp := tls.Alloc(16) defer tls.Free(16) var _ /* tv at bp+0 */ Ttimespec - *(*Ttimespec)(unsafe.Pointer(bp)) = Ttimespec{ + **(**Ttimespec)(__ccgo_up(bp)) = Ttimespec{ Ftv_sec: Int64FromUint32(seconds), } if Xnanosleep(tls, bp, bp) != 0 { - return Uint32FromInt64((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec) + return Uint32FromInt64((**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec) } return uint32(0) } @@ -151438,7 +151438,7 @@ func Xtcgetpgrp(tls *TLS, fd int32) (r Tpid_t) { if Xioctl(tls, fd, int32(TIOCGPGRP), VaList(bp+16, bp)) < 0 { return -int32(1) } - return *(*int32)(unsafe.Pointer(bp)) + return **(**int32)(__ccgo_up(bp)) } func Xtcsetpgrp(tls *TLS, fd int32, pgrp Tpid_t) (r int32) { @@ -151449,7 +151449,7 @@ func Xtcsetpgrp(tls *TLS, fd int32, pgrp Tpid_t) (r int32) { bp := tls.Alloc(32) defer tls.Free(32) var _ /* pgrp_int at bp+0 */ int32 - *(*int32)(unsafe.Pointer(bp)) = pgrp + **(**int32)(__ccgo_up(bp)) = pgrp return Xioctl(tls, fd, int32(TIOCSPGRP), VaList(bp+16, bp)) } @@ -151480,7 +151480,7 @@ func Xttyname(tls *TLS, fd int32) (r uintptr) { v1 = Xttyname_r(tls, fd, uintptr(unsafe.Pointer(&_buf10)), uint64(32)) result = v1 if v1 != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = result + **(**int32)(__ccgo_up(X__errno_location(tls))) = result return UintptrFromInt32(0) } return uintptr(unsafe.Pointer(&_buf10)) @@ -151501,22 +151501,22 @@ func Xttyname_r(tls *TLS, fd int32, name uintptr, size Tsize_t) (r int32) { var _ /* st2 at bp+128 */ Tstat _ = l if !(Xisatty(tls, fd) != 0) { - return *(*int32)(unsafe.Pointer(X__errno_location(tls))) + return **(**int32)(__ccgo_up(X__errno_location(tls))) } X__procfdname(tls, bp+256, Uint32FromInt32(fd)) l = Xreadlink(tls, bp+256, name, size) if l < 0 { - return *(*int32)(unsafe.Pointer(X__errno_location(tls))) + return **(**int32)(__ccgo_up(X__errno_location(tls))) } else { if Uint64FromInt64(l) == size { return int32(ERANGE) } } - *(*uint8)(unsafe.Pointer(name + uintptr(l))) = uint8(0) + **(**uint8)(__ccgo_up(name + uintptr(l))) = uint8(0) if Xstat(tls, name, bp) != 0 || Xfstat(tls, fd, bp+128) != 0 { - return *(*int32)(unsafe.Pointer(X__errno_location(tls))) + return **(**int32)(__ccgo_up(X__errno_location(tls))) } - if (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev != (*(*Tstat)(unsafe.Pointer(bp + 128))).Fst_dev || (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino != (*(*Tstat)(unsafe.Pointer(bp + 128))).Fst_ino { + if (**(**Tstat)(__ccgo_up(bp))).Fst_dev != (**(**Tstat)(__ccgo_up(bp + 128))).Fst_dev || (**(**Tstat)(__ccgo_up(bp))).Fst_ino != (**(**Tstat)(__ccgo_up(bp + 128))).Fst_ino { return int32(ENODEV) } return 0 @@ -151531,7 +151531,7 @@ func Xualarm(tls *TLS, value uint32, interval uint32) (r uint32) { defer tls.Free(64) var _ /* it at bp+0 */ Titimerval var _ /* it_old at bp+32 */ Titimerval - *(*Titimerval)(unsafe.Pointer(bp)) = Titimerval{ + **(**Titimerval)(__ccgo_up(bp)) = Titimerval{ Fit_interval: Ttimeval{ Ftv_usec: Int64FromUint32(interval), }, @@ -151540,7 +151540,7 @@ func Xualarm(tls *TLS, value uint32, interval uint32) (r uint32) { }, } Xsetitimer(tls, ITIMER_REAL, bp, bp+32) - return Uint32FromInt64((*(*Titimerval)(unsafe.Pointer(bp + 32))).Fit_value.Ftv_sec*int64(1000000) + (*(*Titimerval)(unsafe.Pointer(bp + 32))).Fit_value.Ftv_usec) + return Uint32FromInt64((**(**Titimerval)(__ccgo_up(bp + 32))).Fit_value.Ftv_sec*int64(1000000) + (**(**Titimerval)(__ccgo_up(bp + 32))).Fit_value.Ftv_usec) } func Xunlink(tls *TLS, path uintptr) (r int32) { @@ -151567,7 +151567,7 @@ func Xusleep(tls *TLS, useconds uint32) (r int32) { bp := tls.Alloc(16) defer tls.Free(16) var _ /* tv at bp+0 */ Ttimespec - *(*Ttimespec)(unsafe.Pointer(bp)) = Ttimespec{ + **(**Ttimespec)(__ccgo_up(bp)) = Ttimespec{ Ftv_sec: Int64FromUint32(useconds / uint32(1000000)), Ftv_nsec: Int64FromUint32(useconds % uint32(1000000) * uint32(1000)), } @@ -151595,6 +151595,10 @@ func __ccgo_fp(f interface{}) uintptr { return (*iface)(unsafe.Pointer(&f))[1] } +func __ccgo_up(n uintptr) unsafe.Pointer { + return unsafe.Pointer(&n) +} + var X__abort_lock [1]int32 var X__at_quick_exit_lockptr = uintptr(unsafe.Pointer(&_lock)) diff --git a/vendor/modernc.org/libc/ccgo_linux_s390x.go b/vendor/modernc.org/libc/ccgo_linux_s390x.go index bac9ed7121..7fed3b19bd 100644 --- a/vendor/modernc.org/libc/ccgo_linux_s390x.go +++ b/vendor/modernc.org/libc/ccgo_linux_s390x.go @@ -516,7 +516,7 @@ func ___frexp_exp(tls *TLS, x float64, expt uintptr) (r float64) { */ exp_x = Xexp(tls, x-_kln2) hx = uint32(*(*Tuint64_t)(unsafe.Pointer(&exp_x)) >> int32(32)) - *(*int32)(unsafe.Pointer(expt)) = Int32FromUint32(hx>>Int32FromInt32(20) - Uint32FromInt32(Int32FromInt32(0x3ff)+Int32FromInt32(1023)) + _k) + **(**int32)(__ccgo_up(expt)) = Int32FromUint32(hx>>Int32FromInt32(20) - Uint32FromInt32(Int32FromInt32(0x3ff)+Int32FromInt32(1023)) + _k) v1 = uint64(hx&Uint32FromInt32(0xfffff)|Uint32FromInt32((Int32FromInt32(0x3ff)+Int32FromInt32(1023))<>Int32FromInt32(23) - Uint32FromInt32(Int32FromInt32(0x7f)+Int32FromInt32(127)) + _k1) + **(**int32)(__ccgo_up(expt)) = Int32FromUint32(hx>>Int32FromInt32(23) - Uint32FromInt32(Int32FromInt32(0x7f)+Int32FromInt32(127)) + _k1) v1 = hx&uint32(0x7fffff) | Uint32FromInt32((Int32FromInt32(0x7f)+Int32FromInt32(127))< uint32(35) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uint64(0) } } @@ -3249,7 +3249,7 @@ func Xfpathconf(tls *TLS, fd int32, name int32) (r int64) { defer func() { trc("-> %v", r) }() } if Uint64FromInt32(name) >= Uint64FromInt64(42)/Uint64FromInt64(2) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) } return int64(_values[name]) @@ -7426,7 +7426,7 @@ func Xsysconf(tls *TLS, name int32) (r int64) { var _ /* si at bp+144 */ Tsysinfo _, _, _, _, _, _, _ = cnt, i, mem, val, v1, v3, v5 if Uint64FromInt32(name) >= Uint64FromInt64(502)/Uint64FromInt64(2) || !(_values1[name] != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) } else { if int32(_values1[name]) >= -int32(1) { @@ -7434,13 +7434,13 @@ func Xsysconf(tls *TLS, name int32) (r int64) { } else { if int32(_values1[name]) < -int32(256) { Xgetrlimit(tls, int32(_values1[name])&int32(16383), bp) - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur == ^Uint64FromUint64(0) { + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur == ^Uint64FromUint64(0) { return int64(-int32(1)) } - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur > uint64(0x7fffffffffffffff) { + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur > uint64(0x7fffffffffffffff) { v1 = uint64(0x7fffffffffffffff) } else { - v1 = (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur + v1 = (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur } return Int64FromUint64(v1) } @@ -7462,7 +7462,7 @@ func Xsysconf(tls *TLS, name int32) (r int64) { case (-Int32FromInt32(256) | Int32FromInt32(6)) & Int32FromInt32(255): fallthrough case (-Int32FromInt32(256) | Int32FromInt32(7)) & Int32FromInt32(255): - *(*[128]uint8)(unsafe.Pointer(bp + 16)) = [128]uint8{ + **(**[128]uint8)(__ccgo_up(bp + 16)) = [128]uint8{ 0: uint8(1), } X__syscall3(tls, int64(SYS_sched_getaffinity), int64(Int32FromInt32(0)), Int64FromUint64(Uint64FromInt64(128)), int64(bp+16)) @@ -7474,14 +7474,14 @@ func Xsysconf(tls *TLS, name int32) (r int64) { break } for { - if !((*(*[128]uint8)(unsafe.Pointer(bp + 16)))[i] != 0) { + if !((**(**[128]uint8)(__ccgo_up(bp + 16)))[i] != 0) { break } goto _4 _4: ; v5 = bp + 16 + uintptr(i) - *(*uint8)(unsafe.Pointer(v5)) = uint8(int32(*(*uint8)(unsafe.Pointer(v5))) & (Int32FromUint8((*(*[128]uint8)(unsafe.Pointer(bp + 16)))[i]) - Int32FromInt32(1))) + *(*uint8)(unsafe.Pointer(v5)) = uint8(int32(*(*uint8)(unsafe.Pointer(v5))) & (Int32FromUint8((**(**[128]uint8)(__ccgo_up(bp + 16)))[i]) - Int32FromInt32(1))) cnt = cnt + 1 } goto _2 @@ -7494,15 +7494,15 @@ func Xsysconf(tls *TLS, name int32) (r int64) { fallthrough case (-Int32FromInt32(256) | Int32FromInt32(9)) & Int32FromInt32(255): X__lsysinfo(tls, bp+144) - if !((*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fmem_unit != 0) { - (*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fmem_unit = uint32(1) + if !((**(**Tsysinfo)(__ccgo_up(bp + 144))).Fmem_unit != 0) { + (**(**Tsysinfo)(__ccgo_up(bp + 144))).Fmem_unit = uint32(1) } if name == int32(_SC_PHYS_PAGES) { - mem = (*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Ftotalram + mem = uint64((**(**Tsysinfo)(__ccgo_up(bp + 144))).Ftotalram) } else { - mem = (*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Ffreeram + (*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fbufferram + mem = uint64((**(**Tsysinfo)(__ccgo_up(bp + 144))).Ffreeram + (**(**Tsysinfo)(__ccgo_up(bp + 144))).Fbufferram) } - mem = mem * uint64((*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fmem_unit) + mem = mem * uint64((**(**Tsysinfo)(__ccgo_up(bp + 144))).Fmem_unit) mem = mem / uint64(PAGESIZE) if mem > uint64(0x7fffffffffffffff) { v1 = uint64(0x7fffffffffffffff) @@ -8902,7 +8902,7 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { for cond := true; cond; cond = dptr < end { v1 = sptr sptr = sptr + 1 - tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = uint32(**(**uint8)(__ccgo_up(v1))) tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) @@ -8914,7 +8914,7 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { c1 = tmp v1 = sptr sptr = sptr + 1 - tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = uint32(**(**uint8)(__ccgo_up(v1))) tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) @@ -8926,13 +8926,13 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { c2 = tmp v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(c1<>int32(4)) + **(**uint8)(__ccgo_up(v1)) = uint8(c1<>int32(4)) if dptr >= end { break } v1 = sptr sptr = sptr + 1 - tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = uint32(**(**uint8)(__ccgo_up(v1))) tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) @@ -8944,13 +8944,13 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { c3 = tmp v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(c2&uint32(0x0F)<>int32(2)) + **(**uint8)(__ccgo_up(v1)) = uint8(c2&uint32(0x0F)<>int32(2)) if dptr >= end { break } v1 = sptr sptr = sptr + 1 - tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = uint32(**(**uint8)(__ccgo_up(v1))) tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) @@ -8962,7 +8962,7 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { c4 = tmp v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(c3&uint32(0x03)<>int32(2)] + **(**uint8)(__ccgo_up(v1)) = _BF_itoa64[c1>>int32(2)] c1 = c1 & uint32(0x03) << int32(4) if sptr >= end { v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] + **(**uint8)(__ccgo_up(v1)) = _BF_itoa64[c1] break } v1 = sptr sptr = sptr + 1 - c2 = uint32(*(*uint8)(unsafe.Pointer(v1))) + c2 = uint32(**(**uint8)(__ccgo_up(v1))) c1 = c1 | c2>>int32(4) v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] + **(**uint8)(__ccgo_up(v1)) = _BF_itoa64[c1] c1 = c2 & uint32(0x0f) << int32(2) if sptr >= end { v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] + **(**uint8)(__ccgo_up(v1)) = _BF_itoa64[c1] break } v1 = sptr sptr = sptr + 1 - c2 = uint32(*(*uint8)(unsafe.Pointer(v1))) + c2 = uint32(**(**uint8)(__ccgo_up(v1))) c1 = c1 | c2>>int32(6) v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] + **(**uint8)(__ccgo_up(v1)) = _BF_itoa64[c1] v1 = dptr dptr = dptr + 1 - *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c2&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _BF_itoa64[c2&uint32(0x3f)] } } @@ -9023,11 +9023,11 @@ func _BF_swap(tls *TLS, x uintptr, count int32) { v1 = int32(1) if *(*uint8)(unsafe.Pointer(&v1)) != 0 { for { - tmp = *(*TBF_word)(unsafe.Pointer(x)) + tmp = **(**TBF_word)(__ccgo_up(x)) tmp = tmp<>Int32FromInt32(16) v4 = x x += 4 - *(*TBF_word)(unsafe.Pointer(v4)) = tmp&uint32(0x00FF00FF)<>Int32FromInt32(8)&uint32(0x00FF00FF) + **(**TBF_word)(__ccgo_up(v4)) = tmp&uint32(0x00FF00FF)<>Int32FromInt32(8)&uint32(0x00FF00FF) goto _3 _3: ; @@ -9047,7 +9047,7 @@ func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, e _, _, _, _, _, _, _ = i, ptr, tmp1, tmp2, tmp3, tmp4, v2 ptr = start for cond := true; cond; cond = ptr < end { - L = L ^ *(*TBF_word)(unsafe.Pointer(ctx)) + L = L ^ **(**TBF_word)(__ccgo_up(ctx)) i = 0 for { if !(i < int32(16)) { @@ -9059,12 +9059,12 @@ func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, e tmp3 = L >> int32(16) tmp3 = tmp3 & uint32(0xFF) tmp4 = L >> int32(24) - tmp1 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 3*1024 + uintptr(tmp1)*4)) - tmp2 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 2*1024 + uintptr(tmp2)*4)) - tmp3 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 1*1024 + uintptr(tmp3)*4)) - tmp3 = tmp3 + *(*TBF_word)(unsafe.Pointer(ctx + 72 + uintptr(tmp4)*4)) + tmp1 = **(**TBF_word)(__ccgo_up(ctx + 72 + 3*1024 + uintptr(tmp1)*4)) + tmp2 = **(**TBF_word)(__ccgo_up(ctx + 72 + 2*1024 + uintptr(tmp2)*4)) + tmp3 = **(**TBF_word)(__ccgo_up(ctx + 72 + 1*1024 + uintptr(tmp3)*4)) + tmp3 = tmp3 + **(**TBF_word)(__ccgo_up(ctx + 72 + uintptr(tmp4)*4)) tmp3 = tmp3 ^ tmp2 - R = R ^ *(*TBF_word)(unsafe.Pointer(ctx + uintptr(i+int32(1))*4)) + R = R ^ **(**TBF_word)(__ccgo_up(ctx + uintptr(i+int32(1))*4)) tmp3 = tmp3 + tmp1 R = R ^ tmp3 tmp1 = R & uint32(0xFF) @@ -9073,12 +9073,12 @@ func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, e tmp3 = R >> int32(16) tmp3 = tmp3 & uint32(0xFF) tmp4 = R >> int32(24) - tmp1 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 3*1024 + uintptr(tmp1)*4)) - tmp2 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 2*1024 + uintptr(tmp2)*4)) - tmp3 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 1*1024 + uintptr(tmp3)*4)) - tmp3 = tmp3 + *(*TBF_word)(unsafe.Pointer(ctx + 72 + uintptr(tmp4)*4)) + tmp1 = **(**TBF_word)(__ccgo_up(ctx + 72 + 3*1024 + uintptr(tmp1)*4)) + tmp2 = **(**TBF_word)(__ccgo_up(ctx + 72 + 2*1024 + uintptr(tmp2)*4)) + tmp3 = **(**TBF_word)(__ccgo_up(ctx + 72 + 1*1024 + uintptr(tmp3)*4)) + tmp3 = tmp3 + **(**TBF_word)(__ccgo_up(ctx + 72 + uintptr(tmp4)*4)) tmp3 = tmp3 ^ tmp2 - L = L ^ *(*TBF_word)(unsafe.Pointer(ctx + uintptr(i+int32(1)+int32(1))*4)) + L = L ^ **(**TBF_word)(__ccgo_up(ctx + uintptr(i+int32(1)+int32(1))*4)) tmp3 = tmp3 + tmp1 L = L ^ tmp3 goto _1 @@ -9088,13 +9088,13 @@ func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, e } tmp4 = R R = L - L = tmp4 ^ *(*TBF_word)(unsafe.Pointer(ctx + uintptr(Int32FromInt32(BF_N)+Int32FromInt32(1))*4)) + L = tmp4 ^ **(**TBF_word)(__ccgo_up(ctx + uintptr(Int32FromInt32(BF_N)+Int32FromInt32(1))*4)) v2 = ptr ptr += 4 - *(*TBF_word)(unsafe.Pointer(v2)) = L + **(**TBF_word)(__ccgo_up(v2)) = L v2 = ptr ptr += 4 - *(*TBF_word)(unsafe.Pointer(v2)) = R + **(**TBF_word)(__ccgo_up(v2)) = R } return L } @@ -9154,17 +9154,17 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags break } v1 = Uint32FromInt32(0) - (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)] = v1 - (*(*[2]TBF_word)(unsafe.Pointer(bp)))[0] = v1 + (**(**[2]TBF_word)(__ccgo_up(bp)))[int32(1)] = v1 + (**(**[2]TBF_word)(__ccgo_up(bp)))[0] = v1 j = uint32(0) for { if !(j < uint32(4)) { break } - *(*TBF_word)(unsafe.Pointer(bp)) <<= uint32(8) - *(*TBF_word)(unsafe.Pointer(bp)) |= uint32(*(*uint8)(unsafe.Pointer(ptr))) /* correct */ - *(*TBF_word)(unsafe.Pointer(bp + 1*4)) <<= uint32(8) - *(*TBF_word)(unsafe.Pointer(bp + 1*4)) |= Uint32FromInt8(Int8FromUint8(*(*uint8)(unsafe.Pointer(ptr)))) /* bug */ + **(**TBF_word)(__ccgo_up(bp)) <<= uint32(8) + **(**TBF_word)(__ccgo_up(bp)) |= uint32(uint8(**(**uint8)(__ccgo_up(ptr)))) /* correct */ + **(**TBF_word)(__ccgo_up(bp + 1*4)) <<= uint32(8) + **(**TBF_word)(__ccgo_up(bp + 1*4)) |= Uint32FromInt8(Int8FromUint8(**(**uint8)(__ccgo_up(ptr)))) /* bug */ /* * Sign extension in the first char has no effect - nothing to overwrite yet, * and those extra 24 bits will be fully shifted out of the 32-bit word. For @@ -9172,9 +9172,9 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags * extension in tmp[1] occurs. Once this flag is set, it remains set. */ if j != 0 { - sign = sign | (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)]&uint32(0x80) + sign = sign | (**(**[2]TBF_word)(__ccgo_up(bp)))[int32(1)]&uint32(0x80) } - if !(*(*uint8)(unsafe.Pointer(ptr)) != 0) { + if !(**(**uint8)(__ccgo_up(ptr)) != 0) { ptr = key } else { ptr = ptr + 1 @@ -9184,9 +9184,9 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags ; j = j + 1 } - diff = diff | ((*(*[2]TBF_word)(unsafe.Pointer(bp)))[0] ^ (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)]) /* Non-zero on any differences */ - *(*TBF_word)(unsafe.Pointer(expanded + uintptr(i)*4)) = (*(*[2]TBF_word)(unsafe.Pointer(bp)))[bug] - *(*TBF_word)(unsafe.Pointer(initial + uintptr(i)*4)) = *(*TBF_word)(unsafe.Pointer(uintptr(unsafe.Pointer(&_BF_init_state)) + uintptr(i)*4)) ^ (*(*[2]TBF_word)(unsafe.Pointer(bp)))[bug] + diff = diff | ((**(**[2]TBF_word)(__ccgo_up(bp)))[0] ^ (**(**[2]TBF_word)(__ccgo_up(bp)))[int32(1)]) /* Non-zero on any differences */ + **(**TBF_word)(__ccgo_up(expanded + uintptr(i)*4)) = (**(**[2]TBF_word)(__ccgo_up(bp)))[bug] + **(**TBF_word)(__ccgo_up(initial + uintptr(i)*4)) = **(**TBF_word)(__ccgo_up(uintptr(unsafe.Pointer(&_BF_init_state)) + uintptr(i)*4)) ^ (**(**[2]TBF_word)(__ccgo_up(bp)))[bug] goto _2 _2: ; @@ -9217,7 +9217,7 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags * state that could be directly specified by a password to the buggy algorithm * (and to the fully correct one as well, but that's a side-effect). */ - *(*TBF_word)(unsafe.Pointer(initial)) ^= sign + **(**TBF_word)(__ccgo_up(initial)) ^= sign } var _flags_by_subtype = [26]uint8{ @@ -9244,28 +9244,28 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w } } _, _, _, _, _, _, _, _, _, _, _, _ = L, L1, R, count, done, i, ptr, tmp1, tmp2, tmp3, tmp4, v1 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(setting))) != int32('$') || Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 1))) != int32('2') || Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 2)))-int32('a')) > uint32(25) || !(_flags_by_subtype[Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 2)))-int32('a')] != 0) || Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 3))) != int32('$') || Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 4)))-int32('0')) > uint32(1) || Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 5)))-int32('0')) > uint32(9) || Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 6))) != int32('$') { + if Int32FromUint8(**(**uint8)(__ccgo_up(setting))) != int32('$') || Int32FromUint8(**(**uint8)(__ccgo_up(setting + 1))) != int32('2') || Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(setting + 2)))-int32('a')) > uint32(25) || !(_flags_by_subtype[Int32FromUint8(**(**uint8)(__ccgo_up(setting + 2)))-int32('a')] != 0) || Int32FromUint8(**(**uint8)(__ccgo_up(setting + 3))) != int32('$') || Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(setting + 4)))-int32('0')) > uint32(1) || Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(setting + 5)))-int32('0')) > uint32(9) || Int32FromUint8(**(**uint8)(__ccgo_up(setting + 6))) != int32('$') { return UintptrFromInt32(0) } - count = Uint32FromInt32(1) << ((Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 4)))-int32('0'))*int32(10) + (Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 5))) - int32('0'))) + count = Uint32FromInt32(1) << ((Int32FromUint8(**(**uint8)(__ccgo_up(setting + 4)))-int32('0'))*int32(10) + (Int32FromUint8(**(**uint8)(__ccgo_up(setting + 5))) - int32('0'))) if count < min || _BF_decode(tls, bp+4240, setting+7, int32(16)) != 0 { return UintptrFromInt32(0) } _BF_swap(tls, bp+4240, int32(4)) - _BF_set_key(tls, key, bp+4168, bp, _flags_by_subtype[Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 2)))-int32('a')]) + _BF_set_key(tls, key, bp+4168, bp, _flags_by_subtype[Int32FromUint8(**(**uint8)(__ccgo_up(setting + 2)))-int32('a')]) Xmemcpy(tls, bp+72, uintptr(unsafe.Pointer(&_BF_init_state))+72, uint64(4096)) L = uint32(0) R = uint32(0) ptr = bp for cond := true; cond; cond = int32(1) != 0 { - L = _BF_encrypt(tls, bp, L^*(*TBF_word)(unsafe.Pointer(bp + 4240)), R^*(*TBF_word)(unsafe.Pointer(bp + 4240 + 1*4)), ptr, ptr) - R = *(*TBF_word)(unsafe.Pointer(ptr + UintptrFromInt32(1)*4)) + L = _BF_encrypt(tls, bp, L^**(**TBF_word)(__ccgo_up(bp + 4240)), R^**(**TBF_word)(__ccgo_up(bp + 4240 + 1*4)), ptr, ptr) + R = **(**TBF_word)(__ccgo_up(ptr + UintptrFromInt32(1)*4)) ptr = ptr + uintptr(2)*4 if ptr >= bp+uintptr(Int32FromInt32(BF_N)+Int32FromInt32(2)+Int32FromInt32(4)*Int32FromInt32(0x100))*4 { break } - L = _BF_encrypt(tls, bp, L^*(*TBF_word)(unsafe.Pointer(bp + 4240 + 2*4)), R^*(*TBF_word)(unsafe.Pointer(bp + 4240 + 3*4)), ptr, ptr) - R = *(*TBF_word)(unsafe.Pointer(ptr + UintptrFromInt32(1)*4)) + L = _BF_encrypt(tls, bp, L^**(**TBF_word)(__ccgo_up(bp + 4240 + 2*4)), R^**(**TBF_word)(__ccgo_up(bp + 4240 + 3*4)), ptr, ptr) + R = **(**TBF_word)(__ccgo_up(ptr + UintptrFromInt32(1)*4)) ptr = ptr + uintptr(2)*4 } for { @@ -9274,8 +9274,8 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w if !(i < Int32FromInt32(BF_N)+Int32FromInt32(2)) { break } - *(*TBF_word)(unsafe.Pointer(bp + uintptr(i)*4)) ^= *(*TBF_word)(unsafe.Pointer(bp + 4168 + uintptr(i)*4)) - *(*TBF_word)(unsafe.Pointer(bp + uintptr(i+int32(1))*4)) ^= *(*TBF_word)(unsafe.Pointer(bp + 4168 + uintptr(i+int32(1))*4)) + **(**TBF_word)(__ccgo_up(bp + uintptr(i)*4)) ^= **(**TBF_word)(__ccgo_up(bp + 4168 + uintptr(i)*4)) + **(**TBF_word)(__ccgo_up(bp + uintptr(i+int32(1))*4)) ^= **(**TBF_word)(__ccgo_up(bp + 4168 + uintptr(i+int32(1))*4)) goto _3 _3: ; @@ -9288,26 +9288,26 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w break } done = int32(1) - tmp1 = *(*TBF_word)(unsafe.Pointer(bp + 4240)) - tmp2 = *(*TBF_word)(unsafe.Pointer(bp + 4240 + 1*4)) - tmp3 = *(*TBF_word)(unsafe.Pointer(bp + 4240 + 2*4)) - tmp4 = *(*TBF_word)(unsafe.Pointer(bp + 4240 + 3*4)) + tmp1 = **(**TBF_word)(__ccgo_up(bp + 4240)) + tmp2 = **(**TBF_word)(__ccgo_up(bp + 4240 + 1*4)) + tmp3 = **(**TBF_word)(__ccgo_up(bp + 4240 + 2*4)) + tmp4 = **(**TBF_word)(__ccgo_up(bp + 4240 + 3*4)) i = 0 for { if !(i < int32(BF_N)) { break } - *(*TBF_word)(unsafe.Pointer(bp + uintptr(i)*4)) ^= tmp1 - *(*TBF_word)(unsafe.Pointer(bp + uintptr(i+int32(1))*4)) ^= tmp2 - *(*TBF_word)(unsafe.Pointer(bp + uintptr(i+int32(2))*4)) ^= tmp3 - *(*TBF_word)(unsafe.Pointer(bp + uintptr(i+int32(3))*4)) ^= tmp4 + **(**TBF_word)(__ccgo_up(bp + uintptr(i)*4)) ^= tmp1 + **(**TBF_word)(__ccgo_up(bp + uintptr(i+int32(1))*4)) ^= tmp2 + **(**TBF_word)(__ccgo_up(bp + uintptr(i+int32(2))*4)) ^= tmp3 + **(**TBF_word)(__ccgo_up(bp + uintptr(i+int32(3))*4)) ^= tmp4 goto _4 _4: ; i = i + int32(4) } - *(*TBF_word)(unsafe.Pointer(bp + 16*4)) ^= tmp1 - *(*TBF_word)(unsafe.Pointer(bp + 17*4)) ^= tmp2 + **(**TBF_word)(__ccgo_up(bp + 16*4)) ^= tmp1 + **(**TBF_word)(__ccgo_up(bp + 17*4)) ^= tmp2 } goto _2 _2: @@ -9324,10 +9324,10 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w break } L1 = _BF_magic_w[i] - (*(*[2]TBF_word)(unsafe.Pointer(bp + 4264)))[int32(1)] = _BF_magic_w[i+int32(1)] + (**(**[2]TBF_word)(__ccgo_up(bp + 4264)))[int32(1)] = _BF_magic_w[i+int32(1)] count = uint32(64) for { - L1 = _BF_encrypt(tls, bp, L1, (*(*[2]TBF_word)(unsafe.Pointer(bp + 4264)))[int32(1)], bp+4264, bp+4264) + L1 = _BF_encrypt(tls, bp, L1, (**(**[2]TBF_word)(__ccgo_up(bp + 4264)))[int32(1)], bp+4264, bp+4264) goto _7 _7: ; @@ -9337,20 +9337,20 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w break } } - *(*TBF_word)(unsafe.Pointer(bp + 4240 + uintptr(i)*4)) = L1 - *(*TBF_word)(unsafe.Pointer(bp + 4240 + uintptr(i+int32(1))*4)) = (*(*[2]TBF_word)(unsafe.Pointer(bp + 4264)))[int32(1)] + **(**TBF_word)(__ccgo_up(bp + 4240 + uintptr(i)*4)) = L1 + **(**TBF_word)(__ccgo_up(bp + 4240 + uintptr(i+int32(1))*4)) = (**(**[2]TBF_word)(__ccgo_up(bp + 4264)))[int32(1)] goto _5 _5: ; i = i + int32(2) } Xmemcpy(tls, output, setting, Uint64FromInt32(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1))) - *(*uint8)(unsafe.Pointer(output + uintptr(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1)))) = _BF_itoa64[Int32FromUint8(_BF_atoi64[Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1)))))-int32(0x20)])&int32(0x30)] + **(**uint8)(__ccgo_up(output + uintptr(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1)))) = _BF_itoa64[Int32FromUint8(_BF_atoi64[Int32FromUint8(**(**uint8)(__ccgo_up(setting + uintptr(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1)))))-int32(0x20)])&int32(0x30)] /* This has to be bug-compatible with the original implementation, so * only encode 23 of the 24 bytes. :-) */ _BF_swap(tls, bp+4240, int32(6)) _BF_encode(tls, output+uintptr(Int32FromInt32(7)+Int32FromInt32(22)), bp+4240, int32(23)) - *(*uint8)(unsafe.Pointer(output + uintptr(Int32FromInt32(7)+Int32FromInt32(22)+Int32FromInt32(31)))) = uint8('\000') + **(**uint8)(__ccgo_up(output + uintptr(Int32FromInt32(7)+Int32FromInt32(22)+Int32FromInt32(31)))) = uint8('\000') return output } @@ -9409,19 +9409,19 @@ func X__crypt_blowfish(tls *TLS, key uintptr, setting uintptr, output uintptr) ( */ Xmemcpy(tls, bp, test_setting, uint64(30)) if retval != 0 { - flags = uint32(_flags_by_subtype[Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 2)))-int32('a')]) + flags = uint32(_flags_by_subtype[Int32FromUint8(**(**uint8)(__ccgo_up(setting + 2)))-int32('a')]) test_hash = uintptr(unsafe.Pointer(&_test_hashes)) + uintptr(flags&uint32(1))*34 - *(*uint8)(unsafe.Pointer(bp + 2)) = *(*uint8)(unsafe.Pointer(setting + 2)) + **(**uint8)(__ccgo_up(bp + 2)) = **(**uint8)(__ccgo_up(setting + 2)) } Xmemset(tls, bp+30, int32(0x55), uint64(63)) - *(*uint8)(unsafe.Pointer(bp + 30 + uintptr(Uint64FromInt64(63)-Uint64FromInt32(1)))) = uint8(0) + **(**uint8)(__ccgo_up(bp + 30 + uintptr(Uint64FromInt64(63)-Uint64FromInt32(1)))) = uint8(0) p = _BF_crypt(tls, test_key, bp, bp+30, uint32(1)) ok = BoolInt32(p == bp+30 && !(Xmemcmp(tls, p, bp, Uint64FromInt32(Int32FromInt32(7)+Int32FromInt32(22))) != 0) && !(Xmemcmp(tls, p+uintptr(Int32FromInt32(7)+Int32FromInt32(22)), test_hash, Uint64FromInt32(Int32FromInt32(31)+Int32FromInt32(1)+Int32FromInt32(1)+Int32FromInt32(1))) != 0)) k = __ccgo_ts + 58 - _BF_set_key(tls, k, bp+96, bp+168, uint8(2)) /* $2a$ */ - _BF_set_key(tls, k, bp+240, bp+312, uint8(4)) /* $2y$ */ - *(*TBF_word)(unsafe.Pointer(bp + 168)) ^= uint32(0x10000) /* undo the safety (for comparison) */ - ok = BoolInt32(ok != 0 && (*(*TBF_key)(unsafe.Pointer(bp + 168)))[0] == uint32(0xdb9c59bc) && (*(*TBF_key)(unsafe.Pointer(bp + 240)))[int32(17)] == uint32(0x33343500) && !(Xmemcmp(tls, bp+96, bp+240, uint64(72)) != 0) && !(Xmemcmp(tls, bp+168, bp+312, uint64(72)) != 0)) + _BF_set_key(tls, k, bp+96, bp+168, uint8(2)) /* $2a$ */ + _BF_set_key(tls, k, bp+240, bp+312, uint8(4)) /* $2y$ */ + **(**TBF_word)(__ccgo_up(bp + 168)) ^= uint32(0x10000) /* undo the safety (for comparison) */ + ok = BoolInt32(ok != 0 && (**(**TBF_key)(__ccgo_up(bp + 168)))[0] == uint32(0xdb9c59bc) && (**(**TBF_key)(__ccgo_up(bp + 240)))[int32(17)] == uint32(0x33343500) && !(Xmemcmp(tls, bp+96, bp+240, uint64(72)) != 0) && !(Xmemcmp(tls, bp+168, bp+312, uint64(72)) != 0)) if ok != 0 && retval != 0 { return retval } @@ -11271,8 +11271,8 @@ func X__des_setkey(tls *TLS, key uintptr, ekey uintptr) { var i, ibit, j, round, shifts uint32 var k0, k1, kl, kr, rawkey0, rawkey1, t0, t1, v1 Tuint32_t _, _, _, _, _, _, _, _, _, _, _, _, _, _ = i, ibit, j, k0, k1, kl, kr, rawkey0, rawkey1, round, shifts, t0, t1, v1 - rawkey0 = uint32(*(*uint8)(unsafe.Pointer(key + 3))) | uint32(*(*uint8)(unsafe.Pointer(key + 2)))<>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskl)) + uintptr(i+uint32(4))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4))) - k1 = k1 | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j)*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) + k0 = k0 | (**(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_key_perm_maskl)) + uintptr(i)*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_key_perm_maskl)) + uintptr(i+uint32(4))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4))) + k1 = k1 | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j)*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) ibit = ibit - uint32(4) - k1 = k1 | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j+uint32(1))*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(i+uint32(8))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4))) + k1 = k1 | (**(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j+uint32(1))*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(i+uint32(8))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4))) goto _2 _2: ; @@ -11317,19 +11317,19 @@ func X__des_setkey(tls *TLS, key uintptr, ekey uintptr) { if !(i < uint32(4)) { break } - kl = kl | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskl0)) + uintptr(i)*32 + uintptr(t0>>ibit&uint32(7))*4)) - kr = kr | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskr0)) + uintptr(i)*32 + uintptr(t1>>ibit&uint32(7))*4)) + kl = kl | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_comp_maskl0)) + uintptr(i)*32 + uintptr(t0>>ibit&uint32(7))*4)) + kr = kr | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_comp_maskr0)) + uintptr(i)*32 + uintptr(t1>>ibit&uint32(7))*4)) ibit = ibit - uint32(4) - kl = kl | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskl1)) + uintptr(i)*64 + uintptr(t0>>ibit&uint32(0xf))*4)) - kr = kr | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskr1)) + uintptr(i)*64 + uintptr(t1>>ibit&uint32(0xf))*4)) + kl = kl | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_comp_maskl1)) + uintptr(i)*64 + uintptr(t0>>ibit&uint32(0xf))*4)) + kr = kr | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_comp_maskr1)) + uintptr(i)*64 + uintptr(t1>>ibit&uint32(0xf))*4)) ibit = ibit - uint32(3) goto _5 _5: ; i = i + 1 } - *(*Tuint32_t)(unsafe.Pointer(ekey + uintptr(round)*4)) = kl - *(*Tuint32_t)(unsafe.Pointer(ekey + 64 + uintptr(round)*4)) = kr + **(**Tuint32_t)(__ccgo_up(ekey + uintptr(round)*4)) = kl + **(**Tuint32_t)(__ccgo_up(ekey + 64 + uintptr(round)*4)) = kr goto _3 _3: ; @@ -11363,8 +11363,8 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui if !(i < uint32(8)) { break } - l = l | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4))) - r = r | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4))) + l = l | (**(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4))) + r = r | (**(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4))) goto _2 _2: ; @@ -11402,15 +11402,15 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui f = (r48l ^ r48r) & saltbits v5 = kl kl += 4 - r48l = r48l ^ (f ^ *(*Tuint32_t)(unsafe.Pointer(v5))) + r48l = r48l ^ (f ^ **(**Tuint32_t)(__ccgo_up(v5))) v5 = kr kr += 4 - r48r = r48r ^ (f ^ *(*Tuint32_t)(unsafe.Pointer(v5))) + r48r = r48r ^ (f ^ **(**Tuint32_t)(__ccgo_up(v5))) /* * Do S-box lookups (which shrink it back to 32 bits) * and do the P-box permutation at the same time. */ - f = *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + uintptr(r48l>>int32(18))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 1*256 + uintptr(r48l>>Int32FromInt32(12)&uint32(0x3f))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 2*256 + uintptr(r48l>>Int32FromInt32(6)&uint32(0x3f))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 3*256 + uintptr(r48l&uint32(0x3f))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 4*256 + uintptr(r48r>>int32(18))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 5*256 + uintptr(r48r>>Int32FromInt32(12)&uint32(0x3f))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 6*256 + uintptr(r48r>>Int32FromInt32(6)&uint32(0x3f))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_psbox)) + 7*256 + uintptr(r48r&uint32(0x3f))*4)) + f = **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + uintptr(r48l>>int32(18))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 1*256 + uintptr(r48l>>Int32FromInt32(12)&uint32(0x3f))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 2*256 + uintptr(r48l>>Int32FromInt32(6)&uint32(0x3f))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 3*256 + uintptr(r48l&uint32(0x3f))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 4*256 + uintptr(r48r>>int32(18))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 5*256 + uintptr(r48r>>Int32FromInt32(12)&uint32(0x3f))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 6*256 + uintptr(r48r>>Int32FromInt32(6)&uint32(0x3f))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_psbox)) + 7*256 + uintptr(r48r&uint32(0x3f))*4)) /* * Now that we've permuted things, complete f(). */ @@ -11433,17 +11433,17 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui if !(i1 < uint32(4)) { break } - ro = ro | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4))) + ro = ro | (**(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4))) ibit1 = ibit1 - uint32(4) - lo = lo | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4))) + lo = lo | (**(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4))) goto _8 _8: ; i1 = i1 + 1 ibit1 = ibit1 - uint32(4) } - *(*Tuint32_t)(unsafe.Pointer(l_out)) = lo - *(*Tuint32_t)(unsafe.Pointer(r_out)) = ro + **(**Tuint32_t)(__ccgo_up(l_out)) = lo + **(**Tuint32_t)(__ccgo_up(r_out)) = ro } func _des_cipher(tls *TLS, in uintptr, out uintptr, count Tuint32_t, saltbits Tuint32_t, ekey uintptr) { @@ -11453,17 +11453,17 @@ func _des_cipher(tls *TLS, in uintptr, out uintptr, count Tuint32_t, saltbits Tu var _ /* l_out at bp+0 */ Tuint32_t var _ /* r_out at bp+4 */ Tuint32_t _, _ = rawl, rawr - rawl = uint32(*(*uint8)(unsafe.Pointer(in + 3))) | uint32(*(*uint8)(unsafe.Pointer(in + 2)))<> int32(24)) - *(*uint8)(unsafe.Pointer(out + 1)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp)) >> int32(16)) - *(*uint8)(unsafe.Pointer(out + 2)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp)) >> int32(8)) - *(*uint8)(unsafe.Pointer(out + 3)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp))) - *(*uint8)(unsafe.Pointer(out + 4)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp + 4)) >> int32(24)) - *(*uint8)(unsafe.Pointer(out + 5)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp + 4)) >> int32(16)) - *(*uint8)(unsafe.Pointer(out + 6)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp + 4)) >> int32(8)) - *(*uint8)(unsafe.Pointer(out + 7)) = uint8(*(*Tuint32_t)(unsafe.Pointer(bp + 4))) + **(**uint8)(__ccgo_up(out)) = uint8(**(**Tuint32_t)(__ccgo_up(bp)) >> int32(24)) + **(**uint8)(__ccgo_up(out + 1)) = uint8(**(**Tuint32_t)(__ccgo_up(bp)) >> int32(16)) + **(**uint8)(__ccgo_up(out + 2)) = uint8(**(**Tuint32_t)(__ccgo_up(bp)) >> int32(8)) + **(**uint8)(__ccgo_up(out + 3)) = uint8(**(**Tuint32_t)(__ccgo_up(bp))) + **(**uint8)(__ccgo_up(out + 4)) = uint8(**(**Tuint32_t)(__ccgo_up(bp + 4)) >> int32(24)) + **(**uint8)(__ccgo_up(out + 5)) = uint8(**(**Tuint32_t)(__ccgo_up(bp + 4)) >> int32(16)) + **(**uint8)(__ccgo_up(out + 6)) = uint8(**(**Tuint32_t)(__ccgo_up(bp + 4)) >> int32(8)) + **(**uint8)(__ccgo_up(out + 7)) = uint8(**(**Tuint32_t)(__ccgo_up(bp + 4))) } func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uintptr) (r uintptr) { @@ -11487,13 +11487,13 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin for q <= bp+128+uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) { v1 = q q = q + 1 - *(*uint8)(unsafe.Pointer(v1)) = Uint8FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(key))) << int32(1)) - if *(*uint8)(unsafe.Pointer(key)) != 0 { + **(**uint8)(__ccgo_up(v1)) = Uint8FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(key))) << int32(1)) + if **(**uint8)(__ccgo_up(key)) != 0 { key = key + 1 } } X__des_setkey(tls, bp+128, bp) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(setting))) == int32('_') { + if Int32FromUint8(**(**uint8)(__ccgo_up(setting))) == int32('_') { /* * "new"-style: * setting - underscore, 4 chars of count, 4 chars of salt @@ -11505,8 +11505,8 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin if !(i < uint32(5)) { break } - value = _ascii_to_bin(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(i))))) - if Int32FromUint8(_ascii64[value]) != Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(i)))) { + value = _ascii_to_bin(tls, Int32FromUint8(**(**uint8)(__ccgo_up(setting + uintptr(i))))) + if Int32FromUint8(_ascii64[value]) != Int32FromUint8(**(**uint8)(__ccgo_up(setting + uintptr(i)))) { return UintptrFromInt32(0) } count = count | value<<((i-uint32(1))*uint32(6)) @@ -11524,8 +11524,8 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin if !(i < uint32(9)) { break } - value1 = _ascii_to_bin(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(i))))) - if Int32FromUint8(_ascii64[value1]) != Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(i)))) { + value1 = _ascii_to_bin(tls, Int32FromUint8(**(**uint8)(__ccgo_up(setting + uintptr(i))))) + if Int32FromUint8(_ascii64[value1]) != Int32FromUint8(**(**uint8)(__ccgo_up(setting + uintptr(i)))) { return UintptrFromInt32(0) } salt = salt | value1<<((i-uint32(5))*uint32(6)) @@ -11534,7 +11534,7 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin ; i = i + 1 } - for *(*uint8)(unsafe.Pointer(key)) != 0 { + for **(**uint8)(__ccgo_up(key)) != 0 { /* * Encrypt the key with itself. */ @@ -11543,18 +11543,18 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin * And XOR with the next 8 characters of the key. */ q = bp + 128 - for q <= bp+128+uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) && *(*uint8)(unsafe.Pointer(key)) != 0 { + for q <= bp+128+uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) && **(**uint8)(__ccgo_up(key)) != 0 { v4 = q q = q + 1 v1 = v4 v5 = key key = key + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(int32(*(*uint8)(unsafe.Pointer(v1))) ^ Int32FromUint8(*(*uint8)(unsafe.Pointer(v5)))<> int32(8) + l = **(**Tuint32_t)(__ccgo_up(bp + 136)) >> int32(8) v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l&uint32(0x3f)] - l = *(*Tuint32_t)(unsafe.Pointer(bp + 136))<>Int32FromInt32(16)&uint32(0xffff) + **(**uint8)(__ccgo_up(v1)) = _ascii64[l&uint32(0x3f)] + l = **(**Tuint32_t)(__ccgo_up(bp + 136))<>Int32FromInt32(16)&uint32(0xffff) v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l&uint32(0x3f)] - l = *(*Tuint32_t)(unsafe.Pointer(bp + 140)) << int32(2) + **(**uint8)(__ccgo_up(v1)) = _ascii64[l&uint32(0x3f)] + l = **(**Tuint32_t)(__ccgo_up(bp + 140)) << int32(2) v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] + **(**uint8)(__ccgo_up(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l&uint32(0x3f)] - *(*uint8)(unsafe.Pointer(p)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = _ascii64[l&uint32(0x3f)] + **(**uint8)(__ccgo_up(p)) = uint8(0) return output } @@ -11631,7 +11631,7 @@ func X__crypt_des(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uin test_key = __ccgo_ts + 72 test_setting = __ccgo_ts + 93 test_hash = __ccgo_ts + 103 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(setting))) != int32('_') { + if Int32FromUint8(**(**uint8)(__ccgo_up(setting))) != int32('_') { test_setting = __ccgo_ts + 124 test_hash = __ccgo_ts + 127 } @@ -11650,7 +11650,7 @@ func X__crypt_des(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uin if p != 0 && !(Xstrcmp(tls, p, test_hash) != 0) && retval != 0 { return retval } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(setting))) == int32('*') { + if Int32FromUint8(**(**uint8)(__ccgo_up(setting))) == int32('*') { v1 = __ccgo_ts + 141 } else { v1 = __ccgo_ts + 70 @@ -11751,80 +11751,80 @@ func _processblock(tls *TLS, s uintptr, buf uintptr) { if !(i < uint32(16)) { break } - (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] = uint32(*(*Tuint8_t)(unsafe.Pointer(buf + uintptr(uint32(4)*i)))) - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(i)*4)) |= uint32(*(*Tuint8_t)(unsafe.Pointer(buf + uintptr(uint32(4)*i+uint32(1))))) << int32(8) - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(i)*4)) |= uint32(*(*Tuint8_t)(unsafe.Pointer(buf + uintptr(uint32(4)*i+uint32(2))))) << int32(16) - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(i)*4)) |= uint32(*(*Tuint8_t)(unsafe.Pointer(buf + uintptr(uint32(4)*i+uint32(3))))) << int32(24) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[i] = uint32(**(**Tuint8_t)(__ccgo_up(buf + uintptr(uint32(4)*i)))) + **(**Tuint32_t)(__ccgo_up(bp + uintptr(i)*4)) |= uint32(**(**Tuint8_t)(__ccgo_up(buf + uintptr(uint32(4)*i+uint32(1))))) << int32(8) + **(**Tuint32_t)(__ccgo_up(bp + uintptr(i)*4)) |= uint32(**(**Tuint8_t)(__ccgo_up(buf + uintptr(uint32(4)*i+uint32(2))))) << int32(16) + **(**Tuint32_t)(__ccgo_up(bp + uintptr(i)*4)) |= uint32(**(**Tuint8_t)(__ccgo_up(buf + uintptr(uint32(4)*i+uint32(3))))) << int32(24) goto _1 _1: ; i = i + 1 } - a = *(*Tuint32_t)(unsafe.Pointer(s + 8)) - b = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) - c = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 2*4)) - d = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) + a = **(**Tuint32_t)(__ccgo_up(s + 8)) + b = **(**Tuint32_t)(__ccgo_up(s + 8 + 1*4)) + c = **(**Tuint32_t)(__ccgo_up(s + 8 + 2*4)) + d = **(**Tuint32_t)(__ccgo_up(s + 8 + 3*4)) i = uint32(0) for i < uint32(16) { - a = a + (d ^ b&(c^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) + a = a + (d ^ b&(c^d) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[i] + _tab[i]) a = _rol(tls, a, int32(7)) + b i = i + 1 - d = d + (c ^ a&(b^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) + d = d + (c ^ a&(b^c) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[i] + _tab[i]) d = _rol(tls, d, int32(12)) + a i = i + 1 - c = c + (b ^ d&(a^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) + c = c + (b ^ d&(a^b) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[i] + _tab[i]) c = _rol(tls, c, int32(17)) + d i = i + 1 - b = b + (a ^ c&(d^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) + b = b + (a ^ c&(d^a) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[i] + _tab[i]) b = _rol(tls, b, int32(22)) + c i = i + 1 } for i < uint32(32) { - a = a + (c ^ d&(c^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) + a = a + (c ^ d&(c^b) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) a = _rol(tls, a, int32(5)) + b i = i + 1 - d = d + (b ^ c&(b^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) + d = d + (b ^ c&(b^a) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) d = _rol(tls, d, int32(9)) + a i = i + 1 - c = c + (a ^ b&(a^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) + c = c + (a ^ b&(a^d) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) c = _rol(tls, c, int32(14)) + d i = i + 1 - b = b + (d ^ a&(d^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) + b = b + (d ^ a&(d^c) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) b = _rol(tls, b, int32(20)) + c i = i + 1 } for i < uint32(48) { - a = a + (b ^ c ^ d + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) + a = a + (b ^ c ^ d + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) a = _rol(tls, a, int32(4)) + b i = i + 1 - d = d + (a ^ b ^ c + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) + d = d + (a ^ b ^ c + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) d = _rol(tls, d, int32(11)) + a i = i + 1 - c = c + (d ^ a ^ b + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) + c = c + (d ^ a ^ b + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) c = _rol(tls, c, int32(16)) + d i = i + 1 - b = b + (c ^ d ^ a + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) + b = b + (c ^ d ^ a + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) b = _rol(tls, b, int32(23)) + c i = i + 1 } for i < uint32(64) { - a = a + (c ^ (b | ^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) + a = a + (c ^ (b | ^d) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) a = _rol(tls, a, int32(6)) + b i = i + 1 - d = d + (b ^ (a | ^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) + d = d + (b ^ (a | ^c) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) d = _rol(tls, d, int32(10)) + a i = i + 1 - c = c + (a ^ (d | ^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) + c = c + (a ^ (d | ^b) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) c = _rol(tls, c, int32(15)) + d i = i + 1 - b = b + (d ^ (c | ^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) + b = b + (d ^ (c | ^a) + (**(**[16]Tuint32_t)(__ccgo_up(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) b = _rol(tls, b, int32(21)) + c i = i + 1 } - *(*Tuint32_t)(unsafe.Pointer(s + 8)) += a - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) += b - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 2*4)) += c - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) += d + **(**Tuint32_t)(__ccgo_up(s + 8)) += a + **(**Tuint32_t)(__ccgo_up(s + 8 + 1*4)) += b + **(**Tuint32_t)(__ccgo_up(s + 8 + 2*4)) += c + **(**Tuint32_t)(__ccgo_up(s + 8 + 3*4)) += d } func _pad(tls *TLS, s uintptr) { @@ -11833,31 +11833,31 @@ func _pad(tls *TLS, s uintptr) { r = uint32((*Tmd5)(unsafe.Pointer(s)).Flen1 % uint64(64)) v1 = r r = r + 1 - *(*Tuint8_t)(unsafe.Pointer(s + 24 + uintptr(v1))) = uint8(0x80) + **(**Tuint8_t)(__ccgo_up(s + 24 + uintptr(v1))) = uint8(0x80) if r > uint32(56) { Xmemset(tls, s+24+uintptr(r), 0, uint64(uint32(64)-r)) r = uint32(0) _processblock(tls, s, s+24) } Xmemset(tls, s+24+uintptr(r), 0, uint64(uint32(56)-r)) - *(*Tuint64_t)(unsafe.Pointer(s)) *= uint64(8) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 56)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 57)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(8)) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 58)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(16)) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 59)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(24)) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 60)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(32)) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 61)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(40)) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 62)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(48)) - *(*Tuint8_t)(unsafe.Pointer(s + 24 + 63)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(56)) + **(**Tuint64_t)(__ccgo_up(s)) *= uint64(8) + **(**Tuint8_t)(__ccgo_up(s + 24 + 56)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1) + **(**Tuint8_t)(__ccgo_up(s + 24 + 57)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(8)) + **(**Tuint8_t)(__ccgo_up(s + 24 + 58)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(16)) + **(**Tuint8_t)(__ccgo_up(s + 24 + 59)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(24)) + **(**Tuint8_t)(__ccgo_up(s + 24 + 60)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(32)) + **(**Tuint8_t)(__ccgo_up(s + 24 + 61)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(40)) + **(**Tuint8_t)(__ccgo_up(s + 24 + 62)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(48)) + **(**Tuint8_t)(__ccgo_up(s + 24 + 63)) = uint8((*Tmd5)(unsafe.Pointer(s)).Flen1 >> int32(56)) _processblock(tls, s, s+24) } func _md5_init(tls *TLS, s uintptr) { (*Tmd5)(unsafe.Pointer(s)).Flen1 = uint64(0) - *(*Tuint32_t)(unsafe.Pointer(s + 8)) = uint32(0x67452301) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) = uint32(0xefcdab89) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 2*4)) = uint32(0x98badcfe) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) = uint32(0x10325476) + **(**Tuint32_t)(__ccgo_up(s + 8)) = uint32(0x67452301) + **(**Tuint32_t)(__ccgo_up(s + 8 + 1*4)) = uint32(0xefcdab89) + **(**Tuint32_t)(__ccgo_up(s + 8 + 2*4)) = uint32(0x98badcfe) + **(**Tuint32_t)(__ccgo_up(s + 8 + 3*4)) = uint32(0x10325476) } func _md5_sum(tls *TLS, s uintptr, md uintptr) { @@ -11869,10 +11869,10 @@ func _md5_sum(tls *TLS, s uintptr, md uintptr) { if !(i < int32(4)) { break } - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4))) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i+int32(1)))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4)) >> int32(8)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i+int32(2)))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4)) >> int32(16)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i+int32(3)))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4)) >> int32(24)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4))) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i+int32(1)))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4)) >> int32(8)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i+int32(2)))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4)) >> int32(16)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i+int32(3)))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4)) >> int32(24)) goto _1 _1: ; @@ -11886,7 +11886,7 @@ func _md5_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { _, _ = p, r p = m r = uint32((*Tmd5)(unsafe.Pointer(s)).Flen1 % uint64(64)) - *(*Tuint64_t)(unsafe.Pointer(s)) += len1 + **(**Tuint64_t)(__ccgo_up(s)) += len1 if r != 0 { if len1 < uint64(uint32(64)-r) { Xmemcpy(tls, s+24+uintptr(r), p, len1) @@ -11953,7 +11953,7 @@ func _to64(tls *TLS, s uintptr, u uint32, n int32) (r uintptr) { } v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = _b64[u%uint32(64)] + **(**uint8)(__ccgo_up(v2)) = _b64[u%uint32(64)] u = u / uint32(64) } return s @@ -11979,7 +11979,7 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt salt = setting + uintptr(3) i = uint32(0) for { - if !(i < uint32(SALT_MAX) && *(*uint8)(unsafe.Pointer(salt + uintptr(i))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(salt + uintptr(i)))) != int32('$')) { + if !(i < uint32(SALT_MAX) && **(**uint8)(__ccgo_up(salt + uintptr(i))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(salt + uintptr(i)))) != int32('$')) { break } goto _1 @@ -12010,7 +12010,7 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt i = uint32(uint64(i) - Uint64FromInt64(16)) } _md5_update(tls, bp, bp+88, uint64(i)) - (*(*[16]uint8)(unsafe.Pointer(bp + 88)))[0] = uint8(0) + (**(**[16]uint8)(__ccgo_up(bp + 88)))[0] = uint8(0) i = klen for { if !(i != 0) { @@ -12061,20 +12061,20 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt p = output + uintptr(3) + uintptr(slen) v5 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v5)) = uint8('$') + **(**uint8)(__ccgo_up(v5)) = uint8('$') i = uint32(0) for { if !(i < uint32(5)) { break } - p = _to64(tls, p, Uint32FromInt32(Int32FromUint8((*(*[16]uint8)(unsafe.Pointer(bp + 88)))[*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_perm)) + uintptr(i)*3))])<>Int32FromInt32(10) + (*(*[64]Tuint32_t)(unsafe.Pointer(bp)))[i-int32(7)] + (_ror(tls, (*(*[64]Tuint32_t)(unsafe.Pointer(bp)))[i-int32(15)], int32(7)) ^ _ror(tls, (*(*[64]Tuint32_t)(unsafe.Pointer(bp)))[i-int32(15)], int32(18)) ^ (*(*[64]Tuint32_t)(unsafe.Pointer(bp)))[i-int32(15)]>>Int32FromInt32(3)) + (*(*[64]Tuint32_t)(unsafe.Pointer(bp)))[i-int32(16)] + (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i] = _ror(tls, (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(2)], int32(17)) ^ _ror(tls, (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(2)], int32(19)) ^ (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(2)]>>Int32FromInt32(10) + (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(7)] + (_ror(tls, (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(15)], int32(7)) ^ _ror(tls, (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(15)], int32(18)) ^ (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(15)]>>Int32FromInt32(3)) + (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i-int32(16)] goto _2 _2: ; i = i + 1 } - a = *(*Tuint32_t)(unsafe.Pointer(s + 8)) - b = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) - c = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 2*4)) - d = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) - e = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 4*4)) - f = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 5*4)) - g = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 6*4)) - h = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 7*4)) + a = **(**Tuint32_t)(__ccgo_up(s + 8)) + b = **(**Tuint32_t)(__ccgo_up(s + 8 + 1*4)) + c = **(**Tuint32_t)(__ccgo_up(s + 8 + 2*4)) + d = **(**Tuint32_t)(__ccgo_up(s + 8 + 3*4)) + e = **(**Tuint32_t)(__ccgo_up(s + 8 + 4*4)) + f = **(**Tuint32_t)(__ccgo_up(s + 8 + 5*4)) + g = **(**Tuint32_t)(__ccgo_up(s + 8 + 6*4)) + h = **(**Tuint32_t)(__ccgo_up(s + 8 + 7*4)) i = 0 for { if !(i < int32(64)) { break } - t1 = h + (_ror(tls, e, int32(6)) ^ _ror(tls, e, int32(11)) ^ _ror(tls, e, int32(25))) + (g ^ e&(f^g)) + _K[i] + (*(*[64]Tuint32_t)(unsafe.Pointer(bp)))[i] + t1 = h + (_ror(tls, e, int32(6)) ^ _ror(tls, e, int32(11)) ^ _ror(tls, e, int32(25))) + (g ^ e&(f^g)) + _K[i] + (**(**[64]Tuint32_t)(__ccgo_up(bp)))[i] t2 = _ror(tls, a, int32(2)) ^ _ror(tls, a, int32(13)) ^ _ror(tls, a, int32(22)) + (a&b | c&(a|b)) h = g g = f @@ -12311,14 +12311,14 @@ func _processblock1(tls *TLS, s uintptr, buf uintptr) { ; i = i + 1 } - *(*Tuint32_t)(unsafe.Pointer(s + 8)) += a - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) += b - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 2*4)) += c - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) += d - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 4*4)) += e - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 5*4)) += f - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 6*4)) += g - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 7*4)) += h + **(**Tuint32_t)(__ccgo_up(s + 8)) += a + **(**Tuint32_t)(__ccgo_up(s + 8 + 1*4)) += b + **(**Tuint32_t)(__ccgo_up(s + 8 + 2*4)) += c + **(**Tuint32_t)(__ccgo_up(s + 8 + 3*4)) += d + **(**Tuint32_t)(__ccgo_up(s + 8 + 4*4)) += e + **(**Tuint32_t)(__ccgo_up(s + 8 + 5*4)) += f + **(**Tuint32_t)(__ccgo_up(s + 8 + 6*4)) += g + **(**Tuint32_t)(__ccgo_up(s + 8 + 7*4)) += h } func _pad1(tls *TLS, s uintptr) { @@ -12327,35 +12327,35 @@ func _pad1(tls *TLS, s uintptr) { r = uint32((*Tsha256)(unsafe.Pointer(s)).Flen1 % uint64(64)) v1 = r r = r + 1 - *(*Tuint8_t)(unsafe.Pointer(s + 40 + uintptr(v1))) = uint8(0x80) + **(**Tuint8_t)(__ccgo_up(s + 40 + uintptr(v1))) = uint8(0x80) if r > uint32(56) { Xmemset(tls, s+40+uintptr(r), 0, uint64(uint32(64)-r)) r = uint32(0) _processblock1(tls, s, s+40) } Xmemset(tls, s+40+uintptr(r), 0, uint64(uint32(56)-r)) - *(*Tuint64_t)(unsafe.Pointer(s)) *= uint64(8) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 56)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(56)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 57)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(48)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 58)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(40)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 59)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(32)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 60)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(24)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 61)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(16)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 62)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(8)) - *(*Tuint8_t)(unsafe.Pointer(s + 40 + 63)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1) + **(**Tuint64_t)(__ccgo_up(s)) *= uint64(8) + **(**Tuint8_t)(__ccgo_up(s + 40 + 56)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(56)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 57)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(48)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 58)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(40)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 59)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(32)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 60)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(24)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 61)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(16)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 62)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1 >> int32(8)) + **(**Tuint8_t)(__ccgo_up(s + 40 + 63)) = uint8((*Tsha256)(unsafe.Pointer(s)).Flen1) _processblock1(tls, s, s+40) } func _sha256_init(tls *TLS, s uintptr) { (*Tsha256)(unsafe.Pointer(s)).Flen1 = uint64(0) - *(*Tuint32_t)(unsafe.Pointer(s + 8)) = uint32(0x6a09e667) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) = uint32(0xbb67ae85) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 2*4)) = uint32(0x3c6ef372) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) = uint32(0xa54ff53a) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 4*4)) = uint32(0x510e527f) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 5*4)) = uint32(0x9b05688c) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 6*4)) = uint32(0x1f83d9ab) - *(*Tuint32_t)(unsafe.Pointer(s + 8 + 7*4)) = uint32(0x5be0cd19) + **(**Tuint32_t)(__ccgo_up(s + 8)) = uint32(0x6a09e667) + **(**Tuint32_t)(__ccgo_up(s + 8 + 1*4)) = uint32(0xbb67ae85) + **(**Tuint32_t)(__ccgo_up(s + 8 + 2*4)) = uint32(0x3c6ef372) + **(**Tuint32_t)(__ccgo_up(s + 8 + 3*4)) = uint32(0xa54ff53a) + **(**Tuint32_t)(__ccgo_up(s + 8 + 4*4)) = uint32(0x510e527f) + **(**Tuint32_t)(__ccgo_up(s + 8 + 5*4)) = uint32(0x9b05688c) + **(**Tuint32_t)(__ccgo_up(s + 8 + 6*4)) = uint32(0x1f83d9ab) + **(**Tuint32_t)(__ccgo_up(s + 8 + 7*4)) = uint32(0x5be0cd19) } func _sha256_sum(tls *TLS, s uintptr, md uintptr) { @@ -12367,10 +12367,10 @@ func _sha256_sum(tls *TLS, s uintptr, md uintptr) { if !(i < int32(8)) { break } - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4)) >> int32(24)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i+int32(1)))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4)) >> int32(16)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i+int32(2)))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4)) >> int32(8)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(4)*i+int32(3)))) = uint8(*(*Tuint32_t)(unsafe.Pointer(s + 8 + uintptr(i)*4))) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4)) >> int32(24)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i+int32(1)))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4)) >> int32(16)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i+int32(2)))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4)) >> int32(8)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(4)*i+int32(3)))) = uint8(**(**Tuint32_t)(__ccgo_up(s + 8 + uintptr(i)*4))) goto _1 _1: ; @@ -12384,7 +12384,7 @@ func _sha256_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { _, _ = p, r p = m r = uint32((*Tsha256)(unsafe.Pointer(s)).Flen1 % uint64(64)) - *(*Tuint64_t)(unsafe.Pointer(s)) += len1 + **(**Tuint64_t)(__ccgo_up(s)) += len1 if r != 0 { if len1 < uint64(uint32(64)-r) { Xmemcpy(tls, s+40+uintptr(r), p, len1) @@ -12423,7 +12423,7 @@ func _to641(tls *TLS, s uintptr, u uint32, n int32) (r uintptr) { } v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = _b641[u%uint32(64)] + **(**uint8)(__ccgo_up(v2)) = _b641[u%uint32(64)] u = u / uint32(64) } return s @@ -12466,7 +12466,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui var _ /* rounds at bp+200 */ [20]uint8 var _ /* smd at bp+168 */ [32]uint8 _, _, _, _, _, _, _ = i, klen, p, r, salt, slen, u - *(*[20]uint8)(unsafe.Pointer(bp + 200)) = [20]uint8{} + **(**[20]uint8)(__ccgo_up(bp + 200)) = [20]uint8{} /* reject large keys */ klen = uint32(Xstrnlen(tls, key, Uint64FromInt32(Int32FromInt32(KEY_MAX1)+Int32FromInt32(1)))) if klen > uint32(KEY_MAX1) { @@ -12492,14 +12492,14 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui * the host's value of ULONG_MAX. */ salt = salt + uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(salt)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(salt)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } u = Xstrtoul(tls, salt, bp+224, int32(10)) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 224))))) != int32('$') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 224))))) != int32('$') { return uintptr(0) } - salt = *(*uintptr)(unsafe.Pointer(bp + 224)) + uintptr(1) + salt = **(**uintptr)(__ccgo_up(bp + 224)) + uintptr(1) if u < uint64(ROUNDS_MIN) { r = uint32(ROUNDS_MIN) } else { @@ -12514,11 +12514,11 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui } i = uint32(0) for { - if !(i < uint32(SALT_MAX1) && *(*uint8)(unsafe.Pointer(salt + uintptr(i))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(salt + uintptr(i)))) != int32('$')) { + if !(i < uint32(SALT_MAX1) && **(**uint8)(__ccgo_up(salt + uintptr(i))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(salt + uintptr(i)))) != int32('$')) { break } /* reject characters that interfere with /etc/shadow parsing */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(salt + uintptr(i)))) == int32('\n') || Int32FromUint8(*(*uint8)(unsafe.Pointer(salt + uintptr(i)))) == int32(':') { + if Int32FromUint8(**(**uint8)(__ccgo_up(salt + uintptr(i)))) == int32('\n') || Int32FromUint8(**(**uint8)(__ccgo_up(salt + uintptr(i)))) == int32(':') { return uintptr(0) } goto _1 @@ -12572,7 +12572,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui _sha256_init(tls, bp) i = uint32(0) for { - if !(i < Uint32FromInt32(int32(16)+Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp + 104)))[0]))) { + if !(i < Uint32FromInt32(int32(16)+Int32FromUint8((**(**[32]uint8)(__ccgo_up(bp + 104)))[0]))) { break } _sha256_update(tls, bp, salt, uint64(slen)) @@ -12619,14 +12619,14 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui if !(i < uint32(10)) { break } - p = _to641(tls, p, Uint32FromInt32(Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp + 104)))[*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_perm1)) + uintptr(i)*3))])<>Int32FromInt32(6) + (*(*[80]Tuint64_t)(unsafe.Pointer(bp)))[i-int32(7)] + (_ror1(tls, (*(*[80]Tuint64_t)(unsafe.Pointer(bp)))[i-int32(15)], int32(1)) ^ _ror1(tls, (*(*[80]Tuint64_t)(unsafe.Pointer(bp)))[i-int32(15)], int32(8)) ^ (*(*[80]Tuint64_t)(unsafe.Pointer(bp)))[i-int32(15)]>>Int32FromInt32(7)) + (*(*[80]Tuint64_t)(unsafe.Pointer(bp)))[i-int32(16)] + (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i] = _ror1(tls, (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(2)], int32(19)) ^ _ror1(tls, (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(2)], int32(61)) ^ (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(2)]>>Int32FromInt32(6) + (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(7)] + (_ror1(tls, (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(15)], int32(1)) ^ _ror1(tls, (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(15)], int32(8)) ^ (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(15)]>>Int32FromInt32(7)) + (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i-int32(16)] goto _2 _2: ; i = i + 1 } - a = *(*Tuint64_t)(unsafe.Pointer(s + 8)) - b = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 1*8)) - c = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 2*8)) - d = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 3*8)) - e = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 4*8)) - f = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 5*8)) - g = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 6*8)) - h = *(*Tuint64_t)(unsafe.Pointer(s + 8 + 7*8)) + a = **(**Tuint64_t)(__ccgo_up(s + 8)) + b = **(**Tuint64_t)(__ccgo_up(s + 8 + 1*8)) + c = **(**Tuint64_t)(__ccgo_up(s + 8 + 2*8)) + d = **(**Tuint64_t)(__ccgo_up(s + 8 + 3*8)) + e = **(**Tuint64_t)(__ccgo_up(s + 8 + 4*8)) + f = **(**Tuint64_t)(__ccgo_up(s + 8 + 5*8)) + g = **(**Tuint64_t)(__ccgo_up(s + 8 + 6*8)) + h = **(**Tuint64_t)(__ccgo_up(s + 8 + 7*8)) i = 0 for { if !(i < int32(80)) { break } - t1 = h + (_ror1(tls, e, int32(14)) ^ _ror1(tls, e, int32(18)) ^ _ror1(tls, e, int32(41))) + (g ^ e&(f^g)) + _K1[i] + (*(*[80]Tuint64_t)(unsafe.Pointer(bp)))[i] + t1 = h + (_ror1(tls, e, int32(14)) ^ _ror1(tls, e, int32(18)) ^ _ror1(tls, e, int32(41))) + (g ^ e&(f^g)) + _K1[i] + (**(**[80]Tuint64_t)(__ccgo_up(bp)))[i] t2 = _ror1(tls, a, int32(28)) ^ _ror1(tls, a, int32(34)) ^ _ror1(tls, a, int32(39)) + (a&b | c&(a|b)) h = g g = f @@ -12866,14 +12866,14 @@ func _processblock2(tls *TLS, s uintptr, buf uintptr) { ; i = i + 1 } - *(*Tuint64_t)(unsafe.Pointer(s + 8)) += a - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 1*8)) += b - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 2*8)) += c - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 3*8)) += d - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 4*8)) += e - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 5*8)) += f - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 6*8)) += g - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 7*8)) += h + **(**Tuint64_t)(__ccgo_up(s + 8)) += a + **(**Tuint64_t)(__ccgo_up(s + 8 + 1*8)) += b + **(**Tuint64_t)(__ccgo_up(s + 8 + 2*8)) += c + **(**Tuint64_t)(__ccgo_up(s + 8 + 3*8)) += d + **(**Tuint64_t)(__ccgo_up(s + 8 + 4*8)) += e + **(**Tuint64_t)(__ccgo_up(s + 8 + 5*8)) += f + **(**Tuint64_t)(__ccgo_up(s + 8 + 6*8)) += g + **(**Tuint64_t)(__ccgo_up(s + 8 + 7*8)) += h } func _pad2(tls *TLS, s uintptr) { @@ -12882,35 +12882,35 @@ func _pad2(tls *TLS, s uintptr) { r = uint32((*Tsha512)(unsafe.Pointer(s)).Flen1 % uint64(128)) v1 = r r = r + 1 - *(*Tuint8_t)(unsafe.Pointer(s + 72 + uintptr(v1))) = uint8(0x80) + **(**Tuint8_t)(__ccgo_up(s + 72 + uintptr(v1))) = uint8(0x80) if r > uint32(112) { Xmemset(tls, s+72+uintptr(r), 0, uint64(uint32(128)-r)) r = uint32(0) _processblock2(tls, s, s+72) } Xmemset(tls, s+72+uintptr(r), 0, uint64(uint32(120)-r)) - *(*Tuint64_t)(unsafe.Pointer(s)) *= uint64(8) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 120)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(56)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 121)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(48)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 122)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(40)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 123)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(32)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 124)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(24)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 125)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(16)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 126)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(8)) - *(*Tuint8_t)(unsafe.Pointer(s + 72 + 127)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1) + **(**Tuint64_t)(__ccgo_up(s)) *= uint64(8) + **(**Tuint8_t)(__ccgo_up(s + 72 + 120)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(56)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 121)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(48)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 122)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(40)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 123)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(32)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 124)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(24)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 125)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(16)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 126)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1 >> int32(8)) + **(**Tuint8_t)(__ccgo_up(s + 72 + 127)) = uint8((*Tsha512)(unsafe.Pointer(s)).Flen1) _processblock2(tls, s, s+72) } func _sha512_init(tls *TLS, s uintptr) { (*Tsha512)(unsafe.Pointer(s)).Flen1 = uint64(0) - *(*Tuint64_t)(unsafe.Pointer(s + 8)) = uint64(0x6a09e667f3bcc908) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 1*8)) = uint64(0xbb67ae8584caa73b) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 2*8)) = uint64(0x3c6ef372fe94f82b) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 3*8)) = uint64(0xa54ff53a5f1d36f1) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 4*8)) = uint64(0x510e527fade682d1) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 5*8)) = uint64(0x9b05688c2b3e6c1f) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 6*8)) = uint64(0x1f83d9abfb41bd6b) - *(*Tuint64_t)(unsafe.Pointer(s + 8 + 7*8)) = uint64(0x5be0cd19137e2179) + **(**Tuint64_t)(__ccgo_up(s + 8)) = uint64(0x6a09e667f3bcc908) + **(**Tuint64_t)(__ccgo_up(s + 8 + 1*8)) = uint64(0xbb67ae8584caa73b) + **(**Tuint64_t)(__ccgo_up(s + 8 + 2*8)) = uint64(0x3c6ef372fe94f82b) + **(**Tuint64_t)(__ccgo_up(s + 8 + 3*8)) = uint64(0xa54ff53a5f1d36f1) + **(**Tuint64_t)(__ccgo_up(s + 8 + 4*8)) = uint64(0x510e527fade682d1) + **(**Tuint64_t)(__ccgo_up(s + 8 + 5*8)) = uint64(0x9b05688c2b3e6c1f) + **(**Tuint64_t)(__ccgo_up(s + 8 + 6*8)) = uint64(0x1f83d9abfb41bd6b) + **(**Tuint64_t)(__ccgo_up(s + 8 + 7*8)) = uint64(0x5be0cd19137e2179) } func _sha512_sum(tls *TLS, s uintptr, md uintptr) { @@ -12922,14 +12922,14 @@ func _sha512_sum(tls *TLS, s uintptr, md uintptr) { if !(i < int32(8)) { break } - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(56)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(1)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(48)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(2)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(40)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(3)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(32)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(4)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(24)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(5)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(16)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(6)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8)) >> int32(8)) - *(*Tuint8_t)(unsafe.Pointer(md + uintptr(int32(8)*i+int32(7)))) = uint8(*(*Tuint64_t)(unsafe.Pointer(s + 8 + uintptr(i)*8))) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(56)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(1)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(48)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(2)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(40)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(3)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(32)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(4)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(24)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(5)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(16)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(6)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8)) >> int32(8)) + **(**Tuint8_t)(__ccgo_up(md + uintptr(int32(8)*i+int32(7)))) = uint8(**(**Tuint64_t)(__ccgo_up(s + 8 + uintptr(i)*8))) goto _1 _1: ; @@ -12943,7 +12943,7 @@ func _sha512_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { _, _ = p, r p = m r = uint32((*Tsha512)(unsafe.Pointer(s)).Flen1 % uint64(128)) - *(*Tuint64_t)(unsafe.Pointer(s)) += len1 + **(**Tuint64_t)(__ccgo_up(s)) += len1 if r != 0 { if len1 < uint64(uint32(128)-r) { Xmemcpy(tls, s+72+uintptr(r), p, len1) @@ -12982,7 +12982,7 @@ func _to642(tls *TLS, s uintptr, u uint32, n int32) (r uintptr) { } v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = _b642[u%uint32(64)] + **(**uint8)(__ccgo_up(v2)) = _b642[u%uint32(64)] u = u / uint32(64) } return s @@ -13025,11 +13025,11 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui var _ /* rounds at bp+392 */ [20]uint8 var _ /* smd at bp+328 */ [64]uint8 _, _, _, _, _, _, _ = i, klen, p, r, salt, slen, u - *(*[20]uint8)(unsafe.Pointer(bp + 392)) = [20]uint8{} + **(**[20]uint8)(__ccgo_up(bp + 392)) = [20]uint8{} /* reject large keys */ i = uint32(0) for { - if !(i <= uint32(KEY_MAX1) && *(*uint8)(unsafe.Pointer(key + uintptr(i))) != 0) { + if !(i <= uint32(KEY_MAX1) && **(**uint8)(__ccgo_up(key + uintptr(i))) != 0) { break } goto _1 @@ -13061,14 +13061,14 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui * the host's value of ULONG_MAX. */ salt = salt + uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(salt)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(salt)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } u = Xstrtoul(tls, salt, bp+416, int32(10)) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 416))))) != int32('$') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 416))))) != int32('$') { return uintptr(0) } - salt = *(*uintptr)(unsafe.Pointer(bp + 416)) + uintptr(1) + salt = **(**uintptr)(__ccgo_up(bp + 416)) + uintptr(1) if u < uint64(ROUNDS_MIN) { r = uint32(ROUNDS_MIN) } else { @@ -13083,11 +13083,11 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui } i = uint32(0) for { - if !(i < uint32(SALT_MAX1) && *(*uint8)(unsafe.Pointer(salt + uintptr(i))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(salt + uintptr(i)))) != int32('$')) { + if !(i < uint32(SALT_MAX1) && **(**uint8)(__ccgo_up(salt + uintptr(i))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(salt + uintptr(i)))) != int32('$')) { break } /* reject characters that interfere with /etc/shadow parsing */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(salt + uintptr(i)))) == int32('\n') || Int32FromUint8(*(*uint8)(unsafe.Pointer(salt + uintptr(i)))) == int32(':') { + if Int32FromUint8(**(**uint8)(__ccgo_up(salt + uintptr(i)))) == int32('\n') || Int32FromUint8(**(**uint8)(__ccgo_up(salt + uintptr(i)))) == int32(':') { return uintptr(0) } goto _2 @@ -13141,7 +13141,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui _sha512_init(tls, bp) i = uint32(0) for { - if !(i < Uint32FromInt32(int32(16)+Int32FromUint8((*(*[64]uint8)(unsafe.Pointer(bp + 200)))[0]))) { + if !(i < Uint32FromInt32(int32(16)+Int32FromUint8((**(**[64]uint8)(__ccgo_up(bp + 200)))[0]))) { break } _sha512_update(tls, bp, salt, uint64(slen)) @@ -13188,14 +13188,14 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui if !(i < uint32(21)) { break } - p = _to642(tls, p, Uint32FromInt32(Int32FromUint8((*(*[64]uint8)(unsafe.Pointer(bp + 200)))[*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_perm2)) + uintptr(i)*3))])<= 0) { break } v3 = bp + uintptr(i) - *(*uint8)(unsafe.Pointer(v3)) = uint8(uint32(*(*uint8)(unsafe.Pointer(v3))) | Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(key)))&Int32FromInt32(1))<= 0) { break } - *(*Tuint32_t)(unsafe.Pointer(bp + 128 + uintptr(i)*4)) |= Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))&Int32FromInt32(1)) << j + **(**Tuint32_t)(__ccgo_up(bp + 128 + uintptr(i)*4)) |= Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(p)))&Int32FromInt32(1)) << j goto _2 _2: ; @@ -13413,15 +13413,15 @@ func Xencrypt(tls *TLS, block uintptr, edflag int32) { if !(i < int32(16)) { break } - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(i)*4)) = *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&___encrypt_key)) + uintptr(int32(15)-i)*4)) - *(*Tuint32_t)(unsafe.Pointer(bp + 64 + uintptr(i)*4)) = *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&___encrypt_key)) + 64 + uintptr(int32(15)-i)*4)) + **(**Tuint32_t)(__ccgo_up(bp + uintptr(i)*4)) = **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&___encrypt_key)) + uintptr(int32(15)-i)*4)) + **(**Tuint32_t)(__ccgo_up(bp + 64 + uintptr(i)*4)) = **(**Tuint32_t)(__ccgo_up(uintptr(unsafe.Pointer(&___encrypt_key)) + 64 + uintptr(int32(15)-i)*4)) goto _3 _3: ; i = i + 1 } } - X__do_des(tls, (*(*[2]Tuint32_t)(unsafe.Pointer(bp + 128)))[0], (*(*[2]Tuint32_t)(unsafe.Pointer(bp + 128)))[int32(1)], bp+128, bp+128+uintptr(1)*4, uint32(1), uint32(0), key) + X__do_des(tls, (**(**[2]Tuint32_t)(__ccgo_up(bp + 128)))[0], (**(**[2]Tuint32_t)(__ccgo_up(bp + 128)))[int32(1)], bp+128, bp+128+uintptr(1)*4, uint32(1), uint32(0), key) p = block i = 0 for { @@ -13435,7 +13435,7 @@ func Xencrypt(tls *TLS, block uintptr, edflag int32) { } v6 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v6)) = uint8((*(*[2]Tuint32_t)(unsafe.Pointer(bp + 128)))[i] >> j & uint32(1)) + **(**uint8)(__ccgo_up(v6)) = uint8((**(**[2]Tuint32_t)(__ccgo_up(bp + 128)))[i] >> j & uint32(1)) goto _5 _5: ; @@ -13910,7 +13910,7 @@ func X__ctype_get_mb_cur_max(tls *TLS) (r Tsize_t) { } var v1 int32 _ = v1 - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v1 = int32(4) } else { v1 = int32(1) @@ -17474,10 +17474,10 @@ func Xwctype(tls *TLS, s uintptr) (r Twctype_t) { i = int32(1) p = uintptr(unsafe.Pointer(&_names)) for { - if !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if !(**(**uint8)(__ccgo_up(p)) != 0) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) && !(Xstrcmp(tls, s, p) != 0) { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == Int32FromUint8(**(**uint8)(__ccgo_up(p))) && !(Xstrcmp(tls, s, p) != 0) { return Uint64FromInt32(i) } goto _1 @@ -22223,9 +22223,9 @@ func _casemap(tls *TLS, c uint32, dir int32) (r1 int32) { xn = Uint32FromInt32(rd & int32(0xff)) xb = Uint32FromInt32(rd) >> int32(8) for xn != 0 { - try = uint32(*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_exceptions)) + uintptr(xb+xn/uint32(2))*2))) + try = uint32(**(**uint8)(__ccgo_up(uintptr(unsafe.Pointer(&_exceptions)) + uintptr(xb+xn/uint32(2))*2))) if try == c { - r = _rules[*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_exceptions)) + uintptr(xb+xn/uint32(2))*2 + 1))] + r = _rules[**(**uint8)(__ccgo_up(uintptr(unsafe.Pointer(&_exceptions)) + uintptr(xb+xn/uint32(2))*2 + 1))] rt = Uint32FromInt32(r & int32(255)) rd = r >> int32(8) if rt < uint32(2) { @@ -22318,8 +22318,8 @@ func Xwcswidth(tls *TLS, wcs uintptr, n Tsize_t) (r int32) { for { v2 = n n = n - 1 - if v4 = v2 != 0 && *(*Twchar_t)(unsafe.Pointer(wcs)) != 0; v4 { - v3 = Xwcwidth(tls, *(*Twchar_t)(unsafe.Pointer(wcs))) + if v4 = v2 != 0 && **(**Twchar_t)(__ccgo_up(wcs)) != 0; v4 { + v3 = Xwcwidth(tls, **(**Twchar_t)(__ccgo_up(wcs))) k = v3 } if !(v4 && v3 >= 0) { @@ -24519,7 +24519,7 @@ func Xalphasort(tls *TLS, a uintptr, b uintptr) (r int32) { trc("tls=%v a=%v b=%v, (%v:)", tls, a, b, origin(2)) defer func() { trc("-> %v", r) }() } - return Xstrcoll(tls, *(*uintptr)(unsafe.Pointer(a))+19, *(*uintptr)(unsafe.Pointer(b))+19) + return Xstrcoll(tls, **(**uintptr)(__ccgo_up(a))+19, **(**uintptr)(__ccgo_up(b))+19) } type TDIR = struct { @@ -24686,11 +24686,11 @@ func Xfdopendir(tls *TLS, fd int32) (r uintptr) { return uintptr(0) } if Xfcntl(tls, fd, int32(F_GETFL), 0)&int32(O_PATH) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EBADF) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EBADF) return uintptr(0) } - if !((*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&Uint32FromInt32(S_IFMT) == Uint32FromInt32(S_IFDIR)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOTDIR) + if !((**(**Tstat)(__ccgo_up(bp))).Fst_mode&Uint32FromInt32(S_IFMT) == Uint32FromInt32(S_IFDIR)) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOTDIR) return uintptr(0) } v1 = Xcalloc(tls, uint64(1), uint64(2072)) @@ -24825,7 +24825,7 @@ func Xreaddir(tls *TLS, dir uintptr) (r uintptr) { len1 = int32(X__syscall3(tls, int64(SYS_getdents64), int64((*TDIR)(unsafe.Pointer(dir)).Ffd), int64(dir+24), Int64FromUint64(Uint64FromInt64(2048)))) if len1 <= 0 { if len1 < 0 && len1 != -int32(ENOENT) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = -len1 + **(**int32)(__ccgo_up(X__errno_location(tls))) = -len1 } return uintptr(0) } @@ -24833,7 +24833,7 @@ func Xreaddir(tls *TLS, dir uintptr) (r uintptr) { (*TDIR)(unsafe.Pointer(dir)).Fbuf_pos = 0 } de = dir + 24 + uintptr((*TDIR)(unsafe.Pointer(dir)).Fbuf_pos) - *(*int32)(unsafe.Pointer(dir + 12)) += Int32FromUint16((*Tdirent)(unsafe.Pointer(de)).Fd_reclen) + **(**int32)(__ccgo_up(dir + 12)) += Int32FromUint16((*Tdirent)(unsafe.Pointer(de)).Fd_reclen) (*TDIR)(unsafe.Pointer(dir)).Ftell = (*Tdirent)(unsafe.Pointer(de)).Fd_off return de } @@ -24846,24 +24846,24 @@ func Xreaddir_r(tls *TLS, dir uintptr, buf uintptr, result uintptr) (r int32) { var de uintptr var errno_save, ret, v1 int32 _, _, _, _ = de, errno_save, ret, v1 - errno_save = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + errno_save = **(**int32)(__ccgo_up(X__errno_location(tls))) ___lock(tls, dir+20) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = 0 + **(**int32)(__ccgo_up(X__errno_location(tls))) = 0 de = Xreaddir(tls, dir) - v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = **(**int32)(__ccgo_up(X__errno_location(tls))) ret = v1 if v1 != 0 { ___unlock(tls, dir+20) return ret } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = errno_save + **(**int32)(__ccgo_up(X__errno_location(tls))) = errno_save if de != 0 { Xmemcpy(tls, buf, de, uint64((*Tdirent)(unsafe.Pointer(de)).Fd_reclen)) } else { buf = UintptrFromInt32(0) } ___unlock(tls, dir+20) - *(*uintptr)(unsafe.Pointer(result)) = buf + **(**uintptr)(__ccgo_up(result)) = buf return 0 } @@ -24899,12 +24899,12 @@ func Xscandir(tls *TLS, path uintptr, res uintptr, __ccgo_fp_sel uintptr, __ccgo names = uintptr(0) cnt = uint64(0) len1 = uint64(0) - old_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + old_errno = **(**int32)(__ccgo_up(X__errno_location(tls))) if !(d != 0) { return -int32(1) } for { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = 0 + **(**int32)(__ccgo_up(X__errno_location(tls))) = 0 v1 = Xreaddir(tls, d) de = v1 if !(v1 != 0) { @@ -24924,16 +24924,16 @@ func Xscandir(tls *TLS, path uintptr, res uintptr, __ccgo_fp_sel uintptr, __ccgo } names = tmp } - *(*uintptr)(unsafe.Pointer(names + uintptr(cnt)*8)) = Xmalloc(tls, uint64((*Tdirent)(unsafe.Pointer(de)).Fd_reclen)) - if !(*(*uintptr)(unsafe.Pointer(names + uintptr(cnt)*8)) != 0) { + **(**uintptr)(__ccgo_up(names + uintptr(cnt)*8)) = Xmalloc(tls, uint64((*Tdirent)(unsafe.Pointer(de)).Fd_reclen)) + if !(**(**uintptr)(__ccgo_up(names + uintptr(cnt)*8)) != 0) { break } v2 = cnt cnt = cnt + 1 - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(names + uintptr(v2)*8)), de, uint64((*Tdirent)(unsafe.Pointer(de)).Fd_reclen)) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(names + uintptr(v2)*8)), de, uint64((*Tdirent)(unsafe.Pointer(de)).Fd_reclen)) } Xclosedir(tls, d) - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != 0 { + if **(**int32)(__ccgo_up(X__errno_location(tls))) != 0 { if names != 0 { for { v2 = cnt @@ -24941,17 +24941,17 @@ func Xscandir(tls *TLS, path uintptr, res uintptr, __ccgo_fp_sel uintptr, __ccgo if !(v2 > uint64(0)) { break } - Xfree(tls, *(*uintptr)(unsafe.Pointer(names + uintptr(cnt)*8))) + Xfree(tls, **(**uintptr)(__ccgo_up(names + uintptr(cnt)*8))) } } Xfree(tls, names) return -int32(1) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = old_errno + **(**int32)(__ccgo_up(X__errno_location(tls))) = old_errno if __ccgo_fp_cmp != 0 { Xqsort(tls, names, cnt, uint64(8), __ccgo_fp_cmp) } - *(*uintptr)(unsafe.Pointer(res)) = names + **(**uintptr)(__ccgo_up(res)) = names return Int32FromUint64(cnt) } @@ -24982,7 +24982,7 @@ func Xversionsort(tls *TLS, a uintptr, b uintptr) (r int32) { trc("tls=%v a=%v b=%v, (%v:)", tls, a, b, origin(2)) defer func() { trc("-> %v", r) }() } - return Xstrverscmp(tls, *(*uintptr)(unsafe.Pointer(a))+19, *(*uintptr)(unsafe.Pointer(b))+19) + return Xstrverscmp(tls, **(**uintptr)(__ccgo_up(a))+19, **(**uintptr)(__ccgo_up(b))+19) } func X__reset_tls(tls *TLS) { @@ -24994,7 +24994,7 @@ func X__reset_tls(tls *TLS) { var self Tpthread_t _, _, _, _, _ = i, mem, n, p, self self = uintptr(___get_tp(tls)) - n = *(*Tuintptr_t)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(self)).Fdtv)) + n = **(**Tuintptr_t)(__ccgo_up((*t__pthread)(unsafe.Pointer(self)).Fdtv)) if n != 0 { p = X__libc.Ftls_head i = Uint64FromInt32(1) @@ -25002,7 +25002,7 @@ func X__reset_tls(tls *TLS) { if !(i <= n) { break } - mem = uintptr(*(*Tuintptr_t)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(self)).Fdtv + uintptr(i)*8)) - Uint64FromInt32(DTP_OFFSET)) + mem = uintptr(**(**Tuintptr_t)(__ccgo_up((*t__pthread)(unsafe.Pointer(self)).Fdtv + uintptr(i)*8)) - Uint64FromInt32(DTP_OFFSET)) Xmemcpy(tls, mem, (*Ttls_module)(unsafe.Pointer(p)).Fimage, (*Ttls_module)(unsafe.Pointer(p)).Flen1) Xmemset(tls, mem+uintptr((*Ttls_module)(unsafe.Pointer(p)).Flen1), 0, (*Ttls_module)(unsafe.Pointer(p)).Fsize-(*Ttls_module)(unsafe.Pointer(p)).Flen1) goto _1 @@ -25028,7 +25028,7 @@ func X__init_ssp(tls *TLS, entropy uintptr) { * The NULL byte is on the second byte so that off-by-ones can * still be detected. Endianness is taken care of * automatically. */ - *(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stack_chk_guard)) + 1)) = uint8(0) + **(**uint8)(__ccgo_up(uintptr(unsafe.Pointer(&X__stack_chk_guard)) + 1)) = uint8(0) (*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Fcanary = X__stack_chk_guard } @@ -25064,10 +25064,10 @@ func Xclearenv(tls *TLS) (r int32) { e = Xenviron Xenviron = uintptr(0) if e != 0 { - for *(*uintptr)(unsafe.Pointer(e)) != 0 { + for **(**uintptr)(__ccgo_up(e)) != 0 { v1 = e e += 8 - X__env_rm_add(tls, *(*uintptr)(unsafe.Pointer(v1)), uintptr(0)) + X__env_rm_add(tls, **(**uintptr)(__ccgo_up(v1)), uintptr(0)) } } return 0 @@ -25082,14 +25082,14 @@ func Xgetenv(tls *TLS, name uintptr) (r uintptr) { var l Tsize_t _, _ = e, l l = Uint64FromInt64(int64(X__strchrnul(tls, name, int32('='))) - int64(name)) - if l != 0 && !(*(*uint8)(unsafe.Pointer(name + uintptr(l))) != 0) && Xenviron != 0 { + if l != 0 && !(**(**uint8)(__ccgo_up(name + uintptr(l))) != 0) && Xenviron != 0 { e = Xenviron for { - if !(*(*uintptr)(unsafe.Pointer(e)) != 0) { + if !(**(**uintptr)(__ccgo_up(e)) != 0) { break } - if !(Xstrncmp(tls, name, *(*uintptr)(unsafe.Pointer(e)), l) != 0) && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(e)) + uintptr(l)))) == int32('=') { - return *(*uintptr)(unsafe.Pointer(e)) + uintptr(l) + uintptr(1) + if !(Xstrncmp(tls, name, **(**uintptr)(__ccgo_up(e)), l) != 0) && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(e)) + uintptr(l)))) == int32('=') { + return **(**uintptr)(__ccgo_up(e)) + uintptr(l) + uintptr(1) } goto _1 _1: @@ -25115,12 +25115,12 @@ func X__putenv(tls *TLS, s uintptr, l Tsize_t, r uintptr) (r1 int32) { if Xenviron != 0 { e = Xenviron for { - if !(*(*uintptr)(unsafe.Pointer(e)) != 0) { + if !(**(**uintptr)(__ccgo_up(e)) != 0) { break } - if !(Xstrncmp(tls, s, *(*uintptr)(unsafe.Pointer(e)), l+uint64(1)) != 0) { - tmp = *(*uintptr)(unsafe.Pointer(e)) - *(*uintptr)(unsafe.Pointer(e)) = s + if !(Xstrncmp(tls, s, **(**uintptr)(__ccgo_up(e)), l+uint64(1)) != 0) { + tmp = **(**uintptr)(__ccgo_up(e)) + **(**uintptr)(__ccgo_up(e)) = s X__env_rm_add(tls, tmp, r) return 0 } @@ -25146,8 +25146,8 @@ func X__putenv(tls *TLS, s uintptr, l Tsize_t, r uintptr) (r1 int32) { } Xfree(tls, _oldenv) } - *(*uintptr)(unsafe.Pointer(newenv + uintptr(i)*8)) = s - *(*uintptr)(unsafe.Pointer(newenv + uintptr(i+uint64(1))*8)) = uintptr(0) + **(**uintptr)(__ccgo_up(newenv + uintptr(i)*8)) = s + **(**uintptr)(__ccgo_up(newenv + uintptr(i+uint64(1))*8)) = uintptr(0) v2 = newenv _oldenv = v2 Xenviron = v2 @@ -25172,7 +25172,7 @@ func Xputenv(tls *TLS, s uintptr) (r int32) { var l Tsize_t _ = l l = Uint64FromInt64(int64(X__strchrnul(tls, s, int32('='))) - int64(s)) - if !(l != 0) || !(*(*uint8)(unsafe.Pointer(s + uintptr(l))) != 0) { + if !(l != 0) || !(**(**uint8)(__ccgo_up(s + uintptr(l))) != 0) { return Xunsetenv(tls, s) } return X__putenv(tls, s, l, uintptr(0)) @@ -25217,13 +25217,13 @@ func X__env_rm_add(tls *TLS, old uintptr, new1 uintptr) { if !(i < _env_alloced_n) { break } - if *(*uintptr)(unsafe.Pointer(_env_alloced + uintptr(i)*8)) == old { - *(*uintptr)(unsafe.Pointer(_env_alloced + uintptr(i)*8)) = new1 + if **(**uintptr)(__ccgo_up(_env_alloced + uintptr(i)*8)) == old { + **(**uintptr)(__ccgo_up(_env_alloced + uintptr(i)*8)) = new1 Xfree(tls, old) return } else { - if !(*(*uintptr)(unsafe.Pointer(_env_alloced + uintptr(i)*8)) != 0) && new1 != 0 { - *(*uintptr)(unsafe.Pointer(_env_alloced + uintptr(i)*8)) = new1 + if !(**(**uintptr)(__ccgo_up(_env_alloced + uintptr(i)*8)) != 0) && new1 != 0 { + **(**uintptr)(__ccgo_up(_env_alloced + uintptr(i)*8)) = new1 new1 = uintptr(0) } } @@ -25243,7 +25243,7 @@ func X__env_rm_add(tls *TLS, old uintptr, new1 uintptr) { _env_alloced = v2 v3 = _env_alloced_n _env_alloced_n = _env_alloced_n + 1 - *(*uintptr)(unsafe.Pointer(v2 + uintptr(v3)*8)) = new1 + **(**uintptr)(__ccgo_up(v2 + uintptr(v3)*8)) = new1 } var _env_alloced uintptr @@ -25263,8 +25263,8 @@ func Xsetenv(tls *TLS, var1 uintptr, value uintptr, overwrite int32) (r int32) { v1 = Uint64FromInt64(int64(X__strchrnul(tls, var1, int32('='))) - int64(var1)) l1 = v1 } - if v2 || !(v1 != 0) || *(*uint8)(unsafe.Pointer(var1 + uintptr(l1))) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if v2 || !(v1 != 0) || **(**uint8)(__ccgo_up(var1 + uintptr(l1))) != 0 { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } if !(overwrite != 0) && Xgetenv(tls, var1) != 0 { @@ -25276,7 +25276,7 @@ func Xsetenv(tls *TLS, var1 uintptr, value uintptr, overwrite int32) (r int32) { return -int32(1) } Xmemcpy(tls, s, var1, l1) - *(*uint8)(unsafe.Pointer(s + uintptr(l1))) = uint8('=') + **(**uint8)(__ccgo_up(s + uintptr(l1))) = uint8('=') Xmemcpy(tls, s+uintptr(l1)+uintptr(1), value, l2+uint64(1)) return X__putenv(tls, s, l1, s) } @@ -25293,24 +25293,24 @@ func Xunsetenv(tls *TLS, name uintptr) (r int32) { var l Tsize_t _, _, _, _ = e, eo, l, v2 l = Uint64FromInt64(int64(X__strchrnul(tls, name, int32('='))) - int64(name)) - if !(l != 0) || *(*uint8)(unsafe.Pointer(name + uintptr(l))) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if !(l != 0) || **(**uint8)(__ccgo_up(name + uintptr(l))) != 0 { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } if Xenviron != 0 { e = Xenviron eo = e for { - if !(*(*uintptr)(unsafe.Pointer(e)) != 0) { + if !(**(**uintptr)(__ccgo_up(e)) != 0) { break } - if !(Xstrncmp(tls, name, *(*uintptr)(unsafe.Pointer(e)), l) != 0) && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(e)) + uintptr(l)))) == int32('=') { - X__env_rm_add(tls, *(*uintptr)(unsafe.Pointer(e)), uintptr(0)) + if !(Xstrncmp(tls, name, **(**uintptr)(__ccgo_up(e)), l) != 0) && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(e)) + uintptr(l)))) == int32('=') { + X__env_rm_add(tls, **(**uintptr)(__ccgo_up(e)), uintptr(0)) } else { if eo != e { v2 = eo eo += 8 - *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(e)) + **(**uintptr)(__ccgo_up(v2)) = **(**uintptr)(__ccgo_up(e)) } else { eo += 8 } @@ -25321,7 +25321,7 @@ func Xunsetenv(tls *TLS, name uintptr) (r int32) { e += 8 } if eo != e { - *(*uintptr)(unsafe.Pointer(eo)) = uintptr(0) + **(**uintptr)(__ccgo_up(eo)) = uintptr(0) } } return 0 @@ -25631,7 +25631,7 @@ func X__strerror_l(tls *TLS, e int32, loc Tlocale_t) (r uintptr) { e = 0 } s = uintptr(unsafe.Pointer(&_errmsgstr)) + uintptr(_errmsgidx[e]) - return X__lctrans(tls, s, *(*uintptr)(unsafe.Pointer(loc + 5*8))) + return X__lctrans(tls, s, **(**uintptr)(__ccgo_up(loc + 5*8))) } func Xstrerror(tls *TLS, e int32) (r uintptr) { @@ -25768,10 +25768,10 @@ func Xfcntl(tls *TLS, fd int32, cmd int32, va uintptr) (r int32) { if ret != 0 { return int32(X__syscall_ret(tls, Uint64FromInt32(ret))) } - if (*(*Tf_owner_ex)(unsafe.Pointer(bp))).Ftype1 == int32(F_OWNER_PGRP) { - v1 = -(*(*Tf_owner_ex)(unsafe.Pointer(bp))).Fpid + if (**(**Tf_owner_ex)(__ccgo_up(bp))).Ftype1 == int32(F_OWNER_PGRP) { + v1 = -(**(**Tf_owner_ex)(__ccgo_up(bp))).Fpid } else { - v1 = (*(*Tf_owner_ex)(unsafe.Pointer(bp))).Fpid + v1 = (**(**Tf_owner_ex)(__ccgo_up(bp))).Fpid } return v1 } @@ -25944,7 +25944,7 @@ func Xfegetenv(tls *TLS, envp uintptr) (r int32) { trc("tls=%v envp=%v, (%v:)", tls, envp, origin(2)) defer func() { trc("-> %v", r) }() } - *(*Tfenv_t)(unsafe.Pointer(envp)) = _get_fpc(tls) + **(**Tfenv_t)(__ccgo_up(envp)) = _get_fpc(tls) return 0 } @@ -25956,7 +25956,7 @@ func Xfesetenv(tls *TLS, envp uintptr) (r int32) { var v1 uint32 _ = v1 if envp != uintptr(-Int32FromInt32(1)) { - v1 = *(*Tfenv_t)(unsafe.Pointer(envp)) + v1 = **(**Tfenv_t)(__ccgo_up(envp)) } else { v1 = uint32(0) } @@ -26041,7 +26041,7 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26052,7 +26052,7 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26082,7 +26082,7 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26101,7 +26101,7 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26118,7 +26118,7 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26171,7 +26171,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__shgetc(tls, f) } @@ -26183,7 +26183,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__shgetc(tls, f) } @@ -26201,14 +26201,14 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__shgetc(tls, f) } c = v2 } } - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0] = uint32(0) + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[0] = uint32(0) for { if !(Uint32FromInt32(c-int32('0')) < uint32(10) || c == int32('.')) { break @@ -26226,9 +26226,9 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, lnz = int32(dc) } if j != 0 { - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k]*uint32(10) + Uint32FromInt32(c) - uint32('0') + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] = (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k]*uint32(10) + Uint32FromInt32(c) - uint32('0') } else { - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] = Uint32FromInt32(c - int32('0')) + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] = Uint32FromInt32(c - int32('0')) } j = j + 1 v2 = j @@ -26241,7 +26241,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, dc = dc + 1 if c != int32('0') { lnz = (Int32FromInt32(KMAX) - Int32FromInt32(4)) * Int32FromInt32(9) - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(Int32FromInt32(KMAX)-Int32FromInt32(4))*4)) |= uint32(1) + **(**Tuint32_t)(__ccgo_up(bp + uintptr(Int32FromInt32(KMAX)-Int32FromInt32(4))*4)) |= uint32(1) } } } @@ -26252,7 +26252,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__shgetc(tls, f) } @@ -26283,24 +26283,24 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, } } if !(gotdig != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) X__shlim(tls, f, int64(Int32FromInt32(0))) return Float64FromInt32(0) } /* Handle zero specially to avoid nasty special cases later */ - if !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0] != 0) { + if !((**(**[128]Tuint32_t)(__ccgo_up(bp)))[0] != 0) { return float64(float64(sign) * float64(0)) } /* Optimize small integers (w/no exponent) and over/under-flow */ - if lrp == dc && dc < int64(10) && (bits > int32(30) || (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0]>>bits == uint32(0)) { - return float64(float64(sign) * float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0])) + if lrp == dc && dc < int64(10) && (bits > int32(30) || (**(**[128]Tuint32_t)(__ccgo_up(bp)))[0]>>bits == uint32(0)) { + return float64(float64(sign) * float64((**(**[128]Tuint32_t)(__ccgo_up(bp)))[0])) } if lrp > int64(-emin/int32(2)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return float64(float64(float64(sign)*Float64FromFloat64(1.79769313486231570815e+308)) * Float64FromFloat64(1.79769313486231570815e+308)) } if lrp < int64(emin-Int32FromInt32(2)*Int32FromInt32(LDBL_MANT_DIG)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return float64(float64(float64(sign)*Float64FromFloat64(2.22507385850720138309e-308)) * Float64FromFloat64(2.22507385850720138309e-308)) } /* Align incomplete final B1B digit */ @@ -26309,7 +26309,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if !(j < int32(9)) { break } - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(k)*4)) *= uint32(10) + **(**Tuint32_t)(__ccgo_up(bp + uintptr(k)*4)) *= uint32(10) goto _17 _17: ; @@ -26325,19 +26325,19 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, /* Optimize small to mid-size integers (even in exp. notation) */ if lnz < int32(9) && lnz <= rp && rp < int32(18) { if rp == int32(9) { - return float64(float64(sign) * float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0])) + return float64(float64(sign) * float64((**(**[128]Tuint32_t)(__ccgo_up(bp)))[0])) } if rp < int32(9) { - return float64(float64(sign)*float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0])) / float64(_p10s[int32(8)-rp]) + return float64(float64(sign)*float64((**(**[128]Tuint32_t)(__ccgo_up(bp)))[0])) / float64(_p10s[int32(8)-rp]) } bitlim = bits - int32(3)*(rp-Int32FromInt32(9)) - if bitlim > int32(30) || (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0]>>bitlim == uint32(0) { - return float64(float64(float64(sign)*float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0])) * float64(_p10s[rp-int32(10)])) + if bitlim > int32(30) || (**(**[128]Tuint32_t)(__ccgo_up(bp)))[0]>>bitlim == uint32(0) { + return float64(float64(float64(sign)*float64((**(**[128]Tuint32_t)(__ccgo_up(bp)))[0])) * float64(_p10s[rp-int32(10)])) } } /* Drop trailing zeros */ for { - if !!((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[z-int32(1)] != 0) { + if !!((**(**[128]Tuint32_t)(__ccgo_up(bp)))[z-int32(1)] != 0) { break } goto _18 @@ -26360,10 +26360,10 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if !(k != z) { break } - tmp = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] % Uint32FromInt32(p10) - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k]/Uint32FromInt32(p10) + carry + tmp = (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] % Uint32FromInt32(p10) + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] = (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k]/Uint32FromInt32(p10) + carry carry = Uint32FromInt32(int32(1000000000)/p10) * tmp - if k == a && !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] != 0) { + if k == a && !((**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] != 0) { a = (a + int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) rp = rp - int32(9) } @@ -26375,25 +26375,25 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if carry != 0 { v2 = z z = z + 1 - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v2] = carry + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[v2] = carry } rp = rp + (int32(9) - rpm9) } /* Upscale until desired number of bits are left of radix point */ - for rp < Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) || rp == Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) && (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[a] < _th[0] { + for rp < Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) || rp == Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) && (**(**[128]Tuint32_t)(__ccgo_up(bp)))[a] < _th[0] { carry1 = uint32(0) e2 = e2 - int32(29) k = (z - int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) for { - tmp1 = uint64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k])< uint64(1000000000) { carry1 = uint32(tmp1 / uint64(1000000000)) - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] = uint32(tmp1 % uint64(1000000000)) + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] = uint32(tmp1 % uint64(1000000000)) } else { carry1 = uint32(0) - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] = uint32(tmp1) + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] = uint32(tmp1) } - if k == (z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) && k != a && !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] != 0) { + if k == (z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) && k != a && !((**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] != 0) { z = k } if k == a { @@ -26409,9 +26409,9 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, a = (a - int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) if a == z { z = (z - int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr((z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)))*4)) |= (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[z] + **(**Tuint32_t)(__ccgo_up(bp + uintptr((z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)))*4)) |= (**(**[128]Tuint32_t)(__ccgo_up(bp)))[z] } - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[a] = carry1 + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[a] = carry1 } } /* Downscale until exactly number of bits are left of radix point */ @@ -26424,11 +26424,11 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, break } k = (a + i) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) - if k == z || (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] < _th[i] { + if k == z || (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] < _th[i] { i = int32(LD_B1B_DIG) break } - if (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))] > _th[i] { + if (**(**[128]Tuint32_t)(__ccgo_up(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))] > _th[i] { break } goto _24 @@ -26449,10 +26449,10 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if !(k != z) { break } - tmp2 = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] & Uint32FromInt32(int32(1)<>sh + carry2 + tmp2 = (**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] & Uint32FromInt32(int32(1)<>sh + carry2 carry2 = Uint32FromInt32(Int32FromInt32(1000000000)>>sh) * tmp2 - if k == a && !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] != 0) { + if k == a && !((**(**[128]Tuint32_t)(__ccgo_up(bp)))[k] != 0) { a = (a + int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) i = i - 1 rp = rp - int32(9) @@ -26464,10 +26464,10 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, } if carry2 != 0 { if (z+int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) != a { - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[z] = carry2 + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[z] = carry2 z = (z + int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) } else { - *(*Tuint32_t)(unsafe.Pointer(bp + uintptr((z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)))*4)) |= uint32(1) + **(**Tuint32_t)(__ccgo_up(bp + uintptr((z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)))*4)) |= uint32(1) } } goto _23 @@ -26484,9 +26484,9 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if (a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1)) == z { v6 = (z + Int32FromInt32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) z = v6 - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v6-int32(1)] = uint32(0) + (**(**[128]Tuint32_t)(__ccgo_up(bp)))[v6-int32(1)] = uint32(0) } - y = float64(Float64FromFloat64(1e+09)*y) + float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))]) + y = float64(Float64FromFloat64(1e+09)*y) + float64((**(**[128]Tuint32_t)(__ccgo_up(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))]) goto _26 _26: ; @@ -26510,7 +26510,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, } /* Process tail of decimal input so it can affect rounding */ if (a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1)) != z { - t = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))] + t = (**(**[128]Tuint32_t)(__ccgo_up(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))] if t < uint32(500000000) && (t != 0 || (a+i+int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) != z) { frac = frac + float64(float64(0.25)*float64(sign)) } else { @@ -26541,7 +26541,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, e2 = e2 + 1 } if e2+int32(LDBL_MANT_DIG) > emax || denormal != 0 && frac != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) } } return Xscalbnl(tls, y, e2) @@ -26584,7 +26584,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26602,7 +26602,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26614,7 +26614,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26633,7 +26633,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26680,7 +26680,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__shgetc(tls, f) } @@ -26734,11 +26734,11 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 return float64(float64(sign) * float64(0)) } if e2 > int64(-emin) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return float64(float64(float64(sign)*Float64FromFloat64(1.79769313486231570815e+308)) * Float64FromFloat64(1.79769313486231570815e+308)) } if e2 < int64(emin-Int32FromInt32(2)*Int32FromInt32(LDBL_MANT_DIG)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return float64(float64(float64(sign)*Float64FromFloat64(2.22507385850720138309e-308)) * Float64FromFloat64(2.22507385850720138309e-308)) } for x < uint32(0x80000000) { @@ -26767,7 +26767,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 y = bias + float64(float64(sign)*float64(x)) + float64(float64(sign)*y) y = y - bias if !(y != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) } return Xscalbnl(tls, y, int32(e2)) } @@ -26800,7 +26800,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__shgetc(tls, f) } @@ -26820,7 +26820,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -26828,7 +26828,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { } i = uint64(0) for { - if !(i < uint64(8) && c|int32(32) == Int32FromUint8(*(*uint8)(unsafe.Pointer(__ccgo_ts + 336 + uintptr(i))))) { + if !(i < uint64(8) && c|int32(32) == Int32FromUint8(**(**uint8)(__ccgo_up(__ccgo_ts + 336 + uintptr(i))))) { break } if i < uint64(7) { @@ -26836,7 +26836,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -26872,7 +26872,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { if !(i != 0) { i = uint64(0) for { - if !(i < uint64(3) && c|int32(32) == Int32FromUint8(*(*uint8)(unsafe.Pointer(__ccgo_ts + 345 + uintptr(i))))) { + if !(i < uint64(3) && c|int32(32) == Int32FromUint8(**(**uint8)(__ccgo_up(__ccgo_ts + 345 + uintptr(i))))) { break } if i < uint64(2) { @@ -26880,7 +26880,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -26897,7 +26897,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -26913,7 +26913,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -26928,7 +26928,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if !(pok != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) X__shlim(tls, f, int64(Int32FromInt32(0))) return Float64FromInt32(0) } @@ -26954,7 +26954,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) X__shlim(tls, f, int64(Int32FromInt32(0))) return Float64FromInt32(0) } @@ -26963,7 +26963,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27254,7 +27254,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint val = uintptr(unsafe.Pointer(&_table6)) + uintptr(1) neg = 0 if base > uint32(36) || base == uint32(1) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uint64(0) } for { @@ -27262,7 +27262,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__shgetc(tls, f) } @@ -27282,7 +27282,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27293,7 +27293,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27303,12 +27303,12 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } c = v1 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) >= int32(16) { + if Int32FromUint8(**(**uint8)(__ccgo_up(val + uintptr(c)))) >= int32(16) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } @@ -27331,12 +27331,12 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint if base == uint32(0) { base = uint32(10) } - if uint32(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) >= base { + if uint32(**(**uint8)(__ccgo_up(val + uintptr(c)))) >= base { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } X__shlim(tls, f, int64(Int32FromInt32(0))) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uint64(0) } } @@ -27354,7 +27354,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27373,7 +27373,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v1 = X__shgetc(tls, f) } @@ -27384,13 +27384,13 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint } } else { if !(base&(base-Uint32FromInt32(1)) != 0) { - bs = Int32FromUint8(*(*uint8)(unsafe.Pointer(__ccgo_ts + 349 + uintptr(uint32(0x17)*base>>int32(5)&uint32(7))))) + bs = Int32FromUint8(**(**uint8)(__ccgo_up(__ccgo_ts + 349 + uintptr(uint32(0x17)*base>>int32(5)&uint32(7))))) x = uint32(0) for { - if !(uint32(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) < base && x <= Uint32FromUint32(0xffffffff)/Uint32FromInt32(32)) { + if !(uint32(**(**uint8)(__ccgo_up(val + uintptr(c)))) < base && x <= Uint32FromUint32(0xffffffff)/Uint32FromInt32(32)) { break } - x = x<>bs) { + if !(uint32(**(**uint8)(__ccgo_up(val + uintptr(c)))) < base && y <= (Uint64FromUint64(2)*Uint64FromInt64(0x7fffffffffffffff)+Uint64FromInt32(1))>>bs) { break } - y = y<= lim { if !(lim&Uint64FromInt32(1) != 0) && !(neg != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return lim - uint64(1) } else { if y > lim { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return lim } } @@ -27517,8 +27517,8 @@ func X__procfdname(tls *TLS, buf uintptr, fd uint32) { _, _, _, _ = i, j, v2, v5 i = uint32(0) for { - v2 = *(*uint8)(unsafe.Pointer(__ccgo_ts + 358 + uintptr(i))) - *(*uint8)(unsafe.Pointer(buf + uintptr(i))) = v2 + v2 = **(**uint8)(__ccgo_up(__ccgo_ts + 358 + uintptr(i))) + **(**uint8)(__ccgo_up(buf + uintptr(i))) = v2 if !(v2 != 0) { break } @@ -27528,8 +27528,8 @@ func X__procfdname(tls *TLS, buf uintptr, fd uint32) { i = i + 1 } if !(fd != 0) { - *(*uint8)(unsafe.Pointer(buf + uintptr(i))) = uint8('0') - *(*uint8)(unsafe.Pointer(buf + uintptr(i+uint32(1)))) = uint8(0) + **(**uint8)(__ccgo_up(buf + uintptr(i))) = uint8('0') + **(**uint8)(__ccgo_up(buf + uintptr(i+uint32(1)))) = uint8(0) return } j = fd @@ -27543,14 +27543,14 @@ func X__procfdname(tls *TLS, buf uintptr, fd uint32) { j = j / uint32(10) i = i + 1 } - *(*uint8)(unsafe.Pointer(buf + uintptr(i))) = uint8(0) + **(**uint8)(__ccgo_up(buf + uintptr(i))) = uint8(0) for { if !(fd != 0) { break } i = i - 1 v5 = i - *(*uint8)(unsafe.Pointer(buf + uintptr(v5))) = uint8(uint32('0') + fd%uint32(10)) + **(**uint8)(__ccgo_up(buf + uintptr(v5))) = uint8(uint32('0') + fd%uint32(10)) goto _4 _4: ; @@ -27605,7 +27605,7 @@ func X__shgetc(tls *TLS, f uintptr) (r int32) { } (*TFILE)(unsafe.Pointer(f)).Fshcnt = int64((*TFILE)(unsafe.Pointer(f)).Fbuf) - int64((*TFILE)(unsafe.Pointer(f)).Frpos) + cnt if (*TFILE)(unsafe.Pointer(f)).Frpos <= (*TFILE)(unsafe.Pointer(f)).Fbuf { - *(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos + uintptr(-Int32FromInt32(1)))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos + uintptr(-Int32FromInt32(1)))) = Uint8FromInt32(c) } return c } @@ -27616,7 +27616,7 @@ func X__syscall_ret(tls *TLS, r uint64) (r1 int64) { defer func() { trc("-> %v", r1) }() } if r > -Uint64FromUint64(4096) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = Int32FromUint64(-r) + **(**int32)(__ccgo_up(X__errno_location(tls))) = Int32FromUint64(-r) return int64(-int32(1)) } return Int64FromUint64(r) @@ -27691,7 +27691,7 @@ func Xftok(tls *TLS, path uintptr, id int32) (r Tkey_t) { if Xstat(tls, path, bp) < 0 { return -int32(1) } - return Int32FromUint64((*(*Tstat)(unsafe.Pointer(bp))).Fst_ino&Uint64FromInt32(0xffff) | (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev&Uint64FromInt32(0xff)< -Uint64FromInt32(SHMLBA) { v1 = uintptr(ret) } else { - v1 = *(*uintptr)(unsafe.Pointer(bp)) + v1 = **(**uintptr)(__ccgo_up(bp)) } return v1 } @@ -28066,20 +28066,20 @@ func Xcuserid(tls *TLS, buf uintptr) (r uintptr) { var _ /* pwb at bp+56 */ [256]int64 _ = len1 if buf != 0 { - *(*uint8)(unsafe.Pointer(buf)) = uint8(0) + **(**uint8)(__ccgo_up(buf)) = uint8(0) } Xgetpwuid_r(tls, Xgeteuid(tls), bp, bp+56, uint64(2048), bp+48) - if !(*(*uintptr)(unsafe.Pointer(bp + 48)) != 0) { + if !(**(**uintptr)(__ccgo_up(bp + 48)) != 0) { return buf } - len1 = Xstrnlen(tls, (*(*Tpasswd)(unsafe.Pointer(bp))).Fpw_name, uint64(L_cuserid)) + len1 = Xstrnlen(tls, (**(**Tpasswd)(__ccgo_up(bp))).Fpw_name, uint64(L_cuserid)) if len1 == uint64(L_cuserid) { return buf } if !(buf != 0) { buf = uintptr(unsafe.Pointer(&_usridbuf)) } - Xmemcpy(tls, buf, (*(*Tpasswd)(unsafe.Pointer(bp))).Fpw_name, len1+uint64(1)) + Xmemcpy(tls, buf, (**(**Tpasswd)(__ccgo_up(bp))).Fpw_name, len1+uint64(1)) return buf } @@ -28282,10 +28282,10 @@ func Xfutimes(tls *TLS, fd int32, tv uintptr) (r int32) { if !(tv != 0) { return Xfutimens(tls, fd, uintptr(0)) } - (*(*[2]Ttimespec)(unsafe.Pointer(bp)))[0].Ftv_sec = (*(*Ttimeval)(unsafe.Pointer(tv))).Ftv_sec - (*(*[2]Ttimespec)(unsafe.Pointer(bp)))[0].Ftv_nsec = (*(*Ttimeval)(unsafe.Pointer(tv))).Ftv_usec * int64(1000) - (*(*[2]Ttimespec)(unsafe.Pointer(bp)))[int32(1)].Ftv_sec = (*(*Ttimeval)(unsafe.Pointer(tv + 1*16))).Ftv_sec - (*(*[2]Ttimespec)(unsafe.Pointer(bp)))[int32(1)].Ftv_nsec = (*(*Ttimeval)(unsafe.Pointer(tv + 1*16))).Ftv_usec * int64(1000) + (**(**[2]Ttimespec)(__ccgo_up(bp)))[0].Ftv_sec = (**(**Ttimeval)(__ccgo_up(tv))).Ftv_sec + (**(**[2]Ttimespec)(__ccgo_up(bp)))[0].Ftv_nsec = (**(**Ttimeval)(__ccgo_up(tv))).Ftv_usec * int64(1000) + (**(**[2]Ttimespec)(__ccgo_up(bp)))[int32(1)].Ftv_sec = (**(**Ttimeval)(__ccgo_up(tv + 1*16))).Ftv_sec + (**(**[2]Ttimespec)(__ccgo_up(bp)))[int32(1)].Ftv_nsec = (**(**Ttimeval)(__ccgo_up(tv + 1*16))).Ftv_usec * int64(1000) return Xfutimens(tls, fd, bp) } @@ -28302,8 +28302,8 @@ func Xgetdtablesize(tls *TLS) (r int32) { var _ /* rl at bp+0 */ Trlimit _ = v1 Xgetrlimit(tls, int32(RLIMIT_NOFILE), bp) - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur < uint64(INT_MAX) { - v1 = (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur < uint64(INT_MAX) { + v1 = (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur } else { v1 = uint64(INT_MAX) } @@ -28337,7 +28337,7 @@ func Xgetloadavg(tls *TLS, a uintptr, n int32) (r int32) { if !(i < n) { break } - *(*float64)(unsafe.Pointer(a + uintptr(i)*8)) = float64(Float64FromFloat64(1) / float64(Int32FromInt32(1)< int64(1000) || (*Ttimeval)(unsafe.Pointer(in)).Ftv_usec > int64(1000000000) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } - (*(*Ttimex)(unsafe.Pointer(bp))).Foffset = (*Ttimeval)(unsafe.Pointer(in)).Ftv_sec*int64(1000000) + (*Ttimeval)(unsafe.Pointer(in)).Ftv_usec - (*(*Ttimex)(unsafe.Pointer(bp))).Fmodes = uint32(ADJ_OFFSET_SINGLESHOT) + (**(**Ttimex)(__ccgo_up(bp))).Foffset = (*Ttimeval)(unsafe.Pointer(in)).Ftv_sec*int64(1000000) + (*Ttimeval)(unsafe.Pointer(in)).Ftv_usec + (**(**Ttimex)(__ccgo_up(bp))).Fmodes = uint32(ADJ_OFFSET_SINGLESHOT) } if Xadjtimex(tls, bp) < 0 { return -int32(1) } if out != 0 { - (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec = (*(*Ttimex)(unsafe.Pointer(bp))).Foffset / int64(1000000) - v1 = (*(*Ttimex)(unsafe.Pointer(bp))).Foffset % Int64FromInt32(1000000) + (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec = (**(**Ttimex)(__ccgo_up(bp))).Foffset / int64(1000000) + v1 = (**(**Ttimex)(__ccgo_up(bp))).Foffset % Int64FromInt32(1000000) (*Ttimeval)(unsafe.Pointer(out)).Ftv_usec = v1 if v1 < 0 { (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec = (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec - 1 - *(*Tsuseconds_t)(unsafe.Pointer(out + 8)) += int64(1000000) + **(**Tsuseconds_t)(__ccgo_up(out + 8)) += int64(1000000) } } return 0 @@ -29153,7 +29153,7 @@ func Xclock_adjtime(tls *TLS, clock_id Tclockid_t, utx uintptr) (r1 int32) { _ = r r = -int32(ENOSYS) if uint64(8) > uint64(8) { - *(*Tktimex)(unsafe.Pointer(bp)) = Tktimex{ + **(**Tktimex)(__ccgo_up(bp)) = Tktimex{ Fmodes: (*Ttimex)(unsafe.Pointer(utx)).Fmodes, Foffset: (*Ttimex)(unsafe.Pointer(utx)).Foffset, Ffreq: (*Ttimex)(unsafe.Pointer(utx)).Ffreq, @@ -29182,27 +29182,27 @@ func Xclock_adjtime(tls *TLS, clock_id Tclockid_t, utx uintptr) (r1 int32) { r = int32(X__syscall2(tls, int64(SYS_clock_adjtime), int64(clock_id), int64(bp))) } if r >= 0 { - (*Ttimex)(unsafe.Pointer(utx)).Fmodes = (*(*Tktimex)(unsafe.Pointer(bp))).Fmodes - (*Ttimex)(unsafe.Pointer(utx)).Foffset = (*(*Tktimex)(unsafe.Pointer(bp))).Foffset - (*Ttimex)(unsafe.Pointer(utx)).Ffreq = (*(*Tktimex)(unsafe.Pointer(bp))).Ffreq - (*Ttimex)(unsafe.Pointer(utx)).Fmaxerror = (*(*Tktimex)(unsafe.Pointer(bp))).Fmaxerror - (*Ttimex)(unsafe.Pointer(utx)).Festerror = (*(*Tktimex)(unsafe.Pointer(bp))).Festerror - (*Ttimex)(unsafe.Pointer(utx)).Fstatus = (*(*Tktimex)(unsafe.Pointer(bp))).Fstatus - (*Ttimex)(unsafe.Pointer(utx)).Fconstant = (*(*Tktimex)(unsafe.Pointer(bp))).Fconstant - (*Ttimex)(unsafe.Pointer(utx)).Fprecision = (*(*Tktimex)(unsafe.Pointer(bp))).Fprecision - (*Ttimex)(unsafe.Pointer(utx)).Ftolerance = (*(*Tktimex)(unsafe.Pointer(bp))).Ftolerance - (*Ttimex)(unsafe.Pointer(utx)).Ftime.Ftv_sec = (*(*Tktimex)(unsafe.Pointer(bp))).Ftime_sec - (*Ttimex)(unsafe.Pointer(utx)).Ftime.Ftv_usec = (*(*Tktimex)(unsafe.Pointer(bp))).Ftime_usec - (*Ttimex)(unsafe.Pointer(utx)).Ftick = (*(*Tktimex)(unsafe.Pointer(bp))).Ftick - (*Ttimex)(unsafe.Pointer(utx)).Fppsfreq = (*(*Tktimex)(unsafe.Pointer(bp))).Fppsfreq - (*Ttimex)(unsafe.Pointer(utx)).Fjitter = (*(*Tktimex)(unsafe.Pointer(bp))).Fjitter - (*Ttimex)(unsafe.Pointer(utx)).Fshift = (*(*Tktimex)(unsafe.Pointer(bp))).Fshift - (*Ttimex)(unsafe.Pointer(utx)).Fstabil = (*(*Tktimex)(unsafe.Pointer(bp))).Fstabil - (*Ttimex)(unsafe.Pointer(utx)).Fjitcnt = (*(*Tktimex)(unsafe.Pointer(bp))).Fjitcnt - (*Ttimex)(unsafe.Pointer(utx)).Fcalcnt = (*(*Tktimex)(unsafe.Pointer(bp))).Fcalcnt - (*Ttimex)(unsafe.Pointer(utx)).Ferrcnt = (*(*Tktimex)(unsafe.Pointer(bp))).Ferrcnt - (*Ttimex)(unsafe.Pointer(utx)).Fstbcnt = (*(*Tktimex)(unsafe.Pointer(bp))).Fstbcnt - (*Ttimex)(unsafe.Pointer(utx)).Ftai = (*(*Tktimex)(unsafe.Pointer(bp))).Ftai + (*Ttimex)(unsafe.Pointer(utx)).Fmodes = (**(**Tktimex)(__ccgo_up(bp))).Fmodes + (*Ttimex)(unsafe.Pointer(utx)).Foffset = (**(**Tktimex)(__ccgo_up(bp))).Foffset + (*Ttimex)(unsafe.Pointer(utx)).Ffreq = (**(**Tktimex)(__ccgo_up(bp))).Ffreq + (*Ttimex)(unsafe.Pointer(utx)).Fmaxerror = (**(**Tktimex)(__ccgo_up(bp))).Fmaxerror + (*Ttimex)(unsafe.Pointer(utx)).Festerror = (**(**Tktimex)(__ccgo_up(bp))).Festerror + (*Ttimex)(unsafe.Pointer(utx)).Fstatus = (**(**Tktimex)(__ccgo_up(bp))).Fstatus + (*Ttimex)(unsafe.Pointer(utx)).Fconstant = (**(**Tktimex)(__ccgo_up(bp))).Fconstant + (*Ttimex)(unsafe.Pointer(utx)).Fprecision = (**(**Tktimex)(__ccgo_up(bp))).Fprecision + (*Ttimex)(unsafe.Pointer(utx)).Ftolerance = (**(**Tktimex)(__ccgo_up(bp))).Ftolerance + (*Ttimex)(unsafe.Pointer(utx)).Ftime.Ftv_sec = (**(**Tktimex)(__ccgo_up(bp))).Ftime_sec + (*Ttimex)(unsafe.Pointer(utx)).Ftime.Ftv_usec = (**(**Tktimex)(__ccgo_up(bp))).Ftime_usec + (*Ttimex)(unsafe.Pointer(utx)).Ftick = (**(**Tktimex)(__ccgo_up(bp))).Ftick + (*Ttimex)(unsafe.Pointer(utx)).Fppsfreq = (**(**Tktimex)(__ccgo_up(bp))).Fppsfreq + (*Ttimex)(unsafe.Pointer(utx)).Fjitter = (**(**Tktimex)(__ccgo_up(bp))).Fjitter + (*Ttimex)(unsafe.Pointer(utx)).Fshift = (**(**Tktimex)(__ccgo_up(bp))).Fshift + (*Ttimex)(unsafe.Pointer(utx)).Fstabil = (**(**Tktimex)(__ccgo_up(bp))).Fstabil + (*Ttimex)(unsafe.Pointer(utx)).Fjitcnt = (**(**Tktimex)(__ccgo_up(bp))).Fjitcnt + (*Ttimex)(unsafe.Pointer(utx)).Fcalcnt = (**(**Tktimex)(__ccgo_up(bp))).Fcalcnt + (*Ttimex)(unsafe.Pointer(utx)).Ferrcnt = (**(**Tktimex)(__ccgo_up(bp))).Ferrcnt + (*Ttimex)(unsafe.Pointer(utx)).Fstbcnt = (**(**Tktimex)(__ccgo_up(bp))).Fstbcnt + (*Ttimex)(unsafe.Pointer(utx)).Ftai = (**(**Tktimex)(__ccgo_up(bp))).Ftai } return int32(X__syscall_ret(tls, Uint64FromInt32(r))) } @@ -30255,12 +30255,12 @@ func Xprlimit(tls *TLS, pid Tpid_t, resource int32, new_limit uintptr, old_limit var _ /* tmp at bp+0 */ Trlimit _ = r if new_limit != 0 && Bool(^Uint64FromUint64(0) != ^Uint64FromUint64(0)) { - *(*Trlimit)(unsafe.Pointer(bp)) = *(*Trlimit)(unsafe.Pointer(new_limit)) - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur >= ^Uint64FromUint64(0) { - (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur = ^Uint64FromUint64(0) + **(**Trlimit)(__ccgo_up(bp)) = **(**Trlimit)(__ccgo_up(new_limit)) + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur >= ^Uint64FromUint64(0) { + (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur = ^Uint64FromUint64(0) } - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_max >= ^Uint64FromUint64(0) { - (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_max = ^Uint64FromUint64(0) + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_max >= ^Uint64FromUint64(0) { + (**(**Trlimit)(__ccgo_up(bp))).Frlim_max = ^Uint64FromUint64(0) } new_limit = bp } @@ -30456,7 +30456,7 @@ func Xptrace(tls *TLS, req int32, va uintptr) (r int64) { if ret < 0 || Uint32FromInt32(req)-uint32(1) >= uint32(3) { return ret } - return *(*int64)(unsafe.Pointer(bp)) + return **(**int64)(__ccgo_up(bp)) } func Xpwritev2(tls *TLS, fd int32, iov uintptr, count int32, ofs Toff_t, flags int32) (r Tssize_t) { @@ -30768,22 +30768,22 @@ func Xstatx(tls *TLS, dirfd int32, path uintptr, flags int32, mask uint32, stx u if ret != 0 { return ret } - (*Tstatx)(unsafe.Pointer(stx)).Fstx_dev_major = uint32((*(*Tstat)(unsafe.Pointer(bp))).Fst_dev>>Int32FromInt32(31)>>Int32FromInt32(1)&Uint64FromUint32(0xfffff000) | (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev>>Int32FromInt32(8)&Uint64FromInt32(0x00000fff)) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_dev_minor = uint32((*(*Tstat)(unsafe.Pointer(bp))).Fst_dev>>Int32FromInt32(12)&Uint64FromUint32(0xffffff00) | (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev&Uint64FromInt32(0x000000ff)) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_ino = (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino - (*Tstatx)(unsafe.Pointer(stx)).Fstx_mode = uint16((*(*Tstat)(unsafe.Pointer(bp))).Fst_mode) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_nlink = uint32((*(*Tstat)(unsafe.Pointer(bp))).Fst_nlink) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_uid = (*(*Tstat)(unsafe.Pointer(bp))).Fst_uid - (*Tstatx)(unsafe.Pointer(stx)).Fstx_gid = (*(*Tstat)(unsafe.Pointer(bp))).Fst_gid - (*Tstatx)(unsafe.Pointer(stx)).Fstx_size = Uint64FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_size) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_blksize = Uint32FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_blksize) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_blocks = Uint64FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_blocks) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_atime.Ftv_sec = (*(*Tstat)(unsafe.Pointer(bp))).Fst_atim.Ftv_sec - (*Tstatx)(unsafe.Pointer(stx)).Fstx_atime.Ftv_nsec = Uint32FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_atim.Ftv_nsec) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_mtime.Ftv_sec = (*(*Tstat)(unsafe.Pointer(bp))).Fst_mtim.Ftv_sec - (*Tstatx)(unsafe.Pointer(stx)).Fstx_mtime.Ftv_nsec = Uint32FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_mtim.Ftv_nsec) - (*Tstatx)(unsafe.Pointer(stx)).Fstx_ctime.Ftv_sec = (*(*Tstat)(unsafe.Pointer(bp))).Fst_ctim.Ftv_sec - (*Tstatx)(unsafe.Pointer(stx)).Fstx_ctime.Ftv_nsec = Uint32FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_ctim.Ftv_nsec) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_dev_major = uint32((**(**Tstat)(__ccgo_up(bp))).Fst_dev>>Int32FromInt32(31)>>Int32FromInt32(1)&Uint64FromUint32(0xfffff000) | (**(**Tstat)(__ccgo_up(bp))).Fst_dev>>Int32FromInt32(8)&Uint64FromInt32(0x00000fff)) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_dev_minor = uint32((**(**Tstat)(__ccgo_up(bp))).Fst_dev>>Int32FromInt32(12)&Uint64FromUint32(0xffffff00) | (**(**Tstat)(__ccgo_up(bp))).Fst_dev&Uint64FromInt32(0x000000ff)) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_ino = (**(**Tstat)(__ccgo_up(bp))).Fst_ino + (*Tstatx)(unsafe.Pointer(stx)).Fstx_mode = uint16((**(**Tstat)(__ccgo_up(bp))).Fst_mode) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_nlink = uint32((**(**Tstat)(__ccgo_up(bp))).Fst_nlink) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_uid = (**(**Tstat)(__ccgo_up(bp))).Fst_uid + (*Tstatx)(unsafe.Pointer(stx)).Fstx_gid = (**(**Tstat)(__ccgo_up(bp))).Fst_gid + (*Tstatx)(unsafe.Pointer(stx)).Fstx_size = Uint64FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_size) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_blksize = Uint32FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_blksize) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_blocks = Uint64FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_blocks) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_atime.Ftv_sec = (**(**Tstat)(__ccgo_up(bp))).Fst_atim.Ftv_sec + (*Tstatx)(unsafe.Pointer(stx)).Fstx_atime.Ftv_nsec = Uint32FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_atim.Ftv_nsec) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_mtime.Ftv_sec = (**(**Tstat)(__ccgo_up(bp))).Fst_mtim.Ftv_sec + (*Tstatx)(unsafe.Pointer(stx)).Fstx_mtime.Ftv_nsec = Uint32FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_mtim.Ftv_nsec) + (*Tstatx)(unsafe.Pointer(stx)).Fstx_ctime.Ftv_sec = (**(**Tstat)(__ccgo_up(bp))).Fst_ctim.Ftv_sec + (*Tstatx)(unsafe.Pointer(stx)).Fstx_ctime.Ftv_nsec = Uint32FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_ctim.Ftv_nsec) (*Tstatx)(unsafe.Pointer(stx)).Fstx_btime = Tstatx_timestamp{} (*Tstatx)(unsafe.Pointer(stx)).Fstx_mask = uint32(0x7ff) return 0 @@ -30797,8 +30797,8 @@ func Xstime(tls *TLS, t uintptr) (r int32) { bp := tls.Alloc(16) defer tls.Free(16) var _ /* tv at bp+0 */ Ttimeval - *(*Ttimeval)(unsafe.Pointer(bp)) = Ttimeval{ - Ftv_sec: *(*Ttime_t)(unsafe.Pointer(t)), + **(**Ttimeval)(__ccgo_up(bp)) = Ttimeval{ + Ftv_sec: **(**Ttime_t)(__ccgo_up(t)), } return Xsettimeofday(tls, bp, UintptrFromInt32(0)) } @@ -31006,12 +31006,12 @@ func Xwait4(tls *TLS, pid Tpid_t, status uintptr, options int32, ru uintptr) (r1 if r > 0 && ru != 0 && Bool(uint64(8) > uint64(8)) { Xmemcpy(tls, bp, dest, Uint64FromInt32(4)*Uint64FromInt64(8)) (*Trusage)(unsafe.Pointer(ru)).Fru_utime = Ttimeval{ - Ftv_sec: (*(*[4]int64)(unsafe.Pointer(bp)))[0], - Ftv_usec: (*(*[4]int64)(unsafe.Pointer(bp)))[int32(1)], + Ftv_sec: (**(**[4]int64)(__ccgo_up(bp)))[0], + Ftv_usec: (**(**[4]int64)(__ccgo_up(bp)))[int32(1)], } (*Trusage)(unsafe.Pointer(ru)).Fru_stime = Ttimeval{ - Ftv_sec: (*(*[4]int64)(unsafe.Pointer(bp)))[int32(2)], - Ftv_usec: (*(*[4]int64)(unsafe.Pointer(bp)))[int32(3)], + Ftv_sec: (**(**[4]int64)(__ccgo_up(bp)))[int32(2)], + Ftv_usec: (**(**[4]int64)(__ccgo_up(bp)))[int32(3)], } } return int32(X__syscall_ret(tls, Uint64FromInt32(r))) @@ -31134,7 +31134,7 @@ func X__lctrans_cur(tls *TLS, msg uintptr) (r uintptr) { trc("tls=%v msg=%v, (%v:)", tls, msg, origin(2)) defer func() { trc("-> %v", r) }() } - return X__lctrans_impl(tls, msg, *(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale + 5*8))) + return X__lctrans_impl(tls, msg, **(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale + 5*8))) } func _swapc(tls *TLS, x Tuint32_t, c int32) (r Tuint32_t) { @@ -31158,27 +31158,27 @@ func X__mo_lookup(tls *TLS, p uintptr, size Tsize_t, s uintptr) (r uintptr) { var sign, sw int32 _, _, _, _, _, _, _, _, _, _, _ = b, mo, n, o, ol, os, sign, sw, t, tl, ts mo = p - sw = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(mo)) - uint32(0x950412de)) + sw = Int32FromUint32(**(**Tuint32_t)(__ccgo_up(mo)) - uint32(0x950412de)) b = uint32(0) - n = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + 2*4)), sw) - o = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + 3*4)), sw) - t = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + 4*4)), sw) + n = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + 2*4)), sw) + o = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + 3*4)), sw) + t = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + 4*4)), sw) if uint64(n) >= size/uint64(4) || uint64(o) >= size-uint64(uint32(4)*n) || uint64(t) >= size-uint64(uint32(4)*n) || (o|t)%uint32(4) != 0 { return uintptr(0) } o = o / uint32(4) t = t / uint32(4) for { - ol = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + uintptr(o+uint32(2)*(b+n/uint32(2)))*4)), sw) - os = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + uintptr(o+uint32(2)*(b+n/uint32(2))+uint32(1))*4)), sw) - if uint64(os) >= size || uint64(ol) >= size-uint64(os) || *(*uint8)(unsafe.Pointer(p + uintptr(os+ol))) != 0 { + ol = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + uintptr(o+uint32(2)*(b+n/uint32(2)))*4)), sw) + os = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + uintptr(o+uint32(2)*(b+n/uint32(2))+uint32(1))*4)), sw) + if uint64(os) >= size || uint64(ol) >= size-uint64(os) || **(**uint8)(__ccgo_up(p + uintptr(os+ol))) != 0 { return uintptr(0) } sign = Xstrcmp(tls, s, p+uintptr(os)) if !(sign != 0) { - tl = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + uintptr(t+uint32(2)*(b+n/uint32(2)))*4)), sw) - ts = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + uintptr(t+uint32(2)*(b+n/uint32(2))+uint32(1))*4)), sw) - if uint64(ts) >= size || uint64(tl) >= size-uint64(ts) || *(*uint8)(unsafe.Pointer(p + uintptr(ts+tl))) != 0 { + tl = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + uintptr(t+uint32(2)*(b+n/uint32(2)))*4)), sw) + ts = _swapc(tls, **(**Tuint32_t)(__ccgo_up(mo + uintptr(t+uint32(2)*(b+n/uint32(2))+uint32(1))*4)), sw) + if uint64(ts) >= size || uint64(tl) >= size-uint64(ts) || **(**uint8)(__ccgo_up(p + uintptr(ts+tl))) != 0 { return uintptr(0) } return p + uintptr(ts) @@ -31208,7 +31208,7 @@ func Xbind_textdomain_codeset(tls *TLS, domainname uintptr, codeset uintptr) (r defer func() { trc("-> %v", r) }() } if codeset != 0 && Xstrcasecmp(tls, codeset, __ccgo_ts+411) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) } return UintptrFromInt32(0) } @@ -31235,7 +31235,7 @@ func Xcatclose(tls *TLS, catd Tnl_catd) (r int32) { var map1 uintptr _ = map1 map1 = catd - Xmunmap(tls, map1, uint64(*(*Tuint32_t)(unsafe.Pointer(map1 + UintptrFromInt32(8)))+uint32(20))) + Xmunmap(tls, map1, uint64(**(**Tuint32_t)(__ccgo_up(map1 + UintptrFromInt32(8)))+uint32(20))) return 0 } @@ -31243,8 +31243,8 @@ func _cmp(tls *TLS, a uintptr, b uintptr) (r int32) { var x, y Tuint32_t var v1, v2 int32 _, _, _, _ = x, y, v1, v2 - x = *(*Tuint32_t)(unsafe.Pointer(a)) - y = *(*Tuint32_t)(unsafe.Pointer(b)) + x = **(**Tuint32_t)(__ccgo_up(a)) + y = **(**Tuint32_t)(__ccgo_up(b)) if x < y { v1 = -int32(1) } else { @@ -31271,25 +31271,25 @@ func Xcatgets(tls *TLS, catd Tnl_catd, set_id int32, msg_id int32, s uintptr) (r var _ /* set_id_be at bp+0 */ Tuint32_t _, _, _, _, _, _, _, _ = map1, msg, msgs, nmsgs, nsets, set, sets, strings map1 = catd - nsets = *(*Tuint32_t)(unsafe.Pointer(map1 + UintptrFromInt32(4))) + nsets = **(**Tuint32_t)(__ccgo_up(map1 + UintptrFromInt32(4))) sets = map1 + uintptr(20) - msgs = map1 + uintptr(20) + uintptr(*(*Tuint32_t)(unsafe.Pointer(map1 + UintptrFromInt32(12)))) - strings = map1 + uintptr(20) + uintptr(*(*Tuint32_t)(unsafe.Pointer(map1 + UintptrFromInt32(16)))) - *(*Tuint32_t)(unsafe.Pointer(bp)) = Uint32FromInt32(set_id) - *(*Tuint32_t)(unsafe.Pointer(bp + 4)) = Uint32FromInt32(msg_id) + msgs = map1 + uintptr(20) + uintptr(**(**Tuint32_t)(__ccgo_up(map1 + UintptrFromInt32(12)))) + strings = map1 + uintptr(20) + uintptr(**(**Tuint32_t)(__ccgo_up(map1 + UintptrFromInt32(16)))) + **(**Tuint32_t)(__ccgo_up(bp)) = Uint32FromInt32(set_id) + **(**Tuint32_t)(__ccgo_up(bp + 4)) = Uint32FromInt32(msg_id) set = Xbsearch(tls, bp, sets, uint64(nsets), uint64(12), __ccgo_fp(_cmp)) if !(set != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMSG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMSG) return s } - nmsgs = *(*Tuint32_t)(unsafe.Pointer(set + UintptrFromInt32(4))) - msgs = msgs + uintptr(uint32(12)**(*Tuint32_t)(unsafe.Pointer(set + UintptrFromInt32(8)))) + nmsgs = **(**Tuint32_t)(__ccgo_up(set + UintptrFromInt32(4))) + msgs = msgs + uintptr(uint32(12)***(**Tuint32_t)(__ccgo_up(set + UintptrFromInt32(8)))) msg = Xbsearch(tls, bp+4, msgs, uint64(nmsgs), uint64(12), __ccgo_fp(_cmp)) if !(msg != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMSG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMSG) return s } - return strings + uintptr(*(*Tuint32_t)(unsafe.Pointer(msg + UintptrFromInt32(8)))) + return strings + uintptr(**(**Tuint32_t)(__ccgo_up(msg + UintptrFromInt32(8)))) } const ABDAY_1 = 131072 @@ -31359,11 +31359,11 @@ func _do_catopen(tls *TLS, name uintptr) (r Tnl_catd) { map1 = X__map_file(tls, name, bp) /* Size recorded in the file must match file size; otherwise * the information needed to unmap the file will be lost. */ - if !(map1 != 0) || *(*Tuint32_t)(unsafe.Pointer(map1)) != uint32(0xff88ff89) || uint64(uint32(20)+*(*Tuint32_t)(unsafe.Pointer(map1 + UintptrFromInt32(8)))) != *(*Tsize_t)(unsafe.Pointer(bp)) { + if !(map1 != 0) || **(**Tuint32_t)(__ccgo_up(map1)) != uint32(0xff88ff89) || uint64(uint32(20)+**(**Tuint32_t)(__ccgo_up(map1 + UintptrFromInt32(8)))) != **(**Tsize_t)(__ccgo_up(bp)) { if map1 != 0 { - Xmunmap(tls, map1, *(*Tsize_t)(unsafe.Pointer(bp))) + Xmunmap(tls, map1, **(**Tsize_t)(__ccgo_up(bp))) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOENT) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOENT) return uintptr(-Int32FromInt32(1)) } return map1 @@ -31390,7 +31390,7 @@ func Xcatopen(tls *TLS, name uintptr, oflag int32) (r Tnl_catd) { path = v1 } if v2 || !(v1 != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOENT) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOENT) return uintptr(-Int32FromInt32(1)) } if oflag != 0 { @@ -31404,7 +31404,7 @@ func Xcatopen(tls *TLS, name uintptr, oflag int32) (r Tnl_catd) { } p = path for { - if !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if !(**(**uint8)(__ccgo_up(p)) != 0) { break } i = uint64(0) @@ -31413,13 +31413,13 @@ func Xcatopen(tls *TLS, name uintptr, oflag int32) (r Tnl_catd) { if !(p < z) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32('%') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) != int32('%') { v = p l = Uint64FromInt32(1) } else { p = p + 1 v1 = p - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(v1))) { case int32('N'): v = name l = _strlen(tls, v) @@ -31431,7 +31431,7 @@ func Xcatopen(tls *TLS, name uintptr, oflag int32) (r Tnl_catd) { l = Xstrcspn(tls, v, __ccgo_ts+430) case int32('t'): v = X__strchrnul(tls, lang, int32('_')) - if *(*uint8)(unsafe.Pointer(v)) != 0 { + if **(**uint8)(__ccgo_up(v)) != 0 { v = v + 1 } l = Xstrcspn(tls, v, __ccgo_ts+434) @@ -31455,16 +31455,16 @@ func Xcatopen(tls *TLS, name uintptr, oflag int32) (r Tnl_catd) { ; p = p + 1 } - if !(*(*uint8)(unsafe.Pointer(z)) != 0) && (p < z || !(i != 0)) { + if !(**(**uint8)(__ccgo_up(z)) != 0) && (p < z || !(i != 0)) { break } if p < z { goto _4 } - if *(*uint8)(unsafe.Pointer(z)) != 0 { + if **(**uint8)(__ccgo_up(z)) != 0 { z = z + 1 } - (*(*[4096]uint8)(unsafe.Pointer(bp)))[i] = uint8(0) + (**(**[4096]uint8)(__ccgo_up(bp)))[i] = uint8(0) /* Leading : or :: in NLSPATH is same as %N */ if i != 0 { v1 = bp @@ -31480,7 +31480,7 @@ func Xcatopen(tls *TLS, name uintptr, oflag int32) (r Tnl_catd) { ; p = z } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOENT) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOENT) return uintptr(-Int32FromInt32(1)) } @@ -31508,7 +31508,7 @@ func _gettextdir(tls *TLS, domainname uintptr, dirlen uintptr) (r uintptr) { break } if !(Xstrcmp(tls, (*Tbinding)(unsafe.Pointer(p)).Fdomainname, domainname) != 0) && AtomicLoadPInt32(p+12) != 0 { - *(*Tsize_t)(unsafe.Pointer(dirlen)) = Uint64FromInt32((*Tbinding)(unsafe.Pointer(p)).Fdirlen) + **(**Tsize_t)(__ccgo_up(dirlen)) = Uint64FromInt32((*Tbinding)(unsafe.Pointer(p)).Fdirlen) return (*Tbinding)(unsafe.Pointer(p)).Fdirname } goto _1 @@ -31541,7 +31541,7 @@ func Xbindtextdomain(tls *TLS, domainname uintptr, dirname uintptr) (r uintptr) domlen = Xstrnlen(tls, domainname, Uint64FromInt32(Int32FromInt32(NAME_MAX)+Int32FromInt32(1))) dirlen = Xstrnlen(tls, dirname, uint64(PATH_MAX)) if domlen > uint64(NAME_MAX) || dirlen >= uint64(PATH_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } ___lock(tls, uintptr(unsafe.Pointer(&_lock1))) @@ -31657,7 +31657,7 @@ func Xdcngettext(tls *TLS, domainname uintptr, msgid1 uintptr, msgid2 uintptr, n _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = alt_modlen, catlen, catname, csp, dirlen, dirname, domlen, l, lm, loc, loclen, locname, locp, map1, modlen, modname, name, np, old_cats, old_errno, p1, plural, q, r, rem, rule, trans, v11, v12, v21, v3, v5, v6, v8 defer func() { Xrealloc(tls, name, 0) }() loc = (*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale - old_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + old_errno = **(**int32)(__ccgo_up(X__errno_location(tls))) /* match gnu gettext behaviour */ if !(msgid1 != 0) { goto notrans @@ -31688,14 +31688,14 @@ func Xdcngettext(tls *TLS, domainname uintptr, msgid1 uintptr, msgid2 uintptr, n if !(q != 0) { goto notrans } - lm = *(*uintptr)(unsafe.Pointer(loc + uintptr(category)*8)) + lm = **(**uintptr)(__ccgo_up(loc + uintptr(category)*8)) if !!(lm != 0) { goto _2 } goto notrans notrans: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = old_errno + **(**int32)(__ccgo_up(X__errno_location(tls))) = old_errno if n == uint64(1) { v3 = msgid1 } else { @@ -31768,21 +31768,21 @@ _2: } p1 = Xcalloc(tls, uint64(64), uint64(1)) if !(p1 != 0) { - X__munmap(tls, map1, *(*Tsize_t)(unsafe.Pointer(bp))) + X__munmap(tls, map1, **(**Tsize_t)(__ccgo_up(bp))) goto notrans } (*Tmsgcat)(unsafe.Pointer(p1)).Fcat = category (*Tmsgcat)(unsafe.Pointer(p1)).Fbinding = q (*Tmsgcat)(unsafe.Pointer(p1)).Flm = lm (*Tmsgcat)(unsafe.Pointer(p1)).Fmap1 = map1 - (*Tmsgcat)(unsafe.Pointer(p1)).Fmap_size = *(*Tsize_t)(unsafe.Pointer(bp)) + (*Tmsgcat)(unsafe.Pointer(p1)).Fmap_size = **(**Tsize_t)(__ccgo_up(bp)) rule = __ccgo_ts + 485 np = uint64(2) r = X__mo_lookup(tls, (*Tmsgcat)(unsafe.Pointer(p1)).Fmap1, (*Tmsgcat)(unsafe.Pointer(p1)).Fmap_size, __ccgo_ts) for r != 0 && Xstrncmp(tls, r, __ccgo_ts+491, uint64(13)) != 0 { - *(*uintptr)(unsafe.Pointer(bp + 8)) = Xstrchr(tls, r, int32('\n')) - if *(*uintptr)(unsafe.Pointer(bp + 8)) != 0 { - v3 = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(1) + **(**uintptr)(__ccgo_up(bp + 8)) = Xstrchr(tls, r, int32('\n')) + if **(**uintptr)(__ccgo_up(bp + 8)) != 0 { + v3 = **(**uintptr)(__ccgo_up(bp + 8)) + uintptr(1) } else { v3 = uintptr(0) } @@ -31791,7 +31791,7 @@ _2: if r != 0 { r = r + uintptr(13) for { - v11 = Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) + v11 = Int32FromUint8(**(**uint8)(__ccgo_up(r))) v12 = BoolInt32(v11 == int32(' ') || Uint32FromInt32(v11)-uint32('\t') < uint32(5)) goto _13 _13: @@ -31802,15 +31802,15 @@ _2: } if !(Xstrncmp(tls, r, __ccgo_ts+505, uint64(9)) != 0) { np = Xstrtoul(tls, r+uintptr(9), bp+8, int32(10)) - r = *(*uintptr)(unsafe.Pointer(bp + 8)) + r = **(**uintptr)(__ccgo_up(bp + 8)) } - for *(*uint8)(unsafe.Pointer(r)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) != int32(';') { + for **(**uint8)(__ccgo_up(r)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(r))) != int32(';') { r = r + 1 } - if *(*uint8)(unsafe.Pointer(r)) != 0 { + if **(**uint8)(__ccgo_up(r)) != 0 { r = r + 1 for { - v11 = Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) + v11 = Int32FromUint8(**(**uint8)(__ccgo_up(r))) v12 = BoolInt32(v11 == int32(' ') || Uint32FromInt32(v11)-uint32('\t') < uint32(5)) goto _16 _16: @@ -31873,7 +31873,7 @@ _2: trans = trans + uintptr(l+uint64(1)) } } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = old_errno + **(**int32)(__ccgo_up(X__errno_location(tls))) = old_errno return trans } @@ -31917,7 +31917,7 @@ func X__duplocale(tls *TLS, old Tlocale_t) (r Tlocale_t) { if old == uintptr(-Int32FromInt32(1)) { old = uintptr(unsafe.Pointer(&X__libc)) + 56 } - *(*t__locale_struct)(unsafe.Pointer(new1)) = *(*t__locale_struct)(unsafe.Pointer(old)) + **(**t__locale_struct)(__ccgo_up(new1)) = **(**t__locale_struct)(__ccgo_up(old)) return new1 } @@ -98091,13 +98091,13 @@ var _rev_jis = [6879]uint16{ func _fuzzycmp(tls *TLS, a uintptr, b uintptr) (r int32) { for { - if !(*(*uint8)(unsafe.Pointer(a)) != 0 && *(*uint8)(unsafe.Pointer(b)) != 0) { + if !(**(**uint8)(__ccgo_up(a)) != 0 && **(**uint8)(__ccgo_up(b)) != 0) { break } - for *(*uint8)(unsafe.Pointer(a)) != 0 && uint32(*(*uint8)(unsafe.Pointer(a)))|uint32(32)-uint32('a') > uint32(26) && Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(a)))-int32('0')) > uint32(10) { + for **(**uint8)(__ccgo_up(a)) != 0 && uint32(**(**uint8)(__ccgo_up(a)))|uint32(32)-uint32('a') > uint32(26) && Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(a)))-int32('0')) > uint32(10) { a = a + 1 } - if uint32(*(*uint8)(unsafe.Pointer(a)))|uint32(32) != uint32(*(*uint8)(unsafe.Pointer(b))) { + if uint32(**(**uint8)(__ccgo_up(a)))|uint32(32) != uint32(**(**uint8)(__ccgo_up(b))) { return int32(1) } goto _1 @@ -98106,23 +98106,23 @@ func _fuzzycmp(tls *TLS, a uintptr, b uintptr) (r int32) { a = a + 1 b = b + 1 } - return BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(a))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(b)))) + return BoolInt32(Int32FromUint8(**(**uint8)(__ccgo_up(a))) != Int32FromUint8(**(**uint8)(__ccgo_up(b)))) } func _find_charmap(tls *TLS, name uintptr) (r Tsize_t) { var s uintptr _ = s - if !(*(*uint8)(unsafe.Pointer(name)) != 0) { + if !(**(**uint8)(__ccgo_up(name)) != 0) { name = uintptr(unsafe.Pointer(&_charmaps)) } /* "utf8" */ s = uintptr(unsafe.Pointer(&_charmaps)) for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { break } if !(_fuzzycmp(tls, name, s) != 0) { for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { break } goto _2 @@ -98133,11 +98133,11 @@ func _find_charmap(tls *TLS, name uintptr) (r Tsize_t) { return Uint64FromInt64(int64(s+uintptr(1)) - t__predefined_ptrdiff_t(uintptr(unsafe.Pointer(&_charmaps)))) } s = s + uintptr(_strlen(tls, s)+uint64(1)) - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) > int32(0200) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { + if Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) > int32(0200) { s = s + uintptr(2) } else { - s = s + uintptr(uint32(2)+(uint32(64)-uint32(*(*uint8)(unsafe.Pointer(s + 1))))*uint32(5)) + s = s + uintptr(uint32(2)+(uint32(64)-uint32(**(**uint8)(__ccgo_up(s + 1))))*uint32(5)) } } goto _1 @@ -98180,7 +98180,7 @@ func Xiconv_open(tls *TLS, to uintptr, from uintptr) (r Ticonv_t) { f = v2 } if v3 || v2 == Uint64FromInt32(-Int32FromInt32(1)) || Int32FromUint8(_charmaps[t]) >= int32(0330) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(-Int32FromInt32(1)) } cd = _combine_to_from(tls, t, f) @@ -98205,26 +98205,26 @@ func Xiconv_open(tls *TLS, to uintptr, from uintptr) (r Ticonv_t) { func _get_16(tls *TLS, s uintptr, e int32) (r uint32) { e = e & int32(1) - return Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(e))))<> int32(8)) - *(*uint8)(unsafe.Pointer(s + uintptr(int32(1)-e))) = uint8(c) + **(**uint8)(__ccgo_up(s + uintptr(e))) = uint8(c >> int32(8)) + **(**uint8)(__ccgo_up(s + uintptr(int32(1)-e))) = uint8(c) } func _get_32(tls *TLS, s uintptr, e int32) (r uint32) { e = e & int32(3) - return (uint32(*(*uint8)(unsafe.Pointer(s + uintptr(e))))+0)<> int32(24)) - *(*uint8)(unsafe.Pointer(s + uintptr(e^int32(1)))) = uint8(c >> int32(16)) - *(*uint8)(unsafe.Pointer(s + uintptr(e^int32(2)))) = uint8(c >> int32(8)) - *(*uint8)(unsafe.Pointer(s + uintptr(e^int32(3)))) = uint8(c) + **(**uint8)(__ccgo_up(s + uintptr(e^0))) = uint8(c >> int32(24)) + **(**uint8)(__ccgo_up(s + uintptr(e^int32(1)))) = uint8(c >> int32(16)) + **(**uint8)(__ccgo_up(s + uintptr(e^int32(2)))) = uint8(c >> int32(8)) + **(**uint8)(__ccgo_up(s + uintptr(e^int32(3)))) = uint8(c) } /* Adapt as needed */ @@ -98232,11 +98232,11 @@ func _put_32(tls *TLS, s uintptr, c uint32, e int32) { func _legacy_map(tls *TLS, map1 uintptr, c uint32) (r uint32) { var x, v1 uint32 _, _ = x, v1 - if c < Uint32FromInt32(int32(4)*Int32FromUint8(*(*uint8)(unsafe.Pointer(map1 + uintptr(-Int32FromInt32(1)))))) { + if c < Uint32FromInt32(int32(4)*Int32FromUint8(**(**uint8)(__ccgo_up(map1 + uintptr(-Int32FromInt32(1)))))) { return c } - x = c - Uint32FromInt32(int32(4)*Int32FromUint8(*(*uint8)(unsafe.Pointer(map1 + uintptr(-Int32FromInt32(1)))))) - x = Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(map1 + uintptr(x*uint32(5)/uint32(4)))))>>(uint32(2)*x%uint32(8)) | Int32FromUint8(*(*uint8)(unsafe.Pointer(map1 + uintptr(x*uint32(5)/uint32(4)+uint32(1)))))<<(uint32(8)-uint32(2)*x%uint32(8))&int32(1023)) + x = c - Uint32FromInt32(int32(4)*Int32FromUint8(**(**uint8)(__ccgo_up(map1 + uintptr(-Int32FromInt32(1)))))) + x = Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(map1 + uintptr(x*uint32(5)/uint32(4)))))>>(uint32(2)*x%uint32(8)) | Int32FromUint8(**(**uint8)(__ccgo_up(map1 + uintptr(x*uint32(5)/uint32(4)+uint32(1)))))<<(uint32(8)-uint32(2)*x%uint32(8))&int32(1023)) if x < uint32(256) { v1 = x } else { @@ -98253,7 +98253,7 @@ func _uni_to_jis(tls *TLS, c uint32) (r uint32) { for { i = nel / uint32(2) j = uint32(_rev_jis[b+i]) - d = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(j/uint32(256))*188 + uintptr(j%uint32(256))*2))) + d = uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(j/uint32(256))*188 + uintptr(j%uint32(256))*2))) if d == c { return j + uint32(0x2121) } else { @@ -98306,20 +98306,20 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui from = uint32(_extract_from(tls, cd)) map1 = uintptr(unsafe.Pointer(&_charmaps)) + uintptr(from) + uintptr(1) tomap = uintptr(unsafe.Pointer(&_charmaps)) + uintptr(to) + uintptr(1) - *(*Tmbstate_t)(unsafe.Pointer(bp + 24)) = Tmbstate_t{} - type1 = *(*uint8)(unsafe.Pointer(map1 + uintptr(-Int32FromInt32(1)))) - totype = *(*uint8)(unsafe.Pointer(tomap + uintptr(-Int32FromInt32(1)))) + **(**Tmbstate_t)(__ccgo_up(bp + 24)) = Tmbstate_t{} + type1 = **(**uint8)(__ccgo_up(map1 + uintptr(-Int32FromInt32(1)))) + totype = **(**uint8)(__ccgo_up(tomap + uintptr(-Int32FromInt32(1)))) ploc = uintptr(___get_tp(tls)) + 168 - loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) - if !(in != 0) || !(*(*uintptr)(unsafe.Pointer(in)) != 0) || !(*(*Tsize_t)(unsafe.Pointer(inb)) != 0) { + loc = **(**Tlocale_t)(__ccgo_up(ploc)) + if !(in != 0) || !(**(**uintptr)(__ccgo_up(in)) != 0) || !(**(**Tsize_t)(__ccgo_up(inb)) != 0) { return uint64(0) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = uintptr(unsafe.Pointer(&X__c_dot_utf8_locale)) + **(**Tlocale_t)(__ccgo_up(ploc)) = uintptr(unsafe.Pointer(&X__c_dot_utf8_locale)) for { - if !(*(*Tsize_t)(unsafe.Pointer(inb)) != 0) { + if !(**(**Tsize_t)(__ccgo_up(inb)) != 0) { break } - c = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in))))) + c = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in))))) l = uint64(1) switch Int32FromUint8(type1) { case int32(UTF_8): @@ -98371,14 +98371,14 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if c < uint32(128) { goto _23 } - l = Xmbrtowc(tls, bp+32, *(*uintptr)(unsafe.Pointer(in)), *(*Tsize_t)(unsafe.Pointer(inb)), bp+24) + l = Xmbrtowc(tls, bp+32, **(**uintptr)(__ccgo_up(in)), **(**Tsize_t)(__ccgo_up(inb)), bp+24) if l == Uint64FromInt32(-Int32FromInt32(1)) { goto ilseq } if l == Uint64FromInt32(-Int32FromInt32(2)) { goto starved } - c = Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp + 32))) + c = Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp + 32))) goto _23 _3: ; @@ -98389,10 +98389,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui _4: ; l = uint64(4) - if *(*Tsize_t)(unsafe.Pointer(inb)) < l { + if **(**Tsize_t)(__ccgo_up(inb)) < l { goto starved } - c = Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in))))) + c = Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(in))))) if !(0 != 0) { goto _24 } @@ -98401,10 +98401,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui _5: ; l = uint64(4) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(4) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(4) { goto starved } - c = _get_32(tls, *(*uintptr)(unsafe.Pointer(in)), Int32FromUint8(type1)) + c = _get_32(tls, **(**uintptr)(__ccgo_up(in)), Int32FromUint8(type1)) _24: ; if c-uint32(0xd800) < uint32(0x800) || c >= uint32(0x110000) { @@ -98420,10 +98420,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui _7: ; l = uint64(2) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(2) { goto starved } - c = _get_16(tls, *(*uintptr)(unsafe.Pointer(in)), Int32FromUint8(type1)) + c = _get_16(tls, **(**uintptr)(__ccgo_up(in)), Int32FromUint8(type1)) if c-Uint32FromInt32(0xdc00) < uint32(0x400) { goto ilseq } @@ -98432,10 +98432,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto ilseq } l = uint64(4) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(4) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(4) { goto starved } - d = _get_16(tls, *(*uintptr)(unsafe.Pointer(in))+UintptrFromInt32(2), Int32FromUint8(type1)) + d = _get_16(tls, **(**uintptr)(__ccgo_up(in))+UintptrFromInt32(2), Int32FromUint8(type1)) if d-Uint32FromInt32(0xdc00) >= uint32(0x400) { goto ilseq } @@ -98448,10 +98448,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui ; l = uint64(0) if !((*Tstateful_cd)(unsafe.Pointer(scd)).Fstate != 0) { - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(2) { goto starved } - c = _get_16(tls, *(*uintptr)(unsafe.Pointer(in)), 0) + c = _get_16(tls, **(**uintptr)(__ccgo_up(in)), 0) if Int32FromUint8(type1) == int32(UCS2) { if c == uint32(0xfffe) { v26 = int32(UCS2LE) @@ -98478,10 +98478,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui ; l = uint64(0) if !((*Tstateful_cd)(unsafe.Pointer(scd)).Fstate != 0) { - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(4) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(4) { goto starved } - c = _get_32(tls, *(*uintptr)(unsafe.Pointer(in)), 0) + c = _get_32(tls, **(**uintptr)(__ccgo_up(in)), 0) if c == uint32(0xfffe0000) { v25 = int32(UTF_32LE) } else { @@ -98504,10 +98504,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _23 } l = uint64(2) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(2) { goto starved } - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(1)))) if c-uint32(129) <= Uint32FromInt32(Int32FromInt32(159)-Int32FromInt32(129)) { c = c - uint32(129) } else { @@ -98535,7 +98535,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if c >= uint32(84) { goto ilseq } - c = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(c)*188 + uintptr(d)*2))) + c = uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(c)*188 + uintptr(d)*2))) if !(c != 0) { goto ilseq } @@ -98546,10 +98546,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _23 } l = uint64(2) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(2) { goto starved } - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(1)))) if c == uint32(0x8e) { c = d if c-uint32(0xa1) > Uint32FromInt32(Int32FromInt32(0xdf)-Int32FromInt32(0xa1)) { @@ -98563,7 +98563,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if c >= uint32(84) || d >= uint32(94) { goto ilseq } - c = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(c)*188 + uintptr(d)*2))) + c = uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(c)*188 + uintptr(d)*2))) if !(c != 0) { goto ilseq } @@ -98575,11 +98575,11 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } if c == uint32('\033') { l = uint64(3) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(3) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(3) { goto starved } - c = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(2)))) + c = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(1)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(2)))) if c != uint32('(') && c != uint32('$') { goto ilseq } @@ -98614,16 +98614,16 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui fallthrough case uint32(3): l = uint64(2) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(2) { goto starved } - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(1)))) c = c - uint32(0x21) d = d - uint32(0x21) if c >= uint32(84) || d >= uint32(94) { goto ilseq } - c = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(c)*188 + uintptr(d)*2))) + c = uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_jis0208)) + uintptr(c)*188 + uintptr(d)*2))) if !(c != 0) { goto ilseq } @@ -98661,10 +98661,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto ilseq } l = uint64(2) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(2) { goto starved } - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(1)))) if d < uint32(0xa1) && Int32FromUint8(type1) == int32(GB2312) { goto ilseq } @@ -98673,16 +98673,16 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto ilseq } l = uint64(4) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(4) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(4) { goto starved } c = (uint32(10)*c + d - uint32('0')) * uint32(1260) - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(2)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(2)))) if d-uint32(0x81) > uint32(126) { goto ilseq } c = c + uint32(10)*(d-uint32(0x81)) - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(3)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(3)))) if d-uint32('0') > uint32(9) { goto ilseq } @@ -98704,7 +98704,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if !(j < int32(190)) { break } - if uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_gb18030)) + uintptr(i)*380 + uintptr(j)*2)))-d <= c-d { + if uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_gb18030)) + uintptr(i)*380 + uintptr(j)*2)))-d <= c-d { k = k + 1 } goto _31 @@ -98728,7 +98728,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if d > uint32(63) { d = d - 1 } - c = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_gb18030)) + uintptr(c)*380 + uintptr(d)*2))) + c = uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_gb18030)) + uintptr(c)*380 + uintptr(d)*2))) goto _23 _20: ; @@ -98736,10 +98736,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _23 } l = uint64(2) - if *(*Tsize_t)(unsafe.Pointer(inb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(inb)) < uint64(2) { goto starved } - d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) + d = uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(in)) + UintptrFromInt32(1)))) if d-uint32(0x40) >= Uint32FromInt32(Int32FromInt32(0xff)-Int32FromInt32(0x40)) || d-uint32(0x7f) < Uint32FromInt32(Int32FromInt32(0xa1)-Int32FromInt32(0x7f)) { goto ilseq } @@ -98762,21 +98762,21 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui * range in the hkscs table then hard-coded * here. Ugly, yes. */ if c/uint32(256) == uint32(0xdc) { - *(*uintptr)(unsafe.Pointer(bp + 48)) = bp + 40 + **(**uintptr)(__ccgo_up(bp + 48)) = bp + 40 *(*uintptr)(unsafe.Pointer(bp)) = __ccgo_ts + 534 + uintptr(c%uint32(256)) *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint64(4) *(*Tsize_t)(unsafe.Pointer(bp + 16)) = uint64(8) tmpx = Xiconv(tls, _combine_to_from(tls, uint64(to), _find_charmap(tls, __ccgo_ts+551)), bp, bp+8, bp+48, bp+16) - tmplen = Uint64FromInt64(int64(*(*uintptr)(unsafe.Pointer(bp + 48))) - t__predefined_ptrdiff_t(bp+40)) - if tmplen > *(*Tsize_t)(unsafe.Pointer(outb)) { + tmplen = Uint64FromInt64(int64(**(**uintptr)(__ccgo_up(bp + 48))) - t__predefined_ptrdiff_t(bp+40)) + if tmplen > **(**Tsize_t)(__ccgo_up(outb)) { goto toobig } if tmpx != 0 { x = x + 1 } - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(out)), bp+40, tmplen) - *(*uintptr)(unsafe.Pointer(out)) += uintptr(tmplen) - *(*Tsize_t)(unsafe.Pointer(outb)) -= tmplen + Xmemcpy(tls, **(**uintptr)(__ccgo_up(out)), bp+40, tmplen) + **(**uintptr)(__ccgo_up(out)) += uintptr(tmplen) + **(**Tsize_t)(__ccgo_up(outb)) -= tmplen goto _1 } if !(c != 0) { @@ -98785,7 +98785,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _23 } c = c - uint32(0xa1) - c = Uint32FromInt32(Int32FromUint16(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_big5)) + uintptr(c)*314 + uintptr(d)*2))) | BoolInt32(c == uint32(0x27) && (d == uint32(0x3a) || d == uint32(0x3c) || d == uint32(0x42)))<= uint32(93) || d >= uint32(94) { @@ -98843,7 +98843,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if !(j1 < int32(94)) { break } - if uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ksc)) + uintptr(i1)*188 + uintptr(j1)*2)))-d <= c-d { + if uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_ksc)) + uintptr(i1)*188 + uintptr(j1)*2)))-d <= c-d { k = k + 1 } goto _34 @@ -98863,7 +98863,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } goto _23 } - c = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ksc)) + uintptr(c)*188 + uintptr(d)*2))) + c = uint32(**(**uint16)(__ccgo_up(uintptr(unsafe.Pointer(&_ksc)) + uintptr(c)*188 + uintptr(d)*2))) if !(c != 0) { goto ilseq } @@ -98916,26 +98916,26 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _51 _35: ; - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(4) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(4) { goto toobig } - *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(out)))) = Int32FromUint32(c) - *(*uintptr)(unsafe.Pointer(out)) += uintptr(4) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(4) + **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(out)))) = Int32FromUint32(c) + **(**uintptr)(__ccgo_up(out)) += uintptr(4) + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(4) goto _51 _36: ; - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(4) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(4) { k = Uint64FromInt32(Xwctomb(tls, bp+56, Int32FromUint32(c))) - if *(*Tsize_t)(unsafe.Pointer(outb)) < k { + if **(**Tsize_t)(__ccgo_up(outb)) < k { goto toobig } - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(out)), bp+56, k) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(out)), bp+56, k) } else { - k = Uint64FromInt32(Xwctomb(tls, *(*uintptr)(unsafe.Pointer(out)), Int32FromUint32(c))) + k = Uint64FromInt32(Xwctomb(tls, **(**uintptr)(__ccgo_up(out)), Int32FromUint32(c))) } - *(*uintptr)(unsafe.Pointer(out)) += uintptr(k) - *(*Tsize_t)(unsafe.Pointer(outb)) -= k + **(**uintptr)(__ccgo_up(out)) += uintptr(k) + **(**Tsize_t)(__ccgo_up(outb)) -= k goto _51 _37: ; @@ -98951,7 +98951,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui ; _38: ; - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(1) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(1) { goto toobig } if !(c < uint32(256) && c == _legacy_map(tls, tomap, c)) { @@ -98960,14 +98960,14 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto revout revout: ; - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(1) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(1) { goto toobig } v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8(c) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(1) + **(**uint8)(__ccgo_up(v54)) = uint8(c) + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(1) goto _51 _53: ; @@ -99009,7 +99009,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if !(c != 0) { goto subst } - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(2) { goto toobig } d = c % uint32(256) @@ -99022,7 +99022,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } else { v25 = int32(176) } - *(*uint8)(unsafe.Pointer(v54)) = uint8((c+uint32(1))/uint32(2) + Uint32FromInt32(v25)) + **(**uint8)(__ccgo_up(v54)) = uint8((c+uint32(1))/uint32(2) + Uint32FromInt32(v25)) v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 @@ -99031,8 +99031,8 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } else { v62 = d + uint32(126) } - *(*uint8)(unsafe.Pointer(v54)) = uint8(v62) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(2) + **(**uint8)(__ccgo_up(v54)) = uint8(v62) + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(2) goto _51 _40: ; @@ -99047,18 +99047,18 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if !(c != 0) { goto subst } - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(2) { goto toobig } v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8(c/uint32(256) + uint32(0x80)) + **(**uint8)(__ccgo_up(v54)) = uint8(c/uint32(256) + uint32(0x80)) v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8(c%uint32(256) + uint32(0x80)) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(2) + **(**uint8)(__ccgo_up(v54)) = uint8(c%uint32(256) + uint32(0x80)) + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(2) goto _51 _41: ; @@ -99066,102 +99066,102 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto revout } if c-uint32(0xff61) <= Uint32FromInt32(Int32FromInt32(0xdf)-Int32FromInt32(0xa1)) || c == uint32(0xa5) || c == uint32(0x203e) { - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(7) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(7) { goto toobig } v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('\033') + **(**uint8)(__ccgo_up(v54)) = uint8('\033') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('(') + **(**uint8)(__ccgo_up(v54)) = uint8('(') if c == uint32(0xa5) { v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('J') + **(**uint8)(__ccgo_up(v54)) = uint8('J') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('\\') + **(**uint8)(__ccgo_up(v54)) = uint8('\\') } else { if c == uint32(0x203e) { v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('J') + **(**uint8)(__ccgo_up(v54)) = uint8('J') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('~') + **(**uint8)(__ccgo_up(v54)) = uint8('~') } else { v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('I') + **(**uint8)(__ccgo_up(v54)) = uint8('I') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8(c - uint32(0xff61) + uint32(0x21)) + **(**uint8)(__ccgo_up(v54)) = uint8(c - uint32(0xff61) + uint32(0x21)) } } v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('\033') + **(**uint8)(__ccgo_up(v54)) = uint8('\033') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('(') + **(**uint8)(__ccgo_up(v54)) = uint8('(') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('B') - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(7) + **(**uint8)(__ccgo_up(v54)) = uint8('B') + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(7) goto _51 } c = _uni_to_jis(tls, c) if !(c != 0) { goto subst } - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(8) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(8) { goto toobig } v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('\033') + **(**uint8)(__ccgo_up(v54)) = uint8('\033') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('$') + **(**uint8)(__ccgo_up(v54)) = uint8('$') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('B') + **(**uint8)(__ccgo_up(v54)) = uint8('B') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8(c / uint32(256)) + **(**uint8)(__ccgo_up(v54)) = uint8(c / uint32(256)) v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8(c % uint32(256)) + **(**uint8)(__ccgo_up(v54)) = uint8(c % uint32(256)) v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('\033') + **(**uint8)(__ccgo_up(v54)) = uint8('\033') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('(') + **(**uint8)(__ccgo_up(v54)) = uint8('(') v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 - *(*uint8)(unsafe.Pointer(v54)) = uint8('B') - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(8) + **(**uint8)(__ccgo_up(v54)) = uint8('B') + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(8) goto _51 _42: ; @@ -99180,22 +99180,22 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if c >= uint32(0x10000) { c = uint32(0xFFFD) } - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(2) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(2) { goto toobig } - _put_16(tls, *(*uintptr)(unsafe.Pointer(out)), c, Int32FromUint8(totype)) - *(*uintptr)(unsafe.Pointer(out)) += uintptr(2) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(2) + _put_16(tls, **(**uintptr)(__ccgo_up(out)), c, Int32FromUint8(totype)) + **(**uintptr)(__ccgo_up(out)) += uintptr(2) + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(2) goto _51 } - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(4) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(4) { goto toobig } c = c - uint32(0x10000) - _put_16(tls, *(*uintptr)(unsafe.Pointer(out)), c>>int32(10)|uint32(0xd800), Int32FromUint8(totype)) - _put_16(tls, *(*uintptr)(unsafe.Pointer(out))+UintptrFromInt32(2), c&uint32(0x3ff)|uint32(0xdc00), Int32FromUint8(totype)) - *(*uintptr)(unsafe.Pointer(out)) += uintptr(4) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(4) + _put_16(tls, **(**uintptr)(__ccgo_up(out)), c>>int32(10)|uint32(0xd800), Int32FromUint8(totype)) + _put_16(tls, **(**uintptr)(__ccgo_up(out))+UintptrFromInt32(2), c&uint32(0x3ff)|uint32(0xdc00), Int32FromUint8(totype)) + **(**uintptr)(__ccgo_up(out)) += uintptr(4) + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(4) goto _51 _48: ; @@ -99204,22 +99204,22 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui ; _49: ; - if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(4) { + if **(**Tsize_t)(__ccgo_up(outb)) < uint64(4) { goto toobig } - _put_32(tls, *(*uintptr)(unsafe.Pointer(out)), c, Int32FromUint8(totype)) - *(*uintptr)(unsafe.Pointer(out)) += uintptr(4) - *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(4) + _put_32(tls, **(**uintptr)(__ccgo_up(out)), c, Int32FromUint8(totype)) + **(**uintptr)(__ccgo_up(out)) += uintptr(4) + **(**Tsize_t)(__ccgo_up(outb)) -= uint64(4) goto _51 _51: ; goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(in)) += uintptr(l) - *(*Tsize_t)(unsafe.Pointer(inb)) -= l + **(**uintptr)(__ccgo_up(in)) += uintptr(l) + **(**Tsize_t)(__ccgo_up(inb)) -= l } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return x goto ilseq ilseq: @@ -99241,8 +99241,8 @@ starved: goto end end: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = err - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**int32)(__ccgo_up(X__errno_location(tls))) = err + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return x } @@ -99273,7 +99273,7 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { cat = item >> int32(16) idx = item & int32(65535) if item == int32(CODESET) { - if *(*uintptr)(unsafe.Pointer(loc)) != 0 { + if **(**uintptr)(__ccgo_up(loc)) != 0 { v1 = __ccgo_ts + 411 } else { v1 = __ccgo_ts + 556 @@ -99282,8 +99282,8 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { } /* _NL_LOCALE_NAME extension */ if idx == int32(65535) && cat < int32(LC_ALL) { - if *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*8)) != 0 { - v1 = *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*8)) + 16 + if **(**uintptr)(__ccgo_up(loc + uintptr(cat)*8)) != 0 { + v1 = **(**uintptr)(__ccgo_up(loc + uintptr(cat)*8)) + 16 } else { v1 = __ccgo_ts + 562 } @@ -99318,7 +99318,7 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { break } for { - if !(*(*uint8)(unsafe.Pointer(str)) != 0) { + if !(**(**uint8)(__ccgo_up(str)) != 0) { break } goto _4 @@ -99332,8 +99332,8 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { idx = idx - 1 str = str + 1 } - if cat != int32(LC_NUMERIC) && *(*uint8)(unsafe.Pointer(str)) != 0 { - str = X__lctrans(tls, str, *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*8))) + if cat != int32(LC_NUMERIC) && **(**uint8)(__ccgo_up(str)) != 0 { + str = X__lctrans(tls, str, **(**uintptr)(__ccgo_up(loc + uintptr(cat)*8))) } return str } @@ -99406,18 +99406,18 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = builtin, l, map1, n, new1, p, path, z, v1, v2, v3, v4, v5, v6, v7 new1 = uintptr(0) path = uintptr(0) - if !(*(*uint8)(unsafe.Pointer(val)) != 0) { + if !(**(**uint8)(__ccgo_up(val)) != 0) { v1 = Xgetenv(tls, __ccgo_ts+564) val = v1 - if v3 = v1 != 0 && *(*uint8)(unsafe.Pointer(val)) != 0; !v3 { + if v3 = v1 != 0 && **(**uint8)(__ccgo_up(val)) != 0; !v3 { v2 = Xgetenv(tls, uintptr(unsafe.Pointer(&_envvars))+uintptr(cat)*12) val = v2 } - if v5 = v3 || v2 != 0 && *(*uint8)(unsafe.Pointer(val)) != 0; !v5 { + if v5 = v3 || v2 != 0 && **(**uint8)(__ccgo_up(val)) != 0; !v5 { v4 = Xgetenv(tls, __ccgo_ts+425) val = v4 } - if v7 = v5 || v4 != 0 && *(*uint8)(unsafe.Pointer(val)) != 0; !v7 { + if v7 = v5 || v4 != 0 && **(**uint8)(__ccgo_up(val)) != 0; !v7 { v6 = __ccgo_ts + 571 val = v6 } @@ -99426,7 +99426,7 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { /* Limit name length and forbid leading dot or any slashes. */ n = uint64(0) for { - if !(n < uint64(LOCALE_NAME_MAX) && *(*uint8)(unsafe.Pointer(val + uintptr(n))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(val + uintptr(n)))) != int32('/')) { + if !(n < uint64(LOCALE_NAME_MAX) && **(**uint8)(__ccgo_up(val + uintptr(n))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(val + uintptr(n)))) != int32('/')) { break } goto _8 @@ -99434,12 +99434,12 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { ; n = n + 1 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(val))) == int32('.') || *(*uint8)(unsafe.Pointer(val + uintptr(n))) != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(val))) == int32('.') || **(**uint8)(__ccgo_up(val + uintptr(n))) != 0 { val = __ccgo_ts + 571 } - builtin = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(val))) == int32('C') && !(*(*uint8)(unsafe.Pointer(val + 1)) != 0) || !(Xstrcmp(tls, val, __ccgo_ts+571) != 0) || !(Xstrcmp(tls, val, __ccgo_ts+579) != 0)) + builtin = BoolInt32(Int32FromUint8(**(**uint8)(__ccgo_up(val))) == int32('C') && !(**(**uint8)(__ccgo_up(val + 1)) != 0) || !(Xstrcmp(tls, val, __ccgo_ts+571) != 0) || !(Xstrcmp(tls, val, __ccgo_ts+579) != 0)) if builtin != 0 { - if cat == LC_CTYPE && Int32FromUint8(*(*uint8)(unsafe.Pointer(val + 1))) == int32('.') { + if cat == LC_CTYPE && Int32FromUint8(**(**uint8)(__ccgo_up(val + 1))) == int32('.') { return uintptr(unsafe.Pointer(&X__c_dot_utf8)) } return uintptr(0) @@ -99463,7 +99463,7 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { /* FIXME: add a default path? */ if path != 0 { for { - if !(*(*uint8)(unsafe.Pointer(path)) != 0) { + if !(**(**uint8)(__ccgo_up(path)) != 0) { break } z = X__strchrnul(tls, path, int32(':')) @@ -99472,20 +99472,20 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { goto _10 } Xmemcpy(tls, bp, path, l) - (*(*[256]uint8)(unsafe.Pointer(bp)))[l] = uint8('/') + (**(**[256]uint8)(__ccgo_up(bp)))[l] = uint8('/') Xmemcpy(tls, bp+uintptr(l)+uintptr(1), val, n) - (*(*[256]uint8)(unsafe.Pointer(bp)))[l+uint64(1)+n] = uint8(0) + (**(**[256]uint8)(__ccgo_up(bp)))[l+uint64(1)+n] = uint8(0) map1 = X__map_file(tls, bp, bp+256) if map1 != 0 { new1 = Xmalloc(tls, uint64(48)) if !(new1 != 0) { - X__munmap(tls, map1, *(*Tsize_t)(unsafe.Pointer(bp + 256))) + X__munmap(tls, map1, **(**Tsize_t)(__ccgo_up(bp + 256))) break } (*t__locale_map)(unsafe.Pointer(new1)).Fmap1 = map1 - (*t__locale_map)(unsafe.Pointer(new1)).Fmap_size = *(*Tsize_t)(unsafe.Pointer(bp + 256)) + (*t__locale_map)(unsafe.Pointer(new1)).Fmap_size = **(**Tsize_t)(__ccgo_up(bp + 256)) Xmemcpy(tls, new1+16, val, n) - *(*uint8)(unsafe.Pointer(new1 + 16 + uintptr(n))) = uint8(0) + **(**uint8)(__ccgo_up(new1 + 16 + uintptr(n))) = uint8(0) (*t__locale_map)(unsafe.Pointer(new1)).Fnext = AtomicLoadPUintptr(uintptr(unsafe.Pointer(&_loc_head))) AtomicStorePUintptr(uintptr(unsafe.Pointer(&_loc_head)), new1) break @@ -99493,7 +99493,7 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { goto _10 _10: ; - path = z + BoolUintptr(!!(*(*uint8)(unsafe.Pointer(z)) != 0)) + path = z + BoolUintptr(!!(**(**uint8)(__ccgo_up(z)) != 0)) } } /* If no locale definition was found, make a locale map @@ -99508,7 +99508,7 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { (*t__locale_map)(unsafe.Pointer(new1)).Fmap1 = X__c_dot_utf8.Fmap1 (*t__locale_map)(unsafe.Pointer(new1)).Fmap_size = X__c_dot_utf8.Fmap_size Xmemcpy(tls, new1+16, val, n) - *(*uint8)(unsafe.Pointer(new1 + 16 + uintptr(n))) = uint8(0) + **(**uint8)(__ccgo_up(new1 + 16 + uintptr(n))) = uint8(0) (*t__locale_map)(unsafe.Pointer(new1)).Fnext = AtomicLoadPUintptr(uintptr(unsafe.Pointer(&_loc_head))) AtomicStorePUintptr(uintptr(unsafe.Pointer(&_loc_head)), new1) } @@ -99592,7 +99592,7 @@ func _do_newlocale(tls *TLS, mask int32, name uintptr, loc Tlocale_t) (r Tlocale break } if !(mask&(Int32FromInt32(1)<,< are accepted with or without = */ - if i < int32(6) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) == Int32FromUint8(_opch2[i]) { + if i < int32(6) && Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) == Int32FromUint8(_opch2[i]) { (*Tst)(unsafe.Pointer(st)).Fop = i return s + uintptr(2) } @@ -99898,12 +99898,12 @@ func _evalexpr(tls *TLS, st uintptr, s uintptr, d int32) (r uintptr) { return __ccgo_ts } s = _evalbinop(tls, st, s, 0, d) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('?') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32('?') { return s } a = (*Tst)(unsafe.Pointer(st)).Fr s = _evalexpr(tls, st, s+uintptr(1), d) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32(':') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32(':') { return __ccgo_ts } b = (*Tst)(unsafe.Pointer(st)).Fr @@ -99927,10 +99927,10 @@ func X__pleval(tls *TLS, s uintptr, n uint64) (r uint64) { var v1 uint64 var _ /* st at bp+0 */ Tst _ = v1 - (*(*Tst)(unsafe.Pointer(bp))).Fn = n + (**(**Tst)(__ccgo_up(bp))).Fn = n s = _evalexpr(tls, bp, s, int32(100)) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32(';') { - v1 = (*(*Tst)(unsafe.Pointer(bp))).Fr + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32(';') { + v1 = (**(**Tst)(__ccgo_up(bp))).Fr } else { v1 = Uint64FromInt32(-Int32FromInt32(1)) } @@ -99963,7 +99963,7 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { * on the format, so it can easily be changed if needed. */ if cat == int32(LC_ALL) { if name != 0 { - *(*[24]uint8)(unsafe.Pointer(bp + 48)) = [24]uint8{'C', '.', 'U', 'T', 'F', '-', '8'} + **(**[24]uint8)(__ccgo_up(bp + 48)) = [24]uint8{'C', '.', 'U', 'T', 'F', '-', '8'} p = name i = 0 for { @@ -99973,8 +99973,8 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { z = X__strchrnul(tls, p, int32(';')) if int64(z)-int64(p) <= int64(LOCALE_NAME_MAX) { Xmemcpy(tls, bp+48, p, Uint64FromInt64(int64(z)-int64(p))) - (*(*[24]uint8)(unsafe.Pointer(bp + 48)))[int64(z)-int64(p)] = uint8(0) - if *(*uint8)(unsafe.Pointer(z)) != 0 { + (**(**[24]uint8)(__ccgo_up(bp + 48)))[int64(z)-int64(p)] = uint8(0) + if **(**uint8)(__ccgo_up(z)) != 0 { p = z + uintptr(1) } } @@ -99983,13 +99983,13 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { ___unlock(tls, uintptr(unsafe.Pointer(&X__locale_lock))) return uintptr(0) } - *(*uintptr)(unsafe.Pointer(bp + uintptr(i)*8)) = lm + **(**uintptr)(__ccgo_up(bp + uintptr(i)*8)) = lm goto _1 _1: ; i = i + 1 } - X__libc.Fglobal_locale = *(*t__locale_struct)(unsafe.Pointer(bp)) + X__libc.Fglobal_locale = **(**t__locale_struct)(__ccgo_up(bp)) } s = uintptr(unsafe.Pointer(&_buf1)) same = 0 @@ -99998,8 +99998,8 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { if !(i < int32(LC_ALL)) { break } - lm1 = *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 56 + uintptr(i)*8)) - if lm1 == *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 56)) { + lm1 = **(**uintptr)(__ccgo_up(uintptr(unsafe.Pointer(&X__libc)) + 56 + uintptr(i)*8)) + if lm1 == **(**uintptr)(__ccgo_up(uintptr(unsafe.Pointer(&X__libc)) + 56)) { same = same + 1 } if lm1 != 0 { @@ -100010,7 +100010,7 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { part1 = v3 l = _strlen(tls, part1) Xmemcpy(tls, s, part1, l) - *(*uint8)(unsafe.Pointer(s + uintptr(l))) = uint8(';') + **(**uint8)(__ccgo_up(s + uintptr(l))) = uint8(';') s = s + uintptr(l+uint64(1)) goto _2 _2: @@ -100019,7 +100019,7 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { } s = s - 1 v3 = s - *(*uint8)(unsafe.Pointer(v3)) = uint8(0) + **(**uint8)(__ccgo_up(v3)) = uint8(0) ___unlock(tls, uintptr(unsafe.Pointer(&X__locale_lock))) if same == int32(LC_ALL) { v3 = part1 @@ -100034,9 +100034,9 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { ___unlock(tls, uintptr(unsafe.Pointer(&X__locale_lock))) return uintptr(0) } - *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 56 + uintptr(cat)*8)) = lm + **(**uintptr)(__ccgo_up(uintptr(unsafe.Pointer(&X__libc)) + 56 + uintptr(cat)*8)) = lm } else { - lm = *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 56 + uintptr(cat)*8)) + lm = **(**uintptr)(__ccgo_up(uintptr(unsafe.Pointer(&X__libc)) + 56 + uintptr(cat)*8)) } if lm != 0 { v3 = lm + 16 @@ -100083,10 +100083,10 @@ func _vstrfmon_l(tls *TLS, s uintptr, n Tsize_t, loc Tlocale_t, fmt uintptr, ap s0 = s _3: ; - if !(n != 0 && *(*uint8)(unsafe.Pointer(fmt)) != 0) { + if !(n != 0 && **(**uint8)(__ccgo_up(fmt)) != 0) { goto _1 } - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) != int32('%')) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(fmt))) != int32('%')) { goto _4 } goto literal @@ -100096,13 +100096,13 @@ literal: s = s + 1 v6 = fmt fmt = fmt + 1 - *(*uint8)(unsafe.Pointer(v5)) = *(*uint8)(unsafe.Pointer(v6)) + **(**uint8)(__ccgo_up(v5)) = **(**uint8)(__ccgo_up(v6)) n = n - 1 goto _2 _4: ; fmt = fmt + 1 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) == int32('%') { + if Int32FromUint8(**(**uint8)(__ccgo_up(fmt))) == int32('%') { goto literal } fill = int32(' ') @@ -100111,11 +100111,11 @@ _4: nosym = 0 left = 0 for { - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(fmt))) { case int32('='): fmt = fmt + 1 v5 = fmt - fill = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + fill = Int32FromUint8(**(**uint8)(__ccgo_up(v5))) goto _7 case int32('^'): nogrp = int32(1) @@ -100140,10 +100140,10 @@ _4: } fw = 0 for { - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(fmt)))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(fmt)))-uint32('0') < uint32(10)) != 0) { break } - fw = int32(10)*fw + (Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) - int32('0')) + fw = int32(10)*fw + (Int32FromUint8(**(**uint8)(__ccgo_up(fmt))) - int32('0')) goto _9 _9: ; @@ -100151,28 +100151,28 @@ _4: } lp = 0 rp = int32(2) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) == int32('#') { + if Int32FromUint8(**(**uint8)(__ccgo_up(fmt))) == int32('#') { lp = 0 fmt = fmt + 1 for { - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(fmt)))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(fmt)))-uint32('0') < uint32(10)) != 0) { break } - lp = int32(10)*lp + (Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) - int32('0')) + lp = int32(10)*lp + (Int32FromUint8(**(**uint8)(__ccgo_up(fmt))) - int32('0')) goto _10 _10: ; fmt = fmt + 1 } } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) == int32('.') { + if Int32FromUint8(**(**uint8)(__ccgo_up(fmt))) == int32('.') { rp = 0 fmt = fmt + 1 for { - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(fmt)))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(fmt)))-uint32('0') < uint32(10)) != 0) { break } - rp = int32(10)*rp + (Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) - int32('0')) + rp = int32(10)*rp + (Int32FromUint8(**(**uint8)(__ccgo_up(fmt))) - int32('0')) goto _11 _11: ; @@ -100181,7 +100181,7 @@ _4: } v5 = fmt fmt = fmt + 1 - intl = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) == int32('i')) + intl = BoolInt32(Int32FromUint8(**(**uint8)(__ccgo_up(v5))) == int32('i')) w = lp + int32(1) + rp if !(left != 0) && fw > w { w = fw @@ -100189,7 +100189,7 @@ _4: x = VaFloat64(&ap) l = Uint64FromInt32(Xsnprintf(tls, s, n, __ccgo_ts+600, VaList(bp+8, w, rp, x))) if l >= n { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(E2BIG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(E2BIG) return int64(-int32(1)) } s = s + uintptr(l) @@ -100354,7 +100354,7 @@ func Xtextdomain(tls *TLS, domainname uintptr) (r uintptr) { } domlen = _strlen(tls, domainname) if domlen > uint64(NAME_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } if !(_current_domain != 0) { @@ -100464,7 +100464,7 @@ func X__wcsxfrm_l(tls *TLS, dest uintptr, src uintptr, n Tsize_t, loc Tlocale_t) } else { if n != 0 { Xwmemcpy(tls, dest, src, n-uint64(1)) - *(*Twchar_t)(unsafe.Pointer(dest + uintptr(n-uint64(1))*4)) = 0 + **(**Twchar_t)(__ccgo_up(dest + uintptr(n-uint64(1))*4)) = 0 } } return l @@ -100495,7 +100495,7 @@ func Xreallocarray(tls *TLS, ptr uintptr, m Tsize_t, n Tsize_t) (r uintptr) { defer func() { trc("-> %v", r) }() } if n != 0 && m > Uint64FromInt32(-Int32FromInt32(1))/n { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return uintptr(0) } return Xrealloc(tls, ptr, m*n) @@ -100888,25 +100888,25 @@ func X__rem_pio2(tls *TLS, x float64, y uintptr) (r1 int32) { if ix <= uint32(0x4002d97c) { /* |x| ~<= 3pi/4 */ if !(sign != 0) { z = x - _pio2_1 /* one round good to 85 bits */ - *(*float64)(unsafe.Pointer(y)) = z - _pio2_1t - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) - _pio2_1t + **(**float64)(__ccgo_up(y)) = z - _pio2_1t + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) - _pio2_1t return int32(1) } else { z = x + _pio2_1 - *(*float64)(unsafe.Pointer(y)) = z + _pio2_1t - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) + _pio2_1t + **(**float64)(__ccgo_up(y)) = z + _pio2_1t + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) + _pio2_1t return -int32(1) } } else { if !(sign != 0) { z = x - float64(Float64FromInt32(2)*_pio2_1) - *(*float64)(unsafe.Pointer(y)) = z - Tdouble_t(Float64FromInt32(2)*_pio2_1t) - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) - Tdouble_t(Float64FromInt32(2)*_pio2_1t) + **(**float64)(__ccgo_up(y)) = z - Tdouble_t(Float64FromInt32(2)*_pio2_1t) + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) - Tdouble_t(Float64FromInt32(2)*_pio2_1t) return int32(2) } else { z = x + float64(Float64FromInt32(2)*_pio2_1) - *(*float64)(unsafe.Pointer(y)) = z + Tdouble_t(Float64FromInt32(2)*_pio2_1t) - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) + Tdouble_t(Float64FromInt32(2)*_pio2_1t) + **(**float64)(__ccgo_up(y)) = z + Tdouble_t(Float64FromInt32(2)*_pio2_1t) + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) + Tdouble_t(Float64FromInt32(2)*_pio2_1t) return -int32(2) } } @@ -100918,13 +100918,13 @@ func X__rem_pio2(tls *TLS, x float64, y uintptr) (r1 int32) { } if !(sign != 0) { z = x - float64(Float64FromInt32(3)*_pio2_1) - *(*float64)(unsafe.Pointer(y)) = z - Tdouble_t(Float64FromInt32(3)*_pio2_1t) - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) - Tdouble_t(Float64FromInt32(3)*_pio2_1t) + **(**float64)(__ccgo_up(y)) = z - Tdouble_t(Float64FromInt32(3)*_pio2_1t) + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) - Tdouble_t(Float64FromInt32(3)*_pio2_1t) return int32(3) } else { z = x + float64(Float64FromInt32(3)*_pio2_1) - *(*float64)(unsafe.Pointer(y)) = z + Tdouble_t(Float64FromInt32(3)*_pio2_1t) - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) + Tdouble_t(Float64FromInt32(3)*_pio2_1t) + **(**float64)(__ccgo_up(y)) = z + Tdouble_t(Float64FromInt32(3)*_pio2_1t) + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) + Tdouble_t(Float64FromInt32(3)*_pio2_1t) return -int32(3) } } else { @@ -100933,13 +100933,13 @@ func X__rem_pio2(tls *TLS, x float64, y uintptr) (r1 int32) { } if !(sign != 0) { z = x - float64(Float64FromInt32(4)*_pio2_1) - *(*float64)(unsafe.Pointer(y)) = z - Tdouble_t(Float64FromInt32(4)*_pio2_1t) - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) - Tdouble_t(Float64FromInt32(4)*_pio2_1t) + **(**float64)(__ccgo_up(y)) = z - Tdouble_t(Float64FromInt32(4)*_pio2_1t) + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) - Tdouble_t(Float64FromInt32(4)*_pio2_1t) return int32(4) } else { z = x + float64(Float64FromInt32(4)*_pio2_1) - *(*float64)(unsafe.Pointer(y)) = z + Tdouble_t(Float64FromInt32(4)*_pio2_1t) - *(*float64)(unsafe.Pointer(y + 1*8)) = z - *(*float64)(unsafe.Pointer(y)) + Tdouble_t(Float64FromInt32(4)*_pio2_1t) + **(**float64)(__ccgo_up(y)) = z + Tdouble_t(Float64FromInt32(4)*_pio2_1t) + **(**float64)(__ccgo_up(y + 1*8)) = z - **(**float64)(__ccgo_up(y)) + Tdouble_t(Float64FromInt32(4)*_pio2_1t) return -int32(4) } } @@ -100969,8 +100969,8 @@ medium: w = Tdouble_t(fn * _pio2_1t) } } - *(*float64)(unsafe.Pointer(y)) = r - w - *(*float64)(unsafe.Pointer(bp)) = *(*float64)(unsafe.Pointer(y)) + **(**float64)(__ccgo_up(y)) = r - w + *(*float64)(unsafe.Pointer(bp)) = **(**float64)(__ccgo_up(y)) ey = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(52) & uint64(0x7ff)) ex = Int32FromUint32(ix >> int32(20)) if ex-ey > int32(16) { /* 2nd round, good to 118 bits */ @@ -100978,18 +100978,18 @@ medium: w = Tdouble_t(fn * _pio2_2) r = t - w w = Tdouble_t(fn*_pio2_2t) - (t - r - w) - *(*float64)(unsafe.Pointer(y)) = r - w - *(*float64)(unsafe.Pointer(bp)) = *(*float64)(unsafe.Pointer(y)) + **(**float64)(__ccgo_up(y)) = r - w + *(*float64)(unsafe.Pointer(bp)) = **(**float64)(__ccgo_up(y)) ey = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(52) & uint64(0x7ff)) if ex-ey > int32(49) { /* 3rd round, good to 151 bits, covers all cases */ t = r w = Tdouble_t(fn * _pio2_3) r = t - w w = Tdouble_t(fn*_pio2_3t) - (t - r - w) - *(*float64)(unsafe.Pointer(y)) = r - w + **(**float64)(__ccgo_up(y)) = r - w } } - *(*float64)(unsafe.Pointer(y + 1*8)) = r - *(*float64)(unsafe.Pointer(y)) - w + **(**float64)(__ccgo_up(y + 1*8)) = r - **(**float64)(__ccgo_up(y)) - w return n _1: ; @@ -100998,8 +100998,8 @@ _1: */ if ix >= uint32(0x7ff00000) { /* x is inf or NaN */ v2 = x - x - *(*float64)(unsafe.Pointer(y + 1*8)) = v2 - *(*float64)(unsafe.Pointer(y)) = v2 + **(**float64)(__ccgo_up(y + 1*8)) = v2 + **(**float64)(__ccgo_up(y)) = v2 return 0 } /* set z = scalbn(|x|,-ilogb(x)+23) */ @@ -101012,26 +101012,26 @@ _1: if !(i < int32(2)) { break } - (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i] = float64(int32(z)) - z = Tdouble_t((z - (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i]) * float64(1.6777216e+07)) + (**(**[3]float64)(__ccgo_up(bp + 8)))[i] = float64(int32(z)) + z = Tdouble_t((z - (**(**[3]float64)(__ccgo_up(bp + 8)))[i]) * float64(1.6777216e+07)) goto _3 _3: ; i = i + 1 } - (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i] = z + (**(**[3]float64)(__ccgo_up(bp + 8)))[i] = z /* skip zero terms, first term is non-zero */ - for (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i] == float64(0) { + for (**(**[3]float64)(__ccgo_up(bp + 8)))[i] == float64(0) { i = i - 1 } n = X__rem_pio2_large(tls, bp+8, bp+32, Int32FromUint32(ix>>Int32FromInt32(20))-(Int32FromInt32(0x3ff)+Int32FromInt32(23)), i+int32(1), int32(1)) if sign != 0 { - *(*float64)(unsafe.Pointer(y)) = -(*(*[2]float64)(unsafe.Pointer(bp + 32)))[0] - *(*float64)(unsafe.Pointer(y + 1*8)) = -(*(*[2]float64)(unsafe.Pointer(bp + 32)))[int32(1)] + **(**float64)(__ccgo_up(y)) = -(**(**[2]float64)(__ccgo_up(bp + 32)))[0] + **(**float64)(__ccgo_up(y + 1*8)) = -(**(**[2]float64)(__ccgo_up(bp + 32)))[int32(1)] return -n } - *(*float64)(unsafe.Pointer(y)) = (*(*[2]float64)(unsafe.Pointer(bp + 32)))[0] - *(*float64)(unsafe.Pointer(y + 1*8)) = (*(*[2]float64)(unsafe.Pointer(bp + 32)))[int32(1)] + **(**float64)(__ccgo_up(y)) = (**(**[2]float64)(__ccgo_up(bp + 32)))[0] + **(**float64)(__ccgo_up(y + 1*8)) = (**(**[2]float64)(__ccgo_up(bp + 32)))[int32(1)] return n } @@ -101193,7 +101193,7 @@ func X__rem_pio2_large(tls *TLS, x uintptr, y uintptr, e0 int32, nx int32, prec if !(j <= jx) { break } - fw = fw + float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8))*f[jx+i-j]) + fw = fw + float64(**(**float64)(__ccgo_up(x + uintptr(j)*8))*f[jx+i-j]) goto _4 _4: ; @@ -101218,7 +101218,7 @@ recompute: break } fw = float64(int32(float64(Float64FromFloat64(5.960464477539063e-08) * z))) - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] = int32(z - float64(Float64FromFloat64(1.6777216e+07)*fw)) + (**(**[20]Tint32_t)(__ccgo_up(bp)))[i] = int32(z - float64(Float64FromFloat64(1.6777216e+07)*fw)) z = q[j-int32(1)] + fw goto _5 _5: @@ -101233,13 +101233,13 @@ recompute: z = z - float64(n) ih = 0 if q0 > 0 { /* need iq[jz-1] to determine n */ - i = (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz-int32(1)] >> (int32(24) - q0) + i = (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz-int32(1)] >> (int32(24) - q0) n = n + i - *(*Tint32_t)(unsafe.Pointer(bp + uintptr(jz-int32(1))*4)) -= i << (int32(24) - q0) - ih = (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz-int32(1)] >> (int32(23) - q0) + **(**Tint32_t)(__ccgo_up(bp + uintptr(jz-int32(1))*4)) -= i << (int32(24) - q0) + ih = (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz-int32(1)] >> (int32(23) - q0) } else { if q0 == 0 { - ih = (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz-int32(1)] >> int32(23) + ih = (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz-int32(1)] >> int32(23) } else { if z >= float64(0.5) { ih = int32(2) @@ -101254,14 +101254,14 @@ recompute: if !(i < jz) { break } /* compute 1-q */ - j = (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] + j = (**(**[20]Tint32_t)(__ccgo_up(bp)))[i] if carry == 0 { if j != 0 { carry = int32(1) - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] = int32(0x1000000) - j + (**(**[20]Tint32_t)(__ccgo_up(bp)))[i] = int32(0x1000000) - j } } else { - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] = int32(0xffffff) - j + (**(**[20]Tint32_t)(__ccgo_up(bp)))[i] = int32(0xffffff) - j } goto _6 _6: @@ -101271,9 +101271,9 @@ recompute: if q0 > 0 { /* rare case: chance is 1 in 12 */ switch q0 { case int32(1): - *(*Tint32_t)(unsafe.Pointer(bp + uintptr(jz-int32(1))*4)) &= int32(0x7fffff) + **(**Tint32_t)(__ccgo_up(bp + uintptr(jz-int32(1))*4)) &= int32(0x7fffff) case int32(2): - *(*Tint32_t)(unsafe.Pointer(bp + uintptr(jz-int32(1))*4)) &= int32(0x3fffff) + **(**Tint32_t)(__ccgo_up(bp + uintptr(jz-int32(1))*4)) &= int32(0x3fffff) break } } @@ -101292,7 +101292,7 @@ recompute: if !(i >= jk) { break } - j = j | (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] + j = j | (**(**[20]Tint32_t)(__ccgo_up(bp)))[i] goto _7 _7: ; @@ -101301,7 +101301,7 @@ recompute: if j == 0 { /* need recomputation */ k = int32(1) for { - if !((*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jk-k] == 0) { + if !((**(**[20]Tint32_t)(__ccgo_up(bp)))[jk-k] == 0) { break } goto _8 @@ -101321,7 +101321,7 @@ recompute: if !(j <= jx) { break } - fw = fw + float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8))*f[jx+i-j]) + fw = fw + float64(**(**float64)(__ccgo_up(x + uintptr(j)*8))*f[jx+i-j]) goto _10 _10: ; @@ -101341,7 +101341,7 @@ recompute: if z == float64(0) { jz = jz - int32(1) q0 = q0 - int32(24) - for (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] == 0 { + for (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz] == 0 { jz = jz - 1 q0 = q0 - int32(24) } @@ -101349,12 +101349,12 @@ recompute: z = Xscalbn(tls, z, -q0) if z >= float64(1.6777216e+07) { fw = float64(int32(float64(Float64FromFloat64(5.960464477539063e-08) * z))) - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(z - float64(Float64FromFloat64(1.6777216e+07)*fw)) + (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz] = int32(z - float64(Float64FromFloat64(1.6777216e+07)*fw)) jz = jz + int32(1) q0 = q0 + int32(24) - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(fw) + (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz] = int32(fw) } else { - (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(z) + (**(**[20]Tint32_t)(__ccgo_up(bp)))[jz] = int32(z) } } /* convert integer "bit" chunk to floating-point value */ @@ -101364,7 +101364,7 @@ recompute: if !(i >= 0) { break } - q[i] = float64(fw * float64((*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i])) + q[i] = float64(fw * float64((**(**[20]Tint32_t)(__ccgo_up(bp)))[i])) fw = fw * float64(5.960464477539063e-08) goto _11 _11: @@ -101389,7 +101389,7 @@ recompute: ; k = k + 1 } - (*(*[20]float64)(unsafe.Pointer(bp + 80)))[jz-i] = fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[jz-i] = fw goto _12 _12: ; @@ -101415,7 +101415,7 @@ _14: if !(i >= 0) { break } - fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[i] goto _19 _19: ; @@ -101426,7 +101426,7 @@ _14: } else { v2 = -fw } - *(*float64)(unsafe.Pointer(y)) = v2 + **(**float64)(__ccgo_up(y)) = v2 goto _18 _16: ; @@ -101438,7 +101438,7 @@ _15: if !(i >= 0) { break } - fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[i] goto _21 _21: ; @@ -101451,14 +101451,14 @@ _15: } else { v2 = -fw } - *(*float64)(unsafe.Pointer(y)) = v2 - fw = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[0] - fw + **(**float64)(__ccgo_up(y)) = v2 + fw = (**(**[20]float64)(__ccgo_up(bp + 80)))[0] - fw i = int32(1) for { if !(i <= jz) { break } - fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[i] goto _23 _23: ; @@ -101469,7 +101469,7 @@ _15: } else { v2 = -fw } - *(*float64)(unsafe.Pointer(y + 1*8)) = v2 + **(**float64)(__ccgo_up(y + 1*8)) = v2 goto _18 _17: ; /* painful */ @@ -101479,9 +101479,9 @@ _27: if !(i > 0) { goto _25 } - fw = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i-int32(1)] + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] - *(*float64)(unsafe.Pointer(bp + 80 + uintptr(i)*8)) += (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i-int32(1)] - fw - (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i-int32(1)] = fw + fw = (**(**[20]float64)(__ccgo_up(bp + 80)))[i-int32(1)] + (**(**[20]float64)(__ccgo_up(bp + 80)))[i] + **(**float64)(__ccgo_up(bp + 80 + uintptr(i)*8)) += (**(**[20]float64)(__ccgo_up(bp + 80)))[i-int32(1)] - fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[i-int32(1)] = fw goto _26 _26: ; @@ -101495,9 +101495,9 @@ _25: if !(i > int32(1)) { break } - fw = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i-int32(1)] + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] - *(*float64)(unsafe.Pointer(bp + 80 + uintptr(i)*8)) += (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i-int32(1)] - fw - (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i-int32(1)] = fw + fw = (**(**[20]float64)(__ccgo_up(bp + 80)))[i-int32(1)] + (**(**[20]float64)(__ccgo_up(bp + 80)))[i] + **(**float64)(__ccgo_up(bp + 80 + uintptr(i)*8)) += (**(**[20]float64)(__ccgo_up(bp + 80)))[i-int32(1)] - fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[i-int32(1)] = fw goto _28 _28: ; @@ -101509,20 +101509,20 @@ _25: if !(i >= int32(2)) { break } - fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (**(**[20]float64)(__ccgo_up(bp + 80)))[i] goto _29 _29: ; i = i - 1 } if ih == 0 { - *(*float64)(unsafe.Pointer(y)) = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[0] - *(*float64)(unsafe.Pointer(y + 1*8)) = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[int32(1)] - *(*float64)(unsafe.Pointer(y + 2*8)) = fw + **(**float64)(__ccgo_up(y)) = (**(**[20]float64)(__ccgo_up(bp + 80)))[0] + **(**float64)(__ccgo_up(y + 1*8)) = (**(**[20]float64)(__ccgo_up(bp + 80)))[int32(1)] + **(**float64)(__ccgo_up(y + 2*8)) = fw } else { - *(*float64)(unsafe.Pointer(y)) = -(*(*[20]float64)(unsafe.Pointer(bp + 80)))[0] - *(*float64)(unsafe.Pointer(y + 1*8)) = -(*(*[20]float64)(unsafe.Pointer(bp + 80)))[int32(1)] - *(*float64)(unsafe.Pointer(y + 2*8)) = -fw + **(**float64)(__ccgo_up(y)) = -(**(**[20]float64)(__ccgo_up(bp + 80)))[0] + **(**float64)(__ccgo_up(y + 1*8)) = -(**(**[20]float64)(__ccgo_up(bp + 80)))[int32(1)] + **(**float64)(__ccgo_up(y + 2*8)) = -fw } _18: ; @@ -101576,36 +101576,36 @@ func X__rem_pio2f(tls *TLS, x float32, y uintptr) (r int32) { /* Use a specialized rint() to get fn. */ fn = Tdouble_t(float64(x)*_invpio21) + _toint1 - _toint1 n = int32(fn) - *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) + **(**float64)(__ccgo_up(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) /* Matters with directed rounding. */ - if *(*float64)(unsafe.Pointer(y)) < -_pio41 { + if **(**float64)(__ccgo_up(y)) < -_pio41 { n = n - 1 fn = fn - 1 - *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) + **(**float64)(__ccgo_up(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) } else { - if *(*float64)(unsafe.Pointer(y)) > _pio41 { + if **(**float64)(__ccgo_up(y)) > _pio41 { n = n + 1 fn = fn + 1 - *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) + **(**float64)(__ccgo_up(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) } } return n } if ix >= uint32(0x7f800000) { /* x is inf or NaN */ - *(*float64)(unsafe.Pointer(y)) = float64(x - x) + **(**float64)(__ccgo_up(y)) = float64(x - x) return 0 } /* scale x into [2^23, 2^24-1] */ sign = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(bp)) >> int32(31)) e0 = Int32FromUint32(ix>>Int32FromInt32(23) - Uint32FromInt32(Int32FromInt32(0x7f)+Int32FromInt32(23))) /* e0 = ilogb(|x|)-23, positive */ *(*Tuint32_t)(unsafe.Pointer(bp)) = ix - Uint32FromInt32(e0<>int32(52)&uint64(0x7ff) < Uint64FromInt32(Int32FromInt32(0x3ff)+Int32FromInt32(4)) { if !(y != 0) { - return _p10[int32(*(*float64)(unsafe.Pointer(bp)))+int32(15)] + return _p10[int32(**(**float64)(__ccgo_up(bp)))+int32(15)] } y = Xexp2(tls, float64(float64(3.321928094887362)*y)) - return float64(y * _p10[int32(*(*float64)(unsafe.Pointer(bp)))+int32(15)]) + return float64(y * _p10[int32(**(**float64)(__ccgo_up(bp)))+int32(15)]) } return Xpow(tls, float64(10), x) } @@ -104254,14 +104254,14 @@ func Xexp10f(tls *TLS, x float32) (r float32) { Fi [0]Tuint32_t Ff float32 }{} - *(*float32)(unsafe.Pointer(bp + 4)) = *(*float32)(unsafe.Pointer(bp)) + *(*float32)(unsafe.Pointer(bp + 4)) = **(**float32)(__ccgo_up(bp)) /* fabsf(n) < 8 without raising invalid on nan */ if *(*Tuint32_t)(unsafe.Pointer(bp + 4))>>int32(23)&uint32(0xff) < Uint32FromInt32(Int32FromInt32(0x7f)+Int32FromInt32(3)) { if !(y != 0) { - return _p101[int32(*(*float32)(unsafe.Pointer(bp)))+int32(7)] + return _p101[int32(**(**float32)(__ccgo_up(bp)))+int32(7)] } y = Xexp2f(tls, float32(Float32FromFloat32(3.321928094887362)*y)) - return float32(y * _p101[int32(*(*float32)(unsafe.Pointer(bp)))+int32(7)]) + return float32(y * _p101[int32(**(**float32)(__ccgo_up(bp)))+int32(7)]) } return float32(Xexp2(tls, float64(float64(3.321928094887362)*float64(x)))) } @@ -104425,16 +104425,16 @@ _5: /* 2^(k/N) ~= scale * (1 + tail). */ idx = uint64(2) * (ki % Uint64FromInt32(Int32FromInt32(1)<>Int32FromInt32(32) + BoolUint64(t1 > *(*Tuint64_t)(unsafe.Pointer(lo))) + **(**Tuint64_t)(__ccgo_up(lo)) = t1 + t2<>Int32FromInt32(32) + BoolUint64(t1 > **(**Tuint64_t)(__ccgo_up(lo))) } func Xfma(tls *TLS, x1 float64, y1 float64, z float64) (r2 float64) { @@ -105340,11 +105340,11 @@ func Xfma(tls *TLS, x1 float64, y1 float64, z float64) (r2 float64) { if d == 0 { } else { if d < int32(64) { - *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = *(*Tuint64_t)(unsafe.Pointer(bp))<<(int32(64)-d) | *(*Tuint64_t)(unsafe.Pointer(bp + 8))>>d | BoolUint64(!!(*(*Tuint64_t)(unsafe.Pointer(bp + 8))<<(Int32FromInt32(64)-d) != 0)) - *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp)) >> d + **(**Tuint64_t)(__ccgo_up(bp + 8)) = **(**Tuint64_t)(__ccgo_up(bp))<<(int32(64)-d) | **(**Tuint64_t)(__ccgo_up(bp + 8))>>d | BoolUint64(!!(**(**Tuint64_t)(__ccgo_up(bp + 8))<<(Int32FromInt32(64)-d) != 0)) + **(**Tuint64_t)(__ccgo_up(bp)) = **(**Tuint64_t)(__ccgo_up(bp)) >> d } else { - *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = uint64(1) - *(*Tuint64_t)(unsafe.Pointer(bp)) = uint64(0) + **(**Tuint64_t)(__ccgo_up(bp + 8)) = uint64(1) + **(**Tuint64_t)(__ccgo_up(bp)) = uint64(0) } } } @@ -105367,24 +105367,24 @@ func Xfma(tls *TLS, x1 float64, y1 float64, z float64) (r2 float64) { nonzero = int32(1) if samesign != 0 { /* r += z */ - *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) + zlo - *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp)) + (zhi + BoolUint64(*(*Tuint64_t)(unsafe.Pointer(bp + 8)) < zlo)) + **(**Tuint64_t)(__ccgo_up(bp + 8)) = **(**Tuint64_t)(__ccgo_up(bp + 8)) + zlo + **(**Tuint64_t)(__ccgo_up(bp)) = **(**Tuint64_t)(__ccgo_up(bp)) + (zhi + BoolUint64(**(**Tuint64_t)(__ccgo_up(bp + 8)) < zlo)) } else { /* r -= z */ - t = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) - *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) - zlo - *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp)) - zhi - BoolUint64(t < *(*Tuint64_t)(unsafe.Pointer(bp + 8))) - if *(*Tuint64_t)(unsafe.Pointer(bp))>>int32(63) != 0 { - *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = -*(*Tuint64_t)(unsafe.Pointer(bp + 8)) - *(*Tuint64_t)(unsafe.Pointer(bp)) = -*(*Tuint64_t)(unsafe.Pointer(bp)) - BoolUint64(!!(*(*Tuint64_t)(unsafe.Pointer(bp + 8)) != 0)) + t = **(**Tuint64_t)(__ccgo_up(bp + 8)) + **(**Tuint64_t)(__ccgo_up(bp + 8)) = **(**Tuint64_t)(__ccgo_up(bp + 8)) - zlo + **(**Tuint64_t)(__ccgo_up(bp)) = **(**Tuint64_t)(__ccgo_up(bp)) - zhi - BoolUint64(t < **(**Tuint64_t)(__ccgo_up(bp + 8))) + if **(**Tuint64_t)(__ccgo_up(bp))>>int32(63) != 0 { + **(**Tuint64_t)(__ccgo_up(bp + 8)) = -**(**Tuint64_t)(__ccgo_up(bp + 8)) + **(**Tuint64_t)(__ccgo_up(bp)) = -**(**Tuint64_t)(__ccgo_up(bp)) - BoolUint64(!!(**(**Tuint64_t)(__ccgo_up(bp + 8)) != 0)) sign = BoolInt32(!(sign != 0)) } - nonzero = BoolInt32(!!(*(*Tuint64_t)(unsafe.Pointer(bp)) != 0)) + nonzero = BoolInt32(!!(**(**Tuint64_t)(__ccgo_up(bp)) != 0)) } /* set rhi to top 63bit of the result (last bit is sticky) */ if nonzero != 0 { e = e + int32(64) - v1 = *(*Tuint64_t)(unsafe.Pointer(bp)) + v1 = **(**Tuint64_t)(__ccgo_up(bp)) if v1>>Int32FromInt32(32) != 0 { y = uint32(v1 >> int32(32)) r = Int32FromInt32(0) @@ -105417,10 +105417,10 @@ func Xfma(tls *TLS, x1 float64, y1 float64, z float64) (r2 float64) { _3: d = v2 - int32(1) /* note: d > 0 */ - *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp))<>(int32(64)-d) | BoolUint64(!!(*(*Tuint64_t)(unsafe.Pointer(bp + 8))<>(int32(64)-d) | BoolUint64(!!(**(**Tuint64_t)(__ccgo_up(bp + 8))<>Int32FromInt32(32) != 0 { y = uint32(v1 >> int32(32)) r = Int32FromInt32(0) @@ -105453,9 +105453,9 @@ func Xfma(tls *TLS, x1 float64, y1 float64, z float64) (r2 float64) { _6: d = v2 - int32(1) if d < 0 { - *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp + 8))>>int32(1) | *(*Tuint64_t)(unsafe.Pointer(bp + 8))&uint64(1) + **(**Tuint64_t)(__ccgo_up(bp)) = **(**Tuint64_t)(__ccgo_up(bp + 8))>>int32(1) | **(**Tuint64_t)(__ccgo_up(bp + 8))&uint64(1) } else { - *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) << d + **(**Tuint64_t)(__ccgo_up(bp)) = **(**Tuint64_t)(__ccgo_up(bp + 8)) << d } } else { /* exact +-0 */ @@ -105464,7 +105464,7 @@ func Xfma(tls *TLS, x1 float64, y1 float64, z float64) (r2 float64) { } e = e - d /* convert to double */ - i = Int64FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp))) /* i is in [1<<62,(1<<63)-1] */ + i = Int64FromUint64(**(**Tuint64_t)(__ccgo_up(bp))) /* i is in [1<<62,(1<<63)-1] */ if sign != 0 { i = -i } @@ -105485,8 +105485,8 @@ func Xfma(tls *TLS, x1 float64, y1 float64, z float64) (r2 float64) { } /* one bit is lost when scaled, add another top bit to only round once at conversion if it is inexact */ - if *(*Tuint64_t)(unsafe.Pointer(bp))<>int32(1) | *(*Tuint64_t)(unsafe.Pointer(bp))&uint64(1) | Uint64FromUint64(1)<>int32(1)|**(**Tuint64_t)(__ccgo_up(bp))&uint64(1)) | Uint64FromUint64(1)<>d | BoolUint64(!!(*(*Tuint64_t)(unsafe.Pointer(bp))<<(Int32FromInt32(64)-d) != 0))) << d) + i = Int64FromUint64((**(**Tuint64_t)(__ccgo_up(bp))>>d | BoolUint64(!!(**(**Tuint64_t)(__ccgo_up(bp))<<(Int32FromInt32(64)-d) != 0))) << d) if sign != 0 { i = -i } @@ -106086,9 +106086,9 @@ func Xfrexp(tls *TLS, x float64, e uintptr) (r float64) { if !(ee != 0) { if x != 0 { x = Xfrexp(tls, float64(x*float64(1.8446744073709552e+19)), e) - *(*int32)(unsafe.Pointer(e)) -= int32(64) + **(**int32)(__ccgo_up(e)) -= int32(64) } else { - *(*int32)(unsafe.Pointer(e)) = 0 + **(**int32)(__ccgo_up(e)) = 0 } return x } else { @@ -106096,7 +106096,7 @@ func Xfrexp(tls *TLS, x float64, e uintptr) (r float64) { return x } } - *(*int32)(unsafe.Pointer(e)) = ee - int32(0x3fe) + **(**int32)(__ccgo_up(e)) = ee - int32(0x3fe) v1 = bp *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & Uint64FromUint64(0x800fffffffffffff)) v1 = bp @@ -106130,9 +106130,9 @@ func Xfrexpf(tls *TLS, x float32, e uintptr) (r float32) { if !(ee != 0) { if x != 0 { x = Xfrexpf(tls, float32(float64(x)*float64(1.8446744073709552e+19)), e) - *(*int32)(unsafe.Pointer(e)) -= int32(64) + **(**int32)(__ccgo_up(e)) -= int32(64) } else { - *(*int32)(unsafe.Pointer(e)) = 0 + **(**int32)(__ccgo_up(e)) = 0 } return x } else { @@ -106140,7 +106140,7 @@ func Xfrexpf(tls *TLS, x float32, e uintptr) (r float32) { return x } } - *(*int32)(unsafe.Pointer(e)) = ee - int32(0x7e) + **(**int32)(__ccgo_up(e)) = ee - int32(0x7e) v1 = bp *(*Tuint32_t)(unsafe.Pointer(v1)) = Tuint32_t(uint64(*(*Tuint32_t)(unsafe.Pointer(v1))) & Uint64FromUint64(0x807fffff)) v1 = bp @@ -106164,8 +106164,8 @@ func _sq(tls *TLS, hi uintptr, lo uintptr, x float64) { xc = Tdouble_t(x * (Float64FromFloat64(1.34217728e+08) + Float64FromInt32(1))) xh = x - xc + xc xl = x - xh - *(*Tdouble_t)(unsafe.Pointer(hi)) = Tdouble_t(x * x) - *(*Tdouble_t)(unsafe.Pointer(lo)) = Tdouble_t(xh*xh) - *(*Tdouble_t)(unsafe.Pointer(hi)) + Tdouble_t(Tdouble_t(Float64FromInt32(2)*xh)*xl) + Tdouble_t(xl*xl) + **(**Tdouble_t)(__ccgo_up(hi)) = Tdouble_t(x * x) + **(**Tdouble_t)(__ccgo_up(lo)) = Tdouble_t(xh*xh) - **(**Tdouble_t)(__ccgo_up(hi)) + Tdouble_t(Tdouble_t(Float64FromInt32(2)*xh)*xl) + Tdouble_t(xl*xl) } func Xhypot(tls *TLS, x float64, y float64) (r float64) { @@ -106217,21 +106217,21 @@ func Xhypot(tls *TLS, x float64, y float64) (r float64) { v1 = bp + 8 *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & (-Uint64FromUint64(1) >> Int32FromInt32(1))) if *(*Tuint64_t)(unsafe.Pointer(bp)) < *(*Tuint64_t)(unsafe.Pointer(bp + 8)) { - ut = *(*struct { + ut = **(**struct { Fi [0]Tuint64_t Ff float64 - })(unsafe.Pointer(bp)) - *(*struct { + })(__ccgo_up(bp)) + **(**struct { Fi [0]Tuint64_t Ff float64 - })(unsafe.Pointer(bp)) = *(*struct { + })(__ccgo_up(bp)) = **(**struct { Fi [0]Tuint64_t Ff float64 - })(unsafe.Pointer(bp + 8)) - *(*struct { + })(__ccgo_up(bp + 8)) + **(**struct { Fi [0]Tuint64_t Ff float64 - })(unsafe.Pointer(bp + 8)) = ut + })(__ccgo_up(bp + 8)) = ut } /* special cases */ ex = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(52)) @@ -106266,7 +106266,7 @@ func Xhypot(tls *TLS, x float64, y float64) (r float64) { } _sq(tls, bp+16, bp+24, x) _sq(tls, bp+32, bp+40, y) - return float64(z * Xsqrt(tls, *(*Tdouble_t)(unsafe.Pointer(bp + 40))+*(*Tdouble_t)(unsafe.Pointer(bp + 24))+*(*Tdouble_t)(unsafe.Pointer(bp + 32))+*(*Tdouble_t)(unsafe.Pointer(bp + 16)))) + return float64(z * Xsqrt(tls, **(**Tdouble_t)(__ccgo_up(bp + 40))+**(**Tdouble_t)(__ccgo_up(bp + 24))+**(**Tdouble_t)(__ccgo_up(bp + 32))+**(**Tdouble_t)(__ccgo_up(bp + 16)))) } func Xhypotf(tls *TLS, x float32, y float32) (r float32) { @@ -106309,21 +106309,21 @@ func Xhypotf(tls *TLS, x float32, y float32) (r float32) { *(*Tuint32_t)(unsafe.Pointer(bp)) &= -Uint32FromUint32(1) >> Int32FromInt32(1) *(*Tuint32_t)(unsafe.Pointer(bp + 4)) &= -Uint32FromUint32(1) >> Int32FromInt32(1) if *(*Tuint32_t)(unsafe.Pointer(bp)) < *(*Tuint32_t)(unsafe.Pointer(bp + 4)) { - ut = *(*struct { + ut = **(**struct { Fi [0]Tuint32_t Ff float32 - })(unsafe.Pointer(bp)) - *(*struct { + })(__ccgo_up(bp)) + **(**struct { Fi [0]Tuint32_t Ff float32 - })(unsafe.Pointer(bp)) = *(*struct { + })(__ccgo_up(bp)) = **(**struct { Fi [0]Tuint32_t Ff float32 - })(unsafe.Pointer(bp + 4)) - *(*struct { + })(__ccgo_up(bp + 4)) + **(**struct { Fi [0]Tuint32_t Ff float32 - })(unsafe.Pointer(bp + 4)) = ut + })(__ccgo_up(bp + 4)) = ut } x = *(*float32)(unsafe.Pointer(bp)) y = *(*float32)(unsafe.Pointer(bp + 4)) @@ -106751,8 +106751,8 @@ func _pzero(tls *TLS, x float64) (r1 float64) { } } z = float64(1) / float64(x*x) - r = *(*float64)(unsafe.Pointer(p)) + float64(z*(*(*float64)(unsafe.Pointer(p + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 4*8))+float64(z**(*float64)(unsafe.Pointer(p + 5*8))))))))))) - s = float64(1) + float64(z*(*(*float64)(unsafe.Pointer(q))+float64(z*(*(*float64)(unsafe.Pointer(q + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 3*8))+float64(z**(*float64)(unsafe.Pointer(q + 4*8))))))))))) + r = **(**float64)(__ccgo_up(p)) + float64(z*(**(**float64)(__ccgo_up(p + 1*8))+float64(z*(**(**float64)(__ccgo_up(p + 2*8))+float64(z*(**(**float64)(__ccgo_up(p + 3*8))+float64(z*(**(**float64)(__ccgo_up(p + 4*8))+float64(z***(**float64)(__ccgo_up(p + 5*8))))))))))) + s = float64(1) + float64(z*(**(**float64)(__ccgo_up(q))+float64(z*(**(**float64)(__ccgo_up(q + 1*8))+float64(z*(**(**float64)(__ccgo_up(q + 2*8))+float64(z*(**(**float64)(__ccgo_up(q + 3*8))+float64(z***(**float64)(__ccgo_up(q + 4*8))))))))))) return float64(1) + r/s } @@ -106859,8 +106859,8 @@ func _qzero(tls *TLS, x float64) (r1 float64) { } } z = float64(1) / float64(x*x) - r = *(*float64)(unsafe.Pointer(p)) + float64(z*(*(*float64)(unsafe.Pointer(p + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 4*8))+float64(z**(*float64)(unsafe.Pointer(p + 5*8))))))))))) - s = float64(1) + float64(z*(*(*float64)(unsafe.Pointer(q))+float64(z*(*(*float64)(unsafe.Pointer(q + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 4*8))+float64(z**(*float64)(unsafe.Pointer(q + 5*8))))))))))))) + r = **(**float64)(__ccgo_up(p)) + float64(z*(**(**float64)(__ccgo_up(p + 1*8))+float64(z*(**(**float64)(__ccgo_up(p + 2*8))+float64(z*(**(**float64)(__ccgo_up(p + 3*8))+float64(z*(**(**float64)(__ccgo_up(p + 4*8))+float64(z***(**float64)(__ccgo_up(p + 5*8))))))))))) + s = float64(1) + float64(z*(**(**float64)(__ccgo_up(q))+float64(z*(**(**float64)(__ccgo_up(q + 1*8))+float64(z*(**(**float64)(__ccgo_up(q + 2*8))+float64(z*(**(**float64)(__ccgo_up(q + 3*8))+float64(z*(**(**float64)(__ccgo_up(q + 4*8))+float64(z***(**float64)(__ccgo_up(q + 5*8))))))))))))) return (-Float64FromFloat64(0.125) + r/s) / x } @@ -107084,8 +107084,8 @@ func _pzerof(tls *TLS, x float32) (r1 float32) { } } z = float64(Float32FromFloat32(1) / float32(x*x)) - r = float64(*(*float32)(unsafe.Pointer(p))) + Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 1*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 2*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 3*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 4*4)))+Tfloat_t(z*float64(*(*float32)(unsafe.Pointer(p + 5*4)))))))))))) - s = Float64FromFloat32(1) + Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 1*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 2*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 3*4)))+Tfloat_t(z*float64(*(*float32)(unsafe.Pointer(q + 4*4)))))))))))) + r = float64(**(**float32)(__ccgo_up(p))) + Tfloat_t(z*(float64(**(**float32)(__ccgo_up(p + 1*4)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(p + 2*4)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(p + 3*4)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(p + 4*4)))+Tfloat_t(z*float64(**(**float32)(__ccgo_up(p + 5*4)))))))))))) + s = Float64FromFloat32(1) + Tfloat_t(z*(float64(**(**float32)(__ccgo_up(q)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(q + 1*4)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(q + 2*4)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(q + 3*4)))+Tfloat_t(z*float64(**(**float32)(__ccgo_up(q + 4*4)))))))))))) return float32(Float64FromFloat32(1) + r/s) } @@ -107192,8 +107192,8 @@ func _qzerof(tls *TLS, x float32) (r1 float32) { } } z = float64(Float32FromFloat32(1) / float32(x*x)) - r = float64(*(*float32)(unsafe.Pointer(p))) + Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 1*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 2*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 3*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 4*4)))+Tfloat_t(z*float64(*(*float32)(unsafe.Pointer(p + 5*4)))))))))))) - s = Float64FromFloat32(1) + Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 1*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 2*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 3*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 4*4)))+Tfloat_t(z*float64(*(*float32)(unsafe.Pointer(q + 5*4)))))))))))))) + r = float64(**(**float32)(__ccgo_up(p))) + Tfloat_t(z*(float64(**(**float32)(__ccgo_up(p + 1*4)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(p + 2*4)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(p + 3*4)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(p + 4*4)))+Tfloat_t(z*float64(**(**float32)(__ccgo_up(p + 5*4)))))))))))) + s = Float64FromFloat32(1) + Tfloat_t(z*(float64(**(**float32)(__ccgo_up(q)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(q + 1*4)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(q + 2*4)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(q + 3*4)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(q + 4*4)))+Tfloat_t(z*float64(**(**float32)(__ccgo_up(q + 5*4)))))))))))))) return float32((float64(-Float32FromFloat32(0.125)) + r/s) / float64(x)) } @@ -107430,8 +107430,8 @@ func _pone(tls *TLS, x float64) (r1 float64) { } } z = float64(1) / float64(x*x) - r = *(*float64)(unsafe.Pointer(p)) + float64(z*(*(*float64)(unsafe.Pointer(p + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 4*8))+float64(z**(*float64)(unsafe.Pointer(p + 5*8))))))))))) - s = float64(1) + float64(z*(*(*float64)(unsafe.Pointer(q))+float64(z*(*(*float64)(unsafe.Pointer(q + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 3*8))+float64(z**(*float64)(unsafe.Pointer(q + 4*8))))))))))) + r = **(**float64)(__ccgo_up(p)) + float64(z*(**(**float64)(__ccgo_up(p + 1*8))+float64(z*(**(**float64)(__ccgo_up(p + 2*8))+float64(z*(**(**float64)(__ccgo_up(p + 3*8))+float64(z*(**(**float64)(__ccgo_up(p + 4*8))+float64(z***(**float64)(__ccgo_up(p + 5*8))))))))))) + s = float64(1) + float64(z*(**(**float64)(__ccgo_up(q))+float64(z*(**(**float64)(__ccgo_up(q + 1*8))+float64(z*(**(**float64)(__ccgo_up(q + 2*8))+float64(z*(**(**float64)(__ccgo_up(q + 3*8))+float64(z***(**float64)(__ccgo_up(q + 4*8))))))))))) return float64(1) + r/s } @@ -107537,8 +107537,8 @@ func _qone(tls *TLS, x float64) (r1 float64) { } } z = float64(1) / float64(x*x) - r = *(*float64)(unsafe.Pointer(p)) + float64(z*(*(*float64)(unsafe.Pointer(p + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(p + 4*8))+float64(z**(*float64)(unsafe.Pointer(p + 5*8))))))))))) - s = float64(1) + float64(z*(*(*float64)(unsafe.Pointer(q))+float64(z*(*(*float64)(unsafe.Pointer(q + 1*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 2*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 3*8))+float64(z*(*(*float64)(unsafe.Pointer(q + 4*8))+float64(z**(*float64)(unsafe.Pointer(q + 5*8))))))))))))) + r = **(**float64)(__ccgo_up(p)) + float64(z*(**(**float64)(__ccgo_up(p + 1*8))+float64(z*(**(**float64)(__ccgo_up(p + 2*8))+float64(z*(**(**float64)(__ccgo_up(p + 3*8))+float64(z*(**(**float64)(__ccgo_up(p + 4*8))+float64(z***(**float64)(__ccgo_up(p + 5*8))))))))))) + s = float64(1) + float64(z*(**(**float64)(__ccgo_up(q))+float64(z*(**(**float64)(__ccgo_up(q + 1*8))+float64(z*(**(**float64)(__ccgo_up(q + 2*8))+float64(z*(**(**float64)(__ccgo_up(q + 3*8))+float64(z*(**(**float64)(__ccgo_up(q + 4*8))+float64(z***(**float64)(__ccgo_up(q + 5*8))))))))))))) return (float64(0.375) + r/s) / x } @@ -107761,8 +107761,8 @@ func _ponef(tls *TLS, x float32) (r1 float32) { } } z = float64(Float32FromFloat32(1) / float32(x*x)) - r = float64(*(*float32)(unsafe.Pointer(p))) + Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 1*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 2*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 3*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 4*4)))+Tfloat_t(z*float64(*(*float32)(unsafe.Pointer(p + 5*4)))))))))))) - s = Float64FromFloat32(1) + Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 1*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 2*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 3*4)))+Tfloat_t(z*float64(*(*float32)(unsafe.Pointer(q + 4*4)))))))))))) + r = float64(**(**float32)(__ccgo_up(p))) + Tfloat_t(z*(float64(**(**float32)(__ccgo_up(p + 1*4)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(p + 2*4)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(p + 3*4)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(p + 4*4)))+Tfloat_t(z*float64(**(**float32)(__ccgo_up(p + 5*4)))))))))))) + s = Float64FromFloat32(1) + Tfloat_t(z*(float64(**(**float32)(__ccgo_up(q)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(q + 1*4)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(q + 2*4)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(q + 3*4)))+Tfloat_t(z*float64(**(**float32)(__ccgo_up(q + 4*4)))))))))))) return float32(Float64FromFloat32(1) + r/s) } @@ -107868,8 +107868,8 @@ func _qonef(tls *TLS, x float32) (r1 float32) { } } z = float64(Float32FromFloat32(1) / float32(x*x)) - r = float64(*(*float32)(unsafe.Pointer(p))) + Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 1*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 2*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 3*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(p + 4*4)))+Tfloat_t(z*float64(*(*float32)(unsafe.Pointer(p + 5*4)))))))))))) - s = Float64FromFloat32(1) + Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 1*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 2*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 3*4)))+Tfloat_t(z*(float64(*(*float32)(unsafe.Pointer(q + 4*4)))+Tfloat_t(z*float64(*(*float32)(unsafe.Pointer(q + 5*4)))))))))))))) + r = float64(**(**float32)(__ccgo_up(p))) + Tfloat_t(z*(float64(**(**float32)(__ccgo_up(p + 1*4)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(p + 2*4)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(p + 3*4)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(p + 4*4)))+Tfloat_t(z*float64(**(**float32)(__ccgo_up(p + 5*4)))))))))))) + s = Float64FromFloat32(1) + Tfloat_t(z*(float64(**(**float32)(__ccgo_up(q)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(q + 1*4)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(q + 2*4)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(q + 3*4)))+Tfloat_t(z*(float64(**(**float32)(__ccgo_up(q + 4*4)))+Tfloat_t(z*float64(**(**float32)(__ccgo_up(q + 5*4)))))))))))))) return float32((Float64FromFloat32(0.375) + r/s) / float64(x)) } @@ -108550,7 +108550,7 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { }{} *(*float64)(unsafe.Pointer(bp)) = x /* purge off +-inf, NaN, +-0, tiny and negative arguments */ - *(*int32)(unsafe.Pointer(signgamp)) = int32(1) + **(**int32)(__ccgo_up(signgamp)) = int32(1) sign = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(63)) ix = uint32(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(32) & uint64(0x7fffffff)) if ix >= uint32(0x7ff00000) { @@ -108559,7 +108559,7 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { if ix < Uint32FromInt32((Int32FromInt32(0x3ff)-Int32FromInt32(70))< float64(0) { - *(*int32)(unsafe.Pointer(signgamp)) = -int32(1) + **(**int32)(__ccgo_up(signgamp)) = -int32(1) } else { t = -t } @@ -108807,7 +108807,7 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { }{} *(*float32)(unsafe.Pointer(bp)) = x /* purge off +-inf, NaN, +-0, tiny and negative arguments */ - *(*int32)(unsafe.Pointer(signgamp)) = int32(1) + **(**int32)(__ccgo_up(signgamp)) = int32(1) sign = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(bp)) >> int32(31)) ix = *(*Tuint32_t)(unsafe.Pointer(bp)) & uint32(0x7fffffff) if ix >= uint32(0x7f800000) { @@ -108815,7 +108815,7 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { } if ix < uint32(0x35000000) { /* |x| < 2**-21, return -log(|x|) */ if sign != 0 { - *(*int32)(unsafe.Pointer(signgamp)) = -int32(1) + **(**int32)(__ccgo_up(signgamp)) = -int32(1) x = -x } return -Xlogf(tls, x) @@ -108827,7 +108827,7 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { return Float32FromFloat32(1) / (x - x) } if t > Float32FromFloat32(0) { - *(*int32)(unsafe.Pointer(signgamp)) = -int32(1) + **(**int32)(__ccgo_up(signgamp)) = -int32(1) } else { t = -t } @@ -109058,15 +109058,15 @@ func Xlog(tls *TLS, x1 float64) (r1 float64) { r = x1 - float64(1) r2 = Tdouble_t(r * r) r3 = Tdouble_t(r * r2) - y1 = Tdouble_t(r3 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 1*8)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 2*8))) + float64(r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 3*8))) + float64(r3*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 4*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 5*8)))+float64(r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 6*8)))+float64(r3*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 7*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 8*8)))+float64(r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 9*8)))+float64(r3**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 10*8))))))))) + y1 = Tdouble_t(r3 * (**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 1*8)) + float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 2*8))) + float64(r2***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 3*8))) + float64(r3*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 4*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 5*8)))+float64(r2***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 6*8)))+float64(r3*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 7*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 8*8)))+float64(r2***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 9*8)))+float64(r3***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56 + 10*8))))))))) /* Worst-case error is around 0.507 ULP. */ w = Tdouble_t(r * float64(1.34217728e+08)) rhi = r + w - w rlo = r - rhi - w = Tdouble_t(Tdouble_t(rhi*rhi) * *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56))) /* B[0] == -0.5. */ + w = Tdouble_t(Tdouble_t(rhi*rhi) * **(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56))) /* B[0] == -0.5. */ hi = r + w lo = r - hi + w - lo = lo + Tdouble_t(float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56))*rlo)*(rhi+r)) + lo = lo + Tdouble_t(float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 56))*rlo)*(rhi+r)) y1 = y1 + lo y1 = y1 + hi y = y1 @@ -109099,14 +109099,14 @@ func Xlog(tls *TLS, x1 float64) (r1 float64) { i = Int32FromUint64(tmp >> (Int32FromInt32(52) - Int32FromInt32(LOG_TABLE_BITS)) % Uint64FromInt32(Int32FromInt32(1)<> int32(52)) /* arithmetic shift */ iz = uint64(ix - tmp&(Uint64FromUint64(0xfff)< 0x1p-4: 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma). */ - y1 = lo + Tdouble_t(r2**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16))) + Tdouble_t(Tdouble_t(r*r2)*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 1*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 2*8)))+float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 3*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 4*8))))))) + hi + y1 = lo + Tdouble_t(r2***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 16))) + Tdouble_t(Tdouble_t(r*r2)*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 1*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 2*8)))+float64(r2*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 3*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log_data)) + 16 + 4*8))))))) + hi y = y1 v1 = y goto _11 @@ -109568,10 +109568,10 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { r2 = Tdouble_t(r * r) /* rounding error: 0x1p-62. */ r4 = Tdouble_t(r2 * r2) /* Worst-case error is less than 0.54 ULP (0.55 ULP without fma). */ - p = Tdouble_t(r2 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 1*8))))) + p = Tdouble_t(r2 * (**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64)) + float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 1*8))))) y1 = hi + p lo = lo + (hi - y1 + p) - lo = lo + Tdouble_t(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 2*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 3*8)))+float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 4*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 5*8)))))+float64(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 6*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 7*8)))+float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 8*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 9*8))))))))) + lo = lo + Tdouble_t(r4*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 2*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 3*8)))+float64(r2*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 4*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 5*8)))))+float64(r4*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 6*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 7*8)))+float64(r2*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 8*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 9*8))))))))) y1 = y1 + lo y = y1 v1 = y @@ -109603,14 +109603,14 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { i = Int32FromUint64(tmp >> (Int32FromInt32(52) - Int32FromInt32(LOG2_TABLE_BITS)) % Uint64FromInt32(Int32FromInt32(1)<> int32(52)) /* arithmetic shift */ iz = uint64(ix - tmp&(Uint64FromUint64(0xfff)< 0x1p-4: 0.547 ULP (0.550 ULP without fma). ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma). */ - p = *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 1*8))) + float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 2*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 3*8))))) + float64(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 4*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 5*8))))) + p = **(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 16)) + float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 1*8))) + float64(r2*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 2*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 3*8))))) + float64(r4*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 4*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2_data)) + 16 + 5*8))))) y1 = lo + Tdouble_t(r2*p) + hi y = y1 v1 = y @@ -109701,23 +109701,23 @@ func Xlog2f(tls *TLS, x1 float32) (r1 float32) { top = tmp & uint32(0xff800000) iz = ix - top k = Int32FromUint32(tmp) >> int32(23) /* arithmetic shift */ - invc = (*(*struct { + invc = (**(**struct { Finvc float64 Flogc float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + uintptr(i)*16))).Finvc - logc = (*(*struct { + })(__ccgo_up(uintptr(unsafe.Pointer(&X__log2f_data)) + uintptr(i)*16))).Finvc + logc = (**(**struct { Finvc float64 Flogc float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + uintptr(i)*16))).Flogc + })(__ccgo_up(uintptr(unsafe.Pointer(&X__log2f_data)) + uintptr(i)*16))).Flogc z = float64(*(*float32)(unsafe.Pointer(&iz))) /* log2(x) = log1p(z/c-1)/ln2 + log2(c) + k */ r = Tdouble_t(z*invc) - Float64FromInt32(1) y0 = logc + float64(k) /* Pipelined polynomial evaluation to approximate log1p(r)/ln2. */ r2 = Tdouble_t(r * r) - y1 = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 1*8))*r) + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 2*8)) - y1 = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256))*r2) + y1 - p = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 3*8))*r) + y0 + y1 = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 1*8))*r) + **(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 2*8)) + y1 = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2f_data)) + 256))*r2) + y1 + p = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__log2f_data)) + 256 + 3*8))*r) + y0 y1 = Tdouble_t(y1*r2) + p y = float32(y1) v1 = y @@ -109890,22 +109890,22 @@ func Xlogf(tls *TLS, x1 float32) (r1 float32) { i = Int32FromUint32(tmp >> (Int32FromInt32(23) - Int32FromInt32(LOGF_TABLE_BITS)) % Uint32FromInt32(Int32FromInt32(1)<> int32(23) /* arithmetic shift */ iz = ix - tmp&uint32(0xff800000) - invc = (*(*struct { + invc = (**(**struct { Finvc float64 Flogc float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + uintptr(i)*16))).Finvc - logc = (*(*struct { + })(__ccgo_up(uintptr(unsafe.Pointer(&X__logf_data)) + uintptr(i)*16))).Finvc + logc = (**(**struct { Finvc float64 Flogc float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + uintptr(i)*16))).Flogc + })(__ccgo_up(uintptr(unsafe.Pointer(&X__logf_data)) + uintptr(i)*16))).Flogc z = float64(*(*float32)(unsafe.Pointer(&iz))) /* log(x) = log1p(z/c-1) + log(c) + k*Ln2 */ r = Tdouble_t(z*invc) - Float64FromInt32(1) y0 = logc + Tdouble_t(float64(k)*X__logf_data.Fln2) /* Pipelined polynomial evaluation to approximate log1p(r). */ r2 = Tdouble_t(r * r) - y1 = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + 264 + 1*8))*r) + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + 264 + 2*8)) - y1 = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__logf_data)) + 264))*r2) + y1 + y1 = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__logf_data)) + 264 + 1*8))*r) + **(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__logf_data)) + 264 + 2*8)) + y1 = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__logf_data)) + 264))*r2) + y1 y1 = Tdouble_t(y1*r2) + (y0 + r) y = float32(y1) v1 = y @@ -110030,7 +110030,7 @@ func Xmodf(tls *TLS, x float64, iptr uintptr) (r float64) { e = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp))>>Int32FromInt32(52)&Uint64FromInt32(0x7ff)) - int32(0x3ff) /* no fractional part */ if e >= int32(52) { - *(*float64)(unsafe.Pointer(iptr)) = x + **(**float64)(__ccgo_up(iptr)) = x if e == int32(0x400) && *(*Tuint64_t)(unsafe.Pointer(bp))<> Int32FromInt32(12) >> e) if *(*Tuint64_t)(unsafe.Pointer(bp))&mask == uint64(0) { - *(*float64)(unsafe.Pointer(iptr)) = x + **(**float64)(__ccgo_up(iptr)) = x v1 = bp *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & (Uint64FromUint64(1) << Int32FromInt32(63))) return *(*float64)(unsafe.Pointer(bp)) } *(*Tuint64_t)(unsafe.Pointer(bp)) &= ^mask - *(*float64)(unsafe.Pointer(iptr)) = *(*float64)(unsafe.Pointer(bp)) + **(**float64)(__ccgo_up(iptr)) = *(*float64)(unsafe.Pointer(bp)) return x - *(*float64)(unsafe.Pointer(bp)) } @@ -110082,7 +110082,7 @@ func Xmodff(tls *TLS, x float32, iptr uintptr) (r float32) { e = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(bp))>>Int32FromInt32(23)&Uint32FromInt32(0xff)) - int32(0x7f) /* no fractional part */ if e >= int32(23) { - *(*float32)(unsafe.Pointer(iptr)) = x + **(**float32)(__ccgo_up(iptr)) = x if e == int32(0x80) && *(*Tuint32_t)(unsafe.Pointer(bp))<> e) if *(*Tuint32_t)(unsafe.Pointer(bp))&mask == uint32(0) { - *(*float32)(unsafe.Pointer(iptr)) = x + **(**float32)(__ccgo_up(iptr)) = x *(*Tuint32_t)(unsafe.Pointer(bp)) &= uint32(0x80000000) return *(*float32)(unsafe.Pointer(bp)) } *(*Tuint32_t)(unsafe.Pointer(bp)) &= ^mask - *(*float32)(unsafe.Pointer(iptr)) = *(*float32)(unsafe.Pointer(bp)) + **(**float32)(__ccgo_up(iptr)) = *(*float32)(unsafe.Pointer(bp)) return x - *(*float32)(unsafe.Pointer(bp)) } @@ -110117,7 +110117,7 @@ func Xmodfl(tls *TLS, x float64, iptr uintptr) (r1 float64) { var _ /* d at bp+0 */ float64 _ = r r = Xmodf(tls, x, bp) - *(*float64)(unsafe.Pointer(iptr)) = *(*float64)(unsafe.Pointer(bp)) + **(**float64)(__ccgo_up(iptr)) = float64(**(**float64)(__ccgo_up(bp))) return r } @@ -110519,24 +110519,24 @@ func _log_inline(tls *TLS, ix Tuint64_t, tail uintptr) (r1 Tdouble_t) { z = *(*float64)(unsafe.Pointer(&iz)) kd = float64(k) /* log(x) = k*Ln2 + log(c) + log1p(z/c-1). */ - invc = (*(*struct { + invc = (**(**struct { Finvc float64 Fpad float64 Flogc float64 Flogctail float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Finvc - logc = (*(*struct { + })(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Finvc + logc = (**(**struct { Finvc float64 Fpad float64 Flogc float64 Flogctail float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Flogc - logctail = (*(*struct { + })(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Flogc + logctail = (**(**struct { Finvc float64 Fpad float64 Flogc float64 Flogctail float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Flogctail + })(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 72 + uintptr(i)*32))).Flogctail /* Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible. */ r = float64(X__builtin_fma(tls, z, invc, -Float64FromFloat64(1))) @@ -110545,7 +110545,7 @@ func _log_inline(tls *TLS, ix Tuint64_t, tail uintptr) (r1 Tdouble_t) { t2 = t1 + r lo1 = Tdouble_t(kd*X__pow_log_data.Fln2lo) + logctail lo2 = t1 - t2 + r - ar = Tdouble_t(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16)) * r) /* A[0] = -0.5. */ + ar = Tdouble_t(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16)) * r) /* A[0] = -0.5. */ ar2 = Tdouble_t(r * ar) ar3 = Tdouble_t(r * ar2) /* k*Ln2 + log(c) + r + A[0]*r*r. */ @@ -110553,10 +110553,10 @@ func _log_inline(tls *TLS, ix Tuint64_t, tail uintptr) (r1 Tdouble_t) { lo3 = float64(X__builtin_fma(tls, ar, r, -ar2)) lo4 = t2 - hi + ar2 /* p = log1p(r) - r - A[0]*r*r. */ - p = Tdouble_t(ar3 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 1*8)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 2*8))) + float64(ar2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 3*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 4*8)))+float64(ar2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 5*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 6*8))))))))) + p = Tdouble_t(ar3 * (**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 1*8)) + float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 2*8))) + float64(ar2*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 3*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 4*8)))+float64(ar2*(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 5*8))+float64(r***(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__pow_log_data)) + 16 + 6*8))))))))) lo = lo1 + lo2 + lo3 + lo4 + p y = hi + lo - *(*Tdouble_t)(unsafe.Pointer(tail)) = hi - y + lo + **(**Tdouble_t)(__ccgo_up(tail)) = hi - y + lo return y } @@ -110676,16 +110676,16 @@ _4: /* 2^(k/N) ~= scale * (1 + tail). */ idx = uint64(2) * (ki % Uint64FromInt32(Int32FromInt32(1)<> (Int32FromInt32(23) - Int32FromInt32(POWF_SCALE_BITS)) /* arithmetic shift */ - invc = (*(*struct { + invc = (**(**struct { Finvc float64 Flogc float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + uintptr(i)*16))).Finvc - logc = (*(*struct { + })(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + uintptr(i)*16))).Finvc + logc = (**(**struct { Finvc float64 Flogc float64 - })(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + uintptr(i)*16))).Flogc + })(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + uintptr(i)*16))).Flogc z = float64(*(*float32)(unsafe.Pointer(&iz))) /* log2(x) = log1p(z/c-1)/ln2 + log2(c) + k */ r = Tdouble_t(z*invc) - Float64FromInt32(1) y0 = logc + float64(k) /* Pipelined polynomial evaluation to approximate log1p(r)/ln2. */ r2 = Tdouble_t(r * r) - y = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256))*r) + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 1*8)) - p = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 2*8))*r) + *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 3*8)) + y = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256))*r) + **(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 1*8)) + p = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 2*8))*r) + **(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 3*8)) r4 = Tdouble_t(r2 * r2) - q = float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 4*8))*r) + y0 + q = float64(**(**float64)(__ccgo_up(uintptr(unsafe.Pointer(&X__powf_log2_data)) + 256 + 4*8))*r) + y0 q = Tdouble_t(p*r2) + q y = Tdouble_t(y*r4) + q return y @@ -110947,13 +110947,13 @@ _2: kd = kd - X__exp2f_data.Fshift_scaled /* k/N */ r = xd - kd /* exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1) */ - t = *(*Tuint64_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + uintptr(ki%Uint64FromInt32(Int32FromInt32(1)<> int32(63)) sy = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp + 16)) >> int32(63)) uxi = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) - *(*int32)(unsafe.Pointer(quo)) = 0 + **(**int32)(__ccgo_up(quo)) = 0 if v3 = *(*Tuint64_t)(unsafe.Pointer(bp + 16))<> int32(31)) sy = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(bp + 8)) >> int32(31)) uxi = *(*Tuint32_t)(unsafe.Pointer(bp + 4)) - *(*int32)(unsafe.Pointer(quo)) = 0 + **(**int32)(__ccgo_up(quo)) = 0 if v3 = *(*Tuint32_t)(unsafe.Pointer(bp + 8))<= uint32(0x7ff00000) { v1 = x3 - x3 - *(*float64)(unsafe.Pointer(cos)) = v1 - *(*float64)(unsafe.Pointer(sin)) = v1 + **(**float64)(__ccgo_up(cos)) = v1 + **(**float64)(__ccgo_up(sin)) = v1 return } /* argument reduction needed */ n = Uint32FromInt32(X__rem_pio2(tls, x3, bp)) - s = X__sin(tls, (*(*[2]float64)(unsafe.Pointer(bp)))[0], (*(*[2]float64)(unsafe.Pointer(bp)))[int32(1)], int32(1)) - c = X__cos(tls, (*(*[2]float64)(unsafe.Pointer(bp)))[0], (*(*[2]float64)(unsafe.Pointer(bp)))[int32(1)]) + s = X__sin(tls, (**(**[2]float64)(__ccgo_up(bp)))[0], (**(**[2]float64)(__ccgo_up(bp)))[int32(1)], int32(1)) + c = X__cos(tls, (**(**[2]float64)(__ccgo_up(bp)))[0], (**(**[2]float64)(__ccgo_up(bp)))[int32(1)]) switch n & Uint32FromInt32(3) { case uint32(0): - *(*float64)(unsafe.Pointer(sin)) = s - *(*float64)(unsafe.Pointer(cos)) = c + **(**float64)(__ccgo_up(sin)) = s + **(**float64)(__ccgo_up(cos)) = c case uint32(1): - *(*float64)(unsafe.Pointer(sin)) = c - *(*float64)(unsafe.Pointer(cos)) = -s + **(**float64)(__ccgo_up(sin)) = c + **(**float64)(__ccgo_up(cos)) = -s case uint32(2): - *(*float64)(unsafe.Pointer(sin)) = -s - *(*float64)(unsafe.Pointer(cos)) = -c + **(**float64)(__ccgo_up(sin)) = -s + **(**float64)(__ccgo_up(cos)) = -c case uint32(3): fallthrough default: - *(*float64)(unsafe.Pointer(sin)) = -c - *(*float64)(unsafe.Pointer(cos)) = s + **(**float64)(__ccgo_up(sin)) = -c + **(**float64)(__ccgo_up(cos)) = s break } } @@ -112194,23 +112194,23 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { y2 = float64(v1) } } - *(*float32)(unsafe.Pointer(sin)) = x3 - *(*float32)(unsafe.Pointer(cos)) = Float32FromFloat32(1) + **(**float32)(__ccgo_up(sin)) = x3 + **(**float32)(__ccgo_up(cos)) = Float32FromFloat32(1) return } - *(*float32)(unsafe.Pointer(sin)) = X__sindf(tls, float64(x3)) - *(*float32)(unsafe.Pointer(cos)) = X__cosdf(tls, float64(x3)) + **(**float32)(__ccgo_up(sin)) = X__sindf(tls, float64(x3)) + **(**float32)(__ccgo_up(cos)) = X__cosdf(tls, float64(x3)) return } /* |x| ~<= 5*pi/4 */ if ix <= uint32(0x407b53d1) { if ix <= uint32(0x4016cbe3) { /* |x| ~<= 3pi/4 */ if sign != 0 { - *(*float32)(unsafe.Pointer(sin)) = -X__cosdf(tls, float64(x3)+_s1pio2) - *(*float32)(unsafe.Pointer(cos)) = X__sindf(tls, float64(x3)+_s1pio2) + **(**float32)(__ccgo_up(sin)) = -X__cosdf(tls, float64(x3)+_s1pio2) + **(**float32)(__ccgo_up(cos)) = X__sindf(tls, float64(x3)+_s1pio2) } else { - *(*float32)(unsafe.Pointer(sin)) = X__cosdf(tls, _s1pio2-float64(x3)) - *(*float32)(unsafe.Pointer(cos)) = X__sindf(tls, _s1pio2-float64(x3)) + **(**float32)(__ccgo_up(sin)) = X__cosdf(tls, _s1pio2-float64(x3)) + **(**float32)(__ccgo_up(cos)) = X__sindf(tls, _s1pio2-float64(x3)) } return } @@ -112220,24 +112220,24 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { } else { v4 = float64(x3) - _s2pio2 } - *(*float32)(unsafe.Pointer(sin)) = -X__sindf(tls, v4) + **(**float32)(__ccgo_up(sin)) = -X__sindf(tls, v4) if sign != 0 { v4 = float64(x3) + _s2pio2 } else { v4 = float64(x3) - _s2pio2 } - *(*float32)(unsafe.Pointer(cos)) = -X__cosdf(tls, v4) + **(**float32)(__ccgo_up(cos)) = -X__cosdf(tls, v4) return } /* |x| ~<= 9*pi/4 */ if ix <= uint32(0x40e231d5) { if ix <= uint32(0x40afeddf) { /* |x| ~<= 7*pi/4 */ if sign != 0 { - *(*float32)(unsafe.Pointer(sin)) = X__cosdf(tls, float64(x3)+_s3pio2) - *(*float32)(unsafe.Pointer(cos)) = -X__sindf(tls, float64(x3)+_s3pio2) + **(**float32)(__ccgo_up(sin)) = X__cosdf(tls, float64(x3)+_s3pio2) + **(**float32)(__ccgo_up(cos)) = -X__sindf(tls, float64(x3)+_s3pio2) } else { - *(*float32)(unsafe.Pointer(sin)) = -X__cosdf(tls, float64(x3)-_s3pio2) - *(*float32)(unsafe.Pointer(cos)) = X__sindf(tls, float64(x3)-_s3pio2) + **(**float32)(__ccgo_up(sin)) = -X__cosdf(tls, float64(x3)-_s3pio2) + **(**float32)(__ccgo_up(cos)) = X__sindf(tls, float64(x3)-_s3pio2) } return } @@ -112246,41 +112246,41 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { } else { v4 = float64(x3) - _s4pio2 } - *(*float32)(unsafe.Pointer(sin)) = X__sindf(tls, v4) + **(**float32)(__ccgo_up(sin)) = X__sindf(tls, v4) if sign != 0 { v4 = float64(x3) + _s4pio2 } else { v4 = float64(x3) - _s4pio2 } - *(*float32)(unsafe.Pointer(cos)) = X__cosdf(tls, v4) + **(**float32)(__ccgo_up(cos)) = X__cosdf(tls, v4) return } /* sin(Inf or NaN) is NaN */ if ix >= uint32(0x7f800000) { v1 = x3 - x3 - *(*float32)(unsafe.Pointer(cos)) = v1 - *(*float32)(unsafe.Pointer(sin)) = v1 + **(**float32)(__ccgo_up(cos)) = v1 + **(**float32)(__ccgo_up(sin)) = v1 return } /* general argument reduction needed */ n = Uint32FromInt32(X__rem_pio2f(tls, x3, bp)) - s = float64(X__sindf(tls, *(*float64)(unsafe.Pointer(bp)))) - c = float64(X__cosdf(tls, *(*float64)(unsafe.Pointer(bp)))) + s = float64(X__sindf(tls, **(**float64)(__ccgo_up(bp)))) + c = float64(X__cosdf(tls, **(**float64)(__ccgo_up(bp)))) switch n & Uint32FromInt32(3) { case uint32(0): - *(*float32)(unsafe.Pointer(sin)) = float32(s) - *(*float32)(unsafe.Pointer(cos)) = float32(c) + **(**float32)(__ccgo_up(sin)) = float32(s) + **(**float32)(__ccgo_up(cos)) = float32(c) case uint32(1): - *(*float32)(unsafe.Pointer(sin)) = float32(c) - *(*float32)(unsafe.Pointer(cos)) = float32(-s) + **(**float32)(__ccgo_up(sin)) = float32(c) + **(**float32)(__ccgo_up(cos)) = float32(-s) case uint32(2): - *(*float32)(unsafe.Pointer(sin)) = float32(-s) - *(*float32)(unsafe.Pointer(cos)) = float32(-c) + **(**float32)(__ccgo_up(sin)) = float32(-s) + **(**float32)(__ccgo_up(cos)) = float32(-c) case uint32(3): fallthrough default: - *(*float32)(unsafe.Pointer(sin)) = float32(-c) - *(*float32)(unsafe.Pointer(cos)) = float32(s) + **(**float32)(__ccgo_up(sin)) = float32(-c) + **(**float32)(__ccgo_up(cos)) = float32(s) break } } @@ -112296,8 +112296,8 @@ func Xsincosl(tls *TLS, x float64, sin uintptr, cos uintptr) { var _ /* cosd at bp+8 */ float64 var _ /* sind at bp+0 */ float64 Xsincos(tls, x, bp, bp+8) - *(*float64)(unsafe.Pointer(sin)) = *(*float64)(unsafe.Pointer(bp)) - *(*float64)(unsafe.Pointer(cos)) = *(*float64)(unsafe.Pointer(bp + 8)) + **(**float64)(__ccgo_up(sin)) = float64(**(**float64)(__ccgo_up(bp))) + **(**float64)(__ccgo_up(cos)) = float64(**(**float64)(__ccgo_up(bp + 8))) } const M_PI_27 = 1.5707963267948966 @@ -112396,13 +112396,13 @@ func Xsinf(tls *TLS, x3 float32) (r float32) { n = X__rem_pio2f(tls, x3, bp) switch n & Int32FromInt32(3) { case 0: - return X__sindf(tls, *(*float64)(unsafe.Pointer(bp))) + return X__sindf(tls, **(**float64)(__ccgo_up(bp))) case int32(1): - return X__cosdf(tls, *(*float64)(unsafe.Pointer(bp))) + return X__cosdf(tls, **(**float64)(__ccgo_up(bp))) case int32(2): - return X__sindf(tls, -*(*float64)(unsafe.Pointer(bp))) + return X__sindf(tls, -**(**float64)(__ccgo_up(bp))) default: - return -X__cosdf(tls, *(*float64)(unsafe.Pointer(bp))) + return -X__cosdf(tls, **(**float64)(__ccgo_up(bp))) } return r } @@ -112848,7 +112848,7 @@ func Xtan(tls *TLS, x3 float64) (r float64) { } /* argument reduction */ n = Uint32FromInt32(X__rem_pio2(tls, x3, bp)) - return X__tan(tls, (*(*[2]float64)(unsafe.Pointer(bp)))[0], (*(*[2]float64)(unsafe.Pointer(bp)))[int32(1)], Int32FromUint32(n&uint32(1))) + return X__tan(tls, (**(**[2]float64)(__ccgo_up(bp)))[0], (**(**[2]float64)(__ccgo_up(bp)))[int32(1)], Int32FromUint32(n&uint32(1))) } const M_PI_29 = 1.5707963267948966 @@ -112949,7 +112949,7 @@ func Xtanf(tls *TLS, x3 float32) (r float32) { } /* argument reduction */ n = Uint32FromInt32(X__rem_pio2f(tls, x3, bp)) - return X__tandf(tls, *(*float64)(unsafe.Pointer(bp)), Int32FromUint32(n&uint32(1))) + return X__tandf(tls, **(**float64)(__ccgo_up(bp)), Int32FromUint32(n&uint32(1))) } const M_PI_210 = 0 @@ -113489,10 +113489,10 @@ func Xa64l(tls *TLS, s uintptr) (r int64) { x = uint32(0) e = 0 for { - if !(e < int32(36) && *(*uint8)(unsafe.Pointer(s)) != 0) { + if !(e < int32(36) && **(**uint8)(__ccgo_up(s)) != 0) { break } - d = Xstrchr(tls, uintptr(unsafe.Pointer(&_digits)), Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))) + d = Xstrchr(tls, uintptr(unsafe.Pointer(&_digits)), Int32FromUint8(**(**uint8)(__ccgo_up(s)))) if !(d != 0) { break } @@ -113520,14 +113520,14 @@ func Xl64a(tls *TLS, x0 int64) (r uintptr) { if !(x != 0) { break } - *(*uint8)(unsafe.Pointer(p)) = _digits[x&uint32(63)] + **(**uint8)(__ccgo_up(p)) = _digits[x&uint32(63)] goto _1 _1: ; p = p + 1 x = x >> uint32(6) } - *(*uint8)(unsafe.Pointer(p)) = uint8(0) + **(**uint8)(__ccgo_up(p)) = uint8(0) return uintptr(unsafe.Pointer(&_s)) } @@ -113540,22 +113540,22 @@ func Xbasename(tls *TLS, s uintptr) (r uintptr) { } var i Tsize_t _ = i - if !(s != 0) || !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(s != 0) || !(**(**uint8)(__ccgo_up(s)) != 0) { return __ccgo_ts + 598 } i = _strlen(tls, s) - uint64(1) for { - if !(i != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(i)))) == int32('/')) { + if !(i != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(i)))) == int32('/')) { break } - *(*uint8)(unsafe.Pointer(s + uintptr(i))) = uint8(0) + **(**uint8)(__ccgo_up(s + uintptr(i))) = uint8(0) goto _1 _1: ; i = i - 1 } for { - if !(i != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(i-uint64(1))))) != int32('/')) { + if !(i != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(i-uint64(1))))) != int32('/')) { break } goto _2 @@ -113581,12 +113581,12 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { } var i Tsize_t _ = i - if !(s != 0) || !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(s != 0) || !(**(**uint8)(__ccgo_up(s)) != 0) { return __ccgo_ts + 598 } i = _strlen(tls, s) - uint64(1) for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(i)))) == int32('/')) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(i)))) == int32('/')) { break } if !(i != 0) { @@ -113598,7 +113598,7 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { i = i - 1 } for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(i)))) != int32('/')) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(i)))) != int32('/')) { break } if !(i != 0) { @@ -113610,7 +113610,7 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { i = i - 1 } for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(i)))) == int32('/')) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(i)))) == int32('/')) { break } if !(i != 0) { @@ -113621,7 +113621,7 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { ; i = i - 1 } - *(*uint8)(unsafe.Pointer(s + uintptr(i+uint64(1)))) = uint8(0) + **(**uint8)(__ccgo_up(s + uintptr(i+uint64(1)))) = uint8(0) return s } @@ -113712,10 +113712,10 @@ func __strcolcmp(tls *TLS, lstr uintptr, bstr uintptr) (r int32) { var i Tsize_t _ = i i = uint64(0) - for *(*uint8)(unsafe.Pointer(lstr + uintptr(i))) != 0 && *(*uint8)(unsafe.Pointer(bstr + uintptr(i))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(bstr + uintptr(i)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(lstr + uintptr(i)))) { + for **(**uint8)(__ccgo_up(lstr + uintptr(i))) != 0 && **(**uint8)(__ccgo_up(bstr + uintptr(i))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(bstr + uintptr(i)))) == Int32FromUint8(**(**uint8)(__ccgo_up(lstr + uintptr(i)))) { i = i + 1 } - if *(*uint8)(unsafe.Pointer(lstr + uintptr(i))) != 0 || *(*uint8)(unsafe.Pointer(bstr + uintptr(i))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(bstr + uintptr(i)))) != int32(':') { + if **(**uint8)(__ccgo_up(lstr + uintptr(i))) != 0 || **(**uint8)(__ccgo_up(bstr + uintptr(i))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(bstr + uintptr(i)))) != int32(':') { return int32(1) } return 0 @@ -113813,7 +113813,7 @@ func Xfmtmsg(tls *TLS, classification int64, label uintptr, severity int32, text } } if classification&int64(MM_PRINT) != 0 { - for cmsg != 0 && *(*uint8)(unsafe.Pointer(cmsg)) != 0 { + for cmsg != 0 && **(**uint8)(__ccgo_up(cmsg)) != 0 { i = 0 for { if !(msgs[i] != 0) { @@ -113889,7 +113889,7 @@ func Xfmtmsg(tls *TLS, classification int64, label uintptr, severity int32, text if ret&(Int32FromInt32(MM_NOCON)|Int32FromInt32(MM_NOMSG)) == Int32FromInt32(MM_NOCON)|Int32FromInt32(MM_NOMSG) { ret = -int32(1) } - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) return ret } @@ -113905,7 +113905,7 @@ func Xget_current_dir_name(tls *TLS) (r uintptr) { var _ /* b at bp+144 */ Tstat _ = res res = Xgetenv(tls, __ccgo_ts+722) - if res != 0 && *(*uint8)(unsafe.Pointer(res)) != 0 && !(Xstat(tls, res, bp) != 0) && !(Xstat(tls, __ccgo_ts+598, bp+144) != 0) && (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev == (*(*Tstat)(unsafe.Pointer(bp + 144))).Fst_dev && (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino == (*(*Tstat)(unsafe.Pointer(bp + 144))).Fst_ino { + if res != 0 && **(**uint8)(__ccgo_up(res)) != 0 && !(Xstat(tls, res, bp) != 0) && !(Xstat(tls, __ccgo_ts+598, bp+144) != 0) && (**(**Tstat)(__ccgo_up(bp))).Fst_dev == (**(**Tstat)(__ccgo_up(bp + 144))).Fst_dev && (**(**Tstat)(__ccgo_up(bp))).Fst_ino == (**(**Tstat)(__ccgo_up(bp + 144))).Fst_ino { return Xstrdup(tls, res) } return Xgetcwd(tls, uintptr(0), uint64(0)) @@ -113923,18 +113923,18 @@ func X__getauxval(tls *TLS, item uint64) (r uint64) { return uint64(X__libc.Fsecure) } for { - if !(*(*Tsize_t)(unsafe.Pointer(auxv)) != 0) { + if !(**(**Tsize_t)(__ccgo_up(auxv)) != 0) { break } - if *(*Tsize_t)(unsafe.Pointer(auxv)) == item { - return *(*Tsize_t)(unsafe.Pointer(auxv + 1*8)) + if **(**Tsize_t)(__ccgo_up(auxv)) == item { + return **(**Tsize_t)(__ccgo_up(auxv + 1*8)) } goto _1 _1: ; auxv = auxv + uintptr(2)*8 } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOENT) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOENT) return uint64(0) } @@ -113965,7 +113965,7 @@ func Xgetdomainname(tls *TLS, name uintptr, len1 Tsize_t) (r int32) { var _ /* temp at bp+0 */ Tutsname Xuname(tls, bp) if !(len1 != 0) || _strlen(tls, bp+325) >= len1 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } Xstrcpy(tls, name, bp+325) @@ -113986,14 +113986,14 @@ func Xgetentropy(tls *TLS, buffer uintptr, len1 Tsize_t) (r int32) { ret = 0 pos = buffer if len1 > uint64(256) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EIO) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EIO) return -int32(1) } _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp) for len1 != 0 { ret = int32(Xgetrandom(tls, pos, len1, uint32(0))) if ret < 0 { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EINTR) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EINTR) { continue } else { break @@ -114003,7 +114003,7 @@ func Xgetentropy(tls *TLS, buffer uintptr, len1 Tsize_t) (r int32) { len1 = len1 - Uint64FromInt32(ret) ret = 0 } - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) return ret } @@ -114057,46 +114057,46 @@ func Xgetopt(tls *TLS, argc int32, argv uintptr, optstring uintptr) (r int32) { X__optpos = 0 Xoptind = int32(1) } - if Xoptind >= argc || !(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) != 0) { + if Xoptind >= argc || !(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) != 0) { return -int32(1) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))))) != int32('-') { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) == int32('-') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8))))) != int32('-') { + if Int32FromUint8(**(**uint8)(__ccgo_up(optstring))) == int32('-') { v1 = Xoptind Xoptind = Xoptind + 1 - Xoptarg = *(*uintptr)(unsafe.Pointer(argv + uintptr(v1)*8)) + Xoptarg = **(**uintptr)(__ccgo_up(argv + uintptr(v1)*8)) return int32(1) } return -int32(1) } - if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1)) != 0) { + if !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + 1)) != 0) { return -int32(1) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1))) == int32('-') && !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 2)) != 0) { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + 1))) == int32('-') && !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + 2)) != 0) { Xoptind = Xoptind + 1 return -Int32FromInt32(1) } if !(X__optpos != 0) { X__optpos = X__optpos + 1 } - v1 = Xmbtowc(tls, bp, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))+uintptr(X__optpos), uint64(MB_LEN_MAX)) + v1 = Xmbtowc(tls, bp, **(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8))+uintptr(X__optpos), uint64(MB_LEN_MAX)) k = v1 if v1 < 0 { k = int32(1) - *(*Twchar_t)(unsafe.Pointer(bp)) = int32(0xfffd) /* replacement char */ + **(**Twchar_t)(__ccgo_up(bp)) = int32(0xfffd) /* replacement char */ } - optchar = *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + uintptr(X__optpos) + optchar = **(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + uintptr(X__optpos) X__optpos = X__optpos + k - if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + uintptr(X__optpos))) != 0) { + if !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + uintptr(X__optpos))) != 0) { Xoptind = Xoptind + 1 X__optpos = 0 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) == int32('-') || Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) == int32('+') { + if Int32FromUint8(**(**uint8)(__ccgo_up(optstring))) == int32('-') || Int32FromUint8(**(**uint8)(__ccgo_up(optstring))) == int32('+') { optstring = optstring + 1 } i = 0 - *(*Twchar_t)(unsafe.Pointer(bp + 4)) = 0 - for cond := true; cond; cond = l != 0 && *(*Twchar_t)(unsafe.Pointer(bp + 4)) != *(*Twchar_t)(unsafe.Pointer(bp)) { + **(**Twchar_t)(__ccgo_up(bp + 4)) = 0 + for cond := true; cond; cond = l != 0 && **(**Twchar_t)(__ccgo_up(bp + 4)) != **(**Twchar_t)(__ccgo_up(bp)) { l = Xmbtowc(tls, bp+4, optstring+uintptr(i), uint64(MB_LEN_MAX)) if l > 0 { i = i + l @@ -114104,36 +114104,36 @@ func Xgetopt(tls *TLS, argc int32, argv uintptr, optstring uintptr) (r int32) { i = i + 1 } } - if *(*Twchar_t)(unsafe.Pointer(bp + 4)) != *(*Twchar_t)(unsafe.Pointer(bp)) || *(*Twchar_t)(unsafe.Pointer(bp)) == int32(':') { - Xoptopt = *(*Twchar_t)(unsafe.Pointer(bp)) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) != int32(':') && Xopterr != 0 { - X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), __ccgo_ts+726, optchar, Uint64FromInt32(k)) + if **(**Twchar_t)(__ccgo_up(bp + 4)) != **(**Twchar_t)(__ccgo_up(bp)) || **(**Twchar_t)(__ccgo_up(bp)) == int32(':') { + Xoptopt = **(**Twchar_t)(__ccgo_up(bp)) + if Int32FromUint8(**(**uint8)(__ccgo_up(optstring))) != int32(':') && Xopterr != 0 { + X__getopt_msg(tls, **(**uintptr)(__ccgo_up(argv)), __ccgo_ts+726, optchar, Uint64FromInt32(k)) } return int32('?') } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring + uintptr(i)))) == int32(':') { + if Int32FromUint8(**(**uint8)(__ccgo_up(optstring + uintptr(i)))) == int32(':') { Xoptarg = uintptr(0) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring + uintptr(i+int32(1))))) != int32(':') || X__optpos != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(optstring + uintptr(i+int32(1))))) != int32(':') || X__optpos != 0 { v1 = Xoptind Xoptind = Xoptind + 1 - Xoptarg = *(*uintptr)(unsafe.Pointer(argv + uintptr(v1)*8)) + Xoptarg = **(**uintptr)(__ccgo_up(argv + uintptr(v1)*8)) if X__optpos != 0 { Xoptarg = Xoptarg + uintptr(X__optpos) } X__optpos = 0 } if Xoptind > argc { - Xoptopt = *(*Twchar_t)(unsafe.Pointer(bp)) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) == int32(':') { + Xoptopt = **(**Twchar_t)(__ccgo_up(bp)) + if Int32FromUint8(**(**uint8)(__ccgo_up(optstring))) == int32(':') { return int32(':') } if Xopterr != 0 { - X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), __ccgo_ts+750, optchar, Uint64FromInt32(k)) + X__getopt_msg(tls, **(**uintptr)(__ccgo_up(argv)), __ccgo_ts+750, optchar, Uint64FromInt32(k)) } return int32('?') } } - return *(*Twchar_t)(unsafe.Pointer(bp)) + return **(**Twchar_t)(__ccgo_up(bp)) } func X__posix_getopt(tls *TLS, argc int32, argv uintptr, optstring uintptr) (r int32) { @@ -114160,19 +114160,19 @@ func _permute(tls *TLS, argv uintptr, dest int32, src int32) { var i int32 _, _, _ = av, i, tmp av = argv - tmp = *(*uintptr)(unsafe.Pointer(av + uintptr(src)*8)) + tmp = **(**uintptr)(__ccgo_up(av + uintptr(src)*8)) i = src for { if !(i > dest) { break } - *(*uintptr)(unsafe.Pointer(av + uintptr(i)*8)) = *(*uintptr)(unsafe.Pointer(av + uintptr(i-int32(1))*8)) + **(**uintptr)(__ccgo_up(av + uintptr(i)*8)) = **(**uintptr)(__ccgo_up(av + uintptr(i-int32(1))*8)) goto _1 _1: ; i = i - 1 } - *(*uintptr)(unsafe.Pointer(av + uintptr(dest)*8)) = tmp + **(**uintptr)(__ccgo_up(av + uintptr(dest)*8)) = tmp } func ___getopt_long(tls *TLS, argc int32, argv uintptr, optstring uintptr, longopts uintptr, idx uintptr, longonly int32) (r int32) { @@ -114183,17 +114183,17 @@ func ___getopt_long(tls *TLS, argc int32, argv uintptr, optstring uintptr, longo X__optpos = 0 Xoptind = int32(1) } - if Xoptind >= argc || !(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) != 0) { + if Xoptind >= argc || !(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) != 0) { return -int32(1) } skipped = Xoptind - if Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) != int32('+') && Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) != int32('-') { + if Int32FromUint8(**(**uint8)(__ccgo_up(optstring))) != int32('+') && Int32FromUint8(**(**uint8)(__ccgo_up(optstring))) != int32('-') { i = Xoptind for { - if i >= argc || !(*(*uintptr)(unsafe.Pointer(argv + uintptr(i)*8)) != 0) { + if i >= argc || !(**(**uintptr)(__ccgo_up(argv + uintptr(i)*8)) != 0) { return -int32(1) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(i)*8))))) == int32('-') && *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(i)*8)) + 1)) != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(i)*8))))) == int32('-') && **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(i)*8)) + 1)) != 0 { break } goto _1 @@ -114228,31 +114228,31 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, var cnt, colon, i, j, l, match, v2 int32 _, _, _, _, _, _, _, _, _, _, _, _ = arg, cnt, colon, i, j, l, match, name, opt, start, v2, v5 Xoptarg = uintptr(0) - if longopts != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))))) == int32('-') && (longonly != 0 && *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1))) != int32('-') || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1))) == int32('-') && *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 2)) != 0) { - colon = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring + BoolUintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) == int32('+') || Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) == int32('-'))))) == int32(':')) - start = *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + uintptr(1) + if longopts != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8))))) == int32('-') && (longonly != 0 && **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + 1)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + 1))) != int32('-') || Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + 1))) == int32('-') && **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + 2)) != 0) { + colon = BoolInt32(Int32FromUint8(**(**uint8)(__ccgo_up(optstring + BoolUintptr(Int32FromUint8(**(**uint8)(__ccgo_up(optstring))) == int32('+') || Int32FromUint8(**(**uint8)(__ccgo_up(optstring))) == int32('-'))))) == int32(':')) + start = **(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + uintptr(1) v2 = Int32FromInt32(0) i = v2 cnt = v2 for { - if !((*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname != 0) { + if !((**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fname != 0) { break } - name = (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname + name = (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fname opt = start - if Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) == int32('-') { + if Int32FromUint8(**(**uint8)(__ccgo_up(opt))) == int32('-') { opt = opt + 1 } - for *(*uint8)(unsafe.Pointer(opt)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) != int32('=') && Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) { + for **(**uint8)(__ccgo_up(opt)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(opt))) != int32('=') && Int32FromUint8(**(**uint8)(__ccgo_up(opt))) == Int32FromUint8(**(**uint8)(__ccgo_up(name))) { name = name + 1 opt = opt + 1 } - if *(*uint8)(unsafe.Pointer(opt)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) != int32('=') { + if **(**uint8)(__ccgo_up(opt)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(opt))) != int32('=') { goto _1 } arg = opt match = i - if !(*(*uint8)(unsafe.Pointer(name)) != 0) { + if !(**(**uint8)(__ccgo_up(name)) != 0) { cnt = int32(1) break } @@ -114266,12 +114266,12 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, l = int32(int64(arg) - int64(start)) i = 0 for { - if !(*(*uint8)(unsafe.Pointer(optstring + uintptr(i))) != 0) { + if !(**(**uint8)(__ccgo_up(optstring + uintptr(i))) != 0) { break } j = 0 for { - if !(j < l && Int32FromUint8(*(*uint8)(unsafe.Pointer(start + uintptr(j)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring + uintptr(i+j))))) { + if !(j < l && Int32FromUint8(**(**uint8)(__ccgo_up(start + uintptr(j)))) == Int32FromUint8(**(**uint8)(__ccgo_up(optstring + uintptr(i+j))))) { break } goto _4 @@ -114293,44 +114293,44 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, i = match opt = arg Xoptind = Xoptind + 1 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) == int32('=') { - if !((*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fhas_arg != 0) { - Xoptopt = (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fval + if Int32FromUint8(**(**uint8)(__ccgo_up(opt))) == int32('=') { + if !((**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fhas_arg != 0) { + Xoptopt = (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fval if colon != 0 || !(Xopterr != 0) { return int32('?') } - X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), __ccgo_ts+782, (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname, _strlen(tls, (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname)) + X__getopt_msg(tls, **(**uintptr)(__ccgo_up(argv)), __ccgo_ts+782, (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fname, _strlen(tls, (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fname)) return int32('?') } Xoptarg = opt + uintptr(1) } else { - if (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fhas_arg == int32(required_argument) { - v5 = *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + if (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fhas_arg == int32(required_argument) { + v5 = **(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) Xoptarg = v5 if !(v5 != 0) { - Xoptopt = (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fval + Xoptopt = (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fval if colon != 0 { return int32(':') } if !(Xopterr != 0) { return int32('?') } - X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), __ccgo_ts+750, (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname, _strlen(tls, (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname)) + X__getopt_msg(tls, **(**uintptr)(__ccgo_up(argv)), __ccgo_ts+750, (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fname, _strlen(tls, (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fname)) return int32('?') } Xoptind = Xoptind + 1 } } if idx != 0 { - *(*int32)(unsafe.Pointer(idx)) = i + **(**int32)(__ccgo_up(idx)) = i } - if (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fflag != 0 { - *(*int32)(unsafe.Pointer((*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fflag)) = (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fval + if (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fflag != 0 { + **(**int32)(__ccgo_up((**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fflag)) = (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fval return 0 } - return (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fval + return (**(**Toption)(__ccgo_up(longopts + uintptr(i)*32))).Fval } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1))) == int32('-') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8)) + 1))) == int32('-') { Xoptopt = 0 if !(colon != 0) && Xopterr != 0 { if cnt != 0 { @@ -114338,7 +114338,7 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, } else { v5 = __ccgo_ts + 726 } - X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), v5, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))+uintptr(2), _strlen(tls, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))+uintptr(2))) + X__getopt_msg(tls, **(**uintptr)(__ccgo_up(argv)), v5, **(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8))+uintptr(2), _strlen(tls, **(**uintptr)(__ccgo_up(argv + uintptr(Xoptind)*8))+uintptr(2))) } Xoptind = Xoptind + 1 return int32('?') @@ -114413,22 +114413,22 @@ func Xgetrlimit(tls *TLS, resource int32, rlim uintptr) (r int32) { (*Trlimit)(unsafe.Pointer(rlim)).Frlim_max = ^Uint64FromUint64(0) } } - if !(ret != 0) || *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(ENOSYS) { + if !(ret != 0) || **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(ENOSYS) { return ret } if X__syscall_ret(tls, Uint64FromInt64(X__syscall2(tls, int64(SYS_getrlimit), int64(resource), int64(bp)))) < 0 { return -int32(1) } - if (*(*[2]uint64)(unsafe.Pointer(bp)))[0] == -Uint64FromUint64(1) { + if (**(**[2]uint64)(__ccgo_up(bp)))[0] == -Uint64FromUint64(1) { v1 = ^Uint64FromUint64(0) } else { - v1 = (*(*[2]uint64)(unsafe.Pointer(bp)))[0] + v1 = (**(**[2]uint64)(__ccgo_up(bp)))[0] } (*Trlimit)(unsafe.Pointer(rlim)).Frlim_cur = v1 - if (*(*[2]uint64)(unsafe.Pointer(bp)))[int32(1)] == -Uint64FromUint64(1) { + if (**(**[2]uint64)(__ccgo_up(bp)))[int32(1)] == -Uint64FromUint64(1) { v1 = ^Uint64FromUint64(0) } else { - v1 = (*(*[2]uint64)(unsafe.Pointer(bp)))[int32(1)] + v1 = (**(**[2]uint64)(__ccgo_up(bp)))[int32(1)] } (*Trlimit)(unsafe.Pointer(rlim)).Frlim_max = v1 if (*Trlimit)(unsafe.Pointer(rlim)).Frlim_cur >= ^Uint64FromUint64(0) { @@ -114456,12 +114456,12 @@ func Xgetrusage(tls *TLS, who int32, ru uintptr) (r1 int32) { if !(r != 0) && Bool(uint64(8) > uint64(8)) { Xmemcpy(tls, bp, dest, Uint64FromInt32(4)*Uint64FromInt64(8)) (*Trusage)(unsafe.Pointer(ru)).Fru_utime = Ttimeval{ - Ftv_sec: (*(*[4]int64)(unsafe.Pointer(bp)))[0], - Ftv_usec: (*(*[4]int64)(unsafe.Pointer(bp)))[int32(1)], + Ftv_sec: (**(**[4]int64)(__ccgo_up(bp)))[0], + Ftv_usec: (**(**[4]int64)(__ccgo_up(bp)))[int32(1)], } (*Trusage)(unsafe.Pointer(ru)).Fru_stime = Ttimeval{ - Ftv_sec: (*(*[4]int64)(unsafe.Pointer(bp)))[int32(2)], - Ftv_usec: (*(*[4]int64)(unsafe.Pointer(bp)))[int32(3)], + Ftv_sec: (**(**[4]int64)(__ccgo_up(bp)))[int32(2)], + Ftv_usec: (**(**[4]int64)(__ccgo_up(bp)))[int32(3)], } } return int32(X__syscall_ret(tls, Uint64FromInt32(r))) @@ -114476,30 +114476,30 @@ func Xgetsubopt(tls *TLS, opt uintptr, keys uintptr, val uintptr) (r int32) { var l Tsize_t var s, v1, v2 uintptr _, _, _, _, _ = i, l, s, v1, v2 - s = *(*uintptr)(unsafe.Pointer(opt)) - *(*uintptr)(unsafe.Pointer(val)) = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(opt)) = Xstrchr(tls, s, int32(',')) - if *(*uintptr)(unsafe.Pointer(opt)) != 0 { + s = **(**uintptr)(__ccgo_up(opt)) + **(**uintptr)(__ccgo_up(val)) = UintptrFromInt32(0) + **(**uintptr)(__ccgo_up(opt)) = Xstrchr(tls, s, int32(',')) + if **(**uintptr)(__ccgo_up(opt)) != 0 { v2 = opt v1 = *(*uintptr)(unsafe.Pointer(v2)) *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(v2)) + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) } else { - *(*uintptr)(unsafe.Pointer(opt)) = s + uintptr(_strlen(tls, s)) + **(**uintptr)(__ccgo_up(opt)) = s + uintptr(_strlen(tls, s)) } i = 0 for { - if !(*(*uintptr)(unsafe.Pointer(keys + uintptr(i)*8)) != 0) { + if !(**(**uintptr)(__ccgo_up(keys + uintptr(i)*8)) != 0) { break } - l = _strlen(tls, *(*uintptr)(unsafe.Pointer(keys + uintptr(i)*8))) - if Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(keys + uintptr(i)*8)), s, l) != 0 { + l = _strlen(tls, **(**uintptr)(__ccgo_up(keys + uintptr(i)*8))) + if Xstrncmp(tls, **(**uintptr)(__ccgo_up(keys + uintptr(i)*8)), s, l) != 0 { goto _3 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(l)))) == int32('=') { - *(*uintptr)(unsafe.Pointer(val)) = s + uintptr(l) + uintptr(1) + if Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(l)))) == int32('=') { + **(**uintptr)(__ccgo_up(val)) = s + uintptr(l) + uintptr(1) } else { - if *(*uint8)(unsafe.Pointer(s + uintptr(l))) != 0 { + if **(**uint8)(__ccgo_up(s + uintptr(l))) != 0 { goto _3 } } @@ -114788,7 +114788,7 @@ func _convert_ioctl_struct(tls *TLS, map1 uintptr, old uintptr, new1 uintptr, di if !(i < Int32FromUint8((*Tioctl_compat_map)(unsafe.Pointer(map1)).Fnoffs)) { break } - ts_offset = Int32FromUint8(*(*uint8)(unsafe.Pointer(map1 + 12 + uintptr(i)))) + ts_offset = Int32FromUint8(**(**uint8)(__ccgo_up(map1 + 12 + uintptr(i)))) len1 = ts_offset - old_offset if dir == int32(W) { Xmemcpy(tls, old+uintptr(old_offset), new1+uintptr(new_offset), Uint64FromInt32(len1)) @@ -114806,11 +114806,11 @@ func _convert_ioctl_struct(tls *TLS, map1 uintptr, old uintptr, new1 uintptr, di new_offset = new_offset + (align-int32(1))&-new_offset if dir == int32(W) { Xmemcpy(tls, bp, new1+uintptr(new_offset), uint64(8)) - *(*int64)(unsafe.Pointer(bp + 8)) = *(*int64)(unsafe.Pointer(bp)) + **(**int64)(__ccgo_up(bp + 8)) = int64(**(**int64)(__ccgo_up(bp))) Xmemcpy(tls, old+uintptr(old_offset), bp+8, uint64(8)) } else { Xmemcpy(tls, bp+8, old+uintptr(old_offset), uint64(8)) - *(*int64)(unsafe.Pointer(bp)) = *(*int64)(unsafe.Pointer(bp + 8)) + **(**int64)(__ccgo_up(bp)) = int64(**(**int64)(__ccgo_up(bp + 8))) Xmemcpy(tls, new1+uintptr(new_offset), bp, uint64(8)) } new_offset = Int32FromUint64(uint64(new_offset) + Uint64FromInt64(8)) @@ -114888,31 +114888,31 @@ func Xlockf(tls *TLS, fd int32, op int32, size Toff_t) (r int32) { bp := tls.Alloc(48) defer tls.Free(48) var _ /* l at bp+0 */ Tflock - *(*Tflock)(unsafe.Pointer(bp)) = Tflock{ + **(**Tflock)(__ccgo_up(bp)) = Tflock{ Fl_type: int16(F_WRLCK), Fl_whence: int16(1), Fl_len: size, } switch op { case int32(F_TEST): - (*(*Tflock)(unsafe.Pointer(bp))).Fl_type = F_RDLCK + (**(**Tflock)(__ccgo_up(bp))).Fl_type = F_RDLCK if Xfcntl(tls, fd, int32(F_GETLK), VaList(bp+40, bp)) < 0 { return -int32(1) } - if int32((*(*Tflock)(unsafe.Pointer(bp))).Fl_type) == int32(F_UNLCK) || (*(*Tflock)(unsafe.Pointer(bp))).Fl_pid == Xgetpid(tls) { + if int32((**(**Tflock)(__ccgo_up(bp))).Fl_type) == int32(F_UNLCK) || (**(**Tflock)(__ccgo_up(bp))).Fl_pid == Xgetpid(tls) { return 0 } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EACCES) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EACCES) return -int32(1) case F_ULOCK: - (*(*Tflock)(unsafe.Pointer(bp))).Fl_type = int16(F_UNLCK) + (**(**Tflock)(__ccgo_up(bp))).Fl_type = int16(F_UNLCK) fallthrough case int32(F_TLOCK): return Xfcntl(tls, fd, int32(F_SETLK), VaList(bp+40, bp)) case int32(F_LOCK): return Xfcntl(tls, fd, int32(F_SETLKW), VaList(bp+40, bp)) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } @@ -115014,23 +115014,23 @@ func _unescape_ent(tls *TLS, beg uintptr) (r uintptr) { _, _, _, _, _, _, _ = cval, dest, i, src, val, v1, v2 dest = beg src = beg - for *(*uint8)(unsafe.Pointer(src)) != 0 { + for **(**uint8)(__ccgo_up(src)) != 0 { cval = uint8(0) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) != int32('\\') { + if Int32FromUint8(**(**uint8)(__ccgo_up(src))) != int32('\\') { v1 = dest dest = dest + 1 v2 = src src = src + 1 - *(*uint8)(unsafe.Pointer(v1)) = *(*uint8)(unsafe.Pointer(v2)) + **(**uint8)(__ccgo_up(v1)) = **(**uint8)(__ccgo_up(v2)) continue } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 1))) == int32('\\') { + if Int32FromUint8(**(**uint8)(__ccgo_up(src + 1))) == int32('\\') { src = src + 1 v1 = dest dest = dest + 1 v2 = src src = src + 1 - *(*uint8)(unsafe.Pointer(v1)) = *(*uint8)(unsafe.Pointer(v2)) + **(**uint8)(__ccgo_up(v1)) = **(**uint8)(__ccgo_up(v2)) continue } val = src + uintptr(1) @@ -115039,11 +115039,11 @@ func _unescape_ent(tls *TLS, beg uintptr) (r uintptr) { if !(i < int32(3)) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(val))) >= int32('0') && Int32FromUint8(*(*uint8)(unsafe.Pointer(val))) <= int32('7') { + if Int32FromUint8(**(**uint8)(__ccgo_up(val))) >= int32('0') && Int32FromUint8(**(**uint8)(__ccgo_up(val))) <= int32('7') { cval = Uint8FromInt32(int32(cval) << Int32FromInt32(3)) v1 = val val = val + 1 - cval = Uint8FromInt32(int32(cval) + (Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) - Int32FromUint8('0'))) + cval = Uint8FromInt32(int32(cval) + (Int32FromUint8(**(**uint8)(__ccgo_up(v1))) - Int32FromUint8('0'))) } else { break } @@ -115055,17 +115055,17 @@ func _unescape_ent(tls *TLS, beg uintptr) (r uintptr) { if cval != 0 { v1 = dest dest = dest + 1 - *(*uint8)(unsafe.Pointer(v1)) = cval + **(**uint8)(__ccgo_up(v1)) = cval src = val } else { v1 = dest dest = dest + 1 v2 = src src = src + 1 - *(*uint8)(unsafe.Pointer(v1)) = *(*uint8)(unsafe.Pointer(v2)) + **(**uint8)(__ccgo_up(v1)) = **(**uint8)(__ccgo_up(v2)) } } - *(*uint8)(unsafe.Pointer(dest)) = uint8(0) + **(**uint8)(__ccgo_up(dest)) = uint8(0) return beg } @@ -115083,7 +115083,7 @@ func Xgetmntent_r(tls *TLS, f uintptr, mnt uintptr, linebuf uintptr, buflen int3 use_internal = BoolInt32(linebuf == uintptr(unsafe.Pointer(&_internal_buf))) (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_freq = 0 (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_passno = 0 - for cond := true; cond; cond = Int32FromUint8(*(*uint8)(unsafe.Pointer(linebuf + uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[0])))) == int32('#') || Uint64FromInt32((*(*[8]int32)(unsafe.Pointer(bp)))[int32(1)]) == len1 { + for cond := true; cond; cond = Int32FromUint8(**(**uint8)(__ccgo_up(linebuf + uintptr((**(**[8]int32)(__ccgo_up(bp)))[0])))) == int32('#') || Uint64FromInt32((**(**[8]int32)(__ccgo_up(bp)))[int32(1)]) == len1 { if use_internal != 0 { Xgetline(tls, uintptr(unsafe.Pointer(&_internal_buf)), uintptr(unsafe.Pointer(&_internal_bufsize)), f) linebuf = _internal_buf @@ -115095,7 +115095,7 @@ func Xgetmntent_r(tls *TLS, f uintptr, mnt uintptr, linebuf uintptr, buflen int3 } if !(Xstrchr(tls, linebuf, int32('\n')) != 0) { Xfscanf(tls, f, __ccgo_ts+843, 0) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ERANGE) return uintptr(0) } len1 = _strlen(tls, linebuf) @@ -115107,7 +115107,7 @@ func Xgetmntent_r(tls *TLS, f uintptr, mnt uintptr, linebuf uintptr, buflen int3 if !(i < Uint64FromInt64(32)/Uint64FromInt64(4)) { break } - (*(*[8]int32)(unsafe.Pointer(bp)))[i] = Int32FromUint64(len1) + (**(**[8]int32)(__ccgo_up(bp)))[i] = Int32FromUint64(len1) goto _1 _1: ; @@ -115115,14 +115115,14 @@ func Xgetmntent_r(tls *TLS, f uintptr, mnt uintptr, linebuf uintptr, buflen int3 } Xsscanf(tls, linebuf, __ccgo_ts+855, VaList(bp+40, bp, bp+uintptr(1)*4, bp+uintptr(2)*4, bp+uintptr(3)*4, bp+uintptr(4)*4, bp+uintptr(5)*4, bp+uintptr(6)*4, bp+uintptr(7)*4, mnt+32, mnt+36)) } - *(*uint8)(unsafe.Pointer(linebuf + uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(1)]))) = uint8(0) - *(*uint8)(unsafe.Pointer(linebuf + uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(3)]))) = uint8(0) - *(*uint8)(unsafe.Pointer(linebuf + uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(5)]))) = uint8(0) - *(*uint8)(unsafe.Pointer(linebuf + uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(7)]))) = uint8(0) - (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_fsname = _unescape_ent(tls, linebuf+uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[0])) - (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_dir = _unescape_ent(tls, linebuf+uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(2)])) - (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_type = _unescape_ent(tls, linebuf+uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(4)])) - (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_opts = _unescape_ent(tls, linebuf+uintptr((*(*[8]int32)(unsafe.Pointer(bp)))[int32(6)])) + **(**uint8)(__ccgo_up(linebuf + uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(1)]))) = uint8(0) + **(**uint8)(__ccgo_up(linebuf + uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(3)]))) = uint8(0) + **(**uint8)(__ccgo_up(linebuf + uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(5)]))) = uint8(0) + **(**uint8)(__ccgo_up(linebuf + uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(7)]))) = uint8(0) + (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_fsname = _unescape_ent(tls, linebuf+uintptr((**(**[8]int32)(__ccgo_up(bp)))[0])) + (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_dir = _unescape_ent(tls, linebuf+uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(2)])) + (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_type = _unescape_ent(tls, linebuf+uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(4)])) + (*Tmntent)(unsafe.Pointer(mnt)).Fmnt_opts = _unescape_ent(tls, linebuf+uintptr((**(**[8]int32)(__ccgo_up(bp)))[int32(6)])) return mnt } @@ -115179,39 +115179,39 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag var _ /* st at bp+0 */ Tstat _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, de, dfd, err, j, k, l, r, type1, v1, v10, v2, v3, v8 l = _strlen(tls, path) - if l != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(path + uintptr(l-uint64(1))))) == int32('/') { + if l != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(path + uintptr(l-uint64(1))))) == int32('/') { v1 = l - uint64(1) } else { v1 = l } j = v1 v2 = Uint64FromInt32(0) - (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino = v2 - (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev = v2 + (**(**Tstat)(__ccgo_up(bp))).Fst_ino = v2 + (**(**Tstat)(__ccgo_up(bp))).Fst_dev = v2 if flags&int32(FTW_PHYS) != 0 { v3 = Xlstat(tls, path, bp) } else { v3 = BoolInt32(Xstat(tls, path, bp) < 0) } if v3 != 0 { - if !(flags&Int32FromInt32(FTW_PHYS) != 0) && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENOENT) && !(Xlstat(tls, path, bp) != 0) { + if !(flags&Int32FromInt32(FTW_PHYS) != 0) && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENOENT) && !(Xlstat(tls, path, bp) != 0) { type1 = int32(FTW_SLN) } else { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(EACCES) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(EACCES) { return -int32(1) } else { type1 = int32(FTW_NS) } } } else { - if (*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFDIR) { + if (**(**Tstat)(__ccgo_up(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFDIR) { if flags&int32(FTW_DEPTH) != 0 { type1 = int32(FTW_DP) } else { type1 = int32(FTW_D) } } else { - if (*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { + if (**(**Tstat)(__ccgo_up(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { if flags&int32(FTW_PHYS) != 0 { type1 = int32(FTW_SL) } else { @@ -115222,26 +115222,26 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag } } } - if flags&int32(FTW_MOUNT) != 0 && h != 0 && type1 != int32(FTW_NS) && (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev != (*Thistory)(unsafe.Pointer(h)).Fdev { + if flags&int32(FTW_MOUNT) != 0 && h != 0 && type1 != int32(FTW_NS) && (**(**Tstat)(__ccgo_up(bp))).Fst_dev != (*Thistory)(unsafe.Pointer(h)).Fdev { return 0 } - (*(*Thistory)(unsafe.Pointer(bp + 144))).Fchain = h - (*(*Thistory)(unsafe.Pointer(bp + 144))).Fdev = (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev - (*(*Thistory)(unsafe.Pointer(bp + 144))).Fino = (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino + (**(**Thistory)(__ccgo_up(bp + 144))).Fchain = h + (**(**Thistory)(__ccgo_up(bp + 144))).Fdev = (**(**Tstat)(__ccgo_up(bp))).Fst_dev + (**(**Thistory)(__ccgo_up(bp + 144))).Fino = (**(**Tstat)(__ccgo_up(bp))).Fst_ino if h != 0 { v3 = (*Thistory)(unsafe.Pointer(h)).Flevel + int32(1) } else { v3 = 0 } - (*(*Thistory)(unsafe.Pointer(bp + 144))).Flevel = v3 - (*(*Thistory)(unsafe.Pointer(bp + 144))).Fbase = Int32FromUint64(j + uint64(1)) - (*(*TFTW)(unsafe.Pointer(bp + 176))).Flevel = (*(*Thistory)(unsafe.Pointer(bp + 144))).Flevel + (**(**Thistory)(__ccgo_up(bp + 144))).Flevel = v3 + (**(**Thistory)(__ccgo_up(bp + 144))).Fbase = Int32FromUint64(j + uint64(1)) + (**(**TFTW)(__ccgo_up(bp + 176))).Flevel = (**(**Thistory)(__ccgo_up(bp + 144))).Flevel if h != 0 { - (*(*TFTW)(unsafe.Pointer(bp + 176))).Fbase = (*Thistory)(unsafe.Pointer(h)).Fbase + (**(**TFTW)(__ccgo_up(bp + 176))).Fbase = (*Thistory)(unsafe.Pointer(h)).Fbase } else { k = j for { - if !(k != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(path + uintptr(k)))) == int32('/')) { + if !(k != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(path + uintptr(k)))) == int32('/')) { break } goto _5 @@ -115250,7 +115250,7 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag k = k - 1 } for { - if !(k != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(path + uintptr(k-uint64(1))))) != int32('/')) { + if !(k != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(path + uintptr(k-uint64(1))))) != int32('/')) { break } goto _6 @@ -115258,11 +115258,11 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag ; k = k - 1 } - (*(*TFTW)(unsafe.Pointer(bp + 176))).Fbase = Int32FromUint64(k) + (**(**TFTW)(__ccgo_up(bp + 176))).Fbase = Int32FromUint64(k) } if type1 == int32(FTW_D) || type1 == int32(FTW_DP) { dfd = Xopen(tls, path, O_RDONLY, 0) - err = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + err = **(**int32)(__ccgo_up(X__errno_location(tls))) if dfd < 0 && err == int32(EACCES) { type1 = int32(FTW_DNR) } @@ -115281,7 +115281,7 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag if !(h != 0) { break } - if (*Thistory)(unsafe.Pointer(h)).Fdev == (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev && (*Thistory)(unsafe.Pointer(h)).Fino == (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino { + if (*Thistory)(unsafe.Pointer(h)).Fdev == (**(**Tstat)(__ccgo_up(bp))).Fst_dev && (*Thistory)(unsafe.Pointer(h)).Fino == (**(**Tstat)(__ccgo_up(bp))).Fst_ino { return 0 } goto _9 @@ -115291,7 +115291,7 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag } if (type1 == int32(FTW_D) || type1 == int32(FTW_DP)) && fd_limit != 0 { if dfd < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = err + **(**int32)(__ccgo_up(X__errno_location(tls))) = err return -int32(1) } d = Xfdopendir(tls, dfd) @@ -115302,15 +115302,15 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag if !(v10 != 0) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(de + 19))) == int32('.') && (!(*(*uint8)(unsafe.Pointer(de + 19 + 1)) != 0) || Int32FromUint8(*(*uint8)(unsafe.Pointer(de + 19 + 1))) == int32('.') && !(*(*uint8)(unsafe.Pointer(de + 19 + 2)) != 0)) { + if Int32FromUint8(**(**uint8)(__ccgo_up(de + 19))) == int32('.') && (!(**(**uint8)(__ccgo_up(de + 19 + 1)) != 0) || Int32FromUint8(**(**uint8)(__ccgo_up(de + 19 + 1))) == int32('.') && !(**(**uint8)(__ccgo_up(de + 19 + 2)) != 0)) { continue } if _strlen(tls, de+19) >= uint64(PATH_MAX)-l { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENAMETOOLONG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENAMETOOLONG) Xclosedir(tls, d) return -int32(1) } - *(*uint8)(unsafe.Pointer(path + uintptr(j))) = uint8('/') + **(**uint8)(__ccgo_up(path + uintptr(j))) = uint8('/') Xstrcpy(tls, path+uintptr(j)+uintptr(1), de+19) v3 = _do_nftw(tls, path, __ccgo_fp_fn, fd_limit-int32(1), flags, bp+144) r = v3 @@ -115325,7 +115325,7 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag return -int32(1) } } - *(*uint8)(unsafe.Pointer(path + uintptr(l))) = uint8(0) + **(**uint8)(__ccgo_up(path + uintptr(l))) = uint8(0) if v8 = flags&int32(FTW_DEPTH) != 0; v8 { v3 = (*(*func(*TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_fn})))(tls, path, bp, type1, bp+176) r = v3 @@ -115355,13 +115355,13 @@ func Xnftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flags i } l = _strlen(tls, path) if l > uint64(PATH_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENAMETOOLONG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENAMETOOLONG) return -int32(1) } Xmemcpy(tls, bp+4, path, l+uint64(1)) _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp) r = _do_nftw(tls, bp+4, __ccgo_fp_fn, fd_limit, flags, UintptrFromInt32(0)) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) return r } @@ -115379,7 +115379,7 @@ func Xopenpty(tls *TLS, pm uintptr, ps uintptr, name uintptr, tio uintptr, ws ui var _ /* cs at bp+4 */ int32 var _ /* n at bp+0 */ int32 _, _, _ = m, s, v1 - *(*int32)(unsafe.Pointer(bp)) = 0 + **(**int32)(__ccgo_up(bp)) = 0 m = Xopen(tls, __ccgo_ts+929, Int32FromInt32(O_RDWR)|Int32FromInt32(O_NOCTTY), 0) if m < 0 { return -int32(1) @@ -115391,7 +115391,7 @@ func Xopenpty(tls *TLS, pm uintptr, ps uintptr, name uintptr, tio uintptr, ws ui if !(name != 0) { name = bp + 8 } - Xsnprintf(tls, name, uint64(20), __ccgo_ts+939, VaList(bp+40, *(*int32)(unsafe.Pointer(bp)))) + Xsnprintf(tls, name, uint64(20), __ccgo_ts+939, VaList(bp+40, **(**int32)(__ccgo_up(bp)))) v1 = Xopen(tls, name, Int32FromInt32(O_RDWR)|Int32FromInt32(O_NOCTTY), 0) s = v1 if v1 < 0 { @@ -115403,15 +115403,15 @@ func Xopenpty(tls *TLS, pm uintptr, ps uintptr, name uintptr, tio uintptr, ws ui if ws != 0 { Xioctl(tls, s, int32(TIOCSWINSZ), VaList(bp+40, ws)) } - *(*int32)(unsafe.Pointer(pm)) = m - *(*int32)(unsafe.Pointer(ps)) = s - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 4)), uintptr(0)) + **(**int32)(__ccgo_up(pm)) = m + **(**int32)(__ccgo_up(ps)) = s + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 4)), uintptr(0)) return 0 goto fail fail: ; Xclose(tls, m) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 4)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 4)), uintptr(0)) return -int32(1) } @@ -115424,7 +115424,7 @@ func Xptsname(tls *TLS, fd int32) (r uintptr) { _ = err err = X__ptsname_r(tls, fd, uintptr(unsafe.Pointer(&_buf2)), uint64(22)) if err != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = err + **(**int32)(__ccgo_up(X__errno_location(tls))) = err return uintptr(0) } return uintptr(unsafe.Pointer(&_buf2)) @@ -115440,8 +115440,8 @@ func Xposix_openpt(tls *TLS, flags int32) (r1 int32) { var r int32 _ = r r = Xopen(tls, __ccgo_ts+929, flags, 0) - if r < 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENOSPC) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EAGAIN) + if r < 0 && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENOSPC) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EAGAIN) } return r } @@ -115462,7 +115462,7 @@ func Xunlockpt(tls *TLS, fd int32) (r int32) { bp := tls.Alloc(32) defer tls.Free(32) var _ /* unlock at bp+0 */ int32 - *(*int32)(unsafe.Pointer(bp)) = 0 + **(**int32)(__ccgo_up(bp)) = 0 return Xioctl(tls, fd, int32(TIOCSPTLCK), VaList(bp+16, bp)) } @@ -115484,7 +115484,7 @@ func X__ptsname_r(tls *TLS, fd int32, buf uintptr, len1 Tsize_t) (r int32) { if v1 != 0 { return -err } - if Uint64FromInt32(Xsnprintf(tls, buf, len1, __ccgo_ts+939, VaList(bp+16, *(*int32)(unsafe.Pointer(bp))))) >= len1 { + if Uint64FromInt32(Xsnprintf(tls, buf, len1, __ccgo_ts+939, VaList(bp+16, **(**int32)(__ccgo_up(bp))))) >= len1 { return int32(ERANGE) } return 0 @@ -115502,7 +115502,7 @@ func _slash_len(tls *TLS, s uintptr) (r Tsize_t) { var s0 uintptr _ = s0 s0 = s - for Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('/') { + for Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('/') { s = s + 1 } return Uint64FromInt64(int64(s) - int64(s0)) @@ -115526,12 +115526,12 @@ func Xrealpath(tls *TLS, filename uintptr, resolved uintptr) (r uintptr) { nup = uint64(0) check_dir = 0 if !(filename != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } l = Xstrnlen(tls, filename, uint64(4097)) if !(l != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOENT) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOENT) return uintptr(0) } if l >= uint64(PATH_MAX) { @@ -115551,19 +115551,19 @@ _3: ; /* If stack starts with /, the whole component is / or // * and the output state must be reset. */ - if Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p]) == int32('/') { + if Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[p]) == int32('/') { check_dir = 0 nup = uint64(0) q = uint64(0) v4 = q q = q + 1 - (*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[v4] = uint8('/') + (**(**[4096]uint8)(__ccgo_up(bp + 4097)))[v4] = uint8('/') p = p + 1 /* Initial // is special. */ - if Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p]) == int32('/') && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p+uint64(1)]) != int32('/') { + if Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[p]) == int32('/') && Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[p+uint64(1)]) != int32('/') { v4 = q q = q + 1 - (*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[v4] = uint8('/') + (**(**[4096]uint8)(__ccgo_up(bp + 4097)))[v4] = uint8('/') } goto _2 } @@ -115575,30 +115575,30 @@ _3: goto _1 } /* Skip any . component but preserve check_dir status. */ - if l == uint64(1) && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p]) == int32('.') { + if l == uint64(1) && Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[p]) == int32('.') { p = p + l goto _2 } /* Copy next component onto output at least temporarily, to * call readlink, but wait to advance output position until * determining it's not a link. */ - if q != 0 && Int32FromUint8((*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[q-uint64(1)]) != int32('/') { + if q != 0 && Int32FromUint8((**(**[4096]uint8)(__ccgo_up(bp + 4097)))[q-uint64(1)]) != int32('/') { if !(p != 0) { goto toolong } p = p - 1 v4 = p - (*(*[4097]uint8)(unsafe.Pointer(bp)))[v4] = uint8('/') + (**(**[4097]uint8)(__ccgo_up(bp)))[v4] = uint8('/') l = l + 1 } if q+l >= uint64(PATH_MAX) { goto toolong } Xmemcpy(tls, bp+4097+uintptr(q), bp+uintptr(p), l) - (*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[q+l] = uint8(0) + (**(**[4096]uint8)(__ccgo_up(bp + 4097)))[q+l] = uint8(0) p = p + l up = 0 - if l0 == uint64(2) && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p-uint64(2)]) == int32('.') && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p-uint64(1)]) == int32('.') { + if l0 == uint64(2) && Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[p-uint64(2)]) == int32('.') && Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[p-uint64(1)]) == int32('.') { up = int32(1) /* Any non-.. path components we could cancel start * after nup repetitions of the 3-byte string "../"; @@ -115620,13 +115620,13 @@ _3: goto toolong } if !(k != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOENT) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOENT) return uintptr(0) } if !(k < 0) { goto _8 } - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(EINVAL) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(EINVAL) { return uintptr(0) } goto skip_readlink @@ -115634,10 +115634,10 @@ skip_readlink: ; check_dir = 0 if up != 0 { - for q != 0 && Int32FromUint8((*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[q-uint64(1)]) != int32('/') { + for q != 0 && Int32FromUint8((**(**[4096]uint8)(__ccgo_up(bp + 4097)))[q-uint64(1)]) != int32('/') { q = q - 1 } - if q > uint64(1) && (q > uint64(2) || Int32FromUint8((*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[0]) != int32('/')) { + if q > uint64(1) && (q > uint64(2) || Int32FromUint8((**(**[4096]uint8)(__ccgo_up(bp + 4097)))[0]) != int32('/')) { q = q - 1 } goto _2 @@ -115645,20 +115645,20 @@ skip_readlink: if l0 != 0 { q = q + l } - check_dir = Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p]) + check_dir = Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[p]) goto _2 _8: ; cnt = cnt + 1 v4 = cnt if v4 == uint64(SYMLOOP_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ELOOP) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ELOOP) return uintptr(0) } /* If link contents end in /, strip any slashes already on * stack to avoid /->// or //->/// or spurious toolong. */ - if Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[k-int64(1)]) == int32('/') { - for Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p]) == int32('/') { + if Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[k-int64(1)]) == int32('/') { + for Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[p]) == int32('/') { p = p + 1 } } @@ -115675,8 +115675,8 @@ _2: goto _1 _1: ; - (*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[q] = uint8(0) - if Int32FromUint8((*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[0]) != int32('/') { + (**(**[4096]uint8)(__ccgo_up(bp + 4097)))[q] = uint8(0) + if Int32FromUint8((**(**[4096]uint8)(__ccgo_up(bp + 4097)))[0]) != int32('/') { if !(Xgetcwd(tls, bp, uint64(4097)) != 0) { return uintptr(0) } @@ -115689,7 +115689,7 @@ _1: if !(v4 != 0) { break } - for l > uint64(1) && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[l-uint64(1)]) != int32('/') { + for l > uint64(1) && Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[l-uint64(1)]) != int32('/') { l = l - 1 } if l > uint64(1) { @@ -115700,10 +115700,10 @@ _1: p = p + 1 } } - if q-p != 0 && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[l-uint64(1)]) != int32('/') { + if q-p != 0 && Int32FromUint8((**(**[4097]uint8)(__ccgo_up(bp)))[l-uint64(1)]) != int32('/') { v4 = l l = l + 1 - (*(*[4097]uint8)(unsafe.Pointer(bp)))[v4] = uint8('/') + (**(**[4097]uint8)(__ccgo_up(bp)))[v4] = uint8('/') } if l+(q-p)+uint64(1) >= uint64(PATH_MAX) { goto toolong @@ -115720,7 +115720,7 @@ _1: goto toolong toolong: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENAMETOOLONG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENAMETOOLONG) return uintptr(0) } @@ -115769,12 +115769,12 @@ func Xsetrlimit(tls *TLS, resource int32, rlim uintptr) (r int32) { var _ /* tmp at bp+0 */ Trlimit _, _, _ = ret, v1, v2 if ^Uint64FromUint64(0) != ^Uint64FromUint64(0) { - *(*Trlimit)(unsafe.Pointer(bp)) = *(*Trlimit)(unsafe.Pointer(rlim)) - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur >= ^Uint64FromUint64(0) { - (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_cur = ^Uint64FromUint64(0) + **(**Trlimit)(__ccgo_up(bp)) = **(**Trlimit)(__ccgo_up(rlim)) + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur >= ^Uint64FromUint64(0) { + (**(**Trlimit)(__ccgo_up(bp))).Frlim_cur = ^Uint64FromUint64(0) } - if (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_max >= ^Uint64FromUint64(0) { - (*(*Trlimit)(unsafe.Pointer(bp))).Frlim_max = ^Uint64FromUint64(0) + if (**(**Trlimit)(__ccgo_up(bp))).Frlim_max >= ^Uint64FromUint64(0) { + (**(**Trlimit)(__ccgo_up(bp))).Frlim_max = ^Uint64FromUint64(0) } rlim = bp } @@ -115792,7 +115792,7 @@ func Xsetrlimit(tls *TLS, resource int32, rlim uintptr) (r int32) { } else { v2 = ^Uint64FromUint64(0) } - *(*Tctx)(unsafe.Pointer(bp + 16)) = Tctx{ + **(**Tctx)(__ccgo_up(bp + 16)) = Tctx{ Flim: [2]uint64{ 0: v1, 1: v2, @@ -115801,9 +115801,9 @@ func Xsetrlimit(tls *TLS, resource int32, rlim uintptr) (r int32) { Ferr: -int32(1), } ___synccall(tls, __ccgo_fp(_do_setrlimit), bp+16) - if (*(*Tctx)(unsafe.Pointer(bp + 16))).Ferr != 0 { - if (*(*Tctx)(unsafe.Pointer(bp + 16))).Ferr > 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = (*(*Tctx)(unsafe.Pointer(bp + 16))).Ferr + if (**(**Tctx)(__ccgo_up(bp + 16))).Ferr != 0 { + if (**(**Tctx)(__ccgo_up(bp + 16))).Ferr > 0 { + **(**int32)(__ccgo_up(X__errno_location(tls))) = (**(**Tctx)(__ccgo_up(bp + 16))).Ferr } return -int32(1) } @@ -116183,7 +116183,7 @@ func Xcloselog(tls *TLS) { Xclose(tls, _log_fd) _log_fd = -int32(1) ___unlock(tls, uintptr(unsafe.Pointer(&_lock2))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) } func ___openlog(tls *TLS) { @@ -116217,7 +116217,7 @@ func Xopenlog(tls *TLS, ident uintptr, opt int32, facility int32) { ___openlog(tls) } ___unlock(tls, uintptr(unsafe.Pointer(&_lock2))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) } func _is_lost_conn(tls *TLS, e int32) (r int32) { @@ -116234,14 +116234,14 @@ func __vsyslog(tls *TLS, priority int32, message uintptr, ap Tva_list) { var _ /* timebuf at bp+0 */ [16]uint8 var _ /* tm at bp+24 */ Ttm _, _, _, _, _, _ = errno_save, fd, l, l2, pid, v1 - errno_save = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + errno_save = **(**int32)(__ccgo_up(X__errno_location(tls))) if _log_fd < 0 { ___openlog(tls) } if !(priority&Int32FromInt32(LOG_FACMASK) != 0) { priority = priority | _log_facility } - *(*Ttime_t)(unsafe.Pointer(bp + 16)) = Xtime(tls, UintptrFromInt32(0)) + **(**Ttime_t)(__ccgo_up(bp + 16)) = Xtime(tls, UintptrFromInt32(0)) Xgmtime_r(tls, bp+16, bp+24) Xstrftime_l(tls, bp, uint64(16), __ccgo_ts+951, bp+24, uintptr(unsafe.Pointer(&X__c_locale))) if _log_opt&int32(LOG_PID) != 0 { @@ -116251,7 +116251,7 @@ func __vsyslog(tls *TLS, priority int32, message uintptr, ap Tva_list) { } pid = v1 l = Xsnprintf(tls, bp+80, uint64(1024), __ccgo_ts+960, VaList(bp+1120, priority, bp, bp+1104, uintptr(unsafe.Pointer(&_log_ident)), __ccgo_ts+982+BoolUintptr(!(pid != 0)), pid, __ccgo_ts+984+BoolUintptr(!(pid != 0)))) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = errno_save + **(**int32)(__ccgo_up(X__errno_location(tls))) = errno_save l2 = Xvsnprintf(tls, bp+80+uintptr(l), uint64(1024)-Uint64FromInt32(l), message, ap) if l2 >= 0 { if Uint64FromInt32(l2) >= uint64(1024)-Uint64FromInt32(l) { @@ -116259,20 +116259,20 @@ func __vsyslog(tls *TLS, priority int32, message uintptr, ap Tva_list) { } else { l = l + l2 } - if Int32FromUint8((*(*[1024]uint8)(unsafe.Pointer(bp + 80)))[l-int32(1)]) != int32('\n') { + if Int32FromUint8((**(**[1024]uint8)(__ccgo_up(bp + 80)))[l-int32(1)]) != int32('\n') { v1 = l l = l + 1 - (*(*[1024]uint8)(unsafe.Pointer(bp + 80)))[v1] = uint8('\n') + (**(**[1024]uint8)(__ccgo_up(bp + 80)))[v1] = uint8('\n') } - if Xsend(tls, _log_fd, bp+80, Uint64FromInt32(l), 0) < 0 && (!(_is_lost_conn(tls, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) != 0) || Xconnect(tls, _log_fd, uintptr(unsafe.Pointer(&_log_addr)), uint32(12)) < 0 || Xsend(tls, _log_fd, bp+80, Uint64FromInt32(l), 0) < 0) && _log_opt&int32(LOG_CONS) != 0 { + if Xsend(tls, _log_fd, bp+80, Uint64FromInt32(l), 0) < 0 && (!(_is_lost_conn(tls, **(**int32)(__ccgo_up(X__errno_location(tls)))) != 0) || Xconnect(tls, _log_fd, uintptr(unsafe.Pointer(&_log_addr)), uint32(12)) < 0 || Xsend(tls, _log_fd, bp+80, Uint64FromInt32(l), 0) < 0) && _log_opt&int32(LOG_CONS) != 0 { fd = Xopen(tls, __ccgo_ts+679, Int32FromInt32(O_WRONLY)|Int32FromInt32(O_NOCTTY)|Int32FromInt32(O_CLOEXEC), 0) if fd >= 0 { - Xdprintf(tls, fd, __ccgo_ts+986, VaList(bp+1120, l-*(*int32)(unsafe.Pointer(bp + 1104)), bp+80+uintptr(*(*int32)(unsafe.Pointer(bp + 1104))))) + Xdprintf(tls, fd, __ccgo_ts+986, VaList(bp+1120, l-**(**int32)(__ccgo_up(bp + 1104)), bp+80+uintptr(**(**int32)(__ccgo_up(bp + 1104))))) Xclose(tls, fd) } } if _log_opt&int32(LOG_PERROR) != 0 { - Xdprintf(tls, int32(2), __ccgo_ts+986, VaList(bp+1120, l-*(*int32)(unsafe.Pointer(bp + 1104)), bp+80+uintptr(*(*int32)(unsafe.Pointer(bp + 1104))))) + Xdprintf(tls, int32(2), __ccgo_ts+986, VaList(bp+1120, l-**(**int32)(__ccgo_up(bp + 1104)), bp+80+uintptr(**(**int32)(__ccgo_up(bp + 1104))))) } } } @@ -116288,7 +116288,7 @@ func ___vsyslog(tls *TLS, priority int32, message uintptr, ap Tva_list) { ___lock(tls, uintptr(unsafe.Pointer(&_lock2))) __vsyslog(tls, priority, message, ap) ___unlock(tls, uintptr(unsafe.Pointer(&_lock2))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) } func Xsyslog(tls *TLS, priority int32, message uintptr, va uintptr) { @@ -116398,7 +116398,7 @@ func X__mremap(tls *TLS, old_addr uintptr, old_len Tsize_t, new_len Tsize_t, fla _, _ = ap, new_addr new_addr = uintptr(0) if new_len >= Uint64FromInt64(Int64FromInt64(INT64_MAX)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return uintptr(-Int32FromInt32(1)) } if flags&int32(MREMAP_FIXED) != 0 { @@ -116480,17 +116480,17 @@ func X__shm_mapname(tls *TLS, name uintptr, buf uintptr) (r uintptr) { } var p, v1 uintptr _, _ = p, v1 - for Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) == int32('/') { + for Int32FromUint8(**(**uint8)(__ccgo_up(name))) == int32('/') { name = name + 1 } v1 = X__strchrnul(tls, name, int32('/')) p = v1 - if *(*uint8)(unsafe.Pointer(v1)) != 0 || p == name || int64(p)-int64(name) <= int64(2) && Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) == int32('.') && Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) == int32('.') { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if **(**uint8)(__ccgo_up(v1)) != 0 || p == name || int64(p)-int64(name) <= int64(2) && Int32FromUint8(**(**uint8)(__ccgo_up(name))) == int32('.') && Int32FromUint8(**(**uint8)(__ccgo_up(p + uintptr(-Int32FromInt32(1))))) == int32('.') { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } if int64(p)-int64(name) > int64(NAME_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENAMETOOLONG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENAMETOOLONG) return uintptr(0) } Xmemcpy(tls, buf, __ccgo_ts+991, uint64(9)) @@ -116517,7 +116517,7 @@ func Xshm_open(tls *TLS, name uintptr, flag int32, mode Tmode_t) (r int32) { } _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp) fd = Xopen(tls, name, flag|int32(O_NOFOLLOW)|int32(O_CLOEXEC)|int32(O_NONBLOCK), VaList(bp+280, mode)) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) return fd } @@ -116555,7 +116555,7 @@ func Xbtowc(tls *TLS, c int32) (r Twint_t) { if Uint32FromInt32(b) < uint32(128) { v1 = Uint32FromInt32(b) } else { - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v3 = int32(4) } else { v3 = int32(1) @@ -116587,22 +116587,22 @@ func Xc16rtomb(tls *TLS, s uintptr, c16 Tchar16_t, ps uintptr) (r Tsize_t) { } x = ps if !(s != 0) { - if *(*uint32)(unsafe.Pointer(x)) != 0 { + if **(**uint32)(__ccgo_up(x)) != 0 { goto ilseq } return uint64(1) } - if !(*(*uint32)(unsafe.Pointer(x)) != 0) && uint32(c16)-uint32(0xd800) < uint32(0x400) { - *(*uint32)(unsafe.Pointer(x)) = Uint32FromInt32((Int32FromUint16(c16) - int32(0xd7c0)) << int32(10)) + if !(**(**uint32)(__ccgo_up(x)) != 0) && uint32(c16)-uint32(0xd800) < uint32(0x400) { + **(**uint32)(__ccgo_up(x)) = Uint32FromInt32((Int32FromUint16(c16) - int32(0xd7c0)) << int32(10)) return uint64(0) } - if *(*uint32)(unsafe.Pointer(x)) != 0 { + if **(**uint32)(__ccgo_up(x)) != 0 { if uint32(c16)-uint32(0xdc00) >= uint32(0x400) { goto ilseq } else { - wc = Int32FromUint32(*(*uint32)(unsafe.Pointer(x)) + uint32(c16) - uint32(0xdc00)) + wc = Int32FromUint32(**(**uint32)(__ccgo_up(x)) + uint32(c16) - uint32(0xdc00)) } - *(*uint32)(unsafe.Pointer(x)) = uint32(0) + **(**uint32)(__ccgo_up(x)) = uint32(0) } else { wc = Int32FromUint16(c16) } @@ -116610,8 +116610,8 @@ func Xc16rtomb(tls *TLS, s uintptr, c16 Tchar16_t, ps uintptr) (r Tsize_t) { goto ilseq ilseq: ; - *(*uint32)(unsafe.Pointer(x)) = uint32(0) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EILSEQ) + **(**uint32)(__ccgo_up(x)) = uint32(0) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EILSEQ) return Uint64FromInt32(-Int32FromInt32(1)) } @@ -116670,21 +116670,21 @@ func Xmbrtoc16(tls *TLS, pc16 uintptr, s uintptr, n Tsize_t, ps uintptr) (r Tsiz } /* mbrtowc states for partial UTF-8 characters have the high bit set; * we use nonzero states without high bit for pending surrogates. */ - if Int32FromUint32(*(*uint32)(unsafe.Pointer(pending))) > 0 { + if Int32FromUint32(**(**uint32)(__ccgo_up(pending))) > 0 { if pc16 != 0 { - *(*Tchar16_t)(unsafe.Pointer(pc16)) = uint16(*(*uint32)(unsafe.Pointer(pending))) + **(**Tchar16_t)(__ccgo_up(pc16)) = uint16(**(**uint32)(__ccgo_up(pending))) } - *(*uint32)(unsafe.Pointer(pending)) = uint32(0) + **(**uint32)(__ccgo_up(pending)) = uint32(0) return Uint64FromInt32(-Int32FromInt32(3)) } ret = Xmbrtowc(tls, bp, s, n, ps) if ret <= uint64(4) { - if *(*Twchar_t)(unsafe.Pointer(bp)) >= int32(0x10000) { - *(*uint32)(unsafe.Pointer(pending)) = Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))&int32(0x3ff) + int32(0xdc00)) - *(*Twchar_t)(unsafe.Pointer(bp)) = int32(0xd7c0) + *(*Twchar_t)(unsafe.Pointer(bp))>>Int32FromInt32(10) + if **(**Twchar_t)(__ccgo_up(bp)) >= int32(0x10000) { + **(**uint32)(__ccgo_up(pending)) = Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))&int32(0x3ff) + int32(0xdc00)) + **(**Twchar_t)(__ccgo_up(bp)) = int32(0xd7c0) + **(**Twchar_t)(__ccgo_up(bp))>>Int32FromInt32(10) } if pc16 != 0 { - *(*Tchar16_t)(unsafe.Pointer(pc16)) = Uint16FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))) + **(**Tchar16_t)(__ccgo_up(pc16)) = Uint16FromInt32(**(**Twchar_t)(__ccgo_up(bp))) } } return ret @@ -116710,7 +116710,7 @@ func Xmbrtoc32(tls *TLS, pc32 uintptr, s uintptr, n Tsize_t, ps uintptr) (r Tsiz } ret = Xmbrtowc(tls, bp, s, n, ps) if ret <= uint64(4) && pc32 != 0 { - *(*Tchar32_t)(unsafe.Pointer(pc32)) = Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))) + **(**Tchar32_t)(__ccgo_up(pc32)) = Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))) } return ret } @@ -116736,7 +116736,7 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize if !(st != 0) { st = uintptr(unsafe.Pointer(&_internal_state3)) } - c = *(*uint32)(unsafe.Pointer(st)) + c = **(**uint32)(__ccgo_up(st)) if !(s != 0) { if c != 0 { goto ilseq @@ -116751,30 +116751,30 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize return Uint64FromInt32(-Int32FromInt32(2)) } if !(c != 0) { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) < int32(0x80) { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) - *(*Twchar_t)(unsafe.Pointer(wc)) = v1 + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) < int32(0x80) { + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(s))) + **(**Twchar_t)(__ccgo_up(wc)) = v1 return BoolUint64(!!(v1 != 0)) } - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v2 = int32(4) } else { v2 = int32(1) } if v2 == int32(1) { - *(*Twchar_t)(unsafe.Pointer(wc)) = Int32FromInt32(0xdfff) & int32(Int8FromUint8(*(*uint8)(unsafe.Pointer(s)))) + **(**Twchar_t)(__ccgo_up(wc)) = Int32FromInt32(0xdfff) & int32(Int8FromUint8(**(**uint8)(__ccgo_up(s)))) return Uint64FromInt32(1) } - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { goto ilseq } v3 = s s = s + 1 - c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v3)))-uint32(0xc2)] + c = X__fsmu8[uint32(**(**uint8)(__ccgo_up(v3)))-uint32(0xc2)] n = n - 1 } if n != 0 { - if (Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { + if (Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { goto ilseq } goto loop @@ -116782,27 +116782,27 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize ; v3 = s s = s + 1 - c = c<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { goto ilseq } goto loop } } - *(*uint32)(unsafe.Pointer(st)) = c + **(**uint32)(__ccgo_up(st)) = c return Uint64FromInt32(-Int32FromInt32(2)) goto ilseq ilseq: ; - *(*uint32)(unsafe.Pointer(st)) = uint32(0) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EILSEQ) + **(**uint32)(__ccgo_up(st)) = uint32(0) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EILSEQ) return Uint64FromInt32(-Int32FromInt32(1)) } @@ -116813,7 +116813,7 @@ func Xmbsinit(tls *TLS, st uintptr) (r int32) { trc("tls=%v st=%v, (%v:)", tls, st, origin(2)) defer func() { trc("-> %v", r) }() } - return BoolInt32(!(st != 0) || !(*(*uint32)(unsafe.Pointer(st)) != 0)) + return BoolInt32(!(st != 0) || !(**(**uint32)(__ccgo_up(st)) != 0)) } func Xmbsnrtowcs(tls *TLS, wcs uintptr, src uintptr, n Tsize_t, wn Tsize_t, st uintptr) (r Tsize_t) { @@ -116831,7 +116831,7 @@ func Xmbsnrtowcs(tls *TLS, wcs uintptr, src uintptr, n Tsize_t, wn Tsize_t, st u var _ /* wbuf at bp+0 */ [256]Twchar_t _, _, _, _, _, _, _, _ = cnt, l, n2, tmp_s, ws, v1, v2, v3 cnt = uint64(0) - *(*uintptr)(unsafe.Pointer(bp + 1024)) = *(*uintptr)(unsafe.Pointer(src)) + **(**uintptr)(__ccgo_up(bp + 1024)) = **(**uintptr)(__ccgo_up(src)) if !(wcs != 0) { ws = bp wn = Uint64FromInt64(1024) / Uint64FromInt64(4) @@ -116842,7 +116842,7 @@ func Xmbsnrtowcs(tls *TLS, wcs uintptr, src uintptr, n Tsize_t, wn Tsize_t, st u * that mbsrtowcs never reads more than n input bytes. thus * we can use mbsrtowcs as long as it's practical.. */ for { - if v2 = *(*uintptr)(unsafe.Pointer(bp + 1024)) != 0 && wn != 0; v2 { + if v2 = **(**uintptr)(__ccgo_up(bp + 1024)) != 0 && wn != 0; v2 { v1 = n / Uint64FromInt32(4) n2 = v1 } @@ -116852,7 +116852,7 @@ func Xmbsnrtowcs(tls *TLS, wcs uintptr, src uintptr, n Tsize_t, wn Tsize_t, st u if n2 >= wn { n2 = wn } - tmp_s = *(*uintptr)(unsafe.Pointer(bp + 1024)) + tmp_s = **(**uintptr)(__ccgo_up(bp + 1024)) l = Xmbsrtowcs(tls, ws, bp+1024, n2, st) if !(l+Uint64FromInt32(1) != 0) { cnt = l @@ -116863,31 +116863,31 @@ func Xmbsnrtowcs(tls *TLS, wcs uintptr, src uintptr, n Tsize_t, wn Tsize_t, st u ws = ws + uintptr(l)*4 wn = wn - l } - if *(*uintptr)(unsafe.Pointer(bp + 1024)) != 0 { - v3 = n - Uint64FromInt64(int64(*(*uintptr)(unsafe.Pointer(bp + 1024)))-int64(tmp_s)) + if **(**uintptr)(__ccgo_up(bp + 1024)) != 0 { + v3 = n - Uint64FromInt64(int64(**(**uintptr)(__ccgo_up(bp + 1024)))-int64(tmp_s)) } else { v3 = uint64(0) } n = v3 cnt = cnt + l } - if *(*uintptr)(unsafe.Pointer(bp + 1024)) != 0 { + if **(**uintptr)(__ccgo_up(bp + 1024)) != 0 { for wn != 0 && n != 0 { - l = Xmbrtowc(tls, ws, *(*uintptr)(unsafe.Pointer(bp + 1024)), n, st) + l = Xmbrtowc(tls, ws, **(**uintptr)(__ccgo_up(bp + 1024)), n, st) if l+uint64(2) <= uint64(2) { if !(l+Uint64FromInt32(1) != 0) { cnt = l break } if !(l != 0) { - *(*uintptr)(unsafe.Pointer(bp + 1024)) = uintptr(0) + **(**uintptr)(__ccgo_up(bp + 1024)) = uintptr(0) break } /* have to roll back partial character */ - *(*uint32)(unsafe.Pointer(st)) = uint32(0) + **(**uint32)(__ccgo_up(st)) = uint32(0) break } - *(*uintptr)(unsafe.Pointer(bp + 1024)) = *(*uintptr)(unsafe.Pointer(bp + 1024)) + uintptr(l) + **(**uintptr)(__ccgo_up(bp + 1024)) = **(**uintptr)(__ccgo_up(bp + 1024)) + uintptr(l) n = n - l /* safe - this loop runs fewer than sizeof(wbuf)/8 times */ ws += 4 @@ -116896,7 +116896,7 @@ func Xmbsnrtowcs(tls *TLS, wcs uintptr, src uintptr, n Tsize_t, wn Tsize_t, st u } } if wcs != 0 { - *(*uintptr)(unsafe.Pointer(src)) = *(*uintptr)(unsafe.Pointer(bp + 1024)) + **(**uintptr)(__ccgo_up(src)) = **(**uintptr)(__ccgo_up(bp + 1024)) } return cnt } @@ -116912,22 +116912,22 @@ func Xmbsrtowcs(tls *TLS, ws uintptr, src uintptr, wn Tsize_t, st uintptr) (r Ts var v2 bool var v3 int32 _, _, _, _, _, _, _, _ = c, s, wn0, v1, v2, v3, v5, v6 - s = *(*uintptr)(unsafe.Pointer(src)) + s = **(**uintptr)(__ccgo_up(src)) wn0 = wn c = uint32(0) if v2 = st != 0; v2 { - v1 = *(*uint32)(unsafe.Pointer(st)) + v1 = **(**uint32)(__ccgo_up(st)) c = v1 } if v2 && v1 != 0 { if ws != 0 { - *(*uint32)(unsafe.Pointer(st)) = uint32(0) + **(**uint32)(__ccgo_up(st)) = uint32(0) goto resume } else { goto resume0 } } - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v3 = int32(4) } else { v3 = int32(1) @@ -116938,24 +116938,24 @@ func Xmbsrtowcs(tls *TLS, ws uintptr, src uintptr, wn Tsize_t, st uintptr) (r Ts } for { if !(wn != 0) { - *(*uintptr)(unsafe.Pointer(src)) = s + **(**uintptr)(__ccgo_up(src)) = s return wn0 } - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { break } v5 = s s = s + 1 - c = uint32(*(*uint8)(unsafe.Pointer(v5))) + c = uint32(**(**uint8)(__ccgo_up(v5))) v5 = ws ws += 4 - *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromInt32(0xdfff) & int32(Int8FromUint32(c)) + **(**Twchar_t)(__ccgo_up(v5)) = Int32FromInt32(0xdfff) & int32(Int8FromUint32(c)) wn = wn - 1 goto _4 _4: } - *(*Twchar_t)(unsafe.Pointer(ws)) = 0 - *(*uintptr)(unsafe.Pointer(src)) = uintptr(0) + **(**Twchar_t)(__ccgo_up(ws)) = 0 + **(**uintptr)(__ccgo_up(src)) = uintptr(0) return wn0 - wn } if !!(ws != 0) { @@ -116963,39 +116963,39 @@ func Xmbsrtowcs(tls *TLS, ws uintptr, src uintptr, wn Tsize_t, st uintptr) (r Ts } _11: ; - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) && uint64(s)%uint64(4) == uint64(0) { - for !((*(*uint32)(unsafe.Pointer(s))|(*(*uint32)(unsafe.Pointer(s))-Uint32FromInt32(0x01010101)))&Uint32FromUint32(0x80808080) != 0) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(1) < uint32(0x7f) && uint64(s)%uint64(4) == uint64(0) { + for !((**(**uint32)(__ccgo_up(s))|(**(**uint32)(__ccgo_up(s))-Uint32FromInt32(0x01010101)))&Uint32FromUint32(0x80808080) != 0) { s = s + uintptr(4) wn = wn - uint64(4) } } - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(1) < uint32(0x7f) { s = s + 1 wn = wn - 1 goto _10 } - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { goto _9 } v5 = s s = s + 1 - c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v5)))-uint32(0xc2)] + c = X__fsmu8[uint32(**(**uint8)(__ccgo_up(v5)))-uint32(0xc2)] goto resume0 resume0: ; - if (Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { + if (Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { s = s - 1 goto _9 } s = s + 1 if c&(Uint32FromUint32(1)<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { s = s - uintptr(2) goto _9 } s = s + 1 if c&(Uint32FromUint32(1)<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { s = s - uintptr(3) goto _9 } @@ -117017,80 +117017,80 @@ _7: _15: ; if !(wn != 0) { - *(*uintptr)(unsafe.Pointer(src)) = s + **(**uintptr)(__ccgo_up(src)) = s return wn0 } - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) && uint64(s)%uint64(4) == uint64(0) { - for wn >= uint64(5) && !((*(*uint32)(unsafe.Pointer(s))|(*(*uint32)(unsafe.Pointer(s))-Uint32FromInt32(0x01010101)))&Uint32FromUint32(0x80808080) != 0) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(1) < uint32(0x7f) && uint64(s)%uint64(4) == uint64(0) { + for wn >= uint64(5) && !((**(**uint32)(__ccgo_up(s))|(**(**uint32)(__ccgo_up(s))-Uint32FromInt32(0x01010101)))&Uint32FromUint32(0x80808080) != 0) { v5 = ws ws += 4 v6 = s s = s + 1 - *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + **(**Twchar_t)(__ccgo_up(v5)) = Int32FromUint8(**(**uint8)(__ccgo_up(v6))) v5 = ws ws += 4 v6 = s s = s + 1 - *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + **(**Twchar_t)(__ccgo_up(v5)) = Int32FromUint8(**(**uint8)(__ccgo_up(v6))) v5 = ws ws += 4 v6 = s s = s + 1 - *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + **(**Twchar_t)(__ccgo_up(v5)) = Int32FromUint8(**(**uint8)(__ccgo_up(v6))) v5 = ws ws += 4 v6 = s s = s + 1 - *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + **(**Twchar_t)(__ccgo_up(v5)) = Int32FromUint8(**(**uint8)(__ccgo_up(v6))) wn = wn - uint64(4) } } - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(1) < uint32(0x7f) { v5 = ws ws += 4 v6 = s s = s + 1 - *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + **(**Twchar_t)(__ccgo_up(v5)) = Int32FromUint8(**(**uint8)(__ccgo_up(v6))) wn = wn - 1 goto _14 } - if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { goto _13 } v5 = s s = s + 1 - c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v5)))-uint32(0xc2)] + c = X__fsmu8[uint32(**(**uint8)(__ccgo_up(v5)))-uint32(0xc2)] goto resume resume: ; - if (Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { + if (Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { s = s - 1 goto _13 } v5 = s s = s + 1 - c = c<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { s = s - uintptr(2) goto _13 } v5 = s s = s + 1 - c = c<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { s = s - uintptr(3) goto _13 } v5 = s s = s + 1 - c = c< Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { goto ilseq } v3 = s s = s + 1 - c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v3)))-uint32(0xc2)] + c = X__fsmu8[uint32(**(**uint8)(__ccgo_up(v3)))-uint32(0xc2)] /* Avoid excessive checks against n: If shifting the state n-1 * times does not clear the high bit, then the value of n is * insufficient to read a character */ if n < uint64(4) && c<<(uint64(6)*n-uint64(6))&(Uint32FromUint32(1)<>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { + if (Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(**(**uint8)(__ccgo_up(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { goto ilseq } v3 = s s = s + 1 - c = c<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { goto ilseq } v3 = s s = s + 1 - c = c<= uint32(0x40) { + if uint32(**(**uint8)(__ccgo_up(s)))-uint32(0x80) >= uint32(0x40) { goto ilseq } v3 = s s = s + 1 - *(*Twchar_t)(unsafe.Pointer(wc)) = Int32FromUint32(c<>Int32FromInt32(6)) - *(*uint8)(unsafe.Pointer(s)) = Uint8FromInt32(int32(0x80) | wc&int32(0x3f)) + **(**uint8)(__ccgo_up(v2)) = Uint8FromInt32(int32(0xc0) | wc>>Int32FromInt32(6)) + **(**uint8)(__ccgo_up(s)) = Uint8FromInt32(int32(0x80) | wc&int32(0x3f)) return uint64(2) } else { if Uint32FromInt32(wc) < uint32(0xd800) || Uint32FromInt32(wc)-uint32(0xe000) < uint32(0x2000) { v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(int32(0xe0) | wc>>Int32FromInt32(12)) + **(**uint8)(__ccgo_up(v2)) = Uint8FromInt32(int32(0xe0) | wc>>Int32FromInt32(12)) v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(int32(0x80) | wc>>Int32FromInt32(6)&int32(0x3f)) - *(*uint8)(unsafe.Pointer(s)) = Uint8FromInt32(int32(0x80) | wc&int32(0x3f)) + **(**uint8)(__ccgo_up(v2)) = Uint8FromInt32(int32(0x80) | wc>>Int32FromInt32(6)&int32(0x3f)) + **(**uint8)(__ccgo_up(s)) = Uint8FromInt32(int32(0x80) | wc&int32(0x3f)) return uint64(3) } else { if Uint32FromInt32(wc)-uint32(0x10000) < uint32(0x100000) { v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(int32(0xf0) | wc>>Int32FromInt32(18)) + **(**uint8)(__ccgo_up(v2)) = Uint8FromInt32(int32(0xf0) | wc>>Int32FromInt32(18)) v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(int32(0x80) | wc>>Int32FromInt32(12)&int32(0x3f)) + **(**uint8)(__ccgo_up(v2)) = Uint8FromInt32(int32(0x80) | wc>>Int32FromInt32(12)&int32(0x3f)) v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(int32(0x80) | wc>>Int32FromInt32(6)&int32(0x3f)) - *(*uint8)(unsafe.Pointer(s)) = Uint8FromInt32(int32(0x80) | wc&int32(0x3f)) + **(**uint8)(__ccgo_up(v2)) = Uint8FromInt32(int32(0x80) | wc>>Int32FromInt32(6)&int32(0x3f)) + **(**uint8)(__ccgo_up(s)) = Uint8FromInt32(int32(0x80) | wc&int32(0x3f)) return uint64(4) } } } } } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EILSEQ) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EILSEQ) return Uint64FromInt32(-Int32FromInt32(1)) } @@ -117287,7 +117287,7 @@ func Xwcsnrtombs(tls *TLS, dst uintptr, wcs uintptr, wn Tsize_t, n Tsize_t, st u var ws, v1 uintptr var _ /* tmp at bp+0 */ [4]uint8 _, _, _, _ = cnt, l, ws, v1 - ws = *(*uintptr)(unsafe.Pointer(wcs)) + ws = **(**uintptr)(__ccgo_up(wcs)) cnt = uint64(0) if !(dst != 0) { n = uint64(0) @@ -117298,7 +117298,7 @@ func Xwcsnrtombs(tls *TLS, dst uintptr, wcs uintptr, wn Tsize_t, n Tsize_t, st u } else { v1 = dst } - l = Xwcrtomb(tls, v1, *(*Twchar_t)(unsafe.Pointer(ws)), uintptr(0)) + l = Xwcrtomb(tls, v1, **(**Twchar_t)(__ccgo_up(ws)), uintptr(0)) if l == Uint64FromInt32(-Int32FromInt32(1)) { cnt = Uint64FromInt32(-Int32FromInt32(1)) break @@ -117313,7 +117313,7 @@ func Xwcsnrtombs(tls *TLS, dst uintptr, wcs uintptr, wn Tsize_t, n Tsize_t, st u dst = dst + uintptr(l) n = n - l } - if !(*(*Twchar_t)(unsafe.Pointer(ws)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(ws)) != 0) { ws = uintptr(0) break } @@ -117322,7 +117322,7 @@ func Xwcsnrtombs(tls *TLS, dst uintptr, wcs uintptr, wn Tsize_t, n Tsize_t, st u cnt = cnt + l } if dst != 0 { - *(*uintptr)(unsafe.Pointer(wcs)) = ws + **(**uintptr)(__ccgo_up(wcs)) = ws } return cnt } @@ -117341,13 +117341,13 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize N = n if !(s != 0) { n = uint64(0) - ws2 = *(*uintptr)(unsafe.Pointer(ws)) + ws2 = **(**uintptr)(__ccgo_up(ws)) for { - if !(*(*Twchar_t)(unsafe.Pointer(ws2)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(ws2)) != 0) { break } - if Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(ws2))) >= uint32(0x80) { - l = Xwcrtomb(tls, bp, *(*Twchar_t)(unsafe.Pointer(ws2)), uintptr(0)) + if Uint32FromInt32(**(**Twchar_t)(__ccgo_up(ws2))) >= uint32(0x80) { + l = Xwcrtomb(tls, bp, **(**Twchar_t)(__ccgo_up(ws2)), uintptr(0)) if !(l+Uint64FromInt32(1) != 0) { return Uint64FromInt32(-Int32FromInt32(1)) } @@ -117363,13 +117363,13 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize return n } for n >= uint64(4) { - if Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))))-uint32(1) >= uint32(0x7f) { - if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))) != 0) { - *(*uint8)(unsafe.Pointer(s)) = uint8(0) - *(*uintptr)(unsafe.Pointer(ws)) = uintptr(0) + if Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))))-uint32(1) >= uint32(0x7f) { + if !(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))) != 0) { + **(**uint8)(__ccgo_up(s)) = uint8(0) + **(**uintptr)(__ccgo_up(ws)) = uintptr(0) return N - n } - l = Xwcrtomb(tls, s, *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))), uintptr(0)) + l = Xwcrtomb(tls, s, **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))), uintptr(0)) if !(l+Uint64FromInt32(1) != 0) { return Uint64FromInt32(-Int32FromInt32(1)) } @@ -117378,35 +117378,35 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize } else { v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) + **(**uint8)(__ccgo_up(v2)) = Uint8FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws))))) n = n - 1 } - *(*uintptr)(unsafe.Pointer(ws)) += 4 + **(**uintptr)(__ccgo_up(ws)) += 4 } for n != 0 { - if Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))))-uint32(1) >= uint32(0x7f) { - if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))) != 0) { - *(*uint8)(unsafe.Pointer(s)) = uint8(0) - *(*uintptr)(unsafe.Pointer(ws)) = uintptr(0) + if Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))))-uint32(1) >= uint32(0x7f) { + if !(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))) != 0) { + **(**uint8)(__ccgo_up(s)) = uint8(0) + **(**uintptr)(__ccgo_up(ws)) = uintptr(0) return N - n } - l = Xwcrtomb(tls, bp, *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))), uintptr(0)) + l = Xwcrtomb(tls, bp, **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))), uintptr(0)) if !(l+Uint64FromInt32(1) != 0) { return Uint64FromInt32(-Int32FromInt32(1)) } if l > n { return N - n } - Xwcrtomb(tls, s, *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))), uintptr(0)) + Xwcrtomb(tls, s, **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws)))), uintptr(0)) s = s + uintptr(l) n = n - l } else { v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) + **(**uint8)(__ccgo_up(v2)) = Uint8FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(ws))))) n = n - 1 } - *(*uintptr)(unsafe.Pointer(ws)) += 4 + **(**uintptr)(__ccgo_up(ws)) += 4 } return N } @@ -117432,7 +117432,7 @@ func Xwctob(tls *TLS, c Twint_t) (r int32) { if c < uint32(128) { return Int32FromUint32(c) } - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v1 = int32(4) } else { v1 = int32(1) @@ -117578,11 +117578,11 @@ func Xaccept4(tls *TLS, fd int32, addr uintptr, len1 uintptr, flg int32) (r1 int goto _11 _11: ret = int32(X__syscall_ret(tls, Uint64FromInt64(v10))) - if ret >= 0 || *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(ENOSYS) && *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(EINVAL) { + if ret >= 0 || **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(ENOSYS) && **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(EINVAL) { return ret } if flg & ^(Int32FromInt32(SOCK_CLOEXEC)|Int32FromInt32(SOCK_NONBLOCK)) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } ret = Xaccept(tls, fd, addr, len1) @@ -118602,13 +118602,13 @@ func _getoffs(tls *TLS, offs uintptr, base uintptr, s uintptr) (r int32) { _, _ = i, v2 i = 0 for { - for Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))&int32(0xc0) != 0 { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))&int32(0xc0) != int32(0xc0) { + for Int32FromUint8(**(**uint8)(__ccgo_up(s)))&int32(0xc0) != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(s)))&int32(0xc0) != int32(0xc0) { return 0 } - s = base + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))&Int32FromInt32(0x3f)<= int64(0x4000) { @@ -118616,8 +118616,8 @@ func _getoffs(tls *TLS, offs uintptr, base uintptr, s uintptr) (r int32) { } v2 = i i = i + 1 - *(*int16)(unsafe.Pointer(offs + uintptr(v2)*2)) = int16(int64(s) - int64(base)) - s = s + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))+int32(1)) + **(**int16)(__ccgo_up(offs + uintptr(v2)*2)) = int16(int64(s) - int64(base)) + s = s + uintptr(Int32FromUint8(**(**uint8)(__ccgo_up(s)))+int32(1)) goto _1 _1: } @@ -118635,7 +118635,7 @@ func _getlens(tls *TLS, lens uintptr, s uintptr, l int32) (r int32) { k = 0 for { for { - if !(j < l && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(j)))) != int32('.')) { + if !(j < l && Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(j)))) != int32('.')) { break } goto _2 @@ -118648,7 +118648,7 @@ func _getlens(tls *TLS, lens uintptr, s uintptr, l int32) (r int32) { } v3 = i i = i + 1 - *(*uint8)(unsafe.Pointer(lens + uintptr(v3))) = Uint8FromInt32(j - k) + **(**uint8)(__ccgo_up(lens + uintptr(v3))) = Uint8FromInt32(j - k) if j == l { return i } @@ -118678,15 +118678,15 @@ func _match(tls *TLS, offset uintptr, base uintptr, dn uintptr, end uintptr, len for { nlen = nlen - 1 v2 = nlen - l = Int32FromUint8(*(*uint8)(unsafe.Pointer(lens + uintptr(v2)))) + l = Int32FromUint8(**(**uint8)(__ccgo_up(lens + uintptr(v2)))) noff = noff - 1 v2 = noff - o = int32((*(*[128]int16)(unsafe.Pointer(bp)))[v2]) + o = int32((**(**[128]int16)(__ccgo_up(bp)))[v2]) end = end - uintptr(l) - if l != Int32FromUint8(*(*uint8)(unsafe.Pointer(base + uintptr(o)))) || Xmemcmp(tls, base+uintptr(o)+uintptr(1), end, Uint64FromInt32(l)) != 0 { + if l != Int32FromUint8(**(**uint8)(__ccgo_up(base + uintptr(o)))) || Xmemcmp(tls, base+uintptr(o)+uintptr(1), end, Uint64FromInt32(l)) != 0 { return m } - *(*int32)(unsafe.Pointer(offset)) = o + **(**int32)(__ccgo_up(offset)) = o m = m + l if nlen != 0 { m = m + 1 @@ -118717,14 +118717,14 @@ func Xdn_comp(tls *TLS, src uintptr, dst uintptr, space int32, dnptrs uintptr, l m = 0 bestlen = 0 l = Xstrnlen(tls, src, uint64(255)) - if l != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(src + uintptr(l-uint64(1))))) == int32('.') { + if l != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(src + uintptr(l-uint64(1))))) == int32('.') { l = l - 1 } if l > uint64(253) || space <= 0 { return -int32(1) } if !(l != 0) { - *(*uint8)(unsafe.Pointer(dst)) = uint8(0) + **(**uint8)(__ccgo_up(dst)) = uint8(0) return int32(1) } end = src + uintptr(l) @@ -118733,16 +118733,16 @@ func Xdn_comp(tls *TLS, src uintptr, dst uintptr, space int32, dnptrs uintptr, l return -int32(1) } p = dnptrs - if p != 0 && *(*uintptr)(unsafe.Pointer(p)) != 0 { + if p != 0 && **(**uintptr)(__ccgo_up(p)) != 0 { p += 8 for { - if !(*(*uintptr)(unsafe.Pointer(p)) != 0) { + if !(**(**uintptr)(__ccgo_up(p)) != 0) { break } - m = _match(tls, bp, *(*uintptr)(unsafe.Pointer(dnptrs)), *(*uintptr)(unsafe.Pointer(p)), end, bp+4, n) + m = _match(tls, bp, **(**uintptr)(__ccgo_up(dnptrs)), **(**uintptr)(__ccgo_up(p)), end, bp+4, n) if m > bestlen { bestlen = m - bestoff = *(*int32)(unsafe.Pointer(bp)) + bestoff = **(**int32)(__ccgo_up(bp)) if Uint64FromInt32(m) == l { break } @@ -118765,37 +118765,37 @@ func Xdn_comp(tls *TLS, src uintptr, dst uintptr, space int32, dnptrs uintptr, l if !(Uint64FromInt32(i) < l-Uint64FromInt32(bestlen)) { break } - *(*uint8)(unsafe.Pointer(dst + uintptr(i))) = (*(*[127]uint8)(unsafe.Pointer(bp + 4)))[j] + **(**uint8)(__ccgo_up(dst + uintptr(i))) = (**(**[127]uint8)(__ccgo_up(bp + 4)))[j] goto _2 _2: ; v3 = j j = j + 1 - i = i + (Int32FromUint8((*(*[127]uint8)(unsafe.Pointer(bp + 4)))[v3]) + int32(1)) + i = i + (Int32FromUint8((**(**[127]uint8)(__ccgo_up(bp + 4)))[v3]) + int32(1)) } /* add tail */ if bestlen != 0 { v3 = i i = i + 1 - *(*uint8)(unsafe.Pointer(dst + uintptr(v3))) = Uint8FromInt32(int32(0xc0) | bestoff>>int32(8)) + **(**uint8)(__ccgo_up(dst + uintptr(v3))) = Uint8FromInt32(int32(0xc0) | bestoff>>int32(8)) v3 = i i = i + 1 - *(*uint8)(unsafe.Pointer(dst + uintptr(v3))) = Uint8FromInt32(bestoff) + **(**uint8)(__ccgo_up(dst + uintptr(v3))) = Uint8FromInt32(bestoff) } else { v3 = i i = i + 1 - *(*uint8)(unsafe.Pointer(dst + uintptr(v3))) = uint8(0) + **(**uint8)(__ccgo_up(dst + uintptr(v3))) = uint8(0) } /* save dst pointer */ - if i > int32(2) && lastdnptr != 0 && dnptrs != 0 && *(*uintptr)(unsafe.Pointer(dnptrs)) != 0 { - for *(*uintptr)(unsafe.Pointer(p)) != 0 { + if i > int32(2) && lastdnptr != 0 && dnptrs != 0 && **(**uintptr)(__ccgo_up(dnptrs)) != 0 { + for **(**uintptr)(__ccgo_up(p)) != 0 { p += 8 } if p+uintptr(1)*8 < lastdnptr { v8 = p p += 8 - *(*uintptr)(unsafe.Pointer(v8)) = dst - *(*uintptr)(unsafe.Pointer(p)) = uintptr(0) + **(**uintptr)(__ccgo_up(v8)) = dst + **(**uintptr)(__ccgo_up(p)) = uintptr(0) } } return i @@ -118828,11 +118828,11 @@ func X__dn_expand(tls *TLS, base uintptr, end uintptr, src uintptr, dest uintptr break } /* loop invariants: p= int64(end)-int64(p) || int64(j) >= int64(dend)-int64(dest) { return -int32(1) } @@ -118863,10 +118863,10 @@ func X__dn_expand(tls *TLS, base uintptr, end uintptr, src uintptr, dest uintptr dest = dest + 1 v4 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v3)) = *(*uint8)(unsafe.Pointer(v4)) + **(**uint8)(__ccgo_up(v3)) = uint8(**(**uint8)(__ccgo_up(v4))) } } else { - *(*uint8)(unsafe.Pointer(dest)) = uint8(0) + **(**uint8)(__ccgo_up(dest)) = uint8(0) if len1 < 0 { len1 = int32(int64(p+uintptr(1)) - int64(src)) } @@ -118898,20 +118898,20 @@ func Xdn_skipname(tls *TLS, s uintptr, end uintptr) (r int32) { _ = p p = s for p < end { - if !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if !(**(**uint8)(__ccgo_up(p)) != 0) { return int32(int64(p) - int64(s) + int64(1)) } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) >= int32(192) { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) >= int32(192) { if p+uintptr(1) < end { return int32(int64(p) - int64(s) + int64(2)) } else { break } } else { - if int64(end)-int64(p) < int64(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))+int32(1)) { + if int64(end)-int64(p) < int64(Int32FromUint8(**(**uint8)(__ccgo_up(p)))+int32(1)) { break } else { - p = p + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))+int32(1)) + p = p + uintptr(Int32FromUint8(**(**uint8)(__ccgo_up(p)))+int32(1)) } } } @@ -119027,25 +119027,25 @@ func X__dns_parse(tls *TLS, r uintptr, rlen int32, __ccgo_fp_callback uintptr, c if rlen < int32(12) { return -int32(1) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 3)))&int32(15) != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(r + 3)))&int32(15) != 0 { return 0 } p = r + uintptr(12) - qdcount = Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 4)))*int32(256) + Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 5))) - ancount = Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 6)))*int32(256) + Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 7))) + qdcount = Int32FromUint8(**(**uint8)(__ccgo_up(r + 4)))*int32(256) + Int32FromUint8(**(**uint8)(__ccgo_up(r + 5))) + ancount = Int32FromUint8(**(**uint8)(__ccgo_up(r + 6)))*int32(256) + Int32FromUint8(**(**uint8)(__ccgo_up(r + 7))) for { v1 = qdcount qdcount = qdcount - 1 if !(v1 != 0) { break } - for int64(p)-int64(r) < int64(rlen) && uint32(*(*uint8)(unsafe.Pointer(p)))-uint32(1) < uint32(127) { + for int64(p)-int64(r) < int64(rlen) && uint32(**(**uint8)(__ccgo_up(p)))-uint32(1) < uint32(127) { p = p + 1 } if p > r+uintptr(rlen)-uintptr(6) { return -int32(1) } - p = p + uintptr(int32(5)+BoolInt32(!!(*(*uint8)(unsafe.Pointer(p)) != 0))) + p = p + uintptr(int32(5)+BoolInt32(!!(**(**uint8)(__ccgo_up(p)) != 0))) } for { v1 = ancount @@ -119053,18 +119053,18 @@ func X__dns_parse(tls *TLS, r uintptr, rlen int32, __ccgo_fp_callback uintptr, c if !(v1 != 0) { break } - for int64(p)-int64(r) < int64(rlen) && uint32(*(*uint8)(unsafe.Pointer(p)))-uint32(1) < uint32(127) { + for int64(p)-int64(r) < int64(rlen) && uint32(**(**uint8)(__ccgo_up(p)))-uint32(1) < uint32(127) { p = p + 1 } if p > r+uintptr(rlen)-uintptr(12) { return -int32(1) } - p = p + uintptr(int32(1)+BoolInt32(!!(*(*uint8)(unsafe.Pointer(p)) != 0))) - len1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 8)))*int32(256) + Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 9))) + p = p + uintptr(int32(1)+BoolInt32(!!(**(**uint8)(__ccgo_up(p)) != 0))) + len1 = Int32FromUint8(**(**uint8)(__ccgo_up(p + 8)))*int32(256) + Int32FromUint8(**(**uint8)(__ccgo_up(p + 9))) if int64(len1+int32(10)) > int64(r+uintptr(rlen))-int64(p) { return -int32(1) } - if (*(*func(*TLS, uintptr, int32, uintptr, int32, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_callback})))(tls, ctx, Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))), p+uintptr(10), len1, r, rlen) < 0 { + if (*(*func(*TLS, uintptr, int32, uintptr, int32, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_callback})))(tls, ctx, Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))), p+uintptr(10), len1, r, rlen) < 0 { return -int32(1) } p = p + uintptr(int32(10)+len1) @@ -119406,27 +119406,27 @@ func Xether_aton_r(tls *TLS, x uintptr, p_a uintptr) (r uintptr) { break } if ii != 0 { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(x))) != int32(':') { + if Int32FromUint8(**(**uint8)(__ccgo_up(x))) != int32(':') { return uintptr(0) } else { x = x + 1 } } n = Xstrtoul(tls, x, bp+8, int32(16)) - x = *(*uintptr)(unsafe.Pointer(bp + 8)) + x = **(**uintptr)(__ccgo_up(bp + 8)) if n > uint64(0xFF) { return uintptr(0) } /* bad byte */ - *(*Tuint8_t)(unsafe.Pointer(bp + uintptr(ii))) = uint8(n) + **(**Tuint8_t)(__ccgo_up(bp + uintptr(ii))) = uint8(n) goto _1 _1: ; ii = ii + 1 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(x))) != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(x))) != 0 { return uintptr(0) } /* bad format */ - *(*Tether_addr)(unsafe.Pointer(p_a)) = *(*Tether_addr)(unsafe.Pointer(bp)) + **(**Tether_addr)(__ccgo_up(p_a)) = **(**Tether_addr)(__ccgo_up(bp)) return p_a } @@ -119461,7 +119461,7 @@ func Xether_ntoa_r(tls *TLS, p_a uintptr, x uintptr) (r uintptr) { } else { v2 = __ccgo_ts + 1006 } - x = x + uintptr(Xsprintf(tls, x, v2, VaList(bp+8, Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(p_a + uintptr(ii))))))) + x = x + uintptr(Xsprintf(tls, x, v2, VaList(bp+8, Int32FromUint8(**(**Tuint8_t)(__ccgo_up(p_a + uintptr(ii))))))) goto _1 _1: ; @@ -119546,11 +119546,11 @@ func Xgai_strerror(tls *TLS, ecode int32) (r uintptr) { s = uintptr(unsafe.Pointer(&_msgs)) ecode = ecode + 1 for { - if !(ecode != 0 && *(*uint8)(unsafe.Pointer(s)) != 0) { + if !(ecode != 0 && **(**uint8)(__ccgo_up(s)) != 0) { break } for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { break } goto _2 @@ -119564,7 +119564,7 @@ func Xgai_strerror(tls *TLS, ecode int32) (r uintptr) { ecode = ecode + 1 s = s + 1 } - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { s = s + 1 } return X__lctrans_cur(tls, s) @@ -119640,15 +119640,15 @@ func Xgetaddrinfo(tls *TLS, host uintptr, serv uintptr, hint uintptr, res uintpt if s >= 0 { _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp+1608) r = Xconnect(tls, s, ta[i], tl[i]) - saved_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 1608)), uintptr(0)) + saved_errno = **(**int32)(__ccgo_up(X__errno_location(tls))) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 1608)), uintptr(0)) Xclose(tls, s) if !(r != 0) { goto _1 } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = saved_errno + **(**int32)(__ccgo_up(X__errno_location(tls))) = saved_errno } - switch *(*int32)(unsafe.Pointer(X__errno_location(tls))) { + switch **(**int32)(__ccgo_up(X__errno_location(tls))) { case int32(EADDRNOTAVAIL): fallthrough case int32(EAFNOSUPPORT): @@ -119706,32 +119706,32 @@ func Xgetaddrinfo(tls *TLS, host uintptr, serv uintptr, hint uintptr, res uintpt if !(j < nservs) { break } - (*(*Taibuf)(unsafe.Pointer(out + uintptr(k)*88))).Fslot = int16(k) - if (*(*[48]Taddress)(unsafe.Pointer(bp + 8)))[i].Ffamily == int32(PF_INET) { + (**(**Taibuf)(__ccgo_up(out + uintptr(k)*88))).Fslot = int16(k) + if (**(**[48]Taddress)(__ccgo_up(bp + 8)))[i].Ffamily == int32(PF_INET) { v5 = uint64(16) } else { v5 = uint64(28) } - (*(*Taibuf)(unsafe.Pointer(out + uintptr(k)*88))).Fai = Taddrinfo{ - Fai_family: (*(*[48]Taddress)(unsafe.Pointer(bp + 8)))[i].Ffamily, - Fai_socktype: Int32FromUint8((*(*[2]Tservice)(unsafe.Pointer(bp)))[j].Fsocktype), - Fai_protocol: Int32FromUint8((*(*[2]Tservice)(unsafe.Pointer(bp)))[j].Fproto), + (**(**Taibuf)(__ccgo_up(out + uintptr(k)*88))).Fai = Taddrinfo{ + Fai_family: (**(**[48]Taddress)(__ccgo_up(bp + 8)))[i].Ffamily, + Fai_socktype: Int32FromUint8((**(**[2]Tservice)(__ccgo_up(bp)))[j].Fsocktype), + Fai_protocol: Int32FromUint8((**(**[2]Tservice)(__ccgo_up(bp)))[j].Fproto), Fai_addrlen: uint32(v5), Fai_addr: out + uintptr(k)*88 + 48, Fai_canonname: outcanon, } if k != 0 { - (*(*Taibuf)(unsafe.Pointer(out + uintptr(k-int32(1))*88))).Fai.Fai_next = out + uintptr(k)*88 + (**(**Taibuf)(__ccgo_up(out + uintptr(k-int32(1))*88))).Fai.Fai_next = out + uintptr(k)*88 } - switch (*(*[48]Taddress)(unsafe.Pointer(bp + 8)))[i].Ffamily { + switch (**(**[48]Taddress)(__ccgo_up(bp + 8)))[i].Ffamily { case int32(PF_INET): *(*Tsa_family_t)(unsafe.Pointer(out + uintptr(k)*88 + 48)) = uint16(PF_INET) - *(*Tin_port_t)(unsafe.Pointer(out + uintptr(k)*88 + 48 + 2)) = Xhtons(tls, (*(*[2]Tservice)(unsafe.Pointer(bp)))[j].Fport) + *(*Tin_port_t)(unsafe.Pointer(out + uintptr(k)*88 + 48 + 2)) = Xhtons(tls, (**(**[2]Tservice)(__ccgo_up(bp)))[j].Fport) Xmemcpy(tls, out+uintptr(k)*88+48+4, bp+8+uintptr(i)*28+8, uint64(4)) case int32(PF_INET6): *(*Tsa_family_t)(unsafe.Pointer(out + uintptr(k)*88 + 48)) = uint16(PF_INET6) - *(*Tin_port_t)(unsafe.Pointer(out + uintptr(k)*88 + 48 + 2)) = Xhtons(tls, (*(*[2]Tservice)(unsafe.Pointer(bp)))[j].Fport) - *(*Tuint32_t)(unsafe.Pointer(out + uintptr(k)*88 + 48 + 24)) = (*(*[48]Taddress)(unsafe.Pointer(bp + 8)))[i].Fscopeid + *(*Tin_port_t)(unsafe.Pointer(out + uintptr(k)*88 + 48 + 2)) = Xhtons(tls, (**(**[2]Tservice)(__ccgo_up(bp)))[j].Fport) + *(*Tuint32_t)(unsafe.Pointer(out + uintptr(k)*88 + 48 + 24)) = (**(**[48]Taddress)(__ccgo_up(bp + 8)))[i].Fscopeid Xmemcpy(tls, out+uintptr(k)*88+48+8, bp+8+uintptr(i)*28+8, uint64(16)) break } @@ -119746,8 +119746,8 @@ func Xgetaddrinfo(tls *TLS, host uintptr, serv uintptr, hint uintptr, res uintpt ; i = i + 1 } - (*(*Taibuf)(unsafe.Pointer(out))).Fref = int16(nais) - *(*uintptr)(unsafe.Pointer(res)) = out + (**(**Taibuf)(__ccgo_up(out))).Fref = int16(nais) + **(**uintptr)(__ccgo_up(res)) = out return 0 } @@ -119878,12 +119878,12 @@ func Xgethostbyaddr(tls *TLS, a uintptr, l Tsocklen_t, af int32) (r uintptr) { size = size + (size + uint64(1)) _h = Xmalloc(tls, size) if !(_h != 0) { - *(*int32)(unsafe.Pointer(X__h_errno_location(tls))) = int32(NO_RECOVERY) + **(**int32)(__ccgo_up(X__h_errno_location(tls))) = int32(NO_RECOVERY) return uintptr(0) } err = Xgethostbyaddr_r(tls, a, l, af, _h, _h+UintptrFromInt32(1)*32, size-uint64(32), bp, X__h_errno_location(tls)) } - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } var _h uintptr @@ -119920,7 +119920,7 @@ func Xgethostbyaddr_r(tls *TLS, a uintptr, l Tsocklen_t, af int32, h uintptr, bu v1 = uint64(16) } sl = uint32(v1) - *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) + **(**uintptr)(__ccgo_up(res)) = uintptr(0) /* Load address argument into sockaddr structure */ if af == int32(PF_INET6) && l == uint32(16) { Xmemcpy(tls, bp+8, a, uint64(16)) @@ -119928,7 +119928,7 @@ func Xgethostbyaddr_r(tls *TLS, a uintptr, l Tsocklen_t, af int32, h uintptr, bu if af == int32(PF_INET) && l == uint32(4) { Xmemcpy(tls, bp+4, a, uint64(4)) } else { - *(*int32)(unsafe.Pointer(err)) = int32(NO_RECOVERY) + **(**int32)(__ccgo_up(err)) = int32(NO_RECOVERY) return int32(EINVAL) } } @@ -119946,33 +119946,33 @@ func Xgethostbyaddr_r(tls *TLS, a uintptr, l Tsocklen_t, af int32, h uintptr, bu buf = buf + uintptr(Uint64FromInt32(2)*Uint64FromInt64(8)) (*Thostent)(unsafe.Pointer(h)).Fh_aliases = buf buf = buf + uintptr(Uint64FromInt32(2)*Uint64FromInt64(8)) - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list)) = buf - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list)), a, uint64(l)) + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_addr_list)) = buf + Xmemcpy(tls, **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_addr_list)), a, uint64(l)) buf = buf + uintptr(l) - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + 1*8)) = uintptr(0) - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) = buf - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = uintptr(0) + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + 1*8)) = uintptr(0) + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) = buf + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = uintptr(0) switch Xgetnameinfo(tls, bp, sl, buf, uint32(buflen), uintptr(0), uint32(0), 0) { case -int32(3): - *(*int32)(unsafe.Pointer(err)) = int32(TRY_AGAIN) + **(**int32)(__ccgo_up(err)) = int32(TRY_AGAIN) return int32(EAGAIN) case -int32(12): return int32(ERANGE) default: fallthrough case -int32(4): - *(*int32)(unsafe.Pointer(err)) = int32(NO_RECOVERY) + **(**int32)(__ccgo_up(err)) = int32(NO_RECOVERY) return int32(EBADMSG) case -int32(11): - *(*int32)(unsafe.Pointer(err)) = int32(NO_RECOVERY) - return *(*int32)(unsafe.Pointer(X__errno_location(tls))) + **(**int32)(__ccgo_up(err)) = int32(NO_RECOVERY) + return **(**int32)(__ccgo_up(X__errno_location(tls))) case 0: break } (*Thostent)(unsafe.Pointer(h)).Fh_addrtype = af (*Thostent)(unsafe.Pointer(h)).Fh_length = Int32FromUint32(l) - (*Thostent)(unsafe.Pointer(h)).Fh_name = *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) - *(*uintptr)(unsafe.Pointer(res)) = h + (*Thostent)(unsafe.Pointer(h)).Fh_name = **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) + **(**uintptr)(__ccgo_up(res)) = h return 0 } @@ -120001,12 +120001,12 @@ func Xgethostbyname2(tls *TLS, name uintptr, af int32) (r uintptr) { size = size + (size + uint64(1)) _h1 = Xmalloc(tls, size) if !(_h1 != 0) { - *(*int32)(unsafe.Pointer(X__h_errno_location(tls))) = int32(NO_RECOVERY) + **(**int32)(__ccgo_up(X__h_errno_location(tls))) = int32(NO_RECOVERY) return uintptr(0) } err = Xgethostbyname2_r(tls, name, af, _h1, _h1+UintptrFromInt32(1)*32, size-uint64(32), bp, X__h_errno_location(tls)) } - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } var _h1 uintptr @@ -120024,27 +120024,27 @@ func Xgethostbyname2_r(tls *TLS, name uintptr, af int32, h uintptr, buf uintptr, var _ /* addrs at bp+0 */ [48]Taddress var _ /* canon at bp+1344 */ [256]uint8 _, _, _, _, _, _ = align, cnt, i, need, v1, v3 - *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) + **(**uintptr)(__ccgo_up(res)) = uintptr(0) cnt = X__lookup_name(tls, bp, bp+1344, name, af, int32(AI_CANONNAME)) if cnt < 0 { switch cnt { case -int32(2): - *(*int32)(unsafe.Pointer(err)) = int32(HOST_NOT_FOUND) + **(**int32)(__ccgo_up(err)) = int32(HOST_NOT_FOUND) return 0 case -int32(5): - *(*int32)(unsafe.Pointer(err)) = int32(NO_DATA) + **(**int32)(__ccgo_up(err)) = int32(NO_DATA) return 0 case -int32(3): - *(*int32)(unsafe.Pointer(err)) = int32(TRY_AGAIN) + **(**int32)(__ccgo_up(err)) = int32(TRY_AGAIN) return int32(EAGAIN) default: fallthrough case -int32(4): - *(*int32)(unsafe.Pointer(err)) = int32(NO_RECOVERY) + **(**int32)(__ccgo_up(err)) = int32(NO_RECOVERY) return int32(EBADMSG) case -int32(11): - *(*int32)(unsafe.Pointer(err)) = int32(NO_RECOVERY) - return *(*int32)(unsafe.Pointer(X__errno_location(tls))) + **(**int32)(__ccgo_up(err)) = int32(NO_RECOVERY) + return **(**int32)(__ccgo_up(X__errno_location(tls))) } } (*Thostent)(unsafe.Pointer(h)).Fh_addrtype = af @@ -120074,29 +120074,29 @@ func Xgethostbyname2_r(tls *TLS, name uintptr, af int32, h uintptr, buf uintptr, if !(i < cnt) { break } - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)) = buf + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)) = buf buf = buf + uintptr((*Thostent)(unsafe.Pointer(h)).Fh_length) - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)), bp+uintptr(i)*28+8, Uint64FromInt32((*Thostent)(unsafe.Pointer(h)).Fh_length)) + Xmemcpy(tls, **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)), bp+uintptr(i)*28+8, Uint64FromInt32((*Thostent)(unsafe.Pointer(h)).Fh_length)) goto _2 _2: ; i = i + 1 } - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)) = uintptr(0) + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)) = uintptr(0) v3 = buf - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) = v3 + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) = v3 (*Thostent)(unsafe.Pointer(h)).Fh_name = v3 Xstrcpy(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name, bp+1344) buf = buf + uintptr(_strlen(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name)+uint64(1)) if Xstrcmp(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name, name) != 0 { - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = buf - Xstrcpy(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)), name) - buf = buf + uintptr(_strlen(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)))+uint64(1)) + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = buf + Xstrcpy(tls, **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)), name) + buf = buf + uintptr(_strlen(tls, **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)))+uint64(1)) } else { - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = uintptr(0) + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = uintptr(0) } - *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 2*8)) = uintptr(0) - *(*uintptr)(unsafe.Pointer(res)) = h + **(**uintptr)(__ccgo_up((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 2*8)) = uintptr(0) + **(**uintptr)(__ccgo_up(res)) = h return 0 } @@ -120325,7 +120325,7 @@ func _copy_addr(tls *TLS, r uintptr, af int32, sa uintptr, addr uintptr, addrlen case int32(PF_INET6): dst = sa + 8 len1 = int32(16) - if Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(addr))) == int32(0xfe) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(addr + 1)))&int32(0xc0) == int32(0x80) || Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(addr))) == int32(0xff) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(addr + 1)))&int32(0xf) == int32(0x2) { + if Int32FromUint8(**(**Tuint8_t)(__ccgo_up(addr))) == int32(0xfe) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(addr + 1)))&int32(0xc0) == int32(0x80) || Int32FromUint8(**(**Tuint8_t)(__ccgo_up(addr))) == int32(0xff) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(addr + 1)))&int32(0xf) == int32(0x2) { (*(*Tsockaddr_in6)(unsafe.Pointer(sa))).Fsin6_scope_id = Uint32FromInt32(ifindex) } default: @@ -120336,7 +120336,7 @@ func _copy_addr(tls *TLS, r uintptr, af int32, sa uintptr, addr uintptr, addrlen } (*Tsockany)(unsafe.Pointer(sa)).Fsa.Fsa_family = Uint16FromInt32(af) Xmemcpy(tls, dst, addr, Uint64FromInt32(len1)) - *(*uintptr)(unsafe.Pointer(r)) = sa + **(**uintptr)(__ccgo_up(r)) = sa } func _gen_netmask(tls *TLS, r uintptr, af int32, sa uintptr, prefixlen int32) { @@ -120345,7 +120345,7 @@ func _gen_netmask(tls *TLS, r uintptr, af int32, sa uintptr, prefixlen int32) { var i, v1 int32 var _ /* addr at bp+0 */ [16]Tuint8_t _, _ = i, v1 - *(*[16]Tuint8_t)(unsafe.Pointer(bp)) = [16]Tuint8_t{} + **(**[16]Tuint8_t)(__ccgo_up(bp)) = [16]Tuint8_t{} if Uint64FromInt32(prefixlen) > Uint64FromInt32(8)*Uint64FromInt64(16) { prefixlen = Int32FromUint64(Uint64FromInt32(8) * Uint64FromInt64(16)) } @@ -120354,7 +120354,7 @@ func _gen_netmask(tls *TLS, r uintptr, af int32, sa uintptr, prefixlen int32) { if Uint64FromInt32(i) < uint64(16) { v1 = i i = i + 1 - (*(*[16]Tuint8_t)(unsafe.Pointer(bp)))[v1] = Uint8FromInt32(int32(0xff) << (int32(8) - prefixlen%int32(8))) + (**(**[16]Tuint8_t)(__ccgo_up(bp)))[v1] = Uint8FromInt32(int32(0xff) << (int32(8) - prefixlen%int32(8))) } _copy_addr(tls, r, af, sa, bp, uint64(16), 0) } @@ -120368,7 +120368,7 @@ func _copy_lladdr(tls *TLS, r uintptr, sa uintptr, addr uintptr, addrlen Tsize_t (*(*Tsockaddr_ll_hack)(unsafe.Pointer(sa))).Fsll_hatype = hatype (*(*Tsockaddr_ll_hack)(unsafe.Pointer(sa))).Fsll_halen = uint8(addrlen) Xmemcpy(tls, sa+12, addr, addrlen) - *(*uintptr)(unsafe.Pointer(r)) = sa + **(**uintptr)(__ccgo_up(r)) = sa } func _netlink_msg_to_ifaddr(tls *TLS, pctx uintptr, h uintptr) (r int32) { @@ -120397,7 +120397,7 @@ func _netlink_msg_to_ifaddr(tls *TLS, pctx uintptr, h uintptr) (r int32) { rta = rta + uintptr((Int32FromUint16((*Trtattr)(unsafe.Pointer(rta)).Frta_len)+Int32FromInt32(3)) & ^Int32FromInt32(3)) } } else { - ifs0 = *(*uintptr)(unsafe.Pointer(ctx + 16 + uintptr((*Tifaddrmsg)(unsafe.Pointer(ifa)).Fifa_index%uint32(IFADDRS_HASH_SIZE))*8)) + ifs0 = **(**uintptr)(__ccgo_up(ctx + 16 + uintptr((*Tifaddrmsg)(unsafe.Pointer(ifa)).Fifa_index%uint32(IFADDRS_HASH_SIZE))*8)) for { if !(ifs0 != 0) { break @@ -120448,8 +120448,8 @@ func _netlink_msg_to_ifaddr(tls *TLS, pctx uintptr, h uintptr) (r int32) { } if (*Tifaddrs_storage)(unsafe.Pointer(ifs)).Fifa.Fifa_name != 0 { bucket = (*Tifaddrs_storage)(unsafe.Pointer(ifs)).Findex % uint32(IFADDRS_HASH_SIZE) - (*Tifaddrs_storage)(unsafe.Pointer(ifs)).Fhash_next = *(*uintptr)(unsafe.Pointer(ctx + 16 + uintptr(bucket)*8)) - *(*uintptr)(unsafe.Pointer(ctx + 16 + uintptr(bucket)*8)) = ifs + (*Tifaddrs_storage)(unsafe.Pointer(ifs)).Fhash_next = **(**uintptr)(__ccgo_up(ctx + 16 + uintptr(bucket)*8)) + **(**uintptr)(__ccgo_up(ctx + 16 + uintptr(bucket)*8)) = ifs } } else { (*Tifaddrs_storage)(unsafe.Pointer(ifs)).Fifa.Fifa_name = (*Tifaddrs_storage)(unsafe.Pointer(ifs0)).Fifa.Fifa_name @@ -120524,7 +120524,7 @@ func Xgetifaddrs(tls *TLS, ifap uintptr) (r1 int32) { Xmemset(tls, ctx, 0, uint64(528)) r = X__rtnetlink_enumerate(tls, PF_UNSPEC, PF_UNSPEC, __ccgo_fp(_netlink_msg_to_ifaddr), ctx) if r == 0 { - *(*uintptr)(unsafe.Pointer(ifap)) = (*Tifaddrs_ctx)(unsafe.Pointer(ctx)).Ffirst + **(**uintptr)(__ccgo_up(ifap)) = (*Tifaddrs_ctx)(unsafe.Pointer(ctx)).Ffirst } else { Xfreeifaddrs(tls, (*Tifaddrs_ctx)(unsafe.Pointer(ctx)).Ffirst) } @@ -120539,11 +120539,11 @@ func _itoa(tls *TLS, p uintptr, x uint32) (r uintptr) { p = p + uintptr(Uint64FromInt32(3)*Uint64FromInt64(4)) p = p - 1 v1 = p - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) for cond := true; cond; cond = x != 0 { p = p - 1 v1 = p - *(*uint8)(unsafe.Pointer(v1)) = uint8(uint32('0') + x%uint32(10)) + **(**uint8)(__ccgo_up(v1)) = uint8(uint32('0') + x%uint32(10)) x = x / uint32(10) } return p @@ -120552,7 +120552,7 @@ func _itoa(tls *TLS, p uintptr, x uint32) (r uintptr) { func _mkptr4(tls *TLS, s uintptr, ip uintptr) { bp := tls.Alloc(48) defer tls.Free(48) - Xsprintf(tls, s, __ccgo_ts+1012, VaList(bp+8, Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + 3))), Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + 2))), Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + 1))), Int32FromUint8(*(*uint8)(unsafe.Pointer(ip))))) + Xsprintf(tls, s, __ccgo_ts+1012, VaList(bp+8, Int32FromUint8(**(**uint8)(__ccgo_up(ip + 3))), Int32FromUint8(**(**uint8)(__ccgo_up(ip + 2))), Int32FromUint8(**(**uint8)(__ccgo_up(ip + 1))), Int32FromUint8(**(**uint8)(__ccgo_up(ip))))) } func _mkptr6(tls *TLS, s uintptr, ip uintptr) { @@ -120566,16 +120566,16 @@ func _mkptr6(tls *TLS, s uintptr, ip uintptr) { } v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = _xdigits[Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + uintptr(i))))&int32(15)] + **(**uint8)(__ccgo_up(v2)) = _xdigits[Int32FromUint8(**(**uint8)(__ccgo_up(ip + uintptr(i))))&int32(15)] v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8('.') + **(**uint8)(__ccgo_up(v2)) = uint8('.') v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = _xdigits[Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + uintptr(i))))>>int32(4)] + **(**uint8)(__ccgo_up(v2)) = _xdigits[Int32FromUint8(**(**uint8)(__ccgo_up(ip + uintptr(i))))>>int32(4)] v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8('.') + **(**uint8)(__ccgo_up(v2)) = uint8('.') goto _1 _1: ; @@ -120613,13 +120613,13 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int if v1 != 0 { v2 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8('\n') - *(*uint8)(unsafe.Pointer(p)) = Uint8FromInt32(0) + **(**uint8)(__ccgo_up(v2)) = uint8('\n') + **(**uint8)(__ccgo_up(p)) = Uint8FromInt32(0) } p = bp for { - if v7 = *(*uint8)(unsafe.Pointer(p)) != 0; v7 { - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + if v7 = **(**uint8)(__ccgo_up(p)) != 0; v7 { + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v5 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _6 _6: @@ -120632,26 +120632,26 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int ; p = p + 1 } - if !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if !(**(**uint8)(__ccgo_up(p)) != 0) { continue } v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) if X__lookup_ipliteral(tls, bp+1560, bp, PF_UNSPEC) <= 0 { continue } - if (*(*Taddress)(unsafe.Pointer(bp + 1560))).Ffamily == int32(PF_INET) { + if (**(**Taddress)(__ccgo_up(bp + 1560))).Ffamily == int32(PF_INET) { Xmemcpy(tls, bp+1560+8+uintptr(12), bp+1560+8, uint64(4)) Xmemcpy(tls, bp+1560+8, __ccgo_ts+1057, uint64(12)) - (*(*Taddress)(unsafe.Pointer(bp + 1560))).Fscopeid = uint32(0) + (**(**Taddress)(__ccgo_up(bp + 1560))).Fscopeid = uint32(0) } - if Xmemcmp(tls, a, bp+1560+8, uint64(16)) != 0 || (*(*Taddress)(unsafe.Pointer(bp + 1560))).Fscopeid != scopeid { + if Xmemcmp(tls, a, bp+1560+8, uint64(16)) != 0 || (**(**Taddress)(__ccgo_up(bp + 1560))).Fscopeid != scopeid { continue } for { - if v7 = *(*uint8)(unsafe.Pointer(p)) != 0; v7 { - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + if v7 = **(**uint8)(__ccgo_up(p)) != 0; v7 { + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v5 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _12 _12: @@ -120666,8 +120666,8 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int } z = p for { - if v7 = *(*uint8)(unsafe.Pointer(z)) != 0; v7 { - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(z))) + if v7 = **(**uint8)(__ccgo_up(z)) != 0; v7 { + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(z))) v5 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _17 _17: @@ -120680,7 +120680,7 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int ; z = z + 1 } - *(*uint8)(unsafe.Pointer(z)) = uint8(0) + **(**uint8)(__ccgo_up(z)) = uint8(0) if int64(z)-int64(p) < int64(256) { Xmemcpy(tls, buf, p, Uint64FromInt64(int64(z)-int64(p)+int64(1))) break @@ -120711,13 +120711,13 @@ func _reverse_services(tls *TLS, buf uintptr, port int32, dgram int32) { if v1 != 0 { v2 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8('\n') - *(*uint8)(unsafe.Pointer(p)) = Uint8FromInt32(0) + **(**uint8)(__ccgo_up(v2)) = uint8('\n') + **(**uint8)(__ccgo_up(p)) = Uint8FromInt32(0) } p = bp for { - if v7 = *(*uint8)(unsafe.Pointer(p)) != 0; v7 { - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + if v7 = **(**uint8)(__ccgo_up(p)) != 0; v7 { + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v5 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _6 _6: @@ -120730,20 +120730,20 @@ func _reverse_services(tls *TLS, buf uintptr, port int32, dgram int32) { ; p = p + 1 } - if !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if !(**(**uint8)(__ccgo_up(p)) != 0) { continue } v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) svport = Xstrtoul(tls, p, bp+128, int32(10)) - if svport != Uint64FromInt32(port) || *(*uintptr)(unsafe.Pointer(bp + 128)) == p { + if svport != Uint64FromInt32(port) || **(**uintptr)(__ccgo_up(bp + 128)) == p { continue } - if dgram != 0 && Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(bp + 128)), __ccgo_ts+1084, uint64(4)) != 0 { + if dgram != 0 && Xstrncmp(tls, **(**uintptr)(__ccgo_up(bp + 128)), __ccgo_ts+1084, uint64(4)) != 0 { continue } - if !(dgram != 0) && Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(bp + 128)), __ccgo_ts+1089, uint64(4)) != 0 { + if !(dgram != 0) && Xstrncmp(tls, **(**uintptr)(__ccgo_up(bp + 128)), __ccgo_ts+1089, uint64(4)) != 0 { continue } if int64(p)-t__predefined_ptrdiff_t(bp) > int64(32) { @@ -120760,7 +120760,7 @@ func _dns_parse_callback(tls *TLS, c uintptr, rr int32, data uintptr, len1 int32 return 0 } if X__dn_expand(tls, packet, packet+uintptr(plen), data, c, int32(256)) <= 0 { - *(*uint8)(unsafe.Pointer(c)) = uint8(0) + **(**uint8)(__ccgo_up(c)) = uint8(0) } return 0 } @@ -120806,15 +120806,15 @@ func Xgetnameinfo(tls *TLS, sa uintptr, sl Tsocklen_t, node uintptr, nodelen Tso return -int32(6) } if node != 0 && nodelen != 0 { - (*(*[256]uint8)(unsafe.Pointer(bp + 78)))[0] = uint8(0) + (**(**[256]uint8)(__ccgo_up(bp + 78)))[0] = uint8(0) if !(flags&Int32FromInt32(NI_NUMERICHOST) != 0) { _reverse_hosts(tls, bp+78, a, scopeid, af) } - if !(*(*uint8)(unsafe.Pointer(bp + 78)) != 0) && !(flags&Int32FromInt32(NI_NUMERICHOST) != 0) { + if !(**(**uint8)(__ccgo_up(bp + 78)) != 0) && !(flags&Int32FromInt32(NI_NUMERICHOST) != 0) { qlen = X__res_mkquery(tls, 0, bp, int32(1), int32(RR_PTR), uintptr(0), 0, uintptr(0), bp+347, int32(96)) - (*(*[96]uint8)(unsafe.Pointer(bp + 347)))[int32(3)] = uint8(0) /* don't need AD flag */ + (**(**[96]uint8)(__ccgo_up(bp + 347)))[int32(3)] = uint8(0) /* don't need AD flag */ rlen = X__res_send(tls, bp+347, qlen, bp+443, int32(512)) - (*(*[256]uint8)(unsafe.Pointer(bp + 78)))[0] = uint8(0) + (**(**[256]uint8)(__ccgo_up(bp + 78)))[0] = uint8(0) if rlen > 0 { if Uint64FromInt32(rlen) > uint64(512) { rlen = int32(512) @@ -120822,14 +120822,14 @@ func Xgetnameinfo(tls *TLS, sa uintptr, sl Tsocklen_t, node uintptr, nodelen Tso X__dns_parse(tls, bp+443, rlen, __ccgo_fp(_dns_parse_callback), bp+78) } } - if !(*(*uint8)(unsafe.Pointer(bp + 78)) != 0) { + if !(**(**uint8)(__ccgo_up(bp + 78)) != 0) { if flags&int32(NI_NAMEREQD) != 0 { return -int32(2) } Xinet_ntop(tls, af, a, bp+78, uint32(256)) if scopeid != 0 { p = uintptr(0) - if !(flags&Int32FromInt32(NI_NUMERICSCOPE) != 0) && (Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a))) == int32(0xfe) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 1)))&int32(0xc0) == int32(0x80) || Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a))) == int32(0xff) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 1)))&int32(0xf) == int32(0x2)) { + if !(flags&Int32FromInt32(NI_NUMERICSCOPE) != 0) && (Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a))) == int32(0xfe) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 1)))&int32(0xc0) == int32(0x80) || Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a))) == int32(0xff) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 1)))&int32(0xf) == int32(0x2)) { p = Xif_indextoname(tls, scopeid, bp+955+uintptr(1)) } if !(p != 0) { @@ -120837,7 +120837,7 @@ func Xgetnameinfo(tls *TLS, sa uintptr, sl Tsocklen_t, node uintptr, nodelen Tso } p = p - 1 v1 = p - *(*uint8)(unsafe.Pointer(v1)) = uint8('%') + **(**uint8)(__ccgo_up(v1)) = uint8('%') Xstrcat(tls, bp+78, p) } } @@ -120849,11 +120849,11 @@ func Xgetnameinfo(tls *TLS, sa uintptr, sl Tsocklen_t, node uintptr, nodelen Tso if serv != 0 && servlen != 0 { p1 = bp + 78 port = Int32FromUint16(Xntohs(tls, (*Tsockaddr_in)(unsafe.Pointer(sa)).Fsin_port)) - (*(*[256]uint8)(unsafe.Pointer(bp + 78)))[0] = uint8(0) + (**(**[256]uint8)(__ccgo_up(bp + 78)))[0] = uint8(0) if !(flags&Int32FromInt32(NI_NUMERICSERV) != 0) { _reverse_services(tls, bp+78, port, flags&int32(NI_DGRAM)) } - if !(*(*uint8)(unsafe.Pointer(p1)) != 0) { + if !(**(**uint8)(__ccgo_up(p1)) != 0) { p1 = _itoa(tls, bp+334, Uint32FromInt32(port)) } if _strlen(tls, p1) >= uint64(servlen) { @@ -120952,11 +120952,11 @@ func Xgetservbyname_r(tls *TLS, name uintptr, prots uintptr, se uintptr, buf uin var _ /* end at bp+8 */ uintptr var _ /* servs at bp+0 */ [2]Tservice _, _, _, _ = align, cnt, proto, v1 - *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) + **(**uintptr)(__ccgo_up(res)) = uintptr(0) /* Don't treat numeric port number strings as service records. */ - *(*uintptr)(unsafe.Pointer(bp + 8)) = __ccgo_ts + **(**uintptr)(__ccgo_up(bp + 8)) = __ccgo_ts Xstrtoul(tls, name, bp+8, int32(10)) - if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) != 0) { + if !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) != 0) { return int32(ENOENT) } /* Align buffer */ @@ -120991,16 +120991,16 @@ func Xgetservbyname_r(tls *TLS, name uintptr, prots uintptr, se uintptr, buf uin } (*Tservent)(unsafe.Pointer(se)).Fs_name = name (*Tservent)(unsafe.Pointer(se)).Fs_aliases = buf - *(*uintptr)(unsafe.Pointer((*Tservent)(unsafe.Pointer(se)).Fs_aliases)) = (*Tservent)(unsafe.Pointer(se)).Fs_name - *(*uintptr)(unsafe.Pointer((*Tservent)(unsafe.Pointer(se)).Fs_aliases + 1*8)) = uintptr(0) - (*Tservent)(unsafe.Pointer(se)).Fs_port = Int32FromUint16(Xhtons(tls, (*(*[2]Tservice)(unsafe.Pointer(bp)))[0].Fport)) - if Int32FromUint8((*(*[2]Tservice)(unsafe.Pointer(bp)))[0].Fproto) == int32(IPPROTO_TCP) { + **(**uintptr)(__ccgo_up((*Tservent)(unsafe.Pointer(se)).Fs_aliases)) = (*Tservent)(unsafe.Pointer(se)).Fs_name + **(**uintptr)(__ccgo_up((*Tservent)(unsafe.Pointer(se)).Fs_aliases + 1*8)) = uintptr(0) + (*Tservent)(unsafe.Pointer(se)).Fs_port = Int32FromUint16(Xhtons(tls, (**(**[2]Tservice)(__ccgo_up(bp)))[0].Fport)) + if Int32FromUint8((**(**[2]Tservice)(__ccgo_up(bp)))[0].Fproto) == int32(IPPROTO_TCP) { v1 = __ccgo_ts + 1094 } else { v1 = __ccgo_ts + 1098 } (*Tservent)(unsafe.Pointer(se)).Fs_proto = v1 - *(*uintptr)(unsafe.Pointer(res)) = se + **(**uintptr)(__ccgo_up(res)) = se return 0 } @@ -121126,7 +121126,7 @@ _11: if true { break } - if uint64(*(*Tsocklen_t)(unsafe.Pointer(optlen))) < uint64(16) { + if uint64(**(**Tsocklen_t)(__ccgo_up(optlen))) < uint64(16) { return int32(X__syscall_ret(tls, Uint64FromInt32(-Int32FromInt32(EINVAL)))) } if optname == int32(SO_RCVTIMEO) { @@ -121185,9 +121185,9 @@ _11: break } tv = optval - (*Ttimeval)(unsafe.Pointer(tv)).Ftv_sec = (*(*[2]int64)(unsafe.Pointer(bp + 296)))[0] - (*Ttimeval)(unsafe.Pointer(tv)).Ftv_usec = (*(*[2]int64)(unsafe.Pointer(bp + 296)))[int32(1)] - *(*Tsocklen_t)(unsafe.Pointer(optlen)) = uint32(16) + (*Ttimeval)(unsafe.Pointer(tv)).Ftv_sec = (**(**[2]int64)(__ccgo_up(bp + 296)))[0] + (*Ttimeval)(unsafe.Pointer(tv)).Ftv_usec = (**(**[2]int64)(__ccgo_up(bp + 296)))[int32(1)] + **(**Tsocklen_t)(__ccgo_up(optlen)) = uint32(16) case int32(SO_TIMESTAMP): fallthrough case int32(SO_TIMESTAMPNS): @@ -121279,7 +121279,7 @@ func Xherror(tls *TLS, msg uintptr) { } else { v2 = __ccgo_ts } - Xfprintf(tls, uintptr(unsafe.Pointer(&X__stderr_FILE)), __ccgo_ts+1102, VaList(bp+8, v1, v2, Xhstrerror(tls, *(*int32)(unsafe.Pointer(X__h_errno_location(tls)))))) + Xfprintf(tls, uintptr(unsafe.Pointer(&X__stderr_FILE)), __ccgo_ts+1102, VaList(bp+8, v1, v2, Xhstrerror(tls, **(**int32)(__ccgo_up(X__h_errno_location(tls)))))) } var _msgs1 = [84]uint8{'H', 'o', 's', 't', ' ', 'n', 'o', 't', ' ', 'f', 'o', 'u', 'n', 'd', 0, 'T', 'r', 'y', ' ', 'a', 'g', 'a', 'i', 'n', 0, 'N', 'o', 'n', '-', 'r', 'e', 'c', 'o', 'v', 'e', 'r', 'a', 'b', 'l', 'e', ' ', 'e', 'r', 'r', 'o', 'r', 0, 'A', 'd', 'd', 'r', 'e', 's', 's', ' ', 'n', 'o', 't', ' ', 'a', 'v', 'a', 'i', 'l', 'a', 'b', 'l', 'e', 0, 0, 'U', 'n', 'k', 'n', 'o', 'w', 'n', ' ', 'e', 'r', 'r', 'o', 'r'} @@ -121294,11 +121294,11 @@ func Xhstrerror(tls *TLS, ecode int32) (r uintptr) { s = uintptr(unsafe.Pointer(&_msgs1)) ecode = ecode - 1 for { - if !(ecode != 0 && *(*uint8)(unsafe.Pointer(s)) != 0) { + if !(ecode != 0 && **(**uint8)(__ccgo_up(s)) != 0) { break } for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { break } goto _2 @@ -121312,7 +121312,7 @@ func Xhstrerror(tls *TLS, ecode int32) (r uintptr) { ecode = ecode - 1 s = s + 1 } - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { s = s + 1 } return X__lctrans_cur(tls, s) @@ -121400,8 +121400,8 @@ func Xif_indextoname(tls *TLS, index uint32, name uintptr) (r1 uintptr) { r = Xioctl(tls, fd, int32(SIOCGIFNAME), VaList(bp+48, bp)) X__syscall1(tls, int64(SYS_close), int64(fd)) if r < 0 { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENODEV) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENXIO) + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENODEV) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENXIO) } return uintptr(0) } @@ -121454,7 +121454,7 @@ func _netlink_msg_to_nameindex(tls *TLS, pctx uintptr, h uintptr) (r int32) { } /* suppress duplicates */ bucket = index % int32(IFADDRS_HASH_SIZE) - i = *(*uint32)(unsafe.Pointer(ctx + 24 + uintptr(bucket)*4)) + i = **(**uint32)(__ccgo_up(ctx + 24 + uintptr(bucket)*4)) for i != 0 { map1 = (*Tifnameindexctx)(unsafe.Pointer(ctx)).Flist + uintptr(i-uint32(1))*28 if (*Tifnamemap)(unsafe.Pointer(map1)).Findex == Uint32FromInt32(index) && Int32FromUint8((*Tifnamemap)(unsafe.Pointer(map1)).Fnamelen) == namelen && Xmemcmp(tls, map1+9, rta+UintptrFromInt64(4), Uint64FromInt32(namelen)) == 0 { @@ -121483,10 +121483,10 @@ func _netlink_msg_to_nameindex(tls *TLS, pctx uintptr, h uintptr) (r int32) { (*Tifnamemap)(unsafe.Pointer(map1)).Findex = Uint32FromInt32(index) (*Tifnamemap)(unsafe.Pointer(map1)).Fnamelen = Uint8FromInt32(namelen) Xmemcpy(tls, map1+9, rta+UintptrFromInt64(4), Uint64FromInt32(namelen)) - *(*uint32)(unsafe.Pointer(ctx + 8)) += Uint32FromInt32(namelen + int32(1)) + **(**uint32)(__ccgo_up(ctx + 8)) += Uint32FromInt32(namelen + int32(1)) (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum = (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum + 1 - (*Tifnamemap)(unsafe.Pointer(map1)).Fhash_next = *(*uint32)(unsafe.Pointer(ctx + 24 + uintptr(bucket)*4)) - *(*uint32)(unsafe.Pointer(ctx + 24 + uintptr(bucket)*4)) = (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum + (*Tifnamemap)(unsafe.Pointer(map1)).Fhash_next = **(**uint32)(__ccgo_up(ctx + 24 + uintptr(bucket)*4)) + **(**uint32)(__ccgo_up(ctx + 24 + uintptr(bucket)*4)) = (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum return 0 goto _1 _1: @@ -121533,7 +121533,7 @@ func Xif_nameindex(tls *TLS) (r uintptr) { p = p + uintptr((*Tifnamemap)(unsafe.Pointer(s)).Fnamelen) v2 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8(0) + **(**uint8)(__ccgo_up(v2)) = uint8(0) goto _1 _1: ; @@ -121546,9 +121546,9 @@ func Xif_nameindex(tls *TLS) (r uintptr) { goto err err: ; - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 280)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 280)), uintptr(0)) Xfree(tls, (*Tifnameindexctx)(unsafe.Pointer(ctx)).Flist) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOBUFS) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOBUFS) return ifs } @@ -121589,7 +121589,7 @@ func Xinet_addr(tls *TLS, p uintptr) (r Tin_addr_t) { if !(X__inet_aton(tls, p, bp) != 0) { return Uint32FromInt32(-Int32FromInt32(1)) } - return (*(*Tin_addr)(unsafe.Pointer(bp))).Fs_addr + return (**(**Tin_addr)(__ccgo_up(bp))).Fs_addr } func X__inet_aton(tls *TLS, s0 uintptr, dest uintptr) (r int32) { @@ -121606,20 +121606,20 @@ func X__inet_aton(tls *TLS, s0 uintptr, dest uintptr) (r int32) { _, _, _ = d, i, s s = s0 d = dest - *(*[4]uint64)(unsafe.Pointer(bp)) = [4]uint64{} + **(**[4]uint64)(__ccgo_up(bp)) = [4]uint64{} i = 0 for { if !(i < int32(4)) { break } - (*(*[4]uint64)(unsafe.Pointer(bp)))[i] = Xstrtoul(tls, s, bp+32, 0) - if *(*uintptr)(unsafe.Pointer(bp + 32)) == s || *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32))))) != int32('.') || !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + (**(**[4]uint64)(__ccgo_up(bp)))[i] = Xstrtoul(tls, s, bp+32, 0) + if **(**uintptr)(__ccgo_up(bp + 32)) == s || **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 32)))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 32))))) != int32('.') || !(BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return 0 } - if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)))) != 0) { + if !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 32)))) != 0) { break } - s = *(*uintptr)(unsafe.Pointer(bp + 32)) + uintptr(1) + s = **(**uintptr)(__ccgo_up(bp + 32)) + uintptr(1) goto _1 _1: ; @@ -121630,26 +121630,26 @@ func X__inet_aton(tls *TLS, s0 uintptr, dest uintptr) (r int32) { } switch i { case 0: - (*(*[4]uint64)(unsafe.Pointer(bp)))[int32(1)] = (*(*[4]uint64)(unsafe.Pointer(bp)))[0] & uint64(0xffffff) - *(*uint64)(unsafe.Pointer(bp)) >>= uint64(24) + (**(**[4]uint64)(__ccgo_up(bp)))[int32(1)] = (**(**[4]uint64)(__ccgo_up(bp)))[0] & uint64(0xffffff) + **(**uint64)(__ccgo_up(bp)) >>= uint64(24) fallthrough case int32(1): - (*(*[4]uint64)(unsafe.Pointer(bp)))[int32(2)] = (*(*[4]uint64)(unsafe.Pointer(bp)))[int32(1)] & uint64(0xffff) - *(*uint64)(unsafe.Pointer(bp + 1*8)) >>= uint64(16) + (**(**[4]uint64)(__ccgo_up(bp)))[int32(2)] = (**(**[4]uint64)(__ccgo_up(bp)))[int32(1)] & uint64(0xffff) + **(**uint64)(__ccgo_up(bp + 1*8)) >>= uint64(16) fallthrough case int32(2): - (*(*[4]uint64)(unsafe.Pointer(bp)))[int32(3)] = (*(*[4]uint64)(unsafe.Pointer(bp)))[int32(2)] & uint64(0xff) - *(*uint64)(unsafe.Pointer(bp + 2*8)) >>= uint64(8) + (**(**[4]uint64)(__ccgo_up(bp)))[int32(3)] = (**(**[4]uint64)(__ccgo_up(bp)))[int32(2)] & uint64(0xff) + **(**uint64)(__ccgo_up(bp + 2*8)) >>= uint64(8) } i = 0 for { if !(i < int32(4)) { break } - if (*(*[4]uint64)(unsafe.Pointer(bp)))[i] > uint64(255) { + if (**(**[4]uint64)(__ccgo_up(bp)))[i] > uint64(255) { return 0 } - *(*uint8)(unsafe.Pointer(d + uintptr(i))) = uint8((*(*[4]uint64)(unsafe.Pointer(bp)))[i]) + **(**uint8)(__ccgo_up(d + uintptr(i))) = uint8((**(**[4]uint64)(__ccgo_up(bp)))[i]) goto _2 _2: ; @@ -121738,7 +121738,7 @@ func Xinet_ntoa(tls *TLS, _in Tin_addr) (r uintptr) { var a uintptr _ = a a = bp - Xsnprintf(tls, uintptr(unsafe.Pointer(&_buf4)), uint64(16), __ccgo_ts+1110, VaList(bp+16, Int32FromUint8(*(*uint8)(unsafe.Pointer(a))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 1))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 2))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 3))))) + Xsnprintf(tls, uintptr(unsafe.Pointer(&_buf4)), uint64(16), __ccgo_ts+1110, VaList(bp+16, Int32FromUint8(**(**uint8)(__ccgo_up(a))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 1))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 2))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 3))))) return uintptr(unsafe.Pointer(&_buf4)) } @@ -121759,14 +121759,14 @@ func Xinet_ntop(tls *TLS, af int32, a0 uintptr, s uintptr, l Tsocklen_t) (r uint a = a0 switch af { case int32(PF_INET): - if Uint32FromInt32(Xsnprintf(tls, s, uint64(l), __ccgo_ts+1110, VaList(bp+112, Int32FromUint8(*(*uint8)(unsafe.Pointer(a))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 1))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 2))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 3)))))) < l { + if Uint32FromInt32(Xsnprintf(tls, s, uint64(l), __ccgo_ts+1110, VaList(bp+112, Int32FromUint8(**(**uint8)(__ccgo_up(a))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 1))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 2))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 3)))))) < l { return s } case int32(PF_INET6): if Xmemcmp(tls, a, __ccgo_ts+1057, uint64(12)) != 0 { - Xsnprintf(tls, bp, uint64(100), __ccgo_ts+1122, VaList(bp+112, int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 1))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 2)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 3))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 4)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 5))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 6)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 7))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 8)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 9))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 10)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 11))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 12)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 13))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 14)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 15))))) + Xsnprintf(tls, bp, uint64(100), __ccgo_ts+1122, VaList(bp+112, int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 1))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 2)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 3))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 4)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 5))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 6)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 7))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 8)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 9))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 10)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 11))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 12)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 13))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 14)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 15))))) } else { - Xsnprintf(tls, bp, uint64(100), __ccgo_ts+1146, VaList(bp+112, int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 1))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 2)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 3))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 4)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 5))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 6)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 7))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 8)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 9))), int32(256)*Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 10)))+Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 11))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 12))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 13))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 14))), Int32FromUint8(*(*uint8)(unsafe.Pointer(a + 15))))) + Xsnprintf(tls, bp, uint64(100), __ccgo_ts+1146, VaList(bp+112, int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 1))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 2)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 3))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 4)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 5))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 6)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 7))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 8)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 9))), int32(256)*Int32FromUint8(**(**uint8)(__ccgo_up(a + 10)))+Int32FromUint8(**(**uint8)(__ccgo_up(a + 11))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 12))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 13))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 14))), Int32FromUint8(**(**uint8)(__ccgo_up(a + 15))))) } /* Replace longest /(^0|:)[:0]{2,}/ with "::" */ v2 = Int32FromInt32(0) @@ -121774,10 +121774,10 @@ func Xinet_ntop(tls *TLS, af int32, a0 uintptr, s uintptr, l Tsocklen_t) (r uint i = v2 max = Int32FromInt32(2) for { - if !((*(*[100]uint8)(unsafe.Pointer(bp)))[i] != 0) { + if !((**(**[100]uint8)(__ccgo_up(bp)))[i] != 0) { break } - if i != 0 && Int32FromUint8((*(*[100]uint8)(unsafe.Pointer(bp)))[i]) != int32(':') { + if i != 0 && Int32FromUint8((**(**[100]uint8)(__ccgo_up(bp)))[i]) != int32(':') { goto _1 } j = Int32FromUint64(Xstrspn(tls, bp+uintptr(i), __ccgo_ts+1176)) @@ -121792,8 +121792,8 @@ func Xinet_ntop(tls *TLS, af int32, a0 uintptr, s uintptr, l Tsocklen_t) (r uint } if max > int32(3) { v3 = Uint8FromUint8(':') - (*(*[100]uint8)(unsafe.Pointer(bp)))[best+int32(1)] = v3 - (*(*[100]uint8)(unsafe.Pointer(bp)))[best] = v3 + (**(**[100]uint8)(__ccgo_up(bp)))[best+int32(1)] = v3 + (**(**[100]uint8)(__ccgo_up(bp)))[best] = v3 Xmemmove(tls, bp+uintptr(best)+uintptr(2), bp+uintptr(best)+uintptr(max), Uint64FromInt32(i-best-max+int32(1))) } if _strlen(tls, bp) < uint64(l) { @@ -121801,10 +121801,10 @@ func Xinet_ntop(tls *TLS, af int32, a0 uintptr, s uintptr, l Tsocklen_t) (r uint return s } default: - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EAFNOSUPPORT) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EAFNOSUPPORT) return uintptr(0) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOSPC) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOSPC) return uintptr(0) } @@ -121844,23 +121844,23 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { j = v3 v = v3 for { - if !(j < int32(3) && BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s + uintptr(j))))-uint32('0') < uint32(10)) != 0) { + if !(j < int32(3) && BoolInt32(uint32(**(**uint8)(__ccgo_up(s + uintptr(j))))-uint32('0') < uint32(10)) != 0) { break } - v = int32(10)*v + Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(j)))) - int32('0') + v = int32(10)*v + Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(j)))) - int32('0') goto _2 _2: ; j = j + 1 } - if j == 0 || j > int32(1) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('0') || v > int32(255) { + if j == 0 || j > int32(1) && Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('0') || v > int32(255) { return 0 } - *(*uint8)(unsafe.Pointer(a + uintptr(i))) = Uint8FromInt32(v) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(j)))) == 0 && i == int32(3) { + **(**uint8)(__ccgo_up(a + uintptr(i))) = Uint8FromInt32(v) + if Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(j)))) == 0 && i == int32(3) { return int32(1) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(j)))) != int32('.') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(j)))) != int32('.') { return 0 } s = s + uintptr(j+int32(1)) @@ -121872,25 +121872,25 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { return 0 } else { if af != int32(PF_INET6) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EAFNOSUPPORT) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EAFNOSUPPORT) return -int32(1) } } - if v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32(':'); v5 { + if v5 = Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32(':'); v5 { s = s + 1 v4 = s } - if v5 && Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) != int32(':') { + if v5 && Int32FromUint8(**(**uint8)(__ccgo_up(v4))) != int32(':') { return 0 } i = 0 for { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32(':') && brk < 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32(':') && brk < 0 { brk = i - (*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[i&int32(7)] = uint16(0) + (**(**[8]Tuint16_t)(__ccgo_up(bp)))[i&int32(7)] = uint16(0) s = s + 1 v4 = s - if !(*(*uint8)(unsafe.Pointer(v4)) != 0) { + if !(**(**uint8)(__ccgo_up(v4)) != 0) { break } if i == int32(7) { @@ -121903,7 +121903,7 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { v = v3 for { if v5 = j < int32(4); v5 { - v9 = _hexval(tls, uint32(*(*uint8)(unsafe.Pointer(s + uintptr(j))))) + v9 = _hexval(tls, uint32(**(**uint8)(__ccgo_up(s + uintptr(j))))) d = v9 } if !(v5 && v9 >= 0) { @@ -121918,20 +121918,20 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { if j == 0 { return 0 } - (*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[i&int32(7)] = Uint16FromInt32(v) - if !(*(*uint8)(unsafe.Pointer(s + uintptr(j))) != 0) && (brk >= 0 || i == int32(7)) { + (**(**[8]Tuint16_t)(__ccgo_up(bp)))[i&int32(7)] = Uint16FromInt32(v) + if !(**(**uint8)(__ccgo_up(s + uintptr(j))) != 0) && (brk >= 0 || i == int32(7)) { break } if i == int32(7) { return 0 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(j)))) != int32(':') { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(j)))) != int32('.') || i < int32(6) && brk < 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(j)))) != int32(':') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(j)))) != int32('.') || i < int32(6) && brk < 0 { return 0 } need_v4 = int32(1) i = i + 1 - (*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[i&int32(7)] = uint16(0) + (**(**[8]Tuint16_t)(__ccgo_up(bp)))[i&int32(7)] = uint16(0) break } s = s + uintptr(j+int32(1)) @@ -121947,7 +121947,7 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { if !(j < int32(7)-i) { break } - (*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[brk+j] = uint16(0) + (**(**[8]Tuint16_t)(__ccgo_up(bp)))[brk+j] = uint16(0) goto _12 _12: ; @@ -121961,10 +121961,10 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { } v4 = a a = a + 1 - *(*uint8)(unsafe.Pointer(v4)) = Uint8FromInt32(Int32FromUint16((*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[j]) >> int32(8)) + **(**uint8)(__ccgo_up(v4)) = Uint8FromInt32(Int32FromUint16((**(**[8]Tuint16_t)(__ccgo_up(bp)))[j]) >> int32(8)) v4 = a a = a + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8((*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[j]) + **(**uint8)(__ccgo_up(v4)) = uint8((**(**[8]Tuint16_t)(__ccgo_up(bp)))[j]) goto _13 _13: ; @@ -122051,15 +122051,15 @@ func X__lookup_ipliteral(tls *TLS, buf uintptr, name uintptr, family int32) (r i return -int32(5) } Xmemcpy(tls, buf+8, bp, uint64(4)) - (*(*Taddress)(unsafe.Pointer(buf))).Ffamily = int32(PF_INET) - (*(*Taddress)(unsafe.Pointer(buf))).Fscopeid = uint32(0) + (**(**Taddress)(__ccgo_up(buf))).Ffamily = int32(PF_INET) + (**(**Taddress)(__ccgo_up(buf))).Fscopeid = uint32(0) return int32(1) } p = Xstrchr(tls, name, int32('%')) scopeid = uint64(0) if p != 0 && int64(p)-int64(name) < int64(64) { Xmemcpy(tls, bp+20, name, Uint64FromInt64(int64(p)-int64(name))) - (*(*[64]uint8)(unsafe.Pointer(bp + 20)))[int64(p)-int64(name)] = uint8(0) + (**(**[64]uint8)(__ccgo_up(bp + 20)))[int64(p)-int64(name)] = uint8(0) name = bp + 20 } if Xinet_pton(tls, int32(PF_INET6), name, bp+4) <= 0 { @@ -122069,17 +122069,17 @@ func X__lookup_ipliteral(tls *TLS, buf uintptr, name uintptr, family int32) (r i return -int32(5) } Xmemcpy(tls, buf+8, bp+4, uint64(16)) - (*(*Taddress)(unsafe.Pointer(buf))).Ffamily = int32(PF_INET6) + (**(**Taddress)(__ccgo_up(buf))).Ffamily = int32(PF_INET6) if p != 0 { p = p + 1 v1 = p - if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(v1)))-uint32('0') < uint32(10)) != 0 { + if BoolInt32(uint32(**(**uint8)(__ccgo_up(v1)))-uint32('0') < uint32(10)) != 0 { scopeid = Xstrtoull(tls, p, bp+88, int32(10)) } else { - *(*uintptr)(unsafe.Pointer(bp + 88)) = p - uintptr(1) + **(**uintptr)(__ccgo_up(bp + 88)) = p - uintptr(1) } - if *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 88)))) != 0 { - if !(Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(bp + 4))) == int32(0xfe) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(bp + 4 + 1)))&int32(0xc0) == int32(0x80)) && !(Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(bp + 4))) == int32(0xff) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(bp + 4 + 1)))&int32(0xf) == int32(0x2)) { + if **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 88)))) != 0 { + if !(Int32FromUint8(**(**Tuint8_t)(__ccgo_up(bp + 4))) == int32(0xfe) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(bp + 4 + 1)))&int32(0xc0) == int32(0x80)) && !(Int32FromUint8(**(**Tuint8_t)(__ccgo_up(bp + 4))) == int32(0xff) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(bp + 4 + 1)))&int32(0xf) == int32(0x2)) { return -int32(2) } scopeid = uint64(Xif_nametoindex(tls, p)) @@ -122091,7 +122091,7 @@ func X__lookup_ipliteral(tls *TLS, buf uintptr, name uintptr, family int32) (r i return -int32(2) } } - (*(*Taddress)(unsafe.Pointer(buf))).Fscopeid = uint32(scopeid) + (**(**Taddress)(__ccgo_up(buf))).Fscopeid = uint32(scopeid) return int32(1) } @@ -122115,7 +122115,7 @@ func _is_valid_hostname(tls *TLS, host uintptr) (r int32) { } s = host for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) >= int32(0x80) || Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('.') || Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('-') || Xisalnum(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))) != 0) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(s))) >= int32(0x80) || Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('.') || Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('-') || Xisalnum(tls, Int32FromUint8(**(**uint8)(__ccgo_up(s)))) != 0) { break } goto _1 @@ -122123,7 +122123,7 @@ func _is_valid_hostname(tls *TLS, host uintptr) (r int32) { ; s = s + 1 } - return BoolInt32(!(*(*uint8)(unsafe.Pointer(s)) != 0)) + return BoolInt32(!(**(**uint8)(__ccgo_up(s)) != 0)) } func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags int32) (r int32) { @@ -122137,14 +122137,14 @@ func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags in if family != int32(PF_INET6) { v1 = cnt cnt = cnt + 1 - *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ + **(**Taddress)(__ccgo_up(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET), } } if family != int32(PF_INET) { v1 = cnt cnt = cnt + 1 - *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ + **(**Taddress)(__ccgo_up(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET6), } } @@ -122152,7 +122152,7 @@ func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags in if family != int32(PF_INET6) { v1 = cnt cnt = cnt + 1 - *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ + **(**Taddress)(__ccgo_up(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET), Faddr: [16]Tuint8_t{ 0: uint8(127), @@ -122163,7 +122163,7 @@ func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags in if family != int32(PF_INET) { v1 = cnt cnt = cnt + 1 - *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ + **(**Taddress)(__ccgo_up(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET6), Faddr: [16]Tuint8_t{ 15: uint8(1), @@ -122195,7 +122195,7 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family have_canon = 0 f = X__fopen_rb_ca(tls, __ccgo_ts+1046, bp+1544, bp+512, uint64(1032)) if !(f != 0) { - switch *(*int32)(unsafe.Pointer(X__errno_location(tls))) { + switch **(**int32)(__ccgo_up(X__errno_location(tls))) { case int32(ENOENT): fallthrough case int32(ENOTDIR): @@ -122212,21 +122212,21 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family if v1 != 0 { v2 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8('\n') - *(*uint8)(unsafe.Pointer(p)) = Uint8FromInt32(0) + **(**uint8)(__ccgo_up(v2)) = uint8('\n') + **(**uint8)(__ccgo_up(p)) = Uint8FromInt32(0) } p = bp + uintptr(1) for { v1 = Xstrstr(tls, p, name) p = v1 if v12 = v1 != 0; v12 { - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) + v5 = Int32FromUint8(**(**uint8)(__ccgo_up(p + uintptr(-Int32FromInt32(1))))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _7 _7: ; if v11 = !(v6 != 0); !v11 { - v8 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(l)))) + v8 = Int32FromUint8(**(**uint8)(__ccgo_up(p + uintptr(l)))) v9 = BoolInt32(v8 == int32(' ') || Uint32FromInt32(v8)-uint32('\t') < uint32(5)) goto _10 _10: @@ -122246,8 +122246,8 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family /* Isolate IP address to parse */ p = bp for { - if v11 = *(*uint8)(unsafe.Pointer(p)) != 0; v11 { - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + if v11 = **(**uint8)(__ccgo_up(p)) != 0; v11 { + v5 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _16 _16: @@ -122262,7 +122262,7 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family } v1 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) switch _name_from_numeric(tls, buf+uintptr(cnt)*28, bp, family) { case int32(1): cnt = cnt + 1 @@ -122277,8 +122277,8 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family } /* Extract first name as canonical name */ for { - if v11 = *(*uint8)(unsafe.Pointer(p)) != 0; v11 { - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + if v11 = **(**uint8)(__ccgo_up(p)) != 0; v11 { + v5 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _22 _22: @@ -122293,8 +122293,8 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family } z = p for { - if v11 = *(*uint8)(unsafe.Pointer(z)) != 0; v11 { - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(z))) + if v11 = **(**uint8)(__ccgo_up(z)) != 0; v11 { + v5 = Int32FromUint8(**(**uint8)(__ccgo_up(z))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _27 _27: @@ -122307,7 +122307,7 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family ; z = z + 1 } - *(*uint8)(unsafe.Pointer(z)) = uint8(0) + **(**uint8)(__ccgo_up(z)) = uint8(0) if _is_valid_hostname(tls, p) != 0 { have_canon = int32(1) Xmemcpy(tls, canon, p, Uint64FromInt64(int64(z)-int64(p)+int64(1))) @@ -122362,8 +122362,8 @@ func _dns_parse_callback1(tls *TLS, c uintptr, rr int32, data uintptr, len1 int3 family = int32(PF_INET6) break } - (*(*Taddress)(unsafe.Pointer((*Tdpc_ctx)(unsafe.Pointer(ctx)).Faddrs + uintptr((*Tdpc_ctx)(unsafe.Pointer(ctx)).Fcnt)*28))).Ffamily = family - (*(*Taddress)(unsafe.Pointer((*Tdpc_ctx)(unsafe.Pointer(ctx)).Faddrs + uintptr((*Tdpc_ctx)(unsafe.Pointer(ctx)).Fcnt)*28))).Fscopeid = uint32(0) + (**(**Taddress)(__ccgo_up((*Tdpc_ctx)(unsafe.Pointer(ctx)).Faddrs + uintptr((*Tdpc_ctx)(unsafe.Pointer(ctx)).Fcnt)*28))).Ffamily = family + (**(**Taddress)(__ccgo_up((*Tdpc_ctx)(unsafe.Pointer(ctx)).Faddrs + uintptr((*Tdpc_ctx)(unsafe.Pointer(ctx)).Fcnt)*28))).Fscopeid = uint32(0) v2 = ctx + 16 v1 = *(*int32)(unsafe.Pointer(v2)) *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) + 1 @@ -122384,16 +122384,16 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i var _ /* qlens at bp+10192 */ [2]int32 var _ /* qp at bp+10160 */ [2]uintptr _, _, _ = i, nq, qtypes - *(*[2]uintptr)(unsafe.Pointer(bp + 10160)) = [2]uintptr{ + **(**[2]uintptr)(__ccgo_up(bp + 10160)) = [2]uintptr{ 0: bp, 1: bp + 1*280, } - *(*[2]uintptr)(unsafe.Pointer(bp + 10176)) = [2]uintptr{ + **(**[2]uintptr)(__ccgo_up(bp + 10176)) = [2]uintptr{ 0: bp + 560, 1: bp + 560 + 1*4800, } nq = 0 - *(*Tdpc_ctx)(unsafe.Pointer(bp + 10208)) = Tdpc_ctx{ + **(**Tdpc_ctx)(__ccgo_up(bp + 10208)) = Tdpc_ctx{ Faddrs: buf, Fcanon: canon, } @@ -122403,15 +122403,15 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i break } if family != _afrr[i].Faf { - (*(*[2]int32)(unsafe.Pointer(bp + 10192)))[nq] = X__res_mkquery(tls, 0, name, int32(1), _afrr[i].Frr, uintptr(0), 0, uintptr(0), bp+uintptr(nq)*280, int32(280)) - if (*(*[2]int32)(unsafe.Pointer(bp + 10192)))[nq] == -int32(1) { + (**(**[2]int32)(__ccgo_up(bp + 10192)))[nq] = X__res_mkquery(tls, 0, name, int32(1), _afrr[i].Frr, uintptr(0), 0, uintptr(0), bp+uintptr(nq)*280, int32(280)) + if (**(**[2]int32)(__ccgo_up(bp + 10192)))[nq] == -int32(1) { return 0 } qtypes[nq] = _afrr[i].Frr - *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280 + 3)) = uint8(0) /* don't need AD flag */ + **(**uint8)(__ccgo_up(bp + uintptr(nq)*280 + 3)) = uint8(0) /* don't need AD flag */ /* Ensure query IDs are distinct. */ - if nq != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) { - *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280)) = *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280)) + 1 + if nq != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(bp + uintptr(nq)*280))) == Int32FromUint8(**(**uint8)(__ccgo_up(bp))) { + **(**uint8)(__ccgo_up(bp + uintptr(nq)*280)) = **(**uint8)(__ccgo_up(bp + uintptr(nq)*280)) + 1 } nq = nq + 1 } @@ -122428,13 +122428,13 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if !(i < nq) { break } - if (*(*[2]int32)(unsafe.Pointer(bp + 10200)))[i] < int32(4) || Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + 560 + uintptr(i)*4800 + 3)))&int32(15) == int32(2) { + if (**(**[2]int32)(__ccgo_up(bp + 10200)))[i] < int32(4) || Int32FromUint8(**(**uint8)(__ccgo_up(bp + 560 + uintptr(i)*4800 + 3)))&int32(15) == int32(2) { return -int32(3) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + 560 + uintptr(i)*4800 + 3)))&int32(15) == int32(3) { + if Int32FromUint8(**(**uint8)(__ccgo_up(bp + 560 + uintptr(i)*4800 + 3)))&int32(15) == int32(3) { return 0 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + 560 + uintptr(i)*4800 + 3)))&int32(15) != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(bp + 560 + uintptr(i)*4800 + 3)))&int32(15) != 0 { return -int32(4) } goto _2 @@ -122447,18 +122447,18 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if !(i >= 0) { break } - (*(*Tdpc_ctx)(unsafe.Pointer(bp + 10208))).Frrtype = qtypes[i] - if Uint64FromInt32((*(*[2]int32)(unsafe.Pointer(bp + 10200)))[i]) > uint64(4800) { - (*(*[2]int32)(unsafe.Pointer(bp + 10200)))[i] = int32(4800) + (**(**Tdpc_ctx)(__ccgo_up(bp + 10208))).Frrtype = qtypes[i] + if Uint64FromInt32((**(**[2]int32)(__ccgo_up(bp + 10200)))[i]) > uint64(4800) { + (**(**[2]int32)(__ccgo_up(bp + 10200)))[i] = int32(4800) } - X__dns_parse(tls, bp+560+uintptr(i)*4800, (*(*[2]int32)(unsafe.Pointer(bp + 10200)))[i], __ccgo_fp(_dns_parse_callback1), bp+10208) + X__dns_parse(tls, bp+560+uintptr(i)*4800, (**(**[2]int32)(__ccgo_up(bp + 10200)))[i], __ccgo_fp(_dns_parse_callback1), bp+10208) goto _3 _3: ; i = i - 1 } - if (*(*Tdpc_ctx)(unsafe.Pointer(bp + 10208))).Fcnt != 0 { - return (*(*Tdpc_ctx)(unsafe.Pointer(bp + 10208))).Fcnt + if (**(**Tdpc_ctx)(__ccgo_up(bp + 10208))).Fcnt != 0 { + return (**(**Tdpc_ctx)(__ccgo_up(bp + 10208))).Fcnt } return -int32(5) } @@ -122496,10 +122496,10 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f l = v2 dots = v2 for { - if !(*(*uint8)(unsafe.Pointer(name + uintptr(l))) != 0) { + if !(**(**uint8)(__ccgo_up(name + uintptr(l))) != 0) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(name + uintptr(l)))) == int32('.') { + if Int32FromUint8(**(**uint8)(__ccgo_up(name + uintptr(l)))) == int32('.') { dots = dots + 1 } goto _1 @@ -122507,14 +122507,14 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f ; l = l + 1 } - if dots >= uint64((*(*Tresolvconf)(unsafe.Pointer(bp + 256))).Fndots) || Int32FromUint8(*(*uint8)(unsafe.Pointer(name + uintptr(l-uint64(1))))) == int32('.') { - *(*uint8)(unsafe.Pointer(bp)) = uint8(0) + if dots >= uint64((**(**Tresolvconf)(__ccgo_up(bp + 256))).Fndots) || Int32FromUint8(**(**uint8)(__ccgo_up(name + uintptr(l-uint64(1))))) == int32('.') { + **(**uint8)(__ccgo_up(bp)) = uint8(0) } /* Strip final dot for canon, fail if multiple trailing dots. */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(name + uintptr(l-uint64(1))))) == int32('.') { + if Int32FromUint8(**(**uint8)(__ccgo_up(name + uintptr(l-uint64(1))))) == int32('.') { l = l - 1 } - if !(l != 0) || Int32FromUint8(*(*uint8)(unsafe.Pointer(name + uintptr(l-uint64(1))))) == int32('.') { + if !(l != 0) || Int32FromUint8(**(**uint8)(__ccgo_up(name + uintptr(l-uint64(1))))) == int32('.') { return -int32(2) } /* This can never happen; the caller already checked length. */ @@ -122526,14 +122526,14 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f * name is not a CNAME record) and serves as a buffer for passing * the full requested name to name_from_dns. */ Xmemcpy(tls, canon, name, l) - *(*uint8)(unsafe.Pointer(canon + uintptr(l))) = uint8('.') + **(**uint8)(__ccgo_up(canon + uintptr(l))) = uint8('.') p = bp for { - if !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if !(**(**uint8)(__ccgo_up(p)) != 0) { break } for { - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v5 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _7 _7: @@ -122547,8 +122547,8 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f } z = p for { - if v12 = *(*uint8)(unsafe.Pointer(z)) != 0; v12 { - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(z))) + if v12 = **(**uint8)(__ccgo_up(z)) != 0; v12 { + v5 = Int32FromUint8(**(**uint8)(__ccgo_up(z))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _11 _11: @@ -122566,7 +122566,7 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f } if Uint64FromInt64(int64(z)-int64(p)) < uint64(256)-l-uint64(1) { Xmemcpy(tls, canon+uintptr(l)+uintptr(1), p, Uint64FromInt64(int64(z)-int64(p))) - *(*uint8)(unsafe.Pointer(canon + uintptr(Uint64FromInt64(int64(z)-int64(p)+int64(1))+l))) = uint8(0) + **(**uint8)(__ccgo_up(canon + uintptr(Uint64FromInt64(int64(z)-int64(p)+int64(1))+l))) = uint8(0) cnt = _name_from_dns(tls, buf, canon, canon, family, bp+256) if cnt != 0 { return cnt @@ -122577,7 +122577,7 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f ; p = z } - *(*uint8)(unsafe.Pointer(canon + uintptr(l))) = uint8(0) + **(**uint8)(__ccgo_up(canon + uintptr(l))) = uint8(0) return _name_from_dns(tls, buf, canon, name, family, bp+256) } @@ -122638,7 +122638,7 @@ func _policyof(tls *TLS, a uintptr) (r uintptr) { if Xmemcmp(tls, a, uintptr(unsafe.Pointer(&_defpolicy))+uintptr(i)*20, uint64(_defpolicy[i].Flen1)) != 0 { goto _1 } - if Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + uintptr(_defpolicy[i].Flen1))))&Int32FromUint8(_defpolicy[i].Fmask) != Int32FromUint8(*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_defpolicy)) + uintptr(i)*20 + uintptr(_defpolicy[i].Flen1)))) { + if Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + uintptr(_defpolicy[i].Flen1))))&Int32FromUint8(_defpolicy[i].Fmask) != Int32FromUint8(**(**uint8)(__ccgo_up(uintptr(unsafe.Pointer(&_defpolicy)) + uintptr(i)*20 + uintptr(_defpolicy[i].Flen1)))) { goto _1 } return uintptr(unsafe.Pointer(&_defpolicy)) + uintptr(i)*20 @@ -122655,16 +122655,16 @@ func _labelof(tls *TLS, a uintptr) (r int32) { } func _scopeof(tls *TLS, a uintptr) (r int32) { - if Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a))) == int32(0xff) { - return Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 1))) & int32(15) + if Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a))) == int32(0xff) { + return Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 1))) & int32(15) } - if Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a))) == int32(0xfe) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 1)))&int32(0xc0) == int32(0x80) { + if Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a))) == int32(0xfe) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 1)))&int32(0xc0) == int32(0x80) { return int32(2) } - if *(*Tuint32_t)(unsafe.Pointer(a)) == uint32(0) && *(*Tuint32_t)(unsafe.Pointer(a + 1*4)) == uint32(0) && *(*Tuint32_t)(unsafe.Pointer(a + 2*4)) == uint32(0) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 12))) == 0 && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 13))) == 0 && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 14))) == 0 && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 15))) == int32(1) { + if **(**Tuint32_t)(__ccgo_up(a)) == uint32(0) && **(**Tuint32_t)(__ccgo_up(a + 1*4)) == uint32(0) && **(**Tuint32_t)(__ccgo_up(a + 2*4)) == uint32(0) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 12))) == 0 && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 13))) == 0 && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 14))) == 0 && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 15))) == int32(1) { return int32(2) } - if Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a))) == int32(0xfe) && Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(a + 1)))&int32(0xc0) == int32(0xc0) { + if Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a))) == int32(0xfe) && Int32FromUint8(**(**Tuint8_t)(__ccgo_up(a + 1)))&int32(0xc0) == int32(0xc0) { return int32(5) } return int32(14) @@ -122675,7 +122675,7 @@ func _prefixmatch(tls *TLS, s uintptr, d uintptr) (r int32) { _ = i i = uint32(0) for { - if !(i < uint32(128) && !((Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(s + uintptr(i/uint32(8)))))^Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(d + uintptr(i/uint32(8))))))&(Int32FromInt32(128)>>(i%Uint32FromInt32(8))) != 0)) { + if !(i < uint32(128) && !((Int32FromUint8(**(**Tuint8_t)(__ccgo_up(s + uintptr(i/uint32(8)))))^Int32FromUint8(**(**Tuint8_t)(__ccgo_up(d + uintptr(i/uint32(8))))))&(Int32FromInt32(128)>>(i%Uint32FromInt32(8))) != 0)) { break } goto _1 @@ -122713,7 +122713,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i var _ /* salen at bp+92 */ Tsocklen_t _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cnt, da, dalen, dlabel, dpolicy, dprec, dscope, family1, fd, i, j, key, l, prefixlen, sa, v1 cnt = 0 - *(*uint8)(unsafe.Pointer(canon)) = uint8(0) + **(**uint8)(__ccgo_up(canon)) = uint8(0) if name != 0 { /* reject empty name and check len so it fits into temp bufs */ l = Xstrnlen(tls, name, uint64(255)) @@ -122757,7 +122757,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i /* If any v6 results exist, remove v4 results. */ i = 0 for { - if !(i < cnt && (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily != int32(PF_INET6)) { + if !(i < cnt && (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Ffamily != int32(PF_INET6)) { break } goto _2 @@ -122771,10 +122771,10 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if !(i < cnt) { break } - if (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily == int32(PF_INET6) { + if (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Ffamily == int32(PF_INET6) { v1 = j j = j + 1 - *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = *(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28)) + **(**Taddress)(__ccgo_up(buf + uintptr(v1)*28)) = **(**Taddress)(__ccgo_up(buf + uintptr(i)*28)) } goto _3 _3: @@ -122792,12 +122792,12 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if !(i < cnt) { break } - if (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily != int32(PF_INET) { + if (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Ffamily != int32(PF_INET) { goto _6 } Xmemcpy(tls, buf+uintptr(i)*28+8+uintptr(12), buf+uintptr(i)*28+8, uint64(4)) Xmemcpy(tls, buf+uintptr(i)*28+8, __ccgo_ts+1057, uint64(12)) - (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily = int32(PF_INET6) + (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Ffamily = int32(PF_INET6) goto _6 _6: ; @@ -122814,7 +122814,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if !(i < cnt) { break } - if (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily != int32(PF_INET) { + if (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Ffamily != int32(PF_INET) { break } goto _7 @@ -122836,16 +122836,16 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if !(i < cnt) { break } - family1 = (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily + family1 = (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Ffamily key = 0 - *(*Tsockaddr_in6)(unsafe.Pointer(bp + 4)) = Tsockaddr_in6{} - *(*Tsockaddr_in6)(unsafe.Pointer(bp + 32)) = Tsockaddr_in6{ + **(**Tsockaddr_in6)(__ccgo_up(bp + 4)) = Tsockaddr_in6{} + **(**Tsockaddr_in6)(__ccgo_up(bp + 32)) = Tsockaddr_in6{ Fsin6_family: uint16(PF_INET6), Fsin6_port: uint16(65535), - Fsin6_scope_id: (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Fscopeid, + Fsin6_scope_id: (**(**Taddress)(__ccgo_up(buf + uintptr(i)*28))).Fscopeid, } - *(*Tsockaddr_in)(unsafe.Pointer(bp + 60)) = Tsockaddr_in{} - *(*Tsockaddr_in)(unsafe.Pointer(bp + 76)) = Tsockaddr_in{ + **(**Tsockaddr_in)(__ccgo_up(bp + 60)) = Tsockaddr_in{} + **(**Tsockaddr_in)(__ccgo_up(bp + 76)) = Tsockaddr_in{ Fsin_family: uint16(PF_INET), Fsin_port: uint16(65535), } @@ -122854,7 +122854,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i da = bp + 32 dalen = uint32(28) sa = bp + 4 - *(*Tsocklen_t)(unsafe.Pointer(bp + 92)) = uint32(28) + **(**Tsocklen_t)(__ccgo_up(bp + 92)) = uint32(28) } else { Xmemcpy(tls, bp+4+8, __ccgo_ts+1057, uint64(12)) Xmemcpy(tls, bp+32+8+uintptr(12), buf+uintptr(i)*28+8, uint64(4)) @@ -122864,7 +122864,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i da = bp + 76 dalen = uint32(16) sa = bp + 60 - *(*Tsocklen_t)(unsafe.Pointer(bp + 92)) = uint32(16) + **(**Tsocklen_t)(__ccgo_up(bp + 92)) = uint32(16) } dpolicy = _policyof(tls, bp+32+8) dscope = _scopeof(tls, bp+32+8) @@ -122894,14 +122894,14 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i key = key | (int32(15)-dscope)< uint64(65535) { return -int32(8) } if proto != int32(IPPROTO_UDP) { - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fport = uint16(port) - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_STREAM) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fport = uint16(port) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_STREAM) v1 = cnt cnt = cnt + 1 - (*(*Tservice)(unsafe.Pointer(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_TCP) + (**(**Tservice)(__ccgo_up(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_TCP) } if proto != int32(IPPROTO_TCP) { - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fport = uint16(port) - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_DGRAM) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fport = uint16(port) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_DGRAM) v1 = cnt cnt = cnt + 1 - (*(*Tservice)(unsafe.Pointer(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_UDP) + (**(**Tservice)(__ccgo_up(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_UDP) } return cnt } @@ -122987,7 +122987,7 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i l = _strlen(tls, name) f = X__fopen_rb_ca(tls, __ccgo_ts+1070, bp+1168, bp+136, uint64(1032)) if !(f != 0) { - switch *(*int32)(unsafe.Pointer(X__errno_location(tls))) { + switch **(**int32)(__ccgo_up(X__errno_location(tls))) { case int32(ENOENT): fallthrough case int32(ENOTDIR): @@ -123004,8 +123004,8 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i if v3 != 0 { v4 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8('\n') - *(*uint8)(unsafe.Pointer(p)) = Uint8FromInt32(0) + **(**uint8)(__ccgo_up(v4)) = uint8('\n') + **(**uint8)(__ccgo_up(p)) = Uint8FromInt32(0) } /* Find service name */ p = bp @@ -123016,7 +123016,7 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i break } if v10 = p > bp; v10 { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(p + uintptr(-Int32FromInt32(1))))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _9 _9: @@ -123024,8 +123024,8 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i if v10 && !(v2 != 0) { goto _5 } - if v10 = *(*uint8)(unsafe.Pointer(p + uintptr(l))) != 0; v10 { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(l)))) + if v10 = **(**uint8)(__ccgo_up(p + uintptr(l))) != 0; v10 { + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(p + uintptr(l)))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _13 _13: @@ -123045,8 +123045,8 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i /* Skip past canonical name at beginning of line */ p = bp for { - if v10 = *(*uint8)(unsafe.Pointer(p)) != 0; v10 { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + if v10 = **(**uint8)(__ccgo_up(p)) != 0; v10 { + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _18 _18: @@ -123060,28 +123060,28 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i p = p + 1 } port = Xstrtoul(tls, p, bp+128, int32(10)) - if port > uint64(65535) || *(*uintptr)(unsafe.Pointer(bp + 128)) == p { + if port > uint64(65535) || **(**uintptr)(__ccgo_up(bp + 128)) == p { continue } - if !(Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(bp + 128)), __ccgo_ts+1084, uint64(4)) != 0) { + if !(Xstrncmp(tls, **(**uintptr)(__ccgo_up(bp + 128)), __ccgo_ts+1084, uint64(4)) != 0) { if proto == int32(IPPROTO_TCP) { continue } - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fport = uint16(port) - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_DGRAM) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fport = uint16(port) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_DGRAM) v1 = cnt cnt = cnt + 1 - (*(*Tservice)(unsafe.Pointer(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_UDP) + (**(**Tservice)(__ccgo_up(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_UDP) } - if !(Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(bp + 128)), __ccgo_ts+1089, uint64(4)) != 0) { + if !(Xstrncmp(tls, **(**uintptr)(__ccgo_up(bp + 128)), __ccgo_ts+1089, uint64(4)) != 0) { if proto == int32(IPPROTO_UDP) { continue } - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fport = uint16(port) - (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_STREAM) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fport = uint16(port) + (**(**Tservice)(__ccgo_up(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_STREAM) v1 = cnt cnt = cnt + 1 - (*(*Tservice)(unsafe.Pointer(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_TCP) + (**(**Tservice)(__ccgo_up(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_TCP) } } X__fclose_ca(tls, f) @@ -123111,58 +123111,58 @@ func ___netlink_enumerate(tls *TLS, fd int32, seq uint32, type1 int32, af int32, (*(*struct { Fnlh Tnlmsghdr Fg Trtgenmsg - })(unsafe.Pointer(&*(*struct { + })(unsafe.Pointer(&**(**struct { Freq [0]struct { Fnlh Tnlmsghdr Fg Trtgenmsg } Freply [0]Tnlmsghdr Fbuf [8192]Tuint8_t - })(unsafe.Pointer(bp))))).Fnlh.Fnlmsg_len = uint32(20) + })(__ccgo_up(bp))))).Fnlh.Fnlmsg_len = uint32(20) (*(*struct { Fnlh Tnlmsghdr Fg Trtgenmsg - })(unsafe.Pointer(&*(*struct { + })(unsafe.Pointer(&**(**struct { Freq [0]struct { Fnlh Tnlmsghdr Fg Trtgenmsg } Freply [0]Tnlmsghdr Fbuf [8192]Tuint8_t - })(unsafe.Pointer(bp))))).Fnlh.Fnlmsg_type = Uint16FromInt32(type1) + })(__ccgo_up(bp))))).Fnlh.Fnlmsg_type = Uint16FromInt32(type1) (*(*struct { Fnlh Tnlmsghdr Fg Trtgenmsg - })(unsafe.Pointer(&*(*struct { + })(unsafe.Pointer(&**(**struct { Freq [0]struct { Fnlh Tnlmsghdr Fg Trtgenmsg } Freply [0]Tnlmsghdr Fbuf [8192]Tuint8_t - })(unsafe.Pointer(bp))))).Fnlh.Fnlmsg_flags = Uint16FromInt32(Int32FromInt32(NLM_F_ROOT) | Int32FromInt32(NLM_F_MATCH) | Int32FromInt32(NLM_F_REQUEST)) + })(__ccgo_up(bp))))).Fnlh.Fnlmsg_flags = Uint16FromInt32(Int32FromInt32(NLM_F_ROOT) | Int32FromInt32(NLM_F_MATCH) | Int32FromInt32(NLM_F_REQUEST)) (*(*struct { Fnlh Tnlmsghdr Fg Trtgenmsg - })(unsafe.Pointer(&*(*struct { + })(unsafe.Pointer(&**(**struct { Freq [0]struct { Fnlh Tnlmsghdr Fg Trtgenmsg } Freply [0]Tnlmsghdr Fbuf [8192]Tuint8_t - })(unsafe.Pointer(bp))))).Fnlh.Fnlmsg_seq = seq + })(__ccgo_up(bp))))).Fnlh.Fnlmsg_seq = seq (*(*struct { Fnlh Tnlmsghdr Fg Trtgenmsg - })(unsafe.Pointer(&*(*struct { + })(unsafe.Pointer(&**(**struct { Freq [0]struct { Fnlh Tnlmsghdr Fg Trtgenmsg } Freply [0]Tnlmsghdr Fbuf [8192]Tuint8_t - })(unsafe.Pointer(bp))))).Fg.Frtgen_family = Uint8FromInt32(af) + })(__ccgo_up(bp))))).Fg.Frtgen_family = Uint8FromInt32(af) r = int32(Xsend(tls, fd, bp, uint64(20), 0)) if r < 0 { return r @@ -123238,7 +123238,7 @@ func Xns_get16(tls *TLS, cp uintptr) (r uint32) { trc("tls=%v cp=%v, (%v:)", tls, cp, origin(2)) defer func() { trc("-> %v", r) }() } - return Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(cp)))< %v", r) }() } - return uint64(uint32(*(*uint8)(unsafe.Pointer(cp)))<> int32(8)) + **(**uint8)(__ccgo_up(v1)) = uint8(s >> int32(8)) v1 = cp cp = cp + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(s) + **(**uint8)(__ccgo_up(v1)) = uint8(s) } func Xns_put32(tls *TLS, l uint64, cp uintptr) { @@ -123271,16 +123271,16 @@ func Xns_put32(tls *TLS, l uint64, cp uintptr) { _ = v1 v1 = cp cp = cp + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(l >> int32(24)) + **(**uint8)(__ccgo_up(v1)) = uint8(l >> int32(24)) v1 = cp cp = cp + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(l >> int32(16)) + **(**uint8)(__ccgo_up(v1)) = uint8(l >> int32(16)) v1 = cp cp = cp + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(l >> int32(8)) + **(**uint8)(__ccgo_up(v1)) = uint8(l >> int32(8)) v1 = cp cp = cp + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(l) + **(**uint8)(__ccgo_up(v1)) = uint8(l) } func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int32) { @@ -123305,7 +123305,7 @@ func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int3 break } msg = msg + uintptr(2) - *(*Tuint16_t)(unsafe.Pointer(handle + 20 + uintptr(i)*2)) = uint16(Xns_get16(tls, msg-uintptr(2))) + **(**Tuint16_t)(__ccgo_up(handle + 20 + uintptr(i)*2)) = uint16(Xns_get16(tls, msg-uintptr(2))) goto _1 _1: ; @@ -123316,15 +123316,15 @@ func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int3 if !(i < int32(_ns_s_max)) { break } - if *(*Tuint16_t)(unsafe.Pointer(handle + 20 + uintptr(i)*2)) != 0 { - *(*uintptr)(unsafe.Pointer(handle + 32 + uintptr(i)*8)) = msg - r = Xns_skiprr(tls, msg, (*Tns_msg)(unsafe.Pointer(handle)).F_eom, i, Int32FromUint16(*(*Tuint16_t)(unsafe.Pointer(handle + 20 + uintptr(i)*2)))) + if **(**Tuint16_t)(__ccgo_up(handle + 20 + uintptr(i)*2)) != 0 { + **(**uintptr)(__ccgo_up(handle + 32 + uintptr(i)*8)) = msg + r = Xns_skiprr(tls, msg, (*Tns_msg)(unsafe.Pointer(handle)).F_eom, i, Int32FromUint16(**(**Tuint16_t)(__ccgo_up(handle + 20 + uintptr(i)*2)))) if r < 0 { return -int32(1) } msg = msg + uintptr(r) } else { - *(*uintptr)(unsafe.Pointer(handle + 32 + uintptr(i)*8)) = UintptrFromInt32(0) + **(**uintptr)(__ccgo_up(handle + 32 + uintptr(i)*8)) = UintptrFromInt32(0) } goto _2 _2: @@ -123341,7 +123341,7 @@ func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int3 goto bad bad: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EMSGSIZE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EMSGSIZE) return -int32(1) } @@ -123385,7 +123385,7 @@ func Xns_skiprr(tls *TLS, ptr uintptr, eom uintptr, section Tns_sect, count int3 goto bad bad: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EMSGSIZE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EMSGSIZE) return -int32(1) } @@ -123403,31 +123403,31 @@ func Xns_parserr(tls *TLS, handle uintptr, section Tns_sect, rrnum int32, rr uin if section != (*Tns_msg)(unsafe.Pointer(handle)).F_sect { (*Tns_msg)(unsafe.Pointer(handle)).F_sect = section (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum = 0 - (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr = *(*uintptr)(unsafe.Pointer(handle + 32 + uintptr(section)*8)) + (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr = **(**uintptr)(__ccgo_up(handle + 32 + uintptr(section)*8)) } if rrnum == -int32(1) { rrnum = (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum } - if rrnum < 0 || rrnum >= Int32FromUint16(*(*Tuint16_t)(unsafe.Pointer(handle + 20 + uintptr(section)*2))) { + if rrnum < 0 || rrnum >= Int32FromUint16(**(**Tuint16_t)(__ccgo_up(handle + 20 + uintptr(section)*2))) { goto bad } if rrnum < (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum { (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum = 0 - (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr = *(*uintptr)(unsafe.Pointer(handle + 32 + uintptr(section)*8)) + (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr = **(**uintptr)(__ccgo_up(handle + 32 + uintptr(section)*8)) } if rrnum > (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum { r = Xns_skiprr(tls, (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr, (*Tns_msg)(unsafe.Pointer(handle)).F_eom, section, rrnum-(*Tns_msg)(unsafe.Pointer(handle)).F_rrnum) if r < 0 { return -int32(1) } - *(*uintptr)(unsafe.Pointer(handle + 72)) += uintptr(r) + **(**uintptr)(__ccgo_up(handle + 72)) += uintptr(r) (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum = rrnum } r = Xns_name_uncompress(tls, (*Tns_msg)(unsafe.Pointer(handle)).F_msg, (*Tns_msg)(unsafe.Pointer(handle)).F_eom, (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr, rr, uint64(NS_MAXDNAME)) if r < 0 { return -int32(1) } - *(*uintptr)(unsafe.Pointer(handle + 72)) += uintptr(r) + **(**uintptr)(__ccgo_up(handle + 72)) += uintptr(r) if int64(Int32FromInt32(2)*Int32FromInt32(NS_INT16SZ)) > int64((*Tns_msg)(unsafe.Pointer(handle)).F_eom)-int64((*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr) { goto size } @@ -123451,14 +123451,14 @@ func Xns_parserr(tls *TLS, handle uintptr, section Tns_sect, rrnum int32, rr uin goto size } (*Tns_rr)(unsafe.Pointer(rr)).Frdata = (*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr - *(*uintptr)(unsafe.Pointer(handle + 72)) += uintptr((*Tns_rr)(unsafe.Pointer(rr)).Frdlength) + **(**uintptr)(__ccgo_up(handle + 72)) += uintptr((*Tns_rr)(unsafe.Pointer(rr)).Frdlength) } else { (*Tns_rr)(unsafe.Pointer(rr)).Fttl = uint32(0) (*Tns_rr)(unsafe.Pointer(rr)).Frdlength = uint16(0) (*Tns_rr)(unsafe.Pointer(rr)).Frdata = UintptrFromInt32(0) } (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum = (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum + 1 - if (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum > Int32FromUint16(*(*Tuint16_t)(unsafe.Pointer(handle + 20 + uintptr(section)*2))) { + if (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum > Int32FromUint16(**(**Tuint16_t)(__ccgo_up(handle + 20 + uintptr(section)*2))) { (*Tns_msg)(unsafe.Pointer(handle)).F_sect = section + int32(1) if (*Tns_msg)(unsafe.Pointer(handle)).F_sect == int32(_ns_s_max) { (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum = -int32(1) @@ -123471,12 +123471,12 @@ func Xns_parserr(tls *TLS, handle uintptr, section Tns_sect, rrnum int32, rr uin goto bad bad: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENODEV) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENODEV) return -int32(1) goto size size: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EMSGSIZE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EMSGSIZE) return -int32(1) } @@ -123489,7 +123489,7 @@ func Xns_name_uncompress(tls *TLS, msg uintptr, eom uintptr, src uintptr, dst ui _ = r r = Xdn_expand(tls, msg, eom, src, dst, Int32FromUint64(dstsiz)) if r < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EMSGSIZE) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EMSGSIZE) } return r } @@ -123758,9 +123758,9 @@ func X__convert_scm_timestamps(tls *TLS, msg uintptr, csize Tsocklen_t) { common: ; Xmemcpy(tls, bp, cmsg+UintptrFromInt32(1)*16, uint64(8)) - (*(*[2]int64)(unsafe.Pointer(bp + 8)))[0] = *(*int64)(unsafe.Pointer(bp)) + (**(**[2]int64)(__ccgo_up(bp + 8)))[0] = int64(**(**int64)(__ccgo_up(bp))) Xmemcpy(tls, bp, cmsg+UintptrFromInt32(1)*16+uintptr(8), uint64(8)) - (*(*[2]int64)(unsafe.Pointer(bp + 8)))[int32(1)] = *(*int64)(unsafe.Pointer(bp)) + (**(**[2]int64)(__ccgo_up(bp + 8)))[int32(1)] = int64(**(**int64)(__ccgo_up(bp))) goto _5 _5: } @@ -123779,7 +123779,7 @@ func X__convert_scm_timestamps(tls *TLS, msg uintptr, csize Tsocklen_t) { return } if (Uint64FromInt64(16)+Uint64FromInt64(8)-Uint64FromInt32(1)) & ^(Uint64FromInt64(8)-Uint64FromInt32(1)) + (Uint64FromInt64(16)+Uint64FromInt64(8)-Uint64FromInt32(1)) & ^(Uint64FromInt64(8)-Uint64FromInt32(1)) > uint64(csize-(*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_controllen) { - *(*int32)(unsafe.Pointer(msg + 48)) |= int32(MSG_CTRUNC) + **(**int32)(__ccgo_up(msg + 48)) |= int32(MSG_CTRUNC) return } v2 = msg + 44 @@ -123814,10 +123814,10 @@ func Xrecvmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r2 Tssize_t) { orig_controllen = (*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_controllen orig = msg if msg != 0 { - *(*Tmsghdr)(unsafe.Pointer(bp + 96)) = *(*Tmsghdr)(unsafe.Pointer(msg)) + **(**Tmsghdr)(__ccgo_up(bp + 96)) = **(**Tmsghdr)(__ccgo_up(msg)) v1 = Int32FromInt32(0) - (*(*Tmsghdr)(unsafe.Pointer(bp + 96))).F__pad2 = v1 - (*(*Tmsghdr)(unsafe.Pointer(bp + 96))).F__pad1 = v1 + (**(**Tmsghdr)(__ccgo_up(bp + 96))).F__pad2 = v1 + (**(**Tmsghdr)(__ccgo_up(bp + 96))).F__pad1 = v1 msg = bp + 96 } v1 = int32(SYS_recvmsg) @@ -123867,7 +123867,7 @@ _12: X__convert_scm_timestamps(tls, msg, orig_controllen) } if orig != 0 { - *(*Tmsghdr)(unsafe.Pointer(orig)) = *(*Tmsghdr)(unsafe.Pointer(bp + 96)) + **(**Tmsghdr)(__ccgo_up(orig)) = **(**Tmsghdr)(__ccgo_up(bp + 96)) } return r1 } @@ -123893,10 +123893,10 @@ func X__res_mkquery(tls *TLS, op int32, dname uintptr, class int32, type1 int32, var _ /* ts at bp+280 */ Ttimespec _, _, _, _, _ = i, id, j, l, n l = Xstrnlen(tls, dname, uint64(255)) - if l != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(dname + uintptr(l-uint64(1))))) == int32('.') { + if l != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(dname + uintptr(l-uint64(1))))) == int32('.') { l = l - 1 } - if l != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(dname + uintptr(l-uint64(1))))) == int32('.') { + if l != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(dname + uintptr(l-uint64(1))))) == int32('.') { return -int32(1) } n = Int32FromUint64(uint64(17) + l + BoolUint64(!!(l != 0))) @@ -123905,18 +123905,18 @@ func X__res_mkquery(tls *TLS, op int32, dname uintptr, class int32, type1 int32, } /* Construct query template - ID will be filled later */ Xmemset(tls, bp, 0, Uint64FromInt32(n)) - (*(*[280]uint8)(unsafe.Pointer(bp)))[int32(2)] = Uint8FromInt32(op*int32(8) + int32(1)) - (*(*[280]uint8)(unsafe.Pointer(bp)))[int32(3)] = uint8(32) /* AD */ - (*(*[280]uint8)(unsafe.Pointer(bp)))[int32(5)] = uint8(1) + (**(**[280]uint8)(__ccgo_up(bp)))[int32(2)] = Uint8FromInt32(op*int32(8) + int32(1)) + (**(**[280]uint8)(__ccgo_up(bp)))[int32(3)] = uint8(32) /* AD */ + (**(**[280]uint8)(__ccgo_up(bp)))[int32(5)] = uint8(1) Xmemcpy(tls, bp+uintptr(13), dname, l) i = int32(13) for { - if !((*(*[280]uint8)(unsafe.Pointer(bp)))[i] != 0) { + if !((**(**[280]uint8)(__ccgo_up(bp)))[i] != 0) { break } j = i for { - if !((*(*[280]uint8)(unsafe.Pointer(bp)))[j] != 0 && Int32FromUint8((*(*[280]uint8)(unsafe.Pointer(bp)))[j]) != int32('.')) { + if !((**(**[280]uint8)(__ccgo_up(bp)))[j] != 0 && Int32FromUint8((**(**[280]uint8)(__ccgo_up(bp)))[j]) != int32('.')) { break } goto _2 @@ -123927,19 +123927,19 @@ func X__res_mkquery(tls *TLS, op int32, dname uintptr, class int32, type1 int32, if Uint32FromInt32(j-i)-uint32(1) > uint32(62) { return -int32(1) } - (*(*[280]uint8)(unsafe.Pointer(bp)))[i-int32(1)] = Uint8FromInt32(j - i) + (**(**[280]uint8)(__ccgo_up(bp)))[i-int32(1)] = Uint8FromInt32(j - i) goto _1 _1: ; i = j + int32(1) } - (*(*[280]uint8)(unsafe.Pointer(bp)))[i+int32(1)] = Uint8FromInt32(type1) - (*(*[280]uint8)(unsafe.Pointer(bp)))[i+int32(3)] = Uint8FromInt32(class) + (**(**[280]uint8)(__ccgo_up(bp)))[i+int32(1)] = Uint8FromInt32(type1) + (**(**[280]uint8)(__ccgo_up(bp)))[i+int32(3)] = Uint8FromInt32(class) /* Make a reasonably unpredictable id */ Xclock_gettime(tls, CLOCK_REALTIME, bp+280) - id = Int32FromUint64((Uint64FromInt64((*(*Ttimespec)(unsafe.Pointer(bp + 280))).Ftv_nsec) + Uint64FromInt64((*(*Ttimespec)(unsafe.Pointer(bp + 280))).Ftv_nsec)/uint64(65536)) & uint64(0xffff)) - (*(*[280]uint8)(unsafe.Pointer(bp)))[0] = Uint8FromInt32(id / int32(256)) - (*(*[280]uint8)(unsafe.Pointer(bp)))[int32(1)] = Uint8FromInt32(id) + id = Int32FromUint64((Uint64FromInt64((**(**Ttimespec)(__ccgo_up(bp + 280))).Ftv_nsec) + Uint64FromInt64((**(**Ttimespec)(__ccgo_up(bp + 280))).Ftv_nsec)/uint64(65536)) & uint64(0xffff)) + (**(**[280]uint8)(__ccgo_up(bp)))[0] = Uint8FromInt32(id / int32(256)) + (**(**[280]uint8)(__ccgo_up(bp)))[int32(1)] = Uint8FromInt32(id) Xmemcpy(tls, buf, bp, Uint64FromInt32(n)) return n } @@ -124056,11 +124056,11 @@ func _cleanup(tls *TLS, p uintptr) { pfd = p i = 0 for { - if !((*(*Tpollfd)(unsafe.Pointer(pfd + uintptr(i)*8))).Ffd >= -int32(1)) { + if !((**(**Tpollfd)(__ccgo_up(pfd + uintptr(i)*8))).Ffd >= -int32(1)) { break } - if (*(*Tpollfd)(unsafe.Pointer(pfd + uintptr(i)*8))).Ffd >= 0 { - X__syscall1(tls, int64(SYS_close), int64((*(*Tpollfd)(unsafe.Pointer(pfd + uintptr(i)*8))).Ffd)) + if (**(**Tpollfd)(__ccgo_up(pfd + uintptr(i)*8))).Ffd >= 0 { + X__syscall1(tls, int64(SYS_close), int64((**(**Tpollfd)(__ccgo_up(pfd + uintptr(i)*8))).Ffd)) } goto _1 _1: @@ -124073,10 +124073,10 @@ func _mtime(tls *TLS) (r uint64) { bp := tls.Alloc(16) defer tls.Free(16) var _ /* ts at bp+0 */ Ttimespec - if Xclock_gettime(tls, int32(CLOCK_MONOTONIC), bp) < 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENOSYS) { + if Xclock_gettime(tls, int32(CLOCK_MONOTONIC), bp) < 0 && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENOSYS) { Xclock_gettime(tls, CLOCK_REALTIME, bp) } - return Uint64FromInt64((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec)*uint64(1000) + Uint64FromInt64((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_nsec/int64(1000000)) + return Uint64FromInt64((**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec)*uint64(1000) + Uint64FromInt64((**(**Ttimespec)(__ccgo_up(bp))).Ftv_nsec/int64(1000000)) } func _start_tcp(tls *TLS, pfd uintptr, family int32, sa uintptr, sl Tsocklen_t, q uintptr, ql int32) (r1 int32) { @@ -124099,7 +124099,7 @@ func _start_tcp(tls *TLS, pfd uintptr, family int32, sa uintptr, sl Tsocklen_t, Fiov_len: Uint64FromInt32(ql), }, } - *(*Tmsghdr)(unsafe.Pointer(bp + 40)) = Tmsghdr{ + **(**Tmsghdr)(__ccgo_up(bp + 40)) = Tmsghdr{ Fmsg_name: sa, Fmsg_namelen: sl, Fmsg_iov: bp, @@ -124117,12 +124117,12 @@ func _start_tcp(tls *TLS, pfd uintptr, family int32, sa uintptr, sl Tsocklen_t, if r >= 0 { return r } - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EINPROGRESS) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EINPROGRESS) { return 0 } } r = Xconnect(tls, fd, sa, sl) - if !(r != 0) || *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EINPROGRESS) { + if !(r != 0) || **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EINPROGRESS) { return 0 } Xclose(tls, fd) @@ -124141,7 +124141,7 @@ func _step_mh(tls *TLS, mh uintptr, n Tsize_t) { return } (*Tiovec)(unsafe.Pointer((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov)).Fiov_base = (*Tiovec)(unsafe.Pointer((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov)).Fiov_base + uintptr(n) - *(*Tsize_t)(unsafe.Pointer((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov + 8)) -= n + **(**Tsize_t)(__ccgo_up((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov + 8)) -= n } /* Internal contract for __res_msend[_rc]: asize must be >=512, nqueries @@ -124193,11 +124193,11 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a F__ccgo_pad2 [12]byte }{} *(*uint16)(unsafe.Pointer(bp + 88)) = uint16(0) - *(*[3]struct { + **(**[3]struct { Fsin6 [0]Tsockaddr_in6 Fsin Tsockaddr_in F__ccgo_pad2 [12]byte - })(unsafe.Pointer(bp + 116)) = [3]struct { + })(__ccgo_up(bp + 116)) = [3]struct { Fsin6 [0]Tsockaddr_in6 Fsin Tsockaddr_in F__ccgo_pad2 [12]byte @@ -124224,16 +124224,16 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a iplit = conf + uintptr(nns)*28 if (*Taddress)(unsafe.Pointer(iplit)).Ffamily == int32(PF_INET) { Xmemcpy(tls, bp+116+uintptr(nns)*28+4, iplit+8, uint64(4)) - (*(*[3]struct { + (**(**[3]struct { Fsin6 [0]Tsockaddr_in6 Fsin Tsockaddr_in F__ccgo_pad2 [12]byte - })(unsafe.Pointer(bp + 116)))[nns].Fsin.Fsin_port = Xhtons(tls, uint16(53)) - (*(*[3]struct { + })(__ccgo_up(bp + 116)))[nns].Fsin.Fsin_port = Xhtons(tls, uint16(53)) + (**(**[3]struct { Fsin6 [0]Tsockaddr_in6 Fsin Tsockaddr_in F__ccgo_pad2 [12]byte - })(unsafe.Pointer(bp + 116)))[nns].Fsin.Fsin_family = uint16(PF_INET) + })(__ccgo_up(bp + 116)))[nns].Fsin.Fsin_family = uint16(PF_INET) } else { sl = uint32(28) Xmemcpy(tls, bp+116+uintptr(nns)*28+8, iplit+8, uint64(16)) @@ -124251,10 +124251,10 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a /* Get local address and open/bind a socket */ fd = Xsocket(tls, family, Int32FromInt32(SOCK_DGRAM)|Int32FromInt32(SOCK_CLOEXEC)|Int32FromInt32(SOCK_NONBLOCK), 0) /* Handle case where system lacks IPv6 support */ - if fd < 0 && family == int32(PF_INET6) && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EAFNOSUPPORT) { + if fd < 0 && family == int32(PF_INET6) && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EAFNOSUPPORT) { i = 0 for { - if !(i < nns && (*(*Taddress)(unsafe.Pointer(conf + uintptr(nns)*28))).Ffamily == int32(PF_INET6)) { + if !(i < nns && (**(**Taddress)(__ccgo_up(conf + uintptr(nns)*28))).Ffamily == int32(PF_INET6)) { break } goto _7 @@ -124263,7 +124263,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a i = i + 1 } if i == nns { - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 200)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 200)), uintptr(0)) return -int32(1) } fd = Xsocket(tls, int32(PF_INET), Int32FromInt32(SOCK_DGRAM)|Int32FromInt32(SOCK_CLOEXEC)|Int32FromInt32(SOCK_NONBLOCK), 0) @@ -124279,11 +124279,11 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a if !(i < nns) { break } - if Int32FromUint16((*(*[3]struct { + if Int32FromUint16((**(**[3]struct { Fsin6 [0]Tsockaddr_in6 Fsin Tsockaddr_in F__ccgo_pad2 [12]byte - })(unsafe.Pointer(bp + 116)))[i].Fsin.Fsin_family) != int32(PF_INET) { + })(__ccgo_up(bp + 116)))[i].Fsin.Fsin_family) != int32(PF_INET) { goto _8 } Xmemcpy(tls, bp+116+uintptr(i)*28+8+uintptr(12), bp+116+uintptr(i)*28+4, uint64(4)) @@ -124297,16 +124297,16 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a i = i + 1 } } - (*(*struct { + (**(**struct { Fsin6 [0]Tsockaddr_in6 Fsin Tsockaddr_in F__ccgo_pad2 [12]byte - })(unsafe.Pointer(bp + 88))).Fsin.Fsin_family = Uint16FromInt32(family) + })(__ccgo_up(bp + 88))).Fsin.Fsin_family = Uint16FromInt32(family) if fd < 0 || Xbind(tls, fd, bp+88, sl) < 0 { if fd >= 0 { Xclose(tls, fd) } - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 200)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 200)), uintptr(0)) return -int32(1) } /* Past this point, there are no errors. Each individual query will @@ -124327,7 +124327,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), nqueries*8))).Fevents = int16(POLLIN) (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), (nqueries+int32(1))*8))).Ffd = -int32(2) __pthread_cleanup_push(tls, bp+208, __ccgo_fp(_cleanup), pfd) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 200)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 200)), uintptr(0)) Xmemset(tls, alens, 0, uint64(4)*Uint64FromInt32(nqueries)) retry_interval = timeout / attempts next = 0 @@ -124343,7 +124343,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a * have an accepted answer. */ i = 0 for { - if !(i < nqueries && *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) > 0) { + if !(i < nqueries && **(**int32)(__ccgo_up(alens + uintptr(i)*4)) > 0) { break } goto _12 @@ -124361,13 +124361,13 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a if !(i < nqueries) { break } - if !(*(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) != 0) { + if !(**(**int32)(__ccgo_up(alens + uintptr(i)*4)) != 0) { j = 0 for { if !(j < nns) { break } - Xsendto(tls, fd, *(*uintptr)(unsafe.Pointer(queries + uintptr(i)*8)), Uint64FromInt32(*(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))), int32(MSG_NOSIGNAL), bp+116+uintptr(j)*28, sl) + Xsendto(tls, fd, **(**uintptr)(__ccgo_up(queries + uintptr(i)*8)), Uint64FromInt32(**(**int32)(__ccgo_up(qlens + uintptr(i)*4))), int32(MSG_NOSIGNAL), bp+116+uintptr(j)*28, sl) goto _14 _14: ; @@ -124389,11 +124389,11 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a for next < nqueries { *(*[1]Tiovec)(unsafe.Pointer(bp + 8)) = [1]Tiovec{ 0: { - Fiov_base: *(*uintptr)(unsafe.Pointer(answers + uintptr(next)*8)), + Fiov_base: **(**uintptr)(__ccgo_up(answers + uintptr(next)*8)), Fiov_len: Uint64FromInt32(asize), }, } - *(*Tmsghdr)(unsafe.Pointer(bp + 232)) = Tmsghdr{ + **(**Tmsghdr)(__ccgo_up(bp + 232)) = Tmsghdr{ Fmsg_name: bp + 88, Fmsg_namelen: sl, Fmsg_iov: bp + 8, @@ -124424,7 +124424,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a /* Find which query this answer goes with, if any */ i = next for { - if !(i < nqueries && (Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(answers + uintptr(next)*8))))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(queries + uintptr(i)*8))))) || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(answers + uintptr(next)*8)) + 1))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(queries + uintptr(i)*8)) + 1))))) { + if !(i < nqueries && (Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(answers + uintptr(next)*8))))) != Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(queries + uintptr(i)*8))))) || Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(answers + uintptr(next)*8)) + 1))) != Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(queries + uintptr(i)*8)) + 1))))) { break } goto _16 @@ -124435,13 +124435,13 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a if i == nqueries { continue } - if *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) != 0 { + if **(**int32)(__ccgo_up(alens + uintptr(i)*4)) != 0 { continue } /* Only accept positive or negative responses; * retry immediately on server failure, and ignore * all other codes such as refusal. */ - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(answers + uintptr(next)*8)) + 3))) & Int32FromInt32(15) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(answers + uintptr(next)*8)) + 3))) & Int32FromInt32(15) { case 0: fallthrough case int32(3): @@ -124451,7 +124451,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a servfail_retry = servfail_retry - 1 } if v18 && v6 != 0 { - Xsendto(tls, fd, *(*uintptr)(unsafe.Pointer(queries + uintptr(i)*8)), Uint64FromInt32(*(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))), int32(MSG_NOSIGNAL), bp+116+uintptr(j)*28, sl) + Xsendto(tls, fd, **(**uintptr)(__ccgo_up(queries + uintptr(i)*8)), Uint64FromInt32(**(**int32)(__ccgo_up(qlens + uintptr(i)*4))), int32(MSG_NOSIGNAL), bp+116+uintptr(j)*28, sl) } fallthrough default: @@ -124459,10 +124459,10 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a } /* Store answer in the right slot, or update next * available temp slot if it's already in place. */ - *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) = rlen + **(**int32)(__ccgo_up(alens + uintptr(i)*4)) = rlen if i == next { for { - if !(next < nqueries && *(*int32)(unsafe.Pointer(alens + uintptr(next)*4)) != 0) { + if !(next < nqueries && **(**int32)(__ccgo_up(alens + uintptr(next)*4)) != 0) { break } goto _19 @@ -124471,18 +124471,18 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a next = next + 1 } } else { - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(answers + uintptr(i)*8)), *(*uintptr)(unsafe.Pointer(answers + uintptr(next)*8)), Uint64FromInt32(rlen)) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(answers + uintptr(i)*8)), **(**uintptr)(__ccgo_up(answers + uintptr(next)*8)), Uint64FromInt32(rlen)) } /* Ignore further UDP if all slots full or TCP-mode */ if next == nqueries { (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), nqueries*8))).Fevents = 0 } /* If answer is truncated (TC bit), fallback to TCP */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(answers + uintptr(i)*8)) + 2)))&int32(2) != 0 || (*(*Tmsghdr)(unsafe.Pointer(bp + 232))).Fmsg_flags&int32(MSG_TRUNC) != 0 { - *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) = -int32(1) + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(answers + uintptr(i)*8)) + 2)))&int32(2) != 0 || (**(**Tmsghdr)(__ccgo_up(bp + 232))).Fmsg_flags&int32(MSG_TRUNC) != 0 { + **(**int32)(__ccgo_up(alens + uintptr(i)*4)) = -int32(1) _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), uintptr(0)) - r = _start_tcp(tls, pfd+uintptr(i)*8, family, bp+116+uintptr(j)*28, sl, *(*uintptr)(unsafe.Pointer(queries + uintptr(i)*8)), *(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 200)), uintptr(0)) + r = _start_tcp(tls, pfd+uintptr(i)*8, family, bp+116+uintptr(j)*28, sl, **(**uintptr)(__ccgo_up(queries + uintptr(i)*8)), **(**int32)(__ccgo_up(qlens + uintptr(i)*4))) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 200)), uintptr(0)) if r >= 0 { *(*int32)(unsafe.Add(unsafe.Pointer(qpos), i*4)) = r *(*int32)(unsafe.Add(unsafe.Pointer(apos), i*4)) = 0 @@ -124497,8 +124497,8 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a } if int32((*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), i*8))).Frevents)&int32(POLLOUT) != 0 { *(*[2]Tuint8_t)(unsafe.Pointer(bp + 52)) = [2]Tuint8_t{ - 0: Uint8FromInt32(*(*int32)(unsafe.Pointer(qlens + uintptr(i)*4)) >> int32(8)), - 1: Uint8FromInt32(*(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))), + 0: Uint8FromInt32(**(**int32)(__ccgo_up(qlens + uintptr(i)*4)) >> int32(8)), + 1: Uint8FromInt32(**(**int32)(__ccgo_up(qlens + uintptr(i)*4))), } *(*[2]Tiovec)(unsafe.Pointer(bp + 24)) = [2]Tiovec{ 0: { @@ -124506,11 +124506,11 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a Fiov_len: uint64(2), }, 1: { - Fiov_base: *(*uintptr)(unsafe.Pointer(queries + uintptr(i)*8)), - Fiov_len: Uint64FromInt32(*(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))), + Fiov_base: **(**uintptr)(__ccgo_up(queries + uintptr(i)*8)), + Fiov_len: Uint64FromInt32(**(**int32)(__ccgo_up(qlens + uintptr(i)*4))), }, } - *(*Tmsghdr)(unsafe.Pointer(bp + 288)) = Tmsghdr{ + **(**Tmsghdr)(__ccgo_up(bp + 288)) = Tmsghdr{ Fmsg_iov: bp + 24, Fmsg_iovlen: int32(2), } @@ -124519,8 +124519,8 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a if r < 0 { goto out } - *(*int32)(unsafe.Pointer(qpos + uintptr(i)*4)) += r - if *(*int32)(unsafe.Add(unsafe.Pointer(qpos), i*4)) == *(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))+int32(2) { + **(**int32)(__ccgo_up(qpos + uintptr(i)*4)) += r + if *(*int32)(unsafe.Add(unsafe.Pointer(qpos), i*4)) == **(**int32)(__ccgo_up(qlens + uintptr(i)*4))+int32(2) { (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), i*8))).Fevents = int16(POLLIN) } } @@ -124541,11 +124541,11 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a Fiov_len: uint64(2), }, 1: { - Fiov_base: *(*uintptr)(unsafe.Pointer(answers + uintptr(i)*8)), + Fiov_base: **(**uintptr)(__ccgo_up(answers + uintptr(i)*8)), Fiov_len: Uint64FromInt32(asize), }, } - *(*Tmsghdr)(unsafe.Pointer(bp + 344)) = Tmsghdr{ + **(**Tmsghdr)(__ccgo_up(bp + 344)) = Tmsghdr{ Fmsg_iov: bp + 56, Fmsg_iovlen: int32(2), } @@ -124554,25 +124554,25 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a if r <= 0 { goto out } - *(*int32)(unsafe.Pointer(apos + uintptr(i)*4)) += r + **(**int32)(__ccgo_up(apos + uintptr(i)*4)) += r if *(*int32)(unsafe.Add(unsafe.Pointer(apos), i*4)) < int32(2) { goto _21 } - alen = Int32FromUint8(*(*uint8)(unsafe.Pointer(alen_buf + uintptr(i)*2)))*int32(256) + Int32FromUint8(*(*uint8)(unsafe.Pointer(alen_buf + uintptr(i)*2 + 1))) + alen = Int32FromUint8(**(**uint8)(__ccgo_up(alen_buf + uintptr(i)*2)))*int32(256) + Int32FromUint8(**(**uint8)(__ccgo_up(alen_buf + uintptr(i)*2 + 1))) if alen < int32(13) { goto out } if *(*int32)(unsafe.Add(unsafe.Pointer(apos), i*4)) < alen+int32(2) && *(*int32)(unsafe.Add(unsafe.Pointer(apos), i*4)) < asize+int32(2) { goto _21 } - rcode = Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(answers + uintptr(i)*8)) + 3))) & int32(15) + rcode = Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(answers + uintptr(i)*8)) + 3))) & int32(15) if rcode != 0 && rcode != int32(3) { goto out } /* Storing the length here commits the accepted answer. * Immediately close TCP socket so as not to consume * resources we no longer need. */ - *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) = alen + **(**int32)(__ccgo_up(alens + uintptr(i)*4)) = alen X__syscall1(tls, int64(SYS_close), int64((*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), i*8))).Ffd)) (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), i*8))).Ffd = -int32(1) } @@ -124596,8 +124596,8 @@ out: if !(i < nqueries) { break } - if *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) < 0 { - *(*int32)(unsafe.Pointer(alens + uintptr(i)*4)) = 0 + if **(**int32)(__ccgo_up(alens + uintptr(i)*4)) < 0 { + **(**int32)(__ccgo_up(alens + uintptr(i)*4)) = 0 } goto _22 _22: @@ -124635,23 +124635,23 @@ func X__res_send(tls *TLS, _msg uintptr, _msglen int32, _answer uintptr, _anslen var r, v1 int32 var _ /* buf at bp+28 */ [512]uint8 _, _ = r, v1 - if *(*int32)(unsafe.Pointer(bp + 24)) < int32(512) { - r = X__res_send(tls, *(*uintptr)(unsafe.Pointer(bp)), *(*int32)(unsafe.Pointer(bp + 8)), bp+28, int32(512)) + if **(**int32)(__ccgo_up(bp + 24)) < int32(512) { + r = X__res_send(tls, **(**uintptr)(__ccgo_up(bp)), **(**int32)(__ccgo_up(bp + 8)), bp+28, int32(512)) if r >= 0 { - if r < *(*int32)(unsafe.Pointer(bp + 24)) { + if r < **(**int32)(__ccgo_up(bp + 24)) { v1 = r } else { - v1 = *(*int32)(unsafe.Pointer(bp + 24)) + v1 = **(**int32)(__ccgo_up(bp + 24)) } - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(bp + 16)), bp+28, Uint64FromInt32(v1)) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(bp + 16)), bp+28, Uint64FromInt32(v1)) } return r } - r = X__res_msend(tls, int32(1), bp, bp+8, bp+16, bp+24, *(*int32)(unsafe.Pointer(bp + 24))) - if r < 0 || !(*(*int32)(unsafe.Pointer(bp + 24)) != 0) { + r = X__res_msend(tls, int32(1), bp, bp+8, bp+16, bp+24, **(**int32)(__ccgo_up(bp + 24))) + if r < 0 || !(**(**int32)(__ccgo_up(bp + 24)) != 0) { v1 = -int32(1) } else { - v1 = *(*int32)(unsafe.Pointer(bp + 24)) + v1 = **(**int32)(__ccgo_up(bp + 24)) } return v1 } @@ -124698,11 +124698,11 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ (*Tresolvconf)(unsafe.Pointer(conf)).Ftimeout = uint32(5) (*Tresolvconf)(unsafe.Pointer(conf)).Fattempts = uint32(2) if search != 0 { - *(*uint8)(unsafe.Pointer(search)) = uint8(0) + **(**uint8)(__ccgo_up(search)) = uint8(0) } f = X__fopen_rb_ca(tls, __ccgo_ts+1179, bp+512, bp+256, uint64(256)) if !(f != 0) { - switch *(*int32)(unsafe.Pointer(X__errno_location(tls))) { + switch **(**int32)(__ccgo_up(X__errno_location(tls))) { case int32(ENOENT): fallthrough case int32(ENOTDIR): @@ -124721,17 +124721,17 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ continue } if v4 = !(Xstrncmp(tls, bp, __ccgo_ts+1196, uint64(7)) != 0); v4 { - v1 = Int32FromUint8((*(*[256]uint8)(unsafe.Pointer(bp)))[int32(7)]) + v1 = Int32FromUint8((**(**[256]uint8)(__ccgo_up(bp)))[int32(7)]) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _3 _3: } if v4 && v2 != 0 { p = Xstrstr(tls, bp, __ccgo_ts+1204) - if p != 0 && BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p + 6)))-uint32('0') < uint32(10)) != 0 { + if p != 0 && BoolInt32(uint32(**(**uint8)(__ccgo_up(p + 6)))-uint32('0') < uint32(10)) != 0 { p = p + uintptr(6) x = Xstrtoul(tls, p, bp+744, int32(10)) - if *(*uintptr)(unsafe.Pointer(bp + 744)) != p { + if **(**uintptr)(__ccgo_up(bp + 744)) != p { if x > uint64(15) { v5 = uint64(15) } else { @@ -124741,10 +124741,10 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ } } p = Xstrstr(tls, bp, __ccgo_ts+1211) - if p != 0 && BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p + 9)))-uint32('0') < uint32(10)) != 0 { + if p != 0 && BoolInt32(uint32(**(**uint8)(__ccgo_up(p + 9)))-uint32('0') < uint32(10)) != 0 { p = p + uintptr(9) x1 = Xstrtoul(tls, p, bp+744, int32(10)) - if *(*uintptr)(unsafe.Pointer(bp + 744)) != p { + if **(**uintptr)(__ccgo_up(bp + 744)) != p { if x1 > uint64(10) { v5 = uint64(10) } else { @@ -124754,10 +124754,10 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ } } p = Xstrstr(tls, bp, __ccgo_ts+1221) - if p != 0 && (BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p + 8)))-uint32('0') < uint32(10)) != 0 || Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 8))) == int32('.')) { + if p != 0 && (BoolInt32(uint32(**(**uint8)(__ccgo_up(p + 8)))-uint32('0') < uint32(10)) != 0 || Int32FromUint8(**(**uint8)(__ccgo_up(p + 8))) == int32('.')) { p = p + uintptr(8) x2 = Xstrtoul(tls, p, bp+744, int32(10)) - if *(*uintptr)(unsafe.Pointer(bp + 744)) != p { + if **(**uintptr)(__ccgo_up(bp + 744)) != p { if x2 > uint64(60) { v5 = uint64(60) } else { @@ -124769,7 +124769,7 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ continue } if v4 = !(Xstrncmp(tls, bp, __ccgo_ts+1230, uint64(10)) != 0); v4 { - v1 = Int32FromUint8((*(*[256]uint8)(unsafe.Pointer(bp)))[int32(10)]) + v1 = Int32FromUint8((**(**[256]uint8)(__ccgo_up(bp)))[int32(10)]) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _10 _10: @@ -124780,7 +124780,7 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ } p = bp + uintptr(11) for { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _15 _15: @@ -124792,10 +124792,10 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ ; p = p + 1 } - *(*uintptr)(unsafe.Pointer(bp + 744)) = p + **(**uintptr)(__ccgo_up(bp + 744)) = p for { - if v4 = *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 744)))) != 0; v4 { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 744))))) + if v4 = **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 744)))) != 0; v4 { + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 744))))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _19 _19: @@ -124806,9 +124806,9 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ goto _16 _16: ; - *(*uintptr)(unsafe.Pointer(bp + 744)) = *(*uintptr)(unsafe.Pointer(bp + 744)) + 1 + **(**uintptr)(__ccgo_up(bp + 744)) = **(**uintptr)(__ccgo_up(bp + 744)) + 1 } - *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 744)))) = uint8(0) + **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 744)))) = uint8(0) if X__lookup_ipliteral(tls, conf+uintptr(nns)*28, p, PF_UNSPEC) > 0 { nns = nns + 1 } @@ -124818,7 +124818,7 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ continue } if v4 = Xstrncmp(tls, bp, __ccgo_ts+1241, uint64(6)) != 0 && Xstrncmp(tls, bp, __ccgo_ts+1248, uint64(6)) != 0; !v4 { - v1 = Int32FromUint8((*(*[256]uint8)(unsafe.Pointer(bp)))[int32(6)]) + v1 = Int32FromUint8((**(**[256]uint8)(__ccgo_up(bp)))[int32(6)]) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _23 _23: @@ -124828,7 +124828,7 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ } p = bp + uintptr(7) for { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _28 _28: @@ -124894,7 +124894,7 @@ func Xsendmmsg(tls *TLS, fd int32, msgvec uintptr, vlen uint32, flags uint32) (r if r < 0 { goto error } - (*(*Tmmsghdr)(unsafe.Pointer(msgvec + uintptr(i)*64))).Fmsg_len = Uint32FromInt64(r) + (**(**Tmmsghdr)(__ccgo_up(msgvec + uintptr(i)*64))).Fmsg_len = Uint32FromInt64(r) goto _1 _1: ; @@ -124927,18 +124927,18 @@ func Xsendmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r1 Tssize_t) { var _ /* h at bp+96 */ Tmsghdr _, _, _, _, _, _, _, _, _, _, _, _, _ = c1, r, v1, v10, v11, v12, v13, v14, v3, v5, v6, v8, v9 if msg != 0 { - *(*Tmsghdr)(unsafe.Pointer(bp + 96)) = *(*Tmsghdr)(unsafe.Pointer(msg)) + **(**Tmsghdr)(__ccgo_up(bp + 96)) = **(**Tmsghdr)(__ccgo_up(msg)) v1 = Int32FromInt32(0) - (*(*Tmsghdr)(unsafe.Pointer(bp + 96))).F__pad2 = v1 - (*(*Tmsghdr)(unsafe.Pointer(bp + 96))).F__pad1 = v1 + (**(**Tmsghdr)(__ccgo_up(bp + 96))).F__pad2 = v1 + (**(**Tmsghdr)(__ccgo_up(bp + 96))).F__pad1 = v1 msg = bp + 96 - if (*(*Tmsghdr)(unsafe.Pointer(bp + 96))).Fmsg_controllen != 0 { - if uint64((*(*Tmsghdr)(unsafe.Pointer(bp + 96))).Fmsg_controllen) > uint64(1056) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + if (**(**Tmsghdr)(__ccgo_up(bp + 96))).Fmsg_controllen != 0 { + if uint64((**(**Tmsghdr)(__ccgo_up(bp + 96))).Fmsg_controllen) > uint64(1056) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return int64(-int32(1)) } - Xmemcpy(tls, bp+152, (*(*Tmsghdr)(unsafe.Pointer(bp + 96))).Fmsg_control, uint64((*(*Tmsghdr)(unsafe.Pointer(bp + 96))).Fmsg_controllen)) - (*(*Tmsghdr)(unsafe.Pointer(bp + 96))).Fmsg_control = bp + 152 + Xmemcpy(tls, bp+152, (**(**Tmsghdr)(__ccgo_up(bp + 96))).Fmsg_control, uint64((**(**Tmsghdr)(__ccgo_up(bp + 96))).Fmsg_controllen)) + (**(**Tmsghdr)(__ccgo_up(bp + 96))).Fmsg_control = bp + 152 if uint64((*Tmsghdr)(unsafe.Pointer(bp+96)).Fmsg_controllen) >= uint64(16) { v3 = (*Tmsghdr)(unsafe.Pointer(bp + 96)).Fmsg_control } else { @@ -125347,7 +125347,7 @@ func Xsockatmark(tls *TLS, s int32) (r int32) { if Xioctl(tls, s, int32(SIOCATMARK), VaList(bp+16, bp)) < 0 { return -int32(1) } - return *(*int32)(unsafe.Pointer(bp)) + return **(**int32)(__ccgo_up(bp)) } func Xsocket(tls *TLS, domain int32, type1 int32, protocol int32) (r1 int32) { @@ -125515,7 +125515,7 @@ func Xsocketpair(tls *TLS, domain int32, type1 int32, protocol int32, fd uintptr goto _11 _11: r1 = int32(X__syscall_ret(tls, Uint64FromInt64(v10))) - if r1 < 0 && (*(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EINVAL) || *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EPROTONOSUPPORT)) && type1&(Int32FromInt32(SOCK_CLOEXEC)|Int32FromInt32(SOCK_NONBLOCK)) != 0 { + if r1 < 0 && (**(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EINVAL) || **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EPROTONOSUPPORT)) && type1&(Int32FromInt32(SOCK_CLOEXEC)|Int32FromInt32(SOCK_NONBLOCK)) != 0 { v12 = int32(SYS_socketpair) v13 = int32(__SC_socketpair) v14 = 0 @@ -125563,12 +125563,12 @@ _11: return r1 } if type1&int32(SOCK_CLOEXEC) != 0 { - X__syscall3(tls, int64(SYS_fcntl), int64(*(*int32)(unsafe.Pointer(fd))), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) - X__syscall3(tls, int64(SYS_fcntl), int64(*(*int32)(unsafe.Pointer(fd + 1*4))), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) + X__syscall3(tls, int64(SYS_fcntl), int64(**(**int32)(__ccgo_up(fd))), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) + X__syscall3(tls, int64(SYS_fcntl), int64(**(**int32)(__ccgo_up(fd + 1*4))), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) } if type1&int32(SOCK_NONBLOCK) != 0 { - X__syscall3(tls, int64(SYS_fcntl), int64(*(*int32)(unsafe.Pointer(fd))), int64(Int32FromInt32(F_SETFL)), int64(Int32FromInt32(O_NONBLOCK))) - X__syscall3(tls, int64(SYS_fcntl), int64(*(*int32)(unsafe.Pointer(fd + 1*4))), int64(Int32FromInt32(F_SETFL)), int64(Int32FromInt32(O_NONBLOCK))) + X__syscall3(tls, int64(SYS_fcntl), int64(**(**int32)(__ccgo_up(fd))), int64(Int32FromInt32(F_SETFL)), int64(Int32FromInt32(O_NONBLOCK))) + X__syscall3(tls, int64(SYS_fcntl), int64(**(**int32)(__ccgo_up(fd + 1*4))), int64(Int32FromInt32(F_SETFL)), int64(Int32FromInt32(O_NONBLOCK))) } } return r1 @@ -125605,10 +125605,10 @@ func Xfgetgrent(tls *TLS, f uintptr) (r uintptr) { var _ /* nmem at bp+16 */ Tsize_t var _ /* res at bp+0 */ uintptr var _ /* size at bp+8 */ Tsize_t - *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint64(0) - *(*Tsize_t)(unsafe.Pointer(bp + 16)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp + 8)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp + 16)) = uint64(0) X__getgrent_a(tls, f, uintptr(unsafe.Pointer(&_gr)), uintptr(unsafe.Pointer(&_line1)), bp+8, uintptr(unsafe.Pointer(&_mem)), bp+16, bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } var _line1 uintptr @@ -125626,9 +125626,9 @@ func Xfgetpwent(tls *TLS, f uintptr) (r uintptr) { defer tls.Free(16) var _ /* res at bp+8 */ uintptr var _ /* size at bp+0 */ Tsize_t - *(*Tsize_t)(unsafe.Pointer(bp)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp)) = uint64(0) X__getpwent_a(tls, f, uintptr(unsafe.Pointer(&_pw)), uintptr(unsafe.Pointer(&_line2)), bp, bp+8) - return *(*uintptr)(unsafe.Pointer(bp + 8)) + return **(**uintptr)(__ccgo_up(bp + 8)) } var _line2 uintptr @@ -125674,11 +125674,11 @@ func _itoa1(tls *TLS, p uintptr, x Tuint32_t) (r uintptr) { p = p + uintptr(11) p = p - 1 v1 = p - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) for cond := true; cond; cond = x != 0 { p = p - 1 v1 = p - *(*uint8)(unsafe.Pointer(v1)) = uint8(uint32('0') + x%uint32(10)) + **(**uint8)(__ccgo_up(v1)) = uint8(uint32('0') + x%uint32(10)) x = x / uint32(10) } return p @@ -125703,36 +125703,36 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz var _ /* swap at bp+40 */ int32 _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, grlist_len, i, key, len1, ptr, req, rv, tmp, tmp1, v1, v10, v5, v6 rv = 0 - *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) + **(**uintptr)(__ccgo_up(res)) = uintptr(0) _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp) f = Xfopen(tls, __ccgo_ts+1265, __ccgo_ts+404) if !(f != 0) { - rv = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + rv = **(**int32)(__ccgo_up(X__errno_location(tls))) goto done } for { v1 = X__getgrent_a(tls, f, gr, buf, size, mem, nmem, res) rv = v1 - if !(!(v1 != 0) && *(*uintptr)(unsafe.Pointer(res)) != 0) { + if !(!(v1 != 0) && **(**uintptr)(__ccgo_up(res)) != 0) { break } - if name != 0 && !(Xstrcmp(tls, name, (*Tgroup)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(res)))).Fgr_name) != 0) || !(name != 0) && (*Tgroup)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(res)))).Fgr_gid == gid { + if name != 0 && !(Xstrcmp(tls, name, (*Tgroup)(unsafe.Pointer(**(**uintptr)(__ccgo_up(res)))).Fgr_name) != 0) || !(name != 0) && (*Tgroup)(unsafe.Pointer(**(**uintptr)(__ccgo_up(res)))).Fgr_gid == gid { break } } Xfclose(tls, f) - if !(*(*uintptr)(unsafe.Pointer(res)) != 0) && (rv == 0 || rv == int32(ENOENT) || rv == int32(ENOTDIR)) { + if !(**(**uintptr)(__ccgo_up(res)) != 0) && (rv == 0 || rv == int32(ENOENT) || rv == int32(ENOTDIR)) { if name != 0 { v1 = int32(GETGRBYNAME) } else { v1 = int32(GETGRBYGID) } req = v1 - *(*[6]Tint32_t)(unsafe.Pointer(bp + 4)) = [6]Tint32_t{} + **(**[6]Tint32_t)(__ccgo_up(bp + 4)) = [6]Tint32_t{} len1 = uint64(0) grlist_len = uint64(0) - *(*[11]uint8)(unsafe.Pointer(bp + 28)) = [11]uint8{} - *(*int32)(unsafe.Pointer(bp + 40)) = 0 + **(**[11]uint8)(__ccgo_up(bp + 28)) = [11]uint8{} + **(**int32)(__ccgo_up(bp + 40)) = 0 if name != 0 { key = name } else { @@ -125744,116 +125744,116 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz } f = X__nscd_query(tls, req, key, bp+4, uint64(24), bp+40) if !(f != 0) { - rv = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + rv = **(**int32)(__ccgo_up(X__errno_location(tls))) goto done } - if !((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRFOUND)] != 0) { + if !((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRFOUND)] != 0) { rv = 0 goto cleanup_f } - if !((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRNAMELEN)] != 0) || !((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRPASSWDLEN)] != 0) { + if !((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRNAMELEN)] != 0) || !((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRPASSWDLEN)] != 0) { rv = int32(EIO) goto cleanup_f } - if Uint64FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRNAMELEN)]) > uint64(0xffffffffffffffff)-Uint64FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRPASSWDLEN)]) { + if Uint64FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRNAMELEN)]) > uint64(0xffffffffffffffff)-Uint64FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRPASSWDLEN)]) { rv = int32(ENOMEM) goto cleanup_f } - len1 = Uint64FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRNAMELEN)] + (*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRPASSWDLEN)]) + len1 = Uint64FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRNAMELEN)] + (**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRPASSWDLEN)]) i = 0 for { - if !(i < (*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)]) { + if !(i < (**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)]) { break } if Xfread(tls, bp+44, uint64(4), uint64(1), f) < uint64(1) { if Xferror(tls, f) != 0 { - v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = **(**int32)(__ccgo_up(X__errno_location(tls))) } else { v1 = int32(EIO) } rv = v1 goto cleanup_f } - if *(*int32)(unsafe.Pointer(bp + 40)) != 0 { - v5 = *(*Tuint32_t)(unsafe.Pointer(bp + 44)) + if **(**int32)(__ccgo_up(bp + 40)) != 0 { + v5 = **(**Tuint32_t)(__ccgo_up(bp + 44)) v6 = v5>>int32(24) | v5>>int32(8)&uint32(0xff00) | v5< uint64(0xffffffffffffffff)-grlist_len || uint64(*(*Tuint32_t)(unsafe.Pointer(bp + 44))) > uint64(0xffffffffffffffff)-len1 { + if uint64(**(**Tuint32_t)(__ccgo_up(bp + 44))) > uint64(0xffffffffffffffff)-grlist_len || uint64(**(**Tuint32_t)(__ccgo_up(bp + 44))) > uint64(0xffffffffffffffff)-len1 { rv = int32(ENOMEM) goto cleanup_f } - len1 = len1 + uint64(*(*Tuint32_t)(unsafe.Pointer(bp + 44))) - grlist_len = grlist_len + uint64(*(*Tuint32_t)(unsafe.Pointer(bp + 44))) + len1 = len1 + uint64(**(**Tuint32_t)(__ccgo_up(bp + 44))) + grlist_len = grlist_len + uint64(**(**Tuint32_t)(__ccgo_up(bp + 44))) goto _3 _3: ; i = i + 1 } - if len1 > *(*Tsize_t)(unsafe.Pointer(size)) || !(*(*uintptr)(unsafe.Pointer(buf)) != 0) { - tmp = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(buf)), len1) + if len1 > **(**Tsize_t)(__ccgo_up(size)) || !(**(**uintptr)(__ccgo_up(buf)) != 0) { + tmp = Xrealloc(tls, **(**uintptr)(__ccgo_up(buf)), len1) if !(tmp != 0) { - rv = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + rv = **(**int32)(__ccgo_up(X__errno_location(tls))) goto cleanup_f } - *(*uintptr)(unsafe.Pointer(buf)) = tmp - *(*Tsize_t)(unsafe.Pointer(size)) = len1 + **(**uintptr)(__ccgo_up(buf)) = tmp + **(**Tsize_t)(__ccgo_up(size)) = len1 } - if !(Xfread(tls, *(*uintptr)(unsafe.Pointer(buf)), len1, uint64(1), f) != 0) { + if !(Xfread(tls, **(**uintptr)(__ccgo_up(buf)), len1, uint64(1), f) != 0) { if Xferror(tls, f) != 0 { - v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = **(**int32)(__ccgo_up(X__errno_location(tls))) } else { v1 = int32(EIO) } rv = v1 goto cleanup_f } - if Uint64FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)]+int32(1)) > *(*Tsize_t)(unsafe.Pointer(nmem)) { - if Uint64FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)]+int32(1)) > Uint64FromUint64(0xffffffffffffffff)/Uint64FromInt64(8) { + if Uint64FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)]+int32(1)) > **(**Tsize_t)(__ccgo_up(nmem)) { + if Uint64FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)]+int32(1)) > Uint64FromUint64(0xffffffffffffffff)/Uint64FromInt64(8) { rv = int32(ENOMEM) goto cleanup_f } - tmp1 = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(mem)), Uint64FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)]+Int32FromInt32(1))*uint64(8)) + tmp1 = Xrealloc(tls, **(**uintptr)(__ccgo_up(mem)), Uint64FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)]+Int32FromInt32(1))*uint64(8)) if !(tmp1 != 0) { - rv = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + rv = **(**int32)(__ccgo_up(X__errno_location(tls))) goto cleanup_f } - *(*uintptr)(unsafe.Pointer(mem)) = tmp1 - *(*Tsize_t)(unsafe.Pointer(nmem)) = Uint64FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)] + int32(1)) + **(**uintptr)(__ccgo_up(mem)) = tmp1 + **(**Tsize_t)(__ccgo_up(nmem)) = Uint64FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)] + int32(1)) } - if (*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)] != 0 { - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)))) = *(*uintptr)(unsafe.Pointer(buf)) + uintptr((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRNAMELEN)]) + uintptr((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRPASSWDLEN)]) - ptr = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)))) + if (**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)] != 0 { + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)))) = **(**uintptr)(__ccgo_up(buf)) + uintptr((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRNAMELEN)]) + uintptr((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRPASSWDLEN)]) + ptr = **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)))) i = Int32FromInt32(0) for { - if !(ptr != *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem))))+uintptr(grlist_len)) { + if !(ptr != **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem))))+uintptr(grlist_len)) { break } - if !(*(*uint8)(unsafe.Pointer(ptr)) != 0) { + if !(**(**uint8)(__ccgo_up(ptr)) != 0) { i = i + 1 v10 = i - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v10)*8)) = ptr + uintptr(1) + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)) + uintptr(v10)*8)) = ptr + uintptr(1) } goto _9 _9: ; ptr = ptr + 1 } - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(i)*8)) = uintptr(0) - if i != (*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)] { + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)) + uintptr(i)*8)) = uintptr(0) + if i != (**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRMEMCNT)] { rv = int32(EIO) goto cleanup_f } } else { - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)))) = uintptr(0) + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)))) = uintptr(0) } - (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = *(*uintptr)(unsafe.Pointer(buf)) - (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = (*Tgroup)(unsafe.Pointer(gr)).Fgr_name + uintptr((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRNAMELEN)]) - (*Tgroup)(unsafe.Pointer(gr)).Fgr_gid = Uint32FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRGID)]) - (*Tgroup)(unsafe.Pointer(gr)).Fgr_mem = *(*uintptr)(unsafe.Pointer(mem)) - if *(*uint8)(unsafe.Pointer((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd + uintptr(-Int32FromInt32(1)))) != 0 || *(*uint8)(unsafe.Pointer((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd + uintptr((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRPASSWDLEN)]-int32(1)))) != 0 { + (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = **(**uintptr)(__ccgo_up(buf)) + (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = (*Tgroup)(unsafe.Pointer(gr)).Fgr_name + uintptr((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRNAMELEN)]) + (*Tgroup)(unsafe.Pointer(gr)).Fgr_gid = Uint32FromInt32((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRGID)]) + (*Tgroup)(unsafe.Pointer(gr)).Fgr_mem = **(**uintptr)(__ccgo_up(mem)) + if **(**uint8)(__ccgo_up((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd + uintptr(-Int32FromInt32(1)))) != 0 || **(**uint8)(__ccgo_up((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd + uintptr((**(**[6]Tint32_t)(__ccgo_up(bp + 4)))[int32(GRPASSWDLEN)]-int32(1)))) != 0 { rv = int32(EIO) goto cleanup_f } @@ -125861,7 +125861,7 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz rv = int32(EIO) goto cleanup_f } - *(*uintptr)(unsafe.Pointer(res)) = gr + **(**uintptr)(__ccgo_up(res)) = gr goto cleanup_f cleanup_f: ; @@ -125871,9 +125871,9 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz goto done done: ; - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp)), uintptr(0)) if rv != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = rv + **(**int32)(__ccgo_up(X__errno_location(tls))) = rv } return rv } @@ -125889,42 +125889,42 @@ func _getgr_r(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, size var _ /* mem at bp+16 */ uintptr var _ /* nmem at bp+24 */ Tsize_t _, _ = i, rv - *(*uintptr)(unsafe.Pointer(bp)) = uintptr(0) - *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint64(0) - *(*uintptr)(unsafe.Pointer(bp + 16)) = uintptr(0) - *(*Tsize_t)(unsafe.Pointer(bp + 24)) = uint64(0) + **(**uintptr)(__ccgo_up(bp)) = uintptr(0) + **(**Tsize_t)(__ccgo_up(bp + 8)) = uint64(0) + **(**uintptr)(__ccgo_up(bp + 16)) = uintptr(0) + **(**Tsize_t)(__ccgo_up(bp + 24)) = uint64(0) rv = 0 _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp+32) rv = X__getgr_a(tls, name, gid, gr, bp, bp+8, bp+16, bp+24, res) - if *(*uintptr)(unsafe.Pointer(res)) != 0 && size < *(*Tsize_t)(unsafe.Pointer(bp + 8))+(*(*Tsize_t)(unsafe.Pointer(bp + 24))+uint64(1))*uint64(8)+uint64(32) { - *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) + if **(**uintptr)(__ccgo_up(res)) != 0 && size < **(**Tsize_t)(__ccgo_up(bp + 8))+(**(**Tsize_t)(__ccgo_up(bp + 24))+uint64(1))*uint64(8)+uint64(32) { + **(**uintptr)(__ccgo_up(res)) = uintptr(0) rv = int32(ERANGE) } - if *(*uintptr)(unsafe.Pointer(res)) != 0 { + if **(**uintptr)(__ccgo_up(res)) != 0 { buf = buf + uintptr((uint64(16)-uint64(buf))%uint64(16)) (*Tgroup)(unsafe.Pointer(gr)).Fgr_mem = buf - buf = buf + uintptr((*(*Tsize_t)(unsafe.Pointer(bp + 24))+uint64(1))*uint64(8)) - Xmemcpy(tls, buf, *(*uintptr)(unsafe.Pointer(bp)), *(*Tsize_t)(unsafe.Pointer(bp + 8))) - (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = uintptr(int64((*Tgroup)(unsafe.Pointer(gr)).Fgr_name)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf - (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = uintptr(int64((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf + buf = buf + uintptr((**(**Tsize_t)(__ccgo_up(bp + 24))+uint64(1))*uint64(8)) + Xmemcpy(tls, buf, **(**uintptr)(__ccgo_up(bp)), **(**Tsize_t)(__ccgo_up(bp + 8))) + (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = uintptr(int64((*Tgroup)(unsafe.Pointer(gr)).Fgr_name)-int64(**(**uintptr)(__ccgo_up(bp)))) + buf + (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = uintptr(int64((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd)-int64(**(**uintptr)(__ccgo_up(bp)))) + buf i = uint64(0) for { - if !(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + uintptr(i)*8)) != 0) { + if !(**(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 16)) + uintptr(i)*8)) != 0) { break } - *(*uintptr)(unsafe.Pointer((*Tgroup)(unsafe.Pointer(gr)).Fgr_mem + uintptr(i)*8)) = uintptr(int64(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + uintptr(i)*8)))-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf + **(**uintptr)(__ccgo_up((*Tgroup)(unsafe.Pointer(gr)).Fgr_mem + uintptr(i)*8)) = uintptr(int64(**(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 16)) + uintptr(i)*8)))-int64(**(**uintptr)(__ccgo_up(bp)))) + buf goto _1 _1: ; i = i + 1 } - *(*uintptr)(unsafe.Pointer((*Tgroup)(unsafe.Pointer(gr)).Fgr_mem + uintptr(i)*8)) = uintptr(0) + **(**uintptr)(__ccgo_up((*Tgroup)(unsafe.Pointer(gr)).Fgr_mem + uintptr(i)*8)) = uintptr(0) } - Xfree(tls, *(*uintptr)(unsafe.Pointer(bp + 16))) - Xfree(tls, *(*uintptr)(unsafe.Pointer(bp))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 32)), uintptr(0)) + Xfree(tls, **(**uintptr)(__ccgo_up(bp + 16))) + Xfree(tls, **(**uintptr)(__ccgo_up(bp))) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 32)), uintptr(0)) if rv != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = rv + **(**int32)(__ccgo_up(X__errno_location(tls))) = rv } return rv } @@ -125970,8 +125970,8 @@ func Xgetgrent(tls *TLS) (r uintptr) { var _ /* nmem at bp+16 */ Tsize_t var _ /* res at bp+0 */ uintptr var _ /* size at bp+8 */ Tsize_t - *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint64(0) - *(*Tsize_t)(unsafe.Pointer(bp + 16)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp + 8)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp + 16)) = uint64(0) if !(_f1 != 0) { _f1 = Xfopen(tls, __ccgo_ts+1265, __ccgo_ts+404) } @@ -125979,7 +125979,7 @@ func Xgetgrent(tls *TLS) (r uintptr) { return uintptr(0) } X__getgrent_a(tls, _f1, uintptr(unsafe.Pointer(&_gr1)), uintptr(unsafe.Pointer(&_line3)), bp+8, uintptr(unsafe.Pointer(&_mem1)), bp+16, bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func Xgetgrgid(tls *TLS, gid Tgid_t) (r uintptr) { @@ -125992,10 +125992,10 @@ func Xgetgrgid(tls *TLS, gid Tgid_t) (r uintptr) { var _ /* nmem at bp+16 */ Tsize_t var _ /* res at bp+0 */ uintptr var _ /* size at bp+8 */ Tsize_t - *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint64(0) - *(*Tsize_t)(unsafe.Pointer(bp + 16)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp + 8)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp + 16)) = uint64(0) X__getgr_a(tls, uintptr(0), gid, uintptr(unsafe.Pointer(&_gr1)), uintptr(unsafe.Pointer(&_line3)), bp+8, uintptr(unsafe.Pointer(&_mem1)), bp+16, bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func Xgetgrnam(tls *TLS, name uintptr) (r uintptr) { @@ -126008,10 +126008,10 @@ func Xgetgrnam(tls *TLS, name uintptr) (r uintptr) { var _ /* nmem at bp+16 */ Tsize_t var _ /* res at bp+0 */ uintptr var _ /* size at bp+8 */ Tsize_t - *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint64(0) - *(*Tsize_t)(unsafe.Pointer(bp + 16)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp + 8)) = uint64(0) + **(**Tsize_t)(__ccgo_up(bp + 16)) = uint64(0) X__getgr_a(tls, name, uint32(0), uintptr(unsafe.Pointer(&_gr1)), uintptr(unsafe.Pointer(&_line3)), bp+8, uintptr(unsafe.Pointer(&_mem1)), bp+16, bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func Xendgrent(tls *TLS) { @@ -126026,14 +126026,14 @@ func _atou(tls *TLS, s uintptr) (r uint32) { _ = x x = uint32(0) for { - if !(Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-int32('0')) < uint32(10)) { + if !(Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-int32('0')) < uint32(10)) { break } - x = uint32(10)*x + Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-Int32FromUint8('0')) + x = uint32(10)*x + Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-Int32FromUint8('0')) goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s)) = *(*uintptr)(unsafe.Pointer(s)) + 1 + **(**uintptr)(__ccgo_up(s)) = **(**uintptr)(__ccgo_up(s)) + 1 } return x } @@ -126059,107 +126059,107 @@ func X__getgrent_a(tls *TLS, f uintptr, gr uintptr, line uintptr, size uintptr, l = v2 if v2 < 0 { if Xferror(tls, f) != 0 { - v3 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v3 = **(**int32)(__ccgo_up(X__errno_location(tls))) } else { v3 = 0 } rv = v3 - Xfree(tls, *(*uintptr)(unsafe.Pointer(line))) - *(*uintptr)(unsafe.Pointer(line)) = uintptr(0) + Xfree(tls, **(**uintptr)(__ccgo_up(line))) + **(**uintptr)(__ccgo_up(line)) = uintptr(0) gr = uintptr(0) goto end } - *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(line)) + uintptr(l-int64(1)))) = uint8(0) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(line)) - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(line)) + uintptr(l-int64(1)))) = uint8(0) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(line)) + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = v4 - v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v4 + v4 = Xstrchr(tls, **(**uintptr)(__ccgo_up(bp)), int32(':')) + **(**uintptr)(__ccgo_up(bp)) = v4 if !(v4 != 0) { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) - (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = *(*uintptr)(unsafe.Pointer(bp)) - v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v4 + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) + (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = **(**uintptr)(__ccgo_up(bp)) + v4 = Xstrchr(tls, **(**uintptr)(__ccgo_up(bp)), int32(':')) + **(**uintptr)(__ccgo_up(bp)) = v4 if !(v4 != 0) { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) (*Tgroup)(unsafe.Pointer(gr)).Fgr_gid = _atou(tls, bp) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32(':') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) != int32(':') { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) - mems = *(*uintptr)(unsafe.Pointer(bp)) + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) + mems = **(**uintptr)(__ccgo_up(bp)) break goto _1 _1: } - *(*Tsize_t)(unsafe.Pointer(nmem)) = BoolUint64(!!(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) != 0)) + **(**Tsize_t)(__ccgo_up(nmem)) = BoolUint64(!!(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))) != 0)) for { - if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) != 0) { + if !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))) != 0) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32(',') { - *(*Tsize_t)(unsafe.Pointer(nmem)) = *(*Tsize_t)(unsafe.Pointer(nmem)) + 1 + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) == int32(',') { + **(**Tsize_t)(__ccgo_up(nmem)) = **(**Tsize_t)(__ccgo_up(nmem)) + 1 } goto _10 _10: ; - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - } - Xfree(tls, *(*uintptr)(unsafe.Pointer(mem))) - *(*uintptr)(unsafe.Pointer(mem)) = Xcalloc(tls, uint64(8), *(*Tsize_t)(unsafe.Pointer(nmem))+uint64(1)) - if !(*(*uintptr)(unsafe.Pointer(mem)) != 0) { - rv = *(*int32)(unsafe.Pointer(X__errno_location(tls))) - Xfree(tls, *(*uintptr)(unsafe.Pointer(line))) - *(*uintptr)(unsafe.Pointer(line)) = uintptr(0) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + } + Xfree(tls, **(**uintptr)(__ccgo_up(mem))) + **(**uintptr)(__ccgo_up(mem)) = Xcalloc(tls, uint64(8), **(**Tsize_t)(__ccgo_up(nmem))+uint64(1)) + if !(**(**uintptr)(__ccgo_up(mem)) != 0) { + rv = **(**int32)(__ccgo_up(X__errno_location(tls))) + Xfree(tls, **(**uintptr)(__ccgo_up(line))) + **(**uintptr)(__ccgo_up(line)) = uintptr(0) gr = uintptr(0) goto end } - if *(*uint8)(unsafe.Pointer(mems)) != 0 { - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)))) = mems - *(*uintptr)(unsafe.Pointer(bp)) = mems + if **(**uint8)(__ccgo_up(mems)) != 0 { + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)))) = mems + **(**uintptr)(__ccgo_up(bp)) = mems i = Uint64FromInt32(0) for { - if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) != 0) { + if !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))) != 0) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32(',') { - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) == int32(',') { + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) i = i + 1 v13 = i - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v13)*8)) = *(*uintptr)(unsafe.Pointer(bp)) + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)) + uintptr(v13)*8)) = **(**uintptr)(__ccgo_up(bp)) } goto _11 _11: ; - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 } i = i + 1 v13 = i - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v13)*8)) = uintptr(0) + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)) + uintptr(v13)*8)) = uintptr(0) } else { - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)))) = uintptr(0) + **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(mem)))) = uintptr(0) } - (*Tgroup)(unsafe.Pointer(gr)).Fgr_mem = *(*uintptr)(unsafe.Pointer(mem)) + (*Tgroup)(unsafe.Pointer(gr)).Fgr_mem = **(**uintptr)(__ccgo_up(mem)) goto end end: ; - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 8)), uintptr(0)) - *(*uintptr)(unsafe.Pointer(res)) = gr + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 8)), uintptr(0)) + **(**uintptr)(__ccgo_up(res)) = gr if rv != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = rv + **(**int32)(__ccgo_up(X__errno_location(tls))) = rv } return rv } @@ -126188,44 +126188,44 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, i, n, nbytes, nlim, nscdbuf, ret, rv, v1, v14, v3, v4, v6, v9 ret = -int32(1) n = int64(1) - *(*int32)(unsafe.Pointer(bp + 40)) = 0 + **(**int32)(__ccgo_up(bp + 40)) = 0 nscdbuf = uintptr(0) - *(*uintptr)(unsafe.Pointer(bp + 56)) = uintptr(0) - *(*uintptr)(unsafe.Pointer(bp + 64)) = uintptr(0) - *(*Tsize_t)(unsafe.Pointer(bp + 72)) = uint64(0) - nlim = *(*int32)(unsafe.Pointer(ngroups)) + **(**uintptr)(__ccgo_up(bp + 56)) = uintptr(0) + **(**uintptr)(__ccgo_up(bp + 64)) = uintptr(0) + **(**Tsize_t)(__ccgo_up(bp + 72)) = uint64(0) + nlim = **(**int32)(__ccgo_up(ngroups)) if nlim >= int32(1) { v1 = groups groups += 4 - *(*Tgid_t)(unsafe.Pointer(v1)) = gid + **(**Tgid_t)(__ccgo_up(v1)) = gid } f = X__nscd_query(tls, int32(GETINITGR), user, bp+44, uint64(12), bp+40) if !(f != 0) { goto cleanup } - if (*(*[3]Tint32_t)(unsafe.Pointer(bp + 44)))[int32(INITGRFOUND)] != 0 { - nscdbuf = Xcalloc(tls, Uint64FromInt32((*(*[3]Tint32_t)(unsafe.Pointer(bp + 44)))[int32(INITGRNGRPS)]), uint64(4)) + if (**(**[3]Tint32_t)(__ccgo_up(bp + 44)))[int32(INITGRFOUND)] != 0 { + nscdbuf = Xcalloc(tls, Uint64FromInt32((**(**[3]Tint32_t)(__ccgo_up(bp + 44)))[int32(INITGRNGRPS)]), uint64(4)) if !(nscdbuf != 0) { goto cleanup } - nbytes = uint64(4) * Uint64FromInt32((*(*[3]Tint32_t)(unsafe.Pointer(bp + 44)))[int32(INITGRNGRPS)]) + nbytes = uint64(4) * Uint64FromInt32((**(**[3]Tint32_t)(__ccgo_up(bp + 44)))[int32(INITGRNGRPS)]) if nbytes != 0 && !(Xfread(tls, nscdbuf, nbytes, uint64(1), f) != 0) { if !(Xferror(tls, f) != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EIO) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EIO) } goto cleanup } - if *(*int32)(unsafe.Pointer(bp + 40)) != 0 { + if **(**int32)(__ccgo_up(bp + 40)) != 0 { i = 0 for { - if !(i < int64((*(*[3]Tint32_t)(unsafe.Pointer(bp + 44)))[int32(INITGRNGRPS)])) { + if !(i < int64((**(**[3]Tint32_t)(__ccgo_up(bp + 44)))[int32(INITGRNGRPS)])) { break } - v3 = *(*Tuint32_t)(unsafe.Pointer(nscdbuf + uintptr(i)*4)) + v3 = **(**Tuint32_t)(__ccgo_up(nscdbuf + uintptr(i)*4)) v4 = v3>>int32(24) | v3>>int32(8)&uint32(0xff00) | v3<= Uint64FromUint64(0xffffffffffffffff)/Uint64FromInt32(8) { + if Uint64FromInt32((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWNAMELEN)]|(**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWPASSWDLEN)]|(**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWGECOSLEN)]|(**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWDIRLEN)]|(**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWSHELLLEN)]) >= Uint64FromUint64(0xffffffffffffffff)/Uint64FromInt32(8) { rv = int32(ENOMEM) goto cleanup_f } - len1 = Uint64FromInt32((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWNAMELEN)] + (*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWPASSWDLEN)] + (*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWGECOSLEN)] + (*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWDIRLEN)] + (*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWSHELLLEN)]) - if len1 > *(*Tsize_t)(unsafe.Pointer(size)) || !(*(*uintptr)(unsafe.Pointer(buf)) != 0) { - tmp = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(buf)), len1) + len1 = Uint64FromInt32((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWNAMELEN)] + (**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWPASSWDLEN)] + (**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWGECOSLEN)] + (**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWDIRLEN)] + (**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWSHELLLEN)]) + if len1 > **(**Tsize_t)(__ccgo_up(size)) || !(**(**uintptr)(__ccgo_up(buf)) != 0) { + tmp = Xrealloc(tls, **(**uintptr)(__ccgo_up(buf)), len1) if !(tmp != 0) { - rv = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + rv = **(**int32)(__ccgo_up(X__errno_location(tls))) goto cleanup_f } - *(*uintptr)(unsafe.Pointer(buf)) = tmp - *(*Tsize_t)(unsafe.Pointer(size)) = len1 + **(**uintptr)(__ccgo_up(buf)) = tmp + **(**Tsize_t)(__ccgo_up(size)) = len1 } - if !(Xfread(tls, *(*uintptr)(unsafe.Pointer(buf)), len1, uint64(1), f) != 0) { + if !(Xfread(tls, **(**uintptr)(__ccgo_up(buf)), len1, uint64(1), f) != 0) { if Xferror(tls, f) != 0 { - v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = **(**int32)(__ccgo_up(X__errno_location(tls))) } else { v1 = int32(EIO) } rv = v1 goto cleanup_f } - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = *(*uintptr)(unsafe.Pointer(buf)) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name + uintptr((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWNAMELEN)]) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd + uintptr((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWPASSWDLEN)]) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos + uintptr((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWGECOSLEN)]) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir + uintptr((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWDIRLEN)]) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_uid = Uint32FromInt32((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWUID)]) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gid = Uint32FromInt32((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWGID)]) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = **(**uintptr)(__ccgo_up(buf)) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name + uintptr((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWNAMELEN)]) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd + uintptr((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWPASSWDLEN)]) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos + uintptr((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWGECOSLEN)]) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir + uintptr((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWDIRLEN)]) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_uid = Uint32FromInt32((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWUID)]) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gid = Uint32FromInt32((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWGID)]) /* Don't assume that nscd made sure to null terminate strings. * It's supposed to, but malicious nscd should be ignored * rather than causing a crash. */ - if *(*uint8)(unsafe.Pointer((*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd + uintptr(-Int32FromInt32(1)))) != 0 || *(*uint8)(unsafe.Pointer((*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos + uintptr(-Int32FromInt32(1)))) != 0 || *(*uint8)(unsafe.Pointer((*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir + uintptr(-Int32FromInt32(1)))) != 0 || *(*uint8)(unsafe.Pointer((*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell + uintptr((*(*[9]Tint32_t)(unsafe.Pointer(bp + 8)))[int32(PWSHELLLEN)]-int32(1)))) != 0 { + if **(**uint8)(__ccgo_up((*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd + uintptr(-Int32FromInt32(1)))) != 0 || **(**uint8)(__ccgo_up((*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos + uintptr(-Int32FromInt32(1)))) != 0 || **(**uint8)(__ccgo_up((*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir + uintptr(-Int32FromInt32(1)))) != 0 || **(**uint8)(__ccgo_up((*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell + uintptr((**(**[9]Tint32_t)(__ccgo_up(bp + 8)))[int32(PWSHELLLEN)]-int32(1)))) != 0 { rv = int32(EIO) goto cleanup_f } @@ -126461,7 +126461,7 @@ func X__getpw_a(tls *TLS, name uintptr, uid Tuid_t, pw uintptr, buf uintptr, siz rv = int32(EIO) goto cleanup_f } - *(*uintptr)(unsafe.Pointer(res)) = pw + **(**uintptr)(__ccgo_up(res)) = pw goto cleanup_f cleanup_f: ; @@ -126471,9 +126471,9 @@ func X__getpw_a(tls *TLS, name uintptr, uid Tuid_t, pw uintptr, buf uintptr, siz goto done done: ; - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 4)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 4)), uintptr(0)) if rv != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = rv + **(**int32)(__ccgo_up(X__errno_location(tls))) = rv } return rv } @@ -126486,27 +126486,27 @@ func _getpw_r(tls *TLS, name uintptr, uid Tuid_t, pw uintptr, buf uintptr, size var _ /* len at bp+8 */ Tsize_t var _ /* line at bp+0 */ uintptr _ = rv - *(*uintptr)(unsafe.Pointer(bp)) = uintptr(0) - *(*Tsize_t)(unsafe.Pointer(bp + 8)) = uint64(0) + **(**uintptr)(__ccgo_up(bp)) = uintptr(0) + **(**Tsize_t)(__ccgo_up(bp + 8)) = uint64(0) rv = 0 _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp+16) rv = X__getpw_a(tls, name, uid, pw, bp, bp+8, res) - if *(*uintptr)(unsafe.Pointer(res)) != 0 && size < *(*Tsize_t)(unsafe.Pointer(bp + 8)) { - *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) + if **(**uintptr)(__ccgo_up(res)) != 0 && size < **(**Tsize_t)(__ccgo_up(bp + 8)) { + **(**uintptr)(__ccgo_up(res)) = uintptr(0) rv = int32(ERANGE) } - if *(*uintptr)(unsafe.Pointer(res)) != 0 { - Xmemcpy(tls, buf, *(*uintptr)(unsafe.Pointer(bp)), *(*Tsize_t)(unsafe.Pointer(bp + 8))) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_name)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf + if **(**uintptr)(__ccgo_up(res)) != 0 { + Xmemcpy(tls, buf, **(**uintptr)(__ccgo_up(bp)), **(**Tsize_t)(__ccgo_up(bp + 8))) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_name)-int64(**(**uintptr)(__ccgo_up(bp)))) + buf + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd)-int64(**(**uintptr)(__ccgo_up(bp)))) + buf + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos)-int64(**(**uintptr)(__ccgo_up(bp)))) + buf + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir)-int64(**(**uintptr)(__ccgo_up(bp)))) + buf + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = uintptr(int64((*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell)-int64(**(**uintptr)(__ccgo_up(bp)))) + buf } - Xfree(tls, *(*uintptr)(unsafe.Pointer(bp))) - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 16)), uintptr(0)) + Xfree(tls, **(**uintptr)(__ccgo_up(bp))) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 16)), uintptr(0)) if rv != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = rv + **(**int32)(__ccgo_up(X__errno_location(tls))) = rv } return rv } @@ -126557,7 +126557,7 @@ func Xgetpwent(tls *TLS) (r uintptr) { return uintptr(0) } X__getpwent_a(tls, _f2, uintptr(unsafe.Pointer(&_pw1)), uintptr(unsafe.Pointer(&_line4)), uintptr(unsafe.Pointer(&_size)), bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func Xgetpwuid(tls *TLS, uid Tuid_t) (r uintptr) { @@ -126569,7 +126569,7 @@ func Xgetpwuid(tls *TLS, uid Tuid_t) (r uintptr) { defer tls.Free(16) var _ /* res at bp+0 */ uintptr X__getpw_a(tls, uintptr(0), uid, uintptr(unsafe.Pointer(&_pw1)), uintptr(unsafe.Pointer(&_line4)), uintptr(unsafe.Pointer(&_size)), bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func Xgetpwnam(tls *TLS, name uintptr) (r uintptr) { @@ -126581,7 +126581,7 @@ func Xgetpwnam(tls *TLS, name uintptr) (r uintptr) { defer tls.Free(16) var _ /* res at bp+0 */ uintptr X__getpw_a(tls, name, uint32(0), uintptr(unsafe.Pointer(&_pw1)), uintptr(unsafe.Pointer(&_line4)), uintptr(unsafe.Pointer(&_size)), bp) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func Xendpwent(tls *TLS) { @@ -126596,14 +126596,14 @@ func _atou1(tls *TLS, s uintptr) (r uint32) { _ = x x = uint32(0) for { - if !(Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-int32('0')) < uint32(10)) { + if !(Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-int32('0')) < uint32(10)) { break } - x = uint32(10)*x + Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-Int32FromUint8('0')) + x = uint32(10)*x + Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-Int32FromUint8('0')) goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s)) = *(*uintptr)(unsafe.Pointer(s)) + 1 + **(**uintptr)(__ccgo_up(s)) = **(**uintptr)(__ccgo_up(s)) + 1 } return x } @@ -126628,79 +126628,79 @@ func X__getpwent_a(tls *TLS, f uintptr, pw uintptr, line uintptr, size uintptr, l = v2 if v2 < 0 { if Xferror(tls, f) != 0 { - v3 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v3 = **(**int32)(__ccgo_up(X__errno_location(tls))) } else { v3 = 0 } rv = v3 - Xfree(tls, *(*uintptr)(unsafe.Pointer(line))) - *(*uintptr)(unsafe.Pointer(line)) = uintptr(0) + Xfree(tls, **(**uintptr)(__ccgo_up(line))) + **(**uintptr)(__ccgo_up(line)) = uintptr(0) pw = uintptr(0) break } - *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(line)) + uintptr(l-int64(1)))) = uint8(0) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(line)) - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(line)) + uintptr(l-int64(1)))) = uint8(0) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(line)) + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = v4 - v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v4 + v4 = Xstrchr(tls, **(**uintptr)(__ccgo_up(bp)), int32(':')) + **(**uintptr)(__ccgo_up(bp)) = v4 if !(v4 != 0) { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = *(*uintptr)(unsafe.Pointer(bp)) - v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v4 + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = **(**uintptr)(__ccgo_up(bp)) + v4 = Xstrchr(tls, **(**uintptr)(__ccgo_up(bp)), int32(':')) + **(**uintptr)(__ccgo_up(bp)) = v4 if !(v4 != 0) { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) (*Tpasswd)(unsafe.Pointer(pw)).Fpw_uid = _atou1(tls, bp) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32(':') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) != int32(':') { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gid = _atou1(tls, bp) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32(':') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) != int32(':') { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = *(*uintptr)(unsafe.Pointer(bp)) - v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v4 + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = **(**uintptr)(__ccgo_up(bp)) + v4 = Xstrchr(tls, **(**uintptr)(__ccgo_up(bp)), int32(':')) + **(**uintptr)(__ccgo_up(bp)) = v4 if !(v4 != 0) { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = *(*uintptr)(unsafe.Pointer(bp)) - v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v4 + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = **(**uintptr)(__ccgo_up(bp)) + v4 = Xstrchr(tls, **(**uintptr)(__ccgo_up(bp)), int32(':')) + **(**uintptr)(__ccgo_up(bp)) = v4 if !(v4 != 0) { goto _1 } - v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) - (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = *(*uintptr)(unsafe.Pointer(bp)) + v4 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + **(**uint8)(__ccgo_up(v4)) = uint8(0) + (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = **(**uintptr)(__ccgo_up(bp)) break goto _1 _1: } - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 8)), uintptr(0)) - *(*uintptr)(unsafe.Pointer(res)) = pw + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 8)), uintptr(0)) + **(**uintptr)(__ccgo_up(res)) = pw if rv != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = rv + **(**int32)(__ccgo_up(X__errno_location(tls))) = rv } return rv } @@ -126764,7 +126764,7 @@ func X__nscd_query(tls *TLS, req Tint32_t, key uintptr, buf uintptr, len1 Tsize_ var _ /* req_buf at bp+32 */ [3]Tint32_t _, _, _, _, _, _, _ = errno_save, f, fd, i, v1, v3, v4 f = uintptr(0) - *(*[3]Tint32_t)(unsafe.Pointer(bp + 32)) = [3]Tint32_t{ + **(**[3]Tint32_t)(__ccgo_up(bp + 32)) = [3]Tint32_t{ 0: int32(NSCDVERSION), 1: req, 2: Int32FromUint64(Xstrnlen(tls, key, uint64(LOGIN_NAME_MAX)) + uint64(1)), @@ -126779,23 +126779,23 @@ func X__nscd_query(tls *TLS, req Tint32_t, key uintptr, buf uintptr, len1 Tsize_ Fiov_len: _strlen(tls, key) + uint64(1), }, } - *(*Tmsghdr)(unsafe.Pointer(bp + 48)) = Tmsghdr{ + **(**Tmsghdr)(__ccgo_up(bp + 48)) = Tmsghdr{ Fmsg_iov: bp, Fmsg_iovlen: int32(2), } - errno_save = *(*int32)(unsafe.Pointer(X__errno_location(tls))) - *(*int32)(unsafe.Pointer(swap)) = 0 + errno_save = **(**int32)(__ccgo_up(X__errno_location(tls))) + **(**int32)(__ccgo_up(swap)) = 0 goto retry retry: ; Xmemset(tls, buf, 0, len1) - *(*Tint32_t)(unsafe.Pointer(buf)) = int32(NSCDVERSION) + **(**Tint32_t)(__ccgo_up(buf)) = int32(NSCDVERSION) fd = Xsocket(tls, int32(PF_LOCAL), Int32FromInt32(SOCK_STREAM)|Int32FromInt32(SOCK_CLOEXEC), 0) if fd < 0 { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EAFNOSUPPORT) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EAFNOSUPPORT) { f = Xfopen(tls, __ccgo_ts+1288, __ccgo_ts+1298) if f != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = errno_save + **(**int32)(__ccgo_up(X__errno_location(tls))) = errno_save } return f } @@ -126807,7 +126807,7 @@ retry: Xclose(tls, fd) return uintptr(0) } - if (*(*[3]Tint32_t)(unsafe.Pointer(bp + 32)))[int32(2)] > int32(LOGIN_NAME_MAX) { + if (**(**[3]Tint32_t)(__ccgo_up(bp + 32)))[int32(2)] > int32(LOGIN_NAME_MAX) { return f } if Xconnect(tls, fd, uintptr(unsafe.Pointer(&_addr)), uint32(24)) < 0 { @@ -126815,8 +126815,8 @@ retry: * result and the caller is responsible for calling * fclose on the (unconnected) socket. The value of * errno must be left unchanged in this case. */ - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EACCES) || *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ECONNREFUSED) || *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENOENT) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = errno_save + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EACCES) || **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ECONNREFUSED) || **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENOENT) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = errno_save return f } goto error @@ -126833,41 +126833,41 @@ retry: if Xferror(tls, f) != 0 { goto error } - if !(*(*int32)(unsafe.Pointer(swap)) != 0) { + if !(**(**int32)(__ccgo_up(swap)) != 0) { Xfclose(tls, f) i = uint64(0) for { if !(i < Uint64FromInt64(12)/Uint64FromInt64(4)) { break } - v3 = Uint32FromInt32((*(*[3]Tint32_t)(unsafe.Pointer(bp + 32)))[i]) + v3 = Uint32FromInt32((**(**[3]Tint32_t)(__ccgo_up(bp + 32)))[i]) v4 = v3>>int32(24) | v3>>int32(8)&uint32(0xff00) | v3<>int32(24) | v3>>int32(8)&uint32(0xff00) | v3<> int32(16)) - *(*uint16)(unsafe.Pointer(xi + 2*2)) = uint16(x >> int32(32)) + x = uint64(uint32(**(**uint16)(__ccgo_up(xi)))|(uint32(**(**uint16)(__ccgo_up(xi + 1*2)))+0)<> int32(16)) + **(**uint16)(__ccgo_up(xi + 2*2)) = uint16(x >> int32(32)) return x & uint64(0xffffffffffff) } @@ -127177,8 +127177,8 @@ func Xrand_r(tls *TLS, seed uintptr) (r int32) { } var v1 uint32 _ = v1 - v1 = *(*uint32)(unsafe.Pointer(seed))*Uint32FromInt32(1103515245) + Uint32FromInt32(12345) - *(*uint32)(unsafe.Pointer(seed)) = v1 + v1 = **(**uint32)(__ccgo_up(seed))*Uint32FromInt32(1103515245) + Uint32FromInt32(12345) + **(**uint32)(__ccgo_up(seed)) = v1 return Int32FromUint32(_temper(tls, v1) / uint32(2)) } @@ -127237,15 +127237,15 @@ func _lcg64(tls *TLS, x Tuint64_t) (r Tuint64_t) { } func _savestate(tls *TLS) (r uintptr) { - *(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(-Int32FromInt32(1))*4)) = Uint32FromInt32(_n<> int32(16)) - _i = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(-Int32FromInt32(1))*4)) >> Int32FromInt32(8) & uint32(0xff)) - _j = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(-Int32FromInt32(1))*4)) & uint32(0xff)) + _n = Int32FromUint32(**(**Tuint32_t)(__ccgo_up(_x1 + uintptr(-Int32FromInt32(1))*4)) >> int32(16)) + _i = Int32FromUint32(**(**Tuint32_t)(__ccgo_up(_x1 + uintptr(-Int32FromInt32(1))*4)) >> Int32FromInt32(8) & uint32(0xff)) + _j = Int32FromUint32(**(**Tuint32_t)(__ccgo_up(_x1 + uintptr(-Int32FromInt32(1))*4)) & uint32(0xff)) } func ___srandom(tls *TLS, seed uint32) { @@ -127254,7 +127254,7 @@ func ___srandom(tls *TLS, seed uint32) { _, _, _ = k, s, v1 s = uint64(seed) if _n == 0 { - *(*Tuint32_t)(unsafe.Pointer(_x1)) = uint32(s) + **(**Tuint32_t)(__ccgo_up(_x1)) = uint32(s) return } if _n == int32(31) || _n == int32(7) { @@ -127270,14 +127270,14 @@ func ___srandom(tls *TLS, seed uint32) { break } s = _lcg64(tls, s) - *(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(k)*4)) = uint32(s >> int32(32)) + **(**Tuint32_t)(__ccgo_up(_x1 + uintptr(k)*4)) = uint32(s >> int32(32)) goto _2 _2: ; k = k + 1 } /* make sure x contains at least one odd number */ - *(*Tuint32_t)(unsafe.Pointer(_x1)) |= uint32(1) + **(**Tuint32_t)(__ccgo_up(_x1)) |= uint32(1) } func Xsrandom(tls *TLS, seed uint32) { @@ -127350,13 +127350,13 @@ func Xrandom(tls *TLS) (r int64) { _, _, _ = k, v1, v2 ___lock(tls, uintptr(unsafe.Pointer(&_lock3))) if _n == 0 { - v1 = _lcg31(tls, *(*Tuint32_t)(unsafe.Pointer(_x1))) - *(*Tuint32_t)(unsafe.Pointer(_x1)) = v1 + v1 = _lcg31(tls, **(**Tuint32_t)(__ccgo_up(_x1))) + **(**Tuint32_t)(__ccgo_up(_x1)) = v1 k = Int64FromUint32(v1) goto end } - *(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(_i)*4)) += *(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(_j)*4)) - k = Int64FromUint32(*(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(_i)*4)) >> int32(1)) + **(**Tuint32_t)(__ccgo_up(_x1 + uintptr(_i)*4)) += **(**Tuint32_t)(__ccgo_up(_x1 + uintptr(_j)*4)) + k = Int64FromUint32(**(**Tuint32_t)(__ccgo_up(_x1 + uintptr(_i)*4)) >> int32(1)) _i = _i + 1 v2 = _i if v2 == _n { @@ -127562,8 +127562,8 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { defer func() { Xrealloc(tls, b, 0) }() path = Xgetenv(tls, __ccgo_ts+1391) seen_eacces = 0 - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOENT) - if !(*(*uint8)(unsafe.Pointer(file)) != 0) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOENT) + if !(**(**uint8)(__ccgo_up(file)) != 0) { return -int32(1) } if Xstrchr(tls, file, int32('/')) != 0 { @@ -127574,7 +127574,7 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { } k = Xstrnlen(tls, file, Uint64FromInt32(Int32FromInt32(NAME_MAX)+Int32FromInt32(1))) if k > uint64(NAME_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENAMETOOLONG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENAMETOOLONG) return -int32(1) } l = Xstrnlen(tls, path, Uint64FromInt32(Int32FromInt32(PATH_MAX)-Int32FromInt32(1))) + uint64(1) @@ -127586,7 +127586,7 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { if Uint64FromInt64(int64(z)-int64(p)) >= l { v3 = z z = z + 1 - if !(*(*uint8)(unsafe.Pointer(v3)) != 0) { + if !(**(**uint8)(__ccgo_up(v3)) != 0) { break } goto _1 @@ -127595,7 +127595,7 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { *(*uint8)(unsafe.Add(unsafe.Pointer(b), int64(z)-int64(p))) = uint8('/') Xmemcpy(tls, b+uintptr(int64(z)-int64(p))+BoolUintptr(z > p), file, k+uint64(1)) Xexecve(tls, b, argv, envp) - switch *(*int32)(unsafe.Pointer(X__errno_location(tls))) { + switch **(**int32)(__ccgo_up(X__errno_location(tls))) { case int32(EACCES): seen_eacces = int32(1) fallthrough @@ -127607,7 +127607,7 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { } v3 = z z = z + 1 - if !(*(*uint8)(unsafe.Pointer(v3)) != 0) { + if !(**(**uint8)(__ccgo_up(v3)) != 0) { break } goto _1 @@ -127616,7 +127616,7 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { p = z } if seen_eacces != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EACCES) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EACCES) } return -int32(1) } @@ -127653,8 +127653,8 @@ func Xfexecve(tls *TLS, fd int32, argv uintptr, envp uintptr) (r1 int32) { } X__procfdname(tls, bp, Uint32FromInt32(fd)) Xexecve(tls, bp, argv, envp) - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENOENT) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EBADF) + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENOENT) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EBADF) } return -int32(1) } @@ -127891,7 +127891,7 @@ func Xposix_spawnattr_getflags(tls *TLS, attr uintptr, flags uintptr) (r int32) trc("tls=%v attr=%v flags=%v, (%v:)", tls, attr, flags, origin(2)) defer func() { trc("-> %v", r) }() } - *(*int16)(unsafe.Pointer(flags)) = int16((*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__flags) + **(**int16)(__ccgo_up(flags)) = int16((*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__flags) return 0 } @@ -127900,7 +127900,7 @@ func Xposix_spawnattr_getpgroup(tls *TLS, attr uintptr, pgrp uintptr) (r int32) trc("tls=%v attr=%v pgrp=%v, (%v:)", tls, attr, pgrp, origin(2)) defer func() { trc("-> %v", r) }() } - *(*Tpid_t)(unsafe.Pointer(pgrp)) = (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__pgrp + **(**Tpid_t)(__ccgo_up(pgrp)) = (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__pgrp return 0 } @@ -127909,7 +127909,7 @@ func Xposix_spawnattr_getsigdefault(tls *TLS, attr uintptr, def uintptr) (r int3 trc("tls=%v attr=%v def=%v, (%v:)", tls, attr, def, origin(2)) defer func() { trc("-> %v", r) }() } - *(*Tsigset_t)(unsafe.Pointer(def)) = (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__def + **(**Tsigset_t)(__ccgo_up(def)) = (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__def return 0 } @@ -127918,7 +127918,7 @@ func Xposix_spawnattr_getsigmask(tls *TLS, attr uintptr, mask uintptr) (r int32) trc("tls=%v attr=%v mask=%v, (%v:)", tls, attr, mask, origin(2)) defer func() { trc("-> %v", r) }() } - *(*Tsigset_t)(unsafe.Pointer(mask)) = (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__mask + **(**Tsigset_t)(__ccgo_up(mask)) = (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__mask return 0 } @@ -127927,7 +127927,7 @@ func Xposix_spawnattr_init(tls *TLS, attr uintptr) (r int32) { trc("tls=%v attr=%v, (%v:)", tls, attr, origin(2)) defer func() { trc("-> %v", r) }() } - *(*Tposix_spawnattr_t)(unsafe.Pointer(attr)) = Tposix_spawnattr_t{} + **(**Tposix_spawnattr_t)(__ccgo_up(attr)) = Tposix_spawnattr_t{} return 0 } @@ -127992,7 +127992,7 @@ func Xposix_spawnattr_setsigdefault(tls *TLS, attr uintptr, def uintptr) (r int3 trc("tls=%v attr=%v def=%v, (%v:)", tls, attr, def, origin(2)) defer func() { trc("-> %v", r) }() } - (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__def = *(*Tsigset_t)(unsafe.Pointer(def)) + (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__def = **(**Tsigset_t)(__ccgo_up(def)) return 0 } @@ -128001,7 +128001,7 @@ func Xposix_spawnattr_setsigmask(tls *TLS, attr uintptr, mask uintptr) (r int32) trc("tls=%v attr=%v mask=%v, (%v:)", tls, attr, mask, origin(2)) defer func() { trc("-> %v", r) }() } - (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__mask = *(*Tsigset_t)(unsafe.Pointer(mask)) + (*Tposix_spawnattr_t)(unsafe.Pointer(attr)).F__mask = **(**Tsigset_t)(__ccgo_up(mask)) return 0 } @@ -128059,20 +128059,20 @@ func _str_next(tls *TLS, str uintptr, n Tsize_t, step uintptr) (r int32) { var _ /* wc at bp+0 */ Twchar_t _ = k if !(n != 0) { - *(*Tsize_t)(unsafe.Pointer(step)) = uint64(0) + **(**Tsize_t)(__ccgo_up(step)) = uint64(0) return 0 } - if uint32(*(*uint8)(unsafe.Pointer(str))) >= uint32(128) { + if uint32(**(**uint8)(__ccgo_up(str))) >= uint32(128) { k = Xmbtowc(tls, bp, str, n) if k < 0 { - *(*Tsize_t)(unsafe.Pointer(step)) = uint64(1) + **(**Tsize_t)(__ccgo_up(step)) = uint64(1) return -int32(1) } - *(*Tsize_t)(unsafe.Pointer(step)) = Uint64FromInt32(k) - return *(*Twchar_t)(unsafe.Pointer(bp)) + **(**Tsize_t)(__ccgo_up(step)) = Uint64FromInt32(k) + return **(**Twchar_t)(__ccgo_up(bp)) } - *(*Tsize_t)(unsafe.Pointer(step)) = uint64(1) - return Int32FromUint8(*(*uint8)(unsafe.Pointer(str))) + **(**Tsize_t)(__ccgo_up(step)) = uint64(1) + return Int32FromUint8(**(**uint8)(__ccgo_up(str))) } func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r int32) { @@ -128083,43 +128083,43 @@ func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r i var _ /* wc at bp+0 */ Twchar_t _, _, _, _ = esc, k, k1, z esc = 0 - if !(m != 0) || !(*(*uint8)(unsafe.Pointer(pat)) != 0) { - *(*Tsize_t)(unsafe.Pointer(step)) = uint64(0) + if !(m != 0) || !(**(**uint8)(__ccgo_up(pat)) != 0) { + **(**Tsize_t)(__ccgo_up(step)) = uint64(0) return END } - *(*Tsize_t)(unsafe.Pointer(step)) = uint64(1) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) == int32('\\') && *(*uint8)(unsafe.Pointer(pat + 1)) != 0 && !(flags&Int32FromInt32(FNM_NOESCAPE) != 0) { - *(*Tsize_t)(unsafe.Pointer(step)) = uint64(2) + **(**Tsize_t)(__ccgo_up(step)) = uint64(1) + if Int32FromUint8(**(**uint8)(__ccgo_up(pat))) == int32('\\') && **(**uint8)(__ccgo_up(pat + 1)) != 0 && !(flags&Int32FromInt32(FNM_NOESCAPE) != 0) { + **(**Tsize_t)(__ccgo_up(step)) = uint64(2) pat = pat + 1 esc = int32(1) goto escaped } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) == int32('[') { + if Int32FromUint8(**(**uint8)(__ccgo_up(pat))) == int32('[') { k = uint64(1) if k < m { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) == int32('^') || Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) == int32('!') { + if Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k)))) == int32('^') || Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k)))) == int32('!') { k = k + 1 } } if k < m { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) == int32(']') { + if Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k)))) == int32(']') { k = k + 1 } } for { - if !(k < m && *(*uint8)(unsafe.Pointer(pat + uintptr(k))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) != int32(']')) { + if !(k < m && **(**uint8)(__ccgo_up(pat + uintptr(k))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k)))) != int32(']')) { break } - if k+uint64(1) < m && *(*uint8)(unsafe.Pointer(pat + uintptr(k+uint64(1)))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) == int32('[') && (Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k+uint64(1))))) == int32(':') || Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k+uint64(1))))) == int32('.') || Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k+uint64(1))))) == int32('=')) { - z = Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k+uint64(1))))) + if k+uint64(1) < m && **(**uint8)(__ccgo_up(pat + uintptr(k+uint64(1)))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k)))) == int32('[') && (Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k+uint64(1))))) == int32(':') || Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k+uint64(1))))) == int32('.') || Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k+uint64(1))))) == int32('=')) { + z = Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k+uint64(1))))) k = k + uint64(2) - if k < m && *(*uint8)(unsafe.Pointer(pat + uintptr(k))) != 0 { + if k < m && **(**uint8)(__ccgo_up(pat + uintptr(k))) != 0 { k = k + 1 } - for k < m && *(*uint8)(unsafe.Pointer(pat + uintptr(k))) != 0 && (Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k-uint64(1))))) != z || Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) != int32(']')) { + for k < m && **(**uint8)(__ccgo_up(pat + uintptr(k))) != 0 && (Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k-uint64(1))))) != z || Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(k)))) != int32(']')) { k = k + 1 } - if k == m || !(*(*uint8)(unsafe.Pointer(pat + uintptr(k))) != 0) { + if k == m || !(**(**uint8)(__ccgo_up(pat + uintptr(k))) != 0) { break } } @@ -128128,32 +128128,32 @@ func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r i ; k = k + 1 } - if k == m || !(*(*uint8)(unsafe.Pointer(pat + uintptr(k))) != 0) { - *(*Tsize_t)(unsafe.Pointer(step)) = uint64(1) + if k == m || !(**(**uint8)(__ccgo_up(pat + uintptr(k))) != 0) { + **(**Tsize_t)(__ccgo_up(step)) = uint64(1) return int32('[') } - *(*Tsize_t)(unsafe.Pointer(step)) = k + uint64(1) + **(**Tsize_t)(__ccgo_up(step)) = k + uint64(1) return -int32(3) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) == int32('*') { + if Int32FromUint8(**(**uint8)(__ccgo_up(pat))) == int32('*') { return -int32(5) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) == int32('?') { + if Int32FromUint8(**(**uint8)(__ccgo_up(pat))) == int32('?') { return -int32(4) } goto escaped escaped: ; - if uint32(*(*uint8)(unsafe.Pointer(pat))) >= uint32(128) { + if uint32(**(**uint8)(__ccgo_up(pat))) >= uint32(128) { k1 = Xmbtowc(tls, bp, pat, m) if k1 < 0 { - *(*Tsize_t)(unsafe.Pointer(step)) = uint64(0) + **(**Tsize_t)(__ccgo_up(step)) = uint64(0) return -int32(2) } - *(*Tsize_t)(unsafe.Pointer(step)) = Uint64FromInt32(k1 + esc) - return *(*Twchar_t)(unsafe.Pointer(bp)) + **(**Tsize_t)(__ccgo_up(step)) = Uint64FromInt32(k1 + esc) + return **(**Twchar_t)(__ccgo_up(bp)) } - return Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) + return Int32FromUint8(**(**uint8)(__ccgo_up(pat))) } func _casefold(tls *TLS, k int32) (r int32) { @@ -128180,59 +128180,59 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { _, _, _, _, _ = inv, l, l1, p0, z inv = 0 p = p + 1 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('^') || Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('!') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('^') || Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('!') { inv = int32(1) p = p + 1 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32(']') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32(']') { if k == int32(']') { return BoolInt32(!(inv != 0)) } p = p + 1 } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('-') { if k == int32('-') { return BoolInt32(!(inv != 0)) } p = p + 1 } } - *(*Twchar_t)(unsafe.Pointer(bp)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) + **(**Twchar_t)(__ccgo_up(bp)) = Int32FromUint8(**(**uint8)(__ccgo_up(p + uintptr(-Int32FromInt32(1))))) for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32(']')) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(p))) != int32(']')) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') && Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) != int32(']') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('-') && Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) != int32(']') { l = Xmbtowc(tls, bp+4, p+uintptr(1), uint64(4)) if l < 0 { return 0 } - if *(*Twchar_t)(unsafe.Pointer(bp)) <= *(*Twchar_t)(unsafe.Pointer(bp + 4)) { - if Uint32FromInt32(k)-Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))) <= Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp + 4))-*(*Twchar_t)(unsafe.Pointer(bp))) || Uint32FromInt32(kfold)-Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))) <= Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp + 4))-*(*Twchar_t)(unsafe.Pointer(bp))) { + if **(**Twchar_t)(__ccgo_up(bp)) <= **(**Twchar_t)(__ccgo_up(bp + 4)) { + if Uint32FromInt32(k)-Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))) <= Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp + 4))-**(**Twchar_t)(__ccgo_up(bp))) || Uint32FromInt32(kfold)-Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))) <= Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp + 4))-**(**Twchar_t)(__ccgo_up(bp))) { return BoolInt32(!(inv != 0)) } } p = p + uintptr(l-int32(1)) goto _1 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('[') && (Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32(':') || Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('.') || Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('=')) { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('[') && (Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) == int32(':') || Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) == int32('.') || Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) == int32('=')) { p0 = p + uintptr(2) - z = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) + z = Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) p = p + uintptr(3) - for Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) != z || Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32(']') { + for Int32FromUint8(**(**uint8)(__ccgo_up(p + uintptr(-Int32FromInt32(1))))) != z || Int32FromUint8(**(**uint8)(__ccgo_up(p))) != int32(']') { p = p + 1 } if z == int32(':') && int64(p-uintptr(1))-int64(p0) < int64(16) { Xmemcpy(tls, bp+8, p0, Uint64FromInt64(int64(p-uintptr(1))-int64(p0))) - (*(*[16]uint8)(unsafe.Pointer(bp + 8)))[int64(p-uintptr(1))-int64(p0)] = uint8(0) + (**(**[16]uint8)(__ccgo_up(bp + 8)))[int64(p-uintptr(1))-int64(p0)] = uint8(0) if Xiswctype(tls, Uint32FromInt32(k), Xwctype(tls, bp+8)) != 0 || Xiswctype(tls, Uint32FromInt32(kfold), Xwctype(tls, bp+8)) != 0 { return BoolInt32(!(inv != 0)) } } goto _1 } - if uint32(*(*uint8)(unsafe.Pointer(p))) < uint32(128) { - *(*Twchar_t)(unsafe.Pointer(bp)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + if uint32(**(**uint8)(__ccgo_up(p))) < uint32(128) { + **(**Twchar_t)(__ccgo_up(bp)) = Int32FromUint8(uint8(**(**uint8)(__ccgo_up(p)))) } else { l1 = Xmbtowc(tls, bp, p, uint64(4)) if l1 < 0 { @@ -128240,7 +128240,7 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { } p = p + uintptr(l1-int32(1)) } - if *(*Twchar_t)(unsafe.Pointer(bp)) == k || *(*Twchar_t)(unsafe.Pointer(bp)) == kfold { + if **(**Twchar_t)(__ccgo_up(bp)) == k || **(**Twchar_t)(__ccgo_up(bp)) == kfold { return BoolInt32(!(inv != 0)) } goto _1 @@ -128263,7 +128263,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, endpat, endstr, k, kfold, p, ptail, s, stail, tailcnt, v2, v6, v9 tailcnt = uint64(0) if flags&int32(FNM_PERIOD) != 0 { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(str))) == int32('.') && Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) != int32('.') { + if Int32FromUint8(**(**uint8)(__ccgo_up(str))) == int32('.') && Int32FromUint8(**(**uint8)(__ccgo_up(pat))) != int32('.') { return int32(FNM_NOMATCH) } } @@ -128286,8 +128286,8 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, } return v2 } - str = str + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) - n = n - *(*Tsize_t)(unsafe.Pointer(bp + 8)) + str = str + uintptr(**(**Tsize_t)(__ccgo_up(bp + 8))) + n = n - **(**Tsize_t)(__ccgo_up(bp + 8)) if flags&int32(FNM_CASEFOLD) != 0 { v2 = _casefold(tls, k) } else { @@ -128303,8 +128303,8 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, return int32(FNM_NOMATCH) } } - pat = pat + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) - m = m - *(*Tsize_t)(unsafe.Pointer(bp)) + pat = pat + uintptr(**(**Tsize_t)(__ccgo_up(bp))) + m = m - **(**Tsize_t)(__ccgo_up(bp)) goto _1 } break @@ -128335,7 +128335,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, goto _5 _5: ; - p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(**(**Tsize_t)(__ccgo_up(bp))) } /* Past this point we need not check for UNMATCHABLE in pat, * because all of pat has already been parsed once. */ @@ -128353,8 +128353,8 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, if !(s > str && tailcnt != 0) { break } - if v9 = uint32(*(*uint8)(unsafe.Pointer(s + uintptr(-Int32FromInt32(1))))) < uint32(128); !v9 { - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if v9 = uint32(**(**uint8)(__ccgo_up(s + uintptr(-Int32FromInt32(1))))) < uint32(128); !v9 { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v2 = int32(4) } else { v2 = int32(1) @@ -128366,7 +128366,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, for { s = s - 1 v6 = s - if !(uint32(*(*uint8)(unsafe.Pointer(v6)))-uint32(0x80) < uint32(0x40) && s > str) { + if !(uint32(uint8(**(**uint8)(__ccgo_up(v6))))-uint32(0x80) < uint32(0x40) && s > str) { break } } @@ -128384,7 +128384,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, p = ptail for { c = _pat_next(tls, p, Uint64FromInt64(int64(endpat)-int64(p)), bp, flags) - p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(**(**Tsize_t)(__ccgo_up(bp))) v2 = _str_next(tls, s, Uint64FromInt64(int64(endstr)-int64(s)), bp+8) k = v2 if v2 <= 0 { @@ -128393,7 +128393,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, } break } - s = s + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) + s = s + uintptr(**(**Tsize_t)(__ccgo_up(bp + 8))) if flags&int32(FNM_CASEFOLD) != 0 { v2 = _casefold(tls, k) } else { @@ -128401,7 +128401,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, } kfold = v2 if c == -int32(3) { - if !(_match_bracket(tls, p-uintptr(*(*Tsize_t)(unsafe.Pointer(bp))), k, kfold) != 0) { + if !(_match_bracket(tls, p-uintptr(**(**Tsize_t)(__ccgo_up(bp))), k, kfold) != 0) { return int32(FNM_NOMATCH) } } else { @@ -128421,7 +128421,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, s = str for { c = _pat_next(tls, p, Uint64FromInt64(int64(endpat)-int64(p)), bp, flags) - p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(**(**Tsize_t)(__ccgo_up(bp))) /* Encountering * completes/commits a component */ if c == -int32(5) { pat = p @@ -128439,7 +128439,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, } kfold = v2 if c == -int32(3) { - if !(_match_bracket(tls, p-uintptr(*(*Tsize_t)(unsafe.Pointer(bp))), k, kfold) != 0) { + if !(_match_bracket(tls, p-uintptr(**(**Tsize_t)(__ccgo_up(bp))), k, kfold) != 0) { break } } else { @@ -128447,7 +128447,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, break } } - s = s + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) + s = s + uintptr(**(**Tsize_t)(__ccgo_up(bp + 8))) goto _14 _14: } @@ -128458,7 +128458,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, * char, or past all invalid bytes otherwise. */ k = _str_next(tls, str, Uint64FromInt64(int64(endstr)-int64(str)), bp+8) if k > 0 { - str = str + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) + str = str + uintptr(**(**Tsize_t)(__ccgo_up(bp + 8))) } else { str = str + 1 for { @@ -128490,7 +128490,7 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { for { s = str for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('/')) { + if !(**(**uint8)(__ccgo_up(s)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32('/')) { break } goto _2 @@ -128508,9 +128508,9 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { goto _3 _3: ; - p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(**(**Tsize_t)(__ccgo_up(bp))) } - if c != Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) && (!(*(*uint8)(unsafe.Pointer(s)) != 0) || !(flags&Int32FromInt32(FNM_LEADING_DIR) != 0)) { + if c != Int32FromUint8(**(**uint8)(__ccgo_up(s))) && (!(**(**uint8)(__ccgo_up(s)) != 0) || !(flags&Int32FromInt32(FNM_LEADING_DIR) != 0)) { return int32(FNM_NOMATCH) } if _fnmatch_internal(tls, pat, Uint64FromInt64(int64(p)-int64(pat)), str, Uint64FromInt64(int64(s)-int64(str)), flags) != 0 { @@ -128520,7 +128520,7 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { return 0 } str = s + uintptr(1) - pat = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + pat = p + uintptr(**(**Tsize_t)(__ccgo_up(bp))) goto _1 _1: } @@ -128528,10 +128528,10 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { if flags&int32(FNM_LEADING_DIR) != 0 { s = str for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('/') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32('/') { goto _5 } if !(_fnmatch_internal(tls, pat, Uint64FromInt32(-Int32FromInt32(1)), str, Uint64FromInt64(int64(s)-int64(str)), flags) != 0) { @@ -128581,14 +128581,14 @@ func _append(tls *TLS, tail uintptr, name uintptr, len1 Tsize_t, mark int32) (r if !(new1 != 0) { return -int32(1) } - (*Tmatch)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tail)))).Fnext = new1 + (*Tmatch)(unsafe.Pointer(**(**uintptr)(__ccgo_up(tail)))).Fnext = new1 (*Tmatch)(unsafe.Pointer(new1)).Fnext = UintptrFromInt32(0) Xmemcpy(tls, new1+8, name, len1+uint64(1)) - if mark != 0 && len1 != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(name + uintptr(len1-uint64(1))))) != int32('/') { + if mark != 0 && len1 != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(name + uintptr(len1-uint64(1))))) != int32('/') { *(*uint8)(unsafe.Pointer(new1 + 8 + uintptr(len1))) = uint8('/') *(*uint8)(unsafe.Pointer(new1 + 8 + uintptr(len1+uint64(1)))) = uint8(0) } - *(*uintptr)(unsafe.Pointer(tail)) = new1 + **(**uintptr)(__ccgo_up(tail)) = new1 return 0 } @@ -128608,15 +128608,15 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag } /* Special-case the remaining pattern being all slashes, in * which case we can use caller-passed type if it's a dir. */ - if *(*uint8)(unsafe.Pointer(pat)) != 0 && type1 != int32(DT_DIR) { + if **(**uint8)(__ccgo_up(pat)) != 0 && type1 != int32(DT_DIR) { type1 = 0 } - for pos+uint64(1) < uint64(PATH_MAX) && Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) == int32('/') { + for pos+uint64(1) < uint64(PATH_MAX) && Int32FromUint8(**(**uint8)(__ccgo_up(pat))) == int32('/') { v1 = pos pos = pos + 1 v2 = pat pat = pat + 1 - *(*uint8)(unsafe.Pointer(buf + uintptr(v1))) = *(*uint8)(unsafe.Pointer(v2)) + **(**uint8)(__ccgo_up(buf + uintptr(v1))) = **(**uint8)(__ccgo_up(v2)) } /* Consume maximal [escaped-]literal prefix of pattern, copying * and un-escaping it to the running buffer as we go. */ @@ -128625,10 +128625,10 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag in_bracket = 0 overflow = 0 for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(i)))) != int32('*') && Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(i)))) != int32('?') && (!(in_bracket != 0) || Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(i)))) != int32(']'))) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(i)))) != int32('*') && Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(i)))) != int32('?') && (!(in_bracket != 0) || Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(i)))) != int32(']'))) { break } - if !(*(*uint8)(unsafe.Pointer(pat + uintptr(i))) != 0) { + if !(**(**uint8)(__ccgo_up(pat + uintptr(i))) != 0) { if overflow != 0 { return 0 } @@ -128639,25 +128639,25 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag i = v4 break } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(i)))) == int32('[') { + if Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(i)))) == int32('[') { in_bracket = int32(1) } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(i)))) == int32('\\') && !(flags&Int32FromInt32(GLOB_NOESCAPE) != 0) { + if Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(i)))) == int32('\\') && !(flags&Int32FromInt32(GLOB_NOESCAPE) != 0) { /* Backslashes inside a bracket are (at least by * our interpretation) non-special, so if next * char is ']' we have a complete expression. */ - if in_bracket != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(i+int64(1))))) == int32(']') { + if in_bracket != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(i+int64(1))))) == int32(']') { break } /* Unpaired final backslash never matches. */ - if !(*(*uint8)(unsafe.Pointer(pat + uintptr(i+int64(1)))) != 0) { + if !(**(**uint8)(__ccgo_up(pat + uintptr(i+int64(1)))) != 0) { return 0 } i = i + 1 } } } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(i)))) == int32('/') { + if Int32FromUint8(**(**uint8)(__ccgo_up(pat + uintptr(i)))) == int32('/') { if overflow != 0 { return 0 } @@ -128675,7 +128675,7 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag if pos+Uint64FromInt64(j+Int64FromInt32(1)) < uint64(PATH_MAX) { v4 = j j = j + 1 - *(*uint8)(unsafe.Pointer(buf + uintptr(pos+Uint64FromInt64(v4)))) = *(*uint8)(unsafe.Pointer(pat + uintptr(i))) + **(**uint8)(__ccgo_up(buf + uintptr(pos+Uint64FromInt64(v4)))) = **(**uint8)(__ccgo_up(pat + uintptr(i))) } else { if in_bracket != 0 { overflow = int32(1) @@ -128691,17 +128691,17 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag ; i = i + 1 } - *(*uint8)(unsafe.Pointer(buf + uintptr(pos))) = uint8(0) - if !(*(*uint8)(unsafe.Pointer(pat)) != 0) { + **(**uint8)(__ccgo_up(buf + uintptr(pos))) = uint8(0) + if !(**(**uint8)(__ccgo_up(pat)) != 0) { if flags&int32(GLOB_MARK) != 0 && (!(type1 != 0) || type1 == int32(DT_LNK)) && !(Xstat(tls, buf, bp) != 0) { - if (*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFDIR) { + if (**(**Tstat)(__ccgo_up(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFDIR) { type1 = int32(DT_DIR) } else { type1 = int32(DT_REG) } } if !(type1 != 0) && Xlstat(tls, buf, bp) != 0 { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(ENOENT) && ((*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(ENOENT) && ((*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, **(**int32)(__ccgo_up(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0) { return int32(GLOB_ABORTED) } return 0 @@ -128718,7 +128718,7 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag if p2 != 0 && !(flags&Int32FromInt32(GLOB_NOESCAPE) != 0) { p = p2 for { - if !(p > pat && Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) == int32('\\')) { + if !(p > pat && Int32FromUint8(**(**uint8)(__ccgo_up(p + uintptr(-Int32FromInt32(1))))) == int32('\\')) { break } goto _6 @@ -128738,14 +128738,14 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag } dir = Xopendir(tls, v2) if !(dir != 0) { - if (*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0 { + if (*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, **(**int32)(__ccgo_up(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0 { return int32(GLOB_ABORTED) } return 0 } - old_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + old_errno = **(**int32)(__ccgo_up(X__errno_location(tls))) for { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = 0 + **(**int32)(__ccgo_up(X__errno_location(tls))) = 0 v2 = Xreaddir(tls, dir) de = v2 if !(v2 != 0) { @@ -128760,7 +128760,7 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag continue } if p2 != 0 { - *(*uint8)(unsafe.Pointer(p2)) = uint8(0) + **(**uint8)(__ccgo_up(p2)) = uint8(0) } if flags&int32(GLOB_NOESCAPE) != 0 { v9 = int32(FNM_NOESCAPE) @@ -128778,12 +128778,12 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag } /* With GLOB_PERIOD, don't allow matching . or .. unless * fnmatch would match them with FNM_PERIOD rules in effect. */ - if p2 != 0 && flags&int32(GLOB_PERIOD) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(de + 19))) == int32('.') && (!(*(*uint8)(unsafe.Pointer(de + 19 + 1)) != 0) || Int32FromUint8(*(*uint8)(unsafe.Pointer(de + 19 + 1))) == int32('.') && !(*(*uint8)(unsafe.Pointer(de + 19 + 2)) != 0)) && Xfnmatch(tls, pat, de+19, fnm_flags|int32(FNM_PERIOD)) != 0 { + if p2 != 0 && flags&int32(GLOB_PERIOD) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(de + 19))) == int32('.') && (!(**(**uint8)(__ccgo_up(de + 19 + 1)) != 0) || Int32FromUint8(**(**uint8)(__ccgo_up(de + 19 + 1))) == int32('.') && !(**(**uint8)(__ccgo_up(de + 19 + 2)) != 0)) && Xfnmatch(tls, pat, de+19, fnm_flags|int32(FNM_PERIOD)) != 0 { continue } Xmemcpy(tls, buf+uintptr(pos), de+19, l+uint64(1)) if p2 != 0 { - *(*uint8)(unsafe.Pointer(p2)) = saved_sep + **(**uint8)(__ccgo_up(p2)) = saved_sep } if p2 != 0 { v2 = p2 @@ -128796,15 +128796,15 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag return r } } - readerr = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + readerr = **(**int32)(__ccgo_up(X__errno_location(tls))) if p2 != 0 { - *(*uint8)(unsafe.Pointer(p2)) = saved_sep + **(**uint8)(__ccgo_up(p2)) = saved_sep } Xclosedir(tls, dir) - if readerr != 0 && ((*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0) { + if readerr != 0 && ((*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, **(**int32)(__ccgo_up(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0) { return int32(GLOB_ABORTED) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = old_errno + **(**int32)(__ccgo_up(X__errno_location(tls))) = old_errno return 0 } @@ -128830,7 +128830,7 @@ func _freelist(tls *TLS, head uintptr) { } func _sort(tls *TLS, a uintptr, b uintptr) (r int32) { - return Xstrcmp(tls, *(*uintptr)(unsafe.Pointer(a)), *(*uintptr)(unsafe.Pointer(b))) + return Xstrcmp(tls, **(**uintptr)(__ccgo_up(a)), **(**uintptr)(__ccgo_up(b))) } func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { @@ -128843,25 +128843,25 @@ func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { var _ /* pw at bp+0 */ Tpasswd var _ /* res at bp+48 */ uintptr _, _, _, _, _, _, _, _, _ = delim, home, i, name_end, p, v1, v10, v2, v4 - p = *(*uintptr)(unsafe.Pointer(pat)) + uintptr(1) + p = **(**uintptr)(__ccgo_up(pat)) + uintptr(1) i = uint64(0) name_end = X__strchrnul(tls, p, int32('/')) - v1 = *(*uint8)(unsafe.Pointer(name_end)) + v1 = **(**uint8)(__ccgo_up(name_end)) delim = v1 if v1 != 0 { v2 = name_end name_end = name_end + 1 - *(*uint8)(unsafe.Pointer(v2)) = uint8(0) + **(**uint8)(__ccgo_up(v2)) = uint8(0) } - *(*uintptr)(unsafe.Pointer(pat)) = name_end - if *(*uint8)(unsafe.Pointer(p)) != 0 { + **(**uintptr)(__ccgo_up(pat)) = name_end + if **(**uint8)(__ccgo_up(p)) != 0 { v2 = UintptrFromInt32(0) } else { v2 = Xgetenv(tls, __ccgo_ts+1425) } home = v2 if !(home != 0) { - if *(*uint8)(unsafe.Pointer(p)) != 0 { + if **(**uint8)(__ccgo_up(p)) != 0 { v4 = Xgetpwnam_r(tls, p, bp, buf, uint64(PATH_MAX), bp+48) } else { v4 = Xgetpwuid_r(tls, Xgetuid(tls), bp, buf, uint64(PATH_MAX), bp+48) @@ -128880,7 +128880,7 @@ func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { return int32(GLOB_NOSPACE) _7: ; - if !!(*(*uintptr)(unsafe.Pointer(bp + 48)) != 0) { + if !!(**(**uintptr)(__ccgo_up(bp + 48)) != 0) { goto _9 } _6: @@ -128890,26 +128890,26 @@ func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { ; _8: ; - home = (*(*Tpasswd)(unsafe.Pointer(bp))).Fpw_dir + home = (**(**Tpasswd)(__ccgo_up(bp))).Fpw_dir } - for i < Uint64FromInt32(Int32FromInt32(PATH_MAX)-Int32FromInt32(2)) && *(*uint8)(unsafe.Pointer(home)) != 0 { + for i < Uint64FromInt32(Int32FromInt32(PATH_MAX)-Int32FromInt32(2)) && **(**uint8)(__ccgo_up(home)) != 0 { v10 = i i = i + 1 v2 = home home = home + 1 - *(*uint8)(unsafe.Pointer(buf + uintptr(v10))) = *(*uint8)(unsafe.Pointer(v2)) + **(**uint8)(__ccgo_up(buf + uintptr(v10))) = **(**uint8)(__ccgo_up(v2)) } - if *(*uint8)(unsafe.Pointer(home)) != 0 { + if **(**uint8)(__ccgo_up(home)) != 0 { return int32(GLOB_NOMATCH) } v1 = delim - *(*uint8)(unsafe.Pointer(buf + uintptr(i))) = v1 + **(**uint8)(__ccgo_up(buf + uintptr(i))) = v1 if v1 != 0 { i = i + 1 v10 = i - *(*uint8)(unsafe.Pointer(buf + uintptr(v10))) = uint8(0) + **(**uint8)(__ccgo_up(buf + uintptr(v10))) = uint8(0) } - *(*Tsize_t)(unsafe.Pointer(pos)) = i + **(**Tsize_t)(__ccgo_up(pos)) = i return 0 } @@ -128932,10 +128932,10 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint var _ /* s at bp+4120 */ uintptr var _ /* tail at bp+8 */ uintptr _, _, _, _, _, _, _ = cnt, error1, i, offs, p, pathv, v1 - *(*Tmatch)(unsafe.Pointer(bp)) = struct { + **(**Tmatch)(__ccgo_up(bp)) = struct { Fnext uintptr }{} - *(*uintptr)(unsafe.Pointer(bp + 8)) = bp + **(**uintptr)(__ccgo_up(bp + 8)) = bp if flags&int32(GLOB_DOOFFS) != 0 { v1 = (*Tglob_t)(unsafe.Pointer(g)).Fgl_offs } else { @@ -128951,19 +128951,19 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathc = uint64(0) (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv = UintptrFromInt32(0) } - if *(*uint8)(unsafe.Pointer(pat)) != 0 { + if **(**uint8)(__ccgo_up(pat)) != 0 { p = Xstrdup(tls, pat) if !(p != 0) { return int32(GLOB_NOSPACE) } - (*(*[4096]uint8)(unsafe.Pointer(bp + 16)))[0] = uint8(0) - *(*Tsize_t)(unsafe.Pointer(bp + 4112)) = uint64(0) - *(*uintptr)(unsafe.Pointer(bp + 4120)) = p - if flags&(Int32FromInt32(GLOB_TILDE)|Int32FromInt32(GLOB_TILDE_CHECK)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('~') { + (**(**[4096]uint8)(__ccgo_up(bp + 16)))[0] = uint8(0) + **(**Tsize_t)(__ccgo_up(bp + 4112)) = uint64(0) + **(**uintptr)(__ccgo_up(bp + 4120)) = p + if flags&(Int32FromInt32(GLOB_TILDE)|Int32FromInt32(GLOB_TILDE_CHECK)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('~') { error1 = _expand_tilde(tls, bp+4120, bp+16, bp+4112) } if !(error1 != 0) { - error1 = _do_glob(tls, bp+16, *(*Tsize_t)(unsafe.Pointer(bp + 4112)), 0, *(*uintptr)(unsafe.Pointer(bp + 4120)), flags, __ccgo_fp_errfunc, bp+8) + error1 = _do_glob(tls, bp+16, **(**Tsize_t)(__ccgo_up(bp + 4112)), 0, **(**uintptr)(__ccgo_up(bp + 4120)), flags, __ccgo_fp_errfunc, bp+8) } Xfree(tls, p) } @@ -128972,20 +128972,20 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint return error1 } cnt = uint64(0) - *(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*Tmatch)(unsafe.Pointer(bp))).Fnext + **(**uintptr)(__ccgo_up(bp + 8)) = (**(**Tmatch)(__ccgo_up(bp))).Fnext for { - if !(*(*uintptr)(unsafe.Pointer(bp + 8)) != 0) { + if !(**(**uintptr)(__ccgo_up(bp + 8)) != 0) { break } goto _2 _2: ; - *(*uintptr)(unsafe.Pointer(bp + 8)) = (*Tmatch)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fnext + **(**uintptr)(__ccgo_up(bp + 8)) = (*Tmatch)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp + 8)))).Fnext cnt = cnt + 1 } if !(cnt != 0) { if flags&int32(GLOB_NOCHECK) != 0 { - *(*uintptr)(unsafe.Pointer(bp + 8)) = bp + **(**uintptr)(__ccgo_up(bp + 8)) = bp if _append(tls, bp+8, pat, _strlen(tls, pat), 0) != 0 { return int32(GLOB_NOSPACE) } @@ -129015,7 +129015,7 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint if !(i < offs) { break } - *(*uintptr)(unsafe.Pointer((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(i)*8)) = UintptrFromInt32(0) + **(**uintptr)(__ccgo_up((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(i)*8)) = UintptrFromInt32(0) goto _3 _3: ; @@ -129023,20 +129023,20 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint } } i = uint64(0) - *(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*Tmatch)(unsafe.Pointer(bp))).Fnext + **(**uintptr)(__ccgo_up(bp + 8)) = (**(**Tmatch)(__ccgo_up(bp))).Fnext for { if !(i < cnt) { break } - *(*uintptr)(unsafe.Pointer((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(offs+i)*8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + **(**uintptr)(__ccgo_up((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(offs+i)*8)) = **(**uintptr)(__ccgo_up(bp + 8)) + 8 goto _4 _4: ; - *(*uintptr)(unsafe.Pointer(bp + 8)) = (*Tmatch)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fnext + **(**uintptr)(__ccgo_up(bp + 8)) = (*Tmatch)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp + 8)))).Fnext i = i + 1 } - *(*uintptr)(unsafe.Pointer((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(offs+i)*8)) = UintptrFromInt32(0) - *(*Tsize_t)(unsafe.Pointer(g)) += cnt + **(**uintptr)(__ccgo_up((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(offs+i)*8)) = UintptrFromInt32(0) + **(**Tsize_t)(__ccgo_up(g)) += cnt if !(flags&Int32FromInt32(GLOB_NOSORT) != 0) { Xqsort(tls, (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv+uintptr(offs)*8, cnt, uint64(8), __ccgo_fp(_sort)) } @@ -129054,7 +129054,7 @@ func Xglobfree(tls *TLS, g uintptr) { if !(i < (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathc) { break } - Xfree(tls, *(*uintptr)(unsafe.Pointer((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr((*Tglob_t)(unsafe.Pointer(g)).Fgl_offs+i)*8))-uintptr(uint64(UintptrFromInt32(0)+8))) + Xfree(tls, **(**uintptr)(__ccgo_up((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr((*Tglob_t)(unsafe.Pointer(g)).Fgl_offs+i)*8))-uintptr(uint64(UintptrFromInt32(0)+8))) goto _1 _1: ; @@ -129453,7 +129453,7 @@ func _tre_stack_push(tls *TLS, s uintptr, value Ttre_stack_item) (r Treg_errcode var new_size int32 _, _ = new_buffer, new_size if (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr < (*Ttre_stack_t)(unsafe.Pointer(s)).Fsize { - *(*Ttre_stack_item)(unsafe.Pointer((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr((*Ttre_stack_t)(unsafe.Pointer(s)).Fptr)*8)) = value + **(**Ttre_stack_item)(__ccgo_up((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr((*Ttre_stack_t)(unsafe.Pointer(s)).Fptr)*8)) = value (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr = (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr + 1 } else { if (*Ttre_stack_t)(unsafe.Pointer(s)).Fsize >= (*Ttre_stack_t)(unsafe.Pointer(s)).Fmax_size { @@ -129487,7 +129487,7 @@ func _tre_stack_push_voidptr(tls *TLS, s uintptr, value uintptr) (r Treg_errcode defer tls.Free(16) var _ /* item at bp+0 */ Ttre_stack_item *(*uintptr)(unsafe.Pointer(bp)) = value - return _tre_stack_push(tls, s, *(*Ttre_stack_item)(unsafe.Pointer(bp))) + return _tre_stack_push(tls, s, **(**Ttre_stack_item)(__ccgo_up(bp))) } func _tre_stack_pop_int(tls *TLS, s uintptr) (r int32) { @@ -129497,7 +129497,7 @@ func _tre_stack_pop_int(tls *TLS, s uintptr) (r int32) { v2 = s + 12 *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) - 1 v1 = *(*int32)(unsafe.Pointer(v2)) - return *(*int32)(unsafe.Pointer(&*(*Ttre_stack_item)(unsafe.Pointer((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr(v1)*8)))) + return *(*int32)(unsafe.Pointer(&**(**Ttre_stack_item)(__ccgo_up((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr(v1)*8)))) } func _tre_stack_pop_voidptr(tls *TLS, s uintptr) (r uintptr) { @@ -129597,7 +129597,7 @@ func _tre_expand_macro(tls *TLS, s uintptr) (r uintptr) { _ = i i = 0 for { - if !(_tre_macros[i].Fc != 0 && Int32FromUint8(_tre_macros[i].Fc) != Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))) { + if !(_tre_macros[i].Fc != 0 && Int32FromUint8(_tre_macros[i].Fc) != Int32FromUint8(**(**uint8)(__ccgo_up(s)))) { break } goto _1 @@ -129614,7 +129614,7 @@ func _tre_compare_lit(tls *TLS, a uintptr, b uintptr) (r int32) { la = a lb = b /* assumes the range of valid code_min is < INT_MAX */ - return int32((*Ttre_literal_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(la)))).Fcode_min - (*Ttre_literal_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(lb)))).Fcode_min) + return int32((*Ttre_literal_t)(unsafe.Pointer(**(**uintptr)(__ccgo_up(la)))).Fcode_min - (*Ttre_literal_t)(unsafe.Pointer(**(**uintptr)(__ccgo_up(lb)))).Fcode_min) } type Tliterals = struct { @@ -129632,7 +129632,7 @@ func _tre_new_lit(tls *TLS, p uintptr) (r uintptr) { if (*Tliterals)(unsafe.Pointer(p)).Fcap1 >= Int32FromInt32(1)< max { @@ -129824,7 +129824,7 @@ func _parse_bracket_terms(tls *TLS, ctx uintptr, s uintptr, ls uintptr, neg uint v6 = neg + 4 v2 = *(*int32)(unsafe.Pointer(v6)) *(*int32)(unsafe.Pointer(v6)) = *(*int32)(unsafe.Pointer(v6)) + 1 - *(*Ttre_ctype_t)(unsafe.Pointer(neg + 8 + uintptr(v2)*8)) = class + **(**Ttre_ctype_t)(__ccgo_up(neg + 8 + uintptr(v2)*8)) = class } else { lit = _tre_new_lit(tls, ls) if !(lit != 0) { @@ -129864,23 +129864,23 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { _, _, _, _, _, _, _, _, _, _, _ = err, i, lit, max, min, n, nc, negmax, negmin, node, v1 node = uintptr(0) nc = uintptr(0) - (*(*Tliterals)(unsafe.Pointer(bp))).Fmem = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem - (*(*Tliterals)(unsafe.Pointer(bp))).Flen1 = 0 - (*(*Tliterals)(unsafe.Pointer(bp))).Fcap1 = int32(32) - (*(*Tliterals)(unsafe.Pointer(bp))).Fa = Xmalloc(tls, Uint64FromInt32((*(*Tliterals)(unsafe.Pointer(bp))).Fcap1)*uint64(8)) - if !((*(*Tliterals)(unsafe.Pointer(bp))).Fa != 0) { + (**(**Tliterals)(__ccgo_up(bp))).Fmem = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem + (**(**Tliterals)(__ccgo_up(bp))).Flen1 = 0 + (**(**Tliterals)(__ccgo_up(bp))).Fcap1 = int32(32) + (**(**Tliterals)(__ccgo_up(bp))).Fa = Xmalloc(tls, Uint64FromInt32((**(**Tliterals)(__ccgo_up(bp))).Fcap1)*uint64(8)) + if !((**(**Tliterals)(__ccgo_up(bp))).Fa != 0) { return int32(REG_ESPACE) } - (*(*Tneg)(unsafe.Pointer(bp + 24))).Flen1 = 0 - (*(*Tneg)(unsafe.Pointer(bp + 24))).Fnegate = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('^')) - if (*(*Tneg)(unsafe.Pointer(bp + 24))).Fnegate != 0 { + (**(**Tneg)(__ccgo_up(bp + 24))).Flen1 = 0 + (**(**Tneg)(__ccgo_up(bp + 24))).Fnegate = BoolInt32(Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('^')) + if (**(**Tneg)(__ccgo_up(bp + 24))).Fnegate != 0 { s = s + 1 } err = _parse_bracket_terms(tls, ctx, s, bp, bp+24) if err != REG_OK { goto parse_bracket_done } - if (*(*Tneg)(unsafe.Pointer(bp + 24))).Fnegate != 0 { + if (**(**Tneg)(__ccgo_up(bp + 24))).Fnegate != 0 { /* * With REG_NEWLINE, POSIX requires that newlines are not matched by * any form of a non-matching list. @@ -129896,7 +129896,7 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition = -int32(1) } /* Sort the array if we need to negate it. */ - Xqsort(tls, (*(*Tliterals)(unsafe.Pointer(bp))).Fa, Uint64FromInt32((*(*Tliterals)(unsafe.Pointer(bp))).Flen1), uint64(8), __ccgo_fp(_tre_compare_lit)) + Xqsort(tls, (**(**Tliterals)(__ccgo_up(bp))).Fa, Uint64FromInt32((**(**Tliterals)(__ccgo_up(bp))).Flen1), uint64(8), __ccgo_fp(_tre_compare_lit)) /* extra lit for the last negated range */ lit = _tre_new_lit(tls, bp) if !(lit != 0) { @@ -129907,14 +129907,14 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max = int64(Int32FromInt32(TRE_CHAR_MAX) + Int32FromInt32(1)) (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition = -int32(1) /* negated classes */ - if (*(*Tneg)(unsafe.Pointer(bp + 24))).Flen1 != 0 { - nc = X__tre_mem_alloc_impl(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, 0, UintptrFromInt32(0), 0, Uint64FromInt32((*(*Tneg)(unsafe.Pointer(bp + 24))).Flen1+Int32FromInt32(1))*uint64(8)) + if (**(**Tneg)(__ccgo_up(bp + 24))).Flen1 != 0 { + nc = X__tre_mem_alloc_impl(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, 0, UintptrFromInt32(0), 0, Uint64FromInt32((**(**Tneg)(__ccgo_up(bp + 24))).Flen1+Int32FromInt32(1))*uint64(8)) if !(nc != 0) { err = int32(REG_ESPACE) goto parse_bracket_done } - Xmemcpy(tls, nc, bp+24+8, Uint64FromInt32((*(*Tneg)(unsafe.Pointer(bp + 24))).Flen1)*uint64(8)) - *(*Ttre_ctype_t)(unsafe.Pointer(nc + uintptr((*(*Tneg)(unsafe.Pointer(bp + 24))).Flen1)*8)) = uint64(0) + Xmemcpy(tls, nc, bp+24+8, Uint64FromInt32((**(**Tneg)(__ccgo_up(bp + 24))).Flen1)*uint64(8)) + **(**Ttre_ctype_t)(__ccgo_up(nc + uintptr((**(**Tneg)(__ccgo_up(bp + 24))).Flen1)*8)) = uint64(0) } } /* Build a union of the items in the array, negated if necessary. */ @@ -129923,13 +129923,13 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { negmax = v1 i = 0 for { - if !(i < (*(*Tliterals)(unsafe.Pointer(bp))).Flen1) { + if !(i < (**(**Tliterals)(__ccgo_up(bp))).Flen1) { break } - lit = *(*uintptr)(unsafe.Pointer((*(*Tliterals)(unsafe.Pointer(bp))).Fa + uintptr(i)*8)) + lit = **(**uintptr)(__ccgo_up((**(**Tliterals)(__ccgo_up(bp))).Fa + uintptr(i)*8)) min = int32((*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min) max = int32((*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max) - if (*(*Tneg)(unsafe.Pointer(bp + 24))).Fnegate != 0 { + if (**(**Tneg)(__ccgo_up(bp + 24))).Fnegate != 0 { if min <= negmin { /* Overlap. */ if max+int32(1) >= negmin { @@ -129961,22 +129961,22 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { goto parse_bracket_done parse_bracket_done: ; - Xfree(tls, (*(*Tliterals)(unsafe.Pointer(bp))).Fa) + Xfree(tls, (**(**Tliterals)(__ccgo_up(bp))).Fa) (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition + 1 (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = node return err } func _parse_dup_count(tls *TLS, s uintptr, n uintptr) (r uintptr) { - *(*int32)(unsafe.Pointer(n)) = -int32(1) - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + **(**int32)(__ccgo_up(n)) = -int32(1) + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return s } - *(*int32)(unsafe.Pointer(n)) = 0 + **(**int32)(__ccgo_up(n)) = 0 for { - *(*int32)(unsafe.Pointer(n)) = int32(10)**(*int32)(unsafe.Pointer(n)) + (Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) - int32('0')) + **(**int32)(__ccgo_up(n)) = int32(10)***(**int32)(__ccgo_up(n)) + (Int32FromUint8(**(**uint8)(__ccgo_up(s))) - int32('0')) s = s + 1 - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) || *(*int32)(unsafe.Pointer(n)) > int32(RE_DUP_MAX) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) || **(**int32)(__ccgo_up(n)) > int32(RE_DUP_MAX) { break } goto _1 @@ -129994,26 +129994,26 @@ func _parse_dup(tls *TLS, s uintptr, ere int32, pmin uintptr, pmax uintptr) (r u var _ /* min at bp+0 */ int32 _, _, _, _, _ = v1, v2, v3, v4, v5 s = _parse_dup_count(tls, s, bp) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32(',') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32(',') { s = _parse_dup_count(tls, s+uintptr(1), bp+4) } else { - *(*int32)(unsafe.Pointer(bp + 4)) = *(*int32)(unsafe.Pointer(bp)) + **(**int32)(__ccgo_up(bp + 4)) = **(**int32)(__ccgo_up(bp)) } - if v3 = *(*int32)(unsafe.Pointer(bp + 4)) < *(*int32)(unsafe.Pointer(bp)) && *(*int32)(unsafe.Pointer(bp + 4)) >= 0 || *(*int32)(unsafe.Pointer(bp + 4)) > int32(RE_DUP_MAX) || *(*int32)(unsafe.Pointer(bp)) > int32(RE_DUP_MAX) || *(*int32)(unsafe.Pointer(bp)) < 0; !v3 { + if v3 = **(**int32)(__ccgo_up(bp + 4)) < **(**int32)(__ccgo_up(bp)) && **(**int32)(__ccgo_up(bp + 4)) >= 0 || **(**int32)(__ccgo_up(bp + 4)) > int32(RE_DUP_MAX) || **(**int32)(__ccgo_up(bp)) > int32(RE_DUP_MAX) || **(**int32)(__ccgo_up(bp)) < 0; !v3 { if v2 = !(ere != 0); v2 { v1 = s s = s + 1 } } - if v5 = v3 || v2 && Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) != int32('\\'); !v5 { + if v5 = v3 || v2 && Int32FromUint8(**(**uint8)(__ccgo_up(v1))) != int32('\\'); !v5 { v4 = s s = s + 1 } - if v5 || Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) != int32('}') { + if v5 || Int32FromUint8(**(**uint8)(__ccgo_up(v4))) != int32('}') { return uintptr(0) } - *(*int32)(unsafe.Pointer(pmin)) = *(*int32)(unsafe.Pointer(bp)) - *(*int32)(unsafe.Pointer(pmax)) = *(*int32)(unsafe.Pointer(bp + 4)) + **(**int32)(__ccgo_up(pmin)) = **(**int32)(__ccgo_up(bp)) + **(**int32)(__ccgo_up(pmax)) = **(**int32)(__ccgo_up(bp + 4)) return s } @@ -130076,7 +130076,7 @@ func _parse_atom(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { var _ /* wc at bp+0 */ Twchar_t _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, ere, err, i, len1, node, p, tmp1, tmp11, tmp2, tmp21, v, val, v14, v16 ere = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fcflags & int32(REG_EXTENDED) - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(s))) { case int32('['): goto _1 case int32('\\'): @@ -130118,7 +130118,7 @@ _2: /* extensions: \b, \B, \<, \>, \xHH \x{HHHH} */ s = s + 1 v14 = s - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(v14))) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(v14))) { case 0: return int32(REG_EESCAPE) case int32('b'): @@ -130133,7 +130133,7 @@ _2: s = s + 1 v = 0 len1 = int32(2) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('{') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('{') { len1 = int32(8) s = s + 1 } @@ -130142,7 +130142,7 @@ _2: if !(i < len1 && v < int32(0x110000)) { break } - c = _hexval1(tls, uint32(*(*uint8)(unsafe.Pointer(s + uintptr(i))))) + c = _hexval1(tls, uint32(**(**uint8)(__ccgo_up(s + uintptr(i))))) if c < 0 { break } @@ -130154,7 +130154,7 @@ _2: } s = s + uintptr(i) if len1 == int32(8) { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('}') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32('}') { return int32(REG_EBRACE) } s = s + 1 @@ -130185,9 +130185,9 @@ _2: /* fallthrough */ fallthrough default: - if !(ere != 0) && uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('1') < uint32(9) { + if !(ere != 0) && uint32(**(**uint8)(__ccgo_up(s)))-uint32('1') < uint32(9) { /* back reference */ - val = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) - int32('0') + val = Int32FromUint8(**(**uint8)(__ccgo_up(s))) - int32('0') v14 = ctx + 44 v16 = *(*int32)(unsafe.Pointer(v14)) *(*int32)(unsafe.Pointer(v14)) = *(*int32)(unsafe.Pointer(v14)) + 1 @@ -130242,7 +130242,7 @@ _4: _5: ; /* '$' is special everywhere in EREs, and at the end of a BRE subexpression. */ - if !(ere != 0) && *(*uint8)(unsafe.Pointer(s + 1)) != 0 && (Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) != int32('\\') || Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 2))) != int32(')') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 2))) != int32('|')) { + if !(ere != 0) && **(**uint8)(__ccgo_up(s + 1)) != 0 && (Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) != int32('\\') || Int32FromUint8(**(**uint8)(__ccgo_up(s + 2))) != int32(')') && Int32FromUint8(**(**uint8)(__ccgo_up(s + 2))) != int32('|')) { goto parse_literal } node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(2), int32(ASSERT_AT_EOL), -int32(1)) @@ -130278,17 +130278,17 @@ parse_literal: if len1 < 0 { return int32(REG_BADPAT) } - if (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fcflags&int32(REG_ICASE) != 0 && (Xiswupper(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp)))) != 0 || Xiswlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp)))) != 0) { + if (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fcflags&int32(REG_ICASE) != 0 && (Xiswupper(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp)))) != 0 || Xiswlower(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp)))) != 0) { /* multiple opposite case characters are not supported */ - tmp11 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint32(Xtowupper(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))))), Int32FromUint32(Xtowupper(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))))), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) - tmp21 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint32(Xtowlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))))), Int32FromUint32(Xtowlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))))), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) + tmp11 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint32(Xtowupper(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))))), Int32FromUint32(Xtowupper(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))))), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) + tmp21 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint32(Xtowlower(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))))), Int32FromUint32(Xtowlower(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))))), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) if tmp11 != 0 && tmp21 != 0 { node = _tre_ast_new_union(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, tmp11, tmp21) } else { node = uintptr(0) } } else { - node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, *(*Twchar_t)(unsafe.Pointer(bp)), *(*Twchar_t)(unsafe.Pointer(bp)), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) + node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, **(**Twchar_t)(__ccgo_up(bp)), **(**Twchar_t)(__ccgo_up(bp)), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) } (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition + 1 s = s + uintptr(len1) @@ -130330,7 +130330,7 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { return err } for { - if !(ere != 0) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('\\') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) == int32('(') || ere != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('(') { + if !(ere != 0) && Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('\\') && Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) == int32('(') || ere != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('(') { v1 = _tre_stack_push_voidptr(tls, stack, nunion) err = v1 if v1 != REG_OK { @@ -130359,7 +130359,7 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart = s goto _3 } - if !(ere != 0) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('\\') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) == int32(')') || ere != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32(')') && depth != 0 { + if !(ere != 0) && Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('\\') && Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) == int32(')') || ere != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32(')') && depth != 0 { (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(1), -int32(1), -int32(1)) if !((*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn != 0) { return int32(REG_ESPACE) @@ -130375,52 +130375,52 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { parse_iter: ; for { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('\\') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('*') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32('\\') && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32('*') { if !(ere != 0) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('+') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('?') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('{') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32('+') && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32('?') && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != int32('{') { break } } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('\\') && ere != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('\\') && ere != 0 { break } /* extension: treat \+, \? as repetitions in BRE */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('\\') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) != int32('+') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) != int32('?') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) != int32('{') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('\\') && Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) != int32('+') && Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) != int32('?') && Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) != int32('{') { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('\\') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('\\') { s = s + 1 } /* handle ^* at the start of a BRE. */ - if !(ere != 0) && s == (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart+uintptr(1) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(-Int32FromInt32(1))))) == int32('^') { + if !(ere != 0) && s == (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart+uintptr(1) && Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(-Int32FromInt32(1))))) == int32('^') { break } /* extension: multiple consecutive *+?{,} is unspecified, but (a+)+ has to be supported so accepting a++ makes sense, note however that the RE_DUP_MAX limit can be circumvented: (a{255}){255} uses a lot of memory.. */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('{') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('{') { s = _parse_dup(tls, s+uintptr(1), ere, bp, bp+4) if !(s != 0) { return int32(REG_BADBR) } } else { - *(*int32)(unsafe.Pointer(bp)) = 0 - *(*int32)(unsafe.Pointer(bp + 4)) = -int32(1) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('+') { - *(*int32)(unsafe.Pointer(bp)) = int32(1) + **(**int32)(__ccgo_up(bp)) = 0 + **(**int32)(__ccgo_up(bp + 4)) = -int32(1) + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('+') { + **(**int32)(__ccgo_up(bp)) = int32(1) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('?') { - *(*int32)(unsafe.Pointer(bp + 4)) = int32(1) + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('?') { + **(**int32)(__ccgo_up(bp + 4)) = int32(1) } s = s + 1 } - if *(*int32)(unsafe.Pointer(bp + 4)) == 0 { + if **(**int32)(__ccgo_up(bp + 4)) == 0 { (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(1), -int32(1), -int32(1)) } else { - (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = _tre_ast_new_iter(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn, *(*int32)(unsafe.Pointer(bp)), *(*int32)(unsafe.Pointer(bp + 4)), 0) + (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = _tre_ast_new_iter(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn, **(**int32)(__ccgo_up(bp)), **(**int32)(__ccgo_up(bp + 4)), 0) } if !((*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn != 0) { return int32(REG_ESPACE) @@ -130429,13 +130429,13 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { _9: } nbranch = _tre_ast_new_catenation(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, nbranch, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn) - if ere != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('|') || ere != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32(')') && depth != 0 || !(ere != 0) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('\\') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) == int32(')') || !(ere != 0) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('\\') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) == int32('|') || !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if ere != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('|') || ere != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32(')') && depth != 0 || !(ere != 0) && Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('\\') && Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) == int32(')') || !(ere != 0) && Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('\\') && Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) == int32('|') || !(**(**uint8)(__ccgo_up(s)) != 0) { /* extension: empty branch is unspecified (), (|a), (a|) here they are not rejected but match on empty string */ - c = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) + c = Int32FromUint8(**(**uint8)(__ccgo_up(s))) nunion = _tre_ast_new_union(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, nunion, nbranch) nbranch = uintptr(0) - if c == int32('\\') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) == int32('|') { + if c == int32('\\') && Int32FromUint8(**(**uint8)(__ccgo_up(s + 1))) == int32('|') { s = s + uintptr(2) (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart = s } else { @@ -130581,22 +130581,22 @@ func _tre_purge_regset(tls *TLS, regset uintptr, tnfa uintptr, tag int32) { _, _, _ = i, id, start i = 0 for { - if !(*(*int32)(unsafe.Pointer(regset + uintptr(i)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(regset + uintptr(i)*4)) >= 0) { break } - id = *(*int32)(unsafe.Pointer(regset + uintptr(i)*4)) / int32(2) - start = BoolInt32(!(*(*int32)(unsafe.Pointer(regset + uintptr(i)*4))%Int32FromInt32(2) != 0)) + id = **(**int32)(__ccgo_up(regset + uintptr(i)*4)) / int32(2) + start = BoolInt32(!(**(**int32)(__ccgo_up(regset + uintptr(i)*4))%Int32FromInt32(2) != 0)) if start != 0 { - (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id)*16))).Fso_tag = tag + (**(**Ttre_submatch_data_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id)*16))).Fso_tag = tag } else { - (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id)*16))).Feo_tag = tag + (**(**Ttre_submatch_data_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id)*16))).Feo_tag = tag } goto _1 _1: ; i = i + 1 } - *(*int32)(unsafe.Pointer(regset)) = -int32(1) + **(**int32)(__ccgo_up(regset)) = -int32(1) } // C documentation @@ -130625,20 +130625,20 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u direction = int32(_TRE_TAG_MINIMIZE) if !(first_pass != 0) { (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fend_tag = 0 - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags)) = -int32(1) + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags)) = -int32(1) } regset = Xmalloc(tls, uint64(4)*uint64(((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches+Uint32FromInt32(1))*Uint32FromInt32(2))) if regset == UintptrFromInt32(0) { return int32(REG_ESPACE) } - *(*int32)(unsafe.Pointer(regset)) = -int32(1) + **(**int32)(__ccgo_up(regset)) = -int32(1) orig_regset = regset parents = Xmalloc(tls, uint64(4)*uint64((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches+Uint32FromInt32(1))) if parents == UintptrFromInt32(0) { Xfree(tls, regset) return int32(REG_ESPACE) } - *(*int32)(unsafe.Pointer(parents)) = -int32(1) + **(**int32)(__ccgo_up(parents)) = -int32(1) saved_states = Xmalloc(tls, uint64(8)*uint64((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches+Uint32FromInt32(1))) if saved_states == UintptrFromInt32(0) { Xfree(tls, regset) @@ -130650,7 +130650,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u if !(i <= (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches) { break } - (*(*Ttre_tag_states_t)(unsafe.Pointer(saved_states + uintptr(i)*8))).Ftag = -int32(1) + (**(**Ttre_tag_states_t)(__ccgo_up(saved_states + uintptr(i)*8))).Ftag = -int32(1) goto _1 _1: ; @@ -130689,7 +130689,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u /* Add end of this submatch to regset. */ i1 = 0 for { - if !(*(*int32)(unsafe.Pointer(regset + uintptr(i1)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(regset + uintptr(i1)*4)) >= 0) { break } goto _11 @@ -130697,12 +130697,12 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i1 = i1 + 1 } - *(*int32)(unsafe.Pointer(regset + uintptr(i1)*4)) = id*int32(2) + int32(1) - *(*int32)(unsafe.Pointer(regset + uintptr(i1+int32(1))*4)) = -int32(1) + **(**int32)(__ccgo_up(regset + uintptr(i1)*4)) = id*int32(2) + int32(1) + **(**int32)(__ccgo_up(regset + uintptr(i1+int32(1))*4)) = -int32(1) /* Pop this submatch from the parents stack. */ i1 = 0 for { - if !(*(*int32)(unsafe.Pointer(parents + uintptr(i1)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(parents + uintptr(i1)*4)) >= 0) { break } goto _12 @@ -130710,7 +130710,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i1 = i1 + 1 } - *(*int32)(unsafe.Pointer(parents + uintptr(i1-int32(1))*4)) = -int32(1) + **(**int32)(__ccgo_up(parents + uintptr(i1-int32(1))*4)) = -int32(1) goto _10 _3: ; @@ -130720,7 +130720,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u /* Add start of this submatch to regset. */ i2 = 0 for { - if !(*(*int32)(unsafe.Pointer(regset + uintptr(i2)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(regset + uintptr(i2)*4)) >= 0) { break } goto _13 @@ -130728,12 +130728,12 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i2 = i2 + 1 } - *(*int32)(unsafe.Pointer(regset + uintptr(i2)*4)) = id1 * int32(2) - *(*int32)(unsafe.Pointer(regset + uintptr(i2+int32(1))*4)) = -int32(1) + **(**int32)(__ccgo_up(regset + uintptr(i2)*4)) = id1 * int32(2) + **(**int32)(__ccgo_up(regset + uintptr(i2+int32(1))*4)) = -int32(1) if !(first_pass != 0) { i2 = 0 for { - if !(*(*int32)(unsafe.Pointer(parents + uintptr(i2)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(parents + uintptr(i2)*4)) >= 0) { break } goto _14 @@ -130741,26 +130741,26 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i2 = i2 + 1 } - (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id1)*16))).Fparents = UintptrFromInt32(0) + (**(**Ttre_submatch_data_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id1)*16))).Fparents = UintptrFromInt32(0) if i2 > 0 { p = Xmalloc(tls, uint64(4)*Uint64FromInt32(i2+Int32FromInt32(1))) if p == UintptrFromInt32(0) { status = int32(REG_ESPACE) goto _10 } - (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id1)*16))).Fparents = p + (**(**Ttre_submatch_data_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id1)*16))).Fparents = p i2 = 0 for { - if !(*(*int32)(unsafe.Pointer(parents + uintptr(i2)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(parents + uintptr(i2)*4)) >= 0) { break } - *(*int32)(unsafe.Pointer(p + uintptr(i2)*4)) = *(*int32)(unsafe.Pointer(parents + uintptr(i2)*4)) + **(**int32)(__ccgo_up(p + uintptr(i2)*4)) = **(**int32)(__ccgo_up(parents + uintptr(i2)*4)) goto _15 _15: ; i2 = i2 + 1 } - *(*int32)(unsafe.Pointer(p + uintptr(i2)*4)) = -int32(1) + **(**int32)(__ccgo_up(p + uintptr(i2)*4)) = -int32(1) } } /* Add end of this submatch to regset after processing this @@ -130778,16 +130778,16 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u case int32(_LITERAL): lit = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj if !((*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min < Int64FromInt32(0)) || (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min == int64(-int32(4)) { - if *(*int32)(unsafe.Pointer(regset)) >= 0 { + if **(**int32)(__ccgo_up(regset)) >= 0 { /* Regset is not empty, so add a tag before the literal or backref. */ if !(first_pass != 0) { status = _tre_add_tag_left(tls, mem, node, tag) - *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = direction + **(**Ttre_tag_direction_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = direction if minimal_tag >= 0 { i3 = 0 for { - if !(*(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3)*4)) >= 0) { break } goto _16 @@ -130795,9 +130795,9 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i3 = i3 + 1 } - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3)*4)) = tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3+int32(1))*4)) = minimal_tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3+int32(2))*4)) = -int32(1) + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3)*4)) = tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3+int32(1))*4)) = minimal_tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) num_minimals = num_minimals + 1 } @@ -130805,7 +130805,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u } else { (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fnum_tags = int32(1) } - *(*int32)(unsafe.Pointer(regset)) = -int32(1) + **(**int32)(__ccgo_up(regset)) = -int32(1) tag = next_tag num_tags = num_tags + 1 next_tag = next_tag + 1 @@ -130865,7 +130865,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u case int32(_ITERATION): iter = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj if first_pass != 0 { - status = _tre_stack_push_int(tls, stack, BoolInt32(*(*int32)(unsafe.Pointer(regset)) >= 0 || int32(uint32(*(*uint8)(unsafe.Pointer(iter + 16))&0x1>>0)) != 0)) + status = _tre_stack_push_int(tls, stack, BoolInt32(**(**int32)(__ccgo_up(regset)) >= 0 || int32(uint32(*(*uint8)(unsafe.Pointer(iter + 16))&0x1>>0)) != 0)) if status != REG_OK { break } @@ -130896,18 +130896,18 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u break } /* Regset is not empty, so add a tag here. */ - if *(*int32)(unsafe.Pointer(regset)) >= 0 || int32(uint32(*(*uint8)(unsafe.Pointer(iter + 16))&0x1>>0)) != 0 { + if **(**int32)(__ccgo_up(regset)) >= 0 || int32(uint32(*(*uint8)(unsafe.Pointer(iter + 16))&0x1>>0)) != 0 { if !(first_pass != 0) { status = _tre_add_tag_left(tls, mem, node, tag) if int32(uint32(*(*uint8)(unsafe.Pointer(iter + 16))&0x1>>0)) != 0 { - *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = int32(_TRE_TAG_MAXIMIZE) + **(**Ttre_tag_direction_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = int32(_TRE_TAG_MAXIMIZE) } else { - *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = direction + **(**Ttre_tag_direction_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = direction } if minimal_tag >= 0 { i4 = 0 for { - if !(*(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4)*4)) >= 0) { break } goto _17 @@ -130915,15 +130915,15 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i4 = i4 + 1 } - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4)*4)) = tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4+int32(1))*4)) = minimal_tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4+int32(2))*4)) = -int32(1) + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4)*4)) = tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4+int32(1))*4)) = minimal_tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) num_minimals = num_minimals + 1 } _tre_purge_regset(tls, regset, tnfa, tag) } - *(*int32)(unsafe.Pointer(regset)) = -int32(1) + **(**int32)(__ccgo_up(regset)) = -int32(1) tag = next_tag num_tags = num_tags + 1 next_tag = next_tag + 1 @@ -130933,7 +130933,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u uni = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj left1 = (*Ttre_union_t)(unsafe.Pointer(uni)).Fleft right1 = (*Ttre_union_t)(unsafe.Pointer(uni)).Fright - if *(*int32)(unsafe.Pointer(regset)) >= 0 { + if **(**int32)(__ccgo_up(regset)) >= 0 { left_tag = next_tag right_tag = next_tag + int32(1) } else { @@ -130953,7 +130953,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u if status != REG_OK { break } - status = _tre_stack_push_int(tls, stack, BoolInt32(*(*int32)(unsafe.Pointer(regset)) >= 0)) + status = _tre_stack_push_int(tls, stack, BoolInt32(**(**int32)(__ccgo_up(regset)) >= 0)) if status != REG_OK { break } @@ -130997,14 +130997,14 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u break } /* Regset is not empty, so add a tag here. */ - if *(*int32)(unsafe.Pointer(regset)) >= 0 { + if **(**int32)(__ccgo_up(regset)) >= 0 { if !(first_pass != 0) { status = _tre_add_tag_left(tls, mem, node, tag) - *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = direction + **(**Ttre_tag_direction_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag)*4)) = direction if minimal_tag >= 0 { i5 = 0 for { - if !(*(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5)*4)) >= 0) { break } goto _18 @@ -131012,15 +131012,15 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i5 = i5 + 1 } - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5)*4)) = tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5+int32(1))*4)) = minimal_tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5+int32(2))*4)) = -int32(1) + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5)*4)) = tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5+int32(1))*4)) = minimal_tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) num_minimals = num_minimals + 1 } _tre_purge_regset(tls, regset, tnfa, tag) } - *(*int32)(unsafe.Pointer(regset)) = -int32(1) + **(**int32)(__ccgo_up(regset)) = -int32(1) tag = next_tag num_tags = num_tags + 1 next_tag = next_tag + 1 @@ -131037,7 +131037,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u /* Push this submatch on the parents stack. */ i6 = 0 for { - if !(*(*int32)(unsafe.Pointer(parents + uintptr(i6)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(parents + uintptr(i6)*4)) >= 0) { break } goto _19 @@ -131045,8 +131045,8 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i6 = i6 + 1 } - *(*int32)(unsafe.Pointer(parents + uintptr(i6)*4)) = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fsubmatch_id - *(*int32)(unsafe.Pointer(parents + uintptr(i6+int32(1))*4)) = -int32(1) + **(**int32)(__ccgo_up(parents + uintptr(i6)*4)) = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fsubmatch_id + **(**int32)(__ccgo_up(parents + uintptr(i6+int32(1))*4)) = -int32(1) } goto _10 /* end case: ADDTAGS_RECURSE */ _4: @@ -131094,7 +131094,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u will be restored at ADDTAGS_AFTER_UNION_RIGHT below. */ _21: ; - if !(*(*int32)(unsafe.Pointer(regset)) >= 0) { + if !(**(**int32)(__ccgo_up(regset)) >= 0) { goto _20 } regset += 4 @@ -131131,11 +131131,11 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u if (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fnum_submatches > 0 { if !(first_pass != 0) { status = _tre_add_tag_right(tls, mem, left2, tag_left) - *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag_left)*4)) = int32(_TRE_TAG_MAXIMIZE) + **(**Ttre_tag_direction_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag_left)*4)) = int32(_TRE_TAG_MAXIMIZE) if status == REG_OK { status = _tre_add_tag_right(tls, mem, right2, tag_right) } - *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag_right)*4)) = int32(_TRE_TAG_MAXIMIZE) + **(**Ttre_tag_direction_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag_right)*4)) = int32(_TRE_TAG_MAXIMIZE) } num_tags = num_tags + int32(2) } @@ -131153,7 +131153,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u if !(first_pass != 0) && minimal_tag >= 0 { i7 = 0 for { - if !(*(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7)*4)) >= 0) { break } goto _23 @@ -131161,9 +131161,9 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u ; i7 = i7 + 1 } - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7)*4)) = tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7+int32(1))*4)) = minimal_tag - *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7+int32(2))*4)) = -int32(1) + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7)*4)) = tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7+int32(1))*4)) = minimal_tag + **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) num_minimals = num_minimals + 1 } @@ -131220,7 +131220,7 @@ func _tre_copy_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, flags i /* XXX - e.g. [ab] has only one position but two nodes, so we are creating holes in the state space here. Not fatal, just wastes memory. */ - pos = pos + *(*int32)(unsafe.Pointer(pos_add)) + pos = pos + **(**int32)(__ccgo_up(pos_add)) num_copied = num_copied + 1 } else { if (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min == int64(-int32(3)) && flags&int32(COPY_REMOVE_TAGS) != 0 { @@ -131232,30 +131232,30 @@ func _tre_copy_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, flags i } else { if (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min == int64(-int32(3)) && flags&int32(COPY_MAXIMIZE_FIRST_TAG) != 0 && first_tag != 0 { /* Maximize the first tag. */ - *(*Ttre_tag_direction_t)(unsafe.Pointer(tag_directions + uintptr(max)*4)) = int32(_TRE_TAG_MAXIMIZE) + **(**Ttre_tag_direction_t)(__ccgo_up(tag_directions + uintptr(max)*4)) = int32(_TRE_TAG_MAXIMIZE) first_tag = 0 } } } - *(*uintptr)(unsafe.Pointer(result)) = _tre_ast_new_literal(tls, mem, min, max, pos) - if *(*uintptr)(unsafe.Pointer(result)) == UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(result)) = _tre_ast_new_literal(tls, mem, min, max, pos) + if **(**uintptr)(__ccgo_up(result)) == UintptrFromInt32(0) { status = int32(REG_ESPACE) } else { - p = (*Ttre_ast_node_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(result)))).Fobj + p = (*Ttre_ast_node_t)(unsafe.Pointer(**(**uintptr)(__ccgo_up(result)))).Fobj (*Ttre_literal_t)(unsafe.Pointer(p)).Fclass = (*Ttre_literal_t)(unsafe.Pointer(lit)).Fclass (*Ttre_literal_t)(unsafe.Pointer(p)).Fneg_classes = (*Ttre_literal_t)(unsafe.Pointer(lit)).Fneg_classes } - if pos > *(*int32)(unsafe.Pointer(max_pos)) { - *(*int32)(unsafe.Pointer(max_pos)) = pos + if pos > **(**int32)(__ccgo_up(max_pos)) { + **(**int32)(__ccgo_up(max_pos)) = pos } case int32(_UNION): uni = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj - *(*uintptr)(unsafe.Pointer(result)) = _tre_ast_new_union(tls, mem, (*Ttre_union_t)(unsafe.Pointer(uni)).Fleft, (*Ttre_union_t)(unsafe.Pointer(uni)).Fright) - if *(*uintptr)(unsafe.Pointer(result)) == UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(result)) = _tre_ast_new_union(tls, mem, (*Ttre_union_t)(unsafe.Pointer(uni)).Fleft, (*Ttre_union_t)(unsafe.Pointer(uni)).Fright) + if **(**uintptr)(__ccgo_up(result)) == UintptrFromInt32(0) { status = int32(REG_ESPACE) break } - tmp = (*Ttre_ast_node_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(result)))).Fobj + tmp = (*Ttre_ast_node_t)(unsafe.Pointer(**(**uintptr)(__ccgo_up(result)))).Fobj result = tmp status = _tre_stack_push_voidptr(tls, stack, (*Ttre_union_t)(unsafe.Pointer(uni)).Fright) if status != REG_OK { @@ -131283,12 +131283,12 @@ func _tre_copy_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, flags i } case int32(_CATENATION): cat = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj - *(*uintptr)(unsafe.Pointer(result)) = _tre_ast_new_catenation(tls, mem, (*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft, (*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright) - if *(*uintptr)(unsafe.Pointer(result)) == UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(result)) = _tre_ast_new_catenation(tls, mem, (*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft, (*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright) + if **(**uintptr)(__ccgo_up(result)) == UintptrFromInt32(0) { status = int32(REG_ESPACE) break } - tmp1 = (*Ttre_ast_node_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(result)))).Fobj + tmp1 = (*Ttre_ast_node_t)(unsafe.Pointer(**(**uintptr)(__ccgo_up(result)))).Fobj (*Ttre_catenation_t)(unsafe.Pointer(tmp1)).Fleft = UintptrFromInt32(0) (*Ttre_catenation_t)(unsafe.Pointer(tmp1)).Fright = UintptrFromInt32(0) result = tmp1 @@ -131326,12 +131326,12 @@ func _tre_copy_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, flags i if status != REG_OK { break } - *(*uintptr)(unsafe.Pointer(result)) = _tre_ast_new_iter(tls, mem, (*Ttre_iteration_t)(unsafe.Pointer(iter)).Farg, (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmin, (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmax, int32(uint32(*(*uint8)(unsafe.Pointer(iter + 16))&0x1>>0))) - if *(*uintptr)(unsafe.Pointer(result)) == UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(result)) = _tre_ast_new_iter(tls, mem, (*Ttre_iteration_t)(unsafe.Pointer(iter)).Farg, (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmin, (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmax, int32(uint32(*(*uint8)(unsafe.Pointer(iter + 16))&0x1>>0))) + if **(**uintptr)(__ccgo_up(result)) == UintptrFromInt32(0) { status = int32(REG_ESPACE) break } - iter = (*Ttre_ast_node_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(result)))).Fobj + iter = (*Ttre_ast_node_t)(unsafe.Pointer(**(**uintptr)(__ccgo_up(result)))).Fobj result = iter default: break @@ -131339,7 +131339,7 @@ func _tre_copy_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, flags i break } } - *(*int32)(unsafe.Pointer(pos_add)) += num_copied + **(**int32)(__ccgo_up(pos_add)) += num_copied return status } @@ -131367,9 +131367,9 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _status, _status1, bottom, cat, flags, iter, iter1, iter_depth, j, lit, node, pos_add_last, pos_add_save, pos_add_total, seq1, status, symbol, tmp, uni, v2 status = REG_OK bottom = _tre_stack_num_objects(tls, stack) - *(*int32)(unsafe.Pointer(bp)) = 0 + **(**int32)(__ccgo_up(bp)) = 0 pos_add_total = 0 - *(*int32)(unsafe.Pointer(bp + 4)) = 0 + **(**int32)(__ccgo_up(bp + 4)) = 0 iter_depth = 0 _status = _tre_stack_push_voidptr(tls, stack, ast) if _status != REG_OK { @@ -131391,9 +131391,9 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit case int32(_LITERAL): lit = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj if !((*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min < Int64FromInt32(0)) || (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min == int64(-int32(4)) { - *(*int32)(unsafe.Pointer(lit + 16)) += *(*int32)(unsafe.Pointer(bp)) - if (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition > *(*int32)(unsafe.Pointer(bp + 4)) { - *(*int32)(unsafe.Pointer(bp + 4)) = (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition + **(**int32)(__ccgo_up(lit + 16)) += **(**int32)(__ccgo_up(bp)) + if (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition > **(**int32)(__ccgo_up(bp + 4)) { + **(**int32)(__ccgo_up(bp + 4)) = (*Ttre_literal_t)(unsafe.Pointer(lit)).Fposition } } case int32(_UNION): @@ -131434,7 +131434,7 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit } case int32(_ITERATION): iter = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj - status = _tre_stack_push_int(tls, stack, *(*int32)(unsafe.Pointer(bp))) + status = _tre_stack_push_int(tls, stack, **(**int32)(__ccgo_up(bp))) if status != REG_OK { break } @@ -131458,7 +131458,7 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit then don't increase the `pos' fields of the nodes now, it will get done when expanding. */ if (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmin > int32(1) || (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmax > int32(1) { - *(*int32)(unsafe.Pointer(bp)) = 0 + **(**int32)(__ccgo_up(bp)) = 0 } iter_depth = iter_depth + 1 default: @@ -131466,12 +131466,12 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit } case int32(_EXPAND_AFTER_ITER): iter1 = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj - *(*int32)(unsafe.Pointer(bp)) = _tre_stack_pop_int(tls, stack) - pos_add_last = *(*int32)(unsafe.Pointer(bp)) + **(**int32)(__ccgo_up(bp)) = _tre_stack_pop_int(tls, stack) + pos_add_last = **(**int32)(__ccgo_up(bp)) if (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Fmin > int32(1) || (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Fmax > int32(1) { seq1 = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(bp + 8)) = UintptrFromInt32(0) - pos_add_save = *(*int32)(unsafe.Pointer(bp)) + **(**uintptr)(__ccgo_up(bp + 8)) = UintptrFromInt32(0) + pos_add_save = **(**int32)(__ccgo_up(bp)) /* Create a catenated sequence of copies of the node. */ j = 0 for { @@ -131485,15 +131485,15 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit } /* Remove tags from all but the last copy. */ flags = v2 - pos_add_save = *(*int32)(unsafe.Pointer(bp)) + pos_add_save = **(**int32)(__ccgo_up(bp)) status = _tre_copy_ast(tls, mem, stack, (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Farg, flags, bp, tag_directions, bp+16, bp+4) if status != REG_OK { return status } if seq1 != UintptrFromInt32(0) { - seq1 = _tre_ast_new_catenation(tls, mem, seq1, *(*uintptr)(unsafe.Pointer(bp + 16))) + seq1 = _tre_ast_new_catenation(tls, mem, seq1, **(**uintptr)(__ccgo_up(bp + 16))) } else { - seq1 = *(*uintptr)(unsafe.Pointer(bp + 16)) + seq1 = **(**uintptr)(__ccgo_up(bp + 16)) } if seq1 == UintptrFromInt32(0) { return int32(REG_ESPACE) @@ -131505,13 +131505,13 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit } if (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Fmax == -int32(1) { /* No upper limit. */ - pos_add_save = *(*int32)(unsafe.Pointer(bp)) + pos_add_save = **(**int32)(__ccgo_up(bp)) status = _tre_copy_ast(tls, mem, stack, (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Farg, 0, bp, UintptrFromInt32(0), bp+8, bp+4) if status != REG_OK { return status } - *(*uintptr)(unsafe.Pointer(bp + 8)) = _tre_ast_new_iter(tls, mem, *(*uintptr)(unsafe.Pointer(bp + 8)), 0, -int32(1), 0) - if *(*uintptr)(unsafe.Pointer(bp + 8)) == UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(bp + 8)) = _tre_ast_new_iter(tls, mem, **(**uintptr)(__ccgo_up(bp + 8)), 0, -int32(1), 0) + if **(**uintptr)(__ccgo_up(bp + 8)) == UintptrFromInt32(0) { return int32(REG_ESPACE) } } else { @@ -131520,25 +131520,25 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit if !(j < (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Fmax) { break } - pos_add_save = *(*int32)(unsafe.Pointer(bp)) + pos_add_save = **(**int32)(__ccgo_up(bp)) status = _tre_copy_ast(tls, mem, stack, (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Farg, 0, bp, UintptrFromInt32(0), bp+24, bp+4) if status != REG_OK { return status } - if *(*uintptr)(unsafe.Pointer(bp + 8)) != UintptrFromInt32(0) { - *(*uintptr)(unsafe.Pointer(bp + 8)) = _tre_ast_new_catenation(tls, mem, *(*uintptr)(unsafe.Pointer(bp + 24)), *(*uintptr)(unsafe.Pointer(bp + 8))) + if **(**uintptr)(__ccgo_up(bp + 8)) != UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(bp + 8)) = _tre_ast_new_catenation(tls, mem, **(**uintptr)(__ccgo_up(bp + 24)), **(**uintptr)(__ccgo_up(bp + 8))) } else { - *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 24)) + **(**uintptr)(__ccgo_up(bp + 8)) = **(**uintptr)(__ccgo_up(bp + 24)) } - if *(*uintptr)(unsafe.Pointer(bp + 8)) == UintptrFromInt32(0) { + if **(**uintptr)(__ccgo_up(bp + 8)) == UintptrFromInt32(0) { return int32(REG_ESPACE) } tmp = _tre_ast_new_literal(tls, mem, -int32(1), -int32(1), -int32(1)) if tmp == UintptrFromInt32(0) { return int32(REG_ESPACE) } - *(*uintptr)(unsafe.Pointer(bp + 8)) = _tre_ast_new_union(tls, mem, tmp, *(*uintptr)(unsafe.Pointer(bp + 8))) - if *(*uintptr)(unsafe.Pointer(bp + 8)) == UintptrFromInt32(0) { + **(**uintptr)(__ccgo_up(bp + 8)) = _tre_ast_new_union(tls, mem, tmp, **(**uintptr)(__ccgo_up(bp + 8))) + if **(**uintptr)(__ccgo_up(bp + 8)) == UintptrFromInt32(0) { return int32(REG_ESPACE) } goto _3 @@ -131547,12 +131547,12 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit j = j + 1 } } - *(*int32)(unsafe.Pointer(bp)) = pos_add_save + **(**int32)(__ccgo_up(bp)) = pos_add_save if seq1 == UintptrFromInt32(0) { - seq1 = *(*uintptr)(unsafe.Pointer(bp + 8)) + seq1 = **(**uintptr)(__ccgo_up(bp + 8)) } else { - if *(*uintptr)(unsafe.Pointer(bp + 8)) != UintptrFromInt32(0) { - seq1 = _tre_ast_new_catenation(tls, mem, seq1, *(*uintptr)(unsafe.Pointer(bp + 8))) + if **(**uintptr)(__ccgo_up(bp + 8)) != UintptrFromInt32(0) { + seq1 = _tre_ast_new_catenation(tls, mem, seq1, **(**uintptr)(__ccgo_up(bp + 8))) } } if seq1 == UintptrFromInt32(0) { @@ -131562,21 +131562,21 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit (*Ttre_ast_node_t)(unsafe.Pointer(node)).Ftype1 = (*Ttre_ast_node_t)(unsafe.Pointer(seq1)).Ftype1 } iter_depth = iter_depth - 1 - pos_add_total = pos_add_total + (*(*int32)(unsafe.Pointer(bp)) - pos_add_last) + pos_add_total = pos_add_total + (**(**int32)(__ccgo_up(bp)) - pos_add_last) if iter_depth == 0 { - *(*int32)(unsafe.Pointer(bp)) = pos_add_total + **(**int32)(__ccgo_up(bp)) = pos_add_total } default: break } } - *(*int32)(unsafe.Pointer(position)) += pos_add_total + **(**int32)(__ccgo_up(position)) += pos_add_total /* `max_pos' should never be larger than `*position' if the above code works, but just an extra safeguard let's make sure `*position' is set large enough so enough memory will be allocated for the transition table. */ - if *(*int32)(unsafe.Pointer(bp + 4)) > *(*int32)(unsafe.Pointer(position)) { - *(*int32)(unsafe.Pointer(position)) = *(*int32)(unsafe.Pointer(bp + 4)) + if **(**int32)(__ccgo_up(bp + 4)) > **(**int32)(__ccgo_up(position)) { + **(**int32)(__ccgo_up(position)) = **(**int32)(__ccgo_up(bp + 4)) } return status } @@ -131588,9 +131588,9 @@ func _tre_set_empty(tls *TLS, mem Ttre_mem_t) (r uintptr) { if new_set == UintptrFromInt32(0) { return UintptrFromInt32(0) } - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fposition = -int32(1) - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fcode_min = -int32(1) - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fcode_max = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fposition = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fcode_min = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fcode_max = -int32(1) return new_set } @@ -131601,15 +131601,15 @@ func _tre_set_one(tls *TLS, mem Ttre_mem_t, position int32, code_min int32, code if new_set == UintptrFromInt32(0) { return UintptrFromInt32(0) } - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fposition = position - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fcode_min = code_min - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fcode_max = code_max - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fclass = class - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fneg_classes = neg_classes - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set))).Fbackref = backref - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + 1*56))).Fposition = -int32(1) - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + 1*56))).Fcode_min = -int32(1) - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + 1*56))).Fcode_max = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fposition = position + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fcode_min = code_min + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fcode_max = code_max + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fclass = class + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fneg_classes = neg_classes + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set))).Fbackref = backref + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + 1*56))).Fposition = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + 1*56))).Fcode_min = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + 1*56))).Fcode_max = -int32(1) return new_set } @@ -131619,7 +131619,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u _, _, _, _, _, _, _ = i, j, new_set, new_tags, num_tags, s1, s2 num_tags = 0 for { - if !(tags != UintptrFromInt32(0) && *(*int32)(unsafe.Pointer(tags + uintptr(num_tags)*4)) >= 0) { + if !(tags != UintptrFromInt32(0) && **(**int32)(__ccgo_up(tags + uintptr(num_tags)*4)) >= 0) { break } goto _1 @@ -131629,7 +131629,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u } s1 = 0 for { - if !((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fposition >= 0) { + if !((**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fposition >= 0) { break } goto _2 @@ -131639,7 +131639,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u } s2 = 0 for { - if !((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fposition >= 0) { + if !((**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fposition >= 0) { break } goto _3 @@ -131653,22 +131653,22 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u } s1 = 0 for { - if !((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fposition >= 0) { + if !((**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fposition >= 0) { break } - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Fposition = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fposition - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Fcode_min = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fcode_min - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Fcode_max = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fcode_max - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Fassertions = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fassertions | assertions - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Fclass = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fclass - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Fneg_classes = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fneg_classes - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Fbackref = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Fbackref - if (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Ftags == UintptrFromInt32(0) && tags == UintptrFromInt32(0) { - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Ftags = UintptrFromInt32(0) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Fposition = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fposition + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Fcode_min = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fcode_min + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Fcode_max = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fcode_max + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Fassertions = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fassertions | assertions + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Fclass = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fclass + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Fneg_classes = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fneg_classes + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Fbackref = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Fbackref + if (**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Ftags == UintptrFromInt32(0) && tags == UintptrFromInt32(0) { + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Ftags = UintptrFromInt32(0) } else { i = 0 for { - if !((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Ftags != UintptrFromInt32(0) && *(*int32)(unsafe.Pointer((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Ftags + uintptr(i)*4)) >= 0) { + if !((**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Ftags != UintptrFromInt32(0) && **(**int32)(__ccgo_up((**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Ftags + uintptr(i)*4)) >= 0) { break } goto _5 @@ -131685,7 +131685,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u if !(j < i) { break } - *(*int32)(unsafe.Pointer(new_tags + uintptr(j)*4)) = *(*int32)(unsafe.Pointer((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set1 + uintptr(s1)*56))).Ftags + uintptr(j)*4)) + **(**int32)(__ccgo_up(new_tags + uintptr(j)*4)) = **(**int32)(__ccgo_up((**(**Ttre_pos_and_tags_t)(__ccgo_up(set1 + uintptr(s1)*56))).Ftags + uintptr(j)*4)) goto _6 _6: ; @@ -131696,14 +131696,14 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u if !(i < num_tags) { break } - *(*int32)(unsafe.Pointer(new_tags + uintptr(j+i)*4)) = *(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) + **(**int32)(__ccgo_up(new_tags + uintptr(j+i)*4)) = **(**int32)(__ccgo_up(tags + uintptr(i)*4)) goto _7 _7: ; i = i + 1 } - *(*int32)(unsafe.Pointer(new_tags + uintptr(j+i)*4)) = -int32(1) - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Ftags = new_tags + **(**int32)(__ccgo_up(new_tags + uintptr(j+i)*4)) = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1)*56))).Ftags = new_tags } goto _4 _4: @@ -131712,23 +131712,23 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u } s2 = 0 for { - if !((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fposition >= 0) { + if !((**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fposition >= 0) { break } - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fposition = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fposition - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fcode_min = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fcode_min - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fcode_max = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fcode_max + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Fposition = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fposition + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Fcode_min = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fcode_min + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Fcode_max = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fcode_max /* XXX - why not | assertions here as well? */ - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fassertions = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fassertions - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fclass = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fclass - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fneg_classes = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fneg_classes - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fbackref = (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Fbackref - if (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Ftags == UintptrFromInt32(0) { - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Ftags = UintptrFromInt32(0) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Fassertions = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fassertions + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Fclass = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fclass + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Fneg_classes = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fneg_classes + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Fbackref = (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Fbackref + if (**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Ftags == UintptrFromInt32(0) { + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Ftags = UintptrFromInt32(0) } else { i = 0 for { - if !(*(*int32)(unsafe.Pointer((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Ftags + uintptr(i)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Ftags + uintptr(i)*4)) >= 0) { break } goto _9 @@ -131745,21 +131745,21 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u if !(j < i) { break } - *(*int32)(unsafe.Pointer(new_tags + uintptr(j)*4)) = *(*int32)(unsafe.Pointer((*(*Ttre_pos_and_tags_t)(unsafe.Pointer(set2 + uintptr(s2)*56))).Ftags + uintptr(j)*4)) + **(**int32)(__ccgo_up(new_tags + uintptr(j)*4)) = **(**int32)(__ccgo_up((**(**Ttre_pos_and_tags_t)(__ccgo_up(set2 + uintptr(s2)*56))).Ftags + uintptr(j)*4)) goto _10 _10: ; j = j + 1 } - *(*int32)(unsafe.Pointer(new_tags + uintptr(j)*4)) = -int32(1) - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Ftags = new_tags + **(**int32)(__ccgo_up(new_tags + uintptr(j)*4)) = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Ftags = new_tags } goto _8 _8: ; s2 = s2 + 1 } - (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fposition = -int32(1) + (**(**Ttre_pos_and_tags_t)(__ccgo_up(new_set + uintptr(s1+s2)*56))).Fposition = -int32(1) return new_set } @@ -131777,7 +131777,7 @@ func _tre_match_empty(tls *TLS, stack uintptr, node uintptr, tags uintptr, asser bottom = _tre_stack_num_objects(tls, stack) status = REG_OK if num_tags_seen != 0 { - *(*int32)(unsafe.Pointer(num_tags_seen)) = 0 + **(**int32)(__ccgo_up(num_tags_seen)) = 0 } status = _tre_stack_push_voidptr(tls, stack, node) /* Walk through the tree recursively. */ @@ -131793,10 +131793,10 @@ func _tre_match_empty(tls *TLS, stack uintptr, node uintptr, tags uintptr, asser /* Add the tag to `tags'. */ i = 0 for { - if !(*(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(tags + uintptr(i)*4)) >= 0) { break } - if int64(*(*int32)(unsafe.Pointer(tags + uintptr(i)*4))) == (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max { + if int64(**(**int32)(__ccgo_up(tags + uintptr(i)*4))) == (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max { break } goto _1 @@ -131804,13 +131804,13 @@ func _tre_match_empty(tls *TLS, stack uintptr, node uintptr, tags uintptr, asser ; i = i + 1 } - if *(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) < 0 { - *(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) = int32((*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max) - *(*int32)(unsafe.Pointer(tags + uintptr(i+int32(1))*4)) = -int32(1) + if **(**int32)(__ccgo_up(tags + uintptr(i)*4)) < 0 { + **(**int32)(__ccgo_up(tags + uintptr(i)*4)) = int32((*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max) + **(**int32)(__ccgo_up(tags + uintptr(i+int32(1))*4)) = -int32(1) } } if num_tags_seen != 0 { - *(*int32)(unsafe.Pointer(num_tags_seen)) = *(*int32)(unsafe.Pointer(num_tags_seen)) + 1 + **(**int32)(__ccgo_up(num_tags_seen)) = **(**int32)(__ccgo_up(num_tags_seen)) + 1 } } case int64(-int32(2)): @@ -132054,12 +132054,12 @@ func _tre_compute_nfl(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr) (r return status } /* Allocate arrays for the tags and parameters. */ - tags = Xmalloc(tls, uint64(4)*Uint64FromInt32(*(*int32)(unsafe.Pointer(bp))+Int32FromInt32(1))) + tags = Xmalloc(tls, uint64(4)*Uint64FromInt32(**(**int32)(__ccgo_up(bp))+Int32FromInt32(1))) if !(tags != 0) { return int32(REG_ESPACE) } - *(*int32)(unsafe.Pointer(tags)) = -int32(1) - *(*int32)(unsafe.Pointer(bp + 4)) = 0 + **(**int32)(__ccgo_up(tags)) = -int32(1) + **(**int32)(__ccgo_up(bp + 4)) = 0 /* Second pass with tre_mach_empty() to get the list of tags and parameters. */ status = _tre_match_empty(tls, stack, (*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft, tags, bp+4, UintptrFromInt32(0)) @@ -132067,7 +132067,7 @@ func _tre_compute_nfl(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr) (r Xfree(tls, tags) return status } - (*Ttre_ast_node_t)(unsafe.Pointer(node)).Ffirstpos = _tre_set_union(tls, mem, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright)).Ffirstpos, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft)).Ffirstpos, tags, *(*int32)(unsafe.Pointer(bp + 4))) + (*Ttre_ast_node_t)(unsafe.Pointer(node)).Ffirstpos = _tre_set_union(tls, mem, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright)).Ffirstpos, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft)).Ffirstpos, tags, **(**int32)(__ccgo_up(bp + 4))) Xfree(tls, tags) if !((*Ttre_ast_node_t)(unsafe.Pointer(node)).Ffirstpos != 0) { return int32(REG_ESPACE) @@ -132085,12 +132085,12 @@ func _tre_compute_nfl(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr) (r return status } /* Allocate arrays for the tags and parameters. */ - tags = Xmalloc(tls, uint64(4)*Uint64FromInt32(*(*int32)(unsafe.Pointer(bp))+Int32FromInt32(1))) + tags = Xmalloc(tls, uint64(4)*Uint64FromInt32(**(**int32)(__ccgo_up(bp))+Int32FromInt32(1))) if !(tags != 0) { return int32(REG_ESPACE) } - *(*int32)(unsafe.Pointer(tags)) = -int32(1) - *(*int32)(unsafe.Pointer(bp + 4)) = 0 + **(**int32)(__ccgo_up(tags)) = -int32(1) + **(**int32)(__ccgo_up(bp + 4)) = 0 /* Second pass with tre_mach_empty() to get the list of tags and parameters. */ status = _tre_match_empty(tls, stack, (*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright, tags, bp+4, UintptrFromInt32(0)) @@ -132098,7 +132098,7 @@ func _tre_compute_nfl(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr) (r Xfree(tls, tags) return status } - (*Ttre_ast_node_t)(unsafe.Pointer(node)).Flastpos = _tre_set_union(tls, mem, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft)).Flastpos, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright)).Flastpos, tags, *(*int32)(unsafe.Pointer(bp + 4))) + (*Ttre_ast_node_t)(unsafe.Pointer(node)).Flastpos = _tre_set_union(tls, mem, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fleft)).Flastpos, (*Ttre_ast_node_t)(unsafe.Pointer((*Ttre_catenation_t)(unsafe.Pointer(cat)).Fright)).Flastpos, tags, **(**int32)(__ccgo_up(bp + 4))) Xfree(tls, tags) if !((*Ttre_ast_node_t)(unsafe.Pointer(node)).Flastpos != 0) { return int32(REG_ESPACE) @@ -132134,7 +132134,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun prev_p2_pos = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fposition /* Set `trans' to point to the next unused transition from position `p1->position'. */ - trans = transitions + uintptr(*(*int32)(unsafe.Pointer(offs + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)))*56 + trans = transitions + uintptr(**(**int32)(__ccgo_up(offs + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)))*56 for (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fstate != UintptrFromInt32(0) { trans += 56 } @@ -132145,7 +132145,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun the transition from `p1' to `p2'. */ (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fcode_min = Uint32FromInt32((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fcode_min) (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fcode_max = Uint32FromInt32((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fcode_max) - (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fstate = transitions + uintptr(*(*int32)(unsafe.Pointer(offs + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fposition)*4)))*56 + (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fstate = transitions + uintptr(**(**int32)(__ccgo_up(offs + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fposition)*4)))*56 (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fstate_id = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fposition if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fclass != 0 { v1 = int32(ASSERT_CHAR_CLASS) @@ -132160,14 +132160,14 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fassertions = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fassertions | (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fassertions | v1 | v2 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fbackref >= 0 { *(*int32)(unsafe.Pointer(&(*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fu)) = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fbackref - *(*int32)(unsafe.Pointer(trans + 32)) |= int32(ASSERT_BACKREF) + **(**int32)(__ccgo_up(trans + 32)) |= int32(ASSERT_BACKREF) } else { *(*Ttre_ctype_t)(unsafe.Pointer(trans + 40)) = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fclass } if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes != UintptrFromInt32(0) { i = 0 for { - if !(*(*Ttre_ctype_t)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes + uintptr(i)*8)) != Uint64FromInt32(0)) { + if !(**(**Ttre_ctype_t)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes + uintptr(i)*8)) != Uint64FromInt32(0)) { break } goto _3 @@ -132181,29 +132181,29 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun } i = 0 for { - if !(*(*Ttre_ctype_t)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes + uintptr(i)*8)) != Uint64FromInt32(0)) { + if !(**(**Ttre_ctype_t)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes + uintptr(i)*8)) != Uint64FromInt32(0)) { break } - *(*Ttre_ctype_t)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes + uintptr(i)*8)) = *(*Ttre_ctype_t)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes + uintptr(i)*8)) + **(**Ttre_ctype_t)(__ccgo_up((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes + uintptr(i)*8)) = **(**Ttre_ctype_t)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fneg_classes + uintptr(i)*8)) goto _4 _4: ; i = i + 1 } - *(*Ttre_ctype_t)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes + uintptr(i)*8)) = Uint64FromInt32(0) + **(**Ttre_ctype_t)(__ccgo_up((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes + uintptr(i)*8)) = Uint64FromInt32(0) } else { (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes = UintptrFromInt32(0) } /* Find out how many tags this transition has. */ i = 0 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags != UintptrFromInt32(0) { - for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) >= 0 { + for **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) >= 0 { i = i + 1 } } j = 0 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags != UintptrFromInt32(0) { - for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) >= 0 { + for **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) >= 0 { j = j + 1 } } @@ -132220,15 +132220,15 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun } i = 0 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags != UintptrFromInt32(0) { - for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) >= 0 { - *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(i)*4)) = *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) + for **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) >= 0 { + **(**int32)(__ccgo_up((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(i)*4)) = **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) i = i + 1 } } l = i j = 0 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags != UintptrFromInt32(0) { - for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) >= 0 { + for **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) >= 0 { /* Don't add duplicates. */ dup = 0 k = 0 @@ -132236,7 +132236,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun if !(k < i) { break } - if *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(k)*4)) == *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) { + if **(**int32)(__ccgo_up((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(k)*4)) == **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) { dup = int32(1) break } @@ -132248,12 +132248,12 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun if !(dup != 0) { v1 = l l = l + 1 - *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(v1)*4)) = *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) + **(**int32)(__ccgo_up((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(v1)*4)) = **(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) } j = j + 1 } } - *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(l)*4)) = -int32(1) + **(**int32)(__ccgo_up((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(l)*4)) = -int32(1) } p2 += 56 } @@ -132265,7 +132265,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun for (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition >= 0 { p2 = orig_p2 for (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fposition >= 0 { - *(*int32)(unsafe.Pointer(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)) = *(*int32)(unsafe.Pointer(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)) + 1 + **(**int32)(__ccgo_up(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)) = **(**int32)(__ccgo_up(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)) + 1 p2 += 56 } p1 += 56 @@ -132356,11 +132356,11 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { } /* Parse the regexp. */ Xmemset(tls, bp, 0, uint64(56)) - (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fmem = mem - (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fstack = stack - (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fstart = regex - (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fcflags = cflags - (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fmax_backref = -int32(1) + (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fmem = mem + (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fstack = stack + (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fstart = regex + (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fcflags = cflags + (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fmax_backref = -int32(1) errcode = _tre_parse(tls, bp) if errcode != REG_OK { errcode = errcode @@ -132368,10 +132368,10 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { goto error_exit } } - (*Tregex_t)(unsafe.Pointer(preg)).Fre_nsub = Uint64FromInt32((*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fsubmatch_id - int32(1)) - tree = (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fn + (*Tregex_t)(unsafe.Pointer(preg)).Fre_nsub = Uint64FromInt32((**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fsubmatch_id - int32(1)) + tree = (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fn /* Referring to nonexistent subexpressions is illegal. */ - if (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fmax_backref > Int32FromUint64((*Tregex_t)(unsafe.Pointer(preg)).Fre_nsub) { + if (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fmax_backref > Int32FromUint64((*Tregex_t)(unsafe.Pointer(preg)).Fre_nsub) { errcode = int32(REG_ESUBREG) if int32(1) != 0 { goto error_exit @@ -132385,9 +132385,9 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { goto error_exit } } - (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fhave_backrefs = BoolInt32((*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fmax_backref >= 0) + (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fhave_backrefs = BoolInt32((**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fmax_backref >= 0) (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fhave_approx = 0 - (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches = Uint32FromInt32((*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fsubmatch_id) + (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches = Uint32FromInt32((**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fsubmatch_id) /* Set up tags for submatch addressing. If REG_NOSUB is set and the regexp does not have back references, this can be skipped. */ if (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fhave_backrefs != 0 || !(cflags&Int32FromInt32(REG_NOSUB) != 0) { @@ -132417,7 +132417,7 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { goto error_exit } } - submatch_data = Xcalloc(tls, uint64(Uint32FromInt32((*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fsubmatch_id)), uint64(16)) + submatch_data = Xcalloc(tls, uint64(Uint32FromInt32((**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fsubmatch_id)), uint64(16)) if submatch_data == UintptrFromInt32(0) { errcode = int32(REG_ESPACE) if int32(1) != 0 { @@ -132470,14 +132470,14 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { goto error_exit } } - counts = Xmalloc(tls, uint64(4)*Uint64FromInt32((*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fposition)) + counts = Xmalloc(tls, uint64(4)*Uint64FromInt32((**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fposition)) if counts == UintptrFromInt32(0) { errcode = int32(REG_ESPACE) if int32(1) != 0 { goto error_exit } } - offs = Xmalloc(tls, uint64(4)*Uint64FromInt32((*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fposition)) + offs = Xmalloc(tls, uint64(4)*Uint64FromInt32((**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fposition)) if offs == UintptrFromInt32(0) { errcode = int32(REG_ESPACE) if int32(1) != 0 { @@ -132486,10 +132486,10 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { } i = 0 for { - if !(i < (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fposition) { + if !(i < (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fposition) { break } - *(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) = 0 + **(**int32)(__ccgo_up(counts + uintptr(i)*4)) = 0 goto _3 _3: ; @@ -132499,12 +132499,12 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { add = 0 i = 0 for { - if !(i < (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fposition) { + if !(i < (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fposition) { break } - *(*int32)(unsafe.Pointer(offs + uintptr(i)*4)) = add - add = add + (*(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) + int32(1)) - *(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) = 0 + **(**int32)(__ccgo_up(offs + uintptr(i)*4)) = add + add = add + (**(**int32)(__ccgo_up(counts + uintptr(i)*4)) + int32(1)) + **(**int32)(__ccgo_up(counts + uintptr(i)*4)) = 0 goto _4 _4: ; @@ -132547,15 +132547,15 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { if !((*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fposition >= 0) { break } - (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Fstate = transitions + uintptr(*(*int32)(unsafe.Pointer(offs + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fposition)*4)))*56 - (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Fstate_id = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fposition - (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Ftags = UintptrFromInt32(0) + (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*56))).Fstate = transitions + uintptr(**(**int32)(__ccgo_up(offs + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fposition)*4)))*56 + (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*56))).Fstate_id = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fposition + (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*56))).Ftags = UintptrFromInt32(0) /* Copy the arrays p->tags, and p->params, they are allocated from a tre_mem object. */ if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Ftags != 0 { j = 0 for { - if !(*(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Ftags + uintptr(j)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Ftags + uintptr(j)*4)) >= 0) { break } goto _6 @@ -132563,26 +132563,26 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { ; j = j + 1 } - (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Ftags = Xmalloc(tls, uint64(4)*Uint64FromInt32(j+Int32FromInt32(1))) - if !((*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Ftags != 0) { + (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*56))).Ftags = Xmalloc(tls, uint64(4)*Uint64FromInt32(j+Int32FromInt32(1))) + if !((**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*56))).Ftags != 0) { errcode = int32(REG_ESPACE) if int32(1) != 0 { goto error_exit } } - Xmemcpy(tls, (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Ftags, (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Ftags, uint64(4)*Uint64FromInt32(j+Int32FromInt32(1))) + Xmemcpy(tls, (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*56))).Ftags, (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Ftags, uint64(4)*Uint64FromInt32(j+Int32FromInt32(1))) } - (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Fassertions = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fassertions + (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*56))).Fassertions = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fassertions i = i + 1 goto _5 _5: ; p += 56 } - (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Fstate = UintptrFromInt32(0) + (**(**Ttre_tnfa_transition_t)(__ccgo_up(initial + uintptr(i)*56))).Fstate = UintptrFromInt32(0) (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_transitions = Uint32FromInt32(add) - (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ffinal = transitions + uintptr(*(*int32)(unsafe.Pointer(offs + uintptr((*(*Ttre_pos_and_tags_t)(unsafe.Pointer((*Ttre_ast_node_t)(unsafe.Pointer(tree)).Flastpos))).Fposition)*4)))*56 - (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_states = (*(*Ttre_parse_ctx_t)(unsafe.Pointer(bp))).Fposition + (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ffinal = transitions + uintptr(**(**int32)(__ccgo_up(offs + uintptr((**(**Ttre_pos_and_tags_t)(__ccgo_up((*Ttre_ast_node_t)(unsafe.Pointer(tree)).Flastpos))).Fposition)*4)))*56 + (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_states = (**(**Ttre_parse_ctx_t)(__ccgo_up(bp))).Fposition (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags = cflags X__tre_mem_destroy(tls, mem) _tre_stack_destroy(tls, stack) @@ -132625,12 +132625,12 @@ func Xregfree(tls *TLS, preg uintptr) { if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_transitions) { break } - if (*(*Ttre_tnfa_transition_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Fstate != 0 { - if (*(*Ttre_tnfa_transition_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Ftags != 0 { - Xfree(tls, (*(*Ttre_tnfa_transition_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Ftags) + if (**(**Ttre_tnfa_transition_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Fstate != 0 { + if (**(**Ttre_tnfa_transition_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Ftags != 0 { + Xfree(tls, (**(**Ttre_tnfa_transition_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Ftags) } - if (*(*Ttre_tnfa_transition_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Fneg_classes != 0 { - Xfree(tls, (*(*Ttre_tnfa_transition_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Fneg_classes) + if (**(**Ttre_tnfa_transition_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Fneg_classes != 0 { + Xfree(tls, (**(**Ttre_tnfa_transition_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions + uintptr(i)*56))).Fneg_classes) } } goto _1 @@ -132663,8 +132663,8 @@ func Xregfree(tls *TLS, preg uintptr) { if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches) { break } - if (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(i)*16))).Fparents != 0 { - Xfree(tls, (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(i)*16))).Fparents) + if (**(**Ttre_submatch_data_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(i)*16))).Fparents != 0 { + Xfree(tls, (**(**Ttre_submatch_data_t)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(i)*16))).Fparents) } goto _3 _3: @@ -132704,7 +132704,7 @@ func Xregerror(tls *TLS, e int32, preg uintptr, buf uintptr, size Tsize_t) (r Ts _ = s s = uintptr(unsafe.Pointer(&_messages)) for { - if !(e != 0 && *(*uint8)(unsafe.Pointer(s)) != 0) { + if !(e != 0 && **(**uint8)(__ccgo_up(s)) != 0) { break } goto _1 @@ -132713,7 +132713,7 @@ func Xregerror(tls *TLS, e int32, preg uintptr, buf uintptr, size Tsize_t) (r Ts e = e - 1 s = s + uintptr(_strlen(tls, s)+uint64(1)) } - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { s = s + 1 } s = X__lctrans_cur(tls, s) @@ -132739,18 +132739,18 @@ func _tre_tag_order(tls *TLS, num_tags int32, tag_directions uintptr, t1 uintptr if !(i < num_tags) { break } - if *(*Ttre_tag_direction_t)(unsafe.Pointer(tag_directions + uintptr(i)*4)) == int32(_TRE_TAG_MINIMIZE) { - if *(*Tregoff_t)(unsafe.Pointer(t1 + uintptr(i)*8)) < *(*Tregoff_t)(unsafe.Pointer(t2 + uintptr(i)*8)) { + if **(**Ttre_tag_direction_t)(__ccgo_up(tag_directions + uintptr(i)*4)) == int32(_TRE_TAG_MINIMIZE) { + if **(**Tregoff_t)(__ccgo_up(t1 + uintptr(i)*8)) < **(**Tregoff_t)(__ccgo_up(t2 + uintptr(i)*8)) { return int32(1) } - if *(*Tregoff_t)(unsafe.Pointer(t1 + uintptr(i)*8)) > *(*Tregoff_t)(unsafe.Pointer(t2 + uintptr(i)*8)) { + if **(**Tregoff_t)(__ccgo_up(t1 + uintptr(i)*8)) > **(**Tregoff_t)(__ccgo_up(t2 + uintptr(i)*8)) { return 0 } } else { - if *(*Tregoff_t)(unsafe.Pointer(t1 + uintptr(i)*8)) > *(*Tregoff_t)(unsafe.Pointer(t2 + uintptr(i)*8)) { + if **(**Tregoff_t)(__ccgo_up(t1 + uintptr(i)*8)) > **(**Tregoff_t)(__ccgo_up(t2 + uintptr(i)*8)) { return int32(1) } - if *(*Tregoff_t)(unsafe.Pointer(t1 + uintptr(i)*8)) < *(*Tregoff_t)(unsafe.Pointer(t2 + uintptr(i)*8)) { + if **(**Tregoff_t)(__ccgo_up(t1 + uintptr(i)*8)) < **(**Tregoff_t)(__ccgo_up(t2 + uintptr(i)*8)) { return 0 } } @@ -132764,8 +132764,8 @@ func _tre_tag_order(tls *TLS, num_tags int32, tag_directions uintptr, t1 uintptr } func _tre_neg_char_classes_match(tls *TLS, classes uintptr, wc Ttre_cint_t, icase int32) (r int32) { - for *(*Ttre_ctype_t)(unsafe.Pointer(classes)) != Uint64FromInt32(0) { - if !(icase != 0) && Xiswctype(tls, wc, *(*Ttre_ctype_t)(unsafe.Pointer(classes))) != 0 || icase != 0 && (Xiswctype(tls, Xtowupper(tls, wc), *(*Ttre_ctype_t)(unsafe.Pointer(classes))) != 0 || Xiswctype(tls, Xtowlower(tls, wc), *(*Ttre_ctype_t)(unsafe.Pointer(classes))) != 0) { + for **(**Ttre_ctype_t)(__ccgo_up(classes)) != Uint64FromInt32(0) { + if !(icase != 0) && Xiswctype(tls, wc, **(**Ttre_ctype_t)(__ccgo_up(classes))) != 0 || icase != 0 && (Xiswctype(tls, Xtowupper(tls, wc), **(**Ttre_ctype_t)(__ccgo_up(classes))) != 0 || Xiswctype(tls, Xtowlower(tls, wc), **(**Ttre_ctype_t)(__ccgo_up(classes))) != 0) { return int32(1) } else { classes += 8 @@ -132818,7 +132818,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = buf, end, i, match_eo, new_match, num_tags, pbytes, pos, pos_add_next, prev_c, rbytes, reach, reach_i, reach_next, reach_next_i, reach_pos, reg_newline, reg_notbol, reg_noteol, ret, skip, start, str_byte, tag_i, tbytes, tmp_buf, tmp_iptr, tmp_tags, total_bytes, trans_i, xbytes, v1, v18, v7 /* State variables required by GET_NEXT_WCHAR. */ prev_c = 0 - *(*Ttre_char_t)(unsafe.Pointer(bp)) = 0 + **(**Ttre_char_t)(__ccgo_up(bp)) = 0 str_byte = string1 pos = int64(-int32(1)) pos_add_next = int64(1) @@ -132898,9 +132898,9 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_states) { break } - (*(*Ttre_tnfa_reach_t)(unsafe.Pointer(reach + uintptr(i)*16))).Ftags = tmp_buf + (**(**Ttre_tnfa_reach_t)(__ccgo_up(reach + uintptr(i)*16))).Ftags = tmp_buf tmp_buf = tmp_buf + uintptr(xbytes) - (*(*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next + uintptr(i)*16))).Ftags = tmp_buf + (**(**Ttre_tnfa_reach_t)(__ccgo_up(reach_next + uintptr(i)*16))).Ftags = tmp_buf tmp_buf = tmp_buf + uintptr(xbytes) goto _5 _5: @@ -132912,13 +132912,13 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_states) { break } - (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr(i)*16))).Fpos = int64(-int32(1)) + (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr(i)*16))).Fpos = int64(-int32(1)) goto _6 _6: ; i = i + 1 } - prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + prev_c = **(**Ttre_char_t)(__ccgo_up(bp)) pos = pos + pos_add_next v7 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) pos_add_next = v7 @@ -132938,8 +132938,8 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if match_eo < 0 { trans_i = (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Finitial for (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate != UintptrFromInt32(0) { - if (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos < pos { - if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\000') || reg_noteol != 0) && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0 || !(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) || (*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && *(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\000') && BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) == BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || *(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('\000') || BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) != BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0))) { + if (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos < pos { + if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (**(**Ttre_char_t)(__ccgo_up(bp)) != int32('\000') || reg_noteol != 0) && (**(**Ttre_char_t)(__ccgo_up(bp)) != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0 || !(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) || (**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && **(**Ttre_char_t)(__ccgo_up(bp)) != int32('\000') && BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) == BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || **(**Ttre_char_t)(__ccgo_up(bp)) == int32('\000') || BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) != BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0))) { trans_i += 56 continue } @@ -132949,7 +132949,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < num_tags) { break } - *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(i)*8)) = int64(-int32(1)) + **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(i)*8)) = int64(-int32(1)) goto _8 _8: ; @@ -132957,9 +132957,9 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags } tag_i = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags if tag_i != 0 { - for *(*int32)(unsafe.Pointer(tag_i)) >= 0 { - if *(*int32)(unsafe.Pointer(tag_i)) < num_tags { - *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(*(*int32)(unsafe.Pointer(tag_i)))*8)) = pos + for **(**int32)(__ccgo_up(tag_i)) >= 0 { + if **(**int32)(__ccgo_up(tag_i)) < num_tags { + **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(**(**int32)(__ccgo_up(tag_i)))*8)) = pos } tag_i += 4 } @@ -132972,15 +132972,15 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < num_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(i)*8)) = *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(i)*8)) + **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(i)*8)) = **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(i)*8)) goto _9 _9: ; i = i + 1 } } - (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos = pos - (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags = reach_next_i + 8 + (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos = pos + (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags = reach_next_i + 8 reach_next_i += 16 } trans_i += 56 @@ -132993,10 +132993,10 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags } } /* Check for end of string. */ - if !(*(*Ttre_char_t)(unsafe.Pointer(bp)) != 0) { + if !(**(**Ttre_char_t)(__ccgo_up(bp)) != 0) { break } - prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + prev_c = **(**Ttre_char_t)(__ccgo_up(bp)) pos = pos + pos_add_next v7 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) pos_add_next = v7 @@ -133026,16 +133026,16 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags skip = 0 i = 0 for { - if !(*(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i)*4)) >= 0) { + if !(**(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i)*4)) >= 0) { break } - end = *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i)*4)) - start = *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i+int32(1))*4)) + end = **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i)*4)) + start = **(**int32)(__ccgo_up((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i+int32(1))*4)) if end >= num_tags { skip = int32(1) break } else { - if *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Ftags + uintptr(start)*8)) == *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(start)*8)) && *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Ftags + uintptr(end)*8)) < *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(end)*8)) { + if **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Ftags + uintptr(start)*8)) == **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(start)*8)) && **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Ftags + uintptr(end)*8)) < **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(end)*8)) { skip = int32(1) break } @@ -133079,7 +133079,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags } /* Does this transition match the input symbol? */ if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fcode_min <= Uint32FromInt32(prev_c) && (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fcode_max >= Uint32FromInt32(prev_c) { - if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\000') || reg_noteol != 0) && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0 || !(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) || (*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && *(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\000') && BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) == BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || *(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('\000') || BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) != BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && !((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&Int32FromInt32(REG_ICASE) != 0) && !(Xiswctype(tls, Uint32FromInt32(prev_c), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE) != 0 && !(Xiswctype(tls, Xtowlower(tls, Uint32FromInt32(prev_c)), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) && !(Xiswctype(tls, Xtowupper(tls, Uint32FromInt32(prev_c)), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS_NEG) != 0 && _tre_neg_char_classes_match(tls, (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fneg_classes, Uint32FromInt32(prev_c), (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE)) != 0)) { + if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (**(**Ttre_char_t)(__ccgo_up(bp)) != int32('\000') || reg_noteol != 0) && (**(**Ttre_char_t)(__ccgo_up(bp)) != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0 || !(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) || (**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && **(**Ttre_char_t)(__ccgo_up(bp)) != int32('\000') && BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) == BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || **(**Ttre_char_t)(__ccgo_up(bp)) == int32('\000') || BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) != BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && !((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&Int32FromInt32(REG_ICASE) != 0) && !(Xiswctype(tls, Uint32FromInt32(prev_c), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE) != 0 && !(Xiswctype(tls, Xtowlower(tls, Uint32FromInt32(prev_c)), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) && !(Xiswctype(tls, Xtowupper(tls, Uint32FromInt32(prev_c)), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS_NEG) != 0 && _tre_neg_char_classes_match(tls, (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fneg_classes, Uint32FromInt32(prev_c), (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE)) != 0)) { goto _14 } /* Compute the tags after this transition. */ @@ -133088,7 +133088,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < num_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(tmp_tags + uintptr(i)*8)) = *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Ftags + uintptr(i)*8)) + **(**Tregoff_t)(__ccgo_up(tmp_tags + uintptr(i)*8)) = **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Ftags + uintptr(i)*8)) goto _15 _15: ; @@ -133096,22 +133096,22 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags } tag_i = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags if tag_i != UintptrFromInt32(0) { - for *(*int32)(unsafe.Pointer(tag_i)) >= 0 { - if *(*int32)(unsafe.Pointer(tag_i)) < num_tags { - *(*Tregoff_t)(unsafe.Pointer(tmp_tags + uintptr(*(*int32)(unsafe.Pointer(tag_i)))*8)) = pos + for **(**int32)(__ccgo_up(tag_i)) >= 0 { + if **(**int32)(__ccgo_up(tag_i)) < num_tags { + **(**Tregoff_t)(__ccgo_up(tmp_tags + uintptr(**(**int32)(__ccgo_up(tag_i)))*8)) = pos } tag_i += 4 } } - if (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos < pos { + if (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos < pos { /* Found an unvisited node. */ (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Fstate = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate tmp_iptr = (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags = tmp_tags tmp_tags = tmp_iptr - (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos = pos - (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags = reach_next_i + 8 - if (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Fstate == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ffinal && (match_eo == int64(-int32(1)) || num_tags > 0 && *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags)) <= *(*Tregoff_t)(unsafe.Pointer(match_tags))) { + (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos = pos + (**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags = reach_next_i + 8 + if (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Fstate == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ffinal && (match_eo == int64(-int32(1)) || num_tags > 0 && **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags)) <= **(**Tregoff_t)(__ccgo_up(match_tags))) { match_eo = pos new_match = int32(1) i = 0 @@ -133119,7 +133119,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < num_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(i)*8)) = *(*Tregoff_t)(unsafe.Pointer((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(i)*8)) + **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(i)*8)) = **(**Tregoff_t)(__ccgo_up((*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Ftags + uintptr(i)*8)) goto _16 _16: ; @@ -133131,10 +133131,10 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags /* Another path has also reached this state. We choose the winner by examining the tag values for both paths. */ - if _tre_tag_order(tls, num_tags, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions, tmp_tags, *(*uintptr)(unsafe.Pointer((*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags))) != 0 { + if _tre_tag_order(tls, num_tags, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions, tmp_tags, **(**uintptr)(__ccgo_up((**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags))) != 0 { /* The new path wins. */ - tmp_iptr = *(*uintptr)(unsafe.Pointer((*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags)) - *(*uintptr)(unsafe.Pointer((*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags)) = tmp_tags + tmp_iptr = **(**uintptr)(__ccgo_up((**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags)) + **(**uintptr)(__ccgo_up((**(**Ttre_reach_pos_t)(__ccgo_up(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Ftags)) = tmp_tags if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ffinal { match_eo = pos new_match = int32(1) @@ -133143,7 +133143,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags if !(i < num_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(i)*8)) = *(*Tregoff_t)(unsafe.Pointer(tmp_tags + uintptr(i)*8)) + **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(i)*8)) = **(**Tregoff_t)(__ccgo_up(tmp_tags + uintptr(i)*8)) goto _17 _17: ; @@ -133166,7 +133166,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags } (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Fstate = UintptrFromInt32(0) } - *(*Tregoff_t)(unsafe.Pointer(match_end_ofs)) = match_eo + **(**Tregoff_t)(__ccgo_up(match_end_ofs)) = match_eo if match_eo >= 0 { v18 = REG_OK } else { @@ -133237,7 +133237,7 @@ func _tre_tnfa_run_backtrack(tls *TLS, tnfa uintptr, string1 uintptr, match_tags _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bt, bt_len, empty_br_match, eo, i, i1, i2, i3, i4, match_eo, mem, next_c_start, next_state, next_tags, pmatch, pos, pos_add_next, pos_start, prev_c, reg_newline, reg_notbol, reg_noteol, result, ret, s, s1, so, stack, state, states_seen, str_byte, str_byte_start, tags, tmp, tmp1, trans_i, v20, v3, v6 /* State variables required by GET_NEXT_WCHAR. */ prev_c = 0 - *(*Ttre_char_t)(unsafe.Pointer(bp)) = 0 + **(**Ttre_char_t)(__ccgo_up(bp)) = 0 str_byte = string1 pos = 0 pos_add_next = int64(1) @@ -133291,9 +133291,9 @@ retry: if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(i)*8)) = int64(-int32(1)) + **(**Tregoff_t)(__ccgo_up(tags + uintptr(i)*8)) = int64(-int32(1)) if match_tags != 0 { - *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(i)*8)) = int64(-int32(1)) + **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(i)*8)) = int64(-int32(1)) } goto _1 _1: @@ -133305,7 +133305,7 @@ retry: if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_states) { break } - *(*int32)(unsafe.Pointer(states_seen + uintptr(i)*4)) = 0 + **(**int32)(__ccgo_up(states_seen + uintptr(i)*4)) = 0 goto _2 _2: ; @@ -133313,7 +133313,7 @@ retry: } state = UintptrFromInt32(0) pos = pos_start - prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + prev_c = **(**Ttre_char_t)(__ccgo_up(bp)) pos = pos + pos_add_next v3 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) pos_add_next = v3 @@ -133327,7 +133327,7 @@ retry: } str_byte = str_byte + uintptr(pos_add_next) pos_start = pos - next_c_start = *(*Ttre_char_t)(unsafe.Pointer(bp)) + next_c_start = **(**Ttre_char_t)(__ccgo_up(bp)) str_byte_start = str_byte /* Handle initial states. */ next_tags = UintptrFromInt32(0) @@ -133336,7 +133336,7 @@ retry: if !((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate != 0) { break } - if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\000') || reg_noteol != 0) && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0 || !(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) || (*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && *(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\000') && BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) == BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || *(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('\000') || BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) != BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0))) { + if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (**(**Ttre_char_t)(__ccgo_up(bp)) != int32('\000') || reg_noteol != 0) && (**(**Ttre_char_t)(__ccgo_up(bp)) != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0 || !(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) || (**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && **(**Ttre_char_t)(__ccgo_up(bp)) != int32('\000') && BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) == BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || **(**Ttre_char_t)(__ccgo_up(bp)) == int32('\000') || BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) != BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0))) { goto _4 } if state == UintptrFromInt32(0) { @@ -133385,13 +133385,13 @@ retry: (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstr_byte = str_byte (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate_id = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id - (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fnext_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fnext_c = **(**Ttre_char_t)(__ccgo_up(bp)) i1 = 0 for { if !(i1 < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_tags) { break } - *(*Tregoff_t)(unsafe.Pointer((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(i1)*8)) = *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(i1)*8)) + **(**Tregoff_t)(__ccgo_up((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(i1)*8)) = **(**Tregoff_t)(__ccgo_up(tags + uintptr(i1)*8)) goto _5 _5: ; @@ -133399,10 +133399,10 @@ retry: } tmp = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags if tmp != 0 { - for *(*int32)(unsafe.Pointer(tmp)) >= 0 { + for **(**int32)(__ccgo_up(tmp)) >= 0 { v6 = tmp tmp += 4 - *(*Tregoff_t)(unsafe.Pointer((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(*(*int32)(unsafe.Pointer(v6)))*8)) = pos + **(**Tregoff_t)(__ccgo_up((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(**(**int32)(__ccgo_up(v6)))*8)) = pos } } } @@ -133413,10 +133413,10 @@ retry: } if next_tags != 0 { for { - if !(*(*int32)(unsafe.Pointer(next_tags)) >= 0) { + if !(**(**int32)(__ccgo_up(next_tags)) >= 0) { break } - *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(*(*int32)(unsafe.Pointer(next_tags)))*8)) = pos + **(**Tregoff_t)(__ccgo_up(tags + uintptr(**(**int32)(__ccgo_up(next_tags)))*8)) = pos goto _7 _7: ; @@ -133441,7 +133441,7 @@ _9: if !(i2 < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(match_tags + uintptr(i2)*8)) = *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(i2)*8)) + **(**Tregoff_t)(__ccgo_up(match_tags + uintptr(i2)*8)) = **(**Tregoff_t)(__ccgo_up(tags + uintptr(i2)*8)) goto _10 _10: ; @@ -133461,8 +133461,8 @@ _9: /* Get the substring we need to match against. Remember to turn off REG_NOSUB temporarily. */ _tre_fill_pmatch(tls, Uint64FromInt32(bt+int32(1)), pmatch, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags & ^Int32FromInt32(REG_NOSUB), tnfa, tags, pos) - so = (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(bt)*16))).Frm_so - eo = (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(bt)*16))).Frm_eo + so = (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(bt)*16))).Frm_so + eo = (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(bt)*16))).Frm_eo bt_len = eo - so result = Xstrncmp(tls, string1+uintptr(so), str_byte-uintptr(1), Uint64FromInt64(bt_len)) if result == 0 { @@ -133470,15 +133470,15 @@ _9: if bt_len == 0 { empty_br_match = int32(1) } - if empty_br_match != 0 && *(*int32)(unsafe.Pointer(states_seen + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*4)) != 0 { + if empty_br_match != 0 && **(**int32)(__ccgo_up(states_seen + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*4)) != 0 { goto backtrack } - *(*int32)(unsafe.Pointer(states_seen + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*4)) = empty_br_match + **(**int32)(__ccgo_up(states_seen + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*4)) = empty_br_match /* Advance in input string and resync `prev_c', `next_c' and pos. */ str_byte = str_byte + uintptr(bt_len-int64(1)) pos = pos + (bt_len - int64(1)) - prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + prev_c = **(**Ttre_char_t)(__ccgo_up(bp)) pos = pos + pos_add_next v3 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) pos_add_next = v3 @@ -133496,11 +133496,11 @@ _9: } } else { /* Check for end of string. */ - if *(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('\000') { + if **(**Ttre_char_t)(__ccgo_up(bp)) == int32('\000') { goto backtrack } /* Read the next character. */ - prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + prev_c = **(**Ttre_char_t)(__ccgo_up(bp)) pos = pos + pos_add_next v3 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) pos_add_next = v3 @@ -133521,7 +133521,7 @@ _9: break } if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fcode_min <= Uint32FromInt32(prev_c) && (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fcode_max >= Uint32FromInt32(prev_c) { - if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\000') || reg_noteol != 0) && (*(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0 || !(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) || (*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && *(*Ttre_char_t)(unsafe.Pointer(bp)) != int32('\000') && BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) == BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || *(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('\000') || BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) != BoolInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(*(*Ttre_char_t)(unsafe.Pointer(bp)))) != 0)) || ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && !((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&Int32FromInt32(REG_ICASE) != 0) && !(Xiswctype(tls, Uint32FromInt32(prev_c), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE) != 0 && !(Xiswctype(tls, Xtowlower(tls, Uint32FromInt32(prev_c)), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) && !(Xiswctype(tls, Xtowupper(tls, Uint32FromInt32(prev_c)), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS_NEG) != 0 && _tre_neg_char_classes_match(tls, (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fneg_classes, Uint32FromInt32(prev_c), (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE)) != 0)) { + if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions != 0 && ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOL) != 0 && (pos > 0 || reg_notbol != 0) && (prev_c != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOL) != 0 && (**(**Ttre_char_t)(__ccgo_up(bp)) != int32('\000') || reg_noteol != 0) && (**(**Ttre_char_t)(__ccgo_up(bp)) != int32('\n') || !(reg_newline != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_BOW) != 0 && (prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0 || !(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_EOW) != 0 && (!(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) || (**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB) != 0 && (pos != 0 && **(**Ttre_char_t)(__ccgo_up(bp)) != int32('\000') && BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) == BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_AT_WB_NEG) != 0 && (pos == 0 || **(**Ttre_char_t)(__ccgo_up(bp)) == int32('\000') || BoolInt32(prev_c == int32('_') || Xiswalnum(tls, Uint32FromInt32(prev_c)) != 0) != BoolInt32(**(**Ttre_char_t)(__ccgo_up(bp)) == int32('_') || Xiswalnum(tls, Uint32FromInt32(**(**Ttre_char_t)(__ccgo_up(bp)))) != 0)) || ((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && !((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&Int32FromInt32(REG_ICASE) != 0) && !(Xiswctype(tls, Uint32FromInt32(prev_c), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS) != 0 && (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE) != 0 && !(Xiswctype(tls, Xtowlower(tls, Uint32FromInt32(prev_c)), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) && !(Xiswctype(tls, Xtowupper(tls, Uint32FromInt32(prev_c)), *(*Ttre_ctype_t)(unsafe.Pointer(trans_i + 40))) != 0) || (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fassertions&int32(ASSERT_CHAR_CLASS_NEG) != 0 && _tre_neg_char_classes_match(tls, (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fneg_classes, Uint32FromInt32(prev_c), (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags&int32(REG_ICASE)) != 0)) { goto _13 } if next_state == UintptrFromInt32(0) { @@ -133573,13 +133573,13 @@ _9: (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstr_byte = str_byte (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate_id = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id - (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fnext_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) + (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fnext_c = **(**Ttre_char_t)(__ccgo_up(bp)) i3 = 0 for { if !(i3 < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_tags) { break } - *(*Tregoff_t)(unsafe.Pointer((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(i3)*8)) = *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(i3)*8)) + **(**Tregoff_t)(__ccgo_up((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(i3)*8)) = **(**Tregoff_t)(__ccgo_up(tags + uintptr(i3)*8)) goto _14 _14: ; @@ -133587,10 +133587,10 @@ _9: } tmp1 = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags for { - if !(tmp1 != 0 && *(*int32)(unsafe.Pointer(tmp1)) >= 0) { + if !(tmp1 != 0 && **(**int32)(__ccgo_up(tmp1)) >= 0) { break } - *(*Tregoff_t)(unsafe.Pointer((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(*(*int32)(unsafe.Pointer(tmp1)))*8)) = pos + **(**Tregoff_t)(__ccgo_up((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(**(**int32)(__ccgo_up(tmp1)))*8)) = pos goto _15 _15: ; @@ -133610,10 +133610,10 @@ _9: state = next_state /* Update the tag values. */ if next_tags != 0 { - for *(*int32)(unsafe.Pointer(next_tags)) >= 0 { + for **(**int32)(__ccgo_up(next_tags)) >= 0 { v6 = next_tags next_tags += 4 - *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(*(*int32)(unsafe.Pointer(v6)))*8)) = pos + **(**Tregoff_t)(__ccgo_up(tags + uintptr(**(**int32)(__ccgo_up(v6)))*8)) = pos } } goto _17 @@ -133625,18 +133625,18 @@ backtrack: /* A matching transition was not found. Try to backtrack. */ if (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fprev != 0 { if (*Ttre_tnfa_transition_t)(unsafe.Pointer((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate)).Fassertions&int32(ASSERT_BACKREF) != 0 { - *(*int32)(unsafe.Pointer(states_seen + uintptr((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate_id)*4)) = 0 + **(**int32)(__ccgo_up(states_seen + uintptr((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate_id)*4)) = 0 } pos = (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fpos str_byte = (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstr_byte state = (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fstate - *(*Ttre_char_t)(unsafe.Pointer(bp)) = (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fnext_c + **(**Ttre_char_t)(__ccgo_up(bp)) = (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Fnext_c i4 = 0 for { if !(i4 < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_tags) { break } - *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(i4)*8)) = *(*Tregoff_t)(unsafe.Pointer((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(i4)*8)) + **(**Tregoff_t)(__ccgo_up(tags + uintptr(i4)*8)) = **(**Tregoff_t)(__ccgo_up((*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fitem.Ftags + uintptr(i4)*8)) goto _19 _19: ; @@ -133647,10 +133647,10 @@ backtrack: if match_eo < 0 { /* Try starting from a later position in the input string. */ /* Check for end of string. */ - if *(*Ttre_char_t)(unsafe.Pointer(bp)) == int32('\000') { + if **(**Ttre_char_t)(__ccgo_up(bp)) == int32('\000') { goto _8 } - *(*Ttre_char_t)(unsafe.Pointer(bp)) = next_c_start + **(**Ttre_char_t)(__ccgo_up(bp)) = next_c_start str_byte = str_byte_start goto retry } else { @@ -133668,7 +133668,7 @@ _8: v20 = int32(REG_NOMATCH) } ret = v20 - *(*Tregoff_t)(unsafe.Pointer(match_end_ofs)) = match_eo + **(**Tregoff_t)(__ccgo_up(match_end_ofs)) = match_eo goto error_exit error_exit: ; @@ -133703,22 +133703,22 @@ func _tre_fill_pmatch(tls *TLS, nmatch Tsize_t, pmatch uintptr, cflags int32, tn /* Construct submatch offsets from the tags. */ submatch_data = (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data for i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches && uint64(i) < nmatch { - if (*(*Ttre_submatch_data_t)(unsafe.Pointer(submatch_data + uintptr(i)*16))).Fso_tag == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fend_tag { - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = match_eo + if (**(**Ttre_submatch_data_t)(__ccgo_up(submatch_data + uintptr(i)*16))).Fso_tag == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fend_tag { + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_so = match_eo } else { - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = *(*Tregoff_t)(unsafe.Pointer(tags + uintptr((*(*Ttre_submatch_data_t)(unsafe.Pointer(submatch_data + uintptr(i)*16))).Fso_tag)*8)) + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_so = **(**Tregoff_t)(__ccgo_up(tags + uintptr((**(**Ttre_submatch_data_t)(__ccgo_up(submatch_data + uintptr(i)*16))).Fso_tag)*8)) } - if (*(*Ttre_submatch_data_t)(unsafe.Pointer(submatch_data + uintptr(i)*16))).Feo_tag == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fend_tag { - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = match_eo + if (**(**Ttre_submatch_data_t)(__ccgo_up(submatch_data + uintptr(i)*16))).Feo_tag == (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fend_tag { + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_eo = match_eo } else { - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = *(*Tregoff_t)(unsafe.Pointer(tags + uintptr((*(*Ttre_submatch_data_t)(unsafe.Pointer(submatch_data + uintptr(i)*16))).Feo_tag)*8)) + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_eo = **(**Tregoff_t)(__ccgo_up(tags + uintptr((**(**Ttre_submatch_data_t)(__ccgo_up(submatch_data + uintptr(i)*16))).Feo_tag)*8)) } /* If either of the endpoints were not used, this submatch was not part of the match. */ - if (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so == int64(-int32(1)) || (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo == int64(-int32(1)) { + if (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_so == int64(-int32(1)) || (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_eo == int64(-int32(1)) { v1 = int64(-Int32FromInt32(1)) - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = v1 - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = v1 + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_eo = v1 + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_so = v1 } i = i + 1 } @@ -133726,19 +133726,19 @@ func _tre_fill_pmatch(tls *TLS, nmatch Tsize_t, pmatch uintptr, cflags int32, tn submatches. */ i = uint32(0) for i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_submatches && uint64(i) < nmatch { - if (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo == int64(-int32(1)) { + if (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_eo == int64(-int32(1)) { } - parents = (*(*Ttre_submatch_data_t)(unsafe.Pointer(submatch_data + uintptr(i)*16))).Fparents + parents = (**(**Ttre_submatch_data_t)(__ccgo_up(submatch_data + uintptr(i)*16))).Fparents if parents != UintptrFromInt32(0) { j = uint32(0) for { - if !(*(*int32)(unsafe.Pointer(parents + uintptr(j)*4)) >= 0) { + if !(**(**int32)(__ccgo_up(parents + uintptr(j)*4)) >= 0) { break } - if (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so < (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(*(*int32)(unsafe.Pointer(parents + uintptr(j)*4)))*16))).Frm_so || (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo > (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(*(*int32)(unsafe.Pointer(parents + uintptr(j)*4)))*16))).Frm_eo { + if (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_so < (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(**(**int32)(__ccgo_up(parents + uintptr(j)*4)))*16))).Frm_so || (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_eo > (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(**(**int32)(__ccgo_up(parents + uintptr(j)*4)))*16))).Frm_eo { v1 = int64(-Int32FromInt32(1)) - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = v1 - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = v1 + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_eo = v1 + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_so = v1 } goto _2 _2: @@ -133750,8 +133750,8 @@ func _tre_fill_pmatch(tls *TLS, nmatch Tsize_t, pmatch uintptr, cflags int32, tn } } for uint64(i) < nmatch { - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = int64(-int32(1)) - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = int64(-int32(1)) + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_so = int64(-int32(1)) + (**(**Tregmatch_t)(__ccgo_up(pmatch + uintptr(i)*16))).Frm_eo = int64(-int32(1)) i = i + 1 } } @@ -133792,7 +133792,7 @@ func Xregexec(tls *TLS, preg uintptr, string1 uintptr, nmatch Tsize_t, pmatch ui } if status == REG_OK { /* A match was found, so fill the submatch registers. */ - _tre_fill_pmatch(tls, nmatch, pmatch, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags, tnfa, tags, *(*Tregoff_t)(unsafe.Pointer(bp))) + _tre_fill_pmatch(tls, nmatch, pmatch, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fcflags, tnfa, tags, **(**Tregoff_t)(__ccgo_up(bp))) } if tags != 0 { Xfree(tls, tags) @@ -133910,8 +133910,8 @@ func X__tre_mem_alloc_impl(tls *TLS, mem Ttre_mem_t, provided int32, provided_bl size = size + v1 /* Allocate from current block. */ ptr = (*Ttre_mem_struct)(unsafe.Pointer(mem)).Fptr - *(*uintptr)(unsafe.Pointer(mem + 16)) += uintptr(size) - *(*Tsize_t)(unsafe.Pointer(mem + 24)) -= size + **(**uintptr)(__ccgo_up(mem + 16)) += uintptr(size) + **(**Tsize_t)(__ccgo_up(mem + 24)) -= size /* Set to zero if needed. */ if zero != 0 { Xmemset(tls, ptr, 0, size) @@ -133976,10 +133976,10 @@ func _keyhash(tls *TLS, k uintptr) (r Tsize_t) { _, _, _ = h, p, v1 p = k h = uint64(0) - for *(*uint8)(unsafe.Pointer(p)) != 0 { + for **(**uint8)(__ccgo_up(p)) != 0 { v1 = p p = p + 1 - h = uint64(31)*h + uint64(*(*uint8)(unsafe.Pointer(v1))) + h = uint64(31)*h + uint64(**(**uint8)(__ccgo_up(v1))) } return h } @@ -134032,7 +134032,7 @@ func _resize(tls *TLS, nel Tsize_t, htab uintptr) (r int32) { j = j + 1 i = i + v4 } - *(*TENTRY)(unsafe.Pointer(newe)) = *(*TENTRY)(unsafe.Pointer(e)) + **(**TENTRY)(__ccgo_up(newe)) = **(**TENTRY)(__ccgo_up(e)) } goto _2 _2: @@ -134088,7 +134088,7 @@ func Xhsearch(tls *TLS, item TENTRY, action TACTION) (r uintptr) { defer tls.Free(16) var _ /* e at bp+0 */ uintptr ___hsearch_r(tls, item, action, bp, uintptr(unsafe.Pointer(&_htab))) - return *(*uintptr)(unsafe.Pointer(bp)) + return **(**uintptr)(__ccgo_up(bp)) } func ___hcreate_r(tls *TLS, nel Tsize_t, htab uintptr) (r1 int32) { @@ -134121,14 +134121,14 @@ func ___hsearch_r(tls *TLS, item TENTRY, action TACTION, retval uintptr, htab ui hash = _keyhash(tls, item.Fkey) e = _lookup(tls, item.Fkey, hash, htab) if (*TENTRY)(unsafe.Pointer(e)).Fkey != 0 { - *(*uintptr)(unsafe.Pointer(retval)) = e + **(**uintptr)(__ccgo_up(retval)) = e return int32(1) } if action == int32(_FIND) { - *(*uintptr)(unsafe.Pointer(retval)) = uintptr(0) + **(**uintptr)(__ccgo_up(retval)) = uintptr(0) return 0 } - *(*TENTRY)(unsafe.Pointer(e)) = item + **(**TENTRY)(__ccgo_up(e)) = item v2 = (*Thsearch_data)(unsafe.Pointer(htab)).F__tab + 16 *(*Tsize_t)(unsafe.Pointer(v2)) = *(*Tsize_t)(unsafe.Pointer(v2)) + 1 v1 = *(*Tsize_t)(unsafe.Pointer(v2)) @@ -134136,12 +134136,12 @@ func ___hsearch_r(tls *TLS, item TENTRY, action TACTION, retval uintptr, htab ui if !(_resize(tls, uint64(2)*(*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused, htab) != 0) { (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused = (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused - 1 (*TENTRY)(unsafe.Pointer(e)).Fkey = uintptr(0) - *(*uintptr)(unsafe.Pointer(retval)) = uintptr(0) + **(**uintptr)(__ccgo_up(retval)) = uintptr(0) return 0 } e = _lookup(tls, item.Fkey, hash, htab) } - *(*uintptr)(unsafe.Pointer(retval)) = e + **(**uintptr)(__ccgo_up(retval)) = e return int32(1) } @@ -134201,7 +134201,7 @@ func Xlsearch(tls *TLS, key uintptr, base uintptr, nelp uintptr, width Tsize_t, defer func() {}() v1 = width p = base - n = *(*Tsize_t)(unsafe.Pointer(nelp)) + n = **(**Tsize_t)(__ccgo_up(nelp)) i = uint64(0) for { if !(i < n) { @@ -134215,7 +134215,7 @@ func Xlsearch(tls *TLS, key uintptr, base uintptr, nelp uintptr, width Tsize_t, ; i = i + 1 } - *(*Tsize_t)(unsafe.Pointer(nelp)) = n + uint64(1) + **(**Tsize_t)(__ccgo_up(nelp)) = n + uint64(1) return Xmemcpy(tls, p+uintptr(n)*uintptr(v1), key, width) } @@ -134233,7 +134233,7 @@ func Xlfind(tls *TLS, key uintptr, base uintptr, nelp uintptr, width Tsize_t, __ defer func() {}() v1 = width p = base - n = *(*Tsize_t)(unsafe.Pointer(nelp)) + n = **(**Tsize_t)(__ccgo_up(nelp)) i = uint64(0) for { if !(i < n) { @@ -134272,7 +134272,7 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui if !(rootp != 0) { return uintptr(0) } - n = *(*uintptr)(unsafe.Pointer(rootp)) + n = **(**uintptr)(__ccgo_up(rootp)) i = 0 /* *a[0] is an arbitrary non-null pointer that is returned when the root node is deleted. */ @@ -134293,34 +134293,34 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui v1 = i i = i + 1 a[v1] = n + 8 + BoolUintptr(c > 0)*8 - n = *(*uintptr)(unsafe.Pointer(n + 8 + BoolUintptr(c > 0)*8)) + n = **(**uintptr)(__ccgo_up(n + 8 + BoolUintptr(c > 0)*8)) goto _3 _3: } - parent = *(*uintptr)(unsafe.Pointer(a[i-int32(2)])) - if *(*uintptr)(unsafe.Pointer(n + 8)) != 0 { + parent = **(**uintptr)(__ccgo_up(a[i-int32(2)])) + if **(**uintptr)(__ccgo_up(n + 8)) != 0 { /* free the preceding node instead of the deleted one. */ deleted = n v1 = i i = i + 1 a[v1] = n + 8 - n = *(*uintptr)(unsafe.Pointer(n + 8)) - for *(*uintptr)(unsafe.Pointer(n + 8 + 1*8)) != 0 { + n = **(**uintptr)(__ccgo_up(n + 8)) + for **(**uintptr)(__ccgo_up(n + 8 + 1*8)) != 0 { v1 = i i = i + 1 a[v1] = n + 8 + 1*8 - n = *(*uintptr)(unsafe.Pointer(n + 8 + 1*8)) + n = **(**uintptr)(__ccgo_up(n + 8 + 1*8)) } (*Tnode1)(unsafe.Pointer(deleted)).Fkey = (*Tnode1)(unsafe.Pointer(n)).Fkey - child = *(*uintptr)(unsafe.Pointer(n + 8)) + child = **(**uintptr)(__ccgo_up(n + 8)) } else { - child = *(*uintptr)(unsafe.Pointer(n + 8 + 1*8)) + child = **(**uintptr)(__ccgo_up(n + 8 + 1*8)) } /* freed node has at most one child, move it up and rebalance. */ Xfree(tls, n) i = i - 1 v1 = i - *(*uintptr)(unsafe.Pointer(a[v1])) = child + **(**uintptr)(__ccgo_up(a[v1])) = child for { i = i - 1 v1 = i @@ -134343,8 +134343,8 @@ func Xtdestroy(tls *TLS, root uintptr, __ccgo_fp_freekey uintptr) { if r == uintptr(0) { return } - Xtdestroy(tls, *(*uintptr)(unsafe.Pointer(r + 8)), __ccgo_fp_freekey) - Xtdestroy(tls, *(*uintptr)(unsafe.Pointer(r + 8 + 1*8)), __ccgo_fp_freekey) + Xtdestroy(tls, **(**uintptr)(__ccgo_up(r + 8)), __ccgo_fp_freekey) + Xtdestroy(tls, **(**uintptr)(__ccgo_up(r + 8 + 1*8)), __ccgo_fp_freekey) if __ccgo_fp_freekey != 0 { (*(*func(*TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_freekey})))(tls, (*Tnode1)(unsafe.Pointer(r)).Fkey) } @@ -134364,7 +134364,7 @@ func Xtfind(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r uint if !(rootp != 0) { return uintptr(0) } - n = *(*uintptr)(unsafe.Pointer(rootp)) + n = **(**uintptr)(__ccgo_up(rootp)) for { if !(n != 0) { break @@ -134373,7 +134373,7 @@ func Xtfind(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r uint if !(c != 0) { break } - n = *(*uintptr)(unsafe.Pointer(n + 8 + BoolUintptr(c > 0)*8)) + n = **(**uintptr)(__ccgo_up(n + 8 + BoolUintptr(c > 0)*8)) goto _1 _1: } @@ -134395,11 +134395,11 @@ func _rot(tls *TLS, p uintptr, x uintptr, dir int32) (r int32) { var hx, hz int32 var y, z uintptr _, _, _, _ = hx, hz, y, z - y = *(*uintptr)(unsafe.Pointer(x + 8 + uintptr(dir)*8)) - z = *(*uintptr)(unsafe.Pointer(y + 8 + BoolUintptr(!(dir != 0))*8)) + y = **(**uintptr)(__ccgo_up(x + 8 + uintptr(dir)*8)) + z = **(**uintptr)(__ccgo_up(y + 8 + BoolUintptr(!(dir != 0))*8)) hx = (*Tnode1)(unsafe.Pointer(x)).Fh hz = _height(tls, z) - if hz > _height(tls, *(*uintptr)(unsafe.Pointer(y + 8 + uintptr(dir)*8))) { + if hz > _height(tls, **(**uintptr)(__ccgo_up(y + 8 + uintptr(dir)*8))) { /* * x * / \ dir z @@ -134407,10 +134407,10 @@ func _rot(tls *TLS, p uintptr, x uintptr, dir int32) (r int32) { * z D /| | * / \ A B C D * B C */ - *(*uintptr)(unsafe.Pointer(x + 8 + uintptr(dir)*8)) = *(*uintptr)(unsafe.Pointer(z + 8 + BoolUintptr(!(dir != 0))*8)) - *(*uintptr)(unsafe.Pointer(y + 8 + BoolUintptr(!(dir != 0))*8)) = *(*uintptr)(unsafe.Pointer(z + 8 + uintptr(dir)*8)) - *(*uintptr)(unsafe.Pointer(z + 8 + BoolUintptr(!(dir != 0))*8)) = x - *(*uintptr)(unsafe.Pointer(z + 8 + uintptr(dir)*8)) = y + **(**uintptr)(__ccgo_up(x + 8 + uintptr(dir)*8)) = **(**uintptr)(__ccgo_up(z + 8 + BoolUintptr(!(dir != 0))*8)) + **(**uintptr)(__ccgo_up(y + 8 + BoolUintptr(!(dir != 0))*8)) = **(**uintptr)(__ccgo_up(z + 8 + uintptr(dir)*8)) + **(**uintptr)(__ccgo_up(z + 8 + BoolUintptr(!(dir != 0))*8)) = x + **(**uintptr)(__ccgo_up(z + 8 + uintptr(dir)*8)) = y (*Tnode1)(unsafe.Pointer(x)).Fh = hz (*Tnode1)(unsafe.Pointer(y)).Fh = hz (*Tnode1)(unsafe.Pointer(z)).Fh = hz + int32(1) @@ -134420,13 +134420,13 @@ func _rot(tls *TLS, p uintptr, x uintptr, dir int32) (r int32) { * / \ / * A y --> x D * / \ / * z D A z */ - *(*uintptr)(unsafe.Pointer(x + 8 + uintptr(dir)*8)) = z - *(*uintptr)(unsafe.Pointer(y + 8 + BoolUintptr(!(dir != 0))*8)) = x + **(**uintptr)(__ccgo_up(x + 8 + uintptr(dir)*8)) = z + **(**uintptr)(__ccgo_up(y + 8 + BoolUintptr(!(dir != 0))*8)) = x (*Tnode1)(unsafe.Pointer(x)).Fh = hz + int32(1) (*Tnode1)(unsafe.Pointer(y)).Fh = hz + int32(2) z = y } - *(*uintptr)(unsafe.Pointer(p)) = z + **(**uintptr)(__ccgo_up(p)) = z return (*Tnode1)(unsafe.Pointer(z)).Fh - hx } @@ -134441,9 +134441,9 @@ func X__tsearch_balance(tls *TLS, p uintptr) (r int32) { var h0, h1, old, v1 int32 var n uintptr _, _, _, _, _ = h0, h1, n, old, v1 - n = *(*uintptr)(unsafe.Pointer(p)) - h0 = _height(tls, *(*uintptr)(unsafe.Pointer(n + 8))) - h1 = _height(tls, *(*uintptr)(unsafe.Pointer(n + 8 + 1*8))) + n = **(**uintptr)(__ccgo_up(p)) + h0 = _height(tls, **(**uintptr)(__ccgo_up(n + 8))) + h1 = _height(tls, **(**uintptr)(__ccgo_up(n + 8 + 1*8))) if Uint32FromInt32(h0-h1)+uint32(1) < uint32(3) { old = (*Tnode1)(unsafe.Pointer(n)).Fh if h0 < h1 { @@ -134472,7 +134472,7 @@ func Xtsearch(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r1 u if !(rootp != 0) { return uintptr(0) } - n = *(*uintptr)(unsafe.Pointer(rootp)) + n = **(**uintptr)(__ccgo_up(rootp)) i = 0 v1 = i i = i + 1 @@ -134488,7 +134488,7 @@ func Xtsearch(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r1 u v1 = i i = i + 1 a[v1] = n + 8 + BoolUintptr(c > 0)*8 - n = *(*uintptr)(unsafe.Pointer(n + 8 + BoolUintptr(c > 0)*8)) + n = **(**uintptr)(__ccgo_up(n + 8 + BoolUintptr(c > 0)*8)) goto _2 _2: } @@ -134498,13 +134498,13 @@ func Xtsearch(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r1 u } (*Tnode1)(unsafe.Pointer(r)).Fkey = key v4 = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(r + 8 + 1*8)) = v4 - *(*uintptr)(unsafe.Pointer(r + 8)) = v4 + **(**uintptr)(__ccgo_up(r + 8 + 1*8)) = v4 + **(**uintptr)(__ccgo_up(r + 8)) = v4 (*Tnode1)(unsafe.Pointer(r)).Fh = int32(1) /* insert new node, rebalance ancestors. */ i = i - 1 v1 = i - *(*uintptr)(unsafe.Pointer(a[v1])) = r + **(**uintptr)(__ccgo_up(a[v1])) = r for { if v7 = i != 0; v7 { i = i - 1 @@ -134525,9 +134525,9 @@ func _walk(tls *TLS, r uintptr, __ccgo_fp_action uintptr, d int32) { (*(*func(*TLS, uintptr, TVISIT, int32))(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_action})))(tls, r, int32(_leaf), d) } else { (*(*func(*TLS, uintptr, TVISIT, int32))(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_action})))(tls, r, int32(_preorder), d) - _walk(tls, *(*uintptr)(unsafe.Pointer(r + 8)), __ccgo_fp_action, d+int32(1)) + _walk(tls, **(**uintptr)(__ccgo_up(r + 8)), __ccgo_fp_action, d+int32(1)) (*(*func(*TLS, uintptr, TVISIT, int32))(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_action})))(tls, r, int32(_postorder), d) - _walk(tls, *(*uintptr)(unsafe.Pointer(r + 8 + 1*8)), __ccgo_fp_action, d+int32(1)) + _walk(tls, **(**uintptr)(__ccgo_up(r + 8 + 1*8)), __ccgo_fp_action, d+int32(1)) (*(*func(*TLS, uintptr, TVISIT, int32))(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_action})))(tls, r, int32(_endorder), d) } } @@ -134596,7 +134596,7 @@ func Xpselect(tls *TLS, n int32, rfds uintptr, wfds uintptr, efds uintptr, ts ui var v3 uintptr var _ /* data at bp+16 */ [2]Tsyscall_arg_t _, _, _, _, _ = ns, s, v1, v2, v3 - *(*[2]Tsyscall_arg_t)(unsafe.Pointer(bp + 16)) = [2]Tsyscall_arg_t{ + **(**[2]Tsyscall_arg_t)(__ccgo_up(bp + 16)) = [2]Tsyscall_arg_t{ 0: Int64FromUint64(uint64(mask)), 1: int64(Int32FromInt32(_NSIG) / Int32FromInt32(8)), } @@ -134715,10 +134715,10 @@ func Xgetitimer(tls *TLS, which int32, old uintptr) (r1 int32) { if uint64(8) > uint64(8) { r = int32(X__syscall2(tls, int64(SYS_getitimer), int64(which), int64(bp))) if !(r != 0) { - (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_sec = (*(*[4]int64)(unsafe.Pointer(bp)))[0] - (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_usec = (*(*[4]int64)(unsafe.Pointer(bp)))[int32(1)] - (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_sec = (*(*[4]int64)(unsafe.Pointer(bp)))[int32(2)] - (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_usec = (*(*[4]int64)(unsafe.Pointer(bp)))[int32(3)] + (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_sec = (**(**[4]int64)(__ccgo_up(bp)))[0] + (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_usec = (**(**[4]int64)(__ccgo_up(bp)))[int32(1)] + (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_sec = (**(**[4]int64)(__ccgo_up(bp)))[int32(2)] + (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_usec = (**(**[4]int64)(__ccgo_up(bp)))[int32(3)] } return int32(X__syscall_ret(tls, Uint64FromInt32(r))) } @@ -134739,7 +134739,7 @@ func Xkillpg(tls *TLS, pgid Tpid_t, sig int32) (r int32) { defer func() { trc("-> %v", r) }() } if pgid < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } return Xkill(tls, -pgid, sig) @@ -134775,7 +134775,7 @@ func Xpsignal(tls *TLS, sig int32, msg uintptr) { * not permitted to do so. */ old_locale = (*TFILE)(unsafe.Pointer(f)).Flocale old_mode = (*TFILE)(unsafe.Pointer(f)).Fmode - old_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + old_errno = **(**int32)(__ccgo_up(X__errno_location(tls))) if msg != 0 { v2 = msg } else { @@ -134787,7 +134787,7 @@ func Xpsignal(tls *TLS, sig int32, msg uintptr) { v3 = __ccgo_ts } if Xfprintf(tls, f, __ccgo_ts+1102, VaList(bp+8, v2, v3, s)) >= 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = old_errno + **(**int32)(__ccgo_up(X__errno_location(tls))) = old_errno } (*TFILE)(unsafe.Pointer(f)).Fmode = old_mode (*TFILE)(unsafe.Pointer(f)).Flocale = old_locale @@ -134854,10 +134854,10 @@ func Xsetitimer(tls *TLS, which int32, new1 uintptr, old uintptr) (r1 int32) { } r = int32(X__syscall3(tls, int64(SYS_setitimer), int64(which), int64(bp), int64(bp+32))) if !(r != 0) && old != 0 { - (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_sec = (*(*[4]int64)(unsafe.Pointer(bp + 32)))[0] - (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_usec = (*(*[4]int64)(unsafe.Pointer(bp + 32)))[int32(1)] - (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_sec = (*(*[4]int64)(unsafe.Pointer(bp + 32)))[int32(2)] - (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_usec = (*(*[4]int64)(unsafe.Pointer(bp + 32)))[int32(3)] + (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_sec = (**(**[4]int64)(__ccgo_up(bp + 32)))[0] + (*Titimerval)(unsafe.Pointer(old)).Fit_interval.Ftv_usec = (**(**[4]int64)(__ccgo_up(bp + 32)))[int32(1)] + (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_sec = (**(**[4]int64)(__ccgo_up(bp + 32)))[int32(2)] + (*Titimerval)(unsafe.Pointer(old)).Fit_value.Ftv_usec = (**(**[4]int64)(__ccgo_up(bp + 32)))[int32(3)] } return int32(X__syscall_ret(tls, Uint64FromInt32(r))) } @@ -134936,7 +134936,7 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old1 uintptr) (r1 int32) Fv Tuint64_t }{} *(*uint64)(unsafe.Pointer(bp + 8)) = Uint64FromInt64(v2) - if *(*Tuint32_t)(unsafe.Pointer(bp + 8)) != 0 { + if **(**Tuint32_t)(__ccgo_up(bp + 8)) != 0 { v10 = v9 for { old = AtomicLoadPInt32(v10) @@ -134961,7 +134961,7 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old1 uintptr) (r1 int32) goto _15 _15: } - if *(*Tuint32_t)(unsafe.Pointer(bp + 8 + 1*4)) != 0 { + if **(**Tuint32_t)(__ccgo_up(bp + 8 + 1*4)) != 0 { v16 = v9 + uintptr(1)*4 for { old = AtomicLoadPInt32(v16) @@ -135010,15 +135010,15 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old1 uintptr) (r1 int32) X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 23, __ccgo_ts+1517) } } - (*(*Tk_sigaction)(unsafe.Pointer(bp + 16))).Fhandler = *(*uintptr)(unsafe.Pointer(sa)) - (*(*Tk_sigaction)(unsafe.Pointer(bp + 16))).Fflags = Uint64FromInt32((*Tsigaction)(unsafe.Pointer(sa)).Fsa_flags) - (*(*Tk_sigaction)(unsafe.Pointer(bp + 16))).Fflags |= uint64(0x04000000) + (**(**Tk_sigaction)(__ccgo_up(bp + 16))).Fhandler = *(*uintptr)(unsafe.Pointer(sa)) + (**(**Tk_sigaction)(__ccgo_up(bp + 16))).Fflags = Uint64FromInt32((*Tsigaction)(unsafe.Pointer(sa)).Fsa_flags) + (**(**Tk_sigaction)(__ccgo_up(bp + 16))).Fflags |= uint64(0x04000000) if Uint32FromInt32((*Tsigaction)(unsafe.Pointer(sa)).Fsa_flags)&uint32(4) != 0 { v1 = __ccgo_fp(X__restore_rt) } else { v1 = __ccgo_fp(X__restore) } - (*(*Tk_sigaction)(unsafe.Pointer(bp + 16))).Frestorer = v1 + (**(**Tk_sigaction)(__ccgo_up(bp + 16))).Frestorer = v1 Xmemcpy(tls, bp+16+24, sa+8, Uint64FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))) } if sa != 0 { @@ -135033,8 +135033,8 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old1 uintptr) (r1 int32) } r = int32(X__syscall4(tls, int64(SYS_rt_sigaction), int64(sig), int64(v1), int64(v3), int64(Int32FromInt32(_NSIG)/Int32FromInt32(8)))) if old1 != 0 && !(r != 0) { - *(*uintptr)(unsafe.Pointer(old1)) = (*(*Tk_sigaction)(unsafe.Pointer(bp + 48))).Fhandler - (*Tsigaction)(unsafe.Pointer(old1)).Fsa_flags = Int32FromUint64((*(*Tk_sigaction)(unsafe.Pointer(bp + 48))).Fflags) + *(*uintptr)(unsafe.Pointer(old1)) = (**(**Tk_sigaction)(__ccgo_up(bp + 48))).Fhandler + (*Tsigaction)(unsafe.Pointer(old1)).Fsa_flags = Int32FromUint64((**(**Tk_sigaction)(__ccgo_up(bp + 48))).Fflags) Xmemcpy(tls, old1+8, bp+48+24, Uint64FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))) } return int32(X__syscall_ret(tls, Uint64FromInt32(r))) @@ -135051,7 +135051,7 @@ func X__sigaction(tls *TLS, sig int32, sa uintptr, old uintptr) (r1 int32) { var _ /* set at bp+0 */ [1]uint64 _ = r if Uint32FromInt32(sig)-uint32(32) < uint32(3) || Uint32FromInt32(sig)-uint32(1) >= Uint32FromInt32(Int32FromInt32(_NSIG)-Int32FromInt32(1)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } /* Doing anything with the disposition of SIGABRT requires a lock, @@ -135086,10 +135086,10 @@ func Xsigaddset(tls *TLS, set uintptr, sig int32) (r int32) { _ = s s = Uint32FromInt32(sig - int32(1)) if s >= Uint32FromInt32(Int32FromInt32(_NSIG)-Int32FromInt32(1)) || Uint32FromInt32(sig)-uint32(32) < uint32(3) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } - *(*uint64)(unsafe.Pointer(set + uintptr(uint64(s/uint32(8))/uint64(8))*8)) |= uint64(1) << (uint64(s) & (Uint64FromInt32(8)*Uint64FromInt64(8) - Uint64FromInt32(1))) + **(**uint64)(__ccgo_up(set + uintptr(uint64(s/uint32(8))/uint64(8))*8)) |= uint64(1) << (uint64(s) & (Uint64FromInt32(8)*Uint64FromInt64(8) - Uint64FromInt32(1))) return 0 } @@ -135100,11 +135100,11 @@ func Xsigaltstack(tls *TLS, ss uintptr, old uintptr) (r int32) { } if ss != 0 { if !((*Tstack_t)(unsafe.Pointer(ss)).Fss_flags&Int32FromInt32(SS_DISABLE) != 0) && (*Tstack_t)(unsafe.Pointer(ss)).Fss_size < uint64(MINSIGSTKSZ) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return -int32(1) } if (*Tstack_t)(unsafe.Pointer(ss)).Fss_flags&int32(SS_ONSTACK) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } } @@ -135129,7 +135129,7 @@ func Xsigandset(tls *TLS, dest uintptr, left uintptr, right uintptr) (r1 int32) if !(i < Uint64FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))/Uint64FromInt64(8)) { break } - *(*uint64)(unsafe.Pointer(d + uintptr(i)*8)) = *(*uint64)(unsafe.Pointer(l + uintptr(i)*8)) & *(*uint64)(unsafe.Pointer(r + uintptr(i)*8)) + **(**uint64)(__ccgo_up(d + uintptr(i)*8)) = **(**uint64)(__ccgo_up(l + uintptr(i)*8)) & **(**uint64)(__ccgo_up(r + uintptr(i)*8)) goto _1 _1: ; @@ -135147,10 +135147,10 @@ func Xsigdelset(tls *TLS, set uintptr, sig int32) (r int32) { _ = s s = Uint32FromInt32(sig - int32(1)) if s >= Uint32FromInt32(Int32FromInt32(_NSIG)-Int32FromInt32(1)) || Uint32FromInt32(sig)-uint32(32) < uint32(3) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } - *(*uint64)(unsafe.Pointer(set + uintptr(uint64(s/uint32(8))/uint64(8))*8)) &= ^(Uint64FromUint64(1) << (uint64(s) & (Uint64FromInt32(8)*Uint64FromInt64(8) - Uint64FromInt32(1)))) + **(**uint64)(__ccgo_up(set + uintptr(uint64(s/uint32(8))/uint64(8))*8)) &= ^(Uint64FromUint64(1) << (uint64(s) & (Uint64FromInt32(8)*Uint64FromInt64(8) - Uint64FromInt32(1)))) return 0 } @@ -135159,13 +135159,13 @@ func Xsigemptyset(tls *TLS, set uintptr) (r int32) { trc("tls=%v set=%v, (%v:)", tls, set, origin(2)) defer func() { trc("-> %v", r) }() } - *(*uint64)(unsafe.Pointer(set)) = uint64(0) + **(**uint64)(__ccgo_up(set)) = uint64(0) if Bool(uint64(8) == uint64(4)) || Bool(int32(_NSIG) > int32(65)) { - *(*uint64)(unsafe.Pointer(set + 1*8)) = uint64(0) + **(**uint64)(__ccgo_up(set + 1*8)) = uint64(0) } if Bool(uint64(8) == uint64(4)) && Bool(int32(_NSIG) > int32(65)) { - *(*uint64)(unsafe.Pointer(set + 2*8)) = uint64(0) - *(*uint64)(unsafe.Pointer(set + 3*8)) = uint64(0) + **(**uint64)(__ccgo_up(set + 2*8)) = uint64(0) + **(**uint64)(__ccgo_up(set + 3*8)) = uint64(0) } return 0 } @@ -135184,9 +135184,9 @@ func Xsigfillset(tls *TLS, set uintptr) (r int32) { trc("tls=%v set=%v, (%v:)", tls, set, origin(2)) defer func() { trc("-> %v", r) }() } - *(*uint64)(unsafe.Pointer(set)) = uint64(0xfffffffc7fffffff) + **(**uint64)(__ccgo_up(set)) = uint64(0xfffffffc7fffffff) if int32(_NSIG) > int32(65) { - *(*uint64)(unsafe.Pointer(set + 1*8)) = uint64(0xffffffffffffffff) + **(**uint64)(__ccgo_up(set + 1*8)) = uint64(0xffffffffffffffff) } return 0 } @@ -135203,7 +135203,7 @@ func Xsigisemptyset(tls *TLS, set uintptr) (r int32) { if !(i < Uint64FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))/Uint64FromInt64(8)) { break } - if *(*uint64)(unsafe.Pointer(set + uintptr(i)*8)) != 0 { + if **(**uint64)(__ccgo_up(set + uintptr(i)*8)) != 0 { return 0 } goto _1 @@ -135225,7 +135225,7 @@ func Xsigismember(tls *TLS, set uintptr, sig int32) (r int32) { if s >= Uint32FromInt32(Int32FromInt32(_NSIG)-Int32FromInt32(1)) { return 0 } - return BoolInt32(!!(*(*uint64)(unsafe.Pointer(set + uintptr(uint64(s/uint32(8))/uint64(8))*8))&(Uint64FromUint64(1)<<(uint64(s)&(Uint64FromInt32(8)*Uint64FromInt64(8)-Uint64FromInt32(1)))) != 0)) + return BoolInt32(!!(**(**uint64)(__ccgo_up(set + uintptr(uint64(s/uint32(8))/uint64(8))*8))&(Uint64FromUint64(1)<<(uint64(s)&(Uint64FromInt32(8)*Uint64FromInt64(8)-Uint64FromInt32(1)))) != 0)) } func Xsigorset(tls *TLS, dest uintptr, left uintptr, right uintptr) (r1 int32) { @@ -135244,7 +135244,7 @@ func Xsigorset(tls *TLS, dest uintptr, left uintptr, right uintptr) (r1 int32) { if !(i < Uint64FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))/Uint64FromInt64(8)) { break } - *(*uint64)(unsafe.Pointer(d + uintptr(i)*8)) = *(*uint64)(unsafe.Pointer(l + uintptr(i)*8)) | *(*uint64)(unsafe.Pointer(r + uintptr(i)*8)) + **(**uint64)(__ccgo_up(d + uintptr(i)*8)) = **(**uint64)(__ccgo_up(l + uintptr(i)*8)) | **(**uint64)(__ccgo_up(r + uintptr(i)*8)) goto _1 _1: ; @@ -135272,7 +135272,7 @@ func Xsigprocmask(tls *TLS, how int32, set uintptr, old uintptr) (r1 int32) { if !(r != 0) { return r } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = r + **(**int32)(__ccgo_up(X__errno_location(tls))) = r return -int32(1) } @@ -135288,8 +135288,8 @@ func Xsigqueue(tls *TLS, pid Tpid_t, sig int32, value Tsigval) (r1 int32) { var _ /* si at bp+0 */ Tsiginfo_t _ = r Xmemset(tls, bp, 0, uint64(128)) - (*(*Tsiginfo_t)(unsafe.Pointer(bp))).Fsi_signo = sig - (*(*Tsiginfo_t)(unsafe.Pointer(bp))).Fsi_code = -int32(1) + (**(**Tsiginfo_t)(__ccgo_up(bp))).Fsi_signo = sig + (**(**Tsiginfo_t)(__ccgo_up(bp))).Fsi_code = -int32(1) *(*Tsigval)(unsafe.Pointer(bp + 16 + 8)) = value *(*Tuid_t)(unsafe.Pointer(bp + 16 + 4)) = Xgetuid(tls) X__block_app_sigs(tls, bp+128) @@ -135385,7 +135385,7 @@ func Xsigwait(tls *TLS, mask uintptr, sig uintptr) (r int32) { if Xsigtimedwait(tls, mask, bp, uintptr(0)) < 0 { return -int32(1) } - *(*int32)(unsafe.Pointer(sig)) = (*(*Tsiginfo_t)(unsafe.Pointer(bp))).Fsi_signo + **(**int32)(__ccgo_up(sig)) = (**(**Tsiginfo_t)(__ccgo_up(bp))).Fsi_signo return 0 } @@ -135434,7 +135434,7 @@ func X__xmknod(tls *TLS, ver int32, path uintptr, mode Tmode_t, dev uintptr) (r trc("tls=%v ver=%v path=%v mode=%v dev=%v, (%v:)", tls, ver, path, mode, dev, origin(2)) defer func() { trc("-> %v", r) }() } - return Xmknod(tls, path, mode, *(*Tdev_t)(unsafe.Pointer(dev))) + return Xmknod(tls, path, mode, **(**Tdev_t)(__ccgo_up(dev))) } func X__xmknodat(tls *TLS, ver int32, fd int32, path uintptr, mode Tmode_t, dev uintptr) (r int32) { @@ -135442,7 +135442,7 @@ func X__xmknodat(tls *TLS, ver int32, fd int32, path uintptr, mode Tmode_t, dev trc("tls=%v ver=%v fd=%v path=%v mode=%v dev=%v, (%v:)", tls, ver, fd, path, mode, dev, origin(2)) defer func() { trc("-> %v", r) }() } - return Xmknodat(tls, fd, path, mode, *(*Tdev_t)(unsafe.Pointer(dev))) + return Xmknodat(tls, fd, path, mode, **(**Tdev_t)(__ccgo_up(dev))) } func Xchmod(tls *TLS, path uintptr, mode Tmode_t) (r int32) { @@ -135495,7 +135495,7 @@ func Xfchmodat(tls *TLS, fd int32, path uintptr, mode Tmode_t, flag int32) (r in if Xfstatat(tls, fd, path, bp, flag) != 0 { return -int32(1) } - if (*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { + if (**(**Tstat)(__ccgo_up(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { return int32(X__syscall_ret(tls, Uint64FromInt32(-Int32FromInt32(EOPNOTSUPP)))) } v1 = int32(X__syscall3(tls, int64(SYS_openat), int64(fd), int64(path), int64(Int32FromInt32(O_RDONLY)|Int32FromInt32(O_PATH)|Int32FromInt32(O_NOFOLLOW)|Int32FromInt32(O_NOCTTY)|Int32FromInt32(O_CLOEXEC)))) @@ -135509,7 +135509,7 @@ func Xfchmodat(tls *TLS, fd int32, path uintptr, mode Tmode_t, flag int32) (r in X__procfdname(tls, bp+144, Uint32FromInt32(fd2)) ret = Xstat(tls, bp+144, bp) if !(ret != 0) { - if (*(*Tstat)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { + if (**(**Tstat)(__ccgo_up(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) { ret = int32(X__syscall_ret(tls, Uint64FromInt32(-Int32FromInt32(EOPNOTSUPP)))) } else { ret = int32(X__syscall_ret(tls, Uint64FromInt64(X__syscall3(tls, int64(SYS_fchmodat), int64(-Int32FromInt32(100)), int64(bp+144), Int64FromUint32(mode))))) @@ -135589,29 +135589,29 @@ func _fstatat_statx(tls *TLS, fd int32, path uintptr, st uintptr, flag int32) (r if ret != 0 { return ret } - *(*Tstat)(unsafe.Pointer(st)) = Tstat{ - Fst_dev: uint64(uint64((*(*Tstatx1)(unsafe.Pointer(bp))).Fstx_dev_major)&Uint64FromUint64(0xfffff000)<= 0 && !(*(*uint8)(unsafe.Pointer(path)) != 0) { + if flag == int32(AT_EMPTY_PATH) && fd >= 0 && !(**(**uint8)(__ccgo_up(path)) != 0) { ret = int32(X__syscall2(tls, int64(SYS_fstat), int64(fd), int64(bp))) if ret == -int32(EBADF) && X__syscall2(tls, int64(SYS_fcntl), int64(fd), int64(Int32FromInt32(F_GETFD))) >= 0 { ret = int32(X__syscall4(tls, int64(SYS_newfstatat), int64(fd), int64(path), int64(bp), int64(flag))) @@ -135653,10 +135653,10 @@ func _fstatat_kstat(tls *TLS, fd int32, path uintptr, st uintptr, flag int32) (r } } } else { - if (fd == -int32(100) || Int32FromUint8(*(*uint8)(unsafe.Pointer(path))) == int32('/')) && flag == int32(AT_SYMLINK_NOFOLLOW) { + if (fd == -int32(100) || Int32FromUint8(**(**uint8)(__ccgo_up(path))) == int32('/')) && flag == int32(AT_SYMLINK_NOFOLLOW) { ret = int32(X__syscall2(tls, int64(SYS_lstat), int64(path), int64(bp))) } else { - if (fd == -int32(100) || Int32FromUint8(*(*uint8)(unsafe.Pointer(path))) == int32('/')) && !(flag != 0) { + if (fd == -int32(100) || Int32FromUint8(**(**uint8)(__ccgo_up(path))) == int32('/')) && !(flag != 0) { ret = int32(X__syscall2(tls, int64(SYS_stat), int64(path), int64(bp))) } else { ret = int32(X__syscall4(tls, int64(SYS_newfstatat), int64(fd), int64(path), int64(bp), int64(flag))) @@ -135666,29 +135666,29 @@ func _fstatat_kstat(tls *TLS, fd int32, path uintptr, st uintptr, flag int32) (r if ret != 0 { return ret } - *(*Tstat)(unsafe.Pointer(st)) = Tstat{ - Fst_dev: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_dev, - Fst_ino: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_ino, - Fst_nlink: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_nlink, - Fst_mode: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_mode, - Fst_uid: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_uid, - Fst_gid: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_gid, - Fst_rdev: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_rdev, - Fst_size: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_size, + **(**Tstat)(__ccgo_up(st)) = Tstat{ + Fst_dev: (**(**Tkstat)(__ccgo_up(bp))).Fst_dev, + Fst_ino: (**(**Tkstat)(__ccgo_up(bp))).Fst_ino, + Fst_nlink: (**(**Tkstat)(__ccgo_up(bp))).Fst_nlink, + Fst_mode: (**(**Tkstat)(__ccgo_up(bp))).Fst_mode, + Fst_uid: (**(**Tkstat)(__ccgo_up(bp))).Fst_uid, + Fst_gid: (**(**Tkstat)(__ccgo_up(bp))).Fst_gid, + Fst_rdev: (**(**Tkstat)(__ccgo_up(bp))).Fst_rdev, + Fst_size: (**(**Tkstat)(__ccgo_up(bp))).Fst_size, Fst_atim: Ttimespec{ - Ftv_sec: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_atime_sec, - Ftv_nsec: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_atime_nsec, + Ftv_sec: (**(**Tkstat)(__ccgo_up(bp))).Fst_atime_sec, + Ftv_nsec: (**(**Tkstat)(__ccgo_up(bp))).Fst_atime_nsec, }, Fst_mtim: Ttimespec{ - Ftv_sec: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_mtime_sec, - Ftv_nsec: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_mtime_nsec, + Ftv_sec: (**(**Tkstat)(__ccgo_up(bp))).Fst_mtime_sec, + Ftv_nsec: (**(**Tkstat)(__ccgo_up(bp))).Fst_mtime_nsec, }, Fst_ctim: Ttimespec{ - Ftv_sec: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_ctime_sec, - Ftv_nsec: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_ctime_nsec, + Ftv_sec: (**(**Tkstat)(__ccgo_up(bp))).Fst_ctime_sec, + Ftv_nsec: (**(**Tkstat)(__ccgo_up(bp))).Fst_ctime_nsec, }, - Fst_blksize: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_blksize, - Fst_blocks: (*(*Tkstat)(unsafe.Pointer(bp))).Fst_blocks, + Fst_blksize: (**(**Tkstat)(__ccgo_up(bp))).Fst_blksize, + Fst_blocks: (**(**Tkstat)(__ccgo_up(bp))).Fst_blocks, } return 0 } @@ -135743,11 +135743,11 @@ func X__futimesat(tls *TLS, dirfd int32, pathname uintptr, times uintptr) (r int if !(i < int32(2)) { break } - if Uint64FromInt64((*(*Ttimeval)(unsafe.Pointer(times + uintptr(i)*16))).Ftv_usec) >= uint64(1000000) { + if Uint64FromInt64((**(**Ttimeval)(__ccgo_up(times + uintptr(i)*16))).Ftv_usec) >= uint64(1000000) { return int32(X__syscall_ret(tls, Uint64FromInt32(-Int32FromInt32(EINVAL)))) } - (*(*[2]Ttimespec)(unsafe.Pointer(bp)))[i].Ftv_sec = (*(*Ttimeval)(unsafe.Pointer(times + uintptr(i)*16))).Ftv_sec - (*(*[2]Ttimespec)(unsafe.Pointer(bp)))[i].Ftv_nsec = (*(*Ttimeval)(unsafe.Pointer(times + uintptr(i)*16))).Ftv_usec * int64(1000) + (**(**[2]Ttimespec)(__ccgo_up(bp)))[i].Ftv_sec = (**(**Ttimeval)(__ccgo_up(times + uintptr(i)*16))).Ftv_sec + (**(**[2]Ttimespec)(__ccgo_up(bp)))[i].Ftv_nsec = (**(**Ttimeval)(__ccgo_up(times + uintptr(i)*16))).Ftv_usec * int64(1000) goto _1 _1: ; @@ -135843,7 +135843,7 @@ func Xstat(tls *TLS, path uintptr, buf uintptr) (r int32) { } func ___statfs(tls *TLS, path uintptr, buf uintptr) (r int32) { - *(*Tstatfs)(unsafe.Pointer(buf)) = Tstatfs{} + **(**Tstatfs)(__ccgo_up(buf)) = Tstatfs{} return int32(X__syscall_ret(tls, Uint64FromInt64(X__syscall3(tls, int64(SYS_statfs64), int64(path), Int64FromUint64(Uint64FromInt64(88)), int64(buf))))) } @@ -135852,14 +135852,14 @@ func Xfstatfs(tls *TLS, fd int32, buf uintptr) (r int32) { trc("tls=%v fd=%v buf=%v, (%v:)", tls, fd, buf, origin(2)) defer func() { trc("-> %v", r) }() } - *(*Tstatfs)(unsafe.Pointer(buf)) = Tstatfs{} + **(**Tstatfs)(__ccgo_up(buf)) = Tstatfs{} return int32(X__syscall_ret(tls, Uint64FromInt64(X__syscall3(tls, int64(SYS_fstatfs64), int64(fd), Int64FromUint64(Uint64FromInt64(88)), int64(buf))))) } func _fixup(tls *TLS, out uintptr, in uintptr) { var v1 uint32 _ = v1 - *(*Tstatvfs)(unsafe.Pointer(out)) = Tstatvfs{} + **(**Tstatvfs)(__ccgo_up(out)) = Tstatvfs{} (*Tstatvfs)(unsafe.Pointer(out)).Ff_bsize = uint64((*Tstatfs)(unsafe.Pointer(in)).Ff_bsize) if (*Tstatfs)(unsafe.Pointer(in)).Ff_frsize != 0 { v1 = (*Tstatfs)(unsafe.Pointer(in)).Ff_frsize @@ -135873,7 +135873,7 @@ func _fixup(tls *TLS, out uintptr, in uintptr) { (*Tstatvfs)(unsafe.Pointer(out)).Ff_files = (*Tstatfs)(unsafe.Pointer(in)).Ff_files (*Tstatvfs)(unsafe.Pointer(out)).Ff_ffree = (*Tstatfs)(unsafe.Pointer(in)).Ff_ffree (*Tstatvfs)(unsafe.Pointer(out)).Ff_favail = (*Tstatfs)(unsafe.Pointer(in)).Ff_ffree - (*Tstatvfs)(unsafe.Pointer(out)).Ff_fsid = Uint64FromInt32(*(*int32)(unsafe.Pointer(in + 48))) + (*Tstatvfs)(unsafe.Pointer(out)).Ff_fsid = Uint64FromInt32(**(**int32)(__ccgo_up(in + 48))) (*Tstatvfs)(unsafe.Pointer(out)).Ff_flag = uint64((*Tstatfs)(unsafe.Pointer(in)).Ff_flags) (*Tstatvfs)(unsafe.Pointer(out)).Ff_namemax = uint64((*Tstatfs)(unsafe.Pointer(in)).Ff_namelen) (*Tstatvfs)(unsafe.Pointer(out)).Ff_type = (*Tstatfs)(unsafe.Pointer(in)).Ff_type @@ -135928,7 +135928,7 @@ func Xutimensat(tls *TLS, fd int32, path uintptr, times uintptr, flags int32) (r var tv uintptr var _ /* tmp at bp+0 */ [4]int64 _, _, _ = i, r, tv - if times != 0 && (*(*Ttimespec)(unsafe.Pointer(times))).Ftv_nsec == int64(UTIME_NOW) && (*(*Ttimespec)(unsafe.Pointer(times + 1*16))).Ftv_nsec == int64(UTIME_NOW) { + if times != 0 && (**(**Ttimespec)(__ccgo_up(times))).Ftv_nsec == int64(UTIME_NOW) && (**(**Ttimespec)(__ccgo_up(times + 1*16))).Ftv_nsec == int64(UTIME_NOW) { times = uintptr(0) } r = int32(X__syscall4(tls, int64(SYS_utimensat), int64(fd), int64(path), int64(times), int64(flags))) @@ -135943,14 +135943,14 @@ func Xutimensat(tls *TLS, fd int32, path uintptr, times uintptr, flags int32) (r if !(i < int32(2)) { break } - if Uint64FromInt64((*(*Ttimespec)(unsafe.Pointer(times + uintptr(i)*16))).Ftv_nsec) >= uint64(1000000000) { - if (*(*Ttimespec)(unsafe.Pointer(times + uintptr(i)*16))).Ftv_nsec == int64(UTIME_NOW) || (*(*Ttimespec)(unsafe.Pointer(times + uintptr(i)*16))).Ftv_nsec == int64(UTIME_OMIT) { + if Uint64FromInt64((**(**Ttimespec)(__ccgo_up(times + uintptr(i)*16))).Ftv_nsec) >= uint64(1000000000) { + if (**(**Ttimespec)(__ccgo_up(times + uintptr(i)*16))).Ftv_nsec == int64(UTIME_NOW) || (**(**Ttimespec)(__ccgo_up(times + uintptr(i)*16))).Ftv_nsec == int64(UTIME_OMIT) { return int32(X__syscall_ret(tls, Uint64FromInt32(-Int32FromInt32(ENOSYS)))) } return int32(X__syscall_ret(tls, Uint64FromInt32(-Int32FromInt32(EINVAL)))) } - (*(*[4]int64)(unsafe.Pointer(bp)))[int32(2)*i+0] = (*(*Ttimespec)(unsafe.Pointer(times + uintptr(i)*16))).Ftv_sec - (*(*[4]int64)(unsafe.Pointer(bp)))[int32(2)*i+int32(1)] = (*(*Ttimespec)(unsafe.Pointer(times + uintptr(i)*16))).Ftv_nsec / int64(1000) + (**(**[4]int64)(__ccgo_up(bp)))[int32(2)*i+0] = (**(**Ttimespec)(__ccgo_up(times + uintptr(i)*16))).Ftv_sec + (**(**[4]int64)(__ccgo_up(bp)))[int32(2)*i+int32(1)] = (**(**Ttimespec)(__ccgo_up(times + uintptr(i)*16))).Ftv_nsec / int64(1000) goto _1 _1: ; @@ -135985,8 +135985,8 @@ func X__fdopen(tls *TLS, fd int32, mode uintptr) (r uintptr) { var _ /* wsz at bp+0 */ Twinsize _, _, _, _ = f, flags, v1, v2 /* Check for valid initial mode character */ - if !(Xstrchr(tls, __ccgo_ts+1534, Int32FromUint8(*(*uint8)(unsafe.Pointer(mode)))) != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if !(Xstrchr(tls, __ccgo_ts+1534, Int32FromUint8(**(**uint8)(__ccgo_up(mode)))) != 0) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } /* Allocate FILE+buffer or fail */ @@ -135999,7 +135999,7 @@ func X__fdopen(tls *TLS, fd int32, mode uintptr) (r uintptr) { Xmemset(tls, f, 0, uint64(232)) /* Impose mode restrictions */ if !(Xstrchr(tls, mode, int32('+')) != 0) { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('r') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) == int32('r') { v2 = int32(F_NOWR) } else { v2 = int32(F_NORD) @@ -136011,12 +136011,12 @@ func X__fdopen(tls *TLS, fd int32, mode uintptr) (r uintptr) { X__syscall3(tls, int64(SYS_fcntl), int64(fd), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) } /* Set append mode on fd if opened for append */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('a') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) == int32('a') { flags = int32(X__syscall2(tls, int64(SYS_fcntl), int64(fd), int64(Int32FromInt32(F_GETFL)))) if !(flags&Int32FromInt32(O_APPEND) != 0) { X__syscall3(tls, int64(SYS_fcntl), int64(fd), int64(Int32FromInt32(F_SETFL)), int64(flags|Int32FromInt32(O_APPEND))) } - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_APP) + **(**uint32)(__ccgo_up(f)) |= uint32(F_APP) } (*TFILE)(unsafe.Pointer(f)).Ffd = fd (*TFILE)(unsafe.Pointer(f)).Fbuf = f + uintptr(232) + uintptr(UNGET) @@ -136056,7 +136056,7 @@ func X__fmodeflags(tls *TLS, mode uintptr) (r int32) { if Xstrchr(tls, mode, int32('+')) != 0 { flags = int32(O_RDWR) } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('r') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) == int32('r') { flags = O_RDONLY } else { flags = int32(O_WRONLY) @@ -136068,13 +136068,13 @@ func X__fmodeflags(tls *TLS, mode uintptr) (r int32) { if Xstrchr(tls, mode, int32('e')) != 0 { flags = flags | int32(O_CLOEXEC) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) != int32('r') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) != int32('r') { flags = flags | int32(O_CREAT) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('w') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) == int32('w') { flags = flags | int32(O_TRUNC) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('a') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) == int32('a') { flags = flags | int32(O_APPEND) } return flags @@ -136112,22 +136112,22 @@ func X__overflow(tls *TLS, f uintptr, _c int32) (r int32) { var v2, v3 uintptr var _ /* c at bp+0 */ uint8 _, _, _ = v1, v2, v3 - *(*uint8)(unsafe.Pointer(bp)) = Uint8FromInt32(_c) + **(**uint8)(__ccgo_up(bp)) = Uint8FromInt32(_c) if !((*TFILE)(unsafe.Pointer(f)).Fwend != 0) && X__towrite(tls, f) != 0 { return -int32(1) } - if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwend && Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) != (*TFILE)(unsafe.Pointer(f)).Flbf { - v1 = *(*uint8)(unsafe.Pointer(bp)) + if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwend && Int32FromUint8(**(**uint8)(__ccgo_up(bp))) != (*TFILE)(unsafe.Pointer(f)).Flbf { + v1 = **(**uint8)(__ccgo_up(bp)) v3 = f + 40 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - *(*uint8)(unsafe.Pointer(v2)) = v1 + **(**uint8)(__ccgo_up(v2)) = v1 return Int32FromUint8(v1) } if (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fwrite})))(tls, f, bp, uint64(1)) != uint64(1) { return -int32(1) } - return Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) + return Int32FromUint8(**(**uint8)(__ccgo_up(bp))) } func _dummy9(tls *TLS, fd int32) (r int32) { @@ -136165,7 +136165,7 @@ func X__stdio_exit(tls *TLS) { } var f uintptr _ = f - f = *(*uintptr)(unsafe.Pointer(X__ofl_lock(tls))) + f = **(**uintptr)(__ccgo_up(X__ofl_lock(tls))) for { if !(f != 0) { break @@ -136201,7 +136201,7 @@ func X__stdio_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { var v3, v4 uintptr var _ /* iov at bp+0 */ [2]Tiovec _, _, _, _, _ = cnt, v1, v2, v3, v4 - *(*[2]Tiovec)(unsafe.Pointer(bp)) = [2]Tiovec{ + **(**[2]Tiovec)(__ccgo_up(bp)) = [2]Tiovec{ 0: { Fiov_base: buf, Fiov_len: len1 - BoolUint64(!!((*TFILE)(unsafe.Pointer(f)).Fbuf_size != 0)), @@ -136211,10 +136211,10 @@ func X__stdio_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { Fiov_len: (*TFILE)(unsafe.Pointer(f)).Fbuf_size, }, } - if (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len != 0 { + if (**(**[2]Tiovec)(__ccgo_up(bp)))[0].Fiov_len != 0 { v1 = X__syscall_ret(tls, Uint64FromInt64(X__syscall3(tls, int64(SYS_readv), int64((*TFILE)(unsafe.Pointer(f)).Ffd), int64(bp), int64(Int32FromInt32(2))))) } else { - v1 = X__syscall_ret(tls, Uint64FromInt64(X__syscall3(tls, int64(SYS_read), int64((*TFILE)(unsafe.Pointer(f)).Ffd), int64((*(*[2]Tiovec)(unsafe.Pointer(bp)))[int32(1)].Fiov_base), Int64FromUint64((*(*[2]Tiovec)(unsafe.Pointer(bp)))[int32(1)].Fiov_len)))) + v1 = X__syscall_ret(tls, Uint64FromInt64(X__syscall3(tls, int64(SYS_read), int64((*TFILE)(unsafe.Pointer(f)).Ffd), int64((**(**[2]Tiovec)(__ccgo_up(bp)))[int32(1)].Fiov_base), Int64FromUint64((**(**[2]Tiovec)(__ccgo_up(bp)))[int32(1)].Fiov_len)))) } cnt = v1 if cnt <= 0 { @@ -136223,20 +136223,20 @@ func X__stdio_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { } else { v2 = int32(F_EOF) } - *(*uint32)(unsafe.Pointer(f)) |= Uint32FromInt32(v2) + **(**uint32)(__ccgo_up(f)) |= Uint32FromInt32(v2) return uint64(0) } - if Uint64FromInt64(cnt) <= (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len { + if Uint64FromInt64(cnt) <= (**(**[2]Tiovec)(__ccgo_up(bp)))[0].Fiov_len { return Uint64FromInt64(cnt) } - cnt = Int64FromUint64(uint64(cnt) - (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len) + cnt = Int64FromUint64(uint64(cnt) - (**(**[2]Tiovec)(__ccgo_up(bp)))[0].Fiov_len) (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(cnt) if (*TFILE)(unsafe.Pointer(f)).Fbuf_size != 0 { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(buf + uintptr(len1-uint64(1)))) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(buf + uintptr(len1-uint64(1)))) = **(**uint8)(__ccgo_up(v3)) } return len1 } @@ -136263,7 +136263,7 @@ func X__stdio_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) var v5 uint64 var _ /* iovs at bp+0 */ [2]Tiovec _, _, _, _, _, _, _ = cnt, iov, iovcnt, rem, v2, v3, v5 - *(*[2]Tiovec)(unsafe.Pointer(bp)) = [2]Tiovec{ + **(**[2]Tiovec)(__ccgo_up(bp)) = [2]Tiovec{ 0: { Fiov_base: (*TFILE)(unsafe.Pointer(f)).Fwbase, Fiov_len: Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Fwpos) - int64((*TFILE)(unsafe.Pointer(f)).Fwbase)), @@ -136274,7 +136274,7 @@ func X__stdio_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) }, } iov = bp - rem = (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len + (*(*Tiovec)(unsafe.Pointer(iov + 1*16))).Fiov_len + rem = (**(**Tiovec)(__ccgo_up(iov))).Fiov_len + (**(**Tiovec)(__ccgo_up(iov + 1*16))).Fiov_len iovcnt = int32(2) for { cnt = X__syscall_ret(tls, Uint64FromInt64(X__syscall3(tls, int64(SYS_writev), int64((*TFILE)(unsafe.Pointer(f)).Ffd), int64(iov), int64(iovcnt)))) @@ -136291,22 +136291,22 @@ func X__stdio_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) v2 = v3 (*TFILE)(unsafe.Pointer(f)).Fwbase = v2 (*TFILE)(unsafe.Pointer(f)).Fwpos = v2 - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) if iovcnt == int32(2) { v5 = uint64(0) } else { - v5 = len1 - (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len + v5 = len1 - (**(**Tiovec)(__ccgo_up(iov))).Fiov_len } return v5 } rem = rem - Uint64FromInt64(cnt) - if Uint64FromInt64(cnt) > (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len { - cnt = Int64FromUint64(uint64(cnt) - (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len) + if Uint64FromInt64(cnt) > (**(**Tiovec)(__ccgo_up(iov))).Fiov_len { + cnt = Int64FromUint64(uint64(cnt) - (**(**Tiovec)(__ccgo_up(iov))).Fiov_len) iov += 16 iovcnt = iovcnt - 1 } - (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_base = (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_base + uintptr(cnt) - (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len -= Uint64FromInt64(cnt) + (**(**Tiovec)(__ccgo_up(iov))).Fiov_base = (**(**Tiovec)(__ccgo_up(iov))).Fiov_base + uintptr(cnt) + (**(**Tiovec)(__ccgo_up(iov))).Fiov_len -= Uint64FromInt64(cnt) goto _1 _1: } @@ -136336,7 +136336,7 @@ func X__toread(tls *TLS, f uintptr) (r int32) { var v1, v2 uintptr var v4 int32 _, _, _ = v1, v2, v4 - *(*int32)(unsafe.Pointer(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) + **(**int32)(__ccgo_up(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwbase { (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fwrite})))(tls, f, uintptr(0), uint64(0)) } @@ -136346,7 +136346,7 @@ func X__toread(tls *TLS, f uintptr) (r int32) { (*TFILE)(unsafe.Pointer(f)).Fwbase = v1 (*TFILE)(unsafe.Pointer(f)).Fwpos = v1 if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_NORD) != 0 { - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) return -int32(1) } v1 = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr((*TFILE)(unsafe.Pointer(f)).Fbuf_size) @@ -136374,9 +136374,9 @@ func X__towrite(tls *TLS, f uintptr) (r int32) { } var v1 uintptr _ = v1 - *(*int32)(unsafe.Pointer(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) + **(**int32)(__ccgo_up(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_NOWR) != 0 { - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) return -int32(1) } /* Clear read buffer (easier than summoning nasal demons) */ @@ -136410,7 +136410,7 @@ func X__uflow(tls *TLS, f uintptr) (r int32) { defer tls.Free(16) var _ /* c at bp+0 */ uint8 if !(X__toread(tls, f) != 0) && (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fread})))(tls, f, bp, uint64(1)) == uint64(1) { - return Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) + return Int32FromUint8(**(**uint8)(__ccgo_up(bp))) } return -int32(1) } @@ -136441,7 +136441,7 @@ func Xclearerr(tls *TLS, f uintptr) { v1 = 0 } __need_unlock = v1 - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^(Int32FromInt32(F_EOF) | Int32FromInt32(F_ERR))) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^(Int32FromInt32(F_EOF) | Int32FromInt32(F_ERR))) if __need_unlock != 0 { ___unlockfile(tls, f) } @@ -136602,7 +136602,7 @@ func X__freadptr(tls *TLS, f uintptr, sizep uintptr) (r uintptr) { if (*TFILE)(unsafe.Pointer(f)).Frpos == (*TFILE)(unsafe.Pointer(f)).Frend { return uintptr(0) } - *(*Tsize_t)(unsafe.Pointer(sizep)) = Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Frend) - int64((*TFILE)(unsafe.Pointer(f)).Frpos)) + **(**Tsize_t)(__ccgo_up(sizep)) = Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Frend) - int64((*TFILE)(unsafe.Pointer(f)).Frpos)) return (*TFILE)(unsafe.Pointer(f)).Frpos } @@ -136610,14 +136610,14 @@ func X__freadptrinc(tls *TLS, f uintptr, inc Tsize_t) { if __ccgo_strace { trc("tls=%v f=%v inc=%v, (%v:)", tls, f, inc, origin(2)) } - *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(inc) + **(**uintptr)(__ccgo_up(f + 8)) += uintptr(inc) } func X__fseterr(tls *TLS, f uintptr) { if __ccgo_strace { trc("tls=%v f=%v, (%v:)", tls, f, origin(2)) } - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) } func _dummy10(tls *TLS, f uintptr) { @@ -136660,8 +136660,8 @@ func Xfclose(tls *TLS, f uintptr) (r1 int32) { if (*TFILE)(unsafe.Pointer(f)).Fnext != 0 { (*TFILE)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Fnext)).Fprev = (*TFILE)(unsafe.Pointer(f)).Fprev } - if *(*uintptr)(unsafe.Pointer(head)) == f { - *(*uintptr)(unsafe.Pointer(head)) = (*TFILE)(unsafe.Pointer(f)).Fnext + if **(**uintptr)(__ccgo_up(head)) == f { + **(**uintptr)(__ccgo_up(head)) = (*TFILE)(unsafe.Pointer(f)).Fnext } X__ofl_unlock(tls) Xfree(tls, (*TFILE)(unsafe.Pointer(f)).Fgetln_buf) @@ -136762,7 +136762,7 @@ func Xfflush(tls *TLS, f uintptr) (r1 int32) { if AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stderr_used))) != 0 { r = r | Xfflush(tls, AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stderr_used)))) } - f = *(*uintptr)(unsafe.Pointer(X__ofl_lock(tls))) + f = **(**uintptr)(__ccgo_up(X__ofl_lock(tls))) for { if !(f != 0) { break @@ -136850,7 +136850,7 @@ _3: v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v5))) } else { v1 = X__uflow(tls, f) } @@ -136908,7 +136908,7 @@ func Xfgetc(tls *TLS, f1 uintptr) (r int32) { v6 = v1 + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(v5))) } else { v4 = X__uflow(tls, v1) } @@ -136944,7 +136944,7 @@ func Xfgetln(tls *TLS, f uintptr, plen uintptr) (r uintptr) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__uflow(tls, f) } @@ -136957,14 +136957,14 @@ func Xfgetln(tls *TLS, f uintptr, plen uintptr) (r uintptr) { ret = (*TFILE)(unsafe.Pointer(f)).Frpos z = z + 1 v3 = z - *(*Tsize_t)(unsafe.Pointer(plen)) = Uint64FromInt64(int64(v3) - int64(ret)) + **(**Tsize_t)(__ccgo_up(plen)) = Uint64FromInt64(int64(v3) - int64(ret)) (*TFILE)(unsafe.Pointer(f)).Frpos = z } else { *(*[1]Tsize_t)(unsafe.Pointer(bp)) = [1]Tsize_t{} v8 = Xgetline(tls, f+168, bp, f) l = v8 if v8 > 0 { - *(*Tsize_t)(unsafe.Pointer(plen)) = Uint64FromInt64(l) + **(**Tsize_t)(__ccgo_up(plen)) = Uint64FromInt64(l) ret = (*TFILE)(unsafe.Pointer(f)).Fgetln_buf } } @@ -136985,7 +136985,7 @@ func Xfgetpos(tls *TLS, f uintptr, pos uintptr) (r int32) { if off < 0 { return -int32(1) } - *(*int64)(unsafe.Pointer(pos)) = off + **(**int64)(__ccgo_up(pos)) = off return 0 } @@ -137009,14 +137009,14 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { } __need_unlock = v1 if n <= int32(1) { - *(*int32)(unsafe.Pointer(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) + **(**int32)(__ccgo_up(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) if __need_unlock != 0 { ___unlockfile(tls, f) } if n < int32(1) { return uintptr(0) } - *(*uint8)(unsafe.Pointer(s)) = uint8(0) + **(**uint8)(__ccgo_up(s)) = uint8(0) return s } n = n - 1 @@ -137036,7 +137036,7 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { } k = v3 Xmemcpy(tls, p, (*TFILE)(unsafe.Pointer(f)).Frpos, k) - *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(k) + **(**uintptr)(__ccgo_up(f + 8)) += uintptr(k) p = p + uintptr(k) n = Int32FromUint64(uint64(n) - k) if z != 0 || !(n != 0) { @@ -137047,7 +137047,7 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { v7 = f + 8 v6 = *(*uintptr)(unsafe.Pointer(v7)) *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) + 1 - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(v6))) } else { v4 = X__uflow(tls, f) } @@ -137063,13 +137063,13 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { v8 = Uint8FromInt32(c) v6 = p p = p + 1 - *(*uint8)(unsafe.Pointer(v6)) = v8 + **(**uint8)(__ccgo_up(v6)) = v8 if Int32FromUint8(v8) == int32('\n') { break } } if s != 0 { - *(*uint8)(unsafe.Pointer(p)) = uint8(0) + **(**uint8)(__ccgo_up(p)) = uint8(0) } if __need_unlock != 0 { ___unlockfile(tls, f) @@ -137099,43 +137099,43 @@ func ___fgetwc_unlocked_internal(tls *TLS, f uintptr) (r Twint_t) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { l = Uint64FromInt32(Xmbtowc(tls, bp, (*TFILE)(unsafe.Pointer(f)).Frpos, Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Frend)-int64((*TFILE)(unsafe.Pointer(f)).Frpos)))) if l+uint64(1) >= uint64(1) { - *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(l + BoolUint64(!(l != 0))) /* l==0 means 1 byte, null */ - return Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))) + **(**uintptr)(__ccgo_up(f + 8)) += uintptr(l + BoolUint64(!(l != 0))) /* l==0 means 1 byte, null */ + return Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))) } } /* Convert character byte-by-byte */ - *(*Tmbstate_t)(unsafe.Pointer(bp + 8)) = Tmbstate_t{} + **(**Tmbstate_t)(__ccgo_up(bp + 8)) = Tmbstate_t{} first = int32(1) for cond := true; cond; cond = l == Uint64FromInt32(-Int32FromInt32(2)) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } else { v2 = X__uflow(tls, f) } v1 = v2 c = v1 - *(*uint8)(unsafe.Pointer(bp + 16)) = Uint8FromInt32(v1) + **(**uint8)(__ccgo_up(bp + 16)) = Uint8FromInt32(v1) if c < 0 { if !(first != 0) { - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EILSEQ) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EILSEQ) } return uint32(0xffffffff) } l = Xmbrtowc(tls, bp, bp+16, uint64(1), bp+8) if l == Uint64FromInt32(-Int32FromInt32(1)) { if !(first != 0) { - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) - Xungetc(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + 16))), f) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) + Xungetc(tls, Int32FromUint8(**(**uint8)(__ccgo_up(bp + 16))), f) } return uint32(0xffffffff) } first = 0 } - return Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(bp))) + return Uint32FromInt32(**(**Twchar_t)(__ccgo_up(bp))) } func X__fgetwc_unlocked(tls *TLS, f uintptr) (r Twint_t) { @@ -137148,13 +137148,13 @@ func X__fgetwc_unlocked(tls *TLS, f uintptr) (r Twint_t) { var wc Twchar_t _, _, _ = loc, ploc, wc ploc = uintptr(___get_tp(tls)) + 168 - loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) + loc = **(**Tlocale_t)(__ccgo_up(ploc)) if (*TFILE)(unsafe.Pointer(f)).Fmode <= 0 { Xfwide(tls, f, int32(1)) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale + **(**Tlocale_t)(__ccgo_up(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale wc = Int32FromUint32(___fgetwc_unlocked_internal(tls, f)) - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return Uint32FromInt32(wc) } @@ -137226,7 +137226,7 @@ func Xfgetws(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { } v4 = p p += 4 - *(*Twchar_t)(unsafe.Pointer(v4)) = Int32FromUint32(c) + **(**Twchar_t)(__ccgo_up(v4)) = Int32FromUint32(c) if c == uint32('\n') { break } @@ -137235,7 +137235,7 @@ func Xfgetws(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { ; n = n - 1 } - *(*Twchar_t)(unsafe.Pointer(p)) = 0 + **(**Twchar_t)(__ccgo_up(p)) = 0 if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_ERR) != 0 { p = s } @@ -137276,7 +137276,7 @@ func Xfileno(tls *TLS, f uintptr) (r int32) { ___unlockfile(tls, f) } if fd < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EBADF) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EBADF) return -int32(1) } return fd @@ -137329,7 +137329,7 @@ func _mseek(tls *TLS, f uintptr, off Toff_t, whence int32) (r Toff_t) { goto fail fail: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) _1: ; @@ -137337,7 +137337,7 @@ _1: 1: (*Tcookie)(unsafe.Pointer(c)).Fpos, 2: (*Tcookie)(unsafe.Pointer(c)).Flen1, } - base = Int64FromUint64(*(*Tsize_t)(unsafe.Pointer(bp + uintptr(whence)*8))) + base = Int64FromUint64(**(**Tsize_t)(__ccgo_up(bp + uintptr(whence)*8))) if off < -base || off > Int64FromUint64((*Tcookie)(unsafe.Pointer(c)).Fsize)-base { goto fail } @@ -137357,10 +137357,10 @@ func _mread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { } if len1 > rem { len1 = rem - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_EOF) + **(**uint32)(__ccgo_up(f)) |= uint32(F_EOF) } Xmemcpy(tls, buf, (*Tcookie)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie)(unsafe.Pointer(c)).Fpos), len1) - *(*Tsize_t)(unsafe.Pointer(c)) += len1 + **(**Tsize_t)(__ccgo_up(c)) += len1 rem = rem - len1 if rem > (*TFILE)(unsafe.Pointer(f)).Fbuf_size { rem = (*TFILE)(unsafe.Pointer(f)).Fbuf_size @@ -137368,7 +137368,7 @@ func _mread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(rem) Xmemcpy(tls, (*TFILE)(unsafe.Pointer(f)).Frpos, (*Tcookie)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie)(unsafe.Pointer(c)).Fpos), rem) - *(*Tsize_t)(unsafe.Pointer(c)) += rem + **(**Tsize_t)(__ccgo_up(c)) += rem return len1 } @@ -137392,14 +137392,14 @@ func _mwrite(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { len1 = rem } Xmemcpy(tls, (*Tcookie)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie)(unsafe.Pointer(c)).Fpos), buf, len1) - *(*Tsize_t)(unsafe.Pointer(c)) += len1 + **(**Tsize_t)(__ccgo_up(c)) += len1 if (*Tcookie)(unsafe.Pointer(c)).Fpos > (*Tcookie)(unsafe.Pointer(c)).Flen1 { (*Tcookie)(unsafe.Pointer(c)).Flen1 = (*Tcookie)(unsafe.Pointer(c)).Fpos if (*Tcookie)(unsafe.Pointer(c)).Flen1 < (*Tcookie)(unsafe.Pointer(c)).Fsize { - *(*uint8)(unsafe.Pointer((*Tcookie)(unsafe.Pointer(c)).Fbuf + uintptr((*Tcookie)(unsafe.Pointer(c)).Flen1))) = uint8(0) + **(**uint8)(__ccgo_up((*Tcookie)(unsafe.Pointer(c)).Fbuf + uintptr((*Tcookie)(unsafe.Pointer(c)).Flen1))) = uint8(0) } else { if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_NORD) != 0 && (*Tcookie)(unsafe.Pointer(c)).Fsize != 0 { - *(*uint8)(unsafe.Pointer((*Tcookie)(unsafe.Pointer(c)).Fbuf + uintptr((*Tcookie)(unsafe.Pointer(c)).Fsize-uint64(1)))) = uint8(0) + **(**uint8)(__ccgo_up((*Tcookie)(unsafe.Pointer(c)).Fbuf + uintptr((*Tcookie)(unsafe.Pointer(c)).Fsize-uint64(1)))) = uint8(0) } } } @@ -137421,12 +137421,12 @@ func Xfmemopen(tls *TLS, buf uintptr, size Tsize_t, mode uintptr) (r uintptr) { var v3 Tsize_t _, _, _, _, _ = f, plus, v1, v2, v3 plus = BoolInt32(!!(Xstrchr(tls, mode, int32('+')) != 0)) - if !(Xstrchr(tls, __ccgo_ts+1534, Int32FromUint8(*(*uint8)(unsafe.Pointer(mode)))) != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if !(Xstrchr(tls, __ccgo_ts+1534, Int32FromUint8(**(**uint8)(__ccgo_up(mode)))) != 0) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } if !(buf != 0) && size > Uint64FromInt64(Int64FromInt64(INT64_MAX)) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return uintptr(0) } if buf != 0 { @@ -137450,25 +137450,25 @@ func Xfmemopen(tls *TLS, buf uintptr, size Tsize_t, mode uintptr) (r uintptr) { } (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fbuf = buf (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fsize = size - (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fmode = Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) + (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fmode = Int32FromUint8(**(**uint8)(__ccgo_up(mode))) if !(plus != 0) { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('r') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) == int32('r') { v2 = int32(F_NOWR) } else { v2 = int32(F_NORD) } (*Tmem_FILE)(unsafe.Pointer(f)).Ff.Fflags = Uint32FromInt32(v2) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('r') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) == int32('r') { (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Flen1 = size } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('a') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) == int32('a') { v3 = Xstrnlen(tls, buf, size) (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fpos = v3 (*Tmem_FILE)(unsafe.Pointer(f)).Fc.Flen1 = v3 } else { if plus != 0 { - *(*uint8)(unsafe.Pointer((*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fbuf)) = uint8(0) + **(**uint8)(__ccgo_up((*Tmem_FILE)(unsafe.Pointer(f)).Fc.Fbuf)) = uint8(0) } } } @@ -137491,8 +137491,8 @@ func Xfopen(tls *TLS, filename uintptr, mode uintptr) (r uintptr) { var fd, flags int32 _, _, _ = f, fd, flags /* Check for valid initial mode character */ - if !(Xstrchr(tls, __ccgo_ts+1534, Int32FromUint8(*(*uint8)(unsafe.Pointer(mode)))) != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if !(Xstrchr(tls, __ccgo_ts+1534, Int32FromUint8(**(**uint8)(__ccgo_up(mode)))) != 0) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } /* Compute the flags to pass to open() */ @@ -137559,7 +137559,7 @@ func _cookieread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - *(*uint8)(unsafe.Pointer(buf + uintptr(v1))) = *(*uint8)(unsafe.Pointer(v2)) + **(**uint8)(__ccgo_up(buf + uintptr(v1))) = **(**uint8)(__ccgo_up(v2)) return readlen goto bail bail: @@ -137569,7 +137569,7 @@ bail: } else { v4 = int32(F_ERR) } - *(*uint32)(unsafe.Pointer(f)) |= Uint32FromInt32(v4) + **(**uint32)(__ccgo_up(f)) |= Uint32FromInt32(v4) v2 = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = v2 (*TFILE)(unsafe.Pointer(f)).Frpos = v2 @@ -137599,7 +137599,7 @@ func _cookiewrite(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { v1 = v2 (*TFILE)(unsafe.Pointer(f)).Fwbase = v1 (*TFILE)(unsafe.Pointer(f)).Fwpos = v1 - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) return uint64(0) } return Uint64FromInt64(ret) @@ -137614,18 +137614,18 @@ func _cookieseek(tls *TLS, f uintptr, _off Toff_t, whence int32) (r Toff_t) { _, _ = fc, res fc = (*TFILE)(unsafe.Pointer(f)).Fcookie if Uint32FromInt32(whence) > uint32(2) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) } if !((*Tfcookie)(unsafe.Pointer(fc)).Fiofuncs.Fseek != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOPNOTSUPP) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOPNOTSUPP) return int64(-int32(1)) } res = (*(*func(*TLS, uintptr, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{(*Tfcookie)(unsafe.Pointer(fc)).Fiofuncs.Fseek})))(tls, (*Tfcookie)(unsafe.Pointer(fc)).Fcookie, bp, whence) if res < 0 { return int64(res) } - return *(*Toff_t)(unsafe.Pointer(bp)) + return **(**Toff_t)(__ccgo_up(bp)) } func _cookieclose(tls *TLS, f uintptr) (r int32) { @@ -137647,8 +137647,8 @@ func Xfopencookie(tls *TLS, cookie uintptr, mode uintptr, iofuncs Tcookie_io_fun var v2 int32 _, _, _ = f, v1, v2 /* Check for valid initial mode character */ - if !(Xstrchr(tls, __ccgo_ts+1534, Int32FromUint8(*(*uint8)(unsafe.Pointer(mode)))) != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + if !(Xstrchr(tls, __ccgo_ts+1534, Int32FromUint8(**(**uint8)(__ccgo_up(mode)))) != 0) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } /* Allocate FILE+fcookie+buffer or fail */ @@ -137661,7 +137661,7 @@ func Xfopencookie(tls *TLS, cookie uintptr, mode uintptr, iofuncs Tcookie_io_fun Xmemset(tls, f, 0, uint64(232)) /* Impose mode restrictions */ if !(Xstrchr(tls, mode, int32('+')) != 0) { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('r') { + if Int32FromUint8(**(**uint8)(__ccgo_up(mode))) == int32('r') { v2 = int32(F_NOWR) } else { v2 = int32(F_NORD) @@ -137721,7 +137721,7 @@ _3: v7 = f + 40 v6 = *(*uintptr)(unsafe.Pointer(v7)) *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) + 1 - *(*uint8)(unsafe.Pointer(v6)) = v5 + **(**uint8)(__ccgo_up(v6)) = v5 v1 = Int32FromUint8(v5) } else { v1 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) @@ -137783,7 +137783,7 @@ func Xfputc(tls *TLS, c1 int32, f1 uintptr) (r int32) { v8 = v2 + 40 v7 = *(*uintptr)(unsafe.Pointer(v8)) *(*uintptr)(unsafe.Pointer(v8)) = *(*uintptr)(unsafe.Pointer(v8)) + 1 - *(*uint8)(unsafe.Pointer(v7)) = v6 + **(**uint8)(__ccgo_up(v7)) = v6 v5 = Int32FromUint8(v6) } else { v5 = X__overflow(tls, v2, Int32FromUint8(Uint8FromInt32(v1))) @@ -137830,18 +137830,18 @@ func X__fputwc_unlocked(tls *TLS, c Twchar_t, f uintptr) (r Twint_t) { var _ /* mbc at bp+0 */ [4]uint8 _, _, _, _, _, _, _ = l, loc, ploc, v1, v2, v3, v4 ploc = uintptr(___get_tp(tls)) + 168 - loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) + loc = **(**Tlocale_t)(__ccgo_up(ploc)) if (*TFILE)(unsafe.Pointer(f)).Fmode <= 0 { Xfwide(tls, f, int32(1)) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale + **(**Tlocale_t)(__ccgo_up(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale if BoolInt32(Uint32FromInt32(c) < uint32(128)) != 0 { if Int32FromUint8(Uint8FromInt32(c)) != (*TFILE)(unsafe.Pointer(f)).Flbf && (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwend { v2 = Uint8FromInt32(c) v4 = f + 40 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(v3)) = v2 + **(**uint8)(__ccgo_up(v3)) = v2 v1 = Int32FromUint8(v2) } else { v1 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) @@ -137853,7 +137853,7 @@ func X__fputwc_unlocked(tls *TLS, c Twchar_t, f uintptr) (r Twint_t) { if l < 0 { c = Int32FromUint32(0xffffffff) } else { - *(*uintptr)(unsafe.Pointer(f + 40)) += uintptr(l) + **(**uintptr)(__ccgo_up(f + 40)) += uintptr(l) } } else { l = Xwctomb(tls, bp, c) @@ -137863,9 +137863,9 @@ func X__fputwc_unlocked(tls *TLS, c Twchar_t, f uintptr) (r Twint_t) { } } if Uint32FromInt32(c) == uint32(0xffffffff) { - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return Uint32FromInt32(c) } @@ -137922,7 +137922,7 @@ func Xfputws(tls *TLS, _ws uintptr, f uintptr) (r int32) { _, _, _, _, _, _, _ = __need_unlock, l, loc, ploc, v1, v2, v3 l = uint64(0) ploc = uintptr(___get_tp(tls)) + 168 - loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) + loc = **(**Tlocale_t)(__ccgo_up(ploc)) if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) } else { @@ -137930,9 +137930,9 @@ func Xfputws(tls *TLS, _ws uintptr, f uintptr) (r int32) { } __need_unlock = v1 Xfwide(tls, f, int32(1)) - *(*Tlocale_t)(unsafe.Pointer(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale + **(**Tlocale_t)(__ccgo_up(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale for { - if v3 = *(*uintptr)(unsafe.Pointer(bp)) != 0; v3 { + if v3 = **(**uintptr)(__ccgo_up(bp)) != 0; v3 { v2 = Xwcsrtombs(tls, bp+8, bp, uint64(1024), uintptr(0)) l = v2 } @@ -137943,14 +137943,14 @@ func Xfputws(tls *TLS, _ws uintptr, f uintptr) (r int32) { if __need_unlock != 0 { ___unlockfile(tls, f) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return -int32(1) } } if __need_unlock != 0 { ___unlockfile(tls, f) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return Int32FromUint64(l) /* 0 or -1 */ } @@ -137984,7 +137984,7 @@ func Xfread(tls *TLS, destv uintptr, size Tsize_t, nmemb Tsize_t, f uintptr) (r v1 = 0 } __need_unlock = v1 - *(*int32)(unsafe.Pointer(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) + **(**int32)(__ccgo_up(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { /* First exhaust the buffer. */ if Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Frend)-int64((*TFILE)(unsafe.Pointer(f)).Frpos)) < l { @@ -137994,7 +137994,7 @@ func Xfread(tls *TLS, destv uintptr, size Tsize_t, nmemb Tsize_t, f uintptr) (r } k = v2 Xmemcpy(tls, dest, (*TFILE)(unsafe.Pointer(f)).Frpos, k) - *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(k) + **(**uintptr)(__ccgo_up(f + 8)) += uintptr(k) dest = dest + uintptr(k) l = l - k } @@ -138134,7 +138134,7 @@ func X__fseeko_unlocked(tls *TLS, f uintptr, off Toff_t, whence int32) (r int32) _, _ = v1, v2 /* Fail immediately for invalid whence argument. */ if whence != int32(1) && whence != 0 && whence != int32(2) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } /* Adjust relative offset for unread data in buffer, if any. */ @@ -138162,7 +138162,7 @@ func X__fseeko_unlocked(tls *TLS, f uintptr, off Toff_t, whence int32) (r int32) v1 = UintptrFromInt32(0) (*TFILE)(unsafe.Pointer(f)).Frend = v1 (*TFILE)(unsafe.Pointer(f)).Frpos = v1 - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) return 0 } @@ -138207,7 +138207,7 @@ func Xfsetpos(tls *TLS, f uintptr, pos uintptr) (r int32) { trc("tls=%v f=%v pos=%v, (%v:)", tls, f, pos, origin(2)) defer func() { trc("-> %v", r) }() } - return X__fseeko(tls, f, *(*int64)(unsafe.Pointer(pos)), 0) + return X__fseeko(tls, f, int64(**(**int64)(__ccgo_up(pos))), 0) } /* Support signed or unsigned plain-char */ @@ -138277,7 +138277,7 @@ func Xftell(tls *TLS, f uintptr) (r int64) { _ = pos pos = X__ftello(tls, f) if pos > int64(0x7fffffffffffffff) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return int64(-int32(1)) } return pos @@ -138414,7 +138414,7 @@ func Xfwide(tls *TLS, f uintptr, mode int32) (r int32) { __need_unlock = v1 if mode != 0 { if !((*TFILE)(unsafe.Pointer(f)).Flocale != 0) { - if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { + if !!(**(**uintptr)(__ccgo_up((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { v3 = int32(4) } else { v3 = int32(1) @@ -138474,7 +138474,7 @@ func X__fwritex(tls *TLS, s uintptr, l Tsize_t, f uintptr) (r Tsize_t) { /* Match /^(.*\n|)/ */ i = l for { - if !(i != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(i-uint64(1))))) != int32('\n')) { + if !(i != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(i-uint64(1))))) != int32('\n')) { break } goto _1 @@ -138492,7 +138492,7 @@ func X__fwritex(tls *TLS, s uintptr, l Tsize_t, f uintptr) (r Tsize_t) { } } Xmemcpy(tls, (*TFILE)(unsafe.Pointer(f)).Fwpos, s, l) - *(*uintptr)(unsafe.Pointer(f + 40)) += uintptr(l) + **(**uintptr)(__ccgo_up(f + 40)) += uintptr(l) return l + i } @@ -138577,7 +138577,7 @@ _3: v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v5))) } else { v1 = X__uflow(tls, f) } @@ -138635,7 +138635,7 @@ func Xgetc(tls *TLS, f1 uintptr) (r int32) { v6 = v1 + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(v5))) } else { v4 = X__uflow(tls, v1) } @@ -138668,7 +138668,7 @@ func Xgetc_unlocked(tls *TLS, f uintptr) (r int32) { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__uflow(tls, f) } @@ -138711,7 +138711,7 @@ _3: v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v5))) } else { v1 = X__uflow(tls, f) } @@ -138769,7 +138769,7 @@ func Xgetchar(tls *TLS) (r int32) { v6 = v1 + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(v5))) } else { v4 = X__uflow(tls, v1) } @@ -138794,7 +138794,7 @@ func Xgetchar_unlocked(tls *TLS) (r int32) { v3 = uintptr(unsafe.Pointer(&X__stdin_FILE)) + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v2))) } else { v1 = X__uflow(tls, uintptr(unsafe.Pointer(&X__stdin_FILE))) } @@ -138820,16 +138820,16 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize } __need_unlock = v1 if !(n != 0) || !(s != 0) { - *(*int32)(unsafe.Pointer(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**int32)(__ccgo_up(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) if __need_unlock != 0 { ___unlockfile(tls, f) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) } - if !(*(*uintptr)(unsafe.Pointer(s)) != 0) { - *(*Tsize_t)(unsafe.Pointer(n)) = uint64(0) + if !(**(**uintptr)(__ccgo_up(s)) != 0) { + **(**Tsize_t)(__ccgo_up(n)) = uint64(0) } for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { @@ -138844,36 +138844,36 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize z = uintptr(0) k = uint64(0) } - if i+k >= *(*Tsize_t)(unsafe.Pointer(n)) { + if i+k >= **(**Tsize_t)(__ccgo_up(n)) { m = i + k + uint64(2) if !(z != 0) && m < Uint64FromUint64(0xffffffffffffffff)/Uint64FromInt32(4) { m = m + m/uint64(2) } - tmp = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(s)), m) + tmp = Xrealloc(tls, **(**uintptr)(__ccgo_up(s)), m) if !(tmp != 0) { m = i + k + uint64(2) - tmp = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(s)), m) + tmp = Xrealloc(tls, **(**uintptr)(__ccgo_up(s)), m) if !(tmp != 0) { /* Copy as much as fits and ensure no * pushback remains in the FILE buf. */ - k = *(*Tsize_t)(unsafe.Pointer(n)) - i - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(s))+uintptr(i), (*TFILE)(unsafe.Pointer(f)).Frpos, k) - *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(k) - *(*int32)(unsafe.Pointer(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + k = **(**Tsize_t)(__ccgo_up(n)) - i + Xmemcpy(tls, **(**uintptr)(__ccgo_up(s))+uintptr(i), (*TFILE)(unsafe.Pointer(f)).Frpos, k) + **(**uintptr)(__ccgo_up(f + 8)) += uintptr(k) + **(**int32)(__ccgo_up(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) if __need_unlock != 0 { ___unlockfile(tls, f) } - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMEM) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOMEM) return int64(-int32(1)) } } - *(*uintptr)(unsafe.Pointer(s)) = tmp - *(*Tsize_t)(unsafe.Pointer(n)) = m + **(**uintptr)(__ccgo_up(s)) = tmp + **(**Tsize_t)(__ccgo_up(n)) = m } if k != 0 { - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(s))+uintptr(i), (*TFILE)(unsafe.Pointer(f)).Frpos, k) - *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(k) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(s))+uintptr(i), (*TFILE)(unsafe.Pointer(f)).Frpos, k) + **(**uintptr)(__ccgo_up(f + 8)) += uintptr(k) i = i + k } if z != 0 { @@ -138883,7 +138883,7 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize v7 = f + 8 v6 = *(*uintptr)(unsafe.Pointer(v7)) *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) + 1 - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(v6))) } else { v4 = X__uflow(tls, f) } @@ -138900,16 +138900,16 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize } /* If the byte read by getc won't fit without growing the * output buffer, push it back for next iteration. */ - if i+uint64(1) >= *(*Tsize_t)(unsafe.Pointer(n)) { + if i+uint64(1) >= **(**Tsize_t)(__ccgo_up(n)) { v7 = f + 8 *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) - 1 v6 = *(*uintptr)(unsafe.Pointer(v7)) - *(*uint8)(unsafe.Pointer(v6)) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(v6)) = Uint8FromInt32(c) } else { v10 = Uint8FromInt32(c) v11 = i i = i + 1 - *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)) + uintptr(v11))) = v10 + **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)) + uintptr(v11))) = v10 if Int32FromUint8(v10) == delim { break } @@ -138917,7 +138917,7 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize goto _2 _2: } - *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)) + uintptr(i))) = uint8(0) + **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)) + uintptr(i))) = uint8(0) if __need_unlock != 0 { ___unlockfile(tls, f) } @@ -138961,7 +138961,7 @@ func Xgets(tls *TLS, s uintptr) (r uintptr) { v5 = uintptr(unsafe.Pointer(&X__stdin_FILE)) + 8 v4 = *(*uintptr)(unsafe.Pointer(v5)) *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v4))) } else { v3 = X__uflow(tls, uintptr(unsafe.Pointer(&X__stdin_FILE))) } @@ -138972,9 +138972,9 @@ func Xgets(tls *TLS, s uintptr) (r uintptr) { } v6 = i i = i + 1 - *(*uint8)(unsafe.Pointer(s + uintptr(v6))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + uintptr(v6))) = Uint8FromInt32(c) } - *(*uint8)(unsafe.Pointer(s + uintptr(i))) = uint8(0) + **(**uint8)(__ccgo_up(s + uintptr(i))) = uint8(0) if c != int32('\n') && (!((*TFILE)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stdin_FILE)))).Fflags&Uint32FromInt32(F_EOF) != 0) || !(i != 0)) { s = uintptr(0) } @@ -138995,7 +138995,7 @@ func Xgetw(tls *TLS, f uintptr) (r int32) { var _ /* x at bp+0 */ int32 _ = v1 if Xfread(tls, bp, uint64(4), uint64(1), f) != 0 { - v1 = *(*int32)(unsafe.Pointer(bp)) + v1 = **(**int32)(__ccgo_up(bp)) } else { v1 = -int32(1) } @@ -139053,11 +139053,11 @@ func X__ofl_add(tls *TLS, f uintptr) (r uintptr) { var head uintptr _ = head head = X__ofl_lock(tls) - (*TFILE)(unsafe.Pointer(f)).Fnext = *(*uintptr)(unsafe.Pointer(head)) - if *(*uintptr)(unsafe.Pointer(head)) != 0 { - (*TFILE)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(head)))).Fprev = f + (*TFILE)(unsafe.Pointer(f)).Fnext = **(**uintptr)(__ccgo_up(head)) + if **(**uintptr)(__ccgo_up(head)) != 0 { + (*TFILE)(unsafe.Pointer(**(**uintptr)(__ccgo_up(head)))).Fprev = f } - *(*uintptr)(unsafe.Pointer(head)) = f + **(**uintptr)(__ccgo_up(head)) = f X__ofl_unlock(tls) return f } @@ -139091,7 +139091,7 @@ func _ms_seek(tls *TLS, f uintptr, off Toff_t, whence int32) (r Toff_t) { goto fail fail: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) _1: ; @@ -139099,7 +139099,7 @@ _1: 1: (*Tcookie1)(unsafe.Pointer(c)).Fpos, 2: (*Tcookie1)(unsafe.Pointer(c)).Flen1, } - base = Int64FromUint64(*(*Tsize_t)(unsafe.Pointer(bp + uintptr(whence)*8))) + base = Int64FromUint64(**(**Tsize_t)(__ccgo_up(bp + uintptr(whence)*8))) if off < -base || off > int64(0x7fffffffffffffff)-base { goto fail } @@ -139128,16 +139128,16 @@ func _ms_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { } v1 = newbuf (*Tcookie1)(unsafe.Pointer(c)).Fbuf = v1 - *(*uintptr)(unsafe.Pointer((*Tcookie1)(unsafe.Pointer(c)).Fbufp)) = v1 + **(**uintptr)(__ccgo_up((*Tcookie1)(unsafe.Pointer(c)).Fbufp)) = v1 Xmemset(tls, (*Tcookie1)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie1)(unsafe.Pointer(c)).Fspace), 0, len2-(*Tcookie1)(unsafe.Pointer(c)).Fspace) (*Tcookie1)(unsafe.Pointer(c)).Fspace = len2 } Xmemcpy(tls, (*Tcookie1)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie1)(unsafe.Pointer(c)).Fpos), buf, len1) - *(*Tsize_t)(unsafe.Pointer(c + 16)) += len1 + **(**Tsize_t)(__ccgo_up(c + 16)) += len1 if (*Tcookie1)(unsafe.Pointer(c)).Fpos >= (*Tcookie1)(unsafe.Pointer(c)).Flen1 { (*Tcookie1)(unsafe.Pointer(c)).Flen1 = (*Tcookie1)(unsafe.Pointer(c)).Fpos } - *(*Tsize_t)(unsafe.Pointer((*Tcookie1)(unsafe.Pointer(c)).Fsizep)) = (*Tcookie1)(unsafe.Pointer(c)).Fpos + **(**Tsize_t)(__ccgo_up((*Tcookie1)(unsafe.Pointer(c)).Fsizep)) = (*Tcookie1)(unsafe.Pointer(c)).Fpos return len1 } @@ -139170,16 +139170,16 @@ func Xopen_memstream(tls *TLS, bufp uintptr, sizep uintptr) (r uintptr) { (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fbufp = bufp (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fsizep = sizep v5 = Uint64FromInt32(0) - *(*Tsize_t)(unsafe.Pointer(sizep)) = v5 + **(**Tsize_t)(__ccgo_up(sizep)) = v5 v4 = v5 (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fspace = v4 v3 = v4 (*Tms_FILE)(unsafe.Pointer(f)).Fc.Flen1 = v3 (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fpos = v3 v1 = buf - *(*uintptr)(unsafe.Pointer(bufp)) = v1 + **(**uintptr)(__ccgo_up(bufp)) = v1 (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fbuf = v1 - *(*uint8)(unsafe.Pointer(buf)) = uint8(0) + **(**uint8)(__ccgo_up(buf)) = uint8(0) (*Tms_FILE)(unsafe.Pointer(f)).Ff.Fflags = uint32(F_NORD) (*Tms_FILE)(unsafe.Pointer(f)).Ff.Ffd = -int32(1) (*Tms_FILE)(unsafe.Pointer(f)).Ff.Fbuf = f + 280 @@ -139225,7 +139225,7 @@ func _wms_seek(tls *TLS, f uintptr, off Toff_t, whence int32) (r Toff_t) { goto fail fail: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) _1: ; @@ -139233,7 +139233,7 @@ _1: 1: (*Tcookie2)(unsafe.Pointer(c)).Fpos, 2: (*Tcookie2)(unsafe.Pointer(c)).Flen1, } - base = Int64FromUint64(*(*Tsize_t)(unsafe.Pointer(bp + uintptr(whence)*8))) + base = Int64FromUint64(**(**Tsize_t)(__ccgo_up(bp + uintptr(whence)*8))) if off < -base || off > Int64FromInt64(0x7fffffffffffffff)/Int64FromInt32(4)-base { goto fail } @@ -139269,7 +139269,7 @@ func _wms_write(tls *TLS, f uintptr, _buf uintptr, len1 Tsize_t) (r Tsize_t) { } v1 = newbuf (*Tcookie2)(unsafe.Pointer(c)).Fbuf = v1 - *(*uintptr)(unsafe.Pointer((*Tcookie2)(unsafe.Pointer(c)).Fbufp)) = v1 + **(**uintptr)(__ccgo_up((*Tcookie2)(unsafe.Pointer(c)).Fbufp)) = v1 Xmemset(tls, (*Tcookie2)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie2)(unsafe.Pointer(c)).Fspace)*4, 0, uint64(4)*(len2-(*Tcookie2)(unsafe.Pointer(c)).Fspace)) (*Tcookie2)(unsafe.Pointer(c)).Fspace = len2 } @@ -139277,11 +139277,11 @@ func _wms_write(tls *TLS, f uintptr, _buf uintptr, len1 Tsize_t) (r Tsize_t) { if len2 == Uint64FromInt32(-Int32FromInt32(1)) { return uint64(0) } - *(*Tsize_t)(unsafe.Pointer(c + 16)) += len2 + **(**Tsize_t)(__ccgo_up(c + 16)) += len2 if (*Tcookie2)(unsafe.Pointer(c)).Fpos >= (*Tcookie2)(unsafe.Pointer(c)).Flen1 { (*Tcookie2)(unsafe.Pointer(c)).Flen1 = (*Tcookie2)(unsafe.Pointer(c)).Fpos } - *(*Tsize_t)(unsafe.Pointer((*Tcookie2)(unsafe.Pointer(c)).Fsizep)) = (*Tcookie2)(unsafe.Pointer(c)).Fpos + **(**Tsize_t)(__ccgo_up((*Tcookie2)(unsafe.Pointer(c)).Fsizep)) = (*Tcookie2)(unsafe.Pointer(c)).Fpos return len1 } @@ -139314,16 +139314,16 @@ func Xopen_wmemstream(tls *TLS, bufp uintptr, sizep uintptr) (r uintptr) { (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fbufp = bufp (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fsizep = sizep v5 = Uint64FromInt32(0) - *(*Tsize_t)(unsafe.Pointer(sizep)) = v5 + **(**Tsize_t)(__ccgo_up(sizep)) = v5 v4 = v5 (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fspace = v4 v3 = v4 (*Twms_FILE)(unsafe.Pointer(f)).Fc.Flen1 = v3 (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fpos = v3 v1 = buf - *(*uintptr)(unsafe.Pointer(bufp)) = v1 + **(**uintptr)(__ccgo_up(bufp)) = v1 (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fbuf = v1 - *(*Twchar_t)(unsafe.Pointer(buf)) = 0 + **(**Twchar_t)(__ccgo_up(buf)) = 0 (*Twms_FILE)(unsafe.Pointer(f)).Ff.Fflags = uint32(F_NORD) (*Twms_FILE)(unsafe.Pointer(f)).Ff.Ffd = -int32(1) (*Twms_FILE)(unsafe.Pointer(f)).Ff.Fbuf = f + 288 @@ -139362,7 +139362,7 @@ func Xpclose(tls *TLS, f uintptr) (r1 int32) { if r < 0 { return int32(X__syscall_ret(tls, Uint64FromInt32(r))) } - return *(*int32)(unsafe.Pointer(bp)) + return **(**int32)(__ccgo_up(bp)) } func Xperror(tls *TLS, msg uintptr) { @@ -139373,7 +139373,7 @@ func Xperror(tls *TLS, msg uintptr) { var errstr, f, old_locale uintptr _, _, _, _, _, _ = __need_unlock, errstr, f, old_locale, old_mode, v1 f = uintptr(unsafe.Pointer(&X__stderr_FILE)) - errstr = Xstrerror(tls, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) + errstr = Xstrerror(tls, **(**int32)(__ccgo_up(X__errno_location(tls)))) if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) } else { @@ -139384,7 +139384,7 @@ func Xperror(tls *TLS, msg uintptr) { * permitted to change them. */ old_locale = (*TFILE)(unsafe.Pointer(f)).Flocale old_mode = (*TFILE)(unsafe.Pointer(f)).Fmode - if msg != 0 && *(*uint8)(unsafe.Pointer(msg)) != 0 { + if msg != 0 && **(**uint8)(__ccgo_up(msg)) != 0 { Xfwrite(tls, msg, _strlen(tls, msg), uint64(1), f) Xfputc(tls, int32(':'), f) Xfputc(tls, int32(' '), f) @@ -139434,7 +139434,7 @@ _3: v7 = f + 40 v6 = *(*uintptr)(unsafe.Pointer(v7)) *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) + 1 - *(*uint8)(unsafe.Pointer(v6)) = v5 + **(**uint8)(__ccgo_up(v6)) = v5 v1 = Int32FromUint8(v5) } else { v1 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) @@ -139496,7 +139496,7 @@ func Xputc(tls *TLS, c1 int32, f1 uintptr) (r int32) { v8 = v2 + 40 v7 = *(*uintptr)(unsafe.Pointer(v8)) *(*uintptr)(unsafe.Pointer(v8)) = *(*uintptr)(unsafe.Pointer(v8)) + 1 - *(*uint8)(unsafe.Pointer(v7)) = v6 + **(**uint8)(__ccgo_up(v7)) = v6 v5 = Int32FromUint8(v6) } else { v5 = X__overflow(tls, v2, Int32FromUint8(Uint8FromInt32(v1))) @@ -139532,7 +139532,7 @@ func Xputc_unlocked(tls *TLS, c int32, f uintptr) (r int32) { v4 = f + 40 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(v3)) = v2 + **(**uint8)(__ccgo_up(v3)) = v2 v1 = Int32FromUint8(v2) } else { v1 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) @@ -139578,7 +139578,7 @@ _3: v7 = f + 40 v6 = *(*uintptr)(unsafe.Pointer(v7)) *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) + 1 - *(*uint8)(unsafe.Pointer(v6)) = v5 + **(**uint8)(__ccgo_up(v6)) = v5 v1 = Int32FromUint8(v5) } else { v1 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) @@ -139640,7 +139640,7 @@ func Xputchar(tls *TLS, c1 int32) (r int32) { v8 = v2 + 40 v7 = *(*uintptr)(unsafe.Pointer(v8)) *(*uintptr)(unsafe.Pointer(v8)) = *(*uintptr)(unsafe.Pointer(v8)) + 1 - *(*uint8)(unsafe.Pointer(v7)) = v6 + **(**uint8)(__ccgo_up(v7)) = v6 v5 = Int32FromUint8(v6) } else { v5 = X__overflow(tls, v2, Int32FromUint8(Uint8FromInt32(v1))) @@ -139668,7 +139668,7 @@ func Xputchar_unlocked(tls *TLS, c int32) (r int32) { v4 = uintptr(unsafe.Pointer(&X__stdout_FILE)) + 40 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(v3)) = v2 + **(**uint8)(__ccgo_up(v3)) = v2 v1 = Int32FromUint8(v2) } else { v1 = X__overflow(tls, uintptr(unsafe.Pointer(&X__stdout_FILE)), Int32FromUint8(Uint8FromInt32(c))) @@ -139698,7 +139698,7 @@ func Xputs(tls *TLS, s uintptr) (r1 int32) { v5 = uintptr(unsafe.Pointer(&X__stdout_FILE)) + 40 v4 = *(*uintptr)(unsafe.Pointer(v5)) *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) + 1 - *(*uint8)(unsafe.Pointer(v4)) = v3 + **(**uint8)(__ccgo_up(v4)) = v3 v2 = Int32FromUint8(v3) } else { v2 = X__overflow(tls, uintptr(unsafe.Pointer(&X__stdout_FILE)), Int32FromUint8(Uint8FromInt32(Int32FromUint8('\n')))) @@ -139781,7 +139781,7 @@ func Xrewind(tls *TLS, f uintptr) { } __need_unlock = v1 X__fseeko_unlocked(tls, f, 0, 0) - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_ERR)) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^Int32FromInt32(F_ERR)) if __need_unlock != 0 { ___unlockfile(tls, f) } @@ -139871,7 +139871,7 @@ func Xsetvbuf(tls *TLS, f uintptr, buf uintptr, type1 int32, size Tsize_t) (r in return -int32(1) } } - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_SVB) + **(**uint32)(__ccgo_up(f)) |= uint32(F_SVB) return 0 } @@ -140011,14 +140011,14 @@ func Xtempnam(tls *TLS, dir uintptr, pfx uintptr) (r1 uintptr) { pl = _strlen(tls, pfx) l = dl + uint64(1) + pl + uint64(1) + uint64(6) if l >= uint64(PATH_MAX) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENAMETOOLONG) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENAMETOOLONG) return uintptr(0) } Xmemcpy(tls, bp+1, dir, dl) - (*(*[4096]uint8)(unsafe.Pointer(bp + 1)))[dl] = uint8('/') + (**(**[4096]uint8)(__ccgo_up(bp + 1)))[dl] = uint8('/') Xmemcpy(tls, bp+1+uintptr(dl)+uintptr(1), pfx, pl) - (*(*[4096]uint8)(unsafe.Pointer(bp + 1)))[dl+uint64(1)+pl] = uint8('_') - (*(*[4096]uint8)(unsafe.Pointer(bp + 1)))[l] = uint8(0) + (**(**[4096]uint8)(__ccgo_up(bp + 1)))[dl+uint64(1)+pl] = uint8('_') + (**(**[4096]uint8)(__ccgo_up(bp + 1)))[l] = uint8(0) try = 0 for { if !(try < int32(MAXTRIES)) { @@ -140049,7 +140049,7 @@ func Xtmpfile(tls *TLS) (r uintptr) { var fd, try int32 var _ /* s at bp+0 */ [20]uint8 _, _, _ = f, fd, try - *(*[20]uint8)(unsafe.Pointer(bp)) = [20]uint8{'/', 't', 'm', 'p', '/', 't', 'm', 'p', 'f', 'i', 'l', 'e', '_', 'X', 'X', 'X', 'X', 'X', 'X'} + **(**[20]uint8)(__ccgo_up(bp)) = [20]uint8{'/', 't', 'm', 'p', '/', 't', 'm', 'p', 'f', 'i', 'l', 'e', '_', 'X', 'X', 'X', 'X', 'X', 'X'} try = 0 for { if !(try < int32(MAXTRIES)) { @@ -140084,7 +140084,7 @@ func Xtmpnam(tls *TLS, buf uintptr) (r1 uintptr) { var v2 uintptr var _ /* s at bp+1 */ [19]uint8 _, _, _ = r, try, v2 - *(*[19]uint8)(unsafe.Pointer(bp + 1)) = [19]uint8{'/', 't', 'm', 'p', '/', 't', 'm', 'p', 'n', 'a', 'm', '_', 'X', 'X', 'X', 'X', 'X', 'X'} + **(**[19]uint8)(__ccgo_up(bp + 1)) = [19]uint8{'/', 't', 'm', 'p', '/', 't', 'm', 'p', 'n', 'a', 'm', '_', 'X', 'X', 'X', 'X', 'X', 'X'} try = 0 for { if !(try < int32(MAXTRIES)) { @@ -140140,8 +140140,8 @@ func Xungetc(tls *TLS, c int32, f uintptr) (r int32) { v3 = f + 8 *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) - 1 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(c) - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) + **(**uint8)(__ccgo_up(v2)) = Uint8FromInt32(c) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) if __need_unlock != 0 { ___unlockfile(tls, f) } @@ -140162,7 +140162,7 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { var _ /* mbc at bp+0 */ [4]uint8 _, _, _, _, _, _, _, _ = __need_unlock, l, loc, ploc, v1, v3, v4, v5 ploc = uintptr(___get_tp(tls)) + 168 - loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) + loc = **(**Tlocale_t)(__ccgo_up(ploc)) if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) } else { @@ -140172,7 +140172,7 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { if (*TFILE)(unsafe.Pointer(f)).Fmode <= 0 { Xfwide(tls, f, int32(1)) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale + **(**Tlocale_t)(__ccgo_up(ploc)) = (*TFILE)(unsafe.Pointer(f)).Flocale if !((*TFILE)(unsafe.Pointer(f)).Frpos != 0) { X__toread(tls, f) } @@ -140184,24 +140184,24 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { if __need_unlock != 0 { ___unlockfile(tls, f) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return uint32(0xffffffff) } if BoolInt32(c < uint32(128)) != 0 { v5 = f + 8 *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) - 1 v4 = *(*uintptr)(unsafe.Pointer(v5)) - *(*uint8)(unsafe.Pointer(v4)) = uint8(c) + **(**uint8)(__ccgo_up(v4)) = uint8(c) } else { v4 = f + 8 *(*uintptr)(unsafe.Pointer(v4)) -= uintptr(l) Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(v4)), bp, Uint64FromInt32(l)) } - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) if __need_unlock != 0 { ___unlockfile(tls, f) } - *(*Tlocale_t)(unsafe.Pointer(ploc)) = loc + **(**Tlocale_t)(__ccgo_up(ploc)) = loc return c } @@ -140220,12 +140220,12 @@ func Xvasprintf(tls *TLS, s uintptr, fmt uintptr, ap Tva_list) (r int32) { _ = ap2 if v2 = l < 0; !v2 { v1 = Xmalloc(tls, uint64(Uint32FromInt32(l)+uint32(1))) - *(*uintptr)(unsafe.Pointer(s)) = v1 + **(**uintptr)(__ccgo_up(s)) = v1 } if v2 || !(v1 != 0) { return -int32(1) } - return Xvsnprintf(tls, *(*uintptr)(unsafe.Pointer(s)), uint64(Uint32FromInt32(l)+uint32(1)), fmt, ap) + return Xvsnprintf(tls, **(**uintptr)(__ccgo_up(s)), uint64(Uint32FromInt32(l)+uint32(1)), fmt, ap) } func Xvdprintf(tls *TLS, fd int32, fmt uintptr, ap Tva_list) (r int32) { @@ -140236,7 +140236,7 @@ func Xvdprintf(tls *TLS, fd int32, fmt uintptr, ap Tva_list) (r int32) { bp := tls.Alloc(240) defer tls.Free(240) var _ /* f at bp+0 */ TFILE - *(*TFILE)(unsafe.Pointer(bp)) = TFILE{ + **(**TFILE)(__ccgo_up(bp)) = TFILE{ Fwrite: __ccgo_fp(X__stdio_write), Fbuf: fmt, Ffd: fd, @@ -140403,41 +140403,41 @@ type Targ = struct { func _pop_arg(tls *TLS, arg uintptr, type1 int32, ap uintptr) { switch type1 { case int32(_PTR): - *(*uintptr)(unsafe.Pointer(arg)) = VaUintptr(&*(*Tva_list)(unsafe.Pointer(ap))) + *(*uintptr)(unsafe.Pointer(arg)) = VaUintptr(&**(**Tva_list)(__ccgo_up(ap))) case int32(_INT): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_UINT): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint32(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint32(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_LONG): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_ULONG): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&**(**Tva_list)(__ccgo_up(ap))) case int32(_ULLONG): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_SHORT): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt16(int16(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt16(int16(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_USHORT): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint16FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint16FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_CHAR): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt8(int8(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt8(int8(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_UCHAR): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint8FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint8FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_LLONG): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_SIZET): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&**(**Tva_list)(__ccgo_up(ap))) case int32(_IMAX): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_UMAX): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&**(**Tva_list)(__ccgo_up(ap))) case int32(_PDIFF): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_UIPTR): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUintptr(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUintptr(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_DBL): - *(*float64)(unsafe.Pointer(arg)) = float64(VaFloat64(&*(*Tva_list)(unsafe.Pointer(ap)))) + *(*float64)(unsafe.Pointer(arg)) = float64(VaFloat64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_LDBL): - *(*float64)(unsafe.Pointer(arg)) = VaFloat64(&*(*Tva_list)(unsafe.Pointer(ap))) + *(*float64)(unsafe.Pointer(arg)) = VaFloat64(&**(**Tva_list)(__ccgo_up(ap))) } } @@ -140487,7 +140487,7 @@ func _fmt_x(tls *TLS, x Tuintmax_t, s uintptr, lower int32) (r uintptr) { } s = s - 1 v2 = s - *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(Int32FromUint8(_xdigits1[x&uint64(15)]) | lower) + **(**uint8)(__ccgo_up(v2)) = Uint8FromInt32(Int32FromUint8(_xdigits1[x&uint64(15)]) | lower) goto _1 _1: ; @@ -140505,7 +140505,7 @@ func _fmt_o(tls *TLS, x Tuintmax_t, s uintptr) (r uintptr) { } s = s - 1 v2 = s - *(*uint8)(unsafe.Pointer(v2)) = uint8(uint64('0') + x&uint64(7)) + **(**uint8)(__ccgo_up(v2)) = uint8(uint64('0') + x&uint64(7)) goto _1 _1: ; @@ -140524,7 +140524,7 @@ func _fmt_u(tls *TLS, x Tuintmax_t, s uintptr) (r uintptr) { } s = s - 1 v2 = s - *(*uint8)(unsafe.Pointer(v2)) = uint8(uint64('0') + x%uint64(10)) + **(**uint8)(__ccgo_up(v2)) = uint8(uint64('0') + x%uint64(10)) goto _1 _1: ; @@ -140537,7 +140537,7 @@ func _fmt_u(tls *TLS, x Tuintmax_t, s uintptr) (r uintptr) { } s = s - 1 v2 = s - *(*uint8)(unsafe.Pointer(v2)) = uint8(uint64('0') + y%uint64(10)) + **(**uint8)(__ccgo_up(v2)) = uint8(uint64('0') + y%uint64(10)) goto _3 _3: ; @@ -140572,7 +140572,7 @@ func _fmt_fp(tls *TLS, f uintptr, y float64, w int32, p int32, fl int32, t int32 var _ /* e2 at bp+512 */ int32 var _ /* ebuf0 at bp+538 */ [12]uint8 _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, b, carry, carry1, d, e, ebuf, estr, i, j, l, need, pl, prefix, r, re, rm, round, round1, s, s1, s2, s3, s4, sh, sh1, small, x, x1, x2, z, v1, v36, v37, v38, v5, v6, v7 - *(*int32)(unsafe.Pointer(bp + 512)) = 0 + **(**int32)(__ccgo_up(bp + 512)) = 0 prefix = __ccgo_ts + 1616 ebuf = bp + 538 + uintptr(Uint64FromInt32(3)*Uint64FromInt64(4)) pl = int32(1) @@ -140626,7 +140626,7 @@ _4: } y = float64(Xfrexpl(tls, y, bp+512) * Float64FromInt32(2)) if y != 0 { - *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) - 1 + **(**int32)(__ccgo_up(bp + 512)) = **(**int32)(__ccgo_up(bp + 512)) - 1 } if t|int32(32) == int32('a') { round = Float64FromFloat64(8) @@ -140649,7 +140649,7 @@ _4: } round = round * Float64FromInt32(16) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(prefix))) == int32('-') { + if Int32FromUint8(**(**uint8)(__ccgo_up(prefix))) == int32('-') { y = -y y = y - round y = y + round @@ -140659,39 +140659,39 @@ _4: y = y - round } } - if *(*int32)(unsafe.Pointer(bp + 512)) < 0 { - v7 = -*(*int32)(unsafe.Pointer(bp + 512)) + if **(**int32)(__ccgo_up(bp + 512)) < 0 { + v7 = -**(**int32)(__ccgo_up(bp + 512)) } else { - v7 = *(*int32)(unsafe.Pointer(bp + 512)) + v7 = **(**int32)(__ccgo_up(bp + 512)) } estr = _fmt_u(tls, Uint64FromInt32(v7), ebuf) if estr == ebuf { estr = estr - 1 v5 = estr - *(*uint8)(unsafe.Pointer(v5)) = uint8('0') + **(**uint8)(__ccgo_up(v5)) = uint8('0') } estr = estr - 1 v5 = estr - if *(*int32)(unsafe.Pointer(bp + 512)) < 0 { + if **(**int32)(__ccgo_up(bp + 512)) < 0 { v7 = int32('-') } else { v7 = int32('+') } - *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(v7) + **(**uint8)(__ccgo_up(v5)) = Uint8FromInt32(v7) estr = estr - 1 v5 = estr - *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(t + (Int32FromUint8('p') - Int32FromUint8('a'))) + **(**uint8)(__ccgo_up(v5)) = Uint8FromInt32(t + (Int32FromUint8('p') - Int32FromUint8('a'))) s = bp + 516 for cond := true; cond; cond = y != 0 { x = int32(y) v5 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(Int32FromUint8(_xdigits1[x]) | t&int32(32)) + **(**uint8)(__ccgo_up(v5)) = Uint8FromInt32(Int32FromUint8(_xdigits1[x]) | t&int32(32)) y = float64(Float64FromInt32(16) * (y - float64(x))) if int64(s)-t__predefined_ptrdiff_t(bp+516) == int64(1) && (y != 0 || p > 0 || Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0) { v5 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v5)) = uint8('.') + **(**uint8)(__ccgo_up(v5)) = uint8('.') } } if int64(p) > int64(Int32FromInt32(INT_MAX)-Int32FromInt32(2))-(int64(ebuf)-int64(estr))-int64(pl) { @@ -140721,9 +140721,9 @@ _4: } if y != 0 { y = y * Float64FromFloat64(2.68435456e+08) - *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) - int32(28) + **(**int32)(__ccgo_up(bp + 512)) = **(**int32)(__ccgo_up(bp + 512)) - int32(28) } - if *(*int32)(unsafe.Pointer(bp + 512)) < 0 { + if **(**int32)(__ccgo_up(bp + 512)) < 0 { v6 = bp + 8 z = v6 v5 = v6 @@ -140737,17 +140737,17 @@ _4: a = v5 } for cond := true; cond; cond = y != 0 { - *(*Tuint32_t)(unsafe.Pointer(z)) = uint32(y) + **(**Tuint32_t)(__ccgo_up(z)) = uint32(y) v5 = z z += 4 - y = float64(Float64FromInt32(1000000000) * (y - float64(*(*Tuint32_t)(unsafe.Pointer(v5))))) + y = float64(Float64FromInt32(1000000000) * (y - float64(**(**Tuint32_t)(__ccgo_up(v5))))) } - for *(*int32)(unsafe.Pointer(bp + 512)) > 0 { + for **(**int32)(__ccgo_up(bp + 512)) > 0 { carry = uint32(0) - if int32(29) < *(*int32)(unsafe.Pointer(bp + 512)) { + if int32(29) < **(**int32)(__ccgo_up(bp + 512)) { v7 = int32(29) } else { - v7 = *(*int32)(unsafe.Pointer(bp + 512)) + v7 = **(**int32)(__ccgo_up(bp + 512)) } sh = v7 d = z - uintptr(1)*4 @@ -140755,8 +140755,8 @@ _4: if !(d >= a) { break } - x1 = uint64(*(*Tuint32_t)(unsafe.Pointer(d)))< a && !(*(*Tuint32_t)(unsafe.Pointer(z + uintptr(-Int32FromInt32(1))*4)) != 0) { + for z > a && !(**(**Tuint32_t)(__ccgo_up(z + uintptr(-Int32FromInt32(1))*4)) != 0) { z -= 4 } - *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) - sh + **(**int32)(__ccgo_up(bp + 512)) = **(**int32)(__ccgo_up(bp + 512)) - sh } - for *(*int32)(unsafe.Pointer(bp + 512)) < 0 { + for **(**int32)(__ccgo_up(bp + 512)) < 0 { carry1 = uint32(0) - if int32(9) < -*(*int32)(unsafe.Pointer(bp + 512)) { + if int32(9) < -**(**int32)(__ccgo_up(bp + 512)) { v7 = int32(9) } else { - v7 = -*(*int32)(unsafe.Pointer(bp + 512)) + v7 = -**(**int32)(__ccgo_up(bp + 512)) } sh1 = v7 need = Int32FromUint32(uint32(1) + (Uint32FromInt32(p)+Uint32FromInt32(LDBL_MANT_DIG)/Uint32FromUint32(3)+uint32(8))/uint32(9)) @@ -140787,21 +140787,21 @@ _4: if !(d < z) { break } - rm = *(*Tuint32_t)(unsafe.Pointer(d)) & Uint32FromInt32(int32(1)<>sh1 + carry1 + rm = **(**Tuint32_t)(__ccgo_up(d)) & Uint32FromInt32(int32(1)<>sh1 + carry1 carry1 = Uint32FromInt32(Int32FromInt32(1000000000)>>sh1) * rm goto _26 _26: ; d += 4 } - if !(*(*Tuint32_t)(unsafe.Pointer(a)) != 0) { + if !(**(**Tuint32_t)(__ccgo_up(a)) != 0) { a += 4 } if carry1 != 0 { v5 = z z += 4 - *(*Tuint32_t)(unsafe.Pointer(v5)) = carry1 + **(**Tuint32_t)(__ccgo_up(v5)) = carry1 } /* Avoid (slow!) computation past requested precision */ if t|int32(32) == int32('f') { @@ -140813,13 +140813,13 @@ _4: if (int64(z)-int64(b))/4 > int64(need) { z = b + uintptr(need)*4 } - *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) + sh1 + **(**int32)(__ccgo_up(bp + 512)) = **(**int32)(__ccgo_up(bp + 512)) + sh1 } if a < z { i = int32(10) e = int32(Int64FromInt32(9) * ((int64(r) - int64(a)) / 4)) for { - if !(*(*Tuint32_t)(unsafe.Pointer(a)) >= Uint32FromInt32(i)) { + if !(**(**Tuint32_t)(__ccgo_up(a)) >= Uint32FromInt32(i)) { break } goto _29 @@ -140850,11 +140850,11 @@ _4: i = i * int32(10) j = j + 1 } - x2 = *(*Tuint32_t)(unsafe.Pointer(d)) % Uint32FromInt32(i) + x2 = **(**Tuint32_t)(__ccgo_up(d)) % Uint32FromInt32(i) /* Are there any significant digits past j? */ if x2 != 0 || d+uintptr(1)*4 != z { round1 = Float64FromInt32(2) / Float64FromFloat64(2.22044604925031308085e-16) - if *(*Tuint32_t)(unsafe.Pointer(d))/Uint32FromInt32(i)&uint32(1) != 0 || i == int32(1000000000) && d > a && *(*Tuint32_t)(unsafe.Pointer(d + uintptr(-Int32FromInt32(1))*4))&uint32(1) != 0 { + if **(**Tuint32_t)(__ccgo_up(d))/Uint32FromInt32(i)&uint32(1) != 0 || i == int32(1000000000) && d > a && **(**Tuint32_t)(__ccgo_up(d + uintptr(-Int32FromInt32(1))*4))&uint32(1) != 0 { round1 = round1 + Float64FromInt32(2) } if x2 < Uint32FromInt32(i/int32(2)) { @@ -140866,29 +140866,29 @@ _4: small = Float64FromFloat64(1.5) } } - if pl != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(prefix))) == int32('-') { + if pl != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(prefix))) == int32('-') { round1 = round1 * float64(-Int32FromInt32(1)) small = small * float64(-Int32FromInt32(1)) } - *(*Tuint32_t)(unsafe.Pointer(d)) -= x2 + **(**Tuint32_t)(__ccgo_up(d)) -= x2 /* Decide whether to round by probing round+small */ if round1+small != round1 { - *(*Tuint32_t)(unsafe.Pointer(d)) = *(*Tuint32_t)(unsafe.Pointer(d)) + Uint32FromInt32(i) - for *(*Tuint32_t)(unsafe.Pointer(d)) > uint32(999999999) { + **(**Tuint32_t)(__ccgo_up(d)) = **(**Tuint32_t)(__ccgo_up(d)) + Uint32FromInt32(i) + for **(**Tuint32_t)(__ccgo_up(d)) > uint32(999999999) { v5 = d d -= 4 - *(*Tuint32_t)(unsafe.Pointer(v5)) = uint32(0) + **(**Tuint32_t)(__ccgo_up(v5)) = uint32(0) if d < a { a -= 4 v5 = a - *(*Tuint32_t)(unsafe.Pointer(v5)) = uint32(0) + **(**Tuint32_t)(__ccgo_up(v5)) = uint32(0) } - *(*Tuint32_t)(unsafe.Pointer(d)) = *(*Tuint32_t)(unsafe.Pointer(d)) + 1 + **(**Tuint32_t)(__ccgo_up(d)) = **(**Tuint32_t)(__ccgo_up(d)) + 1 } i = int32(10) e = int32(Int64FromInt32(9) * ((int64(r) - int64(a)) / 4)) for { - if !(*(*Tuint32_t)(unsafe.Pointer(a)) >= Uint32FromInt32(i)) { + if !(**(**Tuint32_t)(__ccgo_up(a)) >= Uint32FromInt32(i)) { break } goto _33 @@ -140904,7 +140904,7 @@ _4: } } for { - if !(z > a && !(*(*Tuint32_t)(unsafe.Pointer(z + uintptr(-Int32FromInt32(1))*4)) != 0)) { + if !(z > a && !(**(**Tuint32_t)(__ccgo_up(z + uintptr(-Int32FromInt32(1))*4)) != 0)) { break } goto _34 @@ -140925,11 +140925,11 @@ _4: } if !(Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0) { /* Count trailing zeros in last place */ - if z > a && *(*Tuint32_t)(unsafe.Pointer(z + uintptr(-Int32FromInt32(1))*4)) != 0 { + if z > a && **(**Tuint32_t)(__ccgo_up(z + uintptr(-Int32FromInt32(1))*4)) != 0 { i = int32(10) j = Int32FromInt32(0) for { - if !(*(*Tuint32_t)(unsafe.Pointer(z + uintptr(-Int32FromInt32(1))*4))%Uint32FromInt32(i) == uint32(0)) { + if !(**(**Tuint32_t)(__ccgo_up(z + uintptr(-Int32FromInt32(1))*4))%Uint32FromInt32(i) == uint32(0)) { break } goto _35 @@ -140999,7 +140999,7 @@ _4: for int64(ebuf)-int64(estr) < int64(2) { estr = estr - 1 v5 = estr - *(*uint8)(unsafe.Pointer(v5)) = uint8('0') + **(**uint8)(__ccgo_up(v5)) = uint8('0') } estr = estr - 1 v5 = estr @@ -141008,10 +141008,10 @@ _4: } else { v7 = int32('+') } - *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(v7) + **(**uint8)(__ccgo_up(v5)) = Uint8FromInt32(v7) estr = estr - 1 v5 = estr - *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(t) + **(**uint8)(__ccgo_up(v5)) = Uint8FromInt32(t) if int64(ebuf)-int64(estr) > int64(int32(INT_MAX)-l) { return -int32(1) } @@ -141032,18 +141032,18 @@ _4: if !(d <= r) { break } - s2 = _fmt_u(tls, uint64(*(*Tuint32_t)(unsafe.Pointer(d))), bp+516+uintptr(9)) + s2 = _fmt_u(tls, uint64(**(**Tuint32_t)(__ccgo_up(d))), bp+516+uintptr(9)) if d != a { for s2 > bp+516 { s2 = s2 - 1 v5 = s2 - *(*uint8)(unsafe.Pointer(v5)) = uint8('0') + **(**uint8)(__ccgo_up(v5)) = uint8('0') } } else { if s2 == bp+516+uintptr(9) { s2 = s2 - 1 v5 = s2 - *(*uint8)(unsafe.Pointer(v5)) = uint8('0') + **(**uint8)(__ccgo_up(v5)) = uint8('0') } } _out(tls, f, s2, Uint64FromInt64(int64(bp+516+uintptr(9))-int64(s2))) @@ -141059,11 +141059,11 @@ _4: if !(d < z && p > 0) { break } - s3 = _fmt_u(tls, uint64(*(*Tuint32_t)(unsafe.Pointer(d))), bp+516+uintptr(9)) + s3 = _fmt_u(tls, uint64(**(**Tuint32_t)(__ccgo_up(d))), bp+516+uintptr(9)) for s3 > bp+516 { s3 = s3 - 1 v5 = s3 - *(*uint8)(unsafe.Pointer(v5)) = uint8('0') + **(**uint8)(__ccgo_up(v5)) = uint8('0') } if int32(9) < p { v7 = int32(9) @@ -141087,17 +141087,17 @@ _4: if !(d < z && p >= 0) { break } - s4 = _fmt_u(tls, uint64(*(*Tuint32_t)(unsafe.Pointer(d))), bp+516+uintptr(9)) + s4 = _fmt_u(tls, uint64(**(**Tuint32_t)(__ccgo_up(d))), bp+516+uintptr(9)) if s4 == bp+516+uintptr(9) { s4 = s4 - 1 v5 = s4 - *(*uint8)(unsafe.Pointer(v5)) = uint8('0') + **(**uint8)(__ccgo_up(v5)) = uint8('0') } if d != a { for s4 > bp+516 { s4 = s4 - 1 v5 = s4 - *(*uint8)(unsafe.Pointer(v5)) = uint8('0') + **(**uint8)(__ccgo_up(v5)) = uint8('0') } } else { v5 = s4 @@ -141136,18 +141136,18 @@ func _getint(tls *TLS, s uintptr) (r int32) { _ = i i = 0 for { - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-uint32('0') < uint32(10)) != 0) { break } - if Uint32FromInt32(i) > Uint32FromInt32(INT_MAX)/Uint32FromUint32(10) || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-int32('0') > int32(INT_MAX)-int32(10)*i { + if Uint32FromInt32(i) > Uint32FromInt32(INT_MAX)/Uint32FromUint32(10) || Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-int32('0') > int32(INT_MAX)-int32(10)*i { i = -int32(1) } else { - i = int32(10)*i + (Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s))))) - int32('0')) + i = int32(10)*i + (Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(s))))) - int32('0')) } goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s)) = *(*uintptr)(unsafe.Pointer(s)) + 1 + **(**uintptr)(__ccgo_up(s)) = **(**uintptr)(__ccgo_up(s)) + 1 } return i } @@ -141168,7 +141168,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, var _ /* s at bp+0 */ uintptr var _ /* wc at bp+40 */ [2]Twchar_t _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argpos, cnt, fl, i, l, l10n, p, pl, prefix, ps, st, t, w, ws, xp, z, v31, v34, v45, v5, v6, v8 - *(*uintptr)(unsafe.Pointer(bp)) = fmt + **(**uintptr)(__ccgo_up(bp)) = fmt l10n = uint32(0) cnt = 0 l = 0 @@ -141181,30 +141181,30 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } /* Update output count, end loop when fmt is exhausted */ cnt = cnt + l - if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) != 0) { + if !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))) != 0) { break } /* Handle literal text and %% format specifiers */ - a = *(*uintptr)(unsafe.Pointer(bp)) + a = **(**uintptr)(__ccgo_up(bp)) for { - if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32('%')) { + if !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) != int32('%')) { break } goto _2 _2: ; - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 } - z = *(*uintptr)(unsafe.Pointer(bp)) + z = **(**uintptr)(__ccgo_up(bp)) for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('%') && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1))) == int32('%')) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) == int32('%') && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1))) == int32('%')) { break } goto _3 _3: ; z = z + 1 - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(2) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + uintptr(2) } if int64(z)-int64(a) > int64(int32(INT_MAX)-cnt) { goto overflow @@ -141216,46 +141216,46 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if l != 0 { goto _1 } - if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2))) == int32('$') { + if BoolInt32(uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 2))) == int32('$') { l10n = uint32(1) - argpos = Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1))) - int32('0') - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(3) + argpos = Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1))) - int32('0') + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + uintptr(3) } else { argpos = -int32(1) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 } /* Read modifier flags */ fl = uint32(0) for { - if !(uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-uint32(' ') < uint32(32) && (Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('0')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('\'')-Int32FromUint8(' ')))&(uint32(1)<<(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-int32(' '))) != 0) { + if !(uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))))-uint32(' ') < uint32(32) && (Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('0')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('\'')-Int32FromUint8(' ')))&(uint32(1)<<(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))))-int32(' '))) != 0) { break } - fl = fl | uint32(1)<<(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-int32(' ')) + fl = fl | uint32(1)<<(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))))-int32(' ')) goto _4 _4: ; - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 } /* Read field width */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('*') { - if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2))) == int32('$') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) == int32('*') { + if BoolInt32(uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 2))) == int32('$') { l10n = uint32(1) if !(f != 0) { - *(*int32)(unsafe.Pointer(nl_type + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))-int32('0'))*4)) = int32(_INT) + **(**int32)(__ccgo_up(nl_type + uintptr(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1)))-int32('0'))*4)) = int32(_INT) w = Int32FromInt32(0) } else { - w = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))-int32('0'))*8))) + w = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1)))-int32('0'))*8))) } - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(3) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + uintptr(3) } else { if !(l10n != 0) { if f != 0 { - v5 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) + v5 = VaInt32(&**(**Tva_list)(__ccgo_up(ap))) } else { v5 = 0 } w = v5 - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 } else { goto inval } @@ -141272,32 +141272,32 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } } /* Read precision */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('.') && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1))) == int32('*') { - if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 3))) == int32('$') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) == int32('.') && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 1))) == int32('*') { + if BoolInt32(uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 2)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 3))) == int32('$') { if !(f != 0) { - *(*int32)(unsafe.Pointer(nl_type + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2)))-int32('0'))*4)) = int32(_INT) + **(**int32)(__ccgo_up(nl_type + uintptr(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 2)))-int32('0'))*4)) = int32(_INT) p = Int32FromInt32(0) } else { - p = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2)))-int32('0'))*8))) + p = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 2)))-int32('0'))*8))) } - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(4) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + uintptr(4) } else { if !(l10n != 0) { if f != 0 { - v5 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) + v5 = VaInt32(&**(**Tva_list)(__ccgo_up(ap))) } else { v5 = 0 } p = v5 - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(2) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + uintptr(2) } else { goto inval } } xp = BoolInt32(p >= 0) } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('.') { - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) == int32('.') { + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 p = _getint(tls, bp) xp = int32(1) } else { @@ -141308,13 +141308,13 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, /* Format specifier state machine */ st = uint32(0) for cond := true; cond; cond = st-uint32(1) < uint32(_STOP) { - if uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-uint32('A') > Uint32FromInt32(Int32FromUint8('z')-Int32FromUint8('A')) { + if uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)))))-uint32('A') > Uint32FromInt32(Int32FromUint8('z')-Int32FromUint8('A')) { goto inval } ps = st - v8 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 - st = uint32(*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_states)) + uintptr(st)*58 + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(v8)))-int32('A'))))) + v8 = **(**uintptr)(__ccgo_up(bp)) + **(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1 + st = uint32(**(**uint8)(__ccgo_up(uintptr(unsafe.Pointer(&_states)) + uintptr(st)*58 + uintptr(Int32FromUint8(**(**uint8)(__ccgo_up(v8)))-int32('A'))))) } if !(st != 0) { goto inval @@ -141327,9 +141327,9 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } else { if argpos >= 0 { if !(f != 0) { - *(*int32)(unsafe.Pointer(nl_type + uintptr(argpos)*4)) = Int32FromUint32(st) + **(**int32)(__ccgo_up(nl_type + uintptr(argpos)*4)) = Int32FromUint32(st) } else { - *(*Targ)(unsafe.Pointer(bp + 8)) = *(*Targ)(unsafe.Pointer(nl_arg + uintptr(argpos)*8)) + **(**Targ)(__ccgo_up(bp + 8)) = **(**Targ)(__ccgo_up(nl_arg + uintptr(argpos)*8)) } } else { if f != 0 { @@ -141349,7 +141349,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, z = bp + 16 + uintptr(24) prefix = __ccgo_ts + 1647 pl = 0 - t = Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + uintptr(-Int32FromInt32(1))))) + t = Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + uintptr(-Int32FromInt32(1))))) /* Transform ls,lc -> S,C */ if ps != 0 && t&int32(15) == int32(3) { t = t & ^Int32FromInt32(32) @@ -141407,19 +141407,19 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, ; switch ps { case uint32(_BARE): - *(*int32)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) = cnt + **(**int32)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 8)))) = cnt case uint32(_LPRE): - *(*int64)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) = int64(cnt) + **(**int64)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 8)))) = int64(cnt) case uint32(_LLPRE): - *(*int64)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) = int64(cnt) + **(**int64)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 8)))) = int64(cnt) case uint32(_HPRE): - *(*uint16)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) = Uint16FromInt32(cnt) + **(**uint16)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 8)))) = Uint16FromInt32(cnt) case uint32(_HHPRE): - *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) = Uint8FromInt32(cnt) + **(**uint8)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 8)))) = Uint8FromInt32(cnt) case uint32(_ZTPRE): - *(*Tsize_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) = Uint64FromInt32(cnt) + **(**Tsize_t)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 8)))) = Uint64FromInt32(cnt) case uint32(_JPRE): - *(*Tuintmax_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) = Uint64FromInt32(cnt) + **(**Tuintmax_t)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 8)))) = Uint64FromInt32(cnt) break } goto _1 @@ -141505,7 +141505,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, p = v5 v8 = z - uintptr(v5) a = v8 - *(*uint8)(unsafe.Pointer(v8)) = uint8(*(*Tuintmax_t)(unsafe.Pointer(bp + 8))) + **(**uint8)(__ccgo_up(v8)) = uint8(*(*Tuintmax_t)(unsafe.Pointer(bp + 8))) fl = fl & ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) goto _30 _19: @@ -141513,7 +141513,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if !(int32(1) != 0) { goto _37 } - a = Xstrerror(tls, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) + a = Xstrerror(tls, **(**int32)(__ccgo_up(X__errno_location(tls)))) goto _38 _37: ; @@ -141533,7 +141533,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, v5 = p } z = a + uintptr(Xstrnlen(tls, a, Uint64FromInt32(v5))) - if p < 0 && *(*uint8)(unsafe.Pointer(z)) != 0 { + if p < 0 && **(**uint8)(__ccgo_up(z)) != 0 { goto overflow } p = int32(int64(z) - int64(a)) @@ -141544,8 +141544,8 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if !(*(*Tuintmax_t)(unsafe.Pointer(bp + 8)) != 0) { goto narrow_c } - (*(*[2]Twchar_t)(unsafe.Pointer(bp + 40)))[0] = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(bp + 8))) - (*(*[2]Twchar_t)(unsafe.Pointer(bp + 40)))[int32(1)] = 0 + (**(**[2]Twchar_t)(__ccgo_up(bp + 40)))[0] = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(bp + 8))) + (**(**[2]Twchar_t)(__ccgo_up(bp + 40)))[int32(1)] = 0 *(*uintptr)(unsafe.Pointer(bp + 8)) = bp + 40 p = -int32(1) _21: @@ -141555,10 +141555,10 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, l = v5 i = Uint64FromInt32(v5) for { - if v45 = i < Uint64FromInt32(p) && *(*Twchar_t)(unsafe.Pointer(ws)) != 0; v45 { + if v45 = i < Uint64FromInt32(p) && **(**Twchar_t)(__ccgo_up(ws)) != 0; v45 { v8 = ws ws += 4 - v6 = Xwctomb(tls, bp+48, *(*Twchar_t)(unsafe.Pointer(v8))) + v6 = Xwctomb(tls, bp+48, **(**Twchar_t)(__ccgo_up(v8))) l = v6 } if !(v45 && v6 >= 0 && Uint64FromInt32(l) <= Uint64FromInt32(p)-i) { @@ -141580,10 +141580,10 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, ws = *(*uintptr)(unsafe.Pointer(bp + 8)) i = uint64(0) for { - if v45 = i < uint64(0+Uint32FromInt32(p)) && *(*Twchar_t)(unsafe.Pointer(ws)) != 0; v45 { + if v45 = i < uint64(0+Uint32FromInt32(p)) && **(**Twchar_t)(__ccgo_up(ws)) != 0; v45 { v8 = ws ws += 4 - v5 = Xwctomb(tls, bp+48, *(*Twchar_t)(unsafe.Pointer(v8))) + v5 = Xwctomb(tls, bp+48, **(**Twchar_t)(__ccgo_up(v8))) l = v5 } if !(v45 && i+Uint64FromInt32(v5) <= Uint64FromInt32(p)) { @@ -141659,17 +141659,17 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } i = uint64(1) for { - if !(i <= uint64(NL_ARGMAX) && *(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)) != 0) { + if !(i <= uint64(NL_ARGMAX) && **(**int32)(__ccgo_up(nl_type + uintptr(i)*4)) != 0) { break } - _pop_arg(tls, nl_arg+uintptr(i)*8, *(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)), ap) + _pop_arg(tls, nl_arg+uintptr(i)*8, **(**int32)(__ccgo_up(nl_type + uintptr(i)*4)), ap) goto _51 _51: ; i = i + 1 } for { - if !(i <= uint64(NL_ARGMAX) && !(*(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)) != 0)) { + if !(i <= uint64(NL_ARGMAX) && !(**(**int32)(__ccgo_up(nl_type + uintptr(i)*4)) != 0)) { break } goto _52 @@ -141684,12 +141684,12 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto inval inval: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) goto overflow overflow: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return -int32(1) } @@ -141707,12 +141707,12 @@ func Xvfprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { var _ /* nl_arg at bp+48 */ [10]Targ var _ /* nl_type at bp+8 */ [10]int32 _, _, _, _, _, _, _ = __need_unlock, olderr, ret, saved_buf, v1, v2, v3 - *(*[10]int32)(unsafe.Pointer(bp + 8)) = [10]int32{} + **(**[10]int32)(__ccgo_up(bp + 8)) = [10]int32{} saved_buf = uintptr(0) /* the copy allows passing va_list* even if va_list is an array */ - *(*Tva_list)(unsafe.Pointer(bp)) = ap + **(**Tva_list)(__ccgo_up(bp)) = ap if _printf_core(tls, uintptr(0), fmt, bp, bp+48, bp+8) < 0 { - _ = *(*Tva_list)(unsafe.Pointer(bp)) + _ = **(**Tva_list)(__ccgo_up(bp)) return -int32(1) } if AtomicLoadPInt32(f+140) >= 0 { @@ -141722,7 +141722,7 @@ func Xvfprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } __need_unlock = v1 olderr = Int32FromUint32((*TFILE)(unsafe.Pointer(f)).Fflags & uint32(F_ERR)) - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_ERR)) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^Int32FromInt32(F_ERR)) if !((*TFILE)(unsafe.Pointer(f)).Fbuf_size != 0) { saved_buf = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Fbuf = bp + 128 @@ -141754,11 +141754,11 @@ func Xvfprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_ERR) != 0 { ret = -int32(1) } - *(*uint32)(unsafe.Pointer(f)) |= Uint32FromInt32(olderr) + **(**uint32)(__ccgo_up(f)) |= Uint32FromInt32(olderr) if __need_unlock != 0 { ___unlockfile(tls, f) } - _ = *(*Tva_list)(unsafe.Pointer(bp)) + _ = **(**Tva_list)(__ccgo_up(bp)) return ret } @@ -141775,15 +141775,15 @@ func _store_int(tls *TLS, dest uintptr, size int32, i uint64) { } switch size { case -int32(2): - *(*uint8)(unsafe.Pointer(dest)) = uint8(i) + **(**uint8)(__ccgo_up(dest)) = uint8(i) case -int32(1): - *(*int16)(unsafe.Pointer(dest)) = Int16FromUint64(i) + **(**int16)(__ccgo_up(dest)) = Int16FromUint64(i) case SIZE_def: - *(*int32)(unsafe.Pointer(dest)) = Int32FromUint64(i) + **(**int32)(__ccgo_up(dest)) = Int32FromUint64(i) case int32(SIZE_l): - *(*int64)(unsafe.Pointer(dest)) = Int64FromUint64(i) + **(**int64)(__ccgo_up(dest)) = Int64FromUint64(i) case int32(SIZE_ll): - *(*int64)(unsafe.Pointer(dest)) = Int64FromUint64(i) + **(**int64)(__ccgo_up(dest)) = Int64FromUint64(i) break } } @@ -141846,17 +141846,17 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } p = fmt for { - if !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if !(**(**uint8)(__ccgo_up(p)) != 0) { break } alloc = 0 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(p))) v3 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _5 _5: if v3 != 0 { for { - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) + v4 = Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) v6 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _8 _8: @@ -141871,7 +141871,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v1 = X__shgetc(tls, f) } @@ -141889,16 +141889,16 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { pos = pos + ((*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf))) goto _2 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32('%') || Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('%') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) != int32('%') || Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) == int32('%') { X__shlim(tls, f, int64(Int32FromInt32(0))) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('%') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('%') { p = p + 1 for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v3 = X__shgetc(tls, f) } @@ -141917,13 +141917,13 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v1 = X__shgetc(tls, f) } c = v1 } - if c != Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) { + if c != Int32FromUint8(**(**uint8)(__ccgo_up(p))) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } @@ -141936,12 +141936,12 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { goto _2 } p = p + 1 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('*') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('*') { dest = uintptr(0) p = p + 1 } else { - if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('$') { - dest = _arg_n(tls, ap, Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))-int32('0'))) + if BoolInt32(uint32(**(**uint8)(__ccgo_up(p)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) == int32('$') { + dest = _arg_n(tls, ap, Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(p)))-int32('0'))) p = p + uintptr(2) } else { dest = VaUintptr(&ap) @@ -141949,16 +141949,16 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } width = 0 for { - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p)))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(p)))-uint32('0') < uint32(10)) != 0) { break } - width = int32(10)*width + Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - int32('0') + width = int32(10)*width + Int32FromUint8(**(**uint8)(__ccgo_up(p))) - int32('0') goto _25 _25: ; p = p + 1 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('m') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('m') { wcs = uintptr(0) s = uintptr(0) alloc = BoolInt32(!!(dest != 0)) @@ -141969,16 +141969,16 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { size = SIZE_def v10 = p p = p + 1 - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(v10))) { case int32('h'): - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('h') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('h') { p = p + 1 size = -Int32FromInt32(2) } else { size = -int32(1) } case int32('l'): - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('l') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('l') { p = p + 1 size = Int32FromInt32(SIZE_ll) } else { @@ -142037,7 +142037,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { default: goto fmt_fail } - t = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + t = Int32FromUint8(**(**uint8)(__ccgo_up(p))) /* C or S */ if t&int32(0x2f) == int32(3) { t = t | int32(32) @@ -142061,7 +142061,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v1 = X__shgetc(tls, f) } @@ -142083,7 +142083,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v1 = X__shgetc(tls, f) } @@ -142140,58 +142140,58 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { ; if t == int32('c') || t == int32('s') { Xmemset(tls, bp+16, -int32(1), uint64(257)) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[0] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[0] = uint8(0) if t == int32('s') { - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\t')] = uint8(0) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\n')] = uint8(0) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\v')] = uint8(0) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\f')] = uint8(0) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\r')] = uint8(0) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8(' ')] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\t')] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\n')] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\v')] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\f')] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('\r')] = uint8(0) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8(' ')] = uint8(0) } } else { p = p + 1 v10 = p - if Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) == int32('^') { + if Int32FromUint8(**(**uint8)(__ccgo_up(v10))) == int32('^') { p = p + 1 invert = Int32FromInt32(1) } else { invert = 0 } Xmemset(tls, bp+16, invert, uint64(257)) - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[0] = uint8(0) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') { + (**(**[257]uint8)(__ccgo_up(bp + 16)))[0] = uint8(0) + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('-') { p = p + 1 - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('-')] = Uint8FromInt32(Int32FromInt32(1) - invert) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('-')] = Uint8FromInt32(Int32FromInt32(1) - invert) } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32(']') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32(']') { p = p + 1 - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8(']')] = Uint8FromInt32(Int32FromInt32(1) - invert) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[Int32FromInt32(1)+Int32FromUint8(']')] = Uint8FromInt32(Int32FromInt32(1) - invert) } } for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32(']')) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(p))) != int32(']')) { break } - if !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if !(**(**uint8)(__ccgo_up(p)) != 0) { goto fmt_fail } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') && *(*uint8)(unsafe.Pointer(p + 1)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) != int32(']') { + if Int32FromUint8(**(**uint8)(__ccgo_up(p))) == int32('-') && **(**uint8)(__ccgo_up(p + 1)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(p + 1))) != int32(']') { v10 = p p = p + 1 - c = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10 + uintptr(-Int32FromInt32(1))))) + c = Int32FromUint8(**(**uint8)(__ccgo_up(v10 + uintptr(-Int32FromInt32(1))))) for { - if !(c < Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))) { + if !(c < Int32FromUint8(**(**uint8)(__ccgo_up(p)))) { break } - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[int32(1)+c] = Uint8FromInt32(int32(1) - invert) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[int32(1)+c] = Uint8FromInt32(int32(1) - invert) goto _57 _57: ; c = c + 1 } } - (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[int32(1)+Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))] = Uint8FromInt32(int32(1) - invert) + (**(**[257]uint8)(__ccgo_up(bp + 16)))[int32(1)+Int32FromUint8(**(**uint8)(__ccgo_up(p)))] = Uint8FromInt32(int32(1) - invert) goto _56 _56: ; @@ -142216,19 +142216,19 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } else { wcs = dest } - *(*Tmbstate_t)(unsafe.Pointer(bp + 8)) = Tmbstate_t{} + **(**Tmbstate_t)(__ccgo_up(bp + 8)) = Tmbstate_t{} for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v3 = X__shgetc(tls, f) } v1 = v3 c = v1 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { + if !((**(**[257]uint8)(__ccgo_up(bp + 16)))[v1+int32(1)] != 0) { break } *(*uint8)(unsafe.Pointer(bp)) = Uint8FromInt32(c) @@ -142241,7 +142241,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if wcs != 0 { v64 = i i = i + 1 - *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(v64)*4)) = *(*Twchar_t)(unsafe.Pointer(bp + 276)) + **(**Twchar_t)(__ccgo_up(wcs + uintptr(v64)*4)) = **(**Twchar_t)(__ccgo_up(bp + 276)) } if alloc != 0 && i == k { k = k + (k + uint64(1)) @@ -142266,18 +142266,18 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v3 = X__shgetc(tls, f) } v1 = v3 c = v1 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { + if !((**(**[257]uint8)(__ccgo_up(bp + 16)))[v1+int32(1)] != 0) { break } v64 = i i = i + 1 - *(*uint8)(unsafe.Pointer(s + uintptr(v64))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + uintptr(v64))) = Uint8FromInt32(c) if i == k { k = k + (k + uint64(1)) tmp1 = Xrealloc(tls, s, k) @@ -142296,18 +142296,18 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v17 = f + 8 v11 = *(*uintptr)(unsafe.Pointer(v17)) *(*uintptr)(unsafe.Pointer(v17)) = *(*uintptr)(unsafe.Pointer(v17)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v11))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v11))) } else { v3 = X__shgetc(tls, f) } v1 = v3 c = v1 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { + if !((**(**[257]uint8)(__ccgo_up(bp + 16)))[v1+int32(1)] != 0) { break } v64 = i i = i + 1 - *(*uint8)(unsafe.Pointer(s + uintptr(v64))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + uintptr(v64))) = Uint8FromInt32(c) } } else { for { @@ -142315,13 +142315,13 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v3 = Int32FromUint8(**(**uint8)(__ccgo_up(v10))) } else { v3 = X__shgetc(tls, f) } v1 = v3 c = v1 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { + if !((**(**[257]uint8)(__ccgo_up(bp + 16)))[v1+int32(1)] != 0) { break } } @@ -142339,17 +142339,17 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } if alloc != 0 { if size == int32(SIZE_l) { - *(*uintptr)(unsafe.Pointer(dest)) = wcs + **(**uintptr)(__ccgo_up(dest)) = wcs } else { - *(*uintptr)(unsafe.Pointer(dest)) = s + **(**uintptr)(__ccgo_up(dest)) = s } } if t != int32('c') { if wcs != 0 { - *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) = 0 + **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) = 0 } if s != 0 { - *(*uint8)(unsafe.Pointer(s + uintptr(i))) = uint8(0) + **(**uint8)(__ccgo_up(s + uintptr(i))) = uint8(0) } } goto _54 @@ -142382,7 +142382,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { goto match_fail } if t == int32('p') && dest != 0 { - *(*uintptr)(unsafe.Pointer(dest)) = uintptr(x) + **(**uintptr)(__ccgo_up(dest)) = uintptr(x) } else { _store_int(tls, dest, size, x) } @@ -142410,11 +142410,11 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if dest != 0 { switch size { case SIZE_def: - *(*float32)(unsafe.Pointer(dest)) = float32(y) + **(**float32)(__ccgo_up(dest)) = float32(y) case int32(SIZE_l): - *(*float64)(unsafe.Pointer(dest)) = y + **(**float64)(__ccgo_up(dest)) = y case int32(SIZE_L): - *(*float64)(unsafe.Pointer(dest)) = y + **(**float64)(__ccgo_up(dest)) = y break } } @@ -142580,41 +142580,41 @@ var _states1 = [8][58]uint8{ func _pop_arg1(tls *TLS, arg uintptr, type1 int32, ap uintptr) { switch type1 { case int32(_PTR): - *(*uintptr)(unsafe.Pointer(arg)) = VaUintptr(&*(*Tva_list)(unsafe.Pointer(ap))) + *(*uintptr)(unsafe.Pointer(arg)) = VaUintptr(&**(**Tva_list)(__ccgo_up(ap))) case int32(_INT): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_UINT): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint32(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint32(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_LONG): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_ULONG): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&**(**Tva_list)(__ccgo_up(ap))) case int32(_ULLONG): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUint64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_SHORT): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt16(int16(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt16(int16(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_USHORT): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint16FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint16FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_CHAR): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt8(int8(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt8(int8(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_UCHAR): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint8FromInt32(VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(Uint8FromInt32(VaInt32(&**(**Tva_list)(__ccgo_up(ap))))) case int32(_LLONG): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_SIZET): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&**(**Tva_list)(__ccgo_up(ap))) case int32(_IMAX): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_UMAX): - (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&*(*Tva_list)(unsafe.Pointer(ap))) + (*Targ)(unsafe.Pointer(arg)).Fi = VaUint64(&**(**Tva_list)(__ccgo_up(ap))) case int32(_PDIFF): - (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = Uint64FromInt64(VaInt64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_UIPTR): - (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUintptr(&*(*Tva_list)(unsafe.Pointer(ap)))) + (*Targ)(unsafe.Pointer(arg)).Fi = uint64(VaUintptr(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_DBL): - *(*float64)(unsafe.Pointer(arg)) = float64(VaFloat64(&*(*Tva_list)(unsafe.Pointer(ap)))) + *(*float64)(unsafe.Pointer(arg)) = float64(VaFloat64(&**(**Tva_list)(__ccgo_up(ap)))) case int32(_LDBL): - *(*float64)(unsafe.Pointer(arg)) = VaFloat64(&*(*Tva_list)(unsafe.Pointer(ap))) + *(*float64)(unsafe.Pointer(arg)) = VaFloat64(&**(**Tva_list)(__ccgo_up(ap))) } } @@ -142630,7 +142630,7 @@ func _out1(tls *TLS, f uintptr, s uintptr, l Tsize_t) { } v2 = s s += 4 - Xfputwc(tls, *(*Twchar_t)(unsafe.Pointer(v2)), f) + Xfputwc(tls, **(**Twchar_t)(__ccgo_up(v2)), f) } } @@ -142648,18 +142648,18 @@ func _getint1(tls *TLS, s uintptr) (r int32) { _ = i i = 0 for { - if !(BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))))-uint32('0') < uint32(10)) != 0) { break } - if Uint32FromInt32(i) > Uint32FromInt32(INT_MAX)/Uint32FromUint32(10) || *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s))))-int32('0') > int32(INT_MAX)-int32(10)*i { + if Uint32FromInt32(i) > Uint32FromInt32(INT_MAX)/Uint32FromUint32(10) || **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(s))))-int32('0') > int32(INT_MAX)-int32(10)*i { i = -int32(1) } else { - i = int32(10)*i + (*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)))) - int32('0')) + i = int32(10)*i + (**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(s)))) - int32('0')) } goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s)) += 4 + **(**uintptr)(__ccgo_up(s)) += 4 } return i } @@ -142690,7 +142690,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, var _ /* s at bp+8 */ uintptr var _ /* wc at bp+40 */ Twchar_t _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argpos, bs, cnt, fl, i, l, l10n, p, ps, st, t, w, xp, z, v15, v5, v6, v7, v8, v9 - *(*uintptr)(unsafe.Pointer(bp + 8)) = fmt + **(**uintptr)(__ccgo_up(bp + 8)) = fmt l10n = uint32(0) cnt = 0 l = 0 @@ -142703,30 +142703,30 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } /* Update output count, end loop when fmt is exhausted */ cnt = cnt + l - if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) != 0) { + if !(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) != 0) { break } /* Handle literal text and %% format specifiers */ - a = *(*uintptr)(unsafe.Pointer(bp + 8)) + a = **(**uintptr)(__ccgo_up(bp + 8)) for { - if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) != 0 && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) != int32('%')) { + if !(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) != 0 && **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) != int32('%')) { break } goto _2 _2: ; - *(*uintptr)(unsafe.Pointer(bp + 8)) += 4 + **(**uintptr)(__ccgo_up(bp + 8)) += 4 } - z = *(*uintptr)(unsafe.Pointer(bp + 8)) + z = **(**uintptr)(__ccgo_up(bp + 8)) for { - if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) == int32('%') && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4)) == int32('%')) { + if !(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) == int32('%') && **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 1*4)) == int32('%')) { break } goto _3 _3: ; z += 4 - *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(2)*4 + **(**uintptr)(__ccgo_up(bp + 8)) = **(**uintptr)(__ccgo_up(bp + 8)) + uintptr(2)*4 } if (int64(z)-int64(a))/4 > int64(int32(INT_MAX)-cnt) { goto overflow @@ -142738,42 +142738,42 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if l != 0 { goto _1 } - if BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4)))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4)) == int32('$') { + if BoolInt32(Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 1*4)))-uint32('0') < uint32(10)) != 0 && **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 2*4)) == int32('$') { l10n = uint32(1) - argpos = *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4)) - int32('0') - *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(3)*4 + argpos = **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 1*4)) - int32('0') + **(**uintptr)(__ccgo_up(bp + 8)) = **(**uintptr)(__ccgo_up(bp + 8)) + uintptr(3)*4 } else { argpos = -int32(1) - *(*uintptr)(unsafe.Pointer(bp + 8)) += 4 + **(**uintptr)(__ccgo_up(bp + 8)) += 4 } /* Read modifier flags */ fl = uint32(0) for { - if !(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))))-uint32(' ') < uint32(32) && (Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('0')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('\'')-Int32FromUint8(' ')))&(uint32(1)<<(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8))))-int32(' '))) != 0) { + if !(Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))))-uint32(' ') < uint32(32) && (Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('0')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('\'')-Int32FromUint8(' ')))&(uint32(1)<<(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8))))-int32(' '))) != 0) { break } - fl = fl | uint32(1)<<(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8))))-int32(' ')) + fl = fl | uint32(1)<<(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8))))-int32(' ')) goto _4 _4: ; - *(*uintptr)(unsafe.Pointer(bp + 8)) += 4 + **(**uintptr)(__ccgo_up(bp + 8)) += 4 } /* Read field width */ - if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) == int32('*') { - if BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4)))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4)) == int32('$') { + if **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) == int32('*') { + if BoolInt32(Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 1*4)))-uint32('0') < uint32(10)) != 0 && **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 2*4)) == int32('$') { l10n = uint32(1) - *(*int32)(unsafe.Pointer(nl_type + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4))-int32('0'))*4)) = int32(_INT) - w = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4))-int32('0'))*8))) - *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(3)*4 + **(**int32)(__ccgo_up(nl_type + uintptr(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 1*4))-int32('0'))*4)) = int32(_INT) + w = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 1*4))-int32('0'))*8))) + **(**uintptr)(__ccgo_up(bp + 8)) = **(**uintptr)(__ccgo_up(bp + 8)) + uintptr(3)*4 } else { if !(l10n != 0) { if f != 0 { - v5 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) + v5 = VaInt32(&**(**Tva_list)(__ccgo_up(ap))) } else { v5 = 0 } w = v5 - *(*uintptr)(unsafe.Pointer(bp + 8)) += 4 + **(**uintptr)(__ccgo_up(bp + 8)) += 4 } else { goto inval } @@ -142790,28 +142790,28 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } } /* Read precision */ - if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) == int32('.') && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4)) == int32('*') { - if BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4)))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 3*4)) == int32('$') { - *(*int32)(unsafe.Pointer(nl_type + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4))-int32('0'))*4)) = int32(_INT) - p = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4))-int32('0'))*8))) - *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(4)*4 + if **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) == int32('.') && **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 1*4)) == int32('*') { + if BoolInt32(Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 2*4)))-uint32('0') < uint32(10)) != 0 && **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 3*4)) == int32('$') { + **(**int32)(__ccgo_up(nl_type + uintptr(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 2*4))-int32('0'))*4)) = int32(_INT) + p = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + 2*4))-int32('0'))*8))) + **(**uintptr)(__ccgo_up(bp + 8)) = **(**uintptr)(__ccgo_up(bp + 8)) + uintptr(4)*4 } else { if !(l10n != 0) { if f != 0 { - v5 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) + v5 = VaInt32(&**(**Tva_list)(__ccgo_up(ap))) } else { v5 = 0 } p = v5 - *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(2)*4 + **(**uintptr)(__ccgo_up(bp + 8)) = **(**uintptr)(__ccgo_up(bp + 8)) + uintptr(2)*4 } else { goto inval } } xp = BoolInt32(p >= 0) } else { - if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) == int32('.') { - *(*uintptr)(unsafe.Pointer(bp + 8)) += 4 + if **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))) == int32('.') { + **(**uintptr)(__ccgo_up(bp + 8)) += 4 p = _getint1(tls, bp+8) xp = int32(1) } else { @@ -142822,13 +142822,13 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, /* Format specifier state machine */ st = uint32(0) for cond := true; cond; cond = st-uint32(1) < uint32(_STOP) { - if Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))))-uint32('A') > Uint32FromInt32(Int32FromUint8('z')-Int32FromUint8('A')) { + if Uint32FromInt32(**(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)))))-uint32('A') > Uint32FromInt32(Int32FromUint8('z')-Int32FromUint8('A')) { goto inval } ps = st - v8 = *(*uintptr)(unsafe.Pointer(bp + 8)) - *(*uintptr)(unsafe.Pointer(bp + 8)) += 4 - st = uint32(*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_states1)) + uintptr(st)*58 + uintptr(*(*Twchar_t)(unsafe.Pointer(v8))-int32('A'))))) + v8 = **(**uintptr)(__ccgo_up(bp + 8)) + **(**uintptr)(__ccgo_up(bp + 8)) += 4 + st = uint32(**(**uint8)(__ccgo_up(uintptr(unsafe.Pointer(&_states1)) + uintptr(st)*58 + uintptr(**(**Twchar_t)(__ccgo_up(v8))-int32('A'))))) } if !(st != 0) { goto inval @@ -142840,8 +142840,8 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } } else { if argpos >= 0 { - *(*int32)(unsafe.Pointer(nl_type + uintptr(argpos)*4)) = Int32FromUint32(st) - *(*Targ)(unsafe.Pointer(bp + 16)) = *(*Targ)(unsafe.Pointer(nl_arg + uintptr(argpos)*8)) + **(**int32)(__ccgo_up(nl_type + uintptr(argpos)*4)) = Int32FromUint32(st) + **(**Targ)(__ccgo_up(bp + 16)) = **(**Targ)(__ccgo_up(nl_arg + uintptr(argpos)*8)) } else { if f != 0 { _pop_arg1(tls, bp+16, Int32FromUint32(st), ap) @@ -142857,7 +142857,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_ERR) != 0 { return -int32(1) } - t = *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(-Int32FromInt32(1))*4)) + t = **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 8)) + uintptr(-Int32FromInt32(1))*4)) if ps != 0 && t&int32(15) == int32(3) { t = t & ^Int32FromInt32(32) } @@ -142865,19 +142865,19 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, case int32('n'): switch ps { case uint32(_BARE): - *(*int32)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))) = cnt + **(**int32)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 16)))) = cnt case uint32(_LPRE): - *(*int64)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))) = int64(cnt) + **(**int64)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 16)))) = int64(cnt) case uint32(_LLPRE): - *(*int64)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))) = int64(cnt) + **(**int64)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 16)))) = int64(cnt) case uint32(_HPRE): - *(*uint16)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))) = Uint16FromInt32(cnt) + **(**uint16)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 16)))) = Uint16FromInt32(cnt) case uint32(_HHPRE): - *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))) = Uint8FromInt32(cnt) + **(**uint8)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 16)))) = Uint8FromInt32(cnt) case uint32(_ZTPRE): - *(*Tsize_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))) = Uint64FromInt32(cnt) + **(**Tsize_t)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 16)))) = Uint64FromInt32(cnt) case uint32(_JPRE): - *(*Tuintmax_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))) = Uint64FromInt32(cnt) + **(**Tuintmax_t)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 16)))) = Uint64FromInt32(cnt) break } goto _1 @@ -142906,7 +142906,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, v5 = p } z = a + uintptr(Xwcsnlen(tls, a, Uint64FromInt32(v5)))*4 - if p < 0 && *(*Twchar_t)(unsafe.Pointer(z)) != 0 { + if p < 0 && **(**Twchar_t)(__ccgo_up(z)) != 0 { goto overflow } p = int32((int64(z) - int64(a)) / 4) @@ -142919,7 +142919,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, l = w goto _1 case int32('m'): - *(*uintptr)(unsafe.Pointer(bp + 16)) = Xstrerror(tls, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) + *(*uintptr)(unsafe.Pointer(bp + 16)) = Xstrerror(tls, **(**int32)(__ccgo_up(X__errno_location(tls)))) fallthrough case int32('s'): if !(*(*uintptr)(unsafe.Pointer(bp + 16)) != 0) { @@ -142951,7 +142951,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if i < 0 { return -int32(1) } - if p < 0 && *(*uint8)(unsafe.Pointer(bs)) != 0 { + if p < 0 && **(**uint8)(__ccgo_up(bs)) != 0 { goto overflow } p = l @@ -143012,17 +143012,17 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } i = int32(1) for { - if !(i <= int32(NL_ARGMAX) && *(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)) != 0) { + if !(i <= int32(NL_ARGMAX) && **(**int32)(__ccgo_up(nl_type + uintptr(i)*4)) != 0) { break } - _pop_arg1(tls, nl_arg+uintptr(i)*8, *(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)), ap) + _pop_arg1(tls, nl_arg+uintptr(i)*8, **(**int32)(__ccgo_up(nl_type + uintptr(i)*4)), ap) goto _17 _17: ; i = i + 1 } for { - if !(i <= int32(NL_ARGMAX) && !(*(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)) != 0)) { + if !(i <= int32(NL_ARGMAX) && !(**(**int32)(__ccgo_up(nl_type + uintptr(i)*4)) != 0)) { break } goto _18 @@ -143037,12 +143037,12 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto inval inval: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) goto overflow overflow: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return -int32(1) } @@ -143058,11 +143058,11 @@ func Xvfwprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { var _ /* nl_arg at bp+48 */ [10]Targ var _ /* nl_type at bp+8 */ [10]int32 _, _, _, _ = __need_unlock, olderr, ret, v1 - *(*[10]int32)(unsafe.Pointer(bp + 8)) = [10]int32{} + **(**[10]int32)(__ccgo_up(bp + 8)) = [10]int32{} /* the copy allows passing va_list* even if va_list is an array */ - *(*Tva_list)(unsafe.Pointer(bp)) = ap + **(**Tva_list)(__ccgo_up(bp)) = ap if _wprintf_core(tls, uintptr(0), fmt, bp, bp+48, bp+8) < 0 { - _ = *(*Tva_list)(unsafe.Pointer(bp)) + _ = **(**Tva_list)(__ccgo_up(bp)) return -int32(1) } if AtomicLoadPInt32(f+140) >= 0 { @@ -143073,16 +143073,16 @@ func Xvfwprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { __need_unlock = v1 Xfwide(tls, f, int32(1)) olderr = Int32FromUint32((*TFILE)(unsafe.Pointer(f)).Fflags & uint32(F_ERR)) - *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_ERR)) + **(**uint32)(__ccgo_up(f)) &= Uint32FromInt32(^Int32FromInt32(F_ERR)) ret = _wprintf_core(tls, f, fmt, bp, bp+48, bp+8) if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_ERR) != 0 { ret = -int32(1) } - *(*uint32)(unsafe.Pointer(f)) |= Uint32FromInt32(olderr) + **(**uint32)(__ccgo_up(f)) |= Uint32FromInt32(olderr) if __need_unlock != 0 { ___unlockfile(tls, f) } - _ = *(*Tva_list)(unsafe.Pointer(bp)) + _ = **(**Tva_list)(__ccgo_up(bp)) return ret } @@ -143092,15 +143092,15 @@ func _store_int1(tls *TLS, dest uintptr, size int32, i uint64) { } switch size { case -int32(2): - *(*uint8)(unsafe.Pointer(dest)) = uint8(i) + **(**uint8)(__ccgo_up(dest)) = uint8(i) case -int32(1): - *(*int16)(unsafe.Pointer(dest)) = Int16FromUint64(i) + **(**int16)(__ccgo_up(dest)) = Int16FromUint64(i) case SIZE_def: - *(*int32)(unsafe.Pointer(dest)) = Int32FromUint64(i) + **(**int32)(__ccgo_up(dest)) = Int32FromUint64(i) case int32(SIZE_l): - *(*int64)(unsafe.Pointer(dest)) = Int64FromUint64(i) + **(**int64)(__ccgo_up(dest)) = Int64FromUint64(i) case int32(SIZE_ll): - *(*int64)(unsafe.Pointer(dest)) = Int64FromUint64(i) + **(**int64)(__ccgo_up(dest)) = Int64FromUint64(i) break } } @@ -143132,13 +143132,13 @@ func _in_set(tls *TLS, set uintptr, c int32) (r int32) { var p, v3 uintptr _, _, _ = j, p, v3 p = set - if *(*Twchar_t)(unsafe.Pointer(p)) == int32('-') { + if **(**Twchar_t)(__ccgo_up(p)) == int32('-') { if c == int32('-') { return int32(1) } p += 4 } else { - if *(*Twchar_t)(unsafe.Pointer(p)) == int32(']') { + if **(**Twchar_t)(__ccgo_up(p)) == int32(']') { if c == int32(']') { return int32(1) } @@ -143146,15 +143146,15 @@ func _in_set(tls *TLS, set uintptr, c int32) (r int32) { } } for { - if !(*(*Twchar_t)(unsafe.Pointer(p)) != 0 && *(*Twchar_t)(unsafe.Pointer(p)) != int32(']')) { + if !(**(**Twchar_t)(__ccgo_up(p)) != 0 && **(**Twchar_t)(__ccgo_up(p)) != int32(']')) { break } - if *(*Twchar_t)(unsafe.Pointer(p)) == int32('-') && *(*Twchar_t)(unsafe.Pointer(p + 1*4)) != 0 && *(*Twchar_t)(unsafe.Pointer(p + 1*4)) != int32(']') { + if **(**Twchar_t)(__ccgo_up(p)) == int32('-') && **(**Twchar_t)(__ccgo_up(p + 1*4)) != 0 && **(**Twchar_t)(__ccgo_up(p + 1*4)) != int32(']') { v3 = p p += 4 - j = *(*Twchar_t)(unsafe.Pointer(v3 + uintptr(-Int32FromInt32(1))*4)) + j = **(**Twchar_t)(__ccgo_up(v3 + uintptr(-Int32FromInt32(1))*4)) for { - if !(j < *(*Twchar_t)(unsafe.Pointer(p))) { + if !(j < **(**Twchar_t)(__ccgo_up(p))) { break } if c == j { @@ -143166,7 +143166,7 @@ func _in_set(tls *TLS, set uintptr, c int32) (r int32) { j = j + 1 } } - if c == *(*Twchar_t)(unsafe.Pointer(p)) { + if c == **(**Twchar_t)(__ccgo_up(p)) { return int32(1) } goto _1 @@ -143204,20 +143204,20 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { Xfwide(tls, f, int32(1)) p = fmt for { - if !(*(*Twchar_t)(unsafe.Pointer(p)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(p)) != 0) { break } alloc = 0 - if Xiswspace(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(p)))) != 0 { - for Xiswspace(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(p + 1*4)))) != 0 { + if Xiswspace(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(p)))) != 0 { + for Xiswspace(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(p + 1*4)))) != 0 { p += 4 } for { - if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { + if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(**(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) + v4 = uint32(**(**uint8)(__ccgo_up(v5))) } else { v4 = Xgetwc(tls, f) } @@ -143232,21 +143232,21 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v6 = f + 8 *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 v5 = *(*uintptr)(unsafe.Pointer(v6)) - _ = *(*uint8)(unsafe.Pointer(v5)) + _ = **(**uint8)(__ccgo_up(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } goto _2 } - if *(*Twchar_t)(unsafe.Pointer(p)) != int32('%') || *(*Twchar_t)(unsafe.Pointer(p + 1*4)) == int32('%') { - if *(*Twchar_t)(unsafe.Pointer(p)) == int32('%') { + if **(**Twchar_t)(__ccgo_up(p)) != int32('%') || **(**Twchar_t)(__ccgo_up(p + 1*4)) == int32('%') { + if **(**Twchar_t)(__ccgo_up(p)) == int32('%') { p += 4 for { - if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { + if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(**(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) + v4 = uint32(**(**uint8)(__ccgo_up(v5))) } else { v4 = Xgetwc(tls, f) } @@ -143258,22 +143258,22 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { pos = pos + 1 } } else { - if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { + if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(**(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) + v4 = uint32(**(**uint8)(__ccgo_up(v5))) } else { v4 = Xgetwc(tls, f) } c = Int32FromUint32(v4) } - if c != *(*Twchar_t)(unsafe.Pointer(p)) { + if c != **(**Twchar_t)(__ccgo_up(p)) { if (*TFILE)(unsafe.Pointer(f)).Frend != 0 && Uint32FromInt32(c) < uint32(128) { v6 = f + 8 *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 v5 = *(*uintptr)(unsafe.Pointer(v6)) - _ = *(*uint8)(unsafe.Pointer(v5)) + _ = **(**uint8)(__ccgo_up(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -143286,12 +143286,12 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { goto _2 } p += 4 - if *(*Twchar_t)(unsafe.Pointer(p)) == int32('*') { + if **(**Twchar_t)(__ccgo_up(p)) == int32('*') { dest = uintptr(0) p += 4 } else { - if BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(p)))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(p + 1*4)) == int32('$') { - dest = _arg_n1(tls, ap, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(p))-int32('0'))) + if BoolInt32(Uint32FromInt32(**(**Twchar_t)(__ccgo_up(p)))-uint32('0') < uint32(10)) != 0 && **(**Twchar_t)(__ccgo_up(p + 1*4)) == int32('$') { + dest = _arg_n1(tls, ap, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(p))-int32('0'))) p = p + uintptr(2)*4 } else { dest = VaUintptr(&ap) @@ -143299,16 +143299,16 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } width = 0 for { - if !(BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(p)))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(Uint32FromInt32(**(**Twchar_t)(__ccgo_up(p)))-uint32('0') < uint32(10)) != 0) { break } - width = int32(10)*width + *(*Twchar_t)(unsafe.Pointer(p)) - int32('0') + width = int32(10)*width + **(**Twchar_t)(__ccgo_up(p)) - int32('0') goto _18 _18: ; p += 4 } - if *(*Twchar_t)(unsafe.Pointer(p)) == int32('m') { + if **(**Twchar_t)(__ccgo_up(p)) == int32('m') { wcs = uintptr(0) s = uintptr(0) alloc = BoolInt32(!!(dest != 0)) @@ -143319,16 +143319,16 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { size = SIZE_def v5 = p p += 4 - switch *(*Twchar_t)(unsafe.Pointer(v5)) { + switch **(**Twchar_t)(__ccgo_up(v5)) { case int32('h'): - if *(*Twchar_t)(unsafe.Pointer(p)) == int32('h') { + if **(**Twchar_t)(__ccgo_up(p)) == int32('h') { p += 4 size = -Int32FromInt32(2) } else { size = -int32(1) } case int32('l'): - if *(*Twchar_t)(unsafe.Pointer(p)) == int32('l') { + if **(**Twchar_t)(__ccgo_up(p)) == int32('l') { p += 4 size = Int32FromInt32(SIZE_ll) } else { @@ -143387,7 +143387,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { default: goto fmt_fail } - t = *(*Twchar_t)(unsafe.Pointer(p)) + t = **(**Twchar_t)(__ccgo_up(p)) /* Transform S,C -> ls,lc */ if t&int32(0x2f) == int32(3) { size = int32(SIZE_l) @@ -143396,11 +143396,11 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if t != int32('n') { if t != int32('[') && t|int32(32) != int32('c') { for { - if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { + if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(**(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) + v4 = uint32(**(**uint8)(__ccgo_up(v5))) } else { v4 = Xgetwc(tls, f) } @@ -143412,11 +143412,11 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { pos = pos + 1 } } else { - if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { + if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(**(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) + v4 = uint32(**(**uint8)(__ccgo_up(v5))) } else { v4 = Xgetwc(tls, f) } @@ -143429,7 +143429,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v6 = f + 8 *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 v5 = *(*uintptr)(unsafe.Pointer(v6)) - _ = *(*uint8)(unsafe.Pointer(v5)) + _ = **(**uint8)(__ccgo_up(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -143457,18 +143457,18 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } else { p += 4 v5 = p - if *(*Twchar_t)(unsafe.Pointer(v5)) == int32('^') { + if **(**Twchar_t)(__ccgo_up(v5)) == int32('^') { p += 4 invert = Int32FromInt32(1) } else { invert = 0 } set = p - if *(*Twchar_t)(unsafe.Pointer(p)) == int32(']') { + if **(**Twchar_t)(__ccgo_up(p)) == int32(']') { p += 4 } - for *(*Twchar_t)(unsafe.Pointer(p)) != int32(']') { - if !(*(*Twchar_t)(unsafe.Pointer(p)) != 0) { + for **(**Twchar_t)(__ccgo_up(p)) != int32(']') { + if !(**(**Twchar_t)(__ccgo_up(p)) != 0) { goto fmt_fail } p += 4 @@ -143512,11 +143512,11 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } } for width != 0 { - if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { + if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(**(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 - v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) + v4 = uint32(**(**uint8)(__ccgo_up(v5))) } else { v4 = Xgetwc(tls, f) } @@ -143531,7 +143531,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if wcs != 0 { v37 = i i = i + 1 - *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(v37)*4)) = c + **(**Twchar_t)(__ccgo_up(wcs + uintptr(v37)*4)) = c if alloc != 0 && i == k { k = k + (k + uint64(1)) tmp1 = Xrealloc(tls, wcs, k*uint64(4)) @@ -143571,7 +143571,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { v6 = f + 8 *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 v5 = *(*uintptr)(unsafe.Pointer(v6)) - _ = *(*uint8)(unsafe.Pointer(v5)) + _ = **(**uint8)(__ccgo_up(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -143581,17 +143581,17 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } if alloc != 0 { if size == int32(SIZE_l) { - *(*uintptr)(unsafe.Pointer(dest)) = wcs + **(**uintptr)(__ccgo_up(dest)) = wcs } else { - *(*uintptr)(unsafe.Pointer(dest)) = s + **(**uintptr)(__ccgo_up(dest)) = s } } if t != int32('c') { if wcs != 0 { - *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) = 0 + **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) = 0 } if s != 0 { - *(*uint8)(unsafe.Pointer(s + uintptr(i))) = uint8(0) + **(**uint8)(__ccgo_up(s + uintptr(i))) = uint8(0) } } case int32('d'): @@ -143627,7 +143627,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { width = 0 } Xsnprintf(tls, bp+8, uint64(22), __ccgo_ts+1700, VaList(bp+40, int32(1)+BoolInt32(!(dest != 0)), __ccgo_ts+1718, width, uintptr(unsafe.Pointer(&_size_pfx))+uintptr(size+int32(2))*3, t)) - *(*Toff_t)(unsafe.Pointer(bp)) = 0 + **(**Toff_t)(__ccgo_up(bp)) = 0 if dest != 0 { v5 = dest } else { @@ -143636,11 +143636,11 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if Xfscanf(tls, f, bp+8, VaList(bp+40, v5, bp)) == -int32(1) { goto input_fail } else { - if !(*(*Toff_t)(unsafe.Pointer(bp)) != 0) { + if !(**(**Toff_t)(__ccgo_up(bp)) != 0) { goto match_fail } } - pos = pos + *(*Toff_t)(unsafe.Pointer(bp)) + pos = pos + **(**Toff_t)(__ccgo_up(bp)) default: goto fmt_fail } @@ -143766,8 +143766,8 @@ func _sn_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { k = v1 if k != 0 { Xmemcpy(tls, (*Tcookie3)(unsafe.Pointer(c)).Fs, (*TFILE)(unsafe.Pointer(f)).Fwbase, k) - *(*uintptr)(unsafe.Pointer(c)) += uintptr(k) - *(*Tsize_t)(unsafe.Pointer(c + 8)) -= k + **(**uintptr)(__ccgo_up(c)) += uintptr(k) + **(**Tsize_t)(__ccgo_up(c + 8)) -= k } if (*Tcookie3)(unsafe.Pointer(c)).Fn < l { v1 = (*Tcookie3)(unsafe.Pointer(c)).Fn @@ -143777,10 +143777,10 @@ func _sn_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { k = v1 if k != 0 { Xmemcpy(tls, (*Tcookie3)(unsafe.Pointer(c)).Fs, s, k) - *(*uintptr)(unsafe.Pointer(c)) += uintptr(k) - *(*Tsize_t)(unsafe.Pointer(c + 8)) -= k + **(**uintptr)(__ccgo_up(c)) += uintptr(k) + **(**Tsize_t)(__ccgo_up(c + 8)) -= k } - *(*uint8)(unsafe.Pointer((*Tcookie3)(unsafe.Pointer(c)).Fs)) = uint8(0) + **(**uint8)(__ccgo_up((*Tcookie3)(unsafe.Pointer(c)).Fs)) = uint8(0) v3 = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Fwbase = v3 (*TFILE)(unsafe.Pointer(f)).Fwpos = v3 @@ -143812,18 +143812,18 @@ func Xvsnprintf(tls *TLS, s uintptr, n Tsize_t, fmt uintptr, ap Tva_list) (r int } else { v2 = uint64(0) } - *(*Tcookie3)(unsafe.Pointer(bp + 8)) = Tcookie3{ + **(**Tcookie3)(__ccgo_up(bp + 8)) = Tcookie3{ Fs: v1, Fn: v2, } - *(*TFILE)(unsafe.Pointer(bp + 24)) = TFILE{ + **(**TFILE)(__ccgo_up(bp + 24)) = TFILE{ Fwrite: __ccgo_fp(_sn_write), Fbuf: bp, Flock: -int32(1), Flbf: -int32(1), Fcookie: bp + 8, } - *(*uint8)(unsafe.Pointer((*(*Tcookie3)(unsafe.Pointer(bp + 8))).Fs)) = uint8(0) + **(**uint8)(__ccgo_up((**(**Tcookie3)(__ccgo_up(bp + 8))).Fs)) = uint8(0) return Xvfprintf(tls, bp+24, fmt, ap) } @@ -143872,7 +143872,7 @@ func Xvsscanf(tls *TLS, s uintptr, fmt uintptr, ap Tva_list) (r int32) { bp := tls.Alloc(240) defer tls.Free(240) var _ /* f at bp+0 */ TFILE - *(*TFILE)(unsafe.Pointer(bp)) = TFILE{ + **(**TFILE)(__ccgo_up(bp)) = TFILE{ Fread: __ccgo_fp(_string_read), Fbuf: s, Flock: -int32(1), @@ -143922,14 +143922,14 @@ func _sw_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { (*Tcookie4)(unsafe.Pointer(c)).Fl = (*Tcookie4)(unsafe.Pointer(c)).Fl - 1 (*Tcookie4)(unsafe.Pointer(c)).Fws += 4 } - *(*Twchar_t)(unsafe.Pointer((*Tcookie4)(unsafe.Pointer(c)).Fws)) = 0 + **(**Twchar_t)(__ccgo_up((*Tcookie4)(unsafe.Pointer(c)).Fws)) = 0 if i < 0 { v4 = UintptrFromInt32(0) (*TFILE)(unsafe.Pointer(f)).Fwend = v4 v3 = v4 (*TFILE)(unsafe.Pointer(f)).Fwbase = v3 (*TFILE)(unsafe.Pointer(f)).Fwpos = v3 - *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) + **(**uint32)(__ccgo_up(f)) |= uint32(F_ERR) return Uint64FromInt32(i) } (*TFILE)(unsafe.Pointer(f)).Fwend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr((*TFILE)(unsafe.Pointer(f)).Fbuf_size) @@ -143951,11 +143951,11 @@ func Xvswprintf(tls *TLS, s uintptr, n Tsize_t, fmt uintptr, ap Tva_list) (r1 in var _ /* c at bp+256 */ Tcookie4 var _ /* f at bp+272 */ TFILE _, _ = r, v1 - *(*Tcookie4)(unsafe.Pointer(bp + 256)) = Tcookie4{ + **(**Tcookie4)(__ccgo_up(bp + 256)) = Tcookie4{ Fws: s, Fl: n - uint64(1), } - *(*TFILE)(unsafe.Pointer(bp + 272)) = TFILE{ + **(**TFILE)(__ccgo_up(bp + 272)) = TFILE{ Fwrite: __ccgo_fp(_sw_write), Fbuf: bp, Fbuf_size: uint64(256), @@ -143983,8 +143983,8 @@ func _wstring_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { var v1, v2 uintptr var _ /* src at bp+0 */ uintptr _, _, _ = k, v1, v2 - *(*uintptr)(unsafe.Pointer(bp)) = (*TFILE)(unsafe.Pointer(f)).Fcookie - if !(*(*uintptr)(unsafe.Pointer(bp)) != 0) { + **(**uintptr)(__ccgo_up(bp)) = (*TFILE)(unsafe.Pointer(f)).Fcookie + if !(**(**uintptr)(__ccgo_up(bp)) != 0) { return uint64(0) } k = Xwcsrtombs(tls, (*TFILE)(unsafe.Pointer(f)).Fbuf, bp, (*TFILE)(unsafe.Pointer(f)).Fbuf_size, uintptr(0)) @@ -143996,14 +143996,14 @@ func _wstring_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { } (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(k) - (*TFILE)(unsafe.Pointer(f)).Fcookie = *(*uintptr)(unsafe.Pointer(bp)) + (*TFILE)(unsafe.Pointer(f)).Fcookie = **(**uintptr)(__ccgo_up(bp)) if !(len1 != 0) || !(k != 0) { return uint64(0) } v2 = f + 8 v1 = *(*uintptr)(unsafe.Pointer(v2)) *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(v2)) + 1 - *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v1)) + **(**uint8)(__ccgo_up(buf)) = **(**uint8)(__ccgo_up(v1)) return uint64(1) } @@ -144016,7 +144016,7 @@ func Xvswscanf(tls *TLS, s uintptr, fmt uintptr, ap Tva_list) (r int32) { defer tls.Free(496) var _ /* buf at bp+0 */ [256]uint8 var _ /* f at bp+256 */ TFILE - *(*TFILE)(unsafe.Pointer(bp + 256)) = TFILE{ + **(**TFILE)(__ccgo_up(bp + 256)) = TFILE{ Fread: __ccgo_fp(_wstring_read), Fbuf: bp, Fbuf_size: uint64(256), @@ -144128,7 +144128,7 @@ func Xatoi(tls *TLS, s uintptr) (r int32) { n = 0 neg = 0 for { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(s))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _3 _3: @@ -144137,7 +144137,7 @@ func Xatoi(tls *TLS, s uintptr) (r int32) { } s = s + 1 } - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(s))) { case int32('-'): neg = int32(1) fallthrough @@ -144145,10 +144145,10 @@ func Xatoi(tls *TLS, s uintptr) (r int32) { s = s + 1 } /* Compute n as a negative number to avoid overflow on INT_MIN */ - for BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { + for BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-uint32('0') < uint32(10)) != 0 { v4 = s s = s + 1 - n = int32(10)*n - (Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) - int32('0')) + n = int32(10)*n - (Int32FromUint8(**(**uint8)(__ccgo_up(v4))) - int32('0')) } if neg != 0 { v1 = n @@ -144170,7 +144170,7 @@ func Xatol(tls *TLS, s uintptr) (r int64) { n = 0 neg = 0 for { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(s))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _3 _3: @@ -144179,7 +144179,7 @@ func Xatol(tls *TLS, s uintptr) (r int64) { } s = s + 1 } - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(s))) { case int32('-'): neg = int32(1) fallthrough @@ -144187,10 +144187,10 @@ func Xatol(tls *TLS, s uintptr) (r int64) { s = s + 1 } /* Compute n as a negative number to avoid overflow on LONG_MIN */ - for BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { + for BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-uint32('0') < uint32(10)) != 0 { v4 = s s = s + 1 - n = int64(10)*n - int64(Int32FromUint8(*(*uint8)(unsafe.Pointer(v4)))-Int32FromUint8('0')) + n = int64(10)*n - int64(Int32FromUint8(**(**uint8)(__ccgo_up(v4)))-Int32FromUint8('0')) } if neg != 0 { v5 = n @@ -144212,7 +144212,7 @@ func Xatoll(tls *TLS, s uintptr) (r int64) { n = 0 neg = 0 for { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(s))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _3 _3: @@ -144221,7 +144221,7 @@ func Xatoll(tls *TLS, s uintptr) (r int64) { } s = s + 1 } - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(s))) { case int32('-'): neg = int32(1) fallthrough @@ -144229,10 +144229,10 @@ func Xatoll(tls *TLS, s uintptr) (r int64) { s = s + 1 } /* Compute n as a negative number to avoid overflow on LLONG_MIN */ - for BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { + for BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-uint32('0') < uint32(10)) != 0 { v4 = s s = s + 1 - n = int64(10)*n - int64(Int32FromUint8(*(*uint8)(unsafe.Pointer(v4)))-Int32FromUint8('0')) + n = int64(10)*n - int64(Int32FromUint8(**(**uint8)(__ccgo_up(v4)))-Int32FromUint8('0')) } if neg != 0 { v5 = n @@ -144294,24 +144294,24 @@ func Xecvt(tls *TLS, x float64, n int32, dp uintptr, sign uintptr) (r uintptr) { n = int32(15) } Xsprintf(tls, bp, __ccgo_ts+1721, VaList(bp+40, n-int32(1), x)) - v1 = BoolInt32(Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp)))[0]) == Int32FromUint8('-')) - *(*int32)(unsafe.Pointer(sign)) = v1 + v1 = BoolInt32(Int32FromUint8((**(**[32]uint8)(__ccgo_up(bp)))[0]) == Int32FromUint8('-')) + **(**int32)(__ccgo_up(sign)) = v1 i = v1 j = 0 for { - if !(Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp)))[i]) != int32('e')) { + if !(Int32FromUint8((**(**[32]uint8)(__ccgo_up(bp)))[i]) != int32('e')) { break } - _buf8[j] = (*(*[32]uint8)(unsafe.Pointer(bp)))[i] + _buf8[j] = (**(**[32]uint8)(__ccgo_up(bp)))[i] goto _2 _2: ; v1 = i i = i + 1 - j = j + BoolInt32(Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp)))[v1]) != int32('.')) + j = j + BoolInt32(Int32FromUint8((**(**[32]uint8)(__ccgo_up(bp)))[v1]) != int32('.')) } _buf8[j] = uint8(0) - *(*int32)(unsafe.Pointer(dp)) = Xatoi(tls, bp+uintptr(i)+uintptr(1)) + int32(1) + **(**int32)(__ccgo_up(dp)) = Xatoi(tls, bp+uintptr(i)+uintptr(1)) + int32(1) return uintptr(unsafe.Pointer(&_buf8)) } @@ -144331,15 +144331,15 @@ func Xfcvt(tls *TLS, x float64, n int32, dp uintptr, sign uintptr) (r uintptr) { n = int32(1400) } Xsprintf(tls, bp, __ccgo_ts+1726, VaList(bp+1512, n, x)) - i = BoolInt32(Int32FromUint8((*(*[1500]uint8)(unsafe.Pointer(bp)))[0]) == int32('-')) - if Int32FromUint8((*(*[1500]uint8)(unsafe.Pointer(bp)))[i]) == int32('0') { + i = BoolInt32(Int32FromUint8((**(**[1500]uint8)(__ccgo_up(bp)))[0]) == int32('-')) + if Int32FromUint8((**(**[1500]uint8)(__ccgo_up(bp)))[i]) == int32('0') { lz = Int32FromUint64(Xstrspn(tls, bp+uintptr(i)+uintptr(2), __ccgo_ts+1694)) } else { lz = -Int32FromUint64(Xstrcspn(tls, bp+uintptr(i), __ccgo_ts+598)) } if n <= lz { - *(*int32)(unsafe.Pointer(sign)) = i - *(*int32)(unsafe.Pointer(dp)) = int32(1) + **(**int32)(__ccgo_up(sign)) = i + **(**int32)(__ccgo_up(dp)) = int32(1) if Uint32FromInt32(n) > uint32(14) { n = int32(14) } @@ -144444,13 +144444,13 @@ func _pntz(tls *TLS, p uintptr) (r1 int32) { var v1, v5 uint64 var v8 bool _, _, _, _, _, _, _ = r, v1, v2, v4, v5, v6, v8 - v1 = *(*Tsize_t)(unsafe.Pointer(p)) - uint64(1) + v1 = **(**Tsize_t)(__ccgo_up(p)) - uint64(1) v2 = _a_ctz_64(tls, v1) goto _3 _3: r = v2 if v8 = r != 0; !v8 { - v5 = *(*Tsize_t)(unsafe.Pointer(p + 1*8)) + v5 = **(**Tsize_t)(__ccgo_up(p + 1*8)) v6 = _a_ctz_64(tls, v5) goto _7 _7: @@ -144474,7 +144474,7 @@ func _cycle(tls *TLS, width Tsize_t, ar uintptr, n int32) { if n < int32(2) { return } - *(*uintptr)(unsafe.Pointer(ar + uintptr(n)*8)) = bp + **(**uintptr)(__ccgo_up(ar + uintptr(n)*8)) = bp for width != 0 { if uint64(256) < width { v1 = uint64(256) @@ -144482,14 +144482,14 @@ func _cycle(tls *TLS, width Tsize_t, ar uintptr, n int32) { v1 = width } l = v1 - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(ar + uintptr(n)*8)), *(*uintptr)(unsafe.Pointer(ar)), l) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(ar + uintptr(n)*8)), **(**uintptr)(__ccgo_up(ar)), l) i = 0 for { if !(i < n) { break } - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(ar + uintptr(i)*8)), *(*uintptr)(unsafe.Pointer(ar + uintptr(i+int32(1))*8)), l) - *(*uintptr)(unsafe.Pointer(ar + uintptr(i)*8)) += uintptr(l) + Xmemcpy(tls, **(**uintptr)(__ccgo_up(ar + uintptr(i)*8)), **(**uintptr)(__ccgo_up(ar + uintptr(i+int32(1))*8)), l) + **(**uintptr)(__ccgo_up(ar + uintptr(i)*8)) += uintptr(l) goto _2 _2: ; @@ -144505,23 +144505,23 @@ func _cycle(tls *TLS, width Tsize_t, ar uintptr, n int32) { func _shl(tls *TLS, p uintptr, n int32) { if Uint64FromInt32(n) >= Uint64FromInt32(8)*Uint64FromInt64(8) { n = Int32FromUint64(uint64(n) - Uint64FromInt32(8)*Uint64FromInt64(8)) - *(*Tsize_t)(unsafe.Pointer(p + 1*8)) = *(*Tsize_t)(unsafe.Pointer(p)) - *(*Tsize_t)(unsafe.Pointer(p)) = uint64(0) + **(**Tsize_t)(__ccgo_up(p + 1*8)) = **(**Tsize_t)(__ccgo_up(p)) + **(**Tsize_t)(__ccgo_up(p)) = uint64(0) } - *(*Tsize_t)(unsafe.Pointer(p + 1*8)) <<= Uint64FromInt32(n) - *(*Tsize_t)(unsafe.Pointer(p + 1*8)) |= *(*Tsize_t)(unsafe.Pointer(p)) >> (Uint64FromInt64(8)*Uint64FromInt32(8) - Uint64FromInt32(n)) - *(*Tsize_t)(unsafe.Pointer(p)) <<= Uint64FromInt32(n) + **(**Tsize_t)(__ccgo_up(p + 1*8)) <<= Uint64FromInt32(n) + **(**Tsize_t)(__ccgo_up(p + 1*8)) |= **(**Tsize_t)(__ccgo_up(p)) >> (Uint64FromInt64(8)*Uint64FromInt32(8) - Uint64FromInt32(n)) + **(**Tsize_t)(__ccgo_up(p)) <<= Uint64FromInt32(n) } func _shr(tls *TLS, p uintptr, n int32) { if Uint64FromInt32(n) >= Uint64FromInt32(8)*Uint64FromInt64(8) { n = Int32FromUint64(uint64(n) - Uint64FromInt32(8)*Uint64FromInt64(8)) - *(*Tsize_t)(unsafe.Pointer(p)) = *(*Tsize_t)(unsafe.Pointer(p + 1*8)) - *(*Tsize_t)(unsafe.Pointer(p + 1*8)) = uint64(0) + **(**Tsize_t)(__ccgo_up(p)) = **(**Tsize_t)(__ccgo_up(p + 1*8)) + **(**Tsize_t)(__ccgo_up(p + 1*8)) = uint64(0) } - *(*Tsize_t)(unsafe.Pointer(p)) >>= Uint64FromInt32(n) - *(*Tsize_t)(unsafe.Pointer(p)) |= *(*Tsize_t)(unsafe.Pointer(p + 1*8)) << (Uint64FromInt64(8)*Uint64FromInt32(8) - Uint64FromInt32(n)) - *(*Tsize_t)(unsafe.Pointer(p + 1*8)) >>= Uint64FromInt32(n) + **(**Tsize_t)(__ccgo_up(p)) >>= Uint64FromInt32(n) + **(**Tsize_t)(__ccgo_up(p)) |= **(**Tsize_t)(__ccgo_up(p + 1*8)) << (Uint64FromInt64(8)*Uint64FromInt32(8) - Uint64FromInt32(n)) + **(**Tsize_t)(__ccgo_up(p + 1*8)) >>= Uint64FromInt32(n) } func _sift(tls *TLS, head uintptr, width Tsize_t, __ccgo_fp_cmp Tcmpfun, arg uintptr, pshift int32, lp uintptr) { @@ -144532,23 +144532,23 @@ func _sift(tls *TLS, head uintptr, width Tsize_t, __ccgo_fp_cmp Tcmpfun, arg uin var _ /* ar at bp+0 */ [113]uintptr _, _, _, _ = i, lf, rt, v1 i = int32(1) - (*(*[113]uintptr)(unsafe.Pointer(bp)))[0] = head + (**(**[113]uintptr)(__ccgo_up(bp)))[0] = head for pshift > int32(1) { rt = head - uintptr(width) - lf = head - uintptr(width) - uintptr(*(*Tsize_t)(unsafe.Pointer(lp + uintptr(pshift-int32(2))*8))) - if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, (*(*[113]uintptr)(unsafe.Pointer(bp)))[0], lf, arg) >= 0 && (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, (*(*[113]uintptr)(unsafe.Pointer(bp)))[0], rt, arg) >= 0 { + lf = head - uintptr(width) - uintptr(**(**Tsize_t)(__ccgo_up(lp + uintptr(pshift-int32(2))*8))) + if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, (**(**[113]uintptr)(__ccgo_up(bp)))[0], lf, arg) >= 0 && (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, (**(**[113]uintptr)(__ccgo_up(bp)))[0], rt, arg) >= 0 { break } if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, lf, rt, arg) >= 0 { v1 = i i = i + 1 - (*(*[113]uintptr)(unsafe.Pointer(bp)))[v1] = lf + (**(**[113]uintptr)(__ccgo_up(bp)))[v1] = lf head = lf pshift = pshift - int32(1) } else { v1 = i i = i + 1 - (*(*[113]uintptr)(unsafe.Pointer(bp)))[v1] = rt + (**(**[113]uintptr)(__ccgo_up(bp)))[v1] = rt head = rt pshift = pshift - int32(2) } @@ -144565,24 +144565,24 @@ func _trinkle(tls *TLS, head uintptr, width Tsize_t, __ccgo_fp_cmp Tcmpfun, arg var _ /* p at bp+0 */ [2]Tsize_t _, _, _, _, _, _ = i, lf, rt, stepson, trail, v1 i = int32(1) - (*(*[2]Tsize_t)(unsafe.Pointer(bp)))[0] = *(*Tsize_t)(unsafe.Pointer(pp)) - (*(*[2]Tsize_t)(unsafe.Pointer(bp)))[int32(1)] = *(*Tsize_t)(unsafe.Pointer(pp + 1*8)) - (*(*[113]uintptr)(unsafe.Pointer(bp + 16)))[0] = head - for (*(*[2]Tsize_t)(unsafe.Pointer(bp)))[0] != uint64(1) || (*(*[2]Tsize_t)(unsafe.Pointer(bp)))[int32(1)] != uint64(0) { - stepson = head - uintptr(*(*Tsize_t)(unsafe.Pointer(lp + uintptr(pshift)*8))) - if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, stepson, (*(*[113]uintptr)(unsafe.Pointer(bp + 16)))[0], arg) <= 0 { + (**(**[2]Tsize_t)(__ccgo_up(bp)))[0] = **(**Tsize_t)(__ccgo_up(pp)) + (**(**[2]Tsize_t)(__ccgo_up(bp)))[int32(1)] = **(**Tsize_t)(__ccgo_up(pp + 1*8)) + (**(**[113]uintptr)(__ccgo_up(bp + 16)))[0] = head + for (**(**[2]Tsize_t)(__ccgo_up(bp)))[0] != uint64(1) || (**(**[2]Tsize_t)(__ccgo_up(bp)))[int32(1)] != uint64(0) { + stepson = head - uintptr(**(**Tsize_t)(__ccgo_up(lp + uintptr(pshift)*8))) + if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, stepson, (**(**[113]uintptr)(__ccgo_up(bp + 16)))[0], arg) <= 0 { break } if !(trusty != 0) && pshift > int32(1) { rt = head - uintptr(width) - lf = head - uintptr(width) - uintptr(*(*Tsize_t)(unsafe.Pointer(lp + uintptr(pshift-int32(2))*8))) + lf = head - uintptr(width) - uintptr(**(**Tsize_t)(__ccgo_up(lp + uintptr(pshift-int32(2))*8))) if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, rt, stepson, arg) >= 0 || (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, lf, stepson, arg) >= 0 { break } } v1 = i i = i + 1 - (*(*[113]uintptr)(unsafe.Pointer(bp + 16)))[v1] = stepson + (**(**[113]uintptr)(__ccgo_up(bp + 16)))[v1] = stepson head = stepson trail = _pntz(tls, bp) _shr(tls, bp, trail) @@ -144610,7 +144610,7 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm var _ /* p at bp+768 */ [2]Tsize_t _, _, _, _, _, _, _, _ = head, high, i, pshift, size, trail, v2, v3 size = width * nel - *(*[2]Tsize_t)(unsafe.Pointer(bp + 768)) = [2]Tsize_t{ + **(**[2]Tsize_t)(__ccgo_up(bp + 768)) = [2]Tsize_t{ 0: uint64(1), } pshift = int32(1) @@ -144621,12 +144621,12 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm high = head + uintptr(size) - uintptr(width) /* Precompute Leonardo numbers, scaled by element width */ v2 = width - (*(*[96]Tsize_t)(unsafe.Pointer(bp)))[int32(1)] = v2 - (*(*[96]Tsize_t)(unsafe.Pointer(bp)))[0] = v2 + (**(**[96]Tsize_t)(__ccgo_up(bp)))[int32(1)] = v2 + (**(**[96]Tsize_t)(__ccgo_up(bp)))[0] = v2 i = Uint64FromInt32(2) for { - v3 = (*(*[96]Tsize_t)(unsafe.Pointer(bp)))[i-uint64(2)] + (*(*[96]Tsize_t)(unsafe.Pointer(bp)))[i-uint64(1)] + width - (*(*[96]Tsize_t)(unsafe.Pointer(bp)))[i] = v3 + v3 = (**(**[96]Tsize_t)(__ccgo_up(bp)))[i-uint64(2)] + (**(**[96]Tsize_t)(__ccgo_up(bp)))[i-uint64(1)] + width + (**(**[96]Tsize_t)(__ccgo_up(bp)))[i] = v3 if !(v3 < size) { break } @@ -144636,12 +144636,12 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm i = i + 1 } for head < high { - if (*(*[2]Tsize_t)(unsafe.Pointer(bp + 768)))[0]&uint64(3) == uint64(3) { + if (**(**[2]Tsize_t)(__ccgo_up(bp + 768)))[0]&uint64(3) == uint64(3) { _sift(tls, head, width, __ccgo_fp_cmp, arg, pshift, bp) _shr(tls, bp+768, int32(2)) pshift = pshift + int32(2) } else { - if (*(*[96]Tsize_t)(unsafe.Pointer(bp)))[pshift-int32(1)] >= Uint64FromInt64(int64(high)-int64(head)) { + if (**(**[96]Tsize_t)(__ccgo_up(bp)))[pshift-int32(1)] >= Uint64FromInt64(int64(high)-int64(head)) { _trinkle(tls, head, width, __ccgo_fp_cmp, arg, bp+768, pshift, 0, bp) } else { _sift(tls, head, width, __ccgo_fp_cmp, arg, pshift, bp) @@ -144654,11 +144654,11 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm pshift = int32(1) } } - *(*Tsize_t)(unsafe.Pointer(bp + 768)) |= uint64(1) + **(**Tsize_t)(__ccgo_up(bp + 768)) |= uint64(1) head = head + uintptr(width) } _trinkle(tls, head, width, __ccgo_fp_cmp, arg, bp+768, pshift, 0, bp) - for pshift != int32(1) || (*(*[2]Tsize_t)(unsafe.Pointer(bp + 768)))[0] != uint64(1) || (*(*[2]Tsize_t)(unsafe.Pointer(bp + 768)))[int32(1)] != uint64(0) { + for pshift != int32(1) || (**(**[2]Tsize_t)(__ccgo_up(bp + 768)))[0] != uint64(1) || (**(**[2]Tsize_t)(__ccgo_up(bp + 768)))[int32(1)] != uint64(0) { if pshift <= int32(1) { trail = _pntz(tls, bp+768) _shr(tls, bp+768, trail) @@ -144666,11 +144666,11 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm } else { _shl(tls, bp+768, int32(2)) pshift = pshift - int32(2) - *(*Tsize_t)(unsafe.Pointer(bp + 768)) ^= uint64(7) + **(**Tsize_t)(__ccgo_up(bp + 768)) ^= uint64(7) _shr(tls, bp+768, int32(1)) - _trinkle(tls, head-uintptr((*(*[96]Tsize_t)(unsafe.Pointer(bp)))[pshift])-uintptr(width), width, __ccgo_fp_cmp, arg, bp+768, pshift+int32(1), int32(1), bp) + _trinkle(tls, head-uintptr((**(**[96]Tsize_t)(__ccgo_up(bp)))[pshift])-uintptr(width), width, __ccgo_fp_cmp, arg, bp+768, pshift+int32(1), int32(1), bp) _shl(tls, bp+768, int32(1)) - *(*Tsize_t)(unsafe.Pointer(bp + 768)) |= uint64(1) + **(**Tsize_t)(__ccgo_up(bp + 768)) |= uint64(1) _trinkle(tls, head-uintptr(width), width, __ccgo_fp_cmp, arg, bp+768, pshift, int32(1), bp) } head = head - uintptr(width) @@ -144720,7 +144720,7 @@ func _strtox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { } else { v1 = s } - *(*uintptr)(unsafe.Pointer(p)) = v1 + **(**uintptr)(__ccgo_up(p)) = v1 } return y } @@ -144765,7 +144765,7 @@ func _strtox1(tls *TLS, s uintptr, p uintptr, base int32, lim uint64) (r uint64) y = X__intscan(tls, bp, Uint32FromInt32(base), int32(1), lim) if p != 0 { cnt = Uint64FromInt64((*TFILE)(unsafe.Pointer(bp)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(bp)).Frpos) - int64((*TFILE)(unsafe.Pointer(bp)).Fbuf))) - *(*uintptr)(unsafe.Pointer(p)) = s + uintptr(cnt) + **(**uintptr)(__ccgo_up(p)) = s + uintptr(cnt) } return y } @@ -144876,20 +144876,20 @@ func _do_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { var v2 int32 _, _, _, _, _ = i, wcs, v2, v3, v4 wcs = (*TFILE)(unsafe.Pointer(f)).Fcookie - if !(*(*Twchar_t)(unsafe.Pointer(wcs)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(wcs)) != 0) { wcs = __ccgo_ts + 1752 } i = uint64(0) for { - if !(i < (*TFILE)(unsafe.Pointer(f)).Fbuf_size && *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) != 0) { + if !(i < (*TFILE)(unsafe.Pointer(f)).Fbuf_size && **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) != 0) { break } - if *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) < int32(128) { - v2 = *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) + if **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) < int32(128) { + v2 = **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) } else { v2 = int32('@') } - *(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(i))) = Uint8FromInt32(v2) + **(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(i))) = Uint8FromInt32(v2) goto _1 _1: ; @@ -144902,7 +144902,7 @@ func _do_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(buf)) = **(**uint8)(__ccgo_up(v3)) return uint64(1) } return uint64(0) @@ -144918,20 +144918,20 @@ func _wcstox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { var _ /* f at bp+64 */ TFILE _, _, _, _, _ = cnt, t, y, v1, v2 t = s - *(*TFILE)(unsafe.Pointer(bp + 64)) = TFILE{} - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fflags = uint32(0) + **(**TFILE)(__ccgo_up(bp + 64)) = TFILE{} + (**(**TFILE)(__ccgo_up(bp + 64))).Fflags = uint32(0) v2 = bp + UintptrFromInt32(4) - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fbuf = v2 + (**(**TFILE)(__ccgo_up(bp + 64))).Fbuf = v2 v1 = v2 - (*(*TFILE)(unsafe.Pointer(bp + 64))).Frend = v1 - (*(*TFILE)(unsafe.Pointer(bp + 64))).Frpos = v1 - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fbuf_size = Uint64FromInt64(64) - Uint64FromInt32(4) + (**(**TFILE)(__ccgo_up(bp + 64))).Frend = v1 + (**(**TFILE)(__ccgo_up(bp + 64))).Frpos = v1 + (**(**TFILE)(__ccgo_up(bp + 64))).Fbuf_size = Uint64FromInt64(64) - Uint64FromInt32(4) AtomicStorePInt32(bp+64+140, -int32(1)) - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fread = __ccgo_fp(_do_read) - for Xiswspace(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(t)))) != 0 { + (**(**TFILE)(__ccgo_up(bp + 64))).Fread = __ccgo_fp(_do_read) + for Xiswspace(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(t)))) != 0 { t += 4 } - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fcookie = t + (**(**TFILE)(__ccgo_up(bp + 64))).Fcookie = t X__shlim(tls, bp+64, int64(Int32FromInt32(0))) y = X__floatscan(tls, bp+64, prec, int32(1)) if p != 0 { @@ -144941,7 +144941,7 @@ func _wcstox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { } else { v1 = s } - *(*uintptr)(unsafe.Pointer(p)) = v1 + **(**uintptr)(__ccgo_up(p)) = v1 } return y } @@ -144980,20 +144980,20 @@ func _do_read1(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { var v2 int32 _, _, _, _, _ = i, wcs, v2, v3, v4 wcs = (*TFILE)(unsafe.Pointer(f)).Fcookie - if !(*(*Twchar_t)(unsafe.Pointer(wcs)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(wcs)) != 0) { wcs = __ccgo_ts + 1752 } i = uint64(0) for { - if !(i < (*TFILE)(unsafe.Pointer(f)).Fbuf_size && *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) != 0) { + if !(i < (*TFILE)(unsafe.Pointer(f)).Fbuf_size && **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) != 0) { break } - if *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) < int32(128) { - v2 = *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(i)*4)) + if **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) < int32(128) { + v2 = **(**Twchar_t)(__ccgo_up(wcs + uintptr(i)*4)) } else { v2 = int32('@') } - *(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(i))) = Uint8FromInt32(v2) + **(**uint8)(__ccgo_up((*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(i))) = Uint8FromInt32(v2) goto _1 _1: ; @@ -145006,7 +145006,7 @@ func _do_read1(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 - *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(buf)) = **(**uint8)(__ccgo_up(v3)) return uint64(1) } return uint64(0) @@ -145022,20 +145022,20 @@ func _wcstox1(tls *TLS, s uintptr, p uintptr, base int32, lim uint64) (r uint64) var _ /* f at bp+64 */ TFILE _, _, _, _, _ = cnt, t, y, v1, v2 t = s - *(*TFILE)(unsafe.Pointer(bp + 64)) = TFILE{} - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fflags = uint32(0) + **(**TFILE)(__ccgo_up(bp + 64)) = TFILE{} + (**(**TFILE)(__ccgo_up(bp + 64))).Fflags = uint32(0) v2 = bp + UintptrFromInt32(4) - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fbuf = v2 + (**(**TFILE)(__ccgo_up(bp + 64))).Fbuf = v2 v1 = v2 - (*(*TFILE)(unsafe.Pointer(bp + 64))).Frend = v1 - (*(*TFILE)(unsafe.Pointer(bp + 64))).Frpos = v1 - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fbuf_size = Uint64FromInt64(64) - Uint64FromInt32(4) + (**(**TFILE)(__ccgo_up(bp + 64))).Frend = v1 + (**(**TFILE)(__ccgo_up(bp + 64))).Frpos = v1 + (**(**TFILE)(__ccgo_up(bp + 64))).Fbuf_size = Uint64FromInt64(64) - Uint64FromInt32(4) AtomicStorePInt32(bp+64+140, -int32(1)) - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fread = __ccgo_fp(_do_read1) - for Xiswspace(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(t)))) != 0 { + (**(**TFILE)(__ccgo_up(bp + 64))).Fread = __ccgo_fp(_do_read1) + for Xiswspace(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(t)))) != 0 { t += 4 } - (*(*TFILE)(unsafe.Pointer(bp + 64))).Fcookie = t + (**(**TFILE)(__ccgo_up(bp + 64))).Fcookie = t X__shlim(tls, bp+64, int64(Int32FromInt32(0))) y = X__intscan(tls, bp+64, Uint32FromInt32(base), int32(1), lim) if p != 0 { @@ -145045,7 +145045,7 @@ func _wcstox1(tls *TLS, s uintptr, p uintptr, base int32, lim uint64) (r uint64) } else { v1 = s } - *(*uintptr)(unsafe.Pointer(p)) = v1 + **(**uintptr)(__ccgo_up(p)) = v1 } return y } @@ -145164,8 +145164,8 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt if uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) == uint64(d)&(Uint64FromInt64(8)-Uint64FromInt32(1)) { for { if v3 = uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) != 0 && n != 0; v3 { - v2 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v2 + v2 = **(**uint8)(__ccgo_up(s)) + **(**uint8)(__ccgo_up(d)) = v2 } if !(v3 && Int32FromUint8(v2) != c) { break @@ -145184,10 +145184,10 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt wd = d ws = s for { - if !(n >= uint64(8) && !((*(*uint64)(unsafe.Pointer(ws))^k-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^(*(*uint64)(unsafe.Pointer(ws))^k) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { + if !(n >= uint64(8) && !((**(**uint64)(__ccgo_up(ws))^k-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^(**(**uint64)(__ccgo_up(ws))^k) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { break } - *(*uint64)(unsafe.Pointer(wd)) = *(*uint64)(unsafe.Pointer(ws)) + **(**uint64)(__ccgo_up(wd)) = **(**uint64)(__ccgo_up(ws)) goto _4 _4: ; @@ -145200,8 +145200,8 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt } for { if v3 = n != 0; v3 { - v2 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v2 + v2 = **(**uint8)(__ccgo_up(s)) + **(**uint8)(__ccgo_up(d)) = v2 } if !(v3 && Int32FromUint8(v2) != c) { break @@ -145244,7 +145244,7 @@ func Xmemchr(tls *TLS, src uintptr, c int32, n Tsize_t) (r uintptr) { s = src c = Int32FromUint8(Uint8FromInt32(c)) for { - if !(uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) != 0 && n != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != c) { + if !(uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) != 0 && n != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != c) { break } goto _1 @@ -145253,11 +145253,11 @@ func Xmemchr(tls *TLS, src uintptr, c int32, n Tsize_t) (r uintptr) { s = s + 1 n = n - 1 } - if n != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != c { + if n != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != c { k = Uint64FromInt32(-Int32FromInt32(1)) / Uint64FromInt32(UCHAR_MAX) * Uint64FromInt32(c) w = s for { - if !(n >= Uint64FromInt64(8) && !((*(*uint64)(unsafe.Pointer(w))^k-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^(*(*uint64)(unsafe.Pointer(w))^k) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { + if !(n >= Uint64FromInt64(8) && !((**(**uint64)(__ccgo_up(w))^k-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^(**(**uint64)(__ccgo_up(w))^k) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { break } goto _2 @@ -145269,7 +145269,7 @@ func Xmemchr(tls *TLS, src uintptr, c int32, n Tsize_t) (r uintptr) { s = w } for { - if !(n != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != c) { + if !(n != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != c) { break } goto _3 @@ -145297,7 +145297,7 @@ func Xmemcmp(tls *TLS, vl uintptr, vr uintptr, n Tsize_t) (r1 int32) { l = vl r = vr for { - if !(n != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))) { + if !(n != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(l))) == Int32FromUint8(**(**uint8)(__ccgo_up(r)))) { break } goto _1 @@ -145308,7 +145308,7 @@ func Xmemcmp(tls *TLS, vl uintptr, vr uintptr, n Tsize_t) (r1 int32) { r = r + 1 } if n != 0 { - v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) + v2 = Int32FromUint8(**(**uint8)(__ccgo_up(l))) - Int32FromUint8(**(**uint8)(__ccgo_up(r))) } else { v2 = 0 } @@ -145336,7 +145336,7 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) goto _1 _1: ; @@ -145347,10 +145347,10 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { if !(n >= uint64(16)) { break } - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(0))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(4))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(4))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(8))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(8))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(12))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(12))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(0))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(0))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(4))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(4))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(8))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(8))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(12))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(12))) goto _4 _4: ; @@ -145359,13 +145359,13 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { n = n - uint64(16) } if n&uint64(8) != 0 { - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(0))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(4))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(4))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(0))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(0))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(4))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(4))) d = d + uintptr(8) s = s + uintptr(8) } if n&uint64(4) != 0 { - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(0))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(0))) = **(**uint32)(__ccgo_up(s + UintptrFromInt32(0))) d = d + uintptr(4) s = s + uintptr(4) } @@ -145374,50 +145374,50 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) } if n&uint64(1) != 0 { - *(*uint8)(unsafe.Pointer(d)) = *(*uint8)(unsafe.Pointer(s)) + **(**uint8)(__ccgo_up(d)) = **(**uint8)(__ccgo_up(s)) } return dest } if n >= uint64(32) { switch uint64(d) % Uint64FromInt32(4) { case uint64(1): - w = *(*uint32)(unsafe.Pointer(s)) + w = **(**uint32)(__ccgo_up(s)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) n = n - uint64(3) for { if !(n >= uint64(17)) { break } - x = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(1))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = w<>Int32FromInt32(8) - w = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(5))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(4))) = x<>Int32FromInt32(8) - x = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(9))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(8))) = w<>Int32FromInt32(8) - w = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(13))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(12))) = x<>Int32FromInt32(8) + x = **(**uint32)(__ccgo_up(s + UintptrFromInt32(1))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(0))) = w<>Int32FromInt32(8) + w = **(**uint32)(__ccgo_up(s + UintptrFromInt32(5))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(4))) = x<>Int32FromInt32(8) + x = **(**uint32)(__ccgo_up(s + UintptrFromInt32(9))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(8))) = w<>Int32FromInt32(8) + w = **(**uint32)(__ccgo_up(s + UintptrFromInt32(13))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(12))) = x<>Int32FromInt32(8) goto _15 _15: ; @@ -145426,30 +145426,30 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { n = n - uint64(16) } case uint64(2): - w = *(*uint32)(unsafe.Pointer(s)) + w = **(**uint32)(__ccgo_up(s)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) n = n - uint64(2) for { if !(n >= uint64(18)) { break } - x = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(2))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = w<>Int32FromInt32(16) - w = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(6))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(4))) = x<>Int32FromInt32(16) - x = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(10))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(8))) = w<>Int32FromInt32(16) - w = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(14))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(12))) = x<>Int32FromInt32(16) + x = **(**uint32)(__ccgo_up(s + UintptrFromInt32(2))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(0))) = w<>Int32FromInt32(16) + w = **(**uint32)(__ccgo_up(s + UintptrFromInt32(6))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(4))) = x<>Int32FromInt32(16) + x = **(**uint32)(__ccgo_up(s + UintptrFromInt32(10))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(8))) = w<>Int32FromInt32(16) + w = **(**uint32)(__ccgo_up(s + UintptrFromInt32(14))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(12))) = x<>Int32FromInt32(16) goto _20 _20: ; @@ -145458,25 +145458,25 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { n = n - uint64(16) } case uint64(3): - w = *(*uint32)(unsafe.Pointer(s)) + w = **(**uint32)(__ccgo_up(s)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) n = n - uint64(1) for { if !(n >= uint64(19)) { break } - x = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(3))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = w<>Int32FromInt32(24) - w = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(7))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(4))) = x<>Int32FromInt32(24) - x = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(11))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(8))) = w<>Int32FromInt32(24) - w = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(15))) - *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(12))) = x<>Int32FromInt32(24) + x = **(**uint32)(__ccgo_up(s + UintptrFromInt32(3))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(0))) = w<>Int32FromInt32(24) + w = **(**uint32)(__ccgo_up(s + UintptrFromInt32(7))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(4))) = x<>Int32FromInt32(24) + x = **(**uint32)(__ccgo_up(s + UintptrFromInt32(11))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(8))) = w<>Int32FromInt32(24) + w = **(**uint32)(__ccgo_up(s + UintptrFromInt32(15))) + **(**uint32)(__ccgo_up(d + UintptrFromInt32(12))) = x<>Int32FromInt32(24) goto _23 _23: ; @@ -145492,161 +145492,161 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) } if n&uint64(8) != 0 { v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) } if n&uint64(4) != 0 { v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) } if n&uint64(2) != 0 { v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) v2 = d d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) } if n&uint64(1) != 0 { - *(*uint8)(unsafe.Pointer(d)) = *(*uint8)(unsafe.Pointer(s)) + **(**uint8)(__ccgo_up(d)) = **(**uint8)(__ccgo_up(s)) } return dest for { @@ -145657,7 +145657,7 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) goto _84 _84: ; @@ -145670,8 +145670,8 @@ func _twobyte_memmem(tls *TLS, h uintptr, k Tsize_t, n uintptr) (r uintptr) { var hw, nw Tuint16_t var v2 uintptr _, _, _ = hw, nw, v2 - nw = Uint16FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(n)))< Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(ip+k)))) > Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(jp+k)))) { jp = jp + k k = uint64(1) p = jp - ip @@ -145819,7 +145819,7 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin p = v2 k = v2 for jp+k < l { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(ip+k)))) == Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(jp+k)))) { if k == p { jp = jp + p k = uint64(1) @@ -145827,7 +145827,7 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin k = k + 1 } } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) < Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(ip+k)))) < Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(jp+k)))) { jp = jp + k k = uint64(1) p = jp - ip @@ -145866,8 +145866,8 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin return uintptr(0) } /* Check last byte first; advance by shift on mismatch */ - if (*(*[4]Tsize_t)(unsafe.Pointer(bp)))[uint64(*(*uint8)(unsafe.Pointer(h + uintptr(l-uint64(1)))))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(*(*uint8)(unsafe.Pointer(h + uintptr(l-uint64(1)))))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0 { - k = l - shift[*(*uint8)(unsafe.Pointer(h + uintptr(l-uint64(1))))] + if (**(**[4]Tsize_t)(__ccgo_up(bp)))[uint64(**(**uint8)(__ccgo_up(h + uintptr(l-uint64(1)))))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(**(**uint8)(__ccgo_up(h + uintptr(l-uint64(1)))))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0 { + k = l - shift[**(**uint8)(__ccgo_up(h + uintptr(l-uint64(1))))] if k != 0 { if k < mem { k = mem @@ -145889,7 +145889,7 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin } k = v8 for { - if !(k < l && Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(h + uintptr(k))))) { + if !(k < l && Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(k)))) == Int32FromUint8(**(**uint8)(__ccgo_up(h + uintptr(k))))) { break } goto _10 @@ -145905,7 +145905,7 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin /* Compare left half */ k = ms + uint64(1) for { - if !(k > mem && Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(k-uint64(1))))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(h + uintptr(k-uint64(1)))))) { + if !(k > mem && Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(k-uint64(1))))) == Int32FromUint8(**(**uint8)(__ccgo_up(h + uintptr(k-uint64(1)))))) { break } goto _12 @@ -145942,7 +145942,7 @@ func Xmemmem(tls *TLS, h0 uintptr, k Tsize_t, n0 uintptr, l Tsize_t) (r uintptr) return uintptr(0) } /* Use faster algorithms for short needles */ - h = Xmemchr(tls, h0, Int32FromUint8(*(*uint8)(unsafe.Pointer(n))), k) + h = Xmemchr(tls, h0, Int32FromUint8(**(**uint8)(__ccgo_up(n))), k) if !(h != 0) || l == uint64(1) { return h } @@ -145994,13 +145994,13 @@ func Xmemmove(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) } for { if !(n >= Uint64FromInt64(8)) { break } - *(*TWT)(unsafe.Pointer(d)) = *(*TWT)(unsafe.Pointer(s)) + **(**TWT)(__ccgo_up(d)) = **(**TWT)(__ccgo_up(s)) goto _4 _4: ; @@ -146017,7 +146017,7 @@ func Xmemmove(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { d = d + 1 v3 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + **(**uint8)(__ccgo_up(v2)) = **(**uint8)(__ccgo_up(v3)) goto _5 _5: ; @@ -146031,16 +146031,16 @@ func Xmemmove(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { if !(v1 != 0) { return dest } - *(*uint8)(unsafe.Pointer(d + uintptr(n))) = *(*uint8)(unsafe.Pointer(s + uintptr(n))) + **(**uint8)(__ccgo_up(d + uintptr(n))) = **(**uint8)(__ccgo_up(s + uintptr(n))) } for n >= Uint64FromInt64(8) { n = n - Uint64FromInt64(8) - *(*TWT)(unsafe.Pointer(d + uintptr(n))) = *(*TWT)(unsafe.Pointer(s + uintptr(n))) + **(**TWT)(__ccgo_up(d + uintptr(n))) = **(**TWT)(__ccgo_up(s + uintptr(n))) } } for n != 0 { n = n - 1 - *(*uint8)(unsafe.Pointer(d + uintptr(n))) = *(*uint8)(unsafe.Pointer(s + uintptr(n))) + **(**uint8)(__ccgo_up(d + uintptr(n))) = **(**uint8)(__ccgo_up(s + uintptr(n))) } } return dest @@ -146070,7 +146070,7 @@ func X__memrchr(tls *TLS, m uintptr, c int32, n Tsize_t) (r uintptr) { if !(v1 != 0) { break } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(n)))) == c { + if Int32FromUint8(**(**uint8)(__ccgo_up(s + uintptr(n)))) == c { return s + uintptr(n) } } @@ -146102,20 +146102,20 @@ func Xmemset(tls *TLS, dest uintptr, c int32, n Tsize_t) (r uintptr) { if !(n != 0) { return dest } - *(*uint8)(unsafe.Pointer(s)) = Uint8FromInt32(c) - *(*uint8)(unsafe.Pointer(s + uintptr(n-uint64(1)))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s)) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + uintptr(n-uint64(1)))) = Uint8FromInt32(c) if n <= uint64(2) { return dest } - *(*uint8)(unsafe.Pointer(s + 1)) = Uint8FromInt32(c) - *(*uint8)(unsafe.Pointer(s + 2)) = Uint8FromInt32(c) - *(*uint8)(unsafe.Pointer(s + uintptr(n-uint64(2)))) = Uint8FromInt32(c) - *(*uint8)(unsafe.Pointer(s + uintptr(n-uint64(3)))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + 1)) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + 2)) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + uintptr(n-uint64(2)))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + uintptr(n-uint64(3)))) = Uint8FromInt32(c) if n <= uint64(6) { return dest } - *(*uint8)(unsafe.Pointer(s + 3)) = Uint8FromInt32(c) - *(*uint8)(unsafe.Pointer(s + uintptr(n-uint64(4)))) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + 3)) = Uint8FromInt32(c) + **(**uint8)(__ccgo_up(s + uintptr(n-uint64(4)))) = Uint8FromInt32(c) if n <= uint64(8) { return dest } @@ -146133,26 +146133,26 @@ func Xmemset(tls *TLS, dest uintptr, c int32, n Tsize_t) (r uintptr) { * As in the initial byte-based head/tail fill, each * conditional below ensures that the subsequent offsets * are valid (e.g. !(n<=24) implies n>=28). */ - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(0))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(4))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(0))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(4))) = c32 if n <= uint64(8) { return dest } - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(4))) = c32 - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(8))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(12))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(8))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(4))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(8))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(12))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(8))) = c32 if n <= uint64(24) { return dest } - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(12))) = c32 - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(16))) = c32 - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(20))) = c32 - *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(24))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(28))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(24))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(20))) = c32 - *(*uint32)(unsafe.Pointer(s + uintptr(n) - UintptrFromInt32(16))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(12))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(16))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(20))) = c32 + **(**uint32)(__ccgo_up(s + UintptrFromInt32(24))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(28))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(24))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(20))) = c32 + **(**uint32)(__ccgo_up(s + uintptr(n) - UintptrFromInt32(16))) = c32 /* Align to a multiple of 8 so we can fill 64 bits at a time, * and avoid writing the same bytes twice as much as is * practical without introducing additional branching. */ @@ -146167,10 +146167,10 @@ func Xmemset(tls *TLS, dest uintptr, c int32, n Tsize_t) (r uintptr) { if !(n >= uint64(32)) { break } - *(*uint64)(unsafe.Pointer(s + UintptrFromInt32(0))) = c64 - *(*uint64)(unsafe.Pointer(s + UintptrFromInt32(8))) = c64 - *(*uint64)(unsafe.Pointer(s + UintptrFromInt32(16))) = c64 - *(*uint64)(unsafe.Pointer(s + UintptrFromInt32(24))) = c64 + **(**uint64)(__ccgo_up(s + UintptrFromInt32(0))) = c64 + **(**uint64)(__ccgo_up(s + UintptrFromInt32(8))) = c64 + **(**uint64)(__ccgo_up(s + UintptrFromInt32(16))) = c64 + **(**uint64)(__ccgo_up(s + UintptrFromInt32(24))) = c64 goto _1 _1: ; @@ -146212,8 +146212,8 @@ func X__stpcpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { if !(uint64(s)%Uint64FromInt64(8) != 0) { break } - v2 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v2 + v2 = **(**uint8)(__ccgo_up(s)) + **(**uint8)(__ccgo_up(d)) = v2 if !(v2 != 0) { return d } @@ -146226,7 +146226,7 @@ func X__stpcpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { wd = d ws = s for { - if !!((*(*uint64)(unsafe.Pointer(ws))-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^*(*uint64)(unsafe.Pointer(ws)) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0) { + if !!((**(**uint64)(__ccgo_up(ws))-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^**(**uint64)(__ccgo_up(ws)) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0) { break } goto _3 @@ -146236,14 +146236,14 @@ func X__stpcpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { wd += 8 v5 = ws ws += 8 - *(*uint64)(unsafe.Pointer(v4)) = *(*uint64)(unsafe.Pointer(v5)) + **(**uint64)(__ccgo_up(v4)) = **(**uint64)(__ccgo_up(v5)) } d = wd s = ws } for { - v2 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v2 + v2 = **(**uint8)(__ccgo_up(s)) + **(**uint8)(__ccgo_up(d)) = v2 if !(v2 != 0) { break } @@ -146296,8 +146296,8 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { if uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) == uint64(d)&(Uint64FromInt64(8)-Uint64FromInt32(1)) { for { if v3 = uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) != 0 && n != 0; v3 { - v2 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v2 + v2 = **(**uint8)(__ccgo_up(s)) + **(**uint8)(__ccgo_up(d)) = v2 } if !(v3 && v2 != 0) { break @@ -146309,16 +146309,16 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { s = s + 1 d = d + 1 } - if !(n != 0) || !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(n != 0) || !(**(**uint8)(__ccgo_up(s)) != 0) { goto tail } wd = d ws = s for { - if !(n >= uint64(8) && !((*(*uint64)(unsafe.Pointer(ws))-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^*(*uint64)(unsafe.Pointer(ws)) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { + if !(n >= uint64(8) && !((**(**uint64)(__ccgo_up(ws))-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^**(**uint64)(__ccgo_up(ws)) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { break } - *(*uint64)(unsafe.Pointer(wd)) = *(*uint64)(unsafe.Pointer(ws)) + **(**uint64)(__ccgo_up(wd)) = **(**uint64)(__ccgo_up(ws)) goto _4 _4: ; @@ -146331,8 +146331,8 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { } for { if v3 = n != 0; v3 { - v2 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v2 + v2 = **(**uint8)(__ccgo_up(s)) + **(**uint8)(__ccgo_up(d)) = v2 } if !(v3 && v2 != 0) { break @@ -146378,7 +146378,7 @@ func Xstrcasecmp(tls *TLS, _l uintptr, _r uintptr) (r1 int32) { l = _l r = _r for { - if !(*(*uint8)(unsafe.Pointer(l)) != 0 && *(*uint8)(unsafe.Pointer(r)) != 0 && (Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) || Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(l)))) == Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))))) { + if !(**(**uint8)(__ccgo_up(l)) != 0 && **(**uint8)(__ccgo_up(r)) != 0 && (Int32FromUint8(**(**uint8)(__ccgo_up(l))) == Int32FromUint8(**(**uint8)(__ccgo_up(r))) || Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(l)))) == Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(r)))))) { break } goto _1 @@ -146387,7 +146387,7 @@ func Xstrcasecmp(tls *TLS, _l uintptr, _r uintptr) (r1 int32) { l = l + 1 r = r + 1 } - return Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(l)))) - Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))) + return Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(l)))) - Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(r)))) } func X__strcasecmp_l(tls *TLS, l uintptr, r uintptr, loc Tlocale_t) (r1 int32) { @@ -146415,7 +146415,7 @@ func Xstrcasestr(tls *TLS, h uintptr, n uintptr) (r uintptr) { _ = l l = _strlen(tls, n) for { - if !(*(*uint8)(unsafe.Pointer(h)) != 0) { + if !(**(**uint8)(__ccgo_up(h)) != 0) { break } if !(Xstrncasecmp(tls, h, n, l) != 0) { @@ -146446,7 +146446,7 @@ func Xstrchr(tls *TLS, s uintptr, c int32) (r1 uintptr) { var r, v1 uintptr _, _ = r, v1 r = X__strchrnul(tls, s, c) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) == Int32FromUint8(Uint8FromInt32(c)) { + if Int32FromUint8(**(**uint8)(__ccgo_up(r))) == Int32FromUint8(Uint8FromInt32(c)) { v1 = r } else { v1 = uintptr(0) @@ -146481,7 +146481,7 @@ func X__strchrnul(tls *TLS, s uintptr, c int32) (r uintptr) { if !(uint64(s)%Uint64FromInt64(8) != 0) { break } - if !(*(*uint8)(unsafe.Pointer(s)) != 0) || Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == c { + if !(**(**uint8)(__ccgo_up(s)) != 0) || Int32FromUint8(**(**uint8)(__ccgo_up(s))) == c { return s } goto _1 @@ -146492,7 +146492,7 @@ func X__strchrnul(tls *TLS, s uintptr, c int32) (r uintptr) { k = Uint64FromInt32(-Int32FromInt32(1)) / Uint64FromInt32(UCHAR_MAX) * Uint64FromInt32(c) w = s for { - if !(!((*(*uint64)(unsafe.Pointer(w))-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^*(*uint64)(unsafe.Pointer(w)) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0) && !((*(*uint64)(unsafe.Pointer(w))^k-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^(*(*uint64)(unsafe.Pointer(w))^k) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { + if !(!((**(**uint64)(__ccgo_up(w))-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^**(**uint64)(__ccgo_up(w)) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0) && !((**(**uint64)(__ccgo_up(w))^k-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^(**(**uint64)(__ccgo_up(w))^k) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { break } goto _2 @@ -146502,7 +146502,7 @@ func X__strchrnul(tls *TLS, s uintptr, c int32) (r uintptr) { } s = w for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != c) { + if !(**(**uint8)(__ccgo_up(s)) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(s))) != c) { break } goto _3 @@ -146536,7 +146536,7 @@ func Xstrcmp(tls *TLS, l uintptr, r uintptr) (r1 int32) { defer func() { trc("-> %v", r1) }() } for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) && *(*uint8)(unsafe.Pointer(l)) != 0) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(l))) == Int32FromUint8(**(**uint8)(__ccgo_up(r))) && **(**uint8)(__ccgo_up(l)) != 0) { break } goto _1 @@ -146545,7 +146545,7 @@ func Xstrcmp(tls *TLS, l uintptr, r uintptr) (r1 int32) { l = l + 1 r = r + 1 } - return Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) + return Int32FromUint8(**(**uint8)(__ccgo_up(l))) - Int32FromUint8(**(**uint8)(__ccgo_up(r))) } func Xstrcpy(tls *TLS, dest uintptr, src uintptr) (r uintptr) { @@ -146569,14 +146569,14 @@ func Xstrcspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { var _ /* byteset at bp+0 */ [4]Tsize_t _, _, _ = a, v2, v3 a = s - if !(*(*uint8)(unsafe.Pointer(c)) != 0) || !(*(*uint8)(unsafe.Pointer(c + 1)) != 0) { - return Uint64FromInt64(int64(X__strchrnul(tls, s, Int32FromUint8(*(*uint8)(unsafe.Pointer(c))))) - int64(a)) + if !(**(**uint8)(__ccgo_up(c)) != 0) || !(**(**uint8)(__ccgo_up(c + 1)) != 0) { + return Uint64FromInt64(int64(X__strchrnul(tls, s, Int32FromUint8(**(**uint8)(__ccgo_up(c))))) - int64(a)) } Xmemset(tls, bp, 0, uint64(32)) for { - if v3 = *(*uint8)(unsafe.Pointer(c)) != 0; v3 { - v2 = bp + uintptr(uint64(*(*uint8)(unsafe.Pointer(c)))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 - *(*Tsize_t)(unsafe.Pointer(v2)) |= Uint64FromInt32(1) << (uint64(*(*uint8)(unsafe.Pointer(c))) % (Uint64FromInt32(8) * Uint64FromInt64(8))) + if v3 = **(**uint8)(__ccgo_up(c)) != 0; v3 { + v2 = bp + uintptr(uint64(**(**uint8)(__ccgo_up(c)))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 + *(*Tsize_t)(unsafe.Pointer(v2)) |= Uint64FromInt32(1) << (uint64(**(**uint8)(__ccgo_up(c))) % (Uint64FromInt32(8) * Uint64FromInt64(8))) } if !(v3 && *(*Tsize_t)(unsafe.Pointer(v2)) != 0) { break @@ -146587,7 +146587,7 @@ func Xstrcspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { c = c + 1 } for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0 && !((*(*[4]Tsize_t)(unsafe.Pointer(bp)))[uint64(*(*uint8)(unsafe.Pointer(s)))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(*(*uint8)(unsafe.Pointer(s)))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0)) { + if !(**(**uint8)(__ccgo_up(s)) != 0 && !((**(**[4]Tsize_t)(__ccgo_up(bp)))[uint64(**(**uint8)(__ccgo_up(s)))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(**(**uint8)(__ccgo_up(s)))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0)) { break } goto _4 @@ -146627,7 +146627,7 @@ func Xstrerror_r(tls *TLS, err int32, buf uintptr, buflen Tsize_t) (r int32) { if l >= buflen { if buflen != 0 { Xmemcpy(tls, buf, msg, buflen-uint64(1)) - *(*uint8)(unsafe.Pointer(buf + uintptr(buflen-uint64(1)))) = uint8(0) + **(**uint8)(__ccgo_up(buf + uintptr(buflen-uint64(1)))) = uint8(0) } return int32(ERANGE) } @@ -146687,8 +146687,8 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { if uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) == uint64(d)&(Uint64FromInt64(8)-Uint64FromInt32(1)) { for { if v4 = uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) != 0 && n != 0; v4 { - v3 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v3 + v3 = **(**uint8)(__ccgo_up(s)) + **(**uint8)(__ccgo_up(d)) = v3 } if !(v4 && v3 != 0) { break @@ -146700,14 +146700,14 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { s = s + 1 d = d + 1 } - if n != 0 && *(*uint8)(unsafe.Pointer(s)) != 0 { + if n != 0 && **(**uint8)(__ccgo_up(s)) != 0 { wd = d ws = s for { - if !(n >= uint64(8) && !((*(*uint64)(unsafe.Pointer(ws))-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^*(*uint64)(unsafe.Pointer(ws)) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { + if !(n >= uint64(8) && !((**(**uint64)(__ccgo_up(ws))-Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)) & ^**(**uint64)(__ccgo_up(ws)) & (Uint64FromInt32(-Int32FromInt32(1))/Uint64FromInt32(UCHAR_MAX)*Uint64FromInt32(Int32FromInt32(UCHAR_MAX)/Int32FromInt32(2)+Int32FromInt32(1))) != 0)) { break } - *(*Tsize_t)(unsafe.Pointer(wd)) = *(*uint64)(unsafe.Pointer(ws)) + **(**Tsize_t)(__ccgo_up(wd)) = **(**uint64)(__ccgo_up(ws)) goto _5 _5: ; @@ -146721,8 +146721,8 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { } for { if v4 = n != 0; v4 { - v3 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v3 + v3 = **(**uint8)(__ccgo_up(s)) + **(**uint8)(__ccgo_up(d)) = v3 } if !(v4 && v3 != 0) { break @@ -146734,7 +146734,7 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { s = s + 1 d = d + 1 } - *(*uint8)(unsafe.Pointer(d)) = uint8(0) + **(**uint8)(__ccgo_up(d)) = uint8(0) goto finish finish: ; @@ -146760,7 +146760,7 @@ func Xstrncasecmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { return 0 } for { - if !(*(*uint8)(unsafe.Pointer(l)) != 0 && *(*uint8)(unsafe.Pointer(r)) != 0 && n != 0 && (Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) || Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(l)))) == Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))))) { + if !(**(**uint8)(__ccgo_up(l)) != 0 && **(**uint8)(__ccgo_up(r)) != 0 && n != 0 && (Int32FromUint8(**(**uint8)(__ccgo_up(l))) == Int32FromUint8(**(**uint8)(__ccgo_up(r))) || Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(l)))) == Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(r)))))) { break } goto _2 @@ -146770,7 +146770,7 @@ func Xstrncasecmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { r = r + 1 n = n - 1 } - return Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(l)))) - Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))) + return Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(l)))) - Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(r)))) } func X__strncasecmp_l(tls *TLS, l uintptr, r uintptr, n Tsize_t, loc Tlocale_t) (r1 int32) { @@ -146798,17 +146798,17 @@ func Xstrncat(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { _, _, _ = a, v1, v2 a = d d = d + uintptr(_strlen(tls, d)) - for n != 0 && *(*uint8)(unsafe.Pointer(s)) != 0 { + for n != 0 && **(**uint8)(__ccgo_up(s)) != 0 { n = n - 1 v1 = d d = d + 1 v2 = s s = s + 1 - *(*uint8)(unsafe.Pointer(v1)) = *(*uint8)(unsafe.Pointer(v2)) + **(**uint8)(__ccgo_up(v1)) = **(**uint8)(__ccgo_up(v2)) } v1 = d d = d + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) return a } @@ -146828,7 +146828,7 @@ func Xstrncmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { return 0 } for { - if !(*(*uint8)(unsafe.Pointer(l)) != 0 && *(*uint8)(unsafe.Pointer(r)) != 0 && n != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))) { + if !(**(**uint8)(__ccgo_up(l)) != 0 && **(**uint8)(__ccgo_up(r)) != 0 && n != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(l))) == Int32FromUint8(**(**uint8)(__ccgo_up(r)))) { break } goto _2 @@ -146838,7 +146838,7 @@ func Xstrncmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { r = r + 1 n = n - 1 } - return Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) + return Int32FromUint8(**(**uint8)(__ccgo_up(l))) - Int32FromUint8(**(**uint8)(__ccgo_up(r))) } func Xstrncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { @@ -146864,7 +146864,7 @@ func Xstrndup(tls *TLS, s uintptr, n Tsize_t) (r uintptr) { return UintptrFromInt32(0) } Xmemcpy(tls, d, s, l) - *(*uint8)(unsafe.Pointer(d + uintptr(l))) = uint8(0) + **(**uint8)(__ccgo_up(d + uintptr(l))) = uint8(0) return d } @@ -146893,7 +146893,7 @@ func Xstrpbrk(tls *TLS, s uintptr, b uintptr) (r uintptr) { var v1 uintptr _ = v1 s = s + uintptr(Xstrcspn(tls, s, b)) - if *(*uint8)(unsafe.Pointer(s)) != 0 { + if **(**uint8)(__ccgo_up(s)) != 0 { v1 = s } else { v1 = uintptr(0) @@ -146916,19 +146916,19 @@ func Xstrsep(tls *TLS, str uintptr, sep uintptr) (r uintptr) { } var end, s, v1 uintptr _, _, _ = end, s, v1 - s = *(*uintptr)(unsafe.Pointer(str)) + s = **(**uintptr)(__ccgo_up(str)) if !(s != 0) { return UintptrFromInt32(0) } end = s + uintptr(Xstrcspn(tls, s, sep)) - if *(*uint8)(unsafe.Pointer(end)) != 0 { + if **(**uint8)(__ccgo_up(end)) != 0 { v1 = end end = end + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) } else { end = uintptr(0) } - *(*uintptr)(unsafe.Pointer(str)) = end + **(**uintptr)(__ccgo_up(str)) = end return s } @@ -146954,7 +146954,7 @@ func Xstrsignal(tls *TLS, signum int32) (r uintptr) { break } for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { break } goto _3 @@ -146982,13 +146982,13 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { var _ /* byteset at bp+0 */ [4]Tsize_t _, _, _ = a, v3, v4 a = s - *(*[4]Tsize_t)(unsafe.Pointer(bp)) = [4]Tsize_t{} - if !(*(*uint8)(unsafe.Pointer(c)) != 0) { + **(**[4]Tsize_t)(__ccgo_up(bp)) = [4]Tsize_t{} + if !(**(**uint8)(__ccgo_up(c)) != 0) { return uint64(0) } - if !(*(*uint8)(unsafe.Pointer(c + 1)) != 0) { + if !(**(**uint8)(__ccgo_up(c + 1)) != 0) { for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(c)))) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(s))) == Int32FromUint8(**(**uint8)(__ccgo_up(c)))) { break } goto _1 @@ -146999,9 +146999,9 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { return Uint64FromInt64(int64(s) - int64(a)) } for { - if v4 = *(*uint8)(unsafe.Pointer(c)) != 0; v4 { - v3 = bp + uintptr(uint64(*(*uint8)(unsafe.Pointer(c)))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 - *(*Tsize_t)(unsafe.Pointer(v3)) |= Uint64FromInt32(1) << (uint64(*(*uint8)(unsafe.Pointer(c))) % (Uint64FromInt32(8) * Uint64FromInt64(8))) + if v4 = **(**uint8)(__ccgo_up(c)) != 0; v4 { + v3 = bp + uintptr(uint64(**(**uint8)(__ccgo_up(c)))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 + *(*Tsize_t)(unsafe.Pointer(v3)) |= Uint64FromInt32(1) << (uint64(**(**uint8)(__ccgo_up(c))) % (Uint64FromInt32(8) * Uint64FromInt64(8))) } if !(v4 && *(*Tsize_t)(unsafe.Pointer(v3)) != 0) { break @@ -147012,7 +147012,7 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { c = c + 1 } for { - if !(*(*uint8)(unsafe.Pointer(s)) != 0 && (*(*[4]Tsize_t)(unsafe.Pointer(bp)))[uint64(*(*uint8)(unsafe.Pointer(s)))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(*(*uint8)(unsafe.Pointer(s)))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0 && (**(**[4]Tsize_t)(__ccgo_up(bp)))[uint64(**(**uint8)(__ccgo_up(s)))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(**(**uint8)(__ccgo_up(s)))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0) { break } goto _5 @@ -147027,11 +147027,11 @@ func _twobyte_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { var hw, nw Tuint16_t var v2 uintptr _, _, _ = hw, nw, v2 - nw = Uint16FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(n)))< Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(ip+k)))) > Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(jp+k)))) { jp = jp + k k = uint64(1) p = jp - ip @@ -147165,7 +147165,7 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { p = v2 k = v2 for jp+k < l { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(ip+k)))) == Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(jp+k)))) { if k == p { jp = jp + p k = uint64(1) @@ -147173,7 +147173,7 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { k = k + 1 } } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) < Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(ip+k)))) < Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(jp+k)))) { jp = jp + k k = uint64(1) p = jp - ip @@ -147224,8 +147224,8 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { } } /* Check last byte first; advance by shift on mismatch */ - if (*(*[4]Tsize_t)(unsafe.Pointer(bp)))[uint64(*(*uint8)(unsafe.Pointer(h + uintptr(l-uint64(1)))))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(*(*uint8)(unsafe.Pointer(h + uintptr(l-uint64(1)))))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0 { - k = l - shift[*(*uint8)(unsafe.Pointer(h + uintptr(l-uint64(1))))] + if (**(**[4]Tsize_t)(__ccgo_up(bp)))[uint64(**(**uint8)(__ccgo_up(h + uintptr(l-uint64(1)))))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(**(**uint8)(__ccgo_up(h + uintptr(l-uint64(1)))))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0 { + k = l - shift[**(**uint8)(__ccgo_up(h + uintptr(l-uint64(1))))] if k != 0 { if k < mem { k = mem @@ -147247,7 +147247,7 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { } k = v8 for { - if !(*(*uint8)(unsafe.Pointer(n + uintptr(k))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(h + uintptr(k))))) { + if !(**(**uint8)(__ccgo_up(n + uintptr(k))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(k)))) == Int32FromUint8(**(**uint8)(__ccgo_up(h + uintptr(k))))) { break } goto _10 @@ -147255,7 +147255,7 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { ; k = k + 1 } - if *(*uint8)(unsafe.Pointer(n + uintptr(k))) != 0 { + if **(**uint8)(__ccgo_up(n + uintptr(k))) != 0 { h = h + uintptr(k-ms) mem = uint64(0) goto _9 @@ -147263,7 +147263,7 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { /* Compare left half */ k = ms + uint64(1) for { - if !(k > mem && Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(k-uint64(1))))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(h + uintptr(k-uint64(1)))))) { + if !(k > mem && Int32FromUint8(**(**uint8)(__ccgo_up(n + uintptr(k-uint64(1))))) == Int32FromUint8(**(**uint8)(__ccgo_up(h + uintptr(k-uint64(1)))))) { break } goto _12 @@ -147288,30 +147288,30 @@ func Xstrstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { defer func() { trc("-> %v", r) }() } /* Return immediately on empty needle */ - if !(*(*uint8)(unsafe.Pointer(n)) != 0) { + if !(**(**uint8)(__ccgo_up(n)) != 0) { return h } /* Use faster algorithms for short needles */ - h = Xstrchr(tls, h, Int32FromUint8(*(*uint8)(unsafe.Pointer(n)))) - if !(h != 0) || !(*(*uint8)(unsafe.Pointer(n + 1)) != 0) { + h = Xstrchr(tls, h, Int32FromUint8(**(**uint8)(__ccgo_up(n)))) + if !(h != 0) || !(**(**uint8)(__ccgo_up(n + 1)) != 0) { return h } - if !(*(*uint8)(unsafe.Pointer(h + 1)) != 0) { + if !(**(**uint8)(__ccgo_up(h + 1)) != 0) { return uintptr(0) } - if !(*(*uint8)(unsafe.Pointer(n + 2)) != 0) { + if !(**(**uint8)(__ccgo_up(n + 2)) != 0) { return _twobyte_strstr(tls, h, n) } - if !(*(*uint8)(unsafe.Pointer(h + 2)) != 0) { + if !(**(**uint8)(__ccgo_up(h + 2)) != 0) { return uintptr(0) } - if !(*(*uint8)(unsafe.Pointer(n + 3)) != 0) { + if !(**(**uint8)(__ccgo_up(n + 3)) != 0) { return _threebyte_strstr(tls, h, n) } - if !(*(*uint8)(unsafe.Pointer(h + 3)) != 0) { + if !(**(**uint8)(__ccgo_up(h + 3)) != 0) { return uintptr(0) } - if !(*(*uint8)(unsafe.Pointer(n + 4)) != 0) { + if !(**(**uint8)(__ccgo_up(n + 4)) != 0) { return _fourbyte_strstr(tls, h, n) } return _twoway_strstr(tls, h, n) @@ -147333,16 +147333,16 @@ func Xstrtok(tls *TLS, s uintptr, sep uintptr) (r uintptr) { return UintptrFromInt32(0) } s = s + uintptr(Xstrspn(tls, s, sep)) - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { v1 = UintptrFromInt32(0) _p2 = v1 return v1 } _p2 = s + uintptr(Xstrcspn(tls, s, sep)) - if *(*uint8)(unsafe.Pointer(_p2)) != 0 { + if **(**uint8)(__ccgo_up(_p2)) != 0 { v1 = _p2 _p2 = _p2 + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) } else { _p2 = uintptr(0) } @@ -147360,26 +147360,26 @@ func Xstrtok_r(tls *TLS, s uintptr, sep uintptr, p uintptr) (r uintptr) { var v2 bool _, _, _ = v1, v2, v3 if v2 = !(s != 0); v2 { - v1 = *(*uintptr)(unsafe.Pointer(p)) + v1 = **(**uintptr)(__ccgo_up(p)) s = v1 } if v2 && !(v1 != 0) { return UintptrFromInt32(0) } s = s + uintptr(Xstrspn(tls, s, sep)) - if !(*(*uint8)(unsafe.Pointer(s)) != 0) { + if !(**(**uint8)(__ccgo_up(s)) != 0) { v1 = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(p)) = v1 + **(**uintptr)(__ccgo_up(p)) = v1 return v1 } - *(*uintptr)(unsafe.Pointer(p)) = s + uintptr(Xstrcspn(tls, s, sep)) - if *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)))) != 0 { + **(**uintptr)(__ccgo_up(p)) = s + uintptr(Xstrcspn(tls, s, sep)) + if **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)))) != 0 { v3 = p v1 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 - *(*uint8)(unsafe.Pointer(v1)) = uint8(0) + **(**uint8)(__ccgo_up(v1)) = uint8(0) } else { - *(*uintptr)(unsafe.Pointer(p)) = uintptr(0) + **(**uintptr)(__ccgo_up(p)) = uintptr(0) } return s } @@ -147402,10 +147402,10 @@ func Xstrverscmp(tls *TLS, l0 uintptr, r0 uintptr) (r1 int32) { i = v2 dp = v2 for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(l + uintptr(i)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(r + uintptr(i))))) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(l + uintptr(i)))) == Int32FromUint8(**(**uint8)(__ccgo_up(r + uintptr(i))))) { break } - c = Int32FromUint8(*(*uint8)(unsafe.Pointer(l + uintptr(i)))) + c = Int32FromUint8(**(**uint8)(__ccgo_up(l + uintptr(i)))) if !(c != 0) { return 0 } @@ -147422,15 +147422,15 @@ func Xstrverscmp(tls *TLS, l0 uintptr, r0 uintptr) (r1 int32) { ; i = i + 1 } - if Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(l + uintptr(dp))))-int32('1')) < uint32(9) && Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(r + uintptr(dp))))-int32('1')) < uint32(9) { + if Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(l + uintptr(dp))))-int32('1')) < uint32(9) && Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(r + uintptr(dp))))-int32('1')) < uint32(9) { /* If we're looking at non-degenerate digit sequences starting * with nonzero digits, longest digit string is greater. */ j = i for { - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(l + uintptr(j))))-uint32('0') < uint32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(l + uintptr(j))))-uint32('0') < uint32(10)) != 0) { break } - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(r + uintptr(j))))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(r + uintptr(j))))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return int32(1) } goto _3 @@ -147438,17 +147438,17 @@ func Xstrverscmp(tls *TLS, l0 uintptr, r0 uintptr) (r1 int32) { ; j = j + 1 } - if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(r + uintptr(j))))-uint32('0') < uint32(10)) != 0 { + if BoolInt32(uint32(**(**uint8)(__ccgo_up(r + uintptr(j))))-uint32('0') < uint32(10)) != 0 { return -int32(1) } } else { - if z != 0 && dp < i && (BoolInt32(uint32(*(*uint8)(unsafe.Pointer(l + uintptr(i))))-uint32('0') < uint32(10)) != 0 || BoolInt32(uint32(*(*uint8)(unsafe.Pointer(r + uintptr(i))))-uint32('0') < uint32(10)) != 0) { + if z != 0 && dp < i && (BoolInt32(uint32(**(**uint8)(__ccgo_up(l + uintptr(i))))-uint32('0') < uint32(10)) != 0 || BoolInt32(uint32(**(**uint8)(__ccgo_up(r + uintptr(i))))-uint32('0') < uint32(10)) != 0) { /* Otherwise, if common prefix of digit sequence is * all zeros, digits order less than non-digits. */ - return Int32FromUint8(Uint8FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(l + uintptr(i))))-Int32FromUint8('0'))) - Int32FromUint8(Uint8FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(r + uintptr(i))))-Int32FromUint8('0'))) + return Int32FromUint8(Uint8FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(l + uintptr(i))))-Int32FromUint8('0'))) - Int32FromUint8(Uint8FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(r + uintptr(i))))-Int32FromUint8('0'))) } } - return Int32FromUint8(*(*uint8)(unsafe.Pointer(l + uintptr(i)))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r + uintptr(i)))) + return Int32FromUint8(**(**uint8)(__ccgo_up(l + uintptr(i)))) - Int32FromUint8(**(**uint8)(__ccgo_up(r + uintptr(i)))) } func Xswab(tls *TLS, _src uintptr, _dest uintptr, n Tssize_t) { @@ -147463,8 +147463,8 @@ func Xswab(tls *TLS, _src uintptr, _dest uintptr, n Tssize_t) { if !(n > int64(1)) { break } - *(*uint8)(unsafe.Pointer(dest)) = *(*uint8)(unsafe.Pointer(src + 1)) - *(*uint8)(unsafe.Pointer(dest + 1)) = *(*uint8)(unsafe.Pointer(src)) + **(**uint8)(__ccgo_up(dest)) = **(**uint8)(__ccgo_up(src + 1)) + **(**uint8)(__ccgo_up(dest + 1)) = **(**uint8)(__ccgo_up(src)) dest = dest + uintptr(2) src = src + uintptr(2) goto _1 @@ -147526,7 +147526,7 @@ func Xwcschr(tls *TLS, s uintptr, c Twchar_t) (r uintptr) { return s + uintptr(Xwcslen(tls, s))*4 } for { - if !(*(*Twchar_t)(unsafe.Pointer(s)) != 0 && *(*Twchar_t)(unsafe.Pointer(s)) != c) { + if !(**(**Twchar_t)(__ccgo_up(s)) != 0 && **(**Twchar_t)(__ccgo_up(s)) != c) { break } goto _1 @@ -147534,7 +147534,7 @@ func Xwcschr(tls *TLS, s uintptr, c Twchar_t) (r uintptr) { ; s += 4 } - if *(*Twchar_t)(unsafe.Pointer(s)) != 0 { + if **(**Twchar_t)(__ccgo_up(s)) != 0 { v2 = s } else { v2 = uintptr(0) @@ -147550,7 +147550,7 @@ func Xwcscmp(tls *TLS, l uintptr, r uintptr) (r1 int32) { var v2 int32 _ = v2 for { - if !(*(*Twchar_t)(unsafe.Pointer(l)) == *(*Twchar_t)(unsafe.Pointer(r)) && *(*Twchar_t)(unsafe.Pointer(l)) != 0 && *(*Twchar_t)(unsafe.Pointer(r)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(l)) == **(**Twchar_t)(__ccgo_up(r)) && **(**Twchar_t)(__ccgo_up(l)) != 0 && **(**Twchar_t)(__ccgo_up(r)) != 0) { break } goto _1 @@ -147559,10 +147559,10 @@ func Xwcscmp(tls *TLS, l uintptr, r uintptr) (r1 int32) { l += 4 r += 4 } - if *(*Twchar_t)(unsafe.Pointer(l)) < *(*Twchar_t)(unsafe.Pointer(r)) { + if **(**Twchar_t)(__ccgo_up(l)) < **(**Twchar_t)(__ccgo_up(r)) { v2 = -int32(1) } else { - v2 = BoolInt32(*(*Twchar_t)(unsafe.Pointer(l)) > *(*Twchar_t)(unsafe.Pointer(r))) + v2 = BoolInt32(**(**Twchar_t)(__ccgo_up(l)) > **(**Twchar_t)(__ccgo_up(r))) } return v2 } @@ -147579,10 +147579,10 @@ func Xwcscpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { for { v2 = s s += 4 - v1 = *(*Twchar_t)(unsafe.Pointer(v2)) + v1 = **(**Twchar_t)(__ccgo_up(v2)) v3 = d d += 4 - *(*Twchar_t)(unsafe.Pointer(v3)) = v1 + **(**Twchar_t)(__ccgo_up(v3)) = v1 if !(v1 != 0) { break } @@ -147598,13 +147598,13 @@ func Xwcscspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { var a, v2, v3 uintptr var v1 uint64 _, _, _, _ = a, v1, v2, v3 - if !(*(*Twchar_t)(unsafe.Pointer(c)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(c)) != 0) { return Xwcslen(tls, s) } - if !(*(*Twchar_t)(unsafe.Pointer(c + 1*4)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(c + 1*4)) != 0) { v3 = s a = v3 - v2 = Xwcschr(tls, v3, *(*Twchar_t)(unsafe.Pointer(c))) + v2 = Xwcschr(tls, v3, **(**Twchar_t)(__ccgo_up(c))) s = v2 if v2 != 0 { v1 = Uint64FromInt64((int64(s) - int64(a)) / 4) @@ -147615,7 +147615,7 @@ func Xwcscspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { } a = s for { - if !(*(*Twchar_t)(unsafe.Pointer(s)) != 0 && !(Xwcschr(tls, c, *(*Twchar_t)(unsafe.Pointer(s))) != 0)) { + if !(**(**Twchar_t)(__ccgo_up(s)) != 0 && !(Xwcschr(tls, c, **(**Twchar_t)(__ccgo_up(s))) != 0)) { break } goto _4 @@ -147651,7 +147651,7 @@ func Xwcslen(tls *TLS, s uintptr) (r Tsize_t) { _ = a a = s for { - if !(*(*Twchar_t)(unsafe.Pointer(s)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(s)) != 0) { break } goto _1 @@ -147675,7 +147675,7 @@ func Xwcsncasecmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { return 0 } for { - if !(*(*Twchar_t)(unsafe.Pointer(l)) != 0 && *(*Twchar_t)(unsafe.Pointer(r)) != 0 && n != 0 && (*(*Twchar_t)(unsafe.Pointer(l)) == *(*Twchar_t)(unsafe.Pointer(r)) || Xtowlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(l)))) == Xtowlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(r)))))) { + if !(**(**Twchar_t)(__ccgo_up(l)) != 0 && **(**Twchar_t)(__ccgo_up(r)) != 0 && n != 0 && (**(**Twchar_t)(__ccgo_up(l)) == **(**Twchar_t)(__ccgo_up(r)) || Xtowlower(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(l)))) == Xtowlower(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(r)))))) { break } goto _2 @@ -147685,7 +147685,7 @@ func Xwcsncasecmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { r += 4 n = n - 1 } - return Int32FromUint32(Xtowlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(l)))) - Xtowlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(r))))) + return Int32FromUint32(Xtowlower(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(l)))) - Xtowlower(tls, Uint32FromInt32(**(**Twchar_t)(__ccgo_up(r))))) } func Xwcsncasecmp_l(tls *TLS, l uintptr, r uintptr, n Tsize_t, locale Tlocale_t) (r1 int32) { @@ -147705,17 +147705,17 @@ func Xwcsncat(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { _, _, _ = a, v1, v2 a = d d = d + uintptr(Xwcslen(tls, d))*4 - for n != 0 && *(*Twchar_t)(unsafe.Pointer(s)) != 0 { + for n != 0 && **(**Twchar_t)(__ccgo_up(s)) != 0 { n = n - 1 v1 = d d += 4 v2 = s s += 4 - *(*Twchar_t)(unsafe.Pointer(v1)) = *(*Twchar_t)(unsafe.Pointer(v2)) + **(**Twchar_t)(__ccgo_up(v1)) = **(**Twchar_t)(__ccgo_up(v2)) } v1 = d d += 4 - *(*Twchar_t)(unsafe.Pointer(v1)) = 0 + **(**Twchar_t)(__ccgo_up(v1)) = 0 return a } @@ -147727,7 +147727,7 @@ func Xwcsncmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { var v2, v3 int32 _, _ = v2, v3 for { - if !(n != 0 && *(*Twchar_t)(unsafe.Pointer(l)) == *(*Twchar_t)(unsafe.Pointer(r)) && *(*Twchar_t)(unsafe.Pointer(l)) != 0 && *(*Twchar_t)(unsafe.Pointer(r)) != 0) { + if !(n != 0 && **(**Twchar_t)(__ccgo_up(l)) == **(**Twchar_t)(__ccgo_up(r)) && **(**Twchar_t)(__ccgo_up(l)) != 0 && **(**Twchar_t)(__ccgo_up(r)) != 0) { break } goto _1 @@ -147738,10 +147738,10 @@ func Xwcsncmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { r += 4 } if n != 0 { - if *(*Twchar_t)(unsafe.Pointer(l)) < *(*Twchar_t)(unsafe.Pointer(r)) { + if **(**Twchar_t)(__ccgo_up(l)) < **(**Twchar_t)(__ccgo_up(r)) { v3 = -int32(1) } else { - v3 = BoolInt32(*(*Twchar_t)(unsafe.Pointer(l)) > *(*Twchar_t)(unsafe.Pointer(r))) + v3 = BoolInt32(**(**Twchar_t)(__ccgo_up(l)) > **(**Twchar_t)(__ccgo_up(r))) } v2 = v3 } else { @@ -147758,13 +147758,13 @@ func Xwcsncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { var a, v1, v2 uintptr _, _, _ = a, v1, v2 a = d - for n != 0 && *(*Twchar_t)(unsafe.Pointer(s)) != 0 { + for n != 0 && **(**Twchar_t)(__ccgo_up(s)) != 0 { n = n - 1 v1 = d d += 4 v2 = s s += 4 - *(*Twchar_t)(unsafe.Pointer(v1)) = *(*Twchar_t)(unsafe.Pointer(v2)) + **(**Twchar_t)(__ccgo_up(v1)) = **(**Twchar_t)(__ccgo_up(v2)) } Xwmemset(tls, d, 0, n) return a @@ -147792,7 +147792,7 @@ func Xwcspbrk(tls *TLS, s uintptr, b uintptr) (r uintptr) { var v1 uintptr _ = v1 s = s + uintptr(Xwcscspn(tls, s, b))*4 - if *(*Twchar_t)(unsafe.Pointer(s)) != 0 { + if **(**Twchar_t)(__ccgo_up(s)) != 0 { v1 = s } else { v1 = UintptrFromInt32(0) @@ -147809,7 +147809,7 @@ func Xwcsrchr(tls *TLS, s uintptr, c Twchar_t) (r uintptr) { _, _ = p, v2 p = s + uintptr(Xwcslen(tls, s))*4 for { - if !(p >= s && *(*Twchar_t)(unsafe.Pointer(p)) != c) { + if !(p >= s && **(**Twchar_t)(__ccgo_up(p)) != c) { break } goto _1 @@ -147834,7 +147834,7 @@ func Xwcsspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { _ = a a = s for { - if !(*(*Twchar_t)(unsafe.Pointer(s)) != 0 && Xwcschr(tls, c, *(*Twchar_t)(unsafe.Pointer(s))) != 0) { + if !(**(**Twchar_t)(__ccgo_up(s)) != 0 && Xwcschr(tls, c, **(**Twchar_t)(__ccgo_up(s))) != 0) { break } goto _1 @@ -147853,7 +147853,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { /* Computing length of needle */ l = uint64(0) for { - if !(*(*Twchar_t)(unsafe.Pointer(n + uintptr(l)*4)) != 0 && *(*Twchar_t)(unsafe.Pointer(h + uintptr(l)*4)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(n + uintptr(l)*4)) != 0 && **(**Twchar_t)(__ccgo_up(h + uintptr(l)*4)) != 0) { break } goto _1 @@ -147861,7 +147861,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { ; l = l + 1 } - if *(*Twchar_t)(unsafe.Pointer(n + uintptr(l)*4)) != 0 { + if **(**Twchar_t)(__ccgo_up(n + uintptr(l)*4)) != 0 { return uintptr(0) } /* hit the end of h */ /* Compute maximal suffix */ @@ -147871,7 +147871,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { p = v2 k = v2 for jp+k < l { - if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) == *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { + if **(**Twchar_t)(__ccgo_up(n + uintptr(ip+k)*4)) == **(**Twchar_t)(__ccgo_up(n + uintptr(jp+k)*4)) { if k == p { jp = jp + p k = uint64(1) @@ -147879,7 +147879,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { k = k + 1 } } else { - if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) > *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { + if **(**Twchar_t)(__ccgo_up(n + uintptr(ip+k)*4)) > **(**Twchar_t)(__ccgo_up(n + uintptr(jp+k)*4)) { jp = jp + k k = uint64(1) p = jp - ip @@ -147902,7 +147902,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { p = v2 k = v2 for jp+k < l { - if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) == *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { + if **(**Twchar_t)(__ccgo_up(n + uintptr(ip+k)*4)) == **(**Twchar_t)(__ccgo_up(n + uintptr(jp+k)*4)) { if k == p { jp = jp + p k = uint64(1) @@ -147910,7 +147910,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { k = k + 1 } } else { - if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) < *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { + if **(**Twchar_t)(__ccgo_up(n + uintptr(ip+k)*4)) < **(**Twchar_t)(__ccgo_up(n + uintptr(jp+k)*4)) { jp = jp + k k = uint64(1) p = jp - ip @@ -147968,7 +147968,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { } k = v8 for { - if !(*(*Twchar_t)(unsafe.Pointer(n + uintptr(k)*4)) != 0 && *(*Twchar_t)(unsafe.Pointer(n + uintptr(k)*4)) == *(*Twchar_t)(unsafe.Pointer(h + uintptr(k)*4))) { + if !(**(**Twchar_t)(__ccgo_up(n + uintptr(k)*4)) != 0 && **(**Twchar_t)(__ccgo_up(n + uintptr(k)*4)) == **(**Twchar_t)(__ccgo_up(h + uintptr(k)*4))) { break } goto _10 @@ -147976,7 +147976,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { ; k = k + 1 } - if *(*Twchar_t)(unsafe.Pointer(n + uintptr(k)*4)) != 0 { + if **(**Twchar_t)(__ccgo_up(n + uintptr(k)*4)) != 0 { h = h + uintptr(k-ms)*4 mem = uint64(0) goto _9 @@ -147984,7 +147984,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { /* Compare left half */ k = ms + uint64(1) for { - if !(k > mem && *(*Twchar_t)(unsafe.Pointer(n + uintptr(k-uint64(1))*4)) == *(*Twchar_t)(unsafe.Pointer(h + uintptr(k-uint64(1))*4))) { + if !(k > mem && **(**Twchar_t)(__ccgo_up(n + uintptr(k-uint64(1))*4)) == **(**Twchar_t)(__ccgo_up(h + uintptr(k-uint64(1))*4))) { break } goto _12 @@ -148009,18 +148009,18 @@ func Xwcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { defer func() { trc("-> %v", r) }() } /* Return immediately on empty needle or haystack */ - if !(*(*Twchar_t)(unsafe.Pointer(n)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(n)) != 0) { return h } - if !(*(*Twchar_t)(unsafe.Pointer(h)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(h)) != 0) { return uintptr(0) } /* Use faster algorithms for short needles */ - h = Xwcschr(tls, h, *(*Twchar_t)(unsafe.Pointer(n))) - if !(h != 0) || !(*(*Twchar_t)(unsafe.Pointer(n + 1*4)) != 0) { + h = Xwcschr(tls, h, **(**Twchar_t)(__ccgo_up(n))) + if !(h != 0) || !(**(**Twchar_t)(__ccgo_up(n + 1*4)) != 0) { return h } - if !(*(*Twchar_t)(unsafe.Pointer(h + 1*4)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(h + 1*4)) != 0) { return uintptr(0) } return _twoway_wcsstr(tls, h, n) @@ -148035,26 +148035,26 @@ func Xwcstok(tls *TLS, s uintptr, sep uintptr, p uintptr) (r uintptr) { var v2 bool _, _, _ = v1, v2, v3 if v2 = !(s != 0); v2 { - v1 = *(*uintptr)(unsafe.Pointer(p)) + v1 = **(**uintptr)(__ccgo_up(p)) s = v1 } if v2 && !(v1 != 0) { return UintptrFromInt32(0) } s = s + uintptr(Xwcsspn(tls, s, sep))*4 - if !(*(*Twchar_t)(unsafe.Pointer(s)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(s)) != 0) { v1 = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(p)) = v1 + **(**uintptr)(__ccgo_up(p)) = v1 return v1 } - *(*uintptr)(unsafe.Pointer(p)) = s + uintptr(Xwcscspn(tls, s, sep))*4 - if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)))) != 0 { + **(**uintptr)(__ccgo_up(p)) = s + uintptr(Xwcscspn(tls, s, sep))*4 + if **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(p)))) != 0 { v3 = p v1 = *(*uintptr)(unsafe.Pointer(v3)) *(*uintptr)(unsafe.Pointer(v3)) += 4 - *(*Twchar_t)(unsafe.Pointer(v1)) = 0 + **(**Twchar_t)(__ccgo_up(v1)) = 0 } else { - *(*uintptr)(unsafe.Pointer(p)) = uintptr(0) + **(**uintptr)(__ccgo_up(p)) = uintptr(0) } return s } @@ -148075,7 +148075,7 @@ func Xwmemchr(tls *TLS, s uintptr, c Twchar_t, n Tsize_t) (r uintptr) { var v2 uintptr _ = v2 for { - if !(n != 0 && *(*Twchar_t)(unsafe.Pointer(s)) != c) { + if !(n != 0 && **(**Twchar_t)(__ccgo_up(s)) != c) { break } goto _1 @@ -148100,7 +148100,7 @@ func Xwmemcmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { var v2, v3 int32 _, _ = v2, v3 for { - if !(n != 0 && *(*Twchar_t)(unsafe.Pointer(l)) == *(*Twchar_t)(unsafe.Pointer(r))) { + if !(n != 0 && **(**Twchar_t)(__ccgo_up(l)) == **(**Twchar_t)(__ccgo_up(r))) { break } goto _1 @@ -148111,10 +148111,10 @@ func Xwmemcmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { r += 4 } if n != 0 { - if *(*Twchar_t)(unsafe.Pointer(l)) < *(*Twchar_t)(unsafe.Pointer(r)) { + if **(**Twchar_t)(__ccgo_up(l)) < **(**Twchar_t)(__ccgo_up(r)) { v3 = -int32(1) } else { - v3 = BoolInt32(*(*Twchar_t)(unsafe.Pointer(l)) > *(*Twchar_t)(unsafe.Pointer(r))) + v3 = BoolInt32(**(**Twchar_t)(__ccgo_up(l)) > **(**Twchar_t)(__ccgo_up(r))) } v2 = v3 } else { @@ -148142,7 +148142,7 @@ func Xwmemcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { d += 4 v3 = s s += 4 - *(*Twchar_t)(unsafe.Pointer(v2)) = *(*Twchar_t)(unsafe.Pointer(v3)) + **(**Twchar_t)(__ccgo_up(v2)) = **(**Twchar_t)(__ccgo_up(v3)) } return a } @@ -148166,7 +148166,7 @@ func Xwmemmove(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { if !(v1 != 0) { break } - *(*Twchar_t)(unsafe.Pointer(d + uintptr(n)*4)) = *(*Twchar_t)(unsafe.Pointer(s + uintptr(n)*4)) + **(**Twchar_t)(__ccgo_up(d + uintptr(n)*4)) = **(**Twchar_t)(__ccgo_up(s + uintptr(n)*4)) } } else { for { @@ -148179,7 +148179,7 @@ func Xwmemmove(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { d += 4 v4 = s s += 4 - *(*Twchar_t)(unsafe.Pointer(v3)) = *(*Twchar_t)(unsafe.Pointer(v4)) + **(**Twchar_t)(__ccgo_up(v3)) = **(**Twchar_t)(__ccgo_up(v4)) } } return d0 @@ -148202,7 +148202,7 @@ func Xwmemset(tls *TLS, d uintptr, c Twchar_t, n Tsize_t) (r uintptr) { } v2 = d d += 4 - *(*Twchar_t)(unsafe.Pointer(v2)) = c + **(**Twchar_t)(__ccgo_up(v2)) = c } return ret } @@ -148218,7 +148218,7 @@ func Xmkdtemp(tls *TLS, template uintptr) (r uintptr) { l = _strlen(tls, template) retries = int32(100) if l < uint64(6) || Xmemcmp(tls, template+uintptr(l)-uintptr(6), __ccgo_ts+1760, uint64(6)) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } for { @@ -148231,7 +148231,7 @@ func Xmkdtemp(tls *TLS, template uintptr) (r uintptr) { ; retries = retries - 1 v1 = retries - if !(v1 != 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EEXIST)) { + if !(v1 != 0 && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EEXIST)) { break } } @@ -148259,7 +148259,7 @@ func X__mkostemps(tls *TLS, template uintptr, len1 int32, flags int32) (r int32) _, _, _, _ = fd, l, retries, v1 l = _strlen(tls, template) if l < uint64(6) || Uint64FromInt32(len1) > l-uint64(6) || Xmemcmp(tls, template+uintptr(l)-uintptr(len1)-uintptr(6), __ccgo_ts+1760, uint64(6)) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } flags = flags - flags&(Int32FromInt32(03)|Int32FromInt32(O_PATH)) @@ -148276,7 +148276,7 @@ func X__mkostemps(tls *TLS, template uintptr, len1 int32, flags int32) (r int32) ; retries = retries - 1 v1 = retries - if !(v1 != 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EEXIST)) { + if !(v1 != 0 && **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EEXIST)) { break } } @@ -148322,15 +148322,15 @@ func Xmktemp(tls *TLS, template uintptr) (r uintptr) { l = _strlen(tls, template) retries = int32(100) if l < uint64(6) || Xmemcmp(tls, template+uintptr(l)-uintptr(6), __ccgo_ts+1760, uint64(6)) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) - *(*uint8)(unsafe.Pointer(template)) = uint8(0) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) + **(**uint8)(__ccgo_up(template)) = uint8(0) return template } for { ___randname(tls, template+uintptr(l)-uintptr(6)) if Xstat(tls, template, bp) != 0 { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(ENOENT) { - *(*uint8)(unsafe.Pointer(template)) = uint8(0) + if **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(ENOENT) { + **(**uint8)(__ccgo_up(template)) = uint8(0) } return template } @@ -148343,8 +148343,8 @@ func Xmktemp(tls *TLS, template uintptr) (r uintptr) { break } } - *(*uint8)(unsafe.Pointer(template)) = uint8(0) - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EEXIST) + **(**uint8)(__ccgo_up(template)) = uint8(0) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EEXIST) return template } @@ -148368,13 +148368,13 @@ func Xcfmakeraw(tls *TLS, t uintptr) { if __ccgo_strace { trc("tls=%v t=%v, (%v:)", tls, t, origin(2)) } - *(*Ttcflag_t)(unsafe.Pointer(t)) &= Uint32FromInt32(^(Int32FromInt32(IGNBRK) | Int32FromInt32(BRKINT) | Int32FromInt32(PARMRK) | Int32FromInt32(ISTRIP) | Int32FromInt32(INLCR) | Int32FromInt32(IGNCR) | Int32FromInt32(ICRNL) | Int32FromInt32(IXON))) - *(*Ttcflag_t)(unsafe.Pointer(t + 4)) &= Uint32FromInt32(^Int32FromInt32(OPOST)) - *(*Ttcflag_t)(unsafe.Pointer(t + 12)) &= Uint32FromInt32(^(Int32FromInt32(ECHO) | Int32FromInt32(ECHONL) | Int32FromInt32(ICANON) | Int32FromInt32(ISIG) | Int32FromInt32(IEXTEN))) - *(*Ttcflag_t)(unsafe.Pointer(t + 8)) &= Uint32FromInt32(^(Int32FromInt32(CSIZE) | Int32FromInt32(PARENB))) - *(*Ttcflag_t)(unsafe.Pointer(t + 8)) |= uint32(CS8) - *(*Tcc_t)(unsafe.Pointer(t + 17 + 6)) = uint8(1) - *(*Tcc_t)(unsafe.Pointer(t + 17 + 5)) = uint8(0) + **(**Ttcflag_t)(__ccgo_up(t)) &= Uint32FromInt32(^(Int32FromInt32(IGNBRK) | Int32FromInt32(BRKINT) | Int32FromInt32(PARMRK) | Int32FromInt32(ISTRIP) | Int32FromInt32(INLCR) | Int32FromInt32(IGNCR) | Int32FromInt32(ICRNL) | Int32FromInt32(IXON))) + **(**Ttcflag_t)(__ccgo_up(t + 4)) &= Uint32FromInt32(^Int32FromInt32(OPOST)) + **(**Ttcflag_t)(__ccgo_up(t + 12)) &= Uint32FromInt32(^(Int32FromInt32(ECHO) | Int32FromInt32(ECHONL) | Int32FromInt32(ICANON) | Int32FromInt32(ISIG) | Int32FromInt32(IEXTEN))) + **(**Ttcflag_t)(__ccgo_up(t + 8)) &= Uint32FromInt32(^(Int32FromInt32(CSIZE) | Int32FromInt32(PARENB))) + **(**Ttcflag_t)(__ccgo_up(t + 8)) |= uint32(CS8) + **(**Tcc_t)(__ccgo_up(t + 17 + 6)) = uint8(1) + **(**Tcc_t)(__ccgo_up(t + 17 + 5)) = uint8(0) } func Xcfsetospeed(tls *TLS, tio uintptr, speed Tspeed_t) (r int32) { @@ -148383,11 +148383,11 @@ func Xcfsetospeed(tls *TLS, tio uintptr, speed Tspeed_t) (r int32) { defer func() { trc("-> %v", r) }() } if speed&Uint32FromInt32(^Int32FromInt32(CBAUD)) != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } - *(*Ttcflag_t)(unsafe.Pointer(tio + 8)) &= Uint32FromInt32(^Int32FromInt32(CBAUD)) - *(*Ttcflag_t)(unsafe.Pointer(tio + 8)) |= speed + **(**Ttcflag_t)(__ccgo_up(tio + 8)) &= Uint32FromInt32(^Int32FromInt32(CBAUD)) + **(**Ttcflag_t)(__ccgo_up(tio + 8)) |= speed return 0 } @@ -148466,7 +148466,7 @@ func Xtcgetsid(tls *TLS, fd int32) (r Tpid_t) { if Xioctl(tls, fd, int32(TIOCGSID), VaList(bp+16, bp)) < 0 { return -int32(1) } - return *(*int32)(unsafe.Pointer(bp)) + return **(**int32)(__ccgo_up(bp)) } func Xtcgetwinsize(tls *TLS, fd int32, wsz uintptr) (r int32) { @@ -148496,7 +148496,7 @@ func Xtcsetattr(tls *TLS, fd int32, act int32, tio uintptr) (r int32) { bp := tls.Alloc(16) defer tls.Free(16) if act < 0 || act > int32(2) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } return Xioctl(tls, fd, int32(TCSETS)+act, VaList(bp+8, tio)) @@ -148527,8 +148527,8 @@ func X__map_file(tls *TLS, pathname uintptr, size uintptr) (r uintptr) { return uintptr(0) } if !(X__fstat(tls, fd, bp) != 0) { - map1 = ___mmap(tls, uintptr(0), Uint64FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_size), int32(PROT_READ), int32(MAP_SHARED), fd, 0) - *(*Tsize_t)(unsafe.Pointer(size)) = Uint64FromInt64((*(*Tstat)(unsafe.Pointer(bp))).Fst_size) + map1 = ___mmap(tls, uintptr(0), Uint64FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_size), int32(PROT_READ), int32(MAP_SHARED), fd, 0) + **(**Tsize_t)(__ccgo_up(size)) = Uint64FromInt64((**(**Tstat)(__ccgo_up(bp))).Fst_size) } X__syscall1(tls, int64(SYS_close), int64(fd)) if map1 == uintptr(-Int32FromInt32(1)) { @@ -148700,7 +148700,7 @@ func X__tm_to_secs(tls *TLS, tm uintptr) (r int64) { year = year + int64(adj) } t = X__year_to_secs(tls, year, bp) - t = t + int64(X__month_to_secs(tls, month, *(*int32)(unsafe.Pointer(bp)))) + t = t + int64(X__month_to_secs(tls, month, **(**int32)(__ccgo_up(bp)))) t = t + int64(86400)*int64((*Ttm)(unsafe.Pointer(tm)).Ftm_mday-Int32FromInt32(1)) t = t + int64(3600)*int64((*Ttm)(unsafe.Pointer(tm)).Ftm_hour) t = t + int64(60)*int64((*Ttm)(unsafe.Pointer(tm)).Ftm_min) @@ -148734,14 +148734,14 @@ func _getint2(tls *TLS, p uintptr) (r int32) { _ = x x = uint32(0) for { - if !(Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)))))-int32('0')) < uint32(10)) { + if !(Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)))))-int32('0')) < uint32(10)) { break } - x = Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)))))-int32('0')) + uint32(10)*x + x = Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)))))-int32('0')) + uint32(10)*x goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 } return Int32FromUint32(x) } @@ -148750,20 +148750,20 @@ func _getoff(tls *TLS, p uintptr) (r int32) { var neg, off, v1 int32 _, _, _ = neg, off, v1 neg = 0 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('-') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) == int32('-') { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 neg = int32(1) } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('+') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) == int32('+') { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 } } off = int32(3600) * _getint2(tls, p) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32(':') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) == int32(':') { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 off = off + int32(60)*_getint2(tls, p) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32(':') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) == int32(':') { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 off = off + _getint2(tls, p) } } @@ -148778,61 +148778,61 @@ func _getoff(tls *TLS, p uintptr) (r int32) { func _getrule(tls *TLS, p uintptr, rule uintptr) { var r, v1 int32 _, _ = r, v1 - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) - *(*int32)(unsafe.Pointer(rule)) = v1 + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) + **(**int32)(__ccgo_up(rule)) = v1 r = v1 if r != int32('M') { if r == int32('J') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 } else { - *(*int32)(unsafe.Pointer(rule)) = 0 + **(**int32)(__ccgo_up(rule)) = 0 } - *(*int32)(unsafe.Pointer(rule + 1*4)) = _getint2(tls, p) + **(**int32)(__ccgo_up(rule + 1*4)) = _getint2(tls, p) } else { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 - *(*int32)(unsafe.Pointer(rule + 1*4)) = _getint2(tls, p) - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 - *(*int32)(unsafe.Pointer(rule + 2*4)) = _getint2(tls, p) - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 - *(*int32)(unsafe.Pointer(rule + 3*4)) = _getint2(tls, p) - } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('/') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 - *(*int32)(unsafe.Pointer(rule + 4*4)) = _getoff(tls, p) + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 + **(**int32)(__ccgo_up(rule + 1*4)) = _getint2(tls, p) + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 + **(**int32)(__ccgo_up(rule + 2*4)) = _getint2(tls, p) + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 + **(**int32)(__ccgo_up(rule + 3*4)) = _getint2(tls, p) + } + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) == int32('/') { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 + **(**int32)(__ccgo_up(rule + 4*4)) = _getoff(tls, p) } else { - *(*int32)(unsafe.Pointer(rule + 4*4)) = int32(7200) + **(**int32)(__ccgo_up(rule + 4*4)) = int32(7200) } } func _getname(tls *TLS, d uintptr, p uintptr) { var i, v3 int32 _, _ = i, v3 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('<') { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p))))) == int32('<') { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 i = 0 for { - if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i)))) != int32('>')) { + if !(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)) + uintptr(i))) != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)) + uintptr(i)))) != int32('>')) { break } if i < int32(TZNAME_MAX) { - *(*uint8)(unsafe.Pointer(d + uintptr(i))) = *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))) + **(**uint8)(__ccgo_up(d + uintptr(i))) = **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)) + uintptr(i))) } goto _1 _1: ; i = i + 1 } - if *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))) != 0 { - *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + if **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)) + uintptr(i))) != 0 { + **(**uintptr)(__ccgo_up(p)) = **(**uintptr)(__ccgo_up(p)) + 1 } } else { i = 0 for { - if !(Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))))|int32(32)-int32('a')) < uint32(26)) { + if !(Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)) + uintptr(i))))|int32(32)-int32('a')) < uint32(26)) { break } if i < int32(TZNAME_MAX) { - *(*uint8)(unsafe.Pointer(d + uintptr(i))) = *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))) + **(**uint8)(__ccgo_up(d + uintptr(i))) = **(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(p)) + uintptr(i))) } goto _2 _2: @@ -148840,17 +148840,17 @@ func _getname(tls *TLS, d uintptr, p uintptr) { i = i + 1 } } - *(*uintptr)(unsafe.Pointer(p)) += uintptr(i) + **(**uintptr)(__ccgo_up(p)) += uintptr(i) if i < int32(TZNAME_MAX) { v3 = i } else { v3 = int32(TZNAME_MAX) } - *(*uint8)(unsafe.Pointer(d + uintptr(v3))) = uint8(0) + **(**uint8)(__ccgo_up(d + uintptr(v3))) = uint8(0) } func _zi_read32(tls *TLS, z uintptr) (r Tuint32_t) { - return uint32(*(*uint8)(unsafe.Pointer(z)))< Uint64FromInt32(Int32FromInt32(PATH_MAX)+Int32FromInt32(1)) { - *(*uintptr)(unsafe.Pointer(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) + **(**uintptr)(__ccgo_up(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) i = Uint64FromInt32(3) } if i >= _old_tz_size { @@ -148933,13 +148933,13 @@ func _do_tzset(tls *TLS) { _old_tz = Xmalloc(tls, _old_tz_size) } if _old_tz != 0 { - Xmemcpy(tls, _old_tz, *(*uintptr)(unsafe.Pointer(bp + 288)), i+uint64(1)) + Xmemcpy(tls, _old_tz, **(**uintptr)(__ccgo_up(bp + 288)), i+uint64(1)) } posix_form = 0 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) != int32(':') { - *(*uintptr)(unsafe.Pointer(bp + 296)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) != int32(':') { + **(**uintptr)(__ccgo_up(bp + 296)) = **(**uintptr)(__ccgo_up(bp + 288)) _getname(tls, bp+308, bp+296) - if *(*uintptr)(unsafe.Pointer(bp + 296)) != *(*uintptr)(unsafe.Pointer(bp + 288)) && (Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 296))))) == int32('+') || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 296))))) == int32('-') || BoolInt32(uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 296)))))-uint32('0') < uint32(10)) != 0 || !(Xstrcmp(tls, bp+308, __ccgo_ts+1785) != 0) || !(Xstrcmp(tls, bp+308, __ccgo_ts+1789) != 0)) { + if **(**uintptr)(__ccgo_up(bp + 296)) != **(**uintptr)(__ccgo_up(bp + 288)) && (Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 296))))) == int32('+') || Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 296))))) == int32('-') || BoolInt32(uint32(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 296)))))-uint32('0') < uint32(10)) != 0 || !(Xstrcmp(tls, bp+308, __ccgo_ts+1785) != 0) || !(Xstrcmp(tls, bp+308, __ccgo_ts+1789) != 0)) { posix_form = int32(1) } } @@ -148947,21 +148947,21 @@ func _do_tzset(tls *TLS) { * pathame beginning with "."; in secure mode, only the * standard path will be searched. */ if !(posix_form != 0) { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32(':') { - *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32(':') { + **(**uintptr)(__ccgo_up(bp + 288)) = **(**uintptr)(__ccgo_up(bp + 288)) + 1 } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32('/') || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32('.') { - if !(X__libc.Fsecure != 0) || !(Xstrcmp(tls, *(*uintptr)(unsafe.Pointer(bp + 288)), __ccgo_ts+1770) != 0) { - map1 = X__map_file(tls, *(*uintptr)(unsafe.Pointer(bp + 288)), uintptr(unsafe.Pointer(&_map_size))) + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32('/') || Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32('.') { + if !(X__libc.Fsecure != 0) || !(Xstrcmp(tls, **(**uintptr)(__ccgo_up(bp + 288)), __ccgo_ts+1770) != 0) { + map1 = X__map_file(tls, **(**uintptr)(__ccgo_up(bp + 288)), uintptr(unsafe.Pointer(&_map_size))) } } else { - l = _strlen(tls, *(*uintptr)(unsafe.Pointer(bp + 288))) - if l <= uint64(NAME_MAX) && !(Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp + 288)), int32('.')) != 0) { - Xmemcpy(tls, pathname, *(*uintptr)(unsafe.Pointer(bp + 288)), l+uint64(1)) - *(*uint8)(unsafe.Pointer(pathname + uintptr(l))) = uint8(0) + l = _strlen(tls, **(**uintptr)(__ccgo_up(bp + 288))) + if l <= uint64(NAME_MAX) && !(Xstrchr(tls, **(**uintptr)(__ccgo_up(bp + 288)), int32('.')) != 0) { + Xmemcpy(tls, pathname, **(**uintptr)(__ccgo_up(bp + 288)), l+uint64(1)) + **(**uint8)(__ccgo_up(pathname + uintptr(l))) = uint8(0) try = uintptr(unsafe.Pointer(&_search)) for { - if !(!(map1 != 0) && *(*uint8)(unsafe.Pointer(try)) != 0) { + if !(!(map1 != 0) && **(**uint8)(__ccgo_up(try)) != 0) { break } l = _strlen(tls, try) @@ -148975,18 +148975,18 @@ func _do_tzset(tls *TLS) { } } if !(map1 != 0) { - *(*uintptr)(unsafe.Pointer(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) + **(**uintptr)(__ccgo_up(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) } } if map1 != 0 && (_map_size < uint64(44) || Xmemcmp(tls, map1, __ccgo_ts+1793, uint64(4)) != 0) { X__munmap(tls, map1, _map_size) map1 = uintptr(0) - *(*uintptr)(unsafe.Pointer(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) + **(**uintptr)(__ccgo_up(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) } _zi = map1 if map1 != 0 { scale = int32(2) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(map1 + 4))) != int32('1') { + if Int32FromUint8(**(**uint8)(__ccgo_up(map1 + 4))) != int32('1') { *(*[6]uint8)(unsafe.Pointer(bp)) = [6]uint8{ 0: uint8(1), 1: uint8(1), @@ -149005,18 +149005,18 @@ func _do_tzset(tls *TLS) { _types = _index + uintptr(_zi_read32(tls, _trans-uintptr(12))) _abbrevs = _types + uintptr(uint32(6)*_zi_read32(tls, _trans-uintptr(8))) _abbrevs_end = _abbrevs + uintptr(_zi_read32(tls, _trans-uintptr(4))) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(_zi + uintptr(_map_size-uint64(1))))) == int32('\n') { - *(*uintptr)(unsafe.Pointer(bp + 288)) = _zi + uintptr(_map_size) - uintptr(2) + if Int32FromUint8(**(**uint8)(__ccgo_up(_zi + uintptr(_map_size-uint64(1))))) == int32('\n') { + **(**uintptr)(__ccgo_up(bp + 288)) = _zi + uintptr(_map_size) - uintptr(2) for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) != int32('\n')) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) != int32('\n')) { break } goto _4 _4: ; - *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) - 1 + **(**uintptr)(__ccgo_up(bp + 288)) = **(**uintptr)(__ccgo_up(bp + 288)) - 1 } - *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 + **(**uintptr)(__ccgo_up(bp + 288)) = **(**uintptr)(__ccgo_up(bp + 288)) + 1 } else { v5 = UintptrFromInt32(0) Xtzname[int32(1)] = v5 @@ -149031,12 +149031,12 @@ func _do_tzset(tls *TLS) { if !(p1 < _abbrevs) { break } - if !(*(*uint8)(unsafe.Pointer(p1 + 4)) != 0) && !(Xtzname[0] != 0) { - Xtzname[0] = _abbrevs + uintptr(*(*uint8)(unsafe.Pointer(p1 + 5))) + if !(**(**uint8)(__ccgo_up(p1 + 4)) != 0) && !(Xtzname[0] != 0) { + Xtzname[0] = _abbrevs + uintptr(**(**uint8)(__ccgo_up(p1 + 5))) Xtimezone = Int64FromUint32(-_zi_read32(tls, p1)) } - if *(*uint8)(unsafe.Pointer(p1 + 4)) != 0 && !(Xtzname[int32(1)] != 0) { - Xtzname[int32(1)] = _abbrevs + uintptr(*(*uint8)(unsafe.Pointer(p1 + 5))) + if **(**uint8)(__ccgo_up(p1 + 4)) != 0 && !(Xtzname[int32(1)] != 0) { + Xtzname[int32(1)] = _abbrevs + uintptr(**(**uint8)(__ccgo_up(p1 + 5))) _dst_off = Int32FromUint32(-_zi_read32(tls, p1)) Xdaylight = int32(1) } @@ -149058,8 +149058,8 @@ func _do_tzset(tls *TLS) { return } } - if !(*(*uintptr)(unsafe.Pointer(bp + 288)) != 0) { - *(*uintptr)(unsafe.Pointer(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) + if !(**(**uintptr)(__ccgo_up(bp + 288)) != 0) { + **(**uintptr)(__ccgo_up(bp + 288)) = uintptr(unsafe.Pointer(&X__utc)) } _getname(tls, uintptr(unsafe.Pointer(&_std_name)), bp+288) Xtzname[0] = uintptr(unsafe.Pointer(&_std_name)) @@ -149068,7 +149068,7 @@ func _do_tzset(tls *TLS) { Xtzname[int32(1)] = uintptr(unsafe.Pointer(&_dst_name)) if _dst_name[0] != 0 { Xdaylight = int32(1) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32('+') || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32('-') || Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288)))))-int32('0')) < uint32(10) { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32('+') || Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32('-') || Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288)))))-int32('0')) < uint32(10) { _dst_off = _getoff(tls, bp+288) } else { _dst_off = int32(Xtimezone - int64(3600)) @@ -149077,12 +149077,12 @@ func _do_tzset(tls *TLS) { Xdaylight = 0 _dst_off = int32(Xtimezone) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32(',') { - *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32(',') { + **(**uintptr)(__ccgo_up(bp + 288)) = **(**uintptr)(__ccgo_up(bp + 288)) + 1 _getrule(tls, bp+288, uintptr(unsafe.Pointer(&_r0))) } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32(',') { - *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 288))))) == int32(',') { + **(**uintptr)(__ccgo_up(bp + 288)) = **(**uintptr)(__ccgo_up(bp + 288)) + 1 _getrule(tls, bp+288, uintptr(unsafe.Pointer(&_r12))) } } @@ -149103,7 +149103,7 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { n = Uint64FromInt64((int64(_index) - int64(_trans)) >> scale) if !(n != 0) { if alt != 0 { - *(*Tsize_t)(unsafe.Pointer(alt)) = uint64(0) + **(**Tsize_t)(__ccgo_up(alt)) = uint64(0) } return uint64(0) } @@ -149117,7 +149117,7 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { x = Uint64FromInt32(Int32FromUint64(x)) } if local != 0 { - off = Int32FromUint32(_zi_read32(tls, _types+uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(m-uint64(1)))))))) + off = Int32FromUint32(_zi_read32(tls, _types+uintptr(int32(6)*Int32FromUint8(**(**uint8)(__ccgo_up(_index + uintptr(m-uint64(1)))))))) } if t-int64(off) < int64(Int64FromUint64(x)) { n = n / uint64(2) @@ -149146,7 +149146,7 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { if !(i != 0) { break } - if !(*(*uint8)(unsafe.Pointer(_types + uintptr(i-uint64(6)+uint64(4)))) != 0) { + if !(**(**uint8)(__ccgo_up(_types + uintptr(i-uint64(6)+uint64(4)))) != 0) { j = i - uint64(6) } goto _1 @@ -149161,24 +149161,24 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { * and the index-zero (after transition) type as the alt. */ if t-int64(off) < int64(Int64FromUint64(x)) { if alt != 0 { - *(*Tsize_t)(unsafe.Pointer(alt)) = uint64(*(*uint8)(unsafe.Pointer(_index))) + **(**Tsize_t)(__ccgo_up(alt)) = uint64(**(**uint8)(__ccgo_up(_index))) } return j / uint64(6) } } /* Try to find a neighboring opposite-DST-status rule. */ if alt != 0 { - if a != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(_types + uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(a-uint64(1)))))+int32(4))))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(_types + uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(a))))+int32(4))))) { - *(*Tsize_t)(unsafe.Pointer(alt)) = uint64(*(*uint8)(unsafe.Pointer(_index + uintptr(a-uint64(1))))) + if a != 0 && Int32FromUint8(**(**uint8)(__ccgo_up(_types + uintptr(int32(6)*Int32FromUint8(**(**uint8)(__ccgo_up(_index + uintptr(a-uint64(1)))))+int32(4))))) != Int32FromUint8(**(**uint8)(__ccgo_up(_types + uintptr(int32(6)*Int32FromUint8(**(**uint8)(__ccgo_up(_index + uintptr(a))))+int32(4))))) { + **(**Tsize_t)(__ccgo_up(alt)) = uint64(**(**uint8)(__ccgo_up(_index + uintptr(a-uint64(1))))) } else { - if a+uint64(1) < n && Int32FromUint8(*(*uint8)(unsafe.Pointer(_types + uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(a+uint64(1)))))+int32(4))))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(_types + uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(a))))+int32(4))))) { - *(*Tsize_t)(unsafe.Pointer(alt)) = uint64(*(*uint8)(unsafe.Pointer(_index + uintptr(a+uint64(1))))) + if a+uint64(1) < n && Int32FromUint8(**(**uint8)(__ccgo_up(_types + uintptr(int32(6)*Int32FromUint8(**(**uint8)(__ccgo_up(_index + uintptr(a+uint64(1)))))+int32(4))))) != Int32FromUint8(**(**uint8)(__ccgo_up(_types + uintptr(int32(6)*Int32FromUint8(**(**uint8)(__ccgo_up(_index + uintptr(a))))+int32(4))))) { + **(**Tsize_t)(__ccgo_up(alt)) = uint64(**(**uint8)(__ccgo_up(_index + uintptr(a+uint64(1))))) } else { - *(*Tsize_t)(unsafe.Pointer(alt)) = uint64(*(*uint8)(unsafe.Pointer(_index + uintptr(a)))) + **(**Tsize_t)(__ccgo_up(alt)) = uint64(**(**uint8)(__ccgo_up(_index + uintptr(a)))) } } } - return uint64(*(*uint8)(unsafe.Pointer(_index + uintptr(a)))) + return uint64(**(**uint8)(__ccgo_up(_index + uintptr(a)))) } func _days_in_month1(tls *TLS, m int32, is_leap int32) (r int32) { @@ -149200,28 +149200,28 @@ func _rule_to_secs(tls *TLS, rule uintptr, year int32) (r int64) { var _ /* is_leap at bp+0 */ int32 _, _, _, _, _, _, _ = d, days, m, n, t, wday, x t = X__year_to_secs(tls, int64(year), bp) - if *(*int32)(unsafe.Pointer(rule)) != int32('M') { - x = *(*int32)(unsafe.Pointer(rule + 1*4)) - if *(*int32)(unsafe.Pointer(rule)) == int32('J') && (x < int32(60) || !(*(*int32)(unsafe.Pointer(bp)) != 0)) { + if **(**int32)(__ccgo_up(rule)) != int32('M') { + x = **(**int32)(__ccgo_up(rule + 1*4)) + if **(**int32)(__ccgo_up(rule)) == int32('J') && (x < int32(60) || !(**(**int32)(__ccgo_up(bp)) != 0)) { x = x - 1 } t = t + int64(int32(86400)*x) } else { - m = *(*int32)(unsafe.Pointer(rule + 1*4)) - n = *(*int32)(unsafe.Pointer(rule + 2*4)) - d = *(*int32)(unsafe.Pointer(rule + 3*4)) - t = t + int64(X__month_to_secs(tls, m-int32(1), *(*int32)(unsafe.Pointer(bp)))) + m = **(**int32)(__ccgo_up(rule + 1*4)) + n = **(**int32)(__ccgo_up(rule + 2*4)) + d = **(**int32)(__ccgo_up(rule + 3*4)) + t = t + int64(X__month_to_secs(tls, m-int32(1), **(**int32)(__ccgo_up(bp)))) wday = int32((t+int64(Int32FromInt32(4)*Int32FromInt32(86400)))%int64(Int32FromInt32(7)*Int32FromInt32(86400))) / int32(86400) days = d - wday if days < 0 { days = days + int32(7) } - if n == int32(5) && days+int32(28) >= _days_in_month1(tls, m, *(*int32)(unsafe.Pointer(bp))) { + if n == int32(5) && days+int32(28) >= _days_in_month1(tls, m, **(**int32)(__ccgo_up(bp))) { n = int32(4) } t = t + int64(int32(86400)*(days+int32(7)*(n-int32(1)))) } - t = t + int64(*(*int32)(unsafe.Pointer(rule + 4*4))) + t = t + int64(**(**int32)(__ccgo_up(rule + 4*4))) return t } @@ -149247,11 +149247,11 @@ func X__secs_to_zone(tls *TLS, t int64, local int32, isdst uintptr, offset uintp if _zi != 0 { i = _scan_trans(tls, t, local, bp) if i != Uint64FromInt32(-Int32FromInt32(1)) { - *(*int32)(unsafe.Pointer(isdst)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(_types + uintptr(uint64(6)*i+uint64(4))))) - *(*int64)(unsafe.Pointer(offset)) = int64(Int32FromUint32(_zi_read32(tls, _types+uintptr(uint64(6)*i)))) - *(*uintptr)(unsafe.Pointer(zonename)) = _abbrevs + uintptr(*(*uint8)(unsafe.Pointer(_types + uintptr(uint64(6)*i+uint64(5))))) + **(**int32)(__ccgo_up(isdst)) = Int32FromUint8(**(**uint8)(__ccgo_up(_types + uintptr(uint64(6)*i+uint64(4))))) + **(**int64)(__ccgo_up(offset)) = int64(Int32FromUint32(_zi_read32(tls, _types+uintptr(uint64(6)*i)))) + **(**uintptr)(__ccgo_up(zonename)) = _abbrevs + uintptr(**(**uint8)(__ccgo_up(_types + uintptr(uint64(6)*i+uint64(5))))) if oppoff != 0 { - *(*int64)(unsafe.Pointer(oppoff)) = int64(Int32FromUint32(_zi_read32(tls, _types+uintptr(uint64(6)**(*Tsize_t)(unsafe.Pointer(bp)))))) + **(**int64)(__ccgo_up(oppoff)) = int64(Int32FromUint32(_zi_read32(tls, _types+uintptr(uint64(6)***(**Tsize_t)(__ccgo_up(bp)))))) } ___unlock(tls, uintptr(unsafe.Pointer(&_lock4))) return @@ -149289,23 +149289,23 @@ func X__secs_to_zone(tls *TLS, t int64, local int32, isdst uintptr, offset uintp goto std std: ; - *(*int32)(unsafe.Pointer(isdst)) = 0 - *(*int64)(unsafe.Pointer(offset)) = -Xtimezone + **(**int32)(__ccgo_up(isdst)) = 0 + **(**int64)(__ccgo_up(offset)) = -Xtimezone if oppoff != 0 { - *(*int64)(unsafe.Pointer(oppoff)) = int64(-_dst_off) + **(**int64)(__ccgo_up(oppoff)) = int64(-_dst_off) } - *(*uintptr)(unsafe.Pointer(zonename)) = Xtzname[0] + **(**uintptr)(__ccgo_up(zonename)) = Xtzname[0] ___unlock(tls, uintptr(unsafe.Pointer(&_lock4))) return goto dst dst: ; - *(*int32)(unsafe.Pointer(isdst)) = int32(1) - *(*int64)(unsafe.Pointer(offset)) = int64(-_dst_off) + **(**int32)(__ccgo_up(isdst)) = int32(1) + **(**int64)(__ccgo_up(offset)) = int64(-_dst_off) if oppoff != 0 { - *(*int64)(unsafe.Pointer(oppoff)) = -Xtimezone + **(**int64)(__ccgo_up(oppoff)) = -Xtimezone } - *(*uintptr)(unsafe.Pointer(zonename)) = Xtzname[int32(1)] + **(**uintptr)(__ccgo_up(zonename)) = Xtzname[int32(1)] ___unlock(tls, uintptr(unsafe.Pointer(&_lock4))) } @@ -149348,11 +149348,11 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { if !((y-Int32FromInt32(68))&Int32FromInt32(3) != 0) { leaps = leaps - 1 if is_leap != 0 { - *(*int32)(unsafe.Pointer(is_leap)) = int32(1) + **(**int32)(__ccgo_up(is_leap)) = int32(1) } } else { if is_leap != 0 { - *(*int32)(unsafe.Pointer(is_leap)) = 0 + **(**int32)(__ccgo_up(is_leap)) = 0 } } return int64(int32(31536000)*(y-int32(70)) + int32(86400)*leaps) @@ -149367,7 +149367,7 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { rem = rem + int32(400) } if !(rem != 0) { - *(*int32)(unsafe.Pointer(is_leap)) = int32(1) + **(**int32)(__ccgo_up(is_leap)) = int32(1) centuries = 0 leaps1 = 0 } else { @@ -149388,15 +149388,15 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { } } if !(rem != 0) { - *(*int32)(unsafe.Pointer(is_leap)) = 0 + **(**int32)(__ccgo_up(is_leap)) = 0 leaps1 = 0 } else { leaps1 = Int32FromUint32(Uint32FromInt32(rem) / uint32(4)) rem = Int32FromUint32(uint32(rem) % Uint32FromUint32(4)) - *(*int32)(unsafe.Pointer(is_leap)) = BoolInt32(!(rem != 0)) + **(**int32)(__ccgo_up(is_leap)) = BoolInt32(!(rem != 0)) } } - leaps1 = leaps1 + (int32(97)*cycles + int32(24)*centuries - *(*int32)(unsafe.Pointer(is_leap))) + leaps1 = leaps1 + (int32(97)*cycles + int32(24)*centuries - **(**int32)(__ccgo_up(is_leap))) return (year-int64(100))*int64(31536000) + int64(leaps1)*int64(86400) + int64(946684800) + int64(86400) } @@ -149459,10 +149459,10 @@ func Xclock(tls *TLS) (r Tclock_t) { if X__clock_gettime(tls, int32(CLOCK_PROCESS_CPUTIME_ID), bp) != 0 { return int64(-int32(1)) } - if (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec > Int64FromInt64(0x7fffffffffffffff)/Int64FromInt32(1000000) || (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_nsec/int64(1000) > int64(0x7fffffffffffffff)-int64(1000000)*(*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec { + if (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec > Int64FromInt64(0x7fffffffffffffff)/Int64FromInt32(1000000) || (**(**Ttimespec)(__ccgo_up(bp))).Ftv_nsec/int64(1000) > int64(0x7fffffffffffffff)-int64(1000000)*(**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec { return int64(-int32(1)) } - return (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec*int64(1000000) + (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_nsec/int64(1000) + return (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec*int64(1000000) + (**(**Ttimespec)(__ccgo_up(bp))).Ftv_nsec/int64(1000) } func Xclock_getcpuclockid(tls *TLS, pid Tpid_t, clk uintptr) (r int32) { @@ -149484,7 +149484,7 @@ func Xclock_getcpuclockid(tls *TLS, pid Tpid_t, clk uintptr) (r int32) { if ret != 0 { return -ret } - *(*Tclockid_t)(unsafe.Pointer(clk)) = id + **(**Tclockid_t)(__ccgo_up(clk)) = id return 0 } @@ -149614,8 +149614,8 @@ func Xftime(tls *TLS, tp uintptr) (r int32) { var _ /* ts at bp+0 */ Ttimespec _ = v1 Xclock_gettime(tls, CLOCK_REALTIME, bp) - (*Ttimeb)(unsafe.Pointer(tp)).Ftime = (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec - (*Ttimeb)(unsafe.Pointer(tp)).Fmillitm = Uint16FromInt64((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_nsec / int64(1000000)) + (*Ttimeb)(unsafe.Pointer(tp)).Ftime = (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec + (*Ttimeb)(unsafe.Pointer(tp)).Fmillitm = Uint16FromInt64((**(**Ttimespec)(__ccgo_up(bp))).Ftv_nsec / int64(1000000)) v1 = Int16FromInt32(0) (*Ttimeb)(unsafe.Pointer(tp)).Fdstflag = v1 (*Ttimeb)(unsafe.Pointer(tp)).Ftimezone = v1 @@ -149643,7 +149643,7 @@ func Xgetdate(tls *TLS, s uintptr) (r uintptr) { } f = Xfopen(tls, datemsk, __ccgo_ts+404) if !(f != 0) { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(ENOMEM) { + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(ENOMEM) { Xgetdate_err = int32(6) } else { Xgetdate_err = int32(2) @@ -149652,7 +149652,7 @@ func Xgetdate(tls *TLS, s uintptr) (r uintptr) { } for Xfgets(tls, bp, int32(100), f) != 0 { p = Xstrptime(tls, s, bp, uintptr(unsafe.Pointer(&_tmbuf))) - if p != 0 && !(*(*uint8)(unsafe.Pointer(p)) != 0) { + if p != 0 && !(**(**uint8)(__ccgo_up(p)) != 0) { ret = uintptr(unsafe.Pointer(&_tmbuf)) goto out } @@ -149668,7 +149668,7 @@ out: if f != 0 { Xfclose(tls, f) } - _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 100)), uintptr(0)) + _pthread_setcancelstate(tls, **(**int32)(__ccgo_up(bp + 100)), uintptr(0)) return ret } @@ -149686,8 +149686,8 @@ func Xgettimeofday(tls *TLS, tv uintptr, tz uintptr) (r int32) { return 0 } Xclock_gettime(tls, CLOCK_REALTIME, bp) - (*Ttimeval)(unsafe.Pointer(tv)).Ftv_sec = (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec - (*Ttimeval)(unsafe.Pointer(tv)).Ftv_usec = int64(int32((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_nsec) / int32(1000)) + (*Ttimeval)(unsafe.Pointer(tv)).Ftv_sec = (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec + (*Ttimeval)(unsafe.Pointer(tv)).Ftv_usec = int64(int32((**(**Ttimespec)(__ccgo_up(bp))).Ftv_nsec) / int32(1000)) return 0 } @@ -149706,8 +149706,8 @@ func X__gmtime_r(tls *TLS, t uintptr, tm uintptr) (r uintptr) { trc("tls=%v t=%v tm=%v, (%v:)", tls, t, tm, origin(2)) defer func() { trc("-> %v", r) }() } - if X__secs_to_tm(tls, *(*Ttime_t)(unsafe.Pointer(t)), tm) < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + if X__secs_to_tm(tls, int64(**(**Ttime_t)(__ccgo_up(t))), tm) < 0 { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return uintptr(0) } (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst = 0 @@ -149750,13 +149750,13 @@ func X__localtime_r(tls *TLS, t uintptr, tm uintptr) (r uintptr) { } /* Reject time_t values whose year would overflow int because * __secs_to_zone cannot safely handle them. */ - if *(*Ttime_t)(unsafe.Pointer(t)) < int64(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff))*Int64FromInt64(31622400) || *(*Ttime_t)(unsafe.Pointer(t)) > Int64FromInt32(INT_MAX)*Int64FromInt64(31622400) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + if int64(**(**Ttime_t)(__ccgo_up(t))) < int64(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff))*Int64FromInt64(31622400) || int64(**(**Ttime_t)(__ccgo_up(t))) > Int64FromInt32(INT_MAX)*Int64FromInt64(31622400) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return uintptr(0) } - X__secs_to_zone(tls, *(*Ttime_t)(unsafe.Pointer(t)), 0, tm+32, tm+40, uintptr(0), tm+48) - if X__secs_to_tm(tls, *(*Ttime_t)(unsafe.Pointer(t))+(*Ttm)(unsafe.Pointer(tm)).F__tm_gmtoff, tm) < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + X__secs_to_zone(tls, int64(**(**Ttime_t)(__ccgo_up(t))), 0, tm+32, tm+40, uintptr(0), tm+48) + if X__secs_to_tm(tls, int64(**(**Ttime_t)(__ccgo_up(t)))+(*Ttm)(unsafe.Pointer(tm)).F__tm_gmtoff, tm) < 0 { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return uintptr(0) } return tm @@ -149792,23 +149792,23 @@ func Xmktime(tls *TLS, tm uintptr) (r Ttime_t) { _ = t t = X__tm_to_secs(tls, tm) X__secs_to_zone(tls, t, int32(1), bp+32, bp+40, bp+56, bp+48) - if (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst >= 0 && (*(*Ttm)(unsafe.Pointer(bp))).Ftm_isdst != (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst { - t = t - (*(*int64)(unsafe.Pointer(bp + 56)) - (*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff) + if (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst >= 0 && (**(**Ttm)(__ccgo_up(bp))).Ftm_isdst != (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst { + t = t - int64(**(**int64)(__ccgo_up(bp + 56))-(**(**Ttm)(__ccgo_up(bp))).F__tm_gmtoff) } - t = t - (*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff + t = t - int64((**(**Ttm)(__ccgo_up(bp))).F__tm_gmtoff) if t != t { goto error } X__secs_to_zone(tls, t, 0, bp+32, bp+40, bp+56, bp+48) - if X__secs_to_tm(tls, t+(*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff, bp) < 0 { + if X__secs_to_tm(tls, t+int64((**(**Ttm)(__ccgo_up(bp))).F__tm_gmtoff), bp) < 0 { goto error } - *(*Ttm)(unsafe.Pointer(tm)) = *(*Ttm)(unsafe.Pointer(bp)) + **(**Ttm)(__ccgo_up(tm)) = **(**Ttm)(__ccgo_up(bp)) return t goto error error: ; - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return int64(-int32(1)) } @@ -149969,7 +149969,7 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc val = int64((*Ttm)(unsafe.Pointer(tm)).Ftm_min) goto number case int32('n'): - *(*Tsize_t)(unsafe.Pointer(l)) = uint64(1) + **(**Tsize_t)(__ccgo_up(l)) = uint64(1) return __ccgo_ts + 390 case int32('p'): if (*Ttm)(unsafe.Pointer(tm)).Ftm_hour >= int32(12) { @@ -149988,20 +149988,20 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc item = v1 fmt = X__nl_langinfo_l(tls, item, loc) d = s - *(*Tsize_t)(unsafe.Pointer(l)) = uint64(0) + **(**Tsize_t)(__ccgo_up(l)) = uint64(0) for { - if !(*(*uint8)(unsafe.Pointer(fmt)) != 0) { + if !(**(**uint8)(__ccgo_up(fmt)) != 0) { break } v4 = d d = d + 1 v5 = fmt fmt = fmt + 1 - *(*uint8)(unsafe.Pointer(v4)) = Uint8FromInt32(Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))))) + **(**uint8)(__ccgo_up(v4)) = Uint8FromInt32(Xtolower(tls, Int32FromUint8(**(**uint8)(__ccgo_up(v5))))) goto _3 _3: ; - *(*Tsize_t)(unsafe.Pointer(l)) = *(*Tsize_t)(unsafe.Pointer(l)) + 1 + **(**Tsize_t)(__ccgo_up(l)) = **(**Tsize_t)(__ccgo_up(l)) + 1 } return s case int32('r'): @@ -150018,7 +150018,7 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc val = int64((*Ttm)(unsafe.Pointer(tm)).Ftm_sec) goto number case int32('t'): - *(*Tsize_t)(unsafe.Pointer(l)) = uint64(1) + **(**Tsize_t)(__ccgo_up(l)) = uint64(1) return __ccgo_ts + 1430 case int32('T'): fmt = __ccgo_ts + 1874 @@ -150060,27 +150060,27 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc case int32('Y'): val = int64((*Ttm)(unsafe.Pointer(tm)).Ftm_year) + int64(1900) if val >= int64(10000) { - *(*Tsize_t)(unsafe.Pointer(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1883, VaList(bp+8, val))) + **(**Tsize_t)(__ccgo_up(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1883, VaList(bp+8, val))) return s } width = int32(4) goto number case int32('z'): if (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst < 0 { - *(*Tsize_t)(unsafe.Pointer(l)) = uint64(0) + **(**Tsize_t)(__ccgo_up(l)) = uint64(0) return __ccgo_ts } - *(*Tsize_t)(unsafe.Pointer(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1889, VaList(bp+8, (*Ttm)(unsafe.Pointer(tm)).F__tm_gmtoff/int64(3600)*int64(100)+(*Ttm)(unsafe.Pointer(tm)).F__tm_gmtoff%int64(3600)/int64(60)))) + **(**Tsize_t)(__ccgo_up(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1889, VaList(bp+8, (*Ttm)(unsafe.Pointer(tm)).F__tm_gmtoff/int64(3600)*int64(100)+(*Ttm)(unsafe.Pointer(tm)).F__tm_gmtoff%int64(3600)/int64(60)))) return s case int32('Z'): if (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst < 0 { - *(*Tsize_t)(unsafe.Pointer(l)) = uint64(0) + **(**Tsize_t)(__ccgo_up(l)) = uint64(0) return __ccgo_ts } fmt = X__tm_to_tzname(tls, tm) goto string case int32('%'): - *(*Tsize_t)(unsafe.Pointer(l)) = uint64(1) + **(**Tsize_t)(__ccgo_up(l)) = uint64(1) return __ccgo_ts + 437 default: return uintptr(0) @@ -150095,13 +150095,13 @@ number: } switch v1 { case int32('-'): - *(*Tsize_t)(unsafe.Pointer(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1896, VaList(bp+8, val))) + **(**Tsize_t)(__ccgo_up(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1896, VaList(bp+8, val))) case int32('_'): - *(*Tsize_t)(unsafe.Pointer(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1901, VaList(bp+8, width, val))) + **(**Tsize_t)(__ccgo_up(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1901, VaList(bp+8, width, val))) case int32('0'): fallthrough default: - *(*Tsize_t)(unsafe.Pointer(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1907, VaList(bp+8, width, val))) + **(**Tsize_t)(__ccgo_up(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1907, VaList(bp+8, width, val))) break } return s @@ -150112,7 +150112,7 @@ nl_strcat: goto string string: ; - *(*Tsize_t)(unsafe.Pointer(l)) = _strlen(tls, fmt) + **(**Tsize_t)(__ccgo_up(l)) = _strlen(tls, fmt) return fmt goto nl_strftime nl_strftime: @@ -150121,8 +150121,8 @@ nl_strftime: goto recu_strftime recu_strftime: ; - *(*Tsize_t)(unsafe.Pointer(l)) = X__strftime_l(tls, s, uint64(100), fmt, tm, loc) - if !(*(*Tsize_t)(unsafe.Pointer(l)) != 0) { + **(**Tsize_t)(__ccgo_up(l)) = X__strftime_l(tls, s, uint64(100), fmt, tm, loc) + if !(**(**Tsize_t)(__ccgo_up(l)) != 0) { return uintptr(0) } return s @@ -150149,46 +150149,46 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl if !(l < n) { break } - if !(*(*uint8)(unsafe.Pointer(f)) != 0) { - *(*uint8)(unsafe.Pointer(s + uintptr(l))) = uint8(0) + if !(**(**uint8)(__ccgo_up(f)) != 0) { + **(**uint8)(__ccgo_up(s + uintptr(l))) = uint8(0) return l } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) != int32('%') { + if Int32FromUint8(**(**uint8)(__ccgo_up(f))) != int32('%') { v2 = l l = l + 1 - *(*uint8)(unsafe.Pointer(s + uintptr(v2))) = *(*uint8)(unsafe.Pointer(f)) + **(**uint8)(__ccgo_up(s + uintptr(v2))) = **(**uint8)(__ccgo_up(f)) goto _1 } f = f + 1 pad = 0 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('-') || Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('_') || Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('0') { + if Int32FromUint8(**(**uint8)(__ccgo_up(f))) == int32('-') || Int32FromUint8(**(**uint8)(__ccgo_up(f))) == int32('_') || Int32FromUint8(**(**uint8)(__ccgo_up(f))) == int32('0') { v3 = f f = f + 1 - pad = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) + pad = Int32FromUint8(**(**uint8)(__ccgo_up(v3))) } - v4 = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == Int32FromUint8('+')) + v4 = BoolInt32(Int32FromUint8(**(**uint8)(__ccgo_up(f))) == Int32FromUint8('+')) plus = v4 if v4 != 0 { f = f + 1 } - if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(f)))-uint32('0') < uint32(10)) != 0 { + if BoolInt32(uint32(**(**uint8)(__ccgo_up(f)))-uint32('0') < uint32(10)) != 0 { width = Xstrtoul(tls, f, bp+112, int32(10)) } else { width = uint64(0) - *(*uintptr)(unsafe.Pointer(bp + 112)) = f + **(**uintptr)(__ccgo_up(bp + 112)) = f } - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 112))))) == int32('C') || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 112))))) == int32('F') || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 112))))) == int32('G') || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 112))))) == int32('Y') { - if !(width != 0) && *(*uintptr)(unsafe.Pointer(bp + 112)) != f { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 112))))) == int32('C') || Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 112))))) == int32('F') || Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 112))))) == int32('G') || Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 112))))) == int32('Y') { + if !(width != 0) && **(**uintptr)(__ccgo_up(bp + 112)) != f { width = uint64(1) } } else { width = uint64(0) } - f = *(*uintptr)(unsafe.Pointer(bp + 112)) - if Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('E') || Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('O') { + f = **(**uintptr)(__ccgo_up(bp + 112)) + if Int32FromUint8(**(**uint8)(__ccgo_up(f))) == int32('E') || Int32FromUint8(**(**uint8)(__ccgo_up(f))) == int32('O') { f = f + 1 } - t = X__strftime_fmt_1(tls, bp+8, bp, Int32FromUint8(*(*uint8)(unsafe.Pointer(f))), tm, loc, pad) + t = X__strftime_fmt_1(tls, bp+8, bp, Int32FromUint8(**(**uint8)(__ccgo_up(f))), tm, loc, pad) if !(t != 0) { break } @@ -150196,26 +150196,26 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl /* Trim off any sign and leading zeros, then * count remaining digits to determine behavior * for the + flag. */ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(t))) == int32('+') || Int32FromUint8(*(*uint8)(unsafe.Pointer(t))) == int32('-') { + if Int32FromUint8(**(**uint8)(__ccgo_up(t))) == int32('+') || Int32FromUint8(**(**uint8)(__ccgo_up(t))) == int32('-') { t = t + 1 - *(*Tsize_t)(unsafe.Pointer(bp)) = *(*Tsize_t)(unsafe.Pointer(bp)) - 1 + **(**Tsize_t)(__ccgo_up(bp)) = **(**Tsize_t)(__ccgo_up(bp)) - 1 } for { - if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(t))) == int32('0') && Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(t + 1)))-int32('0')) < uint32(10)) { + if !(Int32FromUint8(**(**uint8)(__ccgo_up(t))) == int32('0') && Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(t + 1)))-int32('0')) < uint32(10)) { break } goto _5 _5: ; t = t + 1 - *(*Tsize_t)(unsafe.Pointer(bp)) = *(*Tsize_t)(unsafe.Pointer(bp)) - 1 + **(**Tsize_t)(__ccgo_up(bp)) = **(**Tsize_t)(__ccgo_up(bp)) - 1 } - if width < *(*Tsize_t)(unsafe.Pointer(bp)) { - width = *(*Tsize_t)(unsafe.Pointer(bp)) + if width < **(**Tsize_t)(__ccgo_up(bp)) { + width = **(**Tsize_t)(__ccgo_up(bp)) } d = uint64(0) for { - if !(Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(t + uintptr(d))))-int32('0')) < uint32(10)) { + if !(Uint32FromInt32(Int32FromUint8(**(**uint8)(__ccgo_up(t + uintptr(d))))-int32('0')) < uint32(10)) { break } goto _6 @@ -150226,41 +150226,41 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl if (*Ttm)(unsafe.Pointer(tm)).Ftm_year < -int32(1900) { v2 = l l = l + 1 - *(*uint8)(unsafe.Pointer(s + uintptr(v2))) = uint8('-') + **(**uint8)(__ccgo_up(s + uintptr(v2))) = uint8('-') width = width - 1 } else { if v9 = plus != 0; v9 { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 112))))) == int32('C') { + if Int32FromUint8(**(**uint8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 112))))) == int32('C') { v4 = int32(3) } else { v4 = int32(5) } } - if v9 && d+(width-*(*Tsize_t)(unsafe.Pointer(bp))) >= Uint64FromInt32(v4) { + if v9 && d+(width-**(**Tsize_t)(__ccgo_up(bp))) >= Uint64FromInt32(v4) { v2 = l l = l + 1 - *(*uint8)(unsafe.Pointer(s + uintptr(v2))) = uint8('+') + **(**uint8)(__ccgo_up(s + uintptr(v2))) = uint8('+') width = width - 1 } } for { - if !(width > *(*Tsize_t)(unsafe.Pointer(bp)) && l < n) { + if !(width > **(**Tsize_t)(__ccgo_up(bp)) && l < n) { break } v2 = l l = l + 1 - *(*uint8)(unsafe.Pointer(s + uintptr(v2))) = uint8('0') + **(**uint8)(__ccgo_up(s + uintptr(v2))) = uint8('0') goto _11 _11: ; width = width - 1 } } - if *(*Tsize_t)(unsafe.Pointer(bp)) > n-l { - *(*Tsize_t)(unsafe.Pointer(bp)) = n - l + if **(**Tsize_t)(__ccgo_up(bp)) > n-l { + **(**Tsize_t)(__ccgo_up(bp)) = n - l } - Xmemcpy(tls, s+uintptr(l), t, *(*Tsize_t)(unsafe.Pointer(bp))) - l = l + *(*Tsize_t)(unsafe.Pointer(bp)) + Xmemcpy(tls, s+uintptr(l), t, **(**Tsize_t)(__ccgo_up(bp))) + l = l + **(**Tsize_t)(__ccgo_up(bp)) goto _1 _1: ; @@ -150270,7 +150270,7 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl if l == n { l = n - uint64(1) } - *(*uint8)(unsafe.Pointer(s + uintptr(l))) = uint8(0) + **(**uint8)(__ccgo_up(s + uintptr(l))) = uint8(0) } return uint64(0) } @@ -150308,18 +150308,18 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { var _ /* relyear at bp+8 */ int32 _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = adj, dest, ex, i, len1, min, neg, range1, w, want_century, v1, v2, v5, v6, v8, v9 want_century = 0 - *(*int32)(unsafe.Pointer(bp + 4)) = 0 - *(*int32)(unsafe.Pointer(bp + 8)) = 0 - for *(*uint8)(unsafe.Pointer(f)) != 0 { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) != int32('%') { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) + **(**int32)(__ccgo_up(bp + 4)) = 0 + **(**int32)(__ccgo_up(bp + 8)) = 0 + for **(**uint8)(__ccgo_up(f)) != 0 { + if Int32FromUint8(**(**uint8)(__ccgo_up(f))) != int32('%') { + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(f))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _3 _3: if v2 != 0 { for { - if v8 = *(*uint8)(unsafe.Pointer(s)) != 0; v8 { - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) + if v8 = **(**uint8)(__ccgo_up(s)) != 0; v8 { + v5 = Int32FromUint8(**(**uint8)(__ccgo_up(s))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _7 _7: @@ -150333,7 +150333,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { s = s + 1 } } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) != Int32FromUint8(**(**uint8)(__ccgo_up(f))) { return uintptr(0) } else { s = s + 1 @@ -150343,19 +150343,19 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { continue } f = f + 1 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('+') { + if Int32FromUint8(**(**uint8)(__ccgo_up(f))) == int32('+') { f = f + 1 } - if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(f)))-uint32('0') < uint32(10)) != 0 { + if BoolInt32(uint32(**(**uint8)(__ccgo_up(f)))-uint32('0') < uint32(10)) != 0 { w = Int32FromUint64(Xstrtoul(tls, f, bp+16, int32(10))) - f = *(*uintptr)(unsafe.Pointer(bp + 16)) + f = **(**uintptr)(__ccgo_up(bp + 16)) } else { w = -int32(1) } adj = 0 v9 = f f = f + 1 - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) { + switch Int32FromUint8(**(**uint8)(__ccgo_up(v9))) { case int32('A'): goto _10 case int32('a'): @@ -150506,8 +150506,8 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { ; _44: ; - if v8 = *(*uint8)(unsafe.Pointer(s)) != 0; v8 { - v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) + if v8 = **(**uint8)(__ccgo_up(s)) != 0; v8 { + v1 = Int32FromUint8(**(**uint8)(__ccgo_up(s))) v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _47 _47: @@ -150529,15 +150529,15 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { ex = Xnl_langinfo(tls, int32(AM_STR)) len1 = _strlen(tls, ex) if !(Xstrncasecmp(tls, s, ex, len1) != 0) { - *(*int32)(unsafe.Pointer(tm + 8)) %= int32(12) + **(**int32)(__ccgo_up(tm + 8)) %= int32(12) s = s + uintptr(len1) goto _41 } ex = Xnl_langinfo(tls, int32(PM_STR)) len1 = _strlen(tls, ex) if !(Xstrncasecmp(tls, s, ex, len1) != 0) { - *(*int32)(unsafe.Pointer(tm + 8)) %= int32(12) - *(*int32)(unsafe.Pointer(tm + 8)) += int32(12) + **(**int32)(__ccgo_up(tm + 8)) %= int32(12) + **(**int32)(__ccgo_up(tm + 8)) += int32(12) s = s + uintptr(len1) goto _41 } @@ -150617,7 +150617,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { ; v9 = s s = s + 1 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) != int32('%') { + if Int32FromUint8(**(**uint8)(__ccgo_up(v9))) != int32('%') { return uintptr(0) } goto _41 @@ -150627,27 +150627,27 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { goto numeric_range numeric_range: ; - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } - *(*int32)(unsafe.Pointer(dest)) = 0 + **(**int32)(__ccgo_up(dest)) = 0 i = int32(1) for { - if !(i <= min+range1 && BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0) { + if !(i <= min+range1 && BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-uint32('0') < uint32(10)) != 0) { break } v9 = s s = s + 1 - *(*int32)(unsafe.Pointer(dest)) = *(*int32)(unsafe.Pointer(dest))*int32(10) + Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) - int32('0') + **(**int32)(__ccgo_up(dest)) = **(**int32)(__ccgo_up(dest))*int32(10) + Int32FromUint8(**(**uint8)(__ccgo_up(v9))) - int32('0') goto _50 _50: ; i = i * int32(10) } - if Uint32FromInt32(*(*int32)(unsafe.Pointer(dest))-min) >= Uint32FromInt32(range1) { + if Uint32FromInt32(**(**int32)(__ccgo_up(dest))-min) >= Uint32FromInt32(range1) { return uintptr(0) } - *(*int32)(unsafe.Pointer(dest)) -= adj + **(**int32)(__ccgo_up(dest)) -= adj switch int64(dest) - int64(tm) { case Int64FromUint64(uint64(UintptrFromInt32(0) + 28)): } @@ -150656,36 +150656,36 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { numeric_digits: ; neg = 0 - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('+') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('+') { s = s + 1 } else { - if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('-') { + if Int32FromUint8(**(**uint8)(__ccgo_up(s))) == int32('-') { neg = int32(1) s = s + 1 } } - if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { + if !(BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } v1 = Int32FromInt32(0) i = v1 - *(*int32)(unsafe.Pointer(dest)) = v1 + **(**int32)(__ccgo_up(dest)) = v1 for { - if !(i < w && BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0) { + if !(i < w && BoolInt32(uint32(**(**uint8)(__ccgo_up(s)))-uint32('0') < uint32(10)) != 0) { break } v9 = s s = s + 1 - *(*int32)(unsafe.Pointer(dest)) = *(*int32)(unsafe.Pointer(dest))*int32(10) + Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) - int32('0') + **(**int32)(__ccgo_up(dest)) = **(**int32)(__ccgo_up(dest))*int32(10) + Int32FromUint8(**(**uint8)(__ccgo_up(v9))) - int32('0') goto _52 _52: ; i = i + 1 } if neg != 0 { - *(*int32)(unsafe.Pointer(dest)) = -*(*int32)(unsafe.Pointer(dest)) + **(**int32)(__ccgo_up(dest)) = -**(**int32)(__ccgo_up(dest)) } - *(*int32)(unsafe.Pointer(dest)) -= adj + **(**int32)(__ccgo_up(dest)) -= adj goto update goto symbolic_range symbolic_range: @@ -150701,7 +150701,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { goto _55 } s = s + uintptr(len1) - *(*int32)(unsafe.Pointer(dest)) = i % range1 + **(**int32)(__ccgo_up(dest)) = i % range1 break goto _55 _55: @@ -150719,12 +150719,12 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { _41: } if want_century != 0 { - (*Ttm)(unsafe.Pointer(tm)).Ftm_year = *(*int32)(unsafe.Pointer(bp + 8)) + (*Ttm)(unsafe.Pointer(tm)).Ftm_year = **(**int32)(__ccgo_up(bp + 8)) if want_century&int32(2) != 0 { - *(*int32)(unsafe.Pointer(tm + 20)) += *(*int32)(unsafe.Pointer(bp + 4))*int32(100) - int32(1900) + **(**int32)(__ccgo_up(tm + 20)) += **(**int32)(__ccgo_up(bp + 4))*int32(100) - int32(1900) } else { if (*Ttm)(unsafe.Pointer(tm)).Ftm_year <= int32(68) { - *(*int32)(unsafe.Pointer(tm + 20)) += int32(100) + **(**int32)(__ccgo_up(tm + 20)) += int32(100) } } } @@ -150741,9 +150741,9 @@ func Xtime(tls *TLS, t uintptr) (r Ttime_t) { var _ /* ts at bp+0 */ Ttimespec X__clock_gettime(tls, CLOCK_REALTIME, bp) if t != 0 { - *(*Ttime_t)(unsafe.Pointer(t)) = (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec + **(**Ttime_t)(__ccgo_up(t)) = (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec } - return (*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec + return (**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec } func Xtimegm(tls *TLS, tm uintptr) (r Ttime_t) { @@ -150758,10 +150758,10 @@ func Xtimegm(tls *TLS, tm uintptr) (r Ttime_t) { _ = t t = X__tm_to_secs(tls, tm) if X__secs_to_tm(tls, t, bp) < 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EOVERFLOW) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EOVERFLOW) return int64(-int32(1)) } - *(*Ttm1)(unsafe.Pointer(tm)) = *(*Ttm1)(unsafe.Pointer(bp)) + **(**Ttm1)(__ccgo_up(tm)) = **(**Ttm1)(__ccgo_up(bp)) (*Ttm1)(unsafe.Pointer(tm)).Ftm_isdst = 0 (*Ttm1)(unsafe.Pointer(tm)).Ftm_gmtoff = 0 (*Ttm1)(unsafe.Pointer(tm)).Ftm_zone = uintptr(unsafe.Pointer(&X__utc)) @@ -150919,92 +150919,92 @@ func X__wcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl if !(l < n) { break } - if !(*(*Twchar_t)(unsafe.Pointer(f)) != 0) { - *(*Twchar_t)(unsafe.Pointer(s + uintptr(l)*4)) = 0 + if !(**(**Twchar_t)(__ccgo_up(f)) != 0) { + **(**Twchar_t)(__ccgo_up(s + uintptr(l)*4)) = 0 return l } - if *(*Twchar_t)(unsafe.Pointer(f)) != int32('%') { + if **(**Twchar_t)(__ccgo_up(f)) != int32('%') { v2 = l l = l + 1 - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = *(*Twchar_t)(unsafe.Pointer(f)) + **(**Twchar_t)(__ccgo_up(s + uintptr(v2)*4)) = **(**Twchar_t)(__ccgo_up(f)) goto _1 } f += 4 pad = 0 - if *(*Twchar_t)(unsafe.Pointer(f)) == int32('-') || *(*Twchar_t)(unsafe.Pointer(f)) == int32('_') || *(*Twchar_t)(unsafe.Pointer(f)) == int32('0') { + if **(**Twchar_t)(__ccgo_up(f)) == int32('-') || **(**Twchar_t)(__ccgo_up(f)) == int32('_') || **(**Twchar_t)(__ccgo_up(f)) == int32('0') { v3 = f f += 4 - pad = *(*Twchar_t)(unsafe.Pointer(v3)) + pad = **(**Twchar_t)(__ccgo_up(v3)) } - v4 = BoolInt32(*(*Twchar_t)(unsafe.Pointer(f)) == Int32FromUint8('+')) + v4 = BoolInt32(**(**Twchar_t)(__ccgo_up(f)) == Int32FromUint8('+')) plus = v4 if v4 != 0 { f += 4 } width = Xwcstoul(tls, f, bp+512, int32(10)) - if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 512)))) == int32('C') || *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 512)))) == int32('F') || *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 512)))) == int32('G') || *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 512)))) == int32('Y') { - if !(width != 0) && *(*uintptr)(unsafe.Pointer(bp + 512)) != f { + if **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 512)))) == int32('C') || **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 512)))) == int32('F') || **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 512)))) == int32('G') || **(**Twchar_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 512)))) == int32('Y') { + if !(width != 0) && **(**uintptr)(__ccgo_up(bp + 512)) != f { width = uint64(1) } } else { width = uint64(0) } - f = *(*uintptr)(unsafe.Pointer(bp + 512)) - if *(*Twchar_t)(unsafe.Pointer(f)) == int32('E') || *(*Twchar_t)(unsafe.Pointer(f)) == int32('O') { + f = **(**uintptr)(__ccgo_up(bp + 512)) + if **(**Twchar_t)(__ccgo_up(f)) == int32('E') || **(**Twchar_t)(__ccgo_up(f)) == int32('O') { f += 4 } - t_mb = X__strftime_fmt_1(tls, bp+8, bp, *(*Twchar_t)(unsafe.Pointer(f)), tm, loc, pad) + t_mb = X__strftime_fmt_1(tls, bp+8, bp, **(**Twchar_t)(__ccgo_up(f)), tm, loc, pad) if !(t_mb != 0) { break } - *(*Tsize_t)(unsafe.Pointer(bp)) = Xmbstowcs(tls, bp+108, t_mb, Uint64FromInt64(400)/Uint64FromInt64(4)) - if *(*Tsize_t)(unsafe.Pointer(bp)) == Uint64FromInt32(-Int32FromInt32(1)) { + **(**Tsize_t)(__ccgo_up(bp)) = Xmbstowcs(tls, bp+108, t_mb, Uint64FromInt64(400)/Uint64FromInt64(4)) + if **(**Tsize_t)(__ccgo_up(bp)) == Uint64FromInt32(-Int32FromInt32(1)) { return uint64(0) } t = bp + 108 if width != 0 { for { - if !(*(*Twchar_t)(unsafe.Pointer(t)) == int32('+') || *(*Twchar_t)(unsafe.Pointer(t)) == int32('-') || *(*Twchar_t)(unsafe.Pointer(t)) == int32('0') && *(*Twchar_t)(unsafe.Pointer(t + 1*4)) != 0) { + if !(**(**Twchar_t)(__ccgo_up(t)) == int32('+') || **(**Twchar_t)(__ccgo_up(t)) == int32('-') || **(**Twchar_t)(__ccgo_up(t)) == int32('0') && **(**Twchar_t)(__ccgo_up(t + 1*4)) != 0) { break } goto _5 _5: ; t += 4 - *(*Tsize_t)(unsafe.Pointer(bp)) = *(*Tsize_t)(unsafe.Pointer(bp)) - 1 + **(**Tsize_t)(__ccgo_up(bp)) = **(**Tsize_t)(__ccgo_up(bp)) - 1 } width = width - 1 if plus != 0 && (*Ttm)(unsafe.Pointer(tm)).Ftm_year >= Int32FromInt32(10000)-Int32FromInt32(1900) { v2 = l l = l + 1 - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = int32('+') + **(**Twchar_t)(__ccgo_up(s + uintptr(v2)*4)) = int32('+') } else { if (*Ttm)(unsafe.Pointer(tm)).Ftm_year < -int32(1900) { v2 = l l = l + 1 - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = int32('-') + **(**Twchar_t)(__ccgo_up(s + uintptr(v2)*4)) = int32('-') } else { width = width + 1 } } for { - if !(width > *(*Tsize_t)(unsafe.Pointer(bp)) && l < n) { + if !(width > **(**Tsize_t)(__ccgo_up(bp)) && l < n) { break } v2 = l l = l + 1 - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = int32('0') + **(**Twchar_t)(__ccgo_up(s + uintptr(v2)*4)) = int32('0') goto _8 _8: ; width = width - 1 } } - if *(*Tsize_t)(unsafe.Pointer(bp)) >= n-l { - *(*Tsize_t)(unsafe.Pointer(bp)) = n - l + if **(**Tsize_t)(__ccgo_up(bp)) >= n-l { + **(**Tsize_t)(__ccgo_up(bp)) = n - l } - Xwmemcpy(tls, s+uintptr(l)*4, t, *(*Tsize_t)(unsafe.Pointer(bp))) - l = l + *(*Tsize_t)(unsafe.Pointer(bp)) + Xwmemcpy(tls, s+uintptr(l)*4, t, **(**Tsize_t)(__ccgo_up(bp))) + l = l + **(**Tsize_t)(__ccgo_up(bp)) goto _1 _1: ; @@ -151014,7 +151014,7 @@ func X__wcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl if l == n { l = n - uint64(1) } - *(*Twchar_t)(unsafe.Pointer(s + uintptr(l)*4)) = 0 + **(**Twchar_t)(__ccgo_up(s + uintptr(l)*4)) = 0 } return uint64(0) } @@ -151067,14 +151067,14 @@ func Xalarm(tls *TLS, seconds uint32) (r uint32) { defer tls.Free(64) var _ /* it at bp+0 */ Titimerval var _ /* old at bp+32 */ Titimerval - *(*Titimerval)(unsafe.Pointer(bp)) = Titimerval{ + **(**Titimerval)(__ccgo_up(bp)) = Titimerval{ Fit_value: Ttimeval{ Ftv_sec: Int64FromUint32(seconds), }, } - *(*Titimerval)(unsafe.Pointer(bp + 32)) = Titimerval{} + **(**Titimerval)(__ccgo_up(bp + 32)) = Titimerval{} Xsetitimer(tls, ITIMER_REAL, bp, bp+32) - return Uint32FromInt64((*(*Titimerval)(unsafe.Pointer(bp + 32))).Fit_value.Ftv_sec + BoolInt64(!!((*(*Titimerval)(unsafe.Pointer(bp + 32))).Fit_value.Ftv_usec != 0))) + return Uint32FromInt64((**(**Titimerval)(__ccgo_up(bp + 32))).Fit_value.Ftv_sec + BoolInt64(!!((**(**Titimerval)(__ccgo_up(bp + 32))).Fit_value.Ftv_usec != 0))) } func Xchdir(tls *TLS, path uintptr) (r int32) { @@ -151215,7 +151215,7 @@ func _checker(tls *TLS, p uintptr) (r int32) { if X__syscall2(tls, int64(SYS_setregid), X__syscall0(tls, int64(SYS_getegid)), int64(-Int32FromInt32(1))) != 0 || X__syscall2(tls, int64(SYS_setreuid), X__syscall0(tls, int64(SYS_geteuid)), int64(-Int32FromInt32(1))) != 0 { X__syscall1(tls, int64(SYS_exit), int64(Int32FromInt32(1))) } - *(*int32)(unsafe.Pointer(bp)) = int32(X__syscall4(tls, int64(SYS_faccessat), int64((*Tctx1)(unsafe.Pointer(c)).Ffd), int64((*Tctx1)(unsafe.Pointer(c)).Ffilename), int64((*Tctx1)(unsafe.Pointer(c)).Famode), int64(Int32FromInt32(0)))) + **(**int32)(__ccgo_up(bp)) = int32(X__syscall4(tls, int64(SYS_faccessat), int64((*Tctx1)(unsafe.Pointer(c)).Ffd), int64((*Tctx1)(unsafe.Pointer(c)).Ffilename), int64((*Tctx1)(unsafe.Pointer(c)).Famode), int64(Int32FromInt32(0)))) X__syscall3(tls, int64(SYS_write), int64((*Tctx1)(unsafe.Pointer(c)).Fp), int64(bp), Int64FromUint64(Uint64FromInt64(4))) return 0 } @@ -151330,7 +151330,7 @@ func Xgetcwd(tls *TLS, buf uintptr, size Tsize_t) (r uintptr) { size = v1 } else { if !(size != 0) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EINVAL) return uintptr(0) } } @@ -151338,8 +151338,8 @@ func Xgetcwd(tls *TLS, buf uintptr, size Tsize_t) (r uintptr) { if ret < 0 { return uintptr(0) } - if ret == 0 || Int32FromUint8(*(*uint8)(unsafe.Pointer(buf))) != int32('/') { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOENT) + if ret == 0 || Int32FromUint8(**(**uint8)(__ccgo_up(buf))) != int32('/') { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOENT) return uintptr(0) } if buf == tmp { @@ -151403,8 +151403,8 @@ func Xgethostname(tls *TLS, name uintptr, len1 Tsize_t) (r int32) { i = uint64(0) for { if v3 = i < len1; v3 { - v2 = *(*uint8)(unsafe.Pointer(bp + 65 + uintptr(i))) - *(*uint8)(unsafe.Pointer(name + uintptr(i))) = v2 + v2 = **(**uint8)(__ccgo_up(bp + 65 + uintptr(i))) + **(**uint8)(__ccgo_up(name + uintptr(i))) = v2 } if !(v3 && v2 != 0) { break @@ -151415,7 +151415,7 @@ func Xgethostname(tls *TLS, name uintptr, len1 Tsize_t) (r int32) { i = i + 1 } if i != 0 && i == len1 { - *(*uint8)(unsafe.Pointer(name + uintptr(i-uint64(1)))) = uint8(0) + **(**uint8)(__ccgo_up(name + uintptr(i-uint64(1)))) = uint8(0) } return 0 } @@ -151508,8 +151508,8 @@ func Xisatty(tls *TLS, fd int32) (r1 int32) { if r == uint64(0) { return int32(1) } - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != int32(EBADF) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOTTY) + if **(**int32)(__ccgo_up(X__errno_location(tls))) != int32(EBADF) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(ENOTTY) } return 0 } @@ -151574,8 +151574,8 @@ func Xnice(tls *TLS, inc int32) (r int32) { prio = -int32(NZERO) } if Xsetpriority(tls, PRIO_PROCESS, uint32(0), prio) != 0 { - if *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EACCES) { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EPERM) + if **(**int32)(__ccgo_up(X__errno_location(tls))) == int32(EACCES) { + **(**int32)(__ccgo_up(X__errno_location(tls))) = int32(EPERM) } return -int32(1) } else { @@ -151622,12 +151622,12 @@ func Xpipe2(tls *TLS, fd uintptr, flag int32) (r int32) { return ret } if flag&int32(O_CLOEXEC) != 0 { - X__syscall3(tls, int64(SYS_fcntl), int64(*(*int32)(unsafe.Pointer(fd))), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) - X__syscall3(tls, int64(SYS_fcntl), int64(*(*int32)(unsafe.Pointer(fd + 1*4))), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) + X__syscall3(tls, int64(SYS_fcntl), int64(**(**int32)(__ccgo_up(fd))), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) + X__syscall3(tls, int64(SYS_fcntl), int64(**(**int32)(__ccgo_up(fd + 1*4))), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) } if flag&int32(O_NONBLOCK) != 0 { - X__syscall3(tls, int64(SYS_fcntl), int64(*(*int32)(unsafe.Pointer(fd))), int64(Int32FromInt32(F_SETFL)), int64(Int32FromInt32(O_NONBLOCK))) - X__syscall3(tls, int64(SYS_fcntl), int64(*(*int32)(unsafe.Pointer(fd + 1*4))), int64(Int32FromInt32(F_SETFL)), int64(Int32FromInt32(O_NONBLOCK))) + X__syscall3(tls, int64(SYS_fcntl), int64(**(**int32)(__ccgo_up(fd))), int64(Int32FromInt32(F_SETFL)), int64(Int32FromInt32(O_NONBLOCK))) + X__syscall3(tls, int64(SYS_fcntl), int64(**(**int32)(__ccgo_up(fd + 1*4))), int64(Int32FromInt32(F_SETFL)), int64(Int32FromInt32(O_NONBLOCK))) } return 0 } @@ -151826,7 +151826,7 @@ func X__setxid(tls *TLS, nr int32, id int32, eid int32, sid int32) (r int32) { _ = v1 /* ret is initially nonzero so that failure of the first thread does not * trigger the safety kill above. */ - *(*Tctx2)(unsafe.Pointer(bp)) = Tctx2{ + **(**Tctx2)(__ccgo_up(bp)) = Tctx2{ Fid: id, Feid: eid, Fsid: sid, @@ -151834,10 +151834,10 @@ func X__setxid(tls *TLS, nr int32, id int32, eid int32, sid int32) (r int32) { Fret: int32(1), } ___synccall(tls, __ccgo_fp(_do_setxid), bp) - if (*(*Tctx2)(unsafe.Pointer(bp))).Fret > 0 { + if (**(**Tctx2)(__ccgo_up(bp))).Fret > 0 { v1 = -int32(EAGAIN) } else { - v1 = (*(*Tctx2)(unsafe.Pointer(bp))).Fret + v1 = (**(**Tctx2)(__ccgo_up(bp))).Fret } return int32(X__syscall_ret(tls, Uint64FromInt32(v1))) } @@ -151850,11 +151850,11 @@ func Xsleep(tls *TLS, seconds uint32) (r uint32) { bp := tls.Alloc(16) defer tls.Free(16) var _ /* tv at bp+0 */ Ttimespec - *(*Ttimespec)(unsafe.Pointer(bp)) = Ttimespec{ + **(**Ttimespec)(__ccgo_up(bp)) = Ttimespec{ Ftv_sec: Int64FromUint32(seconds), } if Xnanosleep(tls, bp, bp) != 0 { - return Uint32FromInt64((*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec) + return Uint32FromInt64((**(**Ttimespec)(__ccgo_up(bp))).Ftv_sec) } return uint32(0) } @@ -151893,7 +151893,7 @@ func Xtcgetpgrp(tls *TLS, fd int32) (r Tpid_t) { if Xioctl(tls, fd, int32(TIOCGPGRP), VaList(bp+16, bp)) < 0 { return -int32(1) } - return *(*int32)(unsafe.Pointer(bp)) + return **(**int32)(__ccgo_up(bp)) } func Xtcsetpgrp(tls *TLS, fd int32, pgrp Tpid_t) (r int32) { @@ -151904,7 +151904,7 @@ func Xtcsetpgrp(tls *TLS, fd int32, pgrp Tpid_t) (r int32) { bp := tls.Alloc(32) defer tls.Free(32) var _ /* pgrp_int at bp+0 */ int32 - *(*int32)(unsafe.Pointer(bp)) = pgrp + **(**int32)(__ccgo_up(bp)) = pgrp return Xioctl(tls, fd, int32(TIOCSPGRP), VaList(bp+16, bp)) } @@ -151935,7 +151935,7 @@ func Xttyname(tls *TLS, fd int32) (r uintptr) { v1 = Xttyname_r(tls, fd, uintptr(unsafe.Pointer(&_buf10)), uint64(32)) result = v1 if v1 != 0 { - *(*int32)(unsafe.Pointer(X__errno_location(tls))) = result + **(**int32)(__ccgo_up(X__errno_location(tls))) = result return UintptrFromInt32(0) } return uintptr(unsafe.Pointer(&_buf10)) @@ -151956,22 +151956,22 @@ func Xttyname_r(tls *TLS, fd int32, name uintptr, size Tsize_t) (r int32) { var _ /* st2 at bp+144 */ Tstat _ = l if !(Xisatty(tls, fd) != 0) { - return *(*int32)(unsafe.Pointer(X__errno_location(tls))) + return **(**int32)(__ccgo_up(X__errno_location(tls))) } X__procfdname(tls, bp+288, Uint32FromInt32(fd)) l = Xreadlink(tls, bp+288, name, size) if l < 0 { - return *(*int32)(unsafe.Pointer(X__errno_location(tls))) + return **(**int32)(__ccgo_up(X__errno_location(tls))) } else { if Uint64FromInt64(l) == size { return int32(ERANGE) } } - *(*uint8)(unsafe.Pointer(name + uintptr(l))) = uint8(0) + **(**uint8)(__ccgo_up(name + uintptr(l))) = uint8(0) if Xstat(tls, name, bp) != 0 || Xfstat(tls, fd, bp+144) != 0 { - return *(*int32)(unsafe.Pointer(X__errno_location(tls))) + return **(**int32)(__ccgo_up(X__errno_location(tls))) } - if (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev != (*(*Tstat)(unsafe.Pointer(bp + 144))).Fst_dev || (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino != (*(*Tstat)(unsafe.Pointer(bp + 144))).Fst_ino { + if (**(**Tstat)(__ccgo_up(bp))).Fst_dev != (**(**Tstat)(__ccgo_up(bp + 144))).Fst_dev || (**(**Tstat)(__ccgo_up(bp))).Fst_ino != (**(**Tstat)(__ccgo_up(bp + 144))).Fst_ino { return int32(ENODEV) } return 0 @@ -151986,7 +151986,7 @@ func Xualarm(tls *TLS, value uint32, interval uint32) (r uint32) { defer tls.Free(64) var _ /* it at bp+0 */ Titimerval var _ /* it_old at bp+32 */ Titimerval - *(*Titimerval)(unsafe.Pointer(bp)) = Titimerval{ + **(**Titimerval)(__ccgo_up(bp)) = Titimerval{ Fit_interval: Ttimeval{ Ftv_usec: Int64FromUint32(interval), }, @@ -151995,7 +151995,7 @@ func Xualarm(tls *TLS, value uint32, interval uint32) (r uint32) { }, } Xsetitimer(tls, ITIMER_REAL, bp, bp+32) - return Uint32FromInt64((*(*Titimerval)(unsafe.Pointer(bp + 32))).Fit_value.Ftv_sec*int64(1000000) + (*(*Titimerval)(unsafe.Pointer(bp + 32))).Fit_value.Ftv_usec) + return Uint32FromInt64((**(**Titimerval)(__ccgo_up(bp + 32))).Fit_value.Ftv_sec*int64(1000000) + (**(**Titimerval)(__ccgo_up(bp + 32))).Fit_value.Ftv_usec) } func Xunlink(tls *TLS, path uintptr) (r int32) { @@ -152022,7 +152022,7 @@ func Xusleep(tls *TLS, useconds uint32) (r int32) { bp := tls.Alloc(16) defer tls.Free(16) var _ /* tv at bp+0 */ Ttimespec - *(*Ttimespec)(unsafe.Pointer(bp)) = Ttimespec{ + **(**Ttimespec)(__ccgo_up(bp)) = Ttimespec{ Ftv_sec: Int64FromUint32(useconds / uint32(1000000)), Ftv_nsec: Int64FromUint32(useconds % uint32(1000000) * uint32(1000)), } @@ -152050,6 +152050,10 @@ func __ccgo_fp(f interface{}) uintptr { return (*iface)(unsafe.Pointer(&f))[1] } +func __ccgo_up(n uintptr) unsafe.Pointer { + return unsafe.Pointer(&n) +} + var X__abort_lock [1]int32 var X__at_quick_exit_lockptr = uintptr(unsafe.Pointer(&_lock)) diff --git a/vendor/modernc.org/libc/etc.go b/vendor/modernc.org/libc/etc.go index 4b71ca3b70..dab9f156ff 100644 --- a/vendor/modernc.org/libc/etc.go +++ b/vendor/modernc.org/libc/etc.go @@ -149,23 +149,23 @@ func addObject(o interface{}) uintptr { func getObject(t uintptr) interface{} { objectMu.Lock() + defer objectMu.Unlock() o := objects[t] if o == nil { panic(todo("", t)) } - objectMu.Unlock() return o } func removeObject(t uintptr) { objectMu.Lock() + defer objectMu.Unlock() if _, ok := objects[t]; !ok { panic(todo("")) } delete(objects, t) - objectMu.Unlock() } func (t *TLS) setErrno(err interface{}) { diff --git a/vendor/modernc.org/libc/libc.go b/vendor/modernc.org/libc/libc.go index 045ac8638f..8f0acef7cb 100644 --- a/vendor/modernc.org/libc/libc.go +++ b/vendor/modernc.org/libc/libc.go @@ -155,8 +155,8 @@ func exit(t *TLS, status int32, audit bool) { CoverCReport(buf) buf.Flush() } - for _, v := range atExit { - v() + for i := len(atExit) - 1; i >= 0; i-- { + atExit[i]() } if audit { t.Close() @@ -2441,9 +2441,16 @@ func Xfgets(t *TLS, s uintptr, size int32, stream uintptr) uintptr { if __ccgo_strace { trc("t=%v s=%v size=%v stream=%v, (%v:)", t, s, size, stream, origin(2)) } + if size < 1 { + return 0 + } + if size == 1 { + *(*byte)(unsafe.Pointer(s)) = 0 + return s + } var b []byte out: - for ; size > 0; size-- { + for ; size > 1; size-- { switch c := Xfgetc(t, stream); c { case '\n': b = append(b, byte(c)) diff --git a/vendor/modernc.org/libc/libc32.go b/vendor/modernc.org/libc/libc32.go index e24ffc798b..b6346c058b 100644 --- a/vendor/modernc.org/libc/libc32.go +++ b/vendor/modernc.org/libc/libc32.go @@ -29,11 +29,11 @@ type ( } ) -type bits []int +type bitz []int // was bits but that is now an import qaulifier in use by mem.go -func newBits(n int) (r bits) { return make(bits, (n+31)>>5) } -func (b bits) has(n int) bool { return b != nil && b[n>>5]&(1<>5] |= 1 << uint(n&31) } +func newBits(n int) (r bitz) { return make(bitz, (n+31)>>5) } +func (b bitz) has(n int) bool { return b != nil && b[n>>5]&(1<>5] |= 1 << uint(n&31) } func Xstrchrnul(tls *TLS, s uintptr, c int32) (r uintptr) { return x___strchrnul(tls, s, c) diff --git a/vendor/modernc.org/libc/libc64.go b/vendor/modernc.org/libc/libc64.go index 219255ea1d..8870bd2722 100644 --- a/vendor/modernc.org/libc/libc64.go +++ b/vendor/modernc.org/libc/libc64.go @@ -27,11 +27,11 @@ type ( } ) -type bits []int +type bitz []int // was bits but that is now an import qaulifier in use by mem.go -func newBits(n int) (r bits) { return make(bits, (n+63)>>6) } -func (b bits) has(n int) bool { return b != nil && b[n>>6]&(1<>6] |= 1 << uint(n&63) } +func newBits(n int) (r bitz) { return make(bitz, (n+63)>>6) } +func (b bitz) has(n int) bool { return b != nil && b[n>>6]&(1<>6] |= 1 << uint(n&63) } func Xstrchrnul(tls *TLS, s uintptr, c int32) (r uintptr) { if __ccgo_strace { diff --git a/vendor/modernc.org/libc/libc_darwin.go b/vendor/modernc.org/libc/libc_darwin.go index 78f5284257..f414444094 100644 --- a/vendor/modernc.org/libc/libc_darwin.go +++ b/vendor/modernc.org/libc/libc_darwin.go @@ -1567,6 +1567,9 @@ func Xfread(t *TLS, ptr uintptr, size, nmemb types.Size_t, stream uintptr) types if __ccgo_strace { trc("t=%v ptr=%v nmemb=%v stream=%v, (%v:)", t, ptr, nmemb, stream, origin(2)) } + if size == 0 || nmemb == 0 { + return 0 + } fd := uintptr(file(stream).fd()) count := size * nmemb var n int @@ -1602,6 +1605,9 @@ func Xfwrite(t *TLS, ptr uintptr, size, nmemb types.Size_t, stream uintptr) type if __ccgo_strace { trc("t=%v ptr=%v nmemb=%v stream=%v, (%v:)", t, ptr, nmemb, stream, origin(2)) } + if size == 0 || nmemb == 0 { + return 0 + } fd := uintptr(file(stream).fd()) count := size * nmemb var n int diff --git a/vendor/modernc.org/libc/libc_freebsd.go b/vendor/modernc.org/libc/libc_freebsd.go index f2f1952067..1974379433 100644 --- a/vendor/modernc.org/libc/libc_freebsd.go +++ b/vendor/modernc.org/libc/libc_freebsd.go @@ -1366,6 +1366,9 @@ func Xfread(t *TLS, ptr uintptr, size, nmemb types.Size_t, stream uintptr) types if __ccgo_strace { trc("t=%v ptr=%v nmemb=%v stream=%v, (%v:)", t, ptr, nmemb, stream, origin(2)) } + if size == 0 || nmemb == 0 { + return 0 + } m, _, err := unix.Syscall(unix.SYS_READ, uintptr(file(stream).fd()), ptr, uintptr(size*nmemb)) if err != 0 { file(stream).setErr() @@ -1384,6 +1387,9 @@ func Xfwrite(t *TLS, ptr uintptr, size, nmemb types.Size_t, stream uintptr) type if __ccgo_strace { trc("t=%v ptr=%v nmemb=%v stream=%v, (%v:)", t, ptr, nmemb, stream, origin(2)) } + if size == 0 || nmemb == 0 { + return 0 + } m, _, err := unix.Syscall(unix.SYS_WRITE, uintptr(file(stream).fd()), ptr, uintptr(size*nmemb)) if err != 0 { file(stream).setErr() diff --git a/vendor/modernc.org/libc/libc_musl.go b/vendor/modernc.org/libc/libc_musl.go index fc58b07a29..69cfff5c1a 100644 --- a/vendor/modernc.org/libc/libc_musl.go +++ b/vendor/modernc.org/libc/libc_musl.go @@ -482,11 +482,12 @@ func (tls *TLS) Longjmp(jb uintptr, val int32) { func Xexit(tls *TLS, code int32) { //TODO atexit finalizers X__stdio_exit(tls) - for _, v := range atExit { - v() + for i := len(atExit) - 1; i >= 0; i-- { + atExit[i]() } atExitHandlersMu.Lock() - for _, v := range atExitHandlers { + for i := len(atExitHandlers) - 1; i >= 0; i-- { + v := atExitHandlers[i] (*(*func(*TLS))(unsafe.Pointer(&struct{ uintptr }{v})))(tls) } os.Exit(int(code)) @@ -1069,7 +1070,6 @@ func Xsysctlbyname(t *TLS, name, oldp, oldlenp, newp uintptr, newlen Tsize_t) in *(*int32)(unsafe.Pointer(oldp)) = int32(runtime.GOMAXPROCS(-1)) return 0 default: - panic(todo("")) t.setErrno(ENOENT) return -1 } diff --git a/vendor/modernc.org/libc/libc_netbsd.go b/vendor/modernc.org/libc/libc_netbsd.go index 05f399e557..59636996b3 100644 --- a/vendor/modernc.org/libc/libc_netbsd.go +++ b/vendor/modernc.org/libc/libc_netbsd.go @@ -1362,6 +1362,9 @@ func Xfread(t *TLS, ptr uintptr, size, nmemb types.Size_t, stream uintptr) types if __ccgo_strace { trc("t=%v ptr=%v nmemb=%v stream=%v, (%v:)", t, ptr, nmemb, stream, origin(2)) } + if size == 0 || nmemb == 0 { + return 0 + } m, _, err := unix.Syscall(unix.SYS_READ, uintptr(file(stream).fd()), ptr, uintptr(size*nmemb)) if err != 0 { file(stream).setErr() @@ -1380,6 +1383,9 @@ func Xfwrite(t *TLS, ptr uintptr, size, nmemb types.Size_t, stream uintptr) type if __ccgo_strace { trc("t=%v ptr=%v nmemb=%v stream=%v, (%v:)", t, ptr, nmemb, stream, origin(2)) } + if size == 0 || nmemb == 0 { + return 0 + } m, _, err := unix.Syscall(unix.SYS_WRITE, uintptr(file(stream).fd()), ptr, uintptr(size*nmemb)) if err != 0 { file(stream).setErr() diff --git a/vendor/modernc.org/libc/libc_openbsd.go b/vendor/modernc.org/libc/libc_openbsd.go index 8b2edaab10..d26eb9fa4e 100644 --- a/vendor/modernc.org/libc/libc_openbsd.go +++ b/vendor/modernc.org/libc/libc_openbsd.go @@ -1415,7 +1415,10 @@ func Xfflush(t *TLS, stream uintptr) int32 { // size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream); func Xfread(t *TLS, ptr uintptr, size, nmemb types.Size_t, stream uintptr) types.Size_t { if __ccgo_strace { - trc("t=%v ptr=%+v nmemb=%d stream=%v, (%v:)", t, unsafe.Slice((*byte)(unsafe.Pointer(ptr)), nmemb), nmemb, *(*int32)(unsafe.Pointer(stream)), origin(2)) + trc("t=%v ptr=%v size=%v nmemb=%v stream=%v, (%v:)", t, ptr, size, nmemb, stream, origin(2)) + } + if size == 0 || nmemb == 0 { + return 0 } buf := unsafe.Slice((*byte)(unsafe.Pointer(ptr)), nmemb*size) m, err := unix.Read(int(file(stream).fd()), buf) @@ -1436,6 +1439,9 @@ func Xfwrite(t *TLS, ptr uintptr, size, nmemb types.Size_t, stream uintptr) type if __ccgo_strace { trc("t=%v ptr=%v nmemb=%v stream=%v, (%v:)", t, ptr, nmemb, stream, origin(2)) } + if size == 0 || nmemb == 0 { + return 0 + } buf := unsafe.Slice((*byte)(unsafe.Pointer(ptr)), nmemb*size) m, err := unix.Write(int(file(stream).fd()), buf) if err != nil { diff --git a/vendor/modernc.org/libc/libc_unix.go b/vendor/modernc.org/libc/libc_unix.go index 69b10279a5..f7ec665305 100644 --- a/vendor/modernc.org/libc/libc_unix.go +++ b/vendor/modernc.org/libc/libc_unix.go @@ -42,49 +42,51 @@ func init() { atExit = append(atExit, func() { closePasswd(&staticGetpwnam) }) } +var ( + signalCh chan os.Signal + signalTls *TLS + signalInit sync.Once +) + +func startSignalHandler() { + signalCh = make(chan os.Signal, 10) + signalTls = NewTLS() + go func() { + for sig := range signalCh { + if s, ok := sig.(unix.Signal); ok { + signum := int32(s) + signalsMu.Lock() + handler := signals[signum] + signalsMu.Unlock() + if handler != 0 && handler != signal.SIG_DFL && handler != signal.SIG_IGN { + var f func(*TLS, int32) + *(*uintptr)(unsafe.Pointer(&f)) = handler + f(signalTls, signum) + } + } + } + }() +} + // sighandler_t signal(int signum, sighandler_t handler); func Xsignal(t *TLS, signum int32, handler uintptr) uintptr { //TODO use sigaction? if __ccgo_strace { trc("t=%v signum=%v handler=%v, (%v:)", t, signum, handler, origin(2)) } - signalsMu.Lock() + signalInit.Do(startSignalHandler) + signalsMu.Lock() defer signalsMu.Unlock() r := signals[signum] signals[signum] = handler switch handler { case signal.SIG_DFL: - panic(todo("%v %#x", unix.Signal(signum), handler)) + gosignal.Reset(unix.Signal(signum)) case signal.SIG_IGN: - switch r { - case signal.SIG_DFL: - gosignal.Ignore(unix.Signal(signum)) //TODO - case signal.SIG_IGN: - gosignal.Ignore(unix.Signal(signum)) - default: - panic(todo("%v %#x", unix.Signal(signum), handler)) - } + gosignal.Ignore(unix.Signal(signum)) default: - switch r { - case signal.SIG_DFL: - c := make(chan os.Signal, 1) - gosignal.Notify(c, unix.Signal(signum)) - go func() { //TODO mechanism to stop/cancel - for { - <-c - var f func(*TLS, int32) - *(*uintptr)(unsafe.Pointer(&f)) = handler - tls := NewTLS() - f(tls, signum) - tls.Close() - } - }() - case signal.SIG_IGN: - panic(todo("%v %#x", unix.Signal(signum), handler)) - default: - panic(todo("%v %#x", unix.Signal(signum), handler)) - } + gosignal.Notify(signalCh, unix.Signal(signum)) } return r } diff --git a/vendor/modernc.org/libc/libc_windows.go b/vendor/modernc.org/libc/libc_windows.go index c72c78a388..bc3366ca98 100644 --- a/vendor/modernc.org/libc/libc_windows.go +++ b/vendor/modernc.org/libc/libc_windows.go @@ -1865,6 +1865,9 @@ func Xfread(t *TLS, ptr uintptr, size, nmemb types.Size_t, stream uintptr) types if __ccgo_strace { trc("t=%v ptr=%v nmemb=%v stream=%v, (%v:)", t, ptr, nmemb, stream, origin(2)) } + if size == 0 || nmemb == 0 { + return 0 + } f, ok := winGetObject(stream).(*file) if !ok { t.setErrno(errno.EBADF) @@ -1881,7 +1884,7 @@ func Xfread(t *TLS, ptr uintptr, size, nmemb types.Size_t, stream uintptr) types if dmesgs { // dmesg("%v: %d %#x x %#x: %#x\n%s", origin(1), file(stream).fd(), size, nmemb, types.Size_t(m)/size, hex.Dump(GoBytes(ptr, int(m)))) - dmesg("%v: %d %#x x %#x: %#x\n%s", origin(1), f._fd, size, nmemb, types.Size_t(n)/size) + dmesg("%v: %d %#x x %#x: %#x", origin(1), f._fd, size, nmemb, types.Size_t(n)/size) } return types.Size_t(n) / size @@ -1893,7 +1896,7 @@ func Xfwrite(t *TLS, ptr uintptr, size, nmemb types.Size_t, stream uintptr) type if __ccgo_strace { trc("t=%v ptr=%v nmemb=%v stream=%v, (%v:)", t, ptr, nmemb, stream, origin(2)) } - if ptr == 0 || size == 0 { + if ptr == 0 || size == 0 || nmemb == 0 { return 0 } @@ -1913,7 +1916,7 @@ func Xfwrite(t *TLS, ptr uintptr, size, nmemb types.Size_t, stream uintptr) type if dmesgs { // // dmesg("%v: %d %#x x %#x: %#x\n%s", origin(1), file(stream).fd(), size, nmemb, types.Size_t(m)/size, hex.Dump(GoBytes(ptr, int(m)))) - dmesg("%v: %d %#x x %#x: %#x\n%s", origin(1), f._fd, size, nmemb, types.Size_t(n)/size) + dmesg("%v: %d %#x x %#x: %#x", origin(1), f._fd, size, nmemb, types.Size_t(n)/size) } return types.Size_t(n) / size } diff --git a/vendor/modernc.org/libc/mem.go b/vendor/modernc.org/libc/mem.go index c8a4f7fe7c..9c642d0f99 100644 --- a/vendor/modernc.org/libc/mem.go +++ b/vendor/modernc.org/libc/mem.go @@ -7,6 +7,9 @@ package libc // import "modernc.org/libc" import ( + "math" + "math/bits" + "modernc.org/libc/errno" "modernc.org/libc/sys/types" "modernc.org/memory" @@ -47,7 +50,12 @@ func Xcalloc(t *TLS, n, size types.Size_t) uintptr { if __ccgo_strace { trc("t=%v n=%v size=%v, (%v:)", t, n, size, origin(2)) } - rq := int(n * size) + hi, rq0 := bits.Mul(uint(n), uint(size)) + if hi != 0 || rq0 > math.MaxInt { + t.setErrno(errno.ENOMEM) + return 0 + } + rq := int(rq0) if rq == 0 { rq = 1 } diff --git a/vendor/modernc.org/libc/mem_brk.go b/vendor/modernc.org/libc/mem_brk.go index 4a76fab7b7..4da8339769 100644 --- a/vendor/modernc.org/libc/mem_brk.go +++ b/vendor/modernc.org/libc/mem_brk.go @@ -12,6 +12,8 @@ package libc // import "modernc.org/libc" import ( + "math" + "math/bits" "unsafe" "modernc.org/libc/errno" @@ -61,7 +63,12 @@ func Xcalloc(t *TLS, n, size types.Size_t) uintptr { if __ccgo_strace { trc("t=%v n=%v size=%v, (%v:)", t, n, size, origin(2)) } - return Xmalloc(t, n*size) + hi, rq := bits.Mul(uint(n), uint(size)) + if hi != 0 || rq > math.MaxInt { + t.setErrno(errno.ENOMEM) + return 0 + } + return Xmalloc(t, types.Size_t(rq)) } // void *realloc(void *ptr, size_t size); @@ -92,6 +99,9 @@ func Xfree(t *TLS, p uintptr) { } func UsableSize(p uintptr) types.Size_t { + if p == 0 { + return 0 + } return types.Size_t(*(*uintptr)(unsafe.Pointer(p - uintptrSize))) } diff --git a/vendor/modernc.org/libc/mem_brk_musl.go b/vendor/modernc.org/libc/mem_brk_musl.go index c0a4ade52a..22bb19f8a3 100644 --- a/vendor/modernc.org/libc/mem_brk_musl.go +++ b/vendor/modernc.org/libc/mem_brk_musl.go @@ -185,6 +185,9 @@ func Xrealloc(tls *TLS, p uintptr, n Tsize_t) (r uintptr) { // malloc r = malloc0(tls, pc, n, false) + if r == 0 { + return 0 + } copy(unsafe.Slice((*byte)(unsafe.Pointer(r)), usable), unsafe.Slice((*byte)(unsafe.Pointer(p)), usable)) Xfree(tls, p) return r diff --git a/vendor/modernc.org/libc/memgrind.go b/vendor/modernc.org/libc/memgrind.go index d525fa2931..0b6beeffdc 100644 --- a/vendor/modernc.org/libc/memgrind.go +++ b/vendor/modernc.org/libc/memgrind.go @@ -12,6 +12,8 @@ package libc // import "modernc.org/libc" import ( "fmt" + "math" + "math/bits" "runtime" "sort" "strings" @@ -117,7 +119,12 @@ func Xcalloc(t *TLS, n, size types.Size_t) uintptr { if __ccgo_strace { trc("t=%v n=%v size=%v, (%v:)", t, n, size, origin(2)) } - rq := int(n * size) + hi, rq0 := bits.Mul(uint(n), uint(size)) + if hi != 0 || rq0 > math.MaxInt { + t.setErrno(errno.ENOMEM) + return 0 + } + rq := int(rq0) if rq == 0 { rq = 1 } @@ -179,9 +186,6 @@ func Xrealloc(t *TLS, ptr uintptr, size types.Size_t) uintptr { panic(fmt.Errorf("%v: realloc, free of unallocated memory: %#x", pc2origin(pc), ptr)) } - delete(allocs, ptr) - delete(allocsMore, ptr) - frees[ptr] = pc } } @@ -194,14 +198,21 @@ func Xrealloc(t *TLS, ptr uintptr, size types.Size_t) uintptr { return 0 } - if memAuditEnabled && p != 0 { - delete(frees, p) - if pc0, ok := allocs[p]; ok { - dmesg("%v: realloc returns same address twice, previous call at %v:", pc2origin(pc), pc2origin(pc0)) - panic(fmt.Errorf("%v: realloc returns same address twice, previous call at %v:", pc2origin(pc), pc2origin(pc0))) + if memAuditEnabled { + if ptr != 0 { + delete(allocs, ptr) + delete(allocsMore, ptr) + frees[ptr] = pc } + if p != 0 { + delete(frees, p) + if pc0, ok := allocs[p]; ok { + dmesg("%v: realloc returns same address twice, previous call at %v:", pc2origin(pc), pc2origin(pc0)) + panic(fmt.Errorf("%v: realloc returns same address twice, previous call at %v:", pc2origin(pc), pc2origin(pc0))) + } - allocs[p] = pc + allocs[p] = pc + } } return p } diff --git a/vendor/modernc.org/libc/memgrind_musl.go b/vendor/modernc.org/libc/memgrind_musl.go index ee7c2dcf05..883be2fde9 100644 --- a/vendor/modernc.org/libc/memgrind_musl.go +++ b/vendor/modernc.org/libc/memgrind_musl.go @@ -12,6 +12,8 @@ package libc // import "modernc.org/libc" import ( "fmt" + "math" + "math/bits" "runtime" "sort" "strings" @@ -117,7 +119,12 @@ func Xcalloc(t *TLS, n, size Tsize_t) uintptr { if __ccgo_strace { trc("t=%v n=%v size=%v, (%v:)", t, n, size, origin(2)) } - rq := int(n * size) + hi, rq0 := bits.Mul(uint(n), uint(size)) + if hi != 0 || rq0 > math.MaxInt { + t.setErrno(ENOMEM) + return 0 + } + rq := int(rq0) if rq == 0 { rq = 1 } @@ -179,9 +186,6 @@ func Xrealloc(t *TLS, ptr uintptr, size Tsize_t) uintptr { panic(fmt.Errorf("%v: realloc, free of unallocated memory: %#x", pc2origin(pc), ptr)) } - delete(allocs, ptr) - delete(allocsMore, ptr) - frees[ptr] = pc } } @@ -194,14 +198,21 @@ func Xrealloc(t *TLS, ptr uintptr, size Tsize_t) uintptr { return 0 } - if memAuditEnabled && p != 0 { - delete(frees, p) - if pc0, ok := allocs[p]; ok { - dmesg("%v: realloc returns same address twice, previous call at %v:", pc2origin(pc), pc2origin(pc0)) - panic(fmt.Errorf("%v: realloc returns same address twice, previous call at %v:", pc2origin(pc), pc2origin(pc0))) + if memAuditEnabled { + if ptr != 0 { + delete(allocs, ptr) + delete(allocsMore, ptr) + frees[ptr] = pc } + if p != 0 { + delete(frees, p) + if pc0, ok := allocs[p]; ok { + dmesg("%v: realloc returns same address twice, previous call at %v:", pc2origin(pc), pc2origin(pc0)) + panic(fmt.Errorf("%v: realloc returns same address twice, previous call at %v:", pc2origin(pc), pc2origin(pc0))) + } - allocs[p] = pc + allocs[p] = pc + } } return p } diff --git a/vendor/modernc.org/libc/pthread.go b/vendor/modernc.org/libc/pthread.go index 538766b2d9..f9a8586d2e 100644 --- a/vendor/modernc.org/libc/pthread.go +++ b/vendor/modernc.org/libc/pthread.go @@ -395,6 +395,10 @@ func Xpthread_cond_timedwait(t *TLS, pCond, pMutex, pAbsTime uintptr) int32 { defer cond.Unlock() delete(cond.waiters, t) + select { + case <-t.wait: + default: + } return errno.ETIMEDOUT } } @@ -651,7 +655,12 @@ func Xpthread_detach(t *TLS, thread pthread.Pthread_t) int32 { trc("t=%v thread=%v, (%v:)", t, thread, origin(2)) } threadsMu.Lock() - threads[int32(thread)].detached = true + tls := threads[int32(thread)] + if tls == nil { + threadsMu.Unlock() + return errno.ESRCH + } + tls.detached = true threadsMu.Unlock() return 0 } @@ -710,6 +719,10 @@ func Xpthread_join(t *TLS, thread pthread.Pthread_t, pValue uintptr) int32 { } threadsMu.Lock() tls := threads[int32(thread)] + if tls == nil { + threadsMu.Unlock() + return errno.ESRCH + } delete(threads, int32(thread)) threadsMu.Unlock() <-tls.done diff --git a/vendor/modernc.org/libc/pthread_musl.go b/vendor/modernc.org/libc/pthread_musl.go index 8b7ecbc664..266908fc6c 100644 --- a/vendor/modernc.org/libc/pthread_musl.go +++ b/vendor/modernc.org/libc/pthread_musl.go @@ -172,9 +172,9 @@ func Xpthread_exit(tls *TLS, result uintptr) { break } } - if state == _DT_JOINABLE { - (*sync.Mutex)(unsafe.Pointer(tls.pthread + unsafe.Offsetof(t__pthread{}.F__ccgo_join_mutex))).Unlock() - } + mu := (*sync.Mutex)(unsafe.Pointer(tls.pthread + unsafe.Offsetof(t__pthread{}.F__ccgo_join_mutex))) + mu.TryLock() + mu.Unlock() atomic.StoreInt32((*int32)(unsafe.Pointer(tls.pthread+unsafe.Offsetof(t__pthread{}.Fdetach_state))), _DT_EXITED) tls.Close() runtime.Goexit() @@ -187,7 +187,7 @@ func Xpthread_join(tls *TLS, t Tpthread_t, res uintptr) (r int32) { (*sync.Mutex)(unsafe.Pointer(t + unsafe.Offsetof(t__pthread{}.F__ccgo_join_mutex))).Lock() if res != 0 { - *(*uintptr)(unsafe.Pointer(res)) = (*t__pthread)(unsafe.Pointer(tls.pthread)).Fresult + *(*uintptr)(unsafe.Pointer(res)) = (*t__pthread)(unsafe.Pointer(t)).Fresult } return 0 } @@ -283,20 +283,20 @@ func Xpthread_mutex_lock(tls *TLS, m uintptr) int32 { return 0 case PTHREAD_MUTEX_RECURSIVE: if atomic.CompareAndSwapInt32(&((*pthreadMutex)(unsafe.Pointer(m)).owner), 0, tls.ID) { - (*pthreadMutex)(unsafe.Pointer(m)).count = 1 + atomic.StoreInt32(&((*pthreadMutex)(unsafe.Pointer(m)).count), 1) (*pthreadMutex)(unsafe.Pointer(m)).Lock() return 0 } if atomic.LoadInt32(&((*pthreadMutex)(unsafe.Pointer(m)).owner)) == tls.ID { - (*pthreadMutex)(unsafe.Pointer(m)).count++ + atomic.AddInt32(&((*pthreadMutex)(unsafe.Pointer(m)).count), 1) return 0 } for { (*pthreadMutex)(unsafe.Pointer(m)).Lock() if atomic.CompareAndSwapInt32(&((*pthreadMutex)(unsafe.Pointer(m)).owner), 0, tls.ID) { - (*pthreadMutex)(unsafe.Pointer(m)).count = 1 + atomic.StoreInt32(&((*pthreadMutex)(unsafe.Pointer(m)).count), 1) return 0 } @@ -463,9 +463,9 @@ func Xpthread_mutexattr_settype(tls *TLS, a uintptr, typ int32) int32 { } func Xpthread_detach(tls *TLS, t uintptr) int32 { - state := atomic.SwapInt32((*int32)(unsafe.Pointer(tls.pthread+unsafe.Offsetof(t__pthread{}.Fdetach_state))), _DT_DETACHED) + state := atomic.SwapInt32((*int32)(unsafe.Pointer(t+unsafe.Offsetof(t__pthread{}.Fdetach_state))), _DT_DETACHED) switch state { - case _DT_EXITED, _DT_DETACHED: + case _DT_JOINABLE, _DT_EXITED, _DT_DETACHED: return 0 default: panic(todo("", tls.ID, state)) diff --git a/vendor/modernc.org/libc/stdatomic.go b/vendor/modernc.org/libc/stdatomic.go index bc718bb752..5743ad8f56 100644 --- a/vendor/modernc.org/libc/stdatomic.go +++ b/vendor/modernc.org/libc/stdatomic.go @@ -83,13 +83,8 @@ func X__c11_atomic_fetch_addInt32(t *TLS, ptr uintptr, val int32, _ int32) (r in } func X__atomic_fetch_addInt32(t *TLS, ptr uintptr, val int32, _ int32) (r int32) { - int32Mu.Lock() - - defer int32Mu.Unlock() - - r = *(*int32)(unsafe.Pointer(ptr)) - *(*int32)(unsafe.Pointer(ptr)) += val - return r + p := (*int32)(unsafe.Pointer(ptr)) + return atomic.AddInt32(p, val) - val } func X__c11_atomic_fetch_addUint32(t *TLS, ptr uintptr, val uint32, _ int32) (r uint32) { @@ -97,13 +92,8 @@ func X__c11_atomic_fetch_addUint32(t *TLS, ptr uintptr, val uint32, _ int32) (r } func X__atomic_fetch_addUint32(t *TLS, ptr uintptr, val uint32, _ int32) (r uint32) { - int32Mu.Lock() - - defer int32Mu.Unlock() - - r = *(*uint32)(unsafe.Pointer(ptr)) - *(*uint32)(unsafe.Pointer(ptr)) += val - return r + p := (*uint32)(unsafe.Pointer(ptr)) + return atomic.AddUint32(p, val) - val } func X__c11_atomic_fetch_addInt64(t *TLS, ptr uintptr, val int64, _ int32) (r int64) { @@ -111,13 +101,8 @@ func X__c11_atomic_fetch_addInt64(t *TLS, ptr uintptr, val int64, _ int32) (r in } func X__atomic_fetch_addInt64(t *TLS, ptr uintptr, val int64, _ int32) (r int64) { - int64Mu.Lock() - - defer int64Mu.Unlock() - - r = *(*int64)(unsafe.Pointer(ptr)) - *(*int64)(unsafe.Pointer(ptr)) += val - return r + p := (*int64)(unsafe.Pointer(ptr)) + return atomic.AddInt64(p, val) - val } func X__c11_atomic_fetch_addUint64(t *TLS, ptr uintptr, val uint64, _ int32) (r uint64) { @@ -125,13 +110,8 @@ func X__c11_atomic_fetch_addUint64(t *TLS, ptr uintptr, val uint64, _ int32) (r } func X__atomic_fetch_addUint64(t *TLS, ptr uintptr, val uint64, _ int32) (r uint64) { - int64Mu.Lock() - - defer int64Mu.Unlock() - - r = *(*uint64)(unsafe.Pointer(ptr)) - *(*uint64)(unsafe.Pointer(ptr)) += val - return r + p := (*uint64)(unsafe.Pointer(ptr)) + return atomic.AddUint64(p, val) - val } // ---- @@ -197,13 +177,13 @@ func X__c11_atomic_fetch_andInt32(t *TLS, ptr uintptr, val int32, _ int32) (r in } func X__atomic_fetch_andInt32(t *TLS, ptr uintptr, val int32, _ int32) (r int32) { - int32Mu.Lock() - - defer int32Mu.Unlock() - - r = *(*int32)(unsafe.Pointer(ptr)) - *(*int32)(unsafe.Pointer(ptr)) &= val - return r + p := (*int32)(unsafe.Pointer(ptr)) + for { + r = atomic.LoadInt32(p) + if atomic.CompareAndSwapInt32(p, r, r&val) { + return r + } + } } func X__c11_atomic_fetch_andUint32(t *TLS, ptr uintptr, val uint32, _ int32) (r uint32) { @@ -211,13 +191,13 @@ func X__c11_atomic_fetch_andUint32(t *TLS, ptr uintptr, val uint32, _ int32) (r } func X__atomic_fetch_andUint32(t *TLS, ptr uintptr, val uint32, _ int32) (r uint32) { - int32Mu.Lock() - - defer int32Mu.Unlock() - - r = *(*uint32)(unsafe.Pointer(ptr)) - *(*uint32)(unsafe.Pointer(ptr)) &= val - return r + p := (*uint32)(unsafe.Pointer(ptr)) + for { + r = atomic.LoadUint32(p) + if atomic.CompareAndSwapUint32(p, r, r&val) { + return r + } + } } func X__c11_atomic_fetch_andInt64(t *TLS, ptr uintptr, val int64, _ int32) (r int64) { @@ -225,13 +205,13 @@ func X__c11_atomic_fetch_andInt64(t *TLS, ptr uintptr, val int64, _ int32) (r in } func X__atomic_fetch_andInt64(t *TLS, ptr uintptr, val int64, _ int32) (r int64) { - int64Mu.Lock() - - defer int64Mu.Unlock() - - r = *(*int64)(unsafe.Pointer(ptr)) - *(*int64)(unsafe.Pointer(ptr)) &= val - return r + p := (*int64)(unsafe.Pointer(ptr)) + for { + r = atomic.LoadInt64(p) + if atomic.CompareAndSwapInt64(p, r, r&val) { + return r + } + } } func X__c11_atomic_fetch_andUint64(t *TLS, ptr uintptr, val uint64, _ int32) (r uint64) { @@ -239,13 +219,13 @@ func X__c11_atomic_fetch_andUint64(t *TLS, ptr uintptr, val uint64, _ int32) (r } func X__atomic_fetch_andUint64(t *TLS, ptr uintptr, val uint64, _ int32) (r uint64) { - int64Mu.Lock() - - defer int64Mu.Unlock() - - r = *(*uint64)(unsafe.Pointer(ptr)) - *(*uint64)(unsafe.Pointer(ptr)) &= val - return r + p := (*uint64)(unsafe.Pointer(ptr)) + for { + r = atomic.LoadUint64(p) + if atomic.CompareAndSwapUint64(p, r, r&val) { + return r + } + } } // ---- @@ -311,13 +291,13 @@ func X__c11_atomic_fetch_orInt32(t *TLS, ptr uintptr, val int32, _ int32) (r int } func X__atomic_fetch_orInt32(t *TLS, ptr uintptr, val int32, _ int32) (r int32) { - int32Mu.Lock() - - defer int32Mu.Unlock() - - r = *(*int32)(unsafe.Pointer(ptr)) - *(*int32)(unsafe.Pointer(ptr)) |= val - return r + p := (*int32)(unsafe.Pointer(ptr)) + for { + r = atomic.LoadInt32(p) + if atomic.CompareAndSwapInt32(p, r, r|val) { + return r + } + } } func X__c11_atomic_fetch_orUint32(t *TLS, ptr uintptr, val uint32, _ int32) (r uint32) { @@ -325,13 +305,13 @@ func X__c11_atomic_fetch_orUint32(t *TLS, ptr uintptr, val uint32, _ int32) (r u } func X__atomic_fetch_orUint32(t *TLS, ptr uintptr, val uint32, _ int32) (r uint32) { - int32Mu.Lock() - - defer int32Mu.Unlock() - - r = *(*uint32)(unsafe.Pointer(ptr)) - *(*uint32)(unsafe.Pointer(ptr)) |= val - return r + p := (*uint32)(unsafe.Pointer(ptr)) + for { + r = atomic.LoadUint32(p) + if atomic.CompareAndSwapUint32(p, r, r|val) { + return r + } + } } func X__c11_atomic_fetch_orInt64(t *TLS, ptr uintptr, val int64, _ int32) (r int64) { @@ -339,13 +319,13 @@ func X__c11_atomic_fetch_orInt64(t *TLS, ptr uintptr, val int64, _ int32) (r int } func X__atomic_fetch_orInt64(t *TLS, ptr uintptr, val int64, _ int32) (r int64) { - int64Mu.Lock() - - defer int64Mu.Unlock() - - r = *(*int64)(unsafe.Pointer(ptr)) - *(*int64)(unsafe.Pointer(ptr)) |= val - return r + p := (*int64)(unsafe.Pointer(ptr)) + for { + r = atomic.LoadInt64(p) + if atomic.CompareAndSwapInt64(p, r, r|val) { + return r + } + } } func X__c11_atomic_fetch_orUint64(t *TLS, ptr uintptr, val uint64, _ int32) (r uint64) { @@ -353,13 +333,13 @@ func X__c11_atomic_fetch_orUint64(t *TLS, ptr uintptr, val uint64, _ int32) (r u } func X__atomic_fetch_orUint64(t *TLS, ptr uintptr, val uint64, _ int32) (r uint64) { - int64Mu.Lock() - - defer int64Mu.Unlock() - - r = *(*uint64)(unsafe.Pointer(ptr)) - *(*uint64)(unsafe.Pointer(ptr)) |= val - return r + p := (*uint64)(unsafe.Pointer(ptr)) + for { + r = atomic.LoadUint64(p) + if atomic.CompareAndSwapUint64(p, r, r|val) { + return r + } + } } // ---- @@ -425,13 +405,8 @@ func X__c11_atomic_fetch_subInt32(t *TLS, ptr uintptr, val int32, _ int32) (r in } func X__atomic_fetch_subInt32(t *TLS, ptr uintptr, val int32, _ int32) (r int32) { - int32Mu.Lock() - - defer int32Mu.Unlock() - - r = *(*int32)(unsafe.Pointer(ptr)) - *(*int32)(unsafe.Pointer(ptr)) -= val - return r + p := (*int32)(unsafe.Pointer(ptr)) + return atomic.AddInt32(p, -val) + val } func X__c11_atomic_fetch_subUint32(t *TLS, ptr uintptr, val uint32, _ int32) (r uint32) { @@ -439,13 +414,8 @@ func X__c11_atomic_fetch_subUint32(t *TLS, ptr uintptr, val uint32, _ int32) (r } func X__atomic_fetch_subUint32(t *TLS, ptr uintptr, val uint32, _ int32) (r uint32) { - int32Mu.Lock() - - defer int32Mu.Unlock() - - r = *(*uint32)(unsafe.Pointer(ptr)) - *(*uint32)(unsafe.Pointer(ptr)) -= val - return r + p := (*uint32)(unsafe.Pointer(ptr)) + return atomic.AddUint32(p, ^(val-1)) + val } func X__c11_atomic_fetch_subInt64(t *TLS, ptr uintptr, val int64, _ int32) (r int64) { @@ -453,13 +423,8 @@ func X__c11_atomic_fetch_subInt64(t *TLS, ptr uintptr, val int64, _ int32) (r in } func X__atomic_fetch_subInt64(t *TLS, ptr uintptr, val int64, _ int32) (r int64) { - int64Mu.Lock() - - defer int64Mu.Unlock() - - r = *(*int64)(unsafe.Pointer(ptr)) - *(*int64)(unsafe.Pointer(ptr)) -= val - return r + p := (*int64)(unsafe.Pointer(ptr)) + return atomic.AddInt64(p, -val) + val } func X__c11_atomic_fetch_subUint64(t *TLS, ptr uintptr, val uint64, _ int32) (r uint64) { @@ -467,13 +432,8 @@ func X__c11_atomic_fetch_subUint64(t *TLS, ptr uintptr, val uint64, _ int32) (r } func X__atomic_fetch_subUint64(t *TLS, ptr uintptr, val uint64, _ int32) (r uint64) { - int64Mu.Lock() - - defer int64Mu.Unlock() - - r = *(*uint64)(unsafe.Pointer(ptr)) - *(*uint64)(unsafe.Pointer(ptr)) -= val - return r + p := (*uint64)(unsafe.Pointer(ptr)) + return atomic.AddUint64(p, ^(val-1)) + val } // ---- @@ -539,13 +499,13 @@ func X__c11_atomic_fetch_xorInt32(t *TLS, ptr uintptr, val int32, _ int32) (r in } func X__atomic_fetch_xorInt32(t *TLS, ptr uintptr, val int32, _ int32) (r int32) { - int32Mu.Lock() - - defer int32Mu.Unlock() - - r = *(*int32)(unsafe.Pointer(ptr)) - *(*int32)(unsafe.Pointer(ptr)) ^= val - return r + p := (*int32)(unsafe.Pointer(ptr)) + for { + r = atomic.LoadInt32(p) + if atomic.CompareAndSwapInt32(p, r, r^val) { + return r + } + } } func X__c11_atomic_fetch_xorUint32(t *TLS, ptr uintptr, val uint32, _ int32) (r uint32) { @@ -553,13 +513,13 @@ func X__c11_atomic_fetch_xorUint32(t *TLS, ptr uintptr, val uint32, _ int32) (r } func X__atomic_fetch_xorUint32(t *TLS, ptr uintptr, val uint32, _ int32) (r uint32) { - int32Mu.Lock() - - defer int32Mu.Unlock() - - r = *(*uint32)(unsafe.Pointer(ptr)) - *(*uint32)(unsafe.Pointer(ptr)) ^= val - return r + p := (*uint32)(unsafe.Pointer(ptr)) + for { + r = atomic.LoadUint32(p) + if atomic.CompareAndSwapUint32(p, r, r^val) { + return r + } + } } func X__c11_atomic_fetch_xorInt64(t *TLS, ptr uintptr, val int64, _ int32) (r int64) { @@ -567,13 +527,13 @@ func X__c11_atomic_fetch_xorInt64(t *TLS, ptr uintptr, val int64, _ int32) (r in } func X__atomic_fetch_xorInt64(t *TLS, ptr uintptr, val int64, _ int32) (r int64) { - int64Mu.Lock() - - defer int64Mu.Unlock() - - r = *(*int64)(unsafe.Pointer(ptr)) - *(*int64)(unsafe.Pointer(ptr)) ^= val - return r + p := (*int64)(unsafe.Pointer(ptr)) + for { + r = atomic.LoadInt64(p) + if atomic.CompareAndSwapInt64(p, r, r^val) { + return r + } + } } func X__c11_atomic_fetch_xorUint64(t *TLS, ptr uintptr, val uint64, _ int32) (r uint64) { @@ -581,13 +541,13 @@ func X__c11_atomic_fetch_xorUint64(t *TLS, ptr uintptr, val uint64, _ int32) (r } func X__atomic_fetch_xorUint64(t *TLS, ptr uintptr, val uint64, _ int32) (r uint64) { - int64Mu.Lock() - - defer int64Mu.Unlock() - - r = *(*uint64)(unsafe.Pointer(ptr)) - *(*uint64)(unsafe.Pointer(ptr)) ^= val - return r + p := (*uint64)(unsafe.Pointer(ptr)) + for { + r = atomic.LoadUint64(p) + if atomic.CompareAndSwapUint64(p, r, r^val) { + return r + } + } } // ---- @@ -765,41 +725,51 @@ func X__atomic_compare_exchangeUint16(t *TLS, ptr, expected, desired uintptr, we } func X__atomic_compare_exchangeInt32(t *TLS, ptr, expected, desired uintptr, weak, success, failure int32) int32 { - int32Mu.Lock() - - defer int32Mu.Unlock() - - have := *(*int32)(unsafe.Pointer(ptr)) - if have == *(*int32)(unsafe.Pointer(expected)) { - *(*int32)(unsafe.Pointer(ptr)) = *(*int32)(unsafe.Pointer(desired)) + p := (*int32)(unsafe.Pointer(ptr)) + exp := (*int32)(unsafe.Pointer(expected)) + des := *(*int32)(unsafe.Pointer(desired)) + old := *exp + if atomic.CompareAndSwapInt32(p, old, des) { return 1 } - - *(*int32)(unsafe.Pointer(expected)) = have + *exp = atomic.LoadInt32(p) return 0 } func X__atomic_compare_exchangeUint32(t *TLS, ptr, expected, desired uintptr, weak, success, failure int32) int32 { - return X__atomic_compare_exchangeInt32(t, ptr, expected, desired, weak, success, failure) + p := (*uint32)(unsafe.Pointer(ptr)) + exp := (*uint32)(unsafe.Pointer(expected)) + des := *(*uint32)(unsafe.Pointer(desired)) + old := *exp + if atomic.CompareAndSwapUint32(p, old, des) { + return 1 + } + *exp = atomic.LoadUint32(p) + return 0 } func X__atomic_compare_exchangeInt64(t *TLS, ptr, expected, desired uintptr, weak, success, failure int32) int32 { - int64Mu.Lock() - - defer int64Mu.Unlock() - - have := *(*int64)(unsafe.Pointer(ptr)) - if have == *(*int64)(unsafe.Pointer(expected)) { - *(*int64)(unsafe.Pointer(ptr)) = *(*int64)(unsafe.Pointer(desired)) + p := (*int64)(unsafe.Pointer(ptr)) + exp := (*int64)(unsafe.Pointer(expected)) + des := *(*int64)(unsafe.Pointer(desired)) + old := *exp + if atomic.CompareAndSwapInt64(p, old, des) { return 1 } - - *(*int64)(unsafe.Pointer(expected)) = have + *exp = atomic.LoadInt64(p) return 0 } func X__atomic_compare_exchangeUint64(t *TLS, ptr, expected, desired uintptr, weak, success, failure int32) int32 { - return X__atomic_compare_exchangeInt64(t, ptr, expected, desired, weak, success, failure) + p := (*uint64)(unsafe.Pointer(ptr)) + exp := (*uint64)(unsafe.Pointer(expected)) + des := *(*uint64)(unsafe.Pointer(desired)) + old := *exp + if atomic.CompareAndSwapUint64(p, old, des) { + return 1 + } + *exp = atomic.LoadUint64(p) + return 0 } func X__c11_atomic_compare_exchange_strongInt8(t *TLS, ptr, expected uintptr, desired int8, success, failure int32) int32 { diff --git a/vendor/modules.txt b/vendor/modules.txt index 2c4f750156..257025210e 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -102,7 +102,7 @@ github.com/anacrolix/btree/internal/abstract ## explicit; go 1.16 github.com/anacrolix/chansync github.com/anacrolix/chansync/events -# github.com/anacrolix/dht/v2 v2.23.0 +# github.com/anacrolix/dht/v2 v2.24.0 ## explicit; go 1.23 github.com/anacrolix/dht/v2 github.com/anacrolix/dht/v2/bep44 @@ -247,11 +247,11 @@ github.com/aws/aws-sdk-go-v2/internal/shareddefaults github.com/aws/aws-sdk-go-v2/internal/strings github.com/aws/aws-sdk-go-v2/internal/sync/singleflight github.com/aws/aws-sdk-go-v2/internal/timeconv -# github.com/aws/aws-sdk-go-v2/config v1.32.17 +# github.com/aws/aws-sdk-go-v2/config v1.32.18 ## explicit; go 1.24 github.com/aws/aws-sdk-go-v2/config github.com/aws/aws-sdk-go-v2/config/internal/ini -# github.com/aws/aws-sdk-go-v2/credentials v1.19.16 +# github.com/aws/aws-sdk-go-v2/credentials v1.19.17 ## explicit; go 1.24 github.com/aws/aws-sdk-go-v2/credentials github.com/aws/aws-sdk-go-v2/credentials/ec2rolecreds @@ -298,7 +298,7 @@ github.com/aws/aws-sdk-go-v2/service/signin/types github.com/aws/aws-sdk-go-v2/service/sso github.com/aws/aws-sdk-go-v2/service/sso/internal/endpoints github.com/aws/aws-sdk-go-v2/service/sso/types -# github.com/aws/aws-sdk-go-v2/service/ssooidc v1.35.21 +# github.com/aws/aws-sdk-go-v2/service/ssooidc v1.36.0 ## explicit; go 1.24 github.com/aws/aws-sdk-go-v2/service/ssooidc github.com/aws/aws-sdk-go-v2/service/ssooidc/internal/endpoints @@ -320,6 +320,7 @@ github.com/aws/smithy-go/encoding/httpbinding github.com/aws/smithy-go/encoding/json github.com/aws/smithy-go/encoding/xml github.com/aws/smithy-go/endpoints +github.com/aws/smithy-go/endpoints/private/bdd github.com/aws/smithy-go/endpoints/private/rulesfn github.com/aws/smithy-go/internal/sync/singleflight github.com/aws/smithy-go/io @@ -956,7 +957,7 @@ github.com/pion/rtp github.com/pion/rtp/codecs github.com/pion/rtp/codecs/av1/obu github.com/pion/rtp/codecs/vp9 -# github.com/pion/sctp v1.9.5 +# github.com/pion/sctp v1.10.0 ## explicit; go 1.24.0 github.com/pion/sctp # github.com/pion/sdp/v3 v3.0.18 @@ -1005,7 +1006,7 @@ github.com/pion/turn/v5/internal/client github.com/pion/turn/v5/internal/ipnet github.com/pion/turn/v5/internal/proto github.com/pion/turn/v5/internal/server -# github.com/pion/webrtc/v4 v4.2.12 +# github.com/pion/webrtc/v4 v4.2.13 ## explicit; go 1.24.0 github.com/pion/webrtc/v4 github.com/pion/webrtc/v4/internal/fmtp @@ -1206,7 +1207,7 @@ go.uber.org/automaxprocs/maxprocs # go.yaml.in/yaml/v2 v2.4.4 ## explicit; go 1.15 go.yaml.in/yaml/v2 -# golang.org/x/crypto v0.51.0 +# golang.org/x/crypto v0.52.0 ## explicit; go 1.25.0 golang.org/x/crypto/blake2b golang.org/x/crypto/blake2s @@ -1246,7 +1247,7 @@ golang.org/x/mod/internal/lazyregexp golang.org/x/mod/modfile golang.org/x/mod/module golang.org/x/mod/semver -# golang.org/x/net v0.54.0 +# golang.org/x/net v0.55.0 ## explicit; go 1.25.0 golang.org/x/net/bpf golang.org/x/net/dns/dnsmessage @@ -1271,7 +1272,7 @@ golang.org/x/sync/errgroup golang.org/x/sync/semaphore golang.org/x/sync/singleflight golang.org/x/sync/syncmap -# golang.org/x/sys v0.44.0 +# golang.org/x/sys v0.45.0 ## explicit; go 1.25.0 golang.org/x/sys/cpu golang.org/x/sys/execabs @@ -1386,7 +1387,7 @@ gopkg.in/yaml.v3 lukechampine.com/blake3 lukechampine.com/blake3/bao lukechampine.com/blake3/guts -# modernc.org/libc v1.72.3 +# modernc.org/libc v1.72.4 ## explicit; go 1.25.0 modernc.org/libc modernc.org/libc/errno